@intentius/chant 0.124.32 → 0.124.34

package/dist/components/release-gate.js

@@ -39,6 +39,14 @@
  * 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.
  *
+ * A dependency the promote also deploys is read from its plan, not from the
+ * estate (#4168 step 4, the rule #3999 gave a pull request): a dependent is
+ * planned against the outputs its upstream's plan says it will expose, and a
+ * reference the plan can't say is listed in `unknownInputs`. Any other
+ * dependency is read as it stands. What each component was planned against is
+ * kept in `reads`, so the promote can hold it back when an upstream applies
+ * as another value (`./promote-rounds.ts`).
+ *
  * 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
@@ -51,7 +59,7 @@
  * component a promote, rollback or redeploy left failed or gated with nothing
  * recorded since (#4035): its record names what ran before that run.
  */
-import { deployContext, resolveComponentGraph, resolveStepInput } from "./driver.js";
+import { deployContext, resolveComponentGraph, resolveStepInput, unresolvedWiringReferences } from "./driver.js";
 import { componentPlanDigest } from "./gate-plan.js";
 import { gateName, RELEASE_GATE_OP } from "../op/gate-name.js";
 import { capabilitySteps, planContext, readComponentOutputs } from "./wave-plan.js";
@@ -187,66 +195,108 @@ export function chantComponentPart(input) {
  * that fails to plan: it becomes a failed member.
  */
 export async function planReleaseChangeSet(input) {
+    return (await planReleaseSet(input)).doc;
+}
+/**
+ * {@link planReleaseChangeSet}, with what each component read. Components are
+ * planned a wave at a time, so a dependency the promote deploys has planned
+ * before its dependents read its outputs.
+ */
+export async function planReleaseSet(input) {
     const { release, env, registry } = input;
     const components = [...input.components];
     const byName = new Map(components.map((c) => [c.name, c]));
     const outputs = { ...(input.seededOutputs ?? {}) };
     const read = new Set(Object.keys(outputs));
     const parts = [];
-    const { order } = resolveComponentGraph(components.map((c) => ({ ...c, dependsOn: (c.dependsOn ?? []).filter((d) => byName.has(d)) })));
-    for (const name of order) {
-        const component = byName.get(name);
-        const digest = input.digests.get(name) ?? "";
-        const plannable = capabilitySteps(component.deploy).filter((s) => registry.has(s.kind) && registry.resolve(s.kind).plan !== undefined);
-        if (plannable.length === 0) {
-            parts.push(chantComponentPart({ component, release, env, digest, current: input.current.get(name), unsettled: input.unsettled?.get(name) }));
-            continue;
-        }
-        const ctx = deployContext({ env }, name);
-        try {
-            for (const dep of component.dependsOn ?? []) {
-                if (read.has(dep) || !byName.has(dep))
-                    continue;
-                read.add(dep);
-                const found = await readComponentOutputs(byName.get(dep), registry, deployContext({ env }, dep), outputs);
-                if (found)
-                    outputs[dep] = found;
+    const plannedBy = new Map();
+    const planned = {};
+    const unknownInputs = {};
+    const reads = {};
+    const inPlan = (name) => input.only === undefined || input.only.has(name);
+    const isPlannable = (c) => capabilitySteps(c.deploy).some((s) => registry.has(s.kind) && registry.resolve(s.kind).plan !== undefined);
+    const { waves } = resolveComponentGraph(components.map((c) => ({ ...c, dependsOn: (c.dependsOn ?? []).filter((d) => byName.has(d)) })));
+    for (const wave of waves) {
+        const planning = wave.filter(inPlan);
+        for (const name of planning) {
+            const component = byName.get(name);
+            const digest = input.digests.get(name) ?? "";
+            const plannable = capabilitySteps(component.deploy).filter((s) => registry.has(s.kind) && registry.resolve(s.kind).plan !== undefined);
+            if (plannable.length === 0) {
+                parts.push(chantComponentPart({ component, release, env, digest, current: input.current.get(name), unsettled: input.unsettled?.get(name) }));
+                continue;
+            }
+            const ctx = deployContext({ env }, name);
+            try {
+                for (const dep of component.dependsOn ?? []) {
+                    if (read.has(dep) || !byName.has(dep))
+                        continue;
+                    read.add(dep);
+                    // A dependency this promote plans exposes what its plan says (#3999).
+                    if (plannedBy.has(dep) && isPlannable(byName.get(dep))) {
+                        const known = plannedBy.get(dep)?.known ?? {};
+                        outputs[dep] = { ...known };
+                        planned[dep] = Object.keys(known).sort();
+                        continue;
+                    }
+                    const found = await readComponentOutputs(byName.get(dep), registry, deployContext({ env }, dep), outputs);
+                    if (found)
+                        outputs[dep] = found;
+                }
+                reads[name] = Object.fromEntries((component.dependsOn ?? []).filter((d) => d in outputs).map((d) => [d, structuredClone(outputs[d])]));
+                const unknown = new Set();
+                let exposes;
+                for (const step of plannable) {
+                    const { kind, ...rest } = step;
+                    for (const r of unresolvedWiringReferences(rest, outputs))
+                        if (plannedBy.has(r.source) && !r.publish)
+                            unknown.add(r.ref);
+                    const result = await registry.resolve(kind).plan(planContext(ctx, rest, outputs), resolveStepInput(rest, {}, outputs));
+                    if (result.outputs)
+                        exposes = { known: { ...(exposes?.known ?? {}), ...result.outputs.known }, unknown: [...new Set([...(exposes?.unknown ?? []), ...result.outputs.unknown])].sort() };
+                    parts.push(result.changeSet ?? {
+                        member: {
+                            member: result.member,
+                            lexicon: "chant",
+                            planner: "chant",
+                            status: "planned",
+                            planDigest: result.planDigest,
+                            holes: [{ address: result.member, reason: `its ${kind} plan describes no changes, so what it changes is unknown` }],
+                        },
+                        entries: [],
+                    });
+                }
+                plannedBy.set(name, exposes);
+                if (unknown.size > 0)
+                    unknownInputs[name] = [...unknown].sort();
             }
-            for (const step of plannable) {
-                const { kind, ...rest } = step;
-                const planned = await registry.resolve(kind).plan(planContext(ctx, rest, outputs), resolveStepInput(rest, {}, outputs));
-                parts.push(planned.changeSet ?? {
+            catch (err) {
+                plannedBy.set(name, undefined);
+                parts.push({
                     member: {
-                        member: planned.member,
+                        member: name,
                         lexicon: "chant",
                         planner: "chant",
-                        status: "planned",
-                        planDigest: planned.planDigest,
-                        holes: [{ address: planned.member, reason: `its ${kind} plan describes no changes, so what it changes is unknown` }],
+                        status: "failed",
+                        error: err instanceof Error ? err.message : String(err),
+                        planDigest: null,
+                        holes: [],
                     },
                     entries: [],
                 });
             }
         }
-        catch (err) {
-            parts.push({
-                member: {
-                    member: name,
-                    lexicon: "chant",
-                    planner: "chant",
-                    status: "failed",
-                    error: err instanceof Error ? err.message : String(err),
-                    planDigest: null,
-                    holes: [],
-                },
-                entries: [],
-            });
-        }
     }
-    return composeChangeSet(parts, {
+    const doc = composeChangeSet(parts, {
         ...(input.chant !== undefined ? { chant: input.chant } : {}),
         planned: { releaseDigest: release.releaseDigest, environment: env },
     });
+    return {
+        doc,
+        reads,
+        ...(Object.keys(planned).length > 0 ? { plannedOutputs: planned } : {}),
+        ...(Object.keys(unknownInputs).length > 0 ? { unknownInputs } : {}),
+    };
 }
 /** The members a release gate refuses: provisional ones, which no approval of the document covers (`change-set.mdx`). */
 export function provisionalMembers(doc) {

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,6 +13,14 @@
  * (`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()`,
@@ -40,6 +48,8 @@ export type WaveComponentPlan = {
     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,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;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,CAkC5B;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"}
+{"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"}