poe-code 14.0.79 → 14.0.80

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

@@ -1,5 +1,6 @@
 import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
 import { internalSymbols } from "./internal-symbols.js";
+import { getGeneratorProperties } from "./generator-properties.js";
 import { getRegexProperties, regexGuestProperties } from "./regexp-properties.js";
 import { getCollectionProperties, collectionGuestProperties, copyCollectionProperties } from "./collection-properties.js";
 export { getCollectionProperties } from "./collection-properties.js";
@@ -118,6 +119,8 @@ export function ownEnumerableSandboxEntries(value, excludedKeys) {
         entries = Object.entries(getRegexProperties(value));
     else if (isSandboxPromise(value))
         entries = Object.entries(getPromiseProperties(value));
+    else if (isSandboxGenerator(value))
+        entries = Object.entries(getGeneratorProperties(value));
     else if (isSandboxMap(value) || isSandboxSet(value))
         entries = Object.entries(getCollectionProperties(value));
     else if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value))
@@ -137,15 +140,15 @@ export function ownSandboxSymbolKeys(value) {
         value = getRegexProperties(value);
     else if (isSandboxPromise(value))
         value = getPromiseProperties(value);
+    else if (isSandboxGenerator(value))
+        value = getGeneratorProperties(value);
     else if (isSandboxMap(value) || isSandboxSet(value))
         value = getCollectionProperties(value);
-    else if (isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value))
-        return [];
     return Object.getOwnPropertySymbols(Object(value)).filter(key => !internalSymbols.has(key));
 }
 export function ownEnumerableSandboxKeys(value, includeSymbols = false) {
     if (includeSymbols) {
-        const properties = isSandboxClosure(value) ? value.properties ?? {} : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value)
+        const properties = isSandboxClosure(value) ? value.properties ?? {} : isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value)
             : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : Object(value);
         return [...ownEnumerableSandboxKeys(value), ...ownSandboxSymbolKeys(value).filter(key => Object.getOwnPropertyDescriptor(properties, key)?.enumerable === true)];
     }
@@ -157,6 +160,8 @@ export function ownEnumerableSandboxKeys(value, includeSymbols = false) {
         return Object.keys(value.properties ?? {});
     if (isSandboxPromise(value))
         return Object.keys(getPromiseProperties(value));
+    if (isSandboxGenerator(value))
+        return Object.keys(getGeneratorProperties(value));
     if (isSandboxRegex(value))
         return Object.keys(getRegexProperties(value));
     if (isSandboxMap(value) || isSandboxSet(value))
@@ -213,6 +218,7 @@ export function createSandboxGenerator(channel, metadata = undefined) {
         enumerable: false,
         value: true
     });
+    getGeneratorProperties(generator);
     return generator;
 }
 export function createSandboxMap(entries = []) {
@@ -501,6 +507,18 @@ export function measureSandboxData(values, options = {}) {
             return;
         }
         if (isSandboxGenerator(value)) {
+            const descriptors = Object.getOwnPropertyDescriptors(getGeneratorProperties(value));
+            for (const key of Reflect.ownKeys(descriptors)) {
+                const descriptor = descriptors[key];
+                usage += typeof key === "string" ? key.length + 1 : 1;
+                if (typeof key === "symbol")
+                    visit(key, depth + 1);
+                if ("value" in descriptor)
+                    visit(descriptor.value, depth + 1);
+                else
+                    for (const closure of retainedAccessorClosures(descriptor))
+                        visit(closure, depth + 1);
+            }
             const snapshot = value.channel.snapshot();
             usage += snapshot.sent.length;
             for (const completion of snapshot.sent)

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

@@ -217,7 +217,9 @@ export function validateGuestHeapNode(raw, heap, maxArrayLength = 0xffffffff) {
         state(node.state);
     }
     else if (node.kind === "guest-generator") {
-        fields(node, ["kind", "state", "astNodeId", "async", "scope", "closureScope", "sent"], ["suspendedScope", "yieldNodeId", "environment", "blockScopes", "finallyCompletions", "expressionStates"]);
+        fields(node, ["kind", "state", "astNodeId", "async", "scope", "closureScope", "sent"], ["suspendedScope", "yieldNodeId", "environment", "blockScopes", "finallyCompletions", "expressionStates", "objectState"]);
+        if (Object.hasOwn(node, "objectState"))
+            state(node.objectState);
         if (!["start", "running", "suspended", "done"].includes(String(node.state)) || typeof node.async !== "boolean" || integer(node.astNodeId) < 1)
             throw new TypeError("Invalid generator state.");
         reference(node.scope, ["scope-frame"]);

package/packages/safe-js/dist/snapshot/guest-heap.d.ts

@@ -61,6 +61,7 @@ export type GuestHeapNode<T> = {
         homeObject?: T;
         newTarget?: T;
     };
+    objectState?: GuestObjectState<T>;
 } | {
     kind: "guest-object";
     state: GuestObjectState<T>;

package/packages/safe-js/dist/snapshot/guest-heap.js

@@ -1,4 +1,5 @@
 import { getClosureOrigin, getGeneratorOrigin } from "../interp/closure-origin.js";
+import { getGeneratorProperties } from "../interp/generator-properties.js";
 import { getIntrinsicIdentity } from "../interp/intrinsics.js";
 import { getSandboxPrototype, hasExplicitSandboxPrototype, hasGuestObjectState, isGuestClosure, materializeFunctionProperties } from "../interp/object-model.js";
 import { isLiveCapability } from "../interp/host-capabilities.js";
@@ -65,6 +66,7 @@ export function captureGuestHeapNode(value, encode) {
         const channel = value.channel.snapshot();
         return {
             kind: "guest-generator", state: value.state, astNodeId: origin.node.nodeId, async: value.async === true,
+            objectState: captureObjectState(value, encode),
             scope: encode(origin.scope), closureScope: encode(origin.closureScope),
             ...(value.state !== "suspended" || origin.suspendedScope === undefined ? {} : { suspendedScope: encode(origin.suspendedScope) }),
             ...(value.state !== "suspended" || origin.blockScopes === undefined ? {} : {
@@ -164,6 +166,8 @@ export function captureGuestHeapNode(value, encode) {
 }
 function captureObjectState(value, encode) {
     let properties = value;
+    if (isSandboxGenerator(value))
+        properties = getGeneratorProperties(value);
     if (isSandboxClosure(value)) {
         properties = value.properties;
         if (isGuestClosure(value))

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

@@ -1,4 +1,5 @@
 import { Budget, SandboxError } from "../interp/budget.js";
+import { getGeneratorProperties } from "../interp/generator-properties.js";
 import { restoreRegexProperties } from "./regexp-properties.js";
 import { classOrigins, createClassConstructor } from "../interp/classes.js";
 import { mapIteratorSnapshot } from "../interp/iteration.js";
@@ -521,6 +522,13 @@ function restoreHeapValue(id, state) {
     if (serialized.kind === "guest-generator") {
         const generator = restoreGuestGenerator(serialized, state);
         state.heapValueById.set(id, generator);
+        const objectState = serialized.objectState;
+        if (objectState !== undefined)
+            state.initializeIterators.push(() => {
+                if (objectState.prototype !== undefined)
+                    setSandboxPrototype(generator, deserializeValue(objectState.prototype, state), state.budget);
+                restorePropertyDescriptors(getGeneratorProperties(generator), objectState.properties, entry => deserializeValue(entry, state));
+            });
         return generator;
     }
     if (serialized.kind === "intrinsic" || serialized.kind === "guest-function" || serialized.kind === "guest-class" || serialized.kind === "guest-object" || serialized.kind === "guest-array" || serialized.kind === "array-iterator") {