@intentius/chant 0.21.0 → 0.22.0

package/dist/build.d.ts

@@ -87,6 +87,13 @@ export interface BuildOptions {
      * The CLI populates this from `options.plugins.flatMap(p => p.intrinsics?.() ?? [])`.
      */
     intrinsics?: IntrinsicDef[];
+    /**
+     * chant #1063 — the lexicon names loaded for this build. Passed straight
+     * through to {@link DiscoveryOptions.lexicons} in `./discovery/index`;
+     * ignored unless {@link fold} is set. The CLI populates this from
+     * `options.plugins.map(p => p.name)`.
+     */
+    lexicons?: readonly string[];
     /**
      * chant #1045 Phase 2 — opt-in: run-fallback files (or, when {@link fold}
      * isn't set, every file) execute together, isolated, in one sandboxed

package/dist/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"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"}

package/dist/cli/commands/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AASnD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oBAAoB;IACpB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,2CAA2C;IAC3C,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,8CAA8C;IAC9C,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B,8BAA8B;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB;IAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAoB/C;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,2JAA2J;IAC3J,WAAW,CAAC,EAAE,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;CACjE;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CA2V9E;AAiDD;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAIlD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAItD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GACxC,MAAM,IAAI,CAmCZ"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AASnD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oBAAoB;IACpB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,2CAA2C;IAC3C,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,8CAA8C;IAC9C,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B,8BAA8B;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB;IAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAoB/C;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,2JAA2J;IAC3J,WAAW,CAAC,EAAE,OAAO,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;CACjE;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAoW9E;AAiDD;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAIlD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAItD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GACxC,MAAM,IAAI,CAmCZ"}

package/dist/cli/commands/check-lexicon-examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-lexicon-examples.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/check-lexicon-examples.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AASH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAsD1F"}
+{"version":3,"file":"check-lexicon-examples.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/check-lexicon-examples.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAUH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAoE1F"}

package/dist/discovery/fold-import.d.ts

@@ -147,9 +147,41 @@ export interface FoldSession {
      * doesn't use build-time parameters pays nothing extra here.
      */
     readonly buildParams?: Readonly<Record<string, BuildParamValue>>;
+    /**
+     * chant #1063 — the exact package specifiers of the lexicons LOADED for
+     * this build (`@intentius/chant-lexicon-aws`, …), derived from the lexicon
+     * names the build already resolved (`resolveProjectLexicons` ->
+     * `loadPlugins`, see ../cli/plugins.ts). This is the entire allowlist
+     * {@link buildExternals} will follow a bare import specifier into — see
+     * {@link activeLexiconPackage} for why the set is matched by TEXT and
+     * built from names the build already knows, rather than by resolving
+     * specifiers to find out what they are.
+     *
+     * Empty when the caller supplied no lexicon list, which disables
+     * lexicon-package resolution entirely rather than falling back to
+     * something more permissive: "an active lexicon of this build" is the
+     * boundary, and a build that can't say what its lexicons are hasn't
+     * established one.
+     */
+    readonly lexiconPackages: ReadonlySet<string>;
 }
-/** Create a fresh, empty {@link FoldSession}. */
-export declare function createFoldSession(intrinsics?: readonly IntrinsicDef[], buildParams?: Readonly<Record<string, BuildParamValue>>): FoldSession;
+/**
+ * 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 declare function lexiconPackageName(lexiconName: string): string;
+/**
+ * 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}.
+ */
+export declare function createFoldSession(intrinsics?: readonly IntrinsicDef[], buildParams?: Readonly<Record<string, BuildParamValue>>, lexicons?: readonly string[]): FoldSession;
 /**
  * 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

package/dist/discovery/fold-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAuB,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAgB3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,mGAAmG;AACnG,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,iBAAiB,CAAC,CAAC;AAElF,MAAM,MAAM,cAAc,GACtB;IACE,EAAE,EAAE,IAAI,CAAC;IACT,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB;;;;;;;;;OASG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC;;;;;;;;;;;;OAYG;IACH,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClC,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC;CAClE;AAED,iDAAiD;AACjD,wBAAgB,iBAAiB,CAC/B,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,GACtD,WAAW,CAEb;AAsmDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,cAAc,CAAC,CAEzB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,GACrD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CA8EtB"}
+{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAuB,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAkB3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,mGAAmG;AACnG,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,iBAAiB,CAAC,CAAC;AAElF,MAAM,MAAM,cAAc,GACtB;IACE,EAAE,EAAE,IAAI,CAAC;IACT,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB;;;;;;;;;OASG;IACH,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC;;;;;;;;;;;;OAYG;IACH,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClC,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,YAAY,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACpE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC;IACjE;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,EACvD,QAAQ,GAAE,SAAS,MAAM,EAAO,GAC/B,WAAW,CAUb;AAiwDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,cAAc,CAAC,CAEzB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,GACrD,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CA8EtB"}

package/dist/discovery/index.d.ts

@@ -43,6 +43,18 @@ export interface DiscoveryOptions {
      * then falls back to run at the unregistered tag).
      */
     intrinsics?: IntrinsicDef[];
+    /**
+     * chant #1063 — the lexicon NAMES loaded for this build (`["aws", "k8s"]`),
+     * i.e. what `resolveProjectLexicons()` returned and `loadPlugins()` then
+     * imported. Threaded into the fold session as the ALLOWLIST of packages a
+     * bare import specifier may be resolved into, so a lexicon's plain data
+     * exports (`Azure`/`GCP`'s pseudo-parameter namespaces, AWS's `S3Actions`,
+     * gitlab's `CI`) fold as identifier values instead of failing the file.
+     * Only meaningful when {@link fold} is set. Default: none — a caller that
+     * doesn't say which lexicons are active gets no bare-specifier resolution
+     * at all, rather than a looser fallback.
+     */
+    lexicons?: readonly string[];
     /**
      * chant #1045 Phase 2 — opt-in: whatever would otherwise reach the
      * in-process `importModule` step (every file, when {@link fold} isn't set;

package/dist/discovery/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/discovery/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAQ/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAI1D;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IACrB,gGAAgG;IAChG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;IAE5B;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAClC,8DAA8D;IAC9D,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACvC,qDAAqD;IACrD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,mDAAmD;IACnD,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB;;;OAGG;IACH,aAAa,EAAE,YAAY,EAAE,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAoQjG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/discovery/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAQ/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAI1D;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IACrB,gGAAgG;IAChG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;IAE5B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAClC,8DAA8D;IAC9D,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACvC,qDAAqD;IACrD,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,mDAAmD;IACnD,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB;;;OAGG;IACH,aAAa,EAAE,YAAY,EAAE,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAsQjG"}

package/dist/fold/fold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/fold/fold.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/fold/fold.ts"],"names":[],"mappings":"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"}

package/dist/fold/subset.d.ts

@@ -105,11 +105,34 @@ export declare const SUPPORTED_UNARY_OPERATORS: ReadonlySet<ts.SyntaxKind>;
 export declare function isLiteralPropertyName(node: ts.PropertyName): node is ts.Identifier | ts.StringLiteral | ts.NumericLiteral;
 /** An element-access key foldable without execution: a string or numeric LITERAL only (EVL003 semantics). */
 export declare function isLiteralElementKey(node: ts.Expression): node is ts.StringLiteral | ts.NumericLiteral;
+/**
+ * A short, single-line rendering of `node`'s source text for embedding in a
+ * diagnostic message — never the raw `getText()`, which reproduces the
+ * node's ENTIRE source verbatim and can span dozens of lines for a real
+ * composite call or object literal (chant #1054: a fold fallback reason that
+ * embeds one of these buries the actual error after it, and breaks any
+ * line-oriented consumer of `[fold:run]` output). Internal whitespace
+ * (including newlines) collapses to a single space, and the result is capped
+ * to a bounded length so one pathological node can't blow out an otherwise
+ * one-line reason either.
+ */
+export declare function briefNodeText(node: ts.Node, maxLength?: number): string;
 export declare function computedPropertyNameMessage(node: ts.PropertyName): string;
 export declare function dynamicElementAccessMessage(keyNode: ts.Expression): string;
 export declare const UNSUPPORTED_OBJECT_MEMBER_MESSAGE = "unsupported object member";
 export declare const UNSUPPORTED_UNARY_MESSAGE = "unsupported unary";
 export declare function unsupportedBinaryMessage(opKind: ts.SyntaxKind): string;
+/**
+ * chant #1054 — the ONE wording for "a bare function/method call used where
+ * chant needs a value it can fold." Before this, `fold()` (this message) and
+ * `../discovery/fold-import.ts`'s `resolveCallExpression` (a top-level
+ * export's own call-as-a-value check) had each grown their own hand-written
+ * copy — "function call as a value" here, "call expression as a value"
+ * there — for the identical rejection, which meant a tool grouping fallback
+ * reasons by text had to match both to avoid silently under-counting one of
+ * them. `resolveCallExpression` now calls this function directly instead of
+ * building its own string.
+ */
 export declare function callExpressionMessage(node: ts.CallExpression): string;
 export declare function unsupportedExpressionMessage(node: ts.Node): string;
 /**

package/dist/fold/subset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subset.d.ts","sourceRoot":"","sources":["../../src/fold/subset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AAEH,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C,uGAAuG;AACvG,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAchE,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAG/D,CAAC;AAEH,gHAAgH;AAChH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,EAAE,CAAC,YAAY,GACpB,IAAI,IAAI,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAE9D;AAED,6GAA6G;AAC7G,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAErG;AAQD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,GAAG,MAAM,CAEzE;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAE1E;AAED,eAAO,MAAM,iCAAiC,8BAA8B,CAAC;AAE7E,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAE7D,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAEtE;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,CAErE;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,EAAE,CAAC,wBAAwB,EACjC,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAc7B;AAWD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAiK7B"}
+{"version":3,"file":"subset.d.ts","sourceRoot":"","sources":["../../src/fold/subset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AAEH,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE/C,uGAAuG;AACvG,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IACd,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD,0FAA0F;AAC1F,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAchE,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,EAAE,CAAC,UAAU,CAG/D,CAAC;AAEH,gHAAgH;AAChH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,EAAE,CAAC,YAAY,GACpB,IAAI,IAAI,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAE9D;AAED,6GAA6G;AAC7G,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,cAAc,CAErG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,SAAS,SAAK,GAAG,MAAM,CAGnE;AAQD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,GAAG,MAAM,CAEzE;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAE1E;AAED,eAAO,MAAM,iCAAiC,8BAA8B,CAAC;AAE7E,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAE7D,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,CAEtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,CAErE;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,EAAE,CAAC,wBAAwB,EACjC,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAc7B;AAWD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,UAAU,CAAC,EAAE,SAAS,YAAY,EAAE,GACnC,eAAe,GAAG,SAAS,CAiK7B"}

package/dist/serializer-walker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializer-walker.d.ts","sourceRoot":"","sources":["../src/serializer-walker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM/C,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IACzD,mEAAmE;IACnE,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1C,+DAA+D;IAC/D,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC;CAChF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,EACpC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAyDT"}
+{"version":3,"file":"serializer-walker.d.ts","sourceRoot":"","sources":["../src/serializer-walker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAM/C,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IACzD,mEAAmE;IACnE,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1C,+DAA+D;IAC/D,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC;CAChF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,EACpC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAuET"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/build.ts

@@ -170,6 +170,14 @@ export interface BuildOptions {
    */
   intrinsics?: IntrinsicDef[];
 
+  /**
+   * chant #1063 — the lexicon names loaded for this build. Passed straight
+   * through to {@link DiscoveryOptions.lexicons} in `./discovery/index`;
+   * ignored unless {@link fold} is set. The CLI populates this from
+   * `options.plugins.map(p => p.name)`.
+   */
+  lexicons?: readonly string[];
+
   /**
    * chant #1045 Phase 2 — opt-in: run-fallback files (or, when {@link fold}
    * isn't set, every file) execute together, isolated, in one sandboxed
@@ -513,6 +521,7 @@ export async function build(
   const discoveryResult = await discover(path, {
     fold: options?.fold,
     intrinsics: options?.intrinsics,
+    lexicons: options?.lexicons,
     sandbox: options?.sandbox,
     buildParams: options?.buildParams,
   });

package/src/cli/commands/build.ts

@@ -201,6 +201,14 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
   // any), hence the guard.
   const intrinsics = options.plugins?.flatMap((plugin) => plugin.intrinsics?.() ?? []) ?? [];
 
+  // #1063 — the same loaded plugins, by NAME, are this build's allowlist for
+  // following a bare import specifier into a lexicon package (so `Azure`,
+  // `GCP`, `S3Actions`, `CI` fold as values). A plugin's `name` is the
+  // lexicon name `loadPlugin()` was called with, which is exactly what
+  // `@intentius/chant-lexicon-<name>` was imported from — see
+  // ../plugins.ts and fold-import.ts's `lexiconPackageName`.
+  const lexicons = options.plugins?.map((plugin) => plugin.name) ?? [];
+
   // Run the build
   const result = await build(infraPath, options.serializers, undefined, {
     ownership,
@@ -208,6 +216,7 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
     fold,
     sandbox,
     intrinsics,
+    lexicons,
     buildParams: paramsResolution.provenance,
   });
 

package/src/cli/commands/check-lexicon-examples.ts

@@ -32,6 +32,7 @@ import { join } from "path";
 import { build } from "../../build";
 import { findInfraFiles } from "../../discovery/files";
 import { detectLexicons } from "../../detectLexicon";
+import { loadChantConfig } from "../../config";
 import { loadPlugins } from "../plugins";
 
 export interface ExampleBuildResult {
@@ -64,7 +65,21 @@ export async function checkExamplesBuild(lexiconDir: string): Promise<ExampleBui
       const files = await findInfraFiles(srcDir);
       if (files.length === 0) continue;
 
-      const lexiconNames = await detectLexicons(files);
+      // An example's own chant.config.{ts,json} (living beside src/, not in
+      // it) can declare `lexicons` explicitly — the same precedence real
+      // `chant build` gives it via resolveProjectLexicons() in ../plugins.ts.
+      // Needed for examples like helm's HelmRender ones, whose composite
+      // legitimately produces entities tagged with a lexicon (e.g. "k8s")
+      // that no source-file import mentions — detection from imports alone
+      // can never see it, so the example built with only its "own" lexicon's
+      // plugin and silently dropped every entity of the other, undetectable
+      // one. Detection from source-file imports (unchanged) remains the
+      // fallback for the many examples with no declared `lexicons` list.
+      const { config: exampleConfig } = await loadChantConfig(join(examplesDir, entry.name));
+      const lexiconNames =
+        exampleConfig.lexicons && exampleConfig.lexicons.length > 0
+          ? exampleConfig.lexicons
+          : await detectLexicons(files);
       if (lexiconNames.length === 0) {
         results.push({
           example: entry.name,

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

@@ -7,6 +7,7 @@ import { tryFoldFile, createFoldSession } from "./fold-import";
 import { isDeclarable } from "../declarable";
 import { isCompositeInstance } from "../composite";
 import { isAttrRefLike } from "../utils";
+import { isIntrinsic } from "../intrinsic";
 import { params as sharedParams } from "../params";
 import type { AttrRef } from "../attrref";
 import type { IntrinsicDef } from "../lexicon";
@@ -165,7 +166,28 @@ describe("tryFoldFile", () => {
 
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.reason).toContain("LocalStack");
+    // chant #1054 — locks in the ONE wording for "a call used as a value,
+    // not foldable" (../fold/subset.ts's `callExpressionMessage`), which
+    // `resolveCallExpression` now reuses instead of its own hand-written
+    // "call expression as a value" copy.
+    expect(result.reason).toBe('"stack" is not foldable: function call as a value is not foldable: LocalStack(...)');
+  });
+
+  test("falls back when a top-level export's callee isn't a plain identifier (chant #1054: same wording as any other call-as-a-value rejection)", async () => {
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        const builder = { build: (props: { name: string }) => ({ name: props.name }) };
+        export const stack = builder.build({ name: "x" });
+      `,
+    );
+
+    const result = await tryFoldFile(file);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).toBe('"stack" is not foldable: function call as a value is not foldable: builder.build(...)');
   });
 
   test("falls back when a prop value is not foldable", async () => {
@@ -286,6 +308,77 @@ describe("tryFoldFile", () => {
       DependsOn: "otherResource",
     });
   });
+
+  // chant #1054 — a destructured composite export's fallback reason used to
+  // embed `decl.node.getText()`: the ENTIRE call expression, which for a
+  // real multi-prop composite call is many lines, burying the real error
+  // after all of it. These lock in the fix: the reason names the binding(s)
+  // and the callee briefly instead, and stays on one line.
+  test("a destructured composite export whose source fails to resolve reports a brief, single-line reason naming the binding names and the callee", async () => {
+    await writeFile(
+      join(testDir, "composites.ts"),
+      `
+        import { createResource } from ${JSON.stringify(runtimePath)};
+        import { Composite } from ${JSON.stringify(compositePath)};
+        const Cluster = createResource("Test::Cluster", "gcp", {});
+        const NodePool = createResource("Test::NodePool", "gcp", {});
+        export const GkeCluster = Composite<{ name: string; location: string }>((props) => {
+          const cluster = new Cluster({ name: props.name });
+          const nodePool = new NodePool({ location: props.location });
+          return { cluster, nodePool };
+        }, "GkeCluster");
+      `,
+    );
+    const file = join(testDir, "cluster.ts");
+    await writeFile(
+      file,
+      `
+        import { GkeCluster } from "./composites";
+        export const { cluster, nodePool } = GkeCluster({
+          name: config.clusterName,
+          location: config.region,
+        });
+      `,
+    );
+
+    const result = await tryFoldFile(file);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).not.toContain("\n");
+    expect(result.reason).toContain('"cluster, nodePool" (destructured from GkeCluster(...))');
+    expect(result.reason).toContain("unresolved identifier: config");
+    // The whole multi-line source is gone — the reason never reproduces the
+    // call's own argument list verbatim.
+    expect(result.reason).not.toContain("clusterName");
+  });
+
+  test("a destructured export whose source resolves but isn't an object still reports a brief, single-line reason", async () => {
+    await writeFile(
+      join(testDir, "factory.ts"),
+      `
+        export function StringFactory(props: { text: string }): string {
+          return props.text;
+        }
+      `,
+    );
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { StringFactory } from "./factory";
+        export const { length } = StringFactory({ text: "hello" });
+      `,
+    );
+
+    const result = await tryFoldFile(file);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).toBe(
+      '"length" (destructured from StringFactory(...)) is not foldable: not a composite call or object',
+    );
+  });
 });
 
 // chant #1020 (epic #1019) — cross-file resolution: an imported binding now
@@ -1596,3 +1689,237 @@ describe("tryFoldFile — registered call-form intrinsics (#1044)", () => {
     expect(result.reason).toContain("same-file resource reference");
   });
 });
+
+/**
+ * chant #1063 — cross-file references into an ACTIVE LEXICON PACKAGE's
+ * exports.
+ *
+ * #1020 taught fold to follow an identifier into another module, but only
+ * through a relative/absolute specifier — a bare package specifier was
+ * skipped outright, so `Azure`, `GCP`, `S3Actions` and gitlab's `CI` all
+ * failed as "unresolved identifier" even though every one of them is a plain
+ * `as const` object the folder already handles. These tests install a real
+ * package into the fixture tree's own `node_modules` and drive the identical
+ * resolution a real `@intentius/chant-lexicon-azure` import takes: a genuine
+ * bare specifier, resolved by {@link fastResolveBareSpecifier} walking up to
+ * `<testDir>/node_modules`, then really imported.
+ *
+ * Every fixture package gets a UNIQUE name. `bareSpecifierPathCache` is
+ * process-wide and keyed by specifier alone (deliberately — see its doc), so
+ * two tests reusing one name would have the second silently resolve to the
+ * first's already-deleted directory.
+ */
+describe("tryFoldFile — active lexicon package exports (#1063)", () => {
+  let testDir: string;
+  let seq = 0;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-fold-import-lexpkg-test-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Install a package into `<testDir>/node_modules/<name>` and return its
+   * bare specifier. `lexiconName` is what a build would list in
+   * `chant.config.ts`'s `lexicons`; the package name follows chant's one
+   * naming convention (`@intentius/chant-lexicon-<name>`), same as
+   * `loadPlugin()` uses.
+   */
+  async function installLexiconPackage(source: string): Promise<{ lexicon: string; specifier: string }> {
+    const lexicon = `fold1063x${seq++}${Date.now().toString(36)}`;
+    const specifier = `@intentius/chant-lexicon-${lexicon}`;
+    const dir = join(testDir, "node_modules", specifier);
+    await mkdir(dir, { recursive: true });
+    await writeFile(
+      join(dir, "package.json"),
+      JSON.stringify({ name: specifier, version: "0.0.0", type: "module", exports: { ".": "./index.js" } }),
+    );
+    await writeFile(join(dir, "index.js"), source);
+    return { lexicon, specifier };
+  }
+
+  /** A pseudo-parameter namespace shaped exactly like `lexicons/azure/src/pseudo.ts`'s `Azure`, plus a plain-data constants object and a callable export. */
+  const LEXICON_SOURCE = `
+    const INTRINSIC_MARKER = Symbol.for("chant.intrinsic");
+    class ArmPseudoParameter {
+      constructor(expression) {
+        this[INTRINSIC_MARKER] = true;
+        this.expression = expression;
+      }
+      toJSON() { return this.expression; }
+    }
+    export const ResourceGroupLocation = new ArmPseudoParameter("[resourceGroup().location]");
+    export const Azure = { ResourceGroupLocation };
+    export const CI = { CommitBranch: "$CI_COMMIT_BRANCH", DefaultBranch: "$CI_DEFAULT_BRANCH" };
+    export const S3Actions = { ReadOnly: ["s3:GetObject", "s3:ListBucket"] };
+    export function defaultTags(tags) { return tags; }
+  `;
+
+  test("a lexicon package's plain-data export resolves and folds when referenced as a value", async () => {
+    const { lexicon, specifier } = await installLexiconPackage(LEXICON_SOURCE);
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { CI, S3Actions } from ${JSON.stringify(specifier)};
+        throw new Error("must never execute — sentinel for #1063 fold verification");
+        export const branch = CI.CommitBranch;
+        export const rule = \`\${CI.CommitBranch} == \${CI.DefaultBranch}\`;
+        export const actions = S3Actions.ReadOnly;
+      `,
+    );
+
+    const result = await tryFoldFile(file, [], createFoldSession([], undefined, [lexicon]));
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.exportedValues.get("branch")).toBe("$CI_COMMIT_BRANCH");
+    // A template literal is the real test that the VALUE arrived, not a
+    // symbolic envelope: an envelope would stringify to "[object Object]".
+    expect(result.exportedValues.get("rule")).toBe("$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH");
+    expect(result.exportedValues.get("actions")).toEqual(["s3:GetObject", "s3:ListBucket"]);
+  });
+
+  test("a pseudo-parameter reached through the namespace stays the REAL live Intrinsic instance, prototype intact", async () => {
+    const { lexicon, specifier } = await installLexiconPackage(LEXICON_SOURCE);
+    await writeFile(
+      join(testDir, "resources.ts"),
+      `
+        import { createResource } from ${JSON.stringify(runtimePath)};
+        export const Group = createResource("Test::Group", "azure", {});
+      `,
+    );
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { Azure } from ${JSON.stringify(specifier)};
+        import { Group } from "./resources";
+        export const group = new Group({ location: Azure.ResourceGroupLocation });
+      `,
+    );
+
+    const result = await tryFoldFile(file, [], createFoldSession([], undefined, [lexicon]));
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const [, entity] = result.entities[0];
+    const location = (entity as unknown as { props: { location: unknown } }).props.location;
+    // Not a plain-object copy: the generic revive walk would have rebuilt it
+    // as `{ expression: … }` and dropped `toJSON`, which is what actually
+    // reaches the serializer.
+    expect(isIntrinsic(location)).toBe(true);
+    expect((location as { toJSON(): unknown }).toJSON()).toBe("[resourceGroup().location]");
+    // Identity: the very object the module exports, not a reconstruction —
+    // the same one a run-path import of this package would hand the file.
+    const mod = (await import(join(testDir, "node_modules", specifier, "index.js"))) as {
+      Azure: { ResourceGroupLocation: unknown };
+    };
+    expect(location).toBe(mod.Azure.ResourceGroupLocation);
+  });
+
+  test("a lexicon package NOT active for this build is not resolved", async () => {
+    const { specifier } = await installLexiconPackage(LEXICON_SOURCE);
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { CI } from ${JSON.stringify(specifier)};
+        export const branch = CI.CommitBranch;
+      `,
+    );
+
+    // The package is installed and importable — the ONLY thing missing is
+    // this build having loaded it as a lexicon.
+    const result = await tryFoldFile(file, [], createFoldSession([], undefined, ["aws"]));
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).toContain("unresolved identifier: CI");
+  });
+
+  test("with no active lexicons at all, a bare specifier is skipped exactly as before", async () => {
+    const { specifier } = await installLexiconPackage(LEXICON_SOURCE);
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { CI } from ${JSON.stringify(specifier)};
+        export const branch = CI.CommitBranch;
+      `,
+    );
+
+    const result = await tryFoldFile(file);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).toContain("unresolved identifier: CI");
+  });
+
+  test("a non-lexicon package is never followed, even when it is installed right next to one that is", async () => {
+    const { lexicon } = await installLexiconPackage(LEXICON_SOURCE);
+    const vendorDir = join(testDir, "node_modules", "some-vendor-pkg");
+    await mkdir(vendorDir, { recursive: true });
+    await writeFile(
+      join(vendorDir, "package.json"),
+      JSON.stringify({ name: "some-vendor-pkg", version: "0.0.0", type: "module", exports: { ".": "./index.js" } }),
+    );
+    await writeFile(join(vendorDir, "index.js"), `export const SETTINGS = { region: "us-east-1" };`);
+
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { SETTINGS } from "some-vendor-pkg";
+        export const region = SETTINGS.region;
+      `,
+    );
+
+    const result = await tryFoldFile(file, [], createFoldSession([], undefined, [lexicon]));
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).toContain("unresolved identifier: SETTINGS");
+  });
+
+  test("a lexicon package's CALLABLE export is not bound as an identifier value", async () => {
+    const { lexicon, specifier } = await installLexiconPackage(LEXICON_SOURCE);
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { defaultTags } from ${JSON.stringify(specifier)};
+        export const tags = defaultTags;
+      `,
+    );
+
+    const result = await tryFoldFile(file, [], createFoldSession([], undefined, [lexicon]));
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).toContain("unresolved identifier: defaultTags");
+  });
+
+  test("process.env still rejects, with the build-parameter guidance, even with an active lexicon package in scope", async () => {
+    const { lexicon, specifier } = await installLexiconPackage(LEXICON_SOURCE);
+    const file = join(testDir, "main.ts");
+    await writeFile(
+      file,
+      `
+        import { CI } from ${JSON.stringify(specifier)};
+        export const branch = CI.CommitBranch;
+        export const region = process.env.AWS_REGION;
+      `,
+    );
+
+    const result = await tryFoldFile(file, [], createFoldSession([], undefined, [lexicon]));
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.reason).toContain(`ambient "process" read is not foldable`);
+  });
+});

package/src/discovery/fold-import.ts

@@ -7,6 +7,7 @@ import { createRequire } from "node:module";
 import { isDeclarable, type Declarable } from "../declarable";
 import { isCompositeInstance, type CompositeInstance } from "../composite";
 import { isAttrRefLike } from "../utils";
+import { isIntrinsic } from "../intrinsic";
 import {
   collectConsts,
   foldResource,
@@ -20,6 +21,7 @@ import {
   type SymbolicValue,
 } from "../fold/fold";
 import { isChantOwnedSpecifier } from "../fold/foldable-helpers";
+import { briefNodeText, callExpressionMessage } from "../fold/subset";
 import { importModule } from "./import";
 import type { IntrinsicDef } from "../lexicon";
 import type { BuildParamValue } from "../build-params";
@@ -171,14 +173,58 @@ export interface FoldSession {
    * doesn't use build-time parameters pays nothing extra here.
    */
   readonly buildParams?: Readonly<Record<string, BuildParamValue>>;
+  /**
+   * chant #1063 — the exact package specifiers of the lexicons LOADED for
+   * this build (`@intentius/chant-lexicon-aws`, …), derived from the lexicon
+   * names the build already resolved (`resolveProjectLexicons` ->
+   * `loadPlugins`, see ../cli/plugins.ts). This is the entire allowlist
+   * {@link buildExternals} will follow a bare import specifier into — see
+   * {@link activeLexiconPackage} for why the set is matched by TEXT and
+   * built from names the build already knows, rather than by resolving
+   * specifiers to find out what they are.
+   *
+   * Empty when the caller supplied no lexicon list, which disables
+   * lexicon-package resolution entirely rather than falling back to
+   * something more permissive: "an active lexicon of this build" is the
+   * boundary, and a build that can't say what its lexicons are hasn't
+   * established one.
+   */
+  readonly lexiconPackages: ReadonlySet<string>;
+}
+
+/**
+ * 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: string): string {
+  return `@intentius/chant-lexicon-${lexiconName}`;
 }
 
-/** Create a fresh, empty {@link FoldSession}. */
+/**
+ * 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}.
+ */
 export function createFoldSession(
   intrinsics: readonly IntrinsicDef[] = [],
   buildParams?: Readonly<Record<string, BuildParamValue>>,
+  lexicons: readonly string[] = [],
 ): FoldSession {
-  return { intrinsics, cache: new Map(), stack: [], importCache: new Map(), resolvePathCache: new Map(), buildParams };
+  return {
+    intrinsics,
+    cache: new Map(),
+    stack: [],
+    importCache: new Map(),
+    resolvePathCache: new Map(),
+    buildParams,
+    lexiconPackages: new Set(lexicons.map(lexiconPackageName)),
+  };
 }
 
 /**
@@ -805,6 +851,100 @@ function paramsModulePath(): string | 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`.
+ */
+function activeLexiconPackage(specifier: string, lexiconPackages: ReadonlySet<string>): string | undefined {
+  return lexiconPackages.has(specifier) ? specifier : 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 deliberately 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 them as plain identifier values here would widen what folds in ways
+ * this issue neither needs nor measured: none of the references #1063 exists
+ * to unblock (`Azure`, `GCP`, `S3Actions`, gitlab's `CI`) is a function.
+ *
+ * Returns `undefined` — never throws — for a package that isn't an active
+ * lexicon, an export the package doesn't have, a 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: ImportBinding,
+  fromFile: string,
+  session: FoldSession,
+): Promise<{ value: unknown } | undefined> {
+  if (!activeLexiconPackage(binding.specifier, session.lexiconPackages)) return undefined;
+
+  let modulePath: string;
+  try {
+    modulePath = resolveModulePathMemoized(binding.specifier, fromFile, session.resolvePathCache);
+  } catch {
+    return undefined;
+  }
+
+  let mod: Record<string, unknown>;
+  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") return undefined;
+  return { value };
+}
+
 // ─────────────────────────────────────────────────────────────────────────
 // Resolution: given the scan + import map, compute the REAL runtime value
 // (Declarable | CompositeInstance) each foldable export would have had if
@@ -962,13 +1102,18 @@ async function resolveLiveValue(node: ts.Expression, ctx: ResolveCtx): Promise<L
  * `isDeclarable`/`isCompositeInstance` value for a top-level export).
  */
 async function resolveCallExpression(node: ts.CallExpression, ctx: ResolveCtx): Promise<unknown> {
+  // 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(`call expression as a value is not foldable: ${node.expression.getText()}(...)`);
+    throw cheapError(callExpressionMessage(node));
   }
   const calleeName = node.expression.text;
   const binding = ctx.imports.get(calleeName);
   if (!binding) {
-    throw cheapError(`call expression as a value is not foldable: ${calleeName}(...)`);
+    throw cheapError(callExpressionMessage(node));
   }
 
   let modulePath: string;
@@ -1161,7 +1306,17 @@ async function reviveFoldedValue(value: FoldedValue, ctx: ResolveCtx, requireLiv
   // 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.
-  if (isAttrRefLike(value) || isDeclarable(value) || isCompositeInstance(value)) {
+  // 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 (isAttrRefLike(value) || isDeclarable(value) || isCompositeInstance(value) || isIntrinsic(value)) {
     return value;
   }
 
@@ -1443,6 +1598,18 @@ function describeFoldFailure(err: unknown, ctx: ResolveCtx): string {
   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: ts.Expression): string {
+  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: ts.Node, message: string): string {
   const { line, column } = locate(node);
@@ -1585,10 +1752,36 @@ async function buildExternals(
     }
 
     if (!isProjectFileSpecifier(binding.specifier)) {
-      // Every other bare specifier (a lexicon/vendor package) 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 #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);
+        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.
       continue;
     }
     let targetPath: string;
@@ -1736,18 +1929,26 @@ async function tryFoldFileCore(file: string, session: FoldSession): Promise<Fold
 
       if (decl.kind === "destructure") {
         let value: unknown;
+        // 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: `destructured export from "${decl.node.getText()}" is not foldable: ${describeFoldFailure(err, ctx)}`,
+            reason: `"${boundNames}" (destructured from ${source}) is not foldable: ${describeFoldFailure(err, ctx)}`,
           };
         }
         if (!isIndexableObject(value)) {
           return {
             ok: false,
-            reason: `destructured export from "${decl.node.getText()}" is not foldable (not a composite call or object)`,
+            reason: `"${boundNames}" (destructured from ${source}) is not foldable: not a composite call or object`,
           };
         }
         for (const { propKey, bindingName } of decl.elements) {

package/src/discovery/index.ts

@@ -56,6 +56,19 @@ export interface DiscoveryOptions {
    */
   intrinsics?: IntrinsicDef[];
 
+  /**
+   * chant #1063 — the lexicon NAMES loaded for this build (`["aws", "k8s"]`),
+   * i.e. what `resolveProjectLexicons()` returned and `loadPlugins()` then
+   * imported. Threaded into the fold session as the ALLOWLIST of packages a
+   * bare import specifier may be resolved into, so a lexicon's plain data
+   * exports (`Azure`/`GCP`'s pseudo-parameter namespaces, AWS's `S3Actions`,
+   * gitlab's `CI`) fold as identifier values instead of failing the file.
+   * Only meaningful when {@link fold} is set. Default: none — a caller that
+   * doesn't say which lexicons are active gets no bare-specifier resolution
+   * at all, rather than a looser fallback.
+   */
+  lexicons?: readonly string[];
+
   /**
    * chant #1045 Phase 2 — opt-in: whatever would otherwise reach the
    * in-process `importModule` step (every file, when {@link fold} isn't set;
@@ -156,7 +169,9 @@ export async function discover(path: string, options?: DiscoveryOptions): Promis
   // a project file imported by several others is folded exactly once, so
   // every referrer shares the identical constructed Declarable/
   // CompositeInstance objects rather than each building its own copy.
-  const foldSession = options?.fold ? createFoldSession(options.intrinsics, buildParamValuesMap) : undefined;
+  const foldSession = options?.fold
+    ? createFoldSession(options.intrinsics, buildParamValuesMap, options.lexicons)
+    : undefined;
   if (options?.fold) {
     for (const file of files) {
       foldAttempts.set(file, await tryFoldFile(file, options.intrinsics, foldSession));

package/src/fold/fold.ts

@@ -5,6 +5,7 @@ import {
   SUPPORTED_UNARY_OPERATORS,
   UNSUPPORTED_OBJECT_MEMBER_MESSAGE,
   UNSUPPORTED_UNARY_MESSAGE,
+  briefNodeText,
   callExpressionMessage,
   computedPropertyNameMessage,
   dynamicElementAccessMessage,
@@ -396,7 +397,7 @@ function foldTaggedTemplate(
   const tagName = node.tag.getText();
   const isRegistered = intrinsics.some((i) => i.name === tagName && intrinsicTagFolds(i));
   if (!isRegistered) {
-    throw foldError(node, `unregistered tagged template intrinsic: ${tagName}\`...\``);
+    throw foldError(node, `unregistered tagged template intrinsic: ${briefNodeText(node.tag)}\`...\``);
   }
 
   const template = node.template;
@@ -635,7 +636,10 @@ export function fold(
     // Reject so the file falls back to run, which constructs and serializes it
     // correctly. EVL permits this statically — it's a documented fold/EVL
     // divergence, like identifier resolution and spread runtime type.
-    throw foldError(node, `nested \`new ${node.expression.getText()}(...)\` as a value is not foldable — falls back to run`);
+    throw foldError(
+      node,
+      `nested \`new ${briefNodeText(node.expression)}(...)\` as a value is not foldable — falls back to run`,
+    );
   }
 
   if (ts.isCallExpression(node)) {

package/src/fold/subset.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { fold, foldResource, collectConsts, FoldError } from "./fold";
-import { findSubsetViolation } from "./subset";
+import { briefNodeText, callExpressionMessage, findSubsetViolation } from "./subset";
 import { evl001NonLiteralExpressionRule } from "../lint/rules/evl001-non-literal-expression";
 import { evl003DynamicPropertyAccessRule } from "../lint/rules/evl003-dynamic-property-access";
 import { evl004SpreadNonConstRule } from "../lint/rules/evl004-spread-non-const";
@@ -350,3 +350,69 @@ describe("findSubsetViolation — optional intrinsic registry (#1044)", () => {
     expect(evl001NonLiteralExpressionRule.check(context).length).toBeGreaterThan(0);
   });
 });
+
+/**
+ * chant #1054 — `briefNodeText` is what keeps every fold fallback reason
+ * that used to embed a node's raw `getText()` down to one bounded line. A
+ * real composite call's source is many lines; a fold reason that reproduces
+ * it verbatim buries the actual error after all of it (the bug this issue
+ * reports) and breaks any line-oriented consumer of `[fold:run]` output.
+ */
+describe("briefNodeText — single-line, bounded diagnostic text (chant #1054)", () => {
+  function initializerOf(source: string): ts.Expression {
+    const sourceFile = ts.createSourceFile("t.ts", source, ts.ScriptTarget.Latest, true);
+    const consts = collectConsts(sourceFile);
+    const init = consts.get("x");
+    if (!init) throw new Error(`fixture error: "x" did not parse in ${JSON.stringify(source)}`);
+    return init;
+  }
+
+  test("a short, single-line node passes through unchanged", () => {
+    expect(briefNodeText(initializerOf(`const x = GkeCluster;`))).toBe("GkeCluster");
+  });
+
+  test("a multi-line node's newlines collapse to spaces — the result is always one line", () => {
+    const text = briefNodeText(
+      initializerOf(`
+        const x = GkeCluster({
+          name: config.clusterName,
+          location: config.region,
+        });
+      `),
+    );
+    expect(text).not.toContain("\n");
+    expect(text.split("\n")).toHaveLength(1);
+  });
+
+  test("text over the length cap is truncated with a trailing marker rather than left unbounded", () => {
+    const text = briefNodeText(
+      initializerOf(`const x = { aVeryLongPropertyNameNumberOne: 1, aVeryLongPropertyNameNumberTwo: 2 };`),
+      20,
+    );
+    expect(text.length).toBe(20);
+    expect(text.endsWith("...")).toBe(true);
+  });
+});
+
+describe("callExpressionMessage — one line regardless of the call's own argument list (chant #1054)", () => {
+  test("only the callee is embedded — a multi-line argument list never leaks into the message", () => {
+    const sourceFile = ts.createSourceFile(
+      "t.ts",
+      `
+        const x = GkeCluster({
+          name: config.clusterName,
+          location: config.region,
+          machineType: "n2-standard-2",
+        });
+      `,
+      ts.ScriptTarget.Latest,
+      true,
+    );
+    const consts = collectConsts(sourceFile);
+    const call = consts.get("x") as ts.CallExpression;
+
+    const message = callExpressionMessage(call);
+
+    expect(message).toBe("function call as a value is not foldable: GkeCluster(...)");
+  });
+});

package/src/fold/subset.ts

@@ -141,6 +141,22 @@ export function isLiteralElementKey(node: ts.Expression): node is ts.StringLiter
   return ts.isStringLiteral(node) || ts.isNumericLiteral(node);
 }
 
+/**
+ * A short, single-line rendering of `node`'s source text for embedding in a
+ * diagnostic message — never the raw `getText()`, which reproduces the
+ * node's ENTIRE source verbatim and can span dozens of lines for a real
+ * composite call or object literal (chant #1054: a fold fallback reason that
+ * embeds one of these buries the actual error after it, and breaks any
+ * line-oriented consumer of `[fold:run]` output). Internal whitespace
+ * (including newlines) collapses to a single space, and the result is capped
+ * to a bounded length so one pathological node can't blow out an otherwise
+ * one-line reason either.
+ */
+export function briefNodeText(node: ts.Node, maxLength = 60): string {
+  const collapsed = node.getText().replace(/\s+/g, " ").trim();
+  return collapsed.length > maxLength ? `${collapsed.slice(0, maxLength - 3)}...` : collapsed;
+}
+
 // ---------------------------------------------------------------------------
 // Shared message builders — `fold()` and `findSubsetViolation` both call
 // these so the diagnostic text for the same violation kind is the same
@@ -148,11 +164,11 @@ export function isLiteralElementKey(node: ts.Expression): node is ts.StringLiter
 // ---------------------------------------------------------------------------
 
 export function computedPropertyNameMessage(node: ts.PropertyName): string {
-  return `computed/dynamic property name not foldable: ${node.getText()}`;
+  return `computed/dynamic property name not foldable: ${briefNodeText(node)}`;
 }
 
 export function dynamicElementAccessMessage(keyNode: ts.Expression): string {
-  return `dynamic property access — computed key must be a string or numeric literal: ${keyNode.getText()}`;
+  return `dynamic property access — computed key must be a string or numeric literal: ${briefNodeText(keyNode)}`;
 }
 
 export const UNSUPPORTED_OBJECT_MEMBER_MESSAGE = "unsupported object member";
@@ -163,8 +179,19 @@ export function unsupportedBinaryMessage(opKind: ts.SyntaxKind): string {
   return `unsupported binary operator: ${ts.SyntaxKind[opKind]}`;
 }
 
+/**
+ * chant #1054 — the ONE wording for "a bare function/method call used where
+ * chant needs a value it can fold." Before this, `fold()` (this message) and
+ * `../discovery/fold-import.ts`'s `resolveCallExpression` (a top-level
+ * export's own call-as-a-value check) had each grown their own hand-written
+ * copy — "function call as a value" here, "call expression as a value"
+ * there — for the identical rejection, which meant a tool grouping fallback
+ * reasons by text had to match both to avoid silently under-counting one of
+ * them. `resolveCallExpression` now calls this function directly instead of
+ * building its own string.
+ */
 export function callExpressionMessage(node: ts.CallExpression): string {
-  return `function call as a value is not foldable: ${node.expression.getText()}(...)`;
+  return `function call as a value is not foldable: ${briefNodeText(node.expression)}(...)`;
 }
 
 export function unsupportedExpressionMessage(node: ts.Node): string {

package/src/serializer-walker.ts

@@ -61,6 +61,20 @@ export function walkValue(
     if (name) {
       return visitor.resourceRef(name);
     }
+    // A resource-kind Declarable constructed inline rather than exported as
+    // its own top-level entity (e.g. K8s `new PersistentVolumeClaim({...})`
+    // embedded directly in a StatefulSet's `volumeClaimTemplates`) has no
+    // logical name to Ref — it was never a key in `entities`, so
+    // resolveAttrRefs() never assigns one. Falling through to the generic
+    // "object" branch below would walk the Declarable's own enumerable
+    // properties, which for a Declarable are its self-referencing attribute
+    // accessors (AttrRef instances whose parent is the Declarable itself,
+    // still unresolved) — never its authored `.props`. That either threw
+    // "logical name not set" (when the resource type declares any
+    // attributes) or silently serialized as `{}` (when it doesn't), instead
+    // of the embedded spec the caller wrote. Embed its own props inline
+    // instead, exactly like a property-kind Declarable already does.
+    return visitor.propertyDeclarable(decl, (v) => walkValue(v, entityNames, visitor));
   }
 
   // Handle arrays