@intentius/chant-lexicon-terraform 0.124.51 → 0.124.54

package/dist/compose/hcl.js

@@ -0,0 +1,302 @@
+/**
+ * The HCL a composition reads from a root's files (chant#4438): its backend
+ * and the state that backend names, its `terraform_remote_state` and
+ * `terraform_estate_outputs` reads, its `live` estate, the providers its lock
+ * file pins, and the local modules it calls.
+ *
+ * Lifted from terragucci at c493e0e (`compose.ts` `blankComments`,
+ * `lockedProviders`, `localModules`, `importLiteral`, `jsonBlocks`;
+ * `detect.ts` `blockBody`, `hclAttr`, `stateOf`, `estateOf`,
+ * `estateOutputReads`, `liveRoots`; `linked.ts` `configFiles`), reading a
+ * root's `-backend-config` from `terraform.roots.<name>.backendConfig` where
+ * terragucci read `TF_CLI_ARGS_init`. Regex over text with comments blanked,
+ * as there: no HCL parse runs.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { isJsonConfigFile, listConfigFilesSafe } from "../hcl/files.js";
+import { literal, stateAddress } from "./state-address.js";
+import { readBackend } from "../state/backend.js";
+/**
+ * HCL text with its comments blanked to spaces, newlines kept, so every
+ * position in it is the same position in the text as written. Strings and
+ * their escapes are read through, so a `#` or `//` in one stays.
+ */
+export function blankComments(text) {
+    const out = text.split("");
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (inString) {
+            if (c === "\\")
+                i++;
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"')
+            inString = true;
+        else if (c === "#" || (c === "/" && text[i + 1] === "/")) {
+            for (; i < text.length && text[i] !== "\n"; i++)
+                out[i] = " ";
+        }
+        else if (c === "/" && text[i + 1] === "*") {
+            const end = text.indexOf("*/", i + 2);
+            const stop = end < 0 ? text.length : end + 2;
+            for (; i < stop; i++)
+                if (text[i] !== "\n")
+                    out[i] = " ";
+            i--;
+        }
+    }
+    return out.join("");
+}
+/** The text of the block that starts at `start`: up to the brace that closes its first `{`. */
+export function blockBody(text, start) {
+    let depth = 0;
+    for (let i = text.indexOf("{", start); i >= 0 && i < text.length; i++) {
+        if (text[i] === "{")
+            depth++;
+        else if (text[i] === "}" && --depth === 0)
+            return text.slice(start, i + 1);
+    }
+    return text.slice(start);
+}
+/**
+ * An HCL block's attribute: its string, `null` when it is written as anything
+ * but a plain string, undefined when it is not written.
+ */
+export const hclAttr = (body) => (name) => {
+    const m = body.match(new RegExp(`(?<![\\w.-])${name}\\s*=(?!=)\\s*(.)`));
+    if (!m)
+        return undefined;
+    if (m[1] !== '"')
+        return null;
+    const start = m.index + m[0].length;
+    let out = "";
+    for (let i = start; i < body.length; i++) {
+        if (body[i] === "\\") {
+            out += body[++i] ?? "";
+            continue;
+        }
+        if (body[i] === '"')
+            return literal(out) ?? null;
+        out += body[i];
+    }
+    return null;
+};
+/**
+ * A root's own configuration files, not its modules', as paths: the set the
+ * root's `binary` reads (`.tf` and `.tf.json`, plus `.tofu` and `.tofu.json`
+ * for tofu or choudoufu), from the lexicon's one lister (chant#4457).
+ */
+export function configFiles(dir, binary) {
+    return listConfigFilesSafe(dir, binary).map((n) => join(dir, n));
+}
+/** The text of a root's own configuration files, comments blanked so positions still match. */
+export function rootTexts(dir, binary) {
+    return configFiles(dir, binary).map((f) => {
+        const raw = readFileSync(f, "utf-8");
+        const json = isJsonConfigFile(f);
+        return { file: f, text: json ? raw : blankComments(raw), json };
+    });
+}
+const objectOf = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : undefined);
+/** A block in Terraform's JSON syntax: an object, or a list of objects whose first is taken. */
+const firstOf = (v) => objectOf(Array.isArray(v) ? v[0] : v);
+const parseJson = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** The blocks of a kind in a JSON-syntax file: `{"import": [...]}` or `{"import": {...}}`. */
+export function jsonBlocks(doc, kind) {
+    const v = objectOf(doc)?.[kind];
+    if (Array.isArray(v))
+        return v.filter((x) => !!x && typeof x === "object");
+    return v && typeof v === "object" ? [v] : [];
+}
+const asKey = (a) => ("unresolved" in a ? undefined : a);
+/** A backend configuration value as an address part: a plain string, `null` for anything else written, undefined for none. */
+const configValue = (v) => {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v === "number" || typeof v === "boolean")
+        return String(v);
+    return literal(v) ?? null;
+};
+/**
+ * The state the root at `dir` keeps, and the states its
+ * `terraform_remote_state` blocks read. `rel` is the root's directory
+ * relative to the project, which a `local` path resolves against.
+ *
+ * Which backend and which configuration name the root's own state is
+ * state/backend.ts's {@link readBackend} verdict (chant#4478): the code with
+ * the `-backend-config` flags of `TF_CLI_ARGS`, `TF_CLI_ARGS_init`,
+ * `backendConfigFiles` and `backendConfig` over it, and what `init` recorded
+ * once it has run. A key neither gives is read from the code's own block,
+ * which still names nested ones (a `cloud` or `remote` backend's
+ * `workspaces`). An address the code does not spell in plain strings is left
+ * out, so nothing lines up with it.
+ */
+export function rootState(dir, rel, input = {}) {
+    const out = { reads: [] };
+    // The code's own backend block, the first one as declaredBackend reads it: its type and attributes.
+    let code;
+    for (const { text, json } of rootTexts(dir, input.binary)) {
+        if (json) {
+            const doc = parseJson(text);
+            for (const t of jsonBlocks(doc, "terraform")) {
+                if (code)
+                    break;
+                if (t.cloud !== undefined) {
+                    const b = firstOf(t.cloud);
+                    code = { type: "cloud", get: (n) => literal(b?.[n] ?? firstOf(b?.workspaces)?.[n]) };
+                    break;
+                }
+                const [type, v] = Object.entries(objectOf(t.backend) ?? {})[0] ?? [];
+                if (!type)
+                    continue;
+                const b = firstOf(v);
+                code = { type, get: (n) => literal(b?.[n] ?? firstOf(b?.workspaces)?.[n]) };
+            }
+            for (const d of jsonBlocks(doc, "data")) {
+                for (const [name, v] of Object.entries(objectOf(d.terraform_remote_state) ?? {})) {
+                    const b = firstOf(v);
+                    const config = objectOf(b?.config);
+                    const type = literal(b?.backend);
+                    if (!config || typeof type !== "string")
+                        continue;
+                    const key = asKey(stateAddress(type, (n) => literal(config[n] ?? firstOf(config.workspaces)?.[n]), rel));
+                    if (key)
+                        out.reads.push({ name, ...key, repeated: b?.count !== undefined || b?.for_each !== undefined });
+                }
+            }
+            continue;
+        }
+        if (!code) {
+            const m = text.match(/\bbackend\s+"([^"]+)"\s*\{/);
+            if (m)
+                code = { type: m[1], get: hclAttr(blockBody(text, m.index)) };
+            else {
+                const c = /^\s*cloud\s*\{/m.exec(text);
+                if (c)
+                    code = { type: "cloud", get: hclAttr(blockBody(text, c.index)) };
+            }
+        }
+        for (const m of text.matchAll(/\bdata\s+"terraform_remote_state"\s+"([^"]+)"\s*\{/g)) {
+            const body = blockBody(text, m.index);
+            const type = hclAttr(body)("backend");
+            if (typeof type !== "string")
+                continue;
+            const config = /\bconfig\s*=\s*\{/.exec(body);
+            const get = config ? hclAttr(blockBody(body, config.index)) : () => undefined;
+            const key = asKey(stateAddress(type, get, rel));
+            if (key)
+                out.reads.push({ name: m[1], ...key, repeated: /^\s*(count|for_each)\s*=/m.test(body) });
+        }
+    }
+    const { backend } = readBackend(dir, input);
+    const fromCode = code?.type === backend.type ? code.get : () => undefined;
+    const get = (n) => configValue(backend.config[n] ?? objectOf(backend.config.workspaces)?.[n]) ?? fromCode(n);
+    out.own = asKey(stateAddress(backend.type, get, rel));
+    return out;
+}
+/** Two addresses name one state: the same key, and the same bucket where both name one. */
+export const sameState = (a, b) => a.key === b.key && (!a.bucket || !b.bucket || a.bucket === b.bucket);
+const LIVE_SIDECAR = "estate.chdf.hcl";
+/**
+ * A choudoufu root's estate, from its `estate.chdf.hcl` or the `live` block in
+ * its `terraform` block; undefined when it declares none. A `live` block takes
+ * effect only under choudoufu, so the files read are the ones choudoufu reads
+ * unless `binary` names another.
+ */
+export function liveEstate(dir, binary = "choudoufu") {
+    const sidecar = join(dir, LIVE_SIDECAR);
+    if (existsSync(sidecar)) {
+        const estate = hclAttr(blankComments(readFileSync(sidecar, "utf-8")))("estate");
+        return { live: true, ...(typeof estate === "string" ? { estate } : {}) };
+    }
+    for (const { text, json } of rootTexts(dir, binary)) {
+        if (json)
+            continue;
+        for (const t of text.matchAll(/^\s*terraform\s*\{/gm)) {
+            const body = blockBody(text, t.index);
+            const live = body.match(/\blive\s*\{/);
+            if (!live)
+                continue;
+            const estate = hclAttr(blockBody(body, live.index))("estate");
+            return { live: true, ...(typeof estate === "string" ? { estate } : {}) };
+        }
+    }
+    return { live: false };
+}
+/** Each `data "terraform_estate_outputs"` block of a root: its label and the estate whose outputs it reads. */
+export function estateOutputReads(dir, binary) {
+    const out = [];
+    for (const { text, json } of rootTexts(dir, binary)) {
+        if (json)
+            continue;
+        for (const m of text.matchAll(/\bdata\s+"terraform_estate_outputs"\s+"([^"]+)"\s*\{/g)) {
+            const e = hclAttr(blockBody(text, m.index))("estate");
+            if (typeof e === "string")
+                out.push({ name: m[1], estate: e });
+        }
+    }
+    return out;
+}
+/** The provider versions a root's lock file pins, by provider address. */
+export function lockedProviders(dir) {
+    const out = new Map();
+    let text = "";
+    try {
+        text = readFileSync(join(dir, ".terraform.lock.hcl"), "utf-8");
+    }
+    catch {
+        return out;
+    }
+    for (const m of text.matchAll(/^provider\s+"([^"]+)"\s*\{/gm)) {
+        const v = blockBody(text, m.index).match(/\bversion\s*=\s*"([^"]+)"/)?.[1];
+        if (v)
+            out.set(m[1], v);
+    }
+    return out;
+}
+/** Local module directories the root at `dir` calls (`source = "./..."` or `"../..."`), followed through, absolute. */
+export function localModules(dir, binary) {
+    const seen = new Set();
+    const queue = [resolve(dir)];
+    while (queue.length > 0) {
+        const at = queue.pop();
+        for (const { text, json } of rootTexts(at, binary)) {
+            if (json)
+                continue;
+            for (const m of text.matchAll(/\bmodule\s+"[^"]+"\s*\{/g)) {
+                const src = blockBody(text, m.index).match(/\bsource\s*=\s*"(\.{1,2}\/[^"]*)"/)?.[1];
+                if (!src)
+                    continue;
+                const abs = resolve(at, src);
+                if (seen.has(abs) || abs === resolve(dir))
+                    continue;
+                seen.add(abs);
+                queue.push(abs);
+            }
+        }
+    }
+    return [...seen].sort();
+}
+/** `abs` relative to `from`, with `/` between parts, `.` for `from` itself. */
+export const relPath = (from, abs) => relative(from, abs).split("\\").join("/") || ".";
+/** An `import` block the composed root can take as it is: a literal string id, no for_each, no provider of the root's own. */
+export function importLiteral(body) {
+    if (/^\s*(for_each|provider)\s*=/m.test(body))
+        return false;
+    return /^\s*id\s*=\s*"(?:[^"\\$%]|\\.)*"\s*$/m.test(body);
+}
+/** Whether a JSON-syntax `import` block takes no literal string id (or has for_each or a provider). */
+export function jsonImportRefused(text) {
+    return jsonBlocks(parseJson(text), "import").some((b) => typeof b.id !== "string" || /\$\{|%\{/.test(b.id) || b.for_each !== undefined || b.provider !== undefined);
+}

package/dist/compose/module-address.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Addresses in a composed root (chant#4442): each member a top-level
+ * `module.<m>` call, so a member's addresses are the composed root's with
+ * `module.<m>.` taken off. `chant terraform report` (../report.ts) and the
+ * composed run's slicer (./slice.ts) and state split (./state-merge.ts) all
+ * strip with these functions, so there is one implementation.
+ */
+type Json = Record<string, unknown>;
+/** The top-level module an address or module address is in, or undefined for the composed root's own. */
+export declare function topModule(address: string): string | undefined;
+/** `address` with its leading `module.<m>` (and index) taken off. An address in no module is returned as it is. */
+export declare function stripModule(address: string): string;
+/** Whether `address` is `module.<m>` or inside it. */
+export declare const inModule: (address: string | undefined, m: string) => boolean;
+/**
+ * A `resource_changes` (or `resource_drift`) entry with its top module taken
+ * off `address`, `previous_address` and `module_address`. A module address
+ * that was the top module itself is dropped, as a root planned alone has none.
+ */
+export declare function stripChange(rc: Json): Json;
+/** The entries of a `resource_changes` list in module `m` (undefined: the composed root's own), each stripped. */
+export declare function moduleChanges(list: unknown, m: string | undefined): Json[];
+export {};
+//# sourceMappingURL=module-address.d.ts.map

package/dist/compose/module-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-address.d.ts","sourceRoot":"","sources":["../../src/compose/module-address.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAMpC,yGAAyG;AACzG,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE7D;AAED,mHAAmH;AACnH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED,sDAAsD;AACtD,eAAO,MAAM,QAAQ,YAAa,MAAM,GAAG,SAAS,KAAK,MAAM,KAAG,OAA4D,CAAC;AAE/H;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,IAAI,GAAG,IAAI,CAS1C;AAED,kHAAkH;AAClH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAAE,CAG1E"}

package/dist/compose/module-address.js

@@ -0,0 +1,43 @@
+/**
+ * Addresses in a composed root (chant#4442): each member a top-level
+ * `module.<m>` call, so a member's addresses are the composed root's with
+ * `module.<m>.` taken off. `chant terraform report` (../report.ts) and the
+ * composed run's slicer (./slice.ts) and state split (./state-merge.ts) all
+ * strip with these functions, so there is one implementation.
+ */
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const TOP_MODULE = /^module\.([^.[\]]+)(?:\[(?:"(?:[^"\\]|\\.)*"|\d+)\])?(?:\.|$)/;
+/** The top-level module an address or module address is in, or undefined for the composed root's own. */
+export function topModule(address) {
+    return TOP_MODULE.exec(address)?.[1];
+}
+/** `address` with its leading `module.<m>` (and index) taken off. An address in no module is returned as it is. */
+export function stripModule(address) {
+    const m = TOP_MODULE.exec(address);
+    return m ? address.slice(m[0].length) : address;
+}
+/** Whether `address` is `module.<m>` or inside it. */
+export const inModule = (address, m) => address !== undefined && topModule(address) === m;
+/**
+ * A `resource_changes` (or `resource_drift`) entry with its top module taken
+ * off `address`, `previous_address` and `module_address`. A module address
+ * that was the top module itself is dropped, as a root planned alone has none.
+ */
+export function stripChange(rc) {
+    const out = { ...rc, address: stripModule(String(rc.address)) };
+    if (typeof rc.previous_address === "string")
+        out.previous_address = stripModule(rc.previous_address);
+    if (typeof rc.module_address === "string") {
+        const rest = stripModule(rc.module_address);
+        if (rest === "" || rest === rc.module_address)
+            delete out.module_address;
+        else
+            out.module_address = rest;
+    }
+    return out;
+}
+/** The entries of a `resource_changes` list in module `m` (undefined: the composed root's own), each stripped. */
+export function moduleChanges(list, m) {
+    const changes = Array.isArray(list) ? list : [];
+    return changes.filter((r) => isObject(r) && topModule(String(r.module_address ?? r.address ?? "")) === m).map(stripChange);
+}

package/dist/compose/root.d.ts

@@ -0,0 +1,127 @@
+/**
+ * The composed root (chant#4441, epic #4419): the temporary root a composed
+ * run plans, one `module` call per member, written into the checkout under
+ * `.chant-compose/`, and every file put back once the run ends.
+ *
+ * Lifted from terragucci's `packages/terragucci/src/compose.ts` at c493e0e
+ * (the composed root section: `writeComposedRoot`, `writeEstateRoot`,
+ * `unionLock`, `liftBlock`, `rewriteJson`, `hclAttributes`, `cliVarFiles`,
+ * `withoutVarFiles`, `rootVarValues`, `declaredVariables`,
+ * `declaredOutputs`; `linked.ts` `refRe`, `hclValue`), taking the
+ * {@link Composition} of `../compose.ts` (#4438). What changed:
+ *
+ * - The directory is `.chant-compose/` and the file each root gains is
+ *   `chant_compose.tf`; a read becomes `var.chant_read_<label>` (#4419
+ *   ruling 5).
+ * - A member is a component; its root's directory is `Composition.dirs`, so a
+ *   module's `source` is that directory relative to the composed root.
+ * - A root's var files are `terraform.roots.<name>.varFiles` as well as its
+ *   tfvars, auto tfvars and `TF_CLI_ARGS` `-var-file`s, and its step's
+ *   `vars` win over all of them, as `-var` does today.
+ * - A `stackOutput()` in a member's `vars` that names another member becomes
+ *   `module.<upstream>.<output>`; one that names a component outside the
+ *   group stays the literal value the step would pass.
+ * - A write that throws partway puts back what it changed before it throws,
+ *   and each root file is kept as bytes, so `restore()` leaves it identical.
+ *
+ * While a root is composed its `backend` block, its `terraform_remote_state`
+ * blocks that read another member, and its `import` and `removed` blocks are
+ * cut from its files. `moved` blocks stay: a module takes them.
+ */
+import { type DriverComponent } from "@intentius/chant/components/driver";
+import type { Composition } from "../compose.js";
+import type { TerraformConfig } from "../config.js";
+import { type RootText } from "./hcl.js";
+/** Where the composed root is written, in the checkout (#4419 ruling 5). */
+export declare const COMPOSE_DIR = ".chant-compose";
+/** The file a composed run adds to each root it composes, declaring the variables its reads become. */
+export declare const COMPOSE_FILE = "chant_compose.tf";
+/** The prefix of the variable a member's read of another member becomes. */
+export declare const READ_VAR_PREFIX = "chant_read_";
+/** The top-level `name = expression` attributes of an HCL attribute file (a `.tfvars`), comments blanked. */
+export declare function hclAttributes(text: string): Map<string, string>;
+/** A JSON value as an HCL expression. */
+export declare function hclValue(value: unknown): string;
+/** A reference to the `terraform_remote_state` block `name`, not to one whose label starts with it. */
+export declare const refRe: (name: string, flags?: string) => RegExp;
+/** A root's declared variables: the type expression and whether it is sensitive. */
+export declare function declaredVariables(texts: readonly Pick<RootText, "text" | "json">[]): Map<string, {
+    type?: string;
+    sensitive: boolean;
+}>;
+/** A root's outputs and whether each is sensitive. */
+export declare function declaredOutputs(texts: readonly Pick<RootText, "text" | "json">[]): Map<string, boolean>;
+/** The `-var-file` paths `TF_CLI_ARGS` and `TF_CLI_ARGS_plan` name, as the binary reads them, relative to the root. */
+export declare function cliVarFiles(env: NodeJS.ProcessEnv): string[];
+/** `env` with the `-var-file` flags taken out of `TF_CLI_ARGS` and `TF_CLI_ARGS_plan`: the composed run passes those files' values as module arguments. */
+export declare function withoutVarFiles(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * A root's variable values as the binary would read them, by name, each an
+ * HCL expression: its tfvars files, its auto tfvars files, the `TF_CLI_ARGS`
+ * `-var-file`s, then `varFiles` (the `-var-file`s chant passes), later over
+ * earlier.
+ */
+export declare function rootVarValues(dir: string, env: NodeJS.ProcessEnv, varFiles?: readonly string[]): Map<string, string>;
+/** Each member's `terraform-apply` step `vars`, as written, for {@link ComposedRootInput.vars}. */
+export declare function memberVars(components: readonly DriverComponent[], c: Pick<Composition, "members">): Record<string, Record<string, unknown>>;
+/** The composed root as written: what to put back, and the generated files that join its digest. */
+export interface ComposedRoot {
+    /** The composed root's directory, absolute. */
+    dir: string;
+    /** The root files rewritten while the run lasts, relative to the project, sorted. {@link restore} puts each back. */
+    rewritten: string[];
+    /** sha256 of each generated file, by its path relative to the project, sorted. The run binds them (#4440, #4444). */
+    generated: [string, string][];
+    /** Each member's outputs, by component, and whether each is sensitive. The composed root re-exports each as `<module>__<name>`. */
+    outputs: Map<string, Map<string, boolean>>;
+    /** Put every root file back as it was and take the generated files away. Safe to call more than once. */
+    restore: () => void;
+}
+export interface ComposedRootInput {
+    /** The checkout's root: where `chant.config.*` was loaded from. `.chant-compose/` is written here. */
+    projectRoot: string;
+    /** What `compositionFor` answered, with members. */
+    composition: Composition;
+    /** The config's `terraform` namespace: each root's `varFiles`. */
+    terraform: TerraformConfig;
+    /** The environment the run has: `TF_CLI_ARGS*` `-var-file`s and `TF_VAR_*` are read from it. */
+    env: NodeJS.ProcessEnv;
+    /** Each member's step `vars` as written, by component ({@link memberVars}). `$env.*` strings are taken as they are. */
+    vars?: Readonly<Record<string, Record<string, unknown> | undefined>>;
+    /** The outputs of components outside the group that a member's `vars` read. */
+    componentOutputs?: Record<string, Record<string, unknown>>;
+    /** How a file is written. Default `writeFileSync`; a test injects a failure here. Putting files back always uses `writeFileSync`. */
+    write?: (file: string, text: string) => void;
+}
+/**
+ * Write the composed root of `composition` into `.chant-compose/` and rewrite
+ * each member: its backend block cut, its `terraform_remote_state` reads of
+ * other members cut and their references turned into a variable the composed
+ * root fills with `{ outputs = module.<upstream> }`, and its `import` and
+ * `removed` blocks lifted into the composed root with `module.<m>.` in front
+ * of their addresses. Each root's variable values, then its step's `vars`,
+ * become the module's arguments. Throws, changing nothing, when a root
+ * already has a `chant_compose.tf`; throws after putting everything back
+ * when a write fails partway.
+ */
+export declare function writeComposedRoot(input: ComposedRootInput): ComposedRoot;
+/** An `import` or `removed` block of module `m`, lifted into the composed root: its address with `module.<m>.` in front. */
+export declare function liftBlock(body: string, kind: "import" | "removed", m: string): string;
+/** A JSON-syntax file rewritten as {@link writeComposedRoot} rewrites HCL: its backend, its reads of members, and its import and removed blocks out. */
+export declare function rewriteJson(raw: string, reads: readonly {
+    name: string;
+}[], m: string, lifted: string[]): string;
+/** The union of the roots' `.terraform.lock.hcl`: one block per provider, with every hash any root's file holds for it. */
+export declare function unionLock(dirs: readonly string[]): string | undefined;
+/**
+ * The composed root of an estate run (`Composition.estate`), written into
+ * `.chant-compose/`: one `module` call per estate whose `source` is the
+ * estate's own directory and nothing else, and each estate's outputs
+ * re-exported as `<module>__<name>`, which is where the plan shows what an
+ * estate's output will be. No estate file is changed, so `restore()` only
+ * takes the generated files away. choudoufu reads each called directory's
+ * own `live` block, and resolves a `terraform_estate_outputs` read of
+ * another estate inside the run.
+ */
+export declare function writeEstateRoot(input: Pick<ComposedRootInput, "projectRoot" | "composition" | "write">): ComposedRoot;
+//# sourceMappingURL=root.d.ts.map

package/dist/compose/root.d.ts.map

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