uniku 0.0.12 → 0.0.13

package/src/ulid/ulid.ts

@@ -0,0 +1,184 @@
+import { incrementBytesInPlace, writeTimestamp48 } from '../common/bytes'
+import { rng } from '../common/random'
+import { BufferError, InvalidInputError } from '../errors'
+import { bytesToUlid, decodeToBytes, decodeUlidTime, encodeRandom, encodeTime } from './crockford'
+
+export type UlidOptions = {
+  /**
+   * 16 bytes of random data to use for ULID generation.
+   * Only the first 10 bytes are used.
+   */
+  random?: Uint8Array
+  /**
+   * Timestamp in milliseconds since Unix epoch.
+   * Defaults to Date.now().
+   */
+  msecs?: number
+}
+
+export type Ulid = {
+  (): string
+  <TBuf extends Uint8Array = Uint8Array>(options: UlidOptions | undefined, buf: TBuf, offset?: number): TBuf
+  (options?: UlidOptions, buf?: undefined, offset?: number): string
+  toBytes(id: string): Uint8Array
+  fromBytes(bytes: Uint8Array): string
+  timestamp(id: string): number
+  isValid(id: unknown): id is string
+  /** The nil ULID (all zeros) */
+  NIL: string
+  /** The max ULID (maximum valid value) */
+  MAX: string
+}
+
+// Validation regex: first char [0-7] to prevent overflow, rest from Crockford alphabet
+const ULID_REGEX = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i
+
+type UlidState = {
+  msecs: number
+  lastRandom: Uint8Array
+}
+
+/**
+ * Module-level state for maintaining monotonic ordering within the same millisecond.
+ *
+ * IMPORTANT: This state persists across all ulid() calls in the module's lifetime.
+ * - In serverless/edge functions with warm starts, state persists between invocations.
+ * - For isolated state, pass explicit `msecs` and `random` via options.
+ * - Tests should mock Date.now() or provide explicit options for deterministic behavior.
+ */
+const state: UlidState = {
+  msecs: -Infinity,
+  lastRandom: new Uint8Array(10),
+}
+
+function ulidBytes(time: number, random: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {
+  if (!buf) {
+    buf = new Uint8Array(16)
+    offset = 0
+  } else if (offset < 0 || offset + 16 > buf.length) {
+    throw new BufferError(
+      'ULID_BUFFER_OUT_OF_BOUNDS',
+      `ULID byte range ${offset}:${offset + 15} is out of buffer bounds`,
+    )
+  }
+
+  // Timestamp (48-bit big-endian milliseconds since Unix epoch) -> bytes 0-5
+  writeTimestamp48(buf, offset, time)
+
+  // Random (80 bits) -> bytes 6-15
+  for (let i = 0; i < 10; i += 1) {
+    buf[offset + 6 + i] = random[i]
+  }
+
+  return buf
+}
+
+/*
+ * Overload: no buffer => return a ULID string.
+ */
+function ulidFn(options?: UlidOptions, buf?: undefined, offset?: number): string
+/*
+ * Overload: caller provides a buffer slice to fill with ULID bytes.
+ */
+function ulidFn<TBuf extends Uint8Array = Uint8Array>(
+  options: UlidOptions | undefined,
+  buf: TBuf,
+  offset?: number,
+): TBuf
+function ulidFn<TBuf extends Uint8Array = Uint8Array>(options?: UlidOptions, buf?: TBuf, offset = 0): string | TBuf {
+  let time: number
+  let random: Uint8Array
+
+  /**
+   * Note: by default, Cloudflare Workers "freezes" time during request handling to prevent
+   * side-channel attacks. This means that Date.now() will return the same value for the entire
+   * duration of a request.
+   * Implications:
+   * - all ULIDs generated within a single request will have the same timestamp.
+   * - the monotonic ordering will rely entirely on incrementing the random portion.
+   */
+  const defaultTime = Date.now()
+
+  if (options) {
+    // Explicit options provided - use them directly without monotonic state
+    time = options.msecs ?? defaultTime
+    if (options.random) {
+      if (options.random.length < 10) {
+        throw new InvalidInputError('ULID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 10 for ULID')
+      }
+      random = options.random
+    } else {
+      random = rng()
+    }
+  } else {
+    time = defaultTime
+
+    if (time > state.msecs) {
+      // New millisecond: generate fresh random
+      random = rng()
+      state.msecs = time
+      state.lastRandom.set(random.subarray(0, 10))
+    } else {
+      // Same millisecond or clock rollback: preserve last timestamp and increment random portion.
+      time = state.msecs
+      if (!incrementBytesInPlace(state.lastRandom)) {
+        state.lastRandom.fill(0xff)
+        throw new InvalidInputError(
+          'ULID_RANDOM_OVERFLOW',
+          'ULID random component overflowed while preserving monotonic order',
+        )
+      }
+      random = state.lastRandom
+    }
+  }
+
+  if (buf) {
+    ulidBytes(time, random, buf, offset)
+    return buf
+  }
+
+  // String mode: encode directly without buffer allocation
+  return encodeTime(time) + encodeRandom(random)
+}
+
+/**
+ * Generate a ULID string or write the bytes into a buffer.
+ *
+ * ULID (Universally Unique Lexicographically Sortable Identifier) is a 128-bit
+ * identifier with millisecond timestamp precision and 80 bits of randomness.
+ * ULIDs are URL-safe, use Crockford's Base32 encoding, and sort lexicographically
+ * by creation time.
+ *
+ * @example
+ * ```ts
+ * import { ulid } from 'uniku/ulid'
+ *
+ * const id = ulid()
+ * // => "01HW9T2W9W9YJ3JZ1H4P4M2T8Q"
+ *
+ * // Extract timestamp
+ * const ts = ulid.timestamp(id)
+ * console.log(new Date(ts))
+ *
+ * // Validate
+ * ulid.isValid(id) // true
+ *
+ * // Convert to/from bytes (16 bytes)
+ * const bytes = ulid.toBytes(id)
+ * const restored = ulid.fromBytes(bytes)
+ * ```
+ */
+function isValid(id: unknown): id is string {
+  return typeof id === 'string' && ULID_REGEX.test(id)
+}
+
+export const ulid: Ulid = Object.assign(ulidFn, {
+  toBytes: (id: string) => decodeToBytes(id),
+  fromBytes: (bytes: Uint8Array) => bytesToUlid(bytes),
+  timestamp: (id: string) => decodeUlidTime(id),
+  isValid,
+  NIL: '00000000000000000000000000',
+  MAX: '7ZZZZZZZZZZZZZZZZZZZZZZZZZ',
+})
+
+export { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'

package/src/uuid/common/hex.ts

@@ -0,0 +1,24 @@
+// ASCII code ranges for hex character validation
+const ASCII_0 = 48 // '0'
+const ASCII_9 = 57 // '9'
+const ASCII_A = 65 // 'A'
+const ASCII_F = 70 // 'F'
+const ASCII_a = 97 // 'a'
+const ASCII_f = 102 // 'f'
+
+/**
+ * Convert a hex character ASCII code to its numeric value (0-15).
+ * Returns -1 for invalid hex characters.
+ */
+export function hexValue(code: number): number {
+  if (code >= ASCII_0 && code <= ASCII_9) {
+    return code - ASCII_0
+  }
+  if (code >= ASCII_A && code <= ASCII_F) {
+    return code - ASCII_A + 10
+  }
+  if (code >= ASCII_a && code <= ASCII_f) {
+    return code - ASCII_a + 10
+  }
+  return -1 // Invalid hex character
+}

package/src/uuid/common/uuid.ts

@@ -0,0 +1,157 @@
+import { ParseError } from '../../errors'
+import { hexValue } from './hex'
+
+const UUID_BYTE_LENGTH = 16
+const UUID_STRING_LENGTH = 36
+
+// Mapping from UUID string position to byte index.
+// -1 indicates a dash position that should be skipped.
+// This avoids intermediate string allocations during parsing.
+const UUID_CHAR_TO_BYTE: number[] = [
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3, // chars 0-7 → bytes 0-3
+  -1, // char 8 is '-'
+  4,
+  4,
+  5,
+  5, // chars 9-12 → bytes 4-5
+  -1, // char 13 is '-'
+  6,
+  6,
+  7,
+  7, // chars 14-17 → bytes 6-7
+  -1, // char 18 is '-'
+  8,
+  8,
+  9,
+  9, // chars 19-22 → bytes 8-9
+  -1, // char 23 is '-'
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  14,
+  14,
+  15,
+  15, // chars 24-35 → bytes 10-15
+]
+
+// Whether each position is the high nibble (true) or low nibble (false)
+const UUID_CHAR_IS_HIGH: boolean[] = [
+  true,
+  false,
+  true,
+  false,
+  true,
+  false,
+  true,
+  false, // chars 0-7
+  false, // dash (ignored)
+  true,
+  false,
+  true,
+  false, // chars 9-12
+  false, // dash
+  true,
+  false,
+  true,
+  false, // chars 14-17
+  false, // dash
+  true,
+  false,
+  true,
+  false, // chars 19-22
+  false, // dash
+  true,
+  false,
+  true,
+  false,
+  true,
+  false,
+  true,
+  false,
+  true,
+  false,
+  true,
+  false, // chars 24-35
+]
+
+// Pre-computed lookup table for byte-to-hex conversion (0x00 -> "00", 0xff -> "ff")
+//
+// Note: this table must remain defined in the same module as `formatUuid`, otherwise the v8 optimizer
+// will cause a performance drop of ~36%.
+const HEX_TABLE: string[] = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))
+
+export function formatUuid(bytes: Uint8Array): string {
+  // Direct string concatenation - optimized for V8's string builder.
+  // This approach avoids loop overhead and intermediate allocations.
+  // See: https://github.com/uuidjs/uuid/pull/434
+  return (
+    HEX_TABLE[bytes[0]] +
+    HEX_TABLE[bytes[1]] +
+    HEX_TABLE[bytes[2]] +
+    HEX_TABLE[bytes[3]] +
+    '-' +
+    HEX_TABLE[bytes[4]] +
+    HEX_TABLE[bytes[5]] +
+    '-' +
+    HEX_TABLE[bytes[6]] +
+    HEX_TABLE[bytes[7]] +
+    '-' +
+    HEX_TABLE[bytes[8]] +
+    HEX_TABLE[bytes[9]] +
+    '-' +
+    HEX_TABLE[bytes[10]] +
+    HEX_TABLE[bytes[11]] +
+    HEX_TABLE[bytes[12]] +
+    HEX_TABLE[bytes[13]] +
+    HEX_TABLE[bytes[14]] +
+    HEX_TABLE[bytes[15]]
+  )
+}
+
+export function parseUuid(value: string): Uint8Array {
+  if (value.length !== UUID_STRING_LENGTH) {
+    throw new ParseError('UUID_INVALID_LENGTH', `UUID string must be 36 characters, got ${value.length}`)
+  }
+
+  // Validate separator positions directly (more efficient than full loop)
+  if (value[8] !== '-' || value[13] !== '-' || value[18] !== '-' || value[23] !== '-') {
+    throw new ParseError(
+      'UUID_INVALID_SEPARATORS',
+      `UUID string has invalid separators at positions 8, 13, 18, 23. Received: "${value}"`,
+    )
+  }
+
+  // Parse bytes directly from UUID string without intermediate string allocations.
+  // This avoids the 9 allocations (5 slices + 4 concatenations) of the naive approach.
+  const bytes = new Uint8Array(UUID_BYTE_LENGTH)
+
+  for (let i = 0; i < UUID_STRING_LENGTH; i += 1) {
+    const byteIdx = UUID_CHAR_TO_BYTE[i]
+    if (byteIdx === -1) continue // Skip dash positions
+
+    const nibble = hexValue(value.charCodeAt(i))
+    if (nibble === -1) {
+      throw new ParseError('UUID_INVALID_HEX_CHAR', `UUID string contains invalid hex character at position ${i}`)
+    }
+
+    if (UUID_CHAR_IS_HIGH[i]) {
+      bytes[byteIdx] = nibble << 4
+    } else {
+      bytes[byteIdx] |= nibble
+    }
+  }
+
+  return bytes
+}

package/src/uuid/v4.ts

@@ -0,0 +1,119 @@
+import { rng } from '../common/random'
+import { BufferError, InvalidInputError } from '../errors'
+import { formatUuid, parseUuid } from './common/uuid'
+
+const randomUUID = /*@__PURE__*/ globalThis.crypto.randomUUID.bind(globalThis.crypto)
+
+export type UuidV4Options = {
+  /**
+   * 16 bytes of random data to use for UUID generation.
+   * Note: Bytes at index 6 and 8 will be modified in-place to set version/variant bits.
+   */
+  random?: Uint8Array
+}
+
+export type UuidV4 = {
+  (): string
+  <TBuf extends Uint8Array = Uint8Array>(options: UuidV4Options | undefined, buf: TBuf, offset?: number): TBuf
+  (options?: UuidV4Options, buf?: undefined, offset?: number): string
+  toBytes(id: string): Uint8Array
+  fromBytes(bytes: Uint8Array): string
+  isValid(id: unknown): id is string
+  /** The nil UUID (all zeros) */
+  NIL: string
+  /** The max UUID (all ones) */
+  MAX: string
+}
+
+const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+
+function v4Bytes(rnds: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {
+  if (rnds.length < 16) {
+    throw new InvalidInputError('UUID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 16')
+  }
+
+  // Set RFC 4122 version (4) and variant (10xx) bits.
+  // Note: This modifies the input array in-place.
+  rnds[6] = (rnds[6] & 0x0f) | 0x40
+  rnds[8] = (rnds[8] & 0x3f) | 0x80
+
+  if (!buf) {
+    // No output buffer provided - return the modified random bytes directly
+    return rnds
+  }
+
+  if (offset < 0 || offset + 16 > buf.length) {
+    throw new BufferError(
+      'UUID_BUFFER_OUT_OF_BOUNDS',
+      `UUID byte range ${offset}:${offset + 15} is out of buffer bounds`,
+    )
+  }
+
+  // Copy 16 UUID bytes into the provided buffer slice.
+  for (let i = 0; i < 16; i += 1) {
+    buf[offset + i] = rnds[i]
+  }
+
+  return buf
+}
+
+/*
+ * Overload: no buffer => return a UUID string.
+ */
+function v4(options?: UuidV4Options, buf?: undefined, offset?: number): string
+/*
+ * Overload: caller provides a buffer slice to fill with UUID bytes.
+ */
+function v4<TBuf extends Uint8Array = Uint8Array>(options: UuidV4Options | undefined, buf: TBuf, offset?: number): TBuf
+function v4<TBuf extends Uint8Array = Uint8Array>(options?: UuidV4Options, buf?: TBuf, offset?: number): string | TBuf {
+  if (!buf && !options) {
+    return randomUUID()
+  }
+
+  return _v4(options, buf, offset)
+}
+
+function _v4<TBuf extends Uint8Array = Uint8Array>(
+  options?: UuidV4Options,
+  buf?: TBuf,
+  offset?: number,
+): string | TBuf {
+  const bytes = v4Bytes(options?.random ?? rng(), buf, offset)
+  return buf ?? formatUuid(bytes)
+}
+
+function isValid(id: unknown): id is string {
+  return typeof id === 'string' && UUID_V4_REGEX.test(id)
+}
+
+/**
+ * Generate a UUID v4 string or write the bytes into a buffer.
+ *
+ * UUID v4 is a purely random UUID with 122 bits of entropy. It's the most
+ * widely compatible UUID format, supported by virtually all databases and systems.
+ * Use when you need maximum compatibility and don't require time-ordering.
+ *
+ * @example
+ * ```ts
+ * import { uuidv4 } from 'uniku/uuid/v4'
+ *
+ * const id = uuidv4()
+ * // => "550e8400-e29b-41d4-a716-446655440000"
+ *
+ * // Validate
+ * uuidv4.isValid(id) // true
+ *
+ * // Convert to/from bytes (16 bytes)
+ * const bytes = uuidv4.toBytes(id)
+ * const restored = uuidv4.fromBytes(bytes)
+ * ```
+ */
+export const uuidv4: UuidV4 = Object.assign(v4, {
+  toBytes: parseUuid,
+  fromBytes: formatUuid,
+  isValid,
+  NIL: '00000000-0000-0000-0000-000000000000',
+  MAX: 'ffffffff-ffff-ffff-ffff-ffffffffffff',
+})
+
+export { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'

package/src/uuid/v7.ts

@@ -0,0 +1,182 @@
+import { rng } from '../common/random'
+import { BufferError, InvalidInputError } from '../errors'
+import { formatUuid, parseUuid } from './common/uuid'
+
+export type UuidV7Options = {
+  /**
+   * 16 bytes of random data to use for UUID generation.
+   * Note: Several bytes will be overwritten with timestamp, version, and variant data.
+   */
+  random?: Uint8Array
+  msecs?: number
+  seq?: number
+}
+
+export type UuidV7 = {
+  (): string
+  <TBuf extends Uint8Array = Uint8Array>(options: UuidV7Options | undefined, buf: TBuf, offset?: number): TBuf
+  (options?: UuidV7Options, buf?: undefined, offset?: number): string
+  toBytes(id: string): Uint8Array
+  fromBytes(bytes: Uint8Array): string
+  timestamp(id: string): number
+  isValid(id: unknown): id is string
+  /** The nil UUID (all zeros) */
+  NIL: string
+  /** The max UUID (all ones) */
+  MAX: string
+}
+
+const UUID_V7_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+
+// Reusable buffer for string output path - avoids allocation per call.
+// Safe because bytes are consumed synchronously by formatUuid().
+const reusableBuf = new Uint8Array(16)
+
+type V7State = {
+  msecs: number
+  seq: number
+}
+
+/**
+ * Module-level state for maintaining monotonic ordering within the same millisecond.
+ *
+ * IMPORTANT: This state persists across all uuidv7() calls in the module's lifetime.
+ * - In serverless/edge functions with warm starts, state persists between invocations.
+ * - For isolated state, pass explicit `msecs` and `seq` via options.
+ * - Tests should mock Date.now() or provide explicit options for deterministic behavior.
+ */
+const state: V7State = { msecs: -Infinity, seq: 0 }
+
+function v7Bytes(
+  rnds: Uint8Array,
+  msecs: number | undefined,
+  seq: number | undefined,
+  buf: Uint8Array,
+  offset = 0,
+): Uint8Array {
+  if (rnds.length < 16) {
+    throw new InvalidInputError('UUID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 16')
+  }
+
+  if (offset < 0 || offset + 16 > buf.length) {
+    throw new BufferError(
+      'UUID_BUFFER_OUT_OF_BOUNDS',
+      `UUID byte range ${offset}:${offset + 15} is out of buffer bounds`,
+    )
+  }
+
+  msecs ??= Date.now()
+  // Derive a 31-bit sequence if not provided by the caller.
+  // Uses the same formula as the hot path for consistency.
+  seq ??= (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]
+
+  // Keep this inline on the UUID v7 hot path. Using writeTimestamp48() here
+  // benchmarked slower than the direct byte writes.
+  buf[offset++] = (msecs / 0x10000000000) & 0xff
+  buf[offset++] = (msecs / 0x100000000) & 0xff
+  buf[offset++] = (msecs / 0x1000000) & 0xff
+  buf[offset++] = (msecs / 0x10000) & 0xff
+  buf[offset++] = (msecs / 0x100) & 0xff
+  buf[offset++] = msecs & 0xff
+
+  // Set version (7) and variant (10xx), then pack sequence and random tail bytes.
+  buf[offset++] = 0x70 | ((seq >>> 28) & 0x0f)
+  buf[offset++] = (seq >>> 20) & 0xff
+  buf[offset++] = 0x80 | ((seq >>> 14) & 0x3f)
+  buf[offset++] = (seq >>> 6) & 0xff
+  // Lower seq bits plus 2 random bits to complete the 128-bit payload.
+  buf[offset++] = ((seq << 2) & 0xff) | (rnds[10] & 0x03)
+  buf[offset++] = rnds[11]
+  buf[offset++] = rnds[12]
+  buf[offset++] = rnds[13]
+  buf[offset++] = rnds[14]
+  buf[offset++] = rnds[15]
+
+  return buf
+}
+
+/*
+ * Overload: no buffer => return a UUID string.
+ */
+function v7(options?: UuidV7Options, buf?: undefined, offset?: number): string
+/*
+ * Overload: caller provides a buffer slice to fill with UUID bytes.
+ */
+function v7<TBuf extends Uint8Array = Uint8Array>(options: UuidV7Options | undefined, buf: TBuf, offset?: number): TBuf
+function v7<TBuf extends Uint8Array = Uint8Array>(options?: UuidV7Options, buf?: TBuf, offset?: number): string | TBuf {
+  let bytes: Uint8Array
+
+  if (options) {
+    bytes = v7Bytes(options.random ?? rng(), options.msecs, options.seq, buf ?? reusableBuf, buf ? offset : 0)
+  } else {
+    // HOT PATH: Inline state management and byte generation for best performance
+    const now = Date.now()
+    const rnds = rng()
+
+    // Update state (inlined for performance)
+    if (now > state.msecs) {
+      state.seq = (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]
+      state.msecs = now
+    } else {
+      state.seq = (state.seq + 1) | 0
+      if (state.seq < 0) {
+        state.seq = 0
+        state.msecs++
+      }
+    }
+
+    bytes = v7Bytes(rnds, state.msecs, state.seq, buf ?? reusableBuf, buf ? offset : 0)
+  }
+
+  return buf ? (bytes as TBuf) : formatUuid(bytes)
+}
+
+function timestamp(id: string): number {
+  const bytes = parseUuid(id)
+  let msecs = 0
+  for (let i = 0; i < 6; i += 1) {
+    msecs = msecs * 256 + bytes[i]
+  }
+  return msecs
+}
+
+function isValid(id: unknown): id is string {
+  return typeof id === 'string' && UUID_V7_REGEX.test(id)
+}
+
+/**
+ * Generate a UUID v7 string or write the bytes into a buffer.
+ *
+ * UUID v7 is a time-ordered UUID that embeds a Unix timestamp in milliseconds,
+ * making IDs naturally sortable by creation time. Ideal for database primary keys
+ * where chronological ordering improves index performance.
+ *
+ * @example
+ * ```ts
+ * import { uuidv7 } from 'uniku/uuid/v7'
+ *
+ * const id = uuidv7()
+ * // => "018e5e5c-7c8a-7000-8000-000000000000"
+ *
+ * // Extract timestamp
+ * const ts = uuidv7.timestamp(id)
+ * console.log(new Date(ts))
+ *
+ * // Validate
+ * uuidv7.isValid(id) // true
+ *
+ * // Convert to/from bytes
+ * const bytes = uuidv7.toBytes(id)
+ * const restored = uuidv7.fromBytes(bytes)
+ * ```
+ */
+export const uuidv7: UuidV7 = Object.assign(v7, {
+  toBytes: parseUuid,
+  fromBytes: formatUuid,
+  timestamp,
+  isValid,
+  NIL: '00000000-0000-0000-0000-000000000000',
+  MAX: 'ffffffff-ffff-ffff-ffff-ffffffffffff',
+})
+
+export { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'

package/build/random-DcKA4vF7.mjs

@@ -1,2 +0,0 @@
-const e=globalThis.crypto.getRandomValues.bind(globalThis.crypto),t=new Uint8Array(256);let n=256;function r(){n>240&&(e(t),n=0);let r=n;return n+=16,t.subarray(r,n)}export{r as t};
-//# sourceMappingURL=random-DcKA4vF7.mjs.map

package/build/random-DcKA4vF7.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"random-DcKA4vF7.mjs","names":[],"sources":["../src/common/random.ts"],"sourcesContent":["const randomFill = /*@__PURE__*/ globalThis.crypto.getRandomValues.bind(globalThis.crypto)\n\n/**\n * Simple, fast random byte pool for ID generation.\n * Uses plain JavaScript for maximum performance - no Atomics overhead.\n * Thread safety is not needed for typical ID generation use cases.\n */\n\nconst POOL_SIZE = 256\nconst rnds8Pool = new Uint8Array(POOL_SIZE)\nlet poolPtr = POOL_SIZE // Start exhausted to trigger first fill\n\n/**\n * Generate 16 bytes of cryptographically strong random data.\n * Uses a pre-filled pool to minimize crypto API calls.\n */\nexport function rng(): Uint8Array {\n  if (poolPtr > POOL_SIZE - 16) {\n    randomFill(rnds8Pool)\n    poolPtr = 0\n  }\n  // Return a view - consumed synchronously within the same call\n  const start = poolPtr\n  poolPtr += 16\n  return rnds8Pool.subarray(start, poolPtr)\n}\n"],"mappings":"AAAA,MAAM,EAA2B,WAAW,OAAO,gBAAgB,KAAK,WAAW,OAAO,CASpF,EAAY,IAAI,WAAW,IAAU,CAC3C,IAAI,EAAU,IAMd,SAAgB,GAAkB,CAC5B,EAAU,MACZ,EAAW,EAAU,CACrB,EAAU,GAGZ,IAAM,EAAQ,EAEd,MADA,IAAW,GACJ,EAAU,SAAS,EAAO,EAAQ"}