@intentius/chant 0.124.30 → 0.124.32

package/dist/components/pr-run.js

@@ -8,26 +8,42 @@
  * everything before applying anything is what makes the two digests
  * comparable: each member is planned against the same state both times.
  *
- * ## Dependents read the outputs standing now
+ * ## What a dependent is planned against
  *
  * A member that reads another one's output through `stackOutput()` is
- * planned with the value that output has now, read through the capability's
- * `outputs` (`readComponentOutputs`). When the change moves that output, the
- * dependent's approved plan still carries the old value; the apply applies
- * it as approved and marks the member `inputsMoved`, and the next run plans
- * it against the new value. A change that must carry a moved output through
- * its dependents in one rollout is what gated waves are for (#3049): each
- * wave is planned after the one before it applied.
+ * planned with one of three values (#3999):
  *
- * A dependency the change did not select is read the same way (#4104), so
- * a change to one cluster plans it against the network it sits on. That is
- * why `components` is every component in the project and not the selection.
- * `--seed-outputs` wins over a read, and a dependency whose steps cannot say
- * leaves its dependents' references unresolved. The apply stage's plan reads
- * the same dependencies, so on the same estate it gets the digest the plan
- * stage showed, and it applies against the outputs its plans read
- * (`set.outputs`). A resume plans against the outputs the approved plans
- * read, from the record (`planOutputs`), and reads nothing those cover.
+ * - the upstream is in the change too: the value its plan says it will
+ *   expose (`CapabilityPlan.outputs`). The report lists these under
+ *   `plannedOutputs`.
+ * - the upstream is not in the change (#4104): the value it has now, read
+ *   through its capability's `outputs` (`readComponentOutputs`). The report
+ *   lists these under `deployedOutputs`. A change to one cluster is planned
+ *   against the network it sits on, which is why `components` is every
+ *   component in the project and not the selection.
+ * - the upstream is in the change and its plan cannot say, or says the value
+ *   is known only after apply: no value. The dependent's members list the
+ *   reference under `unknownInputs`, and the approval does not cover what
+ *   it will do with it.
+ *
+ * `--seed-outputs` wins over both. The apply stage's plan reads the same
+ * values, so on the same estate it gets the digest the plan stage showed.
+ * A resume plans against the outputs the approved plans read, from the
+ * record (`planOutputs`), and reads nothing those cover.
+ *
+ * ## Planning again once an upstream applied
+ *
+ * The apply runs each member's approved plan, except a member whose plan
+ * read an upstream output that is not the value standing when its turn
+ * comes (`movedWiringReferences`): the upstream applied as another value
+ * than its plan said, or the value was unknown. That member, and what is
+ * downstream of it, is held back. Once the rest settled, the held members
+ * are planned again against the outputs the apply left, and that set's
+ * digest is decided at its own gate, `<gate>-round-<n>` (`prRoundGate`), as
+ * a gated wave decides each wave (#3049). Approved, it applies, and a member
+ * that is held again goes to the next round. Not approved, the apply stops
+ * `waiting` with the new digest named, and the same apply with its
+ * `--resume` record carries on from there.
  *
  * ## Finishing an apply that failed partway
  *
@@ -41,15 +57,24 @@
  * the rest applies. Planning everything again would give the applied members
  * empty plans and the set a new digest, and so ask for a second approval of
  * work already approved.
+ *
+ * ## A gate per wave on merge
+ *
+ * `pr-apply --wave-gate` (#4003) applies the approved set a wave at a time.
+ * {@link prWavePlan} narrows the derivation to one wave, which is planned
+ * against the outputs the waves before it left, and {@link waveNotCovered}
+ * says whether the approved change set covers what it planned, by the same
+ * test a resume uses ({@link planCoveredBy}). Covered, the wave applies under
+ * the pull request's approval; not covered, it needs its own.
  */
 import { composeChangeSet, verifyChangeSetDigest } from "../change-set.js";
 import { evaluateGate } from "../op/gate.js";
-import { memberCounts, PR_REPORT_CONTRACT, PR_REPORT_SCHEMA_ID, } from "../pr-loop.js";
-import { deployContext } from "./driver.js";
+import { memberCounts, PR_APPLY_GATE, prRoundGate, PR_REPORT_CONTRACT, PR_REPORT_SCHEMA_ID, } from "../pr-loop.js";
+import { deployContext, movedWiringReferences, unresolvedWiringReferences, } from "./driver.js";
 import { deployUnits } from "./deploy-units.js";
 import { runFanOut } from "./fan-out-run.js";
 import { remainingFanOut } from "./fan-out.js";
-import { planWaveComponent, readDeployedOutputs } from "./wave-plan.js";
+import { capabilitySteps, planWaveComponent, readDeployedOutputs } from "./wave-plan.js";
 /** The phase a pull request's planning is, in its run's events. */
 export const PR_PLAN_PHASE = "plan";
 /** A failed component's members: the units its steps target, else the component itself. */
@@ -61,36 +86,51 @@ function failedParts(component, error) {
     }));
 }
 /**
- * Plan every component in `plan.order`, a wave at a time, each against the
- * outputs its dependencies have now. Never throws for a component that fails
- * to plan: it becomes a failed member, and `failed` is set. Throws when a
- * planned member's dependency is not among `components`, which means the
- * caller passed the selection where the whole graph belongs.
+ * Plan every component in `plan.order`, a wave at a time, each against its
+ * dependencies' planned outputs when the change plans them too, and against
+ * the outputs they have now otherwise. Never throws for a component that
+ * fails to plan: it becomes a failed member, and `failed` is set. Throws
+ * when a planned member's dependency is not among `components`, which means
+ * the caller passed the selection where the whole graph belongs.
  */
 export async function planPrSet(options) {
     const byName = new Map(options.components.map((c) => [c.name, c]));
     const outputs = { ...(options.seededOutputs ?? {}) };
     const read = new Set(Object.keys(outputs));
+    const inChange = new Set(options.plan.order);
+    /** What each component of the change planned to expose, once its wave planned. */
+    const plannedBy = new Map();
     const deployed = {};
+    const planned = {};
     const parts = [];
     const componentOf = new Map();
+    const unknownOf = new Map();
     const plans = {};
     let failed = false;
     const emit = options.onRunEvent;
     emit?.({ type: "phase-start", component: null, phase: PR_PLAN_PHASE });
     for (const wave of options.plan.waves) {
-        // The dependencies' outputs first, each read once. A dependency that
-        // cannot say leaves its references unresolved, which its dependent's
-        // plan reports if it needs them. A dependency outside the selection is
-        // read the same way (#4104).
+        // The dependencies' outputs first, each once. One the change plans is
+        // read from its plan, which an earlier wave made (#3999). Any other is
+        // read from the deployed estate (#4104). A dependency that cannot say
+        // leaves its references unresolved, which its dependent's plan reports
+        // if it needs them.
         const deps = [...new Set(wave.flatMap((name) => byName.get(name)?.dependsOn ?? []))].filter((dep) => !read.has(dep));
+        const fromEstate = [];
         for (const dep of deps) {
             read.add(dep);
             if (!byName.has(dep))
                 throw new Error(`planPrSet: ${dep}, a dependency of a planned member, is not among the components; pass every component in the project`);
+            if (!inChange.has(dep)) {
+                fromEstate.push(dep);
+                continue;
+            }
+            const known = plannedBy.get(dep)?.known ?? {};
+            outputs[dep] = { ...known };
+            planned[dep] = Object.keys(known).sort();
         }
-        Object.assign(deployed, await readDeployedOutputs(deps, byName, options.registry, (dep) => deployContext(options, dep), outputs));
-        const planned = await Promise.all(wave.map(async (name) => {
+        Object.assign(deployed, await readDeployedOutputs(fromEstate, byName, options.registry, (dep) => deployContext(options, dep), outputs));
+        const results = await Promise.all(wave.map(async (name) => {
             const at = { component: name, phase: PR_PLAN_PHASE, step: "plan" };
             emit?.({ type: "step-start", ...at });
             const start = Date.now();
@@ -104,16 +144,21 @@ export async function planPrSet(options) {
             });
             return p;
         }));
-        for (const p of planned) {
+        for (const p of results) {
             const component = byName.get(p.component);
+            const unknown = unknownInputsOf(component, outputs, inChange);
+            if (unknown.unknown.length > 0 || unknown.build.length > 0)
+                unknownOf.set(p.component, unknown);
             if ("error" in p) {
                 failed = true;
+                plannedBy.set(p.component, undefined);
                 for (const part of failedParts(component, p.error)) {
                     parts.push(part);
                     componentOf.set(part.member.member, p.component);
                 }
                 continue;
             }
+            plannedBy.set(p.component, p.outputs);
             plans[p.component] = p.plans;
             for (const part of p.parts) {
                 parts.push(part);
@@ -123,16 +168,71 @@ export async function planPrSet(options) {
     }
     emit?.({ type: "phase-settle", component: null, phase: PR_PLAN_PHASE, status: failed ? "failed" : "ok" });
     const doc = composeChangeSet(parts);
-    const members = doc.members.map((m) => ({
-        member: m.member,
-        component: componentOf.get(m.member) ?? m.member,
-        planDigest: m.planDigest,
-        status: m.status === "failed" ? "plan-failed" : "planned",
-        counts: memberCounts(doc, m.member),
-        ...(m.error ? { error: m.error } : {}),
-    }));
-    const deployedOutputs = Object.fromEntries(Object.entries(deployed).sort(([a], [b]) => a.localeCompare(b)));
-    return { doc, members, plans, outputs, failed, ...(Object.keys(deployedOutputs).length > 0 ? { deployedOutputs } : {}) };
+    const members = doc.members.map((m) => {
+        const component = componentOf.get(m.member) ?? m.member;
+        const unknown = unknownOf.get(component);
+        return {
+            member: m.member,
+            component,
+            planDigest: m.planDigest,
+            status: m.status === "failed" ? "plan-failed" : "planned",
+            counts: memberCounts(doc, m.member),
+            ...(m.error ? { error: m.error } : {}),
+            ...(unknown?.unknown.length ? { unknownInputs: unknown.unknown } : {}),
+            ...(unknown?.build.length ? { buildInputs: unknown.build } : {}),
+        };
+    });
+    const sorted = (r) => Object.fromEntries(Object.entries(r).sort(([a], [b]) => a.localeCompare(b)));
+    const deployedOutputs = sorted(deployed);
+    const plannedOutputs = sorted(planned);
+    return {
+        doc,
+        members,
+        plans,
+        outputs,
+        failed,
+        ...(Object.keys(deployedOutputs).length > 0 ? { deployedOutputs } : {}),
+        ...(Object.keys(plannedOutputs).length > 0 ? { plannedOutputs } : {}),
+    };
+}
+/**
+ * The references `component`'s steps make to an output of a component in
+ * the change that `outputs` holds no value for (#3999), known only after
+ * that upstream applies, each sorted. `build` are the published artifact
+ * identities a build in the change produces (`WiringReference.publish`):
+ * the build's provenance binds those, so they are never approved again.
+ * `unknown` are the rest.
+ */
+function unknownInputsOf(component, outputs, inChange) {
+    const unknown = new Set();
+    const build = new Set();
+    for (const step of capabilitySteps(component.deploy)) {
+        const { kind: _kind, ...rest } = step;
+        for (const r of unresolvedWiringReferences(rest, outputs)) {
+            if (inChange.has(r.source))
+                (r.publish ? build : unknown).add(r.ref);
+        }
+    }
+    return { unknown: [...unknown].sort(), build: [...build].sort() };
+}
+/**
+ * Why `component` cannot apply the plan that read `read` now that `now`
+ * stands (#3999): each reference its steps make that resolves to another
+ * value, said once. `undefined` when every one resolves as it did. A
+ * published artifact's identity from a build in `inChange` never holds a
+ * member back: the build's provenance binds it, not this approval.
+ */
+export function heldReason(component, read, now, inChange = new Set()) {
+    const refs = new Set();
+    for (const step of capabilitySteps(component.deploy)) {
+        const { kind: _kind, ...rest } = step;
+        for (const r of movedWiringReferences(rest, read, now))
+            if (!(r.publish && inChange.has(r.source)))
+                refs.add(r.ref);
+    }
+    if (refs.size === 0)
+        return undefined;
+    return `its plan read ${[...refs].sort().join(", ")} before ${refs.size === 1 ? "that output" : "those outputs"} applied as another value`;
 }
 /**
  * A ledger that reads the real one and records nothing. The plan stage
@@ -178,58 +278,132 @@ export function approversWithoutReview(approvedBy, reviewers) {
     const allowed = new Set(reviewers.map(norm));
     return approvedBy.filter((by) => !allowed.has(norm(by)));
 }
-const sameJson = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+/**
+ * Who approved the gate but wrote the change (#4000): each approval's
+ * `resolvedBy` that names one of `authors`, the forge's naming of the pull
+ * request's author and of its commits' authors and committers. Their own
+ * approval never counts, whether a forge review or a ledger line backs it.
+ */
+export function approversWhoAuthored(approvedBy, authors) {
+    const norm = (s) => s.trim().toLowerCase();
+    const wrote = new Set(authors.map(norm));
+    return approvedBy.filter((by) => wrote.has(norm(by)));
+}
+/** Two runs of one apply as one: `b` ran after `a`, against the outputs `a` left. */
+function joinRuns(a, b) {
+    const status = a.status === "fail" || b.status === "fail" ? "fail" : a.status === "gated" || b.status === "gated" ? "gated" : "ok";
+    const gate = a.gate ?? b.gate;
+    return {
+        plan: a.plan,
+        status,
+        results: [...a.results, ...b.results],
+        completed: [...new Set([...a.completed, ...b.completed])].sort(),
+        failed: [...new Set([...a.failed, ...b.failed])].sort(),
+        blocked: [...a.blocked, ...b.blocked],
+        componentOutputs: b.componentOutputs,
+        ...(gate ? { gate } : {}),
+        ...(b.held ? { held: b.held } : {}),
+    };
+}
 /**
  * Apply the approved plans in dependency order. A failed component blocks
- * its dependents and nothing else (`runFanOut`).
+ * its dependents and nothing else (`runFanOut`). A member whose plan read an
+ * upstream output that is not the value standing when its turn comes is held
+ * back with what is downstream of it, planned again once the rest settled,
+ * and applied when `decideRound` approves that plan (#3999).
  */
 export async function applyPrSet(options) {
-    const before = options.set.outputs;
-    const run = await runFanOut(options.plan, options.components, options.registry, {
+    const byName = new Map(options.components.map((c) => [c.name, c]));
+    const priorCompleted = new Set(options.resumed?.completed ?? []);
+    const inChange = new Set([...options.set.members.map((m) => m.component), ...options.plan.order]);
+    const toApply = new Set([...inChange].filter((name) => !priorCompleted.has(name)));
+    // The outputs standing as the apply starts: what the plans read of
+    // components outside the change, and what an earlier attempt's components
+    // left (the values the plans read, where its record kept none). A planned
+    // value of a component still to apply stands nowhere until it applies.
+    const standing = {
+        ...Object.fromEntries(Object.entries(options.set.outputs).filter(([name]) => !toApply.has(name))),
+        ...(options.resumed?.outputs ?? {}),
+    };
+    const runRound = (plan, plans, read, outputs) => runFanOut(plan, options.components, options.registry, {
         env: options.env,
         ...(options.vars ? { vars: options.vars } : {}),
-        plans: options.set.plans,
-        componentOutputs: { ...before },
+        plans,
+        componentOutputs: outputs,
+        hold: (name, now) => heldReason(byName.get(name), read, now, inChange),
         ...(options.onProgress ? { onProgress: options.onProgress } : {}),
         ...(options.onRunEvent ? { onRunEvent: options.onRunEvent } : {}),
         ...(options.onComponentSettled ? { onComponentSettled: options.onComponentSettled } : {}),
     });
+    let run = await runRound(options.plan, options.set.plans, options.set.outputs, { ...standing });
+    const rounds = [];
+    /** Per component, the round that applied it or holds it, and that round's set, after the first. */
+    const roundOf = new Map();
+    let stopped;
+    while (run.held && run.held.length > 0 && run.status === "ok" && options.decideRound) {
+        const round = rounds.length + 2;
+        const gate = prRoundGate(options.gate ?? PR_APPLY_GATE, round);
+        const heldNames = new Set(run.held.map((h) => h.component));
+        const plan = remainingFanOut(options.plan, options.components, { completed: options.plan.order.filter((name) => !heldNames.has(name)) });
+        const set = await planPrSet({
+            components: options.components,
+            plan,
+            registry: options.registry,
+            env: options.env,
+            ...(options.vars ? { vars: options.vars } : {}),
+            seededOutputs: run.componentOutputs,
+        });
+        for (const name of plan.order)
+            roundOf.set(name, { round, set });
+        const record = (status, approval, message) => {
+            rounds.push({ round, gate, digest: set.doc.digest, components: plan.order, approval, status, ...(message ? { message } : {}), changeSet: set.doc });
+        };
+        if (set.failed) {
+            record("plan-failed", { status: "pending" });
+            stopped = "plan-failed";
+            break;
+        }
+        const decision = await options.decideRound({ round, gate, set, plan });
+        if (!decision.satisfied) {
+            record("waiting", decision.approval, decision.message);
+            stopped = "waiting";
+            break;
+        }
+        const next = await runRound(plan, set.plans, set.outputs, run.componentOutputs);
+        record(next.status === "fail" ? "failed" : "applied", decision.approval);
+        run = joinRuns(run, next);
+    }
     const completed = new Set(run.completed);
-    const priorCompleted = new Set(options.resumed?.completed ?? []);
-    /**
-     * Whether a dependency's outputs moved from what the plans read: by this
-     * run's apply, or by the earlier attempt's when the record kept them.
-     */
-    const movedBy = (dep) => {
-        if (completed.has(dep))
-            return !sameJson(before[dep], run.componentOutputs[dep]);
-        const earlier = options.resumed?.outputs;
-        return priorCompleted.has(dep) && earlier !== undefined && dep in earlier && !sameJson(before[dep], earlier[dep]);
-    };
+    const held = new Map((run.held ?? []).map((h) => [h.component, h]));
     const blocked = new Set(run.blocked.map((b) => b.component));
     const errorOf = (component) => {
-        const result = run.results.find((r) => r.component === component);
+        const result = [...run.results].reverse().find((r) => r.component === component);
         if (result?.status === "gated")
             return `stopped at its own gate ${result.gate?.gate ?? ""}`.trim();
         return result?.records.find((r) => r.status === "fail")?.error;
     };
-    const byName = new Map(options.components.map((c) => [c.name, c]));
     const members = options.set.members.map((m) => {
         if (priorCompleted.has(m.component))
             return { ...m, status: "applied" };
-        if (completed.has(m.component)) {
-            const moved = (byName.get(m.component)?.dependsOn ?? [])
-                .filter(movedBy)
-                .sort();
-            return { ...m, status: "applied", ...(moved.length > 0 ? { inputsMoved: moved } : {}) };
-        }
+        const later = roundOf.get(m.component);
+        const fresh = later?.set.members.find((x) => x.member === m.member);
+        const asPlanned = later && fresh ? { ...m, planDigest: fresh.planDigest, counts: fresh.counts, round: later.round } : m;
+        if (completed.has(m.component))
+            return { ...asPlanned, status: "applied" };
+        const h = held.get(m.component);
+        if (h)
+            return { ...asPlanned, status: "waiting", held: h.heldBy ? `${h.heldBy} is held: ${h.reason}` : h.reason };
+        if (fresh?.status === "plan-failed")
+            return { ...asPlanned, status: "plan-failed", ...(fresh.error ? { error: fresh.error } : {}) };
         if (blocked.has(m.component))
-            return { ...m, status: "blocked" };
+            return { ...asPlanned, status: "blocked" };
         const error = errorOf(m.component);
-        return { ...m, status: "failed", ...(error ? { error } : {}) };
+        return { ...asPlanned, status: "failed", ...(error ? { error } : {}) };
     });
-    return { members, status: run.status === "ok" ? "applied" : "failed", run };
+    const status = run.status !== "ok" || stopped === "plan-failed" ? "failed" : held.size > 0 || stopped === "waiting" ? "waiting" : "applied";
+    return { members, status, run, ...(rounds.length > 0 ? { rounds } : {}) };
 }
+const sameJson = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
 const entryKey = (e) => `${e.member}\u0000${e.address}\u0000${e.deposed ?? ""}`;
 /**
  * Why `member`'s fresh plan is not covered by the approved change set, or
@@ -361,6 +535,48 @@ export async function resumePrSet(options) {
         },
     };
 }
+/**
+ * The fan-out narrowed to wave `wave` of `plan` (1-based), less the
+ * components in `completed` (#4003). Its one wave is what is left of that
+ * wave; a dependency outside it, an earlier wave's component among them, is
+ * a seed. The digest is the derivation's, as {@link remainingFanOut} keeps it.
+ */
+export function prWavePlan(plan, components, wave, completed = []) {
+    const done = new Set(completed);
+    const order = (plan.waves[wave - 1] ?? []).filter((name) => !done.has(name));
+    const inWave = new Set(order);
+    const byName = new Map(components.map((c) => [c.name, c]));
+    const seeds = [
+        ...new Set([...plan.seeds, ...order.flatMap((name) => (byName.get(name)?.dependsOn ?? []).filter((dep) => !inWave.has(dep)))]),
+    ].sort();
+    return { order, waves: order.length > 0 ? [order] : [], skipped: [], seeds, indeterminate: plan.indeterminate, digest: plan.digest };
+}
+/**
+ * Why the approved change set does not cover a wave's new plan, one line per
+ * member, or `[]` when it covers every member (#4003). A member is covered
+ * as {@link planCoveredBy} says, with one rule more: a member whose planner
+ * describes no changes (chant's own empty part, for a capability that
+ * returns no change set) is covered only by the digest it was approved
+ * with, since with no entries there is nothing to compare a moved plan by.
+ */
+export function waveNotCovered(approved, fresh, approvedMembers = []) {
+    // #3999: a member whose approved plan waited only on an artifact a build in
+    // the change publishes is covered by that build's provenance, as it is
+    // without --wave-gate.
+    const byBuild = new Set(approvedMembers.filter((m) => m.buildInputs?.length && !m.unknownInputs?.length).map((m) => m.member));
+    return fresh.members
+        .map((m) => {
+        if (byBuild.has(m.member))
+            return undefined;
+        const was = approved.members.find((a) => a.member === m.member);
+        const opaque = m.planner === "chant" && m.lexicon === "chant" && m.status === "planned";
+        if (opaque && was && was.planDigest !== m.planDigest) {
+            return `${m.member} now plans to ${m.planDigest}, not the approved ${was.planDigest ?? "(none)"}, and its planner describes no changes to compare`;
+        }
+        return planCoveredBy(approved, fresh, m.member);
+    })
+        .filter((r) => r !== undefined);
+}
 /** The report a stage writes. */
 export function prReport(input) {
     const changed = new Set(input.signal.changed);
@@ -381,7 +597,11 @@ export function prReport(input) {
         ...(input.message ? { message: input.message } : {}),
         ...(input.resumed ? { resumed: { applied: [...input.resumed].sort() } } : {}),
         ...(input.set.deployedOutputs ? { deployedOutputs: input.set.deployedOutputs } : {}),
+        ...(input.set.plannedOutputs ? { plannedOutputs: input.set.plannedOutputs } : {}),
+        ...(input.rounds && input.rounds.length > 0 ? { rounds: input.rounds } : {}),
         approval: input.approval,
+        ...(input.waveGate ? { waveGate: input.waveGate } : {}),
+        ...(input.waveGate && input.waves?.length ? { waves: [...input.waves].sort((a, b) => a.wave - b.wave) } : {}),
         selection: {
             changed: input.plan.order.filter((c) => changed.has(c)),
             dependents: input.plan.order.filter((c) => !changed.has(c)),

package/dist/components/wave-plan.d.ts

@@ -19,20 +19,23 @@
  * `@<component>.publish.*`) resolves.
  */
 import { type DriverComponent, type DriverPhase, type DriverStep } from "./driver.js";
-import type { CapabilityRegistry, DeployContext } from "./capability.js";
+import type { CapabilityRegistry, DeployContext, PlannedOutputs } from "./capability.js";
 import type { WaveMember } from "../gated-waves.js";
 import type { ChangeSetPart } from "../change-set.js";
 /**
  * What planning one component produced: its members, what its steps hand to
  * `run`, and each member's change-set part (#3183), or why it could not plan.
  * A member whose capability returns no part gets one with no entries, so the
- * parts always cover the members.
+ * parts always cover the members. `outputs` is what its steps' plans say the
+ * component will expose once applied (#3999), merged the way the driver
+ * merges a run's outputs; absent when no step's plan says.
  */
 export type WaveComponentPlan = {
     component: string;
     members: WaveMember[];
     plans: Record<string, unknown>;
     parts: ChangeSetPart[];
+    outputs?: PlannedOutputs;
 } | {
     component: string;
     error: string;

package/dist/components/wave-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wave-plan.d.ts","sourceRoot":"","sources":["../../src/components/wave-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAA6C,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAE9H,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,GACpG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAUzC,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,UAAU,EAAE,CAc5E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,aAAa,EAClB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,aAAa,CAGf;AAED,oHAAoH;AACpH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,OAAO,CAAC,iBAAiB,CAAC,CAgC5B;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAU9C;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,EAChD,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,aAAa,EAC3C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC/C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAYnC"}
+{"version":3,"file":"wave-plan.d.ts","sourceRoot":"","sources":["../../src/components/wave-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAA6C,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAE9H,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,cAAc,CAAA;CAAE,GAC9H;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAUzC,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,UAAU,EAAE,CAc5E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,aAAa,EAClB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,aAAa,CAGf;AAED,oHAAoH;AACpH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,OAAO,CAAC,iBAAiB,CAAC,CAkC5B;AAUD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAU9C;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,EAChD,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,aAAa,EAC3C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC/C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAYnC"}

package/dist/components/wave-plan.js

@@ -59,6 +59,7 @@ export async function planWaveComponent(component, registry, ctx, componentOutpu
         const members = [];
         const plans = {};
         const parts = [];
+        let outputs;
         for (const step of capabilitySteps(component.deploy)) {
             const capability = registry.resolve(step.kind);
             if (!capability.plan)
@@ -71,6 +72,8 @@ export async function planWaveComponent(component, registry, ctx, componentOutpu
             parts.push(planned.changeSet ?? emptyPart(member));
             if (planned.artifact !== undefined)
                 plans[planned.member] = planned.artifact;
+            if (planned.outputs)
+                outputs = mergePlannedOutputs(outputs, planned.outputs);
         }
         if (members.length === 0) {
             const member = {
@@ -84,12 +87,20 @@ export async function planWaveComponent(component, registry, ctx, componentOutpu
             members.push(member);
             parts.push(emptyPart(member));
         }
-        return { component: component.name, members, plans, parts };
+        return { component: component.name, members, plans, parts, ...(outputs ? { outputs } : {}) };
     }
     catch (err) {
         return { component: component.name, error: err instanceof Error ? err.message : String(err) };
     }
 }
+/** `next` over `prior`, as a later step's outputs win over an earlier one's in a run. */
+function mergePlannedOutputs(prior, next) {
+    const known = { ...(prior?.known ?? {}), ...next.known };
+    const unknown = new Set([...(prior?.unknown ?? []).filter((n) => !(n in next.known)), ...next.unknown]);
+    for (const n of unknown)
+        delete known[n];
+    return { known, unknown: [...unknown].sort() };
+}
 /**
  * The outputs `component` exposes now, read from each step whose capability
  * has `outputs` (#3183), merged the way the driver merges a run's outputs.

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":"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"}
+{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAMjC,OAAO,EAAsC,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,EAAkC,KAAK,iBAAiB,EAAyB,MAAM,cAAc,CAAC;AAsD7G,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGnF,OAAO,EAAgD,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;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;;;;;;;;OAQG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB;;;;;;;;;;;;;OAaG;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;IAC9C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7C;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,gGAAgG;IAChG,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAAC,CAAC;CAC/E;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;GASG;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,EAChC,OAAO,UAAQ;AACf;;;;;;;;;;;GAWG;AACH,eAAe,GAAE,SAAS,MAAM,EAAO;AACvC,uEAAuE;AACvE,SAAS,UAAQ;AACjB;;;GAGG;AACH,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,WAAW,CA2Bb;AAqJD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;;;OAMG;IACH,yBAAyB,EAAE,MAAM,CAAC;IAClC;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAQD,gKAAgK;AAChK,wBAAgB,mBAAmB,IAAI,QAAQ,CAAC,mBAAmB,CAAC,CAEnE;AAED,0EAA0E;AAC1E,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C;AA2RD,oDAAoD;AACpD,UAAU,aAAa;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB;;;yEAGqE;IACrE,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC;CACjC;AAED,4FAA4F;AAC5F,UAAU,sBAAsB;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,EAAE,CAAC,aAAa,CAAC;CACjC;AAswCD;;;;;;;;;;GAUG;AACH,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IAC1B;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;;;;;;OAaG;IACH,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC;IACnC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACpC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;IACtD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC,CAAC;CACxF;AA2ZD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,kBAAkB,GAAG,MAAM,GAAG,SAAS,CA0D3G;AAk5DD;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAwCzG;AAED,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,WAAW,CAAC,MAAM,CAAC,CAAC,CAE9B;AAED,yDAAyD;AACzD,MAAM,MAAM,aAAa;AACvB,oFAAoF;AAClF,UAAU;AACZ,+EAA+E;GAC7E,SAAS,CAAC;AAEd,MAAM,WAAW,SAAS;IACxB,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;CAChF;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,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,SAAS,CAAC,CAkDpB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,qFAAqF;IACrF,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC;IACjE,0GAA0G;IAC1G,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAED,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC;IAC3D,mFAAmF;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChD;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,UAAU,GAAE,SAAS,YAAY,EAAO,EACxC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAkE1C"}

package/dist/discovery/fold-import.js

@@ -11,6 +11,7 @@ import { isIntrinsic } from "../intrinsic.js";
 import { collectConsts, foldResource, fold, propName, FoldError, isFoldableFunction, locate, collectSameFileFunctions, constResolvesToResource, } from "../fold/fold.js";
 import { isChantOwnedSpecifier, isFoldableHelperName } from "../fold/foldable-helpers.js";
 import { lexiconModulePath, lexiconModuleRoot } from "../lexicon-module.js";
+import { compiledModuleSource } from "../module-source.js";
 import { isFile, packageExportsTarget, probeModuleFile, splitBareSpecifier, tsconfigPathsMatch, } from "./specifier-resolve.js";
 import { briefNodeText, callExpressionMessage, computedPropertyNameMessage, isLiteralElementKey, unsupportedBinaryMessage, unsupportedExpressionMessage, UNSUPPORTED_OBJECT_MEMBER_MESSAGE, UNSUPPORTED_UNARY_MESSAGE, SUPPORTED_BINARY_OPERATORS, SUPPORTED_UNARY_OPERATORS, } from "../fold/subset.js";
 import { importModule } from "./import.js";
@@ -1375,10 +1376,11 @@ function isUnfoldableSameFileCall(name, ctx) {
 //     specifier, or its package root for a subpath, against
 //     {@link FoldSession.lexiconPackages}, exactly as
 //     {@link isTrustedExecutableBinding}'s arm 1 matches it — and only then
-//     resolved; a module that resolves to compiled JavaScript or a declaration
-//     file is not interpreted, so a package that ships only `dist` keeps
-//     invoking. Every chant lexicon routes its exports at `./src/*.ts`
-//     (check-lexicon tier 1), so in practice the source is always there.
+//     resolved; a module that resolves to a declaration file, or to compiled
+//     JavaScript with no `src/` source beside its `dist/`, is not interpreted,
+//     so a package that ships only `dist` keeps invoking. Every chant lexicon
+//     publishes `src/` beside the `dist/*.js` its exports name (#3981), and
+//     a compiled module is read from that source.
 //     Interpreting buys provenance: the run path cannot say which parameter
 //     fed a field, and interpretation can (#2161, #3246).
 //
@@ -1713,8 +1715,16 @@ function factoryOrigin(specifier, fromFile, ctx) {
     catch {
         return undefined;
     }
-    if (!isTypeScriptSource(modulePath))
-        return undefined;
+    if (!isTypeScriptSource(modulePath)) {
+        // #3981 — a lexicon's exports resolve to the compiled dist/*.js it
+        // publishes, beside the src/ it was built from. The source is what is
+        // read; an import the body makes still loads the compiled module, since
+        // the compiled CLI points a lexicon's src/*.ts at its dist/*.js.
+        const source = compiledModuleSource(modulePath);
+        if (source === undefined || !isFile(source))
+            return undefined;
+        modulePath = source;
+    }
     const packageRoot = lexiconPackageDirectory(modulePath, packageName);
     return packageRoot === undefined ? undefined : { modulePath, packageRoot };
 }

package/dist/discovery/sandbox/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/discovery/sandbox/bundle.ts"],"names":[],"mappings":"AA0LA,MAAM,WAAW,YAAY;IAC3B,uSAAuS;IACvS,UAAU,EAAE,MAAM,CAAC;IACnB,kJAAkJ;IAClJ,SAAS,EAAE,MAAM,CAAC;IAClB,uQAAuQ;IACvQ,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,uGAAuG;IACvG,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA4B9E"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/discovery/sandbox/bundle.ts"],"names":[],"mappings":"AA2LA,MAAM,WAAW,YAAY;IAC3B,uSAAuS;IACvS,UAAU,EAAE,MAAM,CAAC;IACnB,kJAAkJ;IAClJ,SAAS,EAAE,MAAM,CAAC;IAClB,uQAAuQ;IACvQ,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,uGAAuG;IACvG,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAiC9E"}