@intentius/tsad-conformance 1.4.0

package/fixtures/F-Eval-Binary/logical-return-operand/input.ts

@@ -0,0 +1 @@
+export const x = [0 || "x", "" && 1, null ?? 0, 0 ?? 1, "" ?? "y", false || null, "a" && "b", undefined ?? null];

package/fixtures/F-Eval-Binary/plus-dispatch/expect.json

@@ -0,0 +1,19 @@
+{
+  "rules": [
+    "F-Eval-Binary"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": [
+    "12",
+    "34",
+    "33",
+    "123",
+    2,
+    1,
+    0.30000000000000004,
+    0.7999999999999999
+  ],
+  "note": "+ dispatches on the operands after ToPrimitive: one string makes it concatenation, left to right, so 1 + 2 + \"3\" is \"33\" and \"1\" + 2 + 3 is \"123\"; booleans and null go through ToNumber. The two float results are the doubles ECMAScript produces, not what decimal arithmetic would (R10.1)."
+}

package/fixtures/F-Eval-Binary/plus-dispatch/input.ts

@@ -0,0 +1 @@
+export const x = [1 + "2", "3" + 4, 1 + 2 + "3", "1" + 2 + 3, true + 1, null + 1, 0.1 + 0.2, 0.1 + 0.7];

package/fixtures/F-Eval-Binary/relational-on-strings/expect.json

@@ -0,0 +1,18 @@
+{
+  "rules": [
+    "F-Eval-Binary"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": [
+    true,
+    true,
+    false,
+    true,
+    false,
+    true,
+    true
+  ],
+  "note": "Relational operators compare two strings by code unit (\"10\" < \"9\") and coerce a string against a number (\"10\" < 9 is 10 < 9). Strict equality never coerces. All ECMAScript, and all easy to get wrong in a port that reaches for its host language's comparison."
+}

package/fixtures/F-Eval-Binary/relational-on-strings/input.ts

@@ -0,0 +1 @@
+export const x = ["b" > "a", "10" < "9", "10" < 9, "a" === "a", 1 === "1", "1" !== 1, 2 >= "2"];

package/fixtures/F-Eval-CallEager/evaluated-at-fold-time/expect.json

@@ -0,0 +1,8 @@
+{
+  "rules": ["F-Eval-CallEager", "F-Host-Admission", "S-CallEager"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "app.ts": "fold" },
+  "exports": { "app.ts": { "n": 3 } },
+  "note": "An eager intrinsic is invoked now, with the folded arguments, and the result is the value. F-Host-Admission is what makes that sound: count is a pure function of its arguments, so invoking it at fold time is indistinguishable from invoking it during a run."
+}

package/fixtures/F-Eval-CallEager/evaluated-at-fold-time/project/app.ts

@@ -0,0 +1,3 @@
+import { count } from "@tsad/shapes";
+
+export const n = count([1, 2, 3]);

package/fixtures/F-Eval-CallEager/not-a-function/expect.json

@@ -0,0 +1,22 @@
+{
+  "rules": [
+    "F-Eval-CallEager",
+    "F-Host-NoSubstitution"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "local.ts": "run",
+    "app.ts": "run"
+  },
+  "rejectRule": {
+    "app.ts": "F-Eval-CallEager"
+  },
+  "note": "The registry names count as eager, but the binding the file imported is a project file's number, not the host's function. Revival invokes what the import names and never substitutes the host's own (F-Host-NoSubstitution), so the call rejects: the name alone admits nothing. local.ts would fold on its own; app.ts imports it and runs, so the forward edge (F-Succ) takes it along.",
+  "tentative": {
+    "local.ts": "fold"
+  },
+  "taintedBy": {
+    "local.ts": "app.ts"
+  }
+}

package/fixtures/F-Eval-CallEager/not-a-function/project/app.ts

@@ -0,0 +1,3 @@
+import { count } from "./local";
+
+export const n = count([1, 2, 3]);

package/fixtures/F-Eval-CallEager/not-a-function/project/local.ts

@@ -0,0 +1 @@
+export const count = 3;

package/fixtures/F-Eval-CallHelper/helper-folds/expect.json

@@ -0,0 +1,8 @@
+{
+  "rules": ["F-Eval-CallHelper", "S-CallHelper"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "app.ts": "fold" },
+  "exports": { "app.ts": { "v": "DONE" } },
+  "note": "A registered authoring helper: J1 yields a {__helper} envelope, revival invokes the function the file imported."
+}

package/fixtures/F-Eval-CallHelper/helper-folds/project/app.ts

@@ -0,0 +1,3 @@
+import { upper } from "@tsad/shapes";
+
+export const v = upper("done");

package/fixtures/F-Eval-CallHelper/inside-function-body/expect.json

@@ -0,0 +1,22 @@
+{
+  "rules": [
+    "F-Eval-CallHelper",
+    "F-Div-Depth"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "fn.ts": "run",
+    "app.ts": "run"
+  },
+  "rejectRule": {
+    "app.ts": "F-Eval-CallHelper"
+  },
+  "note": "A helper call inside a folded function body is refused, the same way a `new` and an intrinsic call are. fn.ts would fold on its own; app.ts imports it and runs, so the forward edge (F-Succ) takes it along.",
+  "tentative": {
+    "fn.ts": "fold"
+  },
+  "taintedBy": {
+    "fn.ts": "app.ts"
+  }
+}

package/fixtures/F-Eval-CallHelper/inside-function-body/project/app.ts

@@ -0,0 +1,3 @@
+import { shout } from "./fn";
+
+export const v = shout("a");

package/fixtures/F-Eval-CallHelper/inside-function-body/project/fn.ts

@@ -0,0 +1,5 @@
+import { upper } from "@tsad/shapes";
+
+export function shout(s: string) {
+  return upper(s);
+}

package/fixtures/F-Eval-CallIntrinsic/call-form-folds/expect.json

@@ -0,0 +1,8 @@
+{
+  "rules": ["F-Eval-CallIntrinsic", "F-Host-Registry", "F-Host-Interface", "S-CallIntrinsic"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "app.ts": "fold" },
+  "exports": { "app.ts": { "r": { "Ref": "Bucket" } } },
+  "note": "An intrinsic registered with foldsAsCall: J1 yields an {__intrinsic} envelope and revival invokes the function the file imported. The registry entry is what admits the call form; the same name without the flag is F-Host-Registry's tag-called-as-function fixture."
+}

package/fixtures/F-Eval-CallIntrinsic/call-form-folds/project/app.ts

@@ -0,0 +1,3 @@
+import { ref } from "@tsad/shapes";
+
+export const r = ref("Bucket");

package/fixtures/F-Eval-CallIntrinsic/inside-function-body/expect.json

@@ -0,0 +1,22 @@
+{
+  "rules": [
+    "F-Eval-CallIntrinsic",
+    "F-Div-Depth"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "fn.ts": "run",
+    "app.ts": "run"
+  },
+  "rejectRule": {
+    "app.ts": "F-Eval-CallIntrinsic"
+  },
+  "note": "The call form is refused at depth > 0: an intrinsic reached through a project-local call would be an envelope the file's own declarators never produced. fn.ts would fold on its own; app.ts imports it and runs, so the forward edge (F-Succ) takes it along.",
+  "tentative": {
+    "fn.ts": "fold"
+  },
+  "taintedBy": {
+    "fn.ts": "app.ts"
+  }
+}

package/fixtures/F-Eval-CallIntrinsic/inside-function-body/project/app.ts

@@ -0,0 +1,3 @@
+import { r } from "./fn";
+
+export const v = r();

package/fixtures/F-Eval-CallIntrinsic/inside-function-body/project/fn.ts

@@ -0,0 +1,5 @@
+import { ref } from "@tsad/shapes";
+
+export function r() {
+  return ref("x");
+}

package/fixtures/F-Eval-CallLocal/local-function-folds/expect.json

@@ -0,0 +1,7 @@
+{
+  "rules": ["F-Eval-CallLocal", "S-FnBody", "S-FnParams", "S-ExportFunction", "S-Call"],
+  "project": true,
+  "verdicts": { "pure.ts": "fold", "app.ts": "fold" },
+  "exports": { "app.ts": { "x": { "doubled": 42 } } },
+  "note": "A call into a project file folds whenever the callee's body is in the subset (S-FnBody), with no allowlist: the argument folds in the caller's scope, the body in the defining module's, and the result is plain data."
+}

package/fixtures/F-Eval-CallLocal/local-function-folds/project/app.ts

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

package/fixtures/F-Eval-CallLocal/local-function-folds/project/pure.ts

@@ -0,0 +1,3 @@
+export function twice(n: number) {
+  return { doubled: n * 2 };
+}

package/fixtures/F-Eval-CallLocal/recursion-folds/expect.json

@@ -0,0 +1,17 @@
+{
+  "rules": [
+    "F-Eval-CallLocal",
+    "S-FnBody"
+  ],
+  "project": true,
+  "verdicts": {
+    "rec.ts": "fold",
+    "shallow.ts": "fold"
+  },
+  "exports": {
+    "shallow.ts": {
+      "floor": 0
+    }
+  },
+  "note": "A recursive project-local function, called three deep: the body folds in the defining module's scope, where its own name is bound, and the conditional takes only the taken branch. The bound on depth is F-Depth's, and a fixture for it waits on the spec deciding whether the number is normative."
+}

package/fixtures/F-Eval-CallLocal/recursion-folds/project/rec.ts

@@ -0,0 +1,3 @@
+export function down(n: number) {
+  return n <= 0 ? 0 : down(n - 1);
+}

package/fixtures/F-Eval-CallLocal/recursion-folds/project/shallow.ts

@@ -0,0 +1,3 @@
+import { down } from "./rec";
+
+export const floor = down(3);

package/fixtures/F-Eval-CallLocal/spread-argument-rejected/expect.json

@@ -0,0 +1,20 @@
+{
+  "rules": [
+    "F-Eval-CallLocal"
+  ],
+  "project": true,
+  "verdicts": {
+    "pure.ts": "run",
+    "app.ts": "run"
+  },
+  "rejectRule": {
+    "app.ts": "F-Eval-CallLocal"
+  },
+  "note": "Step 3: a spread argument rejects. The callee is fine; the call is not. pure.ts would fold on its own; app.ts imports it and runs, so the forward edge (F-Succ) takes it along.",
+  "tentative": {
+    "pure.ts": "fold"
+  },
+  "taintedBy": {
+    "pure.ts": "app.ts"
+  }
+}

package/fixtures/F-Eval-CallLocal/spread-argument-rejected/project/app.ts

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

package/fixtures/F-Eval-CallLocal/spread-argument-rejected/project/pure.ts

@@ -0,0 +1,3 @@
+export function twice(n: number) {
+  return { doubled: n * 2 };
+}

package/fixtures/F-Eval-CallMethod/method-missing/expect.json

@@ -0,0 +1,17 @@
+{
+  "rules": [
+    "F-Eval-CallMethod",
+    "F-Div-Method",
+    "F-Div",
+    "F-Direction",
+    "S-CallMethod"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "run",
+  "note": "The receiver folds, but its `m` is not a function. Shape accepts (receiver and arguments are valid expressions; the method name is unconstrained); the folder rejects at the call. F-Direction: the divergence runs the permitted way.",
+  "rejectAt": {
+    "line": 1,
+    "column": 18
+  }
+}

package/fixtures/F-Eval-CallMethod/method-missing/input.ts

@@ -0,0 +1 @@
+export const x = ({ m: 1 }).m();

package/fixtures/F-Eval-CallMethod/null-receiver-dot/expect.json

@@ -0,0 +1,13 @@
+{
+  "rules": [
+    "F-Eval-CallMethod"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "run",
+  "note": "A `.` method call on a receiver that folds to null: running it would throw, so the folder refuses rather than guess.",
+  "rejectAt": {
+    "line": 2,
+    "column": 18
+  }
+}

package/fixtures/F-Eval-CallMethod/null-receiver-dot/input.ts

@@ -0,0 +1,2 @@
+const o = null;
+export const x = o.m();

package/fixtures/F-Eval-CallMethod/null-receiver-optional/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["F-Eval-CallMethod", "S-CallMethod"], "export": "x", "shape": "accept", "fold": "fold", "value": "$undefined",
+  "note": "The same call with `?.`: the chain short-circuits to undefined, which is what running it does." }

package/fixtures/F-Eval-CallMethod/null-receiver-optional/input.ts

@@ -0,0 +1,2 @@
+const o = null;
+export const x = o?.m();

package/fixtures/F-Eval-CallMethod/real-receiver/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["F-Eval-CallMethod", "S-CallMethod"], "export": "x", "shape": "accept", "fold": "fold", "value": "ABC",
+  "note": "A method call on a receiver that folds to a real value whose named property is a function: applied at fold time." }

package/fixtures/F-Eval-CallMethod/real-receiver/input.ts

@@ -0,0 +1 @@
+export const x = "abc".toUpperCase();

package/fixtures/F-Eval-Template/number-formatting/expect.json

@@ -0,0 +1,11 @@
+{
+  "rules": [
+    "F-Eval-Template",
+    "F-Eval-Binary"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": "0.30000000000000004|1e+21|0|0.3333333333333333|100|1.5e-7|9007199254740992|Infinity|123456789012345680000",
+  "note": "ToString of a Number is ECMAScript Number::toString: shortest round-trip digits, exponent form at and above 1e21, -0 prints as 0, an integer literal beyond 2^53 rounds to the nearest double before it is ever formatted. An evaluator in another language has to reproduce every one of these or the same file prints differently per platform (#81)."
+}

package/fixtures/F-Eval-Template/number-formatting/input.ts

@@ -0,0 +1 @@
+export const x = `${0.1 + 0.2}|${1e21}|${-0}|${1 / 3}|${100}|${1.5e-7}|${9007199254740993}|${1 / 0}|${123456789012345680000}`;

package/fixtures/F-Eval-Template/tostring-of-non-numbers/expect.json

@@ -0,0 +1,10 @@
+{
+  "rules": [
+    "F-Eval-Template"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": "true|null|undefined|1,2||s",
+  "note": "ToString for the rest of the scalars and for an array, which joins on a comma with no brackets. An envelope in a span is refused instead (F-Div-TemplateEnvelope); a plain object would print as [object Object] and is deliberately not exercised here."
+}

package/fixtures/F-Eval-Template/tostring-of-non-numbers/input.ts

@@ -0,0 +1 @@
+export const x = `${true}|${null}|${undefined}|${[1, 2]}|${[]}|${"s"}`;

package/fixtures/F-Eval-Unary/coercion/expect.json

@@ -0,0 +1,19 @@
+{
+  "rules": [
+    "F-Eval-Unary"
+  ],
+  "export": "x",
+  "shape": "accept",
+  "fold": "fold",
+  "value": [
+    true,
+    false,
+    false,
+    false,
+    -3,
+    -12,
+    -1,
+    0
+  ],
+  "note": "! is ¬truthy: the empty string is falsy and \"0\" is truthy, every object and array is truthy. Unary minus is −ToNumber: a numeric string with surrounding whitespace parses, true is 1, null is 0, and -null is -0, which the comparison form writes as 0 (R10.1)."
+}

package/fixtures/F-Eval-Unary/coercion/input.ts

@@ -0,0 +1 @@
+export const x = [!"", !"0", ![], !{}, -"3", -" 12 ", -true, -null];

package/fixtures/F-Eval-Undefined/bare-undefined/expect.json

@@ -0,0 +1,2 @@
+{ "rules": ["F-Eval-Undefined", "S-Undefined", "F-Val-Undefined"], "export": "u", "shape": "accept", "fold": "fold", "value": "$undefined",
+  "note": "The identifier `undefined` is a value, not an unresolved name." }

package/fixtures/F-Eval-Undefined/bare-undefined/input.ts

@@ -0,0 +1 @@
+export const u = undefined;

package/fixtures/F-Exc-Registry/call-form-without-registry/expect.json

@@ -0,0 +1,15 @@
+{
+  "rules": [
+    "F-Exc-Registry",
+    "F-Exc",
+    "S-CallIntrinsic"
+  ],
+  "export": "r",
+  "shape": "reject",
+  "fold": "run",
+  "note": "The call form of an intrinsic is admitted by registration. With no registry the classifier rejects conservatively rather than guess, which is the exception F-Exc-Registry states to the shape-accepts direction; the folder, also without one, has no rule for the call and rejects too.",
+  "rejectAt": {
+    "line": 1,
+    "column": 18
+  }
+}

package/fixtures/F-Exc-Registry/call-form-without-registry/input.ts

@@ -0,0 +1 @@
+export const r = ref("Bucket");

package/fixtures/F-Host-Closed-vs-Open/package-call-is-closed/expect.json

@@ -0,0 +1,9 @@
+{
+  "rules": ["F-Host-Closed-vs-Open", "F-Eval-Reject"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "pure.ts": "fold", "open.ts": "fold", "closed.ts": "run" },
+  "exports": { "open.ts": { "v": "n1" } },
+  "rejectRule": { "closed.ts": "F-Eval-Reject" },
+  "note": "The asymmetry: a call into a project file folds whenever the body is in the subset, with no allowlist; a call into a package folds only through a registered name, and Bucket is registered as nothing but a constructor."
+}

package/fixtures/F-Host-Closed-vs-Open/package-call-is-closed/project/closed.ts

@@ -0,0 +1,3 @@
+import { Bucket } from "@tsad/shapes";
+
+export const v = Bucket({ name: "b" });

package/fixtures/F-Host-Closed-vs-Open/package-call-is-closed/project/open.ts

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

package/fixtures/F-Host-Closed-vs-Open/package-call-is-closed/project/pure.ts

@@ -0,0 +1,3 @@
+export function label(n: number) {
+  return "n" + n;
+}

package/fixtures/F-Host-DataExports/plain-data-export/expect.json

@@ -0,0 +1,8 @@
+{
+  "rules": ["F-Host-DataExports", "F-Import"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "app.ts": "fold" },
+  "exports": { "app.ts": { "s": 3 } },
+  "note": "A named import from an active package resolves to the package's real export, and a plain-data export folds as a value."
+}

package/fixtures/F-Host-DataExports/plain-data-export/project/app.ts

@@ -0,0 +1,3 @@
+import { SIZES } from "@tsad/shapes";
+
+export const s = SIZES.large;

package/fixtures/F-Host-Registry/tag-called-as-function/expect.json

@@ -0,0 +1,8 @@
+{
+  "rules": ["F-Host-Registry", "F-Eval-Reject"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "app.ts": "run" },
+  "rejectRule": { "app.ts": "F-Eval-Reject" },
+  "note": "join is registered with isTag, and the three flags are mutually exclusive: the call form folds iff not a tag and foldsAsCall. Calling a tag as a function is admitted by no rule, and the flag is never inferred from the call's shape."
+}

package/fixtures/F-Host-Registry/tag-called-as-function/project/app.ts

@@ -0,0 +1,3 @@
+import { join } from "@tsad/shapes";
+
+export const j = join("a");

package/fixtures/F-Host-Trust/unowned-package/expect.json

@@ -0,0 +1,6 @@
+{
+  "rules": ["F-Host-Trust", "F-Import", "F-Reference"],
+  "project": true,
+  "verdicts": { "app.ts": "run" },
+  "note": "A bare specifier outside both trust arms is never resolved: the binding is absent and a reference to it is an unresolved identifier. Not an error in the import, an unresolved name at the use."
+}

package/fixtures/F-Host-Trust/unowned-package/project/app.ts

@@ -0,0 +1,3 @@
+import { thing } from "some-package";
+
+export const x = { thing };

package/fixtures/F-Namespace/synthetic-namespace-object/expect.json

@@ -0,0 +1,7 @@
+{
+  "rules": ["F-Namespace", "F-Import", "F-Bind"],
+  "project": true,
+  "verdicts": { "values.ts": "fold", "use.ts": "fold" },
+  "exports": { "use.ts": { "url": "localhost:8080" } },
+  "note": "A namespace import of a project file is a synthetic plain object of the target's namespace, so a member access on it indexes like any other object. Every entry here is a primitive, so nothing is captured and no edge exists."
+}

package/fixtures/F-Namespace/synthetic-namespace-object/project/use.ts

@@ -0,0 +1,3 @@
+import * as values from "./values";
+
+export const url = `${values.host}:${values.port}`;

package/fixtures/F-Namespace/synthetic-namespace-object/project/values.ts

@@ -0,0 +1,2 @@
+export const host = "localhost";
+export const port = 8080;

package/fixtures/F-NoExports/nothing-to-produce/expect.json

@@ -0,0 +1,7 @@
+{
+  "rules": ["F-NoExports", "F-Scan"],
+  "project": true,
+  "verdicts": { "empty.ts": "run", "defaulted.ts": "run" },
+  "tentative": { "empty.ts": "run", "defaulted.ts": "run" },
+  "note": "Two ways to fail before any expression is reduced. empty.ts passes the statement gate and yields no declarator, so there is nothing to fold to; defaulted.ts is disqualified by the gate itself. Neither is folded to an empty namespace."
+}

package/fixtures/F-NoExports/nothing-to-produce/project/defaulted.ts

@@ -0,0 +1 @@
+export default { port: 8080 };

package/fixtures/F-NoExports/nothing-to-produce/project/empty.ts

@@ -0,0 +1,3 @@
+const internal = 1;
+
+console.log(internal);

package/fixtures/F-Prebuild/same-file-construction-shared/expect.json

@@ -0,0 +1,19 @@
+{
+  "rules": ["F-Prebuild", "F-Count"],
+  "project": true,
+  "host": "shapes",
+  "verdicts": { "shared.ts": "fold" },
+  "exports": {
+    "shared.ts": {
+      "wrapper": {
+        "inner": { "entityType": "Bucket", "lexicon": "shapes", "props": { "name": "base" }, "attributes": {} },
+        "twice": [
+          { "entityType": "Bucket", "lexicon": "shapes", "props": { "name": "base" }, "attributes": {} },
+          { "entityType": "Bucket", "lexicon": "shapes", "props": { "name": "base" }, "attributes": {} }
+        ]
+      },
+      "base": { "entityType": "Bucket", "lexicon": "shapes", "props": { "name": "base" }, "attributes": {} }
+    }
+  },
+  "note": "A non-exported same-file construction read as a value from an exported sibling, and re-exported by name. Under F-Eval-Ident step 1 without F-Prebuild every reference rejects; with it the file folds and every reference is the one instance F-Prebuild built. Found by the corpus cross-check (#25, #68): twelve chant examples fold this shape and the reference refused all of them."
+}

package/fixtures/F-Prebuild/same-file-construction-shared/project/shared.ts

@@ -0,0 +1,6 @@
+import { Bucket } from "@tsad/shapes";
+
+const base = new Bucket({ name: "base" });
+
+export const wrapper = { inner: base, twice: [base, base] };
+export { base };

package/fixtures/F-Profile-DataHost/plain-data-across-files/expect.json

@@ -0,0 +1,39 @@
+{
+  "rules": [
+    "F-Profile",
+    "F-Profile-DataHost"
+  ],
+  "project": true,
+  "profiles": [
+    "full",
+    "data-host"
+  ],
+  "verdicts": {
+    "defaults.ts": "fold",
+    "service.ts": "fold"
+  },
+  "exports": {
+    "service.ts": {
+      "service": {
+        "name": "svc-platform",
+        "labels": {
+          "team": "platform",
+          "tier": "gold",
+          "exposed": true
+        },
+        "ports": [
+          {
+            "containerPort": 8080,
+            "protocol": "TCP"
+          },
+          {
+            "containerPort": 8443,
+            "protocol": "TCP"
+          }
+        ],
+        "replicas": 3
+      }
+    }
+  },
+  "note": "The whole of what a data-host evaluator needs: literals, a shared const, a spread, a template, a conditional, a cross-file import, and a project-local function folded by interpretation. No host, no new, no run path, and the same answer whether folded or run in JavaScript."
+}

package/fixtures/F-Profile-DataHost/plain-data-across-files/project/defaults.ts

@@ -0,0 +1,5 @@
+export const labels = { team: "platform", tier: "gold" };
+
+export function port(n: number) {
+  return { containerPort: n, protocol: "TCP" };
+}

package/fixtures/F-Profile-DataHost/plain-data-across-files/project/service.ts

@@ -0,0 +1,10 @@
+import { labels, port } from "./defaults";
+
+const http = port(8080);
+
+export const service = {
+  name: `svc-${labels.team}`,
+  labels: { ...labels, exposed: true },
+  ports: [http, port(8443)],
+  replicas: labels.tier === "gold" ? 3 : 1,
+};

package/fixtures/F-Seed/seeded-by-its-own-body/expect.json

@@ -0,0 +1,8 @@
+{
+  "rules": ["F-Seed", "F-Verdict", "F-Call"],
+  "project": true,
+  "verdicts": { "app.ts": "run", "lone.ts": "fold" },
+  "tentative": { "app.ts": "run", "lone.ts": "fold" },
+  "exports": { "lone.ts": { "value": 1 } },
+  "note": "Seed(B) is exactly the files J2 refused. app.ts calls a local function whose body leaves S-FnBody, so it is in the seed on its own account, with no edge involved. lone.ts shares no edge and folds."
+}