@intentius/chant 0.108.1 → 0.110.0

package/src/discovery/fold-import.ts

@@ -52,9 +52,14 @@ import {
   collectCompositeOrigins,
   collectParamDependencies,
   collectTagOrigins,
+  sourceLocationOf,
+  type CompositeCallSite,
   type CompositeParamScope,
+  type HostBindings,
 } from "./param-deps";
-import { getInterpolationFields, setPathProvenance } from "../provenance";
+import { getInterpolationFields, getProvenance, setPathProvenance, setProvenance } from "../provenance";
+import { foldProvenanceOfEntities, type FoldProvenance } from "../fold-provenance";
+import { collectEntities } from "./collect";
 import { intrinsicCallFoldsEagerly, intrinsicTagFolds, type IntrinsicDef } from "../lexicon";
 import type { BuildParamValue } from "../build-params";
 
@@ -1376,6 +1381,13 @@ interface ResolveCtx {
    * failure as before #1020 — this is strictly additive.
    */
   externals: Map<string, unknown>;
+  /**
+   * INTENTIUS/typescript-as-data#248 — the names in {@link externals} a
+   * lexicon package's export supplied. A props expression that reads one is a
+   * `host-value` origin rather than the file's own `direct` one. Absent on a
+   * context that never records direct-entity provenance.
+   */
+  hostValues?: ReadonlySet<string>;
   /**
    * chant #1020 — for a `file`-local import name whose cross-file
    * resolution attempt failed, WHY (a located, human-readable reason —
@@ -1479,6 +1491,13 @@ interface CompositeParamRecorder {
    * `fold()` sees them.
    */
   consts: Map<string, ts.Expression>;
+  /**
+   * chant #3597 — the composite call this body was reached from, when the
+   * fold saw it as written. A call made from already-folded values (the
+   * nested-value path, {@link resolveCompositeCall}) has no node, and its
+   * members record origins without locations.
+   */
+  call?: CompositeCallSite;
 }
 
 /** `{ value }` when `node`'s shape was recognized and resolved (value may itself be `undefined`/`null` — e.g. an optional composite member that wasn't created); `undefined` when the shape isn't one the live resolver understands (a plain literal, etc.) — callers fall back to the original, unchanged handling for that shape. */
@@ -1698,7 +1717,7 @@ async function resolveImportedCall(
 
   if (factory) {
     const args = await resolveCallArguments(node, calleeName, ctx);
-    const interpreted = await interpretCompositeFactory(factory, args, ctx);
+    const interpreted = await interpretCompositeFactory(factory, args, ctx, { file: ctx.file, node });
     if (interpreted) return interpreted.value;
     // Declined — the body's shape passed but something in it did not resolve
     // (an identifier the module's own imports don't reach, a constructor
@@ -1808,7 +1827,17 @@ async function invokeResolvedCallee(
   const packageInternal = ctx.packageRoot !== undefined && isUnderDirectory(modulePath, ctx.packageRoot);
   if (isProjectImport(binding.specifier, ctx.file) && !packageInternal) executionCounts.projectFactoryInvocations += 1;
 
-  return (Fn as (...fnArgs: unknown[]) => unknown)(...args);
+  const result = (Fn as (...fnArgs: unknown[]) => unknown)(...args);
+  // chant#3608 — a host composite invoked rather than interpreted (one the
+  // host publishes, or one whose body interpretation declined) returns the
+  // host's own instance. Mark it as the interpreted form is marked, so an
+  // instance exported whole is expanded and its members, whole or
+  // destructured, are known to come from a composite.
+  const compositeName = (Fn as { compositeName?: unknown }).compositeName;
+  if (typeof compositeName === "string" && isIndexableObject(result) && !isCompositeInstance(result)) {
+    markHostCompositeInstance(result, compositeName);
+  }
+  return result;
 }
 
 /**
@@ -1902,16 +1931,22 @@ async function resolveCallArguments(
   const args: unknown[] = [];
   for (const argNode of node.arguments) {
     const live = await resolveLiveValue(argNode, ctx);
-    if (live === undefined) await resolveSameFileCallReferences(argNode, ctx);
-    // chant #1039 — a folded (non-live) argument may itself contain a
-    // registered intrinsic tagged template; revive it into the real value
-    // before the composite factory actually runs on it (see the "Intrinsic
-    // revival" section below `resolveResourceEntity` uses the same way).
-    args.push(
-      live !== undefined
-        ? live.value
-        : await reviveFoldedValue(fold(argNode, ctx.consts, ctx.intrinsics, ctx.externals), ctx, helperArgs),
-    );
+    if (live !== undefined) {
+      args.push(live.value);
+      continue;
+    }
+    // chant#3610 — the bindings hold for this argument only, so a read of the
+    // same name outside any argument still refuses, whatever the declarator order.
+    const bound = await resolveSameFileCallReferences(argNode, ctx);
+    try {
+      // chant #1039 — a folded (non-live) argument may itself contain a
+      // registered intrinsic tagged template; revive it into the real value
+      // before the composite factory actually runs on it (see the "Intrinsic
+      // revival" section below `resolveResourceEntity` uses the same way).
+      args.push(await reviveFoldedValue(fold(argNode, ctx.consts, ctx.intrinsics, ctx.externals), ctx, helperArgs));
+    } finally {
+      for (const name of bound) ctx.externals.delete(name);
+    }
   }
   return args;
 }
@@ -1933,8 +1968,12 @@ async function resolveCallArguments(
  * resolution that fails, or gives anything but a Declarable or a composite
  * instance, is left alone too, so the reference rejects with the message it
  * always had. Inside a factory body `locals` is empty, so nothing here applies.
+ *
+ * chant#3610 — returns the names it bound, which the caller removes from
+ * `externals` once the argument has folded. A host composite's instance
+ * counts as a composite instance here, as it does everywhere else.
  */
-async function resolveSameFileCallReferences(node: ts.Node, ctx: ResolveCtx): Promise<void> {
+async function resolveSameFileCallReferences(node: ts.Node, ctx: ResolveCtx): Promise<string[]> {
   const names = new Set<string>();
   const visit = (n: ts.Node): void => {
     if (ts.isIdentifier(n)) {
@@ -1950,6 +1989,7 @@ async function resolveSameFileCallReferences(node: ts.Node, ctx: ResolveCtx): Pr
     ts.forEachChild(n, visit);
   };
   visit(node);
+  const bound: string[] = [];
   for (const name of names) {
     let resolved: LiveResolution;
     try {
@@ -1957,10 +1997,17 @@ async function resolveSameFileCallReferences(node: ts.Node, ctx: ResolveCtx): Pr
     } catch {
       continue;
     }
-    if (resolved && (isDeclarable(resolved.value) || isCompositeInstance(resolved.value))) {
+    if (
+      resolved &&
+      (isDeclarable(resolved.value) ||
+        isCompositeInstance(resolved.value) ||
+        hostCompositeName(resolved.value) !== undefined)
+    ) {
       ctx.externals.set(name, resolved.value);
+      bound.push(name);
     }
   }
+  return bound;
 }
 
 /** A same-file `const name = Callee(...)` that `fold()` would refuse as a function call used as a value. */
@@ -2798,6 +2845,7 @@ function isLiteralPropertyNameNode(node: ts.PropertyName): boolean {
 function compositeParamRecorder(
   factory: InterpretableFactory,
   moduleConsts: ReadonlyMap<string, ts.Expression>,
+  call?: CompositeCallSite,
 ): CompositeParamRecorder {
   const whole = new Set<string>();
   const destructured = new Map<string, string>();
@@ -2828,7 +2876,7 @@ function compositeParamRecorder(
     }
   }
 
-  return { composite: factory.compositeName, scope: { whole, destructured }, consts };
+  return { composite: factory.compositeName, scope: { whole, destructured }, consts, ...(call ? { call } : {}) };
 }
 
 /**
@@ -2852,10 +2900,21 @@ function stampCompositeOrigins(entity: unknown, node: ts.NewExpression, ctx: Res
     }
   }
   if (!propsArg) return;
-  const origins = collectCompositeOrigins(propsArg, recorder.consts, recorder.scope, recorder.composite);
+  stampCompositeCall(entity, recorder);
+  const origins = collectCompositeOrigins(propsArg, recorder.consts, recorder.scope, recorder.composite, recorder.call);
   for (const [path, origin] of Object.entries(origins)) setPathProvenance(entity, path, origin);
 }
 
+/**
+ * chant #3597 — record where the composite call that expanded `entity` was
+ * written, beside the per-path origins and in the same pass. First writer
+ * wins, as for every provenance field, so the innermost call is kept.
+ */
+function stampCompositeCall(entity: object, recorder: CompositeParamRecorder): void {
+  if (!recorder.call) return;
+  setProvenance(entity, { compositeCall: sourceLocationOf(recorder.call.file, recorder.call.node) });
+}
+
 /**
  * chant #3212 — the same record for an entity a registered tag built inside an
  * interpreted factory body (`` table`CREATE TABLE ${props.name} ...` ``).
@@ -2873,7 +2932,16 @@ function stampTagOrigins(entity: unknown, node: ts.TaggedTemplateExpression, ctx
   const interpolations = ts.isTemplateExpression(node.template)
     ? node.template.templateSpans.map((span) => span.expression)
     : [];
-  const origins = collectTagOrigins(interpolations, fields, entity.props, recorder.consts, recorder.scope, recorder.composite);
+  stampCompositeCall(entity, recorder);
+  const origins = collectTagOrigins(
+    interpolations,
+    fields,
+    entity.props,
+    recorder.consts,
+    recorder.scope,
+    recorder.composite,
+    recorder.call,
+  );
   for (const [path, origin] of Object.entries(origins)) setPathProvenance(entity, path, origin);
 }
 
@@ -2892,6 +2960,7 @@ async function interpretCompositeFactory(
   factory: InterpretableFactory,
   args: readonly unknown[],
   ctx: ResolveCtx,
+  call?: CompositeCallSite,
 ): Promise<{ value: unknown } | undefined> {
   // A `Composite()` factory takes exactly one props argument. Anything else at
   // the call site means the callee is being used as something this doesn't
@@ -2932,7 +3001,7 @@ async function interpretCompositeFactory(
     interpretDepth: ctx.interpretDepth + 1,
     // chant #2161 — set unconditionally, and NOT inherited from `ctx`: a nested
     // composite records its own parameters, never the enclosing one's.
-    compositeParams: compositeParamRecorder(factory, scope.consts),
+    compositeParams: compositeParamRecorder(factory, scope.consts, call),
   };
 
   const bind = (name: string, value: unknown): void => {
@@ -2973,7 +3042,7 @@ async function interpretCompositeFactory(
     // rejecting it for not being chant's rather than for being malformed.
     // Chant's own form still goes through `Composite`, unchanged.
     const value = factory.hostForm
-      ? members
+      ? markHostCompositeInstance(members, factory.compositeName)
       : (Composite<void, CompositeMembers>(() => members as CompositeMembers, factory.compositeName))();
     executionCounts.factoryInterpretations += 1;
     return { value };
@@ -2987,6 +3056,53 @@ async function interpretCompositeFactory(
   }
 }
 
+/**
+ * chant#3598 — a host composite instance's own marker. Non-enumerable and
+ * symbol-keyed, like provenance, so nothing that serializes or compares the
+ * exports sees it. It carries the composite's name, which the members object
+ * otherwise has no record of once it is returned.
+ */
+const HOST_COMPOSITE_INSTANCE = Symbol.for("chant.fold.hostCompositeInstance");
+
+/**
+ * Mark `members` as the instance a host's composite produced, and return it
+ * unchanged.
+ *
+ * chant#3608 — every declarable member, and every member of a nested host
+ * instance, is also stamped with the composite, the way `expandComposite`
+ * stamps a chant instance's members. A destructured member is never expanded,
+ * so this is the only record it has that a composite wrote it, and without
+ * it a path the fold did not attribute reads as authored and so `direct`.
+ * `setProvenance` keeps the first writer, and a nested instance was marked
+ * when its own call returned, so a member keeps its innermost composite.
+ */
+function markHostCompositeInstance(members: Record<string, unknown>, compositeName: string): Record<string, unknown> {
+  if (Object.isExtensible(members) && !Object.prototype.hasOwnProperty.call(members, HOST_COMPOSITE_INSTANCE)) {
+    Object.defineProperty(members, HOST_COMPOSITE_INSTANCE, {
+      value: compositeName,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+  stampHostCompositeMembers(members, compositeName);
+  return members;
+}
+
+/** Stamp `composite` on each declarable member of a host instance, descending into nested host instances. */
+function stampHostCompositeMembers(members: Record<string, unknown>, compositeName: string): void {
+  for (const member of Object.values(members)) {
+    if (isDeclarable(member)) setProvenance(member, { composite: compositeName });
+    else if (hostCompositeName(member) !== undefined) stampHostCompositeMembers(member as Record<string, unknown>, compositeName);
+  }
+}
+
+/** The composite name a host composite instance was marked with, or `undefined` for any other value. */
+function hostCompositeName(value: unknown): string | undefined {
+  if (!isIndexableObject(value)) return undefined;
+  const name = (value as Record<symbol, unknown>)[HOST_COMPOSITE_INSTANCE];
+  return typeof name === "string" ? name : undefined;
+}
+
 /** Evaluate an admissible factory body's statements in order, binding each `const`, and return the `return` expression's value. */
 async function interpretFactoryBody(
   fn: ts.ArrowFunction | ts.FunctionExpression,
@@ -3829,13 +3945,19 @@ function paramLocalNames(ctx: ResolveCtx): Set<string> {
 /**
  * chant #1443 — record which build parameters each of a resource's authored
  * property expressions reads, before fold substitutes them away. Best-effort
- * and additive: a file with no `params` import, or a constructor called with no
- * object literal, records nothing.
+ * and additive: a constructor called with no object literal records nothing.
+ *
+ * INTENTIUS/typescript-as-data#248 — and which of them read host code, a
+ * method call, an eager lexicon helper or a lexicon export, so fold provenance
+ * reports those `unknown` rather than `direct`.
  */
 function stampParamDependencies(entity: unknown, node: ts.NewExpression, ctx: ResolveCtx): void {
   if (typeof entity !== "object" || entity === null) return;
   const paramLocals = paramLocalNames(ctx);
-  if (paramLocals.size === 0) return;
+  const host: HostBindings = {
+    values: ctx.hostValues ?? new Set(),
+    eagerCalls: new Set(ctx.intrinsics.filter((i) => intrinsicCallFoldsEagerly(i)).map((i) => i.name)),
+  };
   // The same argument `foldResource` treats as props: the first object literal.
   let propsArg: ts.ObjectLiteralExpression | undefined;
   for (const argument of node.arguments ?? []) {
@@ -3845,7 +3967,7 @@ function stampParamDependencies(entity: unknown, node: ts.NewExpression, ctx: Re
     }
   }
   if (!propsArg) return;
-  for (const [path, origin] of Object.entries(collectParamDependencies(propsArg, ctx.consts, paramLocals))) {
+  for (const [path, origin] of Object.entries(collectParamDependencies(propsArg, ctx.consts, paramLocals, host))) {
     setPathProvenance(entity, path, origin);
   }
 }
@@ -4085,13 +4207,20 @@ async function buildExternals(
    * a path lexicon's are, never folded as project files.
    */
   extraLexiconRoots: readonly string[] = [],
-): Promise<{ externals: Map<string, unknown>; failures: Map<string, string>; liveSources: Set<string> }> {
+): Promise<{
+  externals: Map<string, unknown>;
+  failures: Map<string, string>;
+  liveSources: Set<string>;
+  /** Local names bound to a lexicon package's export (INTENTIUS/typescript-as-data#248). */
+  hostValues: Set<string>;
+}> {
   const lexiconRoots =
     extraLexiconRoots.length === 0 ? session.lexiconRoots : [...session.lexiconRoots, ...extraLexiconRoots];
   const externals = new Map<string, unknown>();
   const failures = new Map<string, string>();
   // chant #1044 — see `FoldFileResult.liveSources`.
   const liveSources = new Set<string>();
+  const hostValues = new Set<string>();
 
   for (const [localName, binding] of imports) {
     // chant #1064 — a named `params` import that resolves to chant-core's own
@@ -4168,6 +4297,7 @@ async function buildExternals(
       const lexiconExport = await resolveActiveLexiconExport(binding, file, session);
       if (lexiconExport) {
         externals.set(localName, lexiconExport.value);
+        hostValues.add(localName);
         continue;
       }
       // Every other bare specifier (a non-lexicon vendor package, a lexicon
@@ -4202,7 +4332,10 @@ async function buildExternals(
     // with no `liveSources` edge for the same reason.
     if (session.lexiconModules.has(targetPath)) {
       const lexiconExport = await resolveActiveLexiconExport(binding, file, session);
-      if (lexiconExport) externals.set(localName, lexiconExport.value);
+      if (lexiconExport) {
+        externals.set(localName, lexiconExport.value);
+        hostValues.add(localName);
+      }
       continue;
     }
     // chant#2590 — another file of a multi-file path lexicon is a lexicon
@@ -4220,7 +4353,10 @@ async function buildExternals(
     // constructor or composite resolves through the import path.
     if (inPathLexiconRoot(targetPath, extraLexiconRoots)) {
       const value = await packageDataExport(targetPath, binding.imported, session);
-      if (value) externals.set(localName, value.value);
+      if (value) {
+        externals.set(localName, value.value);
+        hostValues.add(localName);
+      }
       continue;
     }
     if (inPathLexiconRoot(targetPath, lexiconRoots)) continue;
@@ -4269,7 +4405,7 @@ async function buildExternals(
     }
   }
 
-  return { externals, failures, liveSources };
+  return { externals, failures, liveSources, hostValues };
 }
 
 /**
@@ -4345,7 +4481,12 @@ async function tryFoldFileCore(file: string, session: FoldSession): Promise<Fold
     if (scan.declarators.length === 0) return { ok: false, reason: "no foldable resource exports" };
 
     const collected = collectImports(sourceFile);
-    const { externals, failures, liveSources } = await buildExternals(file, collected.named, collected.namespaces, session);
+    const { externals, failures, liveSources, hostValues } = await buildExternals(
+      file,
+      collected.named,
+      collected.namespaces,
+      session,
+    );
 
     const ctx: ResolveCtx = {
       file,
@@ -4356,6 +4497,7 @@ async function tryFoldFileCore(file: string, session: FoldSession): Promise<Fold
       memo: new Map(),
       intrinsics: session.intrinsics,
       externals,
+      hostValues,
       crossFileFailures: failures,
       importCache: session.importCache,
       resolvePathCache: session.resolvePathCache,
@@ -4850,6 +4992,20 @@ export interface FoldProjectVerdict {
   readonly taintedBy?: { from: string; kind: TaintEdgeKind };
   /** The file's complete export namespace, present only when `verdict` is "fold". */
   readonly exports?: ReadonlyMap<string, unknown>;
+  /**
+   * chant#3598 — fold provenance for the entities this file contributes,
+   * keyed by entity name, in the shape `build()` reports as
+   * `BuildResult.foldProvenance`. Present only when `verdict` is "fold" and
+   * the folded files' entities could be collected (a duplicate entity name
+   * fails collection for the whole set, as it fails a build, and then no
+   * verdict carries it). A file that folds and declares nothing with
+   * properties carries `{}`.
+   *
+   * A "run" file has no entry: foldProject never executes one, so it has no
+   * entities to attribute. That holds under `sandbox` too, where nothing
+   * crosses the child-process wire because no child is started.
+   */
+  readonly foldProvenance?: FoldProvenance;
 }
 
 /**
@@ -4910,12 +5066,29 @@ export async function foldProject(
     })),
   );
 
+  const folded = files.filter((file) => attempts.get(file)?.ok === true && !plan.tainted.has(file));
+  const provenanceByFile = foldProvenanceByFile(
+    folded.map((file) => {
+      const attempt = attempts.get(file);
+      return {
+        file,
+        exports: attempt?.ok === true ? expandHostCompositeExports(Object.fromEntries(attempt.exportedValues)) : {},
+      };
+    }),
+  );
+
   const out = new Map<string, FoldProjectVerdict>();
   for (const file of files) {
     const attempt = attempts.get(file)!;
     const tentative = attempt.ok ? "fold" : "run";
     if (attempt.ok && !plan.tainted.has(file)) {
-      out.set(file, { verdict: "fold", tentative, exports: attempt.exportedValues });
+      const foldProvenance = provenanceByFile?.get(file);
+      out.set(file, {
+        verdict: "fold",
+        tentative,
+        exports: attempt.exportedValues,
+        ...(foldProvenance ? { foldProvenance } : {}),
+      });
       continue;
     }
     out.set(file, {
@@ -4927,3 +5100,124 @@ export async function foldProject(
   }
   return out;
 }
+
+/**
+ * chant#3598 — the folded files' fold provenance, split by declaring file.
+ *
+ * This is `build()`'s computation, not a second one: the same
+ * `collectEntities` over the same folded export namespaces `discover()` hands
+ * it, then `foldProvenanceOfEntities` with `getProvenance`. One call over the
+ * whole folded set rather than one per file, because composite expansion and
+ * cross-directory name disambiguation (#932) are decided over the set and an
+ * entity's name is part of what is being reported. The build root is the
+ * files' common directory, which is what `chant build <dir>` passes when every
+ * file sits under `<dir>`.
+ *
+ * Returns `undefined` when collection throws (a duplicate name), the case
+ * where a build has no entities either.
+ */
+function foldProvenanceByFile(
+  modules: Array<{ file: string; exports: Record<string, unknown> }>,
+): Map<string, FoldProvenance> | undefined {
+  if (modules.length === 0) return new Map();
+  let entities: Map<string, Declarable>;
+  try {
+    entities = collectEntities(modules, commonDirectory(modules.map((m) => m.file)));
+  } catch {
+    return undefined;
+  }
+
+  const byResolved = new Map<string, FoldProvenance>();
+  const out = new Map<string, FoldProvenance>();
+  for (const { file } of modules) {
+    const record: FoldProvenance = {};
+    byResolved.set(resolvePath(file), record);
+    out.set(file, record);
+  }
+
+  const all = foldProvenanceOfEntities(entities, getProvenance);
+  for (const [name, record] of Object.entries(all)) {
+    const sourceFile = getProvenance(entities.get(name) as Declarable)?.sourceFile;
+    const target = sourceFile === undefined ? undefined : byResolved.get(resolvePath(sourceFile));
+    if (target) target[name] = record;
+  }
+  return out;
+}
+
+/**
+ * chant#3598 — a file's exports with every host composite instance replaced by
+ * its members, for {@link foldProvenanceByFile} only.
+ *
+ * A host's registration form (chant#2442) returns the members object the
+ * factory built, not a chant `CompositeInstance`, because wrapping it would run
+ * chant's member validation against the host's own entities. `collectEntities`
+ * expands only chant's instances, so an instance exported whole
+ * (`export const store = Store({...})`) contributed no entity and therefore no
+ * record, while a destructured member, a plain declarable export, did.
+ *
+ * The members are named and stamped the way `expandComposite` names and stamps
+ * a chant instance: `${exportName}${Member}`, with a whole-entity `composite`
+ * origin under the paths the fold already attributed. That origin is written
+ * before `collectEntities` adds its `authored` one, and the first writer wins,
+ * so a path the fold did not attribute is `unknown` rather than `direct`.
+ *
+ * Only a top-level export is expanded. A host instance nested in another
+ * composite's body or placed in an array does not fold today, so its file is
+ * `run` and has no record to give.
+ *
+ * The exports a caller receives in the verdict are the originals.
+ */
+function expandHostCompositeExports(exports: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [name, value] of Object.entries(exports)) {
+    if (hostCompositeName(value) === undefined) {
+      out[name] = value;
+      continue;
+    }
+    expandHostCompositeInstance(name, value as Record<string, unknown>, name, out);
+  }
+  return out;
+}
+
+/**
+ * chant#3608 — one host instance's members into `out`, a nested host instance
+ * expanded in place under its member's name (`siteMainBucket`), as
+ * `expandComposite` expands a nested chant instance. Every member belongs to
+ * the top-level `instance`; its composite is the innermost one, which
+ * {@link markHostCompositeInstance} already stamped, so the whole-entity
+ * origin names that composite too.
+ */
+function expandHostCompositeInstance(
+  prefix: string,
+  members: Record<string, unknown>,
+  instance: string,
+  out: Record<string, unknown>,
+): void {
+  const compositeName = hostCompositeName(members) as string;
+  for (const [memberName, member] of Object.entries(members)) {
+    if (memberName.length === 0) continue;
+    const fullName = `${prefix}${memberName[0].toUpperCase()}${memberName.slice(1)}`;
+    if (hostCompositeName(member) !== undefined) {
+      expandHostCompositeInstance(fullName, member as Record<string, unknown>, instance, out);
+      continue;
+    }
+    if (!isDeclarable(member)) continue;
+    setProvenance(member, { composite: compositeName, compositeInstance: instance });
+    const composite = getProvenance(member)?.composite ?? compositeName;
+    setPathProvenance(member, "", { kind: "composite", composite, instance });
+    out[fullName] = member;
+  }
+}
+
+/** The deepest directory every one of `files` sits under. */
+function commonDirectory(files: readonly string[]): string {
+  const split = files.map((file) => dirname(resolvePath(file)).split(sep));
+  const first = split[0];
+  let depth = first.length;
+  for (const parts of split.slice(1)) {
+    let i = 0;
+    while (i < depth && i < parts.length && parts[i] === first[i]) i++;
+    depth = i;
+  }
+  return first.slice(0, depth).join(sep) || sep;
+}

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

@@ -96,15 +96,28 @@ describe("lexicon-package and re-exported composites are interpreted (chant#3247
     expect(folded.errors).toEqual([]);
     expect(foldExecutionCounts()).toMatchObject({ factoryInterpretations: 1, factoryInvocations: 0 });
     const fields = folded.foldProvenance.sinkAssignmentActivityLogSink!.fields;
+    // chant#3597 — where the call and each argument were written in main.ts.
+    const file = join(srcDir, "main.ts");
+    const lines = CALL_SINK.split("\n");
+    const line = lines.findIndex((l) => l.includes("ActivityLogSink({")) + 1;
+    const at = (needle: string) => ({ file, line, column: lines[line - 1].indexOf(needle) + 1 });
+    const call = at("ActivityLogSink({");
+    const written: Record<string, string> = {
+      location: 'location: "eastus"',
+      workspaceId: 'workspaceId: "/subscriptions/s/workspaces/logs"',
+    };
     const param = (...parameters: string[]) => ({
       kind: "composite-parameter",
       composite: "ActivityLogSink",
       instance: "sink",
       parameters,
+      call,
+      arguments: parameters.map((parameter) => ({ parameter, ...at(written[parameter]), text: written[parameter] })),
     });
     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" });
+    expect(fields.name).toEqual({ kind: "composite-literal", composite: "ActivityLogSink", instance: "sink", call });
+    expect(folded.foldProvenance.sinkAssignmentActivityLogSink!.compositeCall).toEqual(call);
 
     // 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"] });