From 2aced985fc059e8288be802f1a12084c75de545c Mon Sep 17 00:00:00 2001
From: Simon Gagnon <git@simoncrypta.dev>
Date: Sun, 9 Aug 2026 22:18:53 -0400
Subject: [PATCH 1/3] fix(template): unique cloneWorkerDatabase names for Jest
 setupFiles

---
 CHANGELOG.md                  |  4 +++
 src/adapters/jest-template.ts |  4 +++
 src/adapters/template-mode.ts | 28 ++++++++++++++---
 tests/template-mode.test.ts   | 59 ++++++++++++++++++++++++++---------
 4 files changed, 76 insertions(+), 19 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e3306a..5bd050b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixed
+
+- TEMPLATE `cloneWorkerDatabase`: default clone name is unique per call (`<worker>_<pid>_<time>`) so Jest `setupFiles` (module reload per file) no longer hits `database already exists` on `_c_<workerId>`
+
 ## 0.2.0-alpha.0
 
 Breaking-ish alpha cut (still `alpha` dist-tag). Public lifecycle verb is now **`acquire`** (was `ensure`).
diff --git a/src/adapters/jest-template.ts b/src/adapters/jest-template.ts
index 9b58685..77f34f4 100644
--- a/src/adapters/jest-template.ts
+++ b/src/adapters/jest-template.ts
@@ -20,8 +20,12 @@ export type {
  * module.exports = createGlobalSetup({ migrate: async ({ databaseUrl }) => {} });
  *
  * // jest.config.cjs
+ * // When .env has a real TEST_DATABASE_URL, set once here (inherits to workers):
+ * // process.env.CEDAR_PG_FORCE = "1";
  * globalSetup: "<rootDir>/jest.cedar-global.cjs",
  * globalTeardown: require.resolve("@cedarjs/pg/jest-teardown"),
+ * // Prefer setupFilesAfterEnv so cloneWorkerDatabase's process memo sticks.
+ * // Plain setupFiles reloads per file — default unique clone names still work.
  * setupFilesAfterEnv: ["<rootDir>/jest.cedar-worker.cjs"],
  *
  * // jest.cedar-worker.cjs
diff --git a/src/adapters/template-mode.ts b/src/adapters/template-mode.ts
index 76c0245..111e845 100644
--- a/src/adapters/template-mode.ts
+++ b/src/adapters/template-mode.ts
@@ -65,17 +65,31 @@ export async function setupTemplateMode(
 
 export type CloneWorkerDatabaseOptions = {
   root?: string;
-  /** Clone suffix; defaults to JEST_WORKER_ID / VITEST_POOL_ID / pid. */
+  /**
+   * Clone suffix. Prefer omitting this: the default is unique per call
+   * (`<worker|w>_<pid>_<base36 time>`) so Jest `setupFiles` (module reload per
+   * file) does not collide on `CREATE DATABASE …_c_<workerId>`.
+   * Process-once memo still dedupes within a single module load
+   * (`setupFilesAfterEnv` + `beforeAll`, or Vitest `setupFiles` with top-level await).
+   */
   name?: string;
 };
 
 let workerOnce: Promise<void> | undefined;
 let workerOnceKey: string | undefined;
 
+/** Unique clone suffix; exported for tests. */
+export function defaultCloneWorkerName(
+  env: NodeJS.ProcessEnv = process.env,
+  pid: number = process.pid,
+  now: number = Date.now(),
+): string {
+  const worker = env.JEST_WORKER_ID ?? env.VITEST_POOL_ID ?? "w";
+  return `${worker}_${pid}_${now.toString(36)}`;
+}
+
 function resolveWorkerName(options: CloneWorkerDatabaseOptions): string {
-  return (
-    options.name ?? process.env.JEST_WORKER_ID ?? process.env.VITEST_POOL_ID ?? String(process.pid)
-  );
+  return options.name ?? defaultCloneWorkerName();
 }
 
 function workerOptionsKey(root: string | undefined, name: string): string {
@@ -83,9 +97,13 @@ function workerOptionsKey(root: string | undefined, name: string): string {
 }
 
 /**
- * Process-once per-worker clone (JEST_WORKER_ID / VITEST_POOL_ID / pid by default).
+ * Process-once clone (unique default name; see {@link defaultCloneWorkerName}).
  * Uses `cloneFromTemplateIfNeeded` (same skip policy as `acquireIfNeeded`) with `setEnv: true`.
  * First call wins for `root`/`name`; conflicting later calls throw.
+ *
+ * Prefer `setupFilesAfterEnv` + `beforeAll` (Jest) or a once-loaded Vitest setup file
+ * so the memo sticks. Plain Jest `setupFiles` reloads the module per file — unique
+ * default names avoid "database already exists"; you still get one clone per file.
  */
 export function cloneWorkerDatabase(options: CloneWorkerDatabaseOptions = {}): Promise<void> {
   const name = resolveWorkerName(options);
diff --git a/tests/template-mode.test.ts b/tests/template-mode.test.ts
index 2e0f1e1..1ebf98a 100644
--- a/tests/template-mode.test.ts
+++ b/tests/template-mode.test.ts
@@ -171,6 +171,16 @@ test("setupTemplateMode skips migrate/mark when acquire is skipped", async () =>
   });
 });
 
+test("defaultCloneWorkerName is unique per call (setupFiles-safe)", async () => {
+  const { defaultCloneWorkerName } = await import("../src/adapters/template-mode.ts");
+  const a = defaultCloneWorkerName({ JEST_WORKER_ID: "3" }, 42, 1_700_000_000_000);
+  const b = defaultCloneWorkerName({ JEST_WORKER_ID: "3" }, 42, 1_700_000_000_001);
+  expect(a).toBe(`3_42_${(1_700_000_000_000).toString(36)}`);
+  expect(b).toBe(`3_42_${(1_700_000_000_001).toString(36)}`);
+  expect(a).not.toBe(b);
+  expect(defaultCloneWorkerName({}, 7, 99)).toBe(`w_7_${(99).toString(36)}`);
+});
+
 test("cloneWorkerDatabase clones via cloneFromTemplateIfNeeded with setEnv true", async () => {
   const prevJest = process.env.JEST_WORKER_ID;
   const prevCedar = process.env.CEDAR_PG;
@@ -182,11 +192,11 @@ test("cloneWorkerDatabase clones via cloneFromTemplateIfNeeded with setEnv true"
   try {
     await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
       const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
-      await cloneWorkerDatabase({ root: "/tmp/wt" });
+      await cloneWorkerDatabase({ root: "/tmp/wt", name: "explicit" });
       expect(cloneFromTemplateIfNeeded).toHaveBeenCalledWith({
         root: "/tmp/wt",
         mode: "test",
-        name: "3",
+        name: "explicit",
         setEnv: true,
       });
     });
@@ -198,10 +208,37 @@ test("cloneWorkerDatabase clones via cloneFromTemplateIfNeeded with setEnv true"
   }
 });
 
-test("cloneWorkerDatabase is idempotent per process", async () => {
+test("cloneWorkerDatabase default name includes worker, pid, and time", async () => {
   const prevJest = process.env.JEST_WORKER_ID;
   const prevCedar = process.env.CEDAR_PG;
-  process.env.JEST_WORKER_ID = "1";
+  process.env.JEST_WORKER_ID = "3";
+  delete process.env.CEDAR_PG;
+
+  const cloneFromTemplateIfNeeded = vi.fn(async () => clonedWorker());
+
+  try {
+    await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
+      const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
+      await cloneWorkerDatabase({ root: "/tmp/wt" });
+      expect(cloneFromTemplateIfNeeded).toHaveBeenCalledWith(
+        expect.objectContaining({
+          root: "/tmp/wt",
+          mode: "test",
+          setEnv: true,
+          name: expect.stringMatching(new RegExp(`^3_${process.pid}_[0-9a-z]+$`)),
+        }),
+      );
+    });
+  } finally {
+    if (prevJest === undefined) delete process.env.JEST_WORKER_ID;
+    else process.env.JEST_WORKER_ID = prevJest;
+    if (prevCedar === undefined) delete process.env.CEDAR_PG;
+    else process.env.CEDAR_PG = prevCedar;
+  }
+});
+
+test("cloneWorkerDatabase is idempotent per process", async () => {
+  const prevCedar = process.env.CEDAR_PG;
   delete process.env.CEDAR_PG;
 
   const cloneFromTemplateIfNeeded = vi.fn(async () =>
@@ -211,22 +248,18 @@ test("cloneWorkerDatabase is idempotent per process", async () => {
   try {
     await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
       const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
-      await cloneWorkerDatabase();
-      await cloneWorkerDatabase();
+      await cloneWorkerDatabase({ name: "stable" });
+      await cloneWorkerDatabase({ name: "stable" });
       expect(cloneFromTemplateIfNeeded).toHaveBeenCalledTimes(1);
     });
   } finally {
-    if (prevJest === undefined) delete process.env.JEST_WORKER_ID;
-    else process.env.JEST_WORKER_ID = prevJest;
     if (prevCedar === undefined) delete process.env.CEDAR_PG;
     else process.env.CEDAR_PG = prevCedar;
   }
 });
 
 test("cloneWorkerDatabase rejects conflicting root/name after first call", async () => {
-  const prevJest = process.env.JEST_WORKER_ID;
   const prevCedar = process.env.CEDAR_PG;
-  process.env.JEST_WORKER_ID = "1";
   delete process.env.CEDAR_PG;
 
   const cloneFromTemplateIfNeeded = vi.fn(async () =>
@@ -236,15 +269,13 @@ test("cloneWorkerDatabase rejects conflicting root/name after first call", async
   try {
     await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
       const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
-      await cloneWorkerDatabase({ root: "/tmp/a" });
-      expect(() => cloneWorkerDatabase({ root: "/tmp/b" })).toThrow(
+      await cloneWorkerDatabase({ root: "/tmp/a", name: "n" });
+      expect(() => cloneWorkerDatabase({ root: "/tmp/b", name: "n" })).toThrow(
         /already started with different root\/name/,
       );
       expect(cloneFromTemplateIfNeeded).toHaveBeenCalledTimes(1);
     });
   } finally {
-    if (prevJest === undefined) delete process.env.JEST_WORKER_ID;
-    else process.env.JEST_WORKER_ID = prevJest;
     if (prevCedar === undefined) delete process.env.CEDAR_PG;
     else process.env.CEDAR_PG = prevCedar;
   }

From 71325383c6d0dbaf09fe26853f07b1c696315fa9 Mon Sep 17 00:00:00 2001
From: Simon Gagnon <git@simoncrypta.dev>
Date: Sun, 9 Aug 2026 22:27:13 -0400
Subject: [PATCH 2/3] fix(template): retain collision-resistant default clone
 names per module load

Unnamed cloneWorkerDatabase calls regenerated Date.now() each time, so a second
call in a later ms threw instead of hitting process memo; entropy also avoids
same-ms collisions across Jest setupFiles reloads.
---
 CHANGELOG.md                  |  2 +-
 src/adapters/template-mode.ts | 21 ++++++++++++-------
 tests/template-mode.test.ts   | 39 ++++++++++++++++++++++++++++-------
 3 files changed, 46 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5bd050b..ece9d59 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@
 
 ### Fixed
 
-- TEMPLATE `cloneWorkerDatabase`: default clone name is unique per call (`<worker>_<pid>_<time>`) so Jest `setupFiles` (module reload per file) no longer hits `database already exists` on `_c_<workerId>`
+- TEMPLATE `cloneWorkerDatabase`: default clone name is unique per module load (`<worker>_<pid>_<time>_<entropy>`) so Jest `setupFiles` (module reload per file) no longer hits `database already exists` on `_c_<workerId>`; unnamed calls retain one name so process-once memo stays stable
 
 ## 0.2.0-alpha.0
 
diff --git a/src/adapters/template-mode.ts b/src/adapters/template-mode.ts
index 111e845..0886469 100644
--- a/src/adapters/template-mode.ts
+++ b/src/adapters/template-mode.ts
@@ -1,3 +1,4 @@
+import { randomBytes } from "node:crypto";
 import { dispose, acquireIfNeeded, type AcquireIfNeededResult } from "../core/lifecycle.ts";
 import { cloneFromTemplateIfNeeded, markTemplate } from "../core/template.ts";
 
@@ -66,10 +67,10 @@ export async function setupTemplateMode(
 export type CloneWorkerDatabaseOptions = {
   root?: string;
   /**
-   * Clone suffix. Prefer omitting this: the default is unique per call
-   * (`<worker|w>_<pid>_<base36 time>`) so Jest `setupFiles` (module reload per
-   * file) does not collide on `CREATE DATABASE …_c_<workerId>`.
-   * Process-once memo still dedupes within a single module load
+   * Clone suffix. Prefer omitting this: the default is unique per module load
+   * (`<worker|w>_<pid>_<base36 time>_<entropy>`) so Jest `setupFiles` (module
+   * reload per file) does not collide on `CREATE DATABASE …_c_<workerId>`.
+   * Unnamed calls reuse one generated name so process-once memo stays stable
    * (`setupFilesAfterEnv` + `beforeAll`, or Vitest `setupFiles` with top-level await).
    */
   name?: string;
@@ -77,19 +78,24 @@ export type CloneWorkerDatabaseOptions = {
 
 let workerOnce: Promise<void> | undefined;
 let workerOnceKey: string | undefined;
+/** Retained default for unnamed calls within one module load. */
+let retainedDefaultName: string | undefined;
 
 /** Unique clone suffix; exported for tests. */
 export function defaultCloneWorkerName(
   env: NodeJS.ProcessEnv = process.env,
   pid: number = process.pid,
   now: number = Date.now(),
+  entropy: string = randomBytes(3).toString("hex"),
 ): string {
   const worker = env.JEST_WORKER_ID ?? env.VITEST_POOL_ID ?? "w";
-  return `${worker}_${pid}_${now.toString(36)}`;
+  return `${worker}_${pid}_${now.toString(36)}_${entropy}`;
 }
 
 function resolveWorkerName(options: CloneWorkerDatabaseOptions): string {
-  return options.name ?? defaultCloneWorkerName();
+  if (options.name !== undefined) return options.name;
+  retainedDefaultName ??= defaultCloneWorkerName();
+  return retainedDefaultName;
 }
 
 function workerOptionsKey(root: string | undefined, name: string): string {
@@ -97,7 +103,7 @@ function workerOptionsKey(root: string | undefined, name: string): string {
 }
 
 /**
- * Process-once clone (unique default name; see {@link defaultCloneWorkerName}).
+ * Process-once clone (unique default name per module load; see {@link defaultCloneWorkerName}).
  * Uses `cloneFromTemplateIfNeeded` (same skip policy as `acquireIfNeeded`) with `setEnv: true`.
  * First call wins for `root`/`name`; conflicting later calls throw.
  *
@@ -128,6 +134,7 @@ export function cloneWorkerDatabase(options: CloneWorkerDatabaseOptions = {}): P
   })().catch((err) => {
     workerOnce = undefined;
     workerOnceKey = undefined;
+    retainedDefaultName = undefined;
     throw err;
   });
   return workerOnce;
diff --git a/tests/template-mode.test.ts b/tests/template-mode.test.ts
index 1ebf98a..9e94260 100644
--- a/tests/template-mode.test.ts
+++ b/tests/template-mode.test.ts
@@ -171,14 +171,14 @@ test("setupTemplateMode skips migrate/mark when acquire is skipped", async () =>
   });
 });
 
-test("defaultCloneWorkerName is unique per call (setupFiles-safe)", async () => {
+test("defaultCloneWorkerName is unique across identical timestamps (setupFiles-safe)", async () => {
   const { defaultCloneWorkerName } = await import("../src/adapters/template-mode.ts");
-  const a = defaultCloneWorkerName({ JEST_WORKER_ID: "3" }, 42, 1_700_000_000_000);
-  const b = defaultCloneWorkerName({ JEST_WORKER_ID: "3" }, 42, 1_700_000_000_001);
-  expect(a).toBe(`3_42_${(1_700_000_000_000).toString(36)}`);
-  expect(b).toBe(`3_42_${(1_700_000_000_001).toString(36)}`);
+  const a = defaultCloneWorkerName({ JEST_WORKER_ID: "3" }, 42, 1_700_000_000_000, "aaa111");
+  const b = defaultCloneWorkerName({ JEST_WORKER_ID: "3" }, 42, 1_700_000_000_000, "bbb222");
+  expect(a).toBe(`3_42_${(1_700_000_000_000).toString(36)}_aaa111`);
+  expect(b).toBe(`3_42_${(1_700_000_000_000).toString(36)}_bbb222`);
   expect(a).not.toBe(b);
-  expect(defaultCloneWorkerName({}, 7, 99)).toBe(`w_7_${(99).toString(36)}`);
+  expect(defaultCloneWorkerName({}, 7, 99, "ccc333")).toBe(`w_7_${(99).toString(36)}_ccc333`);
 });
 
 test("cloneWorkerDatabase clones via cloneFromTemplateIfNeeded with setEnv true", async () => {
@@ -208,7 +208,7 @@ test("cloneWorkerDatabase clones via cloneFromTemplateIfNeeded with setEnv true"
   }
 });
 
-test("cloneWorkerDatabase default name includes worker, pid, and time", async () => {
+test("cloneWorkerDatabase default name includes worker, pid, time, and entropy", async () => {
   const prevJest = process.env.JEST_WORKER_ID;
   const prevCedar = process.env.CEDAR_PG;
   process.env.JEST_WORKER_ID = "3";
@@ -225,7 +225,7 @@ test("cloneWorkerDatabase default name includes worker, pid, and time", async ()
           root: "/tmp/wt",
           mode: "test",
           setEnv: true,
-          name: expect.stringMatching(new RegExp(`^3_${process.pid}_[0-9a-z]+$`)),
+          name: expect.stringMatching(new RegExp(`^3_${process.pid}_[0-9a-z]+_[0-9a-f]{6}$`)),
         }),
       );
     });
@@ -237,6 +237,29 @@ test("cloneWorkerDatabase default name includes worker, pid, and time", async ()
   }
 });
 
+test("cloneWorkerDatabase unnamed calls reuse retained default name", async () => {
+  const prevCedar = process.env.CEDAR_PG;
+  delete process.env.CEDAR_PG;
+
+  const cloneFromTemplateIfNeeded = vi.fn(async () =>
+    clonedWorker({ databaseName: "cpg_tmpl_c_1" }),
+  );
+
+  try {
+    await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
+      const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
+      await cloneWorkerDatabase({ root: "/tmp/wt" });
+      // Different wall time must not change the retained default key.
+      await new Promise((r) => setTimeout(r, 2));
+      await cloneWorkerDatabase({ root: "/tmp/wt" });
+      expect(cloneFromTemplateIfNeeded).toHaveBeenCalledTimes(1);
+    });
+  } finally {
+    if (prevCedar === undefined) delete process.env.CEDAR_PG;
+    else process.env.CEDAR_PG = prevCedar;
+  }
+});
+
 test("cloneWorkerDatabase is idempotent per process", async () => {
   const prevCedar = process.env.CEDAR_PG;
   delete process.env.CEDAR_PG;

From 66ddde5a4e13acc693ea463128a069acb43ad98e Mon Sep 17 00:00:00 2001
From: Simon Gagnon <git@simoncrypta.dev>
Date: Sun, 9 Aug 2026 22:36:32 -0400
Subject: [PATCH 3/3] fix(template): process-scope cloneWorkerDatabase memo on
 globalThis

Module-scoped memo died under Jest setupFiles reloads, causing duplicate
clones on the same worker id. Store the memo on globalThis and keep boring
worker-id defaults instead of unique-per-reload names.
---
 CHANGELOG.md                  |  2 +-
 src/adapters/jest-template.ts |  3 +-
 src/adapters/template-mode.ts | 73 ++++++++++++++++-----------------
 tests/template-mode.test.ts   | 76 ++++++++++++-----------------------
 4 files changed, 63 insertions(+), 91 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ece9d59..80f69f7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@
 
 ### Fixed
 
-- TEMPLATE `cloneWorkerDatabase`: default clone name is unique per module load (`<worker>_<pid>_<time>_<entropy>`) so Jest `setupFiles` (module reload per file) no longer hits `database already exists` on `_c_<workerId>`; unnamed calls retain one name so process-once memo stays stable
+- TEMPLATE `cloneWorkerDatabase`: process-once memo lives on `globalThis` so Jest `setupFiles` (module reload per file) no longer re-clones and hits `database already exists` on `_c_<workerId>`
 
 ## 0.2.0-alpha.0
 
diff --git a/src/adapters/jest-template.ts b/src/adapters/jest-template.ts
index 77f34f4..9ffd6b1 100644
--- a/src/adapters/jest-template.ts
+++ b/src/adapters/jest-template.ts
@@ -24,8 +24,7 @@ export type {
  * // process.env.CEDAR_PG_FORCE = "1";
  * globalSetup: "<rootDir>/jest.cedar-global.cjs",
  * globalTeardown: require.resolve("@cedarjs/pg/jest-teardown"),
- * // Prefer setupFilesAfterEnv so cloneWorkerDatabase's process memo sticks.
- * // Plain setupFiles reloads per file — default unique clone names still work.
+ * // Prefer setupFilesAfterEnv + beforeAll; setupFiles also works (memo is process-scoped).
  * setupFilesAfterEnv: ["<rootDir>/jest.cedar-worker.cjs"],
  *
  * // jest.cedar-worker.cjs
diff --git a/src/adapters/template-mode.ts b/src/adapters/template-mode.ts
index 0886469..ef89c62 100644
--- a/src/adapters/template-mode.ts
+++ b/src/adapters/template-mode.ts
@@ -1,4 +1,3 @@
-import { randomBytes } from "node:crypto";
 import { dispose, acquireIfNeeded, type AcquireIfNeededResult } from "../core/lifecycle.ts";
 import { cloneFromTemplateIfNeeded, markTemplate } from "../core/template.ts";
 
@@ -66,36 +65,36 @@ export async function setupTemplateMode(
 
 export type CloneWorkerDatabaseOptions = {
   root?: string;
-  /**
-   * Clone suffix. Prefer omitting this: the default is unique per module load
-   * (`<worker|w>_<pid>_<base36 time>_<entropy>`) so Jest `setupFiles` (module
-   * reload per file) does not collide on `CREATE DATABASE …_c_<workerId>`.
-   * Unnamed calls reuse one generated name so process-once memo stays stable
-   * (`setupFilesAfterEnv` + `beforeAll`, or Vitest `setupFiles` with top-level await).
-   */
+  /** Clone suffix; defaults to JEST_WORKER_ID / VITEST_POOL_ID / pid. */
   name?: string;
 };
 
-let workerOnce: Promise<void> | undefined;
-let workerOnceKey: string | undefined;
-/** Retained default for unnamed calls within one module load. */
-let retainedDefaultName: string | undefined;
+/** Survives Jest `setupFiles` module reloads (module-scoped `let` does not). */
+const CLONE_WORKER_MEMO = Symbol.for("@cedarjs/pg/cloneWorkerDatabase");
 
-/** Unique clone suffix; exported for tests. */
-export function defaultCloneWorkerName(
-  env: NodeJS.ProcessEnv = process.env,
-  pid: number = process.pid,
-  now: number = Date.now(),
-  entropy: string = randomBytes(3).toString("hex"),
-): string {
-  const worker = env.JEST_WORKER_ID ?? env.VITEST_POOL_ID ?? "w";
-  return `${worker}_${pid}_${now.toString(36)}_${entropy}`;
+type CloneWorkerMemo = {
+  promise: Promise<void>;
+  key: string;
+};
+
+type GlobalWithCloneWorkerMemo = typeof globalThis & {
+  [CLONE_WORKER_MEMO]?: CloneWorkerMemo;
+};
+
+function readCloneWorkerMemo(): CloneWorkerMemo | undefined {
+  return (globalThis as GlobalWithCloneWorkerMemo)[CLONE_WORKER_MEMO];
+}
+
+function writeCloneWorkerMemo(memo: CloneWorkerMemo | undefined): void {
+  const g = globalThis as GlobalWithCloneWorkerMemo;
+  if (memo === undefined) delete g[CLONE_WORKER_MEMO];
+  else g[CLONE_WORKER_MEMO] = memo;
 }
 
 function resolveWorkerName(options: CloneWorkerDatabaseOptions): string {
-  if (options.name !== undefined) return options.name;
-  retainedDefaultName ??= defaultCloneWorkerName();
-  return retainedDefaultName;
+  return (
+    options.name ?? process.env.JEST_WORKER_ID ?? process.env.VITEST_POOL_ID ?? String(process.pid)
+  );
 }
 
 function workerOptionsKey(root: string | undefined, name: string): string {
@@ -103,28 +102,27 @@ function workerOptionsKey(root: string | undefined, name: string): string {
 }
 
 /**
- * Process-once clone (unique default name per module load; see {@link defaultCloneWorkerName}).
+ * Process-once per-worker clone (JEST_WORKER_ID / VITEST_POOL_ID / pid by default).
  * Uses `cloneFromTemplateIfNeeded` (same skip policy as `acquireIfNeeded`) with `setEnv: true`.
  * First call wins for `root`/`name`; conflicting later calls throw.
  *
- * Prefer `setupFilesAfterEnv` + `beforeAll` (Jest) or a once-loaded Vitest setup file
- * so the memo sticks. Plain Jest `setupFiles` reloads the module per file — unique
- * default names avoid "database already exists"; you still get one clone per file.
+ * Memo lives on `globalThis` so Jest `setupFiles` (module reload per file) still
+ * shares one clone per worker. `setupFilesAfterEnv` + `beforeAll` also works.
  */
 export function cloneWorkerDatabase(options: CloneWorkerDatabaseOptions = {}): Promise<void> {
   const name = resolveWorkerName(options);
   const key = workerOptionsKey(options.root, name);
-  if (workerOnce) {
-    if (workerOnceKey !== key) {
+  const existing = readCloneWorkerMemo();
+  if (existing) {
+    if (existing.key !== key) {
       throw new Error(
         `cloneWorkerDatabase already started with different root/name ` +
-          `(first: ${JSON.stringify(workerOnceKey)}, now: ${JSON.stringify(key)})`,
+          `(first: ${JSON.stringify(existing.key)}, now: ${JSON.stringify(key)})`,
       );
     }
-    return workerOnce;
+    return existing.promise;
   }
-  workerOnceKey = key;
-  workerOnce = (async () => {
+  const promise = (async () => {
     await cloneFromTemplateIfNeeded({
       root: options.root,
       mode: "test",
@@ -132,10 +130,9 @@ export function cloneWorkerDatabase(options: CloneWorkerDatabaseOptions = {}): P
       setEnv: true,
     });
   })().catch((err) => {
-    workerOnce = undefined;
-    workerOnceKey = undefined;
-    retainedDefaultName = undefined;
+    writeCloneWorkerMemo(undefined);
     throw err;
   });
-  return workerOnce;
+  writeCloneWorkerMemo({ promise, key });
+  return promise;
 }
diff --git a/tests/template-mode.test.ts b/tests/template-mode.test.ts
index 9e94260..124c7f2 100644
--- a/tests/template-mode.test.ts
+++ b/tests/template-mode.test.ts
@@ -47,6 +47,8 @@ async function withMockedCore<T>(
   },
   run: () => Promise<T>,
 ): Promise<T> {
+  const cloneWorkerMemo = Symbol.for("@cedarjs/pg/cloneWorkerDatabase");
+  delete (globalThis as typeof globalThis & { [cloneWorkerMemo]?: unknown })[cloneWorkerMemo];
   vi.resetModules();
   vi.doMock("../src/core/lifecycle.ts", async () => {
     const actual = await vi.importActual<typeof import("../src/core/lifecycle.ts")>(
@@ -74,6 +76,7 @@ async function withMockedCore<T>(
     vi.doUnmock("../src/core/lifecycle.ts");
     vi.doUnmock("../src/core/template.ts");
     vi.resetModules();
+    delete (globalThis as typeof globalThis & { [cloneWorkerMemo]?: unknown })[cloneWorkerMemo];
   }
 }
 
@@ -171,16 +174,6 @@ test("setupTemplateMode skips migrate/mark when acquire is skipped", async () =>
   });
 });
 
-test("defaultCloneWorkerName is unique across identical timestamps (setupFiles-safe)", async () => {
-  const { defaultCloneWorkerName } = await import("../src/adapters/template-mode.ts");
-  const a = defaultCloneWorkerName({ JEST_WORKER_ID: "3" }, 42, 1_700_000_000_000, "aaa111");
-  const b = defaultCloneWorkerName({ JEST_WORKER_ID: "3" }, 42, 1_700_000_000_000, "bbb222");
-  expect(a).toBe(`3_42_${(1_700_000_000_000).toString(36)}_aaa111`);
-  expect(b).toBe(`3_42_${(1_700_000_000_000).toString(36)}_bbb222`);
-  expect(a).not.toBe(b);
-  expect(defaultCloneWorkerName({}, 7, 99, "ccc333")).toBe(`w_7_${(99).toString(36)}_ccc333`);
-});
-
 test("cloneWorkerDatabase clones via cloneFromTemplateIfNeeded with setEnv true", async () => {
   const prevJest = process.env.JEST_WORKER_ID;
   const prevCedar = process.env.CEDAR_PG;
@@ -192,11 +185,11 @@ test("cloneWorkerDatabase clones via cloneFromTemplateIfNeeded with setEnv true"
   try {
     await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
       const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
-      await cloneWorkerDatabase({ root: "/tmp/wt", name: "explicit" });
+      await cloneWorkerDatabase({ root: "/tmp/wt" });
       expect(cloneFromTemplateIfNeeded).toHaveBeenCalledWith({
         root: "/tmp/wt",
         mode: "test",
-        name: "explicit",
+        name: "3",
         setEnv: true,
       });
     });
@@ -208,37 +201,10 @@ test("cloneWorkerDatabase clones via cloneFromTemplateIfNeeded with setEnv true"
   }
 });
 
-test("cloneWorkerDatabase default name includes worker, pid, time, and entropy", async () => {
+test("cloneWorkerDatabase memo survives module reload (Jest setupFiles)", async () => {
   const prevJest = process.env.JEST_WORKER_ID;
   const prevCedar = process.env.CEDAR_PG;
-  process.env.JEST_WORKER_ID = "3";
-  delete process.env.CEDAR_PG;
-
-  const cloneFromTemplateIfNeeded = vi.fn(async () => clonedWorker());
-
-  try {
-    await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
-      const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
-      await cloneWorkerDatabase({ root: "/tmp/wt" });
-      expect(cloneFromTemplateIfNeeded).toHaveBeenCalledWith(
-        expect.objectContaining({
-          root: "/tmp/wt",
-          mode: "test",
-          setEnv: true,
-          name: expect.stringMatching(new RegExp(`^3_${process.pid}_[0-9a-z]+_[0-9a-f]{6}$`)),
-        }),
-      );
-    });
-  } finally {
-    if (prevJest === undefined) delete process.env.JEST_WORKER_ID;
-    else process.env.JEST_WORKER_ID = prevJest;
-    if (prevCedar === undefined) delete process.env.CEDAR_PG;
-    else process.env.CEDAR_PG = prevCedar;
-  }
-});
-
-test("cloneWorkerDatabase unnamed calls reuse retained default name", async () => {
-  const prevCedar = process.env.CEDAR_PG;
+  process.env.JEST_WORKER_ID = "1";
   delete process.env.CEDAR_PG;
 
   const cloneFromTemplateIfNeeded = vi.fn(async () =>
@@ -247,21 +213,25 @@ test("cloneWorkerDatabase unnamed calls reuse retained default name", async () =
 
   try {
     await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
-      const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
-      await cloneWorkerDatabase({ root: "/tmp/wt" });
-      // Different wall time must not change the retained default key.
-      await new Promise((r) => setTimeout(r, 2));
-      await cloneWorkerDatabase({ root: "/tmp/wt" });
+      const first = await import("../src/adapters/template-mode.ts");
+      await first.cloneWorkerDatabase({ root: "/tmp/wt" });
+      vi.resetModules();
+      const second = await import("../src/adapters/template-mode.ts");
+      await second.cloneWorkerDatabase({ root: "/tmp/wt" });
       expect(cloneFromTemplateIfNeeded).toHaveBeenCalledTimes(1);
     });
   } finally {
+    if (prevJest === undefined) delete process.env.JEST_WORKER_ID;
+    else process.env.JEST_WORKER_ID = prevJest;
     if (prevCedar === undefined) delete process.env.CEDAR_PG;
     else process.env.CEDAR_PG = prevCedar;
   }
 });
 
 test("cloneWorkerDatabase is idempotent per process", async () => {
+  const prevJest = process.env.JEST_WORKER_ID;
   const prevCedar = process.env.CEDAR_PG;
+  process.env.JEST_WORKER_ID = "1";
   delete process.env.CEDAR_PG;
 
   const cloneFromTemplateIfNeeded = vi.fn(async () =>
@@ -271,18 +241,22 @@ test("cloneWorkerDatabase is idempotent per process", async () => {
   try {
     await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
       const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
-      await cloneWorkerDatabase({ name: "stable" });
-      await cloneWorkerDatabase({ name: "stable" });
+      await cloneWorkerDatabase();
+      await cloneWorkerDatabase();
       expect(cloneFromTemplateIfNeeded).toHaveBeenCalledTimes(1);
     });
   } finally {
+    if (prevJest === undefined) delete process.env.JEST_WORKER_ID;
+    else process.env.JEST_WORKER_ID = prevJest;
     if (prevCedar === undefined) delete process.env.CEDAR_PG;
     else process.env.CEDAR_PG = prevCedar;
   }
 });
 
 test("cloneWorkerDatabase rejects conflicting root/name after first call", async () => {
+  const prevJest = process.env.JEST_WORKER_ID;
   const prevCedar = process.env.CEDAR_PG;
+  process.env.JEST_WORKER_ID = "1";
   delete process.env.CEDAR_PG;
 
   const cloneFromTemplateIfNeeded = vi.fn(async () =>
@@ -292,13 +266,15 @@ test("cloneWorkerDatabase rejects conflicting root/name after first call", async
   try {
     await withMockedCore({ cloneFromTemplateIfNeeded }, async () => {
       const { cloneWorkerDatabase } = await import("../src/adapters/template-mode.ts");
-      await cloneWorkerDatabase({ root: "/tmp/a", name: "n" });
-      expect(() => cloneWorkerDatabase({ root: "/tmp/b", name: "n" })).toThrow(
+      await cloneWorkerDatabase({ root: "/tmp/a" });
+      expect(() => cloneWorkerDatabase({ root: "/tmp/b" })).toThrow(
         /already started with different root\/name/,
       );
       expect(cloneFromTemplateIfNeeded).toHaveBeenCalledTimes(1);
     });
   } finally {
+    if (prevJest === undefined) delete process.env.JEST_WORKER_ID;
+    else process.env.JEST_WORKER_ID = prevJest;
     if (prevCedar === undefined) delete process.env.CEDAR_PG;
     else process.env.CEDAR_PG = prevCedar;
   }