poe-code 14.0.38 → 14.0.40

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

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-CSC4EXIV.js";
+} from "./chunk-GO774BRE.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-QXSG4XRW.js.map
+//# sourceMappingURL=chunk-LGJLTEI5.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-LGJLTEI5.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-CSC4EXIV.js";
+} from "./chunks/chunk-GO774BRE.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-GO774BRE.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-LGJLTEI5.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-CSC4EXIV.js";
+} from "./chunks/chunk-GO774BRE.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

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";
@@ -437,13 +438,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 +2120,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");