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

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 Context from "effect/Context";
-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 Context.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.make(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 Context from "effect/Context";
-
-export class DateTimes extends Context.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 Context from "effect/Context";
-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 Context.Service<Ids>()("@typed/id/Ids", {
-  make: Effect.gen(function* () {
-    const services = yield* Effect.context<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;
-};

package/src/Ksuid.ts

@@ -1,74 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { DateTimes } from "./DateTimes.js";
-import { RandomValues } from "./RandomValues.js";
-
-// Constants
-const EPOCH = 14e11; // 2014-03-01T00:00:00Z
-const TIMESTAMP_BYTES = 4;
-const PAYLOAD_BYTES = 16;
-const TOTAL_BYTES = TIMESTAMP_BYTES + PAYLOAD_BYTES;
-const STRING_LENGTH = 27;
-
-// Schema
-export const Ksuid = Schema.String.pipe(
-  Schema.check(Schema.isPattern(/^[0-9A-Za-z]{27}$/)),
-  Schema.brand("@typed/id/KSUID"),
-);
-export type Ksuid = typeof Ksuid.Type;
-
-export const isKsuid: (value: string) => value is Ksuid = Schema.is(Ksuid);
-
-// Types
-type KsuidSeed = Uint8Array & { length: 16 };
-
-// Public API
-export const ksuid: Effect.Effect<Ksuid, never, DateTimes | RandomValues> = Effect.zipWith(
-  DateTimes.now,
-  RandomValues.call<KsuidSeed>(PAYLOAD_BYTES),
-  (timestamp, payload) => {
-    // Create the combined bytes
-    const bytes = new Uint8Array(TOTAL_BYTES);
-
-    // Support for timestamps before the epoch, usually for testing
-    if (timestamp < EPOCH) {
-      timestamp += EPOCH;
-    }
-
-    // Write timestamp (4 bytes, big-endian)
-    const seconds = Math.floor((timestamp - EPOCH) / 1000);
-    bytes[0] = (seconds >>> 24) & 0xff;
-    bytes[1] = (seconds >>> 16) & 0xff;
-    bytes[2] = (seconds >>> 8) & 0xff;
-    bytes[3] = seconds & 0xff;
-
-    // Copy payload
-    bytes.set(payload, TIMESTAMP_BYTES);
-
-    // Encode as base62
-    return Ksuid.make(base62Encode(bytes));
-  },
-);
-
-// Utilities
-const base62Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-const base = BigInt(base62Chars.length);
-
-function base62Encode(bytes: Uint8Array): string {
-  let number = 0n;
-  for (const byte of bytes) {
-    number = (number << 8n) + BigInt(byte);
-  }
-
-  const chars: Array<string> = Array(STRING_LENGTH);
-  let i = chars.length;
-
-  while (i > 0) {
-    i--;
-    const remainder = Number(number % base);
-    chars[i] = base62Chars[remainder];
-    number = number / base;
-  }
-
-  return chars.join("");
-}

package/src/NanoId.ts

@@ -1,33 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import { RandomValues } from "./RandomValues.js";
-
-export const NanoId = Schema.String.pipe(
-  Schema.check(Schema.isPattern(/^[0-9a-zA-Z_-]+$/)),
-  Schema.brand("@typed/id/NanoId"),
-);
-export type NanoId = typeof NanoId.Type;
-
-export const isNanoId: (value: string) => value is NanoId = Schema.is(NanoId);
-
-type NanoIdSeed = Uint8Array & { length: 21 };
-
-export const nanoId: Effect.Effect<NanoId, never, RandomValues> = Effect.map(
-  RandomValues.call<NanoIdSeed>(21),
-  (seed: NanoIdSeed): NanoId => NanoId.make(Array.from(seed, numToCharacter).join("")),
-);
-
-function numToCharacter(byte: number): string {
-  byte &= 63;
-  if (byte < 36) {
-    // `0-9a-z`
-    return byte.toString(36);
-  } else if (byte < 62) {
-    // `A-Z`
-    return (byte - 26).toString(36).toUpperCase();
-  } else if (byte > 62) {
-    return "-";
-  } else {
-    return "_";
-  }
-}

package/src/RandomValues.ts

@@ -1,33 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Random from "effect/Random";
-import * as Context from "effect/Context";
-
-export class RandomValues extends Context.Service<RandomValues>()("@typed/id/RandomValues", {
-  make: Effect.succeed(
-    <A extends Uint8Array>(length: A["length"]): Effect.Effect<A> =>
-      Effect.sync(() => crypto.getRandomValues(new Uint8Array(length)) as A),
-  ),
-}) {
-  static override readonly call = <A extends Uint8Array>(
-    length: A["length"],
-  ): Effect.Effect<A, never, RandomValues> =>
-    RandomValues.asEffect().pipe(Effect.flatMap((randomValues) => randomValues(length)));
-
-  static readonly Default = Layer.effect(RandomValues, RandomValues.make);
-
-  static readonly Random = Layer.effect(
-    RandomValues,
-    Effect.gen(function* () {
-      const random = yield* Random.Random;
-      return RandomValues.of(
-        <A extends Uint8Array>(length: A["length"]): Effect.Effect<A> =>
-          Effect.sync(() => {
-            const view = new Uint8Array(length);
-            for (let i = 0; i < length; ++i) view[i] = random.nextIntUnsafe();
-            return view as A;
-          }),
-      );
-    }),
-  );
-}