@typed/id 1.0.0-beta.3 → 1.0.0-beta.5

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/package.json

@@ -1,33 +1,87 @@
 {
   "name": "@typed/id",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
+  "description": "Branded ID generators and facades for Typed applications.",
+  "license": "MIT",
+  "homepage": "https://github.com/TylorS/typed-smol/tree/main/packages/id#readme",
+  "bugs": "https://github.com/TylorS/typed-smol/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TylorS/typed-smol.git",
+    "directory": "packages/id"
+  },
   "files": [
-    "dist",
-    "src"
+    "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"
+    },
+    "./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.38"
+    "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
-    "typescript": "5.9.3",
-    "vitest": "4.1.1"
+    "typescript": "7.0.2",
+    "vitest": "5.0.0"
   },
   "scripts": {
-    "build": "[ -d dist ] || rm -f tsconfig.tsbuildinfo; 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/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 });
-      }),
-    );
-}

package/src/Id.test.ts

@@ -1,230 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FastCheck from "effect/testing/FastCheck";
-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";
-import { Random } from "effect";
-
-const run = <A, E>(effect: Effect.Effect<A, E, Ids>) =>
-  Effect.runPromise(Effect.provide(effect, Ids.Test()));
-
-describe("@typed/id", () => {
-  describe("type guards (property-based)", () => {
-    describe("isUuid4", () => {
-      it("accepts any UUID v4", () => {
-        FastCheck.assert(
-          FastCheck.property(FastCheck.uuid({ version: 4 }), (s) => Uuid4.isUuid4(s)),
-        );
-      });
-      it("rejects non-UUID-v4 strings", () => {
-        const invalid = FastCheck.oneof(
-          FastCheck.constant(""),
-          FastCheck.string({ maxLength: 35 }).filter((s) => s.length < 36),
-          FastCheck.string().filter(
-            (s) =>
-              !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(s),
-          ),
-        );
-        FastCheck.assert(FastCheck.property(invalid, (s) => !Uuid4.isUuid4(s)));
-      });
-    });
-
-    describe("isUuid5", () => {
-      it("accepts any UUID v5", () => {
-        FastCheck.assert(
-          FastCheck.property(FastCheck.uuid({ version: 5 }), (s) => Uuid5.isUuid5(s)),
-        );
-      });
-      it("rejects non-UUID-v5 strings", () => {
-        const invalid = FastCheck.oneof(
-          FastCheck.constant(""),
-          FastCheck.string().filter(
-            (s) =>
-              !/^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(s),
-          ),
-        );
-        FastCheck.assert(FastCheck.property(invalid, (s) => !Uuid5.isUuid5(s)));
-      });
-    });
-
-    describe("isUuid7", () => {
-      it("accepts any UUID v7", () => {
-        FastCheck.assert(
-          FastCheck.property(FastCheck.uuid({ version: 7 }), (s) => Uuid7.isUuid7(s)),
-        );
-      });
-      it("rejects non-UUID-v7 strings", () => {
-        const invalid = FastCheck.oneof(
-          FastCheck.constant(""),
-          FastCheck.string().filter(
-            (s) =>
-              !/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(s),
-          ),
-        );
-        FastCheck.assert(FastCheck.property(invalid, (s) => !Uuid7.isUuid7(s)));
-      });
-    });
-
-    describe("isCuid", () => {
-      it("accepts any CUID-like string (lowercase letter + base36)", () => {
-        const cuidArb = FastCheck.stringMatching(/^[a-z][0-9a-z]+$/);
-        FastCheck.assert(FastCheck.property(cuidArb, (s) => Cuid.isCuid(s)));
-      });
-      it("rejects strings that do not match CUID pattern", () => {
-        const invalid = FastCheck.oneof(
-          FastCheck.constant(""),
-          FastCheck.string().filter((s) => !/^[a-z][0-9a-z]+$/.test(s)),
-        );
-        FastCheck.assert(FastCheck.property(invalid, (s) => !Cuid.isCuid(s)));
-      });
-    });
-
-    describe("isKsuid", () => {
-      it("accepts any 27-char base62 string", () => {
-        const ksuidArb = FastCheck.stringMatching(/^[0-9A-Za-z]{27}$/);
-        FastCheck.assert(FastCheck.property(ksuidArb, (s) => Ksuid.isKsuid(s)));
-      });
-      it("rejects non-KSUID strings", () => {
-        const invalid = FastCheck.oneof(
-          FastCheck.constant(""),
-          FastCheck.string().filter((s) => s.length !== 27 || !/^[0-9A-Za-z]{27}$/.test(s)),
-        );
-        FastCheck.assert(FastCheck.property(invalid, (s) => !Ksuid.isKsuid(s)));
-      });
-    });
-
-    describe("isNanoId", () => {
-      it("accepts any string with only 0-9a-zA-Z_-", () => {
-        const nanoIdArb = FastCheck.stringMatching(/^[0-9a-zA-Z_-]+$/);
-        FastCheck.assert(FastCheck.property(nanoIdArb, (s) => NanoId.isNanoId(s)));
-      });
-      it("rejects strings with invalid characters", () => {
-        const invalid = FastCheck.oneof(
-          FastCheck.constant(""),
-          FastCheck.string().filter((s) => !/^[0-9a-zA-Z_-]+$/.test(s)),
-        );
-        FastCheck.assert(FastCheck.property(invalid, (s) => !NanoId.isNanoId(s)));
-      });
-    });
-
-    describe("isUlid", () => {
-      it("accepts any valid ULID", () => {
-        FastCheck.assert(FastCheck.property(FastCheck.ulid(), (s) => Ulid.isUlid(s)));
-      });
-      it("rejects non-ULID strings", () => {
-        const invalid = FastCheck.oneof(
-          FastCheck.constant(""),
-          FastCheck.string().filter(
-            (s) => s.length !== 26 || !/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/.test(s),
-          ),
-        );
-        FastCheck.assert(FastCheck.property(invalid, (s) => !Ulid.isUlid(s)));
-      });
-    });
-  });
-
-  describe("Ids service", () => {
-    it("uuid4 produces valid UUID v4", async () => {
-      const id = await run(Ids.uuid4);
-      expect(Uuid4.isUuid4(id)).toBe(true);
-    });
-
-    it("uuid5 produces valid UUID v5", async () => {
-      const id = await run(Ids.uuid5("hello", Uuid5.Uuid5Namespace.DNS));
-      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(Uuid7.isUuid7(id)).toBe(true);
-    });
-
-    it("cuid produces valid CUID", async () => {
-      const id = await run(Ids.cuid);
-      expect(Cuid.isCuid(id)).toBe(true);
-    });
-
-    it("ksuid produces valid KSUID", async () => {
-      const id = await run(Ids.ksuid);
-      expect(Ksuid.isKsuid(id)).toBe(true);
-      expect(id).toHaveLength(27);
-    });
-
-    it("nanoId produces valid NanoId", async () => {
-      const id = await run(Ids.nanoId);
-      expect(NanoId.isNanoId(id)).toBe(true);
-      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);
-    });
-
-    it("Ids.Test with fixed time yields deterministic time-based prefixes", async () => {
-      const runFixed = <A, E>(effect: Effect.Effect<A, E, Ids>) =>
-        effect.pipe(Effect.provide(Ids.Test({})), Random.withSeed(0), Effect.runPromise);
-
-      const [ulid1, ulid2, ksuid1, ksuid2] = await runFixed(
-        Effect.all([Ids.ulid, Ids.ulid, Ids.ksuid, Ids.ksuid], { concurrency: "unbounded" }),
-      );
-      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/Ids.ts

@@ -1,128 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Layer from "effect/Layer";
-import * as ServiceMap from "effect/ServiceMap";
-import type { Cuid } from "./Cuid.js";
-import { cuid, CuidState } from "./Cuid.js";
-import { DateTimes } from "./DateTimes.js";
-import type { Ksuid } from "./Ksuid.js";
-import { ksuid } from "./Ksuid.js";
-import type { NanoId } from "./NanoId.js";
-import { nanoId } from "./NanoId.js";
-import { RandomValues } from "./RandomValues.js";
-import type { Ulid } from "./Ulid.js";
-import { ulid } from "./Ulid.js";
-import type { Uuid4 } from "./Uuid4.js";
-import { uuid4 } from "./Uuid4.js";
-import { type Uuid5, uuid5, Uuid5Namespace } from "./Uuid5.js";
-import type { Uuid7 } from "./Uuid7.js";
-import { uuid7, Uuid7State } from "./Uuid7.js";
-import { TestClock } from "effect/testing";
-
-export class Ids extends ServiceMap.Service<Ids>()("@typed/id/Ids", {
-  make: Effect.gen(function* () {
-    const services = yield* Effect.services<DateTimes | RandomValues | CuidState | Uuid7State>();
-
-    const uuid5_: {
-      (namespace: Uuid5Namespace): (name: string) => Effect.Effect<Uuid5>;
-      (name: string, namespace: Uuid5Namespace): Effect.Effect<Uuid5>;
-      readonly dns: (name: string) => Effect.Effect<Uuid5>;
-      readonly url: (name: string) => Effect.Effect<Uuid5>;
-      readonly oid: (name: string) => Effect.Effect<Uuid5>;
-      readonly x500: (name: string) => Effect.Effect<Uuid5>;
-    } = Object.assign(
-      dual(2, (name: string, namespace: Uuid5Namespace) =>
-        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.provide(cuid, services),
-      ksuid: Effect.provide(ksuid, services),
-      nanoId: Effect.provide(nanoId, services),
-      ulid: Effect.provide(ulid, services),
-      uuid4: Effect.provide(uuid4, services),
-      uuid5: uuid5_,
-      uuid7: Effect.provide(uuid7, services),
-    };
-  }),
-}) {
-  static readonly cuid: Effect.Effect<Cuid, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ cuid }) => cuid,
-  );
-
-  static readonly ksuid: Effect.Effect<Ksuid, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ ksuid }) => ksuid,
-  );
-
-  static readonly nanoId: Effect.Effect<NanoId, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ nanoId }) => nanoId,
-  );
-
-  static readonly ulid: Effect.Effect<Ulid, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ ulid }) => ulid,
-  );
-
-  static readonly uuid4: Effect.Effect<Uuid4, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ uuid4 }) => uuid4,
-  );
-
-  static readonly uuid5: {
-    (namespace: Uuid5Namespace): (name: string) => Effect.Effect<Uuid5, never, Ids>;
-    (name: string, namespace: Uuid5Namespace): Effect.Effect<Uuid5, never, Ids>;
-    readonly dns: (name: string) => Effect.Effect<Uuid5, never, Ids>;
-    readonly url: (name: string) => Effect.Effect<Uuid5, never, Ids>;
-    readonly oid: (name: string) => Effect.Effect<Uuid5, never, Ids>;
-    readonly x500: (name: string) => Effect.Effect<Uuid5, never, Ids>;
-  } = Object.assign(
-    dual(2, (name: string, namespace: Uuid5Namespace) =>
-      Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5(name, namespace)),
-    ),
-    {
-      dns: (name: string) => Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5.dns(name)),
-      url: (name: string) => Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5.url(name)),
-      oid: (name: string) => Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5.oid(name)),
-      x500: (name: string) => Effect.flatMap(Ids.asEffect(), ({ uuid5 }) => uuid5.x500(name)),
-    },
-  );
-  static readonly uuid7: Effect.Effect<Uuid7, never, Ids> = Effect.flatMap(
-    Ids.asEffect(),
-    ({ uuid7 }) => uuid7,
-  );
-
-  static readonly Default: Layer.Layer<Ids | DateTimes | RandomValues, never, never> = Layer.effect(
-    Ids,
-    Ids.make,
-  ).pipe(
-    Layer.provide([CuidState.Default, Uuid7State.Default]),
-    Layer.provideMerge([DateTimes.Default, RandomValues.Default]),
-  );
-
-  static readonly Test = (
-    options?: TestOptions,
-  ): Layer.Layer<Ids | DateTimes | RandomValues | TestClock.TestClock> =>
-    Layer.effect(Ids, Ids.make).pipe(
-      Layer.provide([
-        Layer.effect(CuidState, CuidState.make(options?.envData ?? "node")),
-        Uuid7State.Default,
-      ]),
-      Layer.provideMerge([DateTimes.Fixed(options?.currentTime ?? 0), RandomValues.Random]),
-      Layer.provideMerge(TestClock.layer({})),
-    );
-}
-
-export type TestOptions = {
-  readonly currentTime?: number | string | Date;
-  readonly envData?: string;
-};