@intentius/chant 0.124.31 → 0.124.33

package/dist/components/release-compile.js

@@ -15,7 +15,14 @@
  * ./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.
+ *
+ * Since #4155 a cut also records the other local paths a deploy step names
+ * ({@link recordedInputRefs}: a Helm chart, a kustomize directory, a sync's
+ * source tree, the fields `./deploy-inputs.ts` lists). A directory is
+ * recorded file by file and named in the target's `trees`; a file that is not
+ * UTF-8 is recorded as base64. Such a path that does not exist after the
+ * build, as a chart named from a repository, is not recorded, and the
+ * promote leaves it as written.
  *
  * A project with no components (#4046) is compiled the way `chant build --env
  * <env> -o <output>` builds it ({@link compileBuildOutput}): every file that
@@ -24,6 +31,7 @@
  * back from disk, so a file an earlier build left behind is never recorded.
  */
 import { spawn, spawnSync } from "node:child_process";
+import { isUtf8 } from "node:buffer";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import { loadChantConfig } from "../config.js";
@@ -36,7 +44,8 @@ import { ARCHIVE_STEP_KINDS, BUILD_STEP_KINDS, PUBLISH_STEP_KINDS } from "./prom
 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"];
+export { TEMPLATE_FIELDS } from "./deploy-inputs.js";
+import { DEPLOY_INPUT_FIELDS, directoryFiles, ignoredByGit, TEMPLATE_FIELDS, walkFiles } from "./deploy-inputs.js";
 /** The prefix a step may write before an archive-relative template path. */
 const ARCHIVE_PREFIX = "archive:";
 function isGate(step) {
@@ -79,6 +88,33 @@ export function templateRefs(component) {
     }
     return out;
 }
+/** Every literal path a component's deploy names that a cut records: {@link templateRefs}, plus each kind's own fields in `DEPLOY_INPUT_FIELDS`. */
+export function recordedInputRefs(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 recordedFields(step.kind)) {
+            const raw = step[field];
+            for (const value of Array.isArray(raw) ? raw : [raw]) {
+                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, required: TEMPLATE_FIELDS.includes(field) });
+            }
+        }
+    }
+    return out;
+}
+/** The fields of a step of `kind` whose paths a cut records and a promote points at the recorded copy. */
+export function recordedFields(kind) {
+    return [...TEMPLATE_FIELDS, ...(DEPLOY_INPUT_FIELDS[kind] ?? [])];
+}
+/** A file's bytes as a template: its text when it is UTF-8, else base64. */
+export function templateOf(component, path, file) {
+    const bytes = readFileSync(file);
+    return isUtf8(bytes) ? { component, path, content: bytes.toString("utf-8") } : { component, path, content: bytes.toString("base64"), encoding: "base64" };
+}
 /** 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));
@@ -122,6 +158,8 @@ export function withOnlyArchiveSteps(component) {
     const deploy = component.deploy.map(keep).filter((p) => p !== undefined);
     return deploy.length > 0 ? { name: component.name, dependsOn: [], deploy } : undefined;
 }
+/** The variable a cut's label reaches the build through (#4168). */
+export const RELEASE_LABEL_ENV = "CHANT_RELEASE_LABEL";
 /**
  * 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
@@ -185,21 +223,33 @@ export async function compileEnvironment(inputs, env) {
         return compileBuildOutput(inputs, env, config);
     const rel = (p) => (isAbsolute(p) ? relative(inputs.projectDir, p) : p);
     const templates = [];
+    const trees = [];
     const seen = new Set();
     for (const { component } of components) {
-        for (const ref of templateRefs(component)) {
+        for (const ref of recordedInputRefs(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)) {
+                if (!ref.required)
+                    continue;
                 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())
+            if (statSync(file).isFile()) {
+                templates.push(templateOf(ref.component, ref.path, file));
                 continue;
-            templates.push({ component: ref.component, path: ref.path, content: readFileSync(file, "utf-8") });
+            }
+            // #4155: a directory, file by file. One git ignores is the build's output, recorded whole.
+            const files = ignoredByGit(inputs.projectDir, ref.path) ? walkFiles(inputs.projectDir, ref.path) : directoryFiles(inputs.projectDir, ref.path);
+            const dir = ref.path.replace(/\/+$/, "");
+            for (const f of files) {
+                const under = relative(resolve(inputs.projectDir, dir), resolve(inputs.projectDir, f)).split("\\").join("/");
+                templates.push(templateOf(ref.component, `${dir}/${under}`, resolve(inputs.projectDir, f)));
+            }
+            trees.push({ component: ref.component, path: dir });
         }
     }
     return {
@@ -211,6 +261,7 @@ export async function compileEnvironment(inputs, env) {
         buildInputs: Object.fromEntries(components.map(({ component }) => [component.name, buildInputPaths(component)])),
         componentFiles: Object.fromEntries(components.map(({ component, file }) => [component.name, rel(file)])),
         templates,
+        trees,
     };
 }
 /**
@@ -325,10 +376,15 @@ export function ownChantCommand() {
     const main = process.argv[1] ?? "";
     return [process.execPath, ...process.execArgv, main];
 }
-function runChild(command, args, cwd, env) {
+function runChild(command, args, cwd, env, releaseLabel) {
     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 childEnv = { ...process.env, CHANT_ENV: env };
+        // A label never leaks in from the caller's shell: only the cut sets it.
+        delete childEnv[RELEASE_LABEL_ENV];
+        if (releaseLabel !== undefined)
+            childEnv[RELEASE_LABEL_ENV] = releaseLabel;
+        const child = spawn(bin, [...lead, ...args], { cwd, stdio: ["ignore", "pipe", "pipe"], env: childEnv });
         const out = [];
         const err = [];
         child.stdout.on("data", (c) => out.push(c));
@@ -361,7 +417,7 @@ export function spawnTargetCompiler(inputs, command = ownChantCommand()) {
         return args;
     };
     const call = async (env, extra) => {
-        const run = await runChild(command, ["release", "compile", "--env", env, ...common(), ...extra, "--json"], inputs.projectDir, env);
+        const run = await runChild(command, ["release", "compile", "--env", env, ...common(), ...extra, "--json"], inputs.projectDir, env, inputs.releaseLabel);
         if (run.code !== 0)
             throw new ReleaseCompileError(`compiling "${env}" failed (exit ${run.code})`);
         try {

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

@@ -11,9 +11,19 @@
  * under `.chant/release-templates/<digest>/` in the member's directory and the
  * step reads them from there. The path is relative and fixed by the digest,
  * so a gate approval bound to the promote's plan still matches on a re-run.
+ *
+ * A release cut since #4155 (a target with `trees`) records every local path
+ * a deploy step names (`recordedInputRefs`), directories file by file. A
+ * promote points each of them at the recorded copy: a directory is written
+ * under `.chant/release-templates/<digest>/<name>/`, its digest taken over its
+ * files the way a gate's directory digest is (`./deploy-inputs.ts`). A path
+ * outside the template fields that the release does not record, such as a
+ * chart named from a repository, is left as written. A target cut before
+ * #4155 is pinned as it was then: template fields only, other paths read from
+ * the checkout.
  */
 import type { DriverComponent } from "./driver.js";
-import type { Release, ReleaseTarget } from "../lifecycle/release-store.js";
+import { type Release, type ReleaseTarget } from "../lifecycle/release-store.js";
 import type { ReleaseRecord } from "../lifecycle/release-ledger.js";
 import type { BuildArchiveManifest } from "./verbs/build-archive.js";
 /** Where a promote under a release writes the recorded templates, relative to the member's directory. */
@@ -22,8 +32,12 @@ export declare const RELEASE_TEMPLATES_DIR = ".chant/release-templates";
 export interface PinnedTemplate {
     /** Relative to the member's directory. */
     path: string;
+    /** The text, or the base64 of the bytes under `encoding: "base64"`. */
     content: string;
+    encoding?: "base64";
 }
+/** Reads a recorded template's stored copy by digest: its text, or its base64 under `base64`. */
+export type TemplateReader = (digest: string, encoding?: "base64") => Promise<string | null>;
 /** The release's target for `env`, or an error naming the environments it has. */
 export declare function targetFor(release: Release, env: string): {
     target: ReleaseTarget;
@@ -38,7 +52,7 @@ export declare function isImplicitRelease(release: Release): boolean;
  * the promote is refused: a template the target does not record, one whose
  * bytes are missing, or one whose bytes do not hash to the target's digest.
  */
-export declare function pinReleaseTemplates(components: readonly DriverComponent[], release: Release, target: ReleaseTarget, readTemplate: (digest: string) => Promise<string | null>): Promise<{
+export declare function pinReleaseTemplates(components: readonly DriverComponent[], release: Release, target: ReleaseTarget, readTemplate: TemplateReader): Promise<{
     components: DriverComponent[];
     files: PinnedTemplate[];
 } | {
@@ -53,7 +67,7 @@ export declare function pinReleaseTemplates(components: readonly DriverComponent
  * member's directory; a template whose bytes are missing or don't hash to the
  * target's digest is refused, as {@link pinReleaseTemplates} refuses one.
  */
-export declare function targetFiles(release: Release, target: ReleaseTarget, readTemplate: (digest: string) => Promise<string | null>): Promise<{
+export declare function targetFiles(release: Release, target: ReleaseTarget, readTemplate: TemplateReader): Promise<{
     files: PinnedTemplate[];
 } | {
     errors: string[];

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

@@ -1 +1 @@
-{"version":3,"file":"release-promote.d.ts","sourceRoot":"","sources":["../../src/components/release-promote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAuC,MAAM,UAAU,CAAC;AAErF,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,yGAAyG;AACzG,eAAO,MAAM,qBAAqB,6BAA6B,CAAC;AAEhE,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,aAAa,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAMtG;AAED,sIAAsI;AACtI,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAG3D;AAUD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,EACrB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GACvD,OAAO,CAAC;IAAE,UAAU,EAAE,eAAe,EAAE,CAAC;IAAC,KAAK,EAAE,cAAc,EAAE,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAiD5F;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,EACrB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GACvD,OAAO,CAAC;IAAE,KAAK,EAAE,cAAc,EAAE,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA2B7D;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,CAMxF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,CAQzF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,aAAa,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,CAAC,EACpE,YAAY,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,GAC7E,OAAO,CAAC,MAAM,EAAE,CAAC,CAmBnB"}
+{"version":3,"file":"release-promote.d.ts","sourceRoot":"","sources":["../../src/components/release-promote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAuC,MAAM,UAAU,CAAC;AAErF,OAAO,EAAuB,KAAK,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEnG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,yGAAyG;AACzG,eAAO,MAAM,qBAAqB,6BAA6B,CAAC;AAEhE,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED,iGAAiG;AACjG,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE7F,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,aAAa,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAMtG;AAED,sIAAsI;AACtI,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAG3D;AAUD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,EACrB,YAAY,EAAE,cAAc,GAC3B,OAAO,CAAC;IAAE,UAAU,EAAE,eAAe,EAAE,CAAC;IAAC,KAAK,EAAE,cAAc,EAAE,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAyD5F;AA+CD;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,EACrB,YAAY,EAAE,cAAc,GAC3B,OAAO,CAAC;IAAE,KAAK,EAAE,cAAc,EAAE,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA2B7D;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,CAMxF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,IAAI,CAUzF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,aAAa,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,CAAC,EACpE,YAAY,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,GAC7E,OAAO,CAAC,MAAM,EAAE,CAAC,CAmBnB"}

package/dist/components/release-promote.js

@@ -11,11 +11,22 @@
  * under `.chant/release-templates/<digest>/` in the member's directory and the
  * step reads them from there. The path is relative and fixed by the digest,
  * so a gate approval bound to the promote's plan still matches on a re-run.
+ *
+ * A release cut since #4155 (a target with `trees`) records every local path
+ * a deploy step names (`recordedInputRefs`), directories file by file. A
+ * promote points each of them at the recorded copy: a directory is written
+ * under `.chant/release-templates/<digest>/<name>/`, its digest taken over its
+ * files the way a gate's directory digest is (`./deploy-inputs.ts`). A path
+ * outside the template fields that the release does not record, such as a
+ * chart named from a repository, is left as written. A target cut before
+ * #4155 is pinned as it was then: template fields only, other paths read from
+ * the checkout.
  */
 import { mkdirSync, readdirSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { contentDigest } from "../content-digest.js";
-import { TEMPLATE_FIELDS, templateRefs } from "./release-compile.js";
+import { recordedFields, recordedInputRefs, TEMPLATE_FIELDS, templateRefs } from "./release-compile.js";
+import { templateBytesDigest } from "../lifecycle/release-store.js";
+import { computePlanDigest } from "../lifecycle/plan-digest.js";
 /** Where a promote under a release writes the recorded templates, relative to the member's directory. */
 export const RELEASE_TEMPLATES_DIR = ".chant/release-templates";
 /** The release's target for `env`, or an error naming the environments it has. */
@@ -48,29 +59,41 @@ export async function pinReleaseTemplates(components, release, target, readTempl
     const errors = [];
     const files = [];
     const out = [];
+    // #4155: a target with `trees` records every deploy input; one without was cut before and records template fields only.
+    const full = target.trees !== undefined;
     for (const component of components) {
         const replace = new Map();
-        for (const ref of templateRefs(component)) {
+        const refs = full ? recordedInputRefs(component) : templateRefs(component).map((r) => ({ ...r, required: true }));
+        for (const ref of refs) {
             if (replace.has(ref.value))
                 continue;
+            const dir = ref.path.replace(/\/+$/, "");
+            const tree = full ? target.trees.find((t) => t.component === component.name && t.path === dir) : undefined;
+            if (tree) {
+                const pinned = await pinTree(component.name, tree.path, target, readTemplate);
+                if ("errors" in pinned)
+                    errors.push(...pinned.errors);
+                else {
+                    files.push(...pinned.files);
+                    replace.set(ref.value, pinned.path);
+                }
+                continue;
+            }
             const recorded = target.templates.find((t) => t.component === component.name && t.path === ref.path);
             if (!recorded) {
+                if (!ref.required)
+                    continue;
                 errors.push(`component "${component.name}" reads ${ref.field} "${ref.value}", which release ${release.releaseDigest} does not record for "${target.env}"; ` +
                     `this checkout's deploy is not the one the release was compiled from (commit ${release.commit.slice(0, 12)})`);
                 continue;
             }
-            const content = await readTemplate(recorded.digest);
-            if (content === null) {
-                errors.push(`component "${component.name}": the bytes of template "${ref.path}" (${recorded.digest}) are not on the chant/lifecycle branch; fetch it and try again`);
-                continue;
-            }
-            const got = contentDigest(content);
-            if (got !== recorded.digest) {
-                errors.push(`component "${component.name}": template "${ref.path}" hashes to ${got}, but the release's target for "${target.env}" records ${recorded.digest}; refusing to deploy it`);
+            const read = await readChecked(component.name, ref.path, recorded, target, readTemplate);
+            if ("error" in read) {
+                errors.push(read.error);
                 continue;
             }
             const path = join(RELEASE_TEMPLATES_DIR, recorded.digest.replace(/:/g, "_"), basename(ref.path));
-            files.push({ path, content });
+            files.push({ path, content: read.content, ...(recorded.encoding ? { encoding: recorded.encoding } : {}) });
             replace.set(ref.value, path);
         }
         const rewrite = (phase) => ({
@@ -81,7 +104,7 @@ export async function pinReleaseTemplates(components, release, target, readTempl
                 if (isGate(step))
                     return step;
                 const next = { ...step };
-                for (const field of TEMPLATE_FIELDS) {
+                for (const field of full ? recordedFields(step.kind) : TEMPLATE_FIELDS) {
                     const v = next[field];
                     if (typeof v === "string" && replace.has(v))
                         next[field] = replace.get(v);
@@ -95,6 +118,42 @@ export async function pinReleaseTemplates(components, release, target, readTempl
     }
     return errors.length > 0 ? { errors } : { components: out, files };
 }
+/** One recorded template's stored copy, checked against its digest. */
+async function readChecked(component, path, recorded, target, readTemplate) {
+    const who = component === null ? "" : `component "${component}": `;
+    const content = await readTemplate(recorded.digest, recorded.encoding);
+    if (content === null)
+        return { error: `${who}the bytes of template "${path}" (${recorded.digest}) are not on the chant/lifecycle branch; fetch it and try again` };
+    const got = templateBytesDigest(content, recorded.encoding);
+    if (got !== recorded.digest) {
+        return { error: `${who}template "${path}" hashes to ${got}, but the release's target for "${target.env}" records ${recorded.digest}; refusing to deploy it` };
+    }
+    return { content };
+}
+/**
+ * A recorded directory's files, under `.chant/release-templates/<digest>/<name>/`
+ * (#4155). The digest is taken over the files' paths from the directory and
+ * their bytes, as a gate's directory digest is, so the path names the tree.
+ */
+async function pinTree(component, dir, target, readTemplate) {
+    const prefix = `${dir}/`;
+    const entries = target.templates.filter((t) => t.component === component && t.path.startsWith(prefix));
+    const errors = [];
+    const read = [];
+    for (const e of entries) {
+        const got = await readChecked(component, e.path, e, target, readTemplate);
+        if ("error" in got)
+            errors.push(got.error);
+        else
+            read.push({ rel: e.path.slice(prefix.length), content: got.content, digest: e.digest, ...(e.encoding ? { encoding: e.encoding } : {}) });
+    }
+    if (errors.length > 0)
+        return { errors };
+    read.sort((a, b) => (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0));
+    const digest = computePlanDigest("directory", read.map(({ rel, digest }) => ({ path: rel, digest })));
+    const path = join(RELEASE_TEMPLATES_DIR, digest.replace(/:/g, "_"), basename(dir));
+    return { path, files: read.map((r) => ({ path: join(path, r.rel), content: r.content, ...(r.encoding ? { encoding: r.encoding } : {}) })) };
+}
 /**
  * The files a release's target records, read back by digest and checked, for
  * `chant release export` (#4046). A project with no components has no deploy
@@ -113,12 +172,12 @@ export async function targetFiles(release, target, readTemplate) {
             errors.push(`${who}template "${t.path}" is not a path inside the member's directory; refusing to write it`);
             continue;
         }
-        const content = await readTemplate(t.digest);
+        const content = await readTemplate(t.digest, t.encoding);
         if (content === null) {
             errors.push(`${who}the bytes of template "${t.path}" (${t.digest}) are not on the chant/lifecycle branch; fetch it and try again`);
             continue;
         }
-        const got = contentDigest(content);
+        const got = templateBytesDigest(content, t.encoding);
         if (got !== t.digest) {
             errors.push(`${who}template "${t.path}" hashes to ${got}, but release ${release.releaseDigest} records ${t.digest} for "${target.env}"; refusing to write it`);
             continue;
@@ -129,7 +188,7 @@ export async function targetFiles(release, target, readTemplate) {
                 errors.push(`two components record different bytes at "${t.path}" for "${target.env}", so they can't both be written there`);
             continue;
         }
-        files.push({ path: t.path, content });
+        files.push({ path: t.path, content, ...(t.encoding ? { encoding: t.encoding } : {}) });
     }
     return errors.length > 0 ? { errors } : { files };
 }
@@ -138,7 +197,7 @@ export function writePinnedTemplates(dir, files) {
     for (const f of files) {
         const full = join(dir, f.path);
         mkdirSync(dirname(full), { recursive: true });
-        writeFileSync(full, f.content);
+        writeFileSync(full, f.encoding === "base64" ? Buffer.from(f.content, "base64") : f.content);
     }
 }
 /**
@@ -148,8 +207,10 @@ export function writePinnedTemplates(dir, files) {
  * again from the release.
  */
 export function removePinnedTemplates(dir, files) {
+    // Each file sits under `.chant/release-templates/<digest>/`, a recorded tree's deeper; that digest directory goes.
+    const prefix = RELEASE_TEMPLATES_DIR.split("/").length;
     for (const f of files)
-        rmSync(dirname(join(dir, f.path)), { recursive: true, force: true });
+        rmSync(join(dir, ...f.path.split(/[\\/]/).slice(0, prefix + 1)), { recursive: true, force: true });
     const root = join(dir, RELEASE_TEMPLATES_DIR);
     try {
         if (readdirSync(root).length === 0)

package/dist/components/verbs/bom-writer.d.ts

@@ -68,7 +68,7 @@ export interface BomPackage {
     /** Version string, when known. Omitted for resources with no version concept (e.g. a CFN resource). */
     version?: string;
     /** Package manager / ecosystem this entry came from (e.g. "npm", "maven"), surfaced in SPDX's `externalRefs`/CycloneDX's `purl` when derivable. */
-    type?: "npm" | "maven" | "config" | "external-reference";
+    type?: "npm" | "maven" | "cargo" | "config" | "external-reference";
     /** Package URL (purl), when derivable — e.g. `pkg:npm/left-pad@1.3.0`. */
     purl?: string;
     /** SPDX download location, when known. Defaults to `"NOASSERTION"` per the SPDX spec's requirement that every package declare one. */

package/dist/components/verbs/bom-writer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bom-writer.d.ts","sourceRoot":"","sources":["../../../src/components/verbs/bom-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAIrE;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,2HAA2H;IAC3H,IAAI,EAAE,MAAM,CAAC;IACb,uGAAuG;IACvG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mJAAmJ;IACnJ,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,oBAAoB,CAAC;IACzD,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sIAAsI;IACtI,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0JAA0J;IAC1J,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,iGAAiG;IACjG,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+MAA+M;IAC/M,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,QAAQ,EAAE,UAAU,EAAE,CAAC;CACxB;AAED,oGAAoG;AACpG,MAAM,WAAW,QAAQ;IACvB,yFAAyF;IACzF,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2IAA2I;IAC3I,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,gIAAgI;IAChI,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;CACjC;AAyDD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,GAAE,MAAM,IAAuB,GAAG,MAAM,CAyErF;AAsBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,GAAE,MAAM,IAAuB,GAAG,MAAM,CAgE1F;AAUD,+NAA+N;AAC/N,wBAAgB,QAAQ,CACtB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,QAAQ,EACf,GAAG,CAAC,EAAE,MAAM,IAAI,GACf;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAG1D"}
+{"version":3,"file":"bom-writer.d.ts","sourceRoot":"","sources":["../../../src/components/verbs/bom-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAIrE;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,2HAA2H;IAC3H,IAAI,EAAE,MAAM,CAAC;IACb,uGAAuG;IACvG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mJAAmJ;IACnJ,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,oBAAoB,CAAC;IACnE,0EAA0E;IAC1E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sIAAsI;IACtI,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,0JAA0J;IAC1J,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,iGAAiG;IACjG,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+MAA+M;IAC/M,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,QAAQ,EAAE,UAAU,EAAE,CAAC;CACxB;AAED,oGAAoG;AACpG,MAAM,WAAW,QAAQ;IACvB,yFAAyF;IACzF,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2IAA2I;IAC3I,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,gIAAgI;IAChI,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;CACjC;AAyDD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,GAAE,MAAM,IAAuB,GAAG,MAAM,CAyErF;AAsBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,GAAE,MAAM,IAAuB,GAAG,MAAM,CAgE1F;AAUD,+NAA+N;AAC/N,wBAAgB,QAAQ,CACtB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,QAAQ,EACf,GAAG,CAAC,EAAE,MAAM,IAAI,GACf;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAG1D"}

package/dist/components/verbs/lockfile-sbom-generator.d.ts

@@ -55,6 +55,26 @@ export declare function parseNpmPackageLock(content: string): BomPackage[];
  * inheritance chain.
  */
 export declare function parsePomXml(content: string): BomPackage[];
+/**
+ * Parse a `Cargo.lock` (version 3 or 4) into a flat `BomPackage[]`: one
+ * entry per `[[package]]` with a `source`, so the workspace's own crates,
+ * which have none, are left out as the npm parser leaves out the root.
+ * A dependency is named `name` or `name version` in the lock; only the name
+ * is kept. A small line reader, not a TOML parser: the lock is written by
+ * cargo in one fixed shape.
+ */
+export declare function parseCargoLock(content: string): BomPackage[];
+/** Each lockfile kind's parser and file name. */
+export declare const LOCKFILE_PARSERS: {
+    readonly npm: typeof parseNpmPackageLock;
+    readonly maven: typeof parsePomXml;
+    readonly cargo: typeof parseCargoLock;
+};
+export declare const LOCKFILE_NAMES: {
+    readonly npm: "package-lock.json";
+    readonly maven: "pom.xml";
+    readonly cargo: "Cargo.lock";
+};
 export interface LockfileSbomGeneratorOptions {
     /** Where generated SBOM documents are written on disk, as a sibling of the scanned path (see `sbomOutputPath`). Default: alongside the scanned manifest, named `sbom.<format>.json`. */
     outDir?: string;

package/dist/components/verbs/lockfile-sbom-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lockfile-sbom-generator.d.ts","sourceRoot":"","sources":["../../../src/components/verbs/lockfile-sbom-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,EAAY,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EAMV,aAAa,EACd,MAAM,kBAAkB,CAAC;AAe1B;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CAkCjE;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CA8BzD;AAID,MAAM,WAAW,4BAA4B;IAC3C,wLAAwL;IACxL,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAgBD,qIAAqI;AACrI,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,4BAAiC,GAAG,aAAa,CA0CrG;AAED,gMAAgM;AAChM,eAAO,MAAM,qBAAqB,EAAE,aAA6C,CAAC"}
+{"version":3,"file":"lockfile-sbom-generator.d.ts","sourceRoot":"","sources":["../../../src/components/verbs/lockfile-sbom-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,EAAY,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EAMV,aAAa,EACd,MAAM,kBAAkB,CAAC;AAe1B;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CAkCjE;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CA8BzD;AAID;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CAsB5D;AAED,iDAAiD;AACjD,eAAO,MAAM,gBAAgB;aAAK,GAAG;aAAuB,KAAK;aAAe,KAAK;CAA2B,CAAC;AACjH,eAAO,MAAM,cAAc;aAAK,GAAG,EAAE,mBAAmB;aAAE,KAAK,EAAE,SAAS;aAAE,KAAK,EAAE,YAAY;CAAW,CAAC;AAI3G,MAAM,WAAW,4BAA4B;IAC3C,wLAAwL;IACxL,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAgBD,qIAAqI;AACrI,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,GAAE,4BAAiC,GAAG,aAAa,CA0CrG;AAED,gMAAgM;AAChM,eAAO,MAAM,qBAAqB,EAAE,aAA6C,CAAC"}

package/dist/components/verbs/lockfile-sbom-generator.js

@@ -125,9 +125,46 @@ export function parsePomXml(content) {
     }
     return packages.sort((a, b) => a.name.localeCompare(b.name));
 }
+// ── Cargo.lock (Rust, #4168 decision 12) ────────────────────────────────────
+/**
+ * Parse a `Cargo.lock` (version 3 or 4) into a flat `BomPackage[]`: one
+ * entry per `[[package]]` with a `source`, so the workspace's own crates,
+ * which have none, are left out as the npm parser leaves out the root.
+ * A dependency is named `name` or `name version` in the lock; only the name
+ * is kept. A small line reader, not a TOML parser: the lock is written by
+ * cargo in one fixed shape.
+ */
+export function parseCargoLock(content) {
+    const seen = new Map();
+    const blocks = content.split(/^\[\[package\]\]\s*$/m).slice(1);
+    for (const block of blocks) {
+        const body = block.split(/^\[/m)[0] ?? "";
+        const field = (key) => new RegExp(`^${key}\\s*=\\s*"([^"]*)"`, "m").exec(body)?.[1];
+        const name = field("name");
+        const version = field("version");
+        if (!name || field("source") === undefined)
+            continue;
+        const deps = /^dependencies\s*=\s*\[([\s\S]*?)\]/m.exec(body)?.[1];
+        const dependsOn = deps ? [...deps.matchAll(/"([^"\s]+)[^"]*"/g)].map((m) => m[1]) : [];
+        const key = `${name}@${version ?? ""}`;
+        if (seen.has(key))
+            continue;
+        seen.set(key, {
+            name,
+            version,
+            type: "cargo",
+            purl: version ? `pkg:cargo/${encodeURIComponent(name)}@${version}` : undefined,
+            dependsOn: dependsOn.length ? [...new Set(dependsOn)] : undefined,
+        });
+    }
+    return [...seen.values()].sort((a, b) => a.name.localeCompare(b.name) || (a.version ?? "").localeCompare(b.version ?? ""));
+}
+/** Each lockfile kind's parser and file name. */
+export const LOCKFILE_PARSERS = { npm: parseNpmPackageLock, maven: parsePomXml, cargo: parseCargoLock };
+export const LOCKFILE_NAMES = { npm: "package-lock.json", maven: "pom.xml", cargo: "Cargo.lock" };
 /** Locate the first readable lockfile/manifest under `dir` this generator knows how to parse, in preference order (npm before Maven — most chant components are Node-first). Returns `undefined` if none is found. */
 function findManifest(dir) {
-    for (const [kind, filename] of [["npm", "package-lock.json"], ["maven", "pom.xml"]]) {
+    for (const [kind, filename] of [["npm", "package-lock.json"], ["maven", "pom.xml"], ["cargo", "Cargo.lock"]]) {
         const candidate = join(dir, filename);
         try {
             readFileSync(candidate, "utf-8");
@@ -160,12 +197,12 @@ export function createLockfileSbomGenerator(options = {}) {
     function generateFromDir(dir, subjectName, digest, format = DEFAULT_SBOM_FORMAT) {
         const manifest = findManifest(dir);
         if (!manifest) {
-            throw new Error(`no supported lockfile/manifest found under "${dir}" (looked for package-lock.json, pom.xml) — ` +
+            throw new Error(`no supported lockfile/manifest found under "${dir}" (looked for package-lock.json, pom.xml, Cargo.lock) — ` +
                 `the hermetic lockfile SBOM backend requires a lockfile on disk; use the deep-scan path (#610) for images with no lockfile`);
         }
         const content = readFileSync(manifest.path, "utf-8");
-        const packages = manifest.kind === "npm" ? parseNpmPackageLock(content) : parsePomXml(content);
-        const generatorName = manifest.kind === "npm" ? "chant-lockfile-sbom/package-lock.json" : "chant-lockfile-sbom/pom.xml";
+        const packages = LOCKFILE_PARSERS[manifest.kind](content);
+        const generatorName = `chant-lockfile-sbom/${LOCKFILE_NAMES[manifest.kind]}`;
         const doc = writeBom(format, { subjectName, subjectId: digest ?? manifest.path, packages, generator: generatorName }, now);
         const outDir = options.outDir ?? dir;
         mkdirSync(outDir, { recursive: true });

package/dist/components/wave-plan.d.ts

@@ -13,30 +13,43 @@
  * (`componentPlanDigest`, ./gate-plan.ts, #2574), so a wave mixing roots and
  * other components still has one digest that moves when any of them does.
  *
+ * The files a step without a `plan` deploys from are bound too (#4155,
+ * ./deploy-inputs.ts). A component with no plannable step folds them into its
+ * composition digest. A component with one gets a member more,
+ * `<component>#inputs`, over its other steps' files, so a `lambda-deploy`
+ * source or a Helm chart beside a `cfn-deploy` moves the wave's digest. A step
+ * whose content chant can't name is a hole on that member, so the plan note
+ * lists it as unbound.
+ *
  * Known limit: a step input that reads an earlier step of the same
  * component (`@Phase.field`) has no value before the component runs, so it
  * plans as `undefined`. Cross-component wiring (`stackOutput()`,
  * `@<component>.publish.*`) resolves.
  */
 import { type DriverComponent, type DriverPhase, type DriverStep } from "./driver.js";
-import type { CapabilityRegistry, DeployContext } from "./capability.js";
+import type { CapabilityRegistry, DeployContext, PlannedOutputs } from "./capability.js";
 import type { WaveMember } from "../gated-waves.js";
 import type { ChangeSetPart } from "../change-set.js";
 /**
  * What planning one component produced: its members, what its steps hand to
  * `run`, and each member's change-set part (#3183), or why it could not plan.
  * A member whose capability returns no part gets one with no entries, so the
- * parts always cover the members.
+ * parts always cover the members. `outputs` is what its steps' plans say the
+ * component will expose once applied (#3999), merged the way the driver
+ * merges a run's outputs; absent when no step's plan says.
  */
 export type WaveComponentPlan = {
     component: string;
     members: WaveMember[];
     plans: Record<string, unknown>;
     parts: ChangeSetPart[];
+    outputs?: PlannedOutputs;
 } | {
     component: string;
     error: string;
 };
+/** The member a planning component's other steps add (#4155): their files, under the component's name. */
+export declare const inputsMemberName: (component: string) => string;
 /** Every capability step in a composition, nested phases included, gates left out. */
 export declare function capabilitySteps(phases: readonly DriverPhase[]): DriverStep[];
 /**

package/dist/components/wave-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wave-plan.d.ts","sourceRoot":"","sources":["../../src/components/wave-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAA6C,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAE9H,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,GACpG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAUzC,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,UAAU,EAAE,CAc5E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,aAAa,EAClB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,aAAa,CAGf;AAED,oHAAoH;AACpH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,OAAO,CAAC,iBAAiB,CAAC,CAgC5B;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAU9C;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,EAChD,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,aAAa,EAC3C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC/C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAYnC"}
+{"version":3,"file":"wave-plan.d.ts","sourceRoot":"","sources":["../../src/components/wave-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAA6C,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAI9H,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,cAAc,CAAA;CAAE,GAC9H;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAWzC,0GAA0G;AAC1G,eAAO,MAAM,gBAAgB,cAAe,MAAM,KAAG,MAA+B,CAAC;AAErF,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,UAAU,EAAE,CAc5E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,aAAa,EAClB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,aAAa,CAGf;AAED,oHAAoH;AACpH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,OAAO,CAAC,iBAAiB,CAAC,CAgD5B;AAUD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,eAAe,EAC1B,QAAQ,EAAE,kBAAkB,EAC5B,GAAG,EAAE,aAAa,EAClB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAU9C;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,EAChD,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,aAAa,EAC3C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC/C,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAYnC"}