@intentius/chant 0.41.20 → 0.42.1

package/src/terraform/bridge.ts

@@ -19,7 +19,8 @@
  * is reversible via `terraform import`.
  */
 
-import type { CarveReport } from "./carve";
+import { deferredParamName, type CarveReport } from "./carve";
+import { exciseResourceBlocks, type ExciseTarget } from "./excise";
 
 export interface CarvedIdentity {
   /** The HCL identity attribute, e.g. `bucket` or `name`. */
@@ -41,12 +42,16 @@ export interface FileRewrite {
   original: string;
   rewritten: string;
   changed: boolean;
+  /** Carved addresses whose own `resource` block was removed from this file (#998). */
+  excised: string[];
 }
 
 export interface DeferredInput {
   survivor: string;
   carved: string;
   attrs: string[];
+  /** Build-parameter name(s) the input becomes in the emitted project (#998). */
+  params: string[];
   note: string;
 }
 
@@ -55,6 +60,8 @@ export interface BridgePlan {
   dataSources: DataSourceBlock[];
   rewrites: FileRewrite[];
   deferredInputs: DeferredInput[];
+  /** Every carved address whose own block the rewrites remove, across files. */
+  excised: string[];
   runbook: string;
 }
 
@@ -99,33 +106,56 @@ export function generateBridge(
     hcl: dataSourceHcl(type, name, identities.get(address) ?? {}),
   }));
 
-  // Rewrite every survivor reference to the carved resources into a data ref.
+  // Excise the carve set's own blocks (#998): after `terraform state rm`, a
+  // block left behind would re-create the resource on the next apply. Then
+  // rewrite every remaining survivor reference into a data ref.
+  const exciseTargets: ExciseTarget[] = report.carveSet
+    .filter((m) => !m.address.startsWith("module."))
+    .map((m) => {
+      const [type, ...rest] = m.address.split(".");
+      return { address: m.address, type, name: rest.join(".") };
+    });
   const rewrites: FileRewrite[] = files.map(({ path, content }) => {
-    let rewritten = content;
+    const excision = exciseResourceBlocks(content, exciseTargets);
+    let rewritten = excision.content;
     for (const address of carvedWithInbound.keys()) {
       rewritten = rewritten.replace(referenceRegex(address), `data.${address}`);
     }
-    return { path, original: content, rewritten, changed: rewritten !== content };
+    return { path, original: content, rewritten, changed: rewritten !== content, excised: excision.excised };
   });
+  const excised = rewrites.flatMap((r) => r.excised);
 
-  const deferredInputs: DeferredInput[] = report.outbound.map((e) => ({
-    survivor: e.survivor,
-    carved: e.carved,
-    attrs: e.attrs,
-    note: `${e.carved} reads ${e.survivor}.${e.attrs.join(", ")} — supply this as a deploy-time input to the carved component at apply.`,
-  }));
+  const deferredInputs: DeferredInput[] = report.outbound.map((e) => {
+    const params = (e.via ?? []).map(deferredParamName);
+    const wiring = params.length
+      ? `emit declares it as build param ${params.map((p) => `\`${p}\``).join(", ")} — override with --param at build`
+      : "supply this as a deploy-time input to the carved component at apply";
+    return {
+      survivor: e.survivor,
+      carved: e.carved,
+      attrs: e.attrs,
+      params,
+      note: `${e.carved} reads ${e.survivor}.${e.attrs.join(", ")} — ${wiring}.`,
+    };
+  });
 
   return {
     target: report.target,
     dataSources,
     rewrites,
     deferredInputs,
-    runbook: buildRunbook(report, dataSources, deferredInputs),
+    excised,
+    runbook: buildRunbook(report, dataSources, deferredInputs, excised),
   };
 }
 
 /** The reversible, observe-first handoff runbook (#197). */
-function buildRunbook(report: CarveReport, dataSources: DataSourceBlock[], deferred: DeferredInput[]): string {
+function buildRunbook(
+  report: CarveReport,
+  dataSources: DataSourceBlock[],
+  deferred: DeferredInput[],
+  excised: string[],
+): string {
   const carvedAddrs = report.carveSet.map((m) => m.address);
   const L: string[] = [];
   L.push(`# Carve-out: ${report.target} → chant   [observe-first, reversible]`);
@@ -140,10 +170,14 @@ function buildRunbook(report: CarveReport, dataSources: DataSourceBlock[], defer
   L.push("");
   L.push("## 3. Confirm no destroy, then patch the survivors");
   L.push("    terraform plan   # expect 0 to destroy; refs to the carved resource now error");
+  if (excised.length) {
+    L.push(`    # the generated bridge patch removes the carved block(s): ${excised.join(", ")}`);
+    L.push("    #   (without this, the next apply would re-create what state rm released)");
+  }
   if (dataSources.length) {
-    L.push("    # apply the generated bridge patch — it adds these data sources and rewires references:");
+    L.push("    # it also adds these data sources and rewires references:");
     for (const ds of dataSources) L.push(`    #   data.${ds.type}.${ds.name}  (for ${ds.address})`);
-  } else {
+  } else if (!excised.length) {
     L.push("    # no inbound edges — no survivor patch needed.");
   }
   L.push("    terraform plan   # expect: in-place updates to the survivors only");

package/src/terraform/carve.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from "vitest";
-import { buildGraph } from "./graph";
+import { buildFixtureGraph } from "./__fixtures__/build-graph";
 import { resolveCarveSet, boundaryReport } from "./carve";
 import type { Hcl2JsonTree } from "./types";
 
@@ -27,7 +27,7 @@ const workedExample: Hcl2JsonTree = {
 
 describe("resolveCarveSet", () => {
   test("selected node plus its folded sub-resources", () => {
-    const set = resolveCarveSet(buildGraph(workedExample), "aws_s3_bucket.assets");
+    const set = resolveCarveSet(buildFixtureGraph(workedExample), "aws_s3_bucket.assets");
     expect(set.map((m) => m.address).sort()).toEqual([
       "aws_s3_bucket.assets",
       "aws_s3_bucket_versioning.assets",
@@ -37,13 +37,13 @@ describe("resolveCarveSet", () => {
   });
 
   test("empty for an unknown address", () => {
-    expect(resolveCarveSet(buildGraph(workedExample), "aws_s3_bucket.nope")).toEqual([]);
+    expect(resolveCarveSet(buildFixtureGraph(workedExample), "aws_s3_bucket.nope")).toEqual([]);
   });
 });
 
 describe("boundaryReport", () => {
   test("classifies the Lambda inbound edge; folds the versioning internal edge away", () => {
-    const report = boundaryReport(buildGraph(workedExample), "aws_s3_bucket.assets")!;
+    const report = boundaryReport(buildFixtureGraph(workedExample), "aws_s3_bucket.assets")!;
     expect(report.target).toBe("aws_s3_bucket.assets");
     expect(report.peelability).toBe(88);
     expect(report.reversible).toBe(true);
@@ -56,6 +56,7 @@ describe("boundaryReport", () => {
         survivor: "aws_lambda_function.api",
         carved: "aws_s3_bucket.assets",
         attrs: ["arn", "bucket"],
+        via: ["environment"],
         bridge: "tf-data-source",
         required: "immediately",
       },
@@ -71,7 +72,7 @@ describe("boundaryReport", () => {
       },
     };
     // Carve the queue: it depends on the topic (a survivor) → outbound/deferred.
-    const report = boundaryReport(buildGraph(tree), "aws_sqs_queue.dlq")!;
+    const report = boundaryReport(buildFixtureGraph(tree), "aws_sqs_queue.dlq")!;
     expect(report.inbound).toEqual([]);
     expect(report.outbound).toEqual([
       {
@@ -79,6 +80,7 @@ describe("boundaryReport", () => {
         survivor: "aws_sns_topic.alerts",
         carved: "aws_sqs_queue.dlq",
         attrs: ["arn"],
+        via: ["redrive"],
         bridge: "deferred-input",
         required: "at-apply",
       },
@@ -87,11 +89,11 @@ describe("boundaryReport", () => {
 
   test("unsupported type is flagged in diagnostics", () => {
     const tree: Hcl2JsonTree = { resource: { random_pet: { n: [{ length: 2 }] } } };
-    const report = boundaryReport(buildGraph(tree), "random_pet.n")!;
+    const report = boundaryReport(buildFixtureGraph(tree), "random_pet.n")!;
     expect(report.diagnostics.join(" ")).toMatch(/no known native mapping/i);
   });
 
   test("null for an unknown target", () => {
-    expect(boundaryReport(buildGraph(workedExample), "aws_s3_bucket.nope")).toBeNull();
+    expect(boundaryReport(buildFixtureGraph(workedExample), "aws_s3_bucket.nope")).toBeNull();
   });
 });

package/src/terraform/excise.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, expect } from "vitest";
+import { exciseResourceBlocks, type ExciseTarget } from "./excise";
+
+const bucket: ExciseTarget = { address: "aws_s3_bucket.assets", type: "aws_s3_bucket", name: "assets" };
+const versioning: ExciseTarget = {
+  address: "aws_s3_bucket_versioning.assets",
+  type: "aws_s3_bucket_versioning",
+  name: "assets",
+};
+
+describe("exciseResourceBlocks", () => {
+  test("removes the target block, leaves the rest byte-for-byte", () => {
+    const tf = `# the bucket
+resource "aws_s3_bucket" "assets" {
+  bucket = "myapp-assets-prod"
+  tags   = { Team = "web" }
+}
+
+resource "aws_lambda_function" "api" {
+  function_name = "myapp-api"
+}
+`;
+    const r = exciseResourceBlocks(tf, [bucket]);
+    expect(r.excised).toEqual(["aws_s3_bucket.assets"]);
+    expect(r.content).toBe(`# the bucket
+resource "aws_lambda_function" "api" {
+  function_name = "myapp-api"
+}
+`);
+  });
+
+  test("removes several targets (a folded sub-resource travels with its parent)", () => {
+    const tf = `resource "aws_s3_bucket" "assets" {
+  bucket = "b"
+}
+
+resource "aws_s3_bucket_versioning" "assets" {
+  bucket = aws_s3_bucket.assets.id
+  versioning_configuration {
+    status = "Enabled"
+  }
+}
+
+resource "aws_sns_topic" "alerts" {
+  name = "a"
+}
+`;
+    const r = exciseResourceBlocks(tf, [bucket, versioning]);
+    expect(r.excised).toEqual(["aws_s3_bucket.assets", "aws_s3_bucket_versioning.assets"]);
+    expect(r.content).toBe(`resource "aws_sns_topic" "alerts" {\n  name = "a"\n}\n`);
+  });
+
+  test("a same-name block of a different type stays", () => {
+    const tf = `resource "aws_s3_bucket" "assets" { bucket = "b" }
+resource "aws_s3_bucket_versioning" "assets" { bucket = "b" }
+`;
+    const r = exciseResourceBlocks(tf, [bucket]);
+    expect(r.excised).toEqual(["aws_s3_bucket.assets"]);
+    expect(r.content).toContain('resource "aws_s3_bucket_versioning" "assets"');
+  });
+
+  test("braces inside strings, interpolations, comments, and heredocs do not fool the scanner", () => {
+    const tf = `resource "aws_s3_bucket" "assets" {
+  bucket = "b"
+  # a } in a comment
+  policy = jsonencode({ Statement = [{ Effect = "Allow" }] })
+  note   = "literal } and \${var.m["k}"]} too"
+  user_data = <<EOF
+    if true; then echo "}"; fi
+EOF
+}
+resource "aws_sns_topic" "alerts" { name = "a" }
+`;
+    const r = exciseResourceBlocks(tf, [bucket]);
+    expect(r.excised).toEqual(["aws_s3_bucket.assets"]);
+    expect(r.content).toBe(`resource "aws_sns_topic" "alerts" { name = "a" }\n`);
+  });
+
+  test("no target present → the file comes back unchanged", () => {
+    const tf = `resource "aws_sns_topic" "alerts" { name = "a" }\n`;
+    const r = exciseResourceBlocks(tf, [bucket]);
+    expect(r.excised).toEqual([]);
+    expect(r.content).toBe(tf);
+  });
+
+  test("an unbalanced block is left alone rather than corrupted", () => {
+    const tf = `resource "aws_s3_bucket" "assets" {\n  bucket = "b"\n`;
+    const r = exciseResourceBlocks(tf, [bucket]);
+    expect(r.excised).toEqual([]);
+    expect(r.content).toBe(tf);
+  });
+});

package/src/terraform/excise.ts

@@ -0,0 +1,139 @@
+/**
+ * Excision of a carved resource's own `resource "<type>" "<name>"` block from
+ * the surviving Terraform source (#998 — closes the "auto-excise" limitation).
+ *
+ * After `terraform state rm`, the block left behind would re-CREATE the
+ * resource on the next apply — the one edit the bridge previously left to
+ * hand-work. This removes the carve set's own blocks as part of the survivor
+ * rewrite, so the one bridge `.patch` (#1589) carries the whole handoff edit.
+ *
+ * Pure text transform. The scanner tracks brace depth outside of strings,
+ * comments, template interpolations, and heredocs — enough for real `.tf`
+ * files without pulling in the wasm parser for what is a subtractive edit.
+ */
+
+export interface ExciseTarget {
+  /** Terraform address, e.g. `aws_s3_bucket.assets`. */
+  address: string;
+  type: string;
+  name: string;
+}
+
+export interface ExciseResult {
+  content: string;
+  /** Addresses whose block was found and removed, in file order. */
+  excised: string[];
+}
+
+const HEADER = /^\s*resource\s+"([^"]+)"\s+"([^"]+)"\s*\{/;
+
+/**
+ * Remove the targets' own `resource` blocks from one `.tf` file's text. A
+ * comment line directly above a removed block stays (it may describe more
+ * than the block); the blank line the removal leaves behind is collapsed.
+ */
+export function exciseResourceBlocks(content: string, targets: ExciseTarget[]): ExciseResult {
+  if (targets.length === 0) return { content, excised: [] };
+  const wanted = new Map(targets.map((t) => [`${t.type}.${t.name}`, t.address]));
+  const lines = content.split("\n");
+  const excised: string[] = [];
+  const out: string[] = [];
+
+  let i = 0;
+  while (i < lines.length) {
+    const m = lines[i].match(HEADER);
+    const key = m ? `${m[1]}.${m[2]}` : undefined;
+    if (!m || !wanted.has(key!)) {
+      out.push(lines[i]);
+      i++;
+      continue;
+    }
+
+    const end = blockEnd(lines, i);
+    if (end === -1) {
+      // Unbalanced block — leave the file alone rather than corrupt it.
+      out.push(lines[i]);
+      i++;
+      continue;
+    }
+    excised.push(wanted.get(key!)!);
+    i = end + 1;
+    // Swallow the separator blank line so the removal leaves no doubled gap.
+    if (i < lines.length && lines[i].trim() === "") i++;
+  }
+
+  return { content: out.join("\n"), excised };
+}
+
+/** Index of the line closing the block opened on `start`, or -1 if unbalanced. */
+function blockEnd(lines: string[], start: number): number {
+  // Context stack: block/object braces, strings, `${` interpolations, block
+  // comments. The header's `{` pushes the first "brace"; the block closes when
+  // the stack empties.
+  const stack: Array<"brace" | "string" | "interp" | "comment"> = [];
+  let opened = false;
+  let heredoc: string | null = null;
+
+  for (let ln = start; ln < lines.length; ln++) {
+    const line = lines[ln];
+    if (heredoc !== null) {
+      if (line.trim() === heredoc) heredoc = null;
+      continue;
+    }
+
+    for (let c = 0; c < line.length; c++) {
+      const top = stack[stack.length - 1];
+      const ch = line[c];
+      const next = line[c + 1];
+
+      if (top === "comment") {
+        if (ch === "*" && next === "/") {
+          stack.pop();
+          c++;
+        }
+        continue;
+      }
+
+      if (top === "string") {
+        if (ch === "\\") {
+          c++;
+        } else if (ch === "$" && next === "{" && line[c - 1] !== "$") {
+          stack.push("interp");
+          c++;
+        } else if (ch === '"') {
+          stack.pop();
+        }
+        continue;
+      }
+
+      // Code position (top of file block, a nested brace, or inside `${...}`).
+      if (ch === "#" || (ch === "/" && next === "/")) break; // line comment
+      if (ch === "/" && next === "*") {
+        stack.push("comment");
+        c++;
+        continue;
+      }
+      if (ch === '"') {
+        stack.push("string");
+        continue;
+      }
+      if (ch === "<" && next === "<") {
+        const hd = line.slice(c).match(/^<<-?([A-Za-z_][A-Za-z0-9_-]*)/);
+        if (hd) {
+          heredoc = hd[1];
+          break;
+        }
+      }
+      if (ch === "{") {
+        stack.push("brace");
+        opened = true;
+        continue;
+      }
+      if (ch === "}") {
+        if (top === "brace" || top === "interp") stack.pop();
+        if (opened && stack.length === 0) return ln;
+      }
+    }
+  }
+  return -1;
+}

package/src/terraform/graduate.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from "vitest";
-import { buildGraph } from "./graph";
+import { buildFixtureGraph } from "./__fixtures__/build-graph";
 import { boundaryReport } from "./carve";
-import { graduationPlan, DEFAULT_TAG_OWNERSHIP_KEYS } from "./graduate";
+import { graduationPlan, stampOwnershipIntoSource, DEFAULT_TAG_OWNERSHIP_KEYS } from "./graduate";
 import type { Hcl2JsonTree } from "./types";
 
 const bucketTree: Hcl2JsonTree = {
@@ -13,7 +13,7 @@ const bucketTree: Hcl2JsonTree = {
 
 describe("graduationPlan", () => {
   test("resolves the ownership marker + tags (chant-owned)", () => {
-    const report = boundaryReport(buildGraph(bucketTree), "aws_s3_bucket.assets")!;
+    const report = boundaryReport(buildFixtureGraph(bucketTree), "aws_s3_bucket.assets")!;
     const plan = graduationPlan(report, { stack: "assets", env: "prod" });
 
     expect(plan.marker).toEqual({ stack: "assets", env: "prod" });
@@ -25,14 +25,14 @@ describe("graduationPlan", () => {
   });
 
   test("stack defaults to the resource's local name", () => {
-    const report = boundaryReport(buildGraph(bucketTree), "aws_s3_bucket.assets")!;
+    const report = boundaryReport(buildFixtureGraph(bucketTree), "aws_s3_bucket.assets")!;
     const plan = graduationPlan(report);
     expect(plan.marker.stack).toBe("assets");
     expect(plan.ownershipTags).not.toHaveProperty(DEFAULT_TAG_OWNERSHIP_KEYS.env); // no env → omitted
   });
 
   test("runbook is reversible and BYOL (import rollback, no chant-runs-apply)", () => {
-    const report = boundaryReport(buildGraph(bucketTree), "aws_s3_bucket.assets")!;
+    const report = boundaryReport(buildFixtureGraph(bucketTree), "aws_s3_bucket.assets")!;
     const plan = graduationPlan(report, { env: "prod" });
     const runbook = plan.steps.join("\n");
     expect(runbook).toMatch(/terraform import aws_s3_bucket\.assets/);
@@ -42,8 +42,75 @@ describe("graduationPlan", () => {
 
   test("warns when outbound edges leave deferred inputs to wire", () => {
     // Carve the Lambda: it depends on the bucket (survivor) → outbound/deferred.
-    const report = boundaryReport(buildGraph(bucketTree), "aws_lambda_function.api")!;
+    const report = boundaryReport(buildFixtureGraph(bucketTree), "aws_lambda_function.api")!;
     const plan = graduationPlan(report, { env: "prod" });
     expect(plan.warnings.join(" ")).toMatch(/deferred deploy-time input/i);
   });
 });
+
+const TAGS = { "chant:managed-by": "chant", "chant:stack": "assets", "chant:env": "prod" };
+
+describe("stampOwnershipIntoSource", () => {
+  test("merges into an existing Tags prop, replacing stale chant keys", () => {
+    const src = [
+      'import { Bucket } from "@intentius/chant-lexicon-aws";',
+      "",
+      "export const assets = new Bucket({",
+      '  BucketName: "myapp-assets-prod",',
+      '  Tags: [{"Key":"Team","Value":"web"},{"Key":"chant:stack","Value":"old"}],',
+      "});",
+      "",
+    ].join("\n");
+
+    const res = stampOwnershipIntoSource(src, TAGS)!;
+    expect(res.changed).toBe(true);
+    const tagsLine = res.content.split("\n").find((l) => l.includes("Tags:"))!;
+    const tags = JSON.parse(tagsLine.trim().replace(/^Tags: /, "").replace(/,$/, "")) as Array<{ Key: string; Value: string }>;
+    expect(tags).toEqual([
+      { Key: "Team", Value: "web" },
+      { Key: "chant:managed-by", Value: "chant" },
+      { Key: "chant:stack", Value: "assets" },
+      { Key: "chant:env", Value: "prod" },
+    ]);
+  });
+
+  test("inserts a Tags prop when the constructor has none (unmapped comment untouched)", () => {
+    const src = [
+      "export const api = new LogGroup({",
+      '  LogGroupName: "/myapp/api",',
+      "});",
+      "",
+      "/* Unmapped Terraform attributes (reconcile to native props before building):",
+      '{ "skip_destroy": false }',
+      "*/",
+      "",
+    ].join("\n");
+
+    const res = stampOwnershipIntoSource(src, TAGS)!;
+    expect(res.changed).toBe(true);
+    const lines = res.content.split("\n");
+    expect(lines[2]).toBe(`  Tags: ${JSON.stringify(Object.entries(TAGS).map(([Key, Value]) => ({ Key, Value })))},`);
+    expect(lines[3]).toBe("});");
+    expect(res.content).toContain("skip_destroy"); // the comment survives
+  });
+
+  test("handles an empty props object", () => {
+    const src = "export const igw = new InternetGateway({});\n";
+    const res = stampOwnershipIntoSource(src, TAGS)!;
+    expect(res.changed).toBe(true);
+    expect(res.content).toContain("new InternetGateway({\n  Tags: [");
+    expect(res.content).toMatch(/\}\);\n$/);
+  });
+
+  test("is idempotent: a second stamp changes nothing", () => {
+    const src = 'export const assets = new Bucket({\n  BucketName: "b",\n});\n';
+    const first = stampOwnershipIntoSource(src, TAGS)!;
+    const second = stampOwnershipIntoSource(first.content, TAGS)!;
+    expect(second.changed).toBe(false);
+    expect(second.content).toBe(first.content);
+  });
+
+  test("returns null when there is no constructor to stamp", () => {
+    expect(stampOwnershipIntoSource("// nothing here\n", TAGS)).toBeNull();
+  });
+});

package/src/terraform/graduate.ts

@@ -76,3 +76,52 @@ export function graduationPlan(report: CarveReport, opts: GraduationOptions = {}
 
   return { target: report.target, marker, ownershipTags, steps, warnings };
 }
+
+/**
+ * Stamp the ownership tags into an emitted chant source file (`carve apply
+ * --write-source`). The emitted source is machine-generated (`adoptFromState`),
+ * so its shape is known: one prop per line, `Tags` as a single-line JSON array.
+ * Merges into an existing `Tags` prop (replacing stale chant keys) or inserts
+ * one into the constructor's props object. Returns null when the file has no
+ * recognizable constructor to stamp.
+ */
+export function stampOwnershipIntoSource(
+  content: string,
+  tags: Record<string, string>,
+): { content: string; changed: boolean } | null {
+  const entries = Object.entries(tags).map(([Key, Value]) => ({ Key, Value }));
+  const keys = new Set(Object.keys(tags));
+  const lines = content.split("\n");
+
+  // Merge into an existing Tags prop.
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/^(\s*)Tags: (\[.*\]),$/);
+    if (!m) continue;
+    let existing: Array<{ Key: string; Value: unknown }>;
+    try {
+      existing = JSON.parse(m[2]) as Array<{ Key: string; Value: unknown }>;
+    } catch {
+      continue;
+    }
+    const merged = [...existing.filter((t) => !keys.has(t.Key)), ...entries];
+    const rendered = `${m[1]}Tags: ${JSON.stringify(merged)},`;
+    if (rendered === lines[i]) return { content, changed: false };
+    lines[i] = rendered;
+    return { content: lines.join("\n"), changed: true };
+  }
+
+  // No Tags prop yet: insert one into the constructor's props object.
+  const tagsLine = `  Tags: ${JSON.stringify(entries)},`;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (/^\}\);\s*$/.test(lines[i])) {
+      lines.splice(i, 0, tagsLine);
+      return { content: lines.join("\n"), changed: true };
+    }
+    const empty = lines[i].match(/^(export const .+ = new \w+\()\{\}(\);)\s*$/);
+    if (empty) {
+      lines[i] = `${empty[1]}{\n${tagsLine}\n}${empty[2]}`;
+      return { content: lines.join("\n"), changed: true };
+    }
+  }
+  return null;
+}