@intentius/chant 0.27.0 → 0.29.0

package/src/discovery/fold-composite.test.ts

@@ -0,0 +1,594 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { mkdir, writeFile, rm, realpath } from "node:fs/promises";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as ts from "typescript";
+import { discover } from "./index";
+import { build } from "../build";
+import { walkValue } from "../serializer-walker";
+import type { Declarable } from "../declarable";
+import type { Serializer } from "../serializer";
+import { foldExecutionCounts, resetFoldExecutionCounts, findFactorySubsetViolation } from "./fold-import";
+
+/**
+ * chant #1023 (epic #1019 Phase 5) — composite factory INTERPRETATION.
+ *
+ * `resolveCallExpression` used to have exactly one way to get a composite's
+ * value: import the defining module and call the factory, in the CLI's own
+ * process. That is the execution chant #1093 documented and #1111 could only
+ * fence off by DEMOTING the file to the sandboxed child. Interpretation
+ * removes the call for factories whose bodies stay inside the admissible
+ * subset — see fold-import.ts's contract block for the five rules.
+ *
+ * These tests observe the removal directly rather than inferring it, borrowing
+ * ./sandbox/fold-boundary.test.ts's discipline: the composite's defining
+ * module sets a `globalThis` marker at its top level, so "marker set" is
+ * exactly "this module was imported and run here". The inadmissible variant is
+ * asserted FIRST, so the probe is proven capable of firing before anything
+ * asserts that it doesn't.
+ *
+ * The defining modules deliberately sit OUTSIDE the discovered source
+ * directory. Inside it they would be discovered files in their own right —
+ * and a module whose job is to export a factory function never folds, so
+ * discovery would import it regardless and the marker would fire for a reason
+ * that has nothing to do with the factory call.
+ */
+
+const thisDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(thisDir, "../../../..");
+const compositePath = resolve(thisDir, "../composite");
+
+/**
+ * The real AWS lexicon — an ACTIVE lexicon of every build below, so its
+ * constructors sit on chant #1093's trusted allowlist exactly as they do for a
+ * real project, and the `--sandbox` assertions are about interpretation rather
+ * than about a stand-in nobody would ship. `Bucket`/`Role` carry genuine `Arn`
+ * attributes, so a sibling reference inside a factory body produces a genuine
+ * `AttrRef`; `Tag` is a property-kind class, for the nested-construction case.
+ */
+const LEXICON = "@intentius/chant-lexicon-aws";
+const LEXICON_NAME = "aws";
+
+const MODULE_MARKER = "__chant1023CompositeModuleEvaluated";
+
+type MarkerHost = Record<string, boolean | undefined>;
+
+function moduleRan(): boolean | undefined {
+  return (globalThis as unknown as MarkerHost)[MODULE_MARKER];
+}
+
+function clearMarker(): void {
+  delete (globalThis as unknown as MarkerHost)[MODULE_MARKER];
+}
+
+/** A serializer that renders every entity's real, ref-resolved props — enough to compare a fold build against a run build byte for byte. */
+const specSerializer: Serializer = {
+  // Named for the lexicon whose entities it serializes — `build()` selects a
+  // serializer by the entities' own `lexicon`, not by an arbitrary label.
+  name: LEXICON_NAME,
+  rulePrefix: "TEST",
+  serialize: (entities) => {
+    const names = new Map<Declarable, string>();
+    for (const [name, entity] of entities) names.set(entity, name);
+    const out: Record<string, unknown> = {};
+    for (const [name, entity] of [...entities].sort(([a], [b]) => a.localeCompare(b))) {
+      out[name] = {
+        type: entity.entityType,
+        props: walkValue((entity as unknown as { props: unknown }).props, names, {
+          attrRef: (logicalName, attribute) => ({ GetAtt: [logicalName, attribute] }),
+          resourceRef: (logicalName) => ({ Ref: logicalName }),
+          propertyDeclarable: (e, walk) => walk((e as unknown as { props: unknown }).props),
+        }),
+      };
+    }
+    return JSON.stringify(out, null, 2);
+  },
+};
+
+let seq = 0;
+
+describe("composite factory interpretation (chant #1023)", () => {
+  let testDir: string;
+  let srcDir: string;
+
+  beforeEach(async () => {
+    // Inside the repo (`.cache/` is gitignored), not the system tmpdir, for one
+    // reason: the fixtures import the REAL lexicon package above, which only
+    // resolves from a directory whose `node_modules` walk reaches this
+    // checkout's.
+    const dir = join(repoRoot, ".cache", `chant-1023-${process.pid}-${seq++}`);
+    await rm(dir, { recursive: true, force: true });
+    await mkdir(dir, { recursive: true });
+    testDir = await realpath(dir);
+    srcDir = join(testDir, "src");
+    await mkdir(srcDir, { recursive: true });
+    clearMarker();
+    resetFoldExecutionCounts();
+  });
+
+  afterEach(async () => {
+    clearMarker();
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  /** `composites.ts` — a PROJECT module defining one composite, plus the execution probe. */
+  async function writeComposite(body: string, extraExports = ""): Promise<void> {
+    await writeFile(
+      join(testDir, "composites.ts"),
+      `
+        import { Bucket, Role, Tag } from ${JSON.stringify(LEXICON)};
+        import { Composite } from ${JSON.stringify(compositePath)};
+
+        globalThis[${JSON.stringify(MODULE_MARKER)}] = true;
+
+        export const WebApp = Composite(${body}, "WebApp");
+        ${extraExports}
+      `,
+    );
+  }
+
+  async function writeMain(source: string): Promise<void> {
+    await writeFile(join(srcDir, "main.ts"), source);
+  }
+
+  const CALL_WEBAPP = `
+    import { WebApp } from "../composites";
+    export const web = WebApp({ name: "data", tags: [{ Key: "team", Value: "platform" }] });
+  `;
+
+  /**
+   * The canonical body: `const`s that construct resources, a live sibling
+   * reference, a `??` default, a spread, a nested property construction, a
+   * template, and a return of the member record. Everything the contract
+   * admits, in one factory.
+   */
+  const ADMISSIBLE_BODY = `(props) => {
+    const bucket = new Bucket({
+      BucketName: props.name,
+      VersioningConfiguration: props.versioning ?? { Status: "Enabled" },
+      Tags: [...(props.tags ?? []), { Key: "managed-by", Value: "chant" }],
+    });
+    const role = new Role({
+      RoleName: \`role-for-\${props.name}\`,
+      Description: bucket.Arn,
+      Tags: [new Tag({ Key: "owner", Value: props.name })],
+    });
+    return { bucket, role };
+  }`;
+
+  /** A body one `if` outside the subset — otherwise identical in what it produces. */
+  const INADMISSIBLE_BODY = `(props) => {
+    if (!props.name) { throw new Error("name required"); }
+    const bucket = new Bucket({ BucketName: props.name });
+    return { bucket };
+  }`;
+
+  // ───────────────────────────────────────────────────────────────────────
+  // The probe fires — an inadmissible factory still invokes, exactly as before.
+  // ───────────────────────────────────────────────────────────────────────
+
+  test("an INADMISSIBLE factory is still invoked in-process (the probe fires)", async () => {
+    await writeComposite(INADMISSIBLE_BODY);
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(result.errors).toEqual([]);
+    expect(result.foldDecisions.find((d) => d.file.endsWith("main.ts"))?.mode).toBe("fold");
+    expect(moduleRan(), "the defining module must have been imported and run here").toBe(true);
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 0, projectFactoryInvocations: 1 });
+    expect([...result.entities.keys()]).toEqual(["webBucket"]);
+  });
+
+  // ───────────────────────────────────────────────────────────────────────
+  // The removal itself.
+  // ───────────────────────────────────────────────────────────────────────
+
+  test("an admissible factory is interpreted — its module is never imported", async () => {
+    await writeComposite(ADMISSIBLE_BODY);
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(result.errors).toEqual([]);
+    expect(result.foldDecisions.find((d) => d.file.endsWith("main.ts"))?.mode).toBe("fold");
+    expect(moduleRan(), "composites.ts must NOT have been imported").toBeUndefined();
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 1, projectFactoryInvocations: 0 });
+    expect([...result.entities.keys()].sort()).toEqual(["webBucket", "webRole"]);
+  });
+
+  test("a sibling reference inside the body is a LIVE AttrRef on the real instance", async () => {
+    await writeComposite(ADMISSIBLE_BODY);
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    const role = result.entities.get("webRole") as unknown as { props: { Description: unknown } };
+    const ref = role.props.Description as { getLogicalName?: () => string | undefined; attribute?: string };
+    expect(ref.getLogicalName?.()).toBe("webBucket");
+    expect(ref.attribute).toBe("Arn");
+  });
+
+  test("interpreted output is byte-identical to run output (the #1023 acceptance differential)", async () => {
+    await writeComposite(ADMISSIBLE_BODY);
+    await writeMain(CALL_WEBAPP);
+
+    const runResult = await build(srcDir, [specSerializer], undefined, { fold: false });
+    resetFoldExecutionCounts();
+    const foldResult = await build(srcDir, [specSerializer], undefined, {
+      fold: true,
+      lexicons: [LEXICON_NAME],
+    });
+
+    expect(runResult.errors).toEqual([]);
+    expect(foldResult.errors).toEqual([]);
+    // The comparison only means something if the fold half really interpreted.
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 1, projectFactoryInvocations: 0 });
+
+    const run = String(runResult.outputs.get(LEXICON_NAME));
+    const folded = String(foldResult.outputs.get(LEXICON_NAME));
+    expect(folded).toBe(run);
+    // …and is non-vacuous: the spec carries both members, the `??` default, the
+    // spread tags, the nested property construction and the cross-member ref.
+    expect(run).toContain("webBucket");
+    expect(run).toContain("managed-by");
+    expect(run).toContain("Enabled");
+    expect(run).toContain("GetAtt");
+  });
+
+  test("provenance is stamped from the source's own composite name", async () => {
+    await writeComposite(ADMISSIBLE_BODY);
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    const bucket = result.entities.get("webBucket") as unknown as Record<symbol, unknown>;
+    const provenance = bucket[Symbol.for("chant.provenance")] as { composite?: string } | undefined;
+    expect(provenance?.composite).toBe("WebApp");
+  });
+
+  test("a concise arrow body (no block) interprets", async () => {
+    await writeComposite(`(props) => ({ bucket: new Bucket({ BucketName: props.name }) })`);
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(moduleRan()).toBeUndefined();
+    expect(foldExecutionCounts().factoryInterpretations).toBe(1);
+    expect([...result.entities.keys()]).toEqual(["webBucket"]);
+  });
+
+  test("a destructured props parameter interprets", async () => {
+    await writeComposite(`({ name }) => {
+      const bucket = new Bucket({ BucketName: name });
+      return { bucket };
+    }`);
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(moduleRan()).toBeUndefined();
+    expect((result.entities.get("webBucket") as unknown as { props: { BucketName: string } }).props.BucketName).toBe(
+      "data",
+    );
+  });
+
+  // ───────────────────────────────────────────────────────────────────────
+  // Nesting.
+  // ───────────────────────────────────────────────────────────────────────
+
+  test("a nested composite interprets recursively, and neither module is imported", async () => {
+    await writeFile(
+      join(testDir, "inner.ts"),
+      `
+        import { Bucket } from ${JSON.stringify(LEXICON)};
+        import { Composite } from ${JSON.stringify(compositePath)};
+        globalThis[${JSON.stringify(MODULE_MARKER)}] = true;
+        export const Storage = Composite((props) => {
+          const bucket = new Bucket({ BucketName: props.name });
+          return { bucket };
+        }, "Storage");
+      `,
+    );
+    await writeFile(
+      join(testDir, "outer.ts"),
+      `
+        import { Role } from ${JSON.stringify(LEXICON)};
+        import { Composite } from ${JSON.stringify(compositePath)};
+        import { Storage } from "./inner";
+        globalThis[${JSON.stringify(MODULE_MARKER)}] = true;
+        export const Platform = Composite((props) => {
+          const storage = Storage({ name: props.name });
+          const role = new Role({ Description: storage.bucket.Arn });
+          return { storage, role };
+        }, "Platform");
+      `,
+    );
+    await writeMain(`
+      import { Platform } from "../outer";
+      export const plat = Platform({ name: "data" });
+    `);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(result.errors).toEqual([]);
+    expect(moduleRan(), "neither composite module may be imported").toBeUndefined();
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 2, projectFactoryInvocations: 0 });
+    // Nested expansion names members through both prefixes, exactly as the run
+    // path's `expandComposite` does.
+    expect([...result.entities.keys()].sort()).toEqual(["platRole", "platStorageBucket"]);
+  });
+
+  test("propagate() still merges shared props onto an interpreted instance", async () => {
+    await writeComposite(ADMISSIBLE_BODY);
+    await writeMain(`
+      import { propagate } from ${JSON.stringify(compositePath)};
+      import { WebApp } from "../composites";
+      export const web = propagate(WebApp({ name: "data" }), { Description: "prod" });
+    `);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(moduleRan()).toBeUndefined();
+    const bucket = result.entities.get("webBucket") as unknown as { props: { Description?: string } };
+    expect(bucket.props.Description).toBe("prod");
+  });
+
+  // ───────────────────────────────────────────────────────────────────────
+  // What deliberately still invokes. Each case asserts the FALLBACK is exact:
+  // the module ran, the file still folds, the entities are unchanged.
+  // ───────────────────────────────────────────────────────────────────────
+
+  test("a bare call to a plain exported function is not a registered composite (rule 2)", async () => {
+    await writeComposite(ADMISSIBLE_BODY, `export function makeApp(props) { return WebApp({ name: props.name }); }`);
+    await writeMain(`
+      import { makeApp } from "../composites";
+      export const web = makeApp({ name: "data" });
+    `);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(moduleRan(), "a plain function must still be invoked").toBe(true);
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 0, projectFactoryInvocations: 1 });
+    expect([...result.entities.keys()].sort()).toEqual(["webBucket", "webRole"]);
+  });
+
+  test("a lexicon-package composite is deliberately not interpreted (rule 1)", async () => {
+    // `LambdaApi` is a composite the aws lexicon itself publishes. It folds —
+    // by invocation, in-process, which is exactly what #1093's allowlist
+    // permits for a package the CLI has already loaded.
+    await writeMain(`
+      import { LambdaApi } from ${JSON.stringify(LEXICON)};
+      export const api = LambdaApi({
+        name: "fn",
+        runtime: "nodejs20.x",
+        handler: "index.handler",
+        code: { ZipFile: "exports.handler = async () => ({});" },
+      });
+    `);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(result.errors).toEqual([]);
+    expect(result.foldDecisions.find((d) => d.file.endsWith("main.ts"))?.mode).toBe("fold");
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 0, projectFactoryInvocations: 0 });
+    expect(foldExecutionCounts().factoryInvocations).toBe(1);
+    expect(result.entities.size).toBeGreaterThan(0);
+  });
+
+  test("`Composite` shadowed by a project-local wrapper is not chant's (rule 2)", async () => {
+    await writeFile(
+      join(testDir, "composites.ts"),
+      `
+        import { Bucket } from ${JSON.stringify(LEXICON)};
+        import { Composite } from "./local-composite";
+        globalThis[${JSON.stringify(MODULE_MARKER)}] = true;
+        export const WebApp = Composite((props) => {
+          const bucket = new Bucket({ BucketName: props.name });
+          return { bucket };
+        }, "WebApp");
+      `,
+    );
+    await writeFile(
+      join(testDir, "local-composite.ts"),
+      `
+        import { Composite as ChantComposite } from ${JSON.stringify(compositePath)};
+        export function Composite(factory, name) { return ChantComposite(factory, name); }
+      `,
+    );
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(moduleRan()).toBe(true);
+    expect(foldExecutionCounts().factoryInterpretations).toBe(0);
+    expect([...result.entities.keys()]).toEqual(["webBucket"]);
+  });
+
+  test("a body reference the defining module cannot resolve declines to invocation", async () => {
+    // `sharedTags` comes from a sibling that does NOT fold, so the factory's
+    // shape is admissible but the name is unresolvable — decline, then invoke.
+    await writeFile(
+      join(testDir, "unfoldable.ts"),
+      `export const sharedTags = [{ Key: "a", Value: "b" }]; export default 1;`,
+    );
+    await writeFile(
+      join(testDir, "composites.ts"),
+      `
+        import { Bucket } from ${JSON.stringify(LEXICON)};
+        import { Composite } from ${JSON.stringify(compositePath)};
+        import { sharedTags } from "./unfoldable";
+        globalThis[${JSON.stringify(MODULE_MARKER)}] = true;
+        export const WebApp = Composite((props) => {
+          const bucket = new Bucket({ BucketName: props.name, Tags: sharedTags });
+          return { bucket };
+        }, "WebApp");
+      `,
+    );
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(moduleRan(), "an unresolvable body falls back to invoking, not to failing").toBe(true);
+    expect(foldExecutionCounts().factoryInterpretations).toBe(0);
+    expect((result.entities.get("webBucket") as unknown as { props: { Tags: unknown } }).props.Tags).toEqual([
+      { Key: "a", Value: "b" },
+    ]);
+  });
+
+  test("a module-level resource shared by every call declines rather than interpreting", async () => {
+    await writeFile(
+      join(testDir, "composites.ts"),
+      `
+        import { Bucket, Role } from ${JSON.stringify(LEXICON)};
+        import { Composite } from ${JSON.stringify(compositePath)};
+        globalThis[${JSON.stringify(MODULE_MARKER)}] = true;
+        const sharedBucket = new Bucket({ BucketName: "shared" });
+        export const WebApp = Composite((props) => {
+          const role = new Role({ Description: sharedBucket.Arn, RoleName: props.name });
+          return { role };
+        }, "WebApp");
+      `,
+    );
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+
+    expect(moduleRan(), "a module-level singleton is the run path's to own").toBe(true);
+    expect(foldExecutionCounts().factoryInterpretations).toBe(0);
+    expect([...result.entities.keys()]).toEqual(["webRole"]);
+  });
+
+  test("a mutually recursive pair terminates instead of interpreting forever", async () => {
+    await writeFile(
+      join(testDir, "a.ts"),
+      `
+        import { Bucket } from ${JSON.stringify(LEXICON)};
+        import { Composite } from ${JSON.stringify(compositePath)};
+        import { B } from "./b";
+        export const A = Composite((props) => {
+          const inner = B({ name: props.name });
+          const bucket = new Bucket({ BucketName: props.name });
+          return { inner, bucket };
+        }, "A");
+      `,
+    );
+    await writeFile(
+      join(testDir, "b.ts"),
+      `
+        import { Composite } from ${JSON.stringify(compositePath)};
+        import { A } from "./a";
+        export const B = Composite((props) => {
+          const inner = A({ name: props.name });
+          return { inner };
+        }, "B");
+      `,
+    );
+    await writeMain(`
+      import { A } from "../a";
+      export const app = A({ name: "data" });
+    `);
+
+    // The only requirement is that it TERMINATES with a decision, either way.
+    const result = await discover(srcDir, { fold: true, lexicons: [LEXICON_NAME] });
+    expect(result.foldDecisions.find((d) => d.file.endsWith("main.ts"))).toBeDefined();
+  });
+
+  // ───────────────────────────────────────────────────────────────────────
+  // The --sandbox delta this issue exists for.
+  // ───────────────────────────────────────────────────────────────────────
+
+  test("--sandbox FOLDS an interpretable project composite (chant #1093's residual, closed)", async () => {
+    await writeComposite(ADMISSIBLE_BODY);
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, sandbox: true, lexicons: [LEXICON_NAME] });
+
+    expect(result.errors).toEqual([]);
+    expect(
+      result.foldDecisions.find((d) => d.file.endsWith("main.ts"))?.mode,
+      "before #1023 this file was demoted to the sandboxed child",
+    ).toBe("fold");
+    expect(moduleRan()).toBeUndefined();
+    expect([...result.entities.keys()].sort()).toEqual(["webBucket", "webRole"]);
+  });
+
+  test("--sandbox still demotes an INADMISSIBLE one, with the reason it had before", async () => {
+    await writeComposite(INADMISSIBLE_BODY);
+    await writeMain(CALL_WEBAPP);
+
+    const result = await discover(srcDir, { fold: true, sandbox: true, lexicons: [LEXICON_NAME] });
+
+    expect(result.errors).toEqual([]);
+    const main = result.foldDecisions.find((d) => d.file.endsWith("main.ts"));
+    expect(main?.mode).toBe("run");
+    expect(main?.reason).toContain("--sandbox");
+    expect(main?.reason).toContain("../composites");
+    expect(moduleRan()).toBeUndefined();
+    expect([...result.entities.keys()]).toEqual(["webBucket"]);
+  });
+});
+
+/**
+ * The shape half of the contract, on its own — the half a caller with no
+ * module graph could evaluate. Kept as a direct table so the enumerated rules
+ * in fold-import.ts's contract block have a line-by-line counterpart, rather
+ * than being reachable only through a filesystem fixture.
+ */
+describe("findFactorySubsetViolation — the shape half of the contract (chant #1023)", () => {
+  function factoryOf(source: string): ts.ArrowFunction | ts.FunctionExpression {
+    const file = ts.createSourceFile("f.ts", `const F = ${source};`, ts.ScriptTarget.Latest, true);
+    const statement = file.statements[0] as ts.VariableStatement;
+    return statement.declarationList.declarations[0].initializer as ts.ArrowFunction;
+  }
+
+  const admissible = [
+    ["a concise object body", `(props) => ({ b: new Bucket({ name: props.name }) })`],
+    ["consts then return", `(props) => { const b = new Bucket({ n: props.n }); return { b }; }`],
+    ["a nested construction in a property", `(props) => ({ b: new Bucket({ enc: new Rule({ alg: "AES" }) }) })`],
+    ["a construction in an array", `(props) => ({ b: new Bucket({ rules: [new Rule({ alg: props.alg })] }) })`],
+    ["a spread and a `??` default", `(props) => ({ b: new Bucket({ t: [...(props.t ?? []), "x"] }) })`],
+    ["a ternary", `(props) => ({ b: new Bucket({ n: props.big ? "l" : "s" }) })`],
+    ["a template", `(props) => ({ b: new Bucket({ n: \`p-\${props.n}\` }) })`],
+    ["a tagged template", `(props) => ({ b: new Bucket({ n: Sub\`p-\${props.n}\` }) })`],
+    ["a nested composite call", `(props) => { const i = Inner({ n: props.n }); return { i }; }`],
+    ["a destructured props parameter", `({ n }) => ({ b: new Bucket({ n }) })`],
+    ["a destructured const", `(props) => { const { a } = props; return { b: new Bucket({ a }) }; }`],
+    ["no parameter at all", `() => ({ b: new Bucket({ n: "fixed" }) })`],
+    ["a function expression", `function (props) { return { b: new Bucket({ n: props.n }) }; }`],
+  ] as const;
+
+  for (const [label, source] of admissible) {
+    test(`admits ${label}`, () => {
+      expect(findFactorySubsetViolation(factoryOf(source))).toBeUndefined();
+    });
+  }
+
+  const rejected = [
+    ["an `if` statement", `(props) => { if (props.n) { return {}; } return {}; }`, "IfStatement"],
+    ["a `throw`", `(props) => { throw new Error("x"); const b = 1; return { b }; }`, "ThrowStatement"],
+    ["a `for` loop", `(props) => { for (const x of props.n) {} return {}; }`, "ForOfStatement"],
+    ["`let`", `(props) => { let b = 1; return { b }; }`, "`let`/`var`"],
+    ["a bare expression statement", `(props) => { doThing(); return {}; }`, "ExpressionStatement"],
+    ["an early return", `(props) => { return {}; const b = 1; }`, "early `return`"],
+    ["a method call", `(props) => ({ b: new Bucket({ t: props.t.map(f) }) })`, "call"],
+    ["a member-access constructor", `(props) => ({ b: new ns.Bucket({}) })`, "plain imported constructor"],
+    ["a computed key", `(props) => ({ b: new Bucket({ [props.k]: 1 }) })`, "computed"],
+    ["a dynamic element access", `(props) => ({ b: new Bucket({ n: props.t[props.i] }) })`, "dynamic element access"],
+    ["an unsupported operator", `(props) => ({ b: new Bucket({ n: props.a % 2 }) })`, "unsupported binary"],
+    ["an `await`", `(props) => ({ b: new Bucket({ n: await props.n }) })`, "unsupported expression"],
+    ["two parameters", `(props, extra) => ({})`, "single props parameter"],
+    ["a rest parameter", `(...props) => ({})`, "rest parameter"],
+    ["a defaulted parameter", `(props = {}) => ({})`, "defaulted parameter"],
+    ["a missing return", `(props) => { const b = new Bucket({}); }`, "must end in `return`"],
+    ["an empty body", `(props) => {}`, "no members to interpret"],
+  ] as const;
+
+  for (const [label, source, fragment] of rejected) {
+    test(`rejects ${label}`, () => {
+      const violation = findFactorySubsetViolation(factoryOf(source));
+      expect(violation, `${label} should be rejected`).toBeDefined();
+      expect(violation).toContain(fragment);
+    });
+  }
+});