poe-code 12.0.3 → 12.0.4

package/dist/index.js

@@ -124867,6 +124867,7 @@ var init_known_globals = __esm({
       "isNaN",
       "JSON",
       "Map",
+      "Float32Array",
       "Math",
       "NaN",
       "Number",
@@ -135766,6 +135767,74 @@ var init_otel2 = __esm({
   }
 });
 
+// packages/safejs/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, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (isFloat32Index(key3)) continue;
+    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/safejs/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/safejs/src/interp/budget.ts
 function allocateRegexSteps(steps) {
   if (!Number.isInteger(steps) || steps < 0) {
@@ -136351,6 +136420,48 @@ var init_arrays = __esm({
   }
 });
 
+// packages/safejs/src/snapshot/float32array.ts
+function encodeFloat32Storage(value, id, buffers, reference) {
+  const storage2 = float32Storage(value);
+  const existing = buffers.get(storage2.buffer);
+  if (existing === void 0) buffers.set(storage2.buffer, id);
+  return {
+    kind: "float32array",
+    byteOffset: storage2.byteOffset,
+    length: storage2.length,
+    ...existing === void 0 ? { bytes: Array.from(new Uint8Array(storage2.buffer)) } : { buffer: reference(existing) }
+  };
+}
+function validateFloat32Storage(value) {
+  if (!Number.isSafeInteger(value.length) || Number(value.length) < 0 || !Number.isSafeInteger(value.byteOffset) || Number(value.byteOffset) < 0 || Number(value.byteOffset) % 4 !== 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))
+      throw new TypeError("Invalid Float32Array backing bytes.");
+  }
+}
+function decodeFloat32Storage(value, resolve17) {
+  validateFloat32Storage(value);
+  let buffer;
+  if (Array.isArray(value.bytes)) {
+    buffer = new ArrayBuffer(value.bytes.length);
+    new Uint8Array(buffer).set(value.bytes);
+  } else {
+    const referenced = resolve17(value.buffer);
+    if (!isFloat32Array(referenced)) throw new TypeError("Invalid Float32Array backing reference.");
+    buffer = float32Storage(referenced).buffer;
+  }
+  return new Float32Array(buffer, Number(value.byteOffset), Number(value.length));
+}
+var init_float32array = __esm({
+  "packages/safejs/src/snapshot/float32array.ts"() {
+    "use strict";
+    init_float32();
+  }
+});
+
 // packages/safejs/src/snapshot/dump-format.ts
 function serializeSafeJSSnapshot(snapshot2) {
   const replayError = Object.getOwnPropertyDescriptor(snapshot2, "replayError");
@@ -136367,6 +136478,7 @@ function serializeSafeJSSnapshot(snapshot2) {
 }
 function createDumpFile(snapshot2) {
   const state = {
+    float32Buffers: /* @__PURE__ */ new WeakMap(),
     heap: {},
     heapIds: indexHeapContainers(snapshot2),
     serializedHeapIds: /* @__PURE__ */ new Set()
@@ -136405,6 +136517,7 @@ function serializeDumpValue(value, path191, state) {
   if (typeof value !== "object") {
     return SKIP_VALUE;
   }
+  if (isFloat32Array(value)) return serializeHeapReference(value, path191, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path191, state);
     if (reference2 !== void 0) {
@@ -136428,7 +136541,18 @@ function serializeHeapReference(value, path191, state) {
   }
   if (!state.serializedHeapIds.has(id)) {
     state.serializedHeapIds.add(id);
-    if (isSandboxArguments(value)) {
+    if (isFloat32Array(value)) {
+      const storage2 = encodeFloat32Storage(value, id, state.float32Buffers, (id2) => ({
+        kind: "ref",
+        id: id2
+      }));
+      const entries = /* @__PURE__ */ Object.create(null);
+      state.heap[String(id)] = { ...storage2, entries };
+      for (const [key3, descriptor] of float32DataProperties(value)) {
+        const serialized = serializeDumpValue(descriptor.value, `${path191}.${key3}`, state);
+        entries[key3] = serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
+      }
+    } else if (isSandboxArguments(value)) {
       state.heap[String(id)] = serializeArguments(value, (entry, key3) => {
         const serialized = serializeDumpValue(entry, `${path191}.${key3}`, state);
         return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
@@ -136474,7 +136598,7 @@ function indexHeapContainers(snapshot2) {
   const heapIds = /* @__PURE__ */ new WeakMap();
   let nextId = 1;
   for (const [value, stat36] of stats2.entries()) {
-    if (stat36.count > 1 || stat36.cyclic || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat36.count > 1 || stat36.cyclic || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -136485,7 +136609,7 @@ function collectContainerStats(value, stats2, ancestors) {
   if (value === null || typeof value !== "object") {
     return;
   }
-  if (!Array.isArray(value) && !isPlainObject9(value)) {
+  if (!Array.isArray(value) && !isPlainObject9(value) && !isFloat32Array(value)) {
     return;
   }
   let stat36 = stats2.get(value);
@@ -136553,6 +136677,8 @@ var init_dump_format = __esm({
     init_arguments();
     init_arguments2();
     init_arrays();
+    init_float32();
+    init_float32array();
     DUMP_FORMAT_VERSION = 1;
     EXECUTION_SEMANTICS = "jobs-v7";
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
@@ -136606,6 +136732,11 @@ function validateDumpHeap(root, state) {
     addUnique2(heapIds, id, path191);
     const entry = requireRecord3(value, path191);
     validateErrorType(entry, path191);
+    if (entry.kind === "float32array") {
+      validateFloat32Storage(entry);
+      requireRecord3(entry.entries, `${path191}.entries`);
+      continue;
+    }
     if (entry.kind === "arguments") {
       validateArgumentsProperties(entry, path191);
       continue;
@@ -136971,6 +137102,7 @@ var init_validation = __esm({
     init_shape();
     init_dump_format();
     init_graph_depth();
+    init_float32array();
     DEFAULT_MAX_DEPTH = MAX_DATA_DEPTH;
     DEFAULT_MAX_ENTRIES = 1e5;
     DEFAULT_MAX_STRING_LENGTH = 1e6;
@@ -137362,6 +137494,7 @@ var init_promise_replay = __esm({
 function encodeReplayData(value, options = {}) {
   const nodes = [];
   const seen = /* @__PURE__ */ new WeakMap();
+  const float32Buffers = /* @__PURE__ */ new WeakMap();
   const encode = (entry, depth, path191) => {
     if (depth > MAX_DATA_DEPTH) throw new TypeError("Replay data exceeds the nesting limit.");
     if (entry === null || typeof entry === "boolean" || typeof entry === "string") return entry;
@@ -137402,6 +137535,21 @@ function encodeReplayData(value, options = {}) {
         id: capabilityId,
         properties: child(entry.properties, "properties")
       };
+    } else if (isFloat32Array(entry)) {
+      const storage2 = encodeFloat32Storage(entry, id, float32Buffers, (id2) => ({
+        tag: "ref",
+        id: id2
+      }));
+      const properties = /* @__PURE__ */ Object.create(null);
+      for (const [key3, descriptor] of float32DataProperties(entry)) {
+        properties[key3] = {
+          value: child(descriptor.value, key3),
+          configurable: descriptor.configurable === true,
+          enumerable: descriptor.enumerable === true,
+          writable: descriptor.writable === true
+        };
+      }
+      nodes[id] = { ...storage2, properties, extensible: Object.isExtensible(entry) };
     } else if (isSandboxMap(entry)) {
       nodes[id] = {
         kind: "map",
@@ -137534,6 +137682,15 @@ function decodeReplayData(input, options = {}) {
       options.onCapabilityRestored?.(capability, copy);
       return copy;
     }
+    if (kind === "float32array") {
+      if (typeof node.extensible !== "boolean")
+        throw new TypeError("Invalid Float32Array extensibility.");
+      const result2 = decodeFloat32Storage(node, child);
+      restored.set(id, result2);
+      defineProperties(result2, record(own(node, "properties")), child);
+      if (!node.extensible) Object.preventExtensions(result2);
+      return result2;
+    }
     if (kind === "map") {
       const result2 = createSandboxMap();
       restored.set(id, result2);
@@ -137627,6 +137784,8 @@ var init_replay_data = __esm({
   "packages/safejs/src/snapshot/replay-data.ts"() {
     "use strict";
     init_graph_depth();
+    init_float32();
+    init_float32array();
     init_shape();
     init_values();
     init_arguments2();
@@ -137859,6 +138018,22 @@ function normalize2(value, seen) {
   if (seen.has(value)) throw new TypeError("Host call arguments cannot contain cycles.");
   seen.add(value);
   try {
+    if (isFloat32Array(value)) {
+      const storage2 = float32Storage(value);
+      const properties = /* @__PURE__ */ Object.create(null);
+      for (const [key3, descriptor] of float32DataProperties(value).sort(
+        ([left], [right]) => left < right ? -1 : left > right ? 1 : 0
+      )) {
+        defineOwnDataProperty(properties, key3, normalize2(descriptor.value, seen));
+      }
+      return Object.assign(/* @__PURE__ */ Object.create(null), {
+        $type: "float32array",
+        bytes: normalize2(Array.from(new Uint8Array(storage2.buffer)), seen),
+        byteOffset: storage2.byteOffset,
+        length: storage2.length,
+        properties
+      });
+    }
     if (Array.isArray(value)) {
       const normalized2 = new Array(value.length);
       Object.setPrototypeOf(normalized2, null);
@@ -137890,6 +138065,7 @@ var HostCallResumabilityError, UnresolvedReplayCapabilityError, HostCallJournal;
 var init_host_call = __esm({
   "packages/safejs/src/interp/host-call.ts"() {
     "use strict";
+    init_float32();
     init_values();
     init_replay_data();
     init_validation();
@@ -138750,6 +138926,9 @@ var init_running_state = __esm({
 
 // packages/safejs/src/interp/iteration.ts
 function getSandboxIterator(value) {
+  if (isFloat32Array(value)) {
+    return syncIterator(Float32Array.prototype.values.call(value));
+  }
   if (isSandboxGenerator(value)) {
     return generatorIterator(value);
   }
@@ -138847,6 +139026,7 @@ var init_iteration = __esm({
     "use strict";
     init_values();
     init_running_state();
+    init_float32();
   }
 });
 
@@ -140063,6 +140243,18 @@ function measureSandboxData(values, options = {}) {
     if (seen.has(value)) return;
     seen.add(value);
     usage += 1;
+    if (isFloat32Array(value)) {
+      const storage2 = float32Storage(value);
+      if (!seen.has(storage2.buffer)) {
+        seen.add(storage2.buffer);
+        usage += storage2.byteLength;
+      }
+      for (const [key3, descriptor] of float32DataProperties(value)) {
+        usage += key3.length + 1;
+        visit(descriptor.value);
+      }
+      return;
+    }
     if (Array.isArray(value)) {
       usage += value.length;
       for (let index = 0; index < value.length; index += 1) {
@@ -140171,6 +140363,26 @@ function copyToSandbox(value, state, path191 = "<root>", cloneSandboxCollections
     }
     return sandboxPromise;
   }
+  if (isFloat32Array(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = copyFloat32Storage(value, state);
+    state.seen.set(value, copy);
+    for (const [key3, descriptor] of float32DataProperties(value)) {
+      Object.defineProperty(copy, key3, {
+        ...descriptor,
+        value: copyToSandbox(
+          descriptor.value,
+          state,
+          joinPath(path191, key3),
+          cloneSandboxCollections,
+          depth + 1
+        )
+      });
+    }
+    if (!Object.isExtensible(value)) Object.preventExtensions(copy);
+    return copy;
+  }
   if (value instanceof Map) {
     const existing = state.seen.get(value);
     if (existing !== void 0) {
@@ -140265,6 +140477,20 @@ function copyFromSandbox(value, state, path191 = "<root>", options, depth = 0) {
   if (isSandboxPrimitive(value)) {
     return value;
   }
+  if (isFloat32Array(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    const copy = copyFloat32Storage(value, state);
+    state.seen.set(value, copy);
+    for (const [key3, descriptor] of float32DataProperties(value)) {
+      Object.defineProperty(copy, key3, {
+        ...descriptor,
+        value: copyFromSandbox(descriptor.value, state, joinPath(path191, key3), options, depth + 1)
+      });
+    }
+    if (!Object.isExtensible(value)) Object.preventExtensions(copy);
+    return copy;
+  }
   if (isSandboxClosure(value)) {
     if (options.wrapClosure === void 0) {
       throw new TypeError(
@@ -140380,6 +140606,16 @@ function allocateSandboxValue2(value, budget, seen) {
     budget.allocateString(value);
     return;
   }
+  if (isFloat32Array(value)) {
+    if (seen.has(value)) return;
+    seen.add(value);
+    budget.allocateArrayLength(Math.ceil(float32Storage(value).byteLength / 4));
+    for (const [key3, descriptor] of float32DataProperties(value)) {
+      budget.allocateString(key3);
+      allocateSandboxValue2(descriptor.value, budget, seen);
+    }
+    return;
+  }
   if (Array.isArray(value)) {
     if (seen.has(value)) {
       return;
@@ -140513,6 +140749,7 @@ var init_values = __esm({
   "packages/safejs/src/interp/values.ts"() {
     "use strict";
     init_otel2();
+    init_float32();
     init_budget2();
     init_promise_tracker();
     init_promise_replay();
@@ -141992,6 +142229,27 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path191) {
       state
     );
   }
+  if (isFloat32Array(value)) {
+    const existing = state.seen.get(value);
+    if (existing !== void 0) return existing;
+    checkFloat32Allocation(Math.ceil(float32Storage(value).byteLength / 4), budget);
+    const copy = copyFloat32Storage(value, state);
+    state.seen.set(value, copy);
+    for (const [key3, descriptor] of float32DataProperties(value)) {
+      Object.defineProperty(copy, key3, {
+        ...descriptor,
+        value: copyHostValueToSandbox(
+          descriptor.value,
+          stackFrames,
+          { ...options, capabilityPath: [...options.capabilityPath ?? [], key3] },
+          state,
+          joinPath2(path191, key3)
+        )
+      });
+    }
+    if (!Object.isExtensible(value)) Object.preventExtensions(copy);
+    return copy;
+  }
   if (!options.errorData && isPromiseLike5(value)) {
     if (options.proofFunctions !== void 0)
       throw new TypeError(`Unsupported proof value at ${path191}: promise`);
@@ -142254,6 +142512,7 @@ var init_host_bridge = __esm({
     init_async();
     init_shape();
     init_budget2();
+    init_float32();
     init_exceptions();
     init_otel2();
     init_host_call();
@@ -142674,6 +142933,139 @@ var init_collections = __esm({
   }
 });
 
+// packages/safejs/src/interp/globals/float32array.ts
+function createFloat32ArrayGlobal(budget) {
+  const constructor = createSandboxClosure({
+    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);
+        }
+        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;
+}
+function isFloat32ArrayConstructor(value) {
+  return typeof value === "object" && value !== null && constructors.has(value);
+}
+function getFloat32Member(value, property, budget) {
+  const key3 = String(property);
+  const descriptor = Object.getOwnPropertyDescriptor(value, key3);
+  if (descriptor !== void 0) {
+    if (!("value" in descriptor)) throw new TypeError("Float32Array accessors are not supported.");
+    return descriptor.value;
+  }
+  const storage2 = float32Storage(value);
+  if (key3 === "length") return storage2.length;
+  if (key3 === "byteLength") return storage2.length * 4;
+  if (key3 === "byteOffset") return storage2.byteOffset;
+  if (key3 === "BYTES_PER_ELEMENT") return 4;
+  if (!["set", "slice", "subarray"].includes(key3)) return void 0;
+  return createSandboxClosure({
+    sandbox: true,
+    name: key3,
+    length: key3 === "set" ? 1 : 2,
+    call: (args, context) => {
+      const receiver = context?.thisValue;
+      if (!isFloat32Array(receiver))
+        throw new TypeError(`Float32Array#${key3} requires a Float32Array receiver.`);
+      const storage3 = float32Storage(receiver);
+      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;
+      }
+      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;
+    }
+  });
+}
+function setFloat32Member(value, property, entry) {
+  const key3 = String(property);
+  if (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}'.`);
+  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);
+  const integer2 = Number.isNaN(numeric) ? 0 : Math.trunc(numeric);
+  return integer2 < 0 ? Math.max(length + integer2, 0) : Math.min(integer2, length);
+}
+var constructors;
+var init_float32array2 = __esm({
+  "packages/safejs/src/interp/globals/float32array.ts"() {
+    "use strict";
+    init_float32();
+    init_values();
+    constructors = /* @__PURE__ */ new WeakSet();
+  }
+});
+
 // packages/safejs/src/interp/globals/error.ts
 function createErrorGlobals(options) {
   return Object.fromEntries(
@@ -143030,6 +143422,10 @@ function assignSandboxValues(target, sources) {
       continue;
     }
     for (const [key3, value] of getOwnEnumerableEntries(source)) {
+      if (isFloat32Array(target)) {
+        setFloat32Member(target, key3, value);
+        continue;
+      }
       Object.defineProperty(target, key3, {
         configurable: true,
         enumerable: true,
@@ -143127,6 +143523,8 @@ var init_object_array = __esm({
   "packages/safejs/src/interp/globals/object-array.ts"() {
     "use strict";
     init_shape();
+    init_float32();
+    init_float32array2();
     init_iteration();
     init_values();
   }
@@ -146011,7 +146409,7 @@ function forInObject(value) {
   if (value === null || value === void 0 || isSandboxClosure(value) || isSandboxPromise(value)) {
     return void 0;
   }
-  if (typeof value === "string" || Array.isArray(value) || isPlainForInObject(value)) {
+  if (typeof value === "string" || Array.isArray(value) || isFloat32Array(value) || isPlainForInObject(value)) {
     return Object(value);
   }
   return void 0;
@@ -146513,6 +146911,7 @@ function getPropertyValue(target, property, context) {
   if (typeof target === "string") return getStringMember(target, property, context.budget);
   if (typeof target === "number") return getNumberMember(target, property, context.budget);
   if (typeof target === "boolean") return void 0;
+  if (isFloat32Array(target)) return getFloat32Member(target, property, context.budget);
   if (isSandboxMap(target)) return getMapMember(target, property, createMapMethodOptions(context));
   if (isSandboxSet(target)) return getSetMember(target, property, createSetMethodOptions(context));
   if (isSandboxGenerator(target)) return getGeneratorMember(target, property, context.budget);
@@ -146741,6 +147140,14 @@ async function evaluateMemberCallExpression(node, context) {
       context
     );
   }
+  if (isFloat32Array(member.object)) {
+    return evaluateResolvedCallExpression(
+      node,
+      getFloat32Member(member.object, member.property, context.budget),
+      context,
+      member.object
+    );
+  }
   if (isSandboxSet(member.object)) {
     return evaluatePrimitiveMemberCall(
       node,
@@ -146983,6 +147390,7 @@ function applyBinaryOperator(node, left, right, context) {
       if (isSandboxMapConstructor(right) && isSandboxMap(left)) {
         return true;
       }
+      if (isFloat32ArrayConstructor(right)) return isFloat32Array(left);
       if (isSandboxSetConstructor(right) && isSandboxSet(left)) {
         return true;
       }
@@ -147201,6 +147609,10 @@ function getArrayMemberValue(target, property, context) {
   return getArrayMember(target, property, createArrayMethodOptions(context));
 }
 function setSandboxProperty(target, property, value) {
+  if (isFloat32Array(target)) {
+    setFloat32Member(target, property, value);
+    return;
+  }
   if (isSandboxRegex(target)) {
     setRegexMember(target, property, value);
     return;
@@ -147500,6 +147912,8 @@ var init_interpreter = __esm({
     init_set();
     init_error();
     init_collections();
+    init_float32array2();
+    init_float32();
     init_values();
     init_scope();
     init_var_hoist();
@@ -148113,6 +148527,8 @@ var init_serialize = __esm({
     init_graph_depth();
     init_arguments2();
     init_arrays();
+    init_float32();
+    init_float32array();
     init_values();
     UnsnapshotableValueError = class extends Error {
       path;
@@ -148304,6 +148720,7 @@ function run(source, options = {}) {
             sink: options.sink
           }),
           ...createCollectionGlobals({ budget }),
+          Float32Array: createFloat32ArrayGlobal(budget),
           ...createErrorGlobals({
             budget
           }),
@@ -148771,6 +149188,7 @@ var init_run7 = __esm({
     init_host_call();
     init_console_json();
     init_collections();
+    init_float32array2();
     init_error();
     init_math();
     init_regex();
@@ -155792,7 +156210,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "12.0.3",
+      version: "12.0.4",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",