poe-code 14.0.39 → 14.0.41

package/packages/safe-js/dist/chunks/{chunk-QXSG4XRW.js → chunk-L4NMOY6O.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-CSC4EXIV.js";
+} from "./chunk-5J6BX3HD.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-QXSG4XRW.js.map
+//# sourceMappingURL=chunk-L4NMOY6O.js.map

package/packages/safe-js/dist/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-QXSG4XRW.js";
+} from "./chunks/chunk-L4NMOY6O.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-CSC4EXIV.js";
+} from "./chunks/chunk-5J6BX3HD.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/core.js

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-CSC4EXIV.js";
+} from "./chunks/chunk-5J6BX3HD.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safe-js/dist/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-QXSG4XRW.js";
+} from "./chunks/chunk-L4NMOY6O.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-CSC4EXIV.js";
+} from "./chunks/chunk-5J6BX3HD.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/async.d.ts

@@ -52,6 +52,7 @@ export declare function emitResumeBreakpoint(context: AsyncEvaluationContext, br
 export declare function evaluateArrowFunctionExpression(node: ArrowFunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
 export declare function evaluateFunctionExpression(node: FunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
 export declare function createInterpretedClosure(node: ArrowFunctionExpression | FunctionDeclaration | FunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): import("./values.js").SandboxClosure;
+export declare function executeAsyncFunction(execute: (onSuspend: () => void) => Promise<SandboxValue>, budget: Budget, signal?: AbortSignal): import("./values.js").SandboxPromise;
 export declare function evaluateAwaitExpression(node: AwaitExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
 export declare function normalizeClosureResult(result: SandboxValue | Promise<SandboxValue> | PromiseLike<SandboxValue>, budget?: Budget): SandboxValue;
 export {};

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

@@ -81,36 +81,39 @@ export function createInterpretedClosure(node, context, evaluateNode) {
             };
             if (!node.async)
                 return executeClosure(node, args, callContext?.thisValue, invocationContext, evaluateNode);
-            let completePrefix;
-            const synchronousPrefix = new Promise((resolve) => {
-                completePrefix = resolve;
-            });
-            const promise = new Promise((resolve, reject) => {
-                runAsyncPrefix(async () => {
-                    try {
-                        const value = await executeClosure(node, args, callContext?.thisValue, { ...invocationContext, onSuspend: completePrefix }, evaluateNode);
-                        resolve(isSandboxPromise(value) || getThenable(value) !== undefined
-                            ? awaitSandboxValue(createSandboxPromise(resolveSandboxValue(value, { budget: context.budget }), {
-                                trackReplay: false
-                            }), context.signal, context.budget)
-                            : allocateProducedSandboxValue(value, context.budget));
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                    finally {
-                        completePrefix();
-                    }
-                }).catch((error) => {
-                    reject(error);
-                    completePrefix();
-                });
-            });
-            return createSandboxPromise(promise, { synchronousPrefix });
+            return executeAsyncFunction((onSuspend) => executeClosure(node, args, callContext?.thisValue, { ...invocationContext, onSuspend }, evaluateNode), context.budget, context.signal);
         }
     });
     return closure;
 }
+export function executeAsyncFunction(execute, budget, signal) {
+    let completePrefix;
+    const synchronousPrefix = new Promise((resolve) => {
+        completePrefix = resolve;
+    });
+    const promise = new Promise((resolve, reject) => {
+        runAsyncPrefix(async () => {
+            try {
+                const value = await execute(completePrefix);
+                resolve(isSandboxPromise(value) || getThenable(value) !== undefined
+                    ? awaitSandboxValue(createSandboxPromise(resolveSandboxValue(value, { budget }), {
+                        trackReplay: false
+                    }), signal, budget)
+                    : allocateProducedSandboxValue(value, budget));
+            }
+            catch (error) {
+                reject(error);
+            }
+            finally {
+                completePrefix();
+            }
+        }).catch((error) => {
+            reject(error);
+            completePrefix();
+        });
+    });
+    return createSandboxPromise(promise, { synchronousPrefix });
+}
 function createGeneratorClosure(node, context, evaluateNode) {
     return createSandboxClosure({
         guest: true,

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

@@ -45,6 +45,7 @@ export type InterpreterResult = {
 };
 export type InterpretOptions = {
     assertActive?: () => void;
+    onSuspend?: () => void;
     jobs?: SandboxJobQueue;
     nested?: boolean;
     compilation?: CompileScope;

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

@@ -25,6 +25,7 @@ import { bindPattern } from "./patterns.js";
 import { callStringMethod, getStringMember, isStringMethodName, validateStringMethodArguments } from "./methods/string.js";
 import { callSetMethod, getSetMember, isSetMethodName } from "./methods/set.js";
 import { isSandboxErrorConstructorInstance } from "./globals/error.js";
+import { hasOwnSandboxProperty } from "./globals/object.js";
 import { isSandboxMapConstructor, isSandboxSetConstructor } from "./globals/collections.js";
 import { getFloat32Member, isFloat32ArrayConstructor, setFloat32Member } from "./globals/float32array.js";
 import { isFloat32Array } from "./float32.js";
@@ -110,6 +111,7 @@ export async function interpret(node, options = {}) {
             budget,
             callStack: [],
             onYield: options.onYield,
+            onSuspend: options.onSuspend,
             captureReplayState: options.captureReplayState,
             rootNode: node,
             scope,
@@ -437,13 +439,14 @@ async function evaluateBinaryExpression(node, context) {
     if (right.kind !== "normal") {
         return right;
     }
-    const value = node.operator === "in" && isGuestHostObject(right.value)
-        ? hasHostObjectMember(right.value, await sandboxString(left.value, context.budget, {
-            stack: context.callStack,
-            thisValue: undefined,
-            invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, undefined, thisValue)
-        }))
-        : applyBinaryOperator(node, left.value, right.value, context);
+    let leftValue = left.value;
+    if (node.operator === "in") {
+        if (typeof right.value !== "object" || right.value === null) {
+            throw new TypeError("Right-hand side of 'in' must be an object.");
+        }
+        leftValue = await toPropertyKey(leftValue, context);
+    }
+    const value = applyBinaryOperator(node, leftValue, right.value, context);
     return {
         kind: "normal",
         hasValue: true,
@@ -2118,9 +2121,49 @@ function applyBinaryOperator(node, left, right, context) {
             }
             return false;
         case "in":
-            throw createError("UNSUPPORTED_NODE", node, "Binary operator 'in' is not supported.");
+            return hasSandboxProperty(right, left, context);
     }
 }
+async function toPropertyKey(value, context) {
+    if (isPlainSandboxObject(value) && !isSandboxDate(value) && !isFloat32Array(value) &&
+        !isSandboxGenerator(value) && !isGuestHostObject(value)) {
+        for (const name of ["toString", "valueOf"]) {
+            const method = getMemberValue(value, name, context);
+            if (!isSandboxClosure(method))
+                continue;
+            const primitive = await invokeSandboxClosure(method, [], context, context.callStack, undefined, value);
+            if (primitive === null || typeof primitive !== "object") {
+                return context.budget.allocateString(String(primitive));
+            }
+        }
+        throw new TypeError("Cannot convert object to primitive value.");
+    }
+    return sandboxString(value, context.budget, {
+        stack: context.callStack,
+        thisValue: undefined,
+        invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, undefined, thisValue)
+    });
+}
+function hasSandboxProperty(value, key, context) {
+    let current = value;
+    let depth = 0;
+    while (typeof current === "object" && current !== null) {
+        if (isGuestHostObject(current))
+            return hasHostObjectMember(current, key);
+        if (hasOwnSandboxProperty(current, key, false))
+            return true;
+        if (Array.isArray(current) || !isPlainSandboxObject(current) ||
+            isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current)) {
+            return getPropertyValue(current, key, context) !== undefined;
+        }
+        current = getSandboxPrototype(current, context.budget);
+        if (current !== null) {
+            context.budget.visitNode();
+            assertSandboxDataDepth(++depth);
+        }
+    }
+    return false;
+}
 async function applyCompoundAssignmentOperator(operator, left, right, context) {
     left = await toNumericPrimitive(left, context);
     right = await toNumericPrimitive(right, context);

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

@@ -1131,9 +1131,9 @@ class Parser {
             };
         }
         const token = this.currentToken();
-        if (token.type === "identifier") {
+        if (token.type === "identifier" || token.type === "keyword") {
             this.index += 1;
-            const key = createIdentifier(token);
+            const key = createIdentifierName(token);
             if (this.consumePunctuator(":") !== undefined) {
                 const value = this.parseBindingElement();
                 if (value.type === "RestElement") {
@@ -1148,6 +1148,8 @@ class Parser {
                     span: createSpan(key.span.start, value.span.end)
                 };
             }
+            if (!isIdentifierLikeToken(token))
+                throw unexpectedTokenError(token);
             let value = key;
             if (this.consumePunctuator("=") !== undefined) {
                 const right = this.parseExpression().node;
@@ -1357,9 +1359,9 @@ class Parser {
             };
         }
         const token = this.currentToken();
-        if (token.type === "identifier") {
+        if (token.type === "identifier" || token.type === "keyword") {
             this.index += 1;
-            const key = createIdentifier(token);
+            const key = createIdentifierName(token);
             if (this.consumePunctuator(":") !== undefined) {
                 const value = this.parseAssignmentPatternElement();
                 if (value.type === "RestElement") {
@@ -1374,6 +1376,8 @@ class Parser {
                     span: createSpan(key.span.start, value.span.end)
                 };
             }
+            if (!isIdentifierLikeToken(token))
+                throw unexpectedTokenError(token);
             let value = key;
             if (this.consumePunctuator("=") !== undefined) {
                 const right = this.parseAssignmentExpression().node;
@@ -2027,12 +2031,9 @@ class Parser {
             };
         }
         const token = this.currentToken();
-        if (isIdentifierLikeToken(token) ||
-            (token.type === "keyword" &&
-                this.peekToken(1).type === "punctuator" &&
-                this.peekToken(1).value === "(")) {
+        if (token.type === "identifier" || token.type === "keyword") {
             this.index += 1;
-            const key = createIdentifier(token);
+            const key = createIdentifierName(token);
             if (this.currentToken().type === "punctuator" && this.currentToken().value === "(") {
                 const value = this.parseObjectMethod(asyncToken, key.span.start);
                 return {
@@ -2045,6 +2046,8 @@ class Parser {
                 };
             }
             if (this.consumePunctuator(":") === undefined) {
+                if (!isIdentifierLikeToken(token))
+                    throw unexpectedTokenError(token);
                 assertAllowedIdentifierReference(token);
                 return {
                     type: "Property",
@@ -3484,14 +3487,7 @@ function rebasePosition(position, base) {
     };
 }
 function isLiteralPropertyKey(token) {
-    if (token.type === "numeric" || token.type === "string") {
-        return true;
-    }
-    return (token.type === "keyword" &&
-        (token.value === "true" ||
-            token.value === "false" ||
-            token.value === "null" ||
-            token.value === "undefined"));
+    return token.type === "numeric" || token.type === "string";
 }
 function isIdentifierLikeToken(token) {
     return token.type === "identifier" || (token.type === "keyword" && token.value === "async");

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

@@ -1,4 +1,5 @@
 import { Budget, SandboxError } from "../interp/budget.js";
+import { executeAsyncFunction } from "../interp/async.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { decodeFloat32Storage } from "./float32array.js";
 import { restoreDateTime } from "../interp/date.js";
@@ -429,7 +430,8 @@ function restoreClosureValue(astNodeId, capturedScopeId, state) {
         throw new Error(`Snapshot references unknown closure AST node ${astNodeId}.`);
     }
     const baseClosure = createSandboxClosure({
-        async: true,
+        async: node.async,
+        sandbox: true,
         length: getFunctionLength(node.params),
         ...(node.type === "ArrowFunctionExpression" || node.id === undefined ? {} : { name: node.id.name }),
         ...(node.type !== "ArrowFunctionExpression" &&
@@ -437,18 +439,23 @@ function restoreClosureValue(astNodeId, capturedScopeId, state) {
             !node.generator &&
             !node.async
             ? {
-                construct: async (args) => {
+                construct: async (args, callContext) => {
                     const thisValue = {};
                     const prototype = getGuestFunctionProperty(restoredClosure, "prototype");
                     if (typeof prototype === "object" && prototype !== null) {
                         setSandboxPrototype(thisValue, prototype, state.budget);
                     }
-                    const result = await executeRestoredClosure(node, capturedScopeId, restoredClosure, args, thisValue, state);
+                    const result = await executeRestoredClosure(node, capturedScopeId, restoredClosure, args, thisValue, state, callContext);
                     return typeof result === "object" && result !== null ? result : thisValue;
                 }
             }
             : {}),
-        call: (args, callContext) => createSandboxPromise(executeRestoredClosure(node, capturedScopeId, restoredClosure, args, callContext?.thisValue, state))
+        call: (args, callContext) => {
+            if (node.async) {
+                return executeAsyncFunction((onSuspend) => executeRestoredClosure(node, capturedScopeId, restoredClosure, args, callContext?.thisValue, state, callContext, onSuspend), state.budget);
+            }
+            return executeRestoredClosure(node, capturedScopeId, restoredClosure, args, callContext?.thisValue, state, callContext);
+        }
     });
     const restoredClosure = Object.defineProperties(Object.create(baseClosure), {
         astNodeId: {
@@ -468,9 +475,10 @@ function restoreClosureValue(astNodeId, capturedScopeId, state) {
     Object.defineProperty(restoredClosure, "properties", { get: () => getGuestFunctionProperties(restoredClosure) });
     return restoredClosure;
 }
-async function executeRestoredClosure(node, capturedScopeId, closure, args, thisValue, state) {
-    const operation = state.budget.acquireCompileOwner(false, state.compilation.owner);
-    const compilation = new CompileScope(operation.owner);
+async function executeRestoredClosure(node, capturedScopeId, closure, args, thisValue, state, callContext, onSuspend) {
+    const parent = callContext?.compilation ?? state.compilation;
+    const operation = state.budget.acquireCompileOwner(false, parent.owner);
+    const compilation = new CompileScope(operation.owner, parent);
     state = { ...state, compilation };
     try {
         const capturedScope = state.scopeById.get(capturedScopeId) ?? restoreParentScope(capturedScopeId, state);
@@ -499,6 +507,7 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
                             budget: state.budget,
                             compilation,
                             scope,
+                            nested: true,
                             useScopeDirectly: true
                         });
                         return result.ok
@@ -528,6 +537,7 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
                         budget: state.budget,
                         compilation,
                         scope,
+                        nested: true,
                         useScopeDirectly: true
                     });
                     return result.ok
@@ -551,12 +561,14 @@ async function executeRestoredClosure(node, capturedScopeId, closure, args, this
         const result = await interpret(node.body, {
             budget: state.budget,
             compilation,
+            nested: true,
+            onSuspend,
             scope
         });
         if (!result.ok) {
             throw new Error(result.error.message);
         }
-        reconcileCompiledValues(state.budget, [...scope.retainedValues(), ...state.budget.retainedValues(), result.returnValue], compilation);
+        reconcileCompiledValues(state.budget, [...scope.retainedValues(), ...state.budget.retainedValues(), result.returnValue], compilation, parent, [result.returnValue]);
         return result.returnValue;
     }
     finally {