poe-code 10.0.4 → 11.0.1

package/packages/safejs/dist/cli.js

@@ -19,7 +19,7 @@ import {
   parseMcpConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-SA7XBTIL.js";
+} from "./chunks/chunk-ARFGEQTM.js";
 import {
   Budget,
   SandboxError,
@@ -31,7 +31,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-JLYBD3E6.js";
+} from "./chunks/chunk-DKXGPEOM.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-JLYBD3E6.js";
+} from "./chunks/chunk-DKXGPEOM.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safejs/dist/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-SA7XBTIL.js";
+} from "./chunks/chunk-ARFGEQTM.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -48,7 +48,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-JLYBD3E6.js";
+} from "./chunks/chunk-DKXGPEOM.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/runner/run-harness.ts

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

@@ -422,32 +422,30 @@ async function evaluateAssignmentExpression(node, context) {
             error: createError("UNSUPPORTED_NODE", node, `Unsupported assignment target '${node.left.type}'.`)
         };
     }
-    const binding = context.scope.lookup(node.left.name);
-    if (!binding.found) {
+    const binding = node.operator === "=" ? undefined : context.scope.lookup(node.left.name);
+    if (binding?.found === false) {
         throw new ReferenceError(`Cannot assign to undeclared binding '${node.left.name}'.`);
     }
-    if (binding.kind === "const") {
-        throw new TypeError(`Cannot assign to const '${node.left.name}'`);
-    }
-    if (node.operator === "&&=" && !isTruthy(binding.value)) {
+    const current = binding?.value;
+    if (node.operator === "&&=" && !isTruthy(current)) {
         return {
             kind: "normal",
             hasValue: true,
-            value: binding.value
+            value: current
         };
     }
-    if (node.operator === "||=" && isTruthy(binding.value)) {
+    if (node.operator === "||=" && isTruthy(current)) {
         return {
             kind: "normal",
             hasValue: true,
-            value: binding.value
+            value: current
         };
     }
-    if (node.operator === "??=" && binding.value !== null && binding.value !== undefined) {
+    if (node.operator === "??=" && current !== null && current !== undefined) {
         return {
             kind: "normal",
             hasValue: true,
-            value: binding.value
+            value: current
         };
     }
     const right = await evaluateNode(node.right, context);
@@ -459,7 +457,7 @@ async function evaluateAssignmentExpression(node, context) {
         node.operator === "||=" ||
         node.operator === "??="
         ? right.value
-        : applyCompoundAssignmentOperator(node.operator, binding.value, right.value, context);
+        : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
     context.scope.assign(node.left.name, value);
     return {
         kind: "normal",
@@ -481,55 +479,38 @@ async function evaluateMemberAssignmentExpression(node, context) {
     if (member.kind === "nullish") {
         throw new TypeError("Cannot assign properties of null or undefined.");
     }
-    if (isSandboxRegex(member.object)) {
-        if (node.operator !== "=") {
-            throw new TypeError("RegExp properties only support direct assignment.");
-        }
-        const right = await evaluateNode(node.right, context);
-        if (right.kind !== "normal")
-            return right;
-        setRegexMember(member.object, member.property, right.value);
-        return { kind: "normal", hasValue: true, value: right.value };
-    }
-    if (!isIndexableSandboxValue(member.object)) {
-        throw new TypeError("Assignment expressions require a sandbox object property.");
-    }
-    if (node.operator === "&&=" &&
-        !isTruthy(getMemberValue(member.object, member.property, context))) {
+    const current = node.operator === "=" ? undefined : getPropertyValue(member.object, member.property, context);
+    if (node.operator === "&&=" && !isTruthy(current)) {
         return {
             kind: "normal",
             hasValue: true,
-            value: getMemberValue(member.object, member.property, context)
+            value: current
         };
     }
-    if (node.operator === "||=" &&
-        isTruthy(getMemberValue(member.object, member.property, context))) {
+    if (node.operator === "||=" && isTruthy(current)) {
         return {
             kind: "normal",
             hasValue: true,
-            value: getMemberValue(member.object, member.property, context)
+            value: current
         };
     }
-    if (node.operator === "??=" &&
-        getMemberValue(member.object, member.property, context) !== null &&
-        getMemberValue(member.object, member.property, context) !== undefined) {
+    if (node.operator === "??=" && current !== null && current !== undefined) {
         return {
             kind: "normal",
             hasValue: true,
-            value: getMemberValue(member.object, member.property, context)
+            value: current
         };
     }
     const right = await evaluateNode(node.right, context);
     if (right.kind !== "normal") {
         return right;
     }
-    const current = getMemberValue(member.object, member.property, context);
     const value = node.operator === "=" ||
         node.operator === "&&=" ||
         node.operator === "||=" ||
         node.operator === "??="
         ? right.value
-        : applyCompoundAssignmentOperator(node.operator, current, right.value, context);
+        : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
     setSandboxProperty(member.object, member.property, value);
     return {
         kind: "normal",
@@ -1493,10 +1474,7 @@ async function evaluateIdentifierUpdateExpression(node, context) {
             error: createError("UNBOUND_IDENTIFIER", node.argument, `Identifier '${node.argument.name}' is not defined.`)
         };
     }
-    if (binding.kind === "const") {
-        throw new TypeError(`Cannot assign to const '${node.argument.name}'`);
-    }
-    const current = Number(binding.value);
+    const current = toNumber(await toNumericPrimitive(binding.value, context));
     const next = node.operator === "++" ? current + 1 : current - 1;
     context.scope.assign(node.argument.name, next);
     return {
@@ -1519,10 +1497,7 @@ async function evaluateMemberUpdateExpression(node, context) {
     if (member.kind === "nullish") {
         throw new TypeError("Cannot update properties of null or undefined.");
     }
-    if (!isIndexableSandboxValue(member.object)) {
-        throw new TypeError("Update expressions require a sandbox object property.");
-    }
-    const current = Number(getMemberValue(member.object, member.property, context));
+    const current = toNumber(await toNumericPrimitive(getPropertyValue(member.object, member.property, context), context));
     const next = node.operator === "++" ? current + 1 : current - 1;
     setSandboxProperty(member.object, member.property, next);
     return {
@@ -1533,94 +1508,45 @@ async function evaluateMemberUpdateExpression(node, context) {
 }
 async function evaluateMemberExpression(node, context) {
     const member = await evaluateMemberAccess(node, context);
-    if (member.kind === "error") {
+    if (member.kind === "error")
         return member;
-    }
-    if (member.kind === "completion") {
+    if (member.kind === "completion")
         return member.result;
-    }
     if (member.kind === "nullish") {
-        if (node.optional) {
-            return {
-                kind: "normal",
-                hasValue: true,
-                value: undefined
-            };
-        }
+        if (node.optional)
+            return { kind: "normal", hasValue: true, value: undefined };
         throw new TypeError("Cannot read properties of null or undefined.");
     }
-    if (typeof member.object === "string") {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getStringMember(member.object, member.property, context.budget)
-        };
-    }
-    if (typeof member.object === "number") {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getNumberMember(member.object, member.property, context.budget)
-        };
-    }
-    if (Array.isArray(member.object)) {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getArrayMemberValue(member.object, member.property, context)
-        };
-    }
-    if (isSandboxMap(member.object)) {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getMapMember(member.object, member.property, createMapMethodOptions(context))
-        };
-    }
-    if (isSandboxSet(member.object)) {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getSetMember(member.object, member.property, createSetMethodOptions(context))
-        };
-    }
-    if (isSandboxGenerator(member.object)) {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getGeneratorMember(member.object, member.property, context.budget)
-        };
-    }
-    if (isSandboxClosure(member.object)) {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getClosureMemberValue(member.object, member.property, context)
-        };
-    }
-    if (isSandboxPromise(member.object)) {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getPromiseMember(member.property, context.budget)
-        };
-    }
-    if (isSandboxRegex(member.object)) {
-        return {
-            kind: "normal",
-            hasValue: true,
-            value: getRegexMember(member.object, member.property)
-        };
-    }
-    if (!isIndexableSandboxValue(member.object)) {
-        throw new TypeError("Attempted to read a property from a non-object value.");
-    }
     return {
         kind: "normal",
         hasValue: true,
-        value: getMemberValue(member.object, member.property, context)
+        value: getPropertyValue(member.object, member.property, context)
     };
 }
+function getPropertyValue(target, property, context) {
+    if (typeof target === "string")
+        return getStringMember(target, property, context.budget);
+    if (typeof target === "number")
+        return getNumberMember(target, property, context.budget);
+    if (typeof target === "boolean")
+        return undefined;
+    if (isSandboxMap(target))
+        return getMapMember(target, property, createMapMethodOptions(context));
+    if (isSandboxSet(target))
+        return getSetMember(target, property, createSetMethodOptions(context));
+    if (isSandboxGenerator(target))
+        return getGeneratorMember(target, property, context.budget);
+    if (isSandboxClosure(target))
+        return getClosureMemberValue(target, property, context);
+    if (isSandboxPromise(target))
+        return getPromiseMember(property, context.budget);
+    if (isSandboxRegex(target))
+        return getRegexMember(target, property);
+    if (!isIndexableSandboxValue(target)) {
+        throw new TypeError("Attempted to read a property from a non-object value.");
+    }
+    return getMemberValue(target, property, context);
+}
 async function evaluateCallExpression(node, context) {
     if (node.callee.type === "MemberExpression") {
         context.budget.visitNode();
@@ -2033,7 +1959,9 @@ function applyBinaryOperator(node, left, right, context) {
             throw createError("UNSUPPORTED_NODE", node, "Binary operator 'in' is not supported.");
     }
 }
-function applyCompoundAssignmentOperator(operator, left, right, context) {
+async function applyCompoundAssignmentOperator(operator, left, right, context) {
+    left = await toNumericPrimitive(left, context);
+    right = await toNumericPrimitive(right, context);
     switch (operator) {
         case "+=":
             return applyAdditionOperator(left, right, context);
@@ -2160,6 +2088,9 @@ async function toNumericPrimitive(value, context) {
     if (isIndexableSandboxValue(value)) {
         for (const methodName of ["valueOf", "toString"]) {
             const method = getMemberValue(value, methodName, context);
+            if (methodName === "toString" && method === undefined && !Object.hasOwn(value, methodName)) {
+                return toString(value);
+            }
             if (!isSandboxClosure(method)) {
                 continue;
             }
@@ -2168,6 +2099,7 @@ async function toNumericPrimitive(value, context) {
                 return result;
             }
         }
+        throw new TypeError("Cannot convert object to primitive value.");
     }
     return toString(value);
 }
@@ -2231,17 +2163,31 @@ function getArrayMemberValue(target, property, context) {
     return getArrayMember(target, property, createArrayMethodOptions(context));
 }
 function setSandboxProperty(target, property, value) {
+    if (isSandboxRegex(target)) {
+        setRegexMember(target, property, value);
+        return;
+    }
+    if (!isIndexableSandboxValue(target)) {
+        throw new TypeError("Assignment expressions require a sandbox object property.");
+    }
+    const key = String(property);
     if (Array.isArray(target)) {
         assertCollectionMutable(target);
-        const key = String(property);
         if (key === "length" || isArrayIndexKey(key)) {
             target[key] = value;
             return;
         }
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor !== undefined) {
+        if (descriptor.writable !== true) {
+            throw new TypeError(`Cannot assign to read only property '${key}'.`);
+        }
+        Object.defineProperty(target, key, { value });
+    }
+    else {
         defineSandboxProperty(target, key, value);
-        return;
     }
-    defineSandboxProperty(target, String(property), value);
 }
 function deleteSandboxProperty(target, property) {
     if (Array.isArray(target)) {

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

@@ -126,15 +126,15 @@ export class Scope {
             throw new ReferenceError(`Cannot assign to undeclared binding '${name}'.`);
         }
         const binding = scope.#bindings.get(name);
-        if (binding?.kind === "const") {
-            throw new TypeError(`Cannot assign to const binding '${name}'.`);
-        }
         if (binding === undefined) {
             throw new ReferenceError(`Cannot assign to undeclared binding '${name}'.`);
         }
         if (binding.value === uninitialized) {
             throw new ReferenceError(`Cannot access '${name}' before initialization.`);
         }
+        if (binding.kind === "const") {
+            throw new TypeError(`Cannot assign to const binding '${name}'.`);
+        }
         scope.#bindings.set(name, {
             kind: binding.kind,
             value

package/packages/safejs/dist/snapshot/dump-format.d.ts

@@ -1,5 +1,5 @@
 export declare const DUMP_FORMAT_VERSION = 1;
-export declare const EXECUTION_SEMANTICS = "jobs-v5";
+export declare const EXECUTION_SEMANTICS = "jobs-v6";
 export type DumpableSnapshot = {
     sourceHash: string;
     [key: string]: unknown;

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

@@ -1,5 +1,5 @@
 export const DUMP_FORMAT_VERSION = 1;
-export const EXECUTION_SEMANTICS = "jobs-v5";
+export const EXECUTION_SEMANTICS = "jobs-v6";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";

package/packages/safejs/dist/snapshot/migration.js

@@ -2,8 +2,8 @@ import { HostCallJournal } from "../interp/host-call.js";
 import { decodeReplayData } from "./replay-data.js";
 import { validateSnapshotData } from "./validation.js";
 export function validateMigrationSemantics(value) {
-    if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5"].includes(value))
-        throw new TypeError("Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v5).");
+    if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6"].includes(value))
+        throw new TypeError("Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v6).");
 }
 export function validateMigrationJournal(sourceHash, replay, hostCalls = []) {
     if (replay === undefined)

package/packages/safejs/dist/snapshot/validation.js

@@ -481,10 +481,6 @@ function validateGenericValue(value, path, depth, state) {
         requireString(value, path, state.limits);
         state.dataSize += value.length;
     }
-    else if (typeof value === "number") {
-        if (Number.isInteger(value) && !Number.isSafeInteger(value))
-            fail("invalidValue", path, "integer must be safe");
-    }
     else if (Array.isArray(value)) {
         if (value.length > state.limits.maxEntries)
             fail("budgetExceeded", path, "array is too large");