@poe-platform/safe-js 0.1.364 → 0.1.366

package/dist/safe-js/chunks/{chunk-OTFEHCGJ.js → chunk-BKYW2WCU.js}

@@ -7001,8 +7001,67 @@ function requireUint8Array(value) {
   return value;
 }
 
-// packages/safe-js/src/interp/date.ts
+// packages/safe-js/src/interp/data-view.ts
 import { types as types3 } from "node:util";
+var dataViewPrototypes = /* @__PURE__ */ new WeakMap();
+var dataViewLayouts = /* @__PURE__ */ new WeakMap();
+var dataViewGetters = Object.fromEntries(["buffer", "byteOffset", "byteLength"].map((key) => [key, Object.getOwnPropertyDescriptor(DataView.prototype, key).get]));
+var resize = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize")?.value;
+function isSandboxDataView(value) {
+  return types3.isDataView(value) && Object.getPrototypeOf(value) === DataView.prototype;
+}
+function dataViewBuffer(value) {
+  const buffer = Reflect.apply(dataViewGetters.buffer, value, []);
+  if (!isSandboxArrayBuffer(buffer)) throw new TypeError("DataView requires a non-shared ArrayBuffer.");
+  return buffer;
+}
+function dataViewLayout(value) {
+  const buffer = dataViewBuffer(value);
+  if (arrayBufferDetached(buffer)) return { byteOffset: 0, byteLength: 0 };
+  if (arrayBufferOptions(buffer) !== void 0) {
+    const layout = dataViewLayouts.get(value);
+    if (layout === void 0) throw new TypeError("Resizable DataView persistence requires known view layout.");
+    return layout;
+  }
+  return {
+    byteOffset: Reflect.apply(dataViewGetters.byteOffset, value, []),
+    byteLength: Reflect.apply(dataViewGetters.byteLength, value, [])
+  };
+}
+function restoreDataView(buffer, byteOffset, byteLength, budget) {
+  const originalLength = arrayBufferLength(buffer);
+  const required = byteOffset + (byteLength ?? 0);
+  const options = arrayBufferOptions(buffer);
+  const grow = required > originalLength;
+  if (grow) {
+    if (resize === void 0 || options === void 0 || required > options.maxByteLength)
+      throw new RangeError("DataView layout exceeds backing capacity.");
+    budget?.allocateArrayLength(required);
+    budget?.provisionDataUsage(required - originalLength)();
+    Reflect.apply(resize, buffer, [required]);
+  }
+  try {
+    const view = new DataView(buffer, byteOffset, byteLength);
+    if (options !== void 0) dataViewLayouts.set(view, { byteOffset, ...byteLength === void 0 ? {} : { byteLength } });
+    return view;
+  } finally {
+    if (grow) Reflect.apply(resize, buffer, [originalLength]);
+  }
+}
+function copyDataViewStorage(value, state) {
+  const layout = dataViewLayout(value);
+  return restoreDataView(copyArrayBufferStorage(dataViewBuffer(value), state), layout.byteOffset, layout.byteLength);
+}
+function dataViewDataProperties(value) {
+  return Reflect.ownKeys(value).map((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor)) throw new TypeError("DataView accessors cannot be copied as data.");
+    return [key, descriptor];
+  });
+}
+
+// packages/safe-js/src/interp/date.ts
+import { types as types4 } from "node:util";
 var NativeDate = Date;
 var readTime = NativeDate.prototype.getTime;
 var writeTime = NativeDate.prototype.setTime;
@@ -7019,7 +7078,7 @@ function dateTime(value) {
   return Reflect.apply(readTime, value, []);
 }
 function copyNativeDate(value) {
-  if (!types3.isDate(value)) return void 0;
+  if (!types4.isDate(value)) return void 0;
   if (Object.getPrototypeOf(value) !== NativeDate.prototype)
     throw new TypeError("Date subclasses are not supported.");
   return createSandboxDate(dateTime(value));
@@ -7454,7 +7513,7 @@ function copySandboxArgumentProperties(source, target, copyValue) {
 }
 
 // packages/safe-js/src/interp/boxed.ts
-import { types as types4 } from "node:util";
+import { types as types5 } from "node:util";
 var boxes = /* @__PURE__ */ new WeakSet();
 var numberValue = Number.prototype.valueOf;
 var stringValue = String.prototype.valueOf;
@@ -7462,11 +7521,11 @@ var booleanValue = Boolean.prototype.valueOf;
 var symbolValue = Symbol.prototype.valueOf;
 var bigintValue = BigInt.prototype.valueOf;
 function nativeBoxedValue(value) {
-  if (types4.isNumberObject(value)) return Reflect.apply(numberValue, value, []);
-  if (types4.isStringObject(value)) return Reflect.apply(stringValue, value, []);
-  if (types4.isBooleanObject(value)) return Reflect.apply(booleanValue, value, []);
-  if (types4.isSymbolObject(value)) return Reflect.apply(symbolValue, value, []);
-  if (types4.isBigIntObject(value)) return Reflect.apply(bigintValue, value, []);
+  if (types5.isNumberObject(value)) return Reflect.apply(numberValue, value, []);
+  if (types5.isStringObject(value)) return Reflect.apply(stringValue, value, []);
+  if (types5.isBooleanObject(value)) return Reflect.apply(booleanValue, value, []);
+  if (types5.isSymbolObject(value)) return Reflect.apply(symbolValue, value, []);
+  if (types5.isBigIntObject(value)) return Reflect.apply(bigintValue, value, []);
   return void 0;
 }
 function createSandboxBox(value) {
@@ -7645,7 +7704,7 @@ async function withRunResources(signal, execute) {
 }
 
 // packages/safe-js/src/interp/host-capabilities.ts
-import { types as types5 } from "node:util";
+import { types as types6 } from "node:util";
 var MAX_INDEXED_LENGTH = 65536;
 var MAX_NAMED_KEYS = 65536;
 var MAX_NAMED_KEY_CODE_UNITS = 1048576;
@@ -7700,7 +7759,7 @@ function createLiveHostObject(definition, controller) {
     for (const name of ["keys", "get", "set", "delete"]) {
       const operation = data[name];
       if (operation === void 0 && (name === "set" || name === "delete")) continue;
-      if (typeof operation !== "function" || types5.isProxy(operation) || types5.isAsyncFunction(operation) || types5.isGeneratorFunction(operation))
+      if (typeof operation !== "function" || types6.isProxy(operation) || types6.isAsyncFunction(operation) || types6.isGeneratorFunction(operation))
         throw new TypeError(`Named ${name} must be a synchronous non-generator function, not a proxy.`);
     }
     if (typeof data.maxKeys !== "number" || !Number.isInteger(data.maxKeys) || data.maxKeys < 1 || data.maxKeys > MAX_NAMED_KEYS)
@@ -7747,13 +7806,13 @@ function createLiveHostObject(definition, controller) {
   controller.chargeWork(properties.size + Object.keys(operations).length + 1);
   const host = Object.freeze(/* @__PURE__ */ Object.create(null));
   const guest = Object.freeze(/* @__PURE__ */ Object.create(null));
-  const methods = new Map(
+  const methods2 = new Map(
     Object.entries(operations).map(([name, operation]) => [
       name,
       controller.method(operation)
     ])
   );
-  const state = { host, guest, controller, properties, methods, indexed, named };
+  const state = { host, guest, controller, properties, methods: methods2, indexed, named };
   hostObjects.set(host, state);
   guestObjects.set(guest, state);
   return host;
@@ -7955,7 +8014,7 @@ function namedMutationKeys(state, key, create) {
 function namedKeys(state) {
   const named = state.named;
   return state.controller.read(named.keys, (value) => {
-    if (!Array.isArray(value) || types5.isProxy(value))
+    if (!Array.isArray(value) || types6.isProxy(value))
       throw new TypeError("Named keys must be a dense own-data array of strings, not a proxy.");
     const length = Object.getOwnPropertyDescriptor(value, "length").value;
     if (length > named.maxKeys) throw new RangeError("Named keys exceed maxKeys.");
@@ -8141,11 +8200,11 @@ function isIntrinsicFunction(value) {
 function registerIntrinsicPrototype(budget, prototype, constructor) {
   if (constructor.name === void 0) throw new TypeError("Intrinsic constructors require an installation name.");
   registerBuiltinIdentities(budget, { [constructor.name]: constructor });
-  const methods = [prototype, materializeFunctionProperties(constructor)].flatMap((owner) => Reflect.ownKeys(owner).flatMap((key) => {
+  const methods2 = [prototype, materializeFunctionProperties(constructor)].flatMap((owner) => Reflect.ownKeys(owner).flatMap((key) => {
     const descriptor = Object.getOwnPropertyDescriptor(owner, key);
     return [descriptor.value, ...retainedAccessorClosures(descriptor)];
   })).filter(isGuestClosure);
-  trackIntrinsicState(budget, prototype, constructor, [prototype, constructor, ...methods]);
+  trackIntrinsicState(budget, prototype, constructor, [prototype, constructor, ...methods2]);
 }
 function registerIntrinsicFunction(budget, closure) {
   if (closure.name === void 0) throw new TypeError("Intrinsic functions require an installation name.");
@@ -8154,8 +8213,8 @@ function registerIntrinsicFunction(budget, closure) {
   trackIntrinsicState(budget, closure, closure, [closure]);
 }
 function registerIntrinsicObject(budget, value) {
-  const methods = Object.values(Object.getOwnPropertyDescriptors(value)).map((descriptor) => descriptor.value).filter(isGuestClosure);
-  trackIntrinsicState(budget, value, value, [value, ...methods]);
+  const methods2 = Object.values(Object.getOwnPropertyDescriptors(value)).map((descriptor) => descriptor.value).filter(isGuestClosure);
+  trackIntrinsicState(budget, value, value, [value, ...methods2]);
 }
 function trackIntrinsicState(budget, root, owner, targets) {
   let roots = intrinsicPrototypeRoots.get(budget);
@@ -8228,6 +8287,7 @@ function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
   if (budget === void 0) return null;
   if (isSandboxArrayBuffer(value)) return budget === void 0 ? null : arrayBufferPrototypes.get(budget) ?? null;
+  if (isSandboxDataView(value)) return dataViewPrototypes.get(budget) ?? null;
   if (isNumericTypedArray(value)) return budget === void 0 ? null : typedArrayPrototypes.get(budget)?.get(typedArrayStorage(value).Native) ?? null;
   const errorType = sandboxErrorTypes.get(value);
   if (budget !== void 0 && errorType !== void 0) {
@@ -8338,6 +8398,7 @@ function setSandboxPrototype(value, prototype, budget) {
   prototypes.set(value, prototype);
 }
 function isPrototypeRecord(value) {
+  if (isSandboxDataView(value)) return true;
   if (isSandboxArrayBuffer(value)) return true;
   if (isNumericTypedArray(value)) return true;
   if (isGuestClosure(value)) return true;
@@ -8603,7 +8664,7 @@ function restoreRegexProperties(value, data, decode) {
 }
 
 // packages/safe-js/src/snapshot/validation.ts
-import { types as types7 } from "node:util";
+import { types as types8 } from "node:util";
 
 // packages/safe-js/src/interp/builtin-call.ts
 async function invokeBuiltinClosure(closure, args, budget, context, thisValue, construct = false) {
@@ -11017,7 +11078,7 @@ function formatNumber(value, methodName, argument, budget) {
 }
 
 // packages/safe-js/src/interp/methods/string.ts
-import { types as types6 } from "node:util";
+import { types as types7 } from "node:util";
 
 // packages/safe-js/src/interp/methods/string-locale.ts
 var collatorOptions = [
@@ -11168,7 +11229,7 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
   };
   const symbol = methodName === "match" ? Symbol.match : methodName === "search" ? Symbol.search : methodName === "matchAll" ? Symbol.matchAll : methodName === "replace" || methodName === "replaceAll" ? Symbol.replace : methodName === "split" ? Symbol.split : void 0;
   const pattern = args[0];
-  if (symbol !== void 0 && types6.isRegExp(pattern))
+  if (symbol !== void 0 && types7.isRegExp(pattern))
     throw new TypeError(`String#${methodName} does not accept unbranded host RegExp values.`);
   if (symbol === void 0 || pattern === null || pattern === void 0) return fallback();
   const readProperty = (key) => context?.getProperty !== void 0 ? context.getProperty(pattern, key) : key === "flags" && isSandboxRegex(pattern) && getSandboxPropertyDescriptor(pattern, key, budget) === void 0 ? getRegexMember(pattern, key, budget, context) : getSandboxDataProperty(pattern, key, budget);
@@ -11920,7 +11981,7 @@ function createPrimitiveConstructor(options, budget) {
       writable: isSandboxClosure(value),
       configurable: isSandboxClosure(value)
     });
-  const methods = /* @__PURE__ */ new Map([
+  const methods2 = /* @__PURE__ */ new Map([
     [
       "valueOf",
       createSandboxClosure({
@@ -11932,9 +11993,9 @@ function createPrimitiveConstructor(options, budget) {
     ]
   ]);
   if (kind === "number") {
-    for (const name of numberMethodNames) methods.set(name, getNumberMember(name, budget));
+    for (const name of numberMethodNames) methods2.set(name, getNumberMember(name, budget));
   } else {
-    methods.set(
+    methods2.set(
       "toString",
       createSandboxClosure({
         sandbox: true,
@@ -11944,9 +12005,9 @@ function createPrimitiveConstructor(options, budget) {
       })
     );
     if (kind === "string")
-      for (const name of stringMethodNames) methods.set(name, getStringMember("", name, budget));
+      for (const name of stringMethodNames) methods2.set(name, getStringMember("", name, budget));
   }
-  for (const [name, value] of methods)
+  for (const [name, value] of methods2)
     Object.defineProperty(prototype, name, { value, writable: true, configurable: true });
   installBoxedPrototype(budget, prototype, constructor);
   return constructor;
@@ -19804,7 +19865,7 @@ function toPropertyKey(value, budget, context) {
 }
 
 // packages/safe-js/src/interp/globals/object.ts
-function createObjectGlobal(methods, budget) {
+function createObjectGlobal(methods2, budget) {
   const construct = ([value]) => {
     if (value === null || value === void 0) {
       budget.chargeDataUsage(1);
@@ -19839,7 +19900,7 @@ function createObjectGlobal(methods, budget) {
   const properties = materializeFunctionProperties(constructor);
   const prototype = properties.prototype;
   Object.defineProperty(properties, "prototype", { writable: false });
-  for (const [name, method] of Object.entries(methods)) {
+  for (const [name, method] of Object.entries(methods2)) {
     Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
   }
   const prototypeMethods = {
@@ -21896,6 +21957,39 @@ function snapshotTypedArrayConstructor(value) {
   return numericTypedArrayConstructors[value.arrayType];
 }
 
+// packages/safe-js/src/snapshot/data-view.ts
+function encodeDataViewLayout(value) {
+  const layout = dataViewLayout(value);
+  return {
+    kind: "dataview",
+    byteOffset: layout.byteOffset,
+    byteLength: layout.byteLength ?? 0,
+    ...layout.byteLength === void 0 ? { lengthTracking: true } : {}
+  };
+}
+function captureDataViewState(value, encode) {
+  return {
+    properties: serializePropertyDescriptors(value, encode),
+    ...hasExplicitSandboxPrototype(value) ? { prototype: encode(getSandboxPrototype(value)) } : {}
+  };
+}
+function validateDataViewStorage(value) {
+  if (!Number.isSafeInteger(value.byteOffset) || Number(value.byteOffset) < 0 || !Number.isSafeInteger(value.byteLength) || Number(value.byteLength) < 0 || !Number.isSafeInteger(Number(value.byteOffset) + Number(value.byteLength)))
+    throw new TypeError("Invalid DataView dimensions.");
+  if (!Object.hasOwn(value, "buffer") || Object.hasOwn(value, "bytes")) throw new TypeError("DataView requires a backing buffer reference.");
+  if (Object.hasOwn(value, "lengthTracking") && (value.lengthTracking !== true || value.byteLength !== 0))
+    throw new TypeError("Invalid DataView length-tracking layout.");
+}
+function decodeDataViewStorage(value, resolve, budget) {
+  validateDataViewStorage(value);
+  const buffer = resolve(value.buffer);
+  if (!isSandboxArrayBuffer(buffer)) throw new TypeError("Invalid DataView backing reference.");
+  if (value.lengthTracking === true && arrayBufferOptions(buffer) === void 0)
+    throw new TypeError("Length-tracking DataView requires resizable storage.");
+  budget?.provisionDataUsage(1)();
+  return restoreDataView(buffer, Number(value.byteOffset), value.lengthTracking === true ? void 0 : Number(value.byteLength), budget);
+}
+
 // packages/safe-js/src/snapshot/array-buffer.ts
 function captureArrayBufferState(value, encode) {
   return {
@@ -22077,10 +22171,10 @@ function serializeDumpValue(value, path, state) {
     }
     return { kind: "ref", id };
   }
-  if (hasGuestObjectState(value) && !(state.trustedRunReplay && (isSandboxDate(value) || isSandboxPromise(value) || isPromiseResolvingFunction(value)))) {
+  if (hasGuestObjectState(value) && !isSandboxDataView(value) && !(state.trustedRunReplay && (isSandboxDate(value) || isSandboxPromise(value) || isPromiseResolvingFunction(value)))) {
     throw new TypeError("Guest function properties and prototype links cannot be serialized.");
   }
-  if (isSandboxArrayBuffer(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxBox(value) || isSandboxDate(value) || isNumericTypedArray(value)) return serializeHeapReference(value, path, state);
+  if (isSandboxDataView(value) || isSandboxArrayBuffer(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxBox(value) || isSandboxDate(value) || isNumericTypedArray(value)) return serializeHeapReference(value, path, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path, state);
     if (reference2 !== void 0) {
@@ -22152,6 +22246,18 @@ function serializeHeapReference(value, path, state) {
         const serialized = serializeDumpValue(entry, `${path}.<date-property>`, state);
         return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
       });
+    } else if (isSandboxDataView(value)) {
+      state.heap[String(id)] = {
+        ...encodeDataViewLayout(value),
+        buffer: serializeHeapReference(dataViewBuffer(value), `${path}.buffer`, state),
+        state: captureDataViewState(value, (entry) => {
+          if (entry === void 0) return { kind: "undefined" };
+          if (Object.is(entry, -0)) return { kind: "number", value: "-0" };
+          const serialized = serializeDumpValue(entry, `${path}.<view>`, state);
+          if (serialized === SKIP_VALUE) throw new TypeError("Unsupported DataView property in public dump.");
+          return serialized;
+        })
+      };
     } else if (isSandboxArrayBuffer(value)) {
       state.heap[String(id)] = {
         ...encodeArrayBufferStorage(value, id, state.float32Buffers, (id2) => ({ kind: "ref", id: id2 })),
@@ -22231,7 +22337,7 @@ function indexHeapContainers(snapshot) {
   const heapIds = /* @__PURE__ */ new Map();
   let nextId = 1;
   for (const [value, stat2] of stats.entries()) {
-    if (stat2.count > 1 || stat2.forceHeap === true || guestValues.has(value) || stat2.cyclic || hasNullObjectPrototype(value) || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isNumericTypedArray(value) || isSandboxArrayBuffer(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat2.count > 1 || stat2.forceHeap === true || guestValues.has(value) || stat2.cyclic || hasNullObjectPrototype(value) || ownSerializableSymbolKeys(value).length > 0 || isSandboxBox(value) || isSandboxRegExpIterator(value) || isSandboxRegex(value) && hasCustomRegexProperties(value) || isSandboxDate(value) || isNumericTypedArray(value) || isSandboxArrayBuffer(value) || isSandboxDataView(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -22263,8 +22369,12 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
   stat2.expanded = true;
   ancestors.add(value);
   const guestEntries = [];
+  if (isSandboxDataView(value)) guestEntries.push(dataViewBuffer(value));
   if (isNumericTypedArray(value)) guestEntries.push(typedArrayStorage(value).buffer);
-  const guest = isSandboxArrayBuffer(value) ? { kind: "arraybuffer", state: captureArrayBufferState(value, (entry) => {
+  const guest = isSandboxDataView(value) ? { kind: "dataview", state: captureDataViewState(value, (entry) => {
+    guestEntries.push(entry);
+    return null;
+  }) } : isSandboxArrayBuffer(value) ? { kind: "arraybuffer", state: captureArrayBufferState(value, (entry) => {
     guestEntries.push(entry);
     return null;
   }) } : captureGuestHeapNode(value, (entry) => {
@@ -22272,7 +22382,7 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
     return null;
   });
   if (guest !== void 0) {
-    if (!isSandboxArrayBuffer(value)) guestValues.add(value);
+    if (!isSandboxArrayBuffer(value) && !isSandboxDataView(value)) guestValues.add(value);
     for (const entry of guestEntries) {
       collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
       if (entry !== null && typeof entry === "object") stats.get(entry).forceHeap = true;
@@ -22600,10 +22710,10 @@ function encodeReplayData(value, options = {}) {
         ...symbolProperties.length === 0 ? {} : { symbolProperties },
         ...Object.isExtensible(entry) ? {} : { extensible: false }
       };
-    } else if (isSandboxArrayBuffer(entry)) {
-      const storage = encodeArrayBufferStorage(entry, id, float32Buffers, (id2) => ({ tag: "ref", id: id2 }));
+    } else if (isSandboxArrayBuffer(entry) || isSandboxDataView(entry)) {
+      const storage = isSandboxDataView(entry) ? { ...encodeDataViewLayout(entry), buffer: child(dataViewBuffer(entry), "<buffer>") } : encodeArrayBufferStorage(entry, id, float32Buffers, (id2) => ({ tag: "ref", id: id2 }));
       const properties = /* @__PURE__ */ Object.create(null);
-      for (const [key, descriptor] of arrayBufferDataProperties(entry)) {
+      for (const [key, descriptor] of isSandboxDataView(entry) ? dataViewDataProperties(entry) : arrayBufferDataProperties(entry)) {
         if (typeof key === "symbol") continue;
         properties[key] = {
           value: child(descriptor.value, key),
@@ -22846,9 +22956,9 @@ function decodeReplayData(input, options = {}, parent) {
         if (node.extensible === false) Object.preventExtensions(result3);
         return result3;
       }
-      if (kind === "arraybuffer") {
+      if (kind === "arraybuffer" || kind === "dataview") {
         if (typeof node.extensible !== "boolean") throw new TypeError("Invalid ArrayBuffer extensibility.");
-        const result3 = decodeArrayBufferStorage(node, child, compilation.owner?.budget, detachBuffers);
+        const result3 = kind === "dataview" ? decodeDataViewStorage(node, child, compilation.owner?.budget) : decodeArrayBufferStorage(node, child, compilation.owner?.budget, detachBuffers);
         restored.set(id, result3);
         initializeValues.push(() => {
           defineProperties(result3, record2(own(node, "properties")), child, node.symbolEntries);
@@ -23746,6 +23856,38 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
     state.seen.set(value, date);
     return date;
   }
+  if (isSandboxDataView(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const buffer = dataViewBuffer(value);
+    const length = arrayBufferLength(buffer);
+    budget.allocateArrayLength(arrayBufferOptions(buffer)?.maxByteLength ?? length);
+    budget.provisionDataUsage(length + 2)();
+    const copy = copyDataViewStorage(value, state);
+    state.seen.set(value, copy);
+    copyHostValueToSandbox(
+      buffer,
+      stackFrames,
+      { ...options, capabilityPath: [...options.capabilityPath ?? [], "buffer"] },
+      state,
+      `${path}.buffer`
+    );
+    for (const [key, descriptor] of dataViewDataProperties(value)) {
+      if (typeof key !== "string") throw new TypeError("Host DataView symbol properties require an explicit capability path.");
+      Object.defineProperty(copy, key, {
+        ...descriptor,
+        value: copyHostValueToSandbox(
+          descriptor.value,
+          stackFrames,
+          { ...options, capabilityPath: [...options.capabilityPath ?? [], key] },
+          state,
+          joinPath(path, key)
+        )
+      });
+    }
+    if (!Object.isExtensible(value)) Object.preventExtensions(copy);
+    return copy;
+  }
   if (isSandboxArrayBuffer(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
@@ -24135,9 +24277,9 @@ function createDateGlobal(options) {
       call: (args, context) => coerceDateParts(args, true, options.budget, context)
     })
   };
-  const methods = /* @__PURE__ */ new Map();
+  const methods2 = /* @__PURE__ */ new Map();
   for (const [name, method] of dateMethods)
-    methods.set(
+    methods2.set(
       name,
       createSandboxClosure({
         guest: true,
@@ -24157,8 +24299,8 @@ function createDateGlobal(options) {
         }
       })
     );
-  methods.set("toGMTString", methods.get("toUTCString"));
-  methods.set(Symbol.toPrimitive, createSandboxClosure({
+  methods2.set("toGMTString", methods2.get("toUTCString"));
+  methods2.set(Symbol.toPrimitive, createSandboxClosure({
     guest: true,
     sandbox: true,
     name: "[Symbol.toPrimitive]",
@@ -24174,7 +24316,7 @@ function createDateGlobal(options) {
   for (const [key, value] of Object.entries(staticProperties))
     Object.defineProperty(properties, key, { value, writable: key !== "prototype", configurable: key !== "prototype" });
   Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
-  for (const [key, value] of methods)
+  for (const [key, value] of methods2)
     Object.defineProperty(prototype, key, { value, writable: key !== Symbol.toPrimitive, configurable: true });
   installDatePrototype(options.budget, prototype, constructor);
   return constructor;
@@ -24626,7 +24768,7 @@ function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
       return context.thisValue.values.size;
     }
   });
-  for (const { name, constructor, methods, size, iterator } of [
+  for (const { name, constructor, methods: methods2, size, iterator } of [
     { name: "Map", constructor: mapConstructor, methods: mapMethods, size: mapSize, iterator: mapMethods.entries },
     { name: "Set", constructor: setConstructor, methods: setMethods, size: setSize, iterator: setMethods.values }
   ]) {
@@ -24641,13 +24783,13 @@ function installCollectionPrototypes(budget, mapConstructor, setConstructor) {
     Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
     Object.defineProperty(materializeFunctionProperties(constructor), Symbol.species, { get: accessorAdapter(species, "get"), configurable: true });
     Object.defineProperty(prototype, "constructor", { value: constructor, writable: true, configurable: true });
-    for (const [key, method] of Object.entries(methods))
+    for (const [key, method] of Object.entries(methods2))
       Object.defineProperty(prototype, key, { value: method, writable: true, configurable: true });
     Object.defineProperty(prototype, "size", { get: accessorAdapter(size, "get"), configurable: true });
     Object.defineProperty(prototype, Symbol.toStringTag, { value: name, configurable: true });
     Object.defineProperty(prototype, Symbol.iterator, { value: iterator, writable: true, configurable: true });
     installCollectionPrototype(budget, name, prototype, constructor);
-    for (const method of /* @__PURE__ */ new Set([...Object.values(methods), size, species])) registerIntrinsicFunction(budget, method);
+    for (const method of /* @__PURE__ */ new Set([...Object.values(methods2), size, species])) registerIntrinsicFunction(budget, method);
   }
 }
 
@@ -25413,55 +25555,114 @@ function createRegexGlobals(options) {
   return { RegExp: constructor };
 }
 
-// packages/safe-js/src/interp/globals/misc.ts
-function createMiscGlobals(options) {
-  return {
-    structuredClone: createSandboxClosure({
-      sandbox: true,
-      call: ([value], context) => structuredCloneSandboxValue(value, options.budget, context?.compilation),
-      name: "structuredClone"
-    }),
-    ...createNumericParsers(options.budget),
-    isNaN: createSandboxClosure({
-      sandbox: true,
-      call: ([value], context) => {
-        const number = sandboxNumber(value, options.budget, context);
-        return typeof number === "number" ? Number.isNaN(number) : number.then(Number.isNaN);
-      },
-      name: "isNaN"
-    }),
-    isFinite: createSandboxClosure({
-      sandbox: true,
-      call: ([value], context) => {
-        const number = sandboxNumber(value, options.budget, context);
-        return typeof number === "number" ? Number.isFinite(number) : number.then(Number.isFinite);
-      },
-      name: "isFinite"
+// packages/safe-js/src/interp/globals/structured-clone.ts
+var transferBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
+function createStructuredCloneGlobal(budget) {
+  return createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "structuredClone",
+    length: 1,
+    call: (args, context) => {
+      if (args.length === 0) throw new TypeError("structuredClone requires a value argument.");
+      const [value, options] = args;
+      if (options === void 0 || options === null) return cloneStructuredValue(value, [], budget, context);
+      if (typeof options !== "object") throw new TypeError("structuredClone options must be an object.");
+      return cloneWithOptions(value, options, budget, context);
+    }
+  });
+}
+async function cloneWithOptions(value, options, budget, context) {
+  const bridge = {
+    ...context,
+    stack: context?.stack ?? [],
+    thisValue: void 0,
+    getProperty: context?.getProperty ?? ((object, key) => {
+      const descriptor = getSandboxPropertyDescriptor(object, key, budget);
+      return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, object, context);
     })
   };
+  let current;
+  let iterator;
+  const items = [];
+  const release = retainValues(budget, () => [value, options, current, items, iterator?.retainedValue]);
+  try {
+    current = await bridge.getProperty(options, "transfer");
+    if (current !== void 0) {
+      if (current === null || typeof current !== "object") throw new TypeError("Transfer list must be an iterable object.");
+      iterator = await acquireSandboxIterator(current, budget, bridge);
+      if (iterator === void 0) throw new TypeError("Transfer list must be iterable.");
+      for (; ; ) {
+        budget.visitNode();
+        const result = await iterator.next();
+        current = result;
+        if ((await readIteratorResult(iterator, result, "done")).value) break;
+        current = (await readIteratorResult(iterator, result, "value")).value;
+        if (current === null || typeof current !== "object") {
+          throw new TypeError("Transfer list elements must be objects.");
+        }
+        budget.allocateArrayLength(items.length + 1);
+        budget.provisionDataUsage(items.length + 2)();
+        items.push(current);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const transfers = [];
+    for (const item of items) {
+      budget.visitNode();
+      if (!isSandboxArrayBuffer(item) || seen.has(item))
+        throw new DOMException("Invalid or duplicate transferable.", "DataCloneError");
+      seen.add(item);
+      transfers.push(item);
+    }
+    return cloneStructuredValue(value, transfers, budget, context);
+  } finally {
+    release();
+  }
 }
-function structuredCloneSandboxValue(value, budget, parent) {
+function cloneStructuredValue(value, transfers, budget, context) {
+  const parent = context?.compilation;
   const operation = budget.acquireCompileOwner(false, parent?.owner);
   const compilation = parent?.owner === operation.owner ? parent : new CompileScope(operation.owner);
+  const buffers = /* @__PURE__ */ new WeakMap();
+  let clone;
+  const release = retainValues(budget, () => [value, clone, transfers]);
   try {
-    const clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true, structuredClone: true });
+    let transferSize = 0;
+    for (const buffer of transfers) {
+      const length = arrayBufferLength(buffer);
+      budget.allocateArrayLength(arrayBufferOptions(buffer)?.maxByteLength ?? length);
+      transferSize += length + 1;
+      if (arrayBufferDetached(buffer)) buffers.set(buffer, new ArrayBuffer(0));
+    }
+    budget.provisionDataUsage(transferSize)();
+    clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true, structuredClone: true, float32Buffers: buffers });
     assertSandboxGraphDepth(clone);
     assertStructuredCloneable(clone, /* @__PURE__ */ new WeakSet());
     allocateProducedSandboxValue(clone, budget);
     if (compilation !== parent) reconcileCompiledValues(budget, [clone], compilation);
+    if (transfers.length > 0) {
+      createDataCheckpoint(budget, context)(clone, 0, true);
+      budget.visitNode(transferSize + transfers.length);
+      budget.provisionDataUsage(transferBuffer === void 0 ? transferSize : transfers.length)();
+      for (const buffer of transfers) {
+        if (arrayBufferDetached(buffer)) throw new DOMException("Cannot transfer a detached ArrayBuffer.", "DataCloneError");
+        if (transferBuffer !== void 0) Reflect.apply(transferBuffer, buffer, [0]);
+        else structuredClone(buffer, { transfer: [buffer] });
+        if (!arrayBufferDetached(buffer)) throw new DOMException("ArrayBuffer cannot be transferred.", "DataCloneError");
+      }
+    }
     return clone;
   } finally {
+    release();
     if (compilation !== parent) compilation.dispose();
     operation.release();
   }
 }
 function assertStructuredCloneable(value, seen) {
-  if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value)) {
-    throw new TypeError("structuredClone() cannot clone closures, promises, or collection iterators.");
-  }
-  if (typeof value !== "object" || value === null || seen.has(value)) {
-    return;
-  }
+  if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value))
+    throw new DOMException("Cannot clone closures, promises, or collection iterators.", "DataCloneError");
+  if (typeof value !== "object" || value === null || seen.has(value)) return;
   seen.add(value);
   if (isSandboxMap(value)) {
     for (const [key, entry] of value.entries) {
@@ -25471,14 +25672,34 @@ function assertStructuredCloneable(value, seen) {
     return;
   }
   if (isSandboxSet(value)) {
-    for (const entry of value.values) {
-      assertStructuredCloneable(entry, seen);
-    }
+    for (const entry of value.values) assertStructuredCloneable(entry, seen);
     return;
   }
-  for (const entry of Object.values(value)) {
-    assertStructuredCloneable(entry, seen);
-  }
+  for (const entry of Object.values(value)) assertStructuredCloneable(entry, seen);
+}
+
+// packages/safe-js/src/interp/globals/misc.ts
+function createMiscGlobals(options) {
+  return {
+    structuredClone: createStructuredCloneGlobal(options.budget),
+    ...createNumericParsers(options.budget),
+    isNaN: createSandboxClosure({
+      sandbox: true,
+      call: ([value], context) => {
+        const number = sandboxNumber(value, options.budget, context);
+        return typeof number === "number" ? Number.isNaN(number) : number.then(Number.isNaN);
+      },
+      name: "isNaN"
+    }),
+    isFinite: createSandboxClosure({
+      sandbox: true,
+      call: ([value], context) => {
+        const number = sandboxNumber(value, options.budget, context);
+        return typeof number === "number" ? Number.isFinite(number) : number.then(Number.isFinite);
+      },
+      name: "isFinite"
+    })
+  };
 }
 
 // packages/safe-js/src/interp/globals/uri.ts
@@ -25665,7 +25886,7 @@ function createSymbolGlobal(budget) {
   });
   const properties = materializeFunctionProperties(constructor);
   Object.defineProperty(properties, "prototype", { value: prototype });
-  const methods = {
+  const methods2 = {
     for: createSandboxClosure({
       sandbox: true,
       name: "for",
@@ -25691,7 +25912,7 @@ function createSymbolGlobal(budget) {
       }
     })
   };
-  for (const [name, method] of Object.entries(methods)) {
+  for (const [name, method] of Object.entries(methods2)) {
     Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
   }
   for (const [name, value] of Object.entries(wellKnownSymbols)) {
@@ -25707,28 +25928,28 @@ function createSymbolGlobal(budget) {
 }
 
 // packages/safe-js/src/interp/globals/bigint.ts
+async function sandboxBigInt(value, budget, context, allowNumber = false) {
+  const primitive = value !== null && typeof value === "object" ? await objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number") : value;
+  if (typeof primitive === "bigint") return primitive;
+  if (typeof primitive !== "string" && typeof primitive !== "boolean" && !(allowNumber && typeof primitive === "number"))
+    throw new TypeError("Cannot convert value to BigInt.");
+  const size = typeof primitive === "string" ? primitive.length : 256;
+  budget.visitNode(size);
+  const allocation = {};
+  budget.setRetainedDataUsage(allocation, size);
+  try {
+    return BigInt(primitive);
+  } finally {
+    budget.setRetainedDataUsage(allocation, 0);
+  }
+}
 function createBigIntGlobal(budget) {
-  const convert = async (value, context, allowNumber = false) => {
-    const primitive = value !== null && typeof value === "object" ? await objectToPrimitive(value, budget, context, /* @__PURE__ */ new Set(), "number") : value;
-    if (typeof primitive === "bigint") return primitive;
-    if (typeof primitive !== "string" && typeof primitive !== "boolean" && !(allowNumber && typeof primitive === "number"))
-      throw new TypeError("Cannot convert value to BigInt.");
-    const size = typeof primitive === "string" ? primitive.length : 256;
-    budget.visitNode(size);
-    const allocation = {};
-    budget.setRetainedDataUsage(allocation, size);
-    try {
-      return BigInt(primitive);
-    } finally {
-      budget.setRetainedDataUsage(allocation, 0);
-    }
-  };
   const constructor = createSandboxClosure({
     guest: true,
     sandbox: true,
     name: "BigInt",
     length: 1,
-    call: ([value], context) => convert(value, context, true)
+    call: ([value], context) => sandboxBigInt(value, budget, context, true)
   });
   const prototype = /* @__PURE__ */ Object.create(null);
   Object.defineProperties(prototype, {
@@ -25792,7 +26013,7 @@ function createBigIntGlobal(budget) {
           const number = await sandboxNumber(bits, budget, context);
           const width = Number.isNaN(number) ? 0 : Math.trunc(number);
           if (width < 0 || !Number.isSafeInteger(width)) throw new RangeError("Invalid BigInt width.");
-          const value = await convert(input, context);
+          const value = await sandboxBigInt(input, budget, context);
           const size = value.toString(16).length;
           budget.visitNode(size);
           if (width >= size * 4 + 1 && (name === "asIntN" || value >= 0n)) return value;
@@ -25813,7 +26034,7 @@ function createBigIntGlobal(budget) {
 
 // packages/safe-js/src/interp/globals/array-buffer.ts
 var resizeBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize")?.value;
-var transferBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
+var transferBuffer2 = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "transfer")?.value;
 function createArrayBufferGlobal(budget) {
   const prototype = /* @__PURE__ */ Object.create(null);
   const constructor = createSandboxClosure({
@@ -25986,9 +26207,9 @@ function createArrayBufferGlobal(budget) {
           const count = Math.min(length, arrayBufferLength(receiver));
           budget.visitNode(count);
           new Uint8Array(result, 0, count).set(new Uint8Array(receiver, 0, count));
-          if (transferBuffer !== void 0) {
+          if (transferBuffer2 !== void 0) {
             budget.provisionDataUsage(1)();
-            Reflect.apply(transferBuffer, receiver, [0]);
+            Reflect.apply(transferBuffer2, receiver, [0]);
           } else {
             budget.provisionDataUsage(arrayBufferLength(receiver) + 1)();
             budget.visitNode(arrayBufferLength(receiver));
@@ -26056,6 +26277,129 @@ function createArrayBufferGlobal(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/data-view.ts
+var methods = Object.fromEntries(["Int8", "Uint8", "Int16", "Uint16", "Int32", "Uint32", "Float32", "Float64", "BigInt64", "BigUint64"].flatMap((type) => ["get", "set"].map((operation) => [operation + type, Object.getOwnPropertyDescriptor(DataView.prototype, operation + type).value])));
+var readUint16 = DataView.prototype.getUint16;
+var writeUint16 = DataView.prototype.setUint16;
+methods.getFloat16 = function(...args) {
+  const bits = Reflect.apply(readUint16, this, args);
+  const sign = bits & 32768 ? -1 : 1;
+  const exponent = bits >> 10 & 31, fraction = bits & 1023;
+  if (exponent === 31) return fraction === 0 ? sign * Infinity : NaN;
+  return sign * (exponent === 0 ? fraction * 2 ** -24 : (1 + fraction / 1024) * 2 ** (exponent - 15));
+};
+methods.setFloat16 = function(...args) {
+  const rounded = f16round(args[1]);
+  const sign = rounded < 0 || Object.is(rounded, -0) ? 32768 : 0;
+  const magnitude = Math.abs(rounded);
+  let bits;
+  if (Number.isNaN(magnitude)) bits = 32256;
+  else if (magnitude === Infinity) bits = 31744;
+  else if (magnitude < 2 ** -14) bits = magnitude * 2 ** 24;
+  else {
+    const exponent = Math.floor(Math.log2(magnitude));
+    bits = exponent + 15 << 10 | (magnitude / 2 ** exponent - 1) * 1024;
+  }
+  return Reflect.apply(writeUint16, this, [args[0], sign | bits, args[2]]);
+};
+function createDataViewGlobal(budget) {
+  const prototype = /* @__PURE__ */ Object.create(null);
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "DataView",
+    length: 1,
+    call: () => {
+      throw new TypeError("DataView requires new.");
+    },
+    construct: async (args, context) => {
+      const buffer = args[0];
+      if (!isSandboxArrayBuffer(buffer)) throw new TypeError("DataView requires an ArrayBuffer.");
+      let selected;
+      const release = retainValues(budget, () => [...args, selected]);
+      try {
+        const offset = await dataViewIndex(args[1], budget, context);
+        if (arrayBufferDetached(buffer)) throw new TypeError("Cannot view a detached buffer.");
+        const length = arrayBufferLength(buffer);
+        if (offset > length) throw new RangeError("DataView offset exceeds buffer length.");
+        const size = args[2] === void 0 ? void 0 : await dataViewIndex(args[2], budget, context);
+        if (size !== void 0 && offset + size > length) throw new RangeError("DataView length exceeds buffer length.");
+        const target = context?.newTarget ?? constructor;
+        if (context?.getProperty !== void 0) selected = await context.getProperty(target, "prototype");
+        else {
+          const descriptor = getSandboxPropertyDescriptor(target, "prototype", budget);
+          selected = descriptor === void 0 ? void 0 : await readPropertyDescriptor(descriptor, target, context);
+        }
+        budget.provisionDataUsage(1)();
+        const value = new DataView(buffer, offset, size);
+        if (arrayBufferOptions(buffer) !== void 0) dataViewLayouts.set(value, { byteOffset: offset, ...size === void 0 ? {} : { byteLength: size } });
+        setSandboxPrototype(value, selected !== null && typeof selected === "object" ? selected : prototype, budget);
+        return value;
+      } finally {
+        release();
+      }
+    }
+  });
+  Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "DataView", configurable: true }
+  });
+  const getters = [];
+  for (const [name, getter] of Object.entries(dataViewGetters)) {
+    const closure = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: `get ${name}`,
+      length: 0,
+      call: (_args, context) => {
+        if (!isSandboxDataView(context?.thisValue)) throw new TypeError("DataView getter requires a DataView receiver.");
+        return Reflect.apply(getter, context.thisValue, []);
+      }
+    });
+    Object.defineProperty(prototype, name, { get: accessorAdapter(closure, "get"), configurable: true });
+    getters.push(closure);
+  }
+  for (const [name, method] of Object.entries(methods)) {
+    const setter = name.startsWith("set");
+    Object.defineProperty(prototype, name, {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name,
+        length: setter ? 2 : 1,
+        call: async (args, context) => {
+          const receiver = context?.thisValue;
+          if (!isSandboxDataView(receiver)) throw new TypeError("DataView method requires a DataView receiver.");
+          const release = retainValues(budget, () => [receiver, ...args]);
+          try {
+            const offset = await dataViewIndex(args[0], budget, context);
+            const value = setter ? name.startsWith("setBig") ? await sandboxBigInt(args[1], budget, context) : await sandboxNumber(args[1], budget, context) : void 0;
+            return Reflect.apply(method, receiver, setter ? [offset, value, Boolean(args[2])] : [offset, Boolean(args[1])]);
+          } finally {
+            release();
+          }
+        }
+      })
+    });
+  }
+  setSandboxPrototype(prototype, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
+  dataViewPrototypes.set(budget, prototype);
+  registerBuiltinIdentities(budget, { DataView: constructor });
+  registerIntrinsicFunction(budget, constructor);
+  for (const getter of getters) registerIntrinsicFunction(budget, getter);
+  registerIntrinsicObject(budget, prototype);
+  return constructor;
+}
+async function dataViewIndex(value, budget, context) {
+  const number = await sandboxNumber(value, budget, context);
+  const index = Number.isNaN(number) ? 0 : Math.trunc(number);
+  if (!Number.isSafeInteger(index) || index < 0) throw new RangeError("Invalid DataView index.");
+  return index;
+}
+
 // packages/safe-js/src/interp/globals.ts
 function createBuiltinBindings(options) {
   const bindings = {
@@ -26069,6 +26413,7 @@ function createBuiltinBindings(options) {
     ...createMathGlobals({ random: options.random, budget: options.budget }),
     ...createObjectArrayGlobals(options),
     ArrayBuffer: createArrayBufferGlobal(options.budget),
+    DataView: createDataViewGlobal(options.budget),
     ...createMiscGlobals(options),
     ...createUriGlobals(options.budget),
     ...createPromiseGlobals(options),
@@ -26805,8 +27150,9 @@ function validateDumpHeap(root, state) {
       validateDateRecord(entry, path);
       continue;
     }
-    if (entry.kind === "arraybuffer") {
-      validateArrayBufferStorage(entry);
+    if (entry.kind === "arraybuffer" || entry.kind === "dataview") {
+      if (entry.kind === "dataview") validateDataViewStorage(entry);
+      else validateArrayBufferStorage(entry);
       validateGuestHeapNode({ kind: "guest-object", state: entry.state }, heap, state.limits.maxEntries);
       continue;
     }
@@ -27033,7 +27379,7 @@ function validateHeapValue(value, path, state, heap) {
     fail("invalidValue", path, String(error));
   }
   validateErrorType(record4, path);
-  if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "typedarray", "arraybuffer", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record4.kind)))
+  if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "typedarray", "arraybuffer", "dataview", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record4.kind)))
     fail("unknownTag", `${path}.kind`, "unknown heap tag");
   validateValue(record4, path, 1, state);
   if (record4.kind === "symbol") validateSymbolRecord(record4, path, state);
@@ -27042,8 +27388,9 @@ function validateHeapValue(value, path, state, heap) {
   if (record4.kind === "object") requireRecord(record4.entries, `${path}.entries`);
   if (record4.kind === "boxed") validateBoxedRecord(record4, path, heap);
   if (record4.kind === "date") validateDateRecord(record4, path);
-  if (record4.kind === "arraybuffer") {
-    validateArrayBufferStorage(record4);
+  if (record4.kind === "arraybuffer" || record4.kind === "dataview") {
+    if (record4.kind === "dataview") validateDataViewStorage(record4);
+    else validateArrayBufferStorage(record4);
     validateGuestHeapNode({ kind: "guest-object", state: record4.state }, heap, state.limits.maxEntries);
   }
   if (record4.kind === "float32array" || record4.kind === "typedarray") {
@@ -27242,7 +27589,7 @@ function validateGenericValue(value, path, depth, state) {
   if (typeof value === "object" && value !== null && hasGuestObjectState(value)) {
     fail("invalidState", path, "guest function properties, prototype links and custom descriptors cannot be restored");
   }
-  if (state.dataPropertiesOnly && types7.isProxy(value)) {
+  if (state.dataPropertiesOnly && types8.isProxy(value)) {
     fail("invalidType", path, "proxy objects are not snapshot data");
   }
   if (depth > state.limits.maxDepth)
@@ -28042,6 +28389,7 @@ function measureSandboxData(values, options = {}) {
     const prototype = getSandboxPrototype(value);
     if (prototype !== null) visit(prototype, depth + 1);
     if (isSandboxArrayBuffer(value)) usage += arrayBufferLength(value);
+    if (isSandboxDataView(value)) visit(dataViewBuffer(value), depth + 1);
     if (isNumericTypedArray(value)) {
       const storage = typedArrayStorage(value);
       visit(storage.buffer, depth + 1);
@@ -28187,7 +28535,7 @@ function measureSandboxData(values, options = {}) {
       const descriptor = Object.getOwnPropertyDescriptor(value, key);
       if (descriptor !== void 0) descriptors2.push([key, descriptor]);
     }
-    const includeNonEnumerable = isSandboxDate(value) || isSandboxArrayBuffer(value) || sandboxErrorTypes.has(value) || hasManagedDescriptors(value);
+    const includeNonEnumerable = isSandboxDate(value) || isSandboxArrayBuffer(value) || isSandboxDataView(value) || sandboxErrorTypes.has(value) || hasManagedDescriptors(value);
     for (const [key, descriptor] of descriptors2) {
       if (!descriptor.enumerable && !includeNonEnumerable) continue;
       usage += 1 + key.length;
@@ -28319,7 +28667,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     }
     return copy;
   }
-  if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !(state.structuredClone && (isSandboxDate(value) || isSandboxArrayBuffer(value) || isNumericTypedArray(value)))) {
+  if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !(state.structuredClone && (isSandboxDate(value) || isSandboxArrayBuffer(value) || isSandboxDataView(value) || isNumericTypedArray(value)))) {
     throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
   }
   const primitive = nativeBoxedValue(value);
@@ -28411,6 +28759,30 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     if (!state.structuredClone && !Object.isExtensible(value)) Object.preventExtensions(copy);
     return copy;
   }
+  if (isSandboxDataView(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    if (state.structuredClone) {
+      try {
+        Reflect.apply(dataViewGetters.byteLength, value, []);
+      } catch (error) {
+        if (!(error instanceof TypeError)) throw error;
+        throw new DOMException("Cannot clone an out-of-bounds DataView.", "DataCloneError");
+      }
+    }
+    const copy = copyDataViewStorage(value, state);
+    state.seen.set(value, copy);
+    if (state.structuredClone) return copy;
+    copyToSandbox(dataViewBuffer(value), state, `${path}.buffer`, cloneSandboxCollections, depth + 1);
+    for (const [key, descriptor] of dataViewDataProperties(value)) {
+      Object.defineProperty(copy, key, {
+        ...descriptor,
+        value: copyToSandbox(descriptor.value, state, joinPath2(path, key), cloneSandboxCollections, depth + 1)
+      });
+    }
+    if (!Object.isExtensible(value)) Object.preventExtensions(copy);
+    return copy;
+  }
   if (isNumericTypedArray(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
@@ -28657,12 +29029,13 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     if (!Object.isExtensible(value)) Object.preventExtensions(copy);
     return copy;
   }
-  if (isSandboxArrayBuffer(value)) {
+  if (isSandboxArrayBuffer(value) || isSandboxDataView(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
-    const copy = copyArrayBufferStorage(value, state);
+    const copy = isSandboxDataView(value) ? copyDataViewStorage(value, state) : copyArrayBufferStorage(value, state);
     state.seen.set(value, copy);
-    for (const [key, descriptor] of arrayBufferDataProperties(value)) {
+    if (isSandboxDataView(value)) copyFromSandbox(dataViewBuffer(value), state, `${path}.buffer`, options, depth + 1);
+    for (const [key, descriptor] of isSandboxDataView(value) ? dataViewDataProperties(value) : arrayBufferDataProperties(value)) {
       Object.defineProperty(copy, key, {
         ...descriptor,
         value: copyFromSandbox(descriptor.value, state, joinPath2(path, key), options, depth + 1)
@@ -28832,6 +29205,16 @@ function allocateSandboxValue2(value, budget, seen) {
     budget.allocateString(value);
     return;
   }
+  if (isSandboxDataView(value)) {
+    if (seen.has(value)) return;
+    seen.add(value);
+    allocateSandboxValue2(dataViewBuffer(value), budget, seen);
+    for (const [key, descriptor] of dataViewDataProperties(value)) {
+      if (typeof key === "string") budget.allocateString(key);
+      allocateSandboxValue2(descriptor.value, budget, seen);
+    }
+    return;
+  }
   if (isSandboxArrayBuffer(value)) {
     if (seen.has(value)) return;
     seen.add(value);
@@ -29590,6 +29973,21 @@ function normalize(value, seen) {
   try {
     const date = copyNativeDate(value);
     if (date !== void 0) return Object.assign(/* @__PURE__ */ Object.create(null), { $type: "date", time: serializedDateTime(date) });
+    if (isSandboxDataView(value)) {
+      const properties = /* @__PURE__ */ Object.create(null);
+      const entries = dataViewDataProperties(value);
+      if (entries.some(([key]) => typeof key !== "string")) throw new TypeError("DataView symbol properties require an explicit host-call identity.");
+      for (const [key, descriptor] of entries.sort(([left], [right]) => String(left) < String(right) ? -1 : String(left) > String(right) ? 1 : 0))
+        defineOwnDataProperty(properties, String(key), normalize(descriptor.value, seen));
+      const layout = dataViewLayout(value);
+      return Object.assign(/* @__PURE__ */ Object.create(null), {
+        $type: "dataview",
+        byteOffset: layout.byteOffset,
+        byteLength: layout.byteLength ?? null,
+        buffer: normalize(dataViewBuffer(value), seen),
+        properties
+      });
+    }
     if (isSandboxArrayBuffer(value)) {
       arrayBufferLength(value);
       const properties = /* @__PURE__ */ Object.create(null);
@@ -30582,6 +30980,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "AggregateError",
   "Array",
   "ArrayBuffer",
+  "DataView",
   "Boolean",
   "BigInt",
   "Date",
@@ -40982,7 +41381,7 @@ function createReplayableRandom(options = {}) {
 
 // packages/safe-js/src/realm.ts
 import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
-import { types as types8 } from "node:util";
+import { types as types9 } from "node:util";
 
 // packages/safe-js/src/modules/registry.ts
 function createUnknownModuleMessage2(moduleName, moduleNames) {
@@ -41121,7 +41520,7 @@ var RealmState = class {
         throw new TypeError("Realm limits must be positive safe integers with supported names.");
       this.limits[name] = Number(value);
     }
-    if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types8.isProxy(options.extensions)))
+    if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types9.isProxy(options.extensions)))
       throw new TypeError("Extensions must be a registration array.");
     const registrations = options.extensions ?? [];
     const extensions = [];
@@ -41356,7 +41755,7 @@ var RealmState = class {
     return this.phase.run(phase, () => {
       try {
         const result = call();
-        if (types8.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
+        if (types9.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
           return Promise.resolve(result).then(
             async (value) => {
               await Promise.allSettled(phase.pending);
@@ -41425,7 +41824,7 @@ var RealmState = class {
       },
       read: (operation, validate) => {
         const value = this.invokeHost(operation, operation);
-        if (types8.isPromise(value)) {
+        if (types9.isPromise(value)) {
           void Promise.resolve(value).catch(() => void 0);
           throw new TypeError("Live property operations must be synchronous.");
         }
@@ -41433,7 +41832,7 @@ var RealmState = class {
       },
       write: (operation, value) => {
         const result = this.invokeHost(operation, () => operation(this.exportValue(value)));
-        if (types8.isPromise(result)) {
+        if (types9.isPromise(result)) {
           void Promise.resolve(result).catch(() => void 0);
           throw new TypeError("Live property setters must be synchronous.");
         }
@@ -41642,7 +42041,7 @@ var RealmState = class {
         }
       });
       const output = getExtensionSetup(extension)(context);
-      if (types8.isPromise(output)) {
+      if (types9.isPromise(output)) {
         void Promise.resolve(output).catch(() => void 0);
         throw new TypeError("Extension setup must be synchronous.");
       }
@@ -41834,7 +42233,7 @@ var RealmState = class {
 };
 function readModules(input) {
   const entries = (value, label) => {
-    if (types8.isMap(value) && !types8.isProxy(value)) {
+    if (types9.isMap(value) && !types9.isProxy(value)) {
       const result = [...Map.prototype.entries.call(value)];
       if (result.length > 4096 || result.some(([key]) => typeof key !== "string" || key.length === 0))
         throw new TypeError(`${label} requires bounded string keys.`);
@@ -43103,4 +43502,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-OTFEHCGJ.js.map
+//# sourceMappingURL=chunk-BKYW2WCU.js.map