@intentius/chant 0.124.51 → 0.124.54

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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"}