@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/config/index.js

@@ -1,3 +1,4 @@
+import { E, I, a } from "../../chunks/Environment-BLuXHzzF.js";
 function createField(typeName, parse, options) {
   const hasDefault = options !== void 0 && "default" in options;
   return {
@@ -24,15 +25,15 @@ function num(options) {
     options
   );
 }
-const TRUE_TOKENS = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
-const FALSE_TOKENS = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
+const TrueTokens = /* @__PURE__ */ new Set(["true", "1", "yes", "on"]);
+const FalseTokens = /* @__PURE__ */ new Set(["false", "0", "no", "off"]);
 function bool(options) {
   return createField(
     "boolean",
     (raw) => {
       const token = raw.trim().toLowerCase();
-      if (TRUE_TOKENS.has(token)) return true;
-      if (FALSE_TOKENS.has(token)) return false;
+      if (TrueTokens.has(token)) return true;
+      if (FalseTokens.has(token)) return false;
       throw `expected a boolean (true/false/1/0/yes/no/on/off), got "${raw}"`;
     },
     options
@@ -94,7 +95,7 @@ function list(options) {
     options
   );
 }
-const DEFAULT_RUNTIME_CONFIG_KEY = "__APP_CONFIG__";
+const DefaultRuntimeConfigKey = "__APP_CONFIG__";
 function importMetaEnvSource() {
   try {
     const meta = import.meta;
@@ -103,7 +104,7 @@ function importMetaEnvSource() {
     return {};
   }
 }
-function windowConfigSource(globalKey = DEFAULT_RUNTIME_CONFIG_KEY) {
+function windowConfigSource(globalKey = DefaultRuntimeConfigKey) {
   if (typeof window === "undefined") return {};
   const raw = window[globalKey];
   return raw !== null && typeof raw === "object" ? raw : {};
@@ -167,7 +168,10 @@ function defineConfig(schema, options) {
 }
 export {
   ConfigError,
-  DEFAULT_RUNTIME_CONFIG_KEY,
+  DefaultRuntimeConfigKey,
+  E as Environment,
+  I as IsDevelopment,
+  a as IsProduction,
   bool,
   defaultSources,
   defineConfig,

package/dist/foundation/config/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/config/ConfigField.ts","../../../src/foundation/config/ConfigSource.ts","../../../src/foundation/config/DefineConfig.ts"],"sourcesContent":["// Typed-env field specs. A `ConfigField<T>` describes how one configuration key is parsed from its raw\n// string form, whether it is required, and its fallback — the atoms `defineConfig` reads a source through.\n// Each builder (`str`, `num`, `bool`, `oneOf`, `url`, `port`, `json`, `list`) returns a field whose `parse`\n// handles only a *present* raw string and throws a human-readable message on an invalid value; the engine\n// owns the missing / default / required decision centrally, so a field never re-implements that policy.\n\n/** Tunes one field's presence policy and fallback. A `default` (or `required: false`) makes the field optional. */\nexport interface ConfigFieldOptions<T> {\n  /** Marks the field required. Defaults to `true` unless a `default` is supplied. */\n  readonly required?: boolean;\n\n  /** The value used when the key is absent or empty. Supplying it makes the field optional. */\n  readonly default?: T;\n\n  /** Redacts the raw value from `ConfigError` messages — set for tokens, keys, and passwords. */\n  readonly secret?: boolean;\n}\n\n/**\n * Describes a single configuration key: its scalar type, presence policy, and how to parse a present raw\n * string into `T`. `Optional` is a phantom flag the schema inference reads to widen the output to `T | undefined`\n * for a field that is `required: false` with no `default`.\n */\nexport interface ConfigField<T, Optional extends boolean = false> {\n  /** The human-facing type name used in error messages (`string`, `number`, `one of [...]`, …). */\n  readonly typeName: string;\n\n  /** Whether a missing key is an error. `false` when a `default` is present or `required: false`. */\n  readonly required: boolean;\n\n  /** Whether an explicit `default` was supplied. */\n  readonly hasDefault: boolean;\n\n  /** The configured fallback, meaningful only when `hasDefault` is `true`. */\n  readonly defaultValue?: T;\n\n  /** Whether the raw value is redacted from error output. */\n  readonly secret: boolean;\n\n  /** Phantom marker: `true` widens the inferred output type to `T | undefined`. Never read at runtime. */\n  readonly __optional?: Optional;\n\n  /** Parses a present, non-empty raw string into `T`; throws a `string` message describing the failure. */\n  parse(raw: string): T;\n}\n\n/** Computes a field's phantom optionality from its options literal — optional iff no `default` and `required: false`. */\ntype Optionality<O> = O extends { default: unknown } ? false : O extends { required: false } ? true : false;\n\n/** The upper bound for a field of unknown scalar type — every concrete `ConfigField<T, …>` is assignable to it. */\nexport type AnyConfigField = ConfigField<unknown, boolean>;\n\n/** Shared field constructor — folds the options into the runtime presence policy around a scalar `parse`. */\nfunction createField<T>(\n  typeName: string,\n  parse: (raw: string) => T,\n  options: ConfigFieldOptions<T> | undefined,\n): ConfigField<T, boolean> {\n  const hasDefault = options !== undefined && 'default' in options;\n  return {\n    typeName,\n    parse,\n    hasDefault,\n    defaultValue: hasDefault ? options.default : undefined,\n    // A field is required unless it carries a default or is explicitly opted out.\n    required: hasDefault ? false : options?.required ?? true,\n    secret: options?.secret ?? false,\n  };\n}\n\n/** A string field — the raw value is trimmed and rejected when empty (empty already reads as \"missing\"). */\nexport function str<const O extends ConfigFieldOptions<string> = ConfigFieldOptions<string>>(\n  options?: O,\n): ConfigField<string, Optionality<O>> {\n  return createField('string', (raw) => raw, options) as ConfigField<string, Optionality<O>>;\n}\n\n/** A finite-number field — rejects any raw string that does not parse to a finite JS number. */\nexport function num<const O extends ConfigFieldOptions<number> = ConfigFieldOptions<number>>(\n  options?: O,\n): ConfigField<number, Optionality<O>> {\n  return createField(\n    'number',\n    (raw) => {\n      const value = Number(raw);\n      if (!Number.isFinite(value)) throw `expected a number, got \"${raw}\"`;\n      return value;\n    },\n    options,\n  ) as ConfigField<number, Optionality<O>>;\n}\n\n/** The raw spellings each boolean side accepts, case-insensitively. */\nconst TRUE_TOKENS = new Set(['true', '1', 'yes', 'on']);\nconst FALSE_TOKENS = new Set(['false', '0', 'no', 'off']);\n\n/** A boolean field — accepts `true/1/yes/on` and `false/0/no/off` (case-insensitive); rejects anything else. */\nexport function bool<const O extends ConfigFieldOptions<boolean> = ConfigFieldOptions<boolean>>(\n  options?: O,\n): ConfigField<boolean, Optionality<O>> {\n  return createField(\n    'boolean',\n    (raw) => {\n      const token = raw.trim().toLowerCase();\n      if (TRUE_TOKENS.has(token)) return true;\n      if (FALSE_TOKENS.has(token)) return false;\n      throw `expected a boolean (true/false/1/0/yes/no/on/off), got \"${raw}\"`;\n    },\n    options,\n  ) as ConfigField<boolean, Optionality<O>>;\n}\n\n/** An enum field — the value must be one of `values`; the output type narrows to that literal union. */\nexport function oneOf<const V extends readonly string[], const O extends ConfigFieldOptions<V[number]> = ConfigFieldOptions<V[number]>>(\n  values: V,\n  options?: O,\n): ConfigField<V[number], Optionality<O>> {\n  return createField(\n    `one of [${values.join(', ')}]`,\n    (raw) => {\n      if ((values as readonly string[]).includes(raw)) return raw as V[number];\n      throw `expected one of [${values.join(', ')}], got \"${raw}\"`;\n    },\n    options,\n  ) as ConfigField<V[number], Optionality<O>>;\n}\n\n/** A URL field — validated with the `URL` constructor; the parsed string is returned unchanged. */\nexport function url<const O extends ConfigFieldOptions<string> = ConfigFieldOptions<string>>(\n  options?: O,\n): ConfigField<string, Optionality<O>> {\n  return createField(\n    'url',\n    (raw) => {\n      try {\n        // Construct-and-discard: `URL` throws on a malformed value; we keep the caller's original string.\n        void new URL(raw);\n        return raw;\n      } catch {\n        throw `expected a valid URL, got \"${raw}\"`;\n      }\n    },\n    options,\n  ) as ConfigField<string, Optionality<O>>;\n}\n\n/** A TCP-port field — a finite integer in `1..65535`. */\nexport function port<const O extends ConfigFieldOptions<number> = ConfigFieldOptions<number>>(\n  options?: O,\n): ConfigField<number, Optionality<O>> {\n  return createField(\n    'port',\n    (raw) => {\n      const value = Number(raw);\n      if (!Number.isInteger(value) || value < 1 || value > 65535) throw `expected a port in 1..65535, got \"${raw}\"`;\n      return value;\n    },\n    options,\n  ) as ConfigField<number, Optionality<O>>;\n}\n\n/** A JSON field — `JSON.parse`d into `T`; a malformed document is rejected. */\nexport function json<T, const O extends ConfigFieldOptions<T> = ConfigFieldOptions<T>>(\n  options?: O,\n): ConfigField<T, Optionality<O>> {\n  return createField(\n    'json',\n    (raw) => {\n      try {\n        return JSON.parse(raw) as T;\n      } catch {\n        throw `expected valid JSON, got \"${raw}\"`;\n      }\n    },\n    options,\n  ) as ConfigField<T, Optionality<O>>;\n}\n\n/** Tunes how a `list` field splits its raw value. */\nexport interface ListFieldOptions extends ConfigFieldOptions<readonly string[]> {\n  /** The item separator. Defaults to a comma. */\n  readonly separator?: string;\n}\n\n/** A string-list field — splits on `separator` (default `,`), trims each item, and drops empty items. */\nexport function list<const O extends ListFieldOptions = ListFieldOptions>(\n  options?: O,\n): ConfigField<readonly string[], Optionality<O>> {\n  const separator = options?.separator ?? ',';\n  return createField<readonly string[]>(\n    'list',\n    (raw) =>\n      raw\n        .split(separator)\n        .map((item) => item.trim())\n        .filter((item) => item.length > 0),\n    options,\n  ) as ConfigField<readonly string[], Optionality<O>>;\n}\n","// Configuration sources — the raw key/value stores `defineConfig` reads through. Two ship by default: the\n// build-time `import.meta.env` (Vite inlines it at build) and the runtime `window.__APP_CONFIG__` global an ops\n// team can inject per-environment without a rebuild (12-factor runtime config). A source is a flat record of\n// string values; `defineConfig` merges an ordered list where the *earlier* source wins, so runtime config is\n// layered ahead of build-time env by default. Reading a source never throws — an unavailable one yields `{}`.\n\n/** A flat, read-only key/value store of raw configuration strings. */\nexport type ConfigSource = Readonly<Record<string, string | undefined>>;\n\n/** The default runtime-config global — `window.__APP_CONFIG__`, injected per-environment ahead of build-time env. */\nexport const DEFAULT_RUNTIME_CONFIG_KEY = '__APP_CONFIG__';\n\n/**\n * The build-time source — Vite's `import.meta.env`, inlined at build. Returns `{}` outside a bundler context\n * (e.g. a plain Node test) where `import.meta.env` is absent, so it is always safe to include.\n */\nexport function importMetaEnvSource(): ConfigSource {\n  try {\n    const meta = import.meta as unknown as { env?: Record<string, string | undefined> };\n    return meta.env ?? {};\n  } catch {\n    return {};\n  }\n}\n\n/**\n * The runtime source — a global object (default `window.__APP_CONFIG__`) a deployment injects before the app\n * boots. Returns `{}` when there is no `window` (SSR / Node) or the global is absent or not an object.\n */\nexport function windowConfigSource(globalKey: string = DEFAULT_RUNTIME_CONFIG_KEY): ConfigSource {\n  if (typeof window === 'undefined') return {};\n  const raw = (window as unknown as Record<string, unknown>)[globalKey];\n  return raw !== null && typeof raw === 'object' ? (raw as ConfigSource) : {};\n}\n\n/** An explicit source over a plain record — the injection seam for tests and for values resolved elsewhere. */\nexport function staticSource(values: Record<string, string | undefined>): ConfigSource {\n  return values;\n}\n\n/** The default source order: runtime `window.__APP_CONFIG__` layered ahead of build-time `import.meta.env`. */\nexport function defaultSources(): readonly ConfigSource[] {\n  return [windowConfigSource(), importMetaEnvSource()];\n}\n\n/**\n * Resolves `key` across an ordered source list, first non-empty match wins (earlier source = higher priority).\n * A non-string hit (e.g. `import.meta.env.DEV` is a boolean) is coerced to its string form; an empty string is\n * treated as absent so an unset-but-declared env var falls through to the next source or the field default.\n */\nexport function resolveRaw(sources: readonly ConfigSource[], key: string): string | undefined {\n  for (const source of sources) {\n    const hit = (source as Record<string, unknown>)[key];\n    if (hit === undefined || hit === null) continue;\n    const asString = typeof hit === 'string' ? hit : String(hit);\n    if (asString.length === 0) continue;\n    return asString;\n  }\n  return undefined;\n}\n","// The typed-env engine. `defineConfig(schema, options)` reads each declared key from an ordered source list,\n// parses it through its `ConfigField`, applies defaults, and returns a frozen, fully-typed config object. Unlike\n// storage (which degrades silently), config fails LOUD: every missing-required and invalid-value problem is\n// collected across the whole schema and thrown together as one `ConfigError` at startup — so a misconfigured\n// deploy surfaces all its problems at once, not one boot-crash at a time.\n\nimport type { AnyConfigField, ConfigField } from './ConfigField';\nimport { defaultSources, resolveRaw, type ConfigSource } from './ConfigSource';\n\n/** A schema: a map from output key to its field spec. */\nexport type ConfigSchema = Readonly<Record<string, AnyConfigField>>;\n\n/** Widens an optional field's output to include `undefined`; a required / defaulted field stays `T`. */\ntype InferField<F> = F extends ConfigField<infer T, infer Optional> ? (Optional extends true ? T | undefined : T) : never;\n\n/** The resolved, typed config object inferred from a schema. */\nexport type InferConfig<S extends ConfigSchema> = { readonly [K in keyof S]: InferField<S[K]> };\n\n/** Tunes where `defineConfig` reads from and how keys are namespaced. */\nexport interface DefineConfigOptions {\n  /** The ordered source list; earlier wins. Defaults to `[window.__APP_CONFIG__, import.meta.env]`. */\n  readonly sources?: readonly ConfigSource[];\n\n  /** A prefix prepended to every schema key on lookup (e.g. `'VITE_'` → key `API_URL` reads `VITE_API_URL`). */\n  readonly prefix?: string;\n}\n\n/** One resolution failure — a missing required key or a value that failed its field's `parse`. */\nexport interface ConfigIssue {\n  /** The schema key (output name, without the lookup prefix). */\n  readonly key: string;\n\n  /** The full source key looked up (with prefix). */\n  readonly lookupKey: string;\n\n  /** Why it failed. */\n  readonly reason: 'missing' | 'invalid';\n\n  /** A human-readable description; a `secret` field's raw value is never included. */\n  readonly message: string;\n}\n\n/** Thrown by `defineConfig` when one or more keys are missing or invalid — aggregates every issue found. */\nexport class ConfigError extends Error {\n  /** Every resolution failure across the schema. */\n  readonly issues: readonly ConfigIssue[];\n\n  constructor(issues: readonly ConfigIssue[]) {\n    const lines = issues.map((issue) => `  - ${issue.lookupKey}: ${issue.message}`).join('\\n');\n    super(`Invalid configuration (${issues.length} ${issues.length === 1 ? 'issue' : 'issues'}):\\n${lines}`);\n    this.name = 'ConfigError';\n    this.issues = issues;\n    // Restore the prototype chain across the ES5 `Error` transpilation target so `instanceof` holds.\n    Object.setPrototypeOf(this, ConfigError.prototype);\n  }\n}\n\n/**\n * Resolves a typed configuration object from `schema`. Each key is looked up across the source list (prefix\n * applied), parsed through its field, and defaulted when absent. Empty strings count as absent. All missing /\n * invalid problems are aggregated and thrown together as a single {@link ConfigError}; on success the returned\n * object is frozen. Pass an explicit `sources` (e.g. `[staticSource({...})]`) to make resolution deterministic\n * in tests.\n */\nexport function defineConfig<const S extends ConfigSchema>(schema: S, options?: DefineConfigOptions): InferConfig<S> {\n  const sources = options?.sources ?? defaultSources();\n  const prefix = options?.prefix ?? '';\n\n  const resolved: Record<string, unknown> = {};\n  const issues: ConfigIssue[] = [];\n\n  for (const [key, field] of Object.entries(schema) as [string, AnyConfigField][]) {\n    const lookupKey = `${prefix}${key}`;\n    const raw = resolveRaw(sources, lookupKey);\n\n    if (raw === undefined) {\n      if (field.hasDefault) {\n        resolved[key] = field.defaultValue;\n      } else if (!field.required) {\n        resolved[key] = undefined;\n      } else {\n        issues.push({ key, lookupKey, reason: 'missing', message: `missing required ${field.typeName}` });\n      }\n      continue;\n    }\n\n    try {\n      resolved[key] = field.parse(raw);\n    } catch (error) {\n      // A field's `parse` throws a `string` describing the failure; anything else is coerced defensively.\n      const detail = typeof error === 'string' ? error : `invalid ${field.typeName}`;\n      // Never leak a secret's raw value — the field's own message may quote it, so replace it wholesale.\n      const message = field.secret ? `invalid ${field.typeName} (value redacted)` : detail;\n      issues.push({ key, lookupKey, reason: 'invalid', message });\n    }\n  }\n\n  if (issues.length > 0) throw new ConfigError(issues);\n\n  return Object.freeze(resolved) as InferConfig<S>;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/config/ConfigField.ts","../../../src/foundation/config/ConfigSource.ts","../../../src/foundation/config/DefineConfig.ts"],"sourcesContent":["// Typed-env field specs. A `ConfigField<T>` describes how one configuration key is parsed from its raw\n// string form, whether it is required, and its fallback — the atoms `defineConfig` reads a source through.\n// Each builder (`str`, `num`, `bool`, `oneOf`, `url`, `port`, `json`, `list`) returns a field whose `parse`\n// handles only a *present* raw string and throws a human-readable message on an invalid value; the engine\n// owns the missing / default / required decision centrally, so a field never re-implements that policy.\n\n/** Tunes one field's presence policy and fallback. A `default` (or `required: false`) makes the field optional. */\nexport interface ConfigFieldOptions<T> {\n  /** Marks the field required. Defaults to `true` unless a `default` is supplied. */\n  readonly required?: boolean;\n\n  /** The value used when the key is absent or empty. Supplying it makes the field optional. */\n  readonly default?: T;\n\n  /** Redacts the raw value from `ConfigError` messages — set for tokens, keys, and passwords. */\n  readonly secret?: boolean;\n}\n\n/**\n * Describes a single configuration key: its scalar type, presence policy, and how to parse a present raw\n * string into `T`. `Optional` is a phantom flag the schema inference reads to widen the output to `T | undefined`\n * for a field that is `required: false` with no `default`.\n */\nexport interface ConfigField<T, Optional extends boolean = false> {\n  /** The human-facing type name used in error messages (`string`, `number`, `one of [...]`, …). */\n  readonly typeName: string;\n\n  /** Whether a missing key is an error. `false` when a `default` is present or `required: false`. */\n  readonly required: boolean;\n\n  /** Whether an explicit `default` was supplied. */\n  readonly hasDefault: boolean;\n\n  /** The configured fallback, meaningful only when `hasDefault` is `true`. */\n  readonly defaultValue?: T;\n\n  /** Whether the raw value is redacted from error output. */\n  readonly secret: boolean;\n\n  /** Phantom marker: `true` widens the inferred output type to `T | undefined`. Never read at runtime. */\n  readonly __optional?: Optional;\n\n  /** Parses a present, non-empty raw string into `T`; throws a `string` message describing the failure. */\n  parse(raw: string): T;\n}\n\n/** Computes a field's phantom optionality from its options — optional iff no `default` and `required: false`. */\ntype Optionality<O> = O extends { default: unknown } ? false : O extends { required: false } ? true : false;\n\n/** The upper bound for a field of unknown scalar type — every concrete `ConfigField<T, …>` is assignable to it. */\nexport type AnyConfigField = ConfigField<unknown, boolean>;\n\n/** Shared field constructor — folds the options into the runtime presence policy around a scalar `parse`. */\nfunction createField<T>(\n  typeName: string,\n  parse: (raw: string) => T,\n  options: ConfigFieldOptions<T> | undefined,\n): ConfigField<T, boolean> {\n  const hasDefault = options !== undefined && 'default' in options;\n  return {\n    typeName,\n    parse,\n    hasDefault,\n    defaultValue: hasDefault ? options.default : undefined,\n    // A field is required unless it carries a default or is explicitly opted out.\n    required: hasDefault ? false : (options?.required ?? true),\n    secret: options?.secret ?? false,\n  };\n}\n\n/** A string field — the raw value is trimmed and rejected when empty (empty already reads as \"missing\"). */\nexport function str<const O extends ConfigFieldOptions<string> = ConfigFieldOptions<string>>(\n  options?: O,\n): ConfigField<string, Optionality<O>> {\n  return createField('string', (raw) => raw, options) as ConfigField<string, Optionality<O>>;\n}\n\n/** A finite-number field — rejects any raw string that does not parse to a finite JS number. */\nexport function num<const O extends ConfigFieldOptions<number> = ConfigFieldOptions<number>>(\n  options?: O,\n): ConfigField<number, Optionality<O>> {\n  return createField(\n    'number',\n    (raw) => {\n      const value = Number(raw);\n      if (!Number.isFinite(value)) throw `expected a number, got \"${raw}\"`;\n      return value;\n    },\n    options,\n  ) as ConfigField<number, Optionality<O>>;\n}\n\n/** The raw spellings each boolean side accepts, case-insensitively. */\nconst TrueTokens = new Set(['true', '1', 'yes', 'on']);\nconst FalseTokens = new Set(['false', '0', 'no', 'off']);\n\n/** A boolean field — accepts `true/1/yes/on` and `false/0/no/off` (case-insensitive); rejects anything else. */\nexport function bool<const O extends ConfigFieldOptions<boolean> = ConfigFieldOptions<boolean>>(\n  options?: O,\n): ConfigField<boolean, Optionality<O>> {\n  return createField(\n    'boolean',\n    (raw) => {\n      const token = raw.trim().toLowerCase();\n      if (TrueTokens.has(token)) return true;\n      if (FalseTokens.has(token)) return false;\n      throw `expected a boolean (true/false/1/0/yes/no/on/off), got \"${raw}\"`;\n    },\n    options,\n  ) as ConfigField<boolean, Optionality<O>>;\n}\n\n/** An enum field — the value must be one of `values`; the output type narrows to that literal union. */\nexport function oneOf<\n  const V extends readonly string[],\n  const O extends ConfigFieldOptions<V[number]> = ConfigFieldOptions<V[number]>,\n>(values: V, options?: O): ConfigField<V[number], Optionality<O>> {\n  return createField(\n    `one of [${values.join(', ')}]`,\n    (raw) => {\n      if ((values as readonly string[]).includes(raw)) return raw as V[number];\n      throw `expected one of [${values.join(', ')}], got \"${raw}\"`;\n    },\n    options,\n  ) as ConfigField<V[number], Optionality<O>>;\n}\n\n/** A URL field — validated with the `URL` constructor; the parsed string is returned unchanged. */\nexport function url<const O extends ConfigFieldOptions<string> = ConfigFieldOptions<string>>(\n  options?: O,\n): ConfigField<string, Optionality<O>> {\n  return createField(\n    'url',\n    (raw) => {\n      try {\n        // Construct-and-discard: `URL` throws on a malformed value; we keep the caller's original string.\n        void new URL(raw);\n        return raw;\n      } catch {\n        throw `expected a valid URL, got \"${raw}\"`;\n      }\n    },\n    options,\n  ) as ConfigField<string, Optionality<O>>;\n}\n\n/** A TCP-port field — a finite integer in `1..65535`. */\nexport function port<const O extends ConfigFieldOptions<number> = ConfigFieldOptions<number>>(\n  options?: O,\n): ConfigField<number, Optionality<O>> {\n  return createField(\n    'port',\n    (raw) => {\n      const value = Number(raw);\n      if (!Number.isInteger(value) || value < 1 || value > 65535) throw `expected a port in 1..65535, got \"${raw}\"`;\n      return value;\n    },\n    options,\n  ) as ConfigField<number, Optionality<O>>;\n}\n\n/** A JSON field — `JSON.parse`d into `T`; a malformed document is rejected. */\nexport function json<T, const O extends ConfigFieldOptions<T> = ConfigFieldOptions<T>>(\n  options?: O,\n): ConfigField<T, Optionality<O>> {\n  return createField(\n    'json',\n    (raw) => {\n      try {\n        return JSON.parse(raw) as T;\n      } catch {\n        throw `expected valid JSON, got \"${raw}\"`;\n      }\n    },\n    options,\n  ) as ConfigField<T, Optionality<O>>;\n}\n\n/** Tunes how a `list` field splits its raw value. */\nexport interface ListFieldOptions extends ConfigFieldOptions<readonly string[]> {\n  /** The item separator. Defaults to a comma. */\n  readonly separator?: string;\n}\n\n/** A string-list field — splits on `separator` (default `,`), trims each item, and drops empty items. */\nexport function list<const O extends ListFieldOptions = ListFieldOptions>(\n  options?: O,\n): ConfigField<ReadonlyArray<string>, Optionality<O>> {\n  const separator = options?.separator ?? ',';\n  return createField<readonly string[]>(\n    'list',\n    (raw) =>\n      raw\n        .split(separator)\n        .map((item) => item.trim())\n        .filter((item) => item.length > 0),\n    options,\n  ) as ConfigField<readonly string[], Optionality<O>>;\n}\n","// Configuration sources — the raw key/value stores `defineConfig` reads through. Two ship by default: the\n// build-time `import.meta.env` (Vite inlines it at build) and the runtime `window.__APP_CONFIG__` global an ops\n// team can inject per-environment without a rebuild (12-factor runtime config). A source is a flat record of\n// string values; `defineConfig` merges an ordered list where the *earlier* source wins, so runtime config is\n// layered ahead of build-time env by default. Reading a source never throws — an unavailable one yields `{}`.\n\n/** A flat, read-only key/value store of raw configuration strings. */\nexport type ConfigSource = Readonly<Record<string, string | undefined>>;\n\n/** The default runtime-config global — `window.__APP_CONFIG__`, injected per-environment ahead of build-time env. */\nexport const DefaultRuntimeConfigKey = '__APP_CONFIG__';\n\n/**\n * The build-time source — Vite's `import.meta.env`, inlined at build. Returns `{}` outside a bundler context\n * (e.g. a plain Node test) where `import.meta.env` is absent, so it is always safe to include.\n */\nexport function importMetaEnvSource(): ConfigSource {\n  try {\n    const meta = import.meta as unknown as { env?: Record<string, string | undefined> };\n    return meta.env ?? {};\n  } catch {\n    return {};\n  }\n}\n\n/**\n * The runtime source — a global object (default `window.__APP_CONFIG__`) a deployment injects before the app\n * boots. Returns `{}` when there is no `window` (SSR / Node) or the global is absent or not an object.\n */\nexport function windowConfigSource(globalKey: string = DefaultRuntimeConfigKey): ConfigSource {\n  if (typeof window === 'undefined') return {};\n  const raw = (window as unknown as Record<string, unknown>)[globalKey];\n  return raw !== null && typeof raw === 'object' ? (raw as ConfigSource) : {};\n}\n\n/** An explicit source over a plain record — the injection seam for tests and for values resolved elsewhere. */\nexport function staticSource(values: Record<string, string | undefined>): ConfigSource {\n  return values;\n}\n\n/** The default source order: runtime `window.__APP_CONFIG__` layered ahead of build-time `import.meta.env`. */\nexport function defaultSources(): ReadonlyArray<ConfigSource> {\n  return [windowConfigSource(), importMetaEnvSource()];\n}\n\n/**\n * Resolves `key` across an ordered source list, first non-empty match wins (earlier source = higher priority).\n * A non-string hit (e.g. `import.meta.env.DEV` is a boolean) is coerced to its string form; an empty string is\n * treated as absent so an unset-but-declared env var falls through to the next source or the field default.\n */\nexport function resolveRaw(sources: ReadonlyArray<ConfigSource>, key: string): string | undefined {\n  for (const source of sources) {\n    const hit = (source as Record<string, unknown>)[key];\n    if (hit === undefined || hit === null) continue;\n    const asString = typeof hit === 'string' ? hit : String(hit);\n    if (asString.length === 0) continue;\n    return asString;\n  }\n  return undefined;\n}\n","// The typed-env engine. `defineConfig(schema, options)` reads each declared key from an ordered source list,\n// parses it through its `ConfigField`, applies defaults, and returns a frozen, fully-typed config object. Unlike\n// storage (which degrades silently), config fails LOUD: every missing-required and invalid-value problem is\n// collected across the whole schema and thrown together as one `ConfigError` at startup — so a misconfigured\n// deploy surfaces all its problems at once, not one boot-crash at a time.\n\nimport type { AnyConfigField, ConfigField } from './ConfigField';\nimport { defaultSources, resolveRaw, type ConfigSource } from './ConfigSource';\n\n/** A schema: a map from output key to its field spec. */\nexport type ConfigSchema = Readonly<Record<string, AnyConfigField>>;\n\n/** Widens an optional field's output to include `undefined`; a required / defaulted field stays `T`. */\ntype InferField<F> =\n  F extends ConfigField<infer T, infer Optional> ? (Optional extends true ? T | undefined : T) : never;\n\n/** The resolved, typed config object inferred from a schema. */\nexport type InferConfig<S extends ConfigSchema> = { readonly [K in keyof S]: InferField<S[K]> };\n\n/** Tunes where `defineConfig` reads from and how keys are namespaced. */\nexport interface DefineConfigOptions {\n  /** The ordered source list; earlier wins. Defaults to `[window.__APP_CONFIG__, import.meta.env]`. */\n  readonly sources?: ReadonlyArray<ConfigSource>;\n\n  /** A prefix prepended to every schema key on lookup (e.g. `'VITE_'` → key `API_URL` reads `VITE_API_URL`). */\n  readonly prefix?: string;\n}\n\n/** One resolution failure — a missing required key or a value that failed its field's `parse`. */\nexport interface ConfigIssue {\n  /** The schema key (output name, without the lookup prefix). */\n  readonly key: string;\n\n  /** The full source key looked up (with prefix). */\n  readonly lookupKey: string;\n\n  /** Why it failed. */\n  readonly reason: 'missing' | 'invalid';\n\n  /** A human-readable description; a `secret` field's raw value is never included. */\n  readonly message: string;\n}\n\n/** Thrown by `defineConfig` when one or more keys are missing or invalid — aggregates every issue found. */\nexport class ConfigError extends Error {\n  /** Every resolution failure across the schema. */\n  readonly issues: ReadonlyArray<ConfigIssue>;\n\n  constructor(issues: ReadonlyArray<ConfigIssue>) {\n    const lines = issues.map((issue) => `  - ${issue.lookupKey}: ${issue.message}`).join('\\n');\n    super(`Invalid configuration (${issues.length} ${issues.length === 1 ? 'issue' : 'issues'}):\\n${lines}`);\n    this.name = 'ConfigError';\n    this.issues = issues;\n    // Restore the prototype chain across the ES5 `Error` transpilation target so `instanceof` holds.\n    Object.setPrototypeOf(this, ConfigError.prototype);\n  }\n}\n\n/**\n * Resolves a typed configuration object from `schema`. Each key is looked up across the source list (prefix\n * applied), parsed through its field, and defaulted when absent. Empty strings count as absent. All missing /\n * invalid problems are aggregated and thrown together as a single {@link ConfigError}; on success the returned\n * object is frozen. Pass an explicit `sources` (e.g. `[staticSource({...})]`) to make resolution deterministic\n * in tests.\n */\nexport function defineConfig<const S extends ConfigSchema>(schema: S, options?: DefineConfigOptions): InferConfig<S> {\n  const sources = options?.sources ?? defaultSources();\n  const prefix = options?.prefix ?? '';\n\n  const resolved: Record<string, unknown> = {};\n  const issues: ConfigIssue[] = [];\n\n  for (const [key, field] of Object.entries(schema) as [string, AnyConfigField][]) {\n    const lookupKey = `${prefix}${key}`;\n    const raw = resolveRaw(sources, lookupKey);\n\n    if (raw === undefined) {\n      if (field.hasDefault) {\n        resolved[key] = field.defaultValue;\n      } else if (!field.required) {\n        resolved[key] = undefined;\n      } else {\n        issues.push({ key, lookupKey, reason: 'missing', message: `missing required ${field.typeName}` });\n      }\n      continue;\n    }\n\n    try {\n      resolved[key] = field.parse(raw);\n    } catch (error) {\n      // A field's `parse` throws a `string` describing the failure; anything else is coerced defensively.\n      const detail = typeof error === 'string' ? error : `invalid ${field.typeName}`;\n      // Never leak a secret's raw value — the field's own message may quote it, so replace it wholesale.\n      const message = field.secret ? `invalid ${field.typeName} (value redacted)` : detail;\n      issues.push({ key, lookupKey, reason: 'invalid', message });\n    }\n  }\n\n  if (issues.length > 0) throw new ConfigError(issues);\n\n  return Object.freeze(resolved) as InferConfig<S>;\n}\n"],"names":[],"mappings":"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"}

package/dist/foundation/crypto/Digest.d.ts

@@ -1,7 +1,18 @@
 /** Accepted digest input: a UTF-8-encoded string, a raw `ArrayBuffer`, or an existing byte view. */
 export type BinaryInput = string | ArrayBuffer | Uint8Array;
-/** A hash algorithm `crypto.subtle.digest` implements. SHA-256 is the default choice; SHA-1 is checksum/interop only. */
-export type DigestAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+/** A hash algorithm `crypto.subtle.digest` implements. SHA-256 is the default; SHA-1 is checksum/interop only. */
+export declare const DigestAlgorithm: {
+    /** Names the 160-bit SHA-1 digest — broken for signatures, correct for checksums and git-style interop. */
+    readonly Sha1: "SHA-1";
+    /** Names the 256-bit SHA-2 digest — the default for cache keys, content hashes, and ETags. */
+    readonly Sha256: "SHA-256";
+    /** Names the 384-bit SHA-2 digest — a truncated SHA-512, for callers pinned to a 48-byte width. */
+    readonly Sha384: "SHA-384";
+    /** Names the 512-bit SHA-2 digest — the widest the platform implements. */
+    readonly Sha512: "SHA-512";
+};
+/** A hash algorithm `crypto.subtle.digest` implements. SHA-256 is the default; SHA-1 is checksum/interop only. */
+export type DigestAlgorithm = (typeof DigestAlgorithm)[keyof typeof DigestAlgorithm];
 /** Normalizes any {@link BinaryInput} to bytes; strings become UTF-8. Internal — not exported from the barrel. */
 export declare function toBytes(data: BinaryInput): Uint8Array;
 /**
@@ -9,7 +20,7 @@ export declare function toBytes(data: BinaryInput): Uint8Array;
  * helpers below wrap. **Throws** synchronously when `crypto.subtle` is unavailable (insecure context).
  */
 export declare function digest(algorithm: DigestAlgorithm, data: BinaryInput): Promise<Uint8Array>;
-/** Computes the SHA-256 digest of `data` (32 bytes) — the default hash for cache keys, ETags, and content addressing. */
+/** Computes the SHA-256 digest of `data` (32 bytes) — the default hash for cache keys, ETags, content addressing. */
 export declare function sha256(data: BinaryInput): Promise<Uint8Array>;
 /**
  * Computes the SHA-1 digest of `data` (20 bytes). **Not collision-resistant** — use it only for
@@ -21,5 +32,8 @@ export declare function sha1(data: BinaryInput): Promise<Uint8Array>;
 export declare function sha384(data: BinaryInput): Promise<Uint8Array>;
 /** Computes the SHA-512 digest of `data` (64 bytes) — wider margin than SHA-256, and faster on 64-bit hardware. */
 export declare function sha512(data: BinaryInput): Promise<Uint8Array>;
-/** Computes the SHA-256 digest of `data` as a lowercase 64-char hex string — the ready-to-print form for an ETag or cache key. */
+/**
+ * Computes the SHA-256 digest of `data` as a lowercase 64-char hex string — the ready-to-print form for an ETag
+ * or cache key.
+ */
 export declare function sha256Hex(data: BinaryInput): Promise<string>;

package/dist/foundation/crypto/Encoding.d.ts

@@ -33,7 +33,10 @@ export declare function bytesToBase64Url(bytes: Uint8Array): string;
  * standard-base64 `+` and `/`, which signal that {@link base64ToBytes} was the intended decoder.
  */
 export declare function base64UrlToBytes(base64Url: string): Uint8Array;
-/** Encodes a string to its UTF-8 bytes — the normalization every digest of a string goes through. Inverse of {@link bytesToUtf8}. */
+/**
+ * Encodes a string to its UTF-8 bytes — the normalization every digest of a string goes through.
+ * Inverse of {@link bytesToUtf8}.
+ */
 export declare function utf8ToBytes(text: string): Uint8Array;
 /**
  * Decodes UTF-8 bytes back to a string. **Lenient**: an invalid sequence becomes U+FFFD rather than

package/dist/foundation/crypto/Random.d.ts

@@ -2,7 +2,7 @@
  * Default alphabet: URL-safe base62 (`A-Z`, `a-z`, `0-9`). No `+/=~`, so a generated string is safe in a
  * path segment, a query value, a filename, and an HTML attribute without escaping.
  */
-export declare const URL_SAFE_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+export declare const UrlSafeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 /**
  * Returns the exclusive upper bound for an unbiased byte: the largest multiple of `size` that fits in 256.
  * Bytes at or above it must be discarded — see the file header. Internal — not exported from the barrel.
@@ -19,10 +19,10 @@ export declare function randomBytes(length: number): Uint8Array;
  * biased bytes (see the file header). The injected source is what makes rejection testable. Internal — not
  * exported from the barrel; call {@link randomString} instead.
  */
-export declare function randomStringFrom(length: number, chars: readonly string[], nextBytes: (count: number) => Uint8Array): string;
+export declare function randomStringFrom(length: number, chars: ReadonlyArray<string>, nextBytes: (count: number) => Uint8Array): string;
 /**
  * Generates a random string of `length` characters, drawn uniformly from `alphabet` (default
- * {@link URL_SAFE_ALPHABET}) with rejection sampling — no modulo bias. Use it for opaque tokens, nonces, and
+ * {@link UrlSafeAlphabet}) with rejection sampling — no modulo bias. Use it for opaque tokens, nonces, and
  * collision-resistant suffixes; use `Guid` from `foundation/identifiers` for entity identifiers.
  *
  * The alphabet is split by code point, so an emoji or astral-plane character counts as one character and is

package/dist/foundation/crypto/WebCrypto.d.ts

@@ -9,7 +9,7 @@ export declare function isCryptoAvailable(): boolean;
  * is true. Probe this before offering a hash-dependent feature rather than catching the throw.
  */
 export declare function isSubtleAvailable(): boolean;
-/** Returns the ambient `Crypto`, throwing a diagnostic `Error` when unavailable. Internal — not exported from the barrel. */
+/** Returns the ambient `Crypto`, throwing a diagnostic `Error` when unavailable. Internal — not barrelled. */
 export declare function requireCrypto(): Crypto;
-/** Returns the ambient `SubtleCrypto`, throwing a diagnostic `Error` when unavailable. Internal — not exported from the barrel. */
+/** Returns the ambient `SubtleCrypto`, throwing a diagnostic `Error` when unavailable. Internal — not barrelled. */
 export declare function requireSubtle(): SubtleCrypto;

package/dist/foundation/crypto/index.d.ts

@@ -1,6 +1,6 @@
 export { isCryptoAvailable, isSubtleAvailable } from './WebCrypto';
 export { bytesToHex, hexToBytes, bytesToBase64, base64ToBytes, bytesToBase64Url, base64UrlToBytes, utf8ToBytes, bytesToUtf8, } from './Encoding';
-export { type BinaryInput, type DigestAlgorithm, digest, sha1, sha256, sha384, sha512, sha256Hex, } from './Digest';
-export { URL_SAFE_ALPHABET, randomBytes, randomString } from './Random';
+export { type BinaryInput, type DigestAlgorithm, digest, sha1, sha256, sha384, sha512, sha256Hex } from './Digest';
+export { UrlSafeAlphabet, randomBytes, randomString } from './Random';
 export { timingSafeEqual } from './TimingSafeEqual';
 export { stableStringify, hashObject } from './HashObject';

package/dist/foundation/crypto/index.js

@@ -30,20 +30,20 @@ function requireSubtle() {
   }
   return subtle;
 }
-const HEX_BY_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-const HEX_STRING = /^(?:[0-9a-fA-F]{2})*$/;
-const BASE64_STRING = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/;
-const BASE64URL_STRING = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2}(?:==)?|[A-Za-z0-9_-]{3}=?)?$/;
-const FROM_CHAR_CODE_CHUNK = 32768;
-const UTF8_ENCODER = new TextEncoder();
-const UTF8_DECODER = new TextDecoder();
+const HexByByte = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+const HexString = /^(?:[0-9a-fA-F]{2})*$/;
+const Base64String = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/;
+const Base64UrlString = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2}(?:==)?|[A-Za-z0-9_-]{3}=?)?$/;
+const FromCharCodeChunk = 32768;
+const Utf8Encoder = new TextEncoder();
+const Utf8Decoder = new TextDecoder();
 function bytesToHex(bytes) {
   let hex = "";
-  for (const byte of bytes) hex += HEX_BY_BYTE[byte];
+  for (const byte of bytes) hex += HexByByte[byte];
   return hex;
 }
 function hexToBytes(hex) {
-  if (!HEX_STRING.test(hex)) {
+  if (HexString.exec(hex)?.[0] !== hex) {
     throw new TypeError(
       `hexToBytes: expected an even-length string of hex digits, got "${hex}" (length ${hex.length}).`
     );
@@ -56,13 +56,13 @@ function hexToBytes(hex) {
 }
 function bytesToBase64(bytes) {
   let binary = "";
-  for (let offset = 0; offset < bytes.length; offset += FROM_CHAR_CODE_CHUNK) {
-    binary += String.fromCharCode(...bytes.subarray(offset, offset + FROM_CHAR_CODE_CHUNK));
+  for (let offset = 0; offset < bytes.length; offset += FromCharCodeChunk) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + FromCharCodeChunk));
   }
   return btoa(binary);
 }
 function base64ToBytes(base64) {
-  if (!BASE64_STRING.test(base64)) {
+  if (Base64String.exec(base64)?.[0] !== base64) {
     throw new TypeError(
       `base64ToBytes: expected a canonical standard-base64 string (alphabet A-Za-z0-9+/ with optional = padding), got "${base64}".`
     );
@@ -76,7 +76,7 @@ function bytesToBase64Url(bytes) {
   return bytesToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
 function base64UrlToBytes(base64Url) {
-  if (!BASE64URL_STRING.test(base64Url)) {
+  if (Base64UrlString.exec(base64Url)?.[0] !== base64Url) {
     throw new TypeError(
       `base64UrlToBytes: expected a base64url string (alphabet A-Za-z0-9-_ with optional = padding), got "${base64Url}".`
     );
@@ -86,11 +86,21 @@ function base64UrlToBytes(base64Url) {
   return base64ToBytes(standard + padding);
 }
 function utf8ToBytes(text) {
-  return UTF8_ENCODER.encode(text);
+  return Utf8Encoder.encode(text);
 }
 function bytesToUtf8(bytes) {
-  return UTF8_DECODER.decode(bytes);
-}
+  return Utf8Decoder.decode(bytes);
+}
+const DigestAlgorithm = {
+  /** Names the 160-bit SHA-1 digest — broken for signatures, correct for checksums and git-style interop. */
+  Sha1: "SHA-1",
+  /** Names the 256-bit SHA-2 digest — the default for cache keys, content hashes, and ETags. */
+  Sha256: "SHA-256",
+  /** Names the 384-bit SHA-2 digest — a truncated SHA-512, for callers pinned to a 48-byte width. */
+  Sha384: "SHA-384",
+  /** Names the 512-bit SHA-2 digest — the widest the platform implements. */
+  Sha512: "SHA-512"
+};
 function toBytes(data) {
   if (typeof data === "string") return utf8ToBytes(data);
   if (data instanceof Uint8Array) return data;
@@ -102,22 +112,22 @@ async function digest(algorithm, data) {
   return new Uint8Array(hashed);
 }
 function sha256(data) {
-  return digest("SHA-256", data);
+  return digest(DigestAlgorithm.Sha256, data);
 }
 function sha1(data) {
-  return digest("SHA-1", data);
+  return digest(DigestAlgorithm.Sha1, data);
 }
 function sha384(data) {
-  return digest("SHA-384", data);
+  return digest(DigestAlgorithm.Sha384, data);
 }
 function sha512(data) {
-  return digest("SHA-512", data);
+  return digest(DigestAlgorithm.Sha512, data);
 }
 async function sha256Hex(data) {
   return bytesToHex(await sha256(data));
 }
-const URL_SAFE_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-const MAX_BYTES_PER_CALL = 65536;
+const UrlSafeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const MaxBytesPerCall = 65536;
 function rejectionLimit(size) {
   return 256 - 256 % size;
 }
@@ -127,8 +137,8 @@ function randomBytes(length) {
   }
   const source = requireCrypto();
   const bytes = new Uint8Array(length);
-  for (let offset = 0; offset < length; offset += MAX_BYTES_PER_CALL) {
-    source.getRandomValues(bytes.subarray(offset, Math.min(offset + MAX_BYTES_PER_CALL, length)));
+  for (let offset = 0; offset < length; offset += MaxBytesPerCall) {
+    source.getRandomValues(bytes.subarray(offset, Math.min(offset + MaxBytesPerCall, length)));
   }
   return bytes;
 }
@@ -159,7 +169,7 @@ function randomStringFrom(length, chars, nextBytes) {
   }
   return picked.join("");
 }
-function randomString(length, alphabet = URL_SAFE_ALPHABET) {
+function randomString(length, alphabet = UrlSafeAlphabet) {
   return randomStringFrom(length, [...alphabet], randomBytes);
 }
 function timingSafeEqual(a, b) {
@@ -200,7 +210,7 @@ function hashObject(value) {
   return sha256Hex(stableStringify(value));
 }
 export {
-  URL_SAFE_ALPHABET,
+  UrlSafeAlphabet,
   base64ToBytes,
   base64UrlToBytes,
   bytesToBase64,

package/dist/foundation/crypto/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/crypto/WebCrypto.ts","../../../src/foundation/crypto/Encoding.ts","../../../src/foundation/crypto/Digest.ts","../../../src/foundation/crypto/Random.ts","../../../src/foundation/crypto/TimingSafeEqual.ts","../../../src/foundation/crypto/HashObject.ts"],"sourcesContent":["// Web Crypto resolution + capability probes — the single place this slice reads the ambient\n// `globalThis.crypto`. Isolated for two reasons.\n//\n// 1. The two capabilities fail INDEPENDENTLY, so they must be probed separately. `crypto.getRandomValues`\n//    is available in every modern runtime, secure context or not; `crypto.subtle` is available ONLY in a\n//    secure context (https, localhost, or a file/extension origin) and is `undefined` on a plain `http://`\n//    page served from a LAN IP — a setup that looks fine in dev and breaks on a staging box. Collapsing\n//    both into one \"crypto available\" flag would report random-byte generation as broken whenever digests\n//    are, and vice versa.\n// 2. The global is read at CALL time, never cached at module scope. Caching would freeze an `undefined`\n//    captured during SSR/hydration into the module for the page's lifetime, and would block a test from\n//    stubbing `globalThis.crypto` to exercise a failure path.\n//\n// SSR contract for the whole slice, stated once here and echoed on each consumer: the pure helpers\n// (`Encoding`, `timingSafeEqual`) never touch this file and run anywhere — SSR, workers, insecure origins.\n// The digest and random helpers THROW at the call site when their capability is missing, rather than\n// returning a sentinel: a silently unhashed value or a non-random \"random\" byte is a security defect that\n// a fallback would hide, so failing loudly is the only safe default. Callers that must branch instead of\n// catch use `isCryptoAvailable()` / `isSubtleAvailable()`.\n\n/** Reads the ambient Web Crypto object, or `undefined` when the runtime has none (older SSR hosts, sandboxes). */\nfunction resolveCrypto(): Crypto | undefined {\n  // Widened through an optional-property view: `globalThis.crypto` is typed non-optional by lib.dom, so a\n  // direct `=== undefined` check would be a TS2367 \"no overlap\" error even though it is exactly the case\n  // this function exists to handle.\n  return (globalThis as { crypto?: Crypto }).crypto;\n}\n\n/** Reads the ambient `SubtleCrypto`, or `undefined` when absent — no Web Crypto at all, or an insecure context. */\nfunction resolveSubtle(): SubtleCrypto | undefined {\n  const source = resolveCrypto();\n  if (source === undefined) return undefined;\n\n  // Same widening rationale as `resolveCrypto`: `Crypto.subtle` is typed non-optional but is genuinely\n  // absent outside a secure context.\n  return (source as { subtle?: SubtleCrypto }).subtle;\n}\n\n/**\n * Reports whether `crypto.getRandomValues` can be called — i.e. whether {@link randomBytes} and\n * {@link randomString} will succeed. True in every browser and in Node 19+, including insecure contexts.\n */\nexport function isCryptoAvailable(): boolean {\n  return typeof resolveCrypto()?.getRandomValues === 'function';\n}\n\n/**\n * Reports whether `crypto.subtle` can be called — i.e. whether the digest helpers will succeed. False\n * outside a **secure context** (plain `http://` on a non-localhost host) even when {@link isCryptoAvailable}\n * is true. Probe this before offering a hash-dependent feature rather than catching the throw.\n */\nexport function isSubtleAvailable(): boolean {\n  return typeof resolveSubtle()?.digest === 'function';\n}\n\n/** Returns the ambient `Crypto`, throwing a diagnostic `Error` when unavailable. Internal — not exported from the barrel. */\nexport function requireCrypto(): Crypto {\n  const source = resolveCrypto();\n  if (source === undefined || typeof source.getRandomValues !== 'function') {\n    throw new Error(\n      'Web Crypto is unavailable: `globalThis.crypto.getRandomValues` is not a function. This runtime ' +\n        'cannot produce cryptographically secure bytes — guard the call with `isCryptoAvailable()`.',\n    );\n  }\n\n  return source;\n}\n\n/** Returns the ambient `SubtleCrypto`, throwing a diagnostic `Error` when unavailable. Internal — not exported from the barrel. */\nexport function requireSubtle(): SubtleCrypto {\n  const subtle = resolveSubtle();\n  if (subtle === undefined || typeof subtle.digest !== 'function') {\n    throw new Error(\n      'Web Crypto `subtle` is unavailable: `globalThis.crypto.subtle` is undefined. `crypto.subtle` is ' +\n        'exposed only in a secure context (https, localhost, or a file/extension origin) — an `http://` ' +\n        'page on a LAN host has `crypto.getRandomValues` but no `subtle`. Guard with `isSubtleAvailable()`.',\n    );\n  }\n\n  return subtle;\n}\n","// Byte <-> text codecs: hex, base64, base64url, UTF-8. Pure and synchronous, touching no Web Crypto at\n// all — so every helper here runs under SSR, in a worker, and on an insecure origin, unlike the digest and\n// random helpers. This is the slice's floor: a digest returns bytes, and bytes are unreadable until one of\n// these renders them (ETag header, cache key, checksum shown to a user).\n//\n// Decisions worth stating:\n//  - Decoders are STRICT — malformed input throws a `TypeError`, never a best-effort result. A digest that\n//    silently mis-decodes compares unequal forever and the bug surfaces far from its cause; a throw is\n//    found on the first run. Both `hexToBytes` and `base64ToBytes` validate the full string shape BEFORE\n//    any conversion, so a partial result is never produced.\n//  - base64url is a first-class pair, not a `.replace()` applied to base64 output at each call site. JWT\n//    segments, URL query values, and filename-safe keys all need `-_` and no `=`, and the padding handling\n//    is exactly where the hand-rolled version goes wrong.\n//  - `btoa`/`atob` do the base64 work rather than a hand-rolled table: both are present in every runtime we\n//    target (browsers, Node 16+, workers, Deno/Bun) and are far faster than a JS loop. Their leniency is\n//    what the validation above wraps — by the time they are called the input is known-good.\n//  - `bytesToBase64` chunks its input. `String.fromCharCode(...bytes)` on a multi-MB array overflows the\n//    argument stack (`RangeError: Maximum call stack size exceeded`) — a bug that only appears on large\n//    files, i.e. in production.\n//  - `bytesToUtf8` is LENIENT: invalid sequences become U+FFFD, `TextDecoder`'s default. That matches what\n//    a caller rendering a payload expects. It also makes UTF-8 a lossy round-trip for arbitrary binary by\n//    definition — hash bytes must go through hex or base64, never through this.\n\n/** Precomputed byte -> 2-char lowercase hex, so `bytesToHex` is a table lookup rather than a per-byte `toString(16).padStart`. */\nconst HEX_BY_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n\n/** Matches an even-length run of hex digits (either case), including the empty string. */\nconst HEX_STRING = /^(?:[0-9a-fA-F]{2})*$/;\n\n/**\n * Matches canonical standard base64: whole 4-char groups, then an optional 2- or 3-char tail with correct\n * padding. Rejects a lone trailing char (`{4}n+1` is not a reachable length), over-padding (`YQ===`), and\n * any character outside the standard alphabet — including whitespace and the base64url `-_`.\n */\nconst BASE64_STRING = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/;\n\n/** The base64url counterpart of {@link BASE64_STRING} — `-_` in place of `+/`. Padding is tolerated on input though never emitted. */\nconst BASE64URL_STRING = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2}(?:==)?|[A-Za-z0-9_-]{3}=?)?$/;\n\n/** Largest slice fed to `String.fromCharCode(...)` at once — keeps the spread well under the engine argument limit. */\nconst FROM_CHAR_CODE_CHUNK = 0x8000;\n\n/** Shared UTF-8 encoder. `TextEncoder` is part of the Encoding standard, present in every target runtime (including SSR), so module-scope construction is safe. */\nconst UTF8_ENCODER = new TextEncoder();\n\n/** Shared UTF-8 decoder, lenient by default — see the file header on why `fatal` is not set. */\nconst UTF8_DECODER = new TextDecoder();\n\n/**\n * Renders bytes as a lowercase hex string (2 chars per byte, no separator) — the canonical way to show a\n * digest, an ETag, or a checksum. Inverse of {@link hexToBytes}.\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  let hex = '';\n  for (const byte of bytes) hex += HEX_BY_BYTE[byte]!;\n  return hex;\n}\n\n/**\n * Parses a hex string into bytes, accepting either case. **Throws a `TypeError`** when the input has an odd\n * length or contains a non-hex character — a half-parsed digest is never returned. Inverse of\n * {@link bytesToHex}.\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (!HEX_STRING.test(hex)) {\n    throw new TypeError(\n      `hexToBytes: expected an even-length string of hex digits, got \"${hex}\" (length ${hex.length}).`,\n    );\n  }\n\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);\n  }\n\n  return bytes;\n}\n\n/**\n * Encodes bytes as standard, padded base64 (`+`, `/`, `=`). Safe for arbitrarily large inputs — the source\n * is walked in chunks. Inverse of {@link base64ToBytes}; for URL or JWT contexts use\n * {@link bytesToBase64Url}.\n */\nexport function bytesToBase64(bytes: Uint8Array): string {\n  let binary = '';\n  for (let offset = 0; offset < bytes.length; offset += FROM_CHAR_CODE_CHUNK) {\n    binary += String.fromCharCode(...bytes.subarray(offset, offset + FROM_CHAR_CODE_CHUNK));\n  }\n\n  return btoa(binary);\n}\n\n/**\n * Decodes standard base64 into bytes. Padding may be present or omitted, but the string must otherwise be\n * canonical: **throws a `TypeError`** on any character outside `A-Za-z0-9+/=` (whitespace and the base64url\n * `-_` included), on over-padding, and on an impossible length. Inverse of {@link bytesToBase64}.\n */\nexport function base64ToBytes(base64: string): Uint8Array {\n  if (!BASE64_STRING.test(base64)) {\n    throw new TypeError(\n      `base64ToBytes: expected a canonical standard-base64 string (alphabet A-Za-z0-9+/ with optional ` +\n        `= padding), got \"${base64}\".`,\n    );\n  }\n\n  const binary = atob(base64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < bytes.length; i++) bytes[i] = binary.charCodeAt(i);\n\n  return bytes;\n}\n\n/**\n * Encodes bytes as **unpadded** base64url (RFC 4648 §5) — `-_` in place of `+/`, no `=`. This is the form a\n * JWT segment, a URL query value, and a filename-safe cache key all require. Inverse of\n * {@link base64UrlToBytes}.\n */\nexport function bytesToBase64Url(bytes: Uint8Array): string {\n  return bytesToBase64(bytes).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n/**\n * Decodes base64url into bytes, tolerating the padding that {@link bytesToBase64Url} never emits (some\n * producers add it). **Throws a `TypeError`** on any character outside `A-Za-z0-9-_=` — notably on the\n * standard-base64 `+` and `/`, which signal that {@link base64ToBytes} was the intended decoder.\n */\nexport function base64UrlToBytes(base64Url: string): Uint8Array {\n  if (!BASE64URL_STRING.test(base64Url)) {\n    throw new TypeError(\n      `base64UrlToBytes: expected a base64url string (alphabet A-Za-z0-9-_ with optional = padding), got ` +\n        `\"${base64Url}\".`,\n    );\n  }\n\n  const standard = base64Url.replace(/-/g, '+').replace(/_/g, '/');\n\n  // Re-pad to a 4-char boundary: `atob` accepts unpadded input, but re-padding keeps this on the exact\n  // path `base64ToBytes` validates rather than relying on that leniency.\n  const padding = standard.length % 4 === 0 ? '' : '='.repeat(4 - (standard.length % 4));\n\n  return base64ToBytes(standard + padding);\n}\n\n/** Encodes a string to its UTF-8 bytes — the normalization every digest of a string goes through. Inverse of {@link bytesToUtf8}. */\nexport function utf8ToBytes(text: string): Uint8Array {\n  return UTF8_ENCODER.encode(text);\n}\n\n/**\n * Decodes UTF-8 bytes back to a string. **Lenient**: an invalid sequence becomes U+FFFD rather than\n * throwing, so this is lossy for arbitrary binary — render digest bytes with {@link bytesToHex} or\n * {@link bytesToBase64} instead. Inverse of {@link utf8ToBytes} for any real text.\n */\nexport function bytesToUtf8(bytes: Uint8Array): string {\n  return UTF8_DECODER.decode(bytes);\n}\n","// Cryptographic digests over `crypto.subtle`. Async and non-negotiably so — `SubtleCrypto.digest` returns a\n// promise, and there is no synchronous hash in the platform. A caller that needs a hash inside a render pass\n// must compute it in an effect and hold the result in state; do not go looking for a sync variant.\n//\n// Decisions worth stating:\n//  - The input type is widened to `string | ArrayBuffer | Uint8Array` and normalized here, because every\n//    call site otherwise repeats the same `new TextEncoder().encode(...)` line and they eventually disagree\n//    about encoding. Strings are always UTF-8 — the only encoding that makes a digest reproducible across a\n//    JS client and a .NET backend computing the same hash.\n//  - Bytes are returned, not hex. A digest's natural type is bytes: `timingSafeEqual` consumes them\n//    directly, and the caller picks the rendering (`bytesToHex` for an ETag, `bytesToBase64` for a\n//    `Content-Digest` header). `sha256Hex` exists because hex is the common case and chaining two calls for\n//    it is noise.\n//  - SHA-1 is exposed despite being broken for signatures. It is still the correct tool for a non-adversarial\n//    checksum and, more to the point, for interoperating with systems that already speak it (git object ids,\n//    legacy ETags). Its JSDoc says so; picking it for anything security-bearing is the call site's error.\n//  - `crypto.subtle` is absent outside a secure context, so every function here throws at the call site when\n//    it is missing — see `WebCrypto.ts` for the full contract and `isSubtleAvailable()` for the probe.\n\nimport { bytesToHex, utf8ToBytes } from './Encoding';\nimport { requireSubtle } from './WebCrypto';\n\n/** Accepted digest input: a UTF-8-encoded string, a raw `ArrayBuffer`, or an existing byte view. */\nexport type BinaryInput = string | ArrayBuffer | Uint8Array;\n\n/** A hash algorithm `crypto.subtle.digest` implements. SHA-256 is the default choice; SHA-1 is checksum/interop only. */\nexport type DigestAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';\n\n/** Normalizes any {@link BinaryInput} to bytes; strings become UTF-8. Internal — not exported from the barrel. */\nexport function toBytes(data: BinaryInput): Uint8Array {\n  if (typeof data === 'string') return utf8ToBytes(data);\n  if (data instanceof Uint8Array) return data;\n  return new Uint8Array(data);\n}\n\n/**\n * Hashes `data` with the named algorithm and resolves to the raw digest bytes — the general form the named\n * helpers below wrap. **Throws** synchronously when `crypto.subtle` is unavailable (insecure context).\n */\nexport async function digest(algorithm: DigestAlgorithm, data: BinaryInput): Promise<Uint8Array> {\n  const subtle = requireSubtle();\n\n  // TS 5.7 made `Uint8Array` generic over its backing buffer and narrowed `BufferSource` to\n  // `ArrayBufferView<ArrayBuffer>`, which excludes the `SharedArrayBuffer`-backed views the default\n  // `Uint8Array<ArrayBufferLike>` still admits. `subtle.digest` reads any byte view at runtime, so this\n  // widens the static type without changing behaviour — and without narrowing what callers may pass in.\n  const hashed = await subtle.digest(algorithm, toBytes(data) as BufferSource);\n\n  return new Uint8Array(hashed);\n}\n\n/** Computes the SHA-256 digest of `data` (32 bytes) — the default hash for cache keys, ETags, and content addressing. */\nexport function sha256(data: BinaryInput): Promise<Uint8Array> {\n  return digest('SHA-256', data);\n}\n\n/**\n * Computes the SHA-1 digest of `data` (20 bytes). **Not collision-resistant** — use it only for\n * non-adversarial checksums or to interoperate with a system that already speaks SHA-1 (git, legacy ETags).\n * Reach for {@link sha256} everywhere else.\n */\nexport function sha1(data: BinaryInput): Promise<Uint8Array> {\n  return digest('SHA-1', data);\n}\n\n/** Computes the SHA-384 digest of `data` (48 bytes) — the truncated SHA-512 variant used by subresource integrity. */\nexport function sha384(data: BinaryInput): Promise<Uint8Array> {\n  return digest('SHA-384', data);\n}\n\n/** Computes the SHA-512 digest of `data` (64 bytes) — wider margin than SHA-256, and faster on 64-bit hardware. */\nexport function sha512(data: BinaryInput): Promise<Uint8Array> {\n  return digest('SHA-512', data);\n}\n\n/** Computes the SHA-256 digest of `data` as a lowercase 64-char hex string — the ready-to-print form for an ETag or cache key. */\nexport async function sha256Hex(data: BinaryInput): Promise<string> {\n  return bytesToHex(await sha256(data));\n}\n","// Cryptographically secure randomness over `crypto.getRandomValues`. Available in insecure contexts too, so\n// this works where the digest helpers do not — see `WebCrypto.ts` for the split.\n//\n// The one non-obvious thing in this file is **modulo-bias rejection sampling**, and it is the reason\n// `randomString` exists at all rather than being a two-line snippet at each call site. The naive form\n//\n//     alphabet[randomByte % alphabet.length]\n//\n// is skewed. A byte is uniform over 0..255 — 256 values. With a 62-char alphabet, 256 = 4x62 + 8, so the\n// residues 0..7 are each reachable from 5 bytes while residues 8..61 are reachable from only 4. The first\n// 8 characters of the alphabet come up ~25% more often than the rest. That is invisible in a smoke test and\n// measurable by an attacker over enough samples, which is precisely the wrong failure shape for a token.\n//\n// The fix: discard every byte at or above the largest multiple of the alphabet size that fits in 256\n// (`rejectionLimit`), and only then take the modulo. For 62 that limit is 248, so bytes 248..255 are thrown\n// away and the remaining 248 map 4-to-1 onto 62 characters — exactly uniform. The cost is a re-draw for\n// ~3% of bytes, which is why the generator over-draws and loops instead of asking for exactly `length`.\n//\n// `randomStringFrom` takes its byte source as a parameter so the rejection path is testable with a\n// deterministic stream. It is exported from the file but deliberately absent from the barrel — the\n// \"internal\" signal in this repo is absence from `index.ts`, not a naming prefix.\n//\n// Note the scope boundary: this slice does NOT generate identifiers. `foundation/identifiers` owns UUID\n// generation (`Guid.createV4` / `Guid.createV7`) and should be used for entity ids — `randomString` is for\n// opaque tokens, nonces, and suffixes where a UUID's structure would be meaningless.\n\nimport { requireCrypto } from './WebCrypto';\n\n/**\n * Default alphabet: URL-safe base62 (`A-Z`, `a-z`, `0-9`). No `+/=~`, so a generated string is safe in a\n * path segment, a query value, a filename, and an HTML attribute without escaping.\n */\nexport const URL_SAFE_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n/** `getRandomValues` rejects a view longer than 65536 bytes, so larger requests are filled in passes. */\nconst MAX_BYTES_PER_CALL = 65_536;\n\n/**\n * Returns the exclusive upper bound for an unbiased byte: the largest multiple of `size` that fits in 256.\n * Bytes at or above it must be discarded — see the file header. Internal — not exported from the barrel.\n */\nexport function rejectionLimit(size: number): number {\n  return 256 - (256 % size);\n}\n\n/**\n * Fills `length` cryptographically secure random bytes. Requests above the platform's 65536-byte per-call\n * ceiling are filled in successive passes. **Throws** a `RangeError` on a negative or non-integer length,\n * and an `Error` when Web Crypto is unavailable — never falls back to `Math.random`.\n */\nexport function randomBytes(length: number): Uint8Array {\n  if (!Number.isInteger(length) || length < 0) {\n    throw new RangeError(`randomBytes: length must be a non-negative integer, got ${length}.`);\n  }\n\n  const source = requireCrypto();\n  const bytes = new Uint8Array(length);\n\n  for (let offset = 0; offset < length; offset += MAX_BYTES_PER_CALL) {\n    // `subarray` is a view over the same buffer, so each pass fills `bytes` in place.\n    source.getRandomValues(bytes.subarray(offset, Math.min(offset + MAX_BYTES_PER_CALL, length)));\n  }\n\n  return bytes;\n}\n\n/**\n * Builds a random string of `length` characters from `chars` using the byte stream `nextBytes`, discarding\n * biased bytes (see the file header). The injected source is what makes rejection testable. Internal — not\n * exported from the barrel; call {@link randomString} instead.\n */\nexport function randomStringFrom(\n  length: number,\n  chars: readonly string[],\n  nextBytes: (count: number) => Uint8Array,\n): string {\n  if (!Number.isInteger(length) || length < 0) {\n    throw new RangeError(`randomStringFrom: length must be a non-negative integer, got ${length}.`);\n  }\n\n  if (chars.length === 0 || chars.length > 256) {\n    throw new RangeError(\n      `randomStringFrom: alphabet must hold 1..256 characters, got ${chars.length}. A larger alphabet ` +\n        `cannot be sampled unbiasedly from a single byte.`,\n    );\n  }\n\n  if (length === 0) return '';\n\n  const size = chars.length;\n  const limit = rejectionLimit(size);\n  const picked: string[] = [];\n\n  while (picked.length < length) {\n    const needed = length - picked.length;\n\n    // Over-draw by the expected rejection rate plus a floor, so the common case is a single draw.\n    const bytes = nextBytes(needed + Math.ceil(needed / 4) + 8);\n    if (bytes.length === 0) {\n      throw new RangeError('randomStringFrom: the byte source returned no bytes.');\n    }\n\n    for (const byte of bytes) {\n      if (byte >= limit) continue; // Biased residue — discard rather than fold it in.\n      picked.push(chars[byte % size]!);\n      if (picked.length === length) break;\n    }\n  }\n\n  return picked.join('');\n}\n\n/**\n * Generates a random string of `length` characters, drawn uniformly from `alphabet` (default\n * {@link URL_SAFE_ALPHABET}) with rejection sampling — no modulo bias. Use it for opaque tokens, nonces, and\n * collision-resistant suffixes; use `Guid` from `foundation/identifiers` for entity identifiers.\n *\n * The alphabet is split by code point, so an emoji or astral-plane character counts as one character and is\n * never torn into surrogate halves. It must hold 1..256 code points; duplicated characters skew the result\n * proportionally and are the caller's responsibility.\n */\nexport function randomString(length: number, alphabet: string = URL_SAFE_ALPHABET): string {\n  return randomStringFrom(length, [...alphabet], randomBytes);\n}\n","// Constant-time byte comparison. Exists because `a === b` on a secret is a side channel: the engine's string\n// or array compare returns at the first differing byte, so how long the comparison took reveals how many\n// leading bytes matched. An attacker who can submit guesses and time the response recovers a token one byte\n// at a time — linear work instead of exponential.\n//\n// The fix is to look at every byte regardless: XOR each pair, OR the differences together, and decide once\n// at the end. No branch depends on the data.\n//\n// Length is folded into the same accumulator rather than checked up front with an early `return false`. An\n// early length check is a second, coarser side channel: it separates \"wrong length\" from \"right length,\n// wrong content\" by timing. Seeding the accumulator with `a.length ^ b.length` and walking to the longer of\n// the two collapses both outcomes onto the same path. (The loop bound still tracks the longer input — an\n// input's length is public in essentially every protocol, its *contents* are not.)\n//\n// HONEST LIMITATION, stated because this is security code: JavaScript cannot guarantee constant time. A JIT\n// may deoptimize, bounds checks and `?? 0` are engine-dependent, GC can pause mid-loop, and the runtime is\n// free to reorder. This is a best-effort mitigation that removes the *obvious* early-exit leak, not a\n// hardware guarantee like a constant-time assembly routine. High-value secrets should be compared\n// server-side (Node's `crypto.timingSafeEqual`, .NET's `CryptographicOperations.FixedTimeEquals`), not here.\n\n/**\n * Compares two byte arrays in (best-effort) constant time — no early exit on the first mismatch, and no\n * separate fast path for a length mismatch. Returns true only when both length and every byte match.\n *\n * Use it whenever one side is secret: a digest, an HMAC, a CSRF or session token, a signed URL parameter.\n * For plain non-secret data `===` on the hex form is fine and faster.\n *\n * To compare strings, encode both with `utf8ToBytes` first — a `string` overload is deliberately absent\n * because the encoding step's own timing would need the same care and hiding it here would suggest a\n * guarantee this cannot make. See the file header on what JS can and cannot promise.\n */\nexport function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean {\n  // Seeded with the length difference so a wrong-length input takes the same path as a wrong-content one.\n  let difference = a.length ^ b.length;\n\n  const span = Math.max(a.length, b.length);\n  for (let i = 0; i < span; i++) {\n    // `?? 0` covers the tail of the shorter array; under `noUncheckedIndexedAccess` it is also the honest\n    // type for an indexed read, so the guard and the type narrowing are the same expression.\n    difference |= (a[i] ?? 0) ^ (b[i] ?? 0);\n  }\n\n  return difference === 0;\n}\n","// Stable content hashing for arbitrary values — the \"cache key from a params object\" primitive.\n//\n// `JSON.stringify` is not usable for this directly: it emits keys in insertion order, so `{a:1,b:2}` and\n// `{b:2,a:1}` produce different strings and therefore different keys. Two call sites that build the same\n// query with their properties written in a different order then miss each other's cache entry forever. The\n// bug is invisible locally (one call site, one order) and shows up as a mysteriously low hit rate.\n//\n// So the value is rewritten into a canonical form first — object keys sorted at every depth, array order\n// preserved (order is semantic in an array, incidental in an object) — and only then stringified and\n// hashed.\n//\n// Behaviours that follow from delegating to `JSON.stringify`, documented rather than papered over:\n//  - `toJSON()` is honoured before sorting, so a `Date`/`Temporal` value canonicalizes to its ISO string\n//    instead of collapsing to `{}` the way a blind `Object.keys` walk would leave it.\n//  - `undefined`, functions, and symbol values disappear from objects; `Map`/`Set` hash as `{}`. Feed\n//    plain data, or map those types yourself before hashing.\n//  - A circular reference throws a `TypeError`. The same object appearing twice in a DAG is fine — only a\n//    true cycle is rejected — because the guard is unwound on the way back out.\n//\n// `hashObject` is async and needs `crypto.subtle` (see `WebCrypto.ts`). `stableStringify` is pure and works\n// anywhere, and is exported in its own right: it is often all a caller needs for an in-memory `Map` key,\n// where the digest is pure overhead.\n\nimport { sha256Hex } from './Digest';\n\n/** Recursively canonicalizes a value: `toJSON` first, arrays in order, object keys sorted. `seen` rejects cycles. */\nfunction canonicalize(value: unknown, seen: WeakSet<object>): unknown {\n  if (value === null || typeof value !== 'object') return value;\n\n  // Checked before the object is registered, so a `toJSON` that returns its own receiver terminates here\n  // rather than recursing forever.\n  if (seen.has(value)) {\n    throw new TypeError('stableStringify: circular reference — a value cannot contain itself.');\n  }\n\n  seen.add(value);\n\n  const canonical = canonicalizeObject(value, seen);\n\n  // Unwound so a repeated (but non-cyclic) reference stays legal.\n  seen.delete(value);\n\n  return canonical;\n}\n\n/** Canonicalizes the object cases of {@link canonicalize}, with `value` already registered in `seen`. */\nfunction canonicalizeObject(value: object, seen: WeakSet<object>): unknown {\n  const serializable = value as { toJSON?: () => unknown };\n  if (typeof serializable.toJSON === 'function') {\n    return canonicalize(serializable.toJSON(), seen);\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item: unknown) => canonicalize(item, seen));\n  }\n\n  const record = value as Record<string, unknown>;\n\n  return Object.fromEntries(\n    Object.keys(record)\n      .sort()\n      .map((key): [string, unknown] => [key, canonicalize(record[key], seen)]),\n  );\n}\n\n/**\n * Serializes `value` to JSON with object keys sorted at every depth, so two structurally equal values\n * always produce the same string regardless of property insertion order. Array order is preserved.\n *\n * Pure and synchronous — usable under SSR and as an in-memory `Map` key without hashing. Returns the\n * literal `'undefined'` for an input `JSON.stringify` would drop entirely (`undefined`, a function, a\n * symbol), so the result is always a string. **Throws a `TypeError`** on a circular reference.\n */\nexport function stableStringify(value: unknown): string {\n  return JSON.stringify(canonicalize(value, new WeakSet())) ?? 'undefined';\n}\n\n/**\n * Hashes any JSON-serializable value to a lowercase 64-char SHA-256 hex string, order-independently:\n * `{ a: 1, b: 2 }` and `{ b: 2, a: 1 }` produce the same hash at any nesting depth. The canonical cache key\n * for a params object, a filter set, or a request body.\n *\n * Async and requires a secure context — see {@link stableStringify} for the pure, sync alternative, and\n * `isSubtleAvailable()` to probe before calling.\n */\nexport function hashObject(value: unknown): Promise<string> {\n  return sha256Hex(stableStringify(value));\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/crypto/WebCrypto.ts","../../../src/foundation/crypto/Encoding.ts","../../../src/foundation/crypto/Digest.ts","../../../src/foundation/crypto/Random.ts","../../../src/foundation/crypto/TimingSafeEqual.ts","../../../src/foundation/crypto/HashObject.ts"],"sourcesContent":["// Web Crypto resolution + capability probes — the single place this slice reads the ambient\n// `globalThis.crypto`. Isolated for two reasons.\n//\n// 1. The two capabilities fail INDEPENDENTLY, so they must be probed separately. `crypto.getRandomValues`\n//    is available in every modern runtime, secure context or not; `crypto.subtle` is available ONLY in a\n//    secure context (https, localhost, or a file/extension origin) and is `undefined` on a plain `http://`\n//    page served from a LAN IP — a setup that looks fine in dev and breaks on a staging box. Collapsing\n//    both into one \"crypto available\" flag would report random-byte generation as broken whenever digests\n//    are, and vice versa.\n// 2. The global is read at CALL time, never cached at module scope. Caching would freeze an `undefined`\n//    captured during SSR/hydration into the module for the page's lifetime, and would block a test from\n//    stubbing `globalThis.crypto` to exercise a failure path.\n//\n// SSR contract for the whole slice, stated once here and echoed on each consumer: the pure helpers\n// (`Encoding`, `timingSafeEqual`) never touch this file and run anywhere — SSR, workers, insecure origins.\n// The digest and random helpers THROW at the call site when their capability is missing, rather than\n// returning a sentinel: a silently unhashed value or a non-random \"random\" byte is a security defect that\n// a fallback would hide, so failing loudly is the only safe default. Callers that must branch instead of\n// catch use `isCryptoAvailable()` / `isSubtleAvailable()`.\n\n/** Reads the ambient Web Crypto object, or `undefined` when the runtime has none (older SSR hosts, sandboxes). */\nfunction resolveCrypto(): Crypto | undefined {\n  // Widened through an optional-property view: `globalThis.crypto` is typed non-optional by lib.dom, so a\n  // direct `=== undefined` check would be a TS2367 \"no overlap\" error even though it is exactly the case\n  // this function exists to handle.\n  return (globalThis as { crypto?: Crypto }).crypto;\n}\n\n/** Reads the ambient `SubtleCrypto`, or `undefined` when absent — no Web Crypto at all, or an insecure context. */\nfunction resolveSubtle(): SubtleCrypto | undefined {\n  const source = resolveCrypto();\n  if (source === undefined) return undefined;\n\n  // Same widening rationale as `resolveCrypto`: `Crypto.subtle` is typed non-optional but is genuinely\n  // absent outside a secure context.\n  return (source as { subtle?: SubtleCrypto }).subtle;\n}\n\n/**\n * Reports whether `crypto.getRandomValues` can be called — i.e. whether {@link randomBytes} and\n * {@link randomString} will succeed. True in every browser and in Node 19+, including insecure contexts.\n */\nexport function isCryptoAvailable(): boolean {\n  return typeof resolveCrypto()?.getRandomValues === 'function';\n}\n\n/**\n * Reports whether `crypto.subtle` can be called — i.e. whether the digest helpers will succeed. False\n * outside a **secure context** (plain `http://` on a non-localhost host) even when {@link isCryptoAvailable}\n * is true. Probe this before offering a hash-dependent feature rather than catching the throw.\n */\nexport function isSubtleAvailable(): boolean {\n  return typeof resolveSubtle()?.digest === 'function';\n}\n\n/** Returns the ambient `Crypto`, throwing a diagnostic `Error` when unavailable. Internal — not barrelled. */\nexport function requireCrypto(): Crypto {\n  const source = resolveCrypto();\n  if (source === undefined || typeof source.getRandomValues !== 'function') {\n    throw new Error(\n      'Web Crypto is unavailable: `globalThis.crypto.getRandomValues` is not a function. This runtime ' +\n        'cannot produce cryptographically secure bytes — guard the call with `isCryptoAvailable()`.',\n    );\n  }\n\n  return source;\n}\n\n/** Returns the ambient `SubtleCrypto`, throwing a diagnostic `Error` when unavailable. Internal — not barrelled. */\nexport function requireSubtle(): SubtleCrypto {\n  const subtle = resolveSubtle();\n  if (subtle === undefined || typeof subtle.digest !== 'function') {\n    throw new Error(\n      'Web Crypto `subtle` is unavailable: `globalThis.crypto.subtle` is undefined. `crypto.subtle` is ' +\n        'exposed only in a secure context (https, localhost, or a file/extension origin) — an `http://` ' +\n        'page on a LAN host has `crypto.getRandomValues` but no `subtle`. Guard with `isSubtleAvailable()`.',\n    );\n  }\n\n  return subtle;\n}\n","// Byte <-> text codecs: hex, base64, base64url, UTF-8. Pure and synchronous, touching no Web Crypto at\n// all — so every helper here runs under SSR, in a worker, and on an insecure origin, unlike the digest and\n// random helpers. This is the slice's floor: a digest returns bytes, and bytes are unreadable until one of\n// these renders them (ETag header, cache key, checksum shown to a user).\n//\n// Decisions worth stating:\n//  - Decoders are STRICT — malformed input throws a `TypeError`, never a best-effort result. A digest that\n//    silently mis-decodes compares unequal forever and the bug surfaces far from its cause; a throw is\n//    found on the first run. Both `hexToBytes` and `base64ToBytes` validate the full string shape BEFORE\n//    any conversion, so a partial result is never produced.\n//  - base64url is a first-class pair, not a `.replace()` applied to base64 output at each call site. JWT\n//    segments, URL query values, and filename-safe keys all need `-_` and no `=`, and the padding handling\n//    is exactly where the hand-rolled version goes wrong.\n//  - `btoa`/`atob` do the base64 work rather than a hand-rolled table: both are present in every runtime we\n//    target (browsers, Node 16+, workers, Deno/Bun) and are far faster than a JS loop. Their leniency is\n//    what the validation above wraps — by the time they are called the input is known-good.\n//  - `bytesToBase64` chunks its input. `String.fromCharCode(...bytes)` on a multi-MB array overflows the\n//    argument stack (`RangeError: Maximum call stack size exceeded`) — a bug that only appears on large\n//    files, i.e. in production.\n//  - `bytesToUtf8` is LENIENT: invalid sequences become U+FFFD, `TextDecoder`'s default. That matches what\n//    a caller rendering a payload expects. It also makes UTF-8 a lossy round-trip for arbitrary binary by\n//    definition — hash bytes must go through hex or base64, never through this.\n\n/**\n * Precomputed byte -> 2-char lowercase hex, so `bytesToHex` is a table lookup rather than a per-byte\n * `toString(16).padStart`.\n */\nconst HexByByte = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n\n/** Matches an even-length run of hex digits (either case), including the empty string. */\nconst HexString = /^(?:[0-9a-fA-F]{2})*$/;\n\n/**\n * Matches canonical standard base64: whole 4-char groups, then an optional 2- or 3-char tail with correct\n * padding. Rejects a lone trailing char (`{4}n+1` is not a reachable length), over-padding (`YQ===`), and\n * any character outside the standard alphabet — including whitespace and the base64url `-_`.\n */\nconst Base64String = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/;\n\n/** The base64url counterpart of {@link Base64String} — `-_` for `+/`. Padding tolerated on input, never emitted. */\nconst Base64UrlString = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2}(?:==)?|[A-Za-z0-9_-]{3}=?)?$/;\n\n/** Largest slice fed to `String.fromCharCode(...)` at once — keeps the spread under the engine argument limit. */\nconst FromCharCodeChunk = 0x8000;\n\n/**\n * Shared UTF-8 encoder. `TextEncoder` is part of the Encoding standard, present in every target runtime\n * (including SSR), so module-scope construction is safe.\n */\nconst Utf8Encoder = new TextEncoder();\n\n/** Shared UTF-8 decoder, lenient by default — see the file header on why `fatal` is not set. */\nconst Utf8Decoder = new TextDecoder();\n\n/**\n * Renders bytes as a lowercase hex string (2 chars per byte, no separator) — the canonical way to show a\n * digest, an ETag, or a checksum. Inverse of {@link hexToBytes}.\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  let hex = '';\n  for (const byte of bytes) hex += HexByByte[byte]!;\n  return hex;\n}\n\n/**\n * Parses a hex string into bytes, accepting either case. **Throws a `TypeError`** when the input has an odd\n * length or contains a non-hex character — a half-parsed digest is never returned. Inverse of\n * {@link bytesToHex}.\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (HexString.exec(hex)?.[0] !== hex) {\n    throw new TypeError(\n      `hexToBytes: expected an even-length string of hex digits, got \"${hex}\" (length ${hex.length}).`,\n    );\n  }\n\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);\n  }\n\n  return bytes;\n}\n\n/**\n * Encodes bytes as standard, padded base64 (`+`, `/`, `=`). Safe for arbitrarily large inputs — the source\n * is walked in chunks. Inverse of {@link base64ToBytes}; for URL or JWT contexts use\n * {@link bytesToBase64Url}.\n */\nexport function bytesToBase64(bytes: Uint8Array): string {\n  let binary = '';\n  for (let offset = 0; offset < bytes.length; offset += FromCharCodeChunk) {\n    binary += String.fromCharCode(...bytes.subarray(offset, offset + FromCharCodeChunk));\n  }\n\n  return btoa(binary);\n}\n\n/**\n * Decodes standard base64 into bytes. Padding may be present or omitted, but the string must otherwise be\n * canonical: **throws a `TypeError`** on any character outside `A-Za-z0-9+/=` (whitespace and the base64url\n * `-_` included), on over-padding, and on an impossible length. Inverse of {@link bytesToBase64}.\n */\nexport function base64ToBytes(base64: string): Uint8Array {\n  if (Base64String.exec(base64)?.[0] !== base64) {\n    throw new TypeError(\n      `base64ToBytes: expected a canonical standard-base64 string (alphabet A-Za-z0-9+/ with optional ` +\n        `= padding), got \"${base64}\".`,\n    );\n  }\n\n  const binary = atob(base64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < bytes.length; i++) bytes[i] = binary.charCodeAt(i);\n\n  return bytes;\n}\n\n/**\n * Encodes bytes as **unpadded** base64url (RFC 4648 §5) — `-_` in place of `+/`, no `=`. This is the form a\n * JWT segment, a URL query value, and a filename-safe cache key all require. Inverse of\n * {@link base64UrlToBytes}.\n */\nexport function bytesToBase64Url(bytes: Uint8Array): string {\n  return bytesToBase64(bytes).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n/**\n * Decodes base64url into bytes, tolerating the padding that {@link bytesToBase64Url} never emits (some\n * producers add it). **Throws a `TypeError`** on any character outside `A-Za-z0-9-_=` — notably on the\n * standard-base64 `+` and `/`, which signal that {@link base64ToBytes} was the intended decoder.\n */\nexport function base64UrlToBytes(base64Url: string): Uint8Array {\n  if (Base64UrlString.exec(base64Url)?.[0] !== base64Url) {\n    throw new TypeError(\n      `base64UrlToBytes: expected a base64url string (alphabet A-Za-z0-9-_ with optional = padding), got ` +\n        `\"${base64Url}\".`,\n    );\n  }\n\n  const standard = base64Url.replace(/-/g, '+').replace(/_/g, '/');\n\n  // Re-pad to a 4-char boundary: `atob` accepts unpadded input, but re-padding keeps this on the exact\n  // path `base64ToBytes` validates rather than relying on that leniency.\n  const padding = standard.length % 4 === 0 ? '' : '='.repeat(4 - (standard.length % 4));\n\n  return base64ToBytes(standard + padding);\n}\n\n/**\n * Encodes a string to its UTF-8 bytes — the normalization every digest of a string goes through.\n * Inverse of {@link bytesToUtf8}.\n */\nexport function utf8ToBytes(text: string): Uint8Array {\n  return Utf8Encoder.encode(text);\n}\n\n/**\n * Decodes UTF-8 bytes back to a string. **Lenient**: an invalid sequence becomes U+FFFD rather than\n * throwing, so this is lossy for arbitrary binary — render digest bytes with {@link bytesToHex} or\n * {@link bytesToBase64} instead. Inverse of {@link utf8ToBytes} for any real text.\n */\nexport function bytesToUtf8(bytes: Uint8Array): string {\n  return Utf8Decoder.decode(bytes);\n}\n","// Cryptographic digests over `crypto.subtle`. Async and non-negotiably so — `SubtleCrypto.digest` returns a\n// promise, and there is no synchronous hash in the platform. A caller that needs a hash inside a render pass\n// must compute it in an effect and hold the result in state; do not go looking for a sync variant.\n//\n// Decisions worth stating:\n//  - The input type is widened to `string | ArrayBuffer | Uint8Array` and normalized here, because every\n//    call site otherwise repeats the same `new TextEncoder().encode(...)` line and they eventually disagree\n//    about encoding. Strings are always UTF-8 — the only encoding that makes a digest reproducible across a\n//    JS client and a .NET backend computing the same hash.\n//  - Bytes are returned, not hex. A digest's natural type is bytes: `timingSafeEqual` consumes them\n//    directly, and the caller picks the rendering (`bytesToHex` for an ETag, `bytesToBase64` for a\n//    `Content-Digest` header). `sha256Hex` exists because hex is the common case and chaining two calls for\n//    it is noise.\n//  - SHA-1 is exposed despite being broken for signatures. It is still the correct tool for a non-adversarial\n//    checksum and, more to the point, for interoperating with systems that already speak it (git object ids,\n//    legacy ETags). Its JSDoc says so; picking it for anything security-bearing is the call site's error.\n//  - `crypto.subtle` is absent outside a secure context, so every function here throws at the call site when\n//    it is missing — see `WebCrypto.ts` for the full contract and `isSubtleAvailable()` for the probe.\n\nimport { bytesToHex, utf8ToBytes } from './Encoding';\nimport { requireSubtle } from './WebCrypto';\n\n/** Accepted digest input: a UTF-8-encoded string, a raw `ArrayBuffer`, or an existing byte view. */\nexport type BinaryInput = string | ArrayBuffer | Uint8Array;\n\n/** A hash algorithm `crypto.subtle.digest` implements. SHA-256 is the default; SHA-1 is checksum/interop only. */\nexport const DigestAlgorithm = {\n  /** Names the 160-bit SHA-1 digest — broken for signatures, correct for checksums and git-style interop. */\n  Sha1: 'SHA-1',\n\n  /** Names the 256-bit SHA-2 digest — the default for cache keys, content hashes, and ETags. */\n  Sha256: 'SHA-256',\n\n  /** Names the 384-bit SHA-2 digest — a truncated SHA-512, for callers pinned to a 48-byte width. */\n  Sha384: 'SHA-384',\n\n  /** Names the 512-bit SHA-2 digest — the widest the platform implements. */\n  Sha512: 'SHA-512',\n} as const;\n\n/** A hash algorithm `crypto.subtle.digest` implements. SHA-256 is the default; SHA-1 is checksum/interop only. */\nexport type DigestAlgorithm = (typeof DigestAlgorithm)[keyof typeof DigestAlgorithm];\n\n/** Normalizes any {@link BinaryInput} to bytes; strings become UTF-8. Internal — not exported from the barrel. */\nexport function toBytes(data: BinaryInput): Uint8Array {\n  if (typeof data === 'string') return utf8ToBytes(data);\n  if (data instanceof Uint8Array) return data;\n  return new Uint8Array(data);\n}\n\n/**\n * Hashes `data` with the named algorithm and resolves to the raw digest bytes — the general form the named\n * helpers below wrap. **Throws** synchronously when `crypto.subtle` is unavailable (insecure context).\n */\nexport async function digest(algorithm: DigestAlgorithm, data: BinaryInput): Promise<Uint8Array> {\n  const subtle = requireSubtle();\n\n  // TS 5.7 made `Uint8Array` generic over its backing buffer and narrowed `BufferSource` to\n  // `ArrayBufferView<ArrayBuffer>`, which excludes the `SharedArrayBuffer`-backed views the default\n  // `Uint8Array<ArrayBufferLike>` still admits. `subtle.digest` reads any byte view at runtime, so this\n  // widens the static type without changing behaviour — and without narrowing what callers may pass in.\n  const hashed = await subtle.digest(algorithm, toBytes(data) as BufferSource);\n\n  return new Uint8Array(hashed);\n}\n\n/** Computes the SHA-256 digest of `data` (32 bytes) — the default hash for cache keys, ETags, content addressing. */\nexport function sha256(data: BinaryInput): Promise<Uint8Array> {\n  return digest(DigestAlgorithm.Sha256, data);\n}\n\n/**\n * Computes the SHA-1 digest of `data` (20 bytes). **Not collision-resistant** — use it only for\n * non-adversarial checksums or to interoperate with a system that already speaks SHA-1 (git, legacy ETags).\n * Reach for {@link sha256} everywhere else.\n */\nexport function sha1(data: BinaryInput): Promise<Uint8Array> {\n  return digest(DigestAlgorithm.Sha1, data);\n}\n\n/** Computes the SHA-384 digest of `data` (48 bytes) — the truncated SHA-512 variant used by subresource integrity. */\nexport function sha384(data: BinaryInput): Promise<Uint8Array> {\n  return digest(DigestAlgorithm.Sha384, data);\n}\n\n/** Computes the SHA-512 digest of `data` (64 bytes) — wider margin than SHA-256, and faster on 64-bit hardware. */\nexport function sha512(data: BinaryInput): Promise<Uint8Array> {\n  return digest(DigestAlgorithm.Sha512, data);\n}\n\n/**\n * Computes the SHA-256 digest of `data` as a lowercase 64-char hex string — the ready-to-print form for an ETag\n * or cache key.\n */\nexport async function sha256Hex(data: BinaryInput): Promise<string> {\n  return bytesToHex(await sha256(data));\n}\n","// Cryptographically secure randomness over `crypto.getRandomValues`. Available in insecure contexts too, so\n// this works where the digest helpers do not — see `WebCrypto.ts` for the split.\n//\n// The one non-obvious thing in this file is **modulo-bias rejection sampling**, and it is the reason\n// `randomString` exists at all rather than being a two-line snippet at each call site. The naive form\n//\n//     alphabet[randomByte % alphabet.length]\n//\n// is skewed. A byte is uniform over 0..255 — 256 values. With a 62-char alphabet, 256 = 4x62 + 8, so the\n// residues 0..7 are each reachable from 5 bytes while residues 8..61 are reachable from only 4. The first\n// 8 characters of the alphabet come up ~25% more often than the rest. That is invisible in a smoke test and\n// measurable by an attacker over enough samples, which is precisely the wrong failure shape for a token.\n//\n// The fix: discard every byte at or above the largest multiple of the alphabet size that fits in 256\n// (`rejectionLimit`), and only then take the modulo. For 62 that limit is 248, so bytes 248..255 are thrown\n// away and the remaining 248 map 4-to-1 onto 62 characters — exactly uniform. The cost is a re-draw for\n// ~3% of bytes, which is why the generator over-draws and loops instead of asking for exactly `length`.\n//\n// `randomStringFrom` takes its byte source as a parameter so the rejection path is testable with a\n// deterministic stream. It is exported from the file but deliberately absent from the barrel — the\n// \"internal\" signal in this repo is absence from `index.ts`, not a naming prefix.\n//\n// Note the scope boundary: this slice does NOT generate identifiers. `foundation/identifiers` owns UUID\n// generation (`Guid.createV4` / `Guid.createV7`) and should be used for entity ids — `randomString` is for\n// opaque tokens, nonces, and suffixes where a UUID's structure would be meaningless.\n\nimport { requireCrypto } from './WebCrypto';\n\n/**\n * Default alphabet: URL-safe base62 (`A-Z`, `a-z`, `0-9`). No `+/=~`, so a generated string is safe in a\n * path segment, a query value, a filename, and an HTML attribute without escaping.\n */\nexport const UrlSafeAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n/** `getRandomValues` rejects a view longer than 65536 bytes, so larger requests are filled in passes. */\nconst MaxBytesPerCall = 65_536;\n\n/**\n * Returns the exclusive upper bound for an unbiased byte: the largest multiple of `size` that fits in 256.\n * Bytes at or above it must be discarded — see the file header. Internal — not exported from the barrel.\n */\nexport function rejectionLimit(size: number): number {\n  return 256 - (256 % size);\n}\n\n/**\n * Fills `length` cryptographically secure random bytes. Requests above the platform's 65536-byte per-call\n * ceiling are filled in successive passes. **Throws** a `RangeError` on a negative or non-integer length,\n * and an `Error` when Web Crypto is unavailable — never falls back to `Math.random`.\n */\nexport function randomBytes(length: number): Uint8Array {\n  if (!Number.isInteger(length) || length < 0) {\n    throw new RangeError(`randomBytes: length must be a non-negative integer, got ${length}.`);\n  }\n\n  const source = requireCrypto();\n  const bytes = new Uint8Array(length);\n\n  for (let offset = 0; offset < length; offset += MaxBytesPerCall) {\n    // `subarray` is a view over the same buffer, so each pass fills `bytes` in place.\n    source.getRandomValues(bytes.subarray(offset, Math.min(offset + MaxBytesPerCall, length)));\n  }\n\n  return bytes;\n}\n\n/**\n * Builds a random string of `length` characters from `chars` using the byte stream `nextBytes`, discarding\n * biased bytes (see the file header). The injected source is what makes rejection testable. Internal — not\n * exported from the barrel; call {@link randomString} instead.\n */\nexport function randomStringFrom(\n  length: number,\n  chars: ReadonlyArray<string>,\n  nextBytes: (count: number) => Uint8Array,\n): string {\n  if (!Number.isInteger(length) || length < 0) {\n    throw new RangeError(`randomStringFrom: length must be a non-negative integer, got ${length}.`);\n  }\n\n  if (chars.length === 0 || chars.length > 256) {\n    throw new RangeError(\n      `randomStringFrom: alphabet must hold 1..256 characters, got ${chars.length}. A larger alphabet ` +\n        `cannot be sampled unbiasedly from a single byte.`,\n    );\n  }\n\n  if (length === 0) return '';\n\n  const size = chars.length;\n  const limit = rejectionLimit(size);\n  const picked: string[] = [];\n\n  while (picked.length < length) {\n    const needed = length - picked.length;\n\n    // Over-draw by the expected rejection rate plus a floor, so the common case is a single draw.\n    const bytes = nextBytes(needed + Math.ceil(needed / 4) + 8);\n    if (bytes.length === 0) {\n      throw new RangeError('randomStringFrom: the byte source returned no bytes.');\n    }\n\n    for (const byte of bytes) {\n      if (byte >= limit) continue; // Biased residue — discard rather than fold it in.\n      picked.push(chars[byte % size]!);\n      if (picked.length === length) break;\n    }\n  }\n\n  return picked.join('');\n}\n\n/**\n * Generates a random string of `length` characters, drawn uniformly from `alphabet` (default\n * {@link UrlSafeAlphabet}) with rejection sampling — no modulo bias. Use it for opaque tokens, nonces, and\n * collision-resistant suffixes; use `Guid` from `foundation/identifiers` for entity identifiers.\n *\n * The alphabet is split by code point, so an emoji or astral-plane character counts as one character and is\n * never torn into surrogate halves. It must hold 1..256 code points; duplicated characters skew the result\n * proportionally and are the caller's responsibility.\n */\nexport function randomString(length: number, alphabet: string = UrlSafeAlphabet): string {\n  return randomStringFrom(length, [...alphabet], randomBytes);\n}\n","// Constant-time byte comparison. Exists because `a === b` on a secret is a side channel: the engine's string\n// or array compare returns at the first differing byte, so how long the comparison took reveals how many\n// leading bytes matched. An attacker who can submit guesses and time the response recovers a token one byte\n// at a time — linear work instead of exponential.\n//\n// The fix is to look at every byte regardless: XOR each pair, OR the differences together, and decide once\n// at the end. No branch depends on the data.\n//\n// Length is folded into the same accumulator rather than checked up front with an early `return false`. An\n// early length check is a second, coarser side channel: it separates \"wrong length\" from \"right length,\n// wrong content\" by timing. Seeding the accumulator with `a.length ^ b.length` and walking to the longer of\n// the two collapses both outcomes onto the same path. (The loop bound still tracks the longer input — an\n// input's length is public in essentially every protocol, its *contents* are not.)\n//\n// HONEST LIMITATION, stated because this is security code: JavaScript cannot guarantee constant time. A JIT\n// may deoptimize, bounds checks and `?? 0` are engine-dependent, GC can pause mid-loop, and the runtime is\n// free to reorder. This is a best-effort mitigation that removes the *obvious* early-exit leak, not a\n// hardware guarantee like a constant-time assembly routine. High-value secrets should be compared\n// server-side (Node's `crypto.timingSafeEqual`, .NET's `CryptographicOperations.FixedTimeEquals`), not here.\n\n/**\n * Compares two byte arrays in (best-effort) constant time — no early exit on the first mismatch, and no\n * separate fast path for a length mismatch. Returns true only when both length and every byte match.\n *\n * Use it whenever one side is secret: a digest, an HMAC, a CSRF or session token, a signed URL parameter.\n * For plain non-secret data `===` on the hex form is fine and faster.\n *\n * To compare strings, encode both with `utf8ToBytes` first — a `string` overload is deliberately absent\n * because the encoding step's own timing would need the same care and hiding it here would suggest a\n * guarantee this cannot make. See the file header on what JS can and cannot promise.\n */\nexport function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean {\n  // Seeded with the length difference so a wrong-length input takes the same path as a wrong-content one.\n  let difference = a.length ^ b.length;\n\n  const span = Math.max(a.length, b.length);\n  for (let i = 0; i < span; i++) {\n    // `?? 0` covers the tail of the shorter array; under `noUncheckedIndexedAccess` it is also the honest\n    // type for an indexed read, so the guard and the type narrowing are the same expression.\n    difference |= (a[i] ?? 0) ^ (b[i] ?? 0);\n  }\n\n  return difference === 0;\n}\n","// Stable content hashing for arbitrary values — the \"cache key from a params object\" primitive.\n//\n// `JSON.stringify` is not usable for this directly: it emits keys in insertion order, so `{a:1,b:2}` and\n// `{b:2,a:1}` produce different strings and therefore different keys. Two call sites that build the same\n// query with their properties written in a different order then miss each other's cache entry forever. The\n// bug is invisible locally (one call site, one order) and shows up as a mysteriously low hit rate.\n//\n// So the value is rewritten into a canonical form first — object keys sorted at every depth, array order\n// preserved (order is semantic in an array, incidental in an object) — and only then stringified and\n// hashed.\n//\n// Behaviours that follow from delegating to `JSON.stringify`, documented rather than papered over:\n//  - `toJSON()` is honoured before sorting, so a `Date`/`Temporal` value canonicalizes to its ISO string\n//    instead of collapsing to `{}` the way a blind `Object.keys` walk would leave it.\n//  - `undefined`, functions, and symbol values disappear from objects; `Map`/`Set` hash as `{}`. Feed\n//    plain data, or map those types yourself before hashing.\n//  - A circular reference throws a `TypeError`. The same object appearing twice in a DAG is fine — only a\n//    true cycle is rejected — because the guard is unwound on the way back out.\n//\n// `hashObject` is async and needs `crypto.subtle` (see `WebCrypto.ts`). `stableStringify` is pure and works\n// anywhere, and is exported in its own right: it is often all a caller needs for an in-memory `Map` key,\n// where the digest is pure overhead.\n\nimport { sha256Hex } from './Digest';\n\n/** Recursively canonicalizes a value: `toJSON` first, arrays in order, object keys sorted. `seen` rejects cycles. */\nfunction canonicalize(value: unknown, seen: WeakSet<object>): unknown {\n  if (value === null || typeof value !== 'object') return value;\n\n  // Checked before the object is registered, so a `toJSON` that returns its own receiver terminates here\n  // rather than recursing forever.\n  if (seen.has(value)) {\n    throw new TypeError('stableStringify: circular reference — a value cannot contain itself.');\n  }\n\n  seen.add(value);\n\n  const canonical = canonicalizeObject(value, seen);\n\n  // Unwound so a repeated (but non-cyclic) reference stays legal.\n  seen.delete(value);\n\n  return canonical;\n}\n\n/** Canonicalizes the object cases of {@link canonicalize}, with `value` already registered in `seen`. */\nfunction canonicalizeObject(value: object, seen: WeakSet<object>): unknown {\n  const serializable = value as { toJSON?: () => unknown };\n  if (typeof serializable.toJSON === 'function') {\n    return canonicalize(serializable.toJSON(), seen);\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item: unknown) => canonicalize(item, seen));\n  }\n\n  const record = value as Record<string, unknown>;\n\n  return Object.fromEntries(\n    Object.keys(record)\n      .sort()\n      .map((key): [string, unknown] => [key, canonicalize(record[key], seen)]),\n  );\n}\n\n/**\n * Serializes `value` to JSON with object keys sorted at every depth, so two structurally equal values\n * always produce the same string regardless of property insertion order. Array order is preserved.\n *\n * Pure and synchronous — usable under SSR and as an in-memory `Map` key without hashing. Returns the\n * literal `'undefined'` for an input `JSON.stringify` would drop entirely (`undefined`, a function, a\n * symbol), so the result is always a string. **Throws a `TypeError`** on a circular reference.\n */\nexport function stableStringify(value: unknown): string {\n  return JSON.stringify(canonicalize(value, new WeakSet())) ?? 'undefined';\n}\n\n/**\n * Hashes any JSON-serializable value to a lowercase 64-char SHA-256 hex string, order-independently:\n * `{ a: 1, b: 2 }` and `{ b: 2, a: 1 }` produce the same hash at any nesting depth. The canonical cache key\n * for a params object, a filter set, or a request body.\n *\n * Async and requires a secure context — see {@link stableStringify} for the pure, sync alternative, and\n * `isSubtleAvailable()` to probe before calling.\n */\nexport function hashObject(value: unknown): Promise<string> {\n  return sha256Hex(stableStringify(value));\n}\n"],"names":[],"mappings":"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"}

package/dist/foundation/datetime/Comparison.d.ts

@@ -32,9 +32,9 @@ export declare function isPast(date: Date, now?: Date): boolean;
 /** True when `date` is strictly after `now` (defaults to the current clock; inject for tests). */
 export declare function isFuture(date: Date, now?: Date): boolean;
 /** Returns a copy of the earliest of the given dates. Invalid dates are ignored unless all of them are. */
-export declare function minDate(first: Date, ...rest: readonly Date[]): Date;
+export declare function minDate(first: Date, ...rest: ReadonlyArray<Date>): Date;
 /** Returns a copy of the latest of the given dates. Invalid dates are ignored unless all of them are. */
-export declare function maxDate(first: Date, ...rest: readonly Date[]): Date;
+export declare function maxDate(first: Date, ...rest: ReadonlyArray<Date>): Date;
 /**
  * Returns a copy of `date` pulled inside `[min, max]`. Either bound may be omitted or `null` to leave
  * that side open. Bounds are applied low-then-high, so a caller-inverted pair (`min` after `max`)

package/dist/foundation/datetime/Internals.d.ts

@@ -1,11 +1,11 @@
 /** Milliseconds in one second. */
-export declare const MS_PER_SECOND = 1000;
+export declare const MsPerSecond = 1000;
 /** Milliseconds in one minute. */
-export declare const MS_PER_MINUTE = 60000;
+export declare const MsPerMinute = 60000;
 /** Milliseconds in one hour. */
-export declare const MS_PER_HOUR = 3600000;
+export declare const MsPerHour = 3600000;
 /** Milliseconds in one 24-hour period (nominal — a DST day is 23 or 25 hours). */
-export declare const MS_PER_DAY = 86400000;
+export declare const MsPerDay = 86400000;
 /** Copies a `Date` by timestamp. An invalid input yields an equally-invalid copy (`NaN` time). */
 export declare function cloneDate(date: Date): Date;
 /** Returns the length in days of `monthIndex` (0-11) in `year`, leap years included. */