poe-code 14.0.81 → 14.0.83

package/dist/index.js

@@ -120507,7 +120507,7 @@ function matchPunctuator(source, index) {
     (punctuator) => source.startsWith(punctuator, index) && (punctuator !== "?." || !isDecimalDigit(source[index + 2] ?? ""))
   );
 }
-function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis) {
+function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis, tokens) {
   if (previousToken === void 0) {
     return true;
   }
@@ -120515,6 +120515,7 @@ function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis) {
     return false;
   }
   if (previousToken.type === "keyword") {
+    if (previousToken.value === "of") return endsWithForOfSeparator(tokens);
     return !EXPRESSION_ENDING_KEYWORDS.has(previousToken.value);
   }
   if (previousToken.value === ")") {
@@ -120522,6 +120523,35 @@ function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis) {
   }
   return !isExpressionEndingPunctuator(previousToken.value);
 }
+function endsWithForOfSeparator(tokens) {
+  let depth = 0;
+  let start = -1;
+  for (let index = tokens.length - 2; index >= 0; index--) {
+    const token = tokens[index];
+    if (token.type !== "punctuator") continue;
+    if ([")", "]", "}"].includes(token.value)) depth++;
+    else if (["(", "[", "{"].includes(token.value)) {
+      if (depth > 0) {
+        depth--;
+        continue;
+      }
+      if (token.value === "(" && (tokens[index - 1]?.value === "for" || tokens[index - 1]?.value === "await" && tokens[index - 2]?.value === "for")) start = index + 1;
+      break;
+    } else if (depth === 0 && token.value === ";") break;
+  }
+  if (start < 0) return false;
+  depth = 0;
+  for (let index = start; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token.type === "punctuator") {
+      if (["(", "[", "{"].includes(token.value)) depth++;
+      else if ([")", "]", "}"].includes(token.value)) depth--;
+    }
+    if (depth === 0 && token.type === "keyword" && token.value === "of" && index !== start && tokens[index - 1]?.value !== "." && tokens[index - 1]?.value !== "?." && !(index === start + 1 && ["const", "let", "var"].includes(tokens[start].value)))
+      return index === tokens.length - 1;
+  }
+  return false;
+}
 function updateGroupingState(groupingStack, previousToken, punctuator) {
   if (punctuator === "(") {
     groupingStack.push({
@@ -120905,7 +120935,7 @@ var init_tokenizer2 = __esm({
             lastClosedControlParenthesis = false;
             continue;
           }
-          if (char === "/" && this.peekChar(1) !== "=" && shouldRejectRegexLiteral(tokens[tokens.length - 1], lastClosedControlParenthesis)) {
+          if (char === "/" && this.peekChar(1) !== "=" && shouldRejectRegexLiteral(tokens[tokens.length - 1], lastClosedControlParenthesis, tokens)) {
             if (!this.options.allowRegexLiterals) {
               this.syntaxError("Regular expression literals are not supported", this.position());
             }
@@ -121174,7 +121204,7 @@ var init_tokenizer2 = __esm({
         }
       }
       readSlashOrPunctuator(start) {
-        if (this.currentChar() === "/" && this.peekChar(1) !== "=" && shouldRejectRegexLiteral(this.lastSignificantToken(), this.lastClosedControlParenthesis)) {
+        if (this.currentChar() === "/" && this.peekChar(1) !== "=" && shouldRejectRegexLiteral(this.lastSignificantToken(), this.lastClosedControlParenthesis, this.tokens)) {
           if (!this.options.allowRegexLiterals) {
             this.syntaxError("Regular expression literals are not supported", start);
           }
@@ -123372,7 +123402,7 @@ function isLiteralPropertyKey(token) {
   return token.type === "numeric" || token.type === "string";
 }
 function isIdentifierLikeToken(token) {
-  return token.type === "identifier" || token.type === "keyword" && token.value === "async";
+  return token.type === "identifier" || token.type === "keyword" && (token.value === "async" || token.value === "of");
 }
 function isNewToken(token) {
   return token.value === "new";
@@ -126051,6 +126081,7 @@ var init_parser3 = __esm({
         return void 0;
       }
       findTopLevelForIterationOperator(startIndex) {
+        let operator;
         let depth = 0;
         let previousToken;
         for (let index = startIndex; index < this.tokens.length; index += 1) {
@@ -126060,15 +126091,15 @@ var init_parser3 = __esm({
               depth += 1;
             } else if (token.value === ")" || token.value === "]" || token.value === "}") {
               if (depth === 0 && token.value === ")") {
-                return void 0;
+                return operator;
               }
               depth -= 1;
             } else if (depth === 0 && token.value === ";") {
               return void 0;
             }
           }
-          if (depth === 0 && token.type === "keyword" && (token.value === "of" || token.value === "in") && previousToken?.value !== "." && previousToken?.value !== "?.") {
-            return token;
+          if (depth === 0 && token.type === "keyword" && (token.value === "of" || token.value === "in") && index !== startIndex && !(token.value === "of" && index === startIndex + 1 && ["const", "let", "var"].includes(previousToken?.value ?? "")) && previousToken?.value !== "." && previousToken?.value !== "?.") {
+            operator ??= token;
           }
           previousToken = token;
         }
@@ -126512,60 +126543,6 @@ var init_internal_symbols = __esm({
   }
 });
 
-// packages/safe-js/src/interp/generator-properties.ts
-function getGeneratorProperties(value) {
-  let properties = generatorGuestProperties.get(value);
-  if (properties === void 0) {
-    properties = /* @__PURE__ */ Object.create(null);
-    generatorGuestProperties.set(value, properties);
-  }
-  return properties;
-}
-var generatorGuestProperties;
-var init_generator_properties = __esm({
-  "packages/safe-js/src/interp/generator-properties.ts"() {
-    "use strict";
-    generatorGuestProperties = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// packages/safe-js/src/interp/regexp-properties.ts
-function getRegexProperties(value) {
-  const properties = regexGuestProperties.get(value);
-  if (properties === void 0) throw new TypeError("Invalid sandbox RegExp storage.");
-  return properties;
-}
-var regexGuestProperties;
-var init_regexp_properties = __esm({
-  "packages/safe-js/src/interp/regexp-properties.ts"() {
-    "use strict";
-    regexGuestProperties = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// packages/safe-js/src/interp/collection-properties.ts
-function getCollectionProperties(value) {
-  const properties = collectionGuestProperties.get(value);
-  if (properties === void 0) throw new TypeError("Invalid sandbox collection storage.");
-  return properties;
-}
-function copyCollectionProperties(source, target, encode) {
-  const properties = collectionGuestProperties.get(source) ?? source;
-  for (const key3 of Reflect.ownKeys(properties)) {
-    const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
-    if (!("value" in descriptor)) throw new TypeError("Collection accessor properties cannot be copied as data.");
-    Object.defineProperty(target, key3, { ...descriptor, value: encode(descriptor.value) });
-  }
-  if (!Object.isExtensible(properties)) Object.preventExtensions(target);
-}
-var collectionGuestProperties;
-var init_collection_properties = __esm({
-  "packages/safe-js/src/interp/collection-properties.ts"() {
-    "use strict";
-    collectionGuestProperties = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // packages/safe-js/src/interp/accessors.ts
 function accessorAdapter(closure, kind) {
   if (kind === "get") {
@@ -126630,6 +126607,144 @@ var init_accessors = __esm({
   }
 });
 
+// packages/safe-js/src/interp/symbols.ts
+var wellKnownSymbols;
+var init_symbols2 = __esm({
+  "packages/safe-js/src/interp/symbols.ts"() {
+    "use strict";
+    wellKnownSymbols = Object.freeze({
+      iterator: Symbol.iterator,
+      asyncIterator: Symbol.asyncIterator,
+      hasInstance: Symbol.hasInstance,
+      isConcatSpreadable: Symbol.isConcatSpreadable,
+      match: Symbol.match,
+      matchAll: Symbol.matchAll,
+      replace: Symbol.replace,
+      search: Symbol.search,
+      species: Symbol.species,
+      split: Symbol.split,
+      toPrimitive: Symbol.toPrimitive,
+      toStringTag: Symbol.toStringTag,
+      unscopables: Symbol.unscopables
+    });
+  }
+});
+
+// packages/safe-js/src/interp/intrinsics.ts
+function registerBuiltinIdentities(budget, bindings) {
+  let realm = realms2.get(budget);
+  if (realm === void 0) realms2.set(budget, realm = /* @__PURE__ */ new Map());
+  const pending = Object.entries(bindings).map(([name, value]) => [[name], value]);
+  const visited = /* @__PURE__ */ new WeakSet();
+  for (let index = 0; index < pending.length; index++) {
+    const [path193, value] = pending[index];
+    if (value === null || typeof value !== "object") continue;
+    const id = JSON.stringify(path193);
+    const previous = realm.get(id);
+    if (previous !== void 0 && previous !== value)
+      throw new TypeError(`Duplicate intrinsic identity: ${id}`);
+    realm.set(id, value);
+    if (!identities.has(value)) identities.set(value, id);
+    if (visited.has(value)) continue;
+    visited.add(value);
+    const owner = isSandboxClosure(value) ? value.properties : value;
+    if (owner === void 0) continue;
+    for (const key3 of Reflect.ownKeys(owner)) {
+      if (typeof key3 === "symbol" && internalSymbols.has(key3)) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(owner, key3);
+      const symbolName = typeof key3 === "symbol" ? Object.entries(wellKnownSymbols).find(([, symbol2]) => symbol2 === key3)?.[0] : void 0;
+      if (typeof key3 === "symbol" && symbolName === void 0)
+        throw new TypeError("Intrinsic symbol keys must be well-known symbols.");
+      const member = [...path193, typeof key3 === "string" ? key3 : { symbol: symbolName }];
+      if ("value" in descriptor) pending.push([member, descriptor.value]);
+      for (const kind of ["get", "set"]) {
+        const closure = accessorClosure(descriptor[kind]);
+        if (closure !== void 0) pending.push([[...member, kind], closure]);
+      }
+    }
+  }
+}
+function getIntrinsicIdentity(value) {
+  return identities.get(value);
+}
+function resolveIntrinsicIdentity(budget, id) {
+  const value = realms2.get(budget)?.get(id);
+  if (value === void 0) throw new TypeError(`Unknown intrinsic identity: ${id}`);
+  return value;
+}
+function listIntrinsicIdentities(budget) {
+  return [...realms2.get(budget)?.keys() ?? []];
+}
+function releaseIntrinsicIdentities(budget) {
+  realms2.delete(budget);
+}
+var identities, realms2;
+var init_intrinsics = __esm({
+  "packages/safe-js/src/interp/intrinsics.ts"() {
+    "use strict";
+    init_accessors();
+    init_symbols2();
+    init_internal_symbols();
+    init_values();
+    identities = /* @__PURE__ */ new WeakMap();
+    realms2 = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/generator-properties.ts
+function getGeneratorProperties(value) {
+  let properties = generatorGuestProperties.get(value);
+  if (properties === void 0) {
+    properties = /* @__PURE__ */ Object.create(null);
+    generatorGuestProperties.set(value, properties);
+  }
+  return properties;
+}
+var generatorGuestProperties;
+var init_generator_properties = __esm({
+  "packages/safe-js/src/interp/generator-properties.ts"() {
+    "use strict";
+    generatorGuestProperties = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/regexp-properties.ts
+function getRegexProperties(value) {
+  const properties = regexGuestProperties.get(value);
+  if (properties === void 0) throw new TypeError("Invalid sandbox RegExp storage.");
+  return properties;
+}
+var regexGuestProperties;
+var init_regexp_properties = __esm({
+  "packages/safe-js/src/interp/regexp-properties.ts"() {
+    "use strict";
+    regexGuestProperties = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/collection-properties.ts
+function getCollectionProperties(value) {
+  const properties = collectionGuestProperties.get(value);
+  if (properties === void 0) throw new TypeError("Invalid sandbox collection storage.");
+  return properties;
+}
+function copyCollectionProperties(source, target, encode) {
+  const properties = collectionGuestProperties.get(source) ?? source;
+  for (const key3 of Reflect.ownKeys(properties)) {
+    const descriptor = Object.getOwnPropertyDescriptor(properties, key3);
+    if (!("value" in descriptor)) throw new TypeError("Collection accessor properties cannot be copied as data.");
+    Object.defineProperty(target, key3, { ...descriptor, value: encode(descriptor.value) });
+  }
+  if (!Object.isExtensible(properties)) Object.preventExtensions(target);
+}
+var collectionGuestProperties;
+var init_collection_properties = __esm({
+  "packages/safe-js/src/interp/collection-properties.ts"() {
+    "use strict";
+    collectionGuestProperties = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // packages/safe-js/src/interp/collection-brands.ts
 function isSandboxMap(value) {
   return typeof value === "object" && value !== null && sandboxMapBrand in value;
@@ -127180,90 +127295,6 @@ var init_resources = __esm({
   }
 });
 
-// packages/safe-js/src/interp/symbols.ts
-var wellKnownSymbols;
-var init_symbols2 = __esm({
-  "packages/safe-js/src/interp/symbols.ts"() {
-    "use strict";
-    wellKnownSymbols = Object.freeze({
-      iterator: Symbol.iterator,
-      asyncIterator: Symbol.asyncIterator,
-      hasInstance: Symbol.hasInstance,
-      isConcatSpreadable: Symbol.isConcatSpreadable,
-      match: Symbol.match,
-      matchAll: Symbol.matchAll,
-      replace: Symbol.replace,
-      search: Symbol.search,
-      species: Symbol.species,
-      split: Symbol.split,
-      toPrimitive: Symbol.toPrimitive,
-      toStringTag: Symbol.toStringTag,
-      unscopables: Symbol.unscopables
-    });
-  }
-});
-
-// packages/safe-js/src/interp/intrinsics.ts
-function registerBuiltinIdentities(budget, bindings) {
-  let realm = realms2.get(budget);
-  if (realm === void 0) realms2.set(budget, realm = /* @__PURE__ */ new Map());
-  const pending = Object.entries(bindings).map(([name, value]) => [[name], value]);
-  const visited = /* @__PURE__ */ new WeakSet();
-  for (let index = 0; index < pending.length; index++) {
-    const [path193, value] = pending[index];
-    if (value === null || typeof value !== "object") continue;
-    const id = JSON.stringify(path193);
-    const previous = realm.get(id);
-    if (previous !== void 0 && previous !== value)
-      throw new TypeError(`Duplicate intrinsic identity: ${id}`);
-    realm.set(id, value);
-    if (!identities.has(value)) identities.set(value, id);
-    if (visited.has(value)) continue;
-    visited.add(value);
-    const owner = isSandboxClosure(value) ? value.properties : value;
-    if (owner === void 0) continue;
-    for (const key3 of Reflect.ownKeys(owner)) {
-      if (typeof key3 === "symbol" && internalSymbols.has(key3)) continue;
-      const descriptor = Object.getOwnPropertyDescriptor(owner, key3);
-      const symbolName = typeof key3 === "symbol" ? Object.entries(wellKnownSymbols).find(([, symbol2]) => symbol2 === key3)?.[0] : void 0;
-      if (typeof key3 === "symbol" && symbolName === void 0)
-        throw new TypeError("Intrinsic symbol keys must be well-known symbols.");
-      const member = [...path193, typeof key3 === "string" ? key3 : { symbol: symbolName }];
-      if ("value" in descriptor) pending.push([member, descriptor.value]);
-      for (const kind of ["get", "set"]) {
-        const closure = accessorClosure(descriptor[kind]);
-        if (closure !== void 0) pending.push([[...member, kind], closure]);
-      }
-    }
-  }
-}
-function getIntrinsicIdentity(value) {
-  return identities.get(value);
-}
-function resolveIntrinsicIdentity(budget, id) {
-  const value = realms2.get(budget)?.get(id);
-  if (value === void 0) throw new TypeError(`Unknown intrinsic identity: ${id}`);
-  return value;
-}
-function listIntrinsicIdentities(budget) {
-  return [...realms2.get(budget)?.keys() ?? []];
-}
-function releaseIntrinsicIdentities(budget) {
-  realms2.delete(budget);
-}
-var identities, realms2;
-var init_intrinsics = __esm({
-  "packages/safe-js/src/interp/intrinsics.ts"() {
-    "use strict";
-    init_accessors();
-    init_symbols2();
-    init_internal_symbols();
-    init_values();
-    identities = /* @__PURE__ */ new WeakMap();
-    realms2 = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // packages/safe-js/src/extensions.ts
 import { types as types3 } from "node:util";
 function readDataRecord(value, label) {
@@ -127668,6 +127699,100 @@ var init_host_capabilities = __esm({
   }
 });
 
+// packages/safe-js/src/interp/error-prototypes.ts
+var errorPrototypes;
+var init_error_prototypes = __esm({
+  "packages/safe-js/src/interp/error-prototypes.ts"() {
+    "use strict";
+    errorPrototypes = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/float32.ts
+function isFloat32Array(value) {
+  return ArrayBuffer.isView(value) && Object.getPrototypeOf(value) === Float32Array.prototype && Reflect.apply(readTag, value, []) === "Float32Array";
+}
+function float32Storage(value) {
+  const buffer = Reflect.apply(readBuffer, value, []);
+  if (Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype || bufferResizable !== void 0 && Reflect.apply(bufferResizable, buffer, [])) {
+    throw new TypeError("Float32Array requires a fixed, non-shared ArrayBuffer.");
+  }
+  return {
+    buffer,
+    byteOffset: Reflect.apply(readOffset, value, []),
+    length: Reflect.apply(readLength, value, []),
+    byteLength: Reflect.apply(bufferLength, buffer, [])
+  };
+}
+function float32Properties(value) {
+  const properties = [];
+  for (const key3 of Reflect.ownKeys(value)) {
+    if (typeof key3 === "string" && isFloat32Index(key3)) continue;
+    properties.push([key3, Object.getOwnPropertyDescriptor(value, key3)]);
+  }
+  return properties;
+}
+function float32DataProperties(value) {
+  if (Object.getOwnPropertySymbols(value).length > 0)
+    throw new TypeError("Float32Array symbol properties are not supported.");
+  const properties = [];
+  for (const [key3, descriptor] of float32Properties(value)) {
+    if (typeof key3 !== "string") throw new TypeError("Float32Array symbol properties are not supported.");
+    if (!("value" in descriptor))
+      throw new TypeError(`Float32Array accessor property '${key3}' is not supported.`);
+    properties.push([key3, descriptor]);
+  }
+  return properties;
+}
+function isFloat32Index(key3) {
+  return key3 === "-0" || String(Number(key3)) === key3;
+}
+function float32Number(value) {
+  if (value !== null && typeof value === "object" || typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
+    throw new TypeError(
+      "Float32Array numeric arguments must be primitive numeric-coercible values."
+    );
+  }
+  return Number(value);
+}
+function checkFloat32Allocation(length, budget) {
+  budget.allocateArrayLength(length);
+  budget.provisionDataUsage(length * Float32Array.BYTES_PER_ELEMENT + 1)();
+}
+function copyFloat32Storage(value, state) {
+  const storage2 = float32Storage(value);
+  state.float32Buffers ??= /* @__PURE__ */ new WeakMap();
+  let buffer = state.float32Buffers.get(storage2.buffer);
+  if (buffer === void 0) {
+    buffer = new ArrayBuffer(storage2.byteLength);
+    new Uint8Array(buffer).set(new Uint8Array(storage2.buffer));
+    state.float32Buffers.set(storage2.buffer, buffer);
+  }
+  return new Float32Array(buffer, storage2.byteOffset, storage2.length);
+}
+var typedArrayPrototype, readLength, readOffset, readBuffer, readTag, bufferLength, bufferResizable;
+var init_float32 = __esm({
+  "packages/safe-js/src/interp/float32.ts"() {
+    "use strict";
+    typedArrayPrototype = Object.getPrototypeOf(Float32Array.prototype);
+    readLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "length").get;
+    readOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
+    readBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
+    readTag = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag).get;
+    bufferLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+    bufferResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get;
+  }
+});
+
+// packages/safe-js/src/interp/float32-prototypes.ts
+var float32Prototypes;
+var init_float32_prototypes = __esm({
+  "packages/safe-js/src/interp/float32-prototypes.ts"() {
+    "use strict";
+    float32Prototypes = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // packages/safe-js/src/interp/object-model.ts
 function registerGuestClosure(closure) {
   guestClosures.add(closure);
@@ -127873,11 +127998,19 @@ function releaseObjectPrototype(budget) {
   arrayPrototypes.delete(budget);
   functionPrototypes.delete(budget);
   generatorPrototypes.delete(budget);
+  errorPrototypes.delete(budget);
+  float32Prototypes.delete(budget);
   initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
 function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  if (isFloat32Array(value)) return budget === void 0 ? null : float32Prototypes.get(budget) ?? null;
+  const errorType = sandboxErrorTypes.get(value);
+  if (budget !== void 0 && errorType !== void 0) {
+    const prototype = errorPrototypes.get(budget)?.get(errorType);
+    if (prototype !== void 0) return prototype;
+  }
   if (budget !== void 0 && isGuestClosure(value) && runResources.getStore()?.functionSourceText !== false)
     return functionPrototypes.get(budget) ?? null;
   if (budget !== void 0 && Array.isArray(value)) return arrayPrototypes.get(budget) ?? null;
@@ -127905,6 +128038,8 @@ function getSandboxPropertyDescriptor(value, key3, budget) {
   let current = value;
   let depth = 0;
   while (typeof current === "object" && current !== null && (Array.isArray(current) || isSandboxGenerator(current) || isSandboxDate(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
+    if (isFloat32Array(current) && typeof key3 !== "symbol" && isFloat32Index(String(key3)))
+      return Object.getOwnPropertyDescriptor(current, key3);
     const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? key3 === "prototype" && current.construct !== void 0 && current.boundTarget === void 0 ? materializeFunctionProperties(current) : getGuestFunctionProperties(current) : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
     if (properties === void 0 && isGuestClosure(current) && (key3 === "name" || key3 === "length"))
       return {
@@ -127927,6 +128062,8 @@ function getSandboxDataProperty(value, key3, budget) {
   let current = value;
   let depth = 0;
   while (typeof current === "object" && current !== null) {
+    if (isFloat32Array(current) && typeof key3 !== "symbol" && isFloat32Index(String(key3)))
+      return Object.getOwnPropertyDescriptor(current, key3)?.value;
     if (isGuestHostObject(current)) return typeof key3 === "symbol" ? void 0 : getHostObjectMember(current, String(key3));
     if (isSandboxRegex(current)) return Object.getOwnPropertyDescriptor(getRegexProperties(current), key3)?.value;
     if (isSandboxPromise(current)) return Object.getOwnPropertyDescriptor(getPromiseProperties(current), key3)?.value;
@@ -127978,6 +128115,7 @@ function setSandboxPrototype(value, prototype, budget) {
   prototypes.set(value, prototype);
 }
 function isPrototypeRecord(value) {
+  if (isFloat32Array(value)) return true;
   if (isGuestClosure(value)) return true;
   if (isGuestHostObject(value)) return false;
   if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxPromise(value) || isSandboxRegex(value) || isSandboxSet(value))
@@ -127997,7 +128135,7 @@ function hasGuestObjectState(value) {
   if (isLiveCapability(value)) return true;
   if (functionProperties.has(value) || prototypes.has(value) && !hasNullObjectPrototype(value)) return true;
   if (isSandboxBox(value) || isSandboxDate(value)) return false;
-  return descriptorObjects.has(value) && Object.values(Object.getOwnPropertyDescriptors(value)).some(
+  return descriptorObjects.has(value) && (isFloat32Array(value) ? float32Properties(value).map(([, descriptor]) => descriptor) : Object.values(Object.getOwnPropertyDescriptors(value))).some(
     (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
   );
 }
@@ -128014,6 +128152,10 @@ var init_object_model = __esm({
     init_date();
     init_accessors();
     init_host_capabilities();
+    init_error_prototypes();
+    init_float32();
+    init_float32_prototypes();
+    init_shape();
     init_boxed();
     init_values();
     guestClosures = /* @__PURE__ */ new WeakSet();
@@ -128062,75 +128204,6 @@ var init_raw_json = __esm({
   }
 });
 
-// packages/safe-js/src/interp/float32.ts
-function isFloat32Array(value) {
-  return ArrayBuffer.isView(value) && Object.getPrototypeOf(value) === Float32Array.prototype && Reflect.apply(readTag, value, []) === "Float32Array";
-}
-function float32Storage(value) {
-  const buffer = Reflect.apply(readBuffer, value, []);
-  if (Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype || bufferResizable !== void 0 && Reflect.apply(bufferResizable, buffer, [])) {
-    throw new TypeError("Float32Array requires a fixed, non-shared ArrayBuffer.");
-  }
-  return {
-    buffer,
-    byteOffset: Reflect.apply(readOffset, value, []),
-    length: Reflect.apply(readLength, value, []),
-    byteLength: Reflect.apply(bufferLength, buffer, [])
-  };
-}
-function float32DataProperties(value) {
-  if (Object.getOwnPropertySymbols(value).length > 0)
-    throw new TypeError("Float32Array symbol properties are not supported.");
-  const properties = [];
-  for (const key3 of Object.getOwnPropertyNames(value)) {
-    if (isFloat32Index(key3)) continue;
-    const descriptor = Object.getOwnPropertyDescriptor(value, key3);
-    if (!("value" in descriptor))
-      throw new TypeError(`Float32Array accessor property '${key3}' is not supported.`);
-    properties.push([key3, descriptor]);
-  }
-  return properties;
-}
-function isFloat32Index(key3) {
-  return key3 === "-0" || String(Number(key3)) === key3;
-}
-function float32Number(value) {
-  if (value !== null && typeof value === "object" || typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
-    throw new TypeError(
-      "Float32Array numeric arguments must be primitive numeric-coercible values."
-    );
-  }
-  return Number(value);
-}
-function checkFloat32Allocation(length, budget) {
-  budget.allocateArrayLength(length);
-  budget.provisionDataUsage(length * Float32Array.BYTES_PER_ELEMENT + 1)();
-}
-function copyFloat32Storage(value, state) {
-  const storage2 = float32Storage(value);
-  state.float32Buffers ??= /* @__PURE__ */ new WeakMap();
-  let buffer = state.float32Buffers.get(storage2.buffer);
-  if (buffer === void 0) {
-    buffer = new ArrayBuffer(storage2.byteLength);
-    new Uint8Array(buffer).set(new Uint8Array(storage2.buffer));
-    state.float32Buffers.set(storage2.buffer, buffer);
-  }
-  return new Float32Array(buffer, storage2.byteOffset, storage2.length);
-}
-var typedArrayPrototype, readLength, readOffset, readBuffer, readTag, bufferLength, bufferResizable;
-var init_float32 = __esm({
-  "packages/safe-js/src/interp/float32.ts"() {
-    "use strict";
-    typedArrayPrototype = Object.getPrototypeOf(Float32Array.prototype);
-    readLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "length").get;
-    readOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
-    readBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
-    readTag = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag).get;
-    bufferLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
-    bufferResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get;
-  }
-});
-
 // packages/safe-js/src/interp/promise-tracker.ts
 import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 function assertPromiseExecutionAllowed() {
@@ -128800,6 +128873,8 @@ var init_float32array = __esm({
   "packages/safe-js/src/snapshot/float32array.ts"() {
     "use strict";
     init_float32();
+    init_object_model();
+    init_property_descriptors();
   }
 });
 
@@ -130991,6 +131066,8 @@ async function acquireSandboxIterator(value, budget, context, asyncProtocol = fa
   const iterator = await invokeBuiltinClosure(factory, [], budget, context, value);
   if (typeof iterator !== "object" && typeof iterator !== "function" || iterator === null)
     throw new TypeError("Iterator must be an object.");
+  if (!asyncProtocol && isSandboxGenerator(iterator) && !iterator.async && !hasExplicitSandboxPrototype(iterator) && getSandboxPropertyDescriptor(iterator, "next", budget) === void 0)
+    return getSandboxIterator(iterator, budget, context);
   const next = await context.getProperty(iterator, "next");
   return guestIterator(iterator, next, asyncProtocol, budget, context, signal);
 }
@@ -131023,7 +131100,7 @@ async function readIteratorResult(iterator, result, property) {
 }
 function getSandboxAsyncIterator(value, budget, context, signal) {
   if (isSandboxGenerator(value) && value.async) {
-    return hasExplicitSandboxPrototype(value) ? context?.getProperty === void 0 ? generatorProtocolAdapter(value, budget, context, true, signal) : void 0 : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
+    return hasExplicitSandboxPrototype(value) ? context?.getProperty === void 0 ? guestProtocolAdapter(value, budget, context, true, signal) : void 0 : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
   }
   if (value !== null && (typeof value === "object" || typeof value === "function") && !isGuestHostObject(value)) {
     const method = value[Symbol.asyncIterator];
@@ -131170,11 +131247,15 @@ function getSandboxIterator(value, budget, context) {
   }
   if (isGuestHostObject(value)) return getHostObjectIterator(value);
   if (isFloat32Array(value)) {
+    if (hasExplicitSandboxPrototype(value) || budget !== void 0 && float32Prototypes.has(budget)) {
+      if (getSandboxPropertyDescriptor(value, Symbol.iterator, budget) === void 0) return void 0;
+      return guestProtocolAdapter(value, budget ?? new Budget(), context, false);
+    }
     return syncIterator(Float32Array.prototype.values.call(value));
   }
   if (isSandboxGenerator(value)) {
     if (value.async) return void 0;
-    if (hasExplicitSandboxPrototype(value)) return context?.getProperty === void 0 ? generatorProtocolAdapter(value, budget ?? new Budget(), context, false) : void 0;
+    if (hasExplicitSandboxPrototype(value)) return context?.getProperty === void 0 ? guestProtocolAdapter(value, budget ?? new Budget(), context, false) : void 0;
     return generatorObjectIterator(value, budget, context);
   }
   if (typeof value === "string") {
@@ -131251,7 +131332,7 @@ function collectionIterator(collection, value) {
   adapter.snapshot = () => ({ kind: "builtin", value, index: adapter.snapshotIndex() });
   return adapter;
 }
-function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal) {
+function guestProtocolAdapter(value, budget, context, asyncProtocol, signal) {
   const bridge = {
     ...context,
     stack: context?.stack ?? [],
@@ -131265,7 +131346,7 @@ function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal)
   let resolved;
   let pending;
   const initialize = () => pending ??= acquireSandboxIterator(value, budget, bridge, asyncProtocol, signal).then((iterator) => {
-    if (iterator === void 0) throw new TypeError("Generator does not provide an iterator protocol.");
+    if (iterator === void 0) throw new TypeError("Value does not provide an iterator protocol.");
     return resolved = iterator;
   });
   return {
@@ -131374,6 +131455,7 @@ var init_iteration = __esm({
     init_values();
     init_running_state();
     init_float32();
+    init_float32_prototypes();
     init_boxed();
     init_host_capabilities();
     init_collection_iterator();
@@ -135313,8 +135395,8 @@ async function definePropertiesFromObject(target, descriptors2, budget, context)
 }
 function defineDataProperty8(target, key3, descriptor, budget) {
   budget.visitNode();
-  if (isFloat32Array(target))
-    throw new TypeError("Typed array property descriptors are not supported.");
+  if (isFloat32Array(target) && typeof key3 !== "symbol" && isFloat32Index(String(key3)) && "value" in descriptor)
+    descriptor = { ...descriptor, value: float32Number(descriptor.value) };
   const properties = objectProperties(target, true);
   if (Array.isArray(properties)) {
     if (key3 === "length" && "value" in descriptor)
@@ -136246,62 +136328,338 @@ async function callSetMethod(target, methodName, args, options, stack = []) {
       return createSandboxCollectionIterator(target, methodName);
   }
 }
-var setMethodNames;
-var init_set = __esm({
-  "packages/safe-js/src/interp/methods/set.ts"() {
-    "use strict";
-    init_values();
-    init_running_state();
-    init_collection_callback();
-    init_collection_iterator();
-    setMethodNames = /* @__PURE__ */ new Set([
-      "add",
-      "has",
-      "delete",
-      "clear",
-      "forEach",
-      "keys",
-      "values",
-      "entries"
-    ]);
+var setMethodNames;
+var init_set = __esm({
+  "packages/safe-js/src/interp/methods/set.ts"() {
+    "use strict";
+    init_values();
+    init_running_state();
+    init_collection_callback();
+    init_collection_iterator();
+    setMethodNames = /* @__PURE__ */ new Set([
+      "add",
+      "has",
+      "delete",
+      "clear",
+      "forEach",
+      "keys",
+      "values",
+      "entries"
+    ]);
+  }
+});
+
+// packages/safe-js/src/interp/globals/float32array.ts
+function createFloat32ArrayGlobal(budget, nativePrototype = false) {
+  const constructor = createSandboxClosure({
+    guest: nativePrototype,
+    sandbox: true,
+    name: "Float32Array",
+    length: 3,
+    properties: { BYTES_PER_ELEMENT: 4 },
+    call: () => {
+      throw new TypeError("Constructor Float32Array requires 'new'.");
+    },
+    construct: (args, context) => {
+      if (!nativePrototype) return allocateFloat32Array(args[0], budget);
+      return (async () => {
+        const newTarget = context?.newTarget ?? constructor;
+        const candidate = context?.getProperty === void 0 ? getSandboxDataProperty(newTarget, "prototype", budget) : await context.getProperty(newTarget, "prototype");
+        const prototype = candidate !== null && typeof candidate === "object" ? candidate : float32Prototypes.get(budget);
+        const release2 = retainValues(budget, () => [prototype, ...args]);
+        try {
+          const result = args[0] !== null && typeof args[0] === "object" && !isFloat32Array(args[0]) ? await allocateFloat32Input(args[0], budget, context) : allocateFloat32Array(args[0], budget);
+          setSandboxPrototype(result, prototype, budget);
+          return result;
+        } finally {
+          release2();
+        }
+      })();
+    }
+  });
+  constructors.add(constructor);
+  return constructor;
+}
+async function allocateFloat32Input(source, budget, context) {
+  const callerContext = context;
+  const bridge = {
+    ...callerContext,
+    stack: callerContext?.stack ?? [],
+    thisValue: void 0,
+    getProperty: callerContext?.getProperty ?? ((value, key3) => {
+      const descriptor = getSandboxPropertyDescriptor(value, key3, budget);
+      return descriptor === void 0 ? getSandboxDataProperty(value, key3, budget) : readPropertyDescriptor(descriptor, value, bridge);
+    }),
+    invokeClosure: callerContext?.invokeClosure ?? ((callee, values2, receiver, construct) => invokeBuiltinClosure(callee, values2, budget, callerContext, receiver, construct))
+  };
+  const values = [];
+  let iterator;
+  let current;
+  let result;
+  const release2 = retainValues(budget, () => [source, values, iterator?.retainedValue, current, result]);
+  const checkData = createDataCheckpoint(budget, bridge);
+  try {
+    iterator = await acquireSandboxIterator(source, budget, bridge);
+    let length;
+    if (iterator !== void 0) {
+      while (true) {
+        budget.visitNode();
+        const next = await iterator.next();
+        if (typeof next !== "object" || next === null) throw new TypeError("Iterator result must be an object.");
+        if ((await readIteratorResult(iterator, next, "done")).value) break;
+        current = (await readIteratorResult(iterator, next, "value")).value;
+        budget.allocateArrayLength(values.length + 1);
+        values.push(current);
+        checkData(values, 1 + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([current])));
+      }
+      length = values.length;
+    } else {
+      current = await bridge.getProperty(source, "length");
+      const number = await sandboxNumber(current, budget, bridge);
+      length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+    }
+    checkFloat32Allocation(length, budget);
+    result = new Float32Array(length);
+    checkData(result, 0, true);
+    for (let index = 0; index < length; index++) {
+      budget.visitNode();
+      current = iterator === void 0 ? await bridge.getProperty(source, String(index)) : values[index];
+      result[index] = await sandboxNumber(current, budget, bridge);
+    }
+    return result;
+  } finally {
+    release2();
+  }
+}
+function allocateFloat32Array(source, budget) {
+  if (Array.isArray(source) || isFloat32Array(source)) {
+    const length2 = isFloat32Array(source) ? float32Storage(source).length : source.length;
+    checkFloat32Allocation(length2, budget);
+    if (isFloat32Array(source)) return new Float32Array(source);
+    const result = new Float32Array(length2);
+    for (let index = 0; index < length2; index += 1) {
+      budget.visitNode();
+      const descriptor = Object.getOwnPropertyDescriptor(source, index);
+      if (descriptor !== void 0 && !("value" in descriptor))
+        throw new TypeError("Float32Array input accessors are not supported.");
+      result[index] = float32Number(descriptor?.value);
+    }
+    return result;
   }
-});
-
-// packages/safe-js/src/interp/globals/float32array.ts
-function createFloat32ArrayGlobal(budget) {
-  const constructor = createSandboxClosure({
+  const number = float32Number(source);
+  const length = Number.isNaN(number) ? 0 : Math.trunc(number);
+  if (length < 0 || !Number.isSafeInteger(length))
+    throw new RangeError("Invalid typed array length.");
+  checkFloat32Allocation(length, budget);
+  return new Float32Array(length);
+}
+function createFloat32ArrayPrototypes(budget, constructor) {
+  const prototype = /* @__PURE__ */ Object.create(null);
+  const shared = /* @__PURE__ */ Object.create(null);
+  const abstractCall = () => {
+    throw new TypeError("Abstract TypedArray constructor cannot be called.");
+  };
+  const typedArray = createSandboxClosure({
+    guest: true,
     sandbox: true,
-    name: "Float32Array",
-    length: 3,
-    properties: { BYTES_PER_ELEMENT: 4 },
-    call: () => {
-      throw new TypeError("Constructor Float32Array requires 'new'.");
-    },
-    construct: ([source]) => {
-      if (Array.isArray(source) || isFloat32Array(source)) {
-        const length2 = isFloat32Array(source) ? float32Storage(source).length : source.length;
-        checkFloat32Allocation(length2, budget);
-        if (isFloat32Array(source)) return new Float32Array(source);
-        const result = new Float32Array(length2);
-        for (let index = 0; index < length2; index += 1) {
-          budget.visitNode();
-          const descriptor = Object.getOwnPropertyDescriptor(source, index);
-          if (descriptor !== void 0 && !("value" in descriptor))
-            throw new TypeError("Float32Array input accessors are not supported.");
-          result[index] = float32Number(descriptor?.value);
+    name: "TypedArray",
+    length: 0,
+    call: abstractCall,
+    construct: abstractCall
+  });
+  Object.defineProperty(materializeFunctionProperties(typedArray), "prototype", { value: shared, writable: false });
+  Object.defineProperty(materializeFunctionProperties(typedArray), "from", {
+    writable: true,
+    configurable: true,
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "from",
+      length: 1,
+      call: async (args, context) => {
+        const target = context?.thisValue;
+        const [source, mapper, receiver] = args;
+        if (!isSandboxClosure(target) || target.construct === void 0)
+          throw new TypeError("TypedArray.from requires a constructor receiver.");
+        if (mapper !== void 0 && !isSandboxClosure(mapper))
+          throw new TypeError("TypedArray.from mapper must be callable.");
+        if (source === null || source === void 0)
+          throw new TypeError("TypedArray.from requires a non-null source.");
+        const callerContext = context;
+        context = {
+          ...callerContext,
+          stack: callerContext?.stack ?? [],
+          thisValue: target,
+          getProperty: callerContext?.getProperty ?? ((value, key3) => {
+            const descriptor = getSandboxPropertyDescriptor(value, key3, budget);
+            return descriptor === void 0 ? getSandboxDataProperty(value, key3, budget) : readPropertyDescriptor(descriptor, value, context);
+          }),
+          invokeClosure: callerContext?.invokeClosure ?? ((callee, values2, thisValue, construct) => invokeBuiltinClosure(callee, values2, budget, callerContext, thisValue, construct))
+        };
+        let result;
+        let current;
+        let iterator;
+        const values = [];
+        const release2 = retainValues(budget, () => [target, result, current, iterator?.retainedValue, values, ...args]);
+        const checkData = createDataCheckpoint(budget, context);
+        const read = (key3) => context?.getProperty === void 0 ? getSandboxDataProperty(source, key3, budget) : context.getProperty(source, key3);
+        try {
+          iterator = await acquireSandboxIterator(source, budget, context);
+          let length;
+          if (iterator !== void 0) {
+            while (true) {
+              budget.visitNode();
+              const next = await iterator.next();
+              if (typeof next !== "object" || next === null) throw new TypeError("Iterator result must be an object.");
+              if ((await readIteratorResult(iterator, next, "done")).value) break;
+              current = (await readIteratorResult(iterator, next, "value")).value;
+              budget.allocateArrayLength(values.length + 1);
+              values.push(current);
+              checkData(values, 1 + (budget.limits.dataSize === void 0 ? 0 : measureSandboxData([current])));
+            }
+            length = values.length;
+          } else {
+            const number = await sandboxNumber(await read("length"), budget, context);
+            length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+          }
+          result = await invokeBuiltinClosure(target, [length], budget, context, void 0, true);
+          if (!isFloat32Array(result) || float32Storage(result).length < length)
+            throw new TypeError("TypedArray.from constructor must return sufficient typed storage.");
+          checkData(result, 0, true);
+          for (let index = 0; index < length; index++) {
+            budget.visitNode();
+            current = iterator === void 0 ? await read(String(index)) : values[index];
+            if (mapper !== void 0)
+              current = await invokeBuiltinClosure(mapper, [current, index], budget, context, receiver);
+            result[index] = await sandboxNumber(current, budget, context);
+          }
+          return result;
+        } finally {
+          release2();
         }
-        return result;
       }
-      const number = float32Number(source);
-      const length = Number.isNaN(number) ? 0 : Math.trunc(number);
-      if (length < 0 || !Number.isSafeInteger(length))
-        throw new RangeError("Invalid typed array length.");
-      checkFloat32Allocation(length, budget);
-      return new Float32Array(length);
-    }
+    })
   });
-  constructors.add(constructor);
-  return constructor;
+  Object.defineProperty(materializeFunctionProperties(typedArray), "of", {
+    writable: true,
+    configurable: true,
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "of",
+      length: 0,
+      call: async (args, context) => {
+        const target = context?.thisValue;
+        if (!isSandboxClosure(target) || target.construct === void 0)
+          throw new TypeError("TypedArray.of requires a constructor receiver.");
+        let result;
+        const release2 = retainValues(budget, () => [target, result, ...args]);
+        try {
+          result = await invokeBuiltinClosure(target, [args.length], budget, context, void 0, true);
+          if (!isFloat32Array(result) || float32Storage(result).length < args.length)
+            throw new TypeError("TypedArray.of constructor must return sufficient typed storage.");
+          for (let index = 0; index < args.length; index++) {
+            budget.visitNode();
+            result[index] = await sandboxNumber(args[index], budget, context);
+          }
+          return result;
+        } finally {
+          release2();
+        }
+      }
+    })
+  });
+  Object.defineProperties(materializeFunctionProperties(constructor), {
+    prototype: { value: prototype, writable: false },
+    BYTES_PER_ELEMENT: { value: 4, writable: false, enumerable: false, configurable: false }
+  });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    BYTES_PER_ELEMENT: { value: 4 }
+  });
+  Object.defineProperty(shared, "constructor", { value: typedArray, writable: true, configurable: true });
+  setSandboxPrototype(constructor, typedArray);
+  setSandboxPrototype(prototype, shared);
+  setSandboxPrototype(shared, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
+  const getters = [];
+  for (const key3 of ["length", "byteLength", "byteOffset"]) {
+    const getter = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: `get ${key3}`,
+      length: 0,
+      call: (_args, context) => {
+        if (!isFloat32Array(context?.thisValue)) throw new TypeError(`TypedArray ${key3} requires a typed array receiver.`);
+        const storage2 = float32Storage(context.thisValue);
+        return key3 === "byteLength" ? storage2.length * 4 : storage2[key3];
+      }
+    });
+    getters.push(getter);
+    Object.defineProperty(shared, key3, { get: accessorAdapter(getter, "get"), configurable: true });
+  }
+  for (const key3 of ["set", "slice", "subarray"])
+    Object.defineProperty(shared, key3, { value: getFloat32Member(new Float32Array(0), key3, budget), writable: true, configurable: true });
+  const arrayPrototype = resolveIntrinsicIdentity(budget, '["Array","prototype"]');
+  Object.defineProperty(shared, "toString", { value: getSandboxDataProperty(arrayPrototype, "toString", budget), writable: true, configurable: true });
+  Object.defineProperty(shared, "join", {
+    writable: true,
+    configurable: true,
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "join",
+      length: 1,
+      call: async (args, context) => {
+        if (!isFloat32Array(context?.thisValue)) throw new TypeError("TypedArray join requires a typed array receiver.");
+        const receiver = context.thisValue;
+        const length = float32Storage(receiver).length;
+        let separator = ",";
+        let text5 = "";
+        const release2 = retainValues(budget, () => [receiver, separator, text5, ...args]);
+        try {
+          if (args[0] !== void 0) separator = await sandboxString(args[0], budget, context);
+          for (let index = 0; index < length; index++) {
+            budget.visitNode();
+            text5 = budget.allocateString(text5 + (index === 0 ? "" : separator) + String(receiver[index]));
+          }
+          return text5;
+        } finally {
+          release2();
+        }
+      }
+    })
+  });
+  const tagGetter = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "get [Symbol.toStringTag]",
+    length: 0,
+    call: (_args, context) => isFloat32Array(context?.thisValue) ? "Float32Array" : void 0
+  });
+  getters.push(tagGetter);
+  Object.defineProperty(shared, Symbol.toStringTag, { get: accessorAdapter(tagGetter, "get"), configurable: true });
+  for (const key3 of ["values", "keys", "entries"]) {
+    const method = getSandboxDataProperty(arrayPrototype, key3, budget);
+    const closure = createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: key3,
+      length: 0,
+      call: (args, context) => {
+        if (!isFloat32Array(context?.thisValue)) throw new TypeError(`TypedArray ${key3} requires a typed array receiver.`);
+        return invokeBuiltinClosure(method, args, budget, context, context.thisValue);
+      }
+    });
+    Object.defineProperty(shared, key3, { value: closure, writable: true, configurable: true });
+    if (key3 === "values") Object.defineProperty(shared, Symbol.iterator, { value: closure, writable: true, configurable: true });
+  }
+  float32Prototypes.set(budget, prototype);
+  registerBuiltinIdentities(budget, { Float32Array: constructor, "%TypedArray%": typedArray });
+  registerIntrinsicFunction(budget, constructor);
+  registerIntrinsicFunction(budget, typedArray);
+  registerIntrinsicObject(budget, prototype);
+  registerIntrinsicObject(budget, shared);
+  for (const getter of getters) registerIntrinsicFunction(budget, getter);
 }
 function isFloat32ArrayConstructor(value) {
   return typeof value === "object" && value !== null && constructors.has(value);
@@ -136313,6 +136671,7 @@ function getFloat32Member(value, property, budget) {
     if (!("value" in descriptor)) throw new TypeError("Float32Array accessors are not supported.");
     return descriptor.value;
   }
+  if (float32Prototypes.has(budget)) return void 0;
   const storage2 = float32Storage(value);
   if (key3 === "length") return storage2.length;
   if (key3 === "byteLength") return storage2.length * 4;
@@ -136320,6 +136679,7 @@ function getFloat32Member(value, property, budget) {
   if (key3 === "BYTES_PER_ELEMENT") return 4;
   if (!["set", "slice", "subarray"].includes(key3)) return void 0;
   return createSandboxClosure({
+    guest: true,
     sandbox: true,
     name: key3,
     length: key3 === "set" ? 1 : 2,
@@ -136328,65 +136688,88 @@ function getFloat32Member(value, property, budget) {
       if (!isFloat32Array(receiver))
         throw new TypeError(`Float32Array#${key3} requires a Float32Array receiver.`);
       const storage3 = float32Storage(receiver);
+      const bridge = {
+        ...context,
+        stack: context?.stack ?? [],
+        thisValue: receiver,
+        getProperty: context?.getProperty ?? ((value2, property2) => {
+          const descriptor2 = getSandboxPropertyDescriptor(value2, property2, budget);
+          return descriptor2 === void 0 ? getSandboxDataProperty(value2, property2, budget) : readPropertyDescriptor(descriptor2, value2, bridge);
+        }),
+        invokeClosure: context?.invokeClosure ?? ((callee, values, thisValue, construct) => invokeBuiltinClosure(callee, values, budget, context, thisValue, construct))
+      };
       if (key3 === "set") {
-        const [source, offsetValue = 0] = args;
-        if (!Array.isArray(source) && !isFloat32Array(source))
-          throw new TypeError("Float32Array#set requires an array or Float32Array.");
-        const number = float32Number(offsetValue);
-        const offset = Number.isNaN(number) ? 0 : Math.trunc(number);
-        const length2 = isFloat32Array(source) ? float32Storage(source).length : source.length;
-        if (offset < 0 || !Number.isSafeInteger(offset) || offset + length2 > storage3.length)
-          throw new RangeError("Float32Array#set source is out of bounds.");
-        if (isFloat32Array(source)) {
-          Float32Array.prototype.set.call(receiver, source, offset);
-          return void 0;
-        }
-        checkFloat32Allocation(length2, budget);
-        const copied = new Float32Array(length2);
-        for (let index = 0; index < length2; index += 1) {
-          budget.visitNode();
-          const entry = Object.getOwnPropertyDescriptor(source, index);
-          if (entry !== void 0 && !("value" in entry))
-            throw new TypeError("Float32Array input accessors are not supported.");
-          copied[index] = float32Number(entry?.value);
-        }
-        Float32Array.prototype.set.call(receiver, copied, offset);
-        return void 0;
+        return (async () => {
+          const [source, offsetValue = 0] = args;
+          let current;
+          let sourceObject;
+          const release2 = retainValues(budget, () => [receiver, sourceObject, current, ...args]);
+          try {
+            const number = await sandboxNumber(offsetValue, budget, bridge);
+            const offset = Number.isNaN(number) ? 0 : Math.trunc(number);
+            if (offset < 0) throw new RangeError("Float32Array#set offset is out of bounds.");
+            if (source === null || source === void 0) throw new TypeError("Float32Array#set requires a non-null source.");
+            let length;
+            if (isFloat32Array(source)) length = float32Storage(source).length;
+            else {
+              sourceObject = typeof source === "object" ? source : createSandboxBox(source);
+              current = await bridge.getProperty(sourceObject, "length");
+              const size = await sandboxNumber(current, budget, bridge);
+              length = Number.isNaN(size) || size <= 0 ? 0 : Math.min(Math.trunc(size), Number.MAX_SAFE_INTEGER);
+            }
+            if (offset + length > storage3.length) throw new RangeError("Float32Array#set source is out of bounds.");
+            if (isFloat32Array(source)) Float32Array.prototype.set.call(receiver, source, offset);
+            else for (let index = 0; index < length; index++) {
+              budget.visitNode();
+              current = await bridge.getProperty(sourceObject, String(index));
+              receiver[offset + index] = await sandboxNumber(current, budget, bridge);
+            }
+            return void 0;
+          } finally {
+            release2();
+          }
+        })();
       }
-      const start = relativeIndex(args[0], storage3.length, 0);
-      const end = relativeIndex(args[1], storage3.length, storage3.length);
-      const length = Math.max(end - start, 0);
-      if (key3 === "subarray")
-        return new Float32Array(storage3.buffer, storage3.byteOffset + start * 4, length);
-      checkFloat32Allocation(length, budget);
-      const result = new Float32Array(length);
-      new Uint8Array(result.buffer).set(
-        new Uint8Array(storage3.buffer, storage3.byteOffset + start * 4, length * 4)
-      );
-      return result;
+      return (async () => {
+        const release2 = retainValues(budget, () => [receiver, ...args]);
+        try {
+          const start = relativeIndex(await sandboxNumber(args[0], budget, bridge), storage3.length);
+          const end = args[1] === void 0 ? storage3.length : relativeIndex(await sandboxNumber(args[1], budget, bridge), storage3.length);
+          const length = Math.max(end - start, 0);
+          if (key3 === "subarray")
+            return new Float32Array(storage3.buffer, storage3.byteOffset + start * 4, length);
+          checkFloat32Allocation(length, budget);
+          const result = new Float32Array(length);
+          new Uint8Array(result.buffer).set(
+            new Uint8Array(storage3.buffer, storage3.byteOffset + start * 4, length * 4)
+          );
+          return result;
+        } finally {
+          release2();
+        }
+      })();
     }
   });
 }
-function setFloat32Member(value, property, entry) {
-  const key3 = String(property);
-  if (isFloat32Index(key3)) {
+function setFloat32Member(value, property, entry, budget) {
+  const key3 = typeof property === "symbol" ? property : String(property);
+  if (typeof key3 !== "symbol" && isFloat32Index(key3)) {
     Reflect.set(value, key3, float32Number(entry));
     return;
   }
   const descriptor = Object.getOwnPropertyDescriptor(value, key3);
-  if (descriptor === void 0 && ["length", "byteLength", "byteOffset", "buffer", "BYTES_PER_ELEMENT"].includes(key3))
-    throw new TypeError(`Cannot assign to read only property '${key3}'.`);
-  if (descriptor !== void 0 && (!("value" in descriptor) || !descriptor.writable))
-    throw new TypeError(`Cannot assign to read only property '${key3}'.`);
+  const inherited = descriptor ?? (budget === void 0 ? void 0 : getSandboxPropertyDescriptor(value, key3, budget));
+  if (descriptor === void 0 && typeof key3 === "string" && (budget === void 0 || !float32Prototypes.has(budget)) && ["length", "byteLength", "byteOffset", "buffer", "BYTES_PER_ELEMENT"].includes(key3))
+    throw new TypeError(`Cannot assign to read only property '${String(key3)}'.`);
+  if (inherited !== void 0 && (!("value" in inherited) || !inherited.writable))
+    throw new TypeError(`Cannot assign to read only property '${String(key3)}'.`);
   Object.defineProperty(
     value,
     key3,
     descriptor === void 0 ? { value: entry, configurable: true, enumerable: true, writable: true } : { value: entry }
   );
 }
-function relativeIndex(value, length, fallback) {
-  if (value === void 0) return fallback;
-  const numeric = float32Number(value);
+function relativeIndex(numeric, length) {
   const integer3 = Number.isNaN(numeric) ? 0 : Math.trunc(numeric);
   return integer3 < 0 ? Math.max(length + integer3, 0) : Math.min(integer3, length);
 }
@@ -136396,6 +136779,16 @@ var init_float32array2 = __esm({
     "use strict";
     init_float32();
     init_values();
+    init_accessors();
+    init_float32_prototypes();
+    init_object_model();
+    init_intrinsics();
+    init_builtin_call();
+    init_resources();
+    init_string_coercion();
+    init_iteration();
+    init_data_checkpoint();
+    init_boxed();
     constructors = /* @__PURE__ */ new WeakSet();
   }
 });
@@ -136403,7 +136796,7 @@ var init_float32array2 = __esm({
 // packages/safe-js/src/interp/globals/error.ts
 function createErrorGlobals(options) {
   return Object.fromEntries(
-    errorNames.map((name) => [name, createErrorConstructor(name, options.budget)])
+    errorNames.map((name) => [name, createErrorConstructor(name, options.budget, options.errorPrototypes === true)])
   );
 }
 function isSandboxErrorConstructorInstance2(value, constructor) {
@@ -136416,12 +136809,100 @@ function isSandboxErrorConstructorInstance2(value, constructor) {
   }
   return isSandboxErrorConstructorInstance(value, name);
 }
-function createErrorConstructor(name, budget) {
-  const call = (args, context) => createSubsetError(name, args, context?.stack ?? [], budget);
-  const closure = createSandboxClosure({ sandbox: true, call, construct: call, name });
+function createErrorConstructor(name, budget, guest) {
+  const call = (args, context) => errorPrototypes.has(budget) ? createNativeError(name, args, budget, context, closure) : createSubsetError(name, args, context?.stack ?? [], budget);
+  const closure = createSandboxClosure({ guest, sandbox: true, call, construct: call, name, length: name === "AggregateError" ? 2 : 1 });
   errorConstructorNames.set(closure, name);
   return closure;
 }
+function createErrorPrototypes(budget, constructors2) {
+  const prototypes2 = /* @__PURE__ */ new Map();
+  for (const name of errorNames) prototypes2.set(name, /* @__PURE__ */ Object.create(null));
+  errorPrototypes.set(budget, prototypes2);
+  for (const name of errorNames) {
+    const constructor = constructors2[name];
+    const prototype = prototypes2.get(name);
+    Object.defineProperties(prototype, {
+      name: { value: name, writable: true, configurable: true },
+      message: { value: "", writable: true, configurable: true },
+      constructor: { value: constructor, writable: true, configurable: true }
+    });
+    Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+    setSandboxPrototype(prototype, name === "Error" ? getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget) : prototypes2.get("Error"));
+    if (name !== "Error") setSandboxPrototype(constructor, constructors2.Error);
+  }
+  Object.defineProperty(prototypes2.get("Error"), "toString", {
+    writable: true,
+    configurable: true,
+    value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "toString",
+      length: 0,
+      call: async (_args, context) => {
+        const receiver = context?.thisValue;
+        if (receiver === null || typeof receiver !== "object") throw new TypeError("Error.prototype.toString requires an object.");
+        let name;
+        const release2 = retainValues(budget, () => [receiver, name]);
+        try {
+          const rawName = await readErrorProperty(receiver, "name", budget, context);
+          name = rawName === void 0 ? "Error" : await sandboxString(rawName, budget, context);
+          const rawMessage = await readErrorProperty(receiver, "message", budget, context);
+          const message2 = rawMessage === void 0 ? "" : await sandboxString(rawMessage, budget, context);
+          return budget.allocateString(name === "" ? message2 : message2 === "" ? name : `${name}: ${message2}`);
+        } finally {
+          release2();
+        }
+      }
+    })
+  });
+  registerBuiltinIdentities(budget, Object.fromEntries(errorNames.map((name) => [name, constructors2[name]])));
+  for (const name of errorNames) {
+    registerIntrinsicFunction(budget, constructors2[name]);
+    registerIntrinsicObject(budget, prototypes2.get(name));
+  }
+}
+async function readErrorProperty(value, key3, budget, context) {
+  if (context?.getProperty !== void 0) return context.getProperty(value, key3);
+  const descriptor = getSandboxPropertyDescriptor(value, key3, budget);
+  return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+}
+async function createNativeError(name, args, budget, context, constructor) {
+  const newTarget = context?.newTarget ?? constructor;
+  const candidate = await readErrorProperty(newTarget, "prototype", budget, context);
+  const prototype = candidate !== null && typeof candidate === "object" ? candidate : errorPrototypes.get(budget).get(name);
+  let error3;
+  let iterator;
+  const errors2 = [];
+  const release2 = retainValues(budget, () => [prototype, error3, iterator?.retainedValue, ...errors2, ...args]);
+  try {
+    const message2 = name === "AggregateError" ? args[1] : args[0];
+    const options = name === "AggregateError" ? args[2] : args[1];
+    const text5 = message2 === void 0 ? void 0 : await sandboxString(message2, budget, context);
+    error3 = createSubsetErrorValue(name, text5, context?.stack ?? [], budget);
+    setSandboxPrototype(error3, prototype, budget);
+    if (options !== null && typeof options === "object" && getSandboxPropertyDescriptor(options, "cause", budget) !== void 0) {
+      const cause = await readErrorProperty(options, "cause", budget, context);
+      Object.defineProperty(error3, "cause", { value: cause, writable: true, configurable: true });
+    }
+    if (name === "AggregateError") {
+      iterator = context === void 0 ? getSandboxIterator(args[0], budget) : await acquireSandboxIterator(args[0], budget, context);
+      if (iterator === void 0) throw new TypeError("AggregateError errors must be iterable.");
+      while (true) {
+        budget.visitNode();
+        const result = await iterator.next();
+        if (result === null || typeof result !== "object") throw new TypeError("Iterator result must be an object.");
+        if ((await readIteratorResult(iterator, result, "done")).value) break;
+        budget.allocateArrayLength(errors2.length + 1);
+        errors2.push((await readIteratorResult(iterator, result, "value")).value);
+      }
+      Object.defineProperty(error3, "errors", { value: errors2, writable: true, configurable: true });
+    }
+    return error3;
+  } finally {
+    release2();
+  }
+}
 function createSubsetError(name, args, stackFrames, budget) {
   const message2 = name === "AggregateError" ? args[1] : args[0];
   const options = name === "AggregateError" ? args[2] : args[1];
@@ -136443,6 +136924,13 @@ var errorConstructorNames, errorNames;
 var init_error = __esm({
   "packages/safe-js/src/interp/globals/error.ts"() {
     "use strict";
+    init_error_prototypes();
+    init_object_model();
+    init_intrinsics();
+    init_string_coercion();
+    init_resources();
+    init_accessors();
+    init_iteration();
     init_exceptions();
     init_values();
     errorConstructorNames = /* @__PURE__ */ new WeakMap();
@@ -136478,8 +136966,8 @@ async function ordinaryHasInstance(value, constructor, budget, context) {
     budget.visitNode();
     return evaluateInstanceof(value, constructor.boundTarget, budget, context);
   }
-  if (isFloat32ArrayConstructor(constructor)) return isFloat32Array(value);
-  if (isSandboxErrorConstructorInstance2(value, constructor)) return true;
+  if (isFloat32ArrayConstructor(constructor) && !isGuestClosure(constructor)) return isFloat32Array(value);
+  if ((!isGuestClosure(constructor) || value !== null && typeof value === "object" && !hasExplicitSandboxPrototype(value)) && isSandboxErrorConstructorInstance2(value, constructor)) return true;
   if (!isGuestClosure(constructor) || typeof value !== "object" || value === null) return false;
   const prototype = await readInstanceProperty(constructor, "prototype", budget, context);
   if (typeof prototype !== "object" || prototype === null)
@@ -139078,7 +139566,7 @@ async function evaluateMemberCallExpression(node, context) {
     if (isFloat32Array(member.object)) {
       return evaluateResolvedCallExpression(
         node,
-        getFloat32Member(member.object, member.property, context.budget),
+        await getPropertyValue(member.object, member.property, context),
         context,
         member.object
       );
@@ -139615,8 +140103,7 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
   if (isSandboxGenerator(target)) target = getGeneratorProperties(target);
   if (isSandboxMap(target) || isSandboxSet(target)) target = getCollectionProperties(target);
   if (isFloat32Array(target)) {
-    if (typeof property === "symbol") throw new TypeError("Typed array symbol properties are not yet supported.");
-    setFloat32Member(target, property, value);
+    setFloat32Member(target, property, value, budget);
     return;
   }
   if (isSandboxRegex(target)) {
@@ -140820,11 +141307,10 @@ function surfaceThrownValue(reason, budget, stackFrames = [], span) {
     throw reason;
   }
   if (isSubsetErrorValue(reason)) {
-    normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
-    return reason;
+    return normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
   }
   if (reason instanceof Error) {
-    const error3 = createSubsetErrorValue(
+    const error4 = createSubsetErrorValue(
       reason.name || "Error",
       reason.message,
       stackFrames,
@@ -140835,11 +141321,10 @@ function surfaceThrownValue(reason, budget, stackFrames = [], span) {
         span
       }
     );
-    normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
-    return error3;
+    return normalizeSurfacedSubsetError(error4, budget, stackFrames, span);
   }
   if (isErrorLikeValue(reason)) {
-    const error3 = createSubsetErrorValue(
+    const error4 = createSubsetErrorValue(
       reason.name || "Error",
       reason.message,
       stackFrames,
@@ -140850,13 +141335,13 @@ function surfaceThrownValue(reason, budget, stackFrames = [], span) {
         span
       }
     );
-    normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
-    return error3;
+    return normalizeSurfacedSubsetError(error4, budget, stackFrames, span);
   }
-  return createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
+  const error3 = createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
     chargeBudget: false,
     span
   });
+  return normalizeSurfacedSubsetError(error3, budget, stackFrames, span);
 }
 function createSubsetErrorValue(name, message2, stackFrames, budget, options = {}) {
   const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : void 0;
@@ -140865,11 +141350,15 @@ function createSubsetErrorValue(name, message2, stackFrames, budget, options = {
     const errorMessage9 = budget.allocateString(coerceErrorMessage(message2));
     const header = errorMessage9 === "" ? errorName : `${errorName}: ${errorMessage9}`;
     const stack = budget.allocateString([header, ...[...stackFrames].reverse()].join("\n"));
-    const error3 = {
-      name: errorName,
-      message: errorMessage9,
-      stack
-    };
+    const prototype = options.transport ? void 0 : errorPrototypes.get(budget)?.get(toSandboxErrorName(errorName));
+    const error3 = prototype === void 0 ? { name: errorName, message: errorMessage9, stack } : {};
+    if (prototype !== void 0) {
+      if (message2 !== void 0) Object.defineProperty(error3, "message", { value: errorMessage9, writable: true, configurable: true });
+      if (!errorPrototypes.get(budget).has(errorName))
+        Object.defineProperty(error3, "name", { value: errorName, writable: true, configurable: true });
+      Object.defineProperty(error3, "stack", { value: stack, writable: true, configurable: true });
+      setSandboxPrototype(error3, prototype, budget);
+    }
     sandboxErrorTypes.set(error3, toSandboxErrorName(errorName));
     attachErrorSpan(error3, options.span);
     attachWrappedErrorCause(error3, options.cause);
@@ -140890,6 +141379,7 @@ function isSubsetErrorValue(value) {
   if (typeof value !== "object" || value === null) {
     return false;
   }
+  if (sandboxErrorTypes.has(value)) return true;
   const prototype = Object.getPrototypeOf(value);
   return (prototype === Object.prototype || prototype === null) && typeof value.name === "string" && typeof value.message === "string" && typeof value.stack === "string";
 }
@@ -140899,21 +141389,37 @@ function normalizeSurfacedSubsetError(error3, budget, stackFrames, span) {
     const name = budget.allocateString(toSandboxErrorName(readErrorName(error3)));
     const message2 = budget.allocateString(readSurfacedErrorMessage(error3, name));
     const frames = readSandboxStackFrames(error3.stack);
+    if (!Object.isExtensible(error3) || ["name", "message", "stack"].some((key3) => {
+      const descriptor = Object.getOwnPropertyDescriptor(error3, key3);
+      return descriptor !== void 0 && (!("value" in descriptor) || !descriptor.writable);
+    })) {
+      const original = error3;
+      const descriptors2 = Object.getOwnPropertyDescriptors(original);
+      delete descriptors2.name;
+      delete descriptors2.message;
+      delete descriptors2.stack;
+      error3 = Object.defineProperties({}, descriptors2);
+      const errorType = sandboxErrorTypes.get(original);
+      if (errorType !== void 0) sandboxErrorTypes.set(error3, errorType);
+    }
     error3.name = name;
     error3.message = message2;
     error3.stack = budget.allocateString(
       formatErrorStack(name, message2, frames.length > 0 ? frames : [...stackFrames].reverse())
     );
     attachErrorSpan(error3, readErrorSpan(error3) ?? span);
+    return error3;
   } finally {
     resumeChecks();
   }
 }
 function readErrorName(error3) {
-  return typeof error3.name === "string" && error3.name.length > 0 ? error3.name : "Error";
+  const name = getSandboxDataProperty(error3, "name");
+  return typeof name === "string" && name.length > 0 ? name : sandboxErrorTypes.get(error3) ?? "Error";
 }
 function readSurfacedErrorMessage(error3, name) {
-  const message2 = typeof error3.message === "string" ? error3.message : "";
+  const value = getSandboxDataProperty(error3, "message");
+  const message2 = typeof value === "string" ? value : "";
   if (message2 === "") {
     return `${name} thrown`;
   }
@@ -141202,6 +141708,7 @@ var init_exceptions = __esm({
     init_object2();
     init_resources();
     init_object_model();
+    init_error_prototypes();
     init_property_key();
     init_internal_symbols();
     init_resume_target();
@@ -142723,9 +143230,12 @@ function measureSandboxData(values, options = {}) {
         seen.add(storage2.buffer);
         usage += storage2.byteLength;
       }
-      for (const [key3, descriptor] of float32DataProperties(value)) {
-        usage += key3.length + 1;
-        visit(descriptor.value, depth + 1);
+      for (const [key3, descriptor] of float32Properties(value)) {
+        usage += 1;
+        if (typeof key3 === "string") usage += key3.length;
+        else visit(key3, depth + 1);
+        if ("value" in descriptor) visit(descriptor.value, depth + 1);
+        else for (const closure of retainedAccessorClosures(descriptor)) visit(closure, depth + 1);
       }
       return;
     }
@@ -142858,7 +143368,7 @@ function measureSandboxData(values, options = {}) {
       const descriptor = Object.getOwnPropertyDescriptor(value, key3);
       if (descriptor !== void 0) descriptors2.push([key3, descriptor]);
     }
-    const includeNonEnumerable = isSandboxDate(value) || hasManagedDescriptors(value);
+    const includeNonEnumerable = isSandboxDate(value) || sandboxErrorTypes.has(value) || hasManagedDescriptors(value);
     for (const [key3, descriptor] of descriptors2) {
       if (!descriptor.enumerable && !includeNonEnumerable) continue;
       usage += 1 + key3.length;
@@ -143191,6 +143701,53 @@ function copyFromSandbox(value, state, path193 = "<root>", options, depth = 0) {
     return options.unwrapHostObject(value);
   }
   if (nodeTypes.isProxy(value)) throw new TypeError("Unsupported proxy sandbox value.");
+  if (sandboxErrorTypes.has(value) && hasExplicitSandboxPrototype(value)) {
+    const prototype = getSandboxPrototype(value);
+    let nativePrototype = null;
+    if (prototype !== null) {
+      const identity = getIntrinsicIdentity(prototype);
+      const nativePrototypes = {
+        Error: Error.prototype,
+        TypeError: TypeError.prototype,
+        RangeError: RangeError.prototype,
+        ReferenceError: ReferenceError.prototype,
+        SyntaxError: SyntaxError.prototype,
+        URIError: URIError.prototype,
+        EvalError: EvalError.prototype,
+        AggregateError: AggregateError.prototype
+      };
+      const path194 = identity === void 0 ? [] : JSON.parse(identity);
+      if (path194.length !== 2 || typeof path194[0] !== "string" || path194[1] !== "prototype" || !Object.hasOwn(nativePrototypes, path194[0]))
+        throw new TypeError("Custom Error prototype links cannot be copied as data.");
+      nativePrototype = nativePrototypes[path194[0]];
+      let current = prototype;
+      let prototypeDepth = 0;
+      while (current !== null) {
+        assertSandboxDataDepth(++prototypeDepth);
+        const objectPrototype = getIntrinsicIdentity(current) === '["Object","prototype"]';
+        const owner = objectPrototype ? Object.getOwnPropertyDescriptor(current, "constructor")?.value : current;
+        if (owner === null || typeof owner !== "object" || objectPrototype && getIntrinsicIdentity(owner) !== '["Object"]' || hasGuestObjectState(owner))
+          throw new TypeError("Modified Error prototype links cannot be copied as data.");
+        current = getSandboxPrototype(current);
+      }
+    }
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const descriptors2 = Reflect.ownKeys(value).filter((key3) => typeof key3 !== "symbol" || !internalSymbols.has(key3)).map((key3) => [key3, Object.getOwnPropertyDescriptor(value, key3)]);
+    if (descriptors2.some(([, descriptor]) => !("value" in descriptor)))
+      throw new TypeError("Error accessor properties cannot be copied as data.");
+    const copy = new Error();
+    delete copy.stack;
+    Object.setPrototypeOf(copy, nativePrototype);
+    state.seen.set(value, copy);
+    for (const [key3, descriptor] of descriptors2)
+      Object.defineProperty(copy, key3, {
+        ...descriptor,
+        value: copyFromSandbox(descriptor.value, state, joinPath(path193, key3), options, depth + 1)
+      });
+    if (!Object.isExtensible(value)) Object.preventExtensions(copy);
+    return copy;
+  }
   if (!isSandboxClosure(value) && hasGuestObjectState(value)) {
     throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
   }
@@ -143577,6 +144134,7 @@ var init_values = __esm({
     "use strict";
     init_otel2();
     init_internal_symbols();
+    init_intrinsics();
     init_generator_properties();
     init_regexp_properties();
     init_collection_properties();
@@ -143840,8 +144398,14 @@ function captureGuestHeapNode(value, encode) {
     }
     if (isLiveCapability(value) || isSandboxClosure(value) || isSandboxBox(value) || isSandboxDate(value) || isSandboxRegex(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxArguments(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value)) return void 0;
     const prototype = Object.getPrototypeOf(value);
-    if ((prototype === null || prototype === Object.prototype) && hasGuestObjectState(value))
-      return { kind: "guest-object", state: captureObjectState(value, encode) };
+    if ((prototype === null || prototype === Object.prototype) && hasGuestObjectState(value)) {
+      const errorType = sandboxErrorTypes.get(value);
+      return {
+        kind: "guest-object",
+        state: captureObjectState(value, encode),
+        ...errorType === void 0 ? {} : { errorType }
+      };
+    }
     return void 0;
   }
   if (origin.node.nodeId === void 0) throw new TypeError("Guest closures require an AST node identity.");
@@ -143879,6 +144443,7 @@ var init_guest_heap = __esm({
     "use strict";
     init_closure_origin();
     init_bound_function_state();
+    init_shape();
     init_generator_properties();
     init_intrinsics();
     init_object_model();
@@ -144910,9 +145475,11 @@ function createHostErrorValue(reason, stackFrames, budget, span, state = { seen:
   }
   const error3 = reason instanceof Error ? createSubsetErrorValue(reason.name, reason.message, stackFrames, budget, {
     cause: reason,
-    chargeBudget
+    chargeBudget,
+    transport: true
   }) : createSubsetErrorValue("Error", describeThrownReason(reason), stackFrames, budget, {
-    chargeBudget: false
+    chargeBudget: false,
+    transport: true
   });
   if (reason instanceof Error) {
     state.seen.set(reason, error3);
@@ -147448,11 +148015,11 @@ function createBuiltinBindings(options) {
   const bindings = {
     ...createConsoleJsonGlobals(options),
     ...createCollectionGlobals(options),
-    Float32Array: createFloat32ArrayGlobal(options.budget),
+    Float32Array: createFloat32ArrayGlobal(options.budget, options.float32Prototypes !== false),
     Date: createDateGlobal(options),
     Symbol: createSymbolGlobal(options.budget),
     BigInt: createBigIntGlobal(options.budget),
-    ...createErrorGlobals(options),
+    ...createErrorGlobals({ ...options, errorPrototypes: options.errorPrototypes !== false }),
     ...createMathGlobals({ random: options.random, budget: options.budget }),
     ...createObjectArrayGlobals(options),
     ...createMiscGlobals(options),
@@ -147461,6 +148028,8 @@ function createBuiltinBindings(options) {
     ...createRegexGlobals(options)
   };
   createFunctionPrototype(options.budget, options.functionHasInstance);
+  if (options.float32Prototypes !== false) createFloat32ArrayPrototypes(options.budget, bindings.Float32Array);
+  if (options.errorPrototypes !== false) createErrorPrototypes(options.budget, bindings);
   createGeneratorPrototypes(options.budget);
   registerBuiltinIdentities(options.budget, bindings);
   return bindings;
@@ -147600,7 +148169,9 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     }
     state(node.state);
   } else if (node.kind === "guest-object" || node.kind === "guest-array") {
-    fields(node, ["kind", "state"], node.kind === "guest-array" ? ["templateNodeId", "templateOwner"] : []);
+    fields(node, ["kind", "state"], node.kind === "guest-array" ? ["templateNodeId", "templateOwner"] : ["errorType"]);
+    if (Object.hasOwn(node, "errorType") && !sandboxErrorNames.includes(node.errorType))
+      throw new TypeError("Invalid guest error type.");
     if (Object.hasOwn(node, "templateOwner")) reference(node.templateOwner, ["guest-array"]);
     if (Object.hasOwn(node, "templateNodeId") && integer2(node.templateNodeId) < 1)
       throw new TypeError("Invalid template source identity.");
@@ -147885,6 +148456,7 @@ var init_guest_heap_validation = __esm({
   "packages/safe-js/src/snapshot/guest-heap-validation.ts"() {
     "use strict";
     init_budget2();
+    init_shape();
     init_raw_json();
     init_globals();
     init_intrinsics();
@@ -148204,6 +148776,10 @@ function validateDumpHeap(root, state) {
     if (entry.kind === "float32array") {
       validateFloat32Storage(entry);
       requireRecord3(entry.entries, `${path193}.entries`);
+      if (Object.hasOwn(entry, "state")) {
+        if (Object.keys(entry.entries).length !== 0) fail2("invalidValue", path193, "ambiguous Float32Array property state");
+        validateGuestHeapNode({ kind: "guest-object", state: entry.state }, heap, state.limits.maxEntries);
+      }
       continue;
     }
     if (entry.kind === "arguments") {
@@ -148432,6 +149008,10 @@ function validateHeapValue(value, path193, state, heap) {
   if (record4.kind === "float32array") {
     validateFloat32Storage(record4);
     requireRecord3(record4.entries, `${path193}.entries`);
+    if (Object.hasOwn(record4, "state")) {
+      if (Object.keys(record4.entries).length !== 0) fail2("invalidValue", path193, "ambiguous Float32Array property state");
+      validateGuestHeapNode({ kind: "guest-object", state: record4.state }, heap, state.limits.maxEntries);
+    }
   }
   if (record4.kind === "map") {
     const entries = requireArray(record4.entries, `${path193}.entries`, state);
@@ -148564,7 +149144,7 @@ function validateArrayHeap(record4, path193, state) {
 }
 function validateErrorType(record4, path193) {
   if (!Object.hasOwn(record4, "errorType")) return;
-  if (record4.kind !== "object" || !sandboxErrorNames.includes(record4.errorType)) {
+  if (record4.kind !== "object" && record4.kind !== "guest-object" || !sandboxErrorNames.includes(record4.errorType)) {
     fail2("invalidValue", `${path193}.errorType`, "invalid error metadata");
   }
 }