fix(cli): sweep stale config temp files + document dynamic-import gap; bump TPH lane timeout

F1: loadMetaobjectsConfig now sweeps any .metaobjects-config-proc-*.ts stranded
    by an abnormal exit (SIGKILL between temp-write and the finally cleanup), so
    a consumer's git status never surfaces the pre-processed artifact. Extracted
    the prefix to a PROC_TEMP_PREFIX constant shared by the writer and the sweep.
F2: documented that dynamic import() specifiers are intentionally not rewritten.
F3: api-contract TPH scenario timeout 60s -> 120s (shared TPH_SCENARIO_TIMEOUT_MS)
    — the generated lane hit the 60s ceiling once under cold 4-way parallel
    docker load on the local-ci runner.

From the final whole-branch review follow-ups (F1/F2/F3).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SKaSE8U5cwN4ZGFwhJwxSY

Author: dmealing

server/typescript/packages/cli/src/lib/load-metaobjects-config.ts

@@ -1,4 +1,4 @@
-import { existsSync, unlinkSync } from "node:fs";
+import { existsSync, readdirSync, unlinkSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
@@ -9,6 +9,12 @@ import type { MetaobjectsGenConfig } from "@metaobjectsdev/codegen-ts";
 
 const CONFIG_FILE = "metaobjects.config.ts";
 
+// Prefix for the transient, pre-processed config the loader writes next to the
+// user's config (see the rewrite step below). Normally deleted in a finally
+// block; the prefix is also used to sweep any copies stranded by an abnormal
+// exit so a consumer's `git status` never surfaces one.
+const PROC_TEMP_PREFIX = ".metaobjects-config-proc-";
+
 // Resolve @metaobjectsdev/codegen-ts from the CLI's own node_modules so that
 // metaobjects.config.ts (which lives in the user's project) can import it even
 // when the user's project has no direct dependency on the package.
@@ -116,6 +122,11 @@ function resolveCliPkg(specifier: string): string {
  *
  * Relative imports (`./foo`, `../bar`) are intentionally NOT rewritten; they
  * must continue to resolve relative to the config file's own directory.
+ *
+ * Dynamic `import("specifier")` calls are NOT rewritten either — configs are
+ * loaded eagerly and none of the scaffolded templates use them; a dynamic
+ * import of an aliased package falls back to normal module resolution (and to
+ * jiti's alias map on non-Bun runtimes).
  */
 function rewriteImportSpecifiers(source: string, aliasMap: Record<string, string>): string {
   let result = source;
@@ -144,6 +155,17 @@ export async function loadMetaobjectsConfig(projectRoot: string): Promise<Metaob
     );
   }
 
+  // Self-heal: a SIGKILL mid-load can strand a pre-processed temp config
+  // (PROC_TEMP_PREFIX*.ts) next to the user's config, since deletion normally
+  // happens in the finally block below. Sweep any stale ones before loading so
+  // an abnormal exit never pollutes the consumer's working tree.
+  const configDir = dirname(fullPath);
+  for (const entry of readdirSync(configDir)) {
+    if (entry.startsWith(PROC_TEMP_PREFIX) && entry.endsWith(".ts")) {
+      try { unlinkSync(resolve(configDir, entry)); } catch { /* best-effort */ }
+    }
+  }
+
   // Build the canonical alias map: specifier → resolved absolute path.
   const aliasMap: Record<string, string> = {};
   for (const specifier of Object.keys(CLI_PKG_PATHS)) {
@@ -165,7 +187,7 @@ export async function loadMetaobjectsConfig(projectRoot: string): Promise<Metaob
   let loadPath = fullPath;
   let tempCreated = false;
   if (processed !== original) {
-    const tempName = `.metaobjects-config-proc-${randomBytes(4).toString("hex")}.ts`;
+    const tempName = `${PROC_TEMP_PREFIX}${randomBytes(4).toString("hex")}.ts`;
     const tempPath = resolve(dirname(fullPath), tempName);
     try {
       await writeFile(tempPath, processed, "utf8");

server/typescript/packages/cli/test/unit/load-metaobjects-config.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { loadMetaobjectsConfig } from "../../src/lib/load-metaobjects-config.js";
@@ -78,6 +78,27 @@ describe("loadMetaobjectsConfig", () => {
     }
   });
 
+  test("sweeps a stranded .metaobjects-config-proc-*.ts temp file left by an abnormal exit", async () => {
+    // A SIGKILL during a prior load can strand the pre-processed temp config
+    // (whose deletion normally happens in a finally block). The next load must
+    // self-heal by removing any such stale files before proceeding, so a
+    // consumer's `git status` never shows the artifact.
+    const stale = join(tmp, ".metaobjects-config-proc-deadbeef.ts");
+    writeFileSync(stale, `export default { generators: [] };`);
+    writeFileSync(join(tmp, "metaobjects.config.ts"), `
+      import { defineConfig } from "@metaobjectsdev/codegen-ts";
+      import { entityFile, barrel } from "@metaobjectsdev/codegen-ts/generators";
+      export default defineConfig({
+        outDir: "out", extStyle: "none", dbImport: "../db", dialect: "sqlite",
+        generators: [entityFile(), barrel()],
+      });
+    `);
+    expect(existsSync(stale)).toBe(true);
+    const cfg = await loadMetaobjectsConfig(tmp);
+    expect(cfg.generators.length).toBe(2);      // normal load still works
+    expect(existsSync(stale)).toBe(false);      // stale temp file swept
+  });
+
   test("loads a config that imports from @metaobjectsdev/codegen-ts-tanstack", async () => {
     const osTmp = mkdtempSync(join(tmpdir(), "metaobjects-config-tanstack-"));
     try {

server/typescript/packages/integration-tests/test/api-contract-tph.test.ts

@@ -27,6 +27,12 @@ import {
 const SEED = JSON.parse(readFileSync(join(API_CONTRACT_TPH_DIR, "seed.json"), "utf8")) as TphSeed;
 const META_PATH = join(API_CONTRACT_TPH_DIR, "meta.json");
 
+// 120s per scenario: each spins up its own server + Testcontainers PG. The old
+// 60s ceiling was hit once by the generated lane under cold 4-way parallel
+// docker load on the local-ci runner; the headroom absorbs that startup jitter
+// without weakening the assertions. Both lanes share the same boot cost.
+const TPH_SCENARIO_TIMEOUT_MS = 120_000;
+
 interface Lane { baseUrl: string; applySeed(s: TphSeed): Promise<void>; close(): Promise<void>; }
 
 describe("api contract TPH — hand-rolled reference lane", () => {
@@ -42,7 +48,7 @@ describe("api contract TPH — hand-rolled reference lane", () => {
         if (server) await server.close();
         await pg.stop();
       }
-    }, { timeout: 60_000 });
+    }, { timeout: TPH_SCENARIO_TIMEOUT_MS });
   }
 });
 
@@ -59,7 +65,7 @@ describe("api contract TPH — GENERATED routes lane", () => {
         if (server) await server.close();
         await pg.stop();
       }
-    }, { timeout: 60_000 });
+    }, { timeout: TPH_SCENARIO_TIMEOUT_MS });
   }
 });