{"version":3,"sources":["../src/index.ts","../src/cached-builtins.ts","../src/utils.ts","../src/freeze-shallow.ts","../src/freeze-deep-internal.ts","../src/deep-freeze.ts","../src/immutable-view-collection-wraps.ts","../src/immutable-view.ts","../src/immutable-collection-views.ts","../src/snapshot.ts","../src/secure-snapshot.ts","../src/tamper-evident.ts","../src/vault.ts","../src/verification.ts","../src/check-runtime-integrity.ts"],"sourcesContent":["// Freeze (in-place)\nexport { freezeShallow } from './freeze-shallow';\nexport { freezeShallow as default } from './freeze-shallow';\nexport { deepFreeze } from './deep-freeze';\n\n// View (Proxy, no clone)\nexport { immutableView, isImmutableView, assertImmutableView } from './immutable-view';\nexport { immutableMapView, immutableSetView } from './immutable-collection-views';\n\n// Snapshot (clone + freeze)\nexport { snapshot, lock } from './snapshot';\nexport { secureSnapshot } from './secure-snapshot';\nexport { tamperEvident } from './tamper-evident';\nexport type { TamperEvidentVault } from './tamper-evident';\n\n// Isolation (closure + copy-on-read)\nexport { vault } from './vault';\nexport type { Vault } from './vault';\n\n// Verification\nexport { isDeepFrozen, assertDeepFrozen } from './verification';\nexport { checkRuntimeIntegrity } from './check-runtime-integrity';\nexport type { IntegrityResult } from './check-runtime-integrity';\n\n// Types\nexport type { DeepReadonly, Freezable } from './types';\n","/**\n * Cached references to built-in methods.\n * Captured at module load time to prevent post-import tampering.\n *\n * If an attacker overrides Object.freeze AFTER constancy is imported,\n * the library still uses the original native implementation.\n */\n\nexport const _freeze = Object.freeze;\nexport const _isFrozen = Object.isFrozen;\nexport const _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nexport const _defineProperty = Object.defineProperty;\nexport const _create = Object.create;\nexport const _ownKeys = Reflect.ownKeys;\nexport const _isView = ArrayBuffer.isView;\nexport const _Proxy = Proxy;\n\ndeclare function structuredClone<T>(value: T): T;\nexport const _structuredClone = typeof structuredClone === 'function' ? structuredClone : undefined;\nexport const _jsonStringify = JSON.stringify;\nexport const _isArray = Array.isArray;\n\n// Reflect.* used by immutable-view.ts Proxy handler — cached so post-import\n// poison cannot subvert the view (audit V2/P4).\nexport const _reflectGet = Reflect.get;\nexport const _reflectHas = Reflect.has;\nexport const _reflectGetOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor;\nexport const _reflectGetPrototypeOf = Reflect.getPrototypeOf;\nexport const _reflectIsExtensible = Reflect.isExtensible;\n\n// Object.prototype own-keys fingerprint — captured at module load.\n// Used by checkRuntimeIntegrity to detect prototype pollution injections\n// such as `Object.prototype._leak = 'x'` (audit I5).\n// Stable alphabetical sort for fingerprinting. Uses localeCompare with a fixed\n// 'en-US' locale + variant sensitivity so results are consistent across machines\n// (default-locale calls would vary by runtime environment).\nexport const _fingerprintSort = (a: string, b: string): number =>\n  a.localeCompare(b, 'en-US', { sensitivity: 'variant' });\n\nexport const _objectPrototypeKeysFingerprint = _ownKeys(Object.prototype).length + ':' +\n  _ownKeys(Object.prototype).map(k => typeof k === 'symbol' ? k.description ?? 'sym' : String(k)).sort(_fingerprintSort).join(',');\n\n// Self-test: verify cached builtins work correctly at import time.\n// If builtins were tampered before import, this throws immediately.\n// Covers every captured binding actually used by the library (audit P1).\nconst _selfTest = _freeze({ a: 1 });\nif (!_isFrozen(_selfTest)) {\n  throw new Error('constancy: Object.freeze or Object.isFrozen is compromised — cannot guarantee immutability');\n}\nif (_jsonStringify({ a: 1 }) !== '{\"a\":1}') {\n  throw new Error('constancy: JSON.stringify is compromised — cannot guarantee fingerprint integrity');\n}\nif (_ownKeys(_selfTest).join(',') !== 'a') {\n  throw new Error('constancy: Reflect.ownKeys is compromised — cannot guarantee traversal integrity');\n}\nif (_getOwnPropertyDescriptor(_selfTest, 'a')?.value !== 1) {\n  throw new Error('constancy: Object.getOwnPropertyDescriptor is compromised');\n}\nif (_isArray([]) !== true) {\n  throw new Error('constancy: Array.isArray is compromised');\n}\nif (typeof _structuredClone === 'function') {\n  const _probe = _structuredClone({ a: 1 });\n  if (_probe.a !== 1) {\n    throw new Error('constancy: structuredClone is compromised');\n  }\n}\n","/**\n * Check if value is freezable (object or function, not null/undefined).\n */\nexport function isFreezable(val: unknown): val is object | Function {\n  if (val === null || val === undefined) return false;\n  const t = typeof val;\n  return t === 'object' || t === 'function';\n}\n","import { _freeze } from './cached-builtins';\nimport { isFreezable } from './utils';\n\n/**\n * Shallow-freeze a value. Primitives returned unchanged.\n * Objects/functions frozen via Object.freeze().\n *\n * @param val - Value to freeze\n * @returns Frozen value (Readonly<T> for objects) or primitive unchanged\n *\n * @example\n * const frozen = constancy({ a: 1 });\n * // frozen.a = 2; // TypeError in strict mode\n */\nexport function freezeShallow<T>(val: T): T extends object ? Readonly<T> : T {\n  if (!isFreezable(val)) {\n    return val as any;\n  }\n  return _freeze(val) as any;\n}\n","/**\n * Shared internal helpers: recursive freeze + deep clone.\n * Used by deepFreeze(), snapshot(), vault(), and tamperEvident().\n */\nimport {\n  _freeze,\n  _ownKeys,\n  _getOwnPropertyDescriptor,\n  _isView,\n  _structuredClone,\n} from './cached-builtins';\nimport { isFreezable } from './utils';\n\n/**\n * Deep clone via cached structuredClone. Requires Node >= 18 or modern browser.\n * Preserves: Date, Map, Set, RegExp, ArrayBuffer, circular refs, TypedArrays.\n * Throws TypeError for non-cloneable values (functions, Symbols, DOM nodes).\n */\nexport function deepClone<T>(value: T): T {\n  if (typeof _structuredClone !== 'function') {\n    throw new TypeError('deepClone: structuredClone is not available in this runtime');\n  }\n  try {\n    return _structuredClone(value);\n  } catch (err) {\n    if ((err as Error)?.name === 'DataCloneError') {\n      throw new TypeError(\n        `deepClone: value contains non-cloneable data (functions, Symbols, DOM nodes). ` +\n        `Use immutableView() for non-cloneable objects, or remove non-cloneable properties first.`\n      );\n    }\n    throw err;\n  }\n}\n\n/** Recursively freeze an object graph; guards circular refs via WeakSet.\n *  Skips: TypedArray byte data, accessor (getter/setter) properties,\n *  Map/Set internal slots. See deepFreeze() JSDoc.\n *\n *  @param freezePrototypeChain — when true, also freezes the prototype of each\n *    visited object. Blocks post-freeze prototype poisoning (audit F1). Never\n *    freezes the canonical Object.prototype / Function.prototype / Array.prototype\n *    which would break the entire runtime. */\nexport function freezeDeep(\n  obj: object,\n  seen: WeakSet<object> = new WeakSet(),\n  freezePrototypeChain = false,\n): void {\n  if (seen.has(obj)) return;\n  seen.add(obj);\n\n  if (obj === Object.prototype || obj === Function.prototype || obj === Array.prototype) return;\n\n  // TypedArrays cannot be frozen when non-empty — skip\n  if (_isView(obj) && !(obj instanceof DataView)) return;\n\n  for (const key of _ownKeys(obj)) {\n    const desc = _getOwnPropertyDescriptor(obj, key);\n    if (desc && 'value' in desc && isFreezable(desc.value)) {\n      freezeDeep(desc.value as object, seen, freezePrototypeChain);\n    }\n  }\n\n  if (freezePrototypeChain) {\n    const proto = Object.getPrototypeOf(obj);\n    // Skip canonical root prototypes to avoid breaking the runtime\n    if (proto && proto !== Object.prototype\n      && proto !== Function.prototype && proto !== Array.prototype) {\n      freezeDeep(proto, seen, freezePrototypeChain);\n    }\n  }\n\n  _freeze(obj);\n}\n","import type { DeepReadonly } from './types';\nimport { isFreezable } from './utils';\nimport { freezeDeep } from './freeze-deep-internal';\n\n/** Options for {@link deepFreeze}. */\nexport interface DeepFreezeOptions {\n  /**\n   * Also freeze the prototype chain of every visited object.\n   * Defaults to `false` to preserve backwards compatibility.\n   *\n   * When `true`, any `ClassName.prototype` reachable from the value (and its\n   * nested objects) is frozen. This blocks post-freeze prototype poisoning\n   * (e.g. `Box.prototype.greet = evil` after `deepFreeze(new Box())`), at the\n   * cost of preventing legitimate prototype updates on those classes. See\n   * audit vector F1.\n   */\n  readonly freezePrototypeChain?: boolean;\n}\n\n/**\n * Deep-freeze a value recursively. Handles circular references,\n * Symbol keys, TypedArrays, and getter/setter descriptors.\n *\n * Primitives are returned unchanged. Objects and all their reachable\n * nested properties are frozen in bottom-up order (children before parent)\n * so that the final frozen graph is fully immutable.\n *\n * **Known limitations (by design):**\n * - **Map/Set:** Internal slots (.set(), .add(), .delete()) remain functional\n *   after freeze — use `immutableMapView()`/`immutableSetView()` for full immutability.\n * - **TypedArrays:** Byte data remains writable (non-empty TypedArrays cannot be\n *   frozen). The container property is frozen but indexed writes still work.\n * - **Getters:** Accessor properties are skipped to avoid side effects during freeze.\n *   Objects returned by getters are not frozen.\n * - **Prototypes:** Only own properties are traversed. Inherited properties from\n *   the prototype chain remain mutable. Use `secureSnapshot()` for null-prototype objects.\n *\n * @param val - Value to deep-freeze\n * @returns Deep-frozen value typed as DeepReadonly<T> for objects,\n *          or T unchanged for primitives\n *\n * @example\n * const obj = { nested: { a: 1 }, arr: [1, [2, 3]] };\n * const frozen = deepFreeze(obj);\n * // frozen.nested.a = 2;   // TypeError in strict mode\n * // frozen.arr[1].push(4); // TypeError in strict mode\n */\nexport function deepFreeze<T>(val: T, options: DeepFreezeOptions = {}): T extends object ? DeepReadonly<T> : T {\n  if (!isFreezable(val)) {\n    return val as T extends object ? DeepReadonly<T> : T;\n  }\n  freezeDeep(val as object, undefined, options.freezePrototypeChain === true);\n  return val as T extends object ? DeepReadonly<T> : T;\n}\n","import { isFreezable } from './utils';\n\ntype CreateProxy = <T extends object>(obj: T) => T;\n\n/** Wrap a single value through createProxy if it is freezable */\nfunction wrapValue<T>(val: T, createProxy: CreateProxy): T {\n  return isFreezable(val) ? (createProxy(val as unknown as object) as unknown as T) : val;\n}\n\n/** Wrap a raw iterator so each yielded value passes through createProxy */\nfunction* wrapIterator<T>(iter: Iterator<T>, createProxy: CreateProxy): Generator<T> {\n  let step = iter.next();\n  while (!step.done) {\n    yield wrapValue(step.value, createProxy);\n    step = iter.next();\n  }\n}\n\n/** Wrap a raw entries iterator — entry is [K, V]; only V is wrapped */\nfunction* wrapEntriesIterator<K, V>(\n  iter: Iterator<[K, V]>,\n  createProxy: CreateProxy,\n): Generator<[K, V]> {\n  let step = iter.next();\n  while (!step.done) {\n    const [k, v] = step.value;\n    yield [k, wrapValue(v, createProxy)] as [K, V];\n    step = iter.next();\n  }\n}\n\n/**\n * If `prop` is a value-returning Map method that needs wrapping, return a\n * wrapped version bound to `target`. Returns `null` for other methods.\n */\nexport function wrapMapMethod<K, V>(\n  target: Map<K, V>,\n  prop: string | symbol,\n  createProxy: CreateProxy,\n): ((...args: unknown[]) => unknown) | null {\n  if (prop === 'get') {\n    return (key: unknown) => {\n      const val = target.get(key as K);\n      return val === undefined ? val : wrapValue(val, createProxy);\n    };\n  }\n\n  if (prop === 'values') {\n    return () => {\n      const iter = target.values();\n      return wrapIterator(iter, createProxy);\n    };\n  }\n\n  if (prop === 'entries' || prop === Symbol.iterator) {\n    return () => {\n      const iter = target.entries();\n      return wrapEntriesIterator(iter, createProxy);\n    };\n  }\n\n  if (prop === 'forEach') {\n    return (cb: unknown, thisArg?: unknown) => {\n      target.forEach((v, k, m) => {\n        (cb as (v: V, k: K, m: Map<K, V>) => void).call(\n          thisArg,\n          wrapValue(v, createProxy),\n          k,\n          m,\n        );\n      });\n    };\n  }\n\n  return null;\n}\n\n/**\n * If `prop` is a value-returning Set method that needs wrapping, return a\n * wrapped version bound to `target`. Returns `null` for other methods.\n */\nexport function wrapSetMethod<T>(\n  target: Set<T>,\n  prop: string | symbol,\n  createProxy: CreateProxy,\n): ((...args: unknown[]) => unknown) | null {\n  if (prop === 'values' || prop === 'keys' || prop === Symbol.iterator) {\n    return () => {\n      const iter = target.values();\n      return wrapIterator(iter, createProxy);\n    };\n  }\n\n  if (prop === 'entries') {\n    return () => {\n      // Set entries are [v, v] pairs\n      const iter = target.entries();\n      return (function* () {\n        let step = iter.next();\n        while (!step.done) {\n          const wrapped = wrapValue(step.value[0], createProxy);\n          yield [wrapped, wrapped] as [T, T];\n          step = iter.next();\n        }\n      })();\n    };\n  }\n\n  if (prop === 'forEach') {\n    return (cb: unknown, thisArg?: unknown) => {\n      target.forEach((v, _v2, s) => {\n        (cb as (v: T, v2: T, s: Set<T>) => void).call(\n          thisArg,\n          wrapValue(v, createProxy),\n          wrapValue(v, createProxy),\n          s,\n        );\n      });\n    };\n  }\n\n  return null;\n}\n","import type { DeepReadonly } from './types';\nimport { isFreezable } from './utils';\nimport {\n  _Proxy,\n  _ownKeys,\n  _reflectGet,\n  _reflectHas,\n  _reflectGetOwnPropertyDescriptor,\n  _reflectGetPrototypeOf,\n  _reflectIsExtensible,\n} from './cached-builtins';\nimport { wrapMapMethod, wrapSetMethod } from './immutable-view-collection-wraps';\n\nconst proxyCache = new WeakMap<object, object>();\n/** Private registry of proxies created by immutableView() — unforgeable from outside */\nconst immutableRegistry = new WeakSet<object>();\n\nconst MAP_MUTATORS = new Set(['set', 'delete', 'clear']);\nconst SET_MUTATORS = new Set(['add', 'delete', 'clear']);\nconst WEAKMAP_MUTATORS = new Set(['set', 'delete']);\nconst WEAKSET_MUTATORS = new Set(['add', 'delete']);\nconst ARRAY_MUTATORS = new Set([\n  'push', 'pop', 'shift', 'unshift', 'splice',\n  'sort', 'reverse', 'fill', 'copyWithin',\n]);\nconst DATE_MUTATORS = new Set([\n  'setTime', 'setMilliseconds', 'setUTCMilliseconds',\n  'setSeconds', 'setUTCSeconds', 'setMinutes', 'setUTCMinutes',\n  'setHours', 'setUTCHours', 'setDate', 'setUTCDate',\n  'setMonth', 'setUTCMonth', 'setFullYear', 'setUTCFullYear',\n]);\n\n/** Map of constructor → blocked method names */\nconst MUTATOR_MAP: [Function, Set<string>][] = [\n  [Map, MAP_MUTATORS],\n  [Set, SET_MUTATORS],\n  [WeakMap, WEAKMAP_MUTATORS],\n  [WeakSet, WEAKSET_MUTATORS],\n  [Date, DATE_MUTATORS],\n];\n\n/** Throw a consistent TypeError for any mutation attempt */\nfunction rejectMutation(op: string): never {\n  throw new TypeError(`Cannot ${op}: object is immutable`);\n}\n\n/** Check if target has internal slots (Map/Set/WeakMap/WeakSet/Date) */\nfunction hasInternalSlots(target: object): boolean {\n  return target instanceof Map || target instanceof Set\n    || target instanceof WeakMap || target instanceof WeakSet\n    || target instanceof Date;\n}\n\n/**\n * Known non-mutating read methods on built-in collection types. Any string-keyed\n * function property NOT in this allow-list (and NOT on the class itself) is\n * treated as a potential subclass custom mutator and blocked. Closes audit V3:\n * `class Evil extends Map { sneakSet(k,v){this.set(k,v)} }` previously bypassed\n * the deny list because `sneakSet` was not named in MUTATOR_MAP.\n */\nconst MAP_READ_METHODS = new Set([\n  'get', 'has', 'keys', 'values', 'entries', 'forEach',\n]);\nconst SET_READ_METHODS = new Set([\n  'has', 'keys', 'values', 'entries', 'forEach',\n]);\nconst WEAKMAP_READ_METHODS = new Set(['get', 'has']);\nconst WEAKSET_READ_METHODS = new Set(['has']);\nconst DATE_READ_METHODS = new Set([\n  'getTime', 'getFullYear', 'getUTCFullYear', 'getMonth', 'getUTCMonth',\n  'getDate', 'getUTCDate', 'getDay', 'getUTCDay',\n  'getHours', 'getUTCHours', 'getMinutes', 'getUTCMinutes',\n  'getSeconds', 'getUTCSeconds', 'getMilliseconds', 'getUTCMilliseconds',\n  'getTimezoneOffset', 'valueOf',\n  'toString', 'toDateString', 'toTimeString', 'toLocaleString',\n  'toLocaleDateString', 'toLocaleTimeString', 'toUTCString', 'toISOString',\n  'toJSON',\n]);\n\nconst READ_METHOD_MAP: [Function, Set<string>][] = [\n  [Map, MAP_READ_METHODS],\n  [Set, SET_READ_METHODS],\n  [WeakMap, WEAKMAP_READ_METHODS],\n  [WeakSet, WEAKSET_READ_METHODS],\n  [Date, DATE_READ_METHODS],\n];\n\n/** Check if prop is a blocked mutator method on target. Returns method name or null. */\nfunction getBlockedMutator(target: object, prop: string | symbol): string | null {\n  if (typeof prop !== 'string') return null;\n  for (const [ctor, mutators] of MUTATOR_MAP) {\n    if (target instanceof ctor && mutators.has(prop)) return prop;\n  }\n  if (Array.isArray(target) && ARRAY_MUTATORS.has(prop)) return prop;\n  return null;\n}\n\n/**\n * For objects with internal slots (Map/Set/WeakMap/WeakSet/Date), return true\n * if `prop` is a function that is NOT a known read method. These are treated\n * as subclass-defined mutators and blocked regardless of their actual behavior\n * (defensive deny-by-default — audit V3).\n */\nfunction isSuspectSlottedMethod(target: object, prop: string | symbol, value: unknown): boolean {\n  if (typeof prop !== 'string' || typeof value !== 'function') return false;\n  for (const [ctor, reads] of READ_METHOD_MAP) {\n    if (target instanceof ctor) {\n      // Allow own-prototype standard reads; block everything else that's a function.\n      if (reads.has(prop)) return false;\n      // Also allow Symbol.toStringTag etc. which are handled earlier (typeof !== 'string').\n      return true;\n    }\n  }\n  return false;\n}\n\n/** Check if a property descriptor is non-writable + non-configurable (Proxy invariant) */\nfunction isFrozenDescriptor(target: object, prop: string | symbol): boolean {\n  const desc = _reflectGetOwnPropertyDescriptor(target, prop);\n  return !!desc && !desc.configurable && 'value' in desc && !desc.writable;\n}\n\n/**\n * Try to resolve a method-level override for a property access (mutator block,\n * subclass-deny, collection wrap, slotted bind). Returns `{ handled: false }`\n * when the caller should fall through to default wrap-or-return logic.\n * Extracted to keep the Proxy `get` trap below SonarCloud's cognitive-complexity\n * threshold.\n */\ntype GetOverride =\n  | { handled: true; value: unknown }\n  | { handled: false };\n\nfunction resolveGetOverride(\n  target: object,\n  prop: string | symbol,\n  value: unknown,\n  isSlotted: boolean,\n  makeProxy: <O extends object>(o: O) => O\n): GetOverride {\n  const blocked = getBlockedMutator(target, prop);\n  if (blocked) return { handled: true, value: () => rejectMutation(blocked) };\n\n  if (isSlotted && isSuspectSlottedMethod(target, prop, value)) {\n    return { handled: true, value: () => rejectMutation(`invoke subclass method \"${String(prop)}\"`) };\n  }\n\n  if (target instanceof Map) {\n    const wrapped = wrapMapMethod(target, prop, makeProxy);\n    if (wrapped !== null) return { handled: true, value: wrapped };\n  } else if (target instanceof Set) {\n    const wrapped = wrapSetMethod(target, prop, makeProxy);\n    if (wrapped !== null) return { handled: true, value: wrapped };\n  }\n\n  if (isSlotted && typeof value === 'function') {\n    return { handled: true, value: value.bind(target) };\n  }\n\n  return { handled: false };\n}\n\n/** Create a Proxy that blocks all mutations on obj */\nfunction createImmutableProxy<T extends object>(obj: T): T {\n  if (proxyCache.has(obj)) return proxyCache.get(obj) as T;\n\n  const proxy = new _Proxy(obj, {\n    get(target, prop, receiver) {\n      // Audit V5: when blockToJSON is set, hide the target's toJSON so\n      // JSON.stringify(view) falls back to default Proxy-observable serialization.\n      const opts = targetOptionsCache.get(target);\n      if (opts?.blockToJSON && prop === 'toJSON') return undefined;\n\n      const isSlotted = hasInternalSlots(target);\n      const value = isSlotted\n        ? _reflectGet(target, prop)\n        : _reflectGet(target, prop, receiver);\n\n      const override = resolveGetOverride(target, prop, value, isSlotted, createImmutableProxy);\n      if (override.handled) return override.value;\n\n      // Lazily wrap nested objects. Respect Proxy invariant §10.5.8:\n      // non-writable + non-configurable props must return exact value.\n      if (isFreezable(value)) {\n        if (isFrozenDescriptor(target, prop)) return value;\n        return createImmutableProxy(value as object);\n      }\n\n      return value;\n    },\n\n    set(_t, prop) { return rejectMutation(`set property \"${String(prop)}\"`); },\n    deleteProperty(_t, prop) { return rejectMutation(`delete property \"${String(prop)}\"`); },\n    defineProperty(_t, prop) { return rejectMutation(`define property \"${String(prop)}\"`); },\n    setPrototypeOf() { return rejectMutation('set prototype'); },\n    preventExtensions() { return rejectMutation('prevent extensions'); },\n    getPrototypeOf(target) {\n      const proto = _reflectGetPrototypeOf(target);\n      return proto && isFreezable(proto) ? createImmutableProxy(proto) : proto;\n    },\n    has(target, prop) { return _reflectHas(target, prop); },\n    ownKeys(target) { return _ownKeys(target); },\n    getOwnPropertyDescriptor(target, prop) {\n      const desc = _reflectGetOwnPropertyDescriptor(target, prop);\n      if (desc && 'value' in desc && isFreezable(desc.value)) {\n        if (!isFrozenDescriptor(target, prop)) {\n          return { ...desc, value: createImmutableProxy(desc.value as object) };\n        }\n      }\n      return desc;\n    },\n    isExtensible(target) { return _reflectIsExtensible(target); },\n\n    // Audit V1/V6: block function application with a mutable / slotted `this`.\n    // An attacker could pass a callsite receiver that the function mutates\n    // (`evil.call(target)` where evil does `this.hacked = true`). By default\n    // we require the receiver to be either primitive, the original target, or\n    // another immutable view — anything else is rejected defensively.\n    apply(target, thisArg, args) {\n      if (typeof target !== 'function') {\n        return rejectMutation('apply non-function target');\n      }\n      const safeReceiver =\n        thisArg === null ||\n        thisArg === undefined ||\n        typeof thisArg !== 'object' ||\n        thisArg === target ||\n        immutableRegistry.has(thisArg as object);\n      if (!safeReceiver) {\n        return rejectMutation('apply function with a mutable receiver');\n      }\n      return (target as (...a: unknown[]) => unknown).apply(thisArg, args);\n    },\n\n    // Audit V1: block `new view(...)` entirely. An immutable view of a\n    // constructor should not manufacture mutable instances.\n    construct() {\n      return rejectMutation('construct from immutable view');\n    },\n  });\n\n  proxyCache.set(obj, proxy);\n  immutableRegistry.add(proxy);\n  return proxy;\n}\n\n/** Options for {@link immutableView}. */\nexport interface ImmutableViewOptions {\n  /**\n   * When `true`, suppresses the target's `toJSON()` method through the view.\n   * `JSON.stringify(view)` then serializes via default own-enumerable iteration\n   * (through the Proxy's ownKeys/getOwnPropertyDescriptor traps) instead of\n   * calling the target-supplied `toJSON`. Blocks audit vector V5 where an\n   * attacker-supplied `toJSON` could forge serialized output that the Proxy\n   * traps never observed. Default `false` for backwards compatibility.\n   */\n  readonly blockToJSON?: boolean;\n}\n\n/** Target → options cache. Keyed on raw target so the get trap can consult it. */\nconst targetOptionsCache = new WeakMap<object, ImmutableViewOptions>();\n\n/**\n * Wrap a value in a deeply immutable Proxy **view**.\n *\n * All mutation operations through this reference throw a TypeError.\n * Nested objects are wrapped lazily on first access.\n *\n * **Important:** This is a VIEW, not a snapshot. If the caller retains\n * the original reference, they can still mutate the underlying data.\n * Use `snapshot()` for true data immutability (clone + freeze),\n * or `vault()` for complete reference isolation (closure + copy-on-read).\n *\n * **V5 note (`toJSON` bypass):** By default the target's `toJSON()` method\n * (if any) is called directly by `JSON.stringify` — the Proxy cannot\n * intercept that path, so an attacker-supplied `toJSON` could forge the\n * serialized output. Pass `{ blockToJSON: true }` to suppress `toJSON` and\n * force default property-based serialization through the Proxy traps.\n *\n * @param val - Value to wrap\n * @param options - Optional behavior tweaks\n * @returns A Proxy-based immutable view, typed as DeepReadonly<T>\n *\n * @example\n * const obj = immutableView({ nested: { count: 0 } });\n * obj.nested.count = 1; // throws TypeError\n */\nexport function immutableView<T>(val: T, options: ImmutableViewOptions = {}): T extends object ? DeepReadonly<T> : T {\n  if (!isFreezable(val)) return val as T extends object ? DeepReadonly<T> : T;\n  if (options.blockToJSON) {\n    targetOptionsCache.set(val as object, options);\n  }\n  const proxy = createImmutableProxy(val as object);\n  return proxy as T extends object ? DeepReadonly<T> : T;\n}\n\n/**\n * Check whether a value is a Proxy created by `immutableView()`.\n * Uses a private WeakSet registry — unforgeable from outside the module.\n */\nexport function isImmutableView(val: unknown): boolean {\n  if (!isFreezable(val)) return false;\n  return immutableRegistry.has(val as object);\n}\n\n/**\n * Throws TypeError if `val` is not an immutable view Proxy.\n * @param val - Value to assert\n * @param label - Optional prefix for error message\n */\nexport function assertImmutableView(val: unknown, label?: string): void {\n  if (!isImmutableView(val)) {\n    const msg = label ? `${label}: Not an immutable view` : 'Not an immutable view';\n    throw new TypeError(msg);\n  }\n}\n","/**\n * Immutable wrappers for Map and Set that expose only read operations,\n * blocking all mutation methods at the type level.\n *\n * Deep immutability: object values are deep-frozen on read (lazy). The\n * constructor uses structuredClone for object values so source references\n * remain independently mutable.\n *\n * Note: structuredClone cannot clone functions or Symbols — values containing\n * these will throw DataCloneError at construction, same as snapshot()/vault().\n */\n\nimport { freezeDeep, deepClone } from './freeze-deep-internal';\nimport { isFreezable } from './utils';\n\n/**\n * A read-only wrapper around a `Map` that implements `ReadonlyMap`.\n * Mutation methods (`set`, `delete`, `clear`) are simply absent.\n * Object values are deep-cloned at construction and deep-frozen on first read.\n */\nexport class ImmutableMap<K, V> implements ReadonlyMap<K, V> {\n  readonly #map: Map<K, V>;\n\n  constructor(source: Map<K, V>) {\n    // Clone object values so freezing our copy does not affect the source\n    this.#map = new Map();\n    for (const [k, v] of source) {\n      this.#map.set(k, isFreezable(v) ? (deepClone(v) as V) : v);\n    }\n  }\n\n  get size(): number {\n    return this.#map.size;\n  }\n\n  get(key: K): V | undefined {\n    const val = this.#map.get(key);\n    // Lazy deep-freeze on access — idempotent, cheap on repeat reads\n    if (val !== undefined && isFreezable(val)) {\n      freezeDeep(val as object);\n    }\n    return val;\n  }\n\n  has(key: K): boolean {\n    return this.#map.has(key);\n  }\n\n  keys(): MapIterator<K> {\n    return this.#map.keys();\n  }\n\n  values(): IterableIterator<V> {\n    return this.#frozenValues();\n  }\n\n  entries(): IterableIterator<[K, V]> {\n    return this.#frozenEntries();\n  }\n\n  forEach(callbackfn: (value: V, key: K, map: ReadonlyMap<K, V>) => void): void {\n    this.#map.forEach((value, key) => {\n      if (isFreezable(value)) freezeDeep(value as object);\n      callbackfn(value, key, this);\n    });\n  }\n\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.#frozenEntries();\n  }\n\n  get [Symbol.toStringTag](): string {\n    return 'ImmutableMap';\n  }\n\n  *#frozenValues(): Generator<V, void, unknown> {\n    for (const val of this.#map.values()) {\n      if (isFreezable(val)) freezeDeep(val as object);\n      yield val;\n    }\n  }\n\n  *#frozenEntries(): Generator<[K, V], void, unknown> {\n    for (const [key, val] of this.#map.entries()) {\n      if (isFreezable(val)) freezeDeep(val as object);\n      yield [key, val];\n    }\n  }\n}\n\n/**\n * A read-only wrapper around a `Set` that implements `ReadonlySet`.\n * Mutation methods (`add`, `delete`, `clear`) are simply absent.\n * Object values are deep-cloned at construction and deep-frozen on first read.\n *\n * **Note:** `has()` uses reference identity. Since object values are deep-cloned\n * at construction, `has(originalObj)` returns false — the cloned element has a\n * different reference. Use `has()` only for primitive values or the exact cloned\n * references obtained from the set's iterators.\n */\nexport class ImmutableSet<T> implements ReadonlySet<T> {\n  readonly #set: Set<T>;\n\n  constructor(source: Set<T>) {\n    // Clone object values so freezing our copy does not affect the source\n    this.#set = new Set();\n    for (const v of source) {\n      this.#set.add(isFreezable(v) ? (deepClone(v) as T) : v);\n    }\n  }\n\n  get size(): number {\n    return this.#set.size;\n  }\n\n  has(value: T): boolean {\n    return this.#set.has(value);\n  }\n\n  keys(): IterableIterator<T> {\n    return this.#frozenValues();\n  }\n\n  values(): IterableIterator<T> {\n    return this.#frozenValues();\n  }\n\n  entries(): IterableIterator<[T, T]> {\n    return this.#frozenEntries();\n  }\n\n  forEach(callbackfn: (value: T, value2: T, set: ReadonlySet<T>) => void): void {\n    this.#set.forEach((value) => {\n      if (isFreezable(value)) freezeDeep(value as object);\n      callbackfn(value, value, this);\n    });\n  }\n\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.#frozenValues();\n  }\n\n  get [Symbol.toStringTag](): string {\n    return 'ImmutableSet';\n  }\n\n  *#frozenValues(): Generator<T, void, unknown> {\n    for (const val of this.#set.values()) {\n      if (isFreezable(val)) freezeDeep(val as object);\n      yield val;\n    }\n  }\n\n  *#frozenEntries(): Generator<[T, T], void, unknown> {\n    for (const val of this.#set.values()) {\n      if (isFreezable(val)) freezeDeep(val as object);\n      yield [val, val];\n    }\n  }\n}\n\n// Freeze class prototypes at module load to block global prototype pollution.\n// Without this, an attacker can replace `ImmutableMap.prototype.get` and hijack\n// every wrapper instance in the process (audit vector C5).\nObject.freeze(ImmutableMap.prototype);\nObject.freeze(ImmutableSet.prototype);\n\n/**\n * Wraps a `Map` in an `ImmutableMap`, returning a `ReadonlyMap` typed reference.\n * @param source - The mutable map to wrap\n */\nexport function immutableMapView<K, V>(source: Map<K, V>): ReadonlyMap<K, V> {\n  return new ImmutableMap(source);\n}\n\n/**\n * Wraps a `Set` in an `ImmutableSet`, returning a `ReadonlySet` typed reference.\n * @param source - The mutable set to wrap\n */\nexport function immutableSetView<T>(source: Set<T>): ReadonlySet<T> {\n  return new ImmutableSet(source);\n}\n","import type { DeepReadonly } from './types';\nimport { freezeDeep, deepClone } from './freeze-deep-internal';\nimport { isFreezable } from './utils';\nimport { _ownKeys, _getOwnPropertyDescriptor, _isArray } from './cached-builtins';\n\n/**\n * Yield every child value reachable from a container node for prototype-nullification\n * traversal. Split out of nullifyPlainPrototypes to keep cognitive complexity low.\n */\nfunction* childrenOf(node: object): Generator<unknown> {\n  if (_isArray(node)) {\n    yield* node;\n    return;\n  }\n  if (node instanceof Map || node instanceof Set) {\n    yield* node.values();\n    return;\n  }\n  for (const key of _ownKeys(node)) {\n    const desc = _getOwnPropertyDescriptor(node, key);\n    if (desc && 'value' in desc) yield desc.value;\n  }\n}\n\n/**\n * Recursively sever Object.prototype from every plain-object node in the tree.\n * Preserves built-in types (Array, Date, Map, Set, RegExp, TypedArray) so their\n * methods keep working. Blocks prototype pollution leakage into snapshot output\n * (audit S1).\n */\nfunction nullifyPlainPrototypes(node: unknown, seen: WeakSet<object>): void {\n  if (node === null || typeof node !== 'object') return;\n  if (seen.has(node)) return;\n  seen.add(node);\n\n  // Only touch pristine plain objects; preserve Array, Date, Map, Set, etc.\n  if (Object.getPrototypeOf(node) === Object.prototype) {\n    Object.setPrototypeOf(node, null);\n  }\n\n  for (const child of childrenOf(node)) {\n    nullifyPlainPrototypes(child, seen);\n  }\n}\n\n/**\n * Deep clone + deep freeze a value. Returns an immutable snapshot.\n *\n * The original reference is severed via deep clone, then the clone\n * is recursively frozen. No Proxy involved — no invariant conflicts.\n *\n * **Object.freeze limitation:** Map/Set instances are frozen at the object\n * level, but their internal slot methods (.set(), .add()) still work.\n * For full Map/Set immutability, use `immutableMapView()` / `immutableSetView()`.\n *\n * **Clone domain:** Uses structuredClone (Node 18+). Non-cloneable values\n * (functions, Symbols, DOM nodes) throw TypeError. No fallback — use\n * immutableView() for objects containing non-cloneable properties.\n *\n * @param value - Value to snapshot. Primitives returned unchanged.\n * @returns A frozen deep clone typed as DeepReadonly<T>\n *\n * @example\n * const raw = { user: { isVip: false } };\n * const locked = lock(raw);\n * raw.user.isVip = true;     // original mutated\n * locked.user.isVip;          // false — clone is independent\n * locked.user.isVip = true;  // TypeError — frozen\n */\nexport function snapshot<T>(value: T): DeepReadonly<T> {\n  if (!isFreezable(value)) return value as DeepReadonly<T>;\n  const clone = deepClone(value);\n  nullifyPlainPrototypes(clone, new WeakSet());\n  freezeDeep(clone as object);\n  return clone as DeepReadonly<T>;\n}\n\n/** Alias for snapshot(). Shorter name for power users. */\nexport const lock = snapshot;\n","import { _freeze, _ownKeys, _getOwnPropertyDescriptor, _defineProperty, _create } from './cached-builtins';\n\n/** Returns true for types whose data lives in internal slots, not own properties. */\nfunction isNonPlainObject(value: object): boolean {\n  return Array.isArray(value) || value instanceof Map || value instanceof Set\n    || value instanceof Date || value instanceof RegExp\n    || value instanceof WeakMap || value instanceof WeakSet\n    || ArrayBuffer.isView(value);\n}\n\n/** Recursively secure a nested value, wrapping TypeError with property context. */\nfunction secureNestedValue(key: string | symbol, raw: unknown): unknown {\n  if (raw === null || typeof raw !== 'object') return raw;\n  try {\n    return secureSnapshot(raw as Record<string, unknown>);\n  } catch (err) {\n    if (err instanceof TypeError) {\n      throw new TypeError(\n        `secureSnapshot(): property \"${String(key)}\" contains a ${raw.constructor?.name ?? 'non-plain object'}. ` +\n        `secureSnapshot() only supports plain objects. Nested Date, Map, Set, Array, etc. are not supported.`\n      );\n    }\n    throw err;\n  }\n}\n\n/**\n * Create a maximally-hardened immutable view of `value`.\n *\n * Three layers of protection are applied simultaneously:\n * - **Null prototype** — the target object has no prototype chain, so\n *   `Object.prototype` pollution (e.g. `__proto__`, `toString` attacks)\n *   cannot reach it.\n * - **Getter-only descriptors** — no `value` field is ever written to the\n *   target; every property is exposed only through a `get` accessor backed\n *   by a closure `Map`, so callers cannot intercept or replace the stored\n *   value through normal property assignment.\n * - **`configurable: false`** — the getter cannot be redefined even with\n *   `Object.defineProperty`, making the shape of the object truly permanent.\n *\n * Nested objects are recursively secured. Accessor descriptors (get/set)\n * on the source object are skipped to avoid side effects during construction.\n *\n * **Supported types:** Plain objects only. Throws TypeError for Map, Set,\n * Date, RegExp, Array, TypedArray, and class instances — these types store\n * data in internal slots or indexed properties that cannot be faithfully\n * represented as getter-only descriptors.\n *\n * @param value - Plain object to secure. Throws for non-plain objects.\n * @returns A `Readonly<T>` proxy-free secured copy.\n *\n * @example\n * const cfg = secureSnapshot({ db: { host: 'localhost', port: 5432 } });\n * cfg.db.host;          // 'localhost'\n * cfg.db.host = 'x';   // TypeError (strict) — getter only\n * Object.defineProperty(cfg, 'db', { value: null }); // TypeError — non-configurable\n */\nexport function secureSnapshot<T extends Record<string, unknown>>(value: T): Readonly<T> {\n  if (isNonPlainObject(value)) {\n    throw new TypeError('secureSnapshot() only supports plain objects. Use snapshot() or vault() for other types.');\n  }\n  // Null-prototype object — immune to Object.prototype pollution\n  const target = _create(null) as T;\n  const store = new Map<string | symbol, unknown>();\n\n  for (const key of _ownKeys(value)) {\n    const desc = _getOwnPropertyDescriptor(value, key);\n    if (!desc) continue;\n    // Explicit error on accessor properties — silent drop was a data-loss\n    // surface (audit X1). Caller must convert to plain data before securing.\n    if (!('value' in desc)) {\n      throw new TypeError(\n        `secureSnapshot(): accessor property \"${String(key)}\" is not supported. ` +\n        `Invoke the getter yourself and pass the resolved value as a plain data property.`\n      );\n    }\n\n    store.set(key, secureNestedValue(key, desc.value));\n\n    _defineProperty(target, key, {\n      get: () => store.get(key),\n      enumerable: desc.enumerable ?? true,\n      configurable: false,   // PERMANENT — cannot be redefined\n    });\n  }\n\n  return _freeze(target);\n}\n","import type { DeepReadonly } from './types';\nimport { _freeze, _ownKeys, _jsonStringify, _getOwnPropertyDescriptor } from './cached-builtins';\nimport { freezeDeep, deepClone } from './freeze-deep-internal';\nimport { isFreezable } from './utils';\n\n/**\n * A sealed vault that holds an immutable deep copy of a value and exposes\n * structural hash verification to detect any corruption of internal state.\n */\nexport interface TamperEvidentVault<T> {\n  /** Returns a frozen deep copy of the stored value. */\n  readonly get: () => DeepReadonly<T>;\n  /** Recomputes the hash and compares it to the original fingerprint. */\n  readonly verify: () => boolean;\n  /** Throws a TypeError if the stored hash no longer matches the value. */\n  readonly assertIntact: () => void;\n  /** The original djb2 hash of the serialized value (base-36). */\n  readonly fingerprint: string;\n}\n\n/**\n * 64-bit fingerprint built from two independent non-cryptographic hashes:\n * djb2 (shift+add) and sdbm (multiply+xor). Concatenating them widens the\n * birthday bound from ~2^16 (djb2 alone) to ~2^32 attempts before a collision\n * is expected (audit T1). Still NOT cryptographically secure — callers who\n * need tamper-proof integrity against a motivated attacker must use an HMAC\n * from node:crypto instead.\n */\nfunction hashString(str: string): string {\n  let h1 = 5381; // djb2 seed\n  let h2 = 0;    // sdbm seed\n  for (let i = 0; i < str.length; i++) {\n    const c = str.codePointAt(i) ?? 0;\n    h1 = Math.trunc((h1 << 5) + h1 + c);\n    h2 = Math.trunc(c + (h2 << 6) + (h2 << 16) - h2);\n  }\n  const part1 = (h1 >>> 0).toString(36).padStart(7, '0');\n  const part2 = (h2 >>> 0).toString(36).padStart(7, '0');\n  return part1 + part2;\n}\n\n/** Serialize a non-object primitive to a deterministic string. */\nfunction stringifyPrimitive(val: unknown): string {\n  if (typeof val === 'number') {\n    if (Number.isNaN(val)) return '\"NaN\"';\n    if (!Number.isFinite(val)) return val > 0 ? '\"Infinity\"' : '\"-Infinity\"';\n  }\n  if (val === undefined) return 'undefined';\n  return _jsonStringify(val);\n}\n\n/** Serialize an object's own keys into structurally separated string|symbol sections. */\nfunction stringifyObjectKeys(obj: Record<string | symbol, unknown>, seen: WeakSet<object>): string {\n  const allKeys = _ownKeys(obj);\n  const strKeys: string[] = [];\n  const symKeys: symbol[] = [];\n  for (const k of allKeys) {\n    if (typeof k === 'symbol') symKeys.push(k);\n    else strKeys.push(String(k));\n  }\n\n  strKeys.sort((a, b) => a.localeCompare(b));\n  symKeys.sort((a, b) => a.toString().localeCompare(b.toString()));\n\n  // Audit T7: invoking getters during stringify has side effects and makes\n  // verify() non-deterministic (side-effectful/time-based getters produce\n  // different hashes on each call). Replace accessor descriptors with a\n  // stable structural marker so they contribute to the fingerprint without\n  // being invoked.\n  const readKey = (k: string | symbol): string => {\n    const desc = _getOwnPropertyDescriptor(obj, k);\n    if (desc && !('value' in desc)) {\n      return '\"[Accessor]\"';\n    }\n    return stableStringify(obj[k], seen);\n  };\n\n  const strPairs = strKeys.map(k =>\n    _jsonStringify(k) + ':' + readKey(k)\n  );\n  const symPairs = symKeys.map(k =>\n    _jsonStringify(k.toString()) + ':' + readKey(k)\n  );\n\n  // '|' separates the two sections — structural, not a prefix, so no collision\n  return '{' + strPairs.join(',') + (symPairs.length ? '|' + symPairs.join(',') : '') + '}';\n}\n\n/** Deterministic serialisation: _ownKeys (string + symbol), sorted.\n *  String and symbol keys are serialized in structurally separate sections\n *  (separated by '|') so no crafted string key can collide with a symbol key.\n *\n *  Built-in types with internal slots (Map, Set, Date) are given a dedicated\n *  tagged representation that reaches into the slot data. Without this, every\n *  empty Map/Set and every Date would share the same fingerprint (audit T2/T3/T4). */\nfunction stableStringify(val: unknown, seen: WeakSet<object> = new WeakSet()): string {\n  if (val === null || typeof val !== 'object') return stringifyPrimitive(val);\n\n  // Circular reference guard\n  if (seen.has(val)) return '\"[Circular]\"';\n  seen.add(val);\n\n  if (Array.isArray(val)) {\n    return '[' + val.map(v => stableStringify(v, seen)).join(',') + ']';\n  }\n\n  // Tagged serialization for built-in types whose data is in internal slots\n  if (val instanceof Date) {\n    return 'Date(' + val.getTime() + ')';\n  }\n  if (val instanceof Map) {\n    const entries = Array.from((val as Map<unknown, unknown>).entries())\n      .map(([k, v]) => [stableStringify(k, seen), stableStringify(v, seen)] as const);\n    entries.sort((a, b) => a[0].localeCompare(b[0]));\n    return 'Map{' + entries.map(([k, v]) => k + ':' + v).join(',') + '}';\n  }\n  if (val instanceof Set) {\n    const items = Array.from((val as Set<unknown>).values())\n      .map(v => stableStringify(v, seen));\n    items.sort((a, b) => a.localeCompare(b));\n    return 'Set{' + items.join(',') + '}';\n  }\n  if (val instanceof RegExp) {\n    return 'RegExp(' + val.source + '/' + val.flags + ')';\n  }\n\n  return stringifyObjectKeys(val as Record<string | symbol, unknown>, seen);\n}\n\n/**\n * Seals `value` inside a tamper-evident vault backed by a djb2 structural hash.\n *\n * The vault stores an independent deep clone — mutations to the original object\n * do not affect the vault. `verify()` recomputes the hash on every call.\n *\n * **Note:** The stored clone is closure-isolated and unreachable from outside.\n * `verify()` is a defense-in-depth check — it detects internal library bugs\n * or exotic memory corruption, not JS-level external tampering. The `fingerprint`\n * is useful for comparing snapshots across time or serialization boundaries.\n *\n * **Hash scope:** Covers plain objects, arrays, string + Symbol keys.\n * Does NOT cover Map/Set internal data, Date specifics, or circular refs.\n * Symbols with identical descriptions produce identical hash entries (djb2 limitation).\n * This is a non-cryptographic fingerprint, not a security proof.\n *\n * @example\n * const te = tamperEvident({ id: 1, name: 'Alice' });\n * te.verify();        // true\n * te.assertIntact();  // no-op\n * te.fingerprint;     // e.g. \"3k9h2m\"\n */\nexport function tamperEvident<T>(value: T): TamperEvidentVault<T> {\n  const stored = deepClone(value);\n  // Fix #8: freeze stored clone for defense-in-depth\n  if (isFreezable(stored)) freezeDeep(stored as object);\n  const fingerprint = hashString(stableStringify(stored));\n\n  const get = (): DeepReadonly<T> => {\n    const copy = deepClone(stored);\n    if (isFreezable(copy)) freezeDeep(copy as object);\n    return copy as DeepReadonly<T>;\n  };\n\n  const verify = (): boolean =>\n    hashString(stableStringify(stored)) === fingerprint;\n\n  const assertIntact = (): void => {\n    if (!verify()) {\n      throw new TypeError('TamperEvidentVault: integrity check failed — fingerprint mismatch');\n    }\n  };\n\n  return _freeze({ get, verify, assertIntact, fingerprint });\n}\n","import { _freeze } from './cached-builtins';\nimport { freezeDeep, deepClone } from './freeze-deep-internal';\nimport type { DeepReadonly } from './types';\nimport { isFreezable } from './utils';\n\n/**\n * A sealed container whose stored value can never leak a mutable reference.\n * Every `get()` call returns a fresh frozen deep copy.\n */\nexport interface Vault<T> {\n  readonly get: () => DeepReadonly<T>;\n}\n\n/** Return a deep-frozen copy of `val`, or the primitive itself. */\nfunction frozenCopy<T>(val: T): DeepReadonly<T> {\n  if (!isFreezable(val)) return val as DeepReadonly<T>;\n  const clone = deepClone(val);\n  freezeDeep(clone as object);\n  return clone as DeepReadonly<T>;\n}\n\n/**\n * Seals `value` inside a closure — the original reference is severed\n * immediately. Every call to `get()` returns a new frozen deep copy so\n * callers can never observe or mutate the stored state.\n *\n * **Object.freeze limitation:** Map/Set internal slots remain mutable.\n * Use `immutableMapView()` / `immutableSetView()` for collection immutability.\n *\n * @param value - Any value to protect. Primitives are stored as-is.\n * @returns A frozen `Vault<T>` with a single `get()` accessor.\n *\n * @example\n * const v = vault({ x: 1, nested: { y: 2 } });\n * const a = v.get(); // frozen copy\n * const b = v.get(); // different frozen copy — a !== b\n */\nexport function vault<T>(value: T): Vault<T> {\n  const stored: DeepReadonly<T> = frozenCopy(value);\n\n  return _freeze<Vault<T>>({\n    get: () => frozenCopy(stored as T),\n  });\n}\n","import { _isFrozen, _getOwnPropertyDescriptor, _ownKeys } from './cached-builtins';\nimport { isFreezable } from './utils';\n\n/**\n * Returns true if `val` and all nested data properties are frozen.\n * Primitives are always considered deeply frozen.\n * Handles circular references via WeakSet.\n *\n * **Accessor handling (audit F4/I1):** Accessor (getter/setter) descriptors\n * return `false`. The getter could return a fresh mutable object on every\n * call, so we cannot prove deep-immutability without invoking it (which has\n * side effects and is not safe to do here). The previous behavior silently\n * skipped accessors and returned a false-positive `true`.\n */\nexport function isDeepFrozen(val: unknown, seen: WeakSet<object> = new WeakSet()): boolean {\n  if (!isFreezable(val)) return true;\n\n  const obj = val as object;\n  if (seen.has(obj)) return true;\n  if (!_isFrozen(obj)) return false;\n\n  seen.add(obj);\n\n  for (const key of _ownKeys(obj)) {\n    const desc = _getOwnPropertyDescriptor(obj, key);\n    if (!desc) continue;\n    if (!('value' in desc)) {\n      // Accessor descriptor — cannot prove the getter returns a frozen value.\n      return false;\n    }\n    if (!isDeepFrozen(desc.value, seen)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Throws TypeError if `val` is not deeply frozen.\n * @param val - The value to check.\n * @param label - Optional prefix for the error message.\n */\nexport function assertDeepFrozen(val: unknown, label?: string): void {\n  if (!isDeepFrozen(val)) {\n    const msg = label ? `${label}: Object is not deep frozen` : 'Object is not deep frozen';\n    throw new TypeError(msg);\n  }\n}\n","import {\n  _freeze, _isFrozen,\n  _getOwnPropertyDescriptor, _defineProperty,\n  _create, _ownKeys, _isView, _Proxy,\n  _structuredClone, _jsonStringify, _isArray,\n  _reflectGet, _reflectHas, _reflectGetOwnPropertyDescriptor,\n  _reflectGetPrototypeOf, _reflectIsExtensible,\n  _objectPrototypeKeysFingerprint,\n  _fingerprintSort,\n} from './cached-builtins';\n\ndeclare function structuredClone<T>(value: T): T;\n\nexport interface IntegrityResult {\n  readonly intact: boolean;\n  readonly compromised: readonly string[];\n}\n\n// Table-driven builtin checks — keeps checkRuntimeIntegrity() below SonarCloud's\n// cognitive-complexity threshold (audit I2/I5).\nconst BUILTIN_CHECKS: readonly [string, () => boolean][] = [\n  ['Object.freeze', () => Object.freeze !== _freeze],\n  ['Object.isFrozen', () => Object.isFrozen !== _isFrozen],\n  ['Object.getOwnPropertyDescriptor', () => Object.getOwnPropertyDescriptor !== _getOwnPropertyDescriptor],\n  ['Object.defineProperty', () => Object.defineProperty !== _defineProperty],\n  ['Object.create', () => Object.create !== _create],\n  ['Reflect.ownKeys', () => Reflect.ownKeys !== _ownKeys],\n  ['ArrayBuffer.isView', () => ArrayBuffer.isView !== _isView],\n  ['Proxy', () => Proxy !== _Proxy],\n  ['Reflect', () => typeof Reflect !== 'object' || Reflect === null],\n  ['structuredClone', () => typeof structuredClone === 'function' && structuredClone !== _structuredClone],\n  ['JSON.stringify', () => JSON.stringify !== _jsonStringify],\n  ['Array.isArray', () => Array.isArray !== _isArray],\n  ['Reflect.get', () => Reflect.get !== _reflectGet],\n  ['Reflect.has', () => Reflect.has !== _reflectHas],\n  ['Reflect.getOwnPropertyDescriptor', () => Reflect.getOwnPropertyDescriptor !== _reflectGetOwnPropertyDescriptor],\n  ['Reflect.getPrototypeOf', () => Reflect.getPrototypeOf !== _reflectGetPrototypeOf],\n  ['Reflect.isExtensible', () => Reflect.isExtensible !== _reflectIsExtensible],\n];\n\nfunction computeObjectPrototypeFingerprint(): string {\n  const keys = _ownKeys(Object.prototype);\n  const normalized = keys.map(k =>\n    typeof k === 'symbol' ? k.description ?? 'sym' : String(k)\n  ).sort(_fingerprintSort);\n  return keys.length + ':' + normalized.join(',');\n}\n\n/**\n * Check if critical JS builtins have been tampered with since module load.\n * Compares current global references to the cached copies captured at import time.\n *\n * Use at app startup or before critical operations to detect\n * prototype override attacks (e.g. `Object.freeze = x => x`).\n *\n * @returns Frozen result with `intact` flag and list of compromised builtins\n */\nexport function checkRuntimeIntegrity(): IntegrityResult {\n  const compromised: string[] = BUILTIN_CHECKS\n    .filter(([, check]) => check())\n    .map(([name]) => name);\n\n  if (computeObjectPrototypeFingerprint() !== _objectPrototypeKeysFingerprint) {\n    compromised.push('Object.prototype');\n  }\n\n  return _freeze({ intact: compromised.length === 0, compromised: _freeze(compromised) });\n}\n"],"mappings":"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","names":["index_exports","__export","assertDeepFrozen","assertImmutableView","checkRuntimeIntegrity","deepFreeze","freezeShallow","immutableMapView","immutableSetView","immutableView","isDeepFrozen","isImmutableView","lock","secureSnapshot","snapshot","tamperEvident","vault","__toCommonJS","_freeze","_isFrozen","_getOwnPropertyDescriptor","_defineProperty","_create","_ownKeys","_isView","_Proxy","_structuredClone","_jsonStringify","_isArray","_reflectGet","_reflectHas","_reflectGetOwnPropertyDescriptor","_reflectGetPrototypeOf","_reflectIsExtensible","_fingerprintSort","a","b","_objectPrototypeKeysFingerprint","k","_a","_selfTest","isFreezable","val","freezeShallow","val","isFreezable","_freeze","deepClone","value","_structuredClone","err","freezeDeep","obj","seen","freezePrototypeChain","_isView","key","_ownKeys","desc","_getOwnPropertyDescriptor","isFreezable","proto","_freeze","deepFreeze","val","options","isFreezable","freezeDeep","wrapValue","val","createProxy","isFreezable","wrapIterator","iter","step","wrapEntriesIterator","k","v","wrapMapMethod","target","prop","key","cb","thisArg","m","wrapSetMethod","wrapped","_v2","s","proxyCache","immutableRegistry","MAP_MUTATORS","SET_MUTATORS","WEAKMAP_MUTATORS","WEAKSET_MUTATORS","ARRAY_MUTATORS","DATE_MUTATORS","MUTATOR_MAP","rejectMutation","op","hasInternalSlots","target","MAP_READ_METHODS","SET_READ_METHODS","WEAKMAP_READ_METHODS","WEAKSET_READ_METHODS","DATE_READ_METHODS","READ_METHOD_MAP","getBlockedMutator","prop","ctor","mutators","isSuspectSlottedMethod","value","reads","isFrozenDescriptor","desc","_reflectGetOwnPropertyDescriptor","resolveGetOverride","isSlotted","makeProxy","blocked","wrapped","wrapMapMethod","wrapSetMethod","createImmutableProxy","obj","proxy","_Proxy","receiver","opts","targetOptionsCache","_reflectGet","override","isFreezable","_t","proto","_reflectGetPrototypeOf","_reflectHas","_ownKeys","__spreadProps","__spreadValues","_reflectIsExtensible","thisArg","args","immutableView","val","options","isImmutableView","assertImmutableView","label","msg","_map","_ImmutableMap_instances","frozenValues_fn","frozenEntries_fn","ImmutableMap","source","__privateAdd","__privateSet","k","v","__privateGet","isFreezable","deepClone","key","val","freezeDeep","__privateMethod","callbackfn","value","_set","_ImmutableSet_instances","ImmutableSet","immutableMapView","immutableSetView","childrenOf","node","_isArray","__yieldStar","key","_ownKeys","desc","_getOwnPropertyDescriptor","nullifyPlainPrototypes","seen","child","snapshot","value","isFreezable","clone","deepClone","freezeDeep","lock","isNonPlainObject","value","secureNestedValue","key","raw","_a","_b","secureSnapshot","err","target","_create","store","_ownKeys","desc","_getOwnPropertyDescriptor","_defineProperty","_freeze","hashString","str","_a","h1","h2","i","c","part1","part2","stringifyPrimitive","val","_jsonStringify","stringifyObjectKeys","obj","seen","allKeys","_ownKeys","strKeys","symKeys","k","a","b","readKey","desc","_getOwnPropertyDescriptor","stableStringify","strPairs","symPairs","v","entries","items","tamperEvident","value","stored","deepClone","isFreezable","freezeDeep","fingerprint","get","copy","verify","_freeze","frozenCopy","val","isFreezable","clone","deepClone","freezeDeep","vault","value","stored","_freeze","isDeepFrozen","val","seen","isFreezable","obj","_isFrozen","key","_ownKeys","desc","_getOwnPropertyDescriptor","assertDeepFrozen","label","msg","BUILTIN_CHECKS","_freeze","_isFrozen","_getOwnPropertyDescriptor","_defineProperty","_create","_ownKeys","_isView","_Proxy","_structuredClone","_jsonStringify","_isArray","_reflectGet","_reflectHas","_reflectGetOwnPropertyDescriptor","_reflectGetPrototypeOf","_reflectIsExtensible","computeObjectPrototypeFingerprint","keys","normalized","k","_a","_fingerprintSort","checkRuntimeIntegrity","compromised","check","name","_objectPrototypeKeysFingerprint"]}