@intentius/tsad-conformance 1.4.0 → 1.6.0

package/fixtures/F-Call/a-host-factory-is-invoked/expect.json

@@ -0,0 +1,45 @@
+{
+  "rules": [
+    "F-Call",
+    "F-Host-Interface"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "app.ts": "fold",
+    "plain.ts": "fold",
+    "nested.ts": "run"
+  },
+  "rejectRule": {
+    "nested.ts": "F-Eval-Reject"
+  },
+  "exports": {
+    "app.ts": {
+      "bucket": {
+        "entityType": "Bucket",
+        "lexicon": "shapes",
+        "props": {
+          "name": "b"
+        },
+        "attributes": {}
+      },
+      "pair": {
+        "left": "left",
+        "right": {
+          "__attrRef": {
+            "entity": "bucket",
+            "attribute": "name"
+          }
+        },
+        "entityType": "Pair",
+        "lexicon": "shapes"
+      }
+    },
+    "plain.ts": {
+      "d": {
+        "described": "x"
+      }
+    }
+  },
+  "note": "Step 6 invokes a host-bound factory with the resolved arguments, an attribute reference among them left symbolic (L6.9), and since 1.6 step 7 binds whatever came back, so describe's plain data folds in plain.ts. F-Call is a declarator rule: the same call nested in an object literal is J1's, which has no rule for a call, so nested.ts runs."
+}

package/fixtures/F-Call/a-host-factory-is-invoked/project/app.ts

@@ -0,0 +1,4 @@
+import { makePair, Bucket } from "@tsad/shapes";
+
+export const bucket = new Bucket({ name: "b" });
+export const pair = makePair("left", bucket.name);

package/fixtures/F-Call/a-host-factory-is-invoked/project/nested.ts

@@ -0,0 +1,3 @@
+import { makePair } from "@tsad/shapes";
+
+export const nested = { inner: makePair(1, 2) };

package/fixtures/F-Call/a-host-factory-is-invoked/project/plain.ts

@@ -0,0 +1,3 @@
+import { describe } from "@tsad/shapes";
+
+export const d = describe("x");

package/fixtures/F-Declarator/a-const-alias-of-a-call-resolves-at-the-declarator/expect.json

@@ -0,0 +1,50 @@
+{
+  "rules": [
+    "F-Declarator",
+    "F-Call",
+    "F-Count"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "store.ts": "run",
+    "app.ts": "fold",
+    "nested.ts": "run"
+  },
+  "rejectRule": {
+    "store.ts": "F-Eval-Function",
+    "nested.ts": "F-Eval-Reject"
+  },
+  "exports": {
+    "app.ts": {
+      "pair": {
+        "left": 1,
+        "right": 2,
+        "entityType": "Pair",
+        "lexicon": "shapes"
+      },
+      "data": {
+        "entityType": "Bucket",
+        "lexicon": "shapes",
+        "props": {
+          "name": "b"
+        },
+        "attributes": {}
+      },
+      "whole": {
+        "left": "l",
+        "right": "r",
+        "entityType": "Pair",
+        "lexicon": "shapes"
+      },
+      "left": "l",
+      "chained": {
+        "left": 1,
+        "right": 2,
+        "entityType": "Pair",
+        "lexicon": "shapes"
+      }
+    }
+  },
+  "note": "At a declarator a top-level const alias of a package call resolves through F-Call: a host-published composite invoked, a registered one interpreted, a plain factory invoked, an alias of an alias, and a destructure of one; the whole value or a member of it. The same read nested inside an expression (nested.ts) is J1's, which has no rule for a call, so it runs, as it does at chant."
+}

package/fixtures/F-Declarator/a-const-alias-of-a-call-resolves-at-the-declarator/project/app.ts

@@ -0,0 +1,13 @@
+import { Stack, makePair } from "@tsad/shapes";
+import { Store } from "./store";
+
+const published = Stack({ left: 1, right: 2 });
+const registered = Store({ name: "b" });
+const plain = makePair("l", "r");
+const again = published;
+
+export const pair = published.pair;
+export const data = registered.data;
+export const whole = plain;
+export const left = plain.left;
+export const { pair: chained } = again;

package/fixtures/F-Declarator/a-const-alias-of-a-call-resolves-at-the-declarator/project/nested.ts

@@ -0,0 +1,5 @@
+import { Stack } from "@tsad/shapes";
+
+const w = Stack({ left: 1, right: 2 });
+
+export const v = { p: w.pair };

package/fixtures/F-Declarator/a-const-alias-of-a-call-resolves-at-the-declarator/project/store.ts

@@ -0,0 +1,3 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+export const Store = Composite((props: { name: string }) => ({ data: new Bucket({ name: props.name }) }), "Store");

package/fixtures/F-Div-Step/step-reads-the-resolved-composite/expect.json

@@ -0,0 +1,48 @@
+{
+  "rules": [
+    "F-Div-Step",
+    "S-CompositeStep",
+    "S-Unclaimed",
+    "F-Val-Fate"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "pipeline.ts": "run",
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "first": {
+        "entityType": "Bucket",
+        "lexicon": "shapes",
+        "props": {
+          "name": "first"
+        },
+        "attributes": {}
+      },
+      "both": {
+        "a": {
+          "entityType": "Bucket",
+          "lexicon": "shapes",
+          "props": {
+            "name": "a"
+          },
+          "attributes": {}
+        },
+        "b": {
+          "entityType": "Bucket",
+          "lexicon": "shapes",
+          "props": {
+            "name": "b"
+          },
+          "attributes": {}
+        }
+      }
+    }
+  },
+  "note": "The .step idiom on an unclaimed callee: the classifier admits any call, J1 yields a __compositeStep envelope, and its fate is to resolve the composite through F-Call and read step off the real result. Stage is unclaimed because no helper, intrinsic, local function or const claims the name; its registration module runs, and the caller interprets it from source.",
+  "rejectRule": {
+    "pipeline.ts": "F-Eval-Function"
+  }
+}

package/fixtures/F-Div-Step/step-reads-the-resolved-composite/project/app.ts

@@ -0,0 +1,4 @@
+import { Stage } from "./pipeline";
+
+export const first = Stage({ name: "first" }).step;
+export const both = { a: Stage({ name: "a" }).step, b: Stage({ name: "b" }).step };

package/fixtures/F-Div-Step/step-reads-the-resolved-composite/project/pipeline.ts

@@ -0,0 +1,3 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+export const Stage = Composite((props: { name: string }) => ({ step: new Bucket({ name: props.name }) }), "Stage");

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

@@ -1,9 +1,22 @@
 {
-  "rules": ["F-Host-Closed-vs-Open", "F-Eval-Reject"],
+  "rules": [
+    "F-Host-Closed-vs-Open",
+    "F-Call"
+  ],
   "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."
+  "verdicts": {
+    "pure.ts": "fold",
+    "open.ts": "fold",
+    "closed.ts": "run"
+  },
+  "exports": {
+    "open.ts": {
+      "v": "n1"
+    }
+  },
+  "rejectRule": {
+    "closed.ts": "F-Call"
+  },
+  "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. Bucket is registered as nothing but a constructor, so at the declarator F-Call invokes it (step 6), the call throws, and the file runs; a running file is what a package call outside the allowlist costs."
 }

package/fixtures/F-Host-Composite/a-registered-composite-is-interpreted/expect.json

@@ -0,0 +1,47 @@
+{
+  "rules": [
+    "F-Host-Composite",
+    "F-Call",
+    "F-Count"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "store.ts": "run",
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "store": {
+        "data": {
+          "entityType": "Bucket",
+          "lexicon": "shapes",
+          "props": {
+            "name": "app"
+          },
+          "attributes": {}
+        },
+        "logs": {
+          "entityType": "Bucket",
+          "lexicon": "shapes",
+          "props": {
+            "name": "app-logs"
+          },
+          "attributes": {}
+        }
+      },
+      "logs": {
+        "entityType": "Bucket",
+        "lexicon": "shapes",
+        "props": {
+          "name": "other-logs"
+        },
+        "attributes": {}
+      }
+    }
+  },
+  "note": "The registration form: Composite bound in the defining module to the host's own import makes Store interpretable, so a call folds the factory body against store.ts's scope and never imports it (F-Call step 4). store.ts itself runs, since its declarator is a function used as a value (F-Eval-Function), and that is what lets a caller fold: the binding comes from source. new is admitted inside the body; the destructured call resolves once (F-Count) and indexes the members.",
+  "rejectRule": {
+    "store.ts": "F-Eval-Function"
+  }
+}

package/fixtures/F-Host-Composite/a-registered-composite-is-interpreted/project/app.ts

@@ -0,0 +1,4 @@
+import { Store } from "./store";
+
+export const store = Store({ name: "app" });
+export const { logs } = Store({ name: "other" });

package/fixtures/F-Host-Composite/a-registered-composite-is-interpreted/project/store.ts

@@ -0,0 +1,6 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+export const Store = Composite((props: { name: string }) => ({
+  data: new Bucket({ name: props.name }),
+  logs: new Bucket({ name: `${props.name}-logs` }),
+}), "Store");

package/fixtures/F-IsolatedRefusal/a-project-factory-is-refused-not-invoked/expect.json

@@ -0,0 +1,18 @@
+{
+  "rules": [
+    "F-IsolatedRefusal",
+    "F-Call"
+  ],
+  "project": true,
+  "host": "shapes",
+  "mode": "isolated",
+  "verdicts": {
+    "shapes.ts": "run",
+    "app.ts": "run"
+  },
+  "rejectRule": {
+    "shapes.ts": "F-Eval-Function",
+    "app.ts": "F-IsolatedRefusal"
+  },
+  "note": "Under ι = isolated a project factory that step 4 cannot interpret is refused at step 5 rather than imported and invoked at step 6, even though in open mode the build would fold this file by invocation. The refusal is what isolation costs, stated as a verdict; F-Obs-Counters' projectFactoryInvocations is zero across every folded file under isolated."
+}

package/fixtures/F-IsolatedRefusal/a-project-factory-is-refused-not-invoked/project/app.ts

@@ -0,0 +1,3 @@
+import { Pair2 } from "./shapes";
+
+export const p = Pair2({ name: "a" }, "b");

package/fixtures/F-IsolatedRefusal/a-project-factory-is-refused-not-invoked/project/shapes.ts

@@ -0,0 +1,5 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+// Not interpretable: two parameters (S-FactoryParams). In open mode F-Call
+// step 6 would import this module and invoke the definition instead.
+export const Pair2 = Composite((a: { name: string }, b: string) => ({ bucket: new Bucket({ name: a.name + b }) }), "Pair2");

package/fixtures/F-Obs-Counters/a-build-reports-its-counts/expect.json

@@ -0,0 +1,43 @@
+{
+  "rules": [
+    "F-Obs-Counters",
+    "F-IsolatedRefusal",
+    "F-Call"
+  ],
+  "project": true,
+  "host": "shapes",
+  "mode": "isolated",
+  "verdicts": {
+    "shapes.ts": "run",
+    "app.ts": "fold"
+  },
+  "rejectRule": {
+    "shapes.ts": "F-Eval-Function"
+  },
+  "exports": {
+    "app.ts": {
+      "n": {
+        "bucket": {
+          "entityType": "Bucket",
+          "lexicon": "shapes",
+          "props": {
+            "name": "a"
+          },
+          "attributes": {}
+        }
+      },
+      "p": {
+        "left": "l",
+        "right": "r",
+        "entityType": "Pair",
+        "lexicon": "shapes"
+      }
+    }
+  },
+  "counters": {
+    "factoryInvocations": 1,
+    "projectFactoryInvocations": 0,
+    "factoryInterpretations": 1
+  },
+  "note": "F-Obs-Counters is the observable behind F-NoOwnExecution: three non-negative integers per build. app.ts calls a project composite, which step 5 interprets (one interpretation), and a host factory, which step 6 invokes (one invocation); under isolated no invocation may resolve to project-owned code, so the second counter is zero across the build. Names follow the reference and only the shape is normative."
+}

package/fixtures/F-Obs-Counters/a-build-reports-its-counts/project/app.ts

@@ -0,0 +1,5 @@
+import { makePair } from "@tsad/shapes";
+import { Named } from "./shapes";
+
+export const n = Named({ name: "a" });
+export const p = makePair("l", "r");

package/fixtures/F-Obs-Counters/a-build-reports-its-counts/project/shapes.ts

@@ -0,0 +1,3 @@
+import { Bucket, Composite } from "@tsad/shapes";
+
+export const Named = Composite(({ name }: { name: string }) => ({ bucket: new Bucket({ name }) }), "Named");

package/fixtures/F-Rule-Equivalence/same-source-same-findings/expect.json

@@ -0,0 +1,21 @@
+{
+  "rules": [
+    "F-Rule-Equivalence"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "buckets.ts": "fold",
+    "helpers.ts": "fold"
+  },
+  "findings": {
+    "buckets.ts": [
+      {
+        "rule": "SHAPES001",
+        "subject": "b",
+        "severity": "error"
+      }
+    ]
+  },
+  "note": "Bucket props built three ways, a same-file arrow, a sibling-file function and a literal, and one finding either way. compareAdapters holds two implementations to the same findings from this source whichever path each took, folding or running; that is the property, and it is measured the day a second implementation exposes the rules hook."
+}

package/fixtures/F-Rule-Equivalence/same-source-same-findings/project/buckets.ts

@@ -0,0 +1,8 @@
+import { Bucket } from "@tsad/shapes";
+import { named } from "./helpers";
+
+const props = (name?: string) => (name ? { BucketName: name } : {});
+
+export const a = new Bucket(props("a"));
+export const b = new Bucket(props());
+export const c = new Bucket(named("c"));

package/fixtures/F-Rule-Equivalence/same-source-same-findings/project/helpers.ts

@@ -0,0 +1,3 @@
+export function named(name: string) {
+  return { BucketName: name };
+}

package/fixtures/F-Rule-Input/a-rule-sees-the-folded-namespace/expect.json

@@ -0,0 +1,21 @@
+{
+  "rules": [
+    "F-Rule-Input",
+    "F-Rule-Finding"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "buckets.ts": "fold"
+  },
+  "findings": {
+    "buckets.ts": [
+      {
+        "rule": "SHAPES001",
+        "subject": "bad",
+        "severity": "error"
+      }
+    ]
+  },
+  "note": "The pre-synthesis rule reads final values: two Buckets, one without a BucketName. The finding names the export, the rule's id and the rule's own severity; its message is not compared, and no location is asked for because F-Obs-Provenance is optional."
+}

package/fixtures/F-Rule-Input/a-rule-sees-the-folded-namespace/project/buckets.ts

@@ -0,0 +1,4 @@
+import { Bucket } from "@tsad/shapes";
+
+export const good = new Bucket({ BucketName: "logs" });
+export const bad = new Bucket({});

package/fixtures/F-Rule-Phase/a-post-rule-reads-the-artifact/expect.json

@@ -0,0 +1,21 @@
+{
+  "rules": [
+    "F-Rule-Phase",
+    "F-Rule-Finding"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "pairs.ts": "fold"
+  },
+  "findings": {
+    "artifact": [
+      {
+        "rule": "SHAPES002",
+        "subject": "missing: Bucket",
+        "severity": "warning"
+      }
+    ]
+  },
+  "note": "No Bucket anywhere, so the post-synthesis rule, which reads the serialized artifact and not the namespace, reports the missing-resource form: the subject states what is absent because there is nothing to attach it to (L11.5). The pre-synthesis rule has nothing to say, and a finding it did not make must not appear."
+}

package/fixtures/F-Rule-Phase/a-post-rule-reads-the-artifact/project/pairs.ts

@@ -0,0 +1,3 @@
+import { Pair } from "@tsad/shapes";
+
+export const p = new Pair(1, 2);

package/fixtures/F-Rule-Pure/findings-are-a-function-of-the-input/expect.json

@@ -0,0 +1,21 @@
+{
+  "rules": [
+    "F-Rule-Pure"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "buckets.ts": "fold",
+    "clock.ts": "run"
+  },
+  "findings": {
+    "buckets.ts": [
+      {
+        "rule": "SHAPES001",
+        "subject": "bad",
+        "severity": "error"
+      }
+    ]
+  },
+  "note": "The runner asks for each phase twice and requires the same findings both times; a rule that read a clock or the environment would fail there before any comparison. clock.ts runs, so it has no folded namespace and no rule sees it; the findings are the same whether or not it exists."
+}

package/fixtures/F-Rule-Pure/findings-are-a-function-of-the-input/project/buckets.ts

@@ -0,0 +1,4 @@
+import { Bucket } from "@tsad/shapes";
+
+export const good = new Bucket({ BucketName: "logs" });
+export const bad = new Bucket({});

package/fixtures/F-Rule-Pure/findings-are-a-function-of-the-input/project/clock.ts

@@ -0,0 +1 @@
+export const now = Date.now();

package/fixtures/F-Rule-Supply/the-host-names-the-rule/expect.json

@@ -0,0 +1,21 @@
+{
+  "rules": [
+    "F-Rule-Supply",
+    "F-Rule-Finding"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "findings": {
+    "app.ts": [
+      {
+        "rule": "SHAPES001",
+        "subject": "store",
+        "severity": "error"
+      }
+    ]
+  },
+  "note": "The shapes host supplies two rules by id and phase and no code; the code is the implementation's, and an implementation that carries no rule of that id reports the hook unavailable and the fixture is skipped visibly. Here a Bucket exists, so the post-synthesis rule is silent and only the host's pre-synthesis rule speaks, under the severity the host declared for it (L11.6)."
+}

package/fixtures/F-Rule-Supply/the-host-names-the-rule/project/app.ts

@@ -0,0 +1,4 @@
+import { Bucket, Pair } from "@tsad/shapes";
+
+export const pair = new Pair("x", "y");
+export const store = new Bucket({});

package/fixtures/F-Val-Domain/every-case-is-a-value/expect.json

@@ -0,0 +1,49 @@
+{
+  "rules": [
+    "F-Val-Domain",
+    "F-Val-Serializable"
+  ],
+  "project": true,
+  "host": "shapes",
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "scalars": {
+        "s": "text",
+        "n": 1.5,
+        "b": false,
+        "z": null,
+        "u": "$undefined"
+      },
+      "list": [
+        1,
+        "two",
+        [
+          3
+        ],
+        {
+          "four": 4
+        }
+      ],
+      "bucket": {
+        "entityType": "Bucket",
+        "lexicon": "shapes",
+        "props": {
+          "name": "logs"
+        },
+        "attributes": {}
+      },
+      "reference": {
+        "arn": {
+          "__attrRef": {
+            "entity": "bucket",
+            "attribute": "arn"
+          }
+        }
+      }
+    }
+  },
+  "note": "The closed union's cases that can reach the namespace in the full profile: every scalar including undefined, arrays and objects of them, a resource revived to a live instance, and the one envelope that survives, an attribute reference. Nothing else is a value."
+}

package/fixtures/F-Val-Domain/every-case-is-a-value/project/app.ts

@@ -0,0 +1,6 @@
+import { Bucket } from "@tsad/shapes";
+
+export const scalars = { s: "text", n: 1.5, b: false, z: null, u: undefined };
+export const list = [1, "two", [3], { four: 4 }];
+export const bucket = new Bucket({ name: "logs" });
+export const reference = { arn: bucket.arn };

package/fixtures/F-Val-Envelope/envelopes-are-the-output-in-data-host/expect.json

@@ -0,0 +1,41 @@
+{
+  "rules": [
+    "F-Val-Envelope",
+    "F-Profile-DataHost"
+  ],
+  "project": true,
+  "host": "shapes",
+  "profiles": [
+    "data-host"
+  ],
+  "verdicts": {
+    "app.ts": "fold"
+  },
+  "exports": {
+    "app.ts": {
+      "tagged": {
+        "__intrinsic": "join",
+        "strings": [
+          "bucket-",
+          ""
+        ],
+        "values": [
+          1
+        ]
+      },
+      "called": {
+        "__intrinsic": "ref",
+        "args": [
+          "Logs"
+        ]
+      },
+      "resource": {
+        "__resource": "Bucket",
+        "props": {
+          "name": "logs"
+        }
+      }
+    }
+  },
+  "note": "Three envelopes, recognised by key, as the data-host profile emits them: no fate runs, the envelope is the output. Each is a finished value that denotes something not yet constructed, never a thunk. A helper call is not here because the profile has no helpers: there is nothing to invoke."
+}

package/fixtures/F-Val-Envelope/envelopes-are-the-output-in-data-host/project/app.ts

@@ -0,0 +1,5 @@
+import { Bucket, join, ref } from "@tsad/shapes";
+
+export const tagged = join`bucket-${1}`;
+export const called = ref("Logs");
+export const resource = new Bucket({ name: "logs" });