@intentius/chant-lexicon-terraform 0.124.31 → 0.124.32

package/dist/hcl/suppressions.js

@@ -0,0 +1,189 @@
+/**
+ * Read `# chant-ignore*` comments out of raw `.tf` text.
+ *
+ * `hcl2json` drops comments entirely, and a probe of its output confirmed it
+ * exposes no source ranges either, so a suppression comment has nothing to
+ * attach to once a file goes through `@cdktn/hcl2json`. This module runs a
+ * second, cheap pass over the SAME raw text `./parse.ts` hands the parser,
+ * entirely with line-oriented regexes: a brace-depth counter to find each
+ * top-level block's start line (`terraform`, `locals`, `provider "x"`,
+ * `module "x"`, `variable "x"`, `output "x"`, `resource "t" "n"`,
+ * `data "t" "n"`, the exact set `blocksToEntities` turns into entities, and
+ * the address format below MUST stay in sync with that function's `add()`
+ * calls), and a directive regex for the three comment forms.
+ *
+ * `scanSuppressions` returns per-file lookups keyed by ADDRESS (`./parse.ts`'s
+ * `TerraformEntity.props.address`, e.g. `provider.aws`, `aws_s3_bucket.assets`)
+ * rather than by entity, because `blocksToEntities` computes an entity's final
+ * map key (with a `~2`/`~3` collision suffix) only after this scan has already
+ * run. A FIFO queue per address reconciles the two traversal orders: this
+ * scan reads the file top to bottom, but `blocksToEntities` walks hcl2json's
+ * tree grouped by section (all `variable` blocks together, then all
+ * `resource` blocks, etc.), not in source order. Two blocks that share one
+ * address (the same genuinely-duplicated declaration) are matched to their
+ * queue slot in file order, same as they're numbered `~2`/`~3` in file order.
+ */
+/** A block header keyword with zero labels (`terraform {`, `locals {`). */
+const BARE_RE = /^\s*(terraform|locals|remote_state)\s*\{/;
+/** One label (`provider "aws" {`, `module "vpc" {`, `variable "x" {`, `output "x" {`). */
+const ONE_LABEL_RE = /^\s*(provider|module|variable|output|dependency|generate)\s+"([^"]*)"\s*\{/;
+/** Two labels (`resource "aws_s3_bucket" "assets" {`, `data "aws_ami" "x" {`). */
+const TWO_LABEL_RE = /^\s*(resource|data)\s+"([^"]*)"\s+"([^"]*)"\s*\{/;
+/** A `#`/`//` comment naming one of the three suppression forms. */
+const DIRECTIVE_RE = /^\s*(?:#|\/\/)\s*chant-ignore(-file|-block)?\s*:?\s*(.*)$/;
+/** `./parse.ts`'s own address format per block kind, kept in sync by hand. */
+function addressFor(keyword, labels) {
+    switch (keyword) {
+        case "terraform":
+            return "terraform";
+        case "locals":
+            return "locals";
+        case "remote_state":
+            return "remote_state";
+        case "dependency":
+            return `dependency.${labels[0]}`;
+        case "generate":
+            return `generate.${labels[0]}`;
+        case "provider":
+            return `provider.${labels[0]}`;
+        case "module":
+            return `module.${labels[0]}`;
+        case "variable":
+            return `var.${labels[0]}`;
+        case "output":
+            return `output.${labels[0]}`;
+        case "resource":
+            return `${labels[0]}.${labels[1]}`;
+        case "data":
+            return `data.${labels[0]}.${labels[1]}`;
+        default:
+            return "";
+    }
+}
+/** Strip quoted string contents so a brace inside a literal (a jsonencode payload) doesn't skew depth tracking. */
+function stripStrings(line) {
+    return line.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+}
+function braceDelta(line) {
+    const stripped = stripStrings(line);
+    let delta = 0;
+    for (const ch of stripped) {
+        if (ch === "{")
+            delta++;
+        else if (ch === "}")
+            delta--;
+    }
+    return delta;
+}
+function parseDirectiveBody(rest) {
+    const tokens = rest.split(/\s+/).filter(Boolean);
+    let expires;
+    const idTokens = [];
+    for (const tok of tokens) {
+        const m = /^exp:(\d{4}-\d{2}-\d{2})$/.exec(tok);
+        if (m) {
+            expires = m[1];
+            continue;
+        }
+        idTokens.push(tok);
+    }
+    const joined = idTokens.join(" ").trim();
+    if (joined === "" || joined.toLowerCase() === "all")
+        return { ids: "all", expires };
+    const ids = new Set(joined
+        .split(/[,\s]+/)
+        .map((s) => s.trim().toUpperCase())
+        .filter(Boolean));
+    return { ids, expires };
+}
+function recordBlockLine(queues, address, lineNo) {
+    const q = queues.get(address) ?? [];
+    q.push(lineNo);
+    queues.set(address, q);
+}
+/**
+ * Scan one `.tf` file's raw text. `fileName` only labels the directives it
+ * returns (for messages and dedup); the scan itself is pure text.
+ */
+export function scanSuppressions(fileName, source) {
+    const lines = source.split("\n");
+    const blockLineQueues = new Map();
+    const byAnchorLine = new Map();
+    let fileDirective;
+    let firstNonBlankLine;
+    let depth = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNo = i + 1;
+        const trimmed = line.trim();
+        if (firstNonBlankLine === undefined && trimmed !== "")
+            firstNonBlankLine = lineNo;
+        const directiveMatch = DIRECTIVE_RE.exec(line);
+        if (directiveMatch) {
+            const suffix = directiveMatch[1];
+            const { ids, expires } = parseDirectiveBody(directiveMatch[2].trim());
+            if (suffix === "-file") {
+                fileDirective = {
+                    form: "chant-ignore-file",
+                    ids,
+                    expires,
+                    file: fileName,
+                    line: lineNo,
+                    misplaced: lineNo !== firstNonBlankLine,
+                    key: `${fileName}:${lineNo}:chant-ignore-file`,
+                };
+            }
+            else {
+                const form = suffix === "-block" ? "chant-ignore-block" : "chant-ignore";
+                const directive = {
+                    form,
+                    ids,
+                    expires,
+                    file: fileName,
+                    line: lineNo,
+                    key: `${fileName}:${lineNo}:${form}`,
+                };
+                const anchorLine = lineNo + 1;
+                const list = byAnchorLine.get(anchorLine) ?? [];
+                list.push(directive);
+                byAnchorLine.set(anchorLine, list);
+            }
+        }
+        else if (depth === 0) {
+            // Only look for a block header on a line that isn't itself a directive
+            // comment, and only at top-level nesting (depth 0 before this line).
+            let m = BARE_RE.exec(line);
+            if (m) {
+                recordBlockLine(blockLineQueues, addressFor(m[1], []), lineNo);
+            }
+            else if ((m = ONE_LABEL_RE.exec(line))) {
+                recordBlockLine(blockLineQueues, addressFor(m[1], [m[2]]), lineNo);
+            }
+            else if ((m = TWO_LABEL_RE.exec(line))) {
+                recordBlockLine(blockLineQueues, addressFor(m[1], [m[2], m[3]]), lineNo);
+            }
+        }
+        depth += braceDelta(line);
+    }
+    return { blockLineQueues, byAnchorLine, fileDirective };
+}
+/** Pop the next recorded start line for `address` (FIFO; see module doc). */
+export function popBlockLine(scan, address) {
+    const q = scan.blockLineQueues.get(address);
+    if (!q || q.length === 0)
+        return undefined;
+    return q.shift();
+}
+/**
+ * Directives to attach to the entity being added for `address`: the ones
+ * anchored to its own start line (`chant-ignore`/`chant-ignore-block`), plus
+ * the file-level one, if any. Every entity in a file carries a file-level
+ * directive, misplaced or not (misplaced ones report themselves but suppress
+ * nothing; see `applyInlineSuppressions`).
+ */
+export function directivesFor(scan, address) {
+    const line = popBlockLine(scan, address);
+    const anchored = line !== undefined ? (scan.byAnchorLine.get(line) ?? []) : [];
+    const all = scan.fileDirective ? [...anchored, scan.fileDirective] : anchored;
+    return { line, suppressions: all.length > 0 ? all : undefined };
+}

package/dist/hcl/value.js

@@ -0,0 +1,72 @@
+/**
+ * A value envelope over a parsed block body (chant #2113).
+ *
+ * Every TF post-synth check reads `BlockBody` (`./parse.ts`), raw
+ * `@cdktn/hcl2json` output, and re-derives, by hand, whether an attribute is
+ * a plain literal, a reference/expression, or absent. tflint's OPA ruleset
+ * hands a policy `{value, unknown, sensitive, ephemeral, range}` per
+ * attribute so a check reads that uniformly instead of re-deriving it
+ * (`tflint-ruleset-opa`'s `docs/functions.md`, cited in the #2107 survey).
+ * `attr()` is the equivalent for chant's static string-based body.
+ *
+ * The shape here is narrower than tflint's for one structural reason.
+ * hcl2json converts HCL to plain JSON with no evaluation and no position
+ * data. There is no live Terraform graph behind this parse, so there is no
+ * `unknown` (this runs over source, not a plan), and no `sensitive`/
+ * `ephemeral` flag (those live on a `variable` block's own attributes, not on
+ * every attribute that happens to reference one; a check that cares reads
+ * the referenced variable's declaration itself). `range` is the one field
+ * tflint's envelope carries that this cannot. hcl2json's own output is bare
+ * values, JSON-round-tripped from HCL, with no line/column/byte-range
+ * attached anywhere in the tree, so there is nothing for `attr()` to read a
+ * position from. (#2111 adds a `props.line` to the *entity*, from a separate
+ * text-based mechanism this file does not touch and is not a substitute for
+ * per-attribute ranges. See that issue for how it gets a line at all.)
+ */
+/**
+ * Every `${...}` span within a string, in source order. One level of nested
+ * `{...}` is tolerated (an object constructor or a map-typed function argument
+ * inside the interpolation), which is as far as a regex can go without
+ * becoming a brace-counting parser. `attr()` below decides `"reference"` vs
+ * `"template"` from how many spans this finds and whether the one span (if
+ * there is exactly one) consumes the whole string, not from a second,
+ * separately-anchored pattern, so the two checks can't disagree about what
+ * counts as an interpolation.
+ */
+const INTERPOLATION_SPANS = /\$\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
+/**
+ * Read one attribute of a parsed block body as a value envelope.
+ *
+ * - `"absent"`: `name` is not a key of `body` at all (or is `undefined`/`null`).
+ * - `"reference"`: the value is a string that is nothing but one
+ *   `${...}` interpolation (`"${aws_s3_bucket.foo.id}"`, `"${var.x}"`,
+ *   `"${lower(var.x)}"`; a function call counts, since the whole value is
+ *   still one expression, not a literal). `refs` carries that one expression.
+ * - `"template"`: the value is a string with `${...}` interpolation mixed
+ *   with literal text (`"prefix-${var.x}-suffix"`, or two interpolations in
+ *   one string). `refs` carries every span found, in source order.
+ * - `"literal"`: anything else. A plain string with no interpolation, a
+ *   number, a boolean, an array, or an object (which is how hcl2json encodes
+ *   a nested block under the same key a caller might ask `attr()` about, so
+ *   a nested block reads as `kind: "literal"` with `value` holding its body
+ *   or bodies array). See `hasBlock()` in `../lint/post-synth/tf001.ts`,
+ *   which is exactly that case.
+ *
+ * A malformed `${` with no matching `}` is not specially detected; it falls
+ * through to `"literal"` (no complete span found), matching hcl2json's own
+ * behavior of passing such text through as a plain string.
+ */
+export function attr(body, name) {
+    const raw = body[name];
+    if (raw === undefined || raw === null)
+        return { kind: "absent", raw };
+    if (typeof raw === "string") {
+        const spans = [...raw.matchAll(INTERPOLATION_SPANS)];
+        if (spans.length === 0)
+            return { kind: "literal", value: raw, raw };
+        const refs = spans.map((m) => m[1].trim());
+        const isWholeString = spans.length === 1 && spans[0].index === 0 && spans[0][0].length === raw.length;
+        return isWholeString ? { kind: "reference", refs, raw } : { kind: "template", refs, raw };
+    }
+    return { kind: "literal", value: raw, raw };
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { terraformPlugin } from "./plugin.js";
-export { terraformCapabilityPlugin, terraformApplyCapability, TERRAFORM_VERB_FAMILIES, type TerraformApplyStepInput, type TerraformApplyStepOutput, } from "./components/capability-plugin.js";
+export { terraformCapabilityPlugin, terraformApplyCapability, TerraformPlanMovedError, TERRAFORM_VERB_FAMILIES, type TerraformApplyStepInput, type TerraformApplyStepOutput, } from "./components/capability-plugin.js";
 export { terraformSerializer } from "./serializer.js";
 export { terraformConfigSchema, terraformRootSchema, type TerraformConfig, type TerraformRootConfig, type TerraformConfigNamespace, } from "./config.js";
 export { blocksToEntities, parseTerraformRootContent, parseTerraformRootDir, readLiveSidecarFile, splitBundleContent, terraformEntity, DATA_TYPE, LIVE_SIDECAR_FILENAME, LIVE_TYPE, LOCALS_TYPE, MODULE_TYPE, OUTPUT_TYPE, PROVIDER_TYPE, RESOURCE_TYPE, TERRAFORM_TYPE, VARIABLE_TYPE, type BlockBody, type TerraformEntity, type TerraformFile, type TerraformRootMode, type TerraformRootModeOptions, } from "./hcl/parse.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAM3C,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,GAC9B,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAKnD,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,GAC9B,MAAM,UAAU,CAAC;AAIlB,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,SAAS,EACT,qBAAqB,EACrB,SAAS,EACT,WAAW,EACX,WAAW,EACX,WAAW,EACX,aAAa,EACb,aAAa,EACb,cAAc,EACd,aAAa,EACb,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,GAC9B,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAK9E,OAAO,EACL,aAAa,EACb,aAAa,EACb,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,mBAAmB,GACpB,MAAM,eAAe,CAAC;AAKvB,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,YAAY,EACV,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,YAAY,EACV,sBAAsB,EACtB,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AAIzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,YAAY,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAIzG,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,YAAY,EAAE,2BAA2B,EAAE,8BAA8B,EAAE,MAAM,uCAAuC,CAAC;AAKzH,OAAO,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAQnE,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,2BAA2B,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,gCAAgC,EACrC,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAM3C,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,GAC9B,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAKnD,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,GAC9B,MAAM,UAAU,CAAC;AAIlB,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,SAAS,EACT,qBAAqB,EACrB,SAAS,EACT,WAAW,EACX,WAAW,EACX,WAAW,EACX,aAAa,EACb,aAAa,EACb,cAAc,EACd,aAAa,EACb,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,GAC9B,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAK9E,OAAO,EACL,aAAa,EACb,aAAa,EACb,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,mBAAmB,GACpB,MAAM,eAAe,CAAC;AAKvB,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,YAAY,EACV,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,YAAY,EACV,sBAAsB,EACtB,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AAIzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,YAAY,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAIzG,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,YAAY,EAAE,2BAA2B,EAAE,8BAA8B,EAAE,MAAM,uCAAuC,CAAC;AAKzH,OAAO,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAQnE,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,2BAA2B,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,gCAAgC,EACrC,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,46 @@
+// Plugin
+export { terraformPlugin } from "./plugin.js";
+// The `terraform-apply` component verb (#3049), contributed to core's
+// capability-plugin seam. Core loads `terraformCapabilityPlugin` when a
+// project's chant.config lists this lexicon, so a component can deploy a root
+// and a fan-out can run many of them in gated waves.
+export { terraformCapabilityPlugin, terraformApplyCapability, TerraformPlanMovedError, TERRAFORM_VERB_FAMILIES, } from "./components/capability-plugin.js";
+// Serializer
+export { terraformSerializer } from "./serializer.js";
+// The `terraform` config namespace. Importing this package is what brings the
+// `terraform` key into `ChantConfig` (#1344), so the augmentation must be
+// reachable from the entry point.
+export { terraformConfigSchema, terraformRootSchema, } from "./config.js";
+// HCL parse: one entity per block, shared by the build path and (from #2085)
+// the audit path.
+export { blocksToEntities, parseTerraformRootContent, parseTerraformRootDir, readLiveSidecarFile, splitBundleContent, terraformEntity, DATA_TYPE, LIVE_SIDECAR_FILENAME, LIVE_TYPE, LOCALS_TYPE, MODULE_TYPE, OUTPUT_TYPE, PROVIDER_TYPE, RESOURCE_TYPE, TERRAFORM_TYPE, VARIABLE_TYPE, } from "./hcl/parse.js";
+export { renderTerraformRoots } from "./hcl/roots.js";
+// Typed Op step builders (#2086). Same names as the activities they wrap, and
+// like k3s's they are opt-in from the lexicon root — the activities themselves
+// are reached by the registry through `./op/activities`, never from here.
+export { terraformInit, terraformPlan, terraformApply, terraformShow, choudoufuLivePlan, choudoufuLiveLs, choudoufuLiveCheck, choudoufuAdopt, terraformPinRollout, } from "./op/builders.js";
+// The adoption ledger over `live-plan -json`'s document (#2105). Pure, and
+// exported because the ledger's shape is what a project reading an Op's own
+// result is reading.
+export { parseAdoptionCommands, readAdoptionLedger, renderAdoptionLedger, } from "./op/adoption.js";
+// The Init/Plan/Gate/Apply composite (#2086).
+export { TerraformApplyOp } from "./composites/terraform-apply-op.js";
+// The Init/Plan/[Report] drift composite (#2087).
+export { TerraformWatchOp } from "./composites/terraform-watch-op.js";
+// The Check/Ledger/Gate/Adopt composite (#2105): reconcile for a choudoufu
+// estate, and #2089's answer for this backend.
+export { TerraformAdoptOp } from "./composites/terraform-adopt-op.js";
+// One pin-bump PR per wave (#3189). The pin edit, wave plan and rollout run
+// are in the `@intentius/chant-lexicon-terraform/pin` subpath.
+export { TerraformPinRolloutOp } from "./composites/terraform-pin-rollout-op.js";
+// Live observation over `terraform show -json` (#2087). The plugin reaches
+// `describeResources` through a dynamic import; the ownership keys are here
+// because `ownershipChannel` declares them eagerly.
+export { TERRAFORM_STATE_OWNERSHIP_KEYS } from "./state-ownership.js";
+// The behaviour engine's request from a terraform estate (#2360): the live
+// path for a choudoufu root, reading `live-ls -json` and `live-plan -json`
+// through the same activities `describeResources` runs, and the same producer
+// over the declaration so the two sides of the delta are built alike. The
+// engine is injected, and defaults to core's front (#2495): this lexicon
+// dials none.
+export { predictTerraformBehaviour, terraformBehaviourRequest, terraformPredictOptionsFrom, TERRAFORM_REFERENCE_CATALOG, } from "./behaviour/index.js";

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "c96ca33f1c91980872e9b08bc0fe13f26c9ef8c714bfbee55452eff9a72a3a80",
+    "manifest.json": "a5897bba742d07d4ca58b354e2b739e0e2a56675d23771a5f9abc3e1aaa3dd64",
     "meta.json": "ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356",
     "types/index.d.ts": "022927e6a7b351cc4cf52d5f973f60ccd140e5810e17b32fb8868965aa1db161",
     "rules/plan-before-apply.ts": "7c10245b2c3335253b48ee7d8b075d89f43116bde20313a5d1031b343fef1282",
@@ -56,5 +56,5 @@
     "rules/tf045.ts": "760b1f4f385fbe7a86897efe3078fdeac11bcc9bfb806285d63db50488174b7b",
     "skills/chant-terraform.md": "d9ca7b7c28aed0038ce775a3491150298492eed2858fd3651ed9bfca0e577ae8"
   },
-  "composite": "3b6307ff1b86a825bf774e112bb4afc9253ec7524ae309416023db854204f37e"
+  "composite": "50dacdccb0421ca5ba3994072257c04477565eab99be70a7bf7b82add19786ff"
 }