@intentius/chant 0.124.14 → 0.124.16

package/src/components/fan-out-record.ts

@@ -27,9 +27,8 @@
  * per-wave CI job hands to the next.
  */
 
-import { dirname } from "node:path";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { readWaveRecords, type WaveRecord } from "../gated-waves";
+import { existsSync, readFileSync } from "node:fs";
+import { readWaveRecords, writeWaveRecordFile, type WaveRecord } from "../wave-engine";
 import type { ChangeSetDocument } from "../change-set";
 import type { PrMember } from "../pr-loop";
 
@@ -126,8 +125,5 @@ export function readFanOutAttempt(path: string): FanOutAttempt | undefined {
  * write leaves the previous record whole rather than half a JSON document.
  */
 export function writeFanOutAttempt(path: string, attempt: FanOutAttempt): void {
-  mkdirSync(dirname(path), { recursive: true });
-  const temporary = `${path}.${process.pid}.tmp`;
-  writeFileSync(temporary, JSON.stringify(attempt, null, 2) + "\n");
-  renameSync(temporary, path);
+  writeWaveRecordFile(path, attempt);
 }

package/src/components/fan-out-run.ts

@@ -31,8 +31,10 @@
  * ## Or one approval per wave
  *
  * `waveGate` (#3049) is the other mode. Each wave is planned once the waves
- * before it applied, and its gate binds that wave's set digest
- * (`../gated-waves.ts`). See {@link runGatedWaves}.
+ * before it applied, and its gate binds that wave's set digest. Gate names,
+ * the digest and the gate decision come from the wave engine
+ * (`../wave-engine.ts`, #3766), which `chant run wave` uses too. See
+ * {@link runGatedWaves}.
  */
 
 import {
@@ -50,7 +52,7 @@ import type { CapabilityRegistry } from "./capability";
 import type { PendingGateRecord } from "../lifecycle/gate-ledger";
 import type { DeployContext } from "./capability";
 import { planWaveComponent, type WaveComponentPlan } from "./wave-plan";
-import { waveGateName, waveSetDigest, type WaveMember, type WaveRecord } from "../gated-waves";
+import { decideWaveGate, waveGateName, waveSetDigest, type WaveMember, type WaveRecord } from "../wave-engine";
 
 /**
  * One gate per wave (#3049), each bound to its wave's set digest. The other
@@ -452,10 +454,10 @@ async function runGatedWaves(
       continue;
     }
 
-    const check = await evaluateGate(gates.port, {
+    const check = await decideWaveGate(gates.port, {
       op: waveGate.op,
       gate: gateName,
-      planDigest: digest,
+      digest,
       description: waveGate.description ?? `wave ${waveNum} of ${plan.waves.length}: ${toRun.join(", ")}`,
       ...(waveGate.timeout ? { timeout: waveGate.timeout } : {}),
       ...(options.now ? { now: options.now } : {}),

package/src/components/pr-pipeline.ts

@@ -38,6 +38,7 @@
 
 import type { ForgeKind } from "../pr-forge";
 import { PR_APPLY_GATE } from "../pr-loop";
+import { CI_IMAGE, GITHUB_JOB_TOKEN } from "../ci-jobs";
 
 /** Where both jobs write their reports, kept as a CI artifact. */
 export const PR_LOOP_REPORT_DIR = ".chant/pr";
@@ -55,7 +56,7 @@ export const PR_APPLY_RECORD = ".chant/pr-resume/pr-apply.json";
  * `PR_LOOP_SETUP` adds OpenTofu on top of it. A caller who sets `image`
  * brings both and gets no setup lines.
  */
-export const PR_LOOP_IMAGE = "node:22";
+export const PR_LOOP_IMAGE = CI_IMAGE;
 
 /** Installs OpenTofu into `PR_LOOP_IMAGE`. */
 export const PR_LOOP_SETUP = [
@@ -113,7 +114,7 @@ export function prLoopJobs(forge: ForgeKind, env: string, options: PrLoopPipelin
     ...(member ? ["--member", member] : []),
   ];
   const github = forge !== "gitlab";
-  const token: Record<string, string> = github ? { GITHUB_TOKEN: "${{ github.token }}" } : {};
+  const token: Record<string, string> = github ? { GITHUB_TOKEN: GITHUB_JOB_TOKEN } : {};
   return [
     {
       jobName: "plan",

package/src/composite.ts

@@ -115,11 +115,23 @@ export class CompositeRegistry {
  * });
  * export const storage = SecureStorage({ name: "data" });
  * ```
+ *
+ * `D` (chant#3787) lets a lexicon give the definition a more precise call
+ * signature than `(props: P) => M`, such as a generic one whose members' types
+ * depend on the literal props it is called with. It is a type only: the value
+ * is the same definition, and `D` must still be a `CompositeDefinition<P, M>`,
+ * so an intersection with the precise signature first is the usual form. It
+ * is passed as a type argument rather than by casting the result, because the
+ * fold recognizes a composite by its `export const X = Composite(...)` shape.
  */
-export function Composite<P, M extends CompositeFactoryMembers = CompositeMembers>(
+export function Composite<
+  P,
+  M extends CompositeFactoryMembers = CompositeMembers,
+  D extends CompositeDefinition<P, M> = CompositeDefinition<P, M>,
+>(
   factory: (props: P) => M,
   name?: string,
-): CompositeDefinition<P, M> {
+): D {
   const id = Symbol();
   const compositeName = name ?? "anonymous";
 
@@ -163,7 +175,7 @@ export function Composite<P, M extends CompositeFactoryMembers = CompositeMember
 
   CompositeRegistry.register(definition as CompositeDefinition<unknown>);
 
-  return definition;
+  return definition as D;
 }
 
 /** Non-enumerable, symbol-keyed: invisible to serializers, spreads and comparisons, like provenance. */

package/src/discovery/collect.ts

@@ -4,6 +4,7 @@ import { isCompositeInstance, expandComposite, compositeOfMember } from "../comp
 import { isLexiconOutput } from "../lexicon-output";
 import { DiscoveryError } from "../errors";
 import { setProvenance, type EntityProvenance } from "../provenance";
+import { expandHostComposite, hostCompositeName } from "./host-composite";
 
 /**
  * The entity key for an export. `export default` is per-module — the `Op` pattern
@@ -119,6 +120,18 @@ function enumerateEntries(
             provenance: { sourceFile: file, compositeInstance: name },
           });
         }
+      } else if (hostCompositeName(value) !== undefined) {
+        // chant#3612 — a host composite instance the fold resolved, expanded
+        // here rather than by one caller, so `build()` and `foldProject`
+        // report the same entities for it. See ./host-composite.ts.
+        for (const [expandedName, entity] of expandHostComposite(name, value as Record<string, unknown>)) {
+          entries.push({
+            bareKey: expandedName,
+            value: entity,
+            file,
+            provenance: { sourceFile: file, compositeInstance: name },
+          });
+        }
       } else if (isLexiconOutput(value)) {
         // LexiconOutput is not a Declarable but build() expects to find them in
         // the entities map so it can collect and pass them to serializers.
@@ -133,7 +146,8 @@ function enumerateEntries(
 /**
  * Collects all declarable entities from imported modules.
  * CompositeInstance exports are expanded into individual entities
- * with `{exportName}_{memberName}` naming.
+ * with `{exportName}_{memberName}` naming, and so are host composite
+ * instances the fold resolved (chant#3612, ./host-composite.ts).
  * LexiconOutput exports are also collected so that build() can
  * extract them and pass them to the serializer.
  *

package/src/discovery/fold-build-parity.test.ts

@@ -0,0 +1,71 @@
+/**
+ * chant#3612 — `build()` and `foldProject` report the same entities, under the
+ * same names, with the same provenance, for projects that use composites.
+ *
+ * The two share `collectEntities` and `foldProvenanceOfEntities`; what could
+ * still differ is what each hands them. These fixtures are real examples, one
+ * per lexicon whose composites a project calls, built the way `chant build`
+ * builds them (fold on, the plugins' intrinsics, the lexicon names).
+ */
+import { describe, test, expect, beforeAll } from "vitest";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { build } from "../build";
+import { foldProject, type FoldProvenance } from "../index";
+import { findInfraFiles } from "./files";
+import { loadPlugins, resolveProjectLexicons } from "../cli/plugins";
+import type { LexiconPlugin } from "../lexicon";
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../../..");
+
+const FIXTURES = [
+  "lexicons/aws/examples/fargate-alb",
+  "lexicons/aws/examples/lambda-function",
+  "lexicons/aws/examples/multi-service-alb",
+  "lexicons/k8s/examples/batch-workers",
+  "lexicons/k8s/examples/web-platform",
+  "lexicons/sql/examples/postgres-composites",
+];
+
+describe("build() and foldProject agree on composite-using projects (chant#3612)", () => {
+  // Loading a lexicon (aws's generated barrel above all) is the slow part, and
+  // it is not what the tests measure, so it happens once, up front.
+  const pluginsOf = new Map<string, LexiconPlugin[]>();
+  beforeAll(async () => {
+    for (const fixture of FIXTURES) {
+      const project = join(repoRoot, fixture);
+      pluginsOf.set(fixture, await loadPlugins(await resolveProjectLexicons(project)));
+    }
+  }, 60_000);
+
+  test.each(FIXTURES)("%s", async (fixture) => {
+    const src = join(repoRoot, fixture, "src");
+    const plugins = pluginsOf.get(fixture)!;
+    const intrinsics = plugins.flatMap((p) => p.intrinsics?.() ?? []);
+    const lexicons = plugins.map((p) => p.name);
+
+    const built = await build(src, plugins.map((p) => p.serializer), undefined, { fold: true, intrinsics, lexicons });
+    expect(built.errors).toEqual([]);
+
+    const files = await findInfraFiles(src);
+    const verdicts = await foldProject(files, intrinsics, { lexicons });
+    // Same verdict per file. A file that runs (a `chant.config.ts` in `src`)
+    // has no fold provenance in foldProject, so it is left out of both sides.
+    const mode = new Map(built.foldDecisions.map((d) => [d.file, d.mode]));
+    const folded: FoldProvenance = {};
+    for (const [file, verdict] of verdicts) {
+      expect({ file, verdict: verdict.verdict }).toEqual({ file, verdict: mode.get(file) });
+      Object.assign(folded, verdict.foldProvenance);
+    }
+    const foldedFiles = new Set(files.filter((file) => verdicts.get(file)!.verdict === "fold"));
+    expect(foldedFiles.size).toBeGreaterThan(0);
+    const fromBuild = Object.fromEntries(
+      Object.entries(built.foldProvenance).filter(([, record]) => foldedFiles.has(record.sourceFile ?? "")),
+    );
+
+    // The fixture has to exercise a composite, or the comparison proves nothing.
+    expect(Object.values(fromBuild).some((record) => record.composite !== undefined)).toBe(true);
+    expect(Object.keys(folded).sort()).toEqual(Object.keys(fromBuild).sort());
+    expect(folded).toEqual(fromBuild);
+  });
+});

package/src/discovery/fold-import.ts

@@ -60,6 +60,7 @@ import {
 import { getInterpolationFields, getProvenance, setPathProvenance, setProvenance } from "../provenance";
 import { foldProvenanceOfEntities, type FoldProvenance } from "../fold-provenance";
 import { collectEntities } from "./collect";
+import { hostCompositeName, markHostCompositeInstance } from "./host-composite";
 import { intrinsicCallFoldsEagerly, intrinsicTagFolds, type IntrinsicDef } from "../lexicon";
 import type { BuildParamValue } from "../build-params";
 
@@ -3056,53 +3057,6 @@ async function interpretCompositeFactory(
   }
 }
 
-/**
- * chant#3598 — a host composite instance's own marker. Non-enumerable and
- * symbol-keyed, like provenance, so nothing that serializes or compares the
- * exports sees it. It carries the composite's name, which the members object
- * otherwise has no record of once it is returned.
- */
-const HOST_COMPOSITE_INSTANCE = Symbol.for("chant.fold.hostCompositeInstance");
-
-/**
- * Mark `members` as the instance a host's composite produced, and return it
- * unchanged.
- *
- * chant#3608 — every declarable member, and every member of a nested host
- * instance, is also stamped with the composite, the way `expandComposite`
- * stamps a chant instance's members. A destructured member is never expanded,
- * so this is the only record it has that a composite wrote it, and without
- * it a path the fold did not attribute reads as authored and so `direct`.
- * `setProvenance` keeps the first writer, and a nested instance was marked
- * when its own call returned, so a member keeps its innermost composite.
- */
-function markHostCompositeInstance(members: Record<string, unknown>, compositeName: string): Record<string, unknown> {
-  if (Object.isExtensible(members) && !Object.prototype.hasOwnProperty.call(members, HOST_COMPOSITE_INSTANCE)) {
-    Object.defineProperty(members, HOST_COMPOSITE_INSTANCE, {
-      value: compositeName,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-  stampHostCompositeMembers(members, compositeName);
-  return members;
-}
-
-/** Stamp `composite` on each declarable member of a host instance, descending into nested host instances. */
-function stampHostCompositeMembers(members: Record<string, unknown>, compositeName: string): void {
-  for (const member of Object.values(members)) {
-    if (isDeclarable(member)) setProvenance(member, { composite: compositeName });
-    else if (hostCompositeName(member) !== undefined) stampHostCompositeMembers(member as Record<string, unknown>, compositeName);
-  }
-}
-
-/** The composite name a host composite instance was marked with, or `undefined` for any other value. */
-function hostCompositeName(value: unknown): string | undefined {
-  if (!isIndexableObject(value)) return undefined;
-  const name = (value as Record<symbol, unknown>)[HOST_COMPOSITE_INSTANCE];
-  return typeof name === "string" ? name : undefined;
-}
-
 /** Evaluate an admissible factory body's statements in order, binding each `const`, and return the `return` expression's value. */
 async function interpretFactoryBody(
   fn: ts.ArrowFunction | ts.FunctionExpression,
@@ -5081,7 +5035,7 @@ export async function foldProject(
       const attempt = attempts.get(file);
       return {
         file,
-        exports: attempt?.ok === true ? expandHostCompositeExports(Object.fromEntries(attempt.exportedValues)) : {},
+        exports: attempt?.ok === true ? Object.fromEntries(attempt.exportedValues) : {},
       };
     }),
   );
@@ -5153,71 +5107,6 @@ function foldProvenanceByFile(
   return out;
 }
 
-/**
- * chant#3598 — a file's exports with every host composite instance replaced by
- * its members, for {@link foldProvenanceByFile} only.
- *
- * A host's registration form (chant#2442) returns the members object the
- * factory built, not a chant `CompositeInstance`, because wrapping it would run
- * chant's member validation against the host's own entities. `collectEntities`
- * expands only chant's instances, so an instance exported whole
- * (`export const store = Store({...})`) contributed no entity and therefore no
- * record, while a destructured member, a plain declarable export, did.
- *
- * The members are named and stamped the way `expandComposite` names and stamps
- * a chant instance: `${exportName}${Member}`, with a whole-entity `composite`
- * origin under the paths the fold already attributed. That origin is written
- * before `collectEntities` adds its `authored` one, and the first writer wins,
- * so a path the fold did not attribute is `unknown` rather than `direct`.
- *
- * Only a top-level export is expanded. A host instance nested in another
- * composite's body or placed in an array does not fold today, so its file is
- * `run` and has no record to give.
- *
- * The exports a caller receives in the verdict are the originals.
- */
-function expandHostCompositeExports(exports: Record<string, unknown>): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [name, value] of Object.entries(exports)) {
-    if (hostCompositeName(value) === undefined) {
-      out[name] = value;
-      continue;
-    }
-    expandHostCompositeInstance(name, value as Record<string, unknown>, name, out);
-  }
-  return out;
-}
-
-/**
- * chant#3608 — one host instance's members into `out`, a nested host instance
- * expanded in place under its member's name (`siteMainBucket`), as
- * `expandComposite` expands a nested chant instance. Every member belongs to
- * the top-level `instance`; its composite is the innermost one, which
- * {@link markHostCompositeInstance} already stamped, so the whole-entity
- * origin names that composite too.
- */
-function expandHostCompositeInstance(
-  prefix: string,
-  members: Record<string, unknown>,
-  instance: string,
-  out: Record<string, unknown>,
-): void {
-  const compositeName = hostCompositeName(members) as string;
-  for (const [memberName, member] of Object.entries(members)) {
-    if (memberName.length === 0) continue;
-    const fullName = `${prefix}${memberName[0].toUpperCase()}${memberName.slice(1)}`;
-    if (hostCompositeName(member) !== undefined) {
-      expandHostCompositeInstance(fullName, member as Record<string, unknown>, instance, out);
-      continue;
-    }
-    if (!isDeclarable(member)) continue;
-    setProvenance(member, { composite: compositeName, compositeInstance: instance });
-    const composite = getProvenance(member)?.composite ?? compositeName;
-    setPathProvenance(member, "", { kind: "composite", composite, instance });
-    out[fullName] = member;
-  }
-}
-
 /** The deepest directory every one of `files` sits under. */
 function commonDirectory(files: readonly string[]): string {
   const split = files.map((file) => dirname(resolvePath(file)).split(sep));

package/src/discovery/fold-project-provenance.test.ts

@@ -394,11 +394,15 @@ describe("foldProject provenance for host composites (chant#3608)", () => {
     expect(provenance.bucket.composite).toBe("Archive");
     expect(provenance.bucket.fields).toEqual({ name: unknown, versioned: unknown });
 
-    // build() does not expand a host instance exported whole, so the
-    // destructured member is the one it can be held to.
-    const built = await build(join(root, "archive"), [namesSerializer], undefined, { fold: true });
+    // chant#3612 — build() expands the whole instance too, and agrees on every record.
+    const built = await build(join(root, "archive"), [namesSerializer], undefined, {
+      fold: true,
+      lexiconPackages: ["@tsad/shapes-3608"],
+      sandbox: true,
+    });
     expect(built.errors).toEqual([]);
-    expect(built.foldProvenance.bucket).toEqual(provenance.bucket);
+    expect([...built.entities.keys()].sort()).toEqual(["archiveBucket", "bucket"]);
+    expect(built.foldProvenance).toEqual(provenance);
   });
 
   test("a whole instance's nested composite members have records, and the innermost composite wins", async () => {
@@ -458,6 +462,19 @@ describe("foldProject provenance for host composites (chant#3608)", () => {
     expect(provenance.mainBucket.fields).toMatchObject({ name: innerName("main"), tier: innerTier("main") });
     expect(provenance.fixedBucket.fields).toMatchObject({ name: innerName("fixed"), tier: innerTier("fixed") });
     expect(provenance.side.fields.name).toMatchObject({ kind: "composite-parameter", composite: "Outer", parameters: ["name"] });
+
+    // chant#3612 — build() given the same host package reports the same
+    // entities and the same records. Before, it emitted nothing for `site`
+    // and, with the host off the allowlist, ran the file and read `side` as direct.
+    const built = await build(join(root, "site"), [namesSerializer], undefined, {
+      fold: true,
+      lexiconPackages: ["@tsad/shapes-3608"],
+      sandbox: true,
+    });
+    expect(built.errors).toEqual([]);
+    expect(built.foldDecisions.map((d) => d.mode)).toEqual(["fold"]);
+    expect([...built.entities.keys()].sort()).toEqual(Object.keys(provenance).sort());
+    expect(built.foldProvenance).toEqual(provenance);
   });
 });
 

package/src/discovery/host-composite.ts

@@ -0,0 +1,101 @@
+import { isDeclarable, type Declarable } from "../declarable";
+import { getProvenance, setPathProvenance, setProvenance } from "../provenance";
+
+/**
+ * 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.
+ *
+ * Only the fold path sets it: a host's registration form (chant#2442) returns
+ * the members object the factory built, not a chant `CompositeInstance`, and
+ * chant knows the object came from a composite only because the fold resolved
+ * the call. A file that runs instead has no such knowledge.
+ */
+const HOST_COMPOSITE_INSTANCE = Symbol.for("chant.fold.hostCompositeInstance");
+
+function isPlainIndexable(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * 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.
+ */
+export function markHostCompositeInstance(
+  members: Record<string, unknown>,
+  compositeName: string,
+): Record<string, unknown> {
+  if (Object.isExtensible(members) && !Object.prototype.hasOwnProperty.call(members, HOST_COMPOSITE_INSTANCE)) {
+    Object.defineProperty(members, HOST_COMPOSITE_INSTANCE, {
+      value: compositeName,
+      enumerable: false,
+      configurable: true,
+    });
+  }
+  stampHostCompositeMembers(members, compositeName);
+  return members;
+}
+
+/** Stamp `composite` on each declarable member of a host instance, descending into nested host instances. */
+function stampHostCompositeMembers(members: Record<string, unknown>, compositeName: string): void {
+  for (const member of Object.values(members)) {
+    if (isDeclarable(member)) setProvenance(member, { composite: compositeName });
+    else if (hostCompositeName(member) !== undefined) stampHostCompositeMembers(member as Record<string, unknown>, compositeName);
+  }
+}
+
+/** The composite name a host composite instance was marked with, or `undefined` for any other value. */
+export function hostCompositeName(value: unknown): string | undefined {
+  if (!isPlainIndexable(value)) return undefined;
+  const name = (value as Record<symbol, unknown>)[HOST_COMPOSITE_INSTANCE];
+  return typeof name === "string" ? name : undefined;
+}
+
+/**
+ * chant#3598, chant#3612 — a host composite instance's members as entities,
+ * for `collectEntities`.
+ *
+ * `collectEntities` is the one place `build()` and `foldProject` turn exports
+ * into entities, so expanding here is what makes the two report the same set:
+ * `export const archive = Archive({...})` gives `archiveBucket` to both.
+ *
+ * The members are named and stamped the way `expandComposite` names and stamps
+ * a chant instance: `${exportName}${Member}`, a nested host instance expanded
+ * in place under its member's name (`siteMainBucket`), with a whole-entity
+ * `composite` origin under the paths the fold already attributed. That origin
+ * is written before `collectEntities` adds its own record, and the first
+ * writer wins, so a path the fold did not attribute is `unknown` rather than
+ * `direct`. Every member belongs to the top-level `instance`; its composite is
+ * the innermost one, which {@link markHostCompositeInstance} already stamped.
+ */
+export function expandHostComposite(
+  prefix: string,
+  members: Record<string, unknown>,
+  instance: string = prefix,
+): Array<[string, Declarable]> {
+  const out: Array<[string, Declarable]> = [];
+  const compositeName = hostCompositeName(members) as string;
+  for (const [memberName, member] of Object.entries(members)) {
+    if (memberName.length === 0) continue;
+    const fullName = `${prefix}${memberName[0].toUpperCase()}${memberName.slice(1)}`;
+    if (hostCompositeName(member) !== undefined) {
+      out.push(...expandHostComposite(fullName, member as Record<string, unknown>, instance));
+      continue;
+    }
+    if (!isDeclarable(member)) continue;
+    setProvenance(member, { composite: compositeName, compositeInstance: instance });
+    const composite = getProvenance(member)?.composite ?? compositeName;
+    setPathProvenance(member, "", { kind: "composite", composite, instance });
+    out.push([fullName, member]);
+  }
+  return out;
+}

package/src/discovery/index.ts

@@ -143,6 +143,16 @@ export interface DiscoveryOptions {
    */
   lexicons?: readonly string[];
 
+  /**
+   * chant#3612 — package specifiers to follow a bare import into, verbatim,
+   * alongside whatever {@link lexicons} names. The same allowlist
+   * `FoldProjectOptions.lexiconPackages` gives `foldProject` (chant#2438), so
+   * a build over a host of its own folds the files `foldProject` folds. A
+   * chant project never needs it: its packages are `lexicons`. Only
+   * meaningful when {@link fold} is set. Default: none.
+   */
+  lexiconPackages?: 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;
@@ -289,7 +299,7 @@ export async function discover(path: string, options?: DiscoveryOptions): Promis
         buildParamValuesMap,
         options.lexicons,
         options.sandbox === true,
-        [],
+        options.lexiconPackages ?? [],
         options.executing === true,
         files,
       )

package/src/gate-decision-bundle.test.ts

@@ -6,7 +6,7 @@
  * rule because `@intentius/chant/op/gate` pulls in zod and the git ledger
  * code. `@intentius/chant/gate-decision` holds the decision for a plan digest
  * under `ledger`, `pr-review` and `sealed`, the seal check over
- * node:crypto, and the `identity.gates` rule with its class check (#3862). This bundles it the way terragucci would and reads esbuild's
+ * node:crypto, and the `identity.gates` rule with its class check (#3862), reading the classes pinned packages supply as data, without ajv (#3888). This bundles it the way terragucci would and reads esbuild's
  * own list of what went in.
  */
 
@@ -15,7 +15,7 @@ import { build } from "esbuild";
 import { describe, expect, test } from "vitest";
 import { REPO } from "./workspace/__fixtures__/contract-repo";
 
-const FORBIDDEN = [/node_modules\//, /\/src\/fold\//, /\/src\/lint\//, /\/src\/codegen\//, /\/src\/lifecycle\/git\.ts$/, /\/src\/lifecycle\/gate-ledger\.ts$/];
+const FORBIDDEN = [/node_modules\//, /\/src\/workspace\/(kinds|principal-classes|pin-integrity)\.ts$/, /\/src\/fold\//, /\/src\/lint\//, /\/src\/codegen\//, /\/src\/lifecycle\/git\.ts$/, /\/src\/lifecycle\/gate-ledger\.ts$/];
 
 describe("the gate-decision bundle", () => {
   test("holds the decision, the seal check and the plan digest, and no package or git code", async () => {
@@ -46,13 +46,15 @@ describe("the gate-decision bundle", () => {
       "packages/core/src/notify.ts",
       "packages/core/src/op/gate-point.ts",
       "packages/core/src/op/op-waves.ts",
+      "packages/core/src/wave-layout.ts",
+      "packages/core/src/workspace/class-data.ts",
       "packages/core/src/workspace/identity-gate-rule.ts",
       "packages/core/src/workspace/jsonc.ts",
       "packages/core/src/workspace/trust/gate-seal.ts",
       "packages/core/src/workspace/trust/trust-files.ts",
     ]);
-    // About 27 KB today.
+    // About 43 KB unminified today, 7 KB of it the pinned classes read as data (#3888).
     const bytes = result.outputFiles.reduce((n, f) => n + f.contents.byteLength, 0);
-    expect(bytes).toBeLessThan(40 * 1024);
+    expect(bytes).toBeLessThan(48 * 1024);
   });
 });