@poe-platform/safe-js 0.1.354 → 0.1.356

package/dist/safe-js/chunks/{chunk-CJ7PNS2V.js → chunk-GMJXANAZ.js}

@@ -6887,7 +6887,8 @@ function arrayBufferDataProperties(value) {
   });
 }
 
-// packages/safe-js/src/interp/float32.ts
+// packages/safe-js/src/interp/typed-array.ts
+var numericTypedArrayConstructors = { Float32Array, Uint8Array };
 var typedArrayPrototype = Object.getPrototypeOf(Float32Array.prototype);
 var readLength2 = Object.getOwnPropertyDescriptor(typedArrayPrototype, "length").get;
 var readOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
@@ -6896,57 +6897,62 @@ var readTag = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStri
 var createValuesIterator = Object.getOwnPropertyDescriptor(typedArrayPrototype, "values").value;
 var bufferLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
 var bufferResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get;
-var float32ViewLayouts = /* @__PURE__ */ new WeakMap();
+var typedArrayViewLayouts = /* @__PURE__ */ new WeakMap();
 var resizeBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize")?.value;
-function restoreFloat32View(buffer, byteOffset, length, budget) {
+function restoreTypedArrayView(buffer, byteOffset, length, budget, Native = Float32Array) {
   const originalLength = arrayBufferLength(buffer);
-  const required = byteOffset + (length ?? 0) * 4;
+  const required = byteOffset + (length ?? 0) * Native.BYTES_PER_ELEMENT;
   const options = arrayBufferOptions(buffer);
   const grow = required > originalLength;
   if (grow) {
     if (resizeBuffer === void 0 || options === void 0 || required > options.maxByteLength)
       throw new RangeError("Float32Array layout exceeds backing capacity.");
-    budget?.allocateArrayLength(Math.ceil(required / 4));
+    budget?.allocateArrayLength(Math.ceil(required / Native.BYTES_PER_ELEMENT));
     budget?.provisionDataUsage(required - originalLength)();
     Reflect.apply(resizeBuffer, buffer, [required]);
   }
   try {
-    const view = new Float32Array(buffer, byteOffset, length);
-    if (options !== void 0) float32ViewLayouts.set(view, { byteOffset, ...length === void 0 ? {} : { length } });
+    const view = new Native(buffer, byteOffset, length);
+    if (options !== void 0) typedArrayViewLayouts.set(view, { byteOffset, ...length === void 0 ? {} : { length } });
     return view;
   } finally {
     if (grow) Reflect.apply(resizeBuffer, buffer, [originalLength]);
   }
 }
-function isFloat32Array(value) {
-  return ArrayBuffer.isView(value) && Object.getPrototypeOf(value) === Float32Array.prototype && Reflect.apply(readTag, value, []) === "Float32Array";
+function isNumericTypedArray(value) {
+  if (!ArrayBuffer.isView(value)) return false;
+  const tag = Reflect.apply(readTag, value, []);
+  return Object.hasOwn(numericTypedArrayConstructors, tag) && Object.getPrototypeOf(value) === numericTypedArrayConstructors[tag].prototype;
 }
-function float32Storage(value, requireInBounds = false) {
+function typedArrayStorage(value, requireInBounds = false) {
   if (requireInBounds) Reflect.apply(createValuesIterator, value, []);
   const buffer = Reflect.apply(readBuffer, value, []);
   if (Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype) {
     throw new TypeError("Float32Array requires a non-shared ArrayBuffer.");
   }
+  const Native = numericTypedArrayConstructors[Reflect.apply(readTag, value, [])];
   return {
+    Native,
+    elementSize: Native.BYTES_PER_ELEMENT,
     buffer,
     byteOffset: Reflect.apply(readOffset, value, []),
     length: Reflect.apply(readLength2, value, []),
     byteLength: Reflect.apply(bufferLength, buffer, [])
   };
 }
-function float32Properties(value) {
+function typedArrayProperties(value) {
   const properties = [];
   for (const key of Reflect.ownKeys(value)) {
-    if (typeof key === "string" && isFloat32Index(key)) continue;
+    if (typeof key === "string" && isTypedArrayIndex(key)) continue;
     properties.push([key, Object.getOwnPropertyDescriptor(value, key)]);
   }
   return properties;
 }
-function float32DataProperties(value) {
+function typedArrayDataProperties(value) {
   if (Object.getOwnPropertySymbols(value).length > 0)
     throw new TypeError("Float32Array symbol properties are not supported.");
   const properties = [];
-  for (const [key, descriptor] of float32Properties(value)) {
+  for (const [key, descriptor] of typedArrayProperties(value)) {
     if (typeof key !== "string") throw new TypeError("Float32Array symbol properties are not supported.");
     if (!("value" in descriptor))
       throw new TypeError(`Float32Array accessor property '${key}' is not supported.`);
@@ -6954,10 +6960,10 @@ function float32DataProperties(value) {
   }
   return properties;
 }
-function isFloat32Index(key) {
+function isTypedArrayIndex(key) {
   return key === "-0" || String(Number(key)) === key;
 }
-function float32Number(value) {
+function typedArrayNumber(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."
@@ -6965,19 +6971,19 @@ function float32Number(value) {
   }
   return Number(value);
 }
-function checkFloat32Allocation(length, budget) {
+function checkTypedArrayAllocation(length, budget, elementSize = Float32Array.BYTES_PER_ELEMENT) {
   budget.allocateArrayLength(length);
-  budget.provisionDataUsage(length * Float32Array.BYTES_PER_ELEMENT + 1)();
+  budget.provisionDataUsage(length * elementSize + 1)();
 }
-function copyFloat32Storage(value, state) {
-  const storage = float32Storage(value);
+function copyTypedArrayStorage(value, state) {
+  const storage = typedArrayStorage(value);
   const buffer = copyArrayBufferStorage(storage.buffer, state);
   if (bufferResizable !== void 0 && Reflect.apply(bufferResizable, storage.buffer, [])) {
-    const layout = float32ViewLayouts.get(value);
+    const layout = typedArrayViewLayouts.get(value);
     if (layout === void 0) throw new TypeError("Resizable Float32Array copies require known view layout.");
-    return restoreFloat32View(buffer, layout.byteOffset, layout.length);
+    return restoreTypedArrayView(buffer, layout.byteOffset, layout.length, void 0, storage.Native);
   }
-  return new Float32Array(buffer, storage.byteOffset, storage.length);
+  return new storage.Native(buffer, storage.byteOffset, storage.length);
 }
 
 // packages/safe-js/src/interp/date.ts
@@ -7970,8 +7976,8 @@ function namedKeys(state) {
 // packages/safe-js/src/interp/error-prototypes.ts
 var errorPrototypes = /* @__PURE__ */ new WeakMap();
 
-// packages/safe-js/src/interp/float32-prototypes.ts
-var float32Prototypes = /* @__PURE__ */ new WeakMap();
+// packages/safe-js/src/interp/typed-array-prototypes.ts
+var typedArrayPrototypes = /* @__PURE__ */ new WeakMap();
 
 // packages/safe-js/src/interp/object-model.ts
 var guestClosures = /* @__PURE__ */ new WeakSet();
@@ -8198,7 +8204,7 @@ function releaseObjectPrototype(budget) {
   functionPrototypes.delete(budget);
   generatorPrototypes.delete(budget);
   errorPrototypes.delete(budget);
-  float32Prototypes.delete(budget);
+  typedArrayPrototypes.delete(budget);
   arrayBufferPrototypes.delete(budget);
   initialRegexDescriptors.delete(budget);
   intrinsicPrototypes.delete(budget);
@@ -8206,7 +8212,7 @@ function releaseObjectPrototype(budget) {
 function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
   if (isSandboxArrayBuffer(value)) return budget === void 0 ? null : arrayBufferPrototypes.get(budget) ?? null;
-  if (isFloat32Array(value)) return budget === void 0 ? null : float32Prototypes.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) {
     const prototype = errorPrototypes.get(budget)?.get(errorType);
@@ -8239,7 +8245,7 @@ function getSandboxPropertyDescriptor(value, key, 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 key !== "symbol" && isFloat32Index(String(key)))
+    if (isNumericTypedArray(current) && typeof key !== "symbol" && isTypedArrayIndex(String(key)))
       return Object.getOwnPropertyDescriptor(current, key);
     const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? key === "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) && (key === "name" || key === "length"))
@@ -8263,7 +8269,7 @@ function getSandboxDataProperty(value, key, budget) {
   let current = value;
   let depth = 0;
   while (typeof current === "object" && current !== null) {
-    if (isFloat32Array(current) && typeof key !== "symbol" && isFloat32Index(String(key)))
+    if (isNumericTypedArray(current) && typeof key !== "symbol" && isTypedArrayIndex(String(key)))
       return Object.getOwnPropertyDescriptor(current, key)?.value;
     if (isGuestHostObject(current)) return typeof key === "symbol" ? void 0 : getHostObjectMember(current, String(key));
     if (isSandboxRegex(current)) return Object.getOwnPropertyDescriptor(getRegexProperties(current), key)?.value;
@@ -8317,7 +8323,7 @@ function setSandboxPrototype(value, prototype, budget) {
 }
 function isPrototypeRecord(value) {
   if (isSandboxArrayBuffer(value)) return true;
-  if (isFloat32Array(value)) return true;
+  if (isNumericTypedArray(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))
@@ -8337,7 +8343,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) && (isFloat32Array(value) ? float32Properties(value).map(([, descriptor]) => descriptor) : Object.values(Object.getOwnPropertyDescriptors(value))).some(
+  return descriptorObjects.has(value) && (isNumericTypedArray(value) ? typedArrayProperties(value).map(([, descriptor]) => descriptor) : Object.values(Object.getOwnPropertyDescriptors(value))).some(
     (descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable
   );
 }
@@ -9801,8 +9807,8 @@ function getSandboxIterator(value, budget, context) {
     };
   }
   if (isGuestHostObject(value)) return getHostObjectIterator(value);
-  if (isFloat32Array(value)) {
-    if (hasExplicitSandboxPrototype(value) || budget !== void 0 && float32Prototypes.has(budget)) {
+  if (isNumericTypedArray(value)) {
+    if (hasExplicitSandboxPrototype(value) || budget !== void 0 && typedArrayPrototypes.has(budget)) {
       if (getSandboxPropertyDescriptor(value, Symbol.iterator, budget) === void 0) return void 0;
       return guestProtocolAdapter(value, budget ?? new Budget(), context, false);
     }
@@ -10727,10 +10733,10 @@ async function nextArrayIterator(value, budget, context) {
   if (source === void 0) return { value: void 0, done: true };
   const index = state.index;
   const release = retainValues(budget, () => [value, source]);
-  const read = (key) => context?.getProperty !== void 0 ? context.getProperty(source, key) : readPropertyDescriptor((isFloat32Array(source) ? Object.getOwnPropertyDescriptor(source, key) : void 0) ?? getSandboxPropertyDescriptor(source, key, budget) ?? { value: void 0 }, source, context);
+  const read = (key) => context?.getProperty !== void 0 ? context.getProperty(source, key) : readPropertyDescriptor((isNumericTypedArray(source) ? Object.getOwnPropertyDescriptor(source, key) : void 0) ?? getSandboxPropertyDescriptor(source, key, budget) ?? { value: void 0 }, source, context);
   try {
     budget.visitNode();
-    const number = isFloat32Array(source) ? float32Storage(source, true).length : await sandboxNumber(await read("length"), budget, context);
+    const number = isNumericTypedArray(source) ? typedArrayStorage(source, true).length : await sandboxNumber(await read("length"), budget, context);
     const length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
     if (index >= length) {
       state.source = void 0;
@@ -10814,7 +10820,7 @@ async function canonicalizeGuestLocales(input, budget, context) {
     for (let index = 0; index < length; index++) {
       budget.visitNode();
       const key = String(index);
-      if (getSandboxPropertyDescriptor(list2, key, budget) === void 0 && !(isFloat32Array(list2) && Object.hasOwn(list2, key))) continue;
+      if (getSandboxPropertyDescriptor(list2, key, budget) === void 0 && !(isNumericTypedArray(list2) && Object.hasOwn(list2, key))) continue;
       const value = await readIntlProperty(list2, key, budget, context);
       if (typeof value !== "string" && (typeof value !== "object" || value === null))
         return Reflect.apply(canonicalLocales, Intl, [[value]]);
@@ -13775,7 +13781,7 @@ async function definePropertiesFromObject(target, descriptors2, budget, context)
 }
 function defineDataProperty(target, key, descriptor, budget, context) {
   budget.visitNode();
-  if (isFloat32Array(target) && typeof key !== "symbol" && isFloat32Index(String(key)) && "value" in descriptor) {
+  if (isNumericTypedArray(target) && typeof key !== "symbol" && isTypedArrayIndex(String(key)) && "value" in descriptor) {
     const { value, ...attributes } = descriptor;
     Object.defineProperty(target, key, attributes);
     return (async () => {
@@ -14621,52 +14627,57 @@ async function callSetMethod(target, methodName, args, options, stack = []) {
   }
 }
 
-// packages/safe-js/src/interp/globals/float32array.ts
-var constructors = /* @__PURE__ */ new WeakSet();
-function createFloat32ArrayGlobal(budget, nativePrototype = false) {
+// packages/safe-js/src/interp/globals/numeric-typed-array.ts
+var constructors = /* @__PURE__ */ new WeakMap();
+function createNumericTypedArrayGlobal(budget, nativePrototype = false, Native = Float32Array) {
   const constructor = createSandboxClosure({
     guest: nativePrototype,
     sandbox: true,
-    name: "Float32Array",
+    name: Native.name,
     length: 3,
-    properties: { BYTES_PER_ELEMENT: 4 },
+    properties: { BYTES_PER_ELEMENT: Native.BYTES_PER_ELEMENT },
     call: () => {
       throw new TypeError("Constructor Float32Array requires 'new'.");
     },
     construct: (args, context) => {
-      if (!nativePrototype) return allocateFloat32Array(args[0], budget);
+      if (!nativePrototype) return allocateTypedArray(args[0], budget, Native);
       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 prototype = candidate !== null && typeof candidate === "object" ? candidate : typedArrayPrototypes.get(budget).get(Native);
         const release = retainValues(budget, () => [prototype, ...args]);
         try {
           if (isSandboxArrayBuffer(args[0])) {
             const buffer = args[0];
             const number = await sandboxNumber(args[1], budget, context);
             const offset = Number.isNaN(number) ? 0 : Math.trunc(number);
-            if (!Number.isSafeInteger(offset) || offset < 0 || offset % 4 !== 0)
+            if (!Number.isSafeInteger(offset) || offset < 0 || offset % Native.BYTES_PER_ELEMENT !== 0)
               throw new RangeError("Invalid Float32Array buffer offset.");
-            const bytes = arrayBufferLength(buffer);
             let length;
-            if (args[2] === void 0) {
-              if (arrayBufferOptions(buffer) === void 0 && bytes % 4 !== 0 || offset > bytes)
-                throw new RangeError("Invalid Float32Array buffer length.");
-              length = Math.floor((bytes - offset) / 4);
-            } else {
+            if (args[2] !== void 0) {
               const size = await sandboxNumber(args[2], budget, context);
               length = Number.isNaN(size) ? 0 : Math.trunc(size);
-              if (!Number.isSafeInteger(length) || length < 0 || offset + length * 4 > arrayBufferLength(buffer))
+              if (!Number.isSafeInteger(length) || length < 0)
+                throw new RangeError("Invalid Float32Array view length.");
+            }
+            if (arrayBufferDetached(buffer)) throw new TypeError("Cannot construct Float32Array from a detached ArrayBuffer.");
+            const bytes = arrayBufferLength(buffer);
+            if (length === void 0) {
+              if (arrayBufferOptions(buffer) === void 0 && bytes % Native.BYTES_PER_ELEMENT !== 0 || offset > bytes)
+                throw new RangeError("Invalid Float32Array buffer length.");
+              length = Math.floor((bytes - offset) / Native.BYTES_PER_ELEMENT);
+            } else {
+              if (offset + length * Native.BYTES_PER_ELEMENT > bytes)
                 throw new RangeError("Invalid Float32Array view length.");
             }
             budget.allocateArrayLength(length);
-            const result2 = new Float32Array(buffer, offset, args[2] === void 0 ? void 0 : length);
+            const result2 = new Native(buffer, offset, args[2] === void 0 ? void 0 : length);
             if (arrayBufferOptions(buffer) !== void 0)
-              float32ViewLayouts.set(result2, { byteOffset: offset, ...args[2] === void 0 ? {} : { length } });
+              typedArrayViewLayouts.set(result2, { byteOffset: offset, ...args[2] === void 0 ? {} : { length } });
             setSandboxPrototype(result2, prototype, budget);
             return result2;
           }
-          const result = args[0] !== null && typeof args[0] === "object" && !isFloat32Array(args[0]) ? await allocateFloat32Input(args[0], budget, context) : allocateFloat32Array(args[0], budget);
+          const result = args[0] !== null && typeof args[0] === "object" && !isNumericTypedArray(args[0]) ? await allocateTypedArrayInput(args[0], budget, Native, context) : allocateTypedArray(args[0], budget, Native);
           setSandboxPrototype(result, prototype, budget);
           return result;
         } finally {
@@ -14675,10 +14686,10 @@ function createFloat32ArrayGlobal(budget, nativePrototype = false) {
       })();
     }
   });
-  constructors.add(constructor);
+  constructors.set(constructor, Native);
   return constructor;
 }
-async function allocateFloat32Input(source, budget, context) {
+async function allocateTypedArrayInput(source, budget, Native, context) {
   const callerContext = context;
   const bridge = {
     ...callerContext,
@@ -14716,8 +14727,8 @@ async function allocateFloat32Input(source, budget, context) {
       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);
+    checkTypedArrayAllocation(length, budget, Native.BYTES_PER_ELEMENT);
+    result = new Native(length);
     checkData(result, 0, true);
     for (let index = 0; index < length; index++) {
       budget.visitNode();
@@ -14729,30 +14740,29 @@ async function allocateFloat32Input(source, budget, context) {
     release();
   }
 }
-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);
+function allocateTypedArray(source, budget, Native) {
+  if (Array.isArray(source) || isNumericTypedArray(source)) {
+    const length2 = isNumericTypedArray(source) ? typedArrayStorage(source).length : source.length;
+    checkTypedArrayAllocation(length2, budget, Native.BYTES_PER_ELEMENT);
+    if (isNumericTypedArray(source)) return new Native(source);
+    const result = new Native(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);
+      result[index] = typedArrayNumber(descriptor?.value);
     }
     return result;
   }
-  const number = float32Number(source);
+  const number = typedArrayNumber(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);
+  checkTypedArrayAllocation(length, budget, Native.BYTES_PER_ELEMENT);
+  return new Native(length);
 }
-function createFloat32ArrayPrototypes(budget, constructor) {
-  const prototype = /* @__PURE__ */ Object.create(null);
+function createNumericTypedArrayPrototypes(budget, bindings) {
   const shared = /* @__PURE__ */ Object.create(null);
   const abstractCall = () => {
     throw new TypeError("Abstract TypedArray constructor cannot be called.");
@@ -14821,7 +14831,7 @@ function createFloat32ArrayPrototypes(budget, constructor) {
             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)
+          if (!isNumericTypedArray(result) || typedArrayStorage(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++) {
@@ -14854,7 +14864,7 @@ function createFloat32ArrayPrototypes(budget, constructor) {
         const release = 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)
+          if (!isNumericTypedArray(result) || typedArrayStorage(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();
@@ -14867,17 +14877,25 @@ function createFloat32ArrayPrototypes(budget, constructor) {
       }
     })
   });
-  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 }
-  });
+  const prototypes2 = /* @__PURE__ */ new Map();
+  for (const [name, Native] of Object.entries(numericTypedArrayConstructors)) {
+    const constructor = bindings[name];
+    const prototype = /* @__PURE__ */ Object.create(null);
+    Object.defineProperties(materializeFunctionProperties(constructor), {
+      prototype: { value: prototype, writable: false },
+      BYTES_PER_ELEMENT: { value: Native.BYTES_PER_ELEMENT, writable: false, enumerable: false, configurable: false }
+    });
+    Object.defineProperties(prototype, {
+      constructor: { value: constructor, writable: true, configurable: true },
+      BYTES_PER_ELEMENT: { value: Native.BYTES_PER_ELEMENT }
+    });
+    setSandboxPrototype(constructor, typedArray);
+    setSandboxPrototype(prototype, shared);
+    prototypes2.set(Native, prototype);
+    registerIntrinsicFunction(budget, constructor);
+    registerIntrinsicObject(budget, prototype);
+  }
   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 = [];
   const species = createSandboxClosure({
@@ -14899,16 +14917,16 @@ function createFloat32ArrayPrototypes(budget, constructor) {
       name: `get ${key}`,
       length: 0,
       call: (_args, context) => {
-        if (!isFloat32Array(context?.thisValue)) throw new TypeError(`TypedArray ${key} requires a typed array receiver.`);
-        const storage = float32Storage(context.thisValue);
-        return key === "byteLength" ? storage.length * 4 : storage[key];
+        if (!isNumericTypedArray(context?.thisValue)) throw new TypeError(`TypedArray ${key} requires a typed array receiver.`);
+        const storage = typedArrayStorage(context.thisValue);
+        return key === "byteLength" ? storage.length * storage.elementSize : storage[key];
       }
     });
     getters.push(getter);
     Object.defineProperty(shared, key, { get: accessorAdapter(getter, "get"), configurable: true });
   }
   for (const key of ["set", "slice", "subarray", "fill", "copyWithin", "reverse", "toReversed", "at", "includes", "indexOf", "lastIndexOf", "forEach", "every", "some", "find", "findIndex", "findLast", "findLastIndex", "sort", "toSorted", "with", "reduce", "reduceRight", "map", "filter", "toLocaleString"])
-    Object.defineProperty(shared, key, { value: getFloat32Member(new Float32Array(0), key, budget, constructor), writable: true, configurable: true });
+    Object.defineProperty(shared, key, { value: getTypedArrayMember(new Float32Array(0), key, budget, bindings), 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", {
@@ -14920,9 +14938,9 @@ function createFloat32ArrayPrototypes(budget, constructor) {
       name: "join",
       length: 1,
       call: async (args, context) => {
-        if (!isFloat32Array(context?.thisValue)) throw new TypeError("TypedArray join requires a typed array receiver.");
+        if (!isNumericTypedArray(context?.thisValue)) throw new TypeError("TypedArray join requires a typed array receiver.");
         const receiver = context.thisValue;
-        const length = float32Storage(receiver, true).length;
+        const length = typedArrayStorage(receiver, true).length;
         let separator = ",";
         let text = "";
         const release = retainValues(budget, () => [receiver, separator, text, ...args]);
@@ -14945,7 +14963,7 @@ function createFloat32ArrayPrototypes(budget, constructor) {
     sandbox: true,
     name: "get [Symbol.toStringTag]",
     length: 0,
-    call: (_args, context) => isFloat32Array(context?.thisValue) ? "Float32Array" : void 0
+    call: (_args, context) => isNumericTypedArray(context?.thisValue) ? typedArrayStorage(context.thisValue).Native.name : void 0
   });
   getters.push(tagGetter);
   Object.defineProperty(shared, Symbol.toStringTag, { get: accessorAdapter(tagGetter, "get"), configurable: true });
@@ -14957,38 +14975,36 @@ function createFloat32ArrayPrototypes(budget, constructor) {
       name: key,
       length: 0,
       call: (args, context) => {
-        if (!isFloat32Array(context?.thisValue)) throw new TypeError(`TypedArray ${key} requires a typed array receiver.`);
-        float32Storage(context.thisValue, true);
+        if (!isNumericTypedArray(context?.thisValue)) throw new TypeError(`TypedArray ${key} requires a typed array receiver.`);
+        typedArrayStorage(context.thisValue, true);
         return invokeBuiltinClosure(method, args, budget, context, context.thisValue);
       }
     });
     Object.defineProperty(shared, key, { value: closure, writable: true, configurable: true });
     if (key === "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);
+  typedArrayPrototypes.set(budget, prototypes2);
+  registerBuiltinIdentities(budget, { ...bindings, "%TypedArray%": typedArray });
   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);
+function numericTypedArrayConstructor(value) {
+  return typeof value === "object" && value !== null ? constructors.get(value) : void 0;
 }
-function getFloat32Member(value, property, budget, defaultConstructor) {
+function getTypedArrayMember(value, property, budget, bindings) {
   const key = String(property);
   const descriptor = Object.getOwnPropertyDescriptor(value, key);
   if (descriptor !== void 0) {
     if (!("value" in descriptor)) throw new TypeError("Float32Array accessors are not supported.");
     return descriptor.value;
   }
-  if (float32Prototypes.has(budget)) return void 0;
-  const storage = float32Storage(value);
+  if (typedArrayPrototypes.has(budget)) return void 0;
+  const storage = typedArrayStorage(value);
   if (key === "length") return storage.length;
-  if (key === "byteLength") return storage.length * 4;
+  if (key === "byteLength") return storage.length * storage.elementSize;
   if (key === "byteOffset") return storage.byteOffset;
-  if (key === "BYTES_PER_ELEMENT") return 4;
+  if (key === "BYTES_PER_ELEMENT") return storage.elementSize;
   if (!["set", "slice", "subarray", "fill", "copyWithin", "reverse", "toReversed", "at", "includes", "indexOf", "lastIndexOf", "forEach", "every", "some", "find", "findIndex", "findLast", "findLastIndex", "sort", "toSorted", "with", "reduce", "reduceRight", "map", "filter", "toLocaleString"].includes(key)) return void 0;
   const numberPrototype = key === "toLocaleString" ? getBoxedPrototype(0, budget) : void 0;
   return createSandboxClosure({
@@ -15000,15 +15016,16 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
       if ((key === "sort" || key === "toSorted") && args[0] !== void 0 && !isSandboxClosure(args[0]))
         throw new TypeError("TypedArray sort comparator must be callable.");
       const receiver = context?.thisValue;
-      if (!isFloat32Array(receiver))
+      if (!isNumericTypedArray(receiver))
         throw new TypeError(`Float32Array#${key} requires a Float32Array receiver.`);
-      const storage2 = float32Storage(receiver, key === "sort" || key === "toSorted" || key === "with" || key === "reduce" || key === "reduceRight" || key === "map" || key === "filter" || key === "slice" || key === "fill" || key === "copyWithin" || key === "reverse" || key === "toReversed" || key === "at" || key === "includes" || key === "indexOf" || key === "lastIndexOf" || key === "forEach" || key === "every" || key === "some" || key === "find" || key === "findIndex" || key === "findLast" || key === "findLastIndex" || key === "toLocaleString");
+      const storage2 = typedArrayStorage(receiver, key === "sort" || key === "toSorted" || key === "with" || key === "reduce" || key === "reduceRight" || key === "map" || key === "filter" || key === "slice" || key === "fill" || key === "copyWithin" || key === "reverse" || key === "toReversed" || key === "at" || key === "includes" || key === "indexOf" || key === "lastIndexOf" || key === "forEach" || key === "every" || key === "some" || key === "find" || key === "findIndex" || key === "findLast" || key === "findLastIndex" || key === "toLocaleString");
+      const defaultConstructor = bindings?.[storage2.Native.name];
       if (key === "toReversed") {
         let result;
         const release = retainValues(budget, () => [receiver, result, ...args]);
         try {
-          checkFloat32Allocation(storage2.length, budget);
-          result = new Float32Array(storage2.length);
+          checkTypedArrayAllocation(storage2.length, budget, storage2.elementSize);
+          result = new storage2.Native(storage2.length);
           createDataCheckpoint(budget, context)(result, 0, true);
           for (let index = 0; index < storage2.length; index++) {
             budget.visitNode();
@@ -15022,14 +15039,14 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
       if (key === "reverse") {
         const release = retainValues(budget, () => [receiver, ...args]);
         try {
-          const bytes = new Uint8Array(storage2.buffer, storage2.byteOffset, storage2.length * 4);
+          const bytes = new Uint8Array(storage2.buffer, storage2.byteOffset, storage2.length * storage2.elementSize);
           for (let lower = 0; lower < Math.floor(storage2.length / 2); lower++) {
             const upper = storage2.length - lower - 1;
-            for (let offset = 0; offset < 4; offset++) {
+            for (let offset = 0; offset < storage2.elementSize; offset++) {
               budget.visitNode();
-              const saved = bytes[lower * 4 + offset];
-              bytes[lower * 4 + offset] = bytes[upper * 4 + offset];
-              bytes[upper * 4 + offset] = saved;
+              const saved = bytes[lower * storage2.elementSize + offset];
+              bytes[lower * storage2.elementSize + offset] = bytes[upper * storage2.elementSize + offset];
+              bytes[upper * storage2.elementSize + offset] = saved;
             }
           }
           return receiver;
@@ -15057,16 +15074,16 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
           const release = retainValues(budget, () => [receiver, items, scratch, comparisonResult, ...args]);
           const checkData = createDataCheckpoint(budget, bridge);
           try {
-            checkFloat32Allocation(storage2.length, budget);
-            items = new Float32Array(storage2.length);
+            checkTypedArrayAllocation(storage2.length, budget, storage2.elementSize);
+            items = new storage2.Native(storage2.length);
             checkData(items, 0, true);
             for (let index = 0; index < storage2.length; index++) {
               budget.visitNode();
               items[index] = receiver[index];
             }
             if (storage2.length < 2) return items;
-            checkFloat32Allocation(storage2.length, budget);
-            scratch = new Float32Array(storage2.length);
+            checkTypedArrayAllocation(storage2.length, budget, storage2.elementSize);
+            scratch = new storage2.Native(storage2.length);
             checkData(scratch, 0, true);
             for (let width = 1; width < storage2.length; width *= 2) {
               for (let start = 0; start < storage2.length; start += width * 2) {
@@ -15211,10 +15228,10 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
             const relative = Number.isNaN(number) ? 0 : Math.trunc(number);
             const index = relative < 0 ? storage2.length + relative : relative;
             const replacement = await sandboxNumber(args[1], budget, bridge);
-            if (index < 0 || index >= float32Storage(receiver).length)
+            if (index < 0 || index >= typedArrayStorage(receiver).length)
               throw new RangeError("Float32Array#with index is out of bounds.");
-            checkFloat32Allocation(storage2.length, budget);
-            result = new Float32Array(storage2.length);
+            checkTypedArrayAllocation(storage2.length, budget, storage2.elementSize);
+            result = new storage2.Native(storage2.length);
             createDataCheckpoint(budget, bridge)(result, 0, true);
             for (let offset = 0; offset < storage2.length; offset++) {
               budget.visitNode();
@@ -15248,14 +15265,14 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
             const end = args[2] === void 0 ? storage2.length : relativeIndex(await sandboxNumber(args[2], budget, bridge), storage2.length);
             let count = Math.min(end - start, storage2.length - target);
             if (count > 0) {
-              const current = float32Storage(receiver, true);
+              const current = typedArrayStorage(receiver, true);
               count = Math.min(count, current.length - start, current.length - target);
               if (count > 0) {
-                const bytes = new Uint8Array(current.buffer, current.byteOffset, current.length * 4);
+                const bytes = new Uint8Array(current.buffer, current.byteOffset, current.length * storage2.elementSize);
                 const direction = start < target && target < start + count ? -1 : 1;
-                let from = start * 4 + (direction < 0 ? count * 4 - 1 : 0);
-                let to = target * 4 + (direction < 0 ? count * 4 - 1 : 0);
-                for (let remaining = count * 4; remaining > 0; remaining--) {
+                let from = start * storage2.elementSize + (direction < 0 ? count * storage2.elementSize - 1 : 0);
+                let to = target * storage2.elementSize + (direction < 0 ? count * storage2.elementSize - 1 : 0);
+                for (let remaining = count * storage2.elementSize; remaining > 0; remaining--) {
                   budget.visitNode();
                   bytes[to] = bytes[from];
                   from += direction;
@@ -15276,7 +15293,7 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
             const value2 = await sandboxNumber(args[0], budget, bridge);
             const start = relativeIndex(await sandboxNumber(args[1], budget, bridge), storage2.length);
             const end = args[2] === void 0 ? storage2.length : relativeIndex(await sandboxNumber(args[2], budget, bridge), storage2.length);
-            const current = float32Storage(receiver, true);
+            const current = typedArrayStorage(receiver, true);
             for (let index = start; index < Math.min(end, current.length); index++) {
               budget.visitNode();
               receiver[index] = value2;
@@ -15297,10 +15314,10 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
             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.");
-            const targetStorage = float32Storage(receiver, true);
+            const targetStorage = typedArrayStorage(receiver, true);
             if (source === null || source === void 0) throw new TypeError("Float32Array#set requires a non-null source.");
             let length;
-            if (isFloat32Array(source)) length = float32Storage(source, true).length;
+            if (isNumericTypedArray(source)) length = typedArrayStorage(source, true).length;
             else {
               sourceObject = typeof source === "object" ? source : createSandboxBox(source);
               current = await bridge.getProperty(sourceObject, "length");
@@ -15308,7 +15325,7 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
               length = Number.isNaN(size) || size <= 0 ? 0 : Math.min(Math.trunc(size), Number.MAX_SAFE_INTEGER);
             }
             if (offset + length > targetStorage.length) throw new RangeError("Float32Array#set source is out of bounds.");
-            if (isFloat32Array(source)) Float32Array.prototype.set.call(receiver, source, offset);
+            if (isNumericTypedArray(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));
@@ -15346,8 +15363,8 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
             }
             length = kept.length;
           }
-          const layout = float32ViewLayouts.get(receiver);
-          const offset = (layout?.byteOffset ?? storage2.byteOffset) + start * 4;
+          const layout = typedArrayViewLayouts.get(receiver);
+          const offset = (layout?.byteOffset ?? storage2.byteOffset) + start * storage2.elementSize;
           const tracking = layout !== void 0 && layout.length === void 0 && args[1] === void 0;
           if (defaultConstructor !== void 0) {
             candidate = await bridge.getProperty(receiver, "constructor");
@@ -15362,24 +15379,24 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
           if (candidate !== void 0 && candidate !== null && candidate !== defaultConstructor) {
             const values = key !== "subarray" ? [length] : [storage2.buffer, offset, tracking ? void 0 : length];
             result = await invokeBuiltinClosure(candidate, values, budget, bridge, void 0, true);
-            if (!isFloat32Array(result)) throw new TypeError("TypedArray species must return typed storage.");
-            const target = float32Storage(result, key !== "subarray");
+            if (!isNumericTypedArray(result)) throw new TypeError("TypedArray species must return typed storage.");
+            const target = typedArrayStorage(result, key !== "subarray");
             if (key !== "subarray" && target.length < length)
               throw new TypeError("TypedArray species returned insufficient storage.");
           }
           if (key === "subarray") {
             if (result === void 0) {
-              result = new Float32Array(storage2.buffer, offset, tracking ? void 0 : length);
+              result = new storage2.Native(storage2.buffer, offset, tracking ? void 0 : length);
               if (arrayBufferOptions(storage2.buffer) !== void 0)
-                float32ViewLayouts.set(result, { byteOffset: offset, ...tracking ? {} : { length } });
+                typedArrayViewLayouts.set(result, { byteOffset: offset, ...tracking ? {} : { length } });
             }
             return result;
           }
           if (result === void 0) {
-            checkFloat32Allocation(length, budget);
-            result = new Float32Array(length);
+            checkTypedArrayAllocation(length, budget, storage2.elementSize);
+            result = new storage2.Native(length);
           }
-          if (!isFloat32Array(result)) throw new TypeError("TypedArray species must return typed storage.");
+          if (!isNumericTypedArray(result)) throw new TypeError("TypedArray species must return typed storage.");
           if (key === "filter") {
             for (let index = 0; index < length; index++) {
               budget.visitNode();
@@ -15396,12 +15413,17 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
             return result;
           }
           if (length > 0) {
-            const current = float32Storage(receiver, true);
-            const target = float32Storage(result, true);
+            const current = typedArrayStorage(receiver, true);
+            const target = typedArrayStorage(result, true);
             const count = Math.min(length, Math.max(current.length - start, 0));
-            if (count > 0) {
-              const sourceBytes = new Uint8Array(current.buffer, current.byteOffset + start * 4, count * 4);
-              const targetBytes = new Uint8Array(target.buffer, target.byteOffset, count * 4);
+            if (count > 0 && current.Native !== target.Native) {
+              for (let index = 0; index < count; index++) {
+                budget.visitNode();
+                result[index] = receiver[start + index];
+              }
+            } else if (count > 0) {
+              const sourceBytes = new Uint8Array(current.buffer, current.byteOffset + start * storage2.elementSize, count * storage2.elementSize);
+              const targetBytes = new Uint8Array(target.buffer, target.byteOffset, count * storage2.elementSize);
               if (current.buffer === target.buffer && targetBytes.byteOffset > sourceBytes.byteOffset && targetBytes.byteOffset < sourceBytes.byteOffset + sourceBytes.length) {
                 for (let index = 0; index < sourceBytes.length; index++) {
                   budget.visitNode();
@@ -15418,9 +15440,9 @@ function getFloat32Member(value, property, budget, defaultConstructor) {
     }
   });
 }
-function setFloat32Member(value, property, entry, budget, context) {
+function setTypedArrayMember(value, property, entry, budget, context) {
   const key = typeof property === "symbol" ? property : String(property);
-  if (typeof key !== "symbol" && isFloat32Index(key)) {
+  if (typeof key !== "symbol" && isTypedArrayIndex(key)) {
     return (async () => {
       const release = retainValues(budget, () => [value, entry]);
       try {
@@ -15433,7 +15455,7 @@ function setFloat32Member(value, property, entry, budget, context) {
   }
   const descriptor = Object.getOwnPropertyDescriptor(value, key);
   const inherited = descriptor ?? getSandboxPropertyDescriptor(value, key, budget);
-  if (descriptor === void 0 && typeof key === "string" && !float32Prototypes.has(budget) && ["length", "byteLength", "byteOffset", "buffer", "BYTES_PER_ELEMENT"].includes(key))
+  if (descriptor === void 0 && typeof key === "string" && !typedArrayPrototypes.has(budget) && ["length", "byteLength", "byteOffset", "buffer", "BYTES_PER_ELEMENT"].includes(key))
     throw new TypeError(`Cannot assign to read only property '${String(key)}'.`);
   if (inherited !== void 0 && (!("value" in inherited) || !inherited.writable))
     throw new TypeError(`Cannot assign to read only property '${String(key)}'.`);
@@ -15606,7 +15628,8 @@ async function ordinaryHasInstance(value, constructor, budget, context) {
     budget.visitNode();
     return evaluateInstanceof(value, constructor.boundTarget, budget, context);
   }
-  if (isFloat32ArrayConstructor(constructor) && !isGuestClosure(constructor)) return isFloat32Array(value);
+  if (numericTypedArrayConstructor(constructor) !== void 0 && !isGuestClosure(constructor))
+    return isNumericTypedArray(value) && typedArrayStorage(value).Native === numericTypedArrayConstructor(constructor);
   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);
@@ -17360,7 +17383,7 @@ function forInObject(value) {
   if (value === null || value === void 0 || isSandboxClosure(value)) {
     return void 0;
   }
-  if (typeof value === "string" || Array.isArray(value) || isFloat32Array(value) || isPlainForInObject(value)) {
+  if (typeof value === "string" || Array.isArray(value) || isNumericTypedArray(value) || isPlainForInObject(value)) {
     return Object(value);
   }
   return void 0;
@@ -17939,7 +17962,7 @@ function getPropertyValue(target, property, context, receiver = target) {
   if (typeof target === "string") return getStringMember(target, property, context.budget);
   if (typeof target === "number") return getNumberMember(property, context.budget);
   if (typeof target === "boolean") return void 0;
-  if (isFloat32Array(target)) return getFloat32Member(target, property, context.budget);
+  if (isNumericTypedArray(target)) return getTypedArrayMember(target, property, context.budget);
   if (isSandboxDate(target)) return void 0;
   if (isSandboxMap(target)) return getSandboxPrototype(target, context.budget) === null ? getMapMember(target, property, createMapMethodOptions(context)) : void 0;
   if (isSandboxSet(target)) return getSandboxPrototype(target, context.budget) === null ? getSetMember(target, property, createSetMethodOptions(context)) : void 0;
@@ -18243,7 +18266,7 @@ async function evaluateMemberCallExpression(node, context) {
     if (isSandboxDate(member.object)) {
       return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
     }
-    if (isFloat32Array(member.object)) {
+    if (isNumericTypedArray(member.object)) {
       return evaluateResolvedCallExpression(
         node,
         await getPropertyValue(member.object, member.property, context),
@@ -18534,7 +18557,7 @@ function hasSandboxProperty(value, key, context) {
   while (typeof current === "object" && current !== null) {
     if (isGuestHostObject(current)) return typeof key === "symbol" ? false : hasHostObjectMember(current, String(key));
     if (hasOwnSandboxProperty(current, key, false)) return true;
-    if (!isSandboxDate(current) && !isSandboxRegex(current) && !isSandboxMap(current) && !isSandboxSet(current) && !((isGuestClosure(current) || isSandboxGenerator(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) && (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current))) {
+    if (!isSandboxDate(current) && !isSandboxRegex(current) && !isSandboxMap(current) && !isSandboxSet(current) && !((isGuestClosure(current) || isSandboxGenerator(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) && (Array.isArray(current) || !isPlainSandboxObject(current) || isSandboxDate(current) || isNumericTypedArray(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current))) {
       return getPropertyValue(current, key, context) !== void 0;
     }
     current = getSandboxPrototype(current, context.budget);
@@ -18746,7 +18769,7 @@ function getMemberValue(target, property, context) {
   while (typeof current === "object" && current !== null) {
     if (isSandboxClosure(current)) return getClosureMemberValue(current, property, context);
     if (Array.isArray(current)) return getArrayMemberValue(current, property, context);
-    if (!isPlainSandboxObject(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current) || isFloat32Array(current)) {
+    if (!isPlainSandboxObject(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current) || isNumericTypedArray(current)) {
       return getPropertyValue(current, property, context);
     }
     if (Object.hasOwn(current, String(property))) return current[String(property)];
@@ -18782,8 +18805,8 @@ function setSandboxProperty(target, property, value, budget, checkInherited = tr
   if (isSandboxPromise(target)) target = getPromiseProperties(target);
   if (isSandboxGenerator(target)) target = getGeneratorProperties(target);
   if (isSandboxMap(target) || isSandboxSet(target)) target = getCollectionProperties(target);
-  if (isFloat32Array(target)) {
-    return setFloat32Member(target, property, value, budget, context);
+  if (isNumericTypedArray(target)) {
+    return setTypedArrayMember(target, property, value, budget, context);
   }
   if (isSandboxRegex(target)) {
     setRegexMember(target, property, value, budget);
@@ -19416,7 +19439,7 @@ async function objectToPrimitive(value, budget, context, joining, hint, ordinary
   }
 }
 function conversionHook(value, name, budget, context) {
-  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) && getSandboxPrototype(value, budget) === null || isFloat32Array(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) && getSandboxPrototype(value, budget) === null || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) && getSandboxPrototype(value, budget) === null || isSandboxGenerator(value) || isGuestHostObject(value));
+  const implicitBuiltin = !hasExplicitSandboxPrototype(value) && (Array.isArray(value) && getSandboxPrototype(value, budget) === null || isNumericTypedArray(value) || sandboxErrorTypes.has(value) || isSandboxClosure(value) && getSandboxPrototype(value, budget) === null || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxPromise(value) || isSandboxRegex(value) && getSandboxPrototype(value, budget) === null || isSandboxGenerator(value) || isGuestHostObject(value));
   let current = value;
   let depth = 0;
   while (current !== null) {
@@ -19449,14 +19472,14 @@ async function defaultToString(value, budget, context, joining) {
   if (isSandboxGenerator(value)) return "[object Generator]";
   if (isSandboxRegex(value)) return regexToString(value, budget, context);
   if (isSandboxDate(value)) return budget.allocateString(dateString(value));
-  if (Array.isArray(value) || isFloat32Array(value)) {
+  if (Array.isArray(value) || isNumericTypedArray(value)) {
     if (Object.hasOwn(value, "join")) {
       const join = await readCoercionProperty(value, "join", context);
       if (!isSandboxClosure(join))
-        return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
+        return isNumericTypedArray(value) ? `[object ${typedArrayStorage(value).Native.name}]` : "[object Array]";
       return invokeBuiltinClosure(join, [], budget, context, value);
     }
-    const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
+    const length = isNumericTypedArray(value) ? typedArrayStorage(value).length : value.length;
     return joinSandboxArray(value, length, ",", budget, context, joining);
   }
   if (sandboxErrorTypes.has(value)) {
@@ -19663,7 +19686,7 @@ function typeTag(value, builtinOnly = false) {
   if (isSandboxCollectionIterator(value)) return collectionIteratorState(value).collectionKind === "map" ? "Map Iterator" : "Set Iterator";
   if (isSandboxPromise(value)) return "Promise";
   if (isSandboxGenerator(value)) return "Generator";
-  if (isFloat32Array(value)) return "Float32Array";
+  if (isNumericTypedArray(value)) return typedArrayStorage(value).Native.name;
   return "Object";
 }
 
@@ -21529,33 +21552,36 @@ function serializeArray(value, serializeValue) {
   return { kind: "array", length: value.length, entries };
 }
 
-// packages/safe-js/src/snapshot/float32array.ts
-function encodeFloat32Layout(value) {
-  const storage = float32Storage(value);
-  if (arrayBufferDetached(storage.buffer)) return { byteOffset: 0, length: 0 };
-  if (arrayBufferOptions(storage.buffer) === void 0) return { byteOffset: storage.byteOffset, length: storage.length };
-  const layout = float32ViewLayouts.get(value);
+// packages/safe-js/src/snapshot/typed-array.ts
+function encodeTypedArrayLayout(value) {
+  const storage = typedArrayStorage(value);
+  const identity = storage.Native === Float32Array ? { kind: "float32array" } : { kind: "typedarray", arrayType: storage.Native.name };
+  if (arrayBufferDetached(storage.buffer)) return { ...identity, byteOffset: 0, length: 0 };
+  if (arrayBufferOptions(storage.buffer) === void 0) return { ...identity, byteOffset: storage.byteOffset, length: storage.length };
+  const layout = typedArrayViewLayouts.get(value);
   if (layout === void 0) throw new TypeError("Resizable Float32Array snapshots require known view layout.");
   return {
+    ...identity,
     byteOffset: layout.byteOffset,
     length: layout.length ?? 0,
     ...layout.length === void 0 ? { lengthTracking: true } : {}
   };
 }
-function validateFloat32Storage(value) {
+function validateTypedArrayStorage(value) {
+  const Native = snapshotTypedArrayConstructor(value);
   if (Object.hasOwn(value, "lengthTracking") && (value.lengthTracking !== true || value.length !== 0 || Object.hasOwn(value, "bytes")))
     throw new TypeError("Invalid Float32Array length-tracking layout.");
-  if (!Number.isSafeInteger(value.length) || Number(value.length) < 0 || !Number.isSafeInteger(value.byteOffset) || Number(value.byteOffset) < 0 || Number(value.byteOffset) % 4 !== 0)
+  if (!Number.isSafeInteger(value.length) || Number(value.length) < 0 || !Number.isSafeInteger(value.byteOffset) || Number(value.byteOffset) < 0 || Number(value.byteOffset) % Native.BYTES_PER_ELEMENT !== 0)
     throw new TypeError("Invalid Float32Array view dimensions.");
   if (Object.hasOwn(value, "bytes") === Object.hasOwn(value, "buffer"))
     throw new TypeError("Float32Array requires one backing storage description.");
   if (Object.hasOwn(value, "bytes")) {
-    if (!Array.isArray(value.bytes) || value.bytes.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 255) || Number(value.length) > Math.floor((value.bytes.length - Number(value.byteOffset)) / 4))
+    if (!Array.isArray(value.bytes) || value.bytes.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 255) || Number(value.length) > Math.floor((value.bytes.length - Number(value.byteOffset)) / Native.BYTES_PER_ELEMENT))
       throw new TypeError("Invalid Float32Array backing bytes.");
   }
 }
-function decodeFloat32Storage(value, resolve, budget) {
-  validateFloat32Storage(value);
+function decodeTypedArrayStorage(value, resolve, budget) {
+  validateTypedArrayStorage(value);
   let buffer;
   if (Array.isArray(value.bytes)) {
     buffer = new ArrayBuffer(value.bytes.length);
@@ -21563,12 +21589,21 @@ function decodeFloat32Storage(value, resolve, budget) {
   } else {
     const referenced = resolve(value.buffer);
     if (isSandboxArrayBuffer(referenced)) buffer = referenced;
-    else if (isFloat32Array(referenced)) buffer = float32Storage(referenced).buffer;
+    else if (isNumericTypedArray(referenced)) buffer = typedArrayStorage(referenced).buffer;
     else throw new TypeError("Invalid Float32Array backing reference.");
   }
   if (value.lengthTracking === true && arrayBufferOptions(buffer) === void 0)
     throw new TypeError("Length-tracking layout requires resizable backing storage.");
-  return restoreFloat32View(buffer, Number(value.byteOffset), value.lengthTracking === true ? void 0 : Number(value.length), budget);
+  return restoreTypedArrayView(buffer, Number(value.byteOffset), value.lengthTracking === true ? void 0 : Number(value.length), budget, snapshotTypedArrayConstructor(value));
+}
+function snapshotTypedArrayConstructor(value) {
+  if (value.kind !== "typedarray") {
+    if (Object.hasOwn(value, "arrayType")) throw new TypeError("Legacy Float32Array storage cannot specify another array type.");
+    return Float32Array;
+  }
+  if (typeof value.arrayType !== "string" || !Object.hasOwn(numericTypedArrayConstructors, value.arrayType))
+    throw new TypeError("Invalid typed array storage type.");
+  return numericTypedArrayConstructors[value.arrayType];
 }
 
 // packages/safe-js/src/snapshot/array-buffer.ts
@@ -21623,7 +21658,7 @@ function decodeArrayBufferStorage(value, resolve, budget, deferredDetachment) {
   }
   const referenced = resolve(value.buffer);
   if (isSandboxArrayBuffer(referenced)) return referenced;
-  if (isFloat32Array(referenced)) return float32Storage(referenced).buffer;
+  if (isNumericTypedArray(referenced)) return typedArrayStorage(referenced).buffer;
   throw new TypeError("Invalid ArrayBuffer backing reference.");
 }
 
@@ -21755,7 +21790,7 @@ function serializeDumpValue(value, path, state) {
   if (hasGuestObjectState(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) || isFloat32Array(value)) return serializeHeapReference(value, path, state);
+  if (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) {
@@ -21835,16 +21870,15 @@ function serializeHeapReference(value, path, state) {
           return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
         })
       };
-    } else if (isFloat32Array(value)) {
-      const backing = float32Storage(value);
+    } else if (isNumericTypedArray(value)) {
+      const backing = typedArrayStorage(value);
       const storage = {
-        kind: "float32array",
-        ...encodeFloat32Layout(value),
+        ...encodeTypedArrayLayout(value),
         buffer: serializeHeapReference(backing.buffer, `${path}.buffer`, state)
       };
       const entries = /* @__PURE__ */ Object.create(null);
       state.heap[String(id)] = { ...storage, entries };
-      for (const [key, descriptor] of float32DataProperties(value)) {
+      for (const [key, descriptor] of typedArrayDataProperties(value)) {
         const serialized = serializeDumpValue(descriptor.value, `${path}.${key}`, state);
         entries[key] = serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
       }
@@ -21907,7 +21941,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) || isFloat32Array(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) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -21939,7 +21973,7 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
   stat2.expanded = true;
   ancestors.add(value);
   const guestEntries = [];
-  if (isFloat32Array(value)) guestEntries.push(float32Storage(value).buffer);
+  if (isNumericTypedArray(value)) guestEntries.push(typedArrayStorage(value).buffer);
   const guest = isSandboxArrayBuffer(value) ? { kind: "arraybuffer", state: captureArrayBufferState(value, (entry) => {
     guestEntries.push(entry);
     return null;
@@ -21957,7 +21991,7 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
     return;
   }
   for (const entry of guestEntries) collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
-  if (!Array.isArray(value) && !isPlainObject(value) && !isFloat32Array(value) && !isSandboxDate(value)) {
+  if (!Array.isArray(value) && !isPlainObject(value) && !isNumericTypedArray(value) && !isSandboxDate(value)) {
     ancestors.delete(value);
     return;
   }
@@ -22291,11 +22325,11 @@ function encodeReplayData(value, options = {}) {
       let symbolIndex = 0;
       const symbolEntries = serializeSymbolProperties(entry, (value2) => encode(value2, depth + 1, [...path, { symbol: Math.floor(symbolIndex++ / 2) }]));
       nodes[id] = { ...storage, properties, extensible: Object.isExtensible(entry), symbolEntries };
-    } else if (isFloat32Array(entry)) {
-      const backing = float32Storage(entry);
-      const storage = { kind: "float32array", ...encodeFloat32Layout(entry), buffer: child(backing.buffer, "<buffer>") };
+    } else if (isNumericTypedArray(entry)) {
+      const backing = typedArrayStorage(entry);
+      const storage = { ...encodeTypedArrayLayout(entry), buffer: child(backing.buffer, "<buffer>") };
       const properties = /* @__PURE__ */ Object.create(null);
-      for (const [key, descriptor] of float32DataProperties(entry)) {
+      for (const [key, descriptor] of typedArrayDataProperties(entry)) {
         properties[key] = {
           value: child(descriptor.value, key),
           configurable: descriptor.configurable === true,
@@ -22532,10 +22566,10 @@ function decodeReplayData(input, options = {}, parent) {
         });
         return result3;
       }
-      if (kind === "float32array") {
+      if (kind === "float32array" || kind === "typedarray") {
         if (typeof node.extensible !== "boolean")
           throw new TypeError("Invalid Float32Array extensibility.");
-        const result3 = decodeFloat32Storage(node, child, compilation.owner?.budget);
+        const result3 = decodeTypedArrayStorage(node, child, compilation.owner?.budget);
         restored.set(id, result3);
         defineProperties(result3, record2(own(node, "properties")), child);
         if (!node.extensible) Object.preventExtensions(result3);
@@ -23446,22 +23480,23 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
     if (!Object.isExtensible(value)) Object.preventExtensions(copy);
     return copy;
   }
-  if (isFloat32Array(value)) {
+  if (isNumericTypedArray(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
-    const capacity = arrayBufferOptions(float32Storage(value).buffer)?.maxByteLength;
+    const capacity = arrayBufferOptions(typedArrayStorage(value).buffer)?.maxByteLength;
     if (capacity !== void 0) budget.allocateArrayLength(capacity);
-    checkFloat32Allocation(Math.ceil(float32Storage(value).byteLength / 4), budget);
-    const copy = copyFloat32Storage(value, state);
+    const storage = typedArrayStorage(value);
+    checkTypedArrayAllocation(Math.ceil(storage.byteLength / storage.elementSize), budget, storage.elementSize);
+    const copy = copyTypedArrayStorage(value, state);
     state.seen.set(value, copy);
     copyHostValueToSandbox(
-      float32Storage(value).buffer,
+      typedArrayStorage(value).buffer,
       stackFrames,
       { ...options, capabilityPath: [...options.capabilityPath ?? [], "buffer"] },
       state,
       `${path}.buffer`
     );
-    for (const [key, descriptor] of float32DataProperties(value)) {
+    for (const [key, descriptor] of typedArrayDataProperties(value)) {
       Object.defineProperty(copy, key, {
         ...descriptor,
         value: copyHostValueToSandbox(
@@ -25736,7 +25771,7 @@ function createBuiltinBindings(options) {
   const bindings = {
     ...createConsoleJsonGlobals(options),
     ...createCollectionGlobals(options),
-    Float32Array: createFloat32ArrayGlobal(options.budget, options.float32Prototypes !== false),
+    ...Object.fromEntries(Object.entries(numericTypedArrayConstructors).map(([name, Native]) => [name, createNumericTypedArrayGlobal(options.budget, options.typedArrayPrototypes !== false, Native)])),
     Date: createDateGlobal(options),
     Symbol: createSymbolGlobal(options.budget),
     BigInt: createBigIntGlobal(options.budget),
@@ -25750,7 +25785,7 @@ function createBuiltinBindings(options) {
     ...createRegexGlobals(options)
   };
   createFunctionPrototype(options.budget, options.functionHasInstance);
-  if (options.float32Prototypes !== false) createFloat32ArrayPrototypes(options.budget, bindings.Float32Array);
+  if (options.typedArrayPrototypes !== false) createNumericTypedArrayPrototypes(options.budget, bindings);
   if (options.errorPrototypes !== false) createErrorPrototypes(options.budget, bindings);
   createGeneratorPrototypes(options.budget);
   registerBuiltinIdentities(options.budget, bindings);
@@ -26485,8 +26520,8 @@ function validateDumpHeap(root, state) {
       validateGuestHeapNode({ kind: "guest-object", state: entry.state }, heap, state.limits.maxEntries);
       continue;
     }
-    if (entry.kind === "float32array") {
-      validateFloat32Storage(entry);
+    if (entry.kind === "float32array" || entry.kind === "typedarray") {
+      validateTypedArrayStorage(entry);
       requireRecord(entry.entries, `${path}.entries`);
       if (Object.hasOwn(entry, "state")) {
         if (Object.keys(entry.entries).length !== 0) fail("invalidValue", path, "ambiguous Float32Array property state");
@@ -26708,7 +26743,7 @@ function validateHeapValue(value, path, state, heap) {
     fail("invalidValue", path, String(error));
   }
   validateErrorType(record4, path);
-  if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "arraybuffer", "date", "boxed", "collection-iterator", "regexp-iterator", "regex-object"].includes(String(record4.kind)))
+  if (!["symbol", "arguments", "array", "object", "map", "set", "float32array", "typedarray", "arraybuffer", "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);
@@ -26721,8 +26756,8 @@ function validateHeapValue(value, path, state, heap) {
     validateArrayBufferStorage(record4);
     validateGuestHeapNode({ kind: "guest-object", state: record4.state }, heap, state.limits.maxEntries);
   }
-  if (record4.kind === "float32array") {
-    validateFloat32Storage(record4);
+  if (record4.kind === "float32array" || record4.kind === "typedarray") {
+    validateTypedArrayStorage(record4);
     requireRecord(record4.entries, `${path}.entries`);
     if (Object.hasOwn(record4, "state")) {
       if (Object.keys(record4.entries).length !== 0) fail("invalidValue", path, "ambiguous Float32Array property state");
@@ -27717,10 +27752,10 @@ function measureSandboxData(values, options = {}) {
     const prototype = getSandboxPrototype(value);
     if (prototype !== null) visit(prototype, depth + 1);
     if (isSandboxArrayBuffer(value)) usage += arrayBufferLength(value);
-    if (isFloat32Array(value)) {
-      const storage = float32Storage(value);
+    if (isNumericTypedArray(value)) {
+      const storage = typedArrayStorage(value);
       visit(storage.buffer, depth + 1);
-      for (const [key, descriptor] of float32Properties(value)) {
+      for (const [key, descriptor] of typedArrayProperties(value)) {
         usage += 1;
         if (typeof key === "string") usage += key.length;
         else visit(key, depth + 1);
@@ -27990,7 +28025,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     }
     return copy;
   }
-  if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !(state.structuredClone && isSandboxDate(value))) {
+  if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !(state.structuredClone && (isSandboxDate(value) || isSandboxArrayBuffer(value) || isNumericTypedArray(value)))) {
     throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
   }
   const primitive = nativeBoxedValue(value);
@@ -28059,6 +28094,7 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     if (existing !== void 0) return existing;
     const copy = copyArrayBufferStorage(value, state);
     state.seen.set(value, copy);
+    if (state.structuredClone) return copy;
     for (const [key, descriptor] of arrayBufferDataProperties(value)) {
       Object.defineProperty(copy, key, {
         ...descriptor,
@@ -28081,13 +28117,14 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     if (!state.structuredClone && !Object.isExtensible(value)) Object.preventExtensions(copy);
     return copy;
   }
-  if (isFloat32Array(value)) {
+  if (isNumericTypedArray(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
-    const copy = copyFloat32Storage(value, state);
+    const copy = copyTypedArrayStorage(value, state);
     state.seen.set(value, copy);
-    copyToSandbox(float32Storage(value).buffer, state, `${path}.buffer`, cloneSandboxCollections, depth + 1);
-    for (const [key, descriptor] of float32DataProperties(value)) {
+    if (state.structuredClone) return copy;
+    copyToSandbox(typedArrayStorage(value).buffer, state, `${path}.buffer`, cloneSandboxCollections, depth + 1);
+    for (const [key, descriptor] of typedArrayDataProperties(value)) {
       Object.defineProperty(copy, key, {
         ...descriptor,
         value: copyToSandbox(
@@ -28303,13 +28340,13 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
       guard.close();
     }
   }
-  if (isFloat32Array(value)) {
+  if (isNumericTypedArray(value)) {
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
-    const copy = copyFloat32Storage(value, state);
+    const copy = copyTypedArrayStorage(value, state);
     state.seen.set(value, copy);
-    copyFromSandbox(float32Storage(value).buffer, state, `${path}.buffer`, options, depth + 1);
-    for (const [key, descriptor] of float32DataProperties(value)) {
+    copyFromSandbox(typedArrayStorage(value).buffer, state, `${path}.buffer`, options, depth + 1);
+    for (const [key, descriptor] of typedArrayDataProperties(value)) {
       Object.defineProperty(copy, key, {
         ...descriptor,
         value: copyFromSandbox(descriptor.value, state, joinPath2(path, key), options, depth + 1)
@@ -28514,13 +28551,14 @@ function allocateSandboxValue2(value, budget, seen) {
     }
     return;
   }
-  if (isFloat32Array(value)) {
+  if (isNumericTypedArray(value)) {
     if (seen.has(value)) return;
     seen.add(value);
-    budget.allocateArrayLength(Math.ceil(float32Storage(value).byteLength / 4));
-    const capacity = arrayBufferOptions(float32Storage(value).buffer)?.maxByteLength;
+    const storage = typedArrayStorage(value);
+    budget.allocateArrayLength(Math.ceil(storage.byteLength / storage.elementSize));
+    const capacity = arrayBufferOptions(typedArrayStorage(value).buffer)?.maxByteLength;
     if (capacity !== void 0) budget.allocateArrayLength(capacity);
-    for (const [key, descriptor] of float32DataProperties(value)) {
+    for (const [key, descriptor] of typedArrayDataProperties(value)) {
       budget.allocateString(key);
       allocateSandboxValue2(descriptor.value, budget, seen);
     }
@@ -29267,20 +29305,20 @@ function normalize(value, seen) {
         properties
       });
     }
-    if (isFloat32Array(value)) {
-      const storage = float32Storage(value);
+    if (isNumericTypedArray(value)) {
+      const storage = typedArrayStorage(value);
       const resizable = arrayBufferOptions(storage.buffer) !== void 0;
-      const layout = resizable ? float32ViewLayouts.get(value) : void 0;
+      const layout = resizable ? typedArrayViewLayouts.get(value) : void 0;
       if (resizable && layout === void 0)
         throw new TypeError("Resizable Float32Array host-call identity requires known view layout.");
       const properties = /* @__PURE__ */ Object.create(null);
-      for (const [key, descriptor] of float32DataProperties(value).sort(
+      for (const [key, descriptor] of typedArrayDataProperties(value).sort(
         ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
       )) {
         defineOwnDataProperty(properties, key, normalize(descriptor.value, seen));
       }
       return Object.assign(/* @__PURE__ */ Object.create(null), {
-        $type: "float32array",
+        $type: storage.Native === Float32Array ? "float32array" : storage.Native.name,
         bytes: normalize(Array.from(new Uint8Array(storage.buffer)), seen),
         byteOffset: storage.byteOffset,
         length: storage.length,
@@ -30257,6 +30295,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "JSON",
   "Map",
   "Float32Array",
+  "Uint8Array",
   "Math",
   "NaN",
   "Number",
@@ -42755,4 +42794,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-CJ7PNS2V.js.map
+//# sourceMappingURL=chunk-GMJXANAZ.js.map