@intentius/chant 0.124.52 → 0.124.54

package/dist/components/fan-out-run.js

@@ -41,6 +41,7 @@ import { deployContext, runComponentDeploy, } from "./driver.js";
 import { downstreamWithin, remainingFanOut } from "./fan-out.js";
 import { evaluateGate, gitGateLedgerPort } from "../op/gate.js";
 import { emitGateStep, joinRunEventSinks, progressSinkOf } from "../run-event-stream.js";
+import { groupsByComponent, narrowGroups, planAndRunComponentGroup, runComponentGroup } from "./groups.js";
 import { planWaveComponent } from "./wave-plan.js";
 import { computePlanDigest } from "../lifecycle/plan-digest.js";
 import { decideWaveGate, runWaveLoop, waveGateName, waveSetDigest } from "../wave-engine.js";
@@ -130,13 +131,17 @@ export async function runFanOut(plan, components, registry, options) {
     const componentOutputs = { ...(options.componentOutputs ?? {}) };
     // Resume first, so the gate is decided against the work that is actually left
     // and a re-run does not re-approve. The digest is carried, not recomputed.
-    const active = options.progress ? remainingFanOut(plan, components, options.progress) : plan;
+    // A group keeps what is left of it (#4465).
+    const active = options.progress ? narrowGroups(remainingFanOut(plan, components, options.progress), components, plan.groups) : plan;
     if (options.gate && options.waveGate) {
         throw new Error("a fan-out takes one gate over the set or one gate per wave, not both");
     }
     if (options.waveGate && options.plans) {
         throw new Error("a gated-wave fan-out plans each wave itself, so it takes no plans made beforehand");
     }
+    if (options.waveGate && plan.groups?.length) {
+        throw new Error("a gated-wave fan-out plans component by component, so it takes no groups");
+    }
     if (options.waveGate) {
         return runGatedWaves(plan, active, components, registry, options, options.waveGate, gates, componentOutputs);
     }
@@ -173,44 +178,85 @@ export async function runFanOut(plan, components, registry, options) {
     const results = [];
     const completed = [];
     const failed = [];
+    const notStarted = [];
+    const groupOutcomes = {};
     const blockedBy = new Map();
     const held = new Map();
     let gatedFact;
     const inPlan = new Set(active.order);
     const waveOf = waveNumbers(active.waves);
-    /** Hold `root` and everything downstream of it that has not settled otherwise. */
-    const markHeld = (root, reason) => {
-        held.set(root, { component: root, reason });
+    // ws-107: a group applies as one unit, so it is held and blocked as one.
+    const groupOf = groupsByComponent(active);
+    /** Hold `root` and everything downstream of it that has not settled otherwise. With `heldBy`, `root` is held for that component's reason. */
+    const markHeld = (root, reason, heldBy) => {
+        held.set(root, { component: root, reason, ...(heldBy ? { heldBy } : {}) });
         emit?.({ type: "component-settle", wave: waveOf.get(root), component: root, status: "waiting" });
         for (const [component] of downstreamWithin(components, inPlan, [root])) {
             if (held.has(component) || blockedBy.has(component) || failed.includes(component))
                 continue;
-            held.set(component, { component, reason, heldBy: root });
+            held.set(component, { component, reason, heldBy: heldBy ?? root });
             emit?.({ type: "component-settle", wave: waveOf.get(component), component, status: "waiting" });
         }
     };
-    /** Skip everything downstream of `root`, blaming `root` rather than the nearest edge. */
-    const markBlocked = (root) => {
-        for (const [component, by] of downstreamWithin(components, inPlan, [root])) {
-            if (blockedBy.has(component) || failed.includes(component))
+    /** Skip everything downstream of `roots`, blaming a root rather than the nearest edge. */
+    const markBlocked = (...roots) => {
+        for (const [component, by] of downstreamWithin(components, inPlan, roots)) {
+            if (blockedBy.has(component) || failed.includes(component) || completed.includes(component) || notStarted.includes(component))
                 continue;
             blockedBy.set(component, by);
         }
     };
     for (const [waveIndex, wave] of active.waves.entries()) {
         const waveNum = waveIndex + 1;
+        // A member blocked blocks its whole group, by the same failure.
+        for (const name of wave) {
+            const by = blockedBy.get(name);
+            if (by === undefined)
+                continue;
+            for (const mate of groupOf.get(name)?.components ?? [])
+                if (!blockedBy.has(mate) && mate !== by)
+                    blockedBy.set(mate, by);
+        }
         // A component whose upstream failed in an earlier wave is not dispatched.
         const candidates = wave.filter((name) => inPlan.has(name) && !blockedBy.has(name) && !held.has(name));
         for (const name of candidates) {
+            if (held.has(name))
+                continue;
             const reason = options.hold?.(name, componentOutputs);
-            if (reason !== undefined)
-                markHeld(name, reason);
+            if (reason === undefined)
+                continue;
+            markHeld(name, reason);
+            for (const mate of groupOf.get(name)?.components ?? [])
+                if (!held.has(mate))
+                    markHeld(mate, reason, name);
         }
         const runnable = candidates.filter((name) => !held.has(name));
         if (runnable.length === 0)
             continue;
         emit?.({ type: "wave-start", wave: waveNum, components: runnable });
-        const waveResults = await Promise.all(runnable.map(async (name) => {
+        const groupsHere = [...new Set(runnable.map((name) => groupOf.get(name)).filter((g) => g !== undefined))];
+        // Groups and the wave's other components run side by side, as a wave's components do.
+        const groupRuns = Promise.all(groupsHere.map(async (group) => {
+            for (const name of group.components)
+                emit?.({ type: "component-start", wave: waveNum, component: name });
+            const approved = options.groupRuns?.[group.components[0]];
+            const each = {
+                group,
+                components: byName,
+                registry,
+                env: options.env,
+                ...(options.vars ? { vars: options.vars } : {}),
+                ctxOf: (name) => fanOutContext(options, name),
+                componentOutputs,
+            };
+            const ran = approved === undefined && options.planGroupsAtWave ? await planAndRunComponentGroup(each) : await runComponentGroup({ ...each, run: approved });
+            for (const result of ran.results) {
+                emit?.({ type: "component-settle", wave: waveNum, component: result.component, status: result.status === "fail" ? "failed" : result.status });
+                options.onComponentSettled?.(result, componentOutputs[result.component]);
+            }
+            return ran;
+        }));
+        const waveResults = await Promise.all(runnable.filter((name) => !groupOf.has(name)).map(async (name) => {
             emit?.({ type: "component-start", wave: waveNum, component: name });
             const planned = options.plans?.[name];
             const result = await runComponentDeploy(byName.get(name), { ...fanOutContext(options, name), ...(planned && Object.keys(planned).length > 0 ? { plans: planned } : {}) }, registry, componentOutputs, undefined, gates, emit);
@@ -223,6 +269,7 @@ export async function runFanOut(plan, components, registry, options) {
             options.onComponentSettled?.(result, componentOutputs[name]);
             return result;
         }));
+        const groupResults = await groupRuns;
         results.push(...waveResults);
         for (const result of waveResults) {
             if (result.status === "ok") {
@@ -240,7 +287,26 @@ export async function runFanOut(plan, components, registry, options) {
             gatedFact ?? (gatedFact = result.gate);
             markBlocked(result.component);
         }
-        const waveFailed = waveResults.some((r) => r.status === "fail");
+        // A group's members settle together; what depends on a member that failed
+        // or never started, outside the group, is blocked by that member.
+        for (const ran of groupResults) {
+            results.push(...ran.results);
+            Object.assign(groupOutcomes, ran.outcomes);
+            const stopped = [];
+            for (const result of ran.results) {
+                if (result.status === "ok")
+                    completed.push(result.component);
+                else if (ran.notStarted.includes(result.component))
+                    notStarted.push(result.component);
+                else
+                    failed.push(result.component);
+                if (result.status !== "ok")
+                    stopped.push(result.component);
+            }
+            if (stopped.length > 0)
+                markBlocked(...stopped);
+        }
+        const waveFailed = waveResults.some((r) => r.status === "fail") || groupResults.some((ran) => ran.results.some((r) => r.status === "fail"));
         emit?.({
             type: "wave-settle",
             wave: waveNum,
@@ -254,7 +320,7 @@ export async function runFanOut(plan, components, registry, options) {
         .map(([component, by]) => ({ component, reason: "blocked", blockedBy: by }));
     // A failure outranks a gate: something is actually broken, and reporting the
     // run as "waiting on a human" would hide it. Same precedence the driver uses.
-    const status = failed.length > 0 ? "fail" : gatedFact ? "gated" : "ok";
+    const status = failed.length > 0 || notStarted.length > 0 ? "fail" : gatedFact ? "gated" : "ok";
     emit?.({ type: "run-settle", status: status === "fail" ? "failed" : status, durationMs: null });
     return {
         plan: active,
@@ -266,6 +332,8 @@ export async function runFanOut(plan, components, registry, options) {
         componentOutputs,
         ...(gatedFact ? { gate: gatedFact } : {}),
         ...(held.size > 0 ? { held: active.order.filter((name) => held.has(name)).map((name) => held.get(name)) } : {}),
+        ...(notStarted.length > 0 ? { notStarted: [...notStarted].sort() } : {}),
+        ...(Object.keys(groupOutcomes).length > 0 ? { groupOutcomes } : {}),
     };
 }
 /**

package/dist/components/fan-out-support.d.ts

@@ -30,6 +30,12 @@ export interface DeriveFanOutOptions {
     config?: ChantConfig;
     /** Components that form wave 1 (#3049). See `FanOutRequest.canary`. */
     canary?: string[];
+    /**
+     * The registry whose capabilities' `declaredReads` (#4466) are written into
+     * the components before the order is derived. Absent, the project's own
+     * (`fanOutRegistry`) is built for it.
+     */
+    registry?: CapabilityRegistry;
 }
 export interface DerivedFanOut {
     success: boolean;

package/dist/components/fan-out-support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fan-out-support.d.ts","sourceRoot":"","sources":["../../src/components/fan-out-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,EAAkC,KAAK,YAAY,EAAE,KAAK,qBAAqB,EAAE,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAC3H,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9D,MAAM,WAAW,mBAAmB;IAClC,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,qGAAqG;IACrG,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,8HAA8H;IAC9H,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACrC,kFAAkF;IAClF,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,kFAAkF;IAClF,MAAM,EAAE,qBAAqB,CAAC;IAC9B,IAAI,EAAE,UAAU,CAAC;IACjB,mGAAmG;IACnG,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAkBvF;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAGpG"}
+{"version":3,"file":"fan-out-support.d.ts","sourceRoot":"","sources":["../../src/components/fan-out-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,EAAkC,KAAK,YAAY,EAAE,KAAK,qBAAqB,EAAE,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAC3H,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAE9D,MAAM,WAAW,mBAAmB;IAClC,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,qGAAqG;IACrG,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,8HAA8H;IAC9H,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACrC,kFAAkF;IAClF,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,uEAAuE;IACvE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,kFAAkF;IAClF,MAAM,EAAE,qBAAqB,CAAC;IAC9B,IAAI,EAAE,UAAU,CAAC;IACjB,mGAAmG;IACnG,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAoBvF;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAGpG"}

package/dist/components/fan-out-support.js

@@ -17,6 +17,7 @@ import { resolveComponentTargets } from "./cli-support.js";
 import { applyConfigDefaults } from "./config-defaults.js";
 import { buildCapabilityRegistry } from "./capability-plugin-loader.js";
 import { componentsForUnits, planFanOut } from "./fan-out.js";
+import { withDeclaredReads } from "./declared-reads.js";
 import { loadChantConfig } from "../config.js";
 const EMPTY_PLAN = { order: [], waves: [], skipped: [], seeds: [], indeterminate: [], digest: "" };
 const EMPTY_SIGNAL = { changed: [], indeterminate: [], unclaimed: [] };
@@ -39,7 +40,9 @@ export async function deriveFanOut(options) {
         return { success: false, components: [], signal: EMPTY_SIGNAL, plan: EMPTY_PLAN, error: resolved.error };
     }
     const { config } = options.config ? { config: options.config } : await loadChantConfig(options.path);
-    const components = resolved.targets.map((component) => applyConfigDefaults(component, config));
+    const defaulted = resolved.targets.map((component) => applyConfigDefaults(component, config));
+    // #4466: the reads a capability finds in its steps' files, such as a template's Fn::ImportValue, order and hold like declared ones.
+    const components = await withDeclaredReads(defaulted, options.registry ?? (await fanOutRegistry(options.path, config)), options.path);
     const signal = componentsForUnits(components, options.units);
     const plan = planFanOut({
         components,

package/dist/components/fan-out.d.ts

@@ -33,6 +33,7 @@
  * This plans; it does not run. Executing the plan is ./driver.ts's job.
  */
 import { type DriverComponent } from "./driver.js";
+import type { ReportedGroupRead } from "./capability.js";
 /** Thrown when `changed` or `indeterminate` names a component the project does not have. */
 export declare class UnknownComponentError extends Error {
     readonly field: "changed" | "indeterminate";
@@ -107,6 +108,33 @@ export interface FanOutPlan {
     indeterminate: string[];
     /** Identity of this derivation, for binding one approval to the whole fan-out (#2300's pattern). */
     digest: string;
+    /**
+     * The groups a pull request plans and applies as one (ws-107), each in
+     * one wave, set by `groupFanOut` (./groups.ts). `waves` are then the
+     * grouped waves. `digest` stays the derivation's. Absent when none formed.
+     */
+    groups?: FanOutGroup[];
+    /** The components that could have grouped and did not, each with why (ws-107, ruling 1). Absent when none. */
+    fallbacks?: FanOutGroupFallback[];
+}
+/** Components one capability plans and applies in one call (ws-107). */
+export interface FanOutGroup {
+    /** The kind of the capability every member's one step names. */
+    capability: string;
+    /** The members, upstreams first. */
+    components: string[];
+    /**
+     * The reads between members the capability reported through `groupReads`
+     * (#4447), which no member's step input shows. Absent when none.
+     */
+    reads?: ReportedGroupRead[];
+}
+/** A component that did not join a group (ws-107): its capability's `kind`, and the fallback's `kind` and `reason`. */
+export interface FanOutGroupFallback {
+    component: string;
+    capability: string;
+    kind: string;
+    reason: string;
 }
 /**
  * Derive the fan-out for a change.

package/dist/components/fan-out.d.ts.map

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

package/dist/components/groups.d.ts

@@ -0,0 +1,229 @@
+/**
+ * Groups of components a capability plans and applies as one (ws-107, #4440).
+ *
+ * A pull request's components plan and apply one by one, wave by wave
+ * (`planPrSet`, `runFanOut`). A capability that declares `planGroup` and
+ * `runGroup` (./capability.ts) can take several of them in one call instead,
+ * so a value one member creates reaches the members that read it inside the
+ * same apply, with no round in between.
+ *
+ * Core decides which components form a group, where the group sits among the
+ * waves, what its digest binds and what each member's outcome means. The
+ * capability decides how. Nothing here names a lexicon.
+ *
+ * - {@link findComponentGroups}: which components of the change group, and
+ *   why each other one that could have did not (ws-107, "Which components
+ *   form a group"). Called once by `pr.ts`'s prepare step.
+ * - {@link groupFanOut}: the fan-out with each group in one wave (ws-107,
+ *   "Where the group sits"). The plan stage, the apply stage and every
+ *   `--wave-gate` job read these waves.
+ * - {@link planComponentGroup}: plan a group in one call, and fold the group
+ *   digest into each member's plan digest ({@link bindGroup}).
+ * - {@link runComponentGroup}: apply it in one call, and turn each member's
+ *   outcome into a component result.
+ * - {@link formRunGroups}, {@link componentSetFanOut} and
+ *   {@link planAndRunComponentGroup}: the same groups where a promote under a
+ *   release, `components fan-out` and `run --components` run (#4465).
+ */
+import { type DriverComponent, type DriverComponentResult } from "./driver.js";
+import { type CapabilityPlan, type CapabilityRegistry, type DeployContext, type GroupMemberStatus, type GroupRun } from "./capability.js";
+import type { FanOutGroup, FanOutGroupFallback, FanOutPlan } from "./fan-out.js";
+import { type WaveComponentPlan } from "./wave-plan.js";
+export interface FindComponentGroupsOptions {
+    /** Every component in the project. */
+    components: DriverComponent[];
+    /** The fan-out the change derives (`planFanOut`). Only `order` is grouped. */
+    plan: FanOutPlan;
+    registry: CapabilityRegistry;
+    env: string;
+    vars?: Record<string, unknown>;
+    /**
+     * Only components that share one of these groups may join (#4446): a
+     * resume forms groups again over what is left of the approved ones
+     * ({@link regroupRemaining}), never new ones.
+     */
+    within?: readonly FanOutGroup[];
+}
+/** What {@link findComponentGroups} found, for {@link groupFanOut}. */
+export interface FoundComponentGroups {
+    /** In plan order of their first member, each member list upstreams first. */
+    groups: FanOutGroup[];
+    /** Sorted by component. */
+    fallbacks: FanOutGroupFallback[];
+}
+/**
+ * The groups among the components of the change (ws-107):
+ *
+ * 1. A component is eligible when its deploy is one step, gates counted
+ *    (ruling 3), whose capability declares `planGroup` and `runGroup`.
+ * 2. Eligible components of one capability joined by reads, in either
+ *    direction, form a candidate set. A read is a wiring reference in a
+ *    step, or one the capability reports through `groupReads` (#4447); a
+ *    reported read also counts as a dependency below, orders the members
+ *    and is kept on the group as its `reads`.
+ * 3. While a component outside a set lies on a `dependsOn` path between two
+ *    of its members, the members downstream of it leave the set, and both
+ *    parts are joined by reads again (ruling 2). Outside components are
+ *    taken in plan order.
+ * 4. A set of one is no group. Each other set is offered to its
+ *    capability's `groupFallback`. A fallback without `drop` dissolves it.
+ *    One with `drop` leaves those members out (#4419 ruling 1): the rest
+ *    are joined by reads and split by rule 3 again, a member left on its
+ *    own falls back as `alone` (or `split`, when a dependency path split
+ *    it off), and each set that is left is offered again.
+ * 5. A group whose placement would put it and another each before the other
+ *    is dissolved (`cycle`).
+ *
+ * The fallbacks name every component whose capability declares the pair,
+ * that a read joins to another such component of its capability, and that
+ * ended in no group: `steps`, `split`, `alone`, `cycle`, or the capability's
+ * own kind.
+ */
+export declare function findComponentGroups(options: FindComponentGroupsOptions): Promise<FoundComponentGroups>;
+/**
+ * `plan` with each group of `found` in one wave (ws-107). The members leave
+ * their waves for the group's, upstreams first; a component outside every
+ * group moves to a later wave when a dependency now sits in its own wave or
+ * after it. A wave left empty stays, so wave numbers and their gates keep
+ * their meaning, and waves may be added at the end. `digest` does not change.
+ */
+export declare function groupFanOut(plan: FanOutPlan, components: DriverComponent[], found: FoundComponentGroups): FanOutPlan;
+/**
+ * `plan`, a narrowing of a grouped fan-out (`remainingFanOut`, a round),
+ * with what is left of `groups` placed again: each group keeps its members
+ * that are still in `plan`, and one left with fewer than two is no group.
+ * Nothing is asked of the capability again.
+ */
+export declare function narrowGroups(plan: FanOutPlan, components: DriverComponent[], groups: readonly FanOutGroup[] | undefined): FanOutPlan;
+/**
+ * `plan`, what a resume left of a grouped fan-out (`remainingFanOut`), with
+ * groups formed again over it (ws-107, "Resume"; #4446). Only members left
+ * of one of `groups` group again, by the same rule and the same
+ * `groupFallback`, so what is left of a group plans as a smaller group, or
+ * one by one when fewer than two are left, when they no longer join by
+ * reads, or when the capability refuses them. A capability that drops some
+ * members leaves the rest to group again as {@link findComponentGroups}
+ * does. The fallbacks are the ones this
+ * pass found, then those of `fallbacks` for components still in `plan`.
+ */
+export declare function regroupRemaining(options: Omit<FindComponentGroupsOptions, "within"> & {
+    groups: readonly FanOutGroup[] | undefined;
+    fallbacks?: readonly FanOutGroupFallback[];
+}): Promise<FanOutPlan>;
+/** The group each component of `plan` is a member of. */
+export declare function groupsByComponent(plan: Pick<FanOutPlan, "groups">): Map<string, FanOutGroup>;
+/**
+ * The group digest (ws-107): over the capability's kind, each member's
+ * component, change-set member and own plan digest, sorted, and the
+ * capability's digest of the composition. One member more, or the same
+ * members composed differently, moves it.
+ */
+export declare function groupDigest(kind: string, members: ReadonlyArray<{
+    component: string;
+    member: string;
+    planDigest: string;
+}>, composition: string): string;
+/**
+ * A member's plan with its group folded in (ws-107), after `bindTargets`:
+ * its digest becomes the digest over its own and the group's, written into
+ * its change-set part too, and the part carries the group's digest and the
+ * `reads` the plan does not know. A plan with no part gets an empty one.
+ */
+export declare function bindGroup(planned: CapabilityPlan, digest: string, reads: readonly string[]): CapabilityPlan;
+/** What planning a group gave (ws-107). */
+export interface ComponentGroupPlan {
+    /**
+     * One per member, in the group's order, as `planWaveComponent` gives a
+     * component's: its member, part, planned outputs and shape, its plan under
+     * `plans`. When the group failed to plan, each is that error.
+     */
+    plans: WaveComponentPlan[];
+    /** The group digest folded into each member's. Absent when it failed to plan. */
+    digest?: string;
+    /** What `runGroup` gets back. Absent when it failed to plan. */
+    run?: GroupRun;
+}
+export interface PlanComponentGroupOptions {
+    group: FanOutGroup;
+    components: ReadonlyMap<string, DriverComponent>;
+    registry: CapabilityRegistry;
+    env: string;
+    vars?: Record<string, unknown>;
+    /** Each member's context, as a single step would get it. */
+    ctxOf: (component: string) => DeployContext;
+    /** The outputs planned and read so far. The group's own members' are left out. */
+    outputs: Record<string, Record<string, unknown>>;
+}
+/**
+ * Plan `group` with one `planGroup` call (ws-107). Each member's plan is
+ * bound to its targets (`bindTargets`), then to the group ({@link bindGroup}).
+ * Never throws: a failure, a throwing `planGroup` included, makes every
+ * member plan-failed with its error, and nothing falls back after planning.
+ */
+export declare function planComponentGroup(options: PlanComponentGroupOptions): Promise<ComponentGroupPlan>;
+export interface RunComponentGroupOptions {
+    group: FanOutGroup;
+    components: ReadonlyMap<string, DriverComponent>;
+    registry: CapabilityRegistry;
+    env: string;
+    vars?: Record<string, unknown>;
+    /** Each member's context as a single step would get it, without `plans`. */
+    ctxOf: (component: string) => DeployContext;
+    /** The approved group plan ({@link ComponentGroupPlan.run}). */
+    run: GroupRun | undefined;
+    /** The outputs standing. Each member that applied adds its own, as a run does. */
+    componentOutputs: Record<string, Record<string, unknown>>;
+}
+export interface ComponentGroupRunResult {
+    /** One per member, in the group's order. A `not-started` member's is `fail` with a `skipped` record. */
+    results: DriverComponentResult[];
+    /** The members whose part never began, in the group's order. */
+    notStarted: string[];
+    /**
+     * How each member's part ended, as the capability said (#4446): the
+     * report's `groupOutcome`. A throw gives every member `failed`, or
+     * `not-started` for a moved plan.
+     */
+    outcomes: Record<string, GroupMemberStatus>;
+}
+/**
+ * Apply `group` with one `runGroup` call (ws-107) and map each member's
+ * outcome: `applied` and `no-changes` complete it and record its outputs;
+ * `partial` and `failed` fail it; `not-started` leaves it not started. A
+ * throw fails every member, since core cannot tell what applied, except a
+ * moved plan (`isPlanMovedError`), which leaves every member not started and
+ * marks each record `planMoved`, so the command exits 3.
+ */
+export declare function runComponentGroup(options: RunComponentGroupOptions): Promise<ComponentGroupRunResult>;
+/** The fallback kind of a component that would have joined a group under `--wave-gate` (#4465, ruling 1). */
+export declare const WAVE_GATE_FALLBACK = "wave-gate";
+/**
+ * The fan-out over `components` and nothing else (#4465), as a promote and
+ * `run --components` run them: a dependency outside the set is already
+ * satisfied, and nothing is skipped or seeded. `digest` names the set.
+ */
+export declare function componentSetFanOut(components: readonly DriverComponent[]): FanOutPlan;
+export interface FormRunGroupsOptions extends Omit<FindComponentGroupsOptions, "within"> {
+    /** `--wave-gate`: no group forms (#4465, ruling 1). */
+    waveGate?: boolean;
+}
+/**
+ * `options.plan` with the groups a promote under a release, `components
+ * fan-out` and `run --components` form (#4465), by the rule the
+ * pull-request run uses ({@link findComponentGroups}, {@link groupFanOut}).
+ *
+ * Under a wave gate nothing groups (ruling 1 of #4465): a gated wave plans
+ * component by component, as `runFanOut` requires, so each member of a group
+ * that would have formed falls back with kind {@link WAVE_GATE_FALLBACK},
+ * and the plan keeps its waves.
+ */
+export declare function formRunGroups(options: FormRunGroupsOptions): Promise<FanOutPlan>;
+/**
+ * Plan `group` in its wave against the outputs standing, then apply it
+ * (#4465). `components fan-out` and `run --components` run a group this way,
+ * since neither plans before it applies, as each of their components plans
+ * inside its own step. A group that fails to plan applies nothing: each
+ * member fails with the plan's error and is `not-started`.
+ */
+export declare function planAndRunComponentGroup(options: Omit<RunComponentGroupOptions, "run">): Promise<ComponentGroupRunResult>;
+//# sourceMappingURL=groups.d.ts.map

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

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