poe-code 12.0.3 → 12.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "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",

package/packages/safejs/dist/chunks/{chunk-T55OILHA.js → chunk-LF5LY5O3.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-Z3ZMLYCK.js";
+} from "./chunk-XBRQ72W6.js";
 
 // packages/safejs/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8055,4 +8055,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-T55OILHA.js.map
+//# sourceMappingURL=chunk-LF5LY5O3.js.map

package/packages/safejs/dist/chunks/{chunk-Z3ZMLYCK.js → chunk-XBRQ72W6.js}

@@ -5982,6 +5982,7 @@ var KNOWN_RUNTIME_GLOBALS = [
   "isNaN",
   "JSON",
   "Map",
+  "Float32Array",
   "Math",
   "NaN",
   "Number",
@@ -16959,6 +16960,104 @@ function serializeArray(value, serializeValue) {
   return { kind: "array", length: value.length, entries };
 }
 
+// packages/safejs/src/interp/float32.ts
+var typedArrayPrototype = Object.getPrototypeOf(Float32Array.prototype);
+var readLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "length").get;
+var readOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
+var readBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
+var readTag = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag).get;
+var bufferLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+var bufferResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get;
+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 [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (isFloat32Index(key)) continue;
+    if (!("value" in descriptor))
+      throw new TypeError(`Float32Array accessor property '${key}' is not supported.`);
+    properties.push([key, descriptor]);
+  }
+  return properties;
+}
+function isFloat32Index(key) {
+  return key === "-0" || String(Number(key)) === key;
+}
+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 storage = float32Storage(value);
+  state.float32Buffers ??= /* @__PURE__ */ new WeakMap();
+  let buffer = state.float32Buffers.get(storage.buffer);
+  if (buffer === void 0) {
+    buffer = new ArrayBuffer(storage.byteLength);
+    new Uint8Array(buffer).set(new Uint8Array(storage.buffer));
+    state.float32Buffers.set(storage.buffer, buffer);
+  }
+  return new Float32Array(buffer, storage.byteOffset, storage.length);
+}
+
+// packages/safejs/src/snapshot/float32array.ts
+function encodeFloat32Storage(value, id, buffers, reference) {
+  const storage = float32Storage(value);
+  const existing = buffers.get(storage.buffer);
+  if (existing === void 0) buffers.set(storage.buffer, id);
+  return {
+    kind: "float32array",
+    byteOffset: storage.byteOffset,
+    length: storage.length,
+    ...existing === void 0 ? { bytes: Array.from(new Uint8Array(storage.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, resolve) {
+  validateFloat32Storage(value);
+  let buffer;
+  if (Array.isArray(value.bytes)) {
+    buffer = new ArrayBuffer(value.bytes.length);
+    new Uint8Array(buffer).set(value.bytes);
+  } else {
+    const referenced = resolve(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));
+}
+
 // packages/safejs/src/snapshot/dump-format.ts
 var DUMP_FORMAT_VERSION = 1;
 var EXECUTION_SEMANTICS = "jobs-v7";
@@ -16978,6 +17077,7 @@ function serializeSafeJSSnapshot(snapshot) {
 }
 function createDumpFile(snapshot) {
   const state = {
+    float32Buffers: /* @__PURE__ */ new WeakMap(),
     heap: {},
     heapIds: indexHeapContainers(snapshot),
     serializedHeapIds: /* @__PURE__ */ new Set()
@@ -17016,6 +17116,7 @@ function serializeDumpValue(value, path, state) {
   if (typeof value !== "object") {
     return SKIP_VALUE;
   }
+  if (isFloat32Array(value)) return serializeHeapReference(value, path, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path, state);
     if (reference2 !== void 0) {
@@ -17039,7 +17140,18 @@ function serializeHeapReference(value, path, state) {
   }
   if (!state.serializedHeapIds.has(id)) {
     state.serializedHeapIds.add(id);
-    if (isSandboxArguments(value)) {
+    if (isFloat32Array(value)) {
+      const storage = encodeFloat32Storage(value, id, state.float32Buffers, (id2) => ({
+        kind: "ref",
+        id: id2
+      }));
+      const entries = /* @__PURE__ */ Object.create(null);
+      state.heap[String(id)] = { ...storage, entries };
+      for (const [key, descriptor] of float32DataProperties(value)) {
+        const serialized = serializeDumpValue(descriptor.value, `${path}.${key}`, state);
+        entries[key] = serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
+      }
+    } else if (isSandboxArguments(value)) {
       state.heap[String(id)] = serializeArguments(value, (entry, key) => {
         const serialized = serializeDumpValue(entry, `${path}.${key}`, state);
         return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
@@ -17085,7 +17197,7 @@ function indexHeapContainers(snapshot) {
   const heapIds = /* @__PURE__ */ new WeakMap();
   let nextId = 1;
   for (const [value, stat2] of stats.entries()) {
-    if (stat2.count > 1 || stat2.cyclic || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat2.count > 1 || stat2.cyclic || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -17096,7 +17208,7 @@ function collectContainerStats(value, stats, ancestors) {
   if (value === null || typeof value !== "object") {
     return;
   }
-  if (!Array.isArray(value) && !isPlainObject(value)) {
+  if (!Array.isArray(value) && !isPlainObject(value) && !isFloat32Array(value)) {
     return;
   }
   let stat2 = stats.get(value);
@@ -17232,6 +17344,11 @@ function validateDumpHeap(root, state) {
     addUnique(heapIds, id, path);
     const entry = requireRecord(value, path);
     validateErrorType(entry, path);
+    if (entry.kind === "float32array") {
+      validateFloat32Storage(entry);
+      requireRecord(entry.entries, `${path}.entries`);
+      continue;
+    }
     if (entry.kind === "arguments") {
       validateArgumentsProperties(entry, path);
       continue;
@@ -18575,6 +18692,9 @@ function assertSnapshotInactive(snapshot) {
 
 // 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);
   }
@@ -19860,6 +19980,18 @@ function measureSandboxData(values, options = {}) {
     if (seen.has(value)) return;
     seen.add(value);
     usage += 1;
+    if (isFloat32Array(value)) {
+      const storage = float32Storage(value);
+      if (!seen.has(storage.buffer)) {
+        seen.add(storage.buffer);
+        usage += storage.byteLength;
+      }
+      for (const [key, descriptor] of float32DataProperties(value)) {
+        usage += key.length + 1;
+        visit(descriptor.value);
+      }
+      return;
+    }
     if (Array.isArray(value)) {
       usage += value.length;
       for (let index = 0; index < value.length; index += 1) {
@@ -19968,6 +20100,26 @@ function copyToSandbox(value, state, path = "<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 [key, descriptor] of float32DataProperties(value)) {
+      Object.defineProperty(copy, key, {
+        ...descriptor,
+        value: copyToSandbox(
+          descriptor.value,
+          state,
+          joinPath(path, key),
+          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) {
@@ -20062,6 +20214,20 @@ function copyFromSandbox(value, state, path = "<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 [key, descriptor] of float32DataProperties(value)) {
+      Object.defineProperty(copy, key, {
+        ...descriptor,
+        value: copyFromSandbox(descriptor.value, state, joinPath(path, key), options, depth + 1)
+      });
+    }
+    if (!Object.isExtensible(value)) Object.preventExtensions(copy);
+    return copy;
+  }
   if (isSandboxClosure(value)) {
     if (options.wrapClosure === void 0) {
       throw new TypeError(
@@ -20177,6 +20343,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 [key, descriptor] of float32DataProperties(value)) {
+      budget.allocateString(key);
+      allocateSandboxValue2(descriptor.value, budget, seen);
+    }
+    return;
+  }
   if (Array.isArray(value)) {
     if (seen.has(value)) {
       return;
@@ -20312,6 +20488,7 @@ var MissingReplayCapabilityError = class extends TypeError {
 function encodeReplayData(value, options = {}) {
   const nodes = [];
   const seen = /* @__PURE__ */ new WeakMap();
+  const float32Buffers = /* @__PURE__ */ new WeakMap();
   const encode = (entry, depth, path) => {
     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;
@@ -20352,6 +20529,21 @@ function encodeReplayData(value, options = {}) {
         id: capabilityId,
         properties: child(entry.properties, "properties")
       };
+    } else if (isFloat32Array(entry)) {
+      const storage = encodeFloat32Storage(entry, id, float32Buffers, (id2) => ({
+        tag: "ref",
+        id: id2
+      }));
+      const properties = /* @__PURE__ */ Object.create(null);
+      for (const [key, descriptor] of float32DataProperties(entry)) {
+        properties[key] = {
+          value: child(descriptor.value, key),
+          configurable: descriptor.configurable === true,
+          enumerable: descriptor.enumerable === true,
+          writable: descriptor.writable === true
+        };
+      }
+      nodes[id] = { ...storage, properties, extensible: Object.isExtensible(entry) };
     } else if (isSandboxMap(entry)) {
       nodes[id] = {
         kind: "map",
@@ -20484,6 +20676,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);
@@ -21117,6 +21318,22 @@ function normalize(value, seen) {
   if (seen.has(value)) throw new TypeError("Host call arguments cannot contain cycles.");
   seen.add(value);
   try {
+    if (isFloat32Array(value)) {
+      const storage = float32Storage(value);
+      const properties = /* @__PURE__ */ Object.create(null);
+      for (const [key, descriptor] of float32DataProperties(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",
+        bytes: normalize(Array.from(new Uint8Array(storage.buffer)), seen),
+        byteOffset: storage.byteOffset,
+        length: storage.length,
+        properties
+      });
+    }
     if (Array.isArray(value)) {
       const normalized2 = new Array(value.length);
       Object.setPrototypeOf(normalized2, null);
@@ -22637,6 +22854,27 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
       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 [key, descriptor] of float32DataProperties(value)) {
+      Object.defineProperty(copy, key, {
+        ...descriptor,
+        value: copyHostValueToSandbox(
+          descriptor.value,
+          stackFrames,
+          { ...options, capabilityPath: [...options.capabilityPath ?? [], key] },
+          state,
+          joinPath2(path, key)
+        )
+      });
+    }
+    if (!Object.isExtensible(value)) Object.preventExtensions(copy);
+    return copy;
+  }
   if (!options.errorData && isPromiseLike3(value)) {
     if (options.proofFunctions !== void 0)
       throw new TypeError(`Unsupported proof value at ${path}: promise`);
@@ -23658,6 +23896,131 @@ function createBudgetedSet(values, budget) {
   return createSandboxSet(values);
 }
 
+// packages/safejs/src/interp/globals/float32array.ts
+var constructors = /* @__PURE__ */ new WeakSet();
+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 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;
+  }
+  const storage = float32Storage(value);
+  if (key === "length") return storage.length;
+  if (key === "byteLength") return storage.length * 4;
+  if (key === "byteOffset") return storage.byteOffset;
+  if (key === "BYTES_PER_ELEMENT") return 4;
+  if (!["set", "slice", "subarray"].includes(key)) return void 0;
+  return createSandboxClosure({
+    sandbox: true,
+    name: key,
+    length: key === "set" ? 1 : 2,
+    call: (args, context) => {
+      const receiver = context?.thisValue;
+      if (!isFloat32Array(receiver))
+        throw new TypeError(`Float32Array#${key} requires a Float32Array receiver.`);
+      const storage2 = float32Storage(receiver);
+      if (key === "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 > storage2.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], storage2.length, 0);
+      const end = relativeIndex(args[1], storage2.length, storage2.length);
+      const length = Math.max(end - start, 0);
+      if (key === "subarray")
+        return new Float32Array(storage2.buffer, storage2.byteOffset + start * 4, length);
+      checkFloat32Allocation(length, budget);
+      const result = new Float32Array(length);
+      new Uint8Array(result.buffer).set(
+        new Uint8Array(storage2.buffer, storage2.byteOffset + start * 4, length * 4)
+      );
+      return result;
+    }
+  });
+}
+function setFloat32Member(value, property, entry) {
+  const key = String(property);
+  if (isFloat32Index(key)) {
+    Reflect.set(value, key, float32Number(entry));
+    return;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  if (descriptor === void 0 && ["length", "byteLength", "byteOffset", "buffer", "BYTES_PER_ELEMENT"].includes(key))
+    throw new TypeError(`Cannot assign to read only property '${key}'.`);
+  if (descriptor !== void 0 && (!("value" in descriptor) || !descriptor.writable))
+    throw new TypeError(`Cannot assign to read only property '${key}'.`);
+  Object.defineProperty(
+    value,
+    key,
+    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 integer = Number.isNaN(numeric) ? 0 : Math.trunc(numeric);
+  return integer < 0 ? Math.max(length + integer, 0) : Math.min(integer, length);
+}
+
 // packages/safejs/src/interp/globals/error.ts
 var errorConstructorNames = /* @__PURE__ */ new WeakMap();
 var errorNames = [
@@ -23993,6 +24356,10 @@ function assignSandboxValues(target, sources) {
       continue;
     }
     for (const [key, value] of getOwnEnumerableEntries(source)) {
+      if (isFloat32Array(target)) {
+        setFloat32Member(target, key, value);
+        continue;
+      }
       Object.defineProperty(target, key, {
         configurable: true,
         enumerable: true,
@@ -26941,7 +27308,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;
@@ -27443,6 +27810,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);
@@ -27671,6 +28039,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,
@@ -27913,6 +28289,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;
       }
@@ -28131,6 +28508,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;
@@ -28797,6 +29178,7 @@ function run(source, options = {}) {
             sink: options.sink
           }),
           ...createCollectionGlobals({ budget }),
+          Float32Array: createFloat32ArrayGlobal(budget),
           ...createErrorGlobals({
             budget
           }),
@@ -29294,4 +29676,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-Z3ZMLYCK.js.map
+//# sourceMappingURL=chunk-XBRQ72W6.js.map