@intentius/tsad-conformance 1.4.0

package/fixtures/S-Object/spread-non-object/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-SpreadProp", "F-Eval-Object", "F-Div-SpreadType"], "export": "x", "shape": "accept", "fold": "run", "note": "Shape-valid (n is an identifier); the folder rejects once n folds to a number." }

package/fixtures/S-Object/spread-non-object/input.ts

@@ -0,0 +1 @@
+const n = 5; export const x = { ...n };

package/fixtures/S-Reject/arrow-as-value/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Reject", "F-Eval-Function", "F-Val-Callable"], "export": "x", "shape": "reject", "fold": "run", "note": "A function is never a value." }

package/fixtures/S-Reject/arrow-as-value/input.ts

@@ -0,0 +1 @@
+export const x = () => 1;

package/fixtures/S-Reject/call-as-value/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Reject", "F-Eval-Reject"], "export": "x", "shape": "reject", "fold": "run", "note": "A call has no evaluation case: structurally unrepresentable." }

package/fixtures/S-Reject/call-as-value/input.ts

@@ -0,0 +1 @@
+export const x = getId();

package/fixtures/S-Template/coercion/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["S-Template", "F-Eval-Template"], "export": "x", "shape": "accept", "fold": "fold", "value": "count=3, ok=true, n=null",
+  "note": "Spans coerce by ECMAScript ToString (R10.4 / F-Eval-Template)." }

package/fixtures/S-Template/coercion/input.ts

@@ -0,0 +1,2 @@
+const count = 3;
+export const x = `count=${count}, ok=${true}, n=${null}`;

package/fixtures/S-Template/composite-step-span/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["S-Template", "F-Eval-Template", "F-Div-TemplateEnvelope"], "export": "x", "shape": "accept", "fold": "run",
+  "note": "The .step idiom in a plain template span. Refused since chant-v0.69.0 (#2397), the fifth and last coercible envelope kind; __symbol cannot reach a plain span." }

package/fixtures/S-Template/composite-step-span/input.ts

@@ -0,0 +1 @@
+export const x = `step=${Checkout({}).step}`;

package/fixtures/S-Template/const-span/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["S-Template", "F-Eval-Template", "F-Eval-Ident"], "export": "x", "shape": "accept", "fold": "fold", "value": "Hello World!",
+  "note": "The claim chant#2306 found stated backwards in the docs: a template interpolating a const folds." }

package/fixtures/S-Template/const-span/input.ts

@@ -0,0 +1,2 @@
+const name = "World";
+export const x = `Hello ${name}!`;

package/fixtures/S-Template/envelope-span/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["S-Template", "F-Eval-Template", "F-Div-TemplateEnvelope"], "export": "x", "shape": "accept", "fold": "run",
+  "note": "A symbolic value (here an attribute reference) inside a plain template span is refused. Shape accepts (bucket.arn is a member access); the folder rejects once the span folds to an envelope. chant-v0.68.0 (#2349) made this a refusal on both paths; before it, both paths produced \"[object Object]\"." }

package/fixtures/S-Template/envelope-span/input.ts

@@ -0,0 +1,2 @@
+const bucket = new Bucket({ name: "b" });
+export const x = `${bucket.arn}-suffix`;

package/fixtures/S-Template/nested-construction-span/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["S-Template", "F-Eval-Template", "F-Div-TemplateEnvelope"], "export": "x", "shape": "accept", "fold": "run",
+  "note": "A nested construction in a plain template span. Refused since chant-v0.69.0 (#2397); before that it coerced to \"[object Object]\" on both paths." }

package/fixtures/S-Template/nested-construction-span/input.ts

@@ -0,0 +1 @@
+export const x = `img=${new Image({ name: "node:22" })}`;

package/fixtures/S-Template/no-substitution/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["S-Literal", "F-Eval-Literal"], "export": "x", "shape": "accept", "fold": "fold", "value": "plain",
+  "note": "A template with no substitutions is a literal (S-Literal), not S-Template." }

package/fixtures/S-Template/no-substitution/input.ts

@@ -0,0 +1 @@
+export const x = `plain`;

package/fixtures/S-Template/unfoldable-span/expect.json

@@ -0,0 +1,16 @@
+{
+  "rules": [
+    "S-Template",
+    "S-Reject",
+    "F-Eval-Reject",
+    "F-Reason"
+  ],
+  "export": "x",
+  "shape": "reject",
+  "fold": "run",
+  "rejectAt": {
+    "line": 1,
+    "column": 24
+  },
+  "note": "A span outside the subset rejects the template; the rejection points at the span, not the template (F-Reason: a located rejection is a conformance requirement; its wording is not)."
+}

package/fixtures/S-Template/unfoldable-span/input.ts

@@ -0,0 +1 @@
+export const x = `id=${getId()}`;

package/fixtures/S-Unary/not-and-negate/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Unary", "F-Eval-Unary"], "export": "x", "shape": "accept", "fold": "fold", "value": [true, -2] }

package/fixtures/S-Unary/not-and-negate/input.ts

@@ -0,0 +1 @@
+export const x = [!0, -(2)];

package/fixtures/S-Unclaimed/composite-step/expect.json

@@ -0,0 +1,3 @@
+{ "rules": ["S-Unclaimed", "S-CompositeStep", "F-Eval-Member"], "export": "x", "shape": "accept", "fold": "fold",
+  "value": { "__compositeStep": "Checkout", "args": [{ "v": 4 }] },
+  "note": "An unclaimed bare-identifier callee narrowed to .step folds to the composite-step envelope. Claimed callees (a registered helper, an admitted intrinsic) are not unclaimed and take their own S-Call form; the reference ships no host, so nothing claims Checkout here." }

package/fixtures/S-Unclaimed/composite-step/input.ts

@@ -0,0 +1 @@
+export const x = Checkout({ v: 4 }).step;

package/fixtures/S-Unwrap/as-and-parens/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Unwrap", "F-Eval-Unwrap"], "export": "x", "shape": "accept", "fold": "fold", "value": "a" }

package/fixtures/S-Unwrap/as-and-parens/input.ts

@@ -0,0 +1 @@
+export const x = (("a" as string) satisfies string)!;

package/fixtures/UNCOVERED.md

@@ -0,0 +1,37 @@
+# Rules with no conformance fixture yet
+
+Deliberate, and this list may only shrink (#8). Each entry names the rule and why it is still uncovered. Remove an entry when its fixture lands; the gate fails if an entry is stale.
+
+107 of 138 rules have fixtures. Most of the rules below are uncovered because the corpus is still growing (#24); where a rule needs something the reference implementation does not have, the entry says so.
+
+- `F-Rule-Input` — the harness has no rule hook and no findings-as-data fixture kind yet (#101)
+- `F-Rule-Phase` — the harness has no rule hook and no findings-as-data fixture kind yet (#101)
+- `F-Rule-Pure` — the harness has no rule hook and no findings-as-data fixture kind yet (#101)
+- `F-Rule-Finding` — the harness has no rule hook and no findings-as-data fixture kind yet (#101)
+- `F-Rule-Equivalence` — the harness has no rule hook and no findings-as-data fixture kind yet (#101)
+- `F-Rule-Supply` — the harness has no rule hook and no findings-as-data fixture kind yet (#101)
+- `F-Div-Step` — needs `{__compositeStep}`, which has no fate in the reference implementation (no composite factory form)
+- `F-Eval-Interior` — an unresolved chain inside an intrinsic call folds to a symbol only with a registry in scope, and an expression fixture names no host
+- `F-Host-Composite` — needs the composite registration form `Composite(fn, "N")`, which the reference implementation does not have
+- `F-Host-Generality` — says what a host may vary and what it may not; no verdict exercises it
+- `F-IsolatedRefusal` — needs isolation mode, which the reference implementation does not have
+- `F-NoOwnExecution` — measured by chant's `test/leftness` profile; an adapter reports verdicts and cannot observe execution
+- `F-NotProject` — a file inside the host's own module tree; the reference's project is a map with no outside
+- `F-Obs-Counters` — the conformance adapter exposes no counters
+- `F-Obs-Provenance` — an optional capability, reported rather than asserted
+- `F-Val-Domain` — no fixture yet; corpus is #24's
+- `F-Val-Envelope` — no fixture yet; corpus is #24's
+- `F-Val-Symbol-Scope` — no fixture yet; corpus is #24's
+- `S-Disqualify` — no fixture yet; corpus is #24's
+- `S-ExportDestructure` — no fixture yet; corpus is #24's
+- `S-ExportNamed` — no fixture yet; corpus is #24's
+- `S-ExportResource` — no fixture yet; corpus is #24's
+- `S-ExportSingle` — no fixture yet; corpus is #24's
+- `S-ExportTypeOnly` — no fixture yet; corpus is #24's
+- `S-FactoryBody` — needs the composite factory form, which the reference implementation does not have
+- `S-FactoryParams` — needs the composite factory form, which the reference implementation does not have
+- `S-Module` — no fixture yet; corpus is #24's
+- `S-Prop` — no fixture yet; corpus is #24's
+- `S-ReExport` — no fixture yet; corpus is #24's
+- `S-Shorthand` — no fixture yet; corpus is #24's
+- `S-TopConst` — no fixture yet; corpus is #24's

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@intentius/tsad-conformance",
+  "version": "1.4.0",
+  "description": "The conformance suite of the typescript-as-data specification: fixture loader, runner, and the named hosts. An implementation supplies an adapter and gets a report.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/INTENTIUS/typescript-as-data.git",
+    "directory": "packages/conformance"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "files": [
+    "src/",
+    "dist/",
+    "fixtures/",
+    "spec/"
+  ],
+  "scripts": {
+    "build": "rm -rf dist fixtures spec && tsc -p tsconfig.build.json && cp -R ../../spec/fixtures fixtures && mkdir spec && cp ../../spec/VERSION ../../spec/grammar.md ../../spec/judgments.md ../../spec/values.md ../../spec/divergence.md ../../spec/hosts.md ../../spec/rules.md spec/",
+    "prepack": "npm run build"
+  },
+  "dependencies": {}
+}

package/spec/VERSION

@@ -0,0 +1 @@
+1.4

package/spec/divergence.md

@@ -0,0 +1,129 @@
+# Divergence between the shape classifier and the folder
+
+Normative draft (#17). One subset, two consumers with unequal information
+(R3). This file states the direction in which they may disagree as a claim
+with a proof obligation, enumerates every known divergence, and states the
+two exceptions with the reason each is tolerated. Derived from
+`subset.ts`'s module doc and `findSubsetViolation`, and `fold()`, at
+`e4074c17` with the chant-v0.63.0 addition.
+
+---
+
+## F-Direction (the claim)
+
+Let `shape(e, ρ)` be the classifier's verdict on expression `e` given an
+optional registry `ρ`, and `fold(e, Γ, ρ)` the folder's, given also an
+environment `Γ`.
+
+> **Proposition.** For every `e`, `Γ`, `ρ`: if `fold(e, Γ, ρ)` succeeds, then
+> `shape(e, ρ)` accepts, *except* in the two cases F-Exc-Lazy and
+> F-Exc-Registry below.
+
+Equivalently: the classifier may accept what the folder rejects (a *false
+negative* relative to fold, visible only as a later fallback), and must never
+reject what the folder accepts (a *false positive*, visible as a lint error on
+folding code), outside the two named exceptions.
+
+**Why this direction.** A false negative costs a fallback the author learns
+about from `[fold:run]`. A false positive costs a lint error on correct
+source, and a lint that cries wolf gets disabled. The classifier is also the
+predicate a downstream tool asks "will this fold?", a tool with no registry
+must get an answer that is safe to act on, which means erring toward "it may
+run" (`subset.ts` module doc, point 2c).
+
+**Discharge.** By construction: both consumers import one classifier
+(`subset.ts`), so they cannot disagree on node kinds, operators or key shapes;
+every remaining disagreement is a *resolution* the classifier does not
+perform, enumerated below. And by fixture: one accepting and one rejecting
+fixture per row of F-Div, asserting the classifier's and the folder's verdicts
+side by side (#8, #24). chant's `subset-doc-parity.test.ts` is the precedent.
+
+## F-Div (the divergences in the permitted direction)
+
+Shape accepts; the folder may reject, because it resolves.
+
+| Rule | Shape sees | Folder additionally requires | Row |
+|---|---|---|---|
+| F-Div-Ident | any bare identifier is valid | resolves in `consts` then `externals`; `process` is a pointed rejection | L2.3, L3.6, L3.7 |
+| F-Div-Tag | any tagged-template tag; interior opaque | tag is a registered, tag-foldable intrinsic; interior folds | L2.4 |
+| F-Div-Provenance | a registered helper *name* | the name is bound by an import from chant, not shadowed | L2.11 |
+| F-Div-SpreadType | a spread operand of valid shape | operand folds to an object (object spread) or array (array spread) | L3.4, L3.5 |
+| F-Div-SameFileNew | a bare identifier | if bound to a same-file `new`, only `externals` may answer, and F-Prebuild is what puts the instance there; a folder that cannot construct rejects rather than build a duplicate | L3.8 |
+| F-Div-Nullish | `a.b`, `a[k]` | the object does not fold to `null`/`undefined`; `?.` short-circuits instead (chant-v0.63.0) | L3.10, L3.21 |
+| F-Div-NsNew | `new ⟨Expr⟩(…)` with any callee | the callee is a plain identifier | L3.15 |
+| F-Div-Method | `x.m(…)` | the receiver folds to a real value that is not an envelope and whose `m` is a function | L3.18, L3.19 |
+| F-Div-Step | `⟨call⟩.step` | the callee is an *unclaimed* bare identifier | L3.20 |
+| F-Div-Depth | a `new`, tagged template, helper call, intrinsic call, or `.step` | is not inside a folded function body | L3.16 |
+| F-Div-Eager | a registered eager intrinsic name | resolves to a function; is called, not referenced | L3.17 |
+| F-Div-TemplateEnvelope | a member access or call inside a template span | the span does not fold to an envelope; chant refuses all five reachable kinds since v0.69.0 | L3.23 |
+
+Every row is a fallback, never wrong output. That property, a divergence in
+this direction can only lose coverage, is what makes the direction the safe
+one.
+
+## F-Exc (the two exceptions)
+
+Shape rejects; the folder accepts. Each is stated with why it is tolerated
+rather than fixed.
+
+**F-Exc-Lazy.** Short-circuit laziness. The folder evaluates `&&`, `||`,
+`??` and `?:` lazily and never folds the untaken operand; the classifier is
+flow-insensitive and requires every operand to be shape-valid (L2.9, L3.13).
+`false && sideEffect()` folds to `false` and is a lint error. *Tolerated
+because:* a flow-sensitive classifier is an evaluator, and the cost of the
+false positive is a visible lint error on code whose untaken branch is
+suspect anyway. The implementation's own module doc calls it a wart, and a
+specification should not launder the word.
+
+**F-Exc-Registry.** Call-form registration without a registry. The
+classifier takes `ρ` as an optional parameter. Given one, its answer for a
+plain call is the folder's own; without one, every plain call is a violation,
+including `Ref(bucket)` that the folder accepts (L2.12, L2.13). *Tolerated
+because:* the registry-less answer is the conservative one, it is a
+parameter rather than a guess, and the lint engine now threads the active
+lexicons' registry through (chant#1106) so the exception is closed in
+practice for `chant lint` while remaining true of the classifier in
+isolation.
+
+There is no third exception. An implementation that discovers one has found
+either a bug or a new rule, and must add it here before shipping it.
+
+## What this file does not claim
+
+That the classifier and the folder agree. They do not, and the enumeration
+above is the point. The claim is narrower and more useful: **every
+disagreement outside F-Exc costs coverage, never correctness**, and the two
+that go the other way are named, bounded, and justified.
+
+---
+
+## Rationale
+
+Non-normative. The reasoning that motivated each rule, carried over from the retired `requirements.md` (#46). Keyed by the rule(s) each note supports.
+
+**F-Direction** *(was R3. Membership is decided once, by a classifier permitted to err in one direction only)*
+
+The subset has exactly one definition: `findSubsetViolation` (`subset.ts:289`),
+shared by the folder and by the lint rules EVL001/EVL003 so the linted subset
+and the folded subset cannot drift (L2.*).
+
+**F-Div-*** *(was R3.1. The direction is the requirement, not the agreement)*
+
+The two consumers have different information. A lint pass has no binding
+resolver and no lexicon registry; the folder has both. The shape-only
+classifier may accept what the resolving evaluator rejects, and must never
+reject what it accepts. Enumerated divergences in that direction: identifier
+resolution (L2.3), tag registration (L2.4), helper provenance (L2.11),
+spread-source runtime type (L3.4, L3.5), a bare identifier bound to a
+same-file construction (L3.8), and, since chant-v0.63.0, a member read whose
+object resolves to `null`/`undefined` (L3.10; shape-valid, folder refuses).
+
+**F-Exc-Lazy, F-Exc-Registry** *(was R3.2. The two exceptions must be stated, not tidied away)*
+
+1. **Short-circuit laziness** (L2.9, L3.13). The folder evaluates `&&`, `||`,
+   `??` and the conditional lazily; the classifier requires every branch to be
+   valid. The implementation's own module doc calls this a wart.
+2. **Intrinsic call-form registration** (L2.12). The classifier takes the
+   registry as an optional parameter, exact with one, conservatively rejecting
+   without. The parameter exists so a downstream tool can ask "will this fold?"
+   without running a fold.

package/spec/grammar.md

@@ -0,0 +1,277 @@
+# Grammar of the fold subset
+
+Normative draft (#12). Identifiers are `S-*` per #6: every production here is
+decidable from syntax alone. Where the folder is stricter than the shape rule
+- because it also resolves names or consults a registry, the production says
+so and names the `F-*` rule (judgments.md) that adds the condition. That is
+the one direction R3.1 permits; a production must never be stricter than the
+folder.
+
+Derived from `findSubsetViolation` (`subset.ts:289`), `fold()`
+(`fold.ts:896`), `scanExports` (`fold-import.ts:591`),
+`findFunctionSubsetViolation` and `findFactorySubsetViolation`, at
+`e4074c17`, with the `?.` forms from chant-v0.63.0 (`11572c7a`, #2328). Node kinds are TypeScript's.
+
+Notation: `⟨X⟩` is a nonterminal; `|` alternation; `*` zero or more; `+` one
+or more. Terminals are TypeScript tokens or node kinds. Each production cites
+its inventory row.
+
+---
+
+## 1. Module and statements, the gate
+
+**S-Module.** A module is a sequence of top-level statements. The gate
+examines **only statements carrying `export`**. Every other statement, a
+non-exported `let`, a bare call, an `if`, a non-exported class, is neither
+admitted nor a disqualifier: it is invisible to the gate, and its effects are
+never performed (R2). (`fold-import.ts` `scanExports`, the `continue` for
+non-exported statements; L1.1.)
+
+**S-TopConst.** `const ⟨Identifier⟩ = ⟨Expr⟩`, exported or not, is a binding
+(R6.6, L5.1). A destructured or uninitialized top-level `const` is not a
+binding: the name is invisible.
+
+**S-LocalFunction.** A top-level `function ⟨Identifier⟩ ( ⟨Params⟩ ) ⟨Block⟩`,
+exported or not, and a top-level `const ⟨Identifier⟩ = ⟨Arrow⟩` or
+`= function …`, bind the name to a project-local function (F-Bind). The body
+is judged by S-FnBody at the call, never here; the name used as a value is
+F-Eval-Ident's rejection. Added in `1.2` (#95), after chant was found to
+fold both forms while the text said so for neither.
+
+A module is **admitted** when every exported statement matches one of
+S-ExportResource … S-ExportTypeOnly. One S-Disqualify match rejects the whole
+module (R4.1, L1.2–L1.5).
+
+```
+S-ExportResource    ::= export const ⟨Identifier⟩ = new ⟨Expr⟩ ( ⟨Args⟩ )
+S-ExportSingle      ::= export const ⟨Identifier⟩ = ⟨Expr⟩
+S-ExportDestructure ::= export const { ⟨PlainElement⟩+ } = ⟨Expr⟩
+S-ExportNamed       ::= export { ( ⟨Identifier⟩ ( as ⟨Identifier⟩ )? )+ }
+S-ReExport          ::= export { ( ⟨Identifier⟩ ( as ⟨Identifier⟩ )? )+ } from ⟨StringLiteral⟩
+S-ExportFunction    ::= export function ⟨Identifier⟩ ( ⟨Params⟩ ) ⟨Block⟩
+S-ExportDefault     ::= export default ⟨Expr⟩                                -- data-host; see below
+S-ExportTypeOnly    ::= export type { … }  |  a type-only element of S-ExportNamed / S-ReExport
+
+⟨PlainElement⟩      ::= ⟨Identifier⟩ | ⟨PropertyName⟩ : ⟨Identifier⟩     -- no rest, no default, no nesting
+```
+
+Notes. S-ExportFunction: an overload signature (no body) is skipped, not a
+disqualifier; the bodied declaration that follows is the export. S-ReExport:
+named elements only. S-ExportNamed: a local name must be an identifier, the
+TS 4.5 string module-export-name form disqualifies.
+
+S-ExportDefault is the declarator named `default`, admitted in the
+`data-host` profile since `1.2` (#94); in `full` it stays a disqualifier
+until chant admits it, which the profile table records as permitted and not
+required. `export default function` and `export =` disqualify in both.
+
+```
+S-Disqualify ::= export default …                              -- full only; data-host admits S-ExportDefault
+               | export default function …
+               | export * from …
+               | export class …
+               | export let …  |  export var …
+               | export const ⟨Identifier⟩                    -- no initializer
+               | export const [ … ] = …                       -- array pattern
+               | export const { … ⟨rest | default | nested⟩ … } = …
+               | export { "…" as ⟨Identifier⟩ }
+```
+
+---
+
+## 2. Expressions, the classifier
+
+`⟨Expr⟩` is any production below. The shape rule is what `findSubsetViolation`
+decides; an **F** note is a condition only the folder can check (R3.1).
+
+```
+S-Unwrap      ::= ( ⟨Expr⟩ ) | ⟨Expr⟩ as ⟨Type⟩ | ⟨Expr⟩ satisfies ⟨Type⟩ | ⟨Expr⟩ !
+S-Literal     ::= ⟨StringLiteral⟩ | ⟨NoSubstitutionTemplateLiteral⟩ | ⟨NumericLiteral⟩ | true | false | null
+S-Undefined   ::= undefined
+S-Ident       ::= ⟨Identifier⟩
+S-Template    ::= ` ⟨text⟩ ( ${ ⟨Expr⟩ } ⟨text⟩ )+ `
+S-Tagged      ::= ⟨Identifier⟩ ` … `
+S-Object      ::= { ⟨Member⟩* }
+  ⟨Member⟩    ::= S-Prop | S-Shorthand | S-SpreadProp
+  S-Prop      ::= ⟨LiteralKey⟩ : ⟨Expr⟩
+  S-Shorthand ::= ⟨Identifier⟩
+  S-SpreadProp::= ... ⟨Expr⟩
+  ⟨LiteralKey⟩::= ⟨Identifier⟩ | ⟨StringLiteral⟩ | ⟨NumericLiteral⟩
+S-Array       ::= [ ( ⟨Expr⟩ | ... ⟨Expr⟩ )* ]
+S-Member      ::= ⟨Expr⟩ ( . | ?. ) ⟨Identifier⟩
+S-Index       ::= ⟨Expr⟩ ( [ | ?.[ ) ⟨StringLiteral⟩ | ⟨NumericLiteral⟩ ]
+S-Unary       ::= ! ⟨Expr⟩ | - ⟨Expr⟩
+S-Binary      ::= ⟨Expr⟩ ⟨BinOp⟩ ⟨Expr⟩
+  ⟨BinOp⟩     ::= && | || | ?? | + | - | * | / | === | !== | > | < | >= | <=
+S-Conditional ::= ⟨Expr⟩ ? ⟨Expr⟩ : ⟨Expr⟩
+S-New         ::= new ⟨Expr⟩ ( ⟨Expr⟩* )
+S-Call        ::= S-CallHelper | S-CallIntrinsic | S-CallEager | S-CallMethod | S-CompositeStep
+  S-CallHelper    ::= ⟨HelperName⟩ ( ⟨Expr⟩* )
+  S-CallIntrinsic ::= ⟨Identifier⟩ ( ⟨Expr⟩* )        -- registry-gated
+  S-CallEager     ::= ⟨Identifier⟩ ( ⟨Expr⟩* )        -- registry-gated
+  S-CallMethod    ::= ⟨Expr⟩ ( . | ?. ) ⟨Identifier⟩ ( ⟨Expr⟩* )
+  S-CompositeStep ::= ⟨UnclaimedCall⟩ . step
+  ⟨UnclaimedCall⟩ ::= ⟨Identifier⟩ ( ⟨Expr⟩* )     -- see S-Unclaimed
+S-Reject      ::= anything else
+```
+
+Per-production conditions and divergences:
+
+| Production | Row | Shape rule | F: what the folder adds |
+|---|---|---|---|
+| S-Unwrap | L2.1 | recurse into the operand |; |
+| S-Literal | L2.2 | admitted | numeric → `Number(text)` |
+| S-Undefined |; | an identifier, shape-valid as S-Ident | folds to `undefined` |
+| S-Ident | L2.3 | always shape-valid | must resolve in `consts` then `externals` (R6.6); a bare `process` is a pointed rejection (R8); a name bound to a same-file `new` resolves only via `externals`, where F-Prebuild placed the single instance (R4.6) |
+| S-Template | L2.5 | every span ∈ ⟨Expr⟩ | spans coerce by `ToString` (R10.4) |
+| S-Tagged | L2.4 | interior **opaque**; not recursed | tag must be a registered, tag-foldable intrinsic; interior folds with unresolved dotted chains kept symbolic |
+| S-Prop | L2.6 | key must be ⟨LiteralKey⟩ (EVL001); value ∈ ⟨Expr⟩ |; |
+| S-Shorthand | L2.6 | always shape-valid | the name resolves as S-Ident |
+| S-SpreadProp | L2.6 | operand ∈ ⟨Expr⟩ | operand must fold to a non-null object (R10.6) |
+| S-Array |; | each element or spread operand ∈ ⟨Expr⟩ | spread operand must be an array (R10.6) |
+| S-Member | L2.15 | object ∈ ⟨Expr⟩, `.` or `?.`; **S-CompositeStep takes precedence** when the member is `step` and the object is a call | on a resource-bound identifier → `{__attrRef}` (R10.3); `.` on `null`/`undefined` → **refused** (R10.2, L3.10); `?.` on `null`/`undefined` → short-circuits the rest of the chain to `undefined` (L3.21) |
+| S-Index | L2.7 | key must be a string or numeric **literal** (EVL003); object ∈ ⟨Expr⟩, `[` or `?.[` | same as S-Member, including the `.`/`?.` distinction |
+| S-Unary | L2.8 | operator ∈ {`!`, `-`} | ECMAScript coercion (R10.1) |
+| S-Binary | L2.8, L2.9 | operator ∈ ⟨BinOp⟩; **both** sides ∈ ⟨Expr⟩ (flow-insensitive) | `&&`/`\|\|`/`??` evaluate lazily; the untaken side is never folded (R3.2) |
+| S-Conditional | L2.9 | all three ∈ ⟨Expr⟩ | only the taken branch is folded (R3.2) |
+| S-New | L2.10 | every argument ∈ ⟨Expr⟩, positionally; **callee shape unconstrained** | callee must be a plain identifier (L3.15, R6.3); refused inside a folded function body (R6.3) |
+| S-CallHelper | L2.11 | name ∈ `FOLDABLE_AUTHORING_HELPERS`; args ∈ ⟨Expr⟩ | name must be bound by an import from chant (R3.3); not shadowed by a local `const`; refused inside a folded function body |
+| S-CallIntrinsic | L2.12 | with a registry: name registered with `foldsAsCall`; **without a registry: S-Reject** | name must resolve through the file's imports; refused inside a folded function body |
+| S-CallEager | L2.13 | with a registry: name registered with `foldsEagerly`; without: S-Reject | callee must resolve to a function; evaluated at fold time (R7.3) |
+| S-CallLocal | L2.17, L5.4 | callee is an identifier this file binds by S-LocalFunction or by an import from a project specifier (`./`, `../`); args ∈ ⟨Expr⟩ | the body must satisfy S-FnBody at the call (F-Eval-CallLocal); a cross-file callee needs the module graph, so an expression-level folder refuses it |
+| S-CallMethod | L2.14 | receiver ∈ ⟨Expr⟩, `.` or `?.`; args ∈ ⟨Expr⟩; method name unconstrained | receiver must fold to a real value, not a symbolic envelope; the named property must be a function (R3.3). Receiver `null`/`undefined`: `.` refuses, `?.` short-circuits (L3.22) |
+| S-CompositeStep | L2.15 | any call, any arguments, member exactly `step` | callee must be an *unclaimed* bare identifier (L3.20); refused inside a folded function body |
+| S-Reject | L2.16 | EVL001 |; |
+
+**S-Unclaimed.** A call is *unclaimed* when its callee is a bare identifier
+that no other S-Call form claims. The callee must not be:
+
+- a registered authoring helper
+- an intrinsic the registry admits in call or eager form
+- a project-local function the scope binds
+- shadowed by a local `const`
+
+Only the bare-identifier part is decidable from syntax. The four conditions
+are resolution, so S-CompositeStep admits any call at shape level and
+F-Eval-Member step 2 applies the full test. S-CompositeStep, F-Div-Step and
+F-Eval-Member all used this term without a definition until #51.
+
+**Explicitly outside the subset** (S-Reject at shape level, and rejected by
+the folder): an arrow or function expression as a value (L3.1); class
+expressions; `await`, `yield`; assignment and compound assignment; the comma
+operator; `typeof`, `void`, `delete`, `++`, `--`; `==`, `!=`, `%`, `**`, the
+bitwise operators, `in`, `instanceof`; a computed property name; a
+non-literal element-access key; a call not matching any S-Call form. Optional chaining is
+specified, not merely admitted: since chant-v0.63.0 a `?.` on a nullish object
+produces a chain-short-circuit value that propagates through the remaining
+`.`/`[]`/`!`/`?.()` of the same chain and becomes `undefined` at its end -
+ECMAScript's semantics, implemented rather than coincidental.
+
+---
+
+## 3. Body sub-grammars
+
+Two further statement-level grammars govern what may appear *inside* a
+function the folder evaluates. Both are stricter than S-Module.
+
+**S-FnBody**, a project-local function (R6.5, L5.4):
+
+```
+S-FnParams ::= ( ⟨Identifier⟩ ( = ⟨Expr⟩ )? | { ⟨PlainElement⟩+ } )*    -- no rest, no array pattern
+S-FnBody   ::= ⟨Expr⟩
+             | { ( const ⟨Identifier⟩ = ⟨Expr⟩ | const { ⟨PlainElement⟩+ } = ⟨Expr⟩ )*  ( return ⟨Expr⟩? )? }
+```
+
+No generator, no `async`, no early `return`, no `let`/`var`, no uninitialized
+`const`, no other statement kind. A block with no `return` evaluates to
+`undefined`. Inside S-FnBody the expression grammar **loses** S-New, S-Tagged,
+S-CallHelper, S-CallIntrinsic and S-CompositeStep (R6.3, L3.16).
+
+**S-FactoryBody**, an interpretable composite factory (R7.2 rules 3–5, L7.3–L7.5):
+
+```
+S-FactoryParams ::= ( ⟨Identifier⟩ | { ⟨PlainElement⟩+ } )?     -- at most one; no default, no rest
+S-FactoryBody   ::= ⟨Expr⟩
+                  | { ( const … = ⟨Expr⟩ )*  return ⟨Expr⟩ }      -- must end in return; empty body rejected
+```
+
+Inside S-FactoryBody the expression grammar **gains** `new` in any value
+position and a call through a bare identifier (a nested composite, a
+registered helper, an opted-in intrinsic), and a method call stays out (per
+the contract above `resolveInterpretableFactory`; `checkFactoryExpression`'s
+exact set is not transcribed here, #44 precondition).
+
+The asymmetry between the two. S-FnBody tolerates a missing `return`,
+S-FactoryBody requires one, is R6.5's and is a decision the spec should make
+rather than inherit.
+
+---
+
+## What this grammar does not decide
+
+Resolution (R6.6), registration (R3.2), trust (R2.1), the fold/run verdict and
+its taint (R4, judgments.md), and every semantic rule in R10. A string that
+parses under this grammar is *shape-admissible*; whether it folds is the
+judgments' question.
+
+---
+
+## Rationale
+
+Non-normative. The reasoning that motivated each rule, carried over from the retired `requirements.md` (#46). Keyed by the rule(s) each note supports.
+
+**S-Call** *(was R3.3. A call is structurally unrepresentable, with an enumerated set of exceptions)*
+
+A function call as a value has no evaluation case, it is absent from the
+mechanism, not forbidden by a rule (L2.16). The spec must enumerate the
+exceptions exhaustively, and say which *kind* each is:
+
+| Exception | Kind | Rows |
+|---|---|---|
+| registered authoring helper | closed allowlist, name **and** import provenance | L2.11 |
+| lexicon intrinsic, call form opted in | closed allowlist, per intrinsic | L2.12 |
+| project-local function with a foldable body | open, local; the callee's binding is visible in the file, which is S-CallLocal since `1.2` | L2.17, L5.4 |
+| eagerly-evaluated lexicon function | closed allowlist, evaluates at fold time | L2.13, R7.3 |
+| method call on a real receiver | receiver-type condition, method never checked by name | L2.14, L3.18, L3.19 |
+| `<Identifier>(...).step` | one idiom, member fixed, callee must be unclaimed | L2.15, L3.20 |
+
+"The callee is admitted" and "the receiver is admitted" are different
+admissibility rules and an implementer will conflate them.
+
+---
+
+**S-Module** *(was R6. Admissibility is decided at two layers, and is scope-dependent)*
+
+The first revision specified only the expression layer.
+
+**S-Module, S-Disqualify** *(was R6.1. The statement gate runs first and disqualifies whole files)*
+
+`scanExports` (L1.1–L1.6) recognizes exactly: `export const X = new Type(...)`,
+`export const X = <expr>`, `export const {a, b} = <expr>`, `export {a, b}`,
+`export {a, b} from "./m"`, and `export function f() {}`. Anything else
+disqualifies the file: `export default`, `export * from`, an exported class,
+`let`/`var`, a destructured export with a rest, nested or defaulted element.
+`export type {...}` and type-only re-export elements are erased, not
+disqualifiers (L1.6).
+
+**§2** *(was R6.2. The expression layer is R3's subject and #12's grammar)*
+
+Every expression reachable from an admitted statement is classified by R3's
+single definition. The admissible forms, literals, templates with spans,
+object members with literal keys, element access with literal keys, the
+operator sets, positional `new` arguments, are enumerated by the grammar
+(#12), not here. Inventory rows L2.1, L2.2, L2.5–L2.8, L2.10 remain GAP until
+#12 lands.
+
+**S-FnBody, S-FactoryBody** *(was R6.5. Two further statement-level subsets, and an asymmetry between them)*
+
+A **project-local function** is admissible (L5.4) when its parameters bind
+plainly, its body is a single expression or `const` declarations followed by
+one `return`, and it is not a generator, async, rest-parameter, early-return,
+or `let`/`var` function. Parameter defaults fold in the callee's scope (L5.6).
+A block body with no `return` evaluates to `undefined` (L5.7).
+
+A **composite factory** is admissible (R7.2) under rules 3–5 of the same
+shape, except that its body **must** end in `return` and an empty body is
+rejected (L7.4). The two subsets differ on exactly this point and the spec
+should say why, or fix one.