block-in-file 1.0.0

package/test/cli.test.ts

@@ -0,0 +1,254 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { execSync, spawn } from "node:child_process";
+
+describe("CLI", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "blockinfile-cli-test-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  function runCli(args: string, input?: string): string {
+    const cwd = path.resolve(import.meta.dirname!, "..");
+    const cmd = `npx tsx block-in-file.ts ${args}`;
+    return execSync(cmd, {
+      cwd,
+      input,
+      encoding: "utf-8",
+    });
+  }
+
+  async function runCliWithStderr(args: string, input?: string): Promise<string> {
+    const cwd = path.resolve(import.meta.dirname!, "..");
+    const [command, ...argsArray] = `npx tsx block-in-file.ts ${args}`.split(" ");
+    const child = spawn(command, argsArray, {
+      cwd,
+      shell: true,
+    });
+
+    const stdout: string[] = [];
+    const stderr: string[] = [];
+
+    if (child.stdout) {
+      child.stdout.on("data", (data) => {
+        stdout.push(data.toString());
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (data) => {
+        stderr.push(data.toString());
+      });
+    }
+
+    if (input) {
+      child.stdin?.write(input);
+      child.stdin?.end();
+    }
+
+    return new Promise((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve([...stdout, ...stderr].join(""));
+        } else {
+          reject(new Error(`Command failed with code ${code}`));
+        }
+      });
+      child.on("error", reject);
+    });
+  }
+
+  describe("help and version", () => {
+    it("shows help with --help", () => {
+      const output = runCli("--help");
+      expect(output).toContain("block-in-file");
+      expect(output).toContain("Name for block");
+    });
+
+    it("shows version with --version", () => {
+      const output = runCli("--version");
+      expect(output).toContain("1.0.0");
+    });
+  });
+
+  describe("basic file operations", () => {
+    it("inserts block from stdin", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runCli(`-i - ${targetFile}`, "INSERTED");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("# blockinfile start");
+      expect(result).toContain("INSERTED");
+    });
+
+    it("replaces existing block", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\n# blockinfile start\nOLD\n# blockinfile end\nline2\n");
+
+      runCli(`-i - ${targetFile}`, "NEW");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).not.toContain("OLD");
+      expect(result).toContain("NEW");
+    });
+
+    it("creates named block", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const originalContent = "line1\nline2\n";
+      await fs.writeFile(targetFile, originalContent);
+
+      const output = runCli(`-n myblock -i - ${targetFile} -o -`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toBe(originalContent);
+      expect(output).toContain("# myblock start");
+      expect(output).toContain("CONTENT");
+    });
+
+    it("outputs to stdout", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const originalContent = "line1\nline2\n";
+      await fs.writeFile(targetFile, originalContent);
+
+      const output = runCli(`${targetFile} -o -`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toBe(originalContent);
+      expect(output).toContain("# blockinfile start");
+      expect(output).toContain("CONTENT");
+    });
+
+    it("creates file with create option", async () => {
+      const targetFile = path.join(tempDir, "newfile.txt");
+
+      runCli(`--create file -i - ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("# blockinfile start");
+      expect(result).toContain("CONTENT");
+    });
+
+    it("inserts before matching line", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\nline3\n");
+
+      runCli(`--before '^line2' -i - ${targetFile}`, "INSERTED");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      expect(lines).toContain("INSERTED");
+    });
+
+    it("inserts after matching line", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\nline3\n");
+
+      runCli(`--after '^line2' -i - ${targetFile}`, "INSERTED");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      expect(lines).toContain("INSERTED");
+    });
+
+    it("shows diff with --diff", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      const output = await runCliWithStderr(`${targetFile} --diff -`, "NEW BLOCK");
+
+      expect(output).toContain("---");
+      expect(output).toContain("+++");
+      expect(output).toContain("+");
+    });
+
+    it("uses dos line endings with --dos", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runCli(`-i - ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).not.toContain("\r\n");
+    });
+
+    it("uses dos line endings with --dos", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runCli(`--dos -i - ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("\r\n");
+    });
+  });
+
+  describe("custom markers", () => {
+    it("uses custom comment string", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runCli(`-c '//' -i - ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("// blockinfile start");
+      expect(result).toContain("CONTENT");
+    });
+
+    it("uses custom marker start", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runCli(`--marker-start BEGIN -i - ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("# blockinfile BEGIN");
+      expect(result).toContain("CONTENT");
+    });
+
+    it("uses custom marker end", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runCli(`--marker-end FINISH -i - ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("# blockinfile FINISH");
+      expect(result).toContain("CONTENT");
+    });
+  });
+
+  describe("multiple files", () => {
+    it("processes multiple files", async () => {
+      const file1 = path.join(tempDir, "file1.txt");
+      const file2 = path.join(tempDir, "file2.txt");
+      await fs.writeFile(file1, "line1\n");
+      await fs.writeFile(file2, "line2\n");
+
+      runCli(`${file1} ${file2} -i -`);
+
+      const result1 = await fs.readFile(file1, "utf-8");
+      const result2 = await fs.readFile(file2, "utf-8");
+      expect(result1).toContain("# blockinfile start");
+      expect(result2).toContain("# blockinfile start");
+    });
+  });
+
+  describe("debug mode", () => {
+    it("outputs debug information with --debug", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      const output = runCli(`--debug -i - ${targetFile}`, "CONTENT");
+
+      expect(output).toContain("[DEBUG]");
+    });
+  });
+});

package/test/defaults.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { defaultOptions, getDefaultOptions } from "../src/defaults.ts";
+
+describe("defaults", () => {
+  describe("defaultOptions", () => {
+    it("has expected default values", () => {
+      expect(defaultOptions.comment).toBe("#");
+      expect(defaultOptions.markerStart).toBe("start");
+      expect(defaultOptions.markerEnd).toBe("end");
+      expect(defaultOptions.name).toBe("blockinfile");
+      expect(defaultOptions.create).toBe(false);
+      expect(defaultOptions.dos).toBe(false);
+    });
+
+    it("is frozen and immutable", () => {
+      expect(Object.isFrozen(defaultOptions)).toBe(true);
+      expect(() => {
+        // @ts-expect-error testing immutability
+        defaultOptions.comment = "//";
+      }).toThrow();
+    });
+  });
+
+  describe("getDefaultOptions", () => {
+    it("returns a copy of default options", () => {
+      const opts = getDefaultOptions();
+      expect(opts).toEqual(defaultOptions);
+      expect(opts).not.toBe(defaultOptions);
+    });
+
+    it("returns independent copies", () => {
+      const opts1 = getDefaultOptions();
+      const opts2 = getDefaultOptions();
+      opts1.comment = "//";
+      expect(opts2.comment).toBe("#");
+    });
+  });
+});

package/test/envsubst-edge-cases.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { substitute } from "../src/envsubst.ts";
+
+describe("envsubst edge cases", () => {
+  beforeEach(() => {
+    delete process.env.TEST_VAR;
+    delete process.env.NESTED;
+    delete process.env.VAR;
+  });
+
+  describe("empty variable names", () => {
+    it("should leave ${} unchanged", () => {
+      const result = substitute("value: ${}", { mode: "recursive" });
+      expect(result).toBe("value: ${}");
+    });
+
+    it("should leave $ unchanged (no variable name)", () => {
+      const result = substitute("value: $", { mode: "recursive" });
+      expect(result).toBe("value: $");
+    });
+
+    it("should leave ${} undefined - it doesn't match our pattern", () => {
+      process.env.EMPTY = "";
+      const result = substitute("value: ${EMPTY}", { mode: "recursive" });
+      expect(result).toBe("value: ");
+      delete process.env.EMPTY;
+    });
+  });
+
+  describe("nested braces ${VAR${NESTED}}", () => {
+    it("should expand fully in recursive mode", () => {
+      process.env.NESTED = "inner";
+      process.env.VARinner = "final";
+      const result = substitute("${VAR${NESTED}}", { mode: "recursive" });
+      // Recursive: expands ${NESTED} to "inner", then ${VARinner} to "final"
+      expect(result).toBe("final");
+      delete process.env.NESTED;
+      delete process.env.VARinner;
+    });
+
+    it("should expand fully in recursive mode with undefined outer var", () => {
+      delete process.env.NESTED;
+      process.env.VAR = "value";
+      const result = substitute("${VAR${NESTED}}", { mode: "recursive" });
+      // ${NESTED} becomes "", so ${VAR${NESTED}} becomes ${VAR} which becomes "value"
+      expect(result).toBe("value");
+      delete process.env.VAR;
+    });
+
+    it("should expand inner only in non-recursive mode (single pass)", () => {
+      process.env.NESTED = "inner";
+      process.env.VARinner = "final";
+      const result = substitute("${VAR${NESTED}}", { mode: "non-recursive" });
+      // Non-recursive: expands ${NESTED} to "inner", but not ${VARinner}
+      expect(result).toBe("${VARinner}");
+      delete process.env.NESTED;
+      delete process.env.VARinner;
+    });
+
+    it("should expand inner to empty in non-recursive mode with undefined", () => {
+      delete process.env.NESTED;
+      const result = substitute("${VAR${NESTED}}", { mode: "non-recursive" });
+      // ${NESTED} becomes "", so result is ${VAR}
+      expect(result).toBe("${VAR}");
+    });
+  });
+
+  describe("escaping with backslash", () => {
+    it("should not support escaping (matches envsubst behavior)", () => {
+      process.env.VAR = "value";
+      const result = substitute("\\${VAR}", { mode: "recursive" });
+      // envsubst treats backslash as literal, still substitutes
+      expect(result).toBe("\\value");
+      delete process.env.VAR;
+    });
+
+    it("should handle \\$VAR similarly", () => {
+      process.env.VAR = "value";
+      const result = substitute("\\$VAR", { mode: "recursive" });
+      expect(result).toBe("\\value");
+      delete process.env.VAR;
+    });
+
+    it("should handle multiple backslashes", () => {
+      process.env.VAR = "value";
+      const result = substitute("\\\\${VAR}", { mode: "recursive" });
+      expect(result).toBe("\\\\value");
+      delete process.env.VAR;
+    });
+  });
+
+  describe("special characters", () => {
+    it("should not substitute variables with invalid characters", () => {
+      process.env["VAR-INVALID"] = "value";
+      const result = substitute("${VAR-INVALID}", { mode: "recursive" });
+      // Hyphen not in [a-zA-Z0-9_], so won't match
+      expect(result).toBe("${VAR-INVALID}");
+      delete process.env["VAR-INVALID"];
+    });
+
+    it("should not substitute variables starting with numbers", () => {
+      process.env["1VAR"] = "value";
+      const result = substitute("${1VAR}", { mode: "recursive" });
+      // Doesn't start with [a-zA-Z_], so won't match
+      expect(result).toBe("${1VAR}");
+      delete process.env["1VAR"];
+    });
+
+    it("should substitute variables with underscores", () => {
+      process.env.MY_LONG_VAR_NAME_123 = "value";
+      const result = substitute("${MY_LONG_VAR_NAME_123}", { mode: "recursive" });
+      expect(result).toBe("value");
+      delete process.env.MY_LONG_VAR_NAME_123;
+    });
+  });
+});

package/test/envsubst-integration.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { unlink, writeFile, readFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+const execAsync = promisify(exec);
+
+describe("envsubst integration", () => {
+  const testDir = join(process.cwd(), ".test-envsubst");
+  const testFile = join(testDir, "test.txt");
+
+  beforeEach(async () => {
+    try {
+      await mkdir(testDir, { recursive: true });
+    } catch {}
+    await writeFile(testFile, "original content\n", "utf8");
+  });
+
+  afterEach(async () => {
+    try {
+      await unlink(testFile);
+    } catch {}
+  });
+
+  it("should substitute environment variables with ${VAR} syntax", async () => {
+    process.env.TEST_VAR = "hello world";
+    const input = "content: ${TEST_VAR}";
+
+    await execAsync(`echo '${input}' | npx tsx block-in-file.ts --envsubst=recursive ${testFile}`);
+
+    const content = await readFile(testFile, "utf8");
+    expect(content).toContain("content: hello world");
+    delete process.env.TEST_VAR;
+  });
+
+  it("should substitute nested variables in recursive mode", async () => {
+    process.env.VAR1 = "value1";
+    process.env.VAR2 = "prefix ${VAR1}";
+    const input = "result: ${VAR2}";
+
+    await execAsync(`echo '${input}' | npx tsx block-in-file.ts --envsubst=recursive ${testFile}`);
+
+    const content = await readFile(testFile, "utf8");
+    expect(content).toContain("result: prefix value1");
+    delete process.env.VAR1;
+    delete process.env.VAR2;
+  });
+
+  it("should do single pass in non-recursive mode", async () => {
+    process.env.VAR1 = "final";
+    process.env.VAR2 = "${VAR1}";
+    process.env.VAR3 = "${VAR2}";
+    const input = "${VAR3}";
+
+    await execAsync(
+      `echo '${input}' | npx tsx block-in-file.ts --envsubst=non-recursive ${testFile}`,
+    );
+
+    const content = await readFile(testFile, "utf8");
+    // Non-recursive: only ${VAR3} is replaced, result is ${VAR2}
+    expect(content).toContain("${VAR2}");
+    delete process.env.VAR1;
+    delete process.env.VAR2;
+    delete process.env.VAR3;
+  });
+
+  it("should not substitute when envsubst is false", async () => {
+    process.env.TEST_VAR = "value";
+    const input = "content: ${TEST_VAR}";
+
+    await execAsync(`echo '${input}' | npx tsx block-in-file.ts --envsubst=false ${testFile}`);
+
+    const content = await readFile(testFile, "utf8");
+    expect(content).toContain("content: ${TEST_VAR}");
+    delete process.env.TEST_VAR;
+  });
+});

package/test/envsubst.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { substitute } from "../src/envsubst.ts";
+
+describe("envsubst", () => {
+  beforeEach(() => {
+    delete process.env.TEST_VAR;
+    delete process.env.NESTED_VAR;
+    delete process.env.PREFIX_VAR;
+  });
+
+  describe("basic substitution with ${VAR} syntax", () => {
+    it.each([
+      { input: "content: ${TEST_VAR}", vars: { TEST_VAR: "hello" }, expected: "content: hello" },
+      { input: "${VAR1} and ${VAR2}", vars: { VAR1: "foo", VAR2: "bar" }, expected: "foo and bar" },
+      { input: "${PREFIX}-middle-${SUFFIX}", vars: { PREFIX: "pre", SUFFIX: "post" }, expected: "pre-middle-post" },
+    ])("should substitute: $input", ({ input, vars, expected }) => {
+      Object.assign(process.env, vars);
+      const result = substitute(input, { mode: "non-recursive" });
+      expect(result).toBe(expected);
+      Object.keys(vars).forEach(key => delete process.env[key]);
+    });
+  });
+
+  describe("basic substitution with $VAR syntax", () => {
+    it.each([
+      { input: "content: $TEST_VAR", vars: { TEST_VAR: "hello" }, expected: "content: hello" },
+      { input: "$VAR1 and $VAR2", vars: { VAR1: "foo", VAR2: "bar" }, expected: "foo and bar" },
+    ])("should substitute: $input", ({ input, vars, expected }) => {
+      Object.assign(process.env, vars);
+      const result = substitute(input, { mode: "non-recursive" });
+      expect(result).toBe(expected);
+      Object.keys(vars).forEach(key => delete process.env[key]);
+    });
+  });
+
+  describe("priority - ${VAR} over $VAR", () => {
+    it("should prefer ${VAR} syntax when both are present", () => {
+      process.env.VAR = "value";
+      const result = substitute("${VAR} and $VAR", { mode: "non-recursive" });
+      expect(result).toBe("value and value");
+    });
+
+    it("should not substitute $VAR if it's part of ${VAR}", () => {
+      process.env.VAR = "value";
+      process.env.VAR_BRACE = "other";
+      const result = substitute("${VAR}", { mode: "non-recursive" });
+      expect(result).toBe("value");
+    });
+  });
+
+  describe("recursive mode", () => {
+    it("should substitute nested variables", () => {
+      process.env.VAR1 = "value1";
+      process.env.VAR2 = "prefix ${VAR1}";
+      const result = substitute("result: ${VAR2}", { mode: "recursive" });
+      expect(result).toBe("result: prefix value1");
+      delete process.env.VAR1;
+      delete process.env.VAR2;
+    });
+
+    it("should handle multiple levels of nesting", () => {
+      process.env.VAR1 = "final";
+      process.env.VAR2 = "level2 ${VAR1}";
+      process.env.VAR3 = "level1 ${VAR2}";
+      const result = substitute("start ${VAR3}", { mode: "recursive" });
+      expect(result).toBe("start level1 level2 final");
+      delete process.env.VAR1;
+      delete process.env.VAR2;
+      delete process.env.VAR3;
+    });
+
+    it("should stop when substitution is stable", () => {
+      process.env.VAR1 = "value";
+      process.env.VAR2 = "${VAR1}";
+      const result = substitute("${VAR2}", { mode: "recursive" });
+      expect(result).toBe("value");
+      delete process.env.VAR1;
+      delete process.env.VAR2;
+    });
+  });
+
+  describe("non-recursive mode", () => {
+    it("should do single pass substitution (like envsubst)", () => {
+      process.env.VAR1 = "value1";
+      process.env.VAR2 = "prefix ${VAR1}";
+      const result = substitute("result: ${VAR2}", { mode: "non-recursive" });
+      // Only ${VAR2} is replaced with its value, not ${VAR1}
+      expect(result).toBe("result: prefix ${VAR1}");
+      delete process.env.VAR1;
+      delete process.env.VAR2;
+    });
+
+    it("should handle nested variables in one pass only", () => {
+      process.env.VAR1 = "final";
+      process.env.VAR2 = "${VAR1}";
+      process.env.VAR3 = "${VAR2}";
+      const result = substitute("${VAR3}", { mode: "non-recursive" });
+      // Only ${VAR3} is replaced, result stays as ${VAR2}
+      expect(result).toBe("${VAR2}");
+      delete process.env.VAR1;
+      delete process.env.VAR2;
+      delete process.env.VAR3;
+    });
+  });
+
+  describe("undefined variables", () => {
+    it.each([
+      { input: "content: ${UNDEFINED_VAR}", expected: "content: " },
+      { input: "content: $UNDEFINED_VAR", expected: "content: " },
+    ])("should replace undefined variables with empty string: $input", ({ input, expected }) => {
+      const result = substitute(input, { mode: "non-recursive" });
+      expect(result).toBe(expected);
+    });
+
+    it("should handle mix of defined and undefined variables", () => {
+      process.env.DEFINED_VAR = "value";
+      const result = substitute("${DEFINED_VAR} and ${UNDEFINED_VAR}", { mode: "non-recursive" });
+      expect(result).toBe("value and ");
+      delete process.env.DEFINED_VAR;
+    });
+
+    it("should handle variables with empty values", () => {
+      process.env.EMPTY_VAR = "";
+      const result = substitute("prefix${EMPTY_VAR}suffix", { mode: "non-recursive" });
+      expect(result).toBe("prefixsuffix");
+      delete process.env.EMPTY_VAR;
+    });
+  });
+
+  describe("edge cases", () => {
+    it.each([
+      { input: "", expected: "" },
+      { input: "just plain text", expected: "just plain text" },
+    ])("should handle: $input", ({ input, expected }) => {
+      const result = substitute(input, { mode: "non-recursive" });
+      expect(result).toBe(expected);
+    });
+
+    it.each([
+      { input: "${MY_LONG_VAR_NAME}", varName: "MY_LONG_VAR_NAME", value: "value", expected: "value" },
+      { input: "${VAR123}", varName: "VAR123", value: "value", expected: "value" },
+    ])("should handle variable names with special characters: $input", ({ input, varName, value, expected }) => {
+      process.env[varName] = value;
+      const result = substitute(input, { mode: "non-recursive" });
+      expect(result).toBe(expected);
+      delete process.env[varName];
+    });
+
+    it("should handle variables with empty values", () => {
+      process.env.EMPTY_VAR = "";
+      const result = substitute("prefix${EMPTY_VAR}suffix", { mode: "non-recursive" });
+      expect(result).toBe("prefixsuffix");
+      delete process.env.EMPTY_VAR;
+    });
+  });
+
+  describe("mode: false", () => {
+    it("should not substitute when mode is false", () => {
+      process.env.TEST_VAR = "value";
+      const result = substitute("content: ${TEST_VAR}", { mode: false });
+      expect(result).toBe("content: ${TEST_VAR}");
+    });
+  });
+
+  describe("malformed syntax", () => {
+    it("should handle malformed ${ at end", () => {
+      process.env.TEST_VAR = "value";
+      const result = substitute("content: ${", { mode: "non-recursive" });
+      expect(result).toBe("content: ${");
+    });
+
+    it("should handle malformed ${VAR without closing brace", () => {
+      process.env.TEST_VAR = "value";
+      const result = substitute("content: ${TEST_VAR", { mode: "non-recursive" });
+      expect(result).toBe("content: ${TEST_VAR");
+    });
+
+    it("should handle $ at end", () => {
+      process.env.TEST_VAR = "value";
+      const result = substitute("content: $", { mode: "non-recursive" });
+      expect(result).toBe("content: $");
+    });
+  });
+});