@typed/id 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/_uuid-stringify.d.ts

@@ -1,2 +1,17 @@
+/**
+ * Formats the first 16 bytes of a seed as a lowercase hyphenated UUID string.
+ * @remarks
+ * ## Why
+ * This published low-level helper centralizes UUID byte layout formatting but deliberately does not validate length, version, or variant bits.
+ * ## Ownership and lifetime
+ * This pure function acquires no resources, does not mutate or retain the seed, and returns a new string.
+ * @example
+ * ```ts
+ * import { uuidStringify } from "@typed/id/_uuid-stringify"
+ * const text = uuidStringify(new Uint8Array(16))
+ * ```
+ * @category Formatting
+ * @since 1.0.0
+ */
 export declare function uuidStringify(seed: Uint8Array): string;
 //# sourceMappingURL=_uuid-stringify.d.ts.map

package/dist/_uuid-stringify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_uuid-stringify.d.ts","sourceRoot":"","sources":["../src/_uuid-stringify.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAuBtD"}
+{"version":3,"file":"_uuid-stringify.d.ts","sourceRoot":"","sources":["../src/_uuid-stringify.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAuBtD"}

package/dist/_uuid-stringify.js

@@ -2,6 +2,21 @@ const byteToHex = [];
 for (let i = 0; i < 256; ++i) {
     byteToHex.push((i + 0x100).toString(16).slice(1));
 }
+/**
+ * Formats the first 16 bytes of a seed as a lowercase hyphenated UUID string.
+ * @remarks
+ * ## Why
+ * This published low-level helper centralizes UUID byte layout formatting but deliberately does not validate length, version, or variant bits.
+ * ## Ownership and lifetime
+ * This pure function acquires no resources, does not mutate or retain the seed, and returns a new string.
+ * @example
+ * ```ts
+ * import { uuidStringify } from "@typed/id/_uuid-stringify"
+ * const text = uuidStringify(new Uint8Array(16))
+ * ```
+ * @category Formatting
+ * @since 1.0.0
+ */
 export function uuidStringify(seed) {
     return [
         byteToHex[seed[0]],

package/dist/internal/Ids.d.ts

@@ -0,0 +1,23 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import type { Uuid5 } from "../Uuid5.js";
+import { Uuid5Namespace } from "../Uuid5.js";
+import { DateTimes } from "../DateTimes.js";
+import { RandomValues } from "../RandomValues.js";
+export declare const makeLazyIds: (envData: string) => Effect.Effect<{
+    cuid: Effect.Effect<string & import("effect/Brand").Brand<"@typed/id/CUID">, never, never>;
+    ksuid: Effect.Effect<string & import("effect/Brand").Brand<"@typed/id/KSUID">, Cause.IllegalArgumentError, never>;
+    nanoId: Effect.Effect<string & import("effect/Brand").Brand<"@typed/id/NanoId">, never, never>;
+    ulid: Effect.Effect<string & import("effect/Brand").Brand<"@typed/id/ULID">, Cause.IllegalArgumentError, never>;
+    uuid4: Effect.Effect<string & import("effect/Brand").Brand<"@typed/id/UUID4">, never, never>;
+    uuid5: {
+        (namespace: Uuid5Namespace): (name: string) => Effect.Effect<Uuid5, Cause.IllegalArgumentError>;
+        (name: string, namespace: Uuid5Namespace): Effect.Effect<Uuid5, Cause.IllegalArgumentError>;
+        readonly dns: (name: string) => Effect.Effect<Uuid5, Cause.IllegalArgumentError>;
+        readonly url: (name: string) => Effect.Effect<Uuid5, Cause.IllegalArgumentError>;
+        readonly oid: (name: string) => Effect.Effect<Uuid5, Cause.IllegalArgumentError>;
+        readonly x500: (name: string) => Effect.Effect<Uuid5, Cause.IllegalArgumentError>;
+    };
+    uuid7: Effect.Effect<string & import("effect/Brand").Brand<"@typed/id/UUID7">, Cause.IllegalArgumentError, never>;
+}, never, DateTimes | RandomValues>;
+//# sourceMappingURL=Ids.d.ts.map

package/dist/internal/Ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ids.d.ts","sourceRoot":"","sources":["../../src/internal/Ids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,cAAc,EAAS,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKlD,eAAO,MAAM,WAAW,YAAa,MAAM;;;;;;;oBAQxB,cAAc,GACxB,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC;eAC9D,MAAM,aAAa,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC;sBAC7E,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC;sBAClE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC;sBAClE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC;uBACjE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAC;;;mCAwBnF,CAAC"}

package/dist/internal/Ids.js

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import { Uuid5Namespace, uuid5 } from "../Uuid5.js";
+import { CuidState, cuid } from "../Cuid.js";
+import { ksuid } from "../Ksuid.js";
+import { nanoId } from "../NanoId.js";
+import { ulid } from "../Ulid.js";
+import { uuid4 } from "../Uuid4.js";
+import { Uuid7State, uuid7 } from "../Uuid7.js";
+export const makeLazyIds = (envData) => Effect.gen(function* () {
+    const services = yield* Effect.context();
+    const getCuidState = yield* Effect.cached(Effect.provide(CuidState.make(envData), services));
+    const getUuid7State = yield* Effect.cached(Effect.provide(Uuid7State.make, services));
+    const uuid5_ = Object.assign(dual(2, (name, namespace) => Effect.provide(uuid5(name, namespace), services)), {
+        dns: uuid5(Uuid5Namespace.DNS),
+        url: uuid5(Uuid5Namespace.URL),
+        oid: uuid5(Uuid5Namespace.OID),
+        x500: uuid5(Uuid5Namespace.X500),
+    });
+    return {
+        cuid: Effect.flatMap(getCuidState, (state) => Effect.provideService(cuid, CuidState, state)),
+        ksuid: Effect.provide(ksuid, services),
+        nanoId: Effect.provide(nanoId, services),
+        ulid: Effect.provide(ulid, services),
+        uuid4: Effect.provide(uuid4, services),
+        uuid5: uuid5_,
+        uuid7: Effect.flatMap(getUuid7State, (state) => Effect.provideService(uuid7, Uuid7State, state)),
+    };
+});

package/package.json

@@ -1,29 +1,91 @@
 {
   "name": "@typed/id",
-  "version": "1.0.0-beta.0",
-  "publishConfig": {
-    "access": "public"
+  "version": "1.0.0-beta.10",
+  "description": "Branded ID generators and facades for Typed applications.",
+  "homepage": "https://github.com/TylorS/typed/tree/development/packages/id#readme",
+  "bugs": "https://github.com/TylorS/typed/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TylorS/typed.git",
+    "directory": "packages/id"
   },
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./*": {
-      "types": "./dist/*.d.ts",
-      "import": "./dist/*.js"
+    "./Cuid": {
+      "types": "./dist/Cuid.d.ts",
+      "import": "./dist/Cuid.js"
+    },
+    "./DateTimes": {
+      "types": "./dist/DateTimes.d.ts",
+      "import": "./dist/DateTimes.js"
+    },
+    "./Ids": {
+      "types": "./dist/Ids.d.ts",
+      "import": "./dist/Ids.js"
+    },
+    "./IdsTest": {
+      "types": "./dist/IdsTest.d.ts",
+      "import": "./dist/IdsTest.js"
+    },
+    "./Ksuid": {
+      "types": "./dist/Ksuid.d.ts",
+      "import": "./dist/Ksuid.js"
+    },
+    "./NanoId": {
+      "types": "./dist/NanoId.d.ts",
+      "import": "./dist/NanoId.js"
+    },
+    "./RandomValues": {
+      "types": "./dist/RandomValues.d.ts",
+      "import": "./dist/RandomValues.js"
+    },
+    "./Ulid": {
+      "types": "./dist/Ulid.d.ts",
+      "import": "./dist/Ulid.js"
+    },
+    "./Uuid4": {
+      "types": "./dist/Uuid4.d.ts",
+      "import": "./dist/Uuid4.js"
+    },
+    "./Uuid5": {
+      "types": "./dist/Uuid5.d.ts",
+      "import": "./dist/Uuid5.js"
+    },
+    "./Uuid7": {
+      "types": "./dist/Uuid7.d.ts",
+      "import": "./dist/Uuid7.js"
+    },
+    "./_sha": {
+      "types": "./dist/_sha.d.ts",
+      "import": "./dist/_sha.js"
+    },
+    "./_uuid-stringify": {
+      "types": "./dist/_uuid-stringify.d.ts",
+      "import": "./dist/_uuid-stringify.js"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "effect": "4.0.0-beta.4"
+    "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
-    "typescript": "5.9.3",
-    "vitest": "4.0.18"
+    "typescript": "7.0.2",
+    "vitest": "5.0.0"
   },
   "scripts": {
-    "build": "tsc",
-    "test": "vitest run --passWithNoTests"
+    "build": "node -e \"const fs=require('node:fs'); fs.rmSync('dist',{recursive:true,force:true}); fs.rmSync('tsconfig.tsbuildinfo',{force:true})\" && tsc",
+    "test": "vitest run",
+    "test:types": "tsc -p tsconfig.type-tests.json && tsc -p tsconfig.tests.json"
   }
 }

package/dist/Id.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Id.test.d.ts.map

package/dist/Id.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Id.test.d.ts","sourceRoot":"","sources":["../src/Id.test.ts"],"names":[],"mappings":""}

package/dist/Id.test.js

@@ -1,190 +0,0 @@
-import * as Effect from "effect/Effect";
-import { describe, expect, it } from "vitest";
-import * as Cuid from "./Cuid.js";
-import { Ids } from "./Ids.js";
-import * as Ksuid from "./Ksuid.js";
-import * as NanoId from "./NanoId.js";
-import * as Ulid from "./Ulid.js";
-import * as Uuid4 from "./Uuid4.js";
-import * as Uuid5 from "./Uuid5.js";
-import * as Uuid7 from "./Uuid7.js";
-const run = (effect) => Effect.runPromise(Effect.provide(effect, Ids.Test()));
-describe("@typed/id", () => {
-    describe("type guards", () => {
-        describe("isUuid4", () => {
-            it("accepts valid UUID v4", () => {
-                expect(Uuid4.isUuid4("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(true);
-                expect(Uuid4.isUuid4("550e8400-e29b-41d4-a716-446655440000")).toBe(true);
-            });
-            it("rejects invalid formats", () => {
-                expect(Uuid4.isUuid4("")).toBe(false);
-                expect(Uuid4.isUuid4("not-a-uuid")).toBe(false);
-                expect(Uuid4.isUuid4("f47ac10b-58cc-4372-a567-0e02b2c3d479".replace(/-/g, ""))).toBe(false);
-                expect(Uuid4.isUuid4("g47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // invalid hex
-            });
-            it("rejects UUID v5 as UUID v4", () => {
-                expect(Uuid4.isUuid4("886313e1-3b8a-5372-9b90-0c9aee199e5d")).toBe(false);
-            });
-        });
-        describe("isUuid5", () => {
-            it("accepts valid UUID v5", () => {
-                expect(Uuid5.isUuid5("886313e1-3b8a-5372-9b90-0c9aee199e5d")).toBe(true);
-                expect(Uuid5.isUuid5("c2ee5f2e-5b2e-5f2e-8b2e-5b2e5f2e8b2e")).toBe(true);
-            });
-            it("rejects invalid formats", () => {
-                expect(Uuid5.isUuid5("")).toBe(false);
-                expect(Uuid5.isUuid5("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // v4
-            });
-        });
-        describe("isUuid7", () => {
-            it("accepts valid UUID v7", () => {
-                expect(Uuid7.isUuid7("018eebb4-1f2c-7c3a-8b4d-123456789abc")).toBe(true);
-            });
-            it("rejects invalid formats", () => {
-                expect(Uuid7.isUuid7("")).toBe(false);
-                expect(Uuid7.isUuid7("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // v4
-            });
-        });
-        describe("isCuid", () => {
-            it("accepts valid CUID-like strings (lowercase letter + base36)", () => {
-                expect(Cuid.isCuid("c1234567890abcdefghijklmn")).toBe(true);
-                expect(Cuid.isCuid("a0")).toBe(true);
-            });
-            it("rejects invalid formats", () => {
-                expect(Cuid.isCuid("")).toBe(false);
-                expect(Cuid.isCuid("A123")).toBe(false); // must start with lowercase
-                expect(Cuid.isCuid("1abc")).toBe(false); // must start with letter
-                expect(Cuid.isCuid("c123-456")).toBe(false); // no hyphen
-            });
-        });
-        describe("isKsuid", () => {
-            it("accepts 27-char base62 strings", () => {
-                expect(Ksuid.isKsuid("0ujsszwN8NRYtYaMBZrYCVp4O1")).toBe(true);
-                expect(Ksuid.isKsuid("0123456789ABCDEFGHIJKLMNOP")).toBe(true);
-            });
-            it("rejects invalid formats", () => {
-                expect(Ksuid.isKsuid("")).toBe(false);
-                expect(Ksuid.isKsuid("short")).toBe(false);
-                expect(Ksuid.isKsuid("0ujsszwN8NRYtYaMBZrYCVp4O1!")).toBe(false); // 28 chars, invalid char
-            });
-        });
-        describe("isNanoId", () => {
-            it("accepts strings with only 0-9a-zA-Z_-", () => {
-                expect(NanoId.isNanoId("V1StGXR8_Z5jdHi6B-myT")).toBe(true);
-                expect(NanoId.isNanoId("abc123")).toBe(true);
-                expect(NanoId.isNanoId("_-_")).toBe(true);
-            });
-            it("rejects invalid characters", () => {
-                expect(NanoId.isNanoId("")).toBe(false);
-                expect(NanoId.isNanoId("space in id")).toBe(false);
-                expect(NanoId.isNanoId("dot.id")).toBe(false);
-            });
-        });
-        describe("isUlid", () => {
-            it("accepts valid ULIDs", () => {
-                expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FAV")).toBe(true);
-                expect(Ulid.isUlid("0123456789ABCDEFGHJKMNPQR")).toBe(true);
-            });
-            it("rejects invalid formats", () => {
-                expect(Ulid.isUlid("")).toBe(false);
-                expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FA")).toBe(false); // wrong length
-                expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FAV0")).toBe(false); // wrong length
-                expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FAI")).toBe(false); // I not in Crockford base32
-            });
-        });
-    });
-    describe("Ids service", () => {
-        it("uuid4 produces valid UUID v4", async () => {
-            const id = await run(Ids.uuid4);
-            expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-            expect(Uuid4.isUuid4(id)).toBe(true);
-        });
-        it("uuid5 produces valid UUID v5", async () => {
-            const id = await run(Ids.uuid5("hello", Uuid5.Uuid5Namespace.DNS));
-            expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-            expect(Uuid5.isUuid5(id)).toBe(true);
-        });
-        it("uuid5 is deterministic for same name and namespace", async () => {
-            const a = await run(Ids.uuid5("test", Uuid5.Uuid5Namespace.URL));
-            const b = await run(Ids.uuid5("test", Uuid5.Uuid5Namespace.URL));
-            expect(a).toBe(b);
-        });
-        it("uuid5 differs for different names", async () => {
-            const a = await run(Ids.uuid5("a", Uuid5.Uuid5Namespace.DNS));
-            const b = await run(Ids.uuid5("b", Uuid5.Uuid5Namespace.DNS));
-            expect(a).not.toBe(b);
-        });
-        it("uuid5 predefined namespaces work", async () => {
-            const dns = await run(Ids.uuid5.dns("example.com"));
-            const url = await run(Ids.uuid5.url("https://example.com"));
-            const oid = await run(Ids.uuid5.oid("1.2.3"));
-            const x500 = await run(Ids.uuid5.x500("cn=test"));
-            expect(Uuid5.isUuid5(dns)).toBe(true);
-            expect(Uuid5.isUuid5(url)).toBe(true);
-            expect(Uuid5.isUuid5(oid)).toBe(true);
-            expect(Uuid5.isUuid5(x500)).toBe(true);
-            expect(new Set([dns, url, oid, x500]).size).toBe(4);
-        });
-        it("uuid7 produces valid UUID v7", async () => {
-            const id = await run(Ids.uuid7);
-            expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
-            expect(Uuid7.isUuid7(id)).toBe(true);
-        });
-        it("cuid produces valid CUID", async () => {
-            const id = await run(Ids.cuid);
-            expect(Cuid.isCuid(id)).toBe(true);
-            expect(id).toMatch(/^[a-z][0-9a-z]+$/);
-        });
-        it("ksuid produces valid KSUID", async () => {
-            const id = await run(Ids.ksuid);
-            expect(Ksuid.isKsuid(id)).toBe(true);
-            expect(id).toHaveLength(27);
-            expect(id).toMatch(/^[0-9a-zA-Z]{27}$/);
-        });
-        it("nanoId produces valid NanoId", async () => {
-            const id = await run(Ids.nanoId);
-            expect(NanoId.isNanoId(id)).toBe(true);
-            expect(id).toMatch(/^[0-9a-zA-Z_-]+$/);
-            expect(id).toHaveLength(21);
-        });
-        it("ulid produces valid ULID", async () => {
-            const id = await run(Ids.ulid);
-            expect(Ulid.isUlid(id)).toBe(true);
-            expect(id).toHaveLength(26);
-            expect(id).toMatch(/^[0-9A-HJKMNP-TV-Z]{26}$/);
-        });
-        it("Ids.Test with fixed time yields deterministic time-based prefixes", async () => {
-            const fixedTime = new Date("2025-01-15T12:00:00Z").getTime();
-            const runFixed = (effect) => Effect.runPromise(Effect.provide(effect, Ids.Test({ currentTime: fixedTime })));
-            const ulid1 = await runFixed(Ids.ulid);
-            const ulid2 = await runFixed(Ids.ulid);
-            const ksuid1 = await runFixed(Ids.ksuid);
-            const ksuid2 = await runFixed(Ids.ksuid);
-            expect(ulid1.slice(0, 10)).toBe(ulid2.slice(0, 10));
-            expect(ksuid1.slice(0, 5)).toBe(ksuid2.slice(0, 5));
-        });
-    });
-    describe("Ids.Default", () => {
-        it("runs all generators with default layer", async () => {
-            const program = Effect.gen(function* () {
-                const ids = yield* Ids;
-                const u4 = yield* ids.uuid4;
-                const u5 = yield* ids.uuid5("default-test", Uuid5.Uuid5Namespace.DNS);
-                const u7 = yield* ids.uuid7;
-                const c = yield* ids.cuid;
-                const k = yield* ids.ksuid;
-                const n = yield* ids.nanoId;
-                const u = yield* ids.ulid;
-                return { u4, u5, u7, c, k, n, u };
-            });
-            const result = await Effect.runPromise(Effect.provide(program, Ids.Default));
-            expect(Uuid4.isUuid4(result.u4)).toBe(true);
-            expect(Uuid5.isUuid5(result.u5)).toBe(true);
-            expect(Uuid7.isUuid7(result.u7)).toBe(true);
-            expect(Cuid.isCuid(result.c)).toBe(true);
-            expect(Ksuid.isKsuid(result.k)).toBe(true);
-            expect(NanoId.isNanoId(result.n)).toBe(true);
-            expect(Ulid.isUlid(result.u)).toBe(true);
-        });
-    });
-});

package/src/Cuid.ts

@@ -1,124 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Schema from "effect/Schema";
-import * as ServiceMap from "effect/ServiceMap";
-import { sha512 } from "./_sha.js";
-import { DateTimes } from "./DateTimes.js";
-import { RandomValues } from "./RandomValues.js";
-
-// Constants
-const DEFAULT_LENGTH = 24;
-const BIG_LENGTH = 32;
-const INITIAL_COUNT_MAX = 476782367;
-
-// Schema
-export const Cuid = Schema.String.pipe(
-  Schema.check(Schema.isPattern(/^[a-z][0-9a-z]+$/)),
-  Schema.brand("@typed/id/CUID"),
-);
-export type Cuid = Schema.Schema.Type<typeof Cuid>;
-
-export const isCuid: (value: string) => value is Cuid = Schema.is(Cuid);
-
-// Types
-export type CuidSeed = {
-  readonly timestamp: number;
-  readonly counter: number;
-  readonly random: Uint8Array;
-  readonly fingerprint: string;
-};
-
-export class CuidState extends ServiceMap.Service<CuidState>()("@typed/id/CuidState", {
-  make: (envData: string) =>
-    Effect.gen(function* () {
-      const { now } = yield* DateTimes;
-      const getRandomValues = yield* RandomValues;
-      const initialBytes = yield* getRandomValues(4);
-      const initialValue =
-        Math.abs(
-          (initialBytes[0] << 24) |
-            (initialBytes[1] << 16) |
-            (initialBytes[2] << 8) |
-            initialBytes[3],
-        ) % INITIAL_COUNT_MAX;
-
-      // Create fingerprint from environment data
-      const fingerprint = (yield* hash(envData)).substring(0, BIG_LENGTH);
-
-      let counter = initialValue;
-
-      return Effect.gen(function* () {
-        const timestamp = yield* now;
-        const random = yield* getRandomValues(32);
-        return {
-          timestamp,
-          counter: counter++,
-          random,
-          fingerprint,
-        } satisfies CuidSeed;
-      });
-    }),
-}) {
-  static readonly next = Effect.flatten(CuidState.asEffect());
-
-  static readonly Default = Layer.effect(CuidState, CuidState.make("node")).pipe(
-    Layer.provideMerge([DateTimes.Default, RandomValues.Default]),
-  );
-}
-
-export const cuid: Effect.Effect<Cuid, never, CuidState> = Effect.flatMap(
-  CuidState.next,
-  cuidFromSeed,
-);
-
-// Utilities
-const ALPHABET = Array.from({ length: 26 }, (_, i) => String.fromCharCode(i + 97));
-const encoder = new TextEncoder();
-
-function createEntropy(length: number, random: Uint8Array): string {
-  let entropy = "";
-  let offset = 0;
-
-  while (entropy.length < length) {
-    const value = random[offset];
-    entropy += Math.floor(value % 36).toString(36);
-    offset = (offset + 1) % random.length;
-  }
-
-  return entropy;
-}
-
-function hash(input: string): Effect.Effect<string> {
-  return Effect.map(sha512(encoder.encode(input)), (buffer) => {
-    const view = new Uint8Array(buffer);
-    let value = 0n;
-    for (const byte of view) {
-      value = (value << 8n) + BigInt(byte);
-    }
-    // Drop the first character because it will bias the histogram to the left
-    return value.toString(36).slice(1);
-  });
-}
-
-function cuidFromSeed({ counter, fingerprint, random, timestamp }: CuidSeed): Effect.Effect<Cuid> {
-  return Effect.gen(function* () {
-    // First letter is always a random lowercase letter from the seed
-    const firstLetter = ALPHABET[random[0] % ALPHABET.length];
-
-    // Convert components to base36
-    const time = timestamp.toString(36);
-    const count = counter.toString(36);
-
-    // Create entropy from remaining random bytes
-    const salt = createEntropy(4, random.slice(1));
-
-    // Hash all components together
-    const hashInput = `${time}${salt}${count}${fingerprint}`;
-    const hashed = yield* hash(hashInput);
-
-    // Construct the final CUID
-    const id = `${firstLetter}${hashed.substring(0, DEFAULT_LENGTH - 1)}`;
-
-    return Cuid.makeUnsafe(id);
-  });
-}

package/src/DateTimes.ts

@@ -1,36 +0,0 @@
-import * as Clock from "effect/Clock";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as ServiceMap from "effect/ServiceMap";
-
-export class DateTimes extends ServiceMap.Service<DateTimes>()("@typed/id/DateTimes", {
-  make: Effect.succeed({
-    now: Effect.sync(() => Date.now()),
-    date: Effect.sync(() => new Date()),
-  }),
-}) {
-  static readonly now = Effect.flatMap(DateTimes.asEffect(), ({ now }) => now);
-  static readonly date = Effect.flatMap(DateTimes.asEffect(), ({ date }) => date);
-
-  static readonly Default = Layer.effect(DateTimes, DateTimes.make);
-
-  static readonly Fixed = (baseDate: number | string | Date) =>
-    Layer.effect(
-      DateTimes,
-      Effect.gen(function* () {
-        const clock = yield* Clock.Clock;
-        const base = new Date(baseDate);
-        const baseN = BigInt(base.getTime());
-        const startMillis = yield* clock.currentTimeMillis;
-        const now = clock.currentTimeMillis.pipe(
-          Effect.map((millis) =>
-            // Use BigInt to avoid floating point precision issues which can break deterministic testing
-            Number(baseN + BigInt(millis) - BigInt(startMillis)),
-          ),
-        );
-        const date = now.pipe(Effect.map((millis) => new Date(millis)));
-
-        return DateTimes.of({ now, date });
-      }),
-    );
-}