@intentius/chant 0.101.0 → 0.102.0

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

@@ -0,0 +1,264 @@
+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 { 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 } from "./fold-import";
+
+/**
+ * chant#3247 — a composite a lexicon PACKAGE publishes is interpreted like a
+ * project composite, so its fields keep their parameter provenance, and a
+ * composite behind a barrel re-export is found in the module that defines it.
+ *
+ * The real azure lexicon's `ActivityLogSink` is the package case: it is
+ * exported from the package root through `src/index.ts` and
+ * `src/composites/index.ts`, and its body is one `new PolicyAssignment({...})`
+ * reading two props. The fixtures sit under the repo's `.cache/` so a bare
+ * `@intentius/chant-lexicon-*` import resolves through this checkout's
+ * `node_modules`, as it does for an installed project. chant's own package
+ * specifiers are never `paths`-mapped, so the package route is the one taken.
+ */
+
+const thisDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(thisDir, "../../../..");
+const compositePath = resolve(thisDir, "../composite");
+
+const AZURE = "@intentius/chant-lexicon-azure";
+const AWS = "@intentius/chant-lexicon-aws";
+
+const MODULE_MARKER = "__chant3247CompositeModuleEvaluated";
+type MarkerHost = Record<string, boolean | undefined>;
+const moduleRan = (): boolean | undefined => (globalThis as unknown as MarkerHost)[MODULE_MARKER];
+const clearMarker = (): void => {
+  delete (globalThis as unknown as MarkerHost)[MODULE_MARKER];
+};
+
+/** Renders every entity's ref-resolved props, enough to compare a fold build with a run build byte for byte. */
+function propsSerializer(name: string): Serializer {
+  return {
+    name,
+    rulePrefix: "TEST",
+    serialize: (entities) => {
+      const names = new Map<Declarable, string>();
+      for (const [entityName, entity] of entities) names.set(entity, entityName);
+      const out: Record<string, unknown> = {};
+      for (const [entityName, entity] of [...entities].sort(([a], [b]) => a.localeCompare(b))) {
+        out[entityName] = {
+          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("lexicon-package and re-exported composites are interpreted (chant#3247)", () => {
+  let testDir: string;
+  let srcDir: string;
+
+  beforeEach(async () => {
+    const dir = join(repoRoot, ".cache", `chant-3247-${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 });
+  });
+
+  const CALL_SINK = `
+    import { ActivityLogSink } from ${JSON.stringify(AZURE)};
+    export const sink = ActivityLogSink({ workspaceId: "/subscriptions/s/workspaces/logs", location: "eastus" });
+  `;
+
+  test("a package composite reached through its barrel is interpreted, and every field keeps its origin", async () => {
+    await writeFile(join(srcDir, "main.ts"), CALL_SINK);
+
+    const folded = await build(srcDir, [propsSerializer("azure")], undefined, { fold: true, lexicons: ["azure"] });
+
+    expect(folded.errors).toEqual([]);
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 1, factoryInvocations: 0 });
+    const fields = folded.foldProvenance.sinkAssignmentActivityLogSink!.fields;
+    const param = (...parameters: string[]) => ({
+      kind: "composite-parameter",
+      composite: "ActivityLogSink",
+      instance: "sink",
+      parameters,
+    });
+    expect(fields.location).toEqual(param("location"));
+    expect(fields["parameters.logAnalytics.value"]).toEqual(param("workspaceId"));
+    expect(fields.name).toEqual({ kind: "composite-literal", composite: "ActivityLogSink", instance: "sink" });
+
+    // Interpreting is not a second evaluation: the run path writes the same bytes.
+    const run = await build(srcDir, [propsSerializer("azure")], undefined, { fold: false, lexicons: ["azure"] });
+    expect(run.errors).toEqual([]);
+    expect(folded.outputs.get("azure")).toEqual(run.outputs.get("azure"));
+    expect(run.foldProvenance.sinkAssignmentActivityLogSink!.fields.location).toEqual({
+      kind: "unknown",
+      reason: "composite-not-interpreted",
+    });
+  });
+
+  test("under --sandbox the package's own imports are trusted, so it is still interpreted", async () => {
+    await writeFile(join(srcDir, "main.ts"), CALL_SINK);
+
+    const result = await discover(srcDir, { fold: true, sandbox: true, lexicons: ["azure"] });
+
+    expect(result.errors).toEqual([]);
+    expect(result.foldDecisions.find((d) => d.file.endsWith("main.ts"))?.mode).toBe("fold");
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 1, factoryInvocations: 0 });
+  });
+
+  test("a lexicon the build did not load is not followed", async () => {
+    await writeFile(join(srcDir, "main.ts"), CALL_SINK);
+
+    await discover(srcDir, { fold: true, lexicons: ["aws"] });
+
+    expect(foldExecutionCounts().factoryInterpretations).toBe(0);
+  });
+
+  test("a project barrel's `export *` and renamed `export { } from` reach the defining module", async () => {
+    await mkdir(join(testDir, "lib", "composites"), { recursive: true });
+    await writeFile(
+      join(testDir, "lib", "composites", "web.ts"),
+      `
+        import { Bucket } from ${JSON.stringify(AWS)};
+        import { Composite } from ${JSON.stringify(compositePath)};
+        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, "lib", "composites", "index.ts"), `export * from "./web";\n`);
+    await writeFile(
+      join(testDir, "lib", "index.ts"),
+      `export * from "./composites/index";\nexport { WebApp as Site } from "./composites/web";\n`,
+    );
+    await writeFile(
+      join(srcDir, "main.ts"),
+      `
+        import { WebApp, Site } from "../lib";
+        export const web = WebApp({ name: "data" });
+        export const site = Site({ name: "site" });
+      `,
+    );
+
+    const result = await discover(srcDir, { fold: true, lexicons: ["aws"] });
+
+    expect(result.errors).toEqual([]);
+    expect(moduleRan(), "the defining module was read, never imported").toBeUndefined();
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 2, factoryInvocations: 0 });
+    expect([...result.entities.keys()].sort()).toEqual(["siteBucket", "webBucket"]);
+  });
+
+  /** A stand-in lexicon package installed in the fixture's own `node_modules`. */
+  async function installFakeLexicon(name: string, files: Record<string, string>, exportsTarget: string): Promise<void> {
+    const pkgDir = join(testDir, "node_modules", "@intentius", `chant-lexicon-${name}`);
+    for (const [file, source] of Object.entries(files)) {
+      await mkdir(dirname(join(pkgDir, file)), { recursive: true });
+      await writeFile(join(pkgDir, file), source);
+    }
+    await writeFile(
+      join(pkgDir, "package.json"),
+      JSON.stringify({ name: `@intentius/chant-lexicon-${name}`, type: "module", exports: { ".": exportsTarget } }),
+    );
+  }
+
+  const WEBAPP_DEFINITION = `
+    import { Bucket } from ${JSON.stringify(AWS)};
+    import { Composite } from "@intentius/chant/composite";
+    globalThis[${JSON.stringify(MODULE_MARKER)}] = true;
+    export const WebApp = Composite((props) => {
+      const bucket = new Bucket({ BucketName: props.name });
+      return { bucket };
+    }, "WebApp");
+  `;
+
+  test("a package whose module is compiled JavaScript is invoked, not interpreted", async () => {
+    // The body is admissible (a single expression), so only the module's build
+    // shape keeps it from being interpreted.
+    await installFakeLexicon(
+      "fakejs3247",
+      {
+        "dist/index.js": `
+          import { Composite } from "@intentius/chant/composite";
+          globalThis[${JSON.stringify(MODULE_MARKER)}] = true;
+          export const Wrap = Composite((props) => ({ bucket: props.bucket }), "Wrap");
+        `,
+      },
+      "./dist/index.js",
+    );
+    await writeFile(
+      join(srcDir, "main.ts"),
+      `
+        import { Bucket } from ${JSON.stringify(AWS)};
+        import { Wrap } from "@intentius/chant-lexicon-fakejs3247";
+        export const web = Wrap({ bucket: new Bucket({ BucketName: "data" }) });
+      `,
+    );
+
+    await discover(srcDir, { fold: true, lexicons: ["aws", "fakejs3247"] });
+
+    // Declined before the module was parsed, so the call went to invocation.
+    // Whether that import then succeeds is the stand-in's business: plain Node
+    // cannot load chant's TypeScript source from a `.js` file, so it is not
+    // asserted here.
+    expect(foldExecutionCounts().factoryInterpretations).toBe(0);
+  });
+
+  test("a package re-export that leaves the package's directory is not followed", async () => {
+    await mkdir(join(testDir, "shared"), { recursive: true });
+    await writeFile(join(testDir, "shared", "web.ts"), WEBAPP_DEFINITION);
+    await installFakeLexicon(
+      "fakeescape3247",
+      { "src/index.ts": `export { WebApp } from "../../../../shared/web";\n` },
+      "./src/index.ts",
+    );
+    await writeFile(
+      join(srcDir, "main.ts"),
+      `import { WebApp } from "@intentius/chant-lexicon-fakeescape3247";\nexport const web = WebApp({ name: "data" });\n`,
+    );
+
+    const result = await discover(srcDir, { fold: true, lexicons: ["aws", "fakeescape3247"] });
+
+    expect(result.errors).toEqual([]);
+    expect(foldExecutionCounts().factoryInterpretations).toBe(0);
+  });
+
+  test("the same package composite, TypeScript source, is interpreted", async () => {
+    await installFakeLexicon(
+      "fakets3247",
+      { "src/index.ts": `export * from "./composites/index";\n`, "src/composites/index.ts": `export * from "./web";\n`, "src/composites/web.ts": WEBAPP_DEFINITION },
+      "./src/index.ts",
+    );
+    await writeFile(
+      join(srcDir, "main.ts"),
+      `import { WebApp } from "@intentius/chant-lexicon-fakets3247";\nexport const web = WebApp({ name: "data" });\n`,
+    );
+
+    const result = await discover(srcDir, { fold: true, lexicons: ["aws", "fakets3247"] });
+
+    expect(result.errors).toEqual([]);
+    expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 1, factoryInvocations: 0 });
+    expect([...result.entities.keys()]).toEqual(["webBucket"]);
+  });
+});

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

@@ -0,0 +1,191 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { foldProject } from "./fold-import";
+import { packageExportsTarget, tsconfigPathsTarget } from "./specifier-resolve";
+import type { IntrinsicDef } from "../lexicon";
+
+/** `e` from `esm-only/sub/x` is an intrinsic, so fold has to import that subpath to revive the call. */
+const intrinsics = [{ name: "e", lexicon: "esm", foldsAsCall: true } as unknown as IntrinsicDef];
+
+/**
+ * chant#3090 — the import specifiers `tsc` and `tsx` accept that fold's own
+ * resolver did not: a `.js` or `.mjs` specifier naming a `.ts` or `.mts`
+ * source, an `exports` subpath pattern with only an `import` condition, and a
+ * tsconfig `paths` entry. Each of these used to fall the importing file back
+ * to run with an "unresolved identifier".
+ *
+ * The fixture is the project from the issue, built in a temp directory
+ * because its `node_modules` would not be committed.
+ */
+describe("fold resolves the specifier forms tsc accepts (chant#3090)", () => {
+  let root: string;
+
+  const write = (rel: string, content: string): string => {
+    const path = join(root, rel);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+    return path;
+  };
+
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "chant-fold-specifiers-"));
+    write("tsconfig.json", JSON.stringify({ compilerOptions: { paths: { "@app/*": ["./src/*"] } } }));
+    write("src/config.ts", 'export const a = "config";\n');
+    write("src/lib/index.ts", 'export const b = "lib";\n');
+    write("src/lib/helpers.mts", 'export const c = "helpers";\n');
+    write(
+      "node_modules/esm-only/package.json",
+      JSON.stringify({
+        name: "esm-only",
+        version: "1.0.0",
+        type: "module",
+        exports: { ".": { import: "./dist/index.js" }, "./sub/*": { import: "./sub/*.js" } },
+      }),
+    );
+    write("node_modules/esm-only/dist/index.js", 'export const d = "esm-only";\n');
+    write("node_modules/esm-only/sub/x.js", "export function e(v) { return `sub:${v}`; }\n");
+  });
+
+  afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+  const files = (): string[] => [
+    join(root, "src/config.ts"),
+    join(root, "src/lib/index.ts"),
+    join(root, "src/lib/helpers.mts"),
+  ];
+
+  test("all six specifiers from the issue fold", async () => {
+    const main = write(
+      "src/main.ts",
+      [
+        'import { a } from "./config.js";',
+        'import { b } from "./lib";',
+        'import { c } from "./lib/helpers.mjs";',
+        'import { d } from "esm-only";',
+        'import { e } from "esm-only/sub/x";',
+        'import { a as a2 } from "@app/config";',
+        'export const values = [a, b, c, d, e("x"), a2];',
+        "",
+      ].join("\n"),
+    );
+
+    const verdict = (await foldProject([main, ...files()], intrinsics, { lexiconPackages: ["esm-only"] })).get(main)!;
+
+    expect(verdict.reason).toBeUndefined();
+    expect(verdict.verdict).toBe("fold");
+    expect(Object.fromEntries(verdict.exports!)).toEqual({
+      values: ["config", "lib", "helpers", "esm-only", "sub:x", "config"],
+    });
+  });
+
+  test("a .js specifier names the .ts source even when the .js file exists too", async () => {
+    write("src/config.js", 'export const a = "stale build output";\n');
+    const main = write("src/main.ts", 'import { a } from "./config.js";\nexport const v = a;\n');
+
+    const verdict = (await foldProject([main, ...files()])).get(main)!;
+
+    expect(verdict.verdict).toBe("fold");
+    expect(Object.fromEntries(verdict.exports!)).toEqual({ v: "config" });
+  });
+
+  test("an unresolvable relative specifier keeps a run reason naming the specifier and the importing file", async () => {
+    const main = write("src/main.ts", 'import { a } from "./missing.js";\nexport const v = a;\n');
+
+    const verdict = (await foldProject([main, ...files()])).get(main)!;
+
+    // The `[fold:run]` line starts with the importing file; the reason names
+    // the specifier as the path it was looked for at.
+    expect(verdict.verdict).toBe("run");
+    expect(verdict.reason).toContain(join("src", "missing.js"));
+  });
+
+  test("a paths pattern with no file behind it keeps a run reason", async () => {
+    const main = write("src/main.ts", 'import { a } from "@app/missing";\nexport const v = a;\n');
+
+    const verdict = (await foldProject([main, ...files()])).get(main)!;
+
+    expect(verdict.verdict).toBe("run");
+    expect(verdict.reason).toContain("unresolved identifier: a");
+    expect(verdict.reason).toContain('"@app/missing"');
+  });
+
+  test("paths from an extended config resolve against the config that declares them", async () => {
+    write("tsconfig.json", JSON.stringify({ extends: "./configs/base" }));
+    write("configs/base.json", '{\n  // JSONC, as tsc reads it\n  "compilerOptions": { "paths": { "@app/*": ["../src/*"] } },\n}\n');
+    const main = write("src/main.ts", 'import { a } from "@app/config";\nexport const v = a;\n');
+
+    expect(tsconfigPathsTarget("@app/config", main)).toBe(join(root, "src/config.ts"));
+    const verdict = (await foldProject([main, ...files()])).get(main)!;
+    expect(verdict.verdict).toBe("fold");
+    expect(Object.fromEntries(verdict.exports!)).toEqual({ v: "config" });
+  });
+
+  test("paths resolve against baseUrl when the chain sets one", async () => {
+    write("tsconfig.json", JSON.stringify({ extends: "./configs/base.json", compilerOptions: { baseUrl: "." } }));
+    write("configs/base.json", JSON.stringify({ compilerOptions: { paths: { "@app/*": ["src/*"] } } }));
+    const main = write("src/main.ts", "");
+
+    expect(tsconfigPathsTarget("@app/lib", main)).toBe(join(root, "src/lib/index.ts"));
+    expect(tsconfigPathsTarget("@other/lib", main)).toBeUndefined();
+  });
+
+  test("an exact paths key wins over a pattern, and the longest pattern prefix wins", async () => {
+    write("src/special.ts", "export const s = 1;\n");
+    write(
+      "tsconfig.json",
+      JSON.stringify({
+        compilerOptions: { paths: { "@app/*": ["./src/*"], "@app/lib/*": ["./src/lib/*"], "@app/x": ["./src/special.ts"] } },
+      }),
+    );
+    const main = write("src/main.ts", "");
+
+    expect(tsconfigPathsTarget("@app/x", main)).toBe(join(root, "src/special.ts"));
+    expect(tsconfigPathsTarget("@app/lib/helpers.mjs", main)).toBe(join(root, "src/lib/helpers.mts"));
+  });
+
+  test("a paths entry that maps an active lexicon's name is a project file, and its trust is decided on that path", async () => {
+    write("tsconfig.json", JSON.stringify({ compilerOptions: { paths: { "esm-only": ["./src/shadow.ts"] } } }));
+    const shadow = write(
+      "src/shadow.ts",
+      'export const d = "shadow";\nexport function make(v: string) { return `${v}:${process.pid}`; }\n',
+    );
+    const dataUser = write("src/data.ts", 'import { d } from "esm-only";\nexport const v = d;\n');
+    const callUser = write("src/call.ts", 'import { make } from "esm-only";\nexport const v = make("x");\n');
+    const all = [dataUser, callUser, shadow, ...files()];
+
+    const plain = await foldProject(all, [], { lexiconPackages: ["esm-only"] });
+    // The project file is folded, not the package's export read.
+    expect(Object.fromEntries(plain.get(dataUser)!.exports!)).toEqual({ v: "shadow" });
+    // Invoking it is invoking project code, which the default mode refuses,
+    // whatever the specifier's text says.
+    expect(plain.get(callUser)!.verdict).toBe("run");
+    expect(plain.get(callUser)!.reason).toContain(join("src", "shadow.ts"));
+    expect(plain.get(callUser)!.reason).toContain("does not invoke a declared project function");
+
+    const sandboxed = await foldProject(all, [], { lexiconPackages: ["esm-only"], sandbox: true });
+    expect(sandboxed.get(callUser)!.verdict).toBe("run");
+  });
+});
+
+describe("packageExportsTarget (chant#3090)", () => {
+  test("reads condition objects in key order against import, node and default", () => {
+    expect(packageExportsTarget({ ".": { types: "./a.d.ts", import: "./a.mjs", default: "./a.cjs" } }, ".")).toBe("./a.mjs");
+    expect(packageExportsTarget({ require: "./r.cjs", node: { import: "./n.mjs" } }, ".")).toBe("./n.mjs");
+    expect(packageExportsTarget({ ".": { require: "./r.cjs" } }, ".")).toBeUndefined();
+  });
+
+  test("an exact subpath key wins, then the longest pattern prefix", () => {
+    const map = { "./*": "./src/*.js", "./sub/*": "./sub/*.js", "./sub/x": "./exact.js", "./internal/*": null };
+    expect(packageExportsTarget(map, "./sub/x")).toBe("./exact.js");
+    expect(packageExportsTarget(map, "./sub/y")).toBe("./sub/y.js");
+    expect(packageExportsTarget(map, "./top")).toBe("./src/top.js");
+    expect(packageExportsTarget(map, "./internal/z")).toBeUndefined();
+  });
+
+  test("a subpath is not exported by a root-only exports field", () => {
+    expect(packageExportsTarget("./index.js", "./sub")).toBeUndefined();
+    expect(packageExportsTarget({ import: "./index.js" }, "./sub")).toBeUndefined();
+  });
+});

package/src/discovery/param-deps.test.ts

@@ -1,7 +1,7 @@
 import * as ts from "typescript";
 import { describe, expect, test } from "vitest";
 import { collectConsts } from "../fold/fold";
-import { collectCompositeOrigins, collectParamDependencies } from "./param-deps";
+import { collectCompositeOrigins, collectParamDependencies, collectTagOrigins } from "./param-deps";
 import type { PathOrigin } from "../provenance";
 
 /**
@@ -227,3 +227,68 @@ describe("collectCompositeOrigins", () => {
     });
   });
 });
+
+/**
+ * chant #3212 — the same join for a registered tag. The fixture body ends in
+ * `return table\`...\``; `fields` stands in for what the tag reports per
+ * interpolation, and `props` for the entity it built.
+ */
+function tagOriginsOf(body: string, fields: string[][], props: Record<string, unknown>): Record<string, PathOrigin> {
+  const file = ts.createSourceFile("factory.ts", `const f = (props) => { ${body} };`, ts.ScriptTarget.Latest, true);
+  const consts = new Map<string, ts.Expression>();
+  let tagged: ts.TaggedTemplateExpression | undefined;
+  const visit = (node: ts.Node): void => {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+      consts.set(node.name.text, node.initializer);
+    }
+    if (ts.isReturnStatement(node) && node.expression && ts.isTaggedTemplateExpression(node.expression)) {
+      tagged = node.expression;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(file);
+  if (!tagged || !ts.isTemplateExpression(tagged.template)) throw new Error("fixture returns no interpolated tag");
+  return collectTagOrigins(
+    tagged.template.templateSpans.map((span) => span.expression),
+    fields,
+    props,
+    consts,
+    { whole: new Set(["props"]), destructured: new Map() },
+    "WebService",
+  );
+}
+
+describe("collectTagOrigins", () => {
+  test("a field an interpolation fed is that interpolation's parameters; every other key is fixed", () => {
+    expect(
+      tagOriginsOf(
+        "return table`CREATE TABLE ${props.name} ENGINE = MergeTree TTL ts + INTERVAL ${props.ttl.days} DAY`;",
+        [["name", "ddl"], ["ttl", "ddl"]],
+        { name: "t", engine: "MergeTree", ttl: "ts + INTERVAL 30 DAY", ddl: "...", absent: undefined },
+      ),
+    ).toEqual({
+      name: fromParam("name"),
+      ttl: fromParam("ttl.days"),
+      ddl: fromParam("name", "ttl.days"),
+      engine: fixed,
+    });
+  });
+
+  test("a body const is followed, a sibling entity is not, and an interpolation reading no parameter adds nothing", () => {
+    expect(
+      tagOriginsOf(
+        "const base = `${props.name}_daily`; const events = new Thing({}); return table`CREATE TABLE ${base} ENGINE = ${\"Summing\"} COMMENT ${events}`;",
+        [["name"], ["engine"], ["comment"]],
+        { name: "t_daily", engine: "Summing", comment: "events" },
+      ),
+    ).toEqual({ name: fromParam("name"), engine: fixed, comment: fixed });
+  });
+
+  test("a parameter recorded under a key outranks the key's fixed record", () => {
+    expect(
+      tagOriginsOf("return table`ENGINE = Replacing(${props.version})`;", [["engine.args"]], {
+        engine: { name: "Replacing", args: ["v"] },
+      }),
+    ).toEqual({ "engine.args": fromParam("version"), engine: fixed });
+  });
+});

package/src/discovery/param-deps.ts

@@ -361,3 +361,48 @@ export function collectCompositeOrigins(
   walk(props, "");
   return out;
 }
+
+/**
+ * Path → composite origin for an entity a registered tag built inside an
+ * interpreted composite factory body (chant #3212).
+ *
+ * The tag reports which props paths each interpolation fed (`fields`, from
+ * `setInterpolationFields`), because only the tag parsed the text. This joins
+ * that with the factory parameters each interpolation's expression reads,
+ * walked exactly as {@link collectCompositeOrigins} walks a property's
+ * expression, so a body `const` is followed and a sibling entity is not.
+ *
+ * A path fed by an interpolation that reads a parameter is that parameter. Every
+ * other top-level key of `props` is something the factory's text fixes, and is
+ * recorded `composite-literal` at the key, which a parameter recorded deeper
+ * still outranks by longest prefix.
+ */
+export function collectTagOrigins(
+  interpolations: readonly ts.Expression[],
+  fields: ReadonlyArray<readonly string[]>,
+  props: unknown,
+  consts: ReadonlyMap<string, ts.Expression>,
+  scope: CompositeParamScope,
+  composite: string,
+): Record<string, PathOrigin> {
+  const out: Record<string, PathOrigin> = {};
+
+  interpolations.forEach((expr, index) => {
+    const found = new Set<string>();
+    readCompositeParameters(expr, consts, scope, found);
+    if (found.size === 0) return;
+    for (const path of fields[index] ?? []) {
+      const existing = out[path];
+      const merged = new Set(existing?.kind === "composite-parameter" ? existing.parameters : []);
+      for (const parameter of found) merged.add(parameter);
+      out[path] = { kind: "composite-parameter", composite, parameters: [...merged].sort() };
+    }
+  });
+
+  if (props !== null && typeof props === "object" && !Array.isArray(props)) {
+    for (const [key, value] of Object.entries(props)) {
+      if (value !== undefined) out[key] ??= { kind: "composite-literal", composite };
+    }
+  }
+  return out;
+}