refactor(core): remove test-only ksuid-mint process-global from friendlyId

Production mints ksuid runs explicitly via generateKsuidId() at gated
trigger sites; the mutable process-global only ever let tests puppet
RunId/WaitpointId.generate() into ksuids and cannot express per-org
behavior. Delete setKsuidMintEnabled/isKsuidMintEnabled and the flag
branch; generateInternalId() and IdUtil now always mint cuid. Tests
drive the ksuid path via generateKsuidId() directly, preserving the
25-vs-27 disjoint-length, k-sortability, uniqueness, and payload
round-trip coverage.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: d-cs

packages/core/src/v3/isomorphic/friendlyId.test.ts

@@ -4,8 +4,6 @@ import {
   WaitpointId,
   SnapshotId,
   QueueId,
-  setKsuidMintEnabled,
-  isKsuidMintEnabled,
   generateKsuidId,
   decodeKsuid,
   KSUID_PAYLOAD_BYTES,
@@ -14,12 +12,8 @@ import {
 const CUID_LEN = 25;
 const KSUID_LEN = 27;
 
-afterEach(() => setKsuidMintEnabled(false)); // never leak flag state across tests
-
-describe("KSUID mint (flag-gated) for RunId + WaitpointId", () => {
-  it("flag OFF: run + waitpoint mint cuid (25) and round-trip", () => {
-    setKsuidMintEnabled(false);
-    expect(isKsuidMintEnabled()).toBe(false);
+describe("RunId + WaitpointId mint cuid by default; ksuid via generateKsuidId", () => {
+  it("default: run + waitpoint mint cuid (25) and round-trip", () => {
     for (const util of [RunId, WaitpointId]) {
       const { id, friendlyId } = util.generate();
       expect(id.length).toBe(CUID_LEN);
@@ -30,37 +24,27 @@ describe("KSUID mint (flag-gated) for RunId + WaitpointId", () => {
     }
   });
 
-  it("flag ON: run + waitpoint mint 27-char and round-trip", () => {
-    setKsuidMintEnabled(true);
-    expect(isKsuidMintEnabled()).toBe(true);
+  it("explicit ksuid: a run/waitpoint friendlyId over generateKsuidId() is 27-char and round-trips", () => {
     for (const util of [RunId, WaitpointId]) {
-      const { id, friendlyId } = util.generate();
+      const id = generateKsuidId();
+      const friendlyId = util.toFriendlyId(id);
       expect(id.length).toBe(KSUID_LEN);
       expect(util.fromFriendlyId(friendlyId)).toBe(id);
       expect(util.toId(friendlyId)).toBe(id);
       expect(util.toId(id)).toBe(id);
-      expect(util.toFriendlyId(id)).toBe(friendlyId);
     }
   });
 
-  it("flag ON: SnapshotId stays cuid (25) — never 27-char", () => {
-    setKsuidMintEnabled(true);
-    const { id } = SnapshotId.generate();
-    expect(id.length).toBe(CUID_LEN);
-  });
-
-  it("flag ON: a non-run/waitpoint entity stays cuid (25)", () => {
-    setKsuidMintEnabled(true);
+  it("SnapshotId + QueueId stay cuid (25)", () => {
+    expect(SnapshotId.generate().id.length).toBe(CUID_LEN);
     expect(QueueId.generate().id.length).toBe(CUID_LEN);
   });
 
-  it("disjoint lengths: 27 (new) vs 25 (cuid) — the classifier margin", () => {
-    setKsuidMintEnabled(true);
-    expect(RunId.generate().id.length).not.toBe(SnapshotId.generate().id.length);
+  it("disjoint lengths: 27 (ksuid) vs 25 (cuid) — the classifier margin", () => {
+    expect(generateKsuidId().length).not.toBe(SnapshotId.generate().id.length);
   });
 
-  it("generateKsuidId() is directly callable, independent of the flag", () => {
-    setKsuidMintEnabled(false); // must NOT be gated behind the global flag
+  it("generateKsuidId() is directly callable and yields 27 chars", () => {
     expect(generateKsuidId().length).toBe(KSUID_LEN);
   });
 });

packages/core/src/v3/isomorphic/friendlyId.ts

@@ -7,20 +7,6 @@ export function generateFriendlyId(prefix: string, size?: number) {
   return `${prefix}_${idGenerator(size)}`;
 }
 
-// Injected by the server split-mode bootstrap. Default false =
-// today's behavior (cuid). Isomorphic file: never read process.env here.
-let ksuidMintEnabled = false;
-
-/** Server bootstrap calls this once with isSplitEnabled(). Off by default. */
-export function setKsuidMintEnabled(enabled: boolean): void {
-  ksuidMintEnabled = enabled;
-}
-
-/** Test/diagnostic read-back of the current mint mode. */
-export function isKsuidMintEnabled(): boolean {
-  return ksuidMintEnabled;
-}
-
 // KSUID epoch (2014-05-13T16:53:20Z) — seconds offset applied to the unix timestamp.
 const KSUID_EPOCH = 1_400_000_000;
 const KSUID_TIMESTAMP_BYTES = 4;
@@ -136,10 +122,7 @@ export function decodeKsuid(idOrFriendlyId: string): DecodedKsuid {
   };
 }
 
-export function generateInternalId(useKsuidWhenEnabled = false): string {
-  if (useKsuidWhenEnabled && ksuidMintEnabled) {
-    return generateKsuidId();
-  }
+export function generateInternalId(): string {
   return cuid();
 }
 
@@ -190,13 +173,10 @@ export function fromFriendlyId(friendlyId: string, expectedEntityName?: string):
 }
 
 export class IdUtil {
-  constructor(
-    private entityName: string,
-    private ksuidWhenEnabled = false
-  ) {}
+  constructor(private entityName: string) {}
 
   generate() {
-    const internalId = generateInternalId(this.ksuidWhenEnabled);
+    const internalId = generateInternalId();
 
     return {
       id: internalId,
@@ -225,9 +205,9 @@ export class IdUtil {
 export const BackgroundWorkerId = new IdUtil("worker");
 export const CheckpointId = new IdUtil("checkpoint");
 export const QueueId = new IdUtil("queue");
-export const RunId = new IdUtil("run", true);
+export const RunId = new IdUtil("run");
 export const SnapshotId = new IdUtil("snapshot");
-export const WaitpointId = new IdUtil("waitpoint", true);
+export const WaitpointId = new IdUtil("waitpoint");
 export const BatchId = new IdUtil("batch");
 export const BulkActionId = new IdUtil("bulk");
 export const AttemptId = new IdUtil("attempt");

packages/core/src/v3/isomorphic/runOpsResidency.test.ts

@@ -1,5 +1,5 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { RunId, WaitpointId, SnapshotId, setKsuidMintEnabled } from "./friendlyId.js";
+import { describe, expect, it } from "vitest";
+import { RunId, WaitpointId, SnapshotId, generateKsuidId } from "./friendlyId.js";
 import {
   ownerEngine,
   classifyResidency,
@@ -8,13 +8,10 @@ import {
   UnclassifiableRunId,
 } from "./runOpsResidency.js";
 
-afterEach(() => setKsuidMintEnabled(false)); // never leak mint-flag state across tests
-
 const SAMPLES = 50_000; // property-scale; CI-fast. (Bump locally toward "millions" for deeper coverage.)
 
 describe("ownerEngine — residency classifier", () => {
-  it("cuid-length ids (mint flag OFF) classify LEGACY, friendly + internal", () => {
-    setKsuidMintEnabled(false);
+  it("cuid-length ids (default mint) classify LEGACY, friendly + internal", () => {
     for (const util of [RunId, WaitpointId]) {
       const { id, friendlyId } = util.generate();
       expect(ownerEngine(id)).toBe("LEGACY");
@@ -25,10 +22,10 @@ describe("ownerEngine — residency classifier", () => {
     }
   });
 
-  it("ksuid-length ids (mint flag ON) classify NEW, friendly + internal", () => {
-    setKsuidMintEnabled(true);
+  it("ksuid-length ids (explicit generateKsuidId) classify NEW, friendly + internal", () => {
     for (const util of [RunId, WaitpointId]) {
-      const { id, friendlyId } = util.generate();
+      const id = generateKsuidId();
+      const friendlyId = util.toFriendlyId(id);
       expect(ownerEngine(id)).toBe("NEW");
       expect(ownerEngine(friendlyId)).toBe("NEW");
       expect(classifyResidency(id)).toBe("NEW");
@@ -38,10 +35,8 @@ describe("ownerEngine — residency classifier", () => {
 
   it("disjointness: no cuid sample is ever NEW, no ksuid sample is ever LEGACY", () => {
     for (let i = 0; i < SAMPLES; i++) {
-      setKsuidMintEnabled(false);
       expect(ownerEngine(RunId.generate().id)).toBe("LEGACY");
-      setKsuidMintEnabled(true);
-      expect(ownerEngine(RunId.generate().id)).toBe("NEW");
+      expect(ownerEngine(generateKsuidId())).toBe("NEW");
     }
   });
 
@@ -61,8 +56,7 @@ describe("ownerEngine — residency classifier", () => {
     }
   });
 
-  it("SnapshotId (always cuid, even with flag ON) classifies LEGACY — proves snapshot needs no residency key", () => {
-    setKsuidMintEnabled(true);
+  it("SnapshotId (always cuid) classifies LEGACY — proves snapshot needs no residency key", () => {
     expect(ownerEngine(SnapshotId.generate().id)).toBe("LEGACY");
   });
 });