poe-code 14.0.82 → 14.0.83

package/packages/safe-js/dist/interp/instanceof.js

@@ -27,7 +27,7 @@ export async function ordinaryHasInstance(value, constructor, budget, context) {
         return evaluateInstanceof(value, constructor.boundTarget, budget, context);
     }
     // These existing built-ins do not yet have ordinary prototype graphs.
-    if (isFloat32ArrayConstructor(constructor))
+    if (isFloat32ArrayConstructor(constructor) && !isGuestClosure(constructor))
         return isFloat32Array(value);
     if ((!isGuestClosure(constructor) || (value !== null && typeof value === "object" && !hasExplicitSandboxPrototype(value))) &&
         isSandboxErrorConstructorInstance(value, constructor))

package/packages/safe-js/dist/interp/interpreter.js

@@ -2380,7 +2380,7 @@ async function evaluateMemberCallExpression(node, context) {
             return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
         }
         if (isFloat32Array(member.object)) {
-            return evaluateResolvedCallExpression(node, getFloat32Member(member.object, member.property, context.budget), context, member.object);
+            return evaluateResolvedCallExpression(node, await getPropertyValue(member.object, member.property, context), context, member.object);
         }
         if (isSandboxSet(member.object)) {
             return evaluatePrimitiveMemberCall(node, "Set", member.property, getSetMember(member.object, member.property, createSetMethodOptions(context)), context);
@@ -2911,9 +2911,7 @@ export function setSandboxProperty(target, property, value, budget, checkInherit
     if (isSandboxMap(target) || isSandboxSet(target))
         target = getCollectionProperties(target);
     if (isFloat32Array(target)) {
-        if (typeof property === "symbol")
-            throw new TypeError("Typed array symbol properties are not yet supported.");
-        setFloat32Member(target, property, value);
+        setFloat32Member(target, property, value, budget);
         return;
     }
     if (isSandboxRegex(target)) {

package/packages/safe-js/dist/interp/iteration.js

@@ -1,6 +1,7 @@
 import { isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxSet } from "./values.js";
 import { enterRunningState } from "./running-state.js";
 import { isFloat32Array } from "./float32.js";
+import { float32Prototypes } from "./float32-prototypes.js";
 import { boxedValue, isSandboxBox } from "./boxed.js";
 import { getHostObjectIterator, isGuestHostObject } from "./host-capabilities.js";
 import { isSandboxCollectionIterator, nextCollectionIterator } from "./collection-iterator.js";
@@ -98,6 +99,9 @@ export async function acquireSandboxIterator(value, budget, context, asyncProtoc
     const iterator = await invokeBuiltinClosure(factory, [], budget, context, value);
     if ((typeof iterator !== "object" && typeof iterator !== "function") || iterator === null)
         throw new TypeError("Iterator must be an object.");
+    if (!asyncProtocol && isSandboxGenerator(iterator) && !iterator.async &&
+        !hasExplicitSandboxPrototype(iterator) && getSandboxPropertyDescriptor(iterator, "next", budget) === undefined)
+        return getSandboxIterator(iterator, budget, context);
     const next = await context.getProperty(iterator, "next");
     return guestIterator(iterator, next, asyncProtocol, budget, context, signal);
 }
@@ -137,7 +141,7 @@ export async function readIteratorResult(iterator, result, property) {
 export function getSandboxAsyncIterator(value, budget, context, signal) {
     if (isSandboxGenerator(value) && value.async) {
         return hasExplicitSandboxPrototype(value) ? context?.getProperty === undefined
-            ? generatorProtocolAdapter(value, budget, context, true, signal) : undefined
+            ? guestProtocolAdapter(value, budget, context, true, signal) : undefined
             : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
     }
     if (value !== null &&
@@ -293,6 +297,11 @@ export function getSandboxIterator(value, budget, context) {
     if (isGuestHostObject(value))
         return getHostObjectIterator(value);
     if (isFloat32Array(value)) {
+        if (hasExplicitSandboxPrototype(value) || (budget !== undefined && float32Prototypes.has(budget))) {
+            if (getSandboxPropertyDescriptor(value, Symbol.iterator, budget) === undefined)
+                return undefined;
+            return guestProtocolAdapter(value, budget ?? new Budget(), context, false);
+        }
         return syncIterator(Float32Array.prototype.values.call(value));
     }
     if (isSandboxGenerator(value)) {
@@ -300,7 +309,7 @@ export function getSandboxIterator(value, budget, context) {
             return undefined;
         if (hasExplicitSandboxPrototype(value))
             return context?.getProperty === undefined
-                ? generatorProtocolAdapter(value, budget ?? new Budget(), context, false) : undefined;
+                ? guestProtocolAdapter(value, budget ?? new Budget(), context, false) : undefined;
         return generatorObjectIterator(value, budget, context);
     }
     if (typeof value === "string") {
@@ -386,9 +395,9 @@ function collectionIterator(collection, value) {
     return adapter;
 }
 const asyncGeneratorRequests = new WeakMap();
-function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal) {
-    // Direct host adapters still need guest property reads, receiver binding and
-    // cached next methods, but retain their asynchronous generator result channel.
+function guestProtocolAdapter(value, budget, context, asyncProtocol, signal) {
+    // Direct adapters still need guest property reads, receiver binding and
+    // cached next methods without exposing native iterator objects.
     const bridge = {
         ...context,
         stack: context?.stack ?? [],
@@ -403,7 +412,7 @@ function generatorProtocolAdapter(value, budget, context, asyncProtocol, signal)
     let pending;
     const initialize = () => pending ??= acquireSandboxIterator(value, budget, bridge, asyncProtocol, signal).then(iterator => {
         if (iterator === undefined)
-            throw new TypeError("Generator does not provide an iterator protocol.");
+            throw new TypeError("Value does not provide an iterator protocol.");
         return resolved = iterator;
     });
     return {

package/packages/safe-js/dist/interp/object-model.js

@@ -8,6 +8,8 @@ import { isSandboxDate } from "./date.js";
 import { retainedAccessorClosures } from "./accessors.js";
 import { getHostObjectMember, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
 import { errorPrototypes } from "./error-prototypes.js";
+import { float32Properties, isFloat32Array, isFloat32Index } from "./float32.js";
+import { float32Prototypes } from "./float32-prototypes.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { boxedValue, isSandboxBox } from "./boxed.js";
 import { isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, getPromiseProperties, isSandboxRegex, getRegexProperties, getCollectionProperties, isSandboxSet } from "./values.js";
@@ -276,12 +278,15 @@ export function releaseObjectPrototype(budget) {
     functionPrototypes.delete(budget);
     generatorPrototypes.delete(budget);
     errorPrototypes.delete(budget);
+    float32Prototypes.delete(budget);
     initialRegexDescriptors.delete(budget);
     intrinsicPrototypes.delete(budget);
 }
 export function getSandboxPrototype(value, budget) {
     if (prototypes.has(value))
         return prototypes.get(value) ?? null;
+    if (isFloat32Array(value))
+        return budget === undefined ? null : float32Prototypes.get(budget) ?? null;
     // Host transport records are data-only. Resolve their default prototype in
     // the receiving realm without persisting executable intrinsic graphs.
     const errorType = sandboxErrorTypes.get(value);
@@ -328,6 +333,10 @@ export function getSandboxPropertyDescriptor(value, key, budget) {
     while (typeof current === "object" &&
         current !== null &&
         (Array.isArray(current) || isSandboxGenerator(current) || isSandboxDate(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
+        // An integer-indexed object stops numeric-key lookup even when it occurs
+        // inside another object's prototype chain and the index is invalid.
+        if (isFloat32Array(current) && typeof key !== "symbol" && isFloat32Index(String(key)))
+            return Object.getOwnPropertyDescriptor(current, key);
         const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current)
             ? key === "prototype" && current.construct !== undefined && current.boundTarget === undefined
                 ? materializeFunctionProperties(current) : getGuestFunctionProperties(current)
@@ -350,6 +359,8 @@ export 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)))
+            return Object.getOwnPropertyDescriptor(current, key)?.value;
         if (isGuestHostObject(current))
             return typeof key === "symbol" ? undefined : getHostObjectMember(current, String(key));
         if (isSandboxRegex(current))
@@ -416,6 +427,8 @@ export function setSandboxPrototype(value, prototype, budget) {
     prototypes.set(value, prototype);
 }
 function isPrototypeRecord(value) {
+    if (isFloat32Array(value))
+        return true;
     if (isGuestClosure(value))
         return true;
     if (isGuestHostObject(value))
@@ -447,5 +460,7 @@ export function hasGuestObjectState(value) {
     if (isSandboxBox(value) || isSandboxDate(value))
         return false;
     return (descriptorObjects.has(value) &&
-        Object.values(Object.getOwnPropertyDescriptors(value)).some((descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable));
+        (isFloat32Array(value)
+            ? float32Properties(value).map(([, descriptor]) => descriptor)
+            : Object.values(Object.getOwnPropertyDescriptors(value))).some((descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable));
 }

package/packages/safe-js/dist/interp/values.js

@@ -17,7 +17,7 @@ import { boxedDataProperties, boxedValue, createSandboxBox, isSandboxBox, native
 import { getHostObjectKeys, getHostObjectMember, hasHostObjectMember, measureHostObjectData, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
 import { types as nodeTypes } from "node:util";
 import { CompileScope, RegexCompileGuard, regexCompiledData } from "./regex/compile-guard.js";
-import { copyFloat32Storage, float32DataProperties, float32Storage, isFloat32Array } from "./float32.js";
+import { copyFloat32Storage, float32DataProperties, float32Properties, float32Storage, isFloat32Array } from "./float32.js";
 import { SandboxError } from "./budget.js";
 import { observeSandboxPromise, trackSandboxPromise } from "./promise-tracker.js";
 import { promiseReplayContext } from "./promise-replay.js";
@@ -405,9 +405,17 @@ export function measureSandboxData(values, options = {}) {
                 seen.add(storage.buffer);
                 usage += storage.byteLength;
             }
-            for (const [key, descriptor] of float32DataProperties(value)) {
-                usage += key.length + 1;
-                visit(descriptor.value, depth + 1);
+            for (const [key, descriptor] of float32Properties(value)) {
+                usage += 1;
+                if (typeof key === "string")
+                    usage += key.length;
+                else
+                    visit(key, depth + 1);
+                if ("value" in descriptor)
+                    visit(descriptor.value, depth + 1);
+                else
+                    for (const closure of retainedAccessorClosures(descriptor))
+                        visit(closure, depth + 1);
             }
             return;
         }

package/packages/safe-js/dist/parse/parser.js

@@ -2709,6 +2709,7 @@ class Parser {
         return undefined;
     }
     findTopLevelForIterationOperator(startIndex) {
+        let operator;
         let depth = 0;
         let previousToken;
         for (let index = startIndex; index < this.tokens.length; index += 1) {
@@ -2719,7 +2720,7 @@ class Parser {
                 }
                 else if (token.value === ")" || token.value === "]" || token.value === "}") {
                     if (depth === 0 && token.value === ")") {
-                        return undefined;
+                        return operator;
                     }
                     depth -= 1;
                 }
@@ -2730,9 +2731,12 @@ class Parser {
             if (depth === 0 &&
                 token.type === "keyword" &&
                 (token.value === "of" || token.value === "in") &&
+                index !== startIndex &&
+                !(token.value === "of" && index === startIndex + 1 &&
+                    ["const", "let", "var"].includes(previousToken?.value ?? "")) &&
                 previousToken?.value !== "." &&
                 previousToken?.value !== "?.") {
-                return token;
+                operator ??= token;
             }
             previousToken = token;
         }
@@ -3752,7 +3756,8 @@ function isLiteralPropertyKey(token) {
     return token.type === "numeric" || token.type === "string";
 }
 function isIdentifierLikeToken(token) {
-    return token.type === "identifier" || (token.type === "keyword" && token.value === "async");
+    return token.type === "identifier" ||
+        (token.type === "keyword" && (token.value === "async" || token.value === "of"));
 }
 function isNewToken(token) {
     return token.value === "new";

package/packages/safe-js/dist/parse/tokenizer.js

@@ -358,7 +358,7 @@ class Lexer {
             }
             if (char === "/" &&
                 this.peekChar(1) !== "=" &&
-                shouldRejectRegexLiteral(tokens[tokens.length - 1], lastClosedControlParenthesis)) {
+                shouldRejectRegexLiteral(tokens[tokens.length - 1], lastClosedControlParenthesis, tokens)) {
                 if (!this.options.allowRegexLiterals) {
                     this.syntaxError("Regular expression literals are not supported", this.position());
                 }
@@ -633,7 +633,7 @@ class Lexer {
     readSlashOrPunctuator(start) {
         if (this.currentChar() === "/" &&
             this.peekChar(1) !== "=" &&
-            shouldRejectRegexLiteral(this.lastSignificantToken(), this.lastClosedControlParenthesis)) {
+            shouldRejectRegexLiteral(this.lastSignificantToken(), this.lastClosedControlParenthesis, this.tokens)) {
             if (!this.options.allowRegexLiterals) {
                 this.syntaxError("Regular expression literals are not supported", start);
             }
@@ -919,7 +919,7 @@ function matchPunctuator(source, index) {
     return PUNCTUATORS.find((punctuator) => source.startsWith(punctuator, index) &&
         (punctuator !== "?." || !isDecimalDigit(source[index + 2] ?? "")));
 }
-function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis) {
+function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis, tokens) {
     if (previousToken === undefined) {
         return true;
     }
@@ -930,6 +930,8 @@ function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis) {
         return false;
     }
     if (previousToken.type === "keyword") {
+        if (previousToken.value === "of")
+            return endsWithForOfSeparator(tokens);
         return !EXPRESSION_ENDING_KEYWORDS.has(previousToken.value);
     }
     if (previousToken.value === ")") {
@@ -937,6 +939,46 @@ function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis) {
     }
     return !isExpressionEndingPunctuator(previousToken.value);
 }
+function endsWithForOfSeparator(tokens) {
+    let depth = 0;
+    let start = -1;
+    for (let index = tokens.length - 2; index >= 0; index--) {
+        const token = tokens[index];
+        if (token.type !== "punctuator")
+            continue;
+        if ([")", "]", "}"].includes(token.value))
+            depth++;
+        else if (["(", "[", "{"].includes(token.value)) {
+            if (depth > 0) {
+                depth--;
+                continue;
+            }
+            if (token.value === "(" && (tokens[index - 1]?.value === "for" ||
+                (tokens[index - 1]?.value === "await" && tokens[index - 2]?.value === "for")))
+                start = index + 1;
+            break;
+        }
+        else if (depth === 0 && token.value === ";")
+            break;
+    }
+    if (start < 0)
+        return false;
+    depth = 0;
+    for (let index = start; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token.type === "punctuator") {
+            if (["(", "[", "{"].includes(token.value))
+                depth++;
+            else if ([")", "]", "}"].includes(token.value))
+                depth--;
+        }
+        if (depth === 0 && token.type === "keyword" && token.value === "of" &&
+            index !== start && tokens[index - 1]?.value !== "." && tokens[index - 1]?.value !== "?." &&
+            !(index === start + 1 && ["const", "let", "var"].includes(tokens[start].value)))
+            return index === tokens.length - 1;
+    }
+    return false;
+}
 function updateGroupingState(groupingStack, previousToken, punctuator) {
     if (punctuator === "(") {
         groupingStack.push({

package/packages/safe-js/dist/snapshot/float32array.d.ts

@@ -1,3 +1,6 @@
+import type { GuestObjectState } from "./guest-heap.js";
+export declare function captureFloat32State<T>(value: Float32Array, encode: (value: unknown) => T): GuestObjectState<T>;
+export declare function restoreFloat32Properties<T>(value: Float32Array, state: GuestObjectState<T>, decode: (value: T) => unknown): void;
 export type Float32Data<TReference> = {
     kind: "float32array";
     byteOffset: number;

package/packages/safe-js/dist/snapshot/float32array.js

@@ -1,4 +1,23 @@
-import { float32Storage, isFloat32Array } from "../interp/float32.js";
+import { float32Properties, float32Storage, isFloat32Array, isFloat32Index } from "../interp/float32.js";
+import { getSandboxPrototype, hasExplicitSandboxPrototype } from "../interp/object-model.js";
+import { restorePropertyDescriptors, serializePropertyDescriptors } from "./property-descriptors.js";
+export function captureFloat32State(value, encode) {
+    const metadata = Object.defineProperties(Object.create(null), Object.fromEntries(float32Properties(value)));
+    if (!Object.isExtensible(value))
+        Object.preventExtensions(metadata);
+    return { properties: serializePropertyDescriptors(metadata, encode),
+        ...(hasExplicitSandboxPrototype(value) ? { prototype: encode(getSandboxPrototype(value)) } : {}) };
+}
+export function restoreFloat32Properties(value, state, decode) {
+    const metadata = Object.create(null);
+    restorePropertyDescriptors(metadata, state.properties, decode);
+    const descriptors = Object.getOwnPropertyDescriptors(metadata);
+    if (Object.keys(descriptors).some(isFloat32Index))
+        throw new TypeError("Float32Array metadata cannot replace numeric storage.");
+    Object.defineProperties(value, descriptors);
+    if (!Object.isExtensible(metadata))
+        Object.preventExtensions(value);
+}
 export function encodeFloat32Storage(value, id, buffers, reference) {
     const storage = float32Storage(value);
     const existing = buffers.get(storage.buffer);

package/packages/safe-js/dist/snapshot/restore.js

@@ -17,7 +17,7 @@ import { awaitSandboxValue } from "../interp/cancel.js";
 import { runAsyncPrefix } from "../interp/jobs.js";
 import { toPropertyKey } from "../interp/property-key.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
-import { decodeFloat32Storage } from "./float32array.js";
+import { decodeFloat32Storage, restoreFloat32Properties } from "./float32array.js";
 import { restoreDateTime } from "../interp/date.js";
 import { createRawJson } from "../interp/raw-json.js";
 import { createSandboxBox } from "../interp/boxed.js";
@@ -411,7 +411,11 @@ function initializeIntrinsicRealm(state) {
             return prototype?.kind === "intrinsic" &&
                 prototype.id === JSON.stringify([...JSON.parse(node.id), "prototype"]);
         }));
-    createBuiltinBindings({ budget: state.budget, compileOwner: state.compilation.owner, functionHasInstance, errorPrototypes });
+    const float32 = Object.values(state.heap).find(node => node.kind === "intrinsic" && node.id === '["Float32Array"]');
+    const float32Prototypes = float32?.kind !== "intrinsic" ||
+        float32.state?.properties.properties.some(([key, descriptor]) => key === "prototype" && descriptor.kind === "data" &&
+            !descriptor.writable && !descriptor.enumerable && !descriptor.configurable) === true;
+    createBuiltinBindings({ budget: state.budget, compileOwner: state.compilation.owner, functionHasInstance, errorPrototypes, float32Prototypes });
     state.intrinsicsInitialized = true;
 }
 function restoreHeapValue(id, state) {
@@ -453,8 +457,19 @@ function restoreHeapValue(id, state) {
         return value;
     }
     if (serialized.kind === "float32array") {
+        if (serialized.state !== undefined)
+            initializeIntrinsicRealm(state);
         const value = decodeFloat32Storage(serialized, (reference) => deserializeValue(reference, state));
         state.heapValueById.set(id, value);
+        if (serialized.state !== undefined) {
+            const objectState = serialized.state;
+            state.initializeIterators.push(() => {
+                if (objectState.prototype !== undefined)
+                    setSandboxPrototype(value, deserializeValue(objectState.prototype, state), state.budget);
+                restoreFloat32Properties(value, objectState, entry => deserializeValue(entry, state));
+            });
+            return value;
+        }
         for (const [key, entry] of Object.entries(serialized.entries)) {
             Object.defineProperty(value, key, {
                 value: deserializeValue(entry, state),

package/packages/safe-js/dist/snapshot/serialize.d.ts

@@ -4,7 +4,7 @@ import { type SerializedSymbol, type SerializedSymbolProperty } from "./symbols.
 import { type CollectionIterationMethod, type SandboxCollectionIterator } from "../interp/collection-iterator.js";
 import { type SandboxRegExpIterator } from "../interp/regexp-iterator.js";
 import { type SandboxErrorName } from "../error/shape.js";
-import { type GuestHeapNode } from "./guest-heap.js";
+import { type GuestHeapNode, type GuestObjectState } from "./guest-heap.js";
 import { type SerializedArguments } from "./arguments.js";
 import { type SerializedArray } from "./arrays.js";
 import { type Float32Data } from "./float32array.js";
@@ -75,6 +75,7 @@ export type SerializedHeapValue = GuestHeapNode<SerializedSnapshotValue> | {
     entries: Record<string, SerializedSnapshotValue>;
 } | SerializedDate<SerializedSnapshotValue> | (Float32Data<SerializedReferenceValue> & {
     entries: Record<string, SerializedSnapshotValue>;
+    state?: GuestObjectState<SerializedSnapshotValue>;
 }) | SerializedArguments<SerializedSnapshotValue> | SerializedArray<SerializedSnapshotValue> | {
     kind: "object";
     sandboxNullPrototype?: true;

package/packages/safe-js/dist/snapshot/serialize.js

@@ -11,8 +11,8 @@ import { captureGuestHeapNode } from "./guest-heap.js";
 import { getGeneratorOrigin } from "../interp/closure-origin.js";
 import { serializeArguments } from "./arguments.js";
 import { requiresArrayEntries, serializeArray } from "./arrays.js";
-import { float32DataProperties, isFloat32Array } from "../interp/float32.js";
-import { encodeFloat32Storage } from "./float32array.js";
+import { isFloat32Array } from "../interp/float32.js";
+import { captureFloat32State, encodeFloat32Storage } from "./float32array.js";
 import { dateDataProperties, isSandboxDate } from "../interp/date.js";
 import { serializeDate } from "./date-properties.js";
 import { boxedDataProperties, isSandboxBox } from "../interp/boxed.js";
@@ -104,7 +104,7 @@ function serializeValue(value, path, state) {
         }
         return { kind: "ref", id };
     }
-    if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !isSandboxMap(value) && !isSandboxSet(value)) {
+    if (typeof value === "object" && value !== null && hasGuestObjectState(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isFloat32Array(value)) {
         throw new TypeError("Guest function properties and prototype links cannot be serialized.");
     }
     if (value === null || typeof value === "string" || typeof value === "boolean") {
@@ -265,10 +265,8 @@ function serializeHeapReference(value, path, state) {
                 kind: "ref",
                 id
             }));
-            const entries = Object.create(null);
-            state.heap[String(id)] = { ...storage, entries };
-            for (const [key, descriptor] of float32DataProperties(value))
-                entries[key] = serializeValue(descriptor.value, `${path}.${key}`, state);
+            state.heap[String(id)] = { ...storage, entries: {},
+                state: captureFloat32State(value, entry => serializeValue(entry, `${path}.<typed-array>`, state)) };
         }
         else if (isSandboxArguments(value)) {
             state.heap[String(id)] = serializeArguments(value, (entry, key) => serializeValue(entry, `${path}.${key}`, state));
@@ -431,9 +429,12 @@ function collectContainerStats(value, stats, ancestors, guestValues, depth = 0)
     stat.expanded = true;
     ancestors.add(value);
     const guestEntries = [];
-    const guest = captureGuestHeapNode(value, entry => { guestEntries.push(entry); return null; });
+    const guest = isFloat32Array(value)
+        ? { kind: "float32array", state: captureFloat32State(value, entry => { guestEntries.push(entry); return null; }) }
+        : captureGuestHeapNode(value, entry => { guestEntries.push(entry); return null; });
     if (guest !== undefined) {
-        guestValues.add(value);
+        if (!isFloat32Array(value))
+            guestValues.add(value);
         for (const entry of guestEntries) {
             collectContainerStats(entry, stats, ancestors, guestValues, depth + 1);
             if (entry !== null && typeof entry === "object") {

package/packages/safe-js/dist/snapshot/validation.js

@@ -120,6 +120,11 @@ function validateDumpHeap(root, state) {
         if (entry.kind === "float32array") {
             validateFloat32Storage(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");
+                validateGuestHeapNode({ kind: "guest-object", state: entry.state }, heap, state.limits.maxEntries);
+            }
             continue;
         }
         if (entry.kind === "arguments") {
@@ -551,6 +556,11 @@ function validateHeapValue(value, path, state, heap) {
     if (record.kind === "float32array") {
         validateFloat32Storage(record);
         requireRecord(record.entries, `${path}.entries`);
+        if (Object.hasOwn(record, "state")) {
+            if (Object.keys(record.entries).length !== 0)
+                fail("invalidValue", path, "ambiguous Float32Array property state");
+            validateGuestHeapNode({ kind: "guest-object", state: record.state }, heap, state.limits.maxEntries);
+        }
     }
     if (record.kind === "map") {
         const entries = requireArray(record.entries, `${path}.entries`, state);