@intentius/chant 0.124.12 → 0.124.14

package/dist/discovery/fold-import.js

@@ -0,0 +1,4178 @@
+import * as ts from "typescript";
+import { readFile } from "node:fs/promises";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, basename, join, sep, isAbsolute, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { isDeclarable, isResourceDeclarable } from "../declarable.js";
+import { Composite, isCompositeInstance } from "../composite.js";
+import { isAttrRefLike } from "../utils.js";
+import { isIntrinsic } from "../intrinsic.js";
+import { collectConsts, foldResource, fold, propName, FoldError, isFoldableFunction, locate, collectSameFileFunctions, constResolvesToResource, } from "../fold/fold.js";
+import { isChantOwnedSpecifier, isFoldableHelperName } from "../fold/foldable-helpers.js";
+import { lexiconModulePath, lexiconModuleRoot } from "../lexicon-module.js";
+import { isFile, packageExportsTarget, probeModuleFile, splitBareSpecifier, tsconfigPathsMatch, } from "./specifier-resolve.js";
+import { briefNodeText, callExpressionMessage, computedPropertyNameMessage, isLiteralElementKey, unsupportedBinaryMessage, unsupportedExpressionMessage, UNSUPPORTED_OBJECT_MEMBER_MESSAGE, UNSUPPORTED_UNARY_MESSAGE, SUPPORTED_BINARY_OPERATORS, SUPPORTED_UNARY_OPERATORS, } from "../fold/subset.js";
+import { importModule } from "./import.js";
+import { collectCompositeOrigins, collectParamDependencies, collectTagOrigins, sourceLocationOf, } from "./param-deps.js";
+import { getInterpolationFields, getProvenance, setPathProvenance, setProvenance } from "../provenance.js";
+import { foldProvenanceOfEntities } from "../fold-provenance.js";
+import { collectEntities } from "./collect.js";
+import { intrinsicCallFoldsEagerly, intrinsicTagFolds } from "../lexicon.js";
+/**
+ * chant #1063 — the package specifier a lexicon NAME (`"aws"`, `"gitlab"`)
+ * is installed under. The one naming convention the whole CLI already
+ * depends on: `loadPlugin(name)` imports exactly this
+ * (../cli/plugins.ts), `detectLexicons` scans source for exactly this
+ * (../detectLexicon.ts), and `chant init` writes exactly this into
+ * package.json.
+ */
+export function lexiconPackageName(lexiconName) {
+    return `@intentius/chant-lexicon-${lexiconName}`;
+}
+/**
+ * Create a fresh, empty {@link FoldSession}.
+ *
+ * @param lexicons - chant #1063: the lexicon NAMES active for this build
+ *   (`["aws", "k8s"]`). Converted to package specifiers via
+ *   {@link lexiconPackageName}; see {@link FoldSession.lexiconPackages}.
+ * @param sandbox - chant #1093: this build asked for the #1045 sandbox, so
+ *   fold may not import or invoke anything outside the trusted allowlist —
+ *   see {@link FoldSession.sandbox}.
+ */
+export function createFoldSession(intrinsics = [], buildParams, lexicons = [], sandbox = false, 
+/**
+ * chant#2438 — package specifiers to allow verbatim, alongside the ones
+ * derived from `lexicons`.
+ *
+ * A chant build's active packages are always `@intentius/chant-lexicon-*`,
+ * so naming lexicons is the whole story there. A caller embedding the fold
+ * path against a host that is not a chant lexicon has packages the naming
+ * convention cannot express: the specification's conformance harness supplies
+ * `@tsad/shapes`, which is its host's own specifier. The boundary is
+ * unchanged, an explicitly named package of this build, only now it can be
+ * named as a specifier rather than only as a lexicon.
+ */
+lexiconPackages = [], 
+/** chant#2455 — `ι = executing`. Mutually exclusive with `sandbox`. */
+executing = false, 
+/**
+ * chant#2590 — the build's own source files. A path lexicon's trusted
+ * directory that holds any of them is dropped (see {@link FoldSession.lexiconRoots}).
+ */
+sourceFiles = []) {
+    // chant#2577 — a lexicon declared by path is that module and no package, so
+    // its name contributes the module path and not `@intentius/chant-lexicon-<name>`.
+    const packages = new Set(lexiconPackages);
+    const modules = new Set();
+    const roots = [];
+    for (const name of lexicons) {
+        const modulePath = lexiconModulePath(name);
+        if (modulePath === undefined)
+            packages.add(lexiconPackageName(name));
+        else
+            modules.add(resolveModulePath(modulePath, modulePath));
+        const root = lexiconModuleRoot(name);
+        if (root !== undefined && !sourceFiles.some((file) => isUnderDirectory(resolvePath(file), root)))
+            roots.push(root);
+    }
+    return {
+        intrinsics,
+        cache: new Map(),
+        stack: [],
+        importCache: new Map(),
+        resolvePathCache: new Map(),
+        buildParams,
+        lexiconPackages: packages,
+        lexiconModules: modules,
+        lexiconRoots: roots,
+        sandbox,
+        executing,
+        factoryModules: new Map(),
+    };
+}
+/**
+ * chant #1020 hang fix — memo for {@link resolveModulePath}'s BARE
+ * (package) specifier branch, deliberately PROCESS-WIDE rather than
+ * session-scoped (contrast {@link FoldSession.resolvePathCache}, used for
+ * relative specifiers). A bare specifier like `@intentius/chant-lexicon-aws`
+ * resolves via `createRequire(fromFile).resolve(specifier)` — which package
+ * a name refers to cannot change mid-process (Node's own module cache
+ * already assumes this: nothing invalidates `require.cache`/the dynamic
+ * `import()` cache either if `node_modules` changes under a running
+ * process), so caching the answer for the process's lifetime, across every
+ * `discover()` call/`FoldSession`, is exactly as safe as Node's own
+ * assumptions — unlike a relative specifier (a project file `chant build
+ * --watch` can legitimately add/remove between rebuilds), never unsafe to
+ * reuse.
+ *
+ * This is what actually fixes the hang, not just reduces it: profiling (a
+ * real `sample` during the observed multi-minute stall) traced the cost to
+ * `createRequire(fromFile).resolve(specifier)` ITSELF taking upwards of a
+ * minute — measured on this exact call, in this exact spot, nowhere else —
+ * specifically for the FIRST bare-specifier resolution inside a
+ * `FoldSession` created right after `vitest`'s `vi.resetModules()`
+ * (`sandbox-differential.test.ts`'s own retry path, pre-existing and
+ * unrelated to #1020 — confirmed on `main`, which hits the identical retry
+ * for the identical reason and stays fast). Two narrower versions of this
+ * fix (session-scoped; then process-wide but still keyed by directory) each
+ * still paid that cost at least once more: directory-scoping alone pays it
+ * once per NEW directory a corpus entry introduces, and #1020's cross-file
+ * resolution reaches a real constructor/composite-factory/intrinsic
+ * resolution — hence a real bare-specifier resolve — from strictly more
+ * directories across a 98-entry corpus than the pre-#1020 single-file fold
+ * ever did. Keyed by specifier ALONE (see {@link resolveModulePathMemoized}'s
+ * doc for the directory-independence assumption this relies on), the answer
+ * computed the first time ANY directory needed a given package is there for
+ * every directory after it, `vi.resetModules()` retry or not — the slow call
+ * never has to happen a second time in the same process, for any package.
+ */
+const bareSpecifierPathCache = new Map();
+/**
+ * Memoized {@link resolveModulePath}. A relative/absolute specifier goes
+ * through the session-scoped `resolvePathCache`, keyed by DIRECTORY (not the
+ * full file path: `resolveModulePath` only ever consults `dirname(fromFile)`
+ * — the relative branch resolves against `dirname(fromFile)`, so the
+ * specific FILE within a directory never affects the answer) — a project
+ * file can legitimately be added/removed between builds (`chant build
+ * --watch`), so this cache is thrown away with the rest of the session.
+ *
+ * A bare (package) specifier goes through {@link bareSpecifierPathCache}
+ * instead, keyed by the specifier ALONE — process-wide, no directory
+ * component. `createRequire(fromFile).resolve(specifier)` technically CAN
+ * answer differently for the same specifier from two directories (nested
+ * `node_modules` with a version override), but `discover()`'s real usage is
+ * one `srcDir` per build, whose files overwhelmingly share one effective
+ * `node_modules` resolution — the same assumption bundlers (webpack,
+ * esbuild, vite) already make for their own module resolution caches. See
+ * {@link bareSpecifierPathCache}'s own doc for why process-wide (not just
+ * directory-scoped) is what actually fixes the hang: `examples/foo`'s
+ * directory and `lexicons/aws/examples/bar`'s directory both need
+ * `@intentius/chant-lexicon-aws`, and directory-scoping alone still pays the
+ * pathological cost once per NEW directory, not just once per package.
+ */
+function resolveModulePathMemoized(specifier, fromFile, resolvePathCache) {
+    const isBare = !specifier.startsWith(".") && !isAbsolute(specifier);
+    // chant#3090 — a tsconfig `paths` answer depends on the importing file's
+    // directory and can name a project file that comes and goes between
+    // builds, so it is memoized per session and directory, like a relative one.
+    const key = `${dirname(fromFile)}\0${specifier}`;
+    if (isBare) {
+        const sessionCached = resolvePathCache.get(key);
+        if (sessionCached !== undefined)
+            return sessionCached;
+        const mapped = pathsMappedTarget(specifier, fromFile);
+        if (mapped !== undefined) {
+            resolvePathCache.set(key, mapped);
+            return mapped;
+        }
+        const cached = bareSpecifierPathCache.get(specifier);
+        if (cached !== undefined)
+            return cached;
+        const resolved = resolveModulePath(specifier, fromFile);
+        bareSpecifierPathCache.set(specifier, resolved);
+        return resolved;
+    }
+    const cached = resolvePathCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const resolved = resolveModulePath(specifier, fromFile);
+    resolvePathCache.set(key, resolved);
+    return resolved;
+}
+/**
+ * chant #1020 hang fix — construct an `Error` for a routine, EXPECTED
+ * cross-file resolution failure (an unresolvable import, a non-function
+ * export, a shape this module doesn't support) WITHOUT V8's normal eager
+ * stack-frame capture. Every one of these is thrown, then caught a few
+ * frames up and reduced to `.message` — `tryFoldFileCore`'s own top-level
+ * catch, ultimately, same as {@link FoldError} (see its own doc in
+ * ../fold/fold.ts for the full mechanism and profiling evidence): `.stack` is
+ * never read on this path. Cheap for a shallow call stack, but this module's
+ * cross-file recursion (`foldFileMemoized` -> `buildExternals` ->
+ * `tryFoldFileCore` -> `resolveDeclaratorValue`/`resolveLiveValue` ->
+ * `resolveCallExpression`/`resolveImportedExport`, sometimes several files
+ * deep) makes the live stack deep enough, and hot enough for V8 to inline
+ * aggressively across a 98-entry corpus, that eager capture becomes the
+ * dominant cost — confirmed via `sample` during the observed multi-minute
+ * stall. Every throw site in this module that isn't a {@link FoldError}
+ * itself should use this instead of `new Error(...)`.
+ */
+function cheapError(message) {
+    const prevStackTraceLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    try {
+        return new Error(message);
+    }
+    finally {
+        Error.stackTraceLimit = prevStackTraceLimit;
+    }
+}
+/**
+ * Memoized {@link importModule} — see {@link FoldSession.importCache}'s doc
+ * for why this exists. Keyed by `modulePath` exactly as callers already pass
+ * it (the output of {@link resolveModulePath}, always an absolute path), so
+ * every caller resolving the same module shares the identical in-flight/
+ * settled promise instead of issuing its own `import()`.
+ */
+function importModuleMemoized(modulePath, importCache) {
+    const cached = importCache.get(modulePath);
+    if (cached)
+        return cached;
+    const promise = importModule(modulePath);
+    importCache.set(modulePath, promise);
+    return promise;
+}
+/** True when `node` carries the `export` modifier. */
+function hasExportModifier(node) {
+    return node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+const executionCounts = {
+    factoryInvocations: 0,
+    projectFactoryInvocations: 0,
+    factoryInterpretations: 0,
+};
+/** A snapshot of {@link FoldExecutionCounts}. Process-wide and monotonic — a caller wanting a per-build figure calls {@link resetFoldExecutionCounts} first. */
+export function foldExecutionCounts() {
+    return { ...executionCounts };
+}
+/** Zero {@link foldExecutionCounts}, for a caller measuring one build. */
+export function resetFoldExecutionCounts() {
+    executionCounts.factoryInvocations = 0;
+    executionCounts.projectFactoryInvocations = 0;
+    executionCounts.factoryInterpretations = 0;
+}
+/**
+ * True for any non-null, non-array object — a real `CompositeInstance`, a
+ * real `Declarable`, or (chant #1020) the synthetic plain object a
+ * namespace import's cross-file resolution builds from another file's own
+ * `exportedValues`. Property/member access on any of these is just a plain
+ * bracket index, so {@link resolveLiveValue} doesn't need to special-case
+ * which kind it is.
+ */
+function isIndexableObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Extract a foldable object-binding-pattern element's source property key, or `undefined` if the shape isn't supported (rest element, nested pattern, default value, computed name). */
+function bindingElementPropKey(el) {
+    if (el.dotDotDotToken || el.initializer || !ts.isIdentifier(el.name))
+        return undefined;
+    if (!el.propertyName)
+        return el.name.text;
+    return ts.isIdentifier(el.propertyName) ? el.propertyName.text : undefined;
+}
+/**
+ * Scan a source file's top-level statements for the exported shapes this
+ * module can fold: `export const X = new Type(...)` (resources, #1022),
+ * `export const X = <expr>` / `export const { a, b } = <expr>` (composite
+ * calls and member access on them, #1023), `export { a, b }` (a local
+ * named-export list), and `export { a, b } from "./other"` (a re-export
+ * chain, #1020), and `export function name(...) {...}` (a foldable-function
+ * export, #1373). Any OTHER export construct (`export default`, `export *
+ * from`, an exported class, `let`/`var`, a destructured export with
+ * a rest/nested/defaulted element) makes the whole file ineligible: the
+ * module must run so that construct is actually evaluated. This mirrors the
+ * epic's hybrid design — fallback is per-module, not per-declaration,
+ * because an unfoldable export can itself reference or be referenced by a
+ * foldable one in ways only running proves safe.
+ */
+function scanExports(sourceFile) {
+    const declarators = [];
+    for (const statement of sourceFile.statements) {
+        if (ts.isExportAssignment(statement)) {
+            return { declarators, unfoldableReason: "`export default` is not foldable" };
+        }
+        if (ts.isExportDeclaration(statement)) {
+            if (statement.isTypeOnly)
+                continue; // `export type { ... }` — erased, no runtime value to fold.
+            if (statement.moduleSpecifier) {
+                // chant #1020 — a genuine re-export (`export { a } from "./other"`).
+                // `export * from "./other"` has no `exportClause` at all — no
+                // enumerable element list to resolve one-by-one — and still
+                // disqualifies the file, same as before #1020.
+                if (!ts.isStringLiteral(statement.moduleSpecifier)) {
+                    return { declarators, unfoldableReason: "re-export declaration is not foldable" };
+                }
+                if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+                    return { declarators, unfoldableReason: "re-export declaration is not foldable" };
+                }
+                const elements = [];
+                for (const el of statement.exportClause.elements) {
+                    if (el.isTypeOnly)
+                        continue;
+                    const importedNameNode = el.propertyName ?? el.name;
+                    if (!ts.isIdentifier(importedNameNode)) {
+                        return { declarators, unfoldableReason: "re-export declaration is not foldable" };
+                    }
+                    elements.push({ imported: importedNameNode.text, exportedName: el.name.text });
+                }
+                declarators.push({
+                    kind: "re-export",
+                    specifier: statement.moduleSpecifier.text,
+                    specifierNode: statement.moduleSpecifier,
+                    elements,
+                });
+                continue;
+            }
+            if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+                return { declarators, unfoldableReason: "export declaration is not foldable" };
+            }
+            const elements = [];
+            for (const el of statement.exportClause.elements) {
+                if (el.isTypeOnly)
+                    continue;
+                const localNameNode = el.propertyName ?? el.name;
+                // `export { "string name" as foo }` (TS 4.5+ module-export-name
+                // syntax) isn't a plain identifier reference — not seen in practice
+                // for local (non-re-export) lists; fall back rather than guess.
+                if (!ts.isIdentifier(localNameNode)) {
+                    return { declarators, unfoldableReason: "export declaration is not foldable" };
+                }
+                elements.push({ localNameNode, exportedName: el.name.text });
+            }
+            declarators.push({ kind: "named-export", elements });
+            continue;
+        }
+        if (ts.isFunctionDeclaration(statement) && hasExportModifier(statement)) {
+            // chant #1373 — a named, bodied exported function is a foldable-function
+            // export (see {@link FunctionDeclarator}). An overload signature has no
+            // body and no value of its own — skipped, the implementation that
+            // follows it is the export. `export default function` has no name an
+            // importer could bind and stays a disqualifier, like `export default`.
+            if (statement.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) || !statement.name) {
+                return { declarators, unfoldableReason: "`export default` is not foldable" };
+            }
+            if (!statement.body)
+                continue;
+            declarators.push({ kind: "function", name: statement.name.text });
+            continue;
+        }
+        if (ts.isClassDeclaration(statement) && hasExportModifier(statement)) {
+            return {
+                declarators,
+                unfoldableReason: `exported class declaration "${statement.name?.text ?? "<anonymous>"}" is not foldable`,
+            };
+        }
+        if (!ts.isVariableStatement(statement) || !hasExportModifier(statement))
+            continue;
+        if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) {
+            return { declarators, unfoldableReason: "exported `let`/`var` declaration is not foldable" };
+        }
+        for (const decl of statement.declarationList.declarations) {
+            if (!decl.initializer) {
+                return { declarators, unfoldableReason: "exported destructured or uninitialized declaration is not foldable" };
+            }
+            if (ts.isIdentifier(decl.name)) {
+                if (ts.isNewExpression(decl.initializer)) {
+                    declarators.push({ kind: "resource", name: decl.name.text, node: decl.initializer });
+                }
+                else {
+                    declarators.push({ kind: "single", name: decl.name.text, node: decl.initializer });
+                }
+                continue;
+            }
+            if (ts.isObjectBindingPattern(decl.name)) {
+                const elements = [];
+                let allSupported = true;
+                for (const el of decl.name.elements) {
+                    const propKey = bindingElementPropKey(el);
+                    if (propKey === undefined) {
+                        allSupported = false;
+                        break;
+                    }
+                    elements.push({ propKey, bindingName: el.name.getText() });
+                }
+                if (!allSupported) {
+                    return { declarators, unfoldableReason: "exported destructured or uninitialized declaration is not foldable" };
+                }
+                declarators.push({ kind: "destructure", node: decl.initializer, elements });
+                continue;
+            }
+            // ArrayBindingPattern — not supported.
+            return { declarators, unfoldableReason: "exported destructured or uninitialized declaration is not foldable" };
+        }
+    }
+    return { declarators };
+}
+function collectLocalBindings(sourceFile) {
+    const bindings = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0)
+            continue;
+        for (const decl of statement.declarationList.declarations) {
+            if (!decl.initializer)
+                continue;
+            if (ts.isIdentifier(decl.name)) {
+                bindings.set(decl.name.text, { source: decl.initializer });
+            }
+            else if (ts.isObjectBindingPattern(decl.name)) {
+                for (const el of decl.name.elements) {
+                    const propKey = bindingElementPropKey(el);
+                    if (propKey === undefined)
+                        continue;
+                    bindings.set(el.name.getText(), { source: decl.initializer, propKey });
+                }
+            }
+            // ArrayBindingPattern locals: not indexed — a later reference to one
+            // of its names simply won't be found below, which correctly falls
+            // back (same as referencing any other unresolved identifier).
+        }
+    }
+    return bindings;
+}
+/** `(x) => …` / `function (x) {…}`, possibly wrapped in parens/`as`/`satisfies` — the initializer shapes that make a `const` a function binding. */
+/**
+ * chant #1373 — every top-level function a file declares, exported or not, as
+ * a {@link FoldableFunction}: `function f(...) {...}` and `const f = (...) =>
+ * …`. Placed in the file's own `externals` (so a same-file call folds, and a
+ * sibling function can call it) and exported under its name (so an importer's
+ * `buildExternals` can). The marker carries the file's scope BY REFERENCE:
+ * `ctx.externals` is still being filled (pre-built resources land in it after
+ * this runs) and a body reads it only when called.
+ *
+ * The marker's `consts` drops every `new`-bound const (transitively, through
+ * aliases) — see {@link FoldableFunction.consts} for why a body must reach a
+ * module-level resource through `externals` only.
+ */
+function collectLocalFunctions(sourceFile, ctx) {
+    // chant#2436 — the walk itself, and the `new`-bound stripping that makes it
+    // correct, live in ../fold/fold.ts so a unit-level fold with no externals of
+    // its own binds exactly what a build binds.
+    return collectSameFileFunctions(sourceFile, ctx.consts, ctx.file, ctx.externals, ctx.crossFileFailures);
+}
+/** Map every top-level `import`-bound local identifier to its source module + export name. */
+function collectImports(sourceFile) {
+    const named = new Map();
+    const namespaces = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement))
+            continue;
+        if (!ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const clause = statement.importClause;
+        if (!clause)
+            continue;
+        // A whole-statement `import type { ... } from "x"` is erased at runtime
+        // and never appears in expression position — indexing it would only
+        // ever manufacture a false cross-file dependency edge (taint, or worse,
+        // a phantom import-cycle) between files that share no real value
+        // dependency. Per-specifier `import { type Foo } from "x"` is filtered
+        // below, at the named-element level.
+        if (clause.isTypeOnly)
+            continue;
+        const specifier = statement.moduleSpecifier.text;
+        const specifierNode = statement.moduleSpecifier;
+        if (clause.name) {
+            named.set(clause.name.text, { specifier, imported: "default", specifierNode });
+        }
+        if (clause.namedBindings) {
+            if (ts.isNamedImports(clause.namedBindings)) {
+                for (const element of clause.namedBindings.elements) {
+                    if (element.isTypeOnly)
+                        continue;
+                    const imported = element.propertyName?.text ?? element.name.text;
+                    named.set(element.name.text, { specifier, imported, specifierNode });
+                }
+            }
+            else if (ts.isNamespaceImport(clause.namedBindings)) {
+                namespaces.set(clause.namedBindings.name.text, { specifier, specifierNode });
+            }
+        }
+    }
+    return { named, namespaces };
+}
+/**
+ * chant #1020 hang fix — best-effort fast path for resolving a BARE
+ * specifier by walking `node_modules` directly with the same primitives
+ * (`statSync`/`readFileSync`) the relative-specifier branch below already
+ * uses, reading `package.json`'s "exports"/"main" field by hand instead of
+ * calling `createRequire(fromFile).resolve(specifier)`. Returns `undefined`
+ * — never throws — when the package is not found, its `exports` map does not
+ * export the subpath under the `import`/`node`/`default` conditions, or a
+ * subpath of a package without `exports` has no `package.json` of its own:
+ * the caller then falls back to the slow, authoritative
+ * `createRequire().resolve()` path, so such a specifier is still resolved
+ * correctly, just not quickly.
+ *
+ * chant#3090 — subpaths (`pkg/sub/x`) and `exports` pattern keys
+ * (`"./sub/*"`) resolve here too, with condition objects read in key order
+ * as an ESM import reads them ({@link packageExportsTarget}). Before, a
+ * subpath always reached the `createRequire` fallback, whose CommonJS
+ * conditions miss an `import`-only target.
+ *
+ * Why this exists at all: profiling traced the hang to
+ * `createRequire(fromFile).resolve(specifier)` ITSELF taking upwards of a
+ * minute — and, worse, growing (measured 60s, then 69s, then 361s for
+ * successive NEW packages later in the same run) — inside a vitest worker,
+ * specifically for the FIRST resolution of a given bare specifier in the
+ * process (session-level and even process-wide-by-specifier caching, see
+ * {@link bareSpecifierPathCache}, only avoid paying that cost a SECOND
+ * time). The relative-specifier branch just below, using these exact same
+ * file-system primitives, never showed this slowdown anywhere
+ * in the same profiling — the cost is specific to Node's own
+ * `Module._resolveFilename` machinery, not to file-system access in
+ * general, so replacing just that one call with plain `statSync`/
+ * `readFileSync` sidesteps it entirely for the common case every
+ * `@intentius/chant*` package (and most well-formed npm packages) ships.
+ */
+function fastResolveBareSpecifier(specifier, fromFile) {
+    const parts = splitBareSpecifier(specifier);
+    if (parts === undefined)
+        return undefined;
+    let dir = dirname(fromFile);
+    for (;;) {
+        const packageDir = join(dir, "node_modules", parts.name);
+        if (existsSync(packageDir)) {
+            const resolved = fastResolvePackageEntry(packageDir, parts.subpath);
+            if (resolved === undefined || !isFile(resolved))
+                return undefined;
+            try {
+                return realpathSync(resolved);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined; // reached the filesystem root, unresolved
+        dir = parent;
+    }
+}
+/**
+ * The absolute file `<packageDir>/package.json` names for `subpath` (`"."` or
+ * `"./x"`), or `undefined` — see {@link fastResolveBareSpecifier}'s doc for
+ * which shapes this recognizes. With an `exports` field, that map decides.
+ * Without one, the root is `main` (or `index.js`), and a subpath is read as a
+ * nested package directory with its own `package.json`.
+ */
+function fastResolvePackageEntry(packageDir, subpath) {
+    const pkgJsonPath = join(packageDir, "package.json");
+    if (!existsSync(pkgJsonPath))
+        return undefined;
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof pkg !== "object" || pkg === null)
+        return undefined;
+    const exportsField = pkg.exports;
+    if (exportsField !== undefined) {
+        const target = packageExportsTarget(exportsField, subpath);
+        return target === undefined ? undefined : resolvePath(packageDir, target);
+    }
+    if (subpath !== ".")
+        return fastResolvePackageEntry(join(packageDir, subpath), ".");
+    const main = pkg.main;
+    if (main !== undefined)
+        return typeof main === "string" ? resolvePath(packageDir, main) : undefined;
+    return resolvePath(packageDir, "index.js");
+}
+/**
+ * chant#3090 — the file a tsconfig `paths` entry maps a bare `specifier` to,
+ * from the nearest `tsconfig.json` above `fromFile` ({@link tsconfigPathsTarget}),
+ * or `undefined`.
+ *
+ * chant's own package specifiers ({@link isChantOwnedSpecifier}) are never
+ * mapped. They resolve through `node_modules` to the modules the CLI has
+ * already loaded, which is what {@link isTrustedExecutableBinding} relies on,
+ * and a project's `paths` cannot point them at its own files. This repository's
+ * root tsconfig maps every chant package to its source, and those entries
+ * name the same files `node_modules` does.
+ *
+ * A specifier this maps is a project import ({@link isProjectImport}): it is
+ * folded as a project file and its trust is decided on the resolved path,
+ * even when its text names an active lexicon package.
+ */
+function pathsMappedTarget(specifier, fromFile) {
+    return pathsMatch(specifier, fromFile)?.target;
+}
+/** The tsconfig `paths` match behind {@link pathsMappedTarget}, including a match whose targets name no file. */
+function pathsMatch(specifier, fromFile) {
+    if (specifier.startsWith(".") || isAbsolute(specifier) || isChantOwnedSpecifier(specifier))
+        return undefined;
+    return tsconfigPathsMatch(specifier, fromFile);
+}
+/**
+ * Resolve an import specifier to an absolute module path, the way the
+ * declaring file's own `import` would — without depending on a TS-aware
+ * loader being active. Relative/absolute specifiers are probed against real
+ * TS/JS candidate files on disk ({@link probeModuleFile}, which maps `./x.js`
+ * to `./x.ts` as `tsc` does); a bare specifier a tsconfig `paths` entry maps
+ * resolves to that file ({@link pathsMappedTarget}); other bare package
+ * specifiers try {@link fastResolveBareSpecifier} first, falling back to
+ * Node's own CJS algorithm from the declaring file's location whenever that
+ * returns `undefined`.
+ */
+function resolveModulePath(specifier, fromFile) {
+    if (specifier.startsWith(".") || isAbsolute(specifier)) {
+        const base = specifier.startsWith(".") ? resolvePath(dirname(fromFile), specifier) : specifier;
+        // Nothing found on disk under any probed extension — hand back the bare
+        // base and let `import()` fail with its own, more specific error.
+        return probeModuleFile(base) ?? base;
+    }
+    const mapped = pathsMappedTarget(specifier, fromFile);
+    if (mapped !== undefined)
+        return mapped;
+    const fast = fastResolveBareSpecifier(specifier, fromFile);
+    if (fast !== undefined)
+        return fast;
+    return createRequire(fromFile).resolve(specifier);
+}
+/**
+ * chant #1064 — the one real published subpath a project imports chant's
+ * build-time-parameters module from. {@link buildExternals} matches a bare
+ * specifier against this by TEXT ONLY, never by resolving it — see that
+ * function's own comment for why resolving an arbitrary bare specifier here
+ * would reintroduce the exact pathological cold-resolution cost chant#1020
+ * already fixed once (this module's other comments measure it at up to
+ * ~361s for the first resolution of a genuinely new bare specifier).
+ */
+const PARAMS_BARE_SPECIFIER = "@intentius/chant/params";
+/**
+ * chant #1064 — the absolute path of chant-core's OWN build-time-parameters
+ * runtime module (../params.ts), resolved lazily on first use, from THIS
+ * file's own location, via the exact same relative-specifier resolution
+ * {@link resolveModulePath} already applies to project files — cheap
+ * (`existsSync`/`statSync` candidate probing only, never Node's package
+ * resolution). Used by {@link buildExternals} to recognize a RELATIVE/
+ * ABSOLUTE import of the params module (this module's own test fixtures use
+ * an absolute path, matching the rest of this file's test convention) — a
+ * real project's bare `@intentius/chant/params` import is instead matched by
+ * {@link PARAMS_BARE_SPECIFIER}'s text alone, never through this path.
+ *
+ * Lazy and failure-safe, NOT a module-scope constant: this module is also
+ * bundled into the #1045 sandbox child, where module-init code runs inside
+ * `--permission` with a read allowlist. There `import.meta.url` is the
+ * bundle's temp-dir path, so an init-time probe reaches for `<tmp>/params` —
+ * outside the allowlist — and the `existsSync` throws `ERR_ACCESS_DENIED`,
+ * killing the child before it reports (a real, observed sandbox-vs-run error
+ * drift across six corpus entries). The child runs only the run path and
+ * never calls {@link buildExternals}, so deferring the probe to first fold
+ * use keeps it out of the sandbox entirely; if probing still fails there,
+ * `null` just disables the relative-path recognition rather than erroring.
+ */
+let paramsModulePathMemo;
+function paramsModulePath() {
+    if (paramsModulePathMemo === undefined) {
+        try {
+            paramsModulePathMemo = resolveModulePath("../params", fileURLToPath(import.meta.url));
+        }
+        catch {
+            paramsModulePathMemo = null;
+        }
+    }
+    return paramsModulePathMemo;
+}
+/**
+ * chant #1063 — is `specifier` a bare import of a package that is an ACTIVE
+ * LEXICON of this build? Returns the specifier itself when so, `undefined`
+ * otherwise.
+ *
+ * Three deliberate restrictions, each of which is the point rather than an
+ * omission:
+ *
+ *  - **Text only, no resolution.** The answer is a `Set.has` on a set built
+ *    from the lexicon names the build ALREADY resolved before discovery ran
+ *    (`resolveProjectLexicons` -> `loadPlugins`). Nothing is probed, read, or
+ *    resolved to decide whether a specifier is in scope — so an import of
+ *    some unrelated package costs a string comparison and is then left alone,
+ *    never resolved "just to find out what it is". That matters here more
+ *    than anywhere: `resolveModulePath`'s bare branch can fall through to
+ *    `createRequire(fromFile).resolve(specifier)`, measured at up to ~361s
+ *    for the first resolution of a genuinely new bare specifier in a process
+ *    (see {@link bareSpecifierPathCache}/{@link fastResolveBareSpecifier} —
+ *    this exact class of cost regressed twice during chant#1020).
+ *
+ *  - **Exact package specifier, no subpaths.** `@intentius/chant-lexicon-aws`
+ *    matches; `@intentius/chant-lexicon-aws/actions` does not. Every lexicon
+ *    re-exports its whole public surface from its barrel and every example
+ *    imports it that way, so subpaths buy nothing — and they would cost
+ *    something real: {@link fastResolveBareSpecifier} only recognizes a
+ *    package ROOT (it looks for `<node_modules>/<specifier>/package.json`),
+ *    so a subpath specifier falls through to exactly the slow
+ *    `createRequire().resolve()` path this restriction exists to avoid.
+ *
+ *  - **Lexicons of THIS build only.** Not "any `@intentius/chant-lexicon-*`
+ *    package on disk", and emphatically not "any bare specifier". A lexicon
+ *    the build did not load is as out of scope as `node:fs`.
+ *
+ * chant #1995 — the "no subpaths" restriction above stays as documented for
+ * THIS function's caller ({@link resolveActiveLexiconExport}, #1063's
+ * data-export resolution): every lexicon's public data surface is reachable
+ * from the barrel, so a subpath buys that caller nothing and would cost the
+ * same cold-resolution risk. {@link isTrustedExecutableBinding} (#1093) asks a
+ * different question — not "does this specifier name a reachable data
+ * export" but "has the CLI already loaded this code" — and a project file
+ * reaching a lexicon's generated module by subpath instead of through the
+ * barrel is code the CLI already imported and executed either way, so that
+ * caller resolves a subpath's package root separately, via
+ * {@link bareSpecifierPackageRoot}, rather than widening this function.
+ */
+function activeLexiconPackage(specifier, lexiconPackages) {
+    return lexiconPackages.has(specifier) ? specifier : undefined;
+}
+/**
+ * chant#3090 — {@link activeLexiconPackage} for a specifier imported by
+ * `fromFile`: `undefined` as well when a tsconfig `paths` entry maps the
+ * specifier ({@link pathsMappedTarget}), because the import then names a
+ * project file, not the package the build loaded. Only a specifier whose text
+ * already matches pays the tsconfig lookup.
+ */
+function activeLexiconPackageImport(specifier, fromFile, lexiconPackages) {
+    if (activeLexiconPackage(specifier, lexiconPackages) === undefined)
+        return undefined;
+    return pathsMappedTarget(specifier, fromFile) === undefined ? specifier : undefined;
+}
+/**
+ * chant#2577 — the path-declared counterpart of {@link activeLexiconPackage}:
+ * the resolved module path when a relative or absolute `specifier` reaches
+ * one of this build's {@link FoldSession.lexiconModules}, `undefined`
+ * otherwise. A bare specifier is never resolved here, and a build with no
+ * path-declared lexicon resolves nothing.
+ */
+function activeLexiconModule(specifier, fromFile, lexiconModules, resolvePathCache) {
+    if (lexiconModules.size === 0 || !isProjectImport(specifier, fromFile))
+        return undefined;
+    let modulePath;
+    try {
+        modulePath = resolveModulePathMemoized(specifier, fromFile, resolvePathCache);
+    }
+    catch {
+        return undefined;
+    }
+    return lexiconModules.has(modulePath) ? modulePath : undefined;
+}
+/** chant#2590 — true when absolute `file` lies under absolute directory `dir`. */
+function isUnderDirectory(file, dir) {
+    return file.startsWith(dir.endsWith(sep) ? dir : dir + sep);
+}
+/** chant#2590 — true when `path` lies under one of the build's trusted path-lexicon directories. */
+function inPathLexiconRoot(path, roots) {
+    return roots.some((root) => isUnderDirectory(path, root));
+}
+/**
+ * chant #1995 — the package-ROOT portion of a bare subpath specifier
+ * (`@intentius/chant-lexicon-azure/generated/index` ->
+ * `@intentius/chant-lexicon-azure`), or `undefined` when `specifier` is a
+ * relative/absolute path, is already a bare root with no subpath, or is
+ * malformed (a lone `@scope` with nothing after it).
+ *
+ * Text only, no resolution — the same discipline {@link activeLexiconPackage}
+ * documents and for the identical reason: resolving an arbitrary bare
+ * specifier to find out what package it belongs to is the pathological cold
+ * `require.resolve` chant#1020 measured. A scoped package (`@scope/name`)
+ * reserves its first two `/`-separated segments for the root; an unscoped
+ * package (`name`) reserves one.
+ */
+function bareSpecifierPackageRoot(specifier) {
+    if (specifier.startsWith(".") || isAbsolute(specifier))
+        return undefined;
+    const segments = specifier.split("/");
+    if (specifier.startsWith("@")) {
+        return segments.length > 2 ? `${segments[0]}/${segments[1]}` : undefined;
+    }
+    return segments.length > 1 ? segments[0] : undefined;
+}
+/**
+ * chant #1063 — resolve one named import binding against an active lexicon
+ * package's REAL exports, for {@link buildExternals}.
+ *
+ * The lexicon module is imported (through the session-wide
+ * {@link FoldSession.importCache}, so at most one real `import()` per package
+ * per build) and the requested export read straight off it. That is the same
+ * module object the run path gets — `importModule` is a plain dynamic
+ * `import()` with no cache-busting — so what fold captures here is not a
+ * reconstruction of the lexicon's data but the identical value, down to
+ * object identity for `Azure.ResourceGroupLocation`-style singletons. It is
+ * also the same two-step (resolve path, then import) that
+ * `resolveImportedExport` has always used to reach a lexicon's constructors
+ * and intrinsic functions; the only thing new is that a plain DATA export is
+ * now reachable too.
+ *
+ * Callable exports are otherwise excluded. A lexicon's functions — its
+ * resource classes, composite factories, intrinsic implementations — already
+ * have dedicated resolution paths that know how to INVOKE them
+ * (`resolveResourceEntity`, `resolveCallExpression`, `reviveFoldedValue`), and
+ * binding an arbitrary one as a plain identifier value here would widen what
+ * folds in unmeasured ways. The one exception (chant #1966) is a function its
+ * lexicon registered with {@link IntrinsicDef.foldsEagerly} — the same
+ * per-name, lexicon-declared opt-in `foldsAsCall` is for an intrinsic's
+ * envelope-and-revive form, admitting this one because `fold()`
+ * (../fold/fold.ts) needs to CALL it eagerly — synchronously, before
+ * revival — to support a lexicon's own string-building helpers used inline
+ * (`matrix("os").toString()`, `` `${inputs("x")}` ``), where an envelope
+ * would still be a plain object when the enclosing template folds.
+ *
+ * Returns `undefined` — never throws — for a package that isn't an active
+ * lexicon, an export the package doesn't have, a non-admitted callable
+ * export, or an import that fails. The binding is then simply absent from
+ * `externals`, exactly as before, and `fold()`'s ordinary "unresolved
+ * identifier" failure still fires if the name is actually referenced.
+ */
+async function resolveActiveLexiconExport(binding, fromFile, session) {
+    let modulePath;
+    if (activeLexiconPackageImport(binding.specifier, fromFile, session.lexiconPackages)) {
+        try {
+            modulePath = resolveModulePathMemoized(binding.specifier, fromFile, session.resolvePathCache);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    else {
+        // chant#2577 — a lexicon declared by path, imported by its path.
+        modulePath = activeLexiconModule(binding.specifier, fromFile, session.lexiconModules, session.resolvePathCache);
+        if (modulePath === undefined)
+            return undefined;
+    }
+    let mod;
+    try {
+        mod = await importModuleMemoized(modulePath, session.importCache);
+    }
+    catch {
+        return undefined;
+    }
+    if (!(binding.imported in mod))
+        return undefined;
+    const value = mod[binding.imported];
+    if (typeof value === "function") {
+        const eager = session.intrinsics.some((i) => i.name === binding.imported && intrinsicCallFoldsEagerly(i));
+        if (!eager)
+            return undefined;
+    }
+    return { value };
+}
+/**
+ * chant#3247 — a plain data export of a lexicon package's own module, read off
+ * the real module (see the package-root branch of {@link buildExternals}).
+ * `undefined` for a missing export, a callable one, or a module that does not
+ * import.
+ */
+async function packageDataExport(modulePath, name, session) {
+    let mod;
+    try {
+        mod = await importModuleMemoized(modulePath, session.importCache);
+    }
+    catch {
+        return undefined;
+    }
+    if (!(name in mod) || typeof mod[name] === "function")
+        return undefined;
+    return { value: mod[name] };
+}
+function resolveMemoized(node, ctx) {
+    const cached = ctx.memo.get(node);
+    if (cached)
+        return cached;
+    const promise = resolveLiveValue(node, ctx);
+    ctx.memo.set(node, promise);
+    return promise;
+}
+/**
+ * Attempt to resolve `node` to the real runtime value it would have if the
+ * file were executed. Understands the "spine" of composite consumption: a
+ * bare call (a composite factory, or a wrapper like `propagate()` — resolved
+ * through this file's imports, invoked for real with statically-folded
+ * arguments), a reference to an earlier top-level `const` bound to one of
+ * those (memoized — see {@link ResolveCtx.memo}), and dotted property access
+ * or `!` non-null assertion on the result (`web.deployment`, `web.pdb!`).
+ *
+ * Throws when the shape IS recognized (a call, a member access) but
+ * resolution genuinely fails — unresolved import, non-function import,
+ * folding a nested argument failed, member access on a non-composite value,
+ * the call itself threw. That failure should fall back the whole file to
+ * run, same as any other fold gap.
+ */
+async function resolveLiveValue(node, ctx) {
+    if (ts.isParenthesizedExpression(node) ||
+        ts.isNonNullExpression(node) ||
+        ts.isAsExpression(node) ||
+        ts.isSatisfiesExpression(node)) {
+        return resolveLiveValue(node.expression, ctx);
+    }
+    if (ts.isIdentifier(node)) {
+        const binding = ctx.locals.get(node.text);
+        if (!binding) {
+            // chant #1020 — not a same-file local; try a cross-file resolution
+            // (a plain value, or the real live Declarable/CompositeInstance a
+            // sibling file's own fold produced, or a namespace import's synthetic
+            // exports object). Absent from `externals` falls through to
+            // `undefined`, exactly the pre-#1020 behavior for any unbound name.
+            if (ctx.externals.has(node.text)) {
+                const external = ctx.externals.get(node.text);
+                // chant #1373 — a function marker is callable, never a value. The
+                // export-by-name cases (`export const g = f`, `export { f }`) are
+                // handled by the declarator loop before it gets here.
+                if (isFoldableFunction(external)) {
+                    throw cheapError(`function "${node.text}" used as a value is not foldable`);
+                }
+                return { value: external };
+            }
+            return undefined;
+        }
+        const resolvedSource = await resolveMemoized(binding.source, ctx);
+        if (resolvedSource === undefined)
+            return undefined;
+        if (binding.propKey === undefined)
+            return resolvedSource;
+        if (!isIndexableObject(resolvedSource.value)) {
+            throw cheapError(`destructured member "${binding.propKey}" is not on a composite value`);
+        }
+        return { value: resolvedSource.value[binding.propKey] };
+    }
+    if (ts.isCallExpression(node)) {
+        return { value: await resolveCallExpression(node, ctx) };
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        const base = await resolveLiveValue(node.expression, ctx);
+        if (base === undefined)
+            return undefined;
+        const key = node.name.text;
+        if (!isIndexableObject(base.value)) {
+            throw cheapError(`property access ".${key}" on a non-composite value is not foldable`);
+        }
+        return { value: base.value[key] };
+    }
+    return undefined;
+}
+/**
+ * Resolve a bare call expression — a composite factory call
+ * (`SomeComposite({...})`) or a wrapper that takes a composite instance and
+ * returns one (`propagate(SomeComposite({...}), {...})`). The callee must be
+ * a plain identifier bound by this file's own `import` (a namespace-import
+ * call like `ns.Foo(...)`, or a call to a function/composite DEFINED in this
+ * same file, can't be resolved without running the file — falls back, same
+ * as an unresolvable resource constructor).
+ *
+ * Two ways to get the value, tried in that order:
+ *
+ * 1. **Interpretation** (chant #1023) — the callee is an interpretable
+ *    registered `Composite` defined in a PROJECT file, so its body is
+ *    evaluated statically and nothing is imported or run. See
+ *    {@link resolveInterpretableFactory} for the exact admissible subset.
+ * 2. **Invocation** (chant #1022) — everything else. Each argument is
+ *    resolved (recursively, for a nested composite-call/member-access
+ *    argument like `propagate`'s first one) or folded (for a plain props
+ *    object literal via {@link fold}), the real function is imported and
+ *    invoked, and the RESULT is what matters to the caller —
+ *    {@link resolveLiveValue}'s callers decide what shape they need (a
+ *    `CompositeInstance` for member access, an
+ *    `isDeclarable`/`isCompositeInstance` value for a top-level export).
+ *    No pre-check verifies the resolved callee is "really" a composite.
+ *
+ * Arm 2 is untouched by #1023, including for a factory arm 1 STARTED and then
+ * declined on: interpretation is all-or-nothing per call, and a decline is not
+ * a fold failure — it lands exactly where the code landed before this existed.
+ */
+async function resolveCallExpression(node, ctx) {
+    // chant #1054 — reuses ../fold/subset's `callExpressionMessage` (the SAME
+    // builder `fold()` throws with for a call used as a prop value) rather
+    // than a hand-written "call expression as a value" copy: the two used to
+    // say different things for the identical rejection, which silently broke
+    // any tooling grouping fallback reasons by text.
+    if (!ts.isIdentifier(node.expression)) {
+        throw cheapError(callExpressionMessage(node));
+    }
+    const calleeName = node.expression.text;
+    const binding = ctx.imports.get(calleeName);
+    // chant #1373 — a project-local function with a foldable body (declared in
+    // this file, or imported from a sibling project file) is evaluated
+    // statically, through the same `fold()` branch a NESTED call to it takes.
+    // When its body turns out not to fold, an IMPORTED callee still has the
+    // pre-#1373 path below (interpret as a composite, else import and invoke) —
+    // a helper that wraps a composite call, say, keeps folding by invocation
+    // exactly as it did. A same-file callee has nothing to invoke without
+    // running the file, so the fold diagnostic is the verdict.
+    const local = ctx.externals.get(calleeName);
+    if (isFoldableFunction(local)) {
+        let foldFailure;
+        try {
+            const folded = fold(node, ctx.consts, ctx.intrinsics, ctx.externals);
+            return await reviveFoldedValue(folded, ctx, false);
+        }
+        catch (err) {
+            if (!(err instanceof Error))
+                throw err;
+            foldFailure = err;
+        }
+        // chant#2453 — a DECLARED function is judged by its body, and that is the
+        // whole answer. There is no invocation arm here any more.
+        //
+        // There used to be: when the body did not fold, an imported callee was
+        // imported and invoked instead. chant#2441 narrowed that to stop it
+        // rescuing a depth refusal. The external corpus then showed what the rest
+        // of it does, in a project nobody here maintains
+        // (jhgaylor/infisical-chant, INTENTIUS/typescript-as-data#129):
+        //
+        //     export const namingParams = namingParamsFromEnv();
+        //
+        // whose body reads `process.env`. `F-Eval-Ident` step 4 rejects `process`,
+        // so the body does not fold — and chant imported the module and ran it,
+        // folding the file to whatever the FOLDING PROCESS's environment held. The
+        // file reported `fold`, which reads as "determined statically". Two people
+        // folding the same source got different output and nothing said so.
+        //
+        // That is wrong in chant's own terms before it is wrong in J1's: `--fold`
+        // is the value you would get by running, WITHOUT running, and this ran. So
+        // the rejection propagates and the file runs, carrying the reason
+        // `F-Eval-CallLocal` gives.
+        //
+        // `F-Call` step 6's invocation is for a binding that is neither a declared
+        // function nor an interpretable composite, and it still happens — below,
+        // in the arm this one is not. A composite factory is not a
+        // `FoldableFunction`, so `resolveImportedCall` still interprets it and
+        // still invokes it when interpretation declines.
+        //
+        // chant#2455 — unless the caller asked for `ι = executing` (spec 1.8),
+        // which is this behaviour as a MODE rather than as a silent default. The
+        // value is then what a run would compute in this process, environment and
+        // all, which is exactly why it cannot be implicit.
+        if (ctx.executing && binding) {
+            try {
+                return await resolveImportedCall(node, calleeName, binding, ctx);
+            }
+            catch (err) {
+                throw cheapError(`${foldFailure.message}; invoking it instead failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Name the mode that would have folded it, so the reason is actionable
+        // rather than only correct. Not under `sandbox`, where `executing` is not
+        // an option the caller could take.
+        if (binding && !ctx.sandbox) {
+            throw cheapError(`${foldFailure.message} (the default mode does not invoke a declared project function; ` +
+                "`executing` would run it and fold what it returns)");
+        }
+        throw foldFailure;
+    }
+    if (!binding) {
+        throw cheapError(callExpressionMessage(node));
+    }
+    return resolveImportedCall(node, calleeName, binding, ctx);
+}
+/** The pre-#1373 two-arm resolution of an IMPORTED callee — see {@link resolveCallExpression}. */
+async function resolveImportedCall(node, calleeName, binding, ctx) {
+    // chant #1023 — is this callee a composite whose body can be INTERPRETED
+    // rather than run? Purely a static question (does the defining module parse,
+    // does it declare this export as `Composite(<fn>, "<name>")`, is `<fn>`'s
+    // body inside the admissible subset) — no argument has been evaluated yet
+    // and nothing has been imported, so a `undefined` here has cost nothing and
+    // changed nothing.
+    const factory = await resolveInterpretableFactory(binding, ctx);
+    if (factory) {
+        const args = await resolveCallArguments(node, calleeName, 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
+        // --sandbox refuses). Fall through to arm 2 with the arguments ALREADY
+        // evaluated, so a nested composite-call argument is not built twice.
+        return invokeImportedCallee(node, calleeName, binding, ctx, args);
+    }
+    return invokeImportedCallee(node, calleeName, binding, ctx);
+}
+/**
+ * Arm 2 — import the module the callee came from and call it, in this
+ * process, given ALREADY-RESOLVED argument values. Factored out of
+ * {@link invokeImportedCallee} (chant #1174) so a caller with no raw
+ * `ts.CallExpression` node — {@link resolveCompositeCall}, the nested-value
+ * counterpart to {@link resolveCallExpression} — can reach the identical
+ * refusal/resolve/import/callable-check/call sequence #1022 established,
+ * without inventing a second copy of it.
+ */
+async function invokeResolvedCallee(calleeName, binding, ctx, args) {
+    // chant #1093 — THE gap this check exists for. Invoking the callee runs
+    // project code (the factory body, and its whole module's top level) in the
+    // CLI's own process; under --sandbox that has to happen in the child
+    // instead, so refuse here and let the file fall back to the sandboxed run
+    // path. See {@link sandboxedExecutionRefusal}.
+    const refusal = sandboxedExecutionRefusal(binding, ctx, calleeName, "composite factory");
+    if (refusal)
+        throw cheapError(refusal);
+    // spec 2.0, `F-Call` step 5 — a callee that resolves to a PROJECT FILE is
+    // not imported and invoked here. Invoking it runs the factory body, and its
+    // whole module's top level, in the CLI's own process, and that is the
+    // project's own code rather than a package's.
+    //
+    // Step 2's project-owned invocation moved behind `ι = executing` at v0.72.3
+    // (chant#2455). Step 6 is the same path and had not moved, which is the
+    // whole of this change. The specification took the decision first: its
+    // rationale says of `executing` that "it is never the default", and
+    // `verdict.md` calls `open` the strict default.
+    //
+    // A package factory still runs here, which is what `F-Host-Admission`
+    // governs. A project-file callee that a `Composite` registered is
+    // INTERPRETED at step 4 and never reaches this line; only one that
+    // interpretation declined does, and for that the verdict is `run`. Since
+    // chant#3247 a package's registered composite is interpreted at step 4 too,
+    // and reaches this line only when interpretation declined; it is a
+    // package's code, so it is still invoked.
+    // "Project file" is the specifier's ORIGIN, not its syntax.
+    // {@link isProjectFileSpecifier} is true of any absolute path, and chant's
+    // own modules are imported by absolute path throughout the tests, so the
+    // shape test alone refuses `propagate` and every other host function chant
+    // publishes. {@link isTrustedExecutableBinding} draws the line the rule
+    // means: an active lexicon package or chant-core's own tree is a package's
+    // code, and everything else reached by a relative or absolute specifier is
+    // the project's.
+    if (!ctx.executing && isProjectImport(binding.specifier, ctx.file) && !isTrustedExecutableBinding(binding, ctx)) {
+        throw cheapError(`"${calleeName}" is imported from "${binding.specifier}", which is a project file; ` +
+            "the default mode does not invoke project-owned code (`executing` would run it and fold what it returns)");
+    }
+    let modulePath;
+    try {
+        modulePath = resolveModulePathMemoized(binding.specifier, ctx.file, ctx.resolvePathCache);
+    }
+    catch (err) {
+        throw cheapError(`could not resolve import "${binding.specifier}" for "${calleeName}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Reuses the SAME import mechanism the run path uses ({@link importModule},
+    // ../discovery/import.ts — a plain-path `import()`) rather than a
+    // `pathToFileURL(...)`-wrapped one. For a resource constructor (a
+    // stateless lexicon class) the two would be interchangeable, but a
+    // composite-call resolution (#1023) can import a SIBLING PROJECT FILE
+    // (e.g. `import { network } from "./network"`, not just a lexicon
+    // package) that `discover()`'s own per-file loop ALSO independently
+    // processes — if that file falls back to run and imports the same
+    // sibling for a live value (`network.vpc.VpcId`), the two import calls
+    // MUST resolve to the identical cached module instance, or the run side
+    // ends up with a second, distinct `network`/`vpc` object whose AttrRefs
+    // can never be matched back to the entity fold already registered
+    // (`Cannot serialize AttrRef ...: logical name not set`).
+    let mod;
+    try {
+        mod = await importModuleMemoized(modulePath, ctx.importCache);
+    }
+    catch (err) {
+        throw cheapError(`could not import "${binding.specifier}" to resolve "${calleeName}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const Fn = mod[binding.imported];
+    if (typeof Fn !== "function") {
+        throw cheapError(`"${binding.imported}" from "${binding.specifier}" is not a function`);
+    }
+    executionCounts.factoryInvocations += 1;
+    // chant#3247 — a relative import inside a lexicon package's own composite is
+    // the package's code, not the project's.
+    const packageInternal = ctx.packageRoot !== undefined && isUnderDirectory(modulePath, ctx.packageRoot);
+    if (isProjectImport(binding.specifier, ctx.file) && !packageInternal)
+        executionCounts.projectFactoryInvocations += 1;
+    const result = Fn(...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.compositeName;
+    if (typeof compositeName === "string" && isIndexableObject(result) && !isCompositeInstance(result)) {
+        markHostCompositeInstance(result, compositeName);
+    }
+    return result;
+}
+/**
+ * Arm 2's original entry point — a raw call-expression node in hand. Resolves
+ * arguments (unless the caller already has them) and delegates to
+ * {@link invokeResolvedCallee}. Unchanged from #1022 in both behavior and
+ * ORDER (refusal, resolve, import, callable check, arguments, call); #1023
+ * factored the body out once already, #1174 a second time.
+ *
+ * @param args - Already-evaluated arguments, when the caller has them.
+ */
+async function invokeImportedCallee(node, calleeName, binding, ctx, args) {
+    const callArgs = args ?? (await resolveCallArguments(node, calleeName, ctx));
+    return invokeResolvedCallee(calleeName, binding, ctx, callArgs);
+}
+/**
+ * Resolve a composite-factory call used as a NESTED value — chant #1174's
+ * `<Identifier>(...).step` idiom ({@link FoldedCompositeStepCall}) — given
+ * its callee NAME and already-REVIVED argument values. The nested-value
+ * counterpart to {@link resolveCallExpression}, which the top-level
+ * declarator path (`export const x = Checkout({...})`) already used: the
+ * raw `ts.CallExpression` node isn't needed here because
+ * {@link resolveInterpretableFactory} only needs the import `binding`, and
+ * {@link interpretCompositeFactory}/{@link invokeResolvedCallee} only need
+ * the resolved argument values — which `fold()`'s envelope already folded
+ * and {@link reviveFoldedValue} has already revived by the time this runs.
+ *
+ * Same two arms, same order, as the top-level path: interpret a registered
+ * `Composite` (chant #1023; a lexicon package's own since chant#3247) when its
+ * body qualifies, otherwise import and invoke for real — the arm a
+ * lexicon-package composite whose body leaves the subset (`Checkout`,
+ * `SetupNode`, …) takes, exactly as it does for a top-level
+ * `export const x = Checkout({...})`. An unbound
+ * callee name throws the same "function call as a value" message `fold()`
+ * itself would have, for a caller with no `FoldedCompositeStepCall` special
+ * case to fall into.
+ */
+async function resolveCompositeCall(calleeName, args, ctx) {
+    const binding = ctx.imports.get(calleeName);
+    if (!binding)
+        throw cheapError(`unresolved identifier: ${calleeName}`);
+    const factory = await resolveInterpretableFactory(binding, ctx);
+    if (factory) {
+        const interpreted = await interpretCompositeFactory(factory, args, ctx);
+        if (interpreted)
+            return interpreted.value;
+        // Declined — falls through to arm 2 with the SAME arguments, so a nested
+        // composite-call argument (or a live cross-file reference) is not
+        // resolved a second time. Identical discipline to `resolveImportedCall`.
+    }
+    return invokeResolvedCallee(calleeName, binding, ctx, args);
+}
+/**
+ * Resolve a call's arguments to the real values the callee would receive —
+ * factored out of {@link resolveCallExpression} (chant #1023) so the
+ * interpretation and invocation arms consume ONE evaluation of them. Anything
+ * else would evaluate a nested composite-call argument twice and hand the
+ * callee the second instance while the first was already wired into an
+ * `AttrRef`.
+ *
+ * chant #1112 — ONE rule for a registered authoring helper's arguments,
+ * applied at BOTH sites that can invoke one. `reviveHelperCall` (the
+ * nested-value site, #1082) already revives a helper's arguments with
+ * `requireLiveRefs`, because a helper reads THROUGH its ref (`output()`
+ * derefs the `WeakRef` parent) and a look-alike `{__attrRef}` envelope
+ * makes it produce a wrong result rather than none. This site — a
+ * top-level `export const oArn = output(bucket.Arn, "oArn")` — took the
+ * composite-factory rule (`false`) instead, which is right for a factory
+ * (its props keep the envelope, and the serializer's own walker resolves
+ * it) and wrong for a helper. It went unnoticed while the resulting
+ * `LexiconOutput` was being discarded anyway; with the export namespace
+ * now collected in full, a same-file `output(...)` would reach the
+ * serializer holding an inert envelope where the run path has a real
+ * reference. Rejected here instead, which falls the file back to run —
+ * absent output, never a wrong one.
+ */
+async function resolveCallArguments(node, calleeName, ctx) {
+    const helperArgs = isFoldableHelperName(calleeName);
+    const args = [];
+    for (const argNode of node.arguments) {
+        const live = await resolveLiveValue(argNode, ctx);
+        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;
+}
+/**
+ * chant#3325 — a composite call's props can name a same-file `const` bound to
+ * another call (`left: notes.table`, with `export const notes =
+ * TenantTable({...})` earlier in the file). `fold()` cannot answer that name:
+ * it is synchronous, and the value is a composite instance only the live spine
+ * builds. So before the argument folds, each such name it mentions is resolved
+ * through {@link resolveMemoized}, the same promise the declarator and every
+ * other reference to it share, and the instance goes into `externals`, where
+ * `fold()`'s identifier branch reads it as it reads a pre-built `new` or tag
+ * const (#1169, #3196).
+ *
+ * Only a call `fold()` has no case for qualifies: an imported callee that is
+ * neither a registered authoring helper nor a registered intrinsic. For
+ * anything else the name is left alone and folds exactly as before. A
+ * 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, ctx) {
+    const names = new Set();
+    const visit = (n) => {
+        if (ts.isIdentifier(n)) {
+            if (isUnfoldableSameFileCall(n.text, ctx))
+                names.add(n.text);
+            return;
+        }
+        if (ts.isFunctionLike(n) || ts.isTypeNode(n))
+            return;
+        if (ts.isPropertyAccessExpression(n))
+            return visit(n.expression);
+        if (ts.isPropertyAssignment(n)) {
+            if (ts.isComputedPropertyName(n.name))
+                visit(n.name);
+            return visit(n.initializer);
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(node);
+    const bound = [];
+    for (const name of names) {
+        let resolved;
+        try {
+            resolved = await resolveMemoized(ctx.locals.get(name).source, ctx);
+        }
+        catch {
+            continue;
+        }
+        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. */
+function isUnfoldableSameFileCall(name, ctx) {
+    if (ctx.externals.has(name))
+        return false;
+    const binding = ctx.locals.get(name);
+    if (!binding || binding.propKey !== undefined || ctx.consts.get(name) !== binding.source)
+        return false;
+    const source = binding.source;
+    if (!ts.isCallExpression(source) || !ts.isIdentifier(source.expression))
+        return false;
+    const callee = source.expression.text;
+    return (ctx.imports.has(callee) &&
+        !isFoldableHelperName(callee) &&
+        !ctx.intrinsics.some((i) => i.name === callee) &&
+        !isFoldableFunction(ctx.externals.get(callee)));
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Composite factory interpretation (chant #1023, epic #1019 Phase 5).
+//
+// THE CONTRACT — the admissible factory subset, in ../fold/subset.ts's style.
+//
+// A composite is a factory function, and #1022 got its value the only way it
+// could: by importing the defining module and CALLING it. That is the last
+// place `chant build --fold` executes project-authored code in the CLI's own
+// process (chant #1093), and the reason `--sandbox` has to demote such a file
+// to the sandboxed child instead of folding it (chant #1111). This section
+// removes the call for the factories whose bodies can be evaluated instead.
+//
+// A call is interpreted when ALL of the following hold. Every one of them is
+// checked BEFORE any argument is evaluated or anything is constructed, so a
+// factory outside the subset costs a parse and nothing else:
+//
+//  1. **The callee is bound by an `import` from a PROJECT FILE** (a
+//     relative/absolute specifier, or one a tsconfig `paths` entry maps), **or
+//     from an ACTIVE LEXICON PACKAGE of this build whose module is TypeScript
+//     source** (chant#3247). The package case is matched by text first — the
+//     specifier, or its package root for a subpath, against
+//     {@link FoldSession.lexiconPackages}, exactly as
+//     {@link isTrustedExecutableBinding}'s arm 1 matches it — and only then
+//     resolved; a module that resolves to compiled JavaScript or a declaration
+//     file is not interpreted, so a package that ships only `dist` keeps
+//     invoking. Every chant lexicon routes its exports at `./src/*.ts`
+//     (check-lexicon tier 1), so in practice the source is always there.
+//     Interpreting buys provenance: the run path cannot say which parameter
+//     fed a field, and interpretation can (#2161, #3246).
+//
+//     The trust boundary does not move. A package's composite is interpreted
+//     with that PACKAGE's directory ({@link FactoryModuleScope.packageRoot})
+//     as a trusted lexicon root for the length of its body and nothing else:
+//     the package's own relative imports are trusted under `--sandbox` the way
+//     a subpath of the same package already is, and they are never folded as
+//     project files. The package was imported and run by `loadPlugins` before
+//     discovery began, and every module of it is reachable as a subpath, so
+//     reading its source adds no trust. What it may NOT do is reach outside
+//     that directory: a relative import that leaves the package root is not
+//     followed. A lexicon this build did not load stays as out of scope as
+//     any other bare specifier.
+//  2. **The defining module declares that export as `Composite(<fn>, "<name>")`**
+//     — a top-level `export const <name> = Composite(...)`, where `Composite`
+//     is bound in THAT module to an import of chant's own
+//     ({@link isChantOwnedHelperBinding}, the same provenance question #1082
+//     asks of an authoring helper, and the same answer). This is #1023's
+//     "recognize the callee is a registered Composite": a bare call to
+//     anything else — a project helper function, a `withDefaults(...)`
+//     wrapper, an `import`-then-`export` alias — is not recognized and is not
+//     interpreted. The defining module may sit behind BARREL re-exports
+//     (chant#3247): `export { X } from "./x"`, `export { Y as X } from "./x"`
+//     and `export * from "./x"` are followed, relative specifiers only, at most
+//     {@link MAX_REEXPORT_HOPS} deep, and never out of a package's root. A
+//     module that declares the name itself is answered by that declaration.
+//  3. **`<fn>` is an arrow/function expression taking at most one parameter**,
+//     bound as a plain identifier or a simple object binding pattern (no
+//     default, rest, or nested pattern).
+//  4. **Its body is a single expression, or a block of `const` declarations
+//     followed by one `return`** — and nothing else. No `if`, no `throw`, no
+//     loop, no `let`/`var`, no nested function declaration, no bare expression
+//     statement. This is the line a project's hand-rolled composite modules
+//     fall outside (module-level `buildXxx()` helpers with `if`/`throw` and
+//     `.map()`), and they are meant to: they keep invoking, exactly as before.
+//  5. **Every expression in it is inside the fold subset, extended with the
+//     two things a factory body exists to do**: `new Type(...)` in ANY value
+//     position (a member, a nested property object, an array element), and a
+//     call through a bare identifier. Both are shape-admissible here and
+//     resolution-checked at evaluation, the same permissive-shape /
+//     strict-evaluation split ../fold/subset.ts documents for identifier
+//     binding and helper provenance.
+//
+// Everything else is out: a computed key, a method call (`naming.name(...)` —
+// the callee is a property access, not an identifier), an array method, an
+// operator `fold()` doesn't implement, `await`, a class expression, a template
+// with a computed tag.
+//
+// WHY THIS IS NOT IN ../fold/subset.ts. That module is the shared, shape-only
+// predicate `fold()` and EVL both read, and its own contract is that it may
+// only ever be PERMISSIVE relative to `fold()`, never stricter. Admissibility
+// here is not a shape question at all: rules 1 and 2 need the module graph —
+// which file a name came from, and what that file declares — exactly like
+// #1082's authoring-helper provenance, which subset.ts documents (point 2b)
+// as deliberately out for the same reason. Putting rules 3-5 there alone would
+// describe a subset no caller could act on without also answering 1 and 2, and
+// putting all five there would mean teaching a syntax-only lint rule to
+// resolve imports. The shape half stays checkable by anything that wants it —
+// {@link findFactorySubsetViolation} takes a lone `ts` node — but the shared
+// predicate is not made stricter, or wider, by this issue.
+//
+// WHAT IS PRESERVED. Interpretation is not a second construction path:
+//
+//  - **The instances are real, and made by the lexicon's own constructors.**
+//    A `new Role({...})` in the body resolves `Role` through the DEFINING
+//    module's imports and calls that class, the same class the run path would
+//    have called from the same resolved module path.
+//  - **Sibling references are live, not symbolic.** `role.Arn` reads the
+//    attribute off the `Role` instance this interpretation just built, so it
+//    is a genuine `AttrRef` wired to a genuine parent — identical to running
+//    the factory, and strictly better than a top-level fold's `{__attrRef}`
+//    envelope (an intrinsic that inspects its argument, `Sub`/`Ref`, gets what
+//    it expects here).
+//  - **The instance is assembled by `Composite()` itself.** The members go
+//    back through chant's own {@link Composite} (../composite.ts) rather than
+//    through a hand-built look-alike, so member validation, the non-enumerable
+//    `members`/`_definition` layout `propagate()` and `expandComposite()`
+//    depend on, and provenance stamping are the run path's, by construction
+//    and not by resemblance.
+//  - **`propagate()` still works, untouched.** It is a chant-owned import, so
+//    `propagate(SomeComposite({...}), {...})` invokes the real `propagate` on
+//    the interpreted instance and mutates it in place exactly as it does a run
+//    one — which is why instance identity has to be a real `CompositeInstance`
+//    and not a copy (chant #1097).
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * A backstop for a composite that calls itself, directly or through a member.
+ * {@link FoldSession.stack} cannot see it — the recursion happens entirely
+ * inside one module's source, crossing no file boundary — so this is what
+ * terminates it. Deliberately small: real composite nesting is 2-3 deep, and a
+ * chain past this is a bug, not a design.
+ *
+ * Exhausting it falls the file back to run, naming this bound (#2370). That is
+ * the second half of the specification's `F-Depth`: an implementation states
+ * its bounds and, on exhaustion, falls back rather than fails. The other two —
+ * {@link MAX_RESOLUTION_DEPTH} and `fold()`'s `MAX_FUNCTION_CALL_DEPTH` —
+ * already did.
+ *
+ * It previously returned `undefined` here, which
+ * {@link resolveInterpretableFactory}'s contract defines as "not
+ * interpretable", so the caller invoked the factory instead and the file was
+ * still reported as folded. That conflated two different facts: a factory
+ * whose shape is outside the subset (invoking it is correct) and a factory we
+ * stopped looking at (invoking it is a different evaluation than the one being
+ * reported). The first is a verdict; the second was a silent degradation, and
+ * a reader comparing chant's output against the reference implementation's
+ * "fell back at depth 16" had nothing to explain the difference.
+ */
+const MAX_INTERPRETATION_DEPTH = 16;
+/**
+ * Exhaustion of {@link MAX_INTERPRETATION_DEPTH}, as its own type so it can
+ * pass through {@link interpretCompositeFactory}'s decline.
+ *
+ * That decline — a blanket `catch { return undefined }` — is right for every
+ * other failure inside a factory body: the body turned out not to interpret,
+ * the caller invokes it instead, and the file still folds. It is wrong for
+ * this one, because giving up at a depth bound is not a statement about the
+ * body. Without a type to test, the depth error was caught by the *enclosing*
+ * interpretation, declined, and the factory invoked — which is how the bound
+ * came to be silent (#2370).
+ */
+class InterpretationDepthError extends FoldError {
+}
+/**
+ * Parse a composite-defining module into its static scope, memoized per build.
+ * Returns `undefined` when the file can't be read or parsed — a decline, never
+ * a throw: the caller falls through to the invocation arm, which will produce
+ * its own (identical, pre-#1023) error if the module is genuinely broken.
+ *
+ * Reads and parses only. Nothing is imported, nothing is executed, and the
+ * module's own imports are not resolved yet — see
+ * {@link FactoryModuleScope.resolved}.
+ */
+function readFactoryModule(modulePath, packageRoot, session) {
+    // chant#3247 — keyed by the package root as well: the same file read as a
+    // project file and as package code resolves its imports differently.
+    const key = packageRoot === undefined ? modulePath : `${packageRoot}\0${modulePath}`;
+    const cached = session.factoryModules.get(key);
+    if (cached)
+        return cached;
+    const promise = readFactoryModuleCore(modulePath, packageRoot);
+    session.factoryModules.set(key, promise);
+    return promise;
+}
+async function readFactoryModuleCore(modulePath, packageRoot) {
+    let sourceFile;
+    try {
+        const source = await readFile(modulePath, "utf-8");
+        sourceFile = ts.createSourceFile(modulePath, source, ts.ScriptTarget.Latest, /* setParentNodes */ true);
+    }
+    catch {
+        // Not a readable TypeScript source — an installed package's compiled
+        // entry point reached through a path specifier, a missing file. Decline.
+        return undefined;
+    }
+    const collected = collectImports(sourceFile);
+    const consts = collectConsts(sourceFile);
+    for (const [name] of [...consts]) {
+        if (constResolvesToResource(consts, name, new Set()))
+            consts.delete(name);
+    }
+    return {
+        file: modulePath,
+        sourceFile,
+        packageRoot,
+        consts,
+        imports: collected.named,
+        namespaceImports: collected.namespaces,
+    };
+}
+/**
+ * Resolve a composite-defining module's own imports, once per module per
+ * build. Guarded by {@link FoldSession.stack}, exactly like
+ * {@link foldFileMemoized}: a module already being resolved further up the
+ * same chain is a genuine cycle, and gets an empty scope (every identifier
+ * then reads as unresolved, which declines the interpretation) rather than a
+ * re-entry.
+ */
+function factoryModuleScopeResolved(scope, session) {
+    if (scope.resolved)
+        return scope.resolved;
+    if (session.stack.includes(scope.file) || session.stack.length >= MAX_RESOLUTION_DEPTH) {
+        return Promise.resolve({ externals: new Map(), failures: new Map() });
+    }
+    session.stack.push(scope.file);
+    const roots = scope.packageRoot === undefined ? [] : [scope.packageRoot];
+    scope.resolved = buildExternals(scope.file, scope.imports, scope.namespaceImports, session, roots).finally(() => {
+        const idx = session.stack.lastIndexOf(scope.file);
+        if (idx !== -1)
+            session.stack.splice(idx, 1);
+    });
+    return scope.resolved;
+}
+/**
+ * Find `export const <exportName> = Composite(<fn>, "<name>")` at the top level
+ * of `scope`'s module, verifying that `Composite` really is chant's own in that
+ * module. Returns `undefined` for every other shape — see rule 2 of the
+ * contract above.
+ */
+function findCompositeDefinition(scope, exportName, ctx) {
+    for (const statement of scope.sourceFile.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        if (!hasExportModifier(statement))
+            continue;
+        if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0)
+            continue;
+        for (const decl of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(decl.name) || decl.name.text !== exportName)
+                continue;
+            const init = decl.initializer;
+            if (!init || !ts.isCallExpression(init) || !ts.isIdentifier(init.expression))
+                return undefined;
+            // `Composite` must be bound, in THIS module, to an import of chant's
+            // own — the identical provenance question #1082 asks of an authoring
+            // helper, answered by the identical predicate. A project-local
+            // `function Composite(...)` shadowing the name is not chant's, and a
+            // call to it is not a registered composite.
+            const compositeBinding = scope.imports.get(init.expression.text);
+            if (!compositeBinding || compositeBinding.imported !== "Composite")
+                return undefined;
+            // chant's own is the answer for every chant project, and #1082's
+            // provenance question is why: a project-local `function Composite(...)`
+            // shadowing the name is not chant's. chant#2442 adds the case chant had
+            // never had to consider, a HOST supplying the form (`F-Host-Composite`),
+            // which only a caller that named its own host packages can reach. For a
+            // chant build the set holds only `@intentius/chant-lexicon-*`, and no
+            // lexicon exports a `Composite`, so nothing about a chant project moves.
+            const chantOwned = isChantOwnedHelperBinding(compositeBinding, { ...ctx, file: scope.file });
+            const hostOwned = activeLexiconPackageImport(compositeBinding.specifier, scope.file, ctx.lexiconPackages) !== undefined ||
+                activeLexiconModule(compositeBinding.specifier, scope.file, ctx.lexiconModules, ctx.resolvePathCache) !==
+                    undefined;
+            if (!chantOwned && !hostOwned)
+                return undefined;
+            const [fnArg, nameArg] = init.arguments;
+            if (!fnArg || (!ts.isArrowFunction(fnArg) && !ts.isFunctionExpression(fnArg)))
+                return undefined;
+            // `Composite()`'s own default when the name is omitted (../composite.ts).
+            // COR017 requires the literal in practice; anything that is not a plain
+            // string literal is not something to guess at.
+            if (nameArg !== undefined && !ts.isStringLiteral(nameArg))
+                return undefined;
+            return { fn: fnArg, compositeName: nameArg ? nameArg.text : "anonymous", hostForm: !chantOwned };
+        }
+    }
+    return undefined;
+}
+/**
+ * chant#3247 — how many barrel re-exports {@link findFactoryDefinition}
+ * follows from the imported module to the one that defines the composite. A
+ * lexicon's barrel reaches its composites in two (`src/index.ts` ->
+ * `src/composites/index.ts` -> the file), a dialect subpath in three; past
+ * this the lookup declines, and the composite is invoked as before.
+ */
+const MAX_REEXPORT_HOPS = 8;
+/** A TypeScript source file, not compiled JavaScript and not a declaration file. */
+function isTypeScriptSource(path) {
+    return /\.[cm]?tsx?$/.test(path) && !/\.d\.[cm]?ts$/.test(path);
+}
+/** Process-wide memo for {@link lexiconPackageDirectory}, keyed by package name and directory. */
+const lexiconPackageDirectoryCache = new Map();
+/**
+ * chant#3247 — the directory of package `packageName` that holds the resolved
+ * `modulePath`: the nearest ancestor whose `package.json` names that package.
+ * `undefined` when none does before a `node_modules` directory or the
+ * filesystem root, which declines interpretation. Reads `package.json` files
+ * only; nothing is resolved or imported.
+ */
+function lexiconPackageDirectory(modulePath, packageName) {
+    const start = dirname(modulePath);
+    const key = `${packageName}\0${start}`;
+    if (lexiconPackageDirectoryCache.has(key))
+        return lexiconPackageDirectoryCache.get(key);
+    let found;
+    for (let dir = start; basename(dir) !== "node_modules";) {
+        const pkgJson = join(dir, "package.json");
+        if (existsSync(pkgJson)) {
+            try {
+                if (JSON.parse(readFileSync(pkgJson, "utf-8")).name === packageName) {
+                    found = dir;
+                    break;
+                }
+            }
+            catch {
+                // An unreadable package.json is not the package's; keep walking.
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    lexiconPackageDirectoryCache.set(key, found);
+    return found;
+}
+/**
+ * Rule 1 of the contract: where an import of a composite leads, or `undefined`
+ * when the import is not one interpretation follows. No module is imported.
+ *
+ *  - A project import (relative, absolute, or `paths`-mapped) resolves to its
+ *    file. Inside a package composite's body ({@link ResolveCtx.packageRoot})
+ *    it must stay inside that package.
+ *  - A bare specifier naming an active lexicon package, root or subpath, by
+ *    text, resolves through `node_modules` to a TypeScript source file inside
+ *    that package.
+ *  - Anything else is not followed.
+ */
+function factoryOrigin(specifier, fromFile, ctx) {
+    if (isProjectImport(specifier, fromFile)) {
+        let modulePath;
+        try {
+            modulePath = resolveModulePathMemoized(specifier, fromFile, ctx.resolvePathCache);
+        }
+        catch {
+            return undefined;
+        }
+        if (ctx.packageRoot === undefined)
+            return { modulePath };
+        return isUnderDirectory(modulePath, ctx.packageRoot) ? { modulePath, packageRoot: ctx.packageRoot } : undefined;
+    }
+    // Text first, as {@link isTrustedExecutableBinding}'s arm 1 does: no bare
+    // specifier outside the build's own lexicons is ever resolved here.
+    const packageName = activeLexiconPackage(specifier, ctx.lexiconPackages) ??
+        activeLexiconPackage(bareSpecifierPackageRoot(specifier) ?? "", ctx.lexiconPackages);
+    if (packageName === undefined)
+        return undefined;
+    let modulePath;
+    try {
+        modulePath = resolveModulePathMemoized(specifier, fromFile, ctx.resolvePathCache);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isTypeScriptSource(modulePath))
+        return undefined;
+    const packageRoot = lexiconPackageDirectory(modulePath, packageName);
+    return packageRoot === undefined ? undefined : { modulePath, packageRoot };
+}
+/**
+ * chant#3247 — the re-exports of `exportName` that `sourceFile` forwards, in the order they are worth
+ * trying. Empty when the module declares the name itself (its own
+ * declaration is the answer, interpretable or not) or forwards it from nowhere
+ * this follows. An explicit `export { ... } from` wins over `export *`, as it
+ * does in the language; a type-only re-export, an `export * as ns`, and a bare
+ * `export { X }` of an imported binding are not followed.
+ */
+function reExportsOf(sourceFile, exportName) {
+    const stars = [];
+    for (const statement of sourceFile.statements) {
+        if (ts.isExportDeclaration(statement)) {
+            if (statement.isTypeOnly)
+                continue;
+            const spec = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)
+                ? statement.moduleSpecifier.text
+                : undefined;
+            const clause = statement.exportClause;
+            if (clause === undefined) {
+                if (spec !== undefined)
+                    stars.push({ specifier: spec, imported: exportName, star: true });
+                continue;
+            }
+            if (!ts.isNamedExports(clause)) {
+                if (clause.name.text === exportName)
+                    return [];
+                continue;
+            }
+            for (const el of clause.elements) {
+                if (el.name.text !== exportName)
+                    continue;
+                if (spec === undefined || el.isTypeOnly)
+                    return [];
+                return [{ specifier: spec, imported: (el.propertyName ?? el.name).text, star: false }];
+            }
+            continue;
+        }
+        if (!hasExportModifier(statement))
+            continue;
+        if (ts.isVariableStatement(statement)) {
+            for (const decl of statement.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) && decl.name.text === exportName)
+                    return [];
+            }
+        }
+        else if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) &&
+            statement.name?.text === exportName) {
+            return [];
+        }
+    }
+    return stars;
+}
+/** A text pre-check for an `export *` target: false only when the file cannot export `name`. */
+async function mayProvideExport(file, name) {
+    try {
+        const text = await readFile(file, "utf-8");
+        return text.includes(name) || /export\s*\*\s*from/.test(text);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Rule 2, through barrels: find `exportName`'s `Composite(...)` declaration
+ * starting at `origin` and following {@link reExportsOf} — relative
+ * specifiers only, confined to `origin.packageRoot` when there is one, cycle
+ * safe, and at most {@link MAX_REEXPORT_HOPS} deep. Reads and parses; imports
+ * nothing.
+ */
+async function findFactoryDefinition(origin, exportName, ctx, seen = new Set(), hops = 0) {
+    seen.add(origin.modulePath);
+    const scope = await readFactoryModule(origin.modulePath, origin.packageRoot, ctx.session);
+    if (!scope)
+        return undefined;
+    const definition = findCompositeDefinition(scope, exportName, ctx);
+    if (definition)
+        return { scope, definition };
+    if (hops >= MAX_REEXPORT_HOPS)
+        return undefined;
+    for (const { specifier, imported, star } of reExportsOf(scope.sourceFile, exportName)) {
+        if (!isProjectFileSpecifier(specifier))
+            continue;
+        let target;
+        try {
+            target = resolveModulePathMemoized(specifier, scope.file, ctx.resolvePathCache);
+        }
+        catch {
+            continue;
+        }
+        if (seen.has(target) || !isTypeScriptSource(target))
+            continue;
+        if (origin.packageRoot !== undefined && !isUnderDirectory(target, origin.packageRoot))
+            continue;
+        // An `export *` target that neither names the export nor forwards a star
+        // of its own cannot provide it, so it is not parsed. That keeps a
+        // lexicon's generated barrel (megabytes, behind `export *` in most
+        // lexicons) from being parsed for every call through the package root.
+        if (star && !(await mayProvideExport(target, imported)))
+            continue;
+        const found = await findFactoryDefinition({ modulePath: target, packageRoot: origin.packageRoot }, imported, ctx, seen, hops + 1);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/**
+ * Decide whether `binding`'s callee is an interpretable composite — rules 1-5
+ * of the contract above, in that order, with no evaluation and no import.
+ * `undefined` means "not interpretable", never "broken".
+ */
+async function resolveInterpretableFactory(binding, ctx) {
+    // Rule 1 — a project file, or an active lexicon package's TypeScript source.
+    // A bare specifier outside the build's lexicons is refused on its text.
+    const origin = factoryOrigin(binding.specifier, ctx.file, ctx);
+    if (!origin)
+        return undefined;
+    // Not `undefined`: that answer means "not interpretable" and would invoke
+    // the factory while still reporting the file folded. Giving up is a
+    // different fact and falls the file back to run, naming the bound (#2370).
+    if (ctx.interpretDepth >= MAX_INTERPRETATION_DEPTH) {
+        throw new InterpretationDepthError(`interpretation depth exceeded ${MAX_INTERPRETATION_DEPTH} at "${binding.imported}" — a composite ` +
+            "chain this deep is almost certainly recursive. Falling back to run rather than invoking the " +
+            "factory, which would have reported this file as folded while evaluating it a different way.", 0, 0);
+    }
+    // Rule 2, following barrel re-exports to the defining module.
+    const found = await findFactoryDefinition(origin, binding.imported, ctx);
+    if (!found)
+        return undefined;
+    const { scope, definition } = found;
+    // Rules 3-5.
+    if (findFactorySubsetViolation(definition.fn) !== undefined)
+        return undefined;
+    return { scope, fn: definition.fn, compositeName: definition.compositeName, hostForm: definition.hostForm };
+}
+/**
+ * The SHAPE half of the contract (rules 3-5) — a lone `ts` node in, a reason
+ * string out, or `undefined` when the factory is admissible. Deliberately
+ * takes nothing but the node: it is the half a caller with no module graph
+ * could evaluate, and keeping it separable is what lets the doc above claim
+ * the shape rules are checkable without the provenance ones.
+ */
+export function findFactorySubsetViolation(fn) {
+    // Rule 3 — at most one parameter, bound plainly.
+    if (fn.parameters.length > 1)
+        return "a composite factory takes a single props parameter";
+    const param = fn.parameters[0];
+    if (param) {
+        if (param.dotDotDotToken)
+            return "a rest parameter is not interpretable";
+        if (param.initializer)
+            return "a defaulted parameter is not interpretable";
+        if (ts.isObjectBindingPattern(param.name)) {
+            for (const el of param.name.elements) {
+                if (bindingElementPropKey(el) === undefined) {
+                    return "a destructured props parameter with a rest, default, or nested element is not interpretable";
+                }
+            }
+        }
+        else if (!ts.isIdentifier(param.name)) {
+            return "an array-destructured props parameter is not interpretable";
+        }
+    }
+    // Rule 4 — a concise expression body, or `const`s then one `return`.
+    if (!ts.isBlock(fn.body))
+        return checkFactoryExpression(fn.body);
+    const statements = fn.body.statements;
+    if (statements.length === 0)
+        return "an empty composite factory body has no members to interpret";
+    for (let i = 0; i < statements.length; i += 1) {
+        const statement = statements[i];
+        const last = i === statements.length - 1;
+        if (ts.isReturnStatement(statement)) {
+            if (!last)
+                return "an early `return` is not interpretable";
+            if (!statement.expression)
+                return "a composite factory must return its members";
+            const violation = checkFactoryExpression(statement.expression);
+            if (violation)
+                return violation;
+            continue;
+        }
+        if (last)
+            return "a composite factory body must end in `return`";
+        if (!ts.isVariableStatement(statement)) {
+            return `\`${ts.SyntaxKind[statement.kind]}\` in a composite factory body is not interpretable`;
+        }
+        if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) {
+            return "`let`/`var` in a composite factory body is not interpretable";
+        }
+        for (const decl of statement.declarationList.declarations) {
+            if (!decl.initializer)
+                return "an uninitialized `const` in a composite factory body is not interpretable";
+            if (ts.isObjectBindingPattern(decl.name)) {
+                for (const el of decl.name.elements) {
+                    if (bindingElementPropKey(el) === undefined) {
+                        return "a destructured `const` with a rest, default, or nested element is not interpretable";
+                    }
+                }
+            }
+            else if (!ts.isIdentifier(decl.name)) {
+                return "an array-destructured `const` is not interpretable";
+            }
+            const violation = checkFactoryExpression(decl.initializer);
+            if (violation)
+                return violation;
+        }
+    }
+    return undefined;
+}
+/**
+ * Rule 5 — the fold subset, extended with `new Type(...)` in any value
+ * position and a call through a bare identifier.
+ *
+ * Shape only, in ../fold/subset.ts's sense: whether a `new`'s constructor or a
+ * call's callee actually resolves to something invocable is settled at
+ * evaluation, where the module graph is available. Every operator/key/member
+ * rule is read from ../fold/subset.ts's own exported sets rather than
+ * re-listed, so widening `fold()` widens this in the same commit.
+ */
+function checkFactoryExpression(node) {
+    if (ts.isParenthesizedExpression(node) ||
+        ts.isAsExpression(node) ||
+        ts.isSatisfiesExpression(node) ||
+        ts.isNonNullExpression(node) ||
+        ts.isTypeAssertionExpression(node)) {
+        return checkFactoryExpression(node.expression);
+    }
+    if (ts.isStringLiteral(node) ||
+        ts.isNoSubstitutionTemplateLiteral(node) ||
+        ts.isNumericLiteral(node) ||
+        ts.isIdentifier(node) ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword ||
+        node.kind === ts.SyntaxKind.NullKeyword) {
+        return undefined;
+    }
+    if (ts.isNewExpression(node) || ts.isCallExpression(node)) {
+        // A bare-identifier callee only — `ns.Foo(...)`, `arr.map(...)` and
+        // `props.factory(...)` are all property accesses and all stay out, which
+        // is what keeps a data transform (chant EVL010) from sneaking in.
+        if (!ts.isIdentifier(node.expression)) {
+            return ts.isNewExpression(node)
+                ? `\`new ${briefNodeText(node.expression)}(...)\` needs a plain imported constructor to interpret`
+                : callExpressionMessage(node);
+        }
+        for (const arg of node.arguments ?? []) {
+            const violation = checkFactoryExpression(arg);
+            if (violation)
+                return violation;
+        }
+        return undefined;
+    }
+    if (ts.isTaggedTemplateExpression(node)) {
+        if (!ts.isIdentifier(node.tag))
+            return unsupportedExpressionMessage(node);
+        if (ts.isNoSubstitutionTemplateLiteral(node.template))
+            return undefined;
+        for (const span of node.template.templateSpans) {
+            const violation = checkFactoryExpression(span.expression);
+            if (violation)
+                return violation;
+        }
+        return undefined;
+    }
+    if (ts.isTemplateExpression(node)) {
+        for (const span of node.templateSpans) {
+            const violation = checkFactoryExpression(span.expression);
+            if (violation)
+                return violation;
+        }
+        return undefined;
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop)) {
+                if (!isLiteralPropertyNameNode(prop.name))
+                    return computedPropertyNameMessage(prop.name);
+                const violation = checkFactoryExpression(prop.initializer);
+                if (violation)
+                    return violation;
+            }
+            else if (ts.isShorthandPropertyAssignment(prop)) {
+                if (prop.objectAssignmentInitializer)
+                    return UNSUPPORTED_OBJECT_MEMBER_MESSAGE;
+            }
+            else if (ts.isSpreadAssignment(prop)) {
+                const violation = checkFactoryExpression(prop.expression);
+                if (violation)
+                    return violation;
+            }
+            else {
+                return UNSUPPORTED_OBJECT_MEMBER_MESSAGE;
+            }
+        }
+        return undefined;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        for (const el of node.elements) {
+            const violation = checkFactoryExpression(ts.isSpreadElement(el) ? el.expression : el);
+            if (violation)
+                return violation;
+        }
+        return undefined;
+    }
+    if (ts.isPropertyAccessExpression(node))
+        return checkFactoryExpression(node.expression);
+    if (ts.isElementAccessExpression(node)) {
+        if (!isLiteralElementKey(node.argumentExpression)) {
+            return `dynamic element access [${briefNodeText(node.argumentExpression)}] is not interpretable`;
+        }
+        return checkFactoryExpression(node.expression);
+    }
+    if (ts.isPrefixUnaryExpression(node)) {
+        if (!SUPPORTED_UNARY_OPERATORS.has(node.operator))
+            return UNSUPPORTED_UNARY_MESSAGE;
+        return checkFactoryExpression(node.operand);
+    }
+    if (ts.isBinaryExpression(node)) {
+        if (!SUPPORTED_BINARY_OPERATORS.has(node.operatorToken.kind)) {
+            return unsupportedBinaryMessage(node.operatorToken.kind);
+        }
+        return checkFactoryExpression(node.left) ?? checkFactoryExpression(node.right);
+    }
+    if (ts.isConditionalExpression(node)) {
+        return (checkFactoryExpression(node.condition) ??
+            checkFactoryExpression(node.whenTrue) ??
+            checkFactoryExpression(node.whenFalse));
+    }
+    return unsupportedExpressionMessage(node);
+}
+/** `isLiteralPropertyName` narrowed to the node type {@link propName} accepts, without importing the type predicate's generic form twice. */
+function isLiteralPropertyNameNode(node) {
+    return ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node);
+}
+/**
+ * chant #2161 — how one admissible factory's parameter is bound in its body,
+ * plus the consts an attribution walk has to follow.
+ *
+ * Built from the SOURCE, not from the argument value: the question is which
+ * expression a member's property was written as, not what it evaluated to. A
+ * factory with no parameter at all still gets a recorder, so every path in its
+ * members records as a literal the composite fixes, which is exactly what a
+ * parameterless composite does.
+ */
+function compositeParamRecorder(factory, moduleConsts, call) {
+    const whole = new Set();
+    const destructured = new Map();
+    const param = factory.fn.parameters[0];
+    if (param) {
+        if (ts.isIdentifier(param.name)) {
+            whole.add(param.name.text);
+        }
+        else if (ts.isObjectBindingPattern(param.name)) {
+            for (const el of param.name.elements) {
+                const key = bindingElementPropKey(el);
+                if (key !== undefined && ts.isIdentifier(el.name))
+                    destructured.set(el.name.text, key);
+            }
+        }
+    }
+    // Body `const`s layered over the defining module's, so a hoisted value is
+    // followed. `interpretCompositeFactory` deletes shadowed names from the
+    // context's own const map as it binds values; this map is separate precisely
+    // so the INITIALIZER stays available to the attribution walk.
+    const consts = new Map(moduleConsts);
+    const body = factory.fn.body;
+    if (ts.isBlock(body)) {
+        for (const statement of body.statements) {
+            if (!ts.isVariableStatement(statement))
+                continue;
+            for (const decl of statement.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) && decl.initializer)
+                    consts.set(decl.name.text, decl.initializer);
+            }
+        }
+    }
+    return { composite: factory.compositeName, scope: { whole, destructured }, consts, ...(call ? { call } : {}) };
+}
+/**
+ * chant #2161 — record, for one `new Type({...})` written inside an interpreted
+ * factory body, which factory parameter produced each of its property paths and
+ * which paths the composite fixes.
+ *
+ * Best-effort and additive, exactly like {@link stampParamDependencies}: a
+ * constructor called with no object literal records nothing, and
+ * `setPathProvenance` keeps the first (innermost) writer.
+ */
+function stampCompositeOrigins(entity, node, ctx) {
+    const recorder = ctx.compositeParams;
+    if (!recorder)
+        return;
+    if (typeof entity !== "object" || entity === null)
+        return;
+    let propsArg;
+    for (const argument of node.arguments ?? []) {
+        if (ts.isObjectLiteralExpression(argument)) {
+            propsArg = argument;
+            break;
+        }
+    }
+    if (!propsArg)
+        return;
+    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, recorder) {
+    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} ...` ``).
+ *
+ * A tag's props come from parsing its text, so no object literal says which
+ * field each `${...}` landed in. The tag says so itself through
+ * `setInterpolationFields`; a tag that does not leaves the entity's fields
+ * `unknown`, as before.
+ */
+function stampTagOrigins(entity, node, ctx) {
+    const recorder = ctx.compositeParams;
+    if (!recorder || !isDeclarable(entity) || !isResourceDeclarable(entity))
+        return;
+    const fields = getInterpolationFields(entity);
+    if (!fields)
+        return;
+    const interpolations = ts.isTemplateExpression(node.template)
+        ? node.template.templateSpans.map((span) => span.expression)
+        : [];
+    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);
+}
+/**
+ * Interpret an admissible factory's body against `args`, and assemble the
+ * result through chant's own {@link Composite}.
+ *
+ * Returns `undefined` — a DECLINE, not a failure — when anything in the body
+ * fails to resolve (an identifier the defining module's imports don't reach, a
+ * constructor `--sandbox` refuses, a nested call that isn't a composite). The
+ * caller then invokes for real, landing exactly where it landed before #1023.
+ * That asymmetry is deliberate: interpretation may only ever REMOVE an
+ * execution, never introduce a fold failure that wasn't there.
+ */
+async function interpretCompositeFactory(factory, args, ctx, call) {
+    // 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
+    // model.
+    if (args.length > 1)
+        return undefined;
+    const { scope, fn } = factory;
+    const resolved = await factoryModuleScopeResolved(scope, ctx.session);
+    // The defining module's own scope, with the factory's locals layered on top.
+    // `locals` is deliberately EMPTY: `resolveLiveValue`'s local-binding branch
+    // exists to re-navigate a file's own top-level composite spine, which is not
+    // what a name inside a factory body means. Body bindings live in `externals`
+    // instead, where an identifier resolves to the value already computed for it
+    // — which is what makes `role.Arn` a live `AttrRef` on the real instance.
+    const consts = new Map(scope.consts);
+    const externals = new Map(resolved.externals);
+    const bodyCtx = {
+        file: scope.file,
+        consts,
+        locals: new Map(),
+        imports: scope.imports,
+        namespaceImports: scope.namespaceImports,
+        memo: new Map(),
+        intrinsics: ctx.intrinsics,
+        externals,
+        crossFileFailures: resolved.failures,
+        importCache: ctx.importCache,
+        resolvePathCache: ctx.resolvePathCache,
+        lexiconPackages: ctx.lexiconPackages,
+        lexiconModules: ctx.lexiconModules,
+        // chant#3247 — a package's composite trusts its own package directory for
+        // the length of its body, and nothing outside it.
+        lexiconRoots: scope.packageRoot === undefined ? ctx.lexiconRoots : [...ctx.lexiconRoots, scope.packageRoot],
+        packageRoot: scope.packageRoot,
+        sandbox: ctx.sandbox,
+        executing: ctx.executing,
+        session: ctx.session,
+        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, call),
+    };
+    const bind = (name, value) => {
+        // A body binding SHADOWS a module-level const of the same name, so the
+        // const has to go — `fold()` consults `consts` before `externals`.
+        consts.delete(name);
+        externals.set(name, value);
+    };
+    try {
+        const param = fn.parameters[0];
+        if (param) {
+            const props = args[0];
+            if (ts.isIdentifier(param.name)) {
+                bind(param.name.text, props);
+            }
+            else if (ts.isObjectBindingPattern(param.name)) {
+                if (!isIndexableObject(props))
+                    return undefined;
+                for (const el of param.name.elements) {
+                    const key = bindingElementPropKey(el);
+                    if (key === undefined)
+                        return undefined;
+                    bind(el.name.getText(), props[key]);
+                }
+            }
+        }
+        const members = await interpretFactoryBody(fn, bodyCtx, bind);
+        if (!isIndexableObject(members))
+            return undefined;
+        // Assembled by chant's own `Composite()` — see the contract's "what is
+        // preserved" note. One definition object per interpreted call (rather than
+        // one per module, as the run path has) is the single visible difference:
+        // `_id` is a fresh symbol, which nothing outside `CompositeRegistry` — used
+        // only by tests — reads.
+        // chant#2442 — a HOST's registration form produces the host's own members,
+        // so they are returned as the factory built them. Wrapping them in chant's
+        // `Composite` would run chant's member validation, which asks for chant's
+        // own `Declarable` and rejects an entity carrying a different marker —
+        // 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
+            ? markHostCompositeInstance(members, factory.compositeName)
+            : (Composite(() => members, factory.compositeName))();
+        executionCounts.factoryInterpretations += 1;
+        return { value };
+    }
+    catch (err) {
+        // Every other failure here means "this body did not interpret" and the
+        // caller invokes instead. Exhausting the depth bound means "we stopped
+        // looking", which has to reach the file's fold verdict rather than be
+        // answered with an invocation (#2370).
+        if (err instanceof InterpretationDepthError)
+            throw err;
+        return undefined;
+    }
+}
+/**
+ * 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, compositeName) {
+    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, compositeName) {
+    for (const member of Object.values(members)) {
+        if (isDeclarable(member))
+            setProvenance(member, { composite: compositeName });
+        else if (hostCompositeName(member) !== undefined)
+            stampHostCompositeMembers(member, compositeName);
+    }
+}
+/** The composite name a host composite instance was marked with, or `undefined` for any other value. */
+function hostCompositeName(value) {
+    if (!isIndexableObject(value))
+        return undefined;
+    const name = value[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, ctx, bind) {
+    if (!ts.isBlock(fn.body))
+        return interpretExpression(fn.body, ctx);
+    for (const statement of fn.body.statements) {
+        if (ts.isReturnStatement(statement)) {
+            // `findFactorySubsetViolation` has already established this is the last
+            // statement and has an expression.
+            return interpretExpression(statement.expression, ctx);
+        }
+        const declarations = statement.declarationList.declarations;
+        for (const decl of declarations) {
+            const value = await interpretExpression(decl.initializer, ctx);
+            if (ts.isIdentifier(decl.name)) {
+                bind(decl.name.text, value);
+                continue;
+            }
+            if (!isIndexableObject(value)) {
+                throw cheapError(`destructured \`const\` source in "${briefNodeText(decl.name)}" is not an object`);
+            }
+            for (const el of decl.name.elements) {
+                bind(el.name.getText(), value[bindingElementPropKey(el)]);
+            }
+        }
+    }
+    // Unreachable: rule 4 requires a trailing `return`.
+    throw cheapError("composite factory body did not return");
+}
+/**
+ * Evaluate one expression of a factory body.
+ *
+ * Only the cases that can CONTAIN a construction or a composite call are
+ * handled here; everything else delegates to {@link resolveDeclaratorValue},
+ * which is the same `resolveLiveValue` -> `fold()` -> revive pipeline every
+ * other value in a fold takes. That split is the point: the interpreter owns
+ * as little evaluation semantics as it possibly can, so `fold()` stays the one
+ * definition of what an expression means, and the operators/short-circuiting
+ * duplicated below are duplicated because they must not evaluate a branch
+ * `fold()` would not have evaluated.
+ */
+async function interpretExpression(node, ctx) {
+    if (ts.isParenthesizedExpression(node) ||
+        ts.isAsExpression(node) ||
+        ts.isSatisfiesExpression(node) ||
+        ts.isNonNullExpression(node)) {
+        return interpretExpression(node.expression, ctx);
+    }
+    if (ts.isNewExpression(node))
+        return interpretNewExpression(node, ctx);
+    if (ts.isTaggedTemplateExpression(node)) {
+        const value = (await resolveDeclaratorValue(node, ctx)).value;
+        stampTagOrigins(value, node, ctx);
+        return value;
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const obj = {};
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop)) {
+                obj[propName(prop.name)] = await interpretExpression(prop.initializer, ctx);
+            }
+            else if (ts.isShorthandPropertyAssignment(prop)) {
+                obj[prop.name.text] = await interpretExpression(prop.name, ctx);
+            }
+            else {
+                const src = await interpretExpression(prop.expression, ctx);
+                if (src === null || typeof src !== "object")
+                    throw cheapError("spread source not an object");
+                Object.assign(obj, src);
+            }
+        }
+        return obj;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        const arr = [];
+        for (const el of node.elements) {
+            if (ts.isSpreadElement(el)) {
+                const src = await interpretExpression(el.expression, ctx);
+                if (!Array.isArray(src))
+                    throw cheapError("spread source not an array");
+                arr.push(...src);
+            }
+            else {
+                arr.push(await interpretExpression(el, ctx));
+            }
+        }
+        return arr;
+    }
+    if (ts.isConditionalExpression(node)) {
+        return (await interpretExpression(node.condition, ctx))
+            ? interpretExpression(node.whenTrue, ctx)
+            : interpretExpression(node.whenFalse, ctx);
+    }
+    if (ts.isBinaryExpression(node)) {
+        const S = ts.SyntaxKind;
+        const opKind = node.operatorToken.kind;
+        if (opKind === S.AmpersandAmpersandToken) {
+            const left = await interpretExpression(node.left, ctx);
+            return left ? interpretExpression(node.right, ctx) : left;
+        }
+        if (opKind === S.BarBarToken) {
+            const left = await interpretExpression(node.left, ctx);
+            return left ? left : interpretExpression(node.right, ctx);
+        }
+        if (opKind === S.QuestionQuestionToken) {
+            const left = await interpretExpression(node.left, ctx);
+            return left === null || left === undefined ? interpretExpression(node.right, ctx) : left;
+        }
+    }
+    return (await resolveDeclaratorValue(node, ctx)).value;
+}
+/**
+ * Construct a real resource from a `new Type(...)` anywhere inside a factory
+ * body — a member, a nested property object, an array element.
+ *
+ * Deliberately NOT routed through {@link resolveResourceEntity}: a factory body
+ * evaluates against the DEFINING module's scope with the caller's props already
+ * bound to live values, so each argument is interpreted recursively (through
+ * {@link interpretExpression}, which can produce a live composite instance a
+ * plain `fold()` has no representation for) rather than folded and revived.
+ *
+ * chant #1169 removed the asymmetry that used to motivate this comment: a
+ * nested `new` in a TOP-LEVEL value position now constructs too, via
+ * {@link constructFoldedResource}. The two paths reach the same place — the
+ * class named by an `import`, called with the arguments the source wrote — by
+ * different routes, because a factory body and a file's own top level start
+ * from different scopes.
+ */
+async function interpretNewExpression(node, ctx) {
+    // Guaranteed an identifier by {@link checkFactoryExpression}; re-checked so a
+    // future caller can't reach this with a dotted callee and get a silent miss.
+    if (!ts.isIdentifier(node.expression)) {
+        throw cheapError(`\`new ${briefNodeText(node.expression)}(...)\` needs a plain imported constructor`);
+    }
+    const typeName = node.expression.text;
+    const binding = ctx.imports.get(typeName);
+    if (!binding)
+        throw cheapError(`constructor "${typeName}" is not a resolvable import`);
+    // chant #1093 — same gate, same reason, as every other site that imports a
+    // module in order to execute something from it.
+    const refusal = sandboxedExecutionRefusal(binding, ctx, typeName, "constructor");
+    if (refusal)
+        throw cheapError(refusal);
+    const modulePath = resolveModulePathMemoized(binding.specifier, ctx.file, ctx.resolvePathCache);
+    const mod = await importModuleMemoized(modulePath, ctx.importCache);
+    const Ctor = mod[binding.imported];
+    if (typeof Ctor !== "function") {
+        throw cheapError(`"${binding.imported}" from "${binding.specifier}" is not a constructor`);
+    }
+    const ctorArgs = [];
+    for (const arg of node.arguments ?? [])
+        ctorArgs.push(await interpretExpression(arg, ctx));
+    const instance = new Ctor(...ctorArgs);
+    stampCompositeOrigins(instance, node, ctx);
+    return instance;
+}
+/**
+ * Record one exported name's fully-resolved value: unconditionally into
+ * `exportedValues` (chant #1020) — the file's export namespace, which is
+ * what discovery hands to `collectEntities` and what another file's
+ * cross-file reference resolves against — and, additionally, into `entities`
+ * when the value is a real `Declarable`/`CompositeInstance`.
+ *
+ * chant #1112 — `entities` is a REPORTING subset, not a filter. It used to
+ * be the only thing discovery passed on, which made this function a second
+ * owner of the "which export becomes an entity" decision; it had one fewer
+ * case than the real owner (`enumerateEntries`, ../collect.ts), so a
+ * `LexiconOutput` export folded fine and was then thrown away, and the
+ * template silently lost its `Outputs` section. Discovery now passes
+ * `exportedValues` — the whole namespace, exactly like the run path's real
+ * `exports` object — and `collectEntities` filters it, so nothing here can
+ * fall behind what collection understands. What `entities` still answers is
+ * "how many resources did this file contribute", for the `[fold:fold] x.ts —
+ * N resource(s)` decision line.
+ */
+function applyResolvedValue(name, value, entities, exportedValues) {
+    exportedValues.set(name, value);
+    if (isDeclarable(value) || isCompositeInstance(value)) {
+        entities.push([name, value]);
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Intrinsic revival (chant #1039).
+//
+// `fold()`/`foldResource()` reduce a registered intrinsic tagged template
+// (e.g. AWS `Sub`\`...\`) to a symbolic `FoldedIntrinsic` node —
+// `{ __intrinsic, strings, values }` — and an unresolved external symbol
+// chain inside it (e.g. `AWS.StackName`) to a `SymbolicValue` —
+// `{ __symbol }` (../fold/fold.ts's own doc: "mirrors the runtime call shape
+// `Tag(strings, ...values)` so a later build path can replay it into the
+// real intrinsic object"). This IS that later build path: without it, the
+// symbolic envelope would be passed straight into the constructed entity's
+// props as an inert plain object — the entity would be built (no crash), but
+// its serialized output would silently diverge from the run path's real
+// `Sub`/`PseudoParameter` instances (caught by the #1025 differential the
+// moment intrinsics started actually folding). `reviveFoldedProps` walks the
+// folded props/attributes tree and, for each `{__intrinsic}`/`{__symbol}`
+// node, resolves the real tag function / pseudo-parameter through this
+// file's own imports (same mechanism `resolveResourceEntity` already uses
+// for the resource constructor itself) and invokes/accesses it for real —
+// exactly what running the original tagged template would have done.
+//
+// `{__attrRef}` (a same-file sibling-resource reference, ../fold/fold.ts's
+// `AttrRefValue`) is left untouched when it is NOT nested inside a revived
+// intrinsic: the serializer's generic walker already recognizes that plain
+// envelope structurally (see ../serializer-walker.ts) with no revival
+// needed. But an intrinsic's OWN implementation (e.g. `SubIntrinsic`) needs
+// a genuine `AttrRef` instance internally (`instanceof` checks), which would
+// require wiring a live `WeakRef` to the sibling entity — out of scope here:
+// reject (fall back to run) rather than risk silently wrong output.
+//
+// chant #1169 adds the fourth envelope this walk revives, and the one that
+// closes the corpus's largest fold gate: `{__resource}`, a nested
+// `new Type(...)` used as a value. It is revived the same way and for the same
+// reason as the other three — the real class is resolved through the folding
+// file's own imports and called for real — so what the outer constructor
+// receives is the instance the run path would have handed it, not a look-alike.
+// See {@link constructFoldedResource}.
+// ─────────────────────────────────────────────────────────────────────────
+/** Resolve a bare name bound by this file's own `import` to its real, live export — the same two-step (resolve module path, then `importModule`) `resolveResourceEntity`/`resolveCallExpression` already use for constructors and composite factories. */
+async function resolveImportedExport(name, ctx) {
+    const binding = ctx.imports.get(name);
+    if (!binding) {
+        throw cheapError(`"${name}" is not a resolvable import`);
+    }
+    // chant #1093 — reached for an intrinsic tag and for a symbolic chain's root
+    // (`AWS.StackName`), both of which are resolved BY NAME out of the file's own
+    // imports: nothing guarantees the module behind that name is a lexicon's.
+    // `reviveHelperCall` checks chant-ownership before it gets here; this covers
+    // the paths that don't.
+    const refusal = sandboxedExecutionRefusal(binding, ctx, name, "import");
+    if (refusal)
+        throw cheapError(refusal);
+    let modulePath;
+    try {
+        modulePath = resolveModulePathMemoized(binding.specifier, ctx.file, ctx.resolvePathCache);
+    }
+    catch (err) {
+        throw cheapError(`could not resolve import "${binding.specifier}" for "${name}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let mod;
+    try {
+        mod = await importModuleMemoized(modulePath, ctx.importCache);
+    }
+    catch (err) {
+        throw cheapError(`could not import "${binding.specifier}" to resolve "${name}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return mod[binding.imported];
+}
+/** A bare identifier, or simple dotted access chain rooted at one (`AWS.StackName`, `Azure.ResourceGroupName`) — the only shape {@link fold.ts}'s `isUnresolvedSymbolChain` actually produces `SymbolicValue` text for in practice (element access/non-null on a pseudo-parameter-style namespace isn't a real authoring pattern anywhere in a lexicon today). Anything else is rejected rather than guessed at. */
+const SIMPLE_DOTTED_CHAIN = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/;
+/** Resolve a folded `SymbolicValue`'s raw source text (e.g. `"AWS.StackName"`) back to the real value it refers to, by resolving its root identifier through this file's own imports and then doing real property access down the rest of the chain — reproducing exactly what evaluating that expression at runtime would have done. */
+async function resolveSymbolicValue(text, ctx) {
+    if (!SIMPLE_DOTTED_CHAIN.test(text)) {
+        throw cheapError(`symbol "${text}" is not a simple dotted import reference`);
+    }
+    const [root, ...path] = text.split(".");
+    let value = await resolveImportedExport(root, ctx);
+    for (const key of path) {
+        if (value === null || value === undefined) {
+            throw cheapError(`symbol "${text}": "${root}" has no "${key}"`);
+        }
+        value = value[key];
+    }
+    return value;
+}
+/**
+ * True when {@link reviveFoldedValue} hands `value` back unchanged: a
+ * primitive, or one of the live object kinds its passthrough keeps (an
+ * `AttrRef`, a Declarable, a composite instance, an `Intrinsic`).
+ */
+function revivesAsItself(value) {
+    if (value === null || typeof value !== "object")
+        return true;
+    return isAttrRefLike(value) || isDeclarable(value) || isCompositeInstance(value) || isIntrinsic(value);
+}
+/**
+ * Revive a folded value tree: replace any
+ * `{__intrinsic}`/`{__helper}`/`{__symbol}` envelope with the real value it
+ * represents.
+ *
+ * `requireLiveRefs` tracks whether the CURRENT node is (transitively) an
+ * argument being handed to a real function that will inspect it — a
+ * `{__intrinsic}`'s own interpolated `values`, or a `{__helper}` call's
+ * arguments (chant #1082). In that position a symbolic `{__attrRef}` envelope
+ * is rejected rather than passed along: the receiving implementation needs a
+ * genuine `AttrRef` instance (`instanceof` checks, `WeakRef` derefs — see
+ * `SubIntrinsic`, and `LexiconOutput`'s constructor in ../lexicon-output.ts),
+ * and handing it a look-alike plain object produces output that is wrong
+ * rather than absent. Everywhere else the envelope is left untouched, because
+ * the serializer's generic walker already understands it — see the module-doc
+ * note above.
+ */
+async function reviveFoldedValue(value, ctx, requireLiveRefs) {
+    if (value === null || typeof value !== "object")
+        return value;
+    // chant #1020 — a REAL, already-constructed live object reached via
+    // cross-file resolution (`ctx.externals`, e.g. `network.vpc.VpcId` folding
+    // to a genuine `AttrRef` wired to the actual shared `vpc` instance, or a
+    // bare cross-file identifier folding directly to the shared
+    // Declarable/CompositeInstance itself). None of these have an own
+    // `__symbol`/`__intrinsic`/`__attrRef`/`__resource` marker KEY — an AttrRef
+    // instance's own enumerable fields are `parent`/`attribute`, not a nested
+    // `__attrRef` object — so without this early return the generic object
+    // walk below would silently reconstruct a plain-object copy of it,
+    // destroying the very identity #1020 exists to preserve. Passed through
+    // completely unchanged, exactly like `resolveCallExpression`'s own
+    // `live.value` passthrough for a composite-call argument.
+    // chant #1063 adds the third kind of real object cross-file resolution can
+    // now put here: a live `Intrinsic` instance read off an active lexicon
+    // package (`Azure.ResourceGroupLocation`, `GCP.ProjectId` — see
+    // `resolveActiveLexiconExport`). Same hazard, same fix: the generic walk
+    // below would rebuild it as a plain `{}` copy, dropping the prototype that
+    // carries `toJSON()` and so serializing `{}` where the run path emits
+    // `[resourceGroup().location]`. `isIntrinsic` keys off
+    // `Symbol.for("chant.intrinsic")` (../intrinsic.ts), a GLOBAL symbol, so it
+    // holds across separately-loaded copies of chant-core the way a bare
+    // `instanceof` would not.
+    if (revivesAsItself(value))
+        return value;
+    if (Array.isArray(value)) {
+        const revived = [];
+        for (const el of value)
+            revived.push(await reviveFoldedValue(el, ctx, requireLiveRefs));
+        return revived;
+    }
+    if ("__symbol" in value) {
+        const symbolic = value;
+        return resolveSymbolicValue(symbolic.__symbol, ctx);
+    }
+    if ("__intrinsic" in value) {
+        const intrinsic = value;
+        const Fn = await resolveImportedExport(intrinsic.__intrinsic, ctx);
+        if (typeof Fn !== "function") {
+            throw cheapError(`intrinsic "${intrinsic.__intrinsic}" did not resolve to a function`);
+        }
+        // Two authored forms, one envelope family (../fold/fold.ts's
+        // `FoldedIntrinsic`): the tagged template replays as
+        // `Name(strings, ...values)`, the plain call (chant #1044) as
+        // `Name(...args)`. Both hand their interior to the REAL function the
+        // file itself imported, with `requireLiveRefs` — an intrinsic inspects
+        // what it is given (`SubIntrinsic`'s `instanceof` checks, `Ref`'s
+        // `getLogicalName`), so a look-alike `{__attrRef}` envelope must be
+        // rejected here rather than silently serialized as something else.
+        const revived = [];
+        if ("args" in intrinsic) {
+            for (const a of intrinsic.args)
+                revived.push(await reviveFoldedValue(a, ctx, true));
+            return Fn(...revived);
+        }
+        for (const v of intrinsic.values)
+            revived.push(await reviveFoldedValue(v, ctx, true));
+        // chant #3196 — hand the tag what a real tagged call hands it: a frozen
+        // strings array carrying a frozen, non-enumerable `raw`. A tag that reads
+        // `strings.raw` (a SQL tag keeps backslashes as written) would otherwise
+        // build different text folded than run.
+        const strings = Object.freeze(Object.defineProperty([...intrinsic.strings], "raw", { value: Object.freeze([...intrinsic.raw]) }));
+        return Fn(strings, ...revived);
+    }
+    if ("__helper" in value) {
+        return reviveHelperCall(value, ctx);
+    }
+    if ("__compositeStep" in value) {
+        // chant #1174 — `<Identifier>(...).step`, see {@link FoldedCompositeStepCall}.
+        // Arguments revive with `requireLiveRefs: false` — the same rule
+        // `resolveCallArguments` applies to a NON-helper callee's arguments
+        // (a composite factory stores its props, it doesn't inspect them the way
+        // an intrinsic/helper does), so a `{__attrRef}` among them stays the
+        // symbolic envelope the composite's own resource construction resolves
+        // by name, exactly as a top-level resource's props would.
+        const call = value;
+        const revivedArgs = [];
+        for (const a of call.args)
+            revivedArgs.push(await reviveFoldedValue(a, ctx, false));
+        const result = await resolveCompositeCall(call.__compositeStep, revivedArgs, ctx);
+        if (!isIndexableObject(result)) {
+            throw cheapError(`composite call \`${call.__compositeStep}(...)\` did not resolve to an object with a "step" member`);
+        }
+        return result.step;
+    }
+    if ("__attrRef" in value) {
+        if (requireLiveRefs) {
+            throw cheapError("a same-file resource reference passed to a folded intrinsic or authoring helper is not foldable yet");
+        }
+        return value;
+    }
+    if ("__resource" in value) {
+        // chant #1169 — a nested `new Type(...)` used as a value. This is the
+        // branch that makes the envelope safe: it is replaced, here, by a REAL
+        // instance of the class the source named, built by the same
+        // resolve-through-this-file's-imports machinery `resolveResourceEntity`
+        // uses for a top-level resource and `interpretNewExpression` (#1023) uses
+        // for a construction inside a factory body. Nothing symbolic reaches the
+        // serializer — see {@link fold}'s `new` branch for why that is the whole
+        // safety argument.
+        //
+        // `requireLiveRefs` is propagated rather than reset: a construction in an
+        // ordinary prop position keeps the top-level rule (a `{__attrRef}` inside
+        // it stays an envelope, which the serializer's own walker resolves by name
+        // through `propertyDeclarable` exactly as it does for a top-level
+        // resource's props), while a construction inside an intrinsic's interior
+        // keeps the stricter one and rejects — the receiving implementation
+        // inspects what it is handed, and this is the direction that falls back to
+        // run rather than emitting something wrong.
+        return constructFoldedResource(value, ctx, requireLiveRefs);
+    }
+    const revived = {};
+    for (const [key, v] of Object.entries(value)) {
+        revived[key] = await reviveFoldedValue(v, ctx, requireLiveRefs);
+    }
+    return revived;
+}
+/**
+ * chant #1082 — the provenance half of the registered-authoring-helper check
+ * (the shape/name half is `fold()`'s, see ../fold/foldable-helpers.ts's module
+ * doc). Being in the allowlist is not permission to invoke whatever the name
+ * happens to be bound to: the name must be bound by THIS FILE'S OWN `import`,
+ * and that import must actually come from chant. Only then is the real
+ * function called, with the folded arguments — the same function the run path
+ * would have called, from the same module the source itself named, so fold
+ * cannot diverge from run by construction.
+ *
+ * Anything short of that throws, which falls the whole file back to run: a
+ * local `function phase(...)`, a `phase` imported from the project's own
+ * helpers, a chant-owned import that turns out not to be a function.
+ */
+async function reviveHelperCall(call, ctx) {
+    const name = call.__helper;
+    const binding = ctx.imports.get(name);
+    if (!binding) {
+        throw cheapError(`authoring helper "${name}(...)" is not a resolvable import`);
+    }
+    if (!isChantOwnedHelperBinding(binding, ctx)) {
+        throw cheapError(`"${name}" is imported from "${binding.specifier}", which is not chant's own — ` +
+            `only chant's registered authoring helpers fold as calls`);
+    }
+    const Fn = await resolveImportedExport(name, ctx);
+    if (typeof Fn !== "function") {
+        throw cheapError(`authoring helper "${name}" did not resolve to a function`);
+    }
+    // `requireLiveRefs` — a helper receives its arguments as real values and may
+    // inspect them (`output()` derefs the ref's `WeakRef` parent), so a symbolic
+    // `{__attrRef}` envelope is rejected here rather than silently wrapped into
+    // a wrong result. A ref that resolved cross-file to a genuine live `AttrRef`
+    // passes straight through (see `reviveFoldedValue`'s early return).
+    const args = [];
+    for (const arg of call.args)
+        args.push(await reviveFoldedValue(arg, ctx, true));
+    return Fn(...args);
+}
+/**
+ * True when `binding` names a helper import chant itself owns: a published
+ * chant package specifier ({@link isChantOwnedSpecifier}), or — for in-repo
+ * and test callers, which import chant-core by relative/absolute path the way
+ * this module's own fixtures do — a specifier that resolves to a file inside
+ * chant-core's own tree.
+ *
+ * The path arm resolves only for a relative/absolute specifier, never a bare
+ * one: resolving an arbitrary bare specifier here would reintroduce the
+ * pathological cold-resolution cost chant#1020 measured (see
+ * {@link fastResolveBareSpecifier}), and a bare specifier chant publishes is
+ * already covered by the text arm.
+ *
+ * Not the same question as chant#1093's {@link isTrustedExecutableBinding}
+ * below, and deliberately not shared with it: this one asks "may this NAME be
+ * invoked as one of chant's registered authoring helpers", and a text match
+ * is the right answer for it — a project that shadows `@intentius/chant` in
+ * its own `node_modules` gets its own copy of `output()` invoked either way,
+ * fold or run, so fold cannot diverge from run by trusting the text here.
+ * #1093's question is "may this module execute in the CLI's process at all",
+ * where a specifier the project controls the text of proves nothing.
+ */
+function isChantOwnedHelperBinding(binding, ctx) {
+    if (isChantOwnedSpecifier(binding.specifier))
+        return true;
+    if (!isProjectImport(binding.specifier, ctx.file))
+        return false;
+    let targetPath;
+    try {
+        targetPath = resolveModulePathMemoized(binding.specifier, ctx.file, ctx.resolvePathCache);
+    }
+    catch {
+        return false;
+    }
+    return isChantCorePath(targetPath);
+}
+/**
+ * chant #1093 — the closed allowlist of modules fold may import AND EXECUTE
+ * in the CLI's own process when the #1045 sandbox is active. Exactly two
+ * arms, and neither of them trusts text the project controls:
+ *
+ *  1. **An ACTIVE lexicon package of this build, root OR subpath** — the
+ *     exact specifier matched against {@link FoldSession.lexiconPackages}, a
+ *     closed set built from the lexicon names the BUILD resolved and
+ *     `loadPlugins` already imported (../cli/plugins.ts), not from anything
+ *     the file under fold says; OR (chant #1995) a subpath of one of those
+ *     same packages (`@intentius/chant-lexicon-azure/generated/index`), whose
+ *     package ROOT is extracted from the specifier TEXT
+ *     ({@link bareSpecifierPackageRoot}, no resolution) and checked against
+ *     the identical set. A subpath is trusted because the code it names
+ *     belongs to a package the CLI already imported and executed to load that
+ *     lexicon's serializers/lint rules — reaching one of that package's own
+ *     modules by subpath instead of through the barrel names code the process
+ *     already trusts, not code the project controls.
+ *  2. **chant-core's own executing tree** — the specifier is RESOLVED and the
+ *     resulting path checked against {@link chantCoreRoots}. A text match is
+ *     not enough here: `@intentius/chant` and `@intentius/chant-lexicon-evil`
+ *     are both strings an untrusted repo can write into its own source and
+ *     back with its own `node_modules` directory, and
+ *     {@link isChantOwnedSpecifier} would accept either. Resolution happens
+ *     before the decision rather than after, so an allowed binding pays
+ *     exactly the resolution it was about to pay anyway (the memoized one —
+ *     see {@link resolveModulePathMemoized}); a bare specifier that isn't
+ *     even chant-shaped is rejected on text alone, so no arbitrary bare
+ *     specifier is ever resolved here (chant#1020's cold-resolution cost).
+ *
+ * This is deliberately the boundary chant #1045 drew: "the boundary is around
+ * executing PROJECT SOURCE, which is the untrusted input" — not around chant
+ * itself or the lexicon packages, which the CLI has already imported and
+ * executed in its own process before discovery starts, to get the serializers
+ * and lint rules it cannot run without. Fold reaching the same already-loaded
+ * module (the identical un-cache-busted `import()` of the identical resolved
+ * path) adds no execution the process wasn't already performing.
+ *
+ * Everything else is out: a sibling project file, a project-local helper
+ * module, an arbitrary npm dependency, a lexicon this build didn't load. A
+ * build that supplied no lexicon list keeps only arm 2, rather than falling
+ * back to something more permissive — the same stance
+ * {@link FoldSession.lexiconPackages} takes for #1063.
+ */
+function isTrustedExecutableBinding(binding, ctx) {
+    // chant#3090 — a specifier a tsconfig `paths` entry maps names a project
+    // file whatever its text says, so neither text arm applies to it: it is
+    // resolved and decided on the path below, like a relative specifier.
+    const pathsMapped = pathsMappedTarget(binding.specifier, ctx.file) !== undefined;
+    if (!pathsMapped && activeLexiconPackage(binding.specifier, ctx.lexiconPackages) !== undefined)
+        return true;
+    // chant #1995 — arm 1's subpath case: same allowlist, matched against the
+    // specifier's package ROOT (text only, see bareSpecifierPackageRoot) rather
+    // than the specifier itself, so `<activeLexiconPkg>/generated/index` is
+    // trusted exactly like the bare package import already is.
+    const subpathRoot = bareSpecifierPackageRoot(binding.specifier);
+    if (!pathsMapped && subpathRoot !== undefined && activeLexiconPackage(subpathRoot, ctx.lexiconPackages) !== undefined) {
+        return true;
+    }
+    // Only a chant-shaped or project-relative specifier is worth resolving; any
+    // other bare specifier is untrusted by definition, and resolving it to find
+    // that out would cost the pathological cold `require.resolve` (chant#1020).
+    if (!pathsMapped && !isProjectFileSpecifier(binding.specifier) && !isChantOwnedSpecifier(binding.specifier)) {
+        return false;
+    }
+    let targetPath;
+    try {
+        targetPath = resolveModulePathMemoized(binding.specifier, ctx.file, ctx.resolvePathCache);
+    }
+    catch {
+        return false;
+    }
+    // chant#2577 — arm 1 for a lexicon declared by path: the module
+    // `loadPlugins` already imported, reached by the path the project imports it by.
+    if (ctx.lexiconModules.has(targetPath))
+        return true;
+    // chant#2590 — the subpath case of the same arm: another file of a
+    // multi-file path lexicon, under its trusted directory.
+    if (inPathLexiconRoot(targetPath, ctx.lexiconRoots))
+        return true;
+    return isChantCorePath(targetPath);
+}
+/**
+ * chant #1093 — the one-line fold-fallback reason for a resolution that would
+ * import and execute an untrusted module in the CLI's own process, or
+ * `undefined` when the import may proceed (the sandbox wasn't asked for, or
+ * the module is on {@link isTrustedExecutableBinding}'s allowlist).
+ *
+ * A refusal is not a failure to fold something folder-shaped — the shape is
+ * perfectly foldable and folds fine under plain `--fold`. It is a deliberate
+ * demotion: the file falls back to the run path, and under `--sandbox` the
+ * run path is the sandboxed child (`./index.ts` queues every run-fallback
+ * file for `./sandbox/run.ts`). So the factory/constructor/intrinsic still
+ * executes, with the same arguments, in the same module graph as the rest of
+ * that file — just behind Node's Permission Model and a scrubbed environment
+ * instead of inside the CLI. Coverage drops; the boundary holds.
+ *
+ * @param what - What the binding is being resolved AS, for the message
+ *   ("composite factory", "constructor", …).
+ */
+function sandboxedExecutionRefusal(binding, ctx, name, what) {
+    if (!ctx.sandbox)
+        return undefined;
+    if (isTrustedExecutableBinding(binding, ctx))
+        return undefined;
+    return (`${what} "${name}" is imported from "${binding.specifier}", which is neither chant's own nor an active lexicon — ` +
+        `under --sandbox it is executed in the sandboxed child, not in this process`);
+}
+/**
+ * chant-core's own module roots, derived from THIS module's location:
+ * `packages/core/src` in this repo, and in a published install both
+ * `<pkg>/src` (where `@intentius/chant/*` specifiers resolve, through the
+ * package exports) and `<pkg>/dist` (where the compiled CLI runs from, #3878).
+ * Pure string arithmetic on `import.meta.url`, no filesystem access at all, so
+ * it is safe in the #1045 sandbox child (which locks reads to an allowlist);
+ * lazy and memoized purely to avoid doing it per call.
+ */
+let chantCoreRootsMemo;
+function chantCoreRoots() {
+    if (!chantCoreRootsMemo) {
+        // .../<root>/discovery/fold-import.{ts,js} -> .../<root>
+        const root = dirname(dirname(fileURLToPath(import.meta.url)));
+        const name = basename(root);
+        const sibling = name === "dist" ? join(dirname(root), "src") : name === "src" ? join(dirname(root), "dist") : undefined;
+        chantCoreRootsMemo = sibling ? [root, sibling] : [root];
+    }
+    return chantCoreRootsMemo;
+}
+/** Whether `path` is one of chant-core's own modules (see {@link chantCoreRoots}). */
+function isChantCorePath(path) {
+    return chantCoreRoots().some((root) => path === root || path.startsWith(root + sep));
+}
+/** Revive every value in a folded props/attributes object (see {@link reviveFoldedValue}). */
+async function reviveFoldedProps(props, ctx, requireLiveRefs) {
+    const revived = {};
+    for (const [key, value] of Object.entries(props)) {
+        revived[key] = await reviveFoldedValue(value, ctx, requireLiveRefs);
+    }
+    return revived;
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Resource construction — #1022's mechanism (fold the ctor call's arguments
+// via `fold()`, resolve the constructor through this file's imports,
+// construct the real Declarable), split by chant #1169 into two reusable
+// halves so a NESTED `new Type(...)` used as a value is built by exactly the
+// same code as a file's own top-level resource declaration, not by a second
+// implementation that could quietly differ.
+//
+// `resolveResourceEntity` below is the top-level entry point and keeps its
+// per-declarator reason strings verbatim; `reviveResourceCtorArgs` and
+// `instantiateFoldedResource` are the shared halves, and
+// {@link constructFoldedResource} is the one-call composition of the two that
+// `reviveFoldedValue` uses for a nested construction.
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * Revive a folded constructor call's arguments into the real values the class
+ * will receive.
+ *
+ * chant #1039 — replays any folded intrinsic/symbol envelopes into their real
+ * runtime values before the entity is constructed. A no-op walk when the file
+ * used no registered intrinsics (the overwhelming majority of cases today).
+ *
+ * chant #1082 — when `spec.args` is present the constructor's argument list
+ * isn't the classic `(props)`/`(props, attributes)` shape (AWS's `Parameter` is
+ * `(type, props)`), so the whole list is revived and spread by the caller
+ * instead of `spec.props`, which in that case is only a view onto one of its
+ * entries and would be double-counted.
+ */
+async function reviveResourceCtorArgs(spec, ctx, requireLiveRefs) {
+    if (spec.args) {
+        const revived = [];
+        for (const arg of spec.args)
+            revived.push(await reviveFoldedValue(arg, ctx, requireLiveRefs));
+        return revived;
+    }
+    const props = await reviveFoldedProps(spec.props, ctx, requireLiveRefs);
+    // The runtime constructor's optional second argument (`attributes` — CFN's
+    // DependsOn/Condition/DeletionPolicy/…, see createResource in ../runtime.ts)
+    // is only present in `spec` when the source actually passed one (see
+    // foldResource in ../fold/fold.ts). Passing `undefined` when it's absent
+    // matches the run path's own default (`attributes ?? {}` inside the
+    // constructor).
+    return [props, spec.attributes ? await reviveFoldedProps(spec.attributes, ctx, requireLiveRefs) : undefined];
+}
+/**
+ * Resolve a folded constructor's NAME through `ctx`'s own `import`
+ * declarations and call the real class with `ctorArgs`.
+ *
+ * Throws a {@link cheapError} for every failure; `resolveResourceEntity` turns
+ * those into its per-declarator `reason` strings and the nested path lets them
+ * fall the whole file back to run. `forClause` is the ` for "<export name>"`
+ * fragment the top-level messages carry and a nested construction has no name
+ * for — the only difference between the two callers' diagnostics.
+ */
+async function instantiateFoldedResource(typeName, ctorArgs, ctx, forClause) {
+    const binding = ctx.imports.get(typeName);
+    if (!binding) {
+        throw cheapError(`constructor "${typeName}"${forClause} is not a resolvable import`);
+    }
+    // chant #1093 — a resource class is a lexicon export in every corpus entry
+    // today, but nothing forces that: `new Thing(...)` where `Thing` comes from
+    // a project file (or an arbitrary dependency) would import and run that
+    // module here, in the CLI's process. Same refusal as the composite-factory
+    // path above, and the reason a nested construction cannot widen the #1093
+    // boundary: it reaches its class by exactly this gate.
+    const refusal = sandboxedExecutionRefusal(binding, ctx, typeName, "constructor");
+    if (refusal)
+        throw cheapError(refusal);
+    let modulePath;
+    try {
+        modulePath = resolveModulePathMemoized(binding.specifier, ctx.file, ctx.resolvePathCache);
+    }
+    catch (err) {
+        throw cheapError(`could not resolve import "${binding.specifier}" for "${typeName}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Same import mechanism as `resolveCallExpression` above — see its comment.
+    let mod;
+    try {
+        mod = await importModuleMemoized(modulePath, ctx.importCache);
+    }
+    catch (err) {
+        throw cheapError(`could not import "${binding.specifier}" to resolve "${typeName}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const Ctor = mod[binding.imported];
+    if (typeof Ctor !== "function") {
+        throw cheapError(`"${binding.imported}" from "${binding.specifier}" is not a constructor`);
+    }
+    // Constructed with exactly the arguments the source wrote.
+    return new Ctor(...ctorArgs);
+}
+/**
+ * chant #1169 — build a real instance from a nested `{__resource}` envelope:
+ * revive its arguments, then resolve its class and call it. The composition
+ * {@link reviveFoldedValue} reaches for; identical in every step to what
+ * {@link resolveResourceEntity} does for a top-level declaration, which is the
+ * point — a nested `new Image({...})` and a top-level `export const image = new
+ * Image({...})` produce the same object, from the same class, from the same
+ * resolved module path.
+ */
+async function constructFoldedResource(spec, ctx, requireLiveRefs) {
+    const ctorArgs = await reviveResourceCtorArgs(spec, ctx, requireLiveRefs);
+    return instantiateFoldedResource(spec.__resource, ctorArgs, ctx, "");
+}
+/**
+ * chant #1169 — construct every top-level `const x = new Type(...)` in the file
+ * ONCE, in source order, before any exported declarator is resolved, and put
+ * each instance in `ctx.externals` under its own name.
+ *
+ * This is what makes a same-file resource usable as a VALUE — `image:
+ * nodeImage`, `DependsOn: [dbCluster]`, `export { app }` — and it is the half
+ * of the #1169 gate the nested-`new` lift alone does not reach: the
+ * `{__resource}` envelope covers a construction written INLINE at the value
+ * position, while the far more common authoring shape names it once and refers
+ * to it. `fold()` cannot answer that reference on its own (it is synchronous,
+ * and constructing needs the module graph), so it defers to `externals` — see
+ * its identifier branch for the full argument.
+ *
+ * ONE instance, and identity is the whole point. Every reference in the file
+ * reads this map, and the exported-declarator loop reuses the same object
+ * through `prebuilt` rather than constructing a second one, so a resource
+ * referenced by name and the entity discovery registers are the same object —
+ * which is what makes the serializer's `Ref`/`DependsOn` resolution land on a
+ * logical name at all. Running the module top-to-bottom produces exactly this:
+ * every top-level `const` evaluated once, in order, later ones seeing earlier
+ * ones. Order matters and is preserved — `collectConsts` yields source order, so
+ * `const b = new Thing({ x: a })` finds `a` already built.
+ *
+ * A construction that FAILS is skipped silently rather than failing the file:
+ * the name stays absent from `externals`, so a reference to it rejects with the
+ * identical message it produced before this existed, and an EXPORTED one falls
+ * through to {@link resolveResourceEntity}, which reproduces the failure with
+ * its own located reason. Strictly additive.
+ *
+ * Under `--sandbox` every construction here goes through the same
+ * {@link sandboxedExecutionRefusal} as every other one, so a project-defined
+ * class refuses, the name stays unresolved, and the file demotes to the
+ * sandboxed child exactly as before. Under plain `--fold` this can import a
+ * constructor's module for a const that is never exported — work the RUN path
+ * performs unconditionally for the same file, and through the same
+ * already-memoized `importModule`.
+ */
+/**
+ * The local names this file bound to the build's parameter object (chant
+ * #1443). Object identity against {@link FoldSession.buildParams}, which
+ * `buildExternals` substituted directly, so an unrelated import that happens to
+ * be called `params` is not mistaken for it.
+ */
+function paramLocalNames(ctx) {
+    const out = new Set();
+    const buildParams = ctx.session.buildParams;
+    if (!buildParams)
+        return out;
+    for (const [name, value] of ctx.externals) {
+        if (value === buildParams)
+            out.add(name);
+    }
+    return out;
+}
+/**
+ * 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 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, node, ctx) {
+    if (typeof entity !== "object" || entity === null)
+        return;
+    const paramLocals = paramLocalNames(ctx);
+    const host = {
+        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;
+    for (const argument of node.arguments ?? []) {
+        if (ts.isObjectLiteralExpression(argument)) {
+            propsArg = argument;
+            break;
+        }
+    }
+    if (!propsArg)
+        return;
+    for (const [path, origin] of Object.entries(collectParamDependencies(propsArg, ctx.consts, paramLocals, host))) {
+        setPathProvenance(entity, path, origin);
+    }
+}
+async function preresolveResourceConsts(ctx) {
+    const built = new Map();
+    for (const [name, initializer] of ctx.consts) {
+        // chant #3196 — a same-file `const x = tag\`...\`` for a registered tag
+        // is built once here too, so the export and every reference to `x` share
+        // the one value running the module gives them. That matters when the tag
+        // returns an entity (a SQL `table\`...\``): a second call would build a
+        // second entity discovery never registers.
+        if (ts.isTaggedTemplateExpression(initializer) &&
+            ts.isIdentifier(initializer.tag) &&
+            ctx.intrinsics.some((i) => i.name === initializer.tag.text && intrinsicTagFolds(i))) {
+            try {
+                const value = await reviveFoldedValue(fold(initializer, ctx.consts, ctx.intrinsics, ctx.externals), ctx, false);
+                built.set(initializer, value);
+                // Only a value `reviveFoldedValue` passes through unchanged is safe to
+                // hand a reference. Any other object would be walked into a plain
+                // copy, so a reference to one keeps re-folding the initializer.
+                if (revivesAsItself(value))
+                    ctx.externals.set(name, value);
+            }
+            catch (err) {
+                ctx.prebuildFailures?.set(name, describeFoldFailure(err, ctx));
+            }
+            continue;
+        }
+        if (!ts.isNewExpression(initializer) || !ts.isIdentifier(initializer.expression))
+            continue;
+        try {
+            const spec = foldResource(initializer, ctx.consts, ctx.intrinsics, ctx.externals);
+            const instance = await constructFoldedResource(spec, ctx, false);
+            stampParamDependencies(instance, initializer, ctx);
+            built.set(initializer, instance);
+            ctx.externals.set(name, instance);
+        }
+        catch (err) {
+            // Not constructible here (an unresolvable constructor import, a prop
+            // outside the fold subset, a --sandbox refusal). Leave the name alone:
+            // the failure is deliberately not fatal, and the first reference to the
+            // name rejects on its own terms.
+            //
+            // chant#2423 — but keep the located reason. Without it the file's only
+            // reported cause is the reference site, which is where the consequence
+            // is, not where the problem is.
+            ctx.prebuildFailures?.set(name, describeFoldFailure(err, ctx));
+        }
+    }
+    return built;
+}
+async function resolveResourceEntity(name, node, ctx) {
+    let spec;
+    try {
+        spec = foldResource(node, ctx.consts, ctx.intrinsics, ctx.externals);
+    }
+    catch (err) {
+        if (err instanceof FoldError) {
+            return { ok: false, reason: `"${name}" is not foldable: ${describeFoldFailure(err, ctx)}` };
+        }
+        throw err;
+    }
+    let ctorArgs;
+    try {
+        ctorArgs = await reviveResourceCtorArgs(spec, ctx, false);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: `"${name}" is not foldable: ${describeFoldFailure(err, ctx)}`,
+        };
+    }
+    try {
+        const entity = (await instantiateFoldedResource(spec.__resource, ctorArgs, ctx, ` for "${name}"`));
+        stampParamDependencies(entity, node, ctx);
+        return { ok: true, entity };
+    }
+    catch (err) {
+        return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Cross-file resolution (chant #1020) — resolves an imported PROJECT-file
+// binding to its real, already-constructed value by recursively folding the
+// DEFINING module (in that module's own scope: its own consts, its own
+// imports), memoized per {@link FoldSession} so each cross-file export folds
+// exactly once and every referrer shares the identical object — see
+// `planFoldTaint`'s doc below for why that identity is the entire hard part.
+// A bare package specifier (a lexicon/vendor module) is left alone here: it
+// resolves through the pre-existing `importModule` mechanism at the point a
+// constructor/composite-factory/intrinsic tag is actually used, same as
+// before #1020 — this path exists only to avoid executing PROJECT files.
+// ─────────────────────────────────────────────────────────────────────────
+const UNRESOLVED_IDENTIFIER_RE = /unresolved identifier: (\S+)$/;
+/** The rejection a reference to a const whose pre-build failed produces (chant#2423). */
+const SAME_FILE_RESOURCE_RE = /same-file resource `([^`]+)` used as a value is not foldable/;
+/**
+ * Enrich an otherwise-generic "unresolved identifier: X" failure when X is a
+ * name whose OWN cross-file resolution was attempted and failed for a known
+ * reason (most notably an import cycle) — purely cosmetic, never changes
+ * whether something resolves. Every other failure shape passes through
+ * unchanged.
+ */
+function describeFoldFailure(err, ctx) {
+    if (!(err instanceof Error))
+        return String(err);
+    const match = UNRESOLVED_IDENTIFIER_RE.exec(err.message);
+    if (match) {
+        const reason = ctx.crossFileFailures.get(match[1]);
+        if (reason)
+            return `${err.message} (${reason})`;
+    }
+    // chant#2423 — the reference rejected because the pre-build never produced
+    // the instance. Say what stopped the pre-build, at the line it stopped on.
+    const sameFile = SAME_FILE_RESOURCE_RE.exec(err.message);
+    if (sameFile) {
+        const cause = ctx.prebuildFailures?.get(sameFile[1]);
+        if (cause)
+            return `${err.message} (${cause})`;
+    }
+    return err.message;
+}
+/**
+ * chant #1054 — a short, single-line label for a destructured export's
+ * source expression, for a fold fallback reason: the callee plus `(...)`
+ * for the common composite-call source (`GkeCluster(...)`), or a brief,
+ * bounded rendering of whatever else it is otherwise. Never the source's own
+ * `getText()` — for a real composite call that's the entire multi-line
+ * argument list.
+ */
+function describeDestructureSource(node) {
+    return ts.isCallExpression(node) ? `${briefNodeText(node.expression)}(...)` : briefNodeText(node);
+}
+/** Build a located `FoldError`'s formatted "line:col - message" string anchored at `node` — for a cross-file failure detected here in fold-import.ts (an import cycle, a name genuinely absent from the target module's exports) rather than inside `fold()` itself. */
+function locatedMessage(node, message) {
+    const { line, column } = locate(node);
+    return new FoldError(message, line, column).message;
+}
+/**
+ * Fold `file` with session-wide memoization and cycle detection. The SAME
+ * promise is handed back to every caller that asks for `file` within one
+ * session — `discover()`'s own top-level per-file loop AND any cross-file
+ * reference that reaches into `file` alike — so `file` is folded exactly
+ * once and every referrer shares the identical constructed entities.
+ */
+/**
+ * A backstop, not a realistic limit: no legitimate project should have an
+ * import chain this deep. Exists purely so a FUTURE regression that breaks
+ * memoization (e.g. caching by the wrong key, or checking `stack` after
+ * awaiting instead of before) fails loudly and immediately with a
+ * diagnosable error, instead of recursing until the process runs out of
+ * stack/memory or simply never terminates — a correctness bug in this exact
+ * function is a termination hazard, not just a wrong-answer one, since
+ * `foldFileMemoized` is the one place cross-file resolution can recurse.
+ */
+const MAX_RESOLUTION_DEPTH = 200;
+function foldFileMemoized(file, session) {
+    const cycleStart = session.stack.indexOf(file);
+    if (cycleStart !== -1) {
+        // A file currently being resolved (an ancestor of this very call, still
+        // on the stack) is needed again — a genuine reference cycle, not merely
+        // two files that happen to import each other with no real value
+        // dependency (that could never re-enter here for an ancestor). The
+        // caller ({@link buildExternals}/the re-export declarator handler, which
+        // has the referencing import's own specifier node) attaches a source
+        // position to this via {@link locatedMessage}; here we only have the
+        // file-level chain to name.
+        const cycle = [...session.stack.slice(cycleStart), file].map((f) => basename(f));
+        return Promise.resolve({ ok: false, reason: `import cycle: ${cycle.join(" -> ")}` });
+    }
+    const cached = session.cache.get(file);
+    if (cached)
+        return cached;
+    if (session.stack.length >= MAX_RESOLUTION_DEPTH) {
+        const chain = [...session.stack.slice(-5), file].map((f) => basename(f));
+        return Promise.resolve({
+            ok: false,
+            reason: `cross-file resolution depth exceeded ${MAX_RESOLUTION_DEPTH} ` +
+                `(...-> ${chain.join(" -> ")}) — this is almost certainly a resolution ` +
+                `bug (memoization not taking effect), not a genuinely thousand-file-deep import chain`,
+        });
+    }
+    session.stack.push(file);
+    const promise = tryFoldFileCore(file, session).finally(() => {
+        const idx = session.stack.lastIndexOf(file);
+        if (idx !== -1)
+            session.stack.splice(idx, 1);
+    });
+    session.cache.set(file, promise);
+    return promise;
+}
+/** True for a relative or absolute specifier — a sibling PROJECT file, as opposed to a bare package specifier (an installed lexicon/vendor module). */
+function isProjectFileSpecifier(specifier) {
+    return specifier.startsWith(".") || isAbsolute(specifier);
+}
+/**
+ * chant#3090 — {@link isProjectFileSpecifier} for an import in `fromFile`,
+ * counting a bare specifier that a tsconfig `paths` entry maps to a file
+ * ({@link pathsMappedTarget}) as the project file it names.
+ */
+function isProjectImport(specifier, fromFile) {
+    return isProjectFileSpecifier(specifier) || pathsMappedTarget(specifier, fromFile) !== undefined;
+}
+/**
+ * Eagerly resolve every project-file import binding of `file`'s to its real
+ * cross-file value (see this section's own doc above). A binding that isn't
+ * a project-file specifier, doesn't resolve to a file on disk, or whose
+ * target doesn't fold or doesn't actually export the requested name is
+ * simply left OUT of `externals` — exactly like a name that was never
+ * imported at all, `fold()`'s ordinary "unresolved identifier" failure still
+ * fires if (and only if) that name is actually referenced. `failures`
+ * records WHY, purely to enrich that later message (see
+ * {@link describeFoldFailure}).
+ */
+async function buildExternals(file, imports, namespaceImports, session, 
+/**
+ * chant#3247 — trusted lexicon directories beyond the session's own
+ * {@link FoldSession.lexiconRoots}: the package root of a lexicon-package
+ * composite whose defining module this is. Files under one are treated as
+ * a path lexicon's are, never folded as project files.
+ */
+extraLexiconRoots = []) {
+    const lexiconRoots = extraLexiconRoots.length === 0 ? session.lexiconRoots : [...session.lexiconRoots, ...extraLexiconRoots];
+    const externals = new Map();
+    const failures = new Map();
+    // chant #1044 — see `FoldFileResult.liveSources`.
+    const liveSources = new Set();
+    const hostValues = new Set();
+    for (const [localName, binding] of imports) {
+        // chant #1064 — a named `params` import that resolves to chant-core's own
+        // build-time-parameters module (../params.ts) is substituted directly
+        // from this build's already-resolved values, with NO import performed —
+        // so `params.tier` folds to a LITERAL rather than a symbolic node
+        // (contrast the `{__symbol}` deferral a pseudo-parameter namespace import
+        // like `AWS.StackName` gets — that genuinely can't resolve until a real
+        // module runs; a build parameter's value is already fully known here).
+        //
+        // A BARE specifier is recognized by an exact TEXT match against the one
+        // real published subpath ({@link PARAMS_BARE_SPECIFIER}), NEVER by
+        // resolving it: `resolveModulePathMemoized`'s bare-specifier branch falls
+        // through to Node's own package resolution
+        // (`createRequire(fromFile).resolve(specifier)`), which chant#1020's own
+        // fix-history (see this module's other comments) measured at up to ~361s
+        // for the FIRST resolution of a genuinely new bare specifier in a
+        // process — a cost `buildExternals` previously never paid at all for
+        // bare specifiers (the pre-#1064 code skipped them outright). Since
+        // `binding.imported === "params"` alone says nothing about which package
+        // a project actually imported from, resolving EVERY such bare specifier
+        // to check it would reintroduce exactly that pathological cost for any
+        // corpus/project file that happens to import a same-named binding from
+        // an unrelated package — a real, measured regression this text-match
+        // avoids entirely (no filesystem/package resolution for a bare
+        // specifier, ever, in this branch).
+        //
+        // A RELATIVE/ABSOLUTE specifier is still resolved and path-compared
+        // against {@link paramsModulePath} — that resolution is always cheap
+        // (`existsSync`/`statSync` candidate probing, never Node's package
+        // resolution), so it's safe for this module's own absolute-path test
+        // fixtures to exercise the identical substitution a real bare import
+        // takes, without the bare-specifier cost concern applying.
+        if (session.buildParams && binding.imported === "params") {
+            if (binding.specifier === PARAMS_BARE_SPECIFIER) {
+                externals.set(localName, session.buildParams);
+                continue;
+            }
+            if (isProjectImport(binding.specifier, file)) {
+                try {
+                    const targetPath = resolveModulePathMemoized(binding.specifier, file, session.resolvePathCache);
+                    if (targetPath === paramsModulePath()) {
+                        externals.set(localName, session.buildParams);
+                        continue;
+                    }
+                }
+                catch {
+                    // Unresolvable specifier — fall through to the ordinary handling
+                    // below, same as any other import this loop can't resolve.
+                }
+            }
+        }
+        if (!isProjectImport(binding.specifier, file)) {
+            // chant #1063 — a bare specifier naming one of THIS BUILD's active
+            // lexicon packages resolves to that package's real export, so a plain
+            // data export a lexicon publishes (`Azure`/`GCP`'s pseudo-parameter
+            // namespaces, AWS's `S3Actions`, gitlab's `CI`) is an ordinary
+            // identifier value here rather than fold's most common remaining
+            // "unresolved identifier" failure. See
+            // {@link resolveActiveLexiconExport} for the allowlist, the no-cold-
+            // resolution rule, and why callable exports stay out.
+            //
+            // No `liveSources` edge is recorded for what comes back, unlike the
+            // project-file case just below. `liveSources` (chant #1044) exists so
+            // that a folded file which captured ANOTHER FILE's objects is
+            // invalidated when that file is forced back to run — a fold/run
+            // disagreement about identity. A lexicon package has no such duality:
+            // it is not a discovered source file, `planFoldTaint` never considers
+            // it (it filters to the discovered `files` set), it never falls back to
+            // run, and both paths reach it through the identical un-cache-busted
+            // `import()` of the identical resolved path — so the object fold
+            // captures IS the object the run path holds. There is nothing for the
+            // two sides to disagree about, hence nothing to taint.
+            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
+            // this build didn't load) is left alone here, exactly as before #1064:
+            // it resolves lazily, through the pre-existing `importModule`
+            // mechanism, only once a constructor/composite-factory/intrinsic tag
+            // actually consumes it.
+            //
+            // chant#3090 — except that a tsconfig `paths` entry which matches the
+            // specifier but names no file is recorded, so the reason says which
+            // import failed and why.
+            const unmatched = pathsMatch(binding.specifier, file);
+            if (unmatched) {
+                failures.set(localName, locatedMessage(binding.specifierNode, `tsconfig paths entry "${unmatched.key}" matches "${binding.specifier}" but names no file`));
+            }
+            continue;
+        }
+        let targetPath;
+        try {
+            targetPath = resolveModulePathMemoized(binding.specifier, file, session.resolvePathCache);
+        }
+        catch {
+            continue;
+        }
+        // chant#2577 — a path-declared lexicon is a lexicon, not a project file:
+        // resolve its data export the way the bare-specifier branch above does,
+        // 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);
+                hostValues.add(localName);
+            }
+            continue;
+        }
+        // chant#2590 — another file of a multi-file path lexicon is a lexicon
+        // subpath, not a project file: it is not folded, and like a package
+        // subpath (see the bare-specifier branch above) its data exports are not
+        // read as values. A constructor or composite from it resolves through the
+        // import path, where `isTrustedExecutableBinding` admits it.
+        //
+        // chant#3247 — a file of the lexicon PACKAGE whose composite is being
+        // interpreted is that package's own module, which `loadPlugins` already
+        // imported through the package's barrel. Its plain data exports (an
+        // action table, a policy constant) are read off the real module, so the
+        // value is the run path's own object, identity included. Callables stay
+        // out, as {@link resolveActiveLexiconExport} keeps them out: a
+        // 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);
+                hostValues.add(localName);
+            }
+            continue;
+        }
+        if (inPathLexiconRoot(targetPath, lexiconRoots))
+            continue;
+        const result = await foldFileMemoized(targetPath, session);
+        if (!result.ok) {
+            failures.set(localName, locatedMessage(binding.specifierNode, result.reason));
+            continue;
+        }
+        if (result.exportedValues.has(binding.imported)) {
+            const value = result.exportedValues.get(binding.imported);
+            externals.set(localName, value);
+            if (hasObjectIdentity(value))
+                liveSources.add(targetPath);
+        }
+        else {
+            failures.set(localName, locatedMessage(binding.specifierNode, `"${binding.imported}" is not exported by "${binding.specifier}"`));
+        }
+    }
+    for (const [localName, binding] of namespaceImports) {
+        if (!isProjectImport(binding.specifier, file))
+            continue;
+        let targetPath;
+        try {
+            targetPath = resolveModulePathMemoized(binding.specifier, file, session.resolvePathCache);
+        }
+        catch {
+            continue;
+        }
+        // chant#2577 — a namespace import of a lexicon is left alone, as the
+        // bare-specifier check above leaves a package's alone.
+        if (session.lexiconModules.has(targetPath) || inPathLexiconRoot(targetPath, lexiconRoots))
+            continue;
+        const result = await foldFileMemoized(targetPath, session);
+        if (!result.ok) {
+            failures.set(localName, locatedMessage(binding.specifierNode, result.reason));
+            continue;
+        }
+        // A plain object wrapping the target's own exported values — property
+        // access on it (`ns.someExport`) is then just an ordinary bracket index,
+        // exactly like on a real composite instance (see `isIndexableObject`).
+        externals.set(localName, Object.fromEntries(result.exportedValues));
+        for (const value of result.exportedValues.values()) {
+            if (hasObjectIdentity(value)) {
+                liveSources.add(targetPath);
+                break;
+            }
+        }
+    }
+    return { externals, failures, liveSources, hostValues };
+}
+/**
+ * True when `value` is something whose IDENTITY matters across the
+ * fold/run boundary — any object or function, as opposed to a primitive
+ * (chant #1044). Deliberately coarse: an object that merely *contains* a
+ * `Declarable` is as identity-bearing as the Declarable itself, and cheaply
+ * treating every object as such avoids a deep walk whose only payoff would
+ * be keeping a handful of extra files folded inside an entry that already
+ * falls back. See {@link FoldFileResult.liveSources}.
+ */
+function hasObjectIdentity(value) {
+    // chant #1373 — a foldable-function marker is a description of source, not
+    // an object the run path could hold a different copy of: a call to it
+    // produces the same value folded or run. No identity to disagree about.
+    if (isFoldableFunction(value))
+        return false;
+    return value !== null && (typeof value === "object" || typeof value === "function");
+}
+/**
+ * Resolve a declarator's initializer to its final value: first via the
+ * "live spine" ({@link resolveLiveValue} — same-file composite-call
+ * navigation, and, chant #1020, a cross-file identifier/property-access
+ * chain through `ctx.externals`); when that shape isn't recognized at all
+ * (a plain literal, object/array literal, template, binary expression, …),
+ * via the general reducer ({@link fold} + intrinsic revival) — chant #1020:
+ * this is what lets `export const REGION = "us-east-1";` (and an IMPORTED
+ * REGION used the same way) fold, not just a `new Type(...)`/composite-call
+ * shape. Throws when a shape WAS recognized but resolution genuinely failed
+ * (unresolved import, non-function import, a nested argument's own fold
+ * failed, an unresolved identifier, …) — the caller falls the whole file
+ * back to run, exactly as before #1020.
+ */
+async function resolveDeclaratorValue(node, ctx) {
+    // chant#3325 — memoized, so an exported `const x = Composite(...)` and a
+    // reference to `x` elsewhere in the file hold the one instance.
+    const live = await resolveMemoized(node, ctx);
+    if (live !== undefined)
+        return live;
+    const folded = fold(node, ctx.consts, ctx.intrinsics, ctx.externals);
+    return { value: await reviveFoldedValue(folded, ctx, false) };
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Entry point.
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * Attempt to fold one source file with zero execution of its own top-level
+ * code, sharing `session`'s cross-file memoization (chant #1020) — see
+ * {@link foldFileMemoized}. Internal; {@link tryFoldFile} is the public
+ * entry point below.
+ */
+async function tryFoldFileCore(file, session) {
+    // chant #1373 — chant-core's own modules are library code, not project
+    // source: their exports are reached by importing them (a helper, a
+    // constructor, `params`), never by folding their bodies. Before #1373 every
+    // one of them happened to disqualify itself at the scan (each exports a
+    // function); now that an exported function is a foldable shape, the
+    // exclusion has to be explicit, or a fixture/in-repo import by path would
+    // walk fold into chant's own tree and fold `params` to an empty object.
+    {
+        if (isChantCorePath(file)) {
+            return { ok: false, reason: "chant's own module is not project source" };
+        }
+    }
+    try {
+        const source = await readFile(file, "utf-8");
+        const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, /* setParentNodes */ true);
+        const scan = scanExports(sourceFile);
+        if (scan.unfoldableReason)
+            return { ok: false, reason: scan.unfoldableReason };
+        if (scan.declarators.length === 0)
+            return { ok: false, reason: "no foldable resource exports" };
+        const collected = collectImports(sourceFile);
+        const { externals, failures, liveSources, hostValues } = await buildExternals(file, collected.named, collected.namespaces, session);
+        const ctx = {
+            file,
+            consts: collectConsts(sourceFile),
+            locals: collectLocalBindings(sourceFile),
+            imports: collected.named,
+            namespaceImports: collected.namespaces,
+            memo: new Map(),
+            intrinsics: session.intrinsics,
+            externals,
+            hostValues,
+            crossFileFailures: failures,
+            importCache: session.importCache,
+            resolvePathCache: session.resolvePathCache,
+            lexiconPackages: session.lexiconPackages,
+            lexiconModules: session.lexiconModules,
+            lexiconRoots: session.lexiconRoots,
+            sandbox: session.sandbox,
+            executing: session.executing,
+            session,
+            interpretDepth: 0,
+            // chant#2423 — filled by the pre-build below, read by
+            // `describeFoldFailure` when a reference rejects for a const it could
+            // not build.
+            prebuildFailures: new Map(),
+        };
+        // chant #1169 — every same-file `const x = new Type(...)`, built once, in
+        // source order, before anything references one. See
+        // {@link preresolveResourceConsts}.
+        const prebuiltResources = await preresolveResourceConsts(ctx);
+        // chant #1373 — this file's own functions, callable from its own folds
+        // (and, once exported, from an importer's). Registered after the
+        // resource pre-pass so a marker never shadows a pre-built instance; a
+        // function and a const cannot share a name in valid TypeScript anyway.
+        const localFunctions = collectLocalFunctions(sourceFile, ctx);
+        for (const [name, marker] of localFunctions) {
+            if (!ctx.externals.has(name))
+                ctx.externals.set(name, marker);
+        }
+        const entities = [];
+        const exportedValues = new Map();
+        for (const decl of scan.declarators) {
+            if (decl.kind === "function") {
+                applyResolvedValue(decl.name, localFunctions.get(decl.name), entities, exportedValues);
+                continue;
+            }
+            if (decl.kind === "resource") {
+                // chant #1169 — the pre-pass already built this exact node. Reuse that
+                // instance rather than constructing a second one: a sibling prop that
+                // referenced this resource by name holds the pre-pass object, and if
+                // the entity discovery registers were a different one, the reference
+                // would have no logical name to resolve against.
+                const prebuilt = prebuiltResources.get(decl.node);
+                if (prebuilt !== undefined) {
+                    applyResolvedValue(decl.name, prebuilt, entities, exportedValues);
+                    continue;
+                }
+                const result = await resolveResourceEntity(decl.name, decl.node, ctx);
+                if (!result.ok)
+                    return result;
+                applyResolvedValue(decl.name, result.entity, entities, exportedValues);
+                continue;
+            }
+            if (decl.kind === "single") {
+                // chant #1373 — `export const f = (…) => …` exports the function
+                // marker, exactly like `export function f`; so does an alias of one
+                // (`export const g = f`, `f` declared here or imported).
+                const aliased = ts.isIdentifier(decl.node) ? ctx.externals.get(decl.node.text) : undefined;
+                const marker = localFunctions.get(decl.name) ?? (isFoldableFunction(aliased) ? aliased : undefined);
+                if (marker) {
+                    applyResolvedValue(decl.name, marker, entities, exportedValues);
+                    continue;
+                }
+                // chant #3196 — a registered tagged template the pre-pass built.
+                if (prebuiltResources.has(decl.node)) {
+                    applyResolvedValue(decl.name, prebuiltResources.get(decl.node), entities, exportedValues);
+                    continue;
+                }
+                let value;
+                try {
+                    value = (await resolveDeclaratorValue(decl.node, ctx)).value;
+                }
+                catch (err) {
+                    return { ok: false, reason: `"${decl.name}" is not foldable: ${describeFoldFailure(err, ctx)}` };
+                }
+                applyResolvedValue(decl.name, value, entities, exportedValues);
+                continue;
+            }
+            if (decl.kind === "destructure") {
+                let value;
+                // chant #1054 — identify the destructured export by its BINDING
+                // NAMES and the source's callee (`"cluster, nodePool" (destructured
+                // from GkeCluster(...))`), never `decl.node.getText()`: for a real
+                // composite call that's the entire multi-line source, which buries
+                // the actual error after it and breaks any line-oriented consumer of
+                // `[fold:run]` output.
+                const boundNames = decl.elements.map((el) => el.bindingName).join(", ");
+                const source = describeDestructureSource(decl.node);
+                try {
+                    value = (await resolveDeclaratorValue(decl.node, ctx)).value;
+                }
+                catch (err) {
+                    return {
+                        ok: false,
+                        reason: `"${boundNames}" (destructured from ${source}) is not foldable: ${describeFoldFailure(err, ctx)}`,
+                    };
+                }
+                if (!isIndexableObject(value)) {
+                    return {
+                        ok: false,
+                        reason: `"${boundNames}" (destructured from ${source}) is not foldable: not a composite call or object`,
+                    };
+                }
+                for (const { propKey, bindingName } of decl.elements) {
+                    applyResolvedValue(bindingName, value[propKey], entities, exportedValues);
+                }
+                continue;
+            }
+            if (decl.kind === "named-export") {
+                // Reuses resolveDeclaratorValue's own identifier handling
+                // (ctx.locals/ctx.externals lookup + memoized destructured-member
+                // extraction) rather than duplicating it here.
+                for (const { localNameNode, exportedName } of decl.elements) {
+                    // chant #1373 — `function f() {…}; export { f }`.
+                    const marker = localFunctions.get(localNameNode.text);
+                    if (marker) {
+                        applyResolvedValue(exportedName, marker, entities, exportedValues);
+                        continue;
+                    }
+                    let value;
+                    try {
+                        value = (await resolveDeclaratorValue(localNameNode, ctx)).value;
+                    }
+                    catch (err) {
+                        return { ok: false, reason: `exported "${exportedName}" is not foldable: ${describeFoldFailure(err, ctx)}` };
+                    }
+                    applyResolvedValue(exportedName, value, entities, exportedValues);
+                }
+                continue;
+            }
+            // decl.kind === "re-export" (chant #1020) — resolve each element
+            // through the target module's OWN fold, memoized via the session
+            // exactly like any other cross-file reference (see `foldFileMemoized`
+            // above); a cycle surfaces here too since a re-export is just another
+            // edge in the same module graph.
+            let targetPath;
+            try {
+                targetPath = resolveModulePathMemoized(decl.specifier, file, session.resolvePathCache);
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    reason: `could not resolve re-export "${decl.specifier}": ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+            const result = await foldFileMemoized(targetPath, session);
+            if (!result.ok) {
+                return {
+                    ok: false,
+                    reason: `re-export from "${decl.specifier}" is not foldable: ${locatedMessage(decl.specifierNode, result.reason)}`,
+                };
+            }
+            for (const { imported, exportedName } of decl.elements) {
+                if (!result.exportedValues.has(imported)) {
+                    return {
+                        ok: false,
+                        reason: locatedMessage(decl.specifierNode, `"${imported}" is not exported by "${decl.specifier}"`),
+                    };
+                }
+                const value = result.exportedValues.get(imported);
+                // chant #1044 — a re-export hands another file's OBJECT straight
+                // through under this file's name, so it is a live-identity edge
+                // exactly like an imported binding is (see `liveSources`).
+                if (hasObjectIdentity(value))
+                    liveSources.add(targetPath);
+                applyResolvedValue(exportedName, value, entities, exportedValues);
+            }
+        }
+        return { ok: true, entities, exportedValues, liveSources };
+    }
+    catch (err) {
+        // Any unexpected failure degrades to "fall back to run" rather than
+        // taking discovery down with it — fold is opt-in, not a new failure mode.
+        return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Attempt to fold one source file with zero execution of its own top-level
+ * code. Returns the folded, instantiated entities on success, or a reason
+ * to fall back to the run path (`importModule`) on the first construct
+ * outside the fold subset.
+ *
+ * @param intrinsics - Lexicon-registered intrinsic tags (chant #1039), e.g.
+ *   AWS's `Sub`. Threaded down to {@link fold}/{@link foldResource} so a
+ *   registered tagged template folds instead of unconditionally throwing
+ *   "unregistered tagged template intrinsic". Defaults to none — the caller
+ *   (`discover()`, ultimately `chant build --fold`) is expected to pass the
+ *   target lexicons' combined `intrinsics()`. Ignored when `session` is
+ *   given (its own `intrinsics`, fixed at creation, apply instead).
+ * @param session - chant #1020: share ONE {@link FoldSession} across every
+ *   file in a build (as `discover()` does) so a project file imported by
+ *   several others folds exactly once and every referrer shares the same
+ *   constructed entities — see {@link FoldSession}'s doc. Omit for a
+ *   standalone, single-file fold attempt (creates a private session scoped
+ *   to just this call — a cross-file reference reachable from `file` still
+ *   resolves, just without sharing its cache with any other top-level call).
+ */
+export async function tryFoldFile(file, intrinsics = [], session) {
+    return foldFileMemoized(file, session ?? createFoldSession(intrinsics));
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Cross-file fold/run identity hazard (#1023).
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * A file that folds successfully in isolation must still be forced back to
+ * run if some OTHER discovered file — one that itself falls back to run —
+ * imports it (directly, or transitively through another sibling file it
+ * imports). Composite folding is what makes this reachable: `network.ts`
+ * exporting `export const network = VpcDefault({})` folds cleanly on its
+ * own (no cross-file reference needed), landing its Declarables (`vpc`, its
+ * subnets, …) in `entities` as ONE set of real objects, built by literally
+ * invoking `VpcDefault` from inside `tryFoldFile` — bypassing `network.ts`
+ * as a module entirely (that's the whole point of folding it).
+ *
+ * Before chant #1020, a sibling file like `alb.ts` that did
+ * `import { network } from "./network"; ... vpcId: network.vpc.VpcId`
+ * could never fold that cross-file reference and fell back to run — but
+ * running `alb.ts` for real re-executes `import "./network"` for real too,
+ * which (via Node's module cache) produces the SAME `network.ts` module
+ * instance for every OTHER run-fallback file that imports it, but a
+ * DIFFERENT one than the object `tryFoldFile("network.ts")` already built.
+ * `alb.ts`'s AttrRef for `network.vpc.VpcId` then points at an object
+ * that's never in the `entities` map (only the folded one is), so it can
+ * never be assigned a logical name and serialization fails outright — not
+ * drift, a crash.
+ *
+ * The fix: fold and run must never disagree about which object identity a
+ * given file's exports have. Since `network.ts` itself doesn't need
+ * anything cross-file to fold (only a file's own successful fold could ever
+ * reach this taint — an unresolvable cross-file reference already fails
+ * that file's OWN fold attempt), the safe rule is to force `network.ts`
+ * back to run too, so both `alb.ts`'s real import and `network.ts`'s own
+ * discovery entry resolve through the exact same `importModule` call and
+ * share the exact same singleton module instance. This has to propagate
+ * transitively (if `alb.ts` itself is only reachable by importing a file
+ * that imports `network.ts`), so this is a forward-reachability walk over
+ * the discovered files' relative-import graph, seeded from every file that
+ * doesn't fold on its own.
+ *
+ * chant #1044 adds the OTHER half of the same hazard, in the opposite
+ * direction along the same edges. Forward taint covers "a run file imports a
+ * folded file"; it does not cover "a FOLDED file consumed the objects of a
+ * file that later got forced to run". Once a plain-call intrinsic can fold,
+ * that second case is easy to reach: in `lexicons/aws/examples/lambda-api`,
+ * `health-api.ts` folds and captures `params.ts`'s real `Parameter` instance
+ * through `Ref(environment)`, while `params.ts` itself is forced to run
+ * because a DIFFERENT sibling (`data-bucket.ts`) imports it and falls back.
+ * Discovery then collects the run instance and serializes the folded one —
+ * the same "Logical name not set" crash described above, arriving from the
+ * other side. So `liveSources` (see {@link FoldFileResult}) contributes
+ * reverse edges here: a tainted file taints every folded file that captured
+ * one of its objects. Only object identity propagates — a file that imported
+ * a plain string from a tainted file has nothing to disagree about.
+ *
+ * chant #1020 changes the calculus but not this function: `alb.ts` can now
+ * often fold `network.vpc.VpcId` too (see `buildExternals`/`foldFileMemoized`
+ * above), by reusing THE EXACT SAME `tryFoldFile("network.ts")` call (memoized
+ * per `FoldSession`) that `discover()`'s own per-file loop also uses — so
+ * `alb.ts` and `network.ts` share one real `vpc` object without ever
+ * disagreeing. This invariant is still needed for whatever STILL falls back
+ * after #1020 (a call-as-a-value construct, #1044; a shape #1020 doesn't
+ * cover): the edge collection below is unconditional — it doesn't care
+ * whether an edge happens to ALSO be used for cross-file value resolution —
+ * so the exact same forced-taint safety net still applies to that remaining
+ * boundary, unchanged.
+ */
+/**
+ * file -> set of OTHER files in `files` that it relatively imports OR
+ * re-exports from, regardless of that file's own fold outcome. Extracted
+ * from {@link planFoldTaint} (chant #1083) so a second consumer — the fold
+ * blocker dominator ranking (`./fold-rank.ts`) — can walk the exact same
+ * project-file edges instead of re-parsing every file with its own
+ * specifier-resolution logic. chant #1020 — this counts a namespace import
+ * (`import * as ns from "./x"`, previously skipped — see `collectImports`)
+ * and a re-export (`export { x } from "./y"`, which `collectImports` never
+ * saw at all, since it only looks at `import` declarations): both are real
+ * cross-file value dependencies fold's own resolution follows, so both need
+ * the same edge an ordinary named import already gets.
+ */
+export async function buildProjectImportEdges(files) {
+    const fileSet = new Set(files);
+    const edges = new Map();
+    for (const file of files) {
+        const targets = new Set();
+        const addTarget = (specifier) => {
+            if (!isProjectImport(specifier, file))
+                return; // package import, not a sibling source file
+            let resolved;
+            try {
+                resolved = resolveModulePath(specifier, file);
+            }
+            catch {
+                return;
+            }
+            if (fileSet.has(resolved))
+                targets.add(resolved);
+        };
+        try {
+            const source = await readFile(file, "utf-8");
+            const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+            const collected = collectImports(sourceFile);
+            for (const binding of collected.named.values())
+                addTarget(binding.specifier);
+            for (const binding of collected.namespaces.values())
+                addTarget(binding.specifier);
+            for (const statement of sourceFile.statements) {
+                if (ts.isExportDeclaration(statement) &&
+                    !statement.isTypeOnly &&
+                    statement.moduleSpecifier &&
+                    ts.isStringLiteral(statement.moduleSpecifier)) {
+                    addTarget(statement.moduleSpecifier.text);
+                }
+            }
+        }
+        catch {
+            // Unreadable/unparseable — no edges contributed; tryFoldFile's own
+            // top-level catch already turns this into a "run" decision for the
+            // file itself, which is enough to seed it as tainted below (or, for
+            // the dominator ranking, leaves it a childless node).
+        }
+        edges.set(file, targets);
+    }
+    return edges;
+}
+export async function planFoldTaint(files, wouldFold, liveSources) {
+    return (await planFoldTaintWithEdges(files, wouldFold, liveSources)).tainted;
+}
+/**
+ * {@link planFoldTaint}'s walk, keeping the edge that fired for each file it
+ * reaches. Split out for two consumers that need to say *why*: the fallback
+ * reason in `discover()`, and {@link foldProject}'s verdicts.
+ */
+export async function planFoldTaintWithEdges(files, wouldFold, liveSources) {
+    const fileSet = new Set(files);
+    // file -> set of OTHER discovered files it relatively imports OR re-exports
+    // from — see {@link buildProjectImportEdges}.
+    const edges = await buildProjectImportEdges(files);
+    // chant #1044 — reverse edges: consumed-file -> the folded files that
+    // captured its objects. Same taint set, same fixpoint walk; see this
+    // function's doc for the crash this closes. Kept in their own map as well,
+    // so the walk below can tell which rule an edge belongs to.
+    const reverse = new Map();
+    for (const [consumer, sources] of liveSources ?? []) {
+        if (!fileSet.has(consumer))
+            continue;
+        for (const source of sources) {
+            if (!fileSet.has(source))
+                continue;
+            let back = edges.get(source);
+            if (!back) {
+                back = new Set();
+                edges.set(source, back);
+            }
+            back.add(consumer);
+            let mine = reverse.get(source);
+            if (!mine) {
+                mine = new Set();
+                reverse.set(source, mine);
+            }
+            mine.add(consumer);
+        }
+    }
+    const tainted = new Set(files.filter((f) => wouldFold.get(f) !== true));
+    const reachedBy = new Map();
+    const queue = [...tainted];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const target of edges.get(current) ?? []) {
+            if (!tainted.has(target)) {
+                tainted.add(target);
+                // A forward edge means `current` imports `target`; the reverse map is
+                // consulted second so a file reachable both ways is reported as the
+                // importer case, the one a reader can see in its own source.
+                const forward = !reverse.get(current)?.has(target);
+                reachedBy.set(target, { from: current, kind: forward ? "importer" : "capture" });
+                queue.push(target);
+            }
+        }
+    }
+    return { tainted, reachedBy };
+}
+/**
+ * Fold a whole set of project files and report every file's verdict
+ * (chant#2408).
+ *
+ * `discover()` does this as part of building, and its per-file decisions are
+ * not addressable from outside. Anything that wants to *check* the
+ * cross-file rules needs the whole picture: the forward rule (#1023) needs an
+ * importer, the reverse rule (#1044) needs a capturing sibling, and the
+ * fixpoint needs the whole set, so none of the three is observable one file at
+ * a time. The conformance suite of the specification is the first such caller
+ * (INTENTIUS/typescript-as-data#62).
+ *
+ * Same session, same memo, same taint walk as a real build — this is not a
+ * second implementation of the rules, it is the existing one with its
+ * intermediate results kept instead of consumed.
+ *
+ * `options` carries the rest of what a build's session holds (chant#2422).
+ * Omitting it answers a harsher question than a real build asks: with no
+ * lexicon list nothing reading a lexicon data export folds, and with no build
+ * parameters nothing reading `params` does. See {@link FoldProjectOptions}.
+ */
+export async function foldProject(files, intrinsics = [], options = {}) {
+    // chant#2455 — `sandbox` refuses to import project code at all and
+    // `executing` exists to invoke it. Asking for both is not a preference
+    // between two readings, it is a contradiction, and silently picking one would
+    // make the fold's meaning depend on which.
+    if (options.sandbox === true && options.executing === true) {
+        throw new Error("foldProject: `sandbox` and `executing` are mutually exclusive — the first refuses to import " +
+            "project code and the second exists to invoke it. Pass one.");
+    }
+    const session = createFoldSession(intrinsics, options.buildParams, options.lexicons ?? [], options.sandbox ?? false, options.lexiconPackages ?? [], options.executing ?? false, files);
+    const attempts = new Map();
+    for (const file of files)
+        attempts.set(file, await tryFoldFile(file, intrinsics, session));
+    const plan = await planFoldTaintWithEdges(files, new Map(files.map((file) => [file, attempts.get(file)?.ok === true])), new Map(files.flatMap((file) => {
+        const attempt = attempts.get(file);
+        return attempt?.ok === true ? [[file, attempt.liveSources]] : [];
+    })));
+    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();
+    for (const file of files) {
+        const attempt = attempts.get(file);
+        const tentative = attempt.ok ? "fold" : "run";
+        if (attempt.ok && !plan.tainted.has(file)) {
+            const foldProvenance = provenanceByFile?.get(file);
+            out.set(file, {
+                verdict: "fold",
+                tentative,
+                exports: attempt.exportedValues,
+                ...(foldProvenance ? { foldProvenance } : {}),
+            });
+            continue;
+        }
+        out.set(file, {
+            verdict: "run",
+            tentative,
+            reason: attempt.ok ? undefined : attempt.reason,
+            taintedBy: attempt.ok ? plan.reachedBy.get(file) : undefined,
+        });
+    }
+    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) {
+    if (modules.length === 0)
+        return new Map();
+    let entities;
+    try {
+        entities = collectEntities(modules, commonDirectory(modules.map((m) => m.file)));
+    }
+    catch {
+        return undefined;
+    }
+    const byResolved = new Map();
+    const out = new Map();
+    for (const { file } of modules) {
+        const record = {};
+        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))?.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) {
+    const out = {};
+    for (const [name, value] of Object.entries(exports)) {
+        if (hostCompositeName(value) === undefined) {
+            out[name] = value;
+            continue;
+        }
+        expandHostCompositeInstance(name, value, 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, members, instance, out) {
+    const compositeName = hostCompositeName(members);
+    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, 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) {
+    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;
+}