poe-code 10.0.4 → 11.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "10.0.4",
+  "version": "11.0.1",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",
@@ -57,7 +57,7 @@
     "codegen:python-types": "tsx scripts/generate-agent-spawn-py-types.ts",
     "codegen:check:python-types": "tsx scripts/generate-agent-spawn-py-types.ts --check",
     "install:py-poe-spawn": "pip install -e packages/py-poe-spawn",
-    "predev": "turbo run build --output-logs=errors-only --log-prefix=none --verbosity=0",
+    "predev": "turbo run build --output-logs=errors-only --log-prefix=none --verbosity=0 && node scripts/bundle.mjs",
     "dev": "tsx --import ./scripts/register-template-loader.mjs src/index.ts",
     "start": "node dist/bin.cjs",
     "dev:bundle": "npm run build && node dist/bin.cjs",

package/packages/safejs/dist/chunks/{chunk-SA7XBTIL.js → chunk-ARFGEQTM.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-JLYBD3E6.js";
+} from "./chunk-DKXGPEOM.js";
 
 // packages/safejs/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8048,4 +8048,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-SA7XBTIL.js.map
+//# sourceMappingURL=chunk-ARFGEQTM.js.map

package/packages/safejs/dist/chunks/{chunk-JLYBD3E6.js → chunk-DKXGPEOM.js}

@@ -16919,7 +16919,7 @@ function serializeArguments(value, serializeValue) {
 
 // packages/safejs/src/snapshot/dump-format.ts
 var DUMP_FORMAT_VERSION = 1;
-var EXECUTION_SEMANTICS = "jobs-v5";
+var EXECUTION_SEMANTICS = "jobs-v6";
 var SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
 function serializeSafeJSSnapshot(snapshot) {
   const replayError = Object.getOwnPropertyDescriptor(snapshot, "replayError");
@@ -17413,9 +17413,6 @@ function validateGenericValue(value, path, depth, state) {
   if (typeof value === "string") {
     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");
     if (state.dataPropertiesOnly) {
@@ -21215,9 +21212,9 @@ function shouldIncludeTemplateRaw(record2, key, includeTemplateRaw) {
 
 // packages/safejs/src/snapshot/migration.ts
 function validateMigrationSemantics(value) {
-  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5"].includes(value))
+  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-v5)."
+      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v6)."
     );
 }
 function validateMigrationJournal(sourceHash, replay, hostCalls = []) {
@@ -25423,15 +25420,15 @@ var Scope = 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 === void 0) {
       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
@@ -25951,39 +25948,37 @@ async function evaluateAssignmentExpression(node, context) {
       )
     };
   }
-  const binding = context.scope.lookup(node.left.name);
-  if (!binding.found) {
+  const binding = node.operator === "=" ? void 0 : 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 !== void 0) {
+  if (node.operator === "??=" && current !== null && current !== void 0) {
     return {
       kind: "normal",
       hasValue: true,
-      value: binding.value
+      value: current
     };
   }
   const right = await evaluateNode(node.right, context);
   if (right.kind !== "normal") {
     return right;
   }
-  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : applyCompoundAssignmentOperator(node.operator, binding.value, right.value, context);
+  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
   context.scope.assign(node.left.name, value);
   return {
     kind: "normal",
@@ -26005,45 +26000,33 @@ 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 right2 = await evaluateNode(node.right, context);
-    if (right2.kind !== "normal") return right2;
-    setRegexMember(member.object, member.property, right2.value);
-    return { kind: "normal", hasValue: true, value: right2.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 === "=" ? void 0 : 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) !== void 0) {
+  if (node.operator === "??=" && current !== null && current !== void 0) {
     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);
+  const value = node.operator === "=" || node.operator === "&&=" || node.operator === "||=" || node.operator === "??=" ? right.value : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
   setSandboxProperty(member.object, member.property, value);
   return {
     kind: "normal",
@@ -27010,10 +26993,7 @@ async function evaluateIdentifierUpdateExpression(node, context) {
       )
     };
   }
-  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 {
@@ -27036,10 +27016,9 @@ 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 {
@@ -27050,94 +27029,33 @@ async function evaluateMemberUpdateExpression(node, context) {
 }
 async function evaluateMemberExpression(node, context) {
   const member = await evaluateMemberAccess(node, context);
-  if (member.kind === "error") {
-    return member;
-  }
-  if (member.kind === "completion") {
-    return member.result;
-  }
+  if (member.kind === "error") return member;
+  if (member.kind === "completion") return member.result;
   if (member.kind === "nullish") {
-    if (node.optional) {
-      return {
-        kind: "normal",
-        hasValue: true,
-        value: void 0
-      };
-    }
+    if (node.optional) return { kind: "normal", hasValue: true, value: void 0 };
     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 void 0;
+  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();
@@ -27613,7 +27531,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);
@@ -27740,6 +27660,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 === void 0 && !Object.hasOwn(value, methodName)) {
+        return toString(value);
+      }
       if (!isSandboxClosure(method)) {
         continue;
       }
@@ -27755,6 +27678,7 @@ async function toNumericPrimitive(value, context) {
         return result;
       }
     }
+    throw new TypeError("Cannot convert object to primitive value.");
   }
   return toString(value);
 }
@@ -27809,17 +27733,30 @@ 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" || isArrayIndexKey3(key)) {
       target[key] = value;
       return;
     }
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(target, key);
+  if (descriptor !== void 0) {
+    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)) {
@@ -28939,4 +28876,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-JLYBD3E6.js.map
+//# sourceMappingURL=chunk-DKXGPEOM.js.map