@intentius/chant 0.69.0 → 0.69.1

package/dist/discovery/import.d.ts

@@ -1,9 +1,23 @@
+/**
+ * Forget every recorded evaluation failure.
+ *
+ * For a harness that deliberately starts a fresh module graph and wants the
+ * failures forgotten with it. Nothing in chant calls this: a real build
+ * imports once, and a second import inside one process is supposed to see what
+ * the first one saw.
+ *
+ * It does not make a module re-evaluate. Node's own registry still holds the
+ * failed record and still re-throws; this only clears chant's memory of it. A
+ * caller wanting genuine re-evaluation needs a fresh process.
+ */
+export declare function resetImportFailures(): void;
 /**
  * Dynamically import a module and return its exports.
  *
  * @param path - The file path to import
  * @returns The module exports
- * @throws {DiscoveryError} with type "import" if the import fails
+ * @throws {DiscoveryError} with type "import" if the import fails, including
+ *   on every later import of a module whose evaluation has already failed
  */
 export declare function importModule(path: string): Promise<Record<string, unknown>>;
 //# sourceMappingURL=import.d.ts.map

package/dist/discovery/import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/discovery/import.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQlC"}
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/discovery/import.ts"],"names":[],"mappings":"AA4BA;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAalC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.69.0",
+  "version": "0.69.1",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

package/src/discovery/import.test.ts

@@ -1,9 +1,10 @@
 import { describe, test, expect } from "vitest";
-import { importModule } from "./import";
+import { importModule, resetImportFailures } from "./import";
+import { discover } from "./index";
 import { DiscoveryError } from "../errors";
 import { withTestDir, expectToThrow } from "@intentius/chant-test-utils";
 import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 
 describe("importModule", () => {
 
@@ -198,3 +199,110 @@ describe("importModule", () => {
     });
   });
 });
+
+describe("a module whose evaluation threw stays thrown (#2368)", () => {
+  /**
+   * The spec records an evaluation failure on the module record and re-throws
+   * it on every later import, forever. Node does that; vitest's module runner
+   * does not, and hands the second importer a namespace holding whatever was
+   * initialized before the throw.
+   *
+   * These assert the contract directly. They do not reproduce the runner bug —
+   * a module written to a temp directory is outside vitest's transform root and
+   * is imported by Node, which already records the failure. The reproduction is
+   * the corpus-backed test at the bottom of this file, which is the one that
+   * fails without the failure map.
+   */
+  test("a second import throws the same error, not a half-initialized namespace", async () => {
+    await withTestDir(async (testDir) => {
+      const filePath = join(testDir, "throws.ts");
+      await writeFile(filePath, `const o = undefined as unknown as { k: string };\nexport const value = o.k;\n`);
+
+      const first = await expectToThrow(() => importModule(filePath), DiscoveryError);
+      const second = await expectToThrow(() => importModule(filePath), DiscoveryError);
+
+      expect(second.message).toBe(first.message);
+      expect(second.file).toBe(filePath);
+      // The same error object, because it is the recorded one being replayed
+      // rather than a second failure that happened to look alike.
+      expect(second).toBe(first);
+    });
+  });
+
+  test("a third and fourth import keep throwing", async () => {
+    await withTestDir(async (testDir) => {
+      const filePath = join(testDir, "throws-again.ts");
+      await writeFile(filePath, `const o = undefined as unknown as { k: string };\nexport const value = o.k;\n`);
+
+      await expectToThrow(() => importModule(filePath), DiscoveryError);
+      await expectToThrow(() => importModule(filePath), DiscoveryError);
+      await expectToThrow(() => importModule(filePath), DiscoveryError);
+      await expectToThrow(() => importModule(filePath), DiscoveryError);
+    });
+  });
+
+  test("a module that imports cleanly is unaffected and is not cached as failed", async () => {
+    await withTestDir(async (testDir) => {
+      const filePath = join(testDir, "fine.ts");
+      await writeFile(filePath, `export const value = "ok";\n`);
+
+      const a = await importModule(filePath);
+      const b = await importModule(filePath);
+      expect(a.value).toBe("ok");
+      expect(b.value).toBe("ok");
+    });
+  });
+
+  test("resetImportFailures forgets the record, and does not make the module re-evaluate", async () => {
+    await withTestDir(async (testDir) => {
+      const filePath = join(testDir, "throws-reset.ts");
+      await writeFile(filePath, `const o = undefined as unknown as { k: string };\nexport const value = o.k;\n`);
+
+      const first = await expectToThrow(() => importModule(filePath), DiscoveryError);
+      resetImportFailures();
+
+      // Under Node the registry still holds the failed record and throws
+      // again; under vitest the module is served from its cache. Either way
+      // the escape hatch only clears chant's memory, which is what its doc
+      // says — so this asserts the clearing, not a re-evaluation.
+      let replayedSameObject = false;
+      try {
+        await importModule(filePath);
+      } catch (err) {
+        replayedSameObject = err === first;
+      }
+      expect(replayedSameObject).toBe(false);
+    });
+  });
+});
+
+describe("discover() reports the same errors on a second pass (#2368)", () => {
+  /**
+   * The reproduction from the issue, over the corpus entry that exposed it.
+   *
+   * It has to be a file inside the project: vitest transforms and caches those,
+   * and it is that cache which forgets an evaluation failure. A module written
+   * to a temp directory outside the runner's root is imported by Node natively
+   * and already behaves correctly, so a fixture built with `withTestDir` would
+   * pass with or without the fix and prove nothing.
+   *
+   * `examples/fold-adversarial/src/nullish-property-read.ts` folds to a refusal
+   * and then throws a TypeError when the run path imports it (#2328). Before
+   * the failure map: `discover #1 errors=1`, `discover #2 errors=0`.
+   */
+  const ADVERSARIAL = resolve(import.meta.dirname, "../../../../examples/fold-adversarial/src");
+
+  test("the corpus entry with a throwing file reports it on every pass", async () => {
+    const first = await discover(ADVERSARIAL);
+    const second = await discover(ADVERSARIAL);
+    const third = await discover(ADVERSARIAL);
+
+    expect(first.errors.length).toBeGreaterThan(0);
+    expect(second.errors.length).toBe(first.errors.length);
+    expect(third.errors.length).toBe(first.errors.length);
+
+    const named = (r: { errors: unknown[] }): boolean =>
+      (r.errors[0] as { file?: string }).file?.endsWith("nullish-property-read.ts") === true;
+    expect(named(first) && named(second) && named(third)).toBe(true);
+  });
+});

package/src/discovery/import.ts

@@ -1,20 +1,68 @@
 import { DiscoveryError } from "../errors";
 
+/**
+ * Modules whose evaluation threw, and the error each threw with (#2368).
+ *
+ * The ES module spec says an evaluation failure is recorded on the module
+ * record and re-thrown on every later import of the same specifier, forever,
+ * in that realm. Node implements it — including after the file is edited, so a
+ * module that threw keeps throwing until the process restarts.
+ *
+ * Vitest's module runner does not. It caches the module as *evaluated* and
+ * hands later importers a namespace carrying whichever bindings were
+ * initialized before the throw, so the second import resolves with
+ * half-initialized exports and no error at all.
+ *
+ * That divergence is invisible to `chant build`, which imports a directory
+ * once per process, and highly visible to anything that builds the same
+ * directory twice and compares: whichever build ran first carried the error
+ * and every build after it reported none, so error parity came out of the
+ * ordering rather than out of the tool.
+ *
+ * This map is what makes the answer the same either way. Under Node it never
+ * fires — `import()` throws again before the lookup matters — so it costs
+ * nothing and changes nothing there. Under a runner that forgets, it supplies
+ * the memory the spec requires.
+ */
+const evaluationFailures = new Map<string, DiscoveryError>();
+
+/**
+ * Forget every recorded evaluation failure.
+ *
+ * For a harness that deliberately starts a fresh module graph and wants the
+ * failures forgotten with it. Nothing in chant calls this: a real build
+ * imports once, and a second import inside one process is supposed to see what
+ * the first one saw.
+ *
+ * It does not make a module re-evaluate. Node's own registry still holds the
+ * failed record and still re-throws; this only clears chant's memory of it. A
+ * caller wanting genuine re-evaluation needs a fresh process.
+ */
+export function resetImportFailures(): void {
+  evaluationFailures.clear();
+}
+
 /**
  * Dynamically import a module and return its exports.
  *
  * @param path - The file path to import
  * @returns The module exports
- * @throws {DiscoveryError} with type "import" if the import fails
+ * @throws {DiscoveryError} with type "import" if the import fails, including
+ *   on every later import of a module whose evaluation has already failed
  */
 export async function importModule(
   path: string
 ): Promise<Record<string, unknown>> {
+  const failed = evaluationFailures.get(path);
+  if (failed) throw failed;
+
   try {
     return await import(path);
   } catch (error) {
     const message =
       error instanceof Error ? error.message : "Unknown import error";
-    throw new DiscoveryError(path, message, "import");
+    const discoveryError = new DiscoveryError(path, message, "import");
+    evaluationFailures.set(path, discoveryError);
+    throw discoveryError;
   }
 }