@intentius/chant 0.124.27 → 0.124.29

package/src/components/driver.ts

@@ -56,7 +56,9 @@ import type { PendingGateRecord } from "../lifecycle/gate-ledger";
 import type { CapabilityRegistry, DeployContext } from "./capability";
 import { isPromotedArtifact } from "./auto-release";
 import type { ReleaseIdentity } from "../telemetry-attribution";
-import type { RunProgressEvent, RunProgressStatus } from "./run-progress";
+import type { RunProgressEvent } from "./run-progress";
+import type { RunEventSettleStatus } from "../run-event";
+import { gateEventsOf, joinRunEventSinks, progressSinkOf, type RunEventSink } from "../run-event-stream";
 
 export type { RunProgressEvent } from "./run-progress";
 
@@ -153,7 +155,16 @@ export interface DriverStepRecord {
   output?: unknown;
   error?: string;
   /** Set on a `gate` step that passed (#2119): who resolved it, when, and at what address. */
-  approval?: { gate: string; resolvedBy: string; timestamp: string; url?: string };
+  approval?: {
+    gate: string;
+    resolvedBy: string;
+    timestamp: string;
+    url?: string;
+    /** The gate ledger the approval is in, when it isn't the component's own: a release gate's (#4045). */
+    op?: string;
+    /** Set when the gate passed over an empty change set (#4045) rather than on a person's approval. */
+    empty?: true;
+  };
 }
 
 export interface DriverComponentResult {
@@ -334,6 +345,42 @@ export function resolveStepInput(
   return walk(input) as Record<string, unknown>;
 }
 
+/**
+ * The components (or stacks) whose outputs `input` reads through
+ * cross-component wiring, `stackOutput()` or `@<component>.publish.*`, and
+ * which have no value for it in `componentOutputs`, sorted and each once
+ * (#4084). {@link resolveStepInput} turns each such reference into
+ * `undefined`; a plan uses this to say whose outputs it is waiting on.
+ */
+export function unresolvedWiringSources(
+  input: Record<string, unknown>,
+  componentOutputs: Record<string, Record<string, unknown>>,
+): string[] {
+  const found = new Set<string>();
+  const walk = (value: unknown): void => {
+    if (typeof value === "string") {
+      if (PRIOR_STEP_REF.test(value)) return;
+      const ref = value.match(COMPONENT_ARTIFACT_REF);
+      if (ref && resolvePath(componentOutputs[ref[1]]?.publish, ref[2]) === undefined) found.add(ref[1]);
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach(walk);
+      return;
+    }
+    if (value && typeof value === "object") {
+      if ("stackOutput" in value) {
+        const { stack, name } = (value as { stackOutput: { stack: string; name: string } }).stackOutput;
+        if (resolvePath(componentOutputs[stack], name) === undefined) found.add(stack);
+        return;
+      }
+      Object.values(value as Record<string, unknown>).forEach(walk);
+    }
+  };
+  walk(input);
+  return [...found].sort();
+}
+
 // ── Step + phase execution ───────────────────────────────────────────────
 
 /**
@@ -378,8 +425,8 @@ class GateStop extends Error {
   }
 }
 
-/** A result status as the progress stream spells it — the only difference is `fail` vs `failed`, which the two vocabularies have always disagreed on. */
-function progressStatus(status: DriverComponentResult["status"]): RunProgressStatus {
+/** A result status as the event stream spells it — the only difference is `fail` vs `failed`, which the two vocabularies have always disagreed on. */
+function progressStatus(status: DriverComponentResult["status"]): RunEventSettleStatus {
   return status === "fail" ? "failed" : status;
 }
 
@@ -395,6 +442,27 @@ export interface GateContext {
   releases?: ReadonlyMap<string, string>;
   /** This component's plan digest. Set by {@link runComponentDeploy}, never by a caller. */
   planDigest?: string;
+  /**
+   * The release gate binding (#4045): set by a promote under a release.
+   * Every gate the run reaches is then decided in `op`'s ledger against the
+   * change-set document's digest, the release and the environment, in place
+   * of the component's own ledger and composition digest.
+   */
+  releaseGate?: ReleaseGateBinding;
+}
+
+/**
+ * What a release gate binds (#4045, ws-104 question 2): the change-set
+ * document's digest, the release, and (from the run) the environment.
+ */
+export interface ReleaseGateBinding {
+  /** The gate ledger the release gate is recorded in, for every component of the promote. */
+  op: string;
+  /** The digest of the change-set document planned for this release and environment. */
+  planDigest: string;
+  releaseDigest: string;
+  /** Reads the document stored under a digest and says whether it is empty (`evaluateGate`'s `verifyEmpty`). */
+  verifyEmpty?: (planDigest: string) => Promise<boolean>;
 }
 
 /** Run a single capability step. Never throws for a capability-run failure; returns a fail record instead. */
@@ -451,14 +519,16 @@ async function runCapabilityStep(
  * gate is a read of the ledger rather than work, and starting activities a
  * pending gate is about to strand defeats the point of stopping at it.
  *
- * `onProgress`, when supplied, is called with a `phase-start` event before any
- * step runs, a `step` event around each capability invocation (`"running"`
- * then `"ok"`/`"failed"`), and a `phase-done` event once the phase settles —
- * purely additive observation, never consulted for control flow. Recursion
- * into a nested fan-out phase passes the same callback through, so a nested
- * phase's events use its own name. Left `undefined` by every caller that
- * doesn't opt into `--progress-json` (see ./run-progress.ts), in which case
- * every `onProgress?.(...)` call below is a no-op and behavior is unchanged.
+ * `emit`, when supplied, gets the phase's run events (#4041): `phase-start`
+ * before any step runs, a `step-start` and a `step-settle` around each gate
+ * and each capability invocation, the gate's `gate-resolved` or
+ * `gate-waiting`, a `skipped` settle with `skip: "not-run"` for each step a
+ * failure or a gate stopped, and `phase-settle` once the phase settles. It
+ * is observation only, never consulted for control flow. Recursion into a
+ * nested fan-out phase passes the same sink through, so a nested phase's
+ * events use its own name. `--progress-json` reads the same events through
+ * `progressOfRunEvent` (../run-event-stream.ts), which keeps the older
+ * stream's shape.
  */
 async function runPhase(
   phaseDef: DriverPhase,
@@ -467,22 +537,34 @@ async function runPhase(
   phaseOutputs: Record<string, Record<string, unknown>>,
   componentOutputs: Record<string, Record<string, unknown>>,
   gates: GateContext,
-  onProgress?: (event: RunProgressEvent) => void,
+  emit?: RunEventSink,
 ): Promise<{ records: DriverStepRecord[]; executed: ExecutedStep[] }> {
+  /** Where a step of this phase sits, for its events. */
+  const stepAt = (entry: DriverStep | DriverGate | DriverPhase, step: string) => ({
+    component: ctx.component,
+    phase: phaseDef.phase,
+    step,
+    index: phaseDef.steps.indexOf(entry),
+  });
   /** Decide this phase's gates against the ledger, in authored order, before any of its work starts. Throws `GateStop` at the first one nobody has approved. */
   const decideGates = async (): Promise<DriverStepRecord[]> => {
     const gateRecords: DriverStepRecord[] = [];
     for (const gate of phaseDef.steps.filter(isGateStep)) {
       const start = Date.now();
       const base = { component: ctx.component, phase: phaseDef.phase, kind: `gate:${gateName(gate)}` };
+      const at = stepAt(gate, base.kind);
+      emit?.({ type: "step-start", ...at });
       let check: Awaited<ReturnType<typeof evaluateGate>>;
       try {
         check = await evaluateGate(gates.port, {
-          op: ctx.component,
+          op: gates.releaseGate?.op ?? ctx.component,
           gate: gateName(gate),
           // #2574: an approval counts only for this environment and this plan.
           environment: ctx.env,
           ...(gates.planDigest !== undefined ? { planDigest: gates.planDigest } : {}),
+          // #4045: and under a release, only for that release.
+          ...(gates.releaseGate ? { releaseDigest: gates.releaseGate.releaseDigest } : {}),
+          ...(gates.releaseGate?.verifyEmpty ? { verifyEmpty: gates.releaseGate.verifyEmpty } : {}),
           ...(gate.description ? { description: gate.description } : {}),
           ...(gate.timeout ? { timeout: gate.timeout } : {}),
           ...(gates.now ? { now: gates.now } : {}),
@@ -492,11 +574,22 @@ async function runPhase(
         // executor's gate step does, and the component unwinds like any failure.
         if (!(err instanceof GateNotRecordableError)) throw err;
         gateRecords.push({ ...base, status: "fail" as const, durationMs: Date.now() - start, error: err.message });
+        emit?.({ type: "step-settle", ...at, status: "failed", durationMs: Date.now() - start, error: err.message });
         for (const skipped of phaseDef.steps.filter((s): s is DriverStep | DriverPhase => !isGateStep(s))) {
           gateRecords.push(skippedRecord(skipped));
         }
         throw new StepFailure(gateRecords, []);
       }
+      for (const body of gateEventsOf(
+        check,
+        { ...at, op: gates.releaseGate?.op ?? ctx.component, gate: gateName(gate) },
+        {
+          durationMs: Date.now() - start,
+          ...(!check.satisfied && check.mismatch ? { message: "an approval stands for this gate, but for another environment or plan" } : {}),
+        },
+      )) {
+        emit?.(body);
+      }
       if (!check.satisfied) {
         gateRecords.push({ ...base, status: "skipped" as const, durationMs: Date.now() - start });
         for (const skipped of phaseDef.steps.filter((s): s is DriverStep | DriverPhase => !isGateStep(s))) {
@@ -513,6 +606,8 @@ async function runPhase(
           resolvedBy: check.resolution.resolvedBy,
           timestamp: check.resolution.timestamp,
           ...(check.resolution.url ? { url: check.resolution.url } : {}),
+          ...(gates.releaseGate ? { op: gates.releaseGate.op } : {}),
+          ...(check.via === "empty" ? { empty: true as const } : {}),
         },
       });
     }
@@ -534,7 +629,7 @@ async function runPhase(
   }> => {
     if (isPhaseStep(entry)) {
       try {
-        const nested = await runPhase(entry, ctx, registry, phaseOutputs, componentOutputs, gates, onProgress);
+        const nested = await runPhase(entry, ctx, registry, phaseOutputs, componentOutputs, gates, emit);
         return { ...nested, failed: false };
       } catch (err) {
         if (err instanceof StepFailure) return { records: err.records, executed: err.executed, failed: true };
@@ -554,7 +649,8 @@ async function runPhase(
         throw err;
       }
     }
-    onProgress?.({ type: "step", component: ctx.component, phase: phaseDef.phase, step: entry.kind, status: "running" });
+    const at = stepAt(entry, entry.kind);
+    emit?.({ type: "step-start", ...at });
     const { record, resolvedInput, output } = await runCapabilityStep(
       entry,
       phaseDef.phase,
@@ -563,12 +659,11 @@ async function runPhase(
       phaseOutputs,
       componentOutputs,
     );
-    onProgress?.({
-      type: "step",
-      component: ctx.component,
-      phase: phaseDef.phase,
-      step: entry.kind,
+    emit?.({
+      type: "step-settle",
+      ...at,
       status: record.status === "ok" ? "ok" : "failed",
+      durationMs: record.durationMs,
       ...(record.error !== undefined ? { error: record.error } : {}),
     });
     if (record.status === "ok") {
@@ -586,13 +681,12 @@ async function runPhase(
     };
   };
 
-  const skippedRecord = (entry: DriverStep | DriverPhase): DriverStepRecord => ({
-    component: ctx.component,
-    phase: phaseDef.phase,
-    kind: isPhaseStep(entry) ? entry.phase : (entry as DriverStep).kind,
-    status: "skipped",
-    durationMs: 0,
-  });
+  /** A step a failure or a gate stopped before it started: recorded, and settled `skipped` with `skip: "not-run"`. */
+  const skippedRecord = (entry: DriverStep | DriverPhase): DriverStepRecord => {
+    const kind = isPhaseStep(entry) ? entry.phase : (entry as DriverStep).kind;
+    emit?.({ type: "step-settle", ...stepAt(entry, kind), status: "skipped", skip: "not-run", durationMs: null });
+    return { component: ctx.component, phase: phaseDef.phase, kind, status: "skipped", durationMs: 0 };
+  };
 
   const runEntries = async (): Promise<{ records: DriverStepRecord[]; executed: ExecutedStep[] }> => {
     const gateRecords = await decideGates();
@@ -626,16 +720,16 @@ async function runPhase(
     return { records, executed };
   };
 
-  onProgress?.({ type: "phase-start", component: ctx.component, phase: phaseDef.phase });
+  emit?.({ type: "phase-start", component: ctx.component, phase: phaseDef.phase });
   try {
     const result = await runEntries();
-    onProgress?.({ type: "phase-done", component: ctx.component, phase: phaseDef.phase, status: "ok" });
+    emit?.({ type: "phase-settle", component: ctx.component, phase: phaseDef.phase, status: "ok" });
     return result;
   } catch (err) {
     if (err instanceof GateStop) {
-      onProgress?.({ type: "phase-done", component: ctx.component, phase: phaseDef.phase, status: "gated" });
+      emit?.({ type: "phase-settle", component: ctx.component, phase: phaseDef.phase, status: "gated" });
     } else if (err instanceof StepFailure) {
-      onProgress?.({ type: "phase-done", component: ctx.component, phase: phaseDef.phase, status: "failed" });
+      emit?.({ type: "phase-settle", component: ctx.component, phase: phaseDef.phase, status: "failed" });
     }
     throw err;
   }
@@ -710,14 +804,14 @@ async function rollbackExecuted(
  * any) are recorded into `componentOutputs` under its own name so downstream
  * components can reference `@<name>.publish.*`.
  *
- * `onProgress`, when supplied, is forwarded to every `runPhase` call (both the
- * forward `deploy` phases and, on failure, the component's own authored
- * `rollback` phases) so a `--progress-json` consumer sees `phase-start`/
- * `step`/`phase-done` events for whichever phases actually ran. The saga
- * unwind step-by-step compensation (`rollbackExecuted` below) is not part of
- * the `RunProgressEvent` contract and stays silent — it isn't a `deploy`
- * phase, and its record statuses (`rolled-back`/`rollback-opted-out`) don't
- * map onto the `step` event's `running`/`ok`/`failed` shape.
+ * `onProgress` (the older `RunProgressEvent` stream) and `onRunEvent` (run
+ * events, #4041), when supplied, are forwarded to every `runPhase` call (both
+ * the forward `deploy` phases and, on failure, the component's own authored
+ * `rollback` phases), so a consumer sees the phase and step events of
+ * whichever phases actually ran. The saga unwind step-by-step compensation
+ * (`rollbackExecuted` below) stays silent: it isn't a `deploy` phase, and
+ * its record statuses (`rolled-back`/`rollback-opted-out`) are not step
+ * statuses either stream has.
  */
 export async function runComponentDeploy(
   component: DriverComponent,
@@ -726,7 +820,9 @@ export async function runComponentDeploy(
   componentOutputs: Record<string, Record<string, unknown>>,
   onProgress?: (event: RunProgressEvent) => void,
   gateContext: GateContext = { port: gitGateLedgerPort() },
+  onRunEvent?: RunEventSink,
 ): Promise<DriverComponentResult> {
+  const emit = joinRunEventSinks(onRunEvent, progressSinkOf(onProgress));
   // Each component tracks its own release: a digest one component promoted never stamps another's deploy.
   if (ctx.release) ctx = { ...ctx, release: { ...ctx.release } };
   const phaseOutputs: Record<string, Record<string, unknown>> = {};
@@ -738,19 +834,22 @@ export async function runComponentDeploy(
   if (ctx.release && release !== undefined && ctx.release.version === undefined) ctx.release.version = release;
   const gates: GateContext = {
     ...gateContext,
-    planDigest: componentPlanDigest({
-      environment: ctx.env,
-      component,
-      ...(ctx.vars ? { vars: ctx.vars } : {}),
-      ...(release !== undefined ? { release } : {}),
-    }),
+    // #4045: a release gate binds the release's change set, not this composition.
+    planDigest:
+      gateContext.releaseGate?.planDigest ??
+      componentPlanDigest({
+        environment: ctx.env,
+        component,
+        ...(ctx.vars ? { vars: ctx.vars } : {}),
+        ...(release !== undefined ? { release } : {}),
+      }),
   };
   const records: DriverStepRecord[] = [];
   const allExecuted: ExecutedStep[] = [];
 
   try {
     for (const phaseDef of component.deploy) {
-      const result = await runPhase(phaseDef, ctx, registry, phaseOutputs, componentOutputs, gates, onProgress);
+      const result = await runPhase(phaseDef, ctx, registry, phaseOutputs, componentOutputs, gates, emit);
       records.push(...result.records);
       allExecuted.push(...result.executed);
     }
@@ -784,7 +883,7 @@ export async function runComponentDeploy(
 
     for (const phaseDef of [...(component.rollback ?? [])].reverse()) {
       try {
-        const result = await runPhase(phaseDef, ctx, registry, phaseOutputs, componentOutputs, gates, onProgress);
+        const result = await runPhase(phaseDef, ctx, registry, phaseOutputs, componentOutputs, gates, emit);
         records.push(...result.records);
       } catch (compErr) {
         if (compErr instanceof StepFailure || compErr instanceof GateStop) records.push(...compErr.records);
@@ -919,12 +1018,20 @@ export interface InterpretRunOptions {
    * byte-for-byte the same as before this option existed.
    */
   onProgress?: (event: RunProgressEvent) => void;
+  /**
+   * Where the run's events go (#4041, `chant run --components --events-json`):
+   * the run-event bodies the stream in ../run-event-stream.ts stamps. Like
+   * `onProgress`, never consulted for control flow.
+   */
+  onRunEvent?: RunEventSink;
   /** Where a `gate` step's facts are read and written (#2119). Defaults to the `chant/lifecycle` orphan branch; a test passes `memoryGateLedgerPort()` from `../op/gate.ts`. */
   gates?: GateLedgerPort;
   /** ISO-8601 "now" for gate decisions, so a test is deterministic. */
   now?: string;
   /** The recorded digest a promote or rollback deploys, per component (#2574). Part of the plan a gate approval is bound to. */
   releases?: ReadonlyMap<string, string>;
+  /** A promote under a release (#4045): what every gate the run reaches binds. See {@link GateContext.releaseGate}. */
+  releaseGate?: ReleaseGateBinding;
   /**
    * The release each component deploys (#3061, ws-081), threaded into its
    * `DeployContext.release`. The driver fills in `version` when a publish
@@ -969,14 +1076,15 @@ export async function runInterpretDriver(
   const { order, waves } = resolveComponentGraph(components);
   const byName = new Map(components.map((c) => [c.name, c]));
   const componentOutputs: Record<string, Record<string, unknown>> = { ...(options.componentOutputs ?? {}) };
-  const { onProgress } = options;
+  const emit = joinRunEventSinks(options.onRunEvent, progressSinkOf(options.onProgress));
   const gates: GateContext = {
     port: options.gates ?? gitGateLedgerPort(),
     ...(options.now ? { now: options.now } : {}),
     ...(options.releases ? { releases: options.releases } : {}),
+    ...(options.releaseGate ? { releaseGate: options.releaseGate } : {}),
   };
 
-  onProgress?.({ type: "run-start", waves });
+  emit?.({ type: "run-start", waves });
 
   const results: DriverComponentResult[] = [];
   let failedComponent: string | undefined;
@@ -984,26 +1092,27 @@ export async function runInterpretDriver(
 
   waveLoop: for (const [waveIndex, wave] of waves.entries()) {
     const waveNum = waveIndex + 1;
-    onProgress?.({ type: "wave-start", wave: waveNum, components: wave });
+    emit?.({ type: "wave-start", wave: waveNum, components: wave });
     const waveComponents = wave.map((name) => byName.get(name)!);
     const waveResults = await Promise.all(
       waveComponents.map(async (component) => {
-        onProgress?.({ type: "component-start", wave: waveNum, component: component.name });
+        emit?.({ type: "component-start", wave: waveNum, component: component.name });
         const result = await runComponentDeploy(
           component,
           deployContext(options, component.name),
           registry,
           componentOutputs,
-          onProgress,
+          undefined,
           gates,
+          emit,
         );
-        onProgress?.({ type: "component-done", wave: waveNum, component: component.name, status: progressStatus(result.status) });
+        emit?.({ type: "component-settle", wave: waveNum, component: component.name, status: progressStatus(result.status) });
         return result;
       }),
     );
     results.push(...waveResults);
     const stopped = waveResults.find((r) => r.status !== "ok");
-    onProgress?.({ type: "wave-done", wave: waveNum, status: progressStatus(stopped?.status ?? "ok") });
+    emit?.({ type: "wave-settle", wave: waveNum, status: progressStatus(stopped?.status ?? "ok") });
     if (stopped) {
       // A failure in the same wave outranks a gate: something is actually
       // broken, and reporting the run as "waiting on a human" would hide it.
@@ -1016,7 +1125,7 @@ export async function runInterpretDriver(
 
   const status: DriverRunResult["status"] = failedComponent ? "fail" : gated ? "gated" : "ok";
   const ok = status === "ok";
-  onProgress?.({ type: "run-done", status: progressStatus(status) });
+  emit?.({ type: "run-settle", status: progressStatus(status), durationMs: null });
   const result: DriverRunResult = {
     order, waves, results, ok, status, failedComponent, componentOutputs,
     ...(gated

package/src/components/fan-out-inputs.test.ts

@@ -0,0 +1,85 @@
+/**
+ * What each component would apply, as a digest (#4081), and which of an
+ * earlier attempt's progress holds against it.
+ */
+
+import { describe, expect, test } from "vitest";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { componentInputDigests, progressThatCarries } from "./fan-out-inputs";
+import type { DriverComponent } from "./driver";
+
+function project(): string {
+  const root = mkdtempSync(join(tmpdir(), "fan-out-inputs-"));
+  mkdirSync(join(root, "dist"));
+  for (const name of ["net", "cluster", "app"]) writeFileSync(join(root, "dist", `${name}.json`), `{"name":"${name}"}`);
+  return root;
+}
+
+const component = (name: string, dependsOn: string[] = [], extra: Record<string, unknown> = {}): DriverComponent => ({
+  name,
+  dependsOn,
+  deploy: [{ phase: "Apply", steps: [{ kind: "cfn-deploy", stack: name, template: `dist/${name}.json`, ...extra }] }],
+});
+
+const estate = [component("net"), component("cluster", ["net"]), component("app", ["cluster"])];
+
+describe("componentInputDigests", () => {
+  test("is stable for the same project, environment and files", () => {
+    const root = project();
+    expect(componentInputDigests(estate, { projectRoot: root, env: "prod" })).toEqual(
+      componentInputDigests(estate, { projectRoot: root, env: "prod" }),
+    );
+  });
+
+  test("covers the bytes of a file a step input names, and everything downstream of it", () => {
+    const root = project();
+    const before = componentInputDigests(estate, { projectRoot: root, env: "prod" });
+    writeFileSync(join(root, "dist", "cluster.json"), `{"name":"cluster","queue":true}`);
+    const after = componentInputDigests(estate, { projectRoot: root, env: "prod" });
+    expect(after.net).toBe(before.net);
+    expect(after.cluster).not.toBe(before.cluster);
+    expect(after.app).not.toBe(before.app);
+  });
+
+  test("covers a directory a step names, by its files", () => {
+    const root = project();
+    const chart = [component("chart", [], { chart: "dist" })];
+    const before = componentInputDigests(chart, { projectRoot: root, env: "prod" });
+    writeFileSync(join(root, "dist", "app.json"), "{}");
+    expect(componentInputDigests(chart, { projectRoot: root, env: "prod" }).chart).not.toBe(before.chart);
+  });
+
+  test("covers the environment and the authored steps", () => {
+    const root = project();
+    const prod = componentInputDigests(estate, { projectRoot: root, env: "prod" });
+    expect(componentInputDigests(estate, { projectRoot: root, env: "staging" }).net).not.toBe(prod.net);
+    const moved = [component("net", [], { inputs: { size: 2 } }), ...estate.slice(1)];
+    expect(componentInputDigests(moved, { projectRoot: root, env: "prod" }).net).not.toBe(prod.net);
+  });
+
+  test("ignores a string that is not a file, a path outside the project, and the phase name", () => {
+    const root = project();
+    mkdirSync(join(root, "Apply"));
+    const before = componentInputDigests(estate, { projectRoot: root, env: "prod" });
+    writeFileSync(join(root, "Apply", "x"), "changes nothing");
+    expect(componentInputDigests(estate, { projectRoot: root, env: "prod" })).toEqual(before);
+    const outside = [component("net", [], { other: "../elsewhere.json" })];
+    expect(() => componentInputDigests(outside, { projectRoot: root, env: "prod" })).not.toThrow();
+  });
+});
+
+describe("progressThatCarries", () => {
+  test("carries a component only when its recorded input is the one it has now", () => {
+    const split = progressThatCarries(
+      { completed: ["net", "cluster", "app"], inputs: { net: "a", cluster: "b" } },
+      { net: "a", cluster: "B", app: "c" },
+    );
+    expect(split).toEqual({ carried: ["net"], changed: ["app", "cluster"], unrecorded: false });
+  });
+
+  test("a record with no input digests carries nothing", () => {
+    expect(progressThatCarries({ completed: ["net"] }, { net: "a" })).toEqual({ carried: [], changed: ["net"], unrecorded: true });
+  });
+});