@intentius/chant 0.124.28 → 0.124.30

package/dist/cli/handlers/promote.js

@@ -12,6 +12,13 @@
  * failed or stopped at a gate, so the ledger never misses a deploy that
  * happened. Unlike an auto-recorded release, the record is what these
  * commands are for, so a failed write is an error rather than a warning.
+ * A run that applied partly, or failed, also appends a deploy outcome
+ * (#4035, ../../lifecycle/deploy-outcome.ts) naming what it did to each
+ * component, so `workspace status` reads the environment as mixed.
+ *
+ * `rollback --release` (#4035) is a promote of an earlier release into the
+ * 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";
@@ -26,14 +33,15 @@ import { fanOutRegistry } from "../../components/fan-out-support.js";
 import { renderDriverHuman } from "../../components/driver-output.js";
 import { ndjsonProgressSink } from "../../components/run-progress.js";
 import { openCliRunEvents, refusesBothStreams } from "../run-events.js";
-import { parseDigestPins, planPromotion, planRollback, planRedeploy, withoutBuildSteps, runPromotion, promotionRecord, rollbackRecord, redeployRecord, gateApprover, gateAdmission, } from "../../components/promote.js";
+import { parseDigestPins, planPromotion, planRollback, planReleaseRollback, planRedeploy, withoutBuildSteps, runPromotion, promotionRecord, rollbackRecord, redeployRecord, gateApprover, gateAdmission, } from "../../components/promote.js";
 import { summaryLedgerPrefix, writeGatedRunSummary } from "../../op/gate-summary.js";
 import { approveCommand, describeGateMismatch, gateIsSealed, gitGateLedgerPort } from "../../op/gate.js";
 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 ROLLBACK_USAGE = "chant components rollback <env> --component <name> [--digest <sha256:...>] [--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) {
     console.error(formatBold(verb === "promote" ? `promote ${plan.from} -> ${plan.to}` : `${verb} ${plan.to}`));
@@ -117,7 +125,8 @@ async function bindReleaseGate(input) {
     const releaseDigest = under.release.releaseDigest;
     // What the environment runs now, to compare each component with.
     const { readRelease } = await import("../../lifecycle/release-store.js");
-    const latest = latestPerComponent((await readLedger(env)).filter((r) => r.env === env));
+    const envRecords = (await readLedger(env)).filter((r) => r.env === env);
+    const latest = latestPerComponent(envRecords);
     const releases = new Map();
     const current = new Map();
     for (const item of plan.items) {
@@ -129,6 +138,12 @@ async function bindReleaseGate(input) {
             releases.set(named, await readRelease(named).catch(() => null));
         current.set(item.component, { record, release: named !== undefined ? (releases.get(named) ?? null) : null });
     }
+    // #4035: a component a run left failed or gated runs something the ledger doesn't say.
+    const { readDeployOutcomes } = await import("../../lifecycle/deploy-outcome.js");
+    const unsettled = new Map();
+    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({
         release: under.release,
         env,
@@ -136,6 +151,7 @@ async function bindReleaseGate(input) {
         digests: new Map(plan.items.map((i) => [i.component, i.digest])),
         registry: input.registry,
         current,
+        unsettled,
         seededOutputs: input.seededOutputs,
     });
     const provisional = gate.provisionalMembers(doc);
@@ -359,7 +375,11 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
     const timestamp = new Date().toISOString();
     const recorded = [];
     let recordError;
-    if (deployed.length > 0) {
+    // #4035: a run that applied partly, or failed, records what it did to each
+    // component, so the environment reads as mixed until it is settled.
+    const { deployOutcomeOf, appendDeployOutcome } = await import("../../lifecycle/deploy-outcome.js");
+    const outcome = deployOutcomeOf({ verb, plan, run, releaseDigest: under?.release.releaseDigest ?? null, runId, timestamp, actor: actor });
+    if (deployed.length > 0 || outcome) {
         try {
             for (const item of deployed) {
                 const result = run.results.find((r) => r.component === item.component);
@@ -369,6 +389,8 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
                 const { record: written } = await appendReleaseRecord(under ? { ...input, releaseDigest: under.release.releaseDigest } : input);
                 recorded.push(written);
             }
+            if (outcome)
+                await appendDeployOutcome(outcome);
             await pushLifecycle();
         }
         catch (err) {
@@ -377,7 +399,7 @@ 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 }, null, 2));
+        console.log(JSON.stringify({ ...planJson(plan, removed), ...withChangeSet, run, recorded, ...(outcome ? { outcome } : {}) }, null, 2));
     }
     else {
         for (const r of recorded) {
@@ -388,9 +410,20 @@ async function deployPlan(ctx, verb, plan, project, actor, record, under) {
                     : `Redeployed ${formatBold(r.component)} in ${plan.to} at ${r.digest}`));
         }
     }
+    if (outcome && recordError === undefined) {
+        const unsettled = outcome.components.filter((c) => c.outcome === "failed" || c.outcome === "gated");
+        console.error(formatWarning({
+            message: `"${plan.to}" now runs a mix: ${outcome.components.map((c) => `${c.component} ${c.outcome}`).join(", ")}. ` +
+                `chant workspace status ${plan.to} --json lists what each component runs and the rollback line`,
+        }));
+        for (const c of unsettled)
+            console.error(formatInfo(`settle ${c.component}: ${redeployLine(plan.to, c.component)}, or run the same ${verb} again`));
+    }
     if (recordError !== undefined) {
         console.error(formatError({
-            message: `deployed to "${plan.to}", but the release record was not written: ${recordError}`,
+            message: deployed.length > 0
+                ? `deployed to "${plan.to}", but the release record was not written: ${recordError}`
+                : `the outcome of the ${verb} in "${plan.to}" was not written: ${recordError}`,
             hint: `Pull the chant/lifecycle branch and check \`chant components status ${plan.to}\` before running this again.`,
         }));
         return 1;
@@ -436,6 +469,114 @@ function actorOrRefuse(ctx) {
     }
     return { actor };
 }
+/** The revoked commits, or the exit code of a refusal already printed when the ci tags can't be judged (#4033). */
+async function revokedOrRefuse(what) {
+    const { readRevokedCommits } = await import("../../lifecycle/release-revocation.js");
+    try {
+        return await readRevokedCommits(process.cwd());
+    }
+    catch (err) {
+        console.error(formatError({
+            message: `the ci tags can't be judged, so whether ${what} is revoked is unknown: ${err instanceof Error ? err.message : String(err)} [declaration-invalid]`,
+            hint: "Fix ci.green in chant.workspace.json at base; chant workspace check names the problem.",
+        }));
+        return 1;
+    }
+}
+/**
+ * Resolve `--release` for a promote or a rollback to `env` (#4026, #4035):
+ * the release, its label and its target for `env`. Refused, with the exit
+ * code returned, when the release can't be found, has no target for `env`,
+ * is of a project with no components (#4046), or was cut from a revoked
+ * commit (#4033), so a gate pending for it can't pass.
+ */
+async function resolveUnderRelease(ref, env, verb, fix) {
+    const { resolveRelease } = await import("../../lifecycle/release-store.js");
+    const { targetFor, isImplicitRelease } = await import("../../components/release-promote.js");
+    const found = await resolveRelease(ref);
+    if (!found) {
+        console.error(formatError({ message: `no release is labelled or digested "${ref}" in this member`, hint: "List them with: chant release list" }));
+        return 1;
+    }
+    const target = targetFor(found.release, env);
+    if ("error" in target) {
+        console.error(formatError({ message: target.error }));
+        return 1;
+    }
+    // #4046: a release of a project with no components records build output
+    // and no component, so there is no deploy step here to point at it.
+    if (isImplicitRelease(found.release)) {
+        const name = found.label ?? found.release.releaseDigest;
+        console.error(formatError({
+            message: `release ${name} is of a project with no components, so ${verb} has no component to deploy`,
+            hint: `Write its "${env}" build output with \`chant release export ${name} --env ${env}\`, then run the project's own deploy against those files.`,
+        }));
+        return 1;
+    }
+    // #4033 (ws-105): a release cut from a revoked commit is never deployed,
+    // so a gate pending for it can't pass. Read from local tags, as the cut reads them.
+    const revoked = await revokedOrRefuse(`release ${found.label ?? found.release.releaseDigest}`);
+    if (typeof revoked === "number")
+        return revoked;
+    const { revocationOf, revokedRefusal } = await import("../../lifecycle/release-revocation.js");
+    const revocation = revocationOf(found.release, revoked);
+    if (revocation) {
+        console.error(formatError(revokedRefusal({ releaseDigest: found.release.releaseDigest, label: found.label }, revocation, await fix(found.release))));
+        return 1;
+    }
+    return { release: found.release, label: found.label, target: target.target };
+}
+/**
+ * The line that rolls `env` back past `exclude` (#4035): to the newest
+ * release in its ledger that is still kept and not revoked, by label, or
+ * null when there is none.
+ */
+async function rollbackLineFor(env, records, exclude, revoked) {
+    const { readRelease, readCuts, labelsByDigest } = await import("../../lifecycle/release-store.js");
+    const { revocationOf } = await import("../../lifecycle/release-revocation.js");
+    const target = await rollbackTarget({
+        records,
+        exclude,
+        check: async (digest) => {
+            const release = await readRelease(digest).catch(() => null);
+            return { kept: release !== null, revoked: release !== null && revocationOf(release, revoked) !== null };
+        },
+    });
+    if (!target)
+        return null;
+    const labels = await readCuts().then((c) => labelsByDigest(c.cuts), () => new Map());
+    return releaseRollbackLine(env, target, labels.get(target));
+}
+/**
+ * Refuse a rollback or a redeploy that would put back a release cut from a
+ * revoked commit (#4033, #4035), naming the release to go back to instead.
+ * Returns the exit code of the refusal, or undefined when nothing restored
+ * names a revoked release.
+ */
+async function refuseRevokedRestore(verb, plan, records) {
+    const named = [...new Set(plan.items.map((i) => i.source.releaseDigest).filter((d) => d !== undefined))];
+    if (named.length === 0)
+        return undefined;
+    const revoked = await revokedOrRefuse(`the release this ${verb} restores`);
+    if (typeof revoked === "number")
+        return revoked;
+    if (revoked.size === 0)
+        return undefined;
+    const { readRelease, readCuts, labelsByDigest } = await import("../../lifecycle/release-store.js");
+    const { revocationOf, revokedRefusal } = await import("../../lifecycle/release-revocation.js");
+    for (const digest of named) {
+        const release = await readRelease(digest).catch(() => null);
+        const revocation = release ? revocationOf(release, revoked) : null;
+        if (!revocation)
+            continue;
+        const labels = await readCuts().then((c) => labelsByDigest(c.cuts), () => new Map());
+        const back = await rollbackLineFor(plan.to, records, new Set([digest]), revoked);
+        console.error(formatError(revokedRefusal({ releaseDigest: digest, label: labels.get(digest) ?? null }, revocation, back ? `Restore a release cut from a green commit instead: ${back}` : `No other release "${plan.to}" ran is kept and green; promote a release cut from a green commit (\`chant ci last-green\` names the newest).`)));
+        console.error(formatError({ message: "nothing was deployed" }));
+        return 1;
+    }
+    return undefined;
+}
 export async function runComponentsPromote(ctx) {
     const { args } = ctx;
     const to = args.migrateTo;
@@ -488,29 +629,10 @@ export async function runComponentsPromote(ctx) {
     // #4026: --release names the release this promote deploys, by label or digest.
     let under;
     if (args.release) {
-        const { resolveRelease } = await import("../../lifecycle/release-store.js");
-        const { targetFor, isImplicitRelease } = await import("../../components/release-promote.js");
-        const found = await resolveRelease(args.release);
-        if (!found) {
-            console.error(formatError({ message: `no release is labelled or digested "${args.release}" in this member`, hint: "List them with: chant release list" }));
-            return 1;
-        }
-        const target = targetFor(found.release, to);
-        if ("error" in target) {
-            console.error(formatError({ message: target.error }));
-            return 1;
-        }
-        // #4046: a release of a project with no components records build output
-        // and no component, so there is no deploy step here to point at it.
-        if (isImplicitRelease(found.release)) {
-            const name = found.label ?? found.release.releaseDigest;
-            console.error(formatError({
-                message: `release ${name} is of a project with no components, so promote has no component to deploy`,
-                hint: `Write its "${to}" build output with \`chant release export ${name} --env ${to}\`, then run the project's own deploy against those files.`,
-            }));
-            return 1;
-        }
-        under = { release: found.release, label: found.label, target: target.target };
+        const found = await resolveUnderRelease(args.release, to, "promote", () => "Promote a release cut from a green commit: `chant ci last-green` names the newest, and `chant release list` marks the revoked releases. Fetch the tags first: git fetch origin --tags");
+        if (typeof found === "number")
+            return found;
+        under = found;
     }
     const plan = planPromotion({
         from,
@@ -530,20 +652,31 @@ export async function runComponentsPromote(ctx) {
 export async function runComponentsRollback(ctx) {
     const { args } = ctx;
     const env = args.extraPositional;
-    if (!env || !args.component) {
-        console.error(formatError({ message: "an environment and --component <name> are required", hint: ROLLBACK_USAGE }));
+    if (!env || (!args.component && !args.release)) {
+        console.error(formatError({ message: "an environment and --component <name> or --release <label|digest> are required", hint: ROLLBACK_USAGE }));
+        return 1;
+    }
+    if (args.component && args.release) {
+        console.error(formatError({ message: "--release rolls back every component of a release, so it does not take --component", hint: ROLLBACK_USAGE }));
+        return 1;
+    }
+    if (args.release && args.digest) {
+        console.error(formatError({ message: "--digest picks one release of one component, so it needs --component, not --release", hint: ROLLBACK_USAGE }));
         return 1;
     }
     const who = actorOrRefuse(ctx);
     if (typeof who === "number")
         return who;
+    if (args.release)
+        return runReleaseRollback(ctx, env, args.release, who.actor);
     const project = await loadProject(ctx, args.component);
     if (typeof project === "number")
         return project;
     await fetchLifecycle().catch(() => false);
+    const records = await readLedger(env);
     const plan = planRollback({
         env,
-        records: await readLedger(env),
+        records,
         declared: project.targets.map((c) => c.name),
         component: args.component,
         ...(args.digest ? { digest: args.digest } : {}),
@@ -552,8 +685,48 @@ export async function runComponentsRollback(ctx) {
         console.error(formatError({ message: plan.error, hint: ROLLBACK_USAGE }));
         return 1;
     }
+    const refused = await refuseRevokedRestore("rollback", plan, records);
+    if (refused !== undefined)
+        return refused;
     return deployPlan(ctx, "rollback", plan, project, who.actor, rollbackRecord);
 }
+/**
+ * `chant components rollback <env> --release <label|digest>` (#4035): a
+ * gated promote of an earlier release into `env`. Every component of the
+ * release is restored at the digest `env` recorded running it from that
+ * release, its deploy reads the templates the release recorded for `env`,
+ * and its gates bind the release's change set planned against what `env`
+ * runs now, as `promote --release` binds them (#4045).
+ */
+async function runReleaseRollback(ctx, env, ref, actor) {
+    const project = await loadProject(ctx, "all");
+    if (typeof project === "number")
+        return project;
+    await fetchLifecycle().catch(() => false);
+    const records = await readLedger(env);
+    const under = await resolveUnderRelease(ref, env, "rollback", async (release) => {
+        const revoked = await revokedOrRefuse("the release before it").then((r) => (typeof r === "number" ? new Map() : r));
+        const back = await rollbackLineFor(env, records, new Set([release.releaseDigest]), revoked);
+        return back ? `Roll back to a release cut from a green commit: ${back}` : "Roll back to a release cut from a green commit; `chant release list` marks the revoked releases.";
+    });
+    if (typeof under === "number")
+        return under;
+    const { readDeployOutcomes } = await import("../../lifecycle/deploy-outcome.js");
+    const outcomes = await readDeployOutcomes(env).catch(() => []);
+    const plan = planReleaseRollback({
+        env,
+        records,
+        declared: project.targets.map((c) => c.name),
+        release: under.release,
+        label: under.label,
+        unsettled: new Set(unsettledComponents(records, outcomes).keys()),
+    });
+    if ("error" in plan) {
+        console.error(formatError({ message: plan.error, hint: ROLLBACK_USAGE }));
+        return 1;
+    }
+    return deployPlan(ctx, "rollback", plan, project, actor, rollbackRecord, under);
+}
 export async function runComponentsRedeploy(ctx) {
     const { args } = ctx;
     const env = args.extraPositional;
@@ -568,9 +741,10 @@ export async function runComponentsRedeploy(ctx) {
     if (typeof project === "number")
         return project;
     await fetchLifecycle().catch(() => false);
+    const records = await readLedger(env);
     const plan = planRedeploy({
         env,
-        records: await readLedger(env),
+        records,
         declared: project.targets.map((c) => c.name),
         component: args.component,
         ...(args.digest ? { digest: args.digest } : {}),
@@ -579,5 +753,8 @@ export async function runComponentsRedeploy(ctx) {
         console.error(formatError({ message: plan.error, hint: REDEPLOY_USAGE }));
         return 1;
     }
+    const refused = await refuseRevokedRestore("redeploy", plan, records);
+    if (refused !== undefined)
+        return refused;
     return deployPlan(ctx, "redeploy", plan, project, who.actor, redeployRecord);
 }

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

@@ -1,10 +1,22 @@
 /**
  * `chant release` (#4026, ws-104): the release is what graduates.
  *
- *   release cut [<label>] [--build <command>] [--param k=v]... [--params-file <file>] [--src <dir>] [-o <file>] [--lexicon <name>] [--actor <name>] [--sign [<key file>]] [--json]
- *       cut a release of this member from the checkout's HEAD, which must be green;
+ *   release cut [<label>] [--yes] [--build <command>] [--param k=v]... [--params-file <file>] [--src <dir>] [-o <file>] [--lexicon <name>] [--actor <name>] [--sign [<key file>]] [--json]
+ *       a dry run of a cut of this member from the checkout's HEAD, which must be
+ *       clean, on trunk and pushed, and green (#4027); `--yes` cuts, records,
+ *       and tags the commit `release/<label>` locally;
  *       --sign signs the cut with the actor's ssh key (#4031); `--src`, `-o` and
  *       `--lexicon` shape the build of a project with no components (#4046)
+ *   release publish <label|digest> [--yes] [--allow-unsigned] [--require-provenance] [--json]
+ *       publish a cut release (#4027) to the targets release.publish declares
+ *       (#4047): a dry run unless --yes; refuses a revoked one, one with no
+ *       signature that verifies against .chant/allowed_signers unless
+ *       --allow-unsigned (#4049), and with a target a checkout that is not
+ *       the release's commit; warns with no OIDC provenance, and refuses
+ *       under --require-provenance; attaches SBOMs and provenance (#4049)
+ *   release verify <label|digest> [--json]
+ *       check the release's signature offline against .chant/allowed_signers
+ *       at the release's commit (#4049)
  *   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
@@ -13,12 +25,57 @@
  *   release compile --env <env> [--build <command>] [--artifacts --component <a,b>] --json
  *       internal: what the cut runs in a child process per environment
  *
- * The workstation UX for `cut` grows in #4027. A declaration whose
- * `identity.gates` names a `release` gate requires a signed cut by an actor
- * in its class (#4031).
+ * The workstation checks, the actor and the tag are in
+ * ../../lifecycle/release-workstation.ts, and the publish contract in
+ * ../../lifecycle/release-publish.ts. A declaration whose `identity.gates`
+ * names a `release` gate requires a signed cut by an actor in its class (#4031).
  */
 import type { CommandContext } from "../registry.js";
+/** What to run after a cut (#4027): publish from CI, or push the tag so CI publishes, or deploy the first environment. */
+export declare function nextCommands(req: {
+    ref: string;
+    tag: string | null;
+    inCi: boolean;
+    firstEnv: string | null;
+    /** A project with no components deploys with `release export`, not promote (#4046). */
+    noComponents: boolean;
+}): string[];
+/** The command line that ran, without `--json`, with `--yes` added: what a dry run says to run next. */
+export declare function sameWithYes(argv: readonly string[]): string;
+/**
+ * `release cut [<label>]` (#4026, #4027). A dry run unless `--yes`: it
+ * refuses a dirty tree, a commit that is not on trunk and pushed, and one
+ * that is not green, compiles every environment, and prints what the cut
+ * would record, build and tag, and what publishes where. With `--yes` it
+ * cuts, signs with `--sign`, records the cut with its actor and run id,
+ * tags the commit locally and prints the next command.
+ */
 export declare function runReleaseCut(ctx: CommandContext): Promise<number>;
+/**
+ * `release publish <label|digest> [--yes]` (#4027, #4047): publish a cut
+ * release to the targets the member declares under `release.publish` in
+ * its `chant.config.ts`. It refuses a release no cut names, one cut from a
+ * revoked commit, one with no signature that verifies against the signers
+ * file at base unless `--allow-unsigned` (#4049; never under
+ * identity.gates.release), and, when there is a target, a checkout that is
+ * not the release's commit with a clean tree. It warns before publishing
+ * when the run has no OIDC token, so what it publishes carries no
+ * provenance, and refuses under `--require-provenance`. Each target attaches
+ * an SBOM and the release's provenance statement (#4049). Every
+ * target is planned (its files read and checked, its credentials found)
+ * before any publishes. Without `--yes` it is a dry run that prints the plan
+ * and uploads nothing. With `--yes` it stages every target, then reveals them
+ * (#4048, `runPublish`), recording each step in `_releases/publishes.jsonl`,
+ * so running it again after a failure resumes. Every line is redacted.
+ */
+export declare function runReleasePublish(ctx: CommandContext): Promise<number>;
+/**
+ * `release verify <label|digest> [--json]` (#4049): check, offline, that the
+ * release was signed by a key `.chant/allowed_signers` lists at the release's
+ * commit, and that its file is the digest of what it holds. Exits 0 when it
+ * verifies and 1 when it does not or can't be checked.
+ */
+export declare function runReleaseVerify(ctx: CommandContext): Promise<number>;
 export declare function runReleaseList(ctx: CommandContext): Promise<number>;
 /**
  * `release export <label|digest> --env <env> [-o <dir>]` (#4046): write each

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;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAuBlD,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAoDxE;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBzE;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAOH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAmBlD,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;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAyMxE;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,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"}