@intentius/chant-lexicon-terraform 0.124.52 → 0.124.55

package/dist/components/placeholder-preview.js

@@ -0,0 +1,254 @@
+/**
+ * Previewing a root whose `vars` read outputs not known yet (#4463).
+ *
+ * terraform takes no unknown variable, so such a root used to get no plan at
+ * pull-request time, only a hole. Now it is planned with a stand-in for each
+ * variable that holds no value yet, typed from the root's own `variable`
+ * block ({@link terraformPlaceholder}). Every attribute and output the
+ * stand-ins drive is then marked unknown after apply in the plan JSON
+ * ({@link markPlaceholderDriven}) before the change set, the shape and the
+ * planned outputs are read from it, so no stand-in value reaches the note or
+ * the digest. The member's change-set part lists the variables under
+ * `placeholders`.
+ *
+ * What a stand-in drives is read from the plan's own `configuration`: an
+ * attribute whose expression references `var.<name>`, through module inputs
+ * too, plus any string attribute or output whose planned value carries
+ * {@link TERRAFORM_UNKNOWN_MARK}. A value that reaches an attribute another
+ * way (a number through a `local`) is not marked; the fresh plan at apply
+ * then differs from the preview and asks for an approval of its own, which
+ * costs a round and never applies a change nobody approved.
+ *
+ * A preview is not possible when a variable that holds the unknown read is
+ * not declared, when the unknown sits inside a larger value, when a `count`
+ * or `for_each` reads a stand-in (the preview would show a count the real
+ * value does not have), or when the placeholder plan fails, say on a
+ * `validation` block. The member then stays a hole, as before, and the
+ * hole's reason says why (the 2026-10-25 ruling on #4463).
+ */
+/** The marker every string stand-in carries, so a reader can tell it from a real value. */
+export const TERRAFORM_UNKNOWN_MARK = "known-after-apply";
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+/** Split `text` on `sep` where no bracket is open. */
+function splitTop(text, sep) {
+    const out = [];
+    let depth = 0;
+    let quoted = false;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === '"' && text[i - 1] !== "\\")
+            quoted = !quoted;
+        if (quoted)
+            continue;
+        if (c === "(" || c === "[" || c === "{")
+            depth++;
+        else if (c === ")" || c === "]" || c === "}")
+            depth--;
+        else if (depth === 0 && (typeof sep === "string" ? c === sep : sep.test(c))) {
+            out.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    out.push(text.slice(start));
+    return out.map((s) => s.trim()).filter((s) => s !== "");
+}
+/** `name(inner)` read off a type expression, or `undefined` when it is not one. */
+function call(type, name) {
+    const m = type.match(new RegExp(`^${name}\\s*\\(([\\s\\S]*)\\)$`));
+    return m ? m[1].trim() : undefined;
+}
+/**
+ * A stand-in for a variable of `type`, a Terraform type expression as the
+ * `variable` block writes it (`string`, `list(string)`, `object({ id = string })`).
+ *
+ * - `string`, `any` or no type: {@link TERRAFORM_UNKNOWN_MARK}.
+ * - `number`: 0. `bool`: false.
+ * - `list(...)`, `set(...)`: an empty list. `map(...)`: an empty map.
+ * - `tuple([a, b])`: one stand-in per element type.
+ * - `object({ a = t })`: one stand-in per attribute, `optional(t)` read as `t`.
+ *
+ * An empty collection plans no element, so a resource that iterates one
+ * plans none; the fresh plan at apply then asks for its own approval.
+ */
+export function terraformPlaceholder(type) {
+    const t = (type ?? "").trim().replace(/^\$\{([\s\S]*)\}$/, "$1").trim();
+    if (t === "" || t === "any" || t === "string")
+        return TERRAFORM_UNKNOWN_MARK;
+    if (t === "number")
+        return 0;
+    if (t === "bool")
+        return false;
+    const optional = call(t, "optional");
+    if (optional !== undefined)
+        return terraformPlaceholder(splitTop(optional, ",")[0]);
+    if (call(t, "list") !== undefined || call(t, "set") !== undefined)
+        return [];
+    if (call(t, "map") !== undefined)
+        return {};
+    const tuple = call(t, "tuple");
+    if (tuple !== undefined) {
+        const inner = tuple.replace(/^\[([\s\S]*)\]$/, "$1");
+        return splitTop(inner, ",").map((e) => terraformPlaceholder(e));
+    }
+    const object = call(t, "object");
+    if (object !== undefined) {
+        const inner = object.replace(/^\{([\s\S]*)\}$/, "$1");
+        const out = {};
+        for (const attr of splitTop(inner, /[,\n]/)) {
+            const at = attr.indexOf("=");
+            if (at < 0)
+                continue;
+            const name = attr.slice(0, at).trim().replace(/^"(.*)"$/, "$1");
+            out[name] = terraformPlaceholder(attr.slice(at + 1));
+        }
+        return out;
+    }
+    return TERRAFORM_UNKNOWN_MARK;
+}
+const containsUndefined = (v) => v === undefined || (Array.isArray(v) ? v.some(containsUndefined) : isObject(v) ? Object.values(v).some(containsUndefined) : false);
+/**
+ * The stand-ins for a step's `vars` (#4463): each variable whose value is
+ * `undefined` (a `stackOutput()` read with nothing to read yet) gets
+ * {@link terraformPlaceholder} of its declared type. Returns why instead when
+ * no preview can be made: no variable holds the unknown read, one that does
+ * is not declared in the root, or the unknown sits inside a larger value.
+ */
+export function placeholderVars(vars, declared) {
+    const given = vars ?? {};
+    const placeholders = [];
+    const out = {};
+    for (const [name, value] of Object.entries(given)) {
+        if (value === undefined) {
+            const decl = declared.get(name);
+            if (!decl)
+                return `var.${name} holds the unknown read and the root declares no variable "${name}" to type a stand-in from`;
+            placeholders.push(name);
+            out[name] = terraformPlaceholder(decl.type);
+        }
+        else if (containsUndefined(value)) {
+            return `the unknown read sits inside var.${name}, which a stand-in cannot fill in part`;
+        }
+        else
+            out[name] = value;
+    }
+    if (placeholders.length === 0)
+        return "no variable of the step holds the unknown read";
+    return { placeholders: placeholders.sort(), vars: out };
+}
+/** Every `references` entry under an expression, at any depth (nested blocks are arrays of expression objects). */
+function referencesIn(expr, out = []) {
+    if (Array.isArray(expr))
+        for (const e of expr)
+            referencesIn(e, out);
+    else if (isObject(expr)) {
+        if (Array.isArray(expr.references))
+            for (const r of expr.references)
+                if (typeof r === "string")
+                    out.push(r);
+        for (const [k, v] of Object.entries(expr))
+            if (k !== "references" && k !== "constant_value")
+                referencesIn(v, out);
+    }
+    return out;
+}
+const readsVar = (expr, vars) => referencesIn(expr).some((r) => {
+    const m = r.match(/^var\.([^.[]+)/);
+    return m !== null && vars.has(m[1]);
+});
+const resourceKey = (modulePath, mode, type, name) => `${modulePath}|${mode === "data" ? "data." : ""}${type}.${name}`;
+function walkModule(mod, path, vars, driven) {
+    if (!isObject(mod) || vars.size === 0)
+        return;
+    const at = (address) => (path ? `${path}.${address}` : address);
+    for (const r of Array.isArray(mod.resources) ? mod.resources : []) {
+        if (!isObject(r))
+            continue;
+        const mode = String(r.mode ?? "managed");
+        const address = String(r.address ?? `${r.type}.${r.name}`);
+        if (readsVar(r.count_expression, vars) || readsVar(r.for_each_expression, vars))
+            driven.expansions.push(at(address));
+        const exprs = isObject(r.expressions) ? r.expressions : {};
+        const attrs = new Set(Object.entries(exprs).filter(([, e]) => readsVar(e, vars)).map(([k]) => k));
+        if (attrs.size > 0)
+            driven.attributes.set(resourceKey(path, mode, String(r.type), String(r.name)), attrs);
+    }
+    for (const [name, c] of Object.entries(isObject(mod.module_calls) ? mod.module_calls : {})) {
+        if (!isObject(c))
+            continue;
+        if (readsVar(c.count_expression, vars) || readsVar(c.for_each_expression, vars))
+            driven.expansions.push(at(`module.${name}`));
+        const exprs = isObject(c.expressions) ? c.expressions : {};
+        const inputs = new Set(Object.entries(exprs).filter(([, e]) => readsVar(e, vars)).map(([k]) => k));
+        walkModule(c.module, at(`module.${name}`), inputs, driven);
+    }
+    if (path === "") {
+        for (const [name, o] of Object.entries(isObject(mod.outputs) ? mod.outputs : {})) {
+            if (isObject(o) && readsVar(o.expression, vars))
+                driven.outputs.add(name);
+        }
+    }
+}
+const carriesMark = (v) => typeof v === "string" ? v.includes(TERRAFORM_UNKNOWN_MARK) : Array.isArray(v) ? v.some(carriesMark) : isObject(v) ? Object.values(v).some(carriesMark) : false;
+/** A `resource_changes` item's key in {@link Driven.attributes}: its module path without instance keys. */
+function changeKey(rc) {
+    const modulePath = typeof rc.module_address === "string" ? rc.module_address.replace(/\[[^\]]*\]/g, "") : "";
+    return resourceKey(modulePath, String(rc.mode ?? "managed"), String(rc.type), String(rc.name));
+}
+/**
+ * `planJson` (`show -json` of the placeholder plan) with every attribute and
+ * root output the stand-ins for `placeholders` drive marked unknown after
+ * apply, their planned values dropped. Returns why instead when a `count` or
+ * `for_each` reads a stand-in. The input is not changed.
+ */
+export function markPlaceholderDriven(planJson, placeholders) {
+    const plan = structuredClone(isObject(planJson) ? planJson : {});
+    const driven = { attributes: new Map(), outputs: new Set(), expansions: [] };
+    const config = isObject(plan.configuration) ? plan.configuration : {};
+    walkModule(config.root_module, "", new Set(placeholders), driven);
+    if (driven.expansions.length > 0) {
+        return { refused: `the count or for_each of ${[...new Set(driven.expansions)].sort().join(", ")} reads a stand-in, so the preview cannot say how many instances there are` };
+    }
+    for (const r of Array.isArray(plan.resource_changes) ? plan.resource_changes : []) {
+        if (!isObject(r) || !isObject(r.change))
+            continue;
+        const change = r.change;
+        const after = isObject(change.after) ? change.after : undefined;
+        const attrs = new Set(driven.attributes.get(changeKey(r)) ?? []);
+        for (const [k, v] of Object.entries(after ?? {}))
+            if (carriesMark(v))
+                attrs.add(k);
+        if (attrs.size === 0)
+            continue;
+        const afterUnknown = isObject(change.after_unknown) ? change.after_unknown : {};
+        for (const k of attrs) {
+            afterUnknown[k] = true;
+            if (after)
+                delete after[k];
+        }
+        change.after_unknown = afterUnknown;
+    }
+    const outputChanges = isObject(plan.output_changes) ? plan.output_changes : {};
+    const plannedOutputs = isObject(plan.planned_values) && isObject(plan.planned_values.outputs) ? plan.planned_values.outputs : {};
+    for (const [name, o] of Object.entries(outputChanges))
+        if (isObject(o) && carriesMark(o.after))
+            driven.outputs.add(name);
+    for (const [name, o] of Object.entries(plannedOutputs))
+        if (isObject(o) && carriesMark(o.value))
+            driven.outputs.add(name);
+    for (const name of driven.outputs) {
+        const o = isObject(outputChanges[name]) ? outputChanges[name] : (outputChanges[name] = {});
+        delete o.after;
+        o.after_unknown = true;
+        delete plannedOutputs[name];
+    }
+    return { plan };
+}
+/** The hole a root keeps when its preview is not possible: the old reason, and why there is no preview. */
+export function waitingHole(root, unresolved, why) {
+    return {
+        address: root,
+        type: "terraform_root",
+        reason: `inputs from ${unresolved.join(", ")}; planned again once they apply${why ? `; no preview: ${why}` : ""}`,
+    };
+}

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

@@ -0,0 +1,29 @@
+/**
+ * The files a release records for a `terraform-apply` step (chant#4542).
+ *
+ * The step names its root by key, so core can't see which files it deploys.
+ * `terraformReleaseInputs` answers core's `releaseInputs` with the set a
+ * pull request's plan treats as the root's change (`rootWatchPaths`): the
+ * root's directory, each local module it reaches, and its var files, plus
+ * its backend-config files. A release cut records them for the component,
+ * and a promote or rollback under the release writes them under
+ * `.chant/release-templates/<digest>/` and sets the step's `dir` to the copy
+ * of the root, so `terraform-apply` plans the release's configuration against
+ * the environment's state.
+ *
+ * A root whose state is a file in its own directory (the `local` backend) is
+ * unbound: a plan run in a copy elsewhere would read no state and propose
+ * creating everything. Such a root rolls back through `chant lifecycle
+ * rollback --to`. A live choudoufu root has no state file and is recorded.
+ */
+import type { ReleaseInputs, ReleaseInputsContext, ReleaseInputsUnbound } from "@intentius/chant/components/capability";
+/** The parts of the `terraform-apply` input this reads. */
+interface StepInput {
+    root: string;
+    cwd?: string;
+    dir?: string;
+}
+/** What a release records for one `terraform-apply` step, relative to the member's directory. Null when the root is not declared. */
+export declare function terraformReleaseInputs(input: StepInput, ctx: ReleaseInputsContext): Promise<ReleaseInputs | ReleaseInputsUnbound | null>;
+export {};
+//# sourceMappingURL=release-inputs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"release-inputs.d.ts","sourceRoot":"","sources":["../../src/components/release-inputs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAOxH,2DAA2D;AAC3D,UAAU,SAAS;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAID,qIAAqI;AACrI,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,GAAG,oBAAoB,GAAG,IAAI,CAAC,CA+B9I"}

package/dist/components/release-inputs.js

@@ -0,0 +1,57 @@
+/**
+ * The files a release records for a `terraform-apply` step (chant#4542).
+ *
+ * The step names its root by key, so core can't see which files it deploys.
+ * `terraformReleaseInputs` answers core's `releaseInputs` with the set a
+ * pull request's plan treats as the root's change (`rootWatchPaths`): the
+ * root's directory, each local module it reaches, and its var files, plus
+ * its backend-config files. A release cut records them for the component,
+ * and a promote or rollback under the release writes them under
+ * `.chant/release-templates/<digest>/` and sets the step's `dir` to the copy
+ * of the root, so `terraform-apply` plans the release's configuration against
+ * the environment's state.
+ *
+ * A root whose state is a file in its own directory (the `local` backend) is
+ * unbound: a plan run in a copy elsewhere would read no state and propose
+ * creating everything. Such a root rolls back through `chant lifecycle
+ * rollback --to`. A live choudoufu root has no state file and is recorded.
+ */
+import { dirname, relative, resolve } from "node:path";
+import { loadChantConfigUpward } from "@intentius/chant/config";
+import { rootWatchPaths } from "../changed-roots.js";
+import { liveEstate } from "../compose/hcl.js";
+import { readBackend } from "../state/backend.js";
+const toPosix = (p) => p.split("\\").join("/") || ".";
+/** What a release records for one `terraform-apply` step, relative to the member's directory. Null when the root is not declared. */
+export async function terraformReleaseInputs(input, ctx) {
+    if (typeof input.root !== "string" || input.root === "")
+        return null;
+    const start = resolve(ctx.memberDir, input.cwd ?? ".");
+    const { config, configPath } = await loadChantConfigUpward(start);
+    const projectRoot = configPath ? dirname(configPath) : start;
+    const terraform = config.terraform;
+    const root = terraform?.roots?.[input.root];
+    if (!root)
+        return null;
+    const binary = terraform?.binary;
+    const rootDir = resolve(projectRoot, input.dir ?? root.dir);
+    const live = binary === "choudoufu" && (root.estate !== undefined || liveEstate(rootDir, binary).live);
+    if (!live) {
+        const { backend } = readBackend(rootDir, {
+            ...(root.backendConfig ? { backendConfig: root.backendConfig } : {}),
+            ...(root.backendConfigFiles ? { backendConfigFiles: root.backendConfigFiles } : {}),
+            ...(binary ? { binary } : {}),
+        });
+        if (backend.type === "local") {
+            return {
+                unbound: `root "${input.root}" keeps its state in a local file under ${toPosix(relative(ctx.memberDir, rootDir))}, ` +
+                    "so a plan of a recorded copy would read no state; roll it back with chant lifecycle rollback --to <ref>",
+            };
+        }
+    }
+    const fromMember = (abs) => toPosix(relative(ctx.memberDir, abs));
+    const paths = rootWatchPaths(projectRoot, { dir: relative(projectRoot, rootDir) || ".", ...(root.varFiles ? { varFiles: root.varFiles } : {}) }, binary).map((p) => fromMember(resolve(projectRoot, p)));
+    for (const file of root.backendConfigFiles ?? [])
+        paths.push(fromMember(resolve(rootDir, file)));
+    return { field: "dir", dir: fromMember(rootDir), paths: [...new Set(paths)].sort() };
+}

package/dist/components/trace-facts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `terraform-apply`'s engine facts for its span and op-wave run record
+ * (INTENTIUS/chant#4555): the root, the binary that applied it, and whether
+ * it applied the plan the wave decided. Core adds the plan's resource counts
+ * by action, and writes every key under the CI product's prefix
+ * (`terragucci.root`, `terragucci.binary`).
+ */
+import type { CapabilityTraceFacts } from "@intentius/chant/otlp";
+import type { TerraformApplyStepInput, TerraformApplyStepOutput } from "./capability-plugin.js";
+/** `traceFacts` for `terraform-apply` (#4555). `binary` is the config's `terraform.binary`, `terraform` when it names none. */
+export declare function terraformTraceFacts(input: TerraformApplyStepInput, outcome: {
+    output: TerraformApplyStepOutput;
+} | {
+    error: unknown;
+}, binary: string | undefined): CapabilityTraceFacts;
+//# sourceMappingURL=trace-facts.d.ts.map

package/dist/components/trace-facts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-facts.d.ts","sourceRoot":"","sources":["../../src/components/trace-facts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAE7F,+HAA+H;AAC/H,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,uBAAuB,EAC9B,OAAO,EAAE;IAAE,MAAM,EAAE,wBAAwB,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,EAClE,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,oBAAoB,CAUtB"}

package/dist/components/trace-facts.js

@@ -0,0 +1,19 @@
+/**
+ * `terraform-apply`'s engine facts for its span and op-wave run record
+ * (INTENTIUS/chant#4555): the root, the binary that applied it, and whether
+ * it applied the plan the wave decided. Core adds the plan's resource counts
+ * by action, and writes every key under the CI product's prefix
+ * (`terragucci.root`, `terragucci.binary`).
+ */
+/** `traceFacts` for `terraform-apply` (#4555). `binary` is the config's `terraform.binary`, `terraform` when it names none. */
+export function terraformTraceFacts(input, outcome, binary) {
+    const bin = (binary ?? "terraform").split(/[\\/]/).pop() || "terraform";
+    return {
+        attributes: {
+            root: input.root,
+            binary: bin,
+            ...("output" in outcome && outcome.output ? { "apply.from_wave_plan": outcome.output.fromWavePlan, "apply.outputs": Object.keys(outcome.output.outputs ?? {}).length } : {}),
+            ...(input.cone ? { "plan.cone": input.cone } : {}),
+        },
+    };
+}

package/dist/compose/apply-events.d.ts

@@ -0,0 +1,46 @@
+/**
+ * How each member's part of a composed apply ended (chant#4442, epic #4419),
+ * read from the binary's `apply -json` lines: `applied`, `partial`,
+ * `failed`, `not-started` or `no-changes`, core's `GroupMemberStatus`
+ * (ws-107).
+ *
+ * Lifted from terragucci's `packages/terragucci/src/compose.ts` at c493e0e
+ * (`readApplyEvents`, `memberApply`).
+ */
+import type { GroupMemberStatus } from "@intentius/chant/components/capability";
+import type { Composition } from "../compose.js";
+/** How one member's part of the apply ended. */
+export type MemberApply = GroupMemberStatus;
+/** What `apply -json` said of each module: the changes that completed, started, or errored, and the first error. */
+export interface ApplyEvents {
+    done: Map<string, number>;
+    started: Map<string, number>;
+    errored: Map<string, string>;
+    /** Errors no module's resource names. */
+    other: string[];
+}
+/** Read `apply -json` lines into each module's progress. A line that is not JSON is skipped. */
+export declare function readApplyEvents(out: string, modules: readonly string[]): ApplyEvents;
+/** How a member's part of the apply ended, from its planned changes and the events. */
+export declare function memberApply(m: string, planned: number, ev: ApplyEvents): {
+    apply: MemberApply;
+    done: number;
+};
+/** One member's outcome of a composed apply. */
+export interface MemberApplyOutcome {
+    status: MemberApply;
+    /** Its planned changes that completed. */
+    done: number;
+    /** The first error its part named. */
+    error?: string;
+}
+/**
+ * Every member's outcome of a composed apply, by component, from the
+ * `apply -json` output and each member's planned changes
+ * (`PlanCounts.changes` of its slice).
+ */
+export declare function composedApplyOutcomes(c: Pick<Composition, "order" | "modules">, planned: ReadonlyMap<string, number>, out: string): {
+    members: Record<string, MemberApplyOutcome>;
+    other: string[];
+};
+//# sourceMappingURL=apply-events.d.ts.map

package/dist/compose/apply-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-events.d.ts","sourceRoot":"","sources":["../../src/compose/apply-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C,gDAAgD;AAChD,MAAM,MAAM,WAAW,GAAG,iBAAiB,CAAC;AAE5C,oHAAoH;AACpH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,yCAAyC;IACzC,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AASD,gGAAgG;AAChG,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,WAAW,CA6BpF;AAED,uFAAuF;AACvF,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,GAAG;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAO7G;AAED,gDAAgD;AAChD,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,CAAC;IACpB,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,SAAS,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAUpM"}

package/dist/compose/apply-events.js

@@ -0,0 +1,77 @@
+/**
+ * How each member's part of a composed apply ended (chant#4442, epic #4419),
+ * read from the binary's `apply -json` lines: `applied`, `partial`,
+ * `failed`, `not-started` or `no-changes`, core's `GroupMemberStatus`
+ * (ws-107).
+ *
+ * Lifted from terragucci's `packages/terragucci/src/compose.ts` at c493e0e
+ * (`readApplyEvents`, `memberApply`).
+ */
+import { stripModule, topModule } from "./module-address.js";
+/** Read `apply -json` lines into each module's progress. A line that is not JSON is skipped. */
+export function readApplyEvents(out, modules) {
+    const ev = { done: new Map(), started: new Map(), errored: new Map(), other: [] };
+    const known = new Set(modules);
+    const moduleOf = (addr) => {
+        const m = addr !== undefined ? topModule(addr) : undefined;
+        return m !== undefined && known.has(m) && addr !== `module.${m}` ? m : undefined;
+    };
+    const bump = (map, m) => map.set(m, (map.get(m) ?? 0) + 1);
+    for (const line of out.split("\n")) {
+        if (!line.startsWith("{"))
+            continue;
+        let e;
+        try {
+            e = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const addr = e.hook?.resource?.addr;
+        const m = moduleOf(addr);
+        if (e.type === "apply_start" && m)
+            bump(ev.started, m);
+        else if (e.type === "apply_complete" && m)
+            bump(ev.done, m);
+        else if (e.type === "apply_errored" && m && !ev.errored.has(m))
+            ev.errored.set(m, `${stripModule(addr)}: ${e.hook?.error ?? e["@message"] ?? "errored"}`);
+        else if (e.type === "diagnostic" && e.diagnostic?.severity === "error") {
+            const dm = moduleOf(e.diagnostic.address);
+            const text = `${e.diagnostic.summary ?? "Error"}${e.diagnostic.detail ? `: ${e.diagnostic.detail.split("\n")[0]}` : ""}`;
+            if (dm && !ev.errored.has(dm))
+                ev.errored.set(dm, `${stripModule(e.diagnostic.address)}: Error: ${text}`);
+            else if (!dm)
+                ev.other.push(text);
+        }
+    }
+    return ev;
+}
+/** How a member's part of the apply ended, from its planned changes and the events. */
+export function memberApply(m, planned, ev) {
+    const done = Math.min(ev.done.get(m) ?? 0, planned);
+    if (planned === 0)
+        return { apply: "no-changes", done: 0 };
+    if (done >= planned)
+        return { apply: "applied", done };
+    if (done > 0)
+        return { apply: "partial", done };
+    if (ev.errored.has(m) || (ev.started.get(m) ?? 0) > 0)
+        return { apply: "failed", done };
+    return { apply: "not-started", done };
+}
+/**
+ * Every member's outcome of a composed apply, by component, from the
+ * `apply -json` output and each member's planned changes
+ * (`PlanCounts.changes` of its slice).
+ */
+export function composedApplyOutcomes(c, planned, out) {
+    const ev = readApplyEvents(out, c.order.map((member) => c.modules.get(member)));
+    const members = {};
+    for (const member of c.order) {
+        const m = c.modules.get(member);
+        const { apply, done } = memberApply(m, planned.get(member) ?? 0, ev);
+        const error = ev.errored.get(m);
+        members[member] = { status: apply, done, ...(error && apply !== "applied" ? { error } : {}) };
+    }
+    return { members, other: ev.other };
+}