poe-code 12.0.3 → 12.0.4

package/packages/safejs/dist/cli.js

@@ -20,7 +20,7 @@ import {
   parseMcpConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-T55OILHA.js";
+} from "./chunks/chunk-LF5LY5O3.js";
 import {
   Budget,
   SandboxError,
@@ -32,7 +32,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-Z3ZMLYCK.js";
+} from "./chunks/chunk-XBRQ72W6.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/cli.ts

package/packages/safejs/dist/core.js

@@ -3,7 +3,7 @@ import {
   createReplayableRandom,
   lint,
   run
-} from "./chunks/chunk-Z3ZMLYCK.js";
+} from "./chunks/chunk-XBRQ72W6.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safejs/dist/index.js

@@ -27,7 +27,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-T55OILHA.js";
+} from "./chunks/chunk-LF5LY5O3.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -49,7 +49,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-Z3ZMLYCK.js";
+} from "./chunks/chunk-XBRQ72W6.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/runner/run-harness.ts

package/packages/safejs/dist/interp/float32.d.ts

@@ -0,0 +1,16 @@
+import type { Budget } from "./budget.js";
+export declare function isFloat32Array(value: unknown): value is Float32Array;
+export declare function float32Storage(value: Float32Array): {
+    buffer: ArrayBuffer;
+    byteOffset: number;
+    length: number;
+    byteLength: number;
+};
+export declare function float32DataProperties(value: Float32Array): Array<[string, PropertyDescriptor]>;
+export declare function isFloat32Index(key: string): boolean;
+export declare function float32Number(value: unknown): number;
+export declare function checkFloat32Allocation(length: number, budget: Budget): void;
+export declare function copyFloat32Storage<TValue>(value: Float32Array, state: {
+    seen: WeakMap<object, TValue>;
+    float32Buffers?: WeakMap<ArrayBuffer, ArrayBuffer>;
+}): Float32Array;

package/packages/safejs/dist/interp/float32.js

@@ -0,0 +1,65 @@
+const typedArrayPrototype = Object.getPrototypeOf(Float32Array.prototype);
+const readLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "length").get;
+const readOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
+const readBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
+const readTag = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag).get;
+const bufferLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+const bufferResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get;
+export function isFloat32Array(value) {
+    return (ArrayBuffer.isView(value) &&
+        Object.getPrototypeOf(value) === Float32Array.prototype &&
+        Reflect.apply(readTag, value, []) === "Float32Array");
+}
+export function float32Storage(value) {
+    const buffer = Reflect.apply(readBuffer, value, []);
+    if (Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype ||
+        (bufferResizable !== undefined && 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, [])
+    };
+}
+export 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;
+}
+export function isFloat32Index(key) {
+    return key === "-0" || String(Number(key)) === key;
+}
+export 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);
+}
+export function checkFloat32Allocation(length, budget) {
+    budget.allocateArrayLength(length);
+    budget.provisionDataUsage(length * Float32Array.BYTES_PER_ELEMENT + 1)();
+}
+export function copyFloat32Storage(value, state) {
+    const storage = float32Storage(value);
+    state.float32Buffers ??= new WeakMap();
+    let buffer = state.float32Buffers.get(storage.buffer);
+    if (buffer === undefined) {
+        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);
+}

package/packages/safejs/dist/interp/globals/float32array.d.ts

@@ -0,0 +1,6 @@
+import type { Budget } from "../budget.js";
+import { type SandboxClosure, type SandboxValue } from "../values.js";
+export declare function createFloat32ArrayGlobal(budget: Budget): SandboxClosure;
+export declare function isFloat32ArrayConstructor(value: unknown): boolean;
+export declare function getFloat32Member(value: Float32Array, property: string | number, budget: Budget): SandboxValue;
+export declare function setFloat32Member(value: Float32Array, property: string | number, entry: SandboxValue): void;

package/packages/safejs/dist/interp/globals/float32array.js

@@ -0,0 +1,130 @@
+import { checkFloat32Allocation, float32Number, float32Storage, isFloat32Array, isFloat32Index } from "../float32.js";
+import { createSandboxClosure } from "../values.js";
+const constructors = new WeakSet();
+export 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 length = isFloat32Array(source) ? float32Storage(source).length : source.length;
+                checkFloat32Allocation(length, budget);
+                if (isFloat32Array(source))
+                    return new Float32Array(source);
+                const result = new Float32Array(length);
+                for (let index = 0; index < length; index += 1) {
+                    budget.visitNode();
+                    const descriptor = Object.getOwnPropertyDescriptor(source, index);
+                    if (descriptor !== undefined && !("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;
+}
+export function isFloat32ArrayConstructor(value) {
+    return typeof value === "object" && value !== null && constructors.has(value);
+}
+export function getFloat32Member(value, property, budget) {
+    const key = String(property);
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor !== undefined) {
+        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 undefined;
+    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 storage = 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 length = isFloat32Array(source) ? float32Storage(source).length : source.length;
+                if (offset < 0 || !Number.isSafeInteger(offset) || offset + length > storage.length)
+                    throw new RangeError("Float32Array#set source is out of bounds.");
+                if (isFloat32Array(source)) {
+                    Float32Array.prototype.set.call(receiver, source, offset);
+                    return undefined;
+                }
+                checkFloat32Allocation(length, budget);
+                const copied = new Float32Array(length);
+                for (let index = 0; index < length; index += 1) {
+                    budget.visitNode();
+                    const entry = Object.getOwnPropertyDescriptor(source, index);
+                    if (entry !== undefined && !("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 undefined;
+            }
+            const start = relativeIndex(args[0], storage.length, 0);
+            const end = relativeIndex(args[1], storage.length, storage.length);
+            const length = Math.max(end - start, 0);
+            if (key === "subarray")
+                return new Float32Array(storage.buffer, storage.byteOffset + start * 4, length);
+            checkFloat32Allocation(length, budget);
+            const result = new Float32Array(length);
+            new Uint8Array(result.buffer).set(new Uint8Array(storage.buffer, storage.byteOffset + start * 4, length * 4));
+            return result;
+        }
+    });
+}
+export 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 === undefined &&
+        ["length", "byteLength", "byteOffset", "buffer", "BYTES_PER_ELEMENT"].includes(key))
+        throw new TypeError(`Cannot assign to read only property '${key}'.`);
+    if (descriptor !== undefined && (!("value" in descriptor) || !descriptor.writable))
+        throw new TypeError(`Cannot assign to read only property '${key}'.`);
+    Object.defineProperty(value, key, descriptor === undefined
+        ? { value: entry, configurable: true, enumerable: true, writable: true }
+        : { value: entry });
+}
+function relativeIndex(value, length, fallback) {
+    if (value === undefined)
+        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);
+}

package/packages/safejs/dist/interp/globals/object-array.js

@@ -1,4 +1,6 @@
 import { sandboxErrorTypes } from "../../error/shape.js";
+import { isFloat32Array } from "../float32.js";
+import { setFloat32Member } from "./float32array.js";
 import { getSandboxIterator } from "../iteration.js";
 import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "../values.js";
 export function createObjectArrayGlobals(options) {
@@ -213,6 +215,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,

package/packages/safejs/dist/interp/host-bridge.js

@@ -1,6 +1,7 @@
 import { normalizeClosureResult } from "./async.js";
 import { attachErrorSpan, replaceErrorStack } from "../error/shape.js";
 import { SandboxError } from "./budget.js";
+import { checkFloat32Allocation, copyFloat32Storage, float32DataProperties, float32Storage, isFloat32Array } from "./float32.js";
 import { createSubsetErrorValue } from "./exceptions.js";
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
 import { digestHostCallArguments, HostCallResumabilityError, UnresolvedReplayCapabilityError } from "./host-call.js";
@@ -593,6 +594,23 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
                 : path
         }, state);
     }
+    if (isFloat32Array(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            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, joinPath(path, key))
+            });
+        }
+        if (!Object.isExtensible(value))
+            Object.preventExtensions(copy);
+        return copy;
+    }
     if (!options.errorData && isPromiseLike(value)) {
         if (options.proofFunctions !== undefined)
             throw new TypeError(`Unsupported proof value at ${path}: promise`);

package/packages/safejs/dist/interp/host-call.js

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
+import { float32DataProperties, float32Storage, isFloat32Array } from "./float32.js";
 import { cloneSandboxValue, createSandboxClosure, defineOwnDataProperty, isArrayIndexKey, measureSandboxData } from "./values.js";
 import { decodeReplayData, encodeReplayData } from "../snapshot/replay-data.js";
 import { validateSnapshotData } from "../snapshot/validation.js";
@@ -534,6 +535,20 @@ function normalize(value, seen) {
         throw new TypeError("Host call arguments cannot contain cycles.");
     seen.add(value);
     try {
+        if (isFloat32Array(value)) {
+            const storage = float32Storage(value);
+            const properties = 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(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 normalized = new Array(value.length);
             Object.setPrototypeOf(normalized, null);

package/packages/safejs/dist/interp/interpreter.js

@@ -21,6 +21,8 @@ import { callStringMethod, getStringMember, isStringMethodName, validateStringMe
 import { callSetMethod, getSetMember, isSetMethodName } from "./methods/set.js";
 import { isSandboxErrorConstructor, isSandboxErrorConstructorInstance } from "./globals/error.js";
 import { isSandboxMapConstructor, isSandboxSetConstructor } from "./globals/collections.js";
+import { getFloat32Member, isFloat32ArrayConstructor, setFloat32Member } from "./globals/float32array.js";
+import { isFloat32Array } from "./float32.js";
 import { createSandboxRegex, allocateProducedSandboxValue, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, measureSandboxData } from "./values.js";
 import { Scope } from "./scope.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
@@ -1071,7 +1073,10 @@ function forInObject(value) {
     if (value === null || value === undefined || isSandboxClosure(value) || isSandboxPromise(value)) {
         return undefined;
     }
-    if (typeof value === "string" || Array.isArray(value) || isPlainForInObject(value)) {
+    if (typeof value === "string" ||
+        Array.isArray(value) ||
+        isFloat32Array(value) ||
+        isPlainForInObject(value)) {
         return Object(value);
     }
     return undefined;
@@ -1573,6 +1578,8 @@ function getPropertyValue(target, property, context) {
         return getNumberMember(target, property, context.budget);
     if (typeof target === "boolean")
         return undefined;
+    if (isFloat32Array(target))
+        return getFloat32Member(target, property, context.budget);
     if (isSandboxMap(target))
         return getMapMember(target, property, createMapMethodOptions(context));
     if (isSandboxSet(target))
@@ -1781,6 +1788,9 @@ async function evaluateMemberCallExpression(node, context) {
     if (isSandboxMap(member.object)) {
         return evaluatePrimitiveMemberCall(node, "Map", member.property, getMapMember(member.object, member.property, createMapMethodOptions(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, "Set", member.property, getSetMember(member.object, member.property, createSetMethodOptions(context)), context);
     }
@@ -1988,6 +1998,8 @@ 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;
             }
@@ -2208,6 +2220,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;

package/packages/safejs/dist/interp/iteration.js

@@ -1,6 +1,10 @@
 import { isSandboxGenerator, isSandboxMap, isSandboxSet } from "./values.js";
 import { enterRunningState } from "./running-state.js";
+import { isFloat32Array } from "./float32.js";
 export function getSandboxIterator(value) {
+    if (isFloat32Array(value)) {
+        return syncIterator(Float32Array.prototype.values.call(value));
+    }
     if (isSandboxGenerator(value)) {
         return generatorIterator(value);
     }

package/packages/safejs/dist/interp/values.d.ts

@@ -11,7 +11,7 @@ declare const sandboxRegexPattern: unique symbol;
 declare const sandboxSetBrand: unique symbol;
 declare const sandboxRetainedValues: unique symbol;
 export type SandboxPrimitive = string | number | boolean | null | undefined;
-export type SandboxValue = SandboxPrimitive | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
+export type SandboxValue = SandboxPrimitive | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
 export type SandboxObject = {
     [key: string]: SandboxValue;
 };

package/packages/safejs/dist/interp/values.js

@@ -1,4 +1,5 @@
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
+import { copyFloat32Storage, float32DataProperties, float32Storage, isFloat32Array } from "./float32.js";
 import { SandboxError } from "./budget.js";
 import { observeSandboxPromise, trackSandboxPromise } from "./promise-tracker.js";
 import { promiseReplayContext } from "./promise-replay.js";
@@ -198,6 +199,18 @@ export function measureSandboxData(values, options = {}) {
             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) {
@@ -315,6 +328,22 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
         }
         return sandboxPromise;
     }
+    if (isFloat32Array(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            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 !== undefined) {
@@ -382,6 +411,22 @@ 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 !== undefined)
+            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 === undefined) {
             throw new TypeError("Sandbox closures cannot cross into host values without an explicit wrapper.");
@@ -482,6 +527,17 @@ function allocateSandboxValue(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);
+            allocateSandboxValue(descriptor.value, budget, seen);
+        }
+        return;
+    }
     if (Array.isArray(value)) {
         if (seen.has(value)) {
             return;

package/packages/safejs/dist/lint/rules/known-globals.d.ts

@@ -1 +1 @@
-export declare const KNOWN_RUNTIME_GLOBALS: readonly ["AggregateError", "Array", "Boolean", "Error", "Infinity", "isFinite", "isNaN", "JSON", "Map", "Math", "NaN", "Number", "Object", "parseFloat", "parseInt", "Promise", "RangeError", "ReferenceError", "RegExp", "Set", "String", "structuredClone", "SyntaxError", "TypeError", "console"];
+export declare const KNOWN_RUNTIME_GLOBALS: readonly ["AggregateError", "Array", "Boolean", "Error", "Infinity", "isFinite", "isNaN", "JSON", "Map", "Float32Array", "Math", "NaN", "Number", "Object", "parseFloat", "parseInt", "Promise", "RangeError", "ReferenceError", "RegExp", "Set", "String", "structuredClone", "SyntaxError", "TypeError", "console"];

package/packages/safejs/dist/lint/rules/known-globals.js

@@ -8,6 +8,7 @@ export const KNOWN_RUNTIME_GLOBALS = [
     "isNaN",
     "JSON",
     "Map",
+    "Float32Array",
     "Math",
     "NaN",
     "Number",

package/packages/safejs/dist/run.js

@@ -13,6 +13,7 @@ import { createSandboxPromiseRejectionTracker, observeSandboxPromise, withSandbo
 import { HostCallJournal } from "./interp/host-call.js";
 import { createConsoleJsonGlobals } from "./interp/globals/console-json.js";
 import { createCollectionGlobals } from "./interp/globals/collections.js";
+import { createFloat32ArrayGlobal } from "./interp/globals/float32array.js";
 import { createErrorGlobals } from "./interp/globals/error.js";
 import { createMathGlobals } from "./interp/globals/math.js";
 import { createRegexGlobals } from "./interp/globals/regex.js";
@@ -111,6 +112,7 @@ export function run(source, options = {}) {
                         sink: options.sink
                     }),
                     ...createCollectionGlobals({ budget }),
+                    Float32Array: createFloat32ArrayGlobal(budget),
                     ...createErrorGlobals({
                         budget
                     }),

package/packages/safejs/dist/snapshot/dump-format.js

@@ -5,6 +5,8 @@ import { sandboxErrorTypes } from "../error/shape.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";
 import { serializeArguments } from "./arguments.js";
 import { requiresArrayEntries, serializeArray } from "./arrays.js";
+import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
+import { encodeFloat32Storage } from "./float32array.js";
 const SKIP_VALUE = Symbol("SafeJS.skip-dump-value");
 export function serializeSafeJSSnapshot(snapshot) {
     const replayError = Object.getOwnPropertyDescriptor(snapshot, "replayError");
@@ -23,6 +25,7 @@ export function serializeSafeJSSnapshot(snapshot) {
 }
 function createDumpFile(snapshot) {
     const state = {
+        float32Buffers: new WeakMap(),
         heap: {},
         heapIds: indexHeapContainers(snapshot),
         serializedHeapIds: new Set()
@@ -65,6 +68,8 @@ 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 reference = serializeHeapReference(value, path, state);
         if (reference !== undefined) {
@@ -88,7 +93,19 @@ 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, (id) => ({
+                kind: "ref",
+                id
+            }));
+            const entries = 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;
@@ -138,6 +155,7 @@ function indexHeapContainers(snapshot) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            isFloat32Array(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||
             isSandboxArguments(value) ||
             sandboxErrorTypes.has(value)) {
@@ -151,7 +169,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 stat = stats.get(value);

package/packages/safejs/dist/snapshot/float32array.d.ts

@@ -0,0 +1,12 @@
+export type Float32Data<TReference> = {
+    kind: "float32array";
+    byteOffset: number;
+    length: number;
+} & ({
+    bytes: number[];
+} | {
+    buffer: TReference;
+});
+export declare function encodeFloat32Storage<TReference>(value: Float32Array, id: number, buffers: WeakMap<ArrayBuffer, number>, reference: (id: number) => TReference): Float32Data<TReference>;
+export declare function validateFloat32Storage(value: Record<string, unknown>): void;
+export declare function decodeFloat32Storage(value: Record<string, unknown>, resolve: (reference: unknown) => unknown): Float32Array;