@intentius/chant 0.124.52 → 0.124.54

package/dist/components/pr-run.js

@@ -67,6 +67,14 @@
  * 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.
+ *
+ * ## Groups
+ *
+ * A fan-out with `groups` (ws-107, `./groups.ts`) plans each group with one
+ * `planGroup` call at its wave and applies it with one `runGroup` call
+ * there. A member's read of another member of its group is computed by that
+ * apply: it is no `unknownInputs` entry and holds nothing back. Each member's
+ * digest binds the group's, so the one approval binds the composition.
  */
 import { composeChangeSet, verifyChangeSetDigest } from "../change-set.js";
 import { evaluateGate } from "../op/gate.js";
@@ -76,6 +84,7 @@ import { deployUnits } from "./deploy-units.js";
 import { runFanOut } from "./fan-out-run.js";
 import { remainingFanOut } from "./fan-out.js";
 import { coveredRound } from "./covered-round.js";
+import { groupsByComponent, narrowGroups, planComponentGroup, regroupRemaining } from "./groups.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";
@@ -113,13 +122,18 @@ export async function planPrSet(options) {
     let failed = false;
     const emit = options.onRunEvent;
     emit?.({ type: "phase-start", component: null, phase: PR_PLAN_PHASE });
+    // ws-107: each group plans once, in its wave, with one call.
+    const groupOf = groupsByComponent(options.plan);
+    const groups = [];
     for (const wave of options.plan.waves) {
         // 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));
+        // if it needs them. A member of the dependent's own group plans with it.
+        const deps = [
+            ...new Set(wave.flatMap((name) => (byName.get(name)?.dependsOn ?? []).filter((dep) => !groupOf.get(name)?.components.includes(dep)))),
+        ].filter((dep) => !read.has(dep));
         const fromEstate = [];
         for (const dep of deps) {
             read.add(dep);
@@ -134,26 +148,60 @@ export async function planPrSet(options) {
             planned[dep] = Object.keys(known).sort();
         }
         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();
-            const p = await planWaveComponent(byName.get(name), options.registry, deployContext(options, name), outputs);
+        const settle = (name, start, p) => {
             emit?.({
                 type: "step-settle",
-                ...at,
+                component: name,
+                phase: PR_PLAN_PHASE,
+                step: "plan",
                 status: "error" in p ? "failed" : "ok",
                 durationMs: Date.now() - start,
                 ...("error" in p ? { error: p.error } : {}),
             });
-            return p;
-        }));
+        };
+        const groupsHere = [...new Set(wave.map((name) => groupOf.get(name)).filter((g) => g !== undefined))];
+        const results = (await Promise.all([
+            ...wave
+                .filter((name) => !groupOf.has(name))
+                .map(async (name) => {
+                emit?.({ type: "step-start", component: name, phase: PR_PLAN_PHASE, step: "plan" });
+                const start = Date.now();
+                const p = await planWaveComponent(byName.get(name), options.registry, deployContext(options, name), outputs);
+                settle(name, start, p);
+                return [p];
+            }),
+            ...groupsHere.map(async (group) => {
+                for (const name of group.components)
+                    emit?.({ type: "step-start", component: name, phase: PR_PLAN_PHASE, step: "plan" });
+                const start = Date.now();
+                const g = await planComponentGroup({
+                    group,
+                    components: byName,
+                    registry: options.registry,
+                    env: options.env,
+                    ...(options.vars ? { vars: options.vars } : {}),
+                    ctxOf: (name) => deployContext(options, name),
+                    outputs,
+                });
+                for (const p of g.plans)
+                    settle(p.component, start, p);
+                const error = g.plans.find((p) => "error" in p)?.error;
+                groups.push({ ...group, digest: g.digest ?? null, ...(error !== undefined ? { error } : {}), ...(g.run ? { run: g.run } : {}) });
+                return g.plans;
+            }),
+        ])).flat();
+        /** What each member of a group planned to expose, for its group-mates' reads. */
+        const plannedHere = new Map(results.map((p) => [p.component, "error" in p ? undefined : p.outputs?.known]));
         for (const p of results) {
             const component = byName.get(p.component);
-            const unknown = unknownInputsOf(component, outputs, inChange);
+            const group = groupOf.get(p.component);
+            const mates = group ? new Set(group.components) : undefined;
+            const unknown = unknownInputsOf(component, outputs, inChange, mates);
             if (unknown.unknown.length > 0 || unknown.build.length > 0)
                 unknownOf.set(p.component, unknown);
-            const reads = readsOf(component, outputs);
+            // A read of a group-mate is known when that mate's plan knows it.
+            const readsView = group ? { ...outputs, ...Object.fromEntries(group.components.filter((c) => c !== p.component).map((c) => [c, { ...(plannedHere.get(c) ?? {}) }])) } : outputs;
+            const reads = readsOf(component, readsView);
             if (reads.length > 0)
                 readsBy.set(p.component, reads);
             if ("error" in p) {
@@ -195,12 +243,16 @@ export async function planPrSet(options) {
     const sorted = (r) => Object.fromEntries(Object.entries(r).sort(([a], [b]) => a.localeCompare(b)));
     const deployedOutputs = sorted(deployed);
     const plannedOutputs = sorted(planned);
+    const at = new Map(options.plan.order.map((name, i) => [name, i]));
+    groups.sort((a, b) => (at.get(a.components[0]) ?? 0) - (at.get(b.components[0]) ?? 0));
     return {
         doc,
         members,
         plans,
         outputs,
         failed,
+        ...(groups.length > 0 ? { groups } : {}),
+        ...(options.plan.fallbacks?.length ? { fallbacks: options.plan.fallbacks } : {}),
         ...(Object.keys(shapes).length > 0 ? { shapes } : {}),
         ...(Object.keys(deployedOutputs).length > 0 ? { deployedOutputs } : {}),
         ...(Object.keys(plannedOutputs).length > 0 ? { plannedOutputs } : {}),
@@ -212,14 +264,17 @@ export async function planPrSet(options) {
  * 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.
+ * `unknown` are the rest. A reference to a member of `group`, the
+ * component's own group (ws-107), is neither: the group's apply computes it.
  */
-function unknownInputsOf(component, outputs, inChange) {
+function unknownInputsOf(component, outputs, inChange, group) {
     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 (group?.has(r.source))
+                continue;
             if (inChange.has(r.source))
                 (r.publish ? build : unknown).add(r.ref);
         }
@@ -257,14 +312,16 @@ function readsOf(component, outputs) {
  * 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.
+ * member back: the build's provenance binds it, not this approval. Nor
+ * does a reference to a member of `group`, the component's own group
+ * (ws-107), whose apply computes it.
  */
-export function heldReason(component, read, now, inChange = new Set()) {
+export function heldReason(component, read, now, inChange = new Set(), group = 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)))
+            if (!(r.publish && inChange.has(r.source)) && !group.has(r.source))
                 refs.add(r.ref);
     }
     if (refs.size === 0)
@@ -335,6 +392,10 @@ export function approversWhoAuthored(approvedBy, authors) {
 function roundCover(options, fresh, plan, now, inChange, byName) {
     if (options.approval?.status !== "approved")
         return { covered: false, reason: "no approval of the first plan stands" };
+    // ws-107: a round's group is covered only when it has the approved group's members.
+    const moved = groupsMoved(options.set.groups ?? [], fresh.groups ?? [], plan.order);
+    if (moved)
+        return { covered: false, reason: moved };
     // The values the round reads of a component it plans again are the ones
     // that plan says it will expose: it has not applied yet, so the outputs
     // standing say nothing of it. An output the first plan knew and the round's
@@ -358,15 +419,45 @@ function roundCover(options, fresh, plan, now, inChange, byName) {
         }
         changedKnown[name] = [...refs].sort();
     }
+    // A member whose round plan still reads only outputs of components this
+    // round plans and has not applied (a chain of imports, #4466d) cannot apply
+    // in this round: it is held again once those apply, and its own round
+    // checks its coverage. Only the members this round can apply are checked.
+    const inRound = plan.order;
+    const fromRound = (ref) => inRound.some((c) => ref === c || ref.startsWith(`${c}.`));
+    const waits = (m) => (m.unknownInputs?.length ?? 0) > 0 && m.unknownInputs.every(fromRound);
     const approved = { doc: options.set.doc, members: options.set.members, ...(options.set.shapes ? { shapes: options.set.shapes } : {}) };
     return coveredRound({
         approved,
         approvedDigest: options.set.doc.digest,
-        fresh: { doc: fresh.doc, members: fresh.members, ...(fresh.shapes ? { shapes: fresh.shapes } : {}) },
+        fresh: { doc: fresh.doc, members: fresh.members.filter((m) => !waits(m)), ...(fresh.shapes ? { shapes: fresh.shapes } : {}) },
         changedKnown,
         attributes: (member) => memberAttributes(options.set.doc, fresh.doc, member, fresh.shapes?.[member] !== undefined),
     });
 }
+/**
+ * Why the groups `fresh` planned are not the `approved` ones over the
+ * components in `order` (ws-107), or `undefined` when each group the round
+ * plans has the members the approved group had.
+ */
+function groupsMoved(approved, fresh, order) {
+    const same = (a, b) => a.length === b.length && a.every((c) => b.includes(c));
+    const inRound = new Set(order);
+    for (const was of approved) {
+        const here = was.components.filter((c) => inRound.has(c));
+        if (here.length === 0)
+            continue;
+        const now = fresh.find((g) => g.components.includes(here[0]));
+        if (!now || !same(now.components, was.components)) {
+            return `the approved plan grouped ${was.components.join(", ")}, and the round ${now ? `groups ${now.components.join(", ")}` : `plans ${here.join(", ")} without that group`}`;
+        }
+    }
+    for (const now of fresh) {
+        if (!approved.some((was) => same(was.components, now.components)))
+            return `the round groups ${now.components.join(", ")}, which the approved plan did not`;
+    }
+    return undefined;
+}
 /**
  * The part of coverage that reads the change set's own attributes, shared by
  * a round, a resume and a wave: a member whose planner describes no changes
@@ -397,6 +488,8 @@ function joinRuns(a, b) {
         componentOutputs: b.componentOutputs,
         ...(gate ? { gate } : {}),
         ...(b.held ? { held: b.held } : {}),
+        ...(a.notStarted || b.notStarted ? { notStarted: [...new Set([...(a.notStarted ?? []), ...(b.notStarted ?? [])])].sort() } : {}),
+        ...(a.groupOutcomes || b.groupOutcomes ? { groupOutcomes: { ...(a.groupOutcomes ?? {}), ...(b.groupOutcomes ?? {}) } } : {}),
     };
 }
 /**
@@ -419,18 +512,24 @@ export async function applyPrSet(options) {
         ...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.targets ? { targets: options.targets } : {}),
-        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 runRound = (plan, set, read, outputs) => {
+        // ws-107: each group runs the plan its group planned, and a read of a group-mate holds nothing back.
+        const groupOf = groupsByComponent(plan);
+        const groupRuns = Object.fromEntries((set.groups ?? []).filter((g) => g.run).map((g) => [g.components[0], g.run]));
+        return runFanOut(plan, options.components, options.registry, {
+            env: options.env,
+            ...(options.vars ? { vars: options.vars } : {}),
+            plans: set.plans,
+            ...(Object.keys(groupRuns).length > 0 ? { groupRuns } : {}),
+            ...(options.targets ? { targets: options.targets } : {}),
+            componentOutputs: outputs,
+            hold: (name, now) => heldReason(byName.get(name), read, now, inChange, new Set(groupOf.get(name)?.components ?? [])),
+            ...(options.onProgress ? { onProgress: options.onProgress } : {}),
+            ...(options.onRunEvent ? { onRunEvent: options.onRunEvent } : {}),
+            ...(options.onComponentSettled ? { onComponentSettled: options.onComponentSettled } : {}),
+        });
+    };
+    let run = await runRound(options.plan, options.set, 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();
@@ -439,7 +538,8 @@ export async function applyPrSet(options) {
         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)) });
+        // A held group is planned again as the same group (ws-107).
+        const plan = narrowGroups(remainingFanOut(options.plan, options.components, { completed: options.plan.order.filter((name) => !heldNames.has(name)) }), options.components, options.plan.groups);
         const set = await planPrSet({
             components: options.components,
             plan,
@@ -479,27 +579,35 @@ export async function applyPrSet(options) {
             stopped = "waiting";
             break;
         }
-        const next = await runRound(plan, set.plans, set.outputs, run.componentOutputs);
+        const next = await runRound(plan, set, set.outputs, run.componentOutputs);
         record(next.status === "fail" ? "failed" : "applied", decision.approval, undefined, decision.covered);
         run = joinRuns(run, next);
     }
     const completed = new Set(run.completed);
+    const notStarted = new Set(run.notStarted ?? []);
     const held = new Map((run.held ?? []).map((h) => [h.component, h]));
     const blocked = new Map(run.blocked.map((b) => [b.component, b.blockedBy]));
     const errorOf = (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;
+        return result?.records.find((r) => r.status === "fail" || (notStarted.has(component) && r.status === "skipped"))?.error;
     };
     const members = options.set.members.map((m) => {
         if (priorCompleted.has(m.component))
             return { ...m, status: "applied" };
         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;
+        const planned = later && fresh ? { ...m, planDigest: fresh.planDigest, counts: fresh.counts, round: later.round } : m;
+        // #4446: how its part of a group's apply ended, as the capability said.
+        const groupOutcome = run.groupOutcomes?.[m.component];
+        const asPlanned = groupOutcome ? { ...planned, groupOutcome } : planned;
         if (completed.has(m.component))
             return { ...asPlanned, status: "applied" };
+        if (notStarted.has(m.component)) {
+            const error = errorOf(m.component);
+            return { ...asPlanned, status: "not-started", ...(error ? { error } : {}) };
+        }
         const h = held.get(m.component);
         if (h)
             return { ...asPlanned, status: "waiting", held: h.heldBy ? `${h.heldBy} is held: ${h.reason}` : h.reason };
@@ -614,20 +722,42 @@ export function planCoveredBy(approved, fresh, member) {
  * is `record.digest`, and the document gives that digest. The digest binds
  * the entries, holes and side effects {@link planCoveredBy} reads (#3555),
  * so a record cannot widen what a re-planned member may do.
+ *
+ * A group that failed part way (ws-107, "Resume"; #4446) leaves its
+ * `partial`, `failed` and `not-started` members; `applied` and `no-changes`
+ * ones are in `completed`. What is left of each approved group is grouped
+ * again ({@link regroupRemaining}), so it plans as a smaller group, or one
+ * by one when the rule or the capability says so. The smaller group's
+ * digest differs from the approved one, so coverage rests on entries and
+ * shapes, as for any resumed member.
  */
 export async function resumePrSet(options) {
     const { record } = options;
     if (record.changeSet.digest !== record.digest || !verifyChangeSetDigest(record.changeSet)) {
         return { ok: false, reasons: [`the record's change set is not the one its digest ${record.digest} names`] };
     }
-    const plan = remainingFanOut(options.plan, options.components, { completed: options.completed });
+    const plan = await regroupRemaining({
+        components: options.components,
+        plan: remainingFanOut(options.plan, options.components, { completed: options.completed }),
+        registry: options.registry,
+        env: options.env,
+        ...(options.vars ? { vars: options.vars } : {}),
+        groups: options.plan.groups,
+        ...(options.plan.fallbacks ? { fallbacks: options.plan.fallbacks } : {}),
+    });
+    // The outputs of the applied members of a group with members left: the values the group's apply computed.
+    const left = new Set(plan.order);
+    const fromGroup = Object.fromEntries((options.plan.groups ?? [])
+        .filter((g) => g.components.some((c) => left.has(c)))
+        .flatMap((g) => g.components.filter((c) => !left.has(c) && options.applied?.[c] !== undefined))
+        .map((c) => [c, options.applied[c]]));
     const fresh = await planPrSet({
         components: options.components,
         plan,
         registry: options.registry,
         env: options.env,
         ...(options.vars ? { vars: options.vars } : {}),
-        seededOutputs: { ...(options.seededOutputs ?? {}), ...options.record.planOutputs },
+        seededOutputs: { ...(options.seededOutputs ?? {}), ...options.record.planOutputs, ...fromGroup },
         ...(options.targets ? { targets: options.targets } : {}),
     });
     // #4422: decided as a round decides (`coveredRound`), by the same function a wave uses.
@@ -642,7 +772,9 @@ export async function resumePrSet(options) {
             doc: options.record.changeSet,
             members: options.record.members.map((m) => ({ ...m, status: "planned" })),
             plans: fresh.plans,
-            outputs: options.record.planOutputs,
+            outputs: { ...options.record.planOutputs, ...fromGroup },
+            ...(fresh.groups ? { groups: fresh.groups } : {}),
+            ...(fresh.fallbacks ? { fallbacks: fresh.fallbacks } : {}),
             failed: false,
         },
     };
@@ -661,7 +793,17 @@ export function prWavePlan(plan, components, wave, completed = []) {
     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 };
+    // ws-107: a group sits in one wave, so what is left of it plans and applies as one there.
+    const groups = (plan.groups ?? []).map((g) => ({ ...g, components: g.components.filter((c) => inWave.has(c)) })).filter((g) => g.components.length > 1);
+    return {
+        order,
+        waves: order.length > 0 ? [order] : [],
+        skipped: [],
+        seeds,
+        indeterminate: plan.indeterminate,
+        digest: plan.digest,
+        ...(groups.length > 0 ? { groups } : {}),
+    };
 }
 /**
  * Why the approved change set does not cover a wave's new plan, one line per
@@ -713,9 +855,35 @@ export function waveNotCovered(approved, fresh, approvedMembers = [], shapes = {
     })
         .filter((r) => r !== undefined);
 }
+/**
+ * The report's `groups` (#4446): each group the set planned, with the wave
+ * of `waves` its members sit in and the reads of group-mates its members'
+ * change-set parts name, which the group's apply computes.
+ */
+function reportGroups(set, waves) {
+    const componentOf = new Map(set.members.map((m) => [m.member, m.component]));
+    return (set.groups ?? []).map((g) => {
+        const wave = waves.findIndex((w) => g.components.some((c) => w.includes(c))) + 1;
+        const reads = set.doc.members
+            .filter((m) => g.components.includes(componentOf.get(m.member) ?? m.member))
+            .flatMap((m) => (m.group?.reads ?? []).map((ref) => ({ component: componentOf.get(m.member) ?? m.member, ref })))
+            .sort((a, b) => a.component.localeCompare(b.component) || a.ref.localeCompare(b.ref));
+        return {
+            capability: g.capability,
+            components: [...g.components],
+            wave: wave > 0 ? wave : 1,
+            digest: g.digest,
+            ...(g.error !== undefined ? { error: g.error } : {}),
+            ...(reads.length > 0 ? { reads } : {}),
+        };
+    });
+}
 /** The report a stage writes. */
 export function prReport(input) {
     const changed = new Set(input.signal.changed);
+    const groups = reportGroups(input.set, input.plan.waves);
+    const groupOf = new Map(groups.flatMap((g, i) => g.components.map((c) => [c, i])));
+    const members = (input.members ?? input.set.members).map((m) => (groupOf.has(m.component) ? { ...m, group: groupOf.get(m.component) } : m));
     return {
         $schema: PR_REPORT_SCHEMA_ID,
         contract: PR_REPORT_CONTRACT,
@@ -746,7 +914,9 @@ export function prReport(input) {
             indeterminate: input.plan.indeterminate,
             waves: input.plan.waves,
         },
-        members: input.members ?? input.set.members,
+        ...(groups.length > 0 ? { groups } : {}),
+        ...(input.set.fallbacks?.length ? { fallbacks: input.set.fallbacks.map((f) => ({ ...f })) } : {}),
+        members,
         changeSet: input.set.doc,
     };
 }

package/dist/components/promote-rounds.d.ts

@@ -22,6 +22,12 @@
  * A stage whose components declare no gate has nowhere to wait, so the
  * promote stops there with nothing more deployed.
  *
+ * - **Groups** (ws-107, #4465). With `grouped`, the waves are the grouped
+ *   fan-out's, so each group sits in one wave and is checked, planned again
+ *   and run as one: when any member's input moved, every member left of the
+ *   group is planned again with it. Under `--wave-gate` no group forms
+ *   (`formRunGroups`), so there is none here.
+ *
  * A promote that stops at a round's or a wave's gate writes a resume record
  * ({@link PromoteResume}): the components that applied and the outputs they
  * left. The same promote run again with it skips what applied and carries on
@@ -31,6 +37,7 @@
 import { type DriverComponent, type DriverRunResult, type ReleaseGateBinding } from "./driver.js";
 import type { ChangeSetDocument } from "../change-set.js";
 import type { ReleasePlan } from "./release-gate.js";
+import type { FanOutPlan } from "./fan-out.js";
 export declare const PROMOTE_RESUME_SCHEMA = "chant-promote-resume/v1";
 /** What a promote that stopped at a round's or a wave's gate leaves for the next attempt. */
 export interface PromoteResume {
@@ -80,6 +87,8 @@ export interface PromoteRoundsOptions {
     replan: (only: ReadonlySet<string>, outputs: Record<string, Record<string, unknown>>) => Promise<ChangeSetDocument>;
     /** Store a stage's plan and bind its gates (empty resolutions included). */
     bind: (doc: ChangeSetDocument, gates: string[]) => Promise<ReleaseGateBinding>;
+    /** The grouped fan-out (#4465): its waves replace the ones `dependsOn` gives, and each group is checked as one. */
+    grouped?: FanOutPlan;
 }
 export interface PromoteRoundsResult {
     run: DriverRunResult;

package/dist/components/promote-rounds.d.ts.map

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

package/dist/components/promote-rounds.js

@@ -22,6 +22,12 @@
  * A stage whose components declare no gate has nowhere to wait, so the
  * promote stops there with nothing more deployed.
  *
+ * - **Groups** (ws-107, #4465). With `grouped`, the waves are the grouped
+ *   fan-out's, so each group sits in one wave and is checked, planned again
+ *   and run as one: when any member's input moved, every member left of the
+ *   group is planned again with it. Under `--wave-gate` no group forms
+ *   (`formRunGroups`), so there is none here.
+ *
  * A promote that stops at a round's or a wave's gate writes a resume record
  * ({@link PromoteResume}): the components that applied and the outputs they
  * left. The same promote run again with it skips what applied and carries on
@@ -34,6 +40,7 @@ import { waveNotCovered } from "./pr-run.js";
 import { prRoundGate } from "../pr-loop.js";
 import { waveGateName } from "../gated-waves.js";
 import { capabilitySteps } from "./wave-plan.js";
+import { groupsByComponent } from "./groups.js";
 export const PROMOTE_RESUME_SCHEMA = "chant-promote-resume/v1";
 function isGate(step) {
     return step.kind === "gate";
@@ -107,7 +114,18 @@ function joinRuns(runs, outputs) {
  */
 export async function runPromotionInRounds(options) {
     const byName = new Map(options.components.map((c) => [c.name, c]));
-    const { waves } = resolveComponentGraph(options.components.map((c) => ({ ...c, dependsOn: (c.dependsOn ?? []).filter((d) => byName.has(d)) })));
+    const grouped = options.grouped?.groups?.length ? options.grouped : undefined;
+    const placed = new Set(grouped?.order ?? []);
+    // A grouped fan-out over what a resume left holds no wave for what applied earlier; that is skipped anyway.
+    const waves = grouped
+        ? grouped.waves.map((w) => w.filter((name) => byName.has(name)))
+        : resolveComponentGraph(options.components.map((c) => ({ ...c, dependsOn: (c.dependsOn ?? []).filter((d) => byName.has(d)) }))).waves;
+    if (grouped) {
+        const missing = options.components.filter((c) => !placed.has(c.name) && !(options.completed ?? []).includes(c.name)).map((c) => c.name);
+        if (missing.length > 0)
+            throw new Error(`the grouped waves leave out ${missing.join(", ")}, which this promote runs`);
+    }
+    const groupOf = grouped ? groupsByComponent(grouped) : new Map();
     const completed = [...(options.completed ?? [])];
     const done = new Set(completed);
     let outputs = { ...options.outputs };
@@ -119,9 +137,12 @@ export async function runPromotionInRounds(options) {
         const pending = wave.filter((name) => !done.has(name));
         if (pending.length === 0)
             continue;
-        const check = options.waveGate !== undefined && waveNumber > 1
+        const moved = options.waveGate !== undefined && waveNumber > 1
             ? pending
             : pending.filter((name) => movedInputs(byName.get(name), options.reads[name], outputs).length > 0);
+        // A group is planned again as one: a member whose input moved takes the rest of its group with it.
+        const withMates = new Set(moved.flatMap((name) => [name, ...(groupOf.get(name)?.components ?? [])]));
+        const check = pending.filter((name) => withMates.has(name));
         const batches = [];
         const rest = pending.filter((name) => !check.includes(name));
         if (check.length > 0) {

package/dist/components/promote.d.ts

@@ -41,6 +41,8 @@ import { type ReleaseRecord, type ReleaseRecordInput, type ReleaseAdmission, typ
 import { CapabilityRegistry, type Capability } from "./capability.js";
 import { type DriverComponent, type DriverComponentResult, type ReleaseGateBinding, type DriverRunResult } from "./driver.js";
 import type { GateLedgerPort } from "../op/gate.js";
+import type { GroupRun } from "./capability.js";
+import type { FanOutPlan } from "./fan-out.js";
 import type { Release } from "../lifecycle/release-store.js";
 import type { RunProgressEvent } from "./run-progress.js";
 import type { RunEventSink } from "../run-event-stream.js";
@@ -253,6 +255,21 @@ export interface RunPromotionOptions {
     onProgress?: (event: RunProgressEvent) => void;
     /** Where the run's events go (#4041, `--events-json`). */
     onRunEvent?: RunEventSink;
+    /**
+     * The grouped fan-out (ws-107, #4465, `formRunGroups`): each of its groups
+     * applies as one, in the wave it places it in. Absent, or without
+     * `groups`: every component runs its own deploy, as before.
+     */
+    grouped?: FanOutPlan;
+    /**
+     * The approved plan of each group, as the release gate's plan made it
+     * (`ReleasePlan.groups`). A group runs the one whose members are its own;
+     * the newest first. A group with none plans in its wave and applies only
+     * under `planGroupsAtWave`, and fails otherwise.
+     */
+    groupRuns?: readonly GroupRun[];
+    /** A promote with no release gate to bind plans each group in its wave (#4465). */
+    planGroupsAtWave?: boolean;
 }
 /**
  * Deploy the plan's components to `plan.to`, in dependency order. A

package/dist/components/promote.d.ts.map

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