=== BEGIN ARTIFACT FEATURE-Accessors.md ===
# FEATURE: Accessors

Object fields, array indices, dynamic keys, optional access, and negative indices follow jq semantics.

## Programmatic Acceptance

=== AC value-002-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"\[|\."

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC value-002-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Arithmetic-and-Structural-Operators.md ===
# FEATURE: Arithmetic and Structural Operators

Arithmetic, string, array, object, recursive merge, repetition, and splitting operators are supported.

## Programmatic Acceptance

=== AC flow-001-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"\+|\*|//"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC flow-001-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Boolean-and-Alternative-Operators.md ===
# FEATURE: Boolean and Alternative Operators

Boolean, negation, defined-or, and defined-or assignment semantics are supported.

## Programmatic Acceptance

=== AC flow-002-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"//|and|or|not"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC flow-002-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Complex-Assignments.md ===
# FEATURE: Complex Assignments

Complex assignments handle generated and deeply nested paths.

## Programmatic Acceptance

=== AC path-004-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"\|=|//="

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC path-004-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Conditionals-and-Exception-Flow.md ===
# FEATURE: Conditionals and Exception Flow

Conditional branches, try/catch handling, and optional evaluation are supported.

## Programmatic Acceptance

=== AC flow-003-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"if |try |catch|\?"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC flow-003-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Destructuring-Alternatives.md ===
# FEATURE: Destructuring Alternatives

Destructuring patterns and `?//` alternatives are supported.

## Programmatic Acceptance

=== AC func-004-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"\?//| as \$"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC func-004-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Filter-Grammar.md ===
# FEATURE: Filter Grammar

The parser implements jq expression grammar, precedence, composition, indexing, construction, and optional operators.

## Programmatic Acceptance

=== AC parse-003-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"\[|\{|\||\?"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC parse-003-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Function-Definitions.md ===
# FEATURE: Function Definitions

Function definitions provide lexical scope, redefinition, and recursion.

## Programmatic Acceptance

=== AC function-definitions-scoped-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"def "

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC function-definitions-scoped-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Generator-Core.md ===
# FEATURE: Generator Core

Filters evaluate as ordered streams with multiplicity, backtracking, and empty results.

## Programmatic Acceptance

=== AC core-001-conformance ===
import json
import os
import subprocess
import sys

SELECT = r",|empty|range\("

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC core-001-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Labels-and-Breaks.md ===
# FEATURE: Labels and Breaks

Lexically scoped labels and break control are supported.

## Programmatic Acceptance

=== AC flow-004-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"label |break "

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC flow-004-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Literals-and-Strings.md ===
# FEATURE: Literals and Strings

JSON literals, escaped strings, formatted strings, and interpolation are supported.

## Programmatic Acceptance

=== AC parse-002-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"\(@|\(\\|\{|\["

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC parse-002-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Path-Discovery.md ===
# FEATURE: Path Discovery

Path discovery and projections support exact and generated path expressions.

## Programmatic Acceptance

=== AC path-001-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"path\("

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC path-001-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Recursive-Generators.md ===
# FEATURE: Recursive Generators

Recursive generator filters preserve termination and stream ordering.

## Programmatic Acceptance

=== AC recursive-generators-scoped-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"foreach|recurse"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC recursive-generators-scoped-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Regular-Expressions.md ===
# FEATURE: Regular Expressions

Regex matching, captures, scanning, splitting, and substitution use Python standard-library regular expressions.

## Programmatic Acceptance

=== AC regex-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"test\(|match\(|capture\(|scan\(|sub\("

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC regex-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Scoped-Conformance.md ===
# FEATURE: Scoped Conformance Verification

Construct-specific conformance verification executes selected cases and requires a non-empty passing result.

## Programmatic Acceptance

=== AC scoped-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"reduce"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC scoped-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Sorting-and-Grouping.md ===
# FEATURE: Sorting and Grouping

Sorting, grouping, uniqueness, and extrema use jq structural comparison.

## Programmatic Acceptance

=== AC data-002-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"sort|group_by|unique|min|max"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC data-002-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-String-Manipulation.md ===
# FEATURE: String Manipulation

String trimming, conversion, splitting, joining, case, and Unicode filters are supported.

## Programmatic Acceptance

=== AC text-001-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"split|join|ascii_downcase|ascii_upcase|trim"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC text-001-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Type-and-Numeric-Primitives.md ===
# FEATURE: Type and Numeric Primitives

Type, length, numeric conversion, predicates, and mathematical primitive filters are supported.

## Programmatic Acceptance

=== AC value-004-conformance ===
import json
import os
import subprocess
import sys

SELECT = r"type|length|tonumber|floor|ceil"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC value-004-conformance
=== END ARTIFACT ===
=== BEGIN ARTIFACT FEATURE-Variable-Bindings.md ===
# FEATURE: Variable Bindings

Lexical bindings, shadowing, and destructuring patterns are supported.

## Programmatic Acceptance

=== AC variable-bindings-scoped-conformance ===
import json
import os
import subprocess
import sys

SELECT = r" as \$"

result = subprocess.run(
    [sys.executable, "sources/run_conformance.py", "--select", SELECT, "--json"],
    capture_output=True,
    text=True,
    env={**os.environ, "JQ": f"{os.getcwd()}/jq"},
)
print(result.stdout)
print(result.stderr, file=sys.stderr)
report = json.loads(result.stdout)
tally = report["summary"]
assert sum(tally.values()) > 0, f"selector matched no case: {SELECT}"
assert tally["fail"] == 0 and tally["error"] == 0, tally
assert result.returncode == 0, result.returncode
=== END AC variable-bindings-scoped-conformance
=== END ARTIFACT ===