@intentius/chant 0.124.27 → 0.124.29

package/dist/components/release-compile.js

@@ -0,0 +1,382 @@
+/**
+ * Compiling a release (#4026, ws-104 question 5): what one environment
+ * compiles to, and the artifacts built once.
+ *
+ * A template is synthesized for one environment per invocation: `--env` sets
+ * `CHANT_ENV` before the project is imported, and `*.component.ts` files are
+ * imported with a plain `import()`, which caches the module. So each
+ * environment is compiled in a child process of its own
+ * ({@link spawnTargetCompiler}), running `chant release compile --env <env>`,
+ * which calls {@link compileEnvironment} in that process and prints the
+ * result as JSON. The artifacts are built in one more child, for the first
+ * environment in which each component is enabled ({@link buildReleaseArtifacts}).
+ *
+ * What counts as a template is data, as the build and publish kinds are in
+ * ./promote.ts: a literal path in a deploy step's `template`, `manifest` or
+ * `values` field ({@link TEMPLATE_FIELDS}), read after the environment's build
+ * command has run. A path with the `archive:` prefix names the file after it.
+ * A path that names a directory, such as a chart, is not a template.
+ *
+ * A project with no components (#4046) is compiled the way `chant build --env
+ * <env> -o <output>` builds it ({@link compileBuildOutput}): every file that
+ * build writes is a template with `component: null`, and the target's params
+ * are the build's `buildParams`. The files are kept in memory rather than read
+ * back from disk, so a file an earlier build left behind is never recorded.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { loadChantConfig } from "../config.js";
+import { resolveFlaggedBuildParams } from "../flag-params.js";
+import { discoverComponents } from "./discover.js";
+import { withoutDisabled } from "./cli-support.js";
+import { applyConfigDefaults } from "./config-defaults.js";
+import { fanOutRegistry } from "./fan-out-support.js";
+import { ARCHIVE_STEP_KINDS, BUILD_STEP_KINDS, PUBLISH_STEP_KINDS } from "./promote.js";
+import { DriverRunFailure, runInterpretDriver } from "./driver.js";
+import { memoryGateLedgerPort } from "../op/gate.js";
+/** The deploy step fields whose literal file paths are a component's templates. */
+export const TEMPLATE_FIELDS = ["template", "manifest", "values"];
+/** The prefix a step may write before an archive-relative template path. */
+const ARCHIVE_PREFIX = "archive:";
+function isGate(step) {
+    return step.kind === "gate";
+}
+function isPhase(step) {
+    return typeof step.phase === "string" && Array.isArray(step.steps);
+}
+/** Every step of a composition with the phase it sits in, nested phases included, in order. */
+function stepsOf(phases) {
+    const out = [];
+    const walk = (phase) => {
+        for (const step of phase.steps) {
+            if (isPhase(step))
+                walk(step);
+            else if (!isGate(step))
+                out.push({ phase: phase.phase, step });
+        }
+    };
+    phases.forEach(walk);
+    return out;
+}
+const isLiteralPath = (v) => typeof v === "string" && v !== "" && !v.startsWith("@") && !v.startsWith("$");
+/** The templates a component's deploy reads: literal paths in {@link TEMPLATE_FIELDS} of its steps other than build and publish steps. */
+export function templateRefs(component) {
+    const out = [];
+    for (const { phase, step } of stepsOf(component.deploy)) {
+        if (BUILD_STEP_KINDS.includes(step.kind) || PUBLISH_STEP_KINDS.includes(step.kind))
+            continue;
+        for (const field of TEMPLATE_FIELDS) {
+            const raw = step[field];
+            const values = Array.isArray(raw) ? raw : [raw];
+            for (const value of values) {
+                if (!isLiteralPath(value))
+                    continue;
+                const path = value.startsWith(ARCHIVE_PREFIX) ? value.slice(ARCHIVE_PREFIX.length) : value;
+                out.push({ component: component.name, phase, kind: step.kind, field, value, path });
+            }
+        }
+    }
+    return out;
+}
+/** A component's build-time steps ({@link BUILD_STEP_KINDS}), each as declared, in composition order. */
+export function buildStepsOf(component) {
+    return stepsOf(component.deploy).map((s) => s.step).filter((s) => BUILD_STEP_KINDS.includes(s.kind));
+}
+/** A component's publish steps ({@link PUBLISH_STEP_KINDS}), each as declared, in composition order. */
+export function publishStepsOf(component) {
+    return stepsOf(component.deploy).map((s) => s.step).filter((s) => PUBLISH_STEP_KINDS.includes(s.kind));
+}
+/** The literal paths a component's archive steps read: `docker-build`'s `context` and `dockerfile`, `zip-package`'s `source`, `jvm-build`'s `path`. */
+export function buildInputPaths(component) {
+    const out = [];
+    for (const step of buildStepsOf(component)) {
+        if (step.kind === "docker-build") {
+            if (isLiteralPath(step.context)) {
+                out.push(step.context);
+                out.push(isLiteralPath(step.dockerfile) ? `${step.context}/${step.dockerfile}` : `${step.context}/Dockerfile`);
+            }
+        }
+        else if (step.kind === "zip-package" && isLiteralPath(step.source))
+            out.push(step.source);
+        else if (step.kind === "jvm-build" && isLiteralPath(step.path))
+            out.push(step.path);
+    }
+    return [...new Set(out)];
+}
+/** A component's composition with only its archive steps ({@link ARCHIVE_STEP_KINDS}) left, gates and every other step taken out. */
+export function withOnlyArchiveSteps(component) {
+    const keep = (phase) => {
+        const steps = [];
+        for (const step of phase.steps) {
+            if (isPhase(step)) {
+                const nested = keep(step);
+                if (nested)
+                    steps.push(nested);
+            }
+            else if (!isGate(step) && ARCHIVE_STEP_KINDS.includes(step.kind))
+                steps.push(step);
+        }
+        return steps.length > 0 ? { phase: phase.phase, steps } : undefined;
+    };
+    const deploy = component.deploy.map(keep).filter((p) => p !== undefined);
+    return deploy.length > 0 ? { name: component.name, dependsOn: [], deploy } : undefined;
+}
+/**
+ * Where a project with no components writes its build output when the cut
+ * names no `-o`. YAML, since the k8s and helm serializers write YAML whatever
+ * the extension, and a JSON output converts to it.
+ */
+export const DEFAULT_BUILD_OUTPUT = "dist/build.yaml";
+/** Thrown when an environment can't be compiled. */
+export class ReleaseCompileError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ReleaseCompileError";
+    }
+}
+async function loadComponents(inputs, env) {
+    const { config } = await loadChantConfig(inputs.projectDir).catch(() => ({ config: {} }));
+    // #4024: a workspace member's flag records back their parameters, so a flag's value is a param with source flag:<name>.
+    const resolved = await resolveFlaggedBuildParams(inputs.projectDir, config.buildParams, {
+        ...(inputs.params ? { cli: inputs.params } : {}),
+        ...(inputs.paramsFile ? { paramsFile: inputs.paramsFile.replaceAll("{env}", env) } : {}),
+    }, env);
+    if (!resolved.success)
+        throw new ReleaseCompileError(`build parameters for "${env}" did not resolve:\n${resolved.errors.join("\n")}`);
+    const discovered = await discoverComponents(inputs.projectDir, { buildParams: resolved.provenance });
+    if (discovered.errors.length > 0)
+        throw new ReleaseCompileError(discovered.errors.map((e) => e.message).join("\n"));
+    const all = [...discovered.components.values()];
+    const plain = all.map(({ component }) => ({
+        name: component.name,
+        dependsOn: component.dependsOn,
+        deploy: component.deploy,
+        ...(component.rollback ? { rollback: component.rollback } : {}),
+    }));
+    const enabled = withoutDisabled(all.map((d) => d.component), plain);
+    const fileOf = new Map(all.map((d) => [d.component.name, d.filePath]));
+    return {
+        config,
+        params: resolved.provenance.map(({ name, value, source }) => ({ name, value, source })),
+        declared: all.length,
+        components: enabled.map((c) => ({ component: applyConfigDefaults(c, config), file: fileOf.get(c.name) })),
+    };
+}
+/**
+ * Compile the member for `env` in this process: run the build command, resolve
+ * the build parameters, discover the components enabled under them, and read
+ * the templates their deploys name. Call it once per process, with
+ * `CHANT_ENV` already set to `env`, since component modules are cached.
+ */
+export async function compileEnvironment(inputs, env) {
+    if (inputs.buildCommand) {
+        const run = spawnSync(inputs.buildCommand, {
+            cwd: inputs.projectDir,
+            shell: true,
+            stdio: ["ignore", 2, 2],
+            env: { ...process.env, CHANT_ENV: env },
+        });
+        if (run.status !== 0)
+            throw new ReleaseCompileError(`the build command for "${env}" exited ${run.status ?? "with a signal"}: ${inputs.buildCommand}`);
+    }
+    const { config, params, declared, components } = await loadComponents(inputs, env);
+    if (declared === 0)
+        return compileBuildOutput(inputs, env, config);
+    const rel = (p) => (isAbsolute(p) ? relative(inputs.projectDir, p) : p);
+    const templates = [];
+    const seen = new Set();
+    for (const { component } of components) {
+        for (const ref of templateRefs(component)) {
+            const key = `${ref.component}\u0000${ref.path}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const file = resolve(inputs.projectDir, ref.path);
+            if (!existsSync(file)) {
+                throw new ReleaseCompileError(`component "${ref.component}": its ${ref.kind} step in phase "${ref.phase}" reads ${ref.field} "${ref.value}", ` +
+                    `and no such file exists after the build for "${env}"`);
+            }
+            if (!statSync(file).isFile())
+                continue;
+            templates.push({ component: ref.component, path: ref.path, content: readFileSync(file, "utf-8") });
+        }
+    }
+    return {
+        env,
+        params,
+        components: components.map((c) => c.component.name),
+        buildSteps: Object.fromEntries(components.map(({ component }) => [component.name, buildStepsOf(component)])),
+        publishSteps: Object.fromEntries(components.map(({ component }) => [component.name, publishStepsOf(component)])),
+        buildInputs: Object.fromEntries(components.map(({ component }) => [component.name, buildInputPaths(component)])),
+        componentFiles: Object.fromEntries(components.map(({ component, file }) => [component.name, rel(file)])),
+        templates,
+    };
+}
+/**
+ * Compile a project with no components for `env` (#4046, ws-104 question 5):
+ * build it as `chant build <src> --env <env> -o <output>` would, and record
+ * each file that build writes as a template with `component: null`, by its
+ * path relative to the member's directory. The params are the build's own
+ * `buildParams`. Nothing is written to disk.
+ */
+export async function compileBuildOutput(inputs, env, config) {
+    if (!inputs.src && config.stacks && config.stacks.length > 0) {
+        throw new ReleaseCompileError(`this project declares ${config.stacks.length} stack(s) in chant.config.ts and no component, and a release of a project with no components compiles one build root; ` +
+            "name it with --src <dir>");
+    }
+    const projectDir = resolve(inputs.projectDir);
+    const root = resolve(projectDir, inputs.src ?? config.sourceDir ?? ".");
+    const output = resolve(projectDir, inputs.output ?? DEFAULT_BUILD_OUTPUT);
+    const rel = relative(projectDir, output);
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+        throw new ReleaseCompileError(`the build output "${inputs.output}" is outside the member's directory; name a file inside it`);
+    }
+    // Loaded here: a project with components never needs the lexicon plugins in this process.
+    const { loadPlugins, resolveProjectLexicons } = await import("../cli/plugins.js");
+    const { buildCommand, printWarnings, resolveBuildFormat } = await import("../cli/commands/build.js");
+    const plugins = await loadPlugins(await resolveProjectLexicons(projectDir, inputs.lexicon ? { lexicon: inputs.lexicon } : {}));
+    const serializers = plugins.map((p) => p.serializer).filter((s) => !inputs.lexicon || s.name === inputs.lexicon);
+    if (serializers.length === 0) {
+        throw new ReleaseCompileError(inputs.lexicon ? `no serializer found for lexicon "${inputs.lexicon}"` : "this project has no component and no lexicon, so there is nothing to compile a release from");
+    }
+    const files = new Map();
+    const result = await buildCommand({
+        path: root,
+        output,
+        format: resolveBuildFormat(undefined, output).format,
+        serializers,
+        plugins,
+        env,
+        ...(inputs.params ? { params: inputs.params } : {}),
+        ...(inputs.paramsFile ? { paramsFile: inputs.paramsFile.replaceAll("{env}", env) } : {}),
+        writeFile: (path, content) => files.set(path, content),
+    });
+    printWarnings(result.warnings);
+    if (!result.success) {
+        throw new ReleaseCompileError(`the build for "${env}" failed:\n${result.errors.join("\n")}`);
+    }
+    if (result.fileCount === 0 && result.resourceCount === 0) {
+        throw new ReleaseCompileError(`no source files were found under ${relative(projectDir, root) || "."}, so there is nothing to compile a release from`);
+    }
+    const templates = [];
+    for (const [path, content] of files) {
+        const p = relative(projectDir, path);
+        if (p.startsWith("..") || isAbsolute(p)) {
+            throw new ReleaseCompileError(`the build for "${env}" writes ${path}, outside the member's directory, so the release can't record it`);
+        }
+        templates.push({ component: null, path: p.split("\\").join("/"), content });
+    }
+    templates.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    return {
+        env,
+        params: (result.buildParams ?? []).map(({ name, value, source }) => ({ name, value, source })),
+        components: [],
+        buildSteps: {},
+        buildInputs: {},
+        componentFiles: {},
+        templates,
+    };
+}
+/**
+ * Build the artifacts of `names` once, for `env`: run each component's archive
+ * steps, and nothing else, through the driver. `docker-build` gives an `image`
+ * entry, `zip-package` and `jvm-build` an `asset` entry, each with the path it
+ * wrote and its digest.
+ */
+export async function buildReleaseArtifacts(inputs, env, names, registry) {
+    const { config, components } = await loadComponents(inputs, env);
+    const wanted = new Set(names);
+    const targets = components
+        .filter(({ component }) => wanted.has(component.name))
+        .map(({ component }) => withOnlyArchiveSteps(component))
+        .filter((c) => c !== undefined);
+    if (targets.length === 0)
+        return [];
+    const reg = registry ?? (await fanOutRegistry(inputs.projectDir, config));
+    let run;
+    try {
+        run = await runInterpretDriver(targets, reg, { env, gates: memoryGateLedgerPort() });
+    }
+    catch (err) {
+        if (err instanceof DriverRunFailure) {
+            const failed = err.result.results.find((r) => r.status === "fail");
+            const step = failed?.records.find((r) => r.status === "fail");
+            throw new ReleaseCompileError(`building the artifacts of "${failed?.component ?? "?"}" failed${step?.error ? `: ${step.error}` : ""}`);
+        }
+        throw err;
+    }
+    const artifacts = [];
+    for (const result of run.results) {
+        for (const record of result.records) {
+            if (record.status !== "ok" || !ARCHIVE_STEP_KINDS.includes(record.kind))
+                continue;
+            const out = record.output;
+            if (typeof out?.archivePath !== "string" || typeof out.digest !== "string") {
+                throw new ReleaseCompileError(`component "${result.component}": its ${record.kind} step returned no archive path and digest`);
+            }
+            artifacts.push({ component: result.component, kind: record.kind === "docker-build" ? "image" : "asset", path: out.archivePath, digest: out.digest });
+        }
+    }
+    return artifacts;
+}
+/** How {@link spawnTargetCompiler} starts this chant. */
+export function ownChantCommand() {
+    const main = process.argv[1] ?? "";
+    return [process.execPath, ...process.execArgv, main];
+}
+function runChild(command, args, cwd, env) {
+    return new Promise((resolvePromise, reject) => {
+        const [bin, ...lead] = command;
+        const child = spawn(bin, [...lead, ...args], { cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, CHANT_ENV: env } });
+        const out = [];
+        const err = [];
+        child.stdout.on("data", (c) => out.push(c));
+        child.stderr.on("data", (c) => {
+            err.push(c);
+            process.stderr.write(c);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolvePromise({ code: code ?? 1, stdout: Buffer.concat(out).toString("utf-8"), stderr: Buffer.concat(err).toString("utf-8") }));
+    });
+}
+/**
+ * The compiler the CLI uses: each environment in a child process of this same
+ * chant (`chant release compile --env <env> --json`), with `CHANT_ENV` set to
+ * that environment before anything imports the project.
+ */
+export function spawnTargetCompiler(inputs, command = ownChantCommand()) {
+    const common = () => {
+        const args = [];
+        if (inputs.src)
+            args.push("--src", inputs.src);
+        if (inputs.output)
+            args.push("--output", inputs.output);
+        if (inputs.lexicon)
+            args.push("--lexicon", inputs.lexicon);
+        for (const [k, v] of Object.entries(inputs.params ?? {}))
+            args.push("--param", `${k}=${v}`);
+        if (inputs.paramsFile)
+            args.push("--params-file", inputs.paramsFile);
+        return args;
+    };
+    const call = async (env, extra) => {
+        const run = await runChild(command, ["release", "compile", "--env", env, ...common(), ...extra, "--json"], inputs.projectDir, env);
+        if (run.code !== 0)
+            throw new ReleaseCompileError(`compiling "${env}" failed (exit ${run.code})`);
+        try {
+            return JSON.parse(run.stdout);
+        }
+        catch {
+            throw new ReleaseCompileError(`compiling "${env}" printed something that is not JSON`);
+        }
+    };
+    return {
+        async compile(env) {
+            return (await call(env, inputs.buildCommand ? ["--build", inputs.buildCommand] : []));
+        },
+        async buildArtifacts(env, components) {
+            return (await call(env, ["--artifacts", "--component", components.join(",")])).artifacts;
+        },
+    };
+}

package/dist/components/release-gate.d.ts

@@ -0,0 +1,135 @@
+/**
+ * The release gate (#4045, ws-104 questions 2 and 6): the gate `chant
+ * components promote --release` passes for an environment.
+ *
+ * ## What it binds
+ *
+ * A promote under a release plans the release's change set for the
+ * environment it deploys to ({@link planReleaseChangeSet}), stores it on
+ * `chant/lifecycle` under its digest (`../lifecycle/gate-change-set.ts`), and
+ * decides every gate its components reach against three values:
+ *
+ * - the change-set document's `digest`, in `planDigest`;
+ * - the release, in `releaseDigest`;
+ * - the environment, in `environment`.
+ *
+ * An approval counts only when all three match (`evaluateGate` in
+ * `../op/gate.ts`). The document itself names the release and the environment
+ * it was planned for, and both are part of its digest, so a stored document
+ * names the one release its gate bound and two releases never share a digest.
+ *
+ * Every gate a promote under a release reaches is recorded in one ledger,
+ * {@link RELEASE_GATE_OP}, rather than in each component's. The gate name a
+ * composition authors is kept, so components that share a gate name share one
+ * gate per environment, and one approval of the release's change set passes
+ * each of them. A promote of one component (`--component`) plans that
+ * component's subset, which has its own digest and needs its own approval.
+ *
+ * ## Empty change sets
+ *
+ * When the change set changes nothing ({@link isEmptyChangeSet}), the
+ * promote writes an `empty: true` resolution for each gate, with the actor
+ * running it in `resolvedBy` ({@link emptyResolution}). A gate counts it only
+ * after it reads the stored document back and finds it empty
+ * ({@link emptyVerifier}). Quorum and signing rules don't apply to it.
+ *
+ * ## The members
+ *
+ * A component with a step whose capability can plan (`terraform-apply`) is
+ * planned by that capability, as a pull request's plan is. A plan that
+ * returns no change-set part is a hole, since nothing says what it changes.
+ *
+ * Any other component is a `chant` member compared with what the
+ * environment runs now: its latest deploy record and the release that record
+ * names. The artifact digest, each template the release's target records for
+ * the component, and the target's parameters are compared, and each one that
+ * differs is an attribute of one `update` entry (a `create` when the
+ * environment has no deploy of the component). When they are all equal the
+ * member has no entries. When the environment's deploy names no release, or
+ * the release it names can't be read, the member has a hole: nothing says
+ * what the environment runs, so the change can't be shown empty. So does a
+ * component a promote, rollback or redeploy left failed or gated with nothing
+ * recorded since (#4035): its record names what ran before that run.
+ */
+import type { CapabilityRegistry } from "./capability.js";
+import { type DriverComponent } from "./driver.js";
+import { RELEASE_GATE_OP } from "../op/gate-name.js";
+import { type ChangeSetDocument, type ChangeSetPart } from "../change-set.js";
+import type { Release } from "../lifecycle/release-store.js";
+import type { ReleaseRecord } from "../lifecycle/release-ledger.js";
+import type { GateResolutionInput } from "../lifecycle/gate-ledger.js";
+import type { StoredChangeSetRead } from "../lifecycle/change-set-store.js";
+/** The gate ledger every release gate is recorded in: `_gates/release.jsonl`, under the member's prefix. */
+export { RELEASE_GATE_OP };
+/** The address and type a `chant` member's one entry has. */
+export declare const RELEASE_COMPONENT_ENTRY_TYPE = "chant:component";
+/** The name of every gate the compositions declare, nested phases included, sorted and distinct. */
+export declare function gateNamesOf(components: readonly DriverComponent[]): string[];
+/** What an environment runs of one component now: its latest deploy record, and the release that record names when it can be read. */
+export interface CurrentDeploy {
+    record: ReleaseRecord;
+    release: Release | null;
+}
+export interface ReleaseChangeSetInput {
+    release: Release;
+    /** The environment promoted to. */
+    env: string;
+    /** The promoted compositions, with build steps taken out and templates pinned to the release. */
+    components: readonly DriverComponent[];
+    /** The artifact digest each component is promoted at. */
+    digests: ReadonlyMap<string, string>;
+    registry: CapabilityRegistry;
+    /** Per component, what `env` runs now. A component missing here has never been deployed to it. */
+    current: ReadonlyMap<string, CurrentDeploy>;
+    /**
+     * Components a promote, rollback or redeploy left failed or gated in `env`
+     * with nothing recorded since (#4035), each with why. What they run is not
+     * known, so each is a hole whatever its ledger record says.
+     */
+    unsettled?: ReadonlyMap<string, string>;
+    /** Outputs supplied by the caller (`--seed-outputs`). */
+    seededOutputs?: Record<string, Record<string, unknown>>;
+    /** The chant version to record in the document. */
+    chant?: string;
+}
+/**
+ * A component no capability plans, as a `chant` member: what the release
+ * deploys compared with what the environment runs now. See the module doc.
+ */
+export declare function chantComponentPart(input: {
+    component: DriverComponent;
+    release: Release;
+    env: string;
+    digest: string;
+    current: CurrentDeploy | undefined;
+    /** Why the component is unsettled in `env` (#4035), when it is. */
+    unsettled?: string;
+}): ChangeSetPart;
+/**
+ * Plan the release's change set for `env`: one part per promoted component
+ * (or per member its planning capability names), composed into a document
+ * that names the release and the environment. Never throws for a component
+ * that fails to plan: it becomes a failed member.
+ */
+export declare function planReleaseChangeSet(input: ReleaseChangeSetInput): Promise<ChangeSetDocument>;
+/** The members a release gate refuses: provisional ones, which no approval of the document covers (`change-set.mdx`). */
+export declare function provisionalMembers(doc: ChangeSetDocument): string[];
+/**
+ * The `verifyEmpty` a release gate decides with: the document stored under
+ * the digest, read back and checked against its digest by `read`, is the
+ * one planned for this release and environment, and it is empty.
+ */
+export declare function emptyVerifier(read: (digest: string) => Promise<StoredChangeSetRead>, planned: {
+    releaseDigest: string;
+    environment: string;
+}): (digest: string) => Promise<boolean>;
+/** The `empty: true` resolution a promote writes for one release gate over an empty change set. */
+export declare function emptyResolution(input: {
+    gate: string;
+    doc: ChangeSetDocument;
+    actor: string;
+    timestamp: string;
+    gitSha?: string;
+    runId?: string;
+}): GateResolutionInput;
+//# sourceMappingURL=release-gate.d.ts.map

package/dist/components/release-gate.d.ts.map

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