@intentius/tsad-conformance 1.4.0

package/fixtures/F-Seed/seeded-by-its-own-body/project/app.ts

@@ -0,0 +1,8 @@
+export function classify(n: number) {
+  if (n > 0) {
+    return "big";
+  }
+  return "small";
+}
+
+export const label = classify(1);

package/fixtures/F-Seed/seeded-by-its-own-body/project/lone.ts

@@ -0,0 +1 @@
+export const value = 1;

package/fixtures/F-Succ/backward-along-captures/expect.json

@@ -0,0 +1,26 @@
+{
+  "rules": [
+    "F-Succ",
+    "F-Capture",
+    "F-Identity",
+    "F-Memo",
+    "F-Taint",
+    "F-Obs-Report"
+  ],
+  "project": true,
+  "verdicts": {
+    "breaker.ts": "run",
+    "shared.ts": "run",
+    "sibling.ts": "run"
+  },
+  "tentative": {
+    "breaker.ts": "run",
+    "shared.ts": "fold",
+    "sibling.ts": "fold"
+  },
+  "taintedBy": {
+    "shared.ts": "breaker.ts",
+    "sibling.ts": "shared.ts"
+  },
+  "note": "The backward edge, two hops. breaker.ts is in the seed and taints shared.ts forward; shared.ts then taints sibling.ts backward because sibling.ts captured its registry object. Nothing in sibling.ts predicts its own verdict, which is why a fallback report has to be able to name the capture. The captured value is a plain object, which F-Identity's reference test admits and its entity test would not: the edge exists here because F-Capture over-approximates on purpose. It is also the fixture that holds F-Memo: the edge only exists because the object in sibling.ts's namespace is the very object shared.ts produced, and it caught a revival pass that rebuilt plain structures and handed out copies. The reason on the capturer must be able to say it was forced to run because the source runs and it captured the source's objects; nothing in its own source predicts that (F-Obs-Report)."
+}

package/fixtures/F-Succ/backward-along-captures/project/breaker.ts

@@ -0,0 +1,10 @@
+import { registry } from "./shared";
+
+export function guard(r: { name: string }) {
+  if (r.name) {
+    return r.name;
+  }
+  return "";
+}
+
+export const name = guard(registry);

package/fixtures/F-Succ/backward-along-captures/project/shared.ts

@@ -0,0 +1 @@
+export const registry = { name: "shared" };

package/fixtures/F-Succ/backward-along-captures/project/sibling.ts

@@ -0,0 +1,3 @@
+import { registry } from "./shared";
+
+export const wrapper = { registry };

package/fixtures/F-Succ/forward-into-imports/expect.json

@@ -0,0 +1,8 @@
+{
+  "rules": ["F-Succ", "F-Taint", "F-Import"],
+  "project": true,
+  "verdicts": { "app.ts": "run", "config.ts": "run" },
+  "tentative": { "app.ts": "run", "config.ts": "fold" },
+  "taintedBy": { "config.ts": "app.ts" },
+  "note": "The forward edge. config.ts folds on its own, and runs anyway because app.ts, which imports it, runs: app.ts's real import would construct a second settings object. This is chant#1107's observation, that fixing a leaf buys nothing while an importer still runs."
+}

package/fixtures/F-Succ/forward-into-imports/project/app.ts

@@ -0,0 +1,10 @@
+import { settings } from "./config";
+
+export function ensure(p: number) {
+  if (p > 0) {
+    return p;
+  }
+  return 1;
+}
+
+export const port = ensure(settings.port);

package/fixtures/F-Succ/forward-into-imports/project/config.ts

@@ -0,0 +1 @@
+export const settings = { port: 8080 };

package/fixtures/F-Taint/independent-file-still-folds/expect.json

@@ -0,0 +1,9 @@
+{
+  "rules": ["F-Taint", "F-Fix", "F-Verdict"],
+  "project": true,
+  "verdicts": { "app.ts": "run", "alone.ts": "fold" },
+  "tentative": { "app.ts": "run", "alone.ts": "fold" },
+  "taintedBy": {},
+  "exports": { "alone.ts": { "value": { "kept": true, "items": [1, 2] } } },
+  "note": "The control. T(B) is the LEAST set closed under Succ, so a file no edge reaches keeps its fold verdict. An implementation that fell back whenever any file in the build fell back would pass the other three fixtures and fail this one."
+}

package/fixtures/F-Taint/independent-file-still-folds/project/alone.ts

@@ -0,0 +1 @@
+export const value = { kept: true, items: [1, 2] };

package/fixtures/F-Taint/independent-file-still-folds/project/app.ts

@@ -0,0 +1,8 @@
+export function classify(n: number) {
+  if (n > 0) {
+    return "big";
+  }
+  return "small";
+}
+
+export const label = classify(1);

package/fixtures/F-Total/one-bad-declarator-fails-the-file/expect.json

@@ -0,0 +1,7 @@
+{
+  "rules": ["F-Total", "F-Declarator", "F-Reference"],
+  "project": true,
+  "verdicts": { "mixed.ts": "run" },
+  "tentative": { "mixed.ts": "run" },
+  "note": "No partial namespace is ever produced. The first declarator reduces and the second does not, and the verdict is run for the whole file, so a consumer never sees a half-folded module."
+}

package/fixtures/F-Total/one-bad-declarator-fails-the-file/project/mixed.ts

@@ -0,0 +1,3 @@
+export const good = { a: 1 };
+
+export const bad = missing.value;

package/fixtures/F-Val-Arity/props-attributes-and-spread/expect.json

@@ -0,0 +1,14 @@
+{
+  "rules": ["F-Val-Arity"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "arities.ts": "fold" },
+  "exports": {
+    "arities.ts": {
+      "withProps": { "entityType": "Bucket", "lexicon": "shapes", "props": { "name": "a" }, "attributes": {} },
+      "withAttributes": { "entityType": "Bucket", "lexicon": "shapes", "props": { "name": "b" }, "attributes": { "region": "eu" } },
+      "spread": { "left": 1, "right": "two", "entityType": "Pair", "lexicon": "shapes" }
+    }
+  },
+  "note": "Both arms. A leading object literal is props, a second one is attributes, and anything else is spread positionally. The three forms are distinguished at fold time by the shape of the argument list, so revival has only to honour what the envelope recorded."
+}

package/fixtures/F-Val-Arity/props-attributes-and-spread/project/arities.ts

@@ -0,0 +1,5 @@
+import { Bucket, Pair } from "@tsad/shapes";
+
+export const withProps = new Bucket({ name: "a" });
+export const withAttributes = new Bucket({ name: "b" }, { region: "eu" });
+export const spread = new Pair(1, "two");

package/fixtures/F-Val-Callable/host-function-as-value/expect.json

@@ -0,0 +1,16 @@
+{
+  "rules": [
+    "F-Val-Callable",
+    "F-Eval-Ident",
+    "F-Import"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "app.ts": "run"
+  },
+  "rejectRule": {
+    "app.ts": "F-Eval-Ident"
+  },
+  "note": "A host function bound by an import and used as a value (#69). The binding exists, so a call would fold (it is a registered helper); the value use is refused, because a callable is reached only by the form that invokes it and could never reach a serializer. chant refuses the same file by never binding an unregistered callable; the verdicts agree."
+}

package/fixtures/F-Val-Callable/host-function-as-value/project/app.ts

@@ -0,0 +1,3 @@
+import { upper } from "@tsad/shapes";
+
+export const f = { shout: upper };

package/fixtures/F-Val-Fate/revive-every-envelope/expect.json

@@ -0,0 +1,15 @@
+{
+  "rules": ["F-Val-Fate", "F-Val-Position"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "entities.ts": "fold" },
+  "exports": {
+    "entities.ts": {
+      "bucket": { "entityType": "Bucket", "lexicon": "shapes", "props": { "name": "logs" }, "attributes": {} },
+      "tagged": "bucket-1",
+      "shouted": "DONE",
+      "reference": { "who": { "__attrRef": { "entity": "bucket", "attribute": "name" } } }
+    }
+  },
+  "note": "Four of the six envelopes and the one that survives. The resource is constructed by the class the file imports, the intrinsic tag and the helper are invoked, and the attribute reference passes through unrevived because nothing in the build has named the instance yet."
+}

package/fixtures/F-Val-Fate/revive-every-envelope/project/entities.ts

@@ -0,0 +1,6 @@
+import { Bucket, join, upper } from "@tsad/shapes";
+
+export const bucket = new Bucket({ name: "logs" });
+export const tagged = join`bucket-${1}`;
+export const shouted = upper("done");
+export const reference = { who: bucket.name };

package/fixtures/F-Val-Live/plain-data-is-not-live/expect.json

@@ -0,0 +1,9 @@
+{
+  "rules": ["F-Val-Live", "F-Identity"],
+  "project": true,
+  "verdicts": { "source.ts": "run", "breaker.ts": "run", "quiet.ts": "fold" },
+  "tentative": { "source.ts": "fold", "breaker.ts": "run", "quiet.ts": "fold" },
+  "taintedBy": { "source.ts": "breaker.ts" },
+  "exports": { "quiet.ts": { "data": { "n": 2, "nested": { "deeper": [2, 2] } } } },
+  "note": "The entity test earning its keep. breaker.ts is in the seed and taints source.ts forward. quiet.ts calls the same function and survives, because nothing the call returned carries a live object: under the reference test every parameter helper would be a taint source and quiet.ts would fall back with it."
+}

package/fixtures/F-Val-Live/plain-data-is-not-live/project/breaker.ts

@@ -0,0 +1,10 @@
+import { plain } from "./source";
+
+export function guard(n: number) {
+  if (n > 0) {
+    return n;
+  }
+  return 0;
+}
+
+export const value = guard(plain(1).n);

package/fixtures/F-Val-Live/plain-data-is-not-live/project/quiet.ts

@@ -0,0 +1,3 @@
+import { plain } from "./source";
+
+export const data = plain(2);

package/fixtures/F-Val-Live/plain-data-is-not-live/project/source.ts

@@ -0,0 +1,5 @@
+export function plain(n: number) {
+  return { n: n, nested: { deeper: [n, n] } };
+}
+
+export const marker = 1;

package/fixtures/F-Val-Position/attrref-in-host-arguments/expect.json

@@ -0,0 +1,8 @@
+{
+  "rules": ["F-Val-Position", "F-Val-Fate"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "rejected.ts": "run" },
+  "tentative": { "rejected.ts": "run" },
+  "note": "The other arm. An attribute reference passes through revival everywhere except inside a host call's arguments, where it is rejected: the receiver would see a look-alike plain object instead of a live instance and produce wrong output rather than absent output. Wrong output is the one failure a fallback cannot repair, so this is a rejection and not a pass-through."
+}

package/fixtures/F-Val-Position/attrref-in-host-arguments/project/rejected.ts

@@ -0,0 +1,4 @@
+import { Bucket, upper } from "@tsad/shapes";
+
+export const bucket = new Bucket({ name: "logs" });
+export const shouted = upper(bucket.name);

package/fixtures/F-Val-Undefined/array-element-undefined/expect.json

@@ -0,0 +1,15 @@
+{
+  "rules": [
+    "F-Val-Undefined",
+    "F-Eval-Array"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": [
+    1,
+    "$undefined",
+    3
+  ],
+  "note": "In an array position undefined stays undefined in the namespace and becomes null at emission, not absent: the array keeps its length (F-Val-Undefined)."
+}

package/fixtures/F-Val-Undefined/array-element-undefined/input.ts

@@ -0,0 +1 @@
+export const x = [1, undefined, 3];

package/fixtures/F-Val-Undefined/conditional-yields-undefined/expect.json

@@ -0,0 +1,13 @@
+{
+  "rules": [
+    "F-Val-Undefined",
+    "F-Eval-Conditional"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": {
+    "a": "$undefined"
+  },
+  "note": "The idiom a selective-by-omission consumer will write: a field set only when a condition holds. The untaken branch is never folded; the taken one yields undefined and the key is present with it."
+}

package/fixtures/F-Val-Undefined/conditional-yields-undefined/input.ts

@@ -0,0 +1,2 @@
+const on = false;
+export const x = { a: on ? 1 : undefined };

package/fixtures/F-Val-Undefined/optional-chain-yields-undefined-property/expect.json

@@ -0,0 +1,13 @@
+{
+  "rules": [
+    "F-Val-Undefined",
+    "F-Eval-Member"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": {
+    "b": "$undefined"
+  },
+  "note": "A short-circuited chain yields undefined, and the property it lands in is present with that value, exactly as running the expression leaves it."
+}

package/fixtures/F-Val-Undefined/optional-chain-yields-undefined-property/input.ts

@@ -0,0 +1,2 @@
+const o = { a: null };
+export const x = { b: o.a?.c };

package/fixtures/F-Val-Undefined/property-literal-undefined/expect.json

@@ -0,0 +1,16 @@
+{
+  "rules": [
+    "F-Val-Undefined",
+    "F-Eval-Undefined",
+    "F-Eval-Object",
+    "F-Val-Serializable"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": {
+    "a": 1,
+    "b": "$undefined"
+  },
+  "note": "The key is present in the folded namespace with the value undefined; emission drops it (F-Val-Undefined). A consumer whose contract is selective-by-omission has to know which of the two it is reading, and the namespace keeps the distinction that JSON loses (#82)."
+}

package/fixtures/F-Val-Undefined/property-literal-undefined/input.ts

@@ -0,0 +1 @@
+export const x = { a: 1, b: undefined };

package/fixtures/F-Val-Undefined/spread-carries-undefined/expect.json

@@ -0,0 +1,14 @@
+{
+  "rules": [
+    "F-Val-Undefined",
+    "F-Eval-Object"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": {
+    "a": "$undefined",
+    "b": 1
+  },
+  "note": "Object spread copies own enumerable entries, and an undefined-valued entry is one of them (R10.5). The key travels; only emission drops it."
+}

package/fixtures/F-Val-Undefined/spread-carries-undefined/input.ts

@@ -0,0 +1,2 @@
+const d = { a: undefined };
+export const x = { ...d, b: 1 };

package/fixtures/S-Array/spread/expect.json

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

package/fixtures/S-Array/spread/input.ts

@@ -0,0 +1 @@
+const t = [2, 3]; export const x = [1, ...t, 4];

package/fixtures/S-Binary/arithmetic-and-concat/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Binary", "F-Eval-Binary"], "export": "x", "shape": "accept", "fold": "fold", "value": [3, "a1", 3.5, true, false], "note": "R10.1: ECMAScript semantics per operator, including + string dispatch." }

package/fixtures/S-Binary/arithmetic-and-concat/input.ts

@@ -0,0 +1 @@
+export const x = [1 + 2, "a" + 1, 7 / 2, 3 === 3, 2 < 1];

package/fixtures/S-Binary/lazy-untaken-unfoldable/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Binary", "F-Eval-Binary", "F-Exc-Lazy"], "export": "x", "shape": "reject", "fold": "fold", "value": false, "note": "F-Exc-Lazy: the classifier rejects (right operand out of subset); the folder never folds the untaken side. The exception to F-Direction, exercised." }

package/fixtures/S-Binary/lazy-untaken-unfoldable/input.ts

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

package/fixtures/S-Binary/nullish-coalesce/expect.json

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

package/fixtures/S-Binary/nullish-coalesce/input.ts

@@ -0,0 +1 @@
+const u = undefined; export const x = u ?? "d";

package/fixtures/S-CallLocal/imported-callee-is-shape-valid/expect.json

@@ -0,0 +1,10 @@
+{
+  "rules": [
+    "S-CallLocal",
+    "S-Call"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "run",
+  "note": "The callee is bound by an import from a project specifier, which the classifier can see in the file, so the call is shape-valid (spec 1.2). An expression fixture has no module graph, so the folder cannot resolve twice and refuses; the whole-build form is F-Eval-CallLocal/local-function-folds. chant's classifier rejects this today (chant#2435), and the agreement test holds the shape half out until it does not."
+}

package/fixtures/S-CallLocal/imported-callee-is-shape-valid/input.ts

@@ -0,0 +1,3 @@
+import { twice } from "./pure";
+
+export const x = twice(21);

package/fixtures/S-Conditional/taken-branch-only/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Conditional", "F-Eval-Conditional", "F-Exc-Lazy"], "export": "x", "shape": "reject", "fold": "fold", "value": "yes", "note": "F-Exc-Lazy for the conditional: untaken branch is never folded." }

package/fixtures/S-Conditional/taken-branch-only/input.ts

@@ -0,0 +1 @@
+export const x = true ? "yes" : getId();

package/fixtures/S-ExportDefault/imported-by-sibling/expect.json

@@ -0,0 +1,30 @@
+{
+  "rules": [
+    "S-ExportDefault",
+    "F-Import",
+    "F-Declarator"
+  ],
+  "project": true,
+  "profiles": [
+    "data-host"
+  ],
+  "verdicts": {
+    "policy.ts": "fold",
+    "app.ts": "fold"
+  },
+  "exports": {
+    "policy.ts": {
+      "default": {
+        "name": "svc",
+        "replicas": 2
+      }
+    },
+    "app.ts": {
+      "doubled": {
+        "name": "svc",
+        "replicas": 4
+      }
+    }
+  },
+  "note": "A default import binds the target's default export (F-Import), and the value is data like any other."
+}

package/fixtures/S-ExportDefault/imported-by-sibling/project/app.ts

@@ -0,0 +1,3 @@
+import policy from "./policy";
+
+export const doubled = { ...policy, replicas: policy.replicas * 2 };

package/fixtures/S-ExportDefault/imported-by-sibling/project/policy.ts

@@ -0,0 +1 @@
+export default { name: "svc", replicas: 2 };

package/fixtures/S-ExportDefault/plain-object/expect.json

@@ -0,0 +1,21 @@
+{
+  "rules": [
+    "S-ExportDefault",
+    "F-Declarator",
+    "F-Scan"
+  ],
+  "export": "default",
+  "shape": "accept",
+  "fold": "fold",
+  "value": {
+    "a": 1,
+    "b": [
+      2,
+      3
+    ]
+  },
+  "profiles": [
+    "data-host"
+  ],
+  "note": "The idiom of every configuration file (spec 1.2, #94). The export is named default. Tagged data-host only: the full profile keeps export default under S-Disqualify until chant admits it, and the first consumer worked around it with a named export."
+}

package/fixtures/S-ExportDefault/plain-object/input.ts

@@ -0,0 +1 @@
+export default { a: 1, b: [2, 3] };

package/fixtures/S-Ident/const-chain/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Ident", "F-Eval-Ident"], "export": "x", "shape": "accept", "fold": "fold", "value": 1, "note": "F-Eval-Ident step 2: a const resolves to its initializer, transitively." }

package/fixtures/S-Ident/const-chain/input.ts

@@ -0,0 +1 @@
+const a = 1; const b = a; export const x = b;

package/fixtures/S-Ident/process/expect.json

@@ -0,0 +1 @@
+{ "rules": ["F-Eval-Ident"], "export": "x", "shape": "accept", "fold": "run", "note": "F-Eval-Ident step 4: a bare process reference is a pointed rejection." }

package/fixtures/S-Ident/process/input.ts

@@ -0,0 +1 @@
+export const x = process;

package/fixtures/S-Ident/unresolved/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Ident", "F-Eval-Ident", "F-Div-Ident"], "export": "x", "shape": "accept", "fold": "run", "note": "F-Direction: shape accepts any identifier; the folder rejects an unresolved one. The canonical permitted-direction divergence." }

package/fixtures/S-Ident/unresolved/input.ts

@@ -0,0 +1 @@
+export const x = nope;

package/fixtures/S-Index/dynamic-key/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Index", "F-Eval-Index"], "export": "x", "shape": "reject", "fold": "run", "note": "EVL003: a non-literal key is rejected at shape and at fold." }

package/fixtures/S-Index/dynamic-key/input.ts

@@ -0,0 +1 @@
+const o = { k: "v" }; const key = "k"; export const x = o[key];

package/fixtures/S-Index/literal-key/expect.json

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

package/fixtures/S-Index/literal-key/input.ts

@@ -0,0 +1 @@
+const o = { k: "v" }; export const x = o["k"];

package/fixtures/S-Literal/null-and-booleans/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Literal", "S-Array", "F-Eval-Literal", "F-Eval-Array"], "export": "x", "shape": "accept", "fold": "fold", "value": [true, false, null] }

package/fixtures/S-Literal/null-and-booleans/input.ts

@@ -0,0 +1 @@
+export const x = [true, false, null];

package/fixtures/S-Literal/numeric/expect.json

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

package/fixtures/S-Literal/numeric/input.ts

@@ -0,0 +1 @@
+export const x = 42;

package/fixtures/S-LocalFunction/arrow-const-call/expect.json

@@ -0,0 +1,21 @@
+{
+  "rules": [
+    "S-LocalFunction",
+    "F-Bind",
+    "F-Eval-CallLocal",
+    "S-FnBody"
+  ],
+  "project": true,
+  "verdicts": {
+    "label.ts": "fold"
+  },
+  "exports": {
+    "label.ts": {
+      "y": {
+        "label": "k",
+        "upper": true
+      }
+    }
+  },
+  "note": "A const bound to an arrow is a project-local function, and its concise body is S-FnBody's first alternative. This is the helper the first consumer wrote and had refused; chant's build folds it (chant#2435 is the classifier)."
+}

package/fixtures/S-LocalFunction/arrow-const-call/project/label.ts

@@ -0,0 +1,3 @@
+const label = (s: string) => ({ label: s, upper: s === "k" });
+
+export const y = label("k");

package/fixtures/S-LocalFunction/function-as-value-still-rejects/expect.json

@@ -0,0 +1,11 @@
+{
+  "rules": [
+    "S-LocalFunction",
+    "F-Eval-Ident",
+    "F-Val-Callable"
+  ],
+  "export": "f",
+  "shape": "accept",
+  "fold": "run",
+  "note": "Binding the arrow as a function changes nothing about its use as a value: F-Eval-Ident step 3 rejects a FoldableFunction in value position, so nothing unserialisable reaches the namespace."
+}

package/fixtures/S-LocalFunction/function-as-value-still-rejects/input.ts

@@ -0,0 +1,3 @@
+const label = (s: string) => ({ label: s });
+
+export const f = { g: label };

package/fixtures/S-LocalFunction/same-file-declaration-call/expect.json

@@ -0,0 +1,19 @@
+{
+  "rules": [
+    "S-LocalFunction",
+    "F-Bind",
+    "F-Eval-CallLocal"
+  ],
+  "project": true,
+  "verdicts": {
+    "twice.ts": "fold"
+  },
+  "exports": {
+    "twice.ts": {
+      "x": {
+        "doubled": 42
+      }
+    }
+  },
+  "note": "A same-file function declaration, not exported, binds a project-local function (spec 1.2, #95). chant's build folded this before the text said so; its classifier and its expression folder still refuse it (chant#2435), which is why this is a whole-build fixture."
+}

package/fixtures/S-LocalFunction/same-file-declaration-call/project/twice.ts

@@ -0,0 +1,5 @@
+function twice(n: number) {
+  return { doubled: n * 2 };
+}
+
+export const x = twice(21);

package/fixtures/S-Member/nested/expect.json

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

package/fixtures/S-Member/nested/input.ts

@@ -0,0 +1 @@
+const o = { a: { b: "deep" } }; export const x = o.a.b;

package/fixtures/S-Member/nullish-plain-refuses/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Member", "F-Eval-Member", "F-Div-Nullish"], "export": "x", "shape": "accept", "fold": "run", "note": "chant-v0.63.0: a plain read on undefined refuses (running throws). Shape cannot see it." }

package/fixtures/S-Member/nullish-plain-refuses/input.ts

@@ -0,0 +1 @@
+const o = { a: { b: 1 } }; export const x = o.nope.b;

package/fixtures/S-Member/optional-chain/expect.json

@@ -0,0 +1 @@
+{"rules": ["S-Member", "F-Eval-Member"], "export": "x", "shape": "accept", "fold": "fold", "value": "$undefined", "note": "?. on a nullish object short-circuits the chain to undefined (F-Eval-Member steps 3\u20134, chant-v0.63.0). The folded value is undefined itself; what a serializer does with it is F-Val-Undefined's question, not this fixture's."}

package/fixtures/S-Member/optional-chain/input.ts

@@ -0,0 +1 @@
+const o = { a: { b: 1 } }; export const x = o.nope?.b;

package/fixtures/S-Object/spread-later-wins/expect.json

@@ -0,0 +1 @@
+{ "rules": ["S-Object", "S-SpreadProp", "F-Eval-Object"], "export": "x", "shape": "accept", "fold": "fold", "value": { "a": 1, "b": 3, "c": 4 }, "note": "R10.5: insertion order, later key wins." }

package/fixtures/S-Object/spread-later-wins/input.ts

@@ -0,0 +1 @@
+const d = { a: 1, b: 2 }; export const x = { ...d, b: 3, c: 4 };