@intentius/chant 0.124.33 → 0.124.35

package/dist/cli/handlers/promote.js

@@ -20,8 +20,9 @@
  * environment: every component of the release at the digest the environment
  * ran from it, through the release gate `promote --release` binds (#4045).
  */
-import { resolve } from "node:path";
-import { readFileSync } from "node:fs";
+import { ENV_VAR } from "../../env.js";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { loadChantConfig } from "../../config.js";
 import { promotionOrder } from "../../workspace/promotion-order.js";
 import { resolvePromotionSource } from "../../components/promote-order.js";
@@ -41,7 +42,7 @@ import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli.js";
 import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format.js";
 import { GATED_EXIT_CODE } from "./run.js";
 import { redeployLine, releaseRollbackLine, rollbackTarget, unsettledComponents } from "../../lifecycle/mixed-environment.js";
-const PROMOTE_USAGE = "chant components promote --to <env> [--from <env>] [--allow-skip] [--release <label|digest>] [--component <name> [--digest <sha256:...>] | --digest <component>=<sha256:...> ...] [--dry-run] [--json]";
+const PROMOTE_USAGE = "chant components promote --to <env> [--from <env>] [--allow-skip] [--release <label|digest>] [--component <name> [--digest <sha256:...>] | --digest <component>=<sha256:...> ...] [--wave-gate <gate>] [--resume <file>] [--dry-run] [--json]";
 const ROLLBACK_USAGE = "chant components rollback <env> (--component <name> [--digest <sha256:...>] | --release <label|digest>) [--dry-run] [--json]";
 const REDEPLOY_USAGE = "chant components redeploy <env> --component <name> [--digest <sha256:...>] [--dry-run] [--json]";
 function renderPlan(verb, plan, removed) {
@@ -73,9 +74,16 @@ function planJson(plan, removed) {
 function resolveActor(ctx) {
     return ctx.args.actor ?? process.env.GITHUB_ACTOR ?? process.env.GITLAB_USER_LOGIN ?? process.env.USER;
 }
-/** Config, params and the declared components, or the exit code of a refusal already printed. */
-async function loadProject(ctx, selector) {
+/**
+ * Config, params and the declared components, or the exit code of a refusal
+ * already printed. `env` is the environment being deployed: it is set as
+ * `CHANT_ENV` before the components load, as `--env` sets it for `chant run`
+ * (../main.ts), so a component that reads it (a stack name per environment)
+ * deploys to that environment and not to the one it was promoted from (#4222).
+ */
+async function loadProject(ctx, selector, env) {
     const { args } = ctx;
+    process.env[ENV_VAR] = env;
     const projectPath = resolve(".");
     const { config } = await loadChantConfig(projectPath).catch(() => ({ config: {} }));
     const paramsResolution = resolveCliBuildParams(config.buildParams, {
@@ -115,6 +123,11 @@ async function readLedger(env) {
  * a refusal already printed: a provisional member, or a member that failed
  * to plan. On an empty change set, each gate gets an `empty: true`
  * resolution the run then counts once it reads the stored document back.
+ *
+ * A dependent is planned against what a promoted upstream's plan says it will
+ * expose (#4168 step 4). With a resume record, only what is left is planned,
+ * against the outputs the record kept, and the approval the record names
+ * carries on when it covers that plan.
  */
 async function bindReleaseGate(input) {
     const { plan, under, port } = input;
@@ -145,71 +158,157 @@ async function bindReleaseGate(input) {
     for (const [component, u] of unsettledComponents(envRecords, await readDeployOutcomes(env).catch(() => []))) {
         unsettled.set(component, `the ${u.outcome.verb} run ${u.outcome.runId} left ${component} ${u.state} in "${env}" and nothing has been recorded for it since, so what it runs is not known`);
     }
-    const doc = await gate.planReleaseChangeSet({
+    const digests = new Map(plan.items.map((i) => [i.component, i.digest]));
+    const planSet = (only, outputs) => gate.planReleaseSet({
         release: under.release,
         env,
         components: input.prepared,
-        digests: new Map(plan.items.map((i) => [i.component, i.digest])),
+        digests,
         registry: input.registry,
         current,
         unsettled,
-        seededOutputs: input.seededOutputs,
+        seededOutputs: outputs,
+        ...(only ? { only } : {}),
     });
-    const provisional = gate.provisionalMembers(doc);
-    if (provisional.length > 0) {
-        console.error(formatError({
-            message: `the change set of release ${under.label ?? releaseDigest} for "${env}" has provisional members (${provisional.join(", ")}), which no approval covers; nothing was deployed`,
-            hint: "Deploy what they read first, so they plan against real values.",
-        }));
-        return 1;
-    }
-    const failed = doc.members.filter((m) => m.status === "failed");
-    if (failed.length > 0) {
-        for (const m of failed)
-            console.error(formatError({ message: `${m.member} failed to plan for "${env}"${m.error ? `: ${m.error}` : ""}` }));
-        console.error(formatError({ message: "nothing was deployed" }));
-        return 1;
-    }
-    // The document is stored before the gate is decided, so the plan a pending
-    // gate waits on can be read, and an empty pass can be checked.
     const { storeGateChangeSet } = await import("../../lifecycle/gate-change-set.js");
-    try {
-        const stored = await storeGateChangeSet({ doc, cwd: input.projectPath, at: input.head ?? null });
-        if (stored.warning)
-            console.error(formatWarning({ message: stored.warning }));
-    }
-    catch (err) {
-        console.error(formatWarning({ message: `could not store the change set ${doc.digest}: ${err instanceof Error ? err.message : String(err)}` }));
-    }
+    const { readStoredChangeSet } = await import("../../lifecycle/change-set-store.js");
     const { isEmptyChangeSet } = await import("../../change-set.js");
-    const empty = isEmptyChangeSet(doc);
-    console.error(formatInfo(`release gate: change set ${doc.digest} for "${env}"` +
-        (empty ? ", empty: its gates pass without an approval" : `, ${doc.summary.entries} entr${doc.summary.entries === 1 ? "y" : "ies"}, ${doc.summary.holes} hole(s)`) +
-        ` (chant change-set show ${doc.digest})`));
-    if (empty) {
-        if (!port.appendResolution)
-            throw new Error("the gate ledger can't record a resolution, so an empty change set can't pass its gates");
-        const { resolutions } = await port.read(gate.RELEASE_GATE_OP);
-        const timestamp = new Date().toISOString();
-        for (const name of gates) {
-            const standing = resolutions.some((r) => r.empty === true && r.gate === name && r.environment === env && r.releaseDigest === releaseDigest && r.planDigest === doc.digest);
-            if (standing)
-                continue;
-            // Pushed with the resolution; the deploy records the promote writes push the same branch.
-            await port.appendResolution(gate.emptyResolution({ gate: name, doc, actor: input.actor, timestamp, ...(input.head ? { gitSha: input.head } : {}) }));
+    const verifyEmpty = gate.emptyVerifier((digest) => readStoredChangeSet(digest, { cwd: input.projectPath }), { releaseDigest, environment: env });
+    /** Refuse, store, and pass the gates of an empty plan; the binding, or the exit code of a refusal already printed. */
+    const bindDoc = async (doc, names, what) => {
+        const provisional = gate.provisionalMembers(doc);
+        if (provisional.length > 0) {
+            console.error(formatError({
+                message: `${what} of release ${under.label ?? releaseDigest} for "${env}" has provisional members (${provisional.join(", ")}), which no approval covers; nothing more was deployed`,
+                hint: "Deploy what they read first, so they plan against real values.",
+            }));
+            return 1;
         }
-    }
-    const { readStoredChangeSet } = await import("../../lifecycle/change-set-store.js");
-    return {
-        doc,
-        empty,
-        binding: {
-            op: gate.RELEASE_GATE_OP,
-            planDigest: doc.digest,
-            releaseDigest,
-            verifyEmpty: gate.emptyVerifier((digest) => readStoredChangeSet(digest, { cwd: input.projectPath }), { releaseDigest, environment: env }),
+        const failed = doc.members.filter((m) => m.status === "failed");
+        if (failed.length > 0) {
+            for (const m of failed)
+                console.error(formatError({ message: `${m.member} failed to plan for "${env}"${m.error ? `: ${m.error}` : ""}` }));
+            console.error(formatError({ message: "nothing more was deployed" }));
+            return 1;
+        }
+        // The document is stored before the gate is decided, so the plan a pending
+        // gate waits on can be read, and an empty pass can be checked.
+        try {
+            const stored = await storeGateChangeSet({ doc, cwd: input.projectPath, at: input.head ?? null });
+            if (stored.warning)
+                console.error(formatWarning({ message: stored.warning }));
+        }
+        catch (err) {
+            console.error(formatWarning({ message: `could not store the change set ${doc.digest}: ${err instanceof Error ? err.message : String(err)}` }));
+        }
+        const empty = isEmptyChangeSet(doc);
+        console.error(formatInfo(`release gate: ${what} ${doc.digest} for "${env}"` +
+            (empty ? ", empty: its gates pass without an approval" : `, ${doc.summary.entries} entr${doc.summary.entries === 1 ? "y" : "ies"}, ${doc.summary.holes} hole(s)`) +
+            ` (chant change-set show ${doc.digest})`));
+        if (empty) {
+            if (!port.appendResolution)
+                throw new Error("the gate ledger can't record a resolution, so an empty change set can't pass its gates");
+            const { resolutions } = await port.read(gate.RELEASE_GATE_OP);
+            const timestamp = new Date().toISOString();
+            for (const name of names) {
+                const standing = resolutions.some((r) => r.empty === true && r.gate === name && r.environment === env && r.releaseDigest === releaseDigest && r.planDigest === doc.digest);
+                if (standing)
+                    continue;
+                // Pushed with the resolution; the deploy records the promote writes push the same branch.
+                await port.appendResolution(gate.emptyResolution({ gate: name, doc, actor: input.actor, timestamp, ...(input.head ? { gitSha: input.head } : {}) }));
+            }
+        }
+        return { binding: { op: gate.RELEASE_GATE_OP, planDigest: doc.digest, releaseDigest, verifyEmpty }, empty };
+    };
+    const later = {
+        replan: async (only, outputs) => (await planSet(only, outputs)).doc,
+        bind: async (doc, names) => {
+            const bound = await bindDoc(doc, names, "a later plan");
+            if (typeof bound === "number")
+                throw new PromoteStageRefused();
+            return bound.binding;
         },
     };
+    // #4168 step 4: a resume plans what is left against the outputs it kept.
+    if (input.resume) {
+        const done = new Set(input.resume.completed);
+        const left = new Set(plan.items.map((i) => i.component).filter((c) => !done.has(c)));
+        const fresh = await planSet(left, { ...input.seededOutputs, ...input.resume.outputs });
+        const stored = await readStoredChangeSet(input.resume.approvedDigest, { cwd: input.projectPath });
+        if (stored.status === "found") {
+            const { waveNotCovered } = await import("../../components/pr-run.js");
+            const notCovered = waveNotCovered(stored.document, fresh.doc);
+            if (notCovered.length === 0) {
+                console.error(formatInfo(`resuming: ${done.size} component(s) applied earlier; what is left is covered by change set ${stored.document.digest}`));
+                return {
+                    doc: stored.document,
+                    empty: isEmptyChangeSet(stored.document),
+                    binding: { op: gate.RELEASE_GATE_OP, planDigest: stored.document.digest, releaseDigest, verifyEmpty },
+                    reads: fresh.reads,
+                    resumedFrom: stored.document.digest,
+                    ...(fresh.plannedOutputs ? { plannedOutputs: fresh.plannedOutputs } : {}),
+                    ...(fresh.unknownInputs ? { unknownInputs: fresh.unknownInputs } : {}),
+                    ...later,
+                };
+            }
+            for (const line of notCovered)
+                console.error(formatWarning({ message: `resume: ${line}` }));
+        }
+        const bound = await bindDoc(fresh.doc, gates, "change set");
+        if (typeof bound === "number")
+            return bound;
+        return { doc: fresh.doc, ...bound, reads: fresh.reads, ...(fresh.plannedOutputs ? { plannedOutputs: fresh.plannedOutputs } : {}), ...(fresh.unknownInputs ? { unknownInputs: fresh.unknownInputs } : {}), ...later };
+    }
+    const first = await planSet(undefined, input.seededOutputs);
+    const bound = await bindDoc(first.doc, gates, "change set");
+    if (typeof bound === "number")
+        return bound;
+    for (const [component, refs] of Object.entries(first.unknownInputs ?? {})) {
+        console.error(formatInfo(`${component} reads ${refs.join(", ")}, known only once its upstream applies; it is planned again then, and needs its own approval if its plan moves`));
+    }
+    return { doc: first.doc, ...bound, reads: first.reads, ...(first.plannedOutputs ? { plannedOutputs: first.plannedOutputs } : {}), ...(first.unknownInputs ? { unknownInputs: first.unknownInputs } : {}), ...later };
+}
+/** A later round's or wave's plan was refused (provisional or failed members); the refusal is already printed. */
+class PromoteStageRefused extends Error {
+    constructor() {
+        super("a later round's plan was refused");
+        this.name = "PromoteStageRefused";
+    }
+}
+/**
+ * The pull requests a release carries into `env` and how each was approved
+ * on merge (#4168 decision 2): shown beside the release gate, never counted
+ * by it. The commits are the release commit's first-parent history since
+ * the commits `env` runs, at most 200, read from the merge records.
+ */
+async function pullRequestApprovals(release, since, cwd) {
+    const { execFileSync } = await import("node:child_process");
+    const { readMergeRecord } = await import("../../lifecycle/merge-record.js");
+    let commits = [];
+    try {
+        const out = execFileSync("git", ["rev-list", "--first-parent", "--max-count=200", release.commit, ...since.map((c) => `^${c}`)], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        commits = out.split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const commit of commits) {
+        const record = await readMergeRecord(commit, { cwd }).catch(() => null);
+        if (record)
+            records.push(record);
+    }
+    return records;
+}
+/** One line per merge record: where it came from and how its plan stood against its approval. */
+function approvalLine(r) {
+    const from = r.source.kind === "pull-request" ? `#${r.source.pr}` : r.source.kind === "work-item" ? r.source.records.map((x) => `${x.kind}:${x.id}`).join(", ") : "direct push";
+    const how = r.plan === "approved"
+        ? `approved by ${r.approvedBy.join(", ") || "nobody named"}${r.authorApproved?.length ? ` (by its author: ${r.authorApproved.join(", ")})` : ""}`
+        : r.plan === "changed"
+            ? `its plan moved after the approval of ${r.approvedDigest ?? "another digest"}`
+            : r.plan;
+    return `${r.commit.slice(0, 12)} ${from}: ${how}`;
 }
 /**
  * Prepare, run and record a plan. Shared by promote, rollback and redeploy,
@@ -224,15 +323,21 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
     const prepared = [];
     const removed = new Map();
     const refusals = [];
+    // #4222: a component with no artifact, deployed from the templates the release records, and its record's digest.
+    const templateDigests = new Map();
+    const { releaseTemplatesDigest } = await import("../../components/release-promote.js");
     for (const item of plan.items) {
+        const templates = under ? releaseTemplatesDigest(under.target, item.component) : null;
         // A rollback and a redeploy deploy a release this environment already
         // received, so neither runs the publish step.
-        const result = withoutBuildSteps(byName.get(item.component), verb === "promote" ? {} : { pinDigest: item.digest, verb: `a ${verb}` });
+        const result = withoutBuildSteps(byName.get(item.component), { ...(verb === "promote" ? {} : { pinDigest: item.digest, verb: `a ${verb}` }), templatesPinned: templates !== null });
         if ("error" in result)
             refusals.push(result.error);
         else {
             prepared.push(result.component);
             removed.set(item.component, result.removed);
+            if (result.templateOnly && templates !== null)
+                templateDigests.set(item.component, templates);
         }
     }
     if (refusals.length > 0) {
@@ -319,16 +424,43 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
     // #4045: under a release, every gate binds the release's change set for this environment.
     let releaseGate;
     let changeSetJson;
+    let bound;
+    // #4168 step 4: a promote that stopped at a round's or a wave's gate left a resume record.
+    const rounds = await import("../../components/promote-rounds.js");
+    const resumePath = resolve(project.projectPath, args.resume ?? join(".chant", "promote", `${plan.to}.resume.json`));
+    let resume;
+    if (under && existsSync(resumePath)) {
+        try {
+            const record = JSON.parse(readFileSync(resumePath, "utf8"));
+            if (record.schema === rounds.PROMOTE_RESUME_SCHEMA && record.env === plan.to && record.releaseDigest === under.release.releaseDigest)
+                resume = record;
+            else if (args.resume)
+                console.error(formatWarning({ message: `--resume ${args.resume} is for another release or environment; planning from the start` }));
+        }
+        catch (err) {
+            console.error(formatWarning({ message: `could not read the resume record ${resumePath}: ${err instanceof Error ? err.message : String(err)}` }));
+        }
+    }
+    let pullRequests = [];
     if (under) {
         try {
-            const bound = await bindReleaseGate({ plan, prepared, under, registry, port, seededOutputs, actor: actor, projectPath: project.projectPath, head });
-            if (typeof bound === "number") {
+            const result = await bindReleaseGate({ plan, prepared, under, registry, port, seededOutputs, actor: actor, projectPath: project.projectPath, head, ...(resume ? { resume } : {}) });
+            if (typeof result === "number") {
                 tidy();
-                return bound;
+                return result;
             }
-            if (bound) {
-                releaseGate = bound.binding;
-                changeSetJson = { changeSet: bound.doc.digest, empty: bound.empty };
+            if (result) {
+                bound = result;
+                releaseGate = result.binding;
+                changeSetJson = { changeSet: result.doc.digest, empty: result.empty };
+                // #4168 decision 2: the pull requests' own approvals, shown beside the gate.
+                const since = [...new Set((await readLedger(plan.to)).filter((r) => r.env === plan.to).map((r) => r.gitSha))];
+                pullRequests = await pullRequestApprovals(under.release, since, project.projectPath);
+                if (pullRequests.length > 0 && !args.json) {
+                    console.error(formatInfo(`pull requests this release carries into "${plan.to}" (shown, not counted by the release gate):`));
+                    for (const r of pullRequests)
+                        console.error(`  ${approvalLine(r)}`);
+                }
             }
         }
         catch (err) {
@@ -336,6 +468,11 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
             throw err;
         }
     }
+    if (args.waveGate && !bound) {
+        console.error(formatError({ message: "--wave-gate needs a promote under --release whose compositions declare a gate", hint: PROMOTE_USAGE }));
+        tidy();
+        return 1;
+    }
     // The run id the release records carry, chosen before the run so that
     // `--events-json` (#4041) names the run by it too.
     const { runId, runOrigin } = resolveRunId(args.runId);
@@ -346,25 +483,88 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
         cwd: project.projectPath,
     });
     let run;
+    let staged;
+    // #4168 step 4: a wave at a time when a dependent read an upstream's plan,
+    // under --wave-gate, or on a resume; one run otherwise.
+    const inPlan = new Set(plan.items.map((i) => i.component));
+    const readsPlanned = bound?.plannedOutputs !== undefined && Object.keys(bound.plannedOutputs).some((d) => inPlan.has(d));
+    const inRounds = bound !== undefined && (readsPlanned || args.waveGate !== undefined || resume !== undefined);
     try {
-        run = await runPromotion({
-            plan,
-            components: prepared,
-            registry,
-            componentOutputs: seededOutputs,
-            gates: port,
-            ...(releaseGate ? { releaseGate } : {}),
-            ...(args.progressJson ? { onProgress: ndjsonProgressSink() } : {}),
-            ...(events ? { onRunEvent: events.emit } : {}),
-        });
+        if (inRounds && bound) {
+            staged = await rounds.runPromotionInRounds({
+                components: prepared,
+                outputs: { ...seededOutputs, ...(resume?.outputs ?? {}) },
+                binding: bound.binding,
+                approved: bound.doc,
+                reads: bound.reads,
+                ...(resume ? { completed: resume.completed } : {}),
+                ...(args.waveGate ? { waveGate: args.waveGate } : {}),
+                replan: bound.replan,
+                bind: bound.bind,
+                run: (components, outputs, binding) => runPromotion({
+                    plan: { ...plan, items: plan.items.filter((i) => components.some((c) => c.name === i.component)) },
+                    components,
+                    registry,
+                    componentOutputs: outputs,
+                    gates: port,
+                    releaseGate: binding,
+                    ...(args.progressJson ? { onProgress: ndjsonProgressSink() } : {}),
+                    ...(events ? { onRunEvent: events.emit } : {}),
+                }),
+            });
+            run = staged.run;
+        }
+        else {
+            run = await runPromotion({
+                plan,
+                components: prepared,
+                registry,
+                componentOutputs: seededOutputs,
+                gates: port,
+                ...(releaseGate ? { releaseGate } : {}),
+                ...(args.progressJson ? { onProgress: ndjsonProgressSink() } : {}),
+                ...(events ? { onRunEvent: events.emit } : {}),
+            });
+        }
     }
     catch (err) {
+        if (err instanceof PromoteStageRefused) {
+            events?.settle("failed", err.message);
+            return 1;
+        }
         events?.settle("failed", err instanceof Error ? err.message : String(err));
         throw err;
     }
     finally {
         tidy();
     }
+    if (staged && bound) {
+        for (const stage of staged.stages) {
+            const label = stage.kind === "round" ? `round ${stage.number}` : `wave ${stage.number}`;
+            console.error(formatInfo(`${label} (${stage.components.join(", ")}): planned again as ${stage.digest}, ${stage.status}`));
+            for (const line of stage.notCovered)
+                console.error(`  not covered by ${bound.doc.digest}: ${line}`);
+            if (stage.message)
+                console.error(formatError({ message: stage.message }));
+        }
+        if (run.status === "ok") {
+            rmSync(resumePath, { force: true });
+        }
+        else if (staged.completed.length > 0) {
+            const record = {
+                schema: rounds.PROMOTE_RESUME_SCHEMA,
+                env: plan.to,
+                releaseDigest: under.release.releaseDigest,
+                approvedDigest: resume?.approvedDigest ?? bound.resumedFrom ?? bound.doc.digest,
+                completed: staged.completed,
+                outputs: staged.outputs,
+                at: new Date().toISOString(),
+            };
+            mkdirSync(dirname(resumePath), { recursive: true });
+            writeFileSync(resumePath, `${JSON.stringify(record, null, 2)}\n`);
+            console.error(formatInfo(`resume record: ${resumePath}; the same promote carries on from here`));
+        }
+    }
     // The driver settles the stream; this only ends one it left open.
     events?.settle(run.status === "fail" ? "failed" : run.status);
     if (!args.json)
@@ -387,7 +587,8 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
                 const approver = gateApprover(result);
                 const admission = gateAdmission(result);
                 const input = record(item, plan.to, { runId, ...(runOrigin ? { runOrigin } : {}), actor: actor, timestamp, ...(approver ? { approver } : {}), ...(admission ? { admission } : {}) });
-                const { record: written } = await appendReleaseRecord(under ? { ...input, releaseDigest: under.release.releaseDigest } : input);
+                const templates = templateDigests.get(item.component);
+                const { record: written } = await appendReleaseRecord(under ? { ...input, ...(templates ? { digest: templates } : {}), releaseDigest: under.release.releaseDigest } : input);
                 recorded.push(written);
             }
             if (outcome)
@@ -400,7 +601,9 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
     }
     if (args.json) {
         const withChangeSet = under && changeSetJson ? { release: { ...releaseJson.release, ...changeSetJson } } : releaseJson;
-        console.log(JSON.stringify({ ...planJson(plan, removed), ...withChangeSet, run, recorded, ...(outcome ? { outcome } : {}) }, null, 2));
+        const stagedJson = staged ? { stages: staged.stages, ...(bound?.plannedOutputs ? { plannedOutputs: bound.plannedOutputs } : {}), ...(bound?.unknownInputs ? { unknownInputs: bound.unknownInputs } : {}) } : {};
+        const prJson = pullRequests.length > 0 ? { pullRequests: pullRequests.map((r) => ({ commit: r.commit, source: r.source, plan: r.plan, digest: r.digest, approvedBy: r.approvedBy, ...(r.authorApproved ? { authorApproved: r.authorApproved } : {}) })) } : {};
+        console.log(JSON.stringify({ ...planJson(plan, removed), ...withChangeSet, ...stagedJson, ...prJson, run, recorded, ...(outcome ? { outcome } : {}) }, null, 2));
     }
     else {
         for (const r of recorded) {
@@ -604,7 +807,7 @@ export async function runComponentsPromote(ctx) {
     const who = actorOrRefuse(ctx);
     if (typeof who === "number")
         return who;
-    const project = await loadProject(ctx, args.component ?? "all");
+    const project = await loadProject(ctx, args.component ?? "all", to);
     if (typeof project === "number")
         return project;
     // The member's `environments` array is its promotion order (#4030). It
@@ -686,7 +889,7 @@ export async function runComponentsRollback(ctx) {
         return who;
     if (args.release)
         return runReleaseRollback(ctx, env, args.release, who.actor);
-    const project = await loadProject(ctx, args.component);
+    const project = await loadProject(ctx, args.component, env);
     if (typeof project === "number")
         return project;
     await fetchLifecycle().catch(() => false);
@@ -716,7 +919,7 @@ export async function runComponentsRollback(ctx) {
  * runs now, as `promote --release` binds them (#4045).
  */
 async function runReleaseRollback(ctx, env, ref, actor) {
-    const project = await loadProject(ctx, "all");
+    const project = await loadProject(ctx, "all", env);
     if (typeof project === "number")
         return project;
     await fetchLifecycle().catch(() => false);
@@ -754,7 +957,7 @@ export async function runComponentsRedeploy(ctx) {
     const who = actorOrRefuse(ctx);
     if (typeof who === "number")
         return who;
-    const project = await loadProject(ctx, args.component);
+    const project = await loadProject(ctx, args.component, env);
     if (typeof project === "number")
         return project;
     await fetchLifecycle().catch(() => false);

package/dist/cli/handlers/release.d.ts

@@ -20,6 +20,11 @@
  *   release candidates [--env <env>] [--json]
  *       the green commits of trunk a release can be cut from, each with what it
  *       would ship, and what each environment runs (#4168 4.2)
+ *   release compose <name> [--base <label|sha>] (--pr <n> | --work <id>)... [--yes] [--json]
+ *       pick chosen trunk changes onto a base, each with a Chant-Composed-From
+ *       trailer, on the pushed branch chant/compose/<name> (#4168 4.3); a dry
+ *       run unless --yes. `release cut` takes a green commit of that branch,
+ *       and `--channel <tag>` makes its publish move that tag, not latest
  *   release list [--json]
  *       every release of this member with its targets, its cuts and where it runs;
  *       `--json` prints the read contract's `releases` document
@@ -103,4 +108,11 @@ export declare function runReleaseExport(ctx: CommandContext): Promise<number>;
 /** Internal: compile one environment, or build artifacts, in this process, and print the JSON the cut reads. */
 export declare function runReleaseCompile(ctx: CommandContext): Promise<number>;
 export declare function runReleaseUnknown(ctx: CommandContext): Promise<number>;
+/**
+ * `release compose <name> [--base <label|sha>] (--pr <n> | --work <id>)... [--yes] [--json]`
+ * (#4168 4.3): pick the chosen trunk changes onto a base, on
+ * `chant/compose/<name>` (../../lifecycle/release-compose.ts). A dry run
+ * unless `--yes`, which moves the branch and pushes it so CI builds it.
+ */
+export declare function runReleaseCompose(ctx: CommandContext): Promise<number>;
 //# sourceMappingURL=release.d.ts.map

package/dist/cli/handlers/release.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/release.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAOH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAyBlD,0HAA0H;AAC1H,wBAAgB,YAAY,CAAC,GAAG,EAAE;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,uFAAuF;IACvF,YAAY,EAAE,OAAO,CAAC;CACvB,GAAG,MAAM,EAAE,CASX;AAED,wGAAwG;AACxG,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAG3D;AAiBD;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAwNxE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA2G5E;AAQD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAkC3E;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAiC/E;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8BzE;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAyC3E;AAED,gHAAgH;AAChH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAsB5E;AAED,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAG5E"}
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/release.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAOH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAyBlD,0HAA0H;AAC1H,wBAAgB,YAAY,CAAC,GAAG,EAAE;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,uFAAuF;IACvF,YAAY,EAAE,OAAO,CAAC;CACvB,GAAG,MAAM,EAAE,CASX;AAED,wGAAwG;AACxG,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAG3D;AAiBD;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAqPxE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA4G5E;AAQD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAkC3E;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAsC/E;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8BzE;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAyC3E;AAED,gHAAgH;AAChH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAsB5E;AAED,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAG5E;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAsD5E"}