@intentius/chant 0.124.40 → 0.124.41

package/dist/pr-loop.js

@@ -63,6 +63,12 @@ export const PR_REPORT_WAVES_FLOOR = "0.124.32";
 export const PR_REPORT_PLANNED_OUTPUTS_FLOOR = "0.124.32";
 /** The chant that writes the `record` stage and the `recorded` status (#4168 step 1). */
 export const PR_REPORT_RECORD_FLOOR = "0.124.33";
+/** The first chant whose report can carry `hooks` (#4288). */
+export const PR_REPORT_HOOKS_FLOOR = "0.124.41";
+/** The first chant whose plan report can carry `overdue` (#4289). */
+export const PR_REPORT_OVERDUE_FLOOR = "0.124.41";
+/** The first chant whose report can carry `policy` and the `policy-denied` and `policy-error` refusals (#4294). */
+export const PR_REPORT_POLICY_FLOOR = "0.124.41";
 /** The gate a pull request's apply waits on, unless the pipeline names another. */
 export const PR_APPLY_GATE = "pr-apply";
 /**
@@ -143,11 +149,15 @@ function headline(report) {
         case "recorded":
             return `Recorded the plan of ${members} on merge. Nothing applied: a release that carries this commit deploys it.`;
         case "plan-failed":
+            if (report.hooks?.some((h) => h.outcome === "failed"))
+                return "A hook failed, so nothing can apply.";
             return `Planning failed for ${report.members.filter((m) => m.status === "plan-failed").length} of ${members}, so nothing can apply.`;
         case "applied":
             return `Applied ${members}.`;
-        case "failed":
-            return `The apply failed: ${report.members.filter((m) => m.status === "failed").length} failed, ${report.members.filter((m) => m.status === "applied").length} applied.`;
+        case "failed": {
+            const blocked = report.members.filter((m) => m.status === "blocked").length;
+            return `The apply failed: ${report.members.filter((m) => m.status === "failed").length} failed, ${blocked > 0 ? `${blocked} blocked, ` : ""}${report.members.filter((m) => m.status === "applied").length} applied.`;
+        }
         case "wave-applied": {
             const applied = (report.waves ?? []).filter((w) => w.status === "applied").map((w) => w.wave);
             const total = report.selection.waves.length;
@@ -161,6 +171,49 @@ function headline(report) {
             return `Applied ${report.members.filter((m) => m.status === "applied").length} of ${members}; ${report.members.filter((m) => m.status === "waiting").length} wait on an approval of the plan made after their upstream applied.`;
     }
 }
+/**
+ * The blocked set (#4291): each component a failure held, grouped by the
+ * component that failed, and that the rest went on. Undefined when nothing
+ * is blocked.
+ */
+function blockedLine(members) {
+    const byRoot = new Map();
+    for (const m of members) {
+        if (m.status !== "blocked")
+            continue;
+        const by = m.blockedBy ?? "a dependency";
+        byRoot.set(by, (byRoot.get(by) ?? new Set()).add(m.component));
+    }
+    if (byRoot.size === 0)
+        return undefined;
+    const groups = [...byRoot]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([by, names]) => `${[...names].sort().map(code).join(", ")} (blocked by ${by === "a dependency" ? by : code(by)})`);
+    return `Blocked, so not applied: ${groups.join("; ")}. A failure blocks only the members that depend on it, so the rest went on.`;
+}
+/** The policy's lines in the note (#4294): what denied or held the plan, and how a denial is overridden. */
+function policyLines(report) {
+    const p = report.policy;
+    if (!p)
+        return [];
+    const at = `read at ${code(short(p.base))}`;
+    const each = (list) => list.map((f) => `- ${code(f.rule)}: ${f.message}`);
+    const out = [""];
+    if (p.result === "error")
+        out.push(`Policy (${p.engine}, ${at}) could not be checked, so nothing applies: ${p.error ?? "no answer"}.`);
+    else if (p.result === "passed")
+        out.push(`Policy (${p.engine}, ${at}) passed.`);
+    if (p.denials.length > 0) {
+        out.push(p.override ? `Policy (${p.engine}, ${at}) denied this plan; ${code(p.override.by)} overrode it: ${p.override.reason}` : `Policy (${p.engine}, ${at}) denied this plan:`, ...each(p.denials));
+        if (!p.override && p.overrideCommand)
+            out.push("", `A person the overriders file at base lists may override it once pr-apply has recorded the denial: ${code(p.overrideCommand)}`);
+    }
+    if (p.holds.length > 0)
+        out.push(`Policy (${p.engine}, ${at}) holds this plan for a person's approval of its digest:`, ...each(p.holds));
+    if (p.warnings.length > 0)
+        out.push(`Policy warnings: ${p.warnings.join("; ")}`);
+    return out;
+}
 /** Who a wave applied or waits under, as a table cell. */
 function waveApproval(w) {
     const whose = w.approval === "pull-request" ? "the pull request's" : "its own";
@@ -219,6 +272,8 @@ export function renderPrNote(report, options = {}) {
     ];
     if (report.message)
         out.push("", `> ${report.message.split("\n").join("\n> ")}`);
+    for (const o of report.overdue ?? [])
+        out.push("", `Warning: ${o.message}`);
     if (report.resumed && report.resumed.applied.length > 0) {
         out.push("", `Resumed under the same approval: ${report.resumed.applied.map(code).join(", ")} applied in an earlier attempt and did not run again.`);
     }
@@ -227,6 +282,7 @@ export function renderPrNote(report, options = {}) {
         for (const m of report.members) {
             const holes = memberHoleReasons(report, m.member);
             const status = STATUS_WORDS[m.status] +
+                (m.status === "blocked" && m.blockedBy ? ` by ${code(m.blockedBy)}` : "") +
                 (m.inputsMoved?.length ? `, inputs from ${m.inputsMoved.join(", ")} moved` : "") +
                 (holes.length > 0 ? `; ${holes.length > 2 ? `${holes[0]}; and ${holes.length - 1} more, listed under Holes` : holes.join("; ")}` : "");
             // A member whose plan has holes and no entries says nothing about what
@@ -239,7 +295,18 @@ export function renderPrNote(report, options = {}) {
             out.push("", "A member whose inputs moved applied the plan it was approved with. The next run plans it against the new values.");
         }
     }
+    const blocked = blockedLine(report.members);
+    if (blocked)
+        out.push("", blocked);
     out.push(...waveLines(report, options.approver ?? "<you>"));
+    // #4288: the hooks that did not pass, by name; a passed hook is a count.
+    const hooks = report.hooks ?? [];
+    if (hooks.length > 0) {
+        const passed = hooks.filter((h) => h.outcome === "passed").length;
+        const other = hooks.filter((h) => h.outcome !== "passed").map((h) => `${code(h.name)} ${h.moment}${h.target ? ` for ${code(h.target)}` : ""} ${h.outcome === "held" ? "held" : "failed"} (exit ${h.exit})`);
+        out.push("", `Hooks: ${passed} passed${other.length > 0 ? `; ${other.join("; ")}` : ""}.`);
+    }
+    out.push(...policyLines(report));
     if (report.selection.unclaimed.length > 0) {
         out.push("", `Changed, and deployed by no component: ${report.selection.unclaimed.map(code).join(", ")}.`);
     }
@@ -334,7 +401,11 @@ export function prStatusDescription(report) {
                 text = "refused: an earlier wave has not applied";
                 break;
             }
-            text = `refused: ${report.refusal === "plan-changed" ? "the plan changed after review" : report.refusal === "not-a-reviewer" ? "the approver has not approved the pull request" : report.refusal === "author-approved" ? "the approver wrote the change" : report.refusal === "no-pull-request" ? "no pull request merged this commit" : "the plan is not approved"}`;
+            if (report.refusal === "policy-denied" || report.refusal === "policy-error") {
+                text = report.refusal === "policy-denied" ? `refused: the policy denied the plan (${(report.policy?.rules ?? []).join(", ")})` : "refused: the policy could not be checked";
+                break;
+            }
+            text = `refused: ${report.refusal === "plan-changed" ? "the plan changed after review" : report.refusal === "not-a-reviewer" ? "the approver has not approved the pull request" : report.refusal === "author-approved" ? "the approver wrote the change" : report.refusal === "no-pull-request" ? "no pull request merged this commit" : report.refusal === "locked" ? "another pull request holds a target lock" : "the plan is not approved"}`;
             break;
         }
     }
@@ -345,6 +416,9 @@ export function prStatusState(report) {
     // #4168 decision 1: a merge whose plan differs from the approved one is recorded, and its status fails.
     if (report.status === "recorded")
         return report.approval.status === "changed" ? "failure" : "success";
+    // #4294: a plan the policy denied, with no override, or one it could not check, fails at the plan stage as it would at the apply.
+    if (report.status === "planned" && report.policy && (report.policy.result === "error" || (report.policy.result === "denied" && !report.policy.override)))
+        return "failure";
     if (report.status === "planned" || report.status === "applied" || report.status === "wave-applied" || report.status === "nothing")
         return "success";
     if (report.status === "refused" && (report.refusal === "not-approved" || report.refusal === "wave-not-approved"))

package/dist/pr-post.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Post a pull request's plan note and its `chant/plan` status from the plan
+ * report (#4295), in a job or a process that runs none of the change's code.
+ *
+ * The plan job runs the pull request's code and holds no forge token
+ * (./ci-handover.ts), so `pr-plan --no-status` only writes its report. Then
+ * `chant components pr-post` in the `plan-note` job, or `chant ci run plan`
+ * once its steps settle, reads the report and posts.
+ *
+ * The report is the change's: its code could write anything into it. So it
+ * is read as data. The pull request, the head, the environment and the
+ * member come from the caller, never the report, and a report that names
+ * others is refused. The note is rendered again here from the report, and
+ * every hidden HTML comment after its first line is defused, so a forged
+ * marker cannot claim another environment's note. A plan job that failed
+ * fails the status whatever its report says.
+ */
+import { type PrOverdue, type PrReport } from "./pr-loop.js";
+import { type PrForge } from "./pr-forge.js";
+/** The plan report's file under the report directory. */
+export declare const PR_PLAN_REPORT_FILE = "pr-plan.json";
+/** What {@link postPlanReport} posts for. */
+export interface PlanPostInput {
+    forge: PrForge;
+    /** The report directory the plan job wrote, `.chant/pr`. */
+    dir: string;
+    /** The pull request, from the forge's event. */
+    pr: number;
+    /** The commit the plan job checked out, from the forge's event. */
+    head: string;
+    env: string;
+    member?: string;
+    /** The plan job's own result (`needs.plan.result`). `failure` fails the status. */
+    result?: string;
+    /**
+     * The scheduled Ops that stopped running (#4289), asked here since the plan
+     * job held no token to ask with. It replaces any `overdue` in the report.
+     */
+    overdue?: () => Promise<PrOverdue[]>;
+}
+/** What {@link postPlanReport} did. */
+export interface PlanPostResult {
+    state: "success" | "failure" | "pending";
+    description: string;
+    /** Whether a note was posted. A refused or missing report posts none. */
+    noted: boolean;
+    /** Why the report was not used, when it was not. */
+    refused?: string;
+    warnings: string[];
+}
+/**
+ * Read the plan report under `dir` and check it is the one the caller ran:
+ * a plan report for the same pull request, head, environment and member.
+ * Returns the report, or why it is not used.
+ */
+export declare function readPlanReport(input: Pick<PlanPostInput, "dir" | "pr" | "head" | "env" | "member">): {
+    report: PrReport;
+} | {
+    refused: string;
+};
+/**
+ * The note for `report`, rendered here, with every `<!--` after the marker
+ * line written as `&lt;!--`, so the note carries no hidden marker but its own.
+ */
+export declare function planNoteFor(report: PrReport, forge: Pick<PrForge, "kind" | "host">, marker: string): string;
+/**
+ * Post the status and the note for the plan report under `input.dir`. A
+ * forge that refuses a call is a warning. A report that is missing or not
+ * the caller's sets a failed status and posts no note.
+ */
+export declare function postPlanReport(input: PlanPostInput): Promise<PlanPostResult>;
+//# sourceMappingURL=pr-post.d.ts.map

package/dist/pr-post.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pr-post.d.ts","sourceRoot":"","sources":["../src/pr-post.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EAAmF,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC3I,OAAO,EAAoB,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5D,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAElD,6CAA6C;AAC7C,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAC;IACX,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mFAAmF;IACnF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;CACtC;AAED,uCAAuC;AACvC,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,KAAK,EAAE,OAAO,CAAC;IACf,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAID;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,IAAI,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC,GAAG;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAoB/I;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAQ3G;AAID;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,CAkDlF"}

package/dist/pr-post.js

@@ -0,0 +1,134 @@
+/**
+ * Post a pull request's plan note and its `chant/plan` status from the plan
+ * report (#4295), in a job or a process that runs none of the change's code.
+ *
+ * The plan job runs the pull request's code and holds no forge token
+ * (./ci-handover.ts), so `pr-plan --no-status` only writes its report. Then
+ * `chant components pr-post` in the `plan-note` job, or `chant ci run plan`
+ * once its steps settle, reads the report and posts.
+ *
+ * The report is the change's: its code could write anything into it. So it
+ * is read as data. The pull request, the head, the environment and the
+ * member come from the caller, never the report, and a report that names
+ * others is refused. The note is rendered again here from the report, and
+ * every hidden HTML comment after its first line is defused, so a forged
+ * marker cannot claim another environment's note. A plan job that failed
+ * fails the status whatever its report says.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { prNoteMarker, prStatusContext, prStatusDescription, prStatusState, renderPrNote } from "./pr-loop.js";
+import { forgePrincipalOf } from "./pr-forge.js";
+import { GITHUB_COMMENT_LIMIT, GITLAB_NOTE_LIMIT } from "./plan-summary.js";
+/** The plan report's file under the report directory. */
+export const PR_PLAN_REPORT_FILE = "pr-plan.json";
+const SHA = /^[0-9a-f]{40}$/;
+/**
+ * Read the plan report under `dir` and check it is the one the caller ran:
+ * a plan report for the same pull request, head, environment and member.
+ * Returns the report, or why it is not used.
+ */
+export function readPlanReport(input) {
+    const file = join(input.dir, PR_PLAN_REPORT_FILE);
+    if (!existsSync(file))
+        return { refused: "the plan job wrote no report" };
+    let doc;
+    try {
+        doc = JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch (err) {
+        return { refused: `the plan report does not read: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    if (!doc || typeof doc !== "object" || Array.isArray(doc))
+        return { refused: "the plan report is not an object" };
+    const r = doc;
+    if (r.stage !== "plan")
+        return { refused: `the report is not a plan report (stage ${JSON.stringify(r.stage)})` };
+    if (r.pr !== input.pr)
+        return { refused: `the report is for pull request ${JSON.stringify(r.pr)}, not ${input.pr}` };
+    if (typeof r.head !== "string" || !SHA.test(r.head) || r.head !== input.head)
+        return { refused: `the report is for head ${JSON.stringify(r.head)}, not ${input.head}` };
+    if (r.env !== input.env)
+        return { refused: `the report is for environment ${JSON.stringify(r.env)}, not ${input.env}` };
+    if ((r.member ?? undefined) !== input.member)
+        return { refused: `the report is for member ${JSON.stringify(r.member ?? null)}, not ${JSON.stringify(input.member ?? null)}` };
+    if (!Array.isArray(r.members) || !r.changeSet || typeof r.changeSet !== "object" || !r.selection || typeof r.selection !== "object" || !r.approval || typeof r.approval !== "object") {
+        return { refused: "the plan report is missing its members, change set, selection or approval" };
+    }
+    return { report: doc };
+}
+/**
+ * The note for `report`, rendered here, with every `<!--` after the marker
+ * line written as `&lt;!--`, so the note carries no hidden marker but its own.
+ */
+export function planNoteFor(report, forge, marker) {
+    const note = renderPrNote(report, {
+        limit: forge.kind === "gitlab" ? GITLAB_NOTE_LIMIT : GITHUB_COMMENT_LIMIT,
+        approver: forgePrincipalOf(forge.kind, forge.host, "<your-login>"),
+    });
+    const at = note.indexOf("\n");
+    const rest = (at < 0 ? "" : note.slice(at + 1)).split("<!--").join("&lt;!--");
+    return `${marker}\n${rest}`;
+}
+const cut = (text, max = 140) => (text.length > max ? `${text.slice(0, max - 3)}...` : text);
+/**
+ * Post the status and the note for the plan report under `input.dir`. A
+ * forge that refuses a call is a warning. A report that is missing or not
+ * the caller's sets a failed status and posts no note.
+ */
+export async function postPlanReport(input) {
+    const warnings = [];
+    const context = prStatusContext("plan", input.member);
+    const read = readPlanReport(input);
+    const failedJob = input.result === "failure" || input.result === "cancelled";
+    let state;
+    let description;
+    let note;
+    let refused;
+    if ("refused" in read) {
+        refused = read.refused;
+        state = "failure";
+        description = cut(read.refused);
+    }
+    else {
+        let report = read.report;
+        if (input.overdue) {
+            const { overdue: _forged, ...rest } = report;
+            const found = await input.overdue().catch(() => []);
+            report = (found.length > 0 ? { ...rest, overdue: found } : rest);
+        }
+        try {
+            state = prStatusState(report);
+            description = prStatusDescription(report);
+            // A member the change does not reach has nothing to say on the pull request (as pr-plan's own publish).
+            if (!(input.member && report.status === "nothing" && !report.overdue?.length))
+                note = planNoteFor(report, input.forge, prNoteMarker(input.env, input.member));
+        }
+        catch (err) {
+            refused = `the plan report does not render: ${err instanceof Error ? err.message : String(err)}`;
+            state = "failure";
+            description = cut(refused);
+            note = undefined;
+        }
+        if (failedJob && state !== "failure") {
+            state = "failure";
+            description = cut(`the plan job failed; ${description}`);
+        }
+    }
+    try {
+        await input.forge.setStatus(input.head, { context, state, description: cut(description), ...(input.forge.runUrl ? { url: input.forge.runUrl } : {}) });
+    }
+    catch (err) {
+        warnings.push(`could not set the ${context} status: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (note !== undefined) {
+        try {
+            await input.forge.upsertNote(input.pr, prNoteMarker(input.env, input.member), note);
+        }
+        catch (err) {
+            warnings.push(`could not post the note on #${input.pr}: ${err instanceof Error ? err.message : String(err)}`);
+            note = undefined;
+        }
+    }
+    return { state, description: cut(description), noted: note !== undefined, ...(refused ? { refused } : {}), warnings };
+}

package/dist/wave-blocked.d.ts

@@ -0,0 +1,79 @@
+export declare const WAVE_OUTCOME_VERSION = 1;
+export type WaveMemberStatus = "applied" | "unchanged" | "failed" | "waiting" | "refused" | "decided" | "not-applied" | "blocked";
+export interface WaveMemberOutcome {
+    status: WaveMemberStatus;
+    /** A blocked member's: the member whose outcome held it, past any member blocked in between. */
+    by?: string;
+}
+export interface WaveOutcomeFile {
+    version: typeof WAVE_OUTCOME_VERSION;
+    wave: number;
+    /** When the job wrote it: the newest outcome of a member wins. */
+    at: string;
+    members: Record<string, WaveMemberOutcome>;
+    /** The wave holds every later member, each blocked by `wave-<k>`. */
+    holds_all?: true;
+}
+/** Whether `outcome` lets a dependent through: it applied, or had nothing to apply. */
+export declare function passesThrough(outcome: WaveMemberOutcome | undefined): boolean;
+/**
+ * The members of `members` an upstream that did not apply holds, each with
+ * the member whose outcome holds it. `upstreams` is each member's upstreams;
+ * only those in `earlier` count (a member of this wave or a later one is no
+ * upstream it waits for here). An upstream with no outcome did not apply as
+ * far as this run knows, so it holds its dependents and names itself. A
+ * blocked upstream passes on the member that blocked it. With `holdsAll`,
+ * every member is blocked by `wave-<holdsAll>`.
+ */
+export declare function blockedMembers(members: readonly string[], upstreams: ReadonlyMap<string, Iterable<string>>, earlier: ReadonlySet<string>, outcomes: ReadonlyMap<string, WaveMemberOutcome>, holdsAll?: number): Map<string, string>;
+/**
+ * Walk waves 1 to `before - 1` and give each member that has no outcome the
+ * one it ends with: `blocked` behind an upstream that did not apply. A member
+ * with no outcome that nothing blocks has not run yet: it is in `unsettled`,
+ * and wave `before` cannot run until it has. `outcomes` is what the records
+ * say: `applied` for what applied, and `failed`, `waiting` or `not-applied`
+ * for what did not. Returns those outcomes with the blocked members added.
+ */
+export declare function settleEarlierWaves(waves: readonly (readonly string[])[], before: number, upstreams: ReadonlyMap<string, Iterable<string>>, outcomes: ReadonlyMap<string, WaveMemberOutcome>): {
+    outcomes: Map<string, WaveMemberOutcome>;
+    unsettled: string[];
+};
+/**
+ * Whether every member that did not apply waits for an approval, or is
+ * blocked behind one that does: the run waits rather than failed, so the
+ * job ends as waiting (exit 3), and the approval's re-run applies them.
+ */
+export declare function onlyWaiting(outcomes: ReadonlyMap<string, WaveMemberOutcome>): boolean;
+/** The blocked members grouped by what blocked them, as a log and a note list them: `app-01, app-02 (blocked by cluster-a)`. */
+export declare function blockedWords(blocked: ReadonlyMap<string, string>): string;
+/**
+ * How the run came out, from every member's newest outcome: "8 applied, 1
+ * failed, 6 blocked", with waiting, refused and the rest named when there
+ * are any, and undefined when every member applied or had nothing to apply.
+ */
+export declare function runSummary(outcomes: Iterable<WaveMemberOutcome>): string | undefined;
+/** The outcome file of a wave's job, or of one group or share of it. */
+export declare function waveOutcomeFileName(wave: number, part?: {
+    group?: string;
+    share?: number;
+}): string;
+/** Write a wave job's outcome file in `dir`, members sorted by name. Returns its path. */
+export declare function writeWaveOutcomeFile(dir: string, wave: number, part: {
+    group?: string;
+    share?: number;
+}, members: Record<string, WaveMemberOutcome>, at?: string, holdsAll?: boolean): string;
+/**
+ * The outcome of each member of the waves before `wave`, as their jobs wrote
+ * them under `dirs`, and the earliest such wave that holds every later
+ * member, if any. For a member more than one job wrote (a re-run, or a split
+ * wave's deciding job and the share that applied it), the newest. A file
+ * that does not parse, or is of another version, is skipped.
+ */
+export declare function earlierWaveOutcomes(dirs: readonly string[], wave: number): {
+    members: Map<string, WaveMemberOutcome & {
+        wave: number;
+        at: string;
+    }>;
+    holdsAll?: number;
+};
+//# sourceMappingURL=wave-blocked.d.ts.map

package/dist/wave-blocked.d.ts.map

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