poe-code 11.0.26 → 11.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "11.0.26",
+  "version": "11.0.28",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/safejs/dist/chunks/{chunk-YVBVZ7MR.js → chunk-3OFXSTL2.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-4TA6S7L6.js";
+} from "./chunk-FAAW5HF7.js";
 
 // packages/safejs/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8055,4 +8055,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-YVBVZ7MR.js.map
+//# sourceMappingURL=chunk-3OFXSTL2.js.map

package/packages/safejs/dist/chunks/{chunk-4TA6S7L6.js → chunk-FAAW5HF7.js}

@@ -20946,7 +20946,7 @@ var HostCallJournal = class {
   }
 };
 function copyOutcome(outcome) {
-  return outcome.status === "fulfilled" ? { status: "fulfilled", value: deepCopyToSandbox(outcome.value) } : { status: "rejected", reason: deepCopyToSandbox(outcome.reason) };
+  return outcome.status === "fulfilled" ? { status: "fulfilled", value: cloneSandboxValue(outcome.value) } : { status: "rejected", reason: cloneSandboxValue(outcome.reason) };
 }
 function restoreReplayCalls(input, encodedOutcomes, callbackSizes, requiredHostCapabilities = /* @__PURE__ */ new Set()) {
   validateSnapshotData(input);
@@ -22063,6 +22063,7 @@ function wrapCallerInjectedFunction(name, value, options, state) {
           entries: /* @__PURE__ */ new Map(),
           hostFunctions: /* @__PURE__ */ new Map(),
           sourceFunctions: /* @__PURE__ */ new Map(),
+          proofFunctions: /* @__PURE__ */ new WeakMap(),
           active: /* @__PURE__ */ new Set(),
           seen: /* @__PURE__ */ new WeakMap(),
           restored: []
@@ -22241,6 +22242,7 @@ function executeHostCall(record2, restored, invoke, stackFrames, options, span,
     );
   }
   if (restored && record2.policy === "read-side-effect" && record2.lifecycle !== "created") {
+    let active = true;
     const context = callbacks === void 0 ? void 0 : {
       callbacks: new Map(callbacks.hostFunctions),
       replayed: callbacks.restored.map((invocation) => ({
@@ -22249,9 +22251,23 @@ function executeHostCall(record2, restored, invoke, stackFrames, options, span,
       })),
       async waitForCallbacks() {
         while (callbacks.active.size > 0) await Promise.allSettled([...callbacks.active]);
+      },
+      toSandboxValue(value) {
+        if (!active) throw new TypeError("Host call resume context is no longer active.");
+        if (options.signal?.aborted) throw readAbortReason2(options.signal);
+        return copyHostValueToSandbox(
+          value,
+          stackFrames,
+          { ...options, proofFunctions: callbacks.proofFunctions },
+          { seen: /* @__PURE__ */ new WeakMap() },
+          "<root>"
+        );
       }
     };
-    return createHostCallPromise(record2, hostCalls.reconcile(record2, context), hostCalls);
+    const outcome2 = hostCalls.reconcile(record2, context).finally(() => {
+      active = false;
+    });
+    return createHostCallPromise(record2, outcome2, hostCalls);
   }
   if (restored && callbacks !== void 0) callbacks.nextReissuedInvocation = 0;
   hostCalls.start(record2);
@@ -22491,6 +22507,7 @@ function wrapSandboxClosureForHost(closure, stackFrames, budget, callbacks) {
   callbacks?.entries.set(id, invoke);
   callbacks?.hostFunctions.set(id, wrapped);
   callbacks?.sourceFunctions.set(id, closure);
+  callbacks?.proofFunctions.set(wrapped, closure);
   if (callbacks?.record !== void 0)
     callbacks.journal?.registerCallbackFunction(callbacks.record, id, closure, wrapped);
   return wrapped;
@@ -22569,9 +22586,17 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
     throw new TypeError("Host error data must not contain functions or promises.");
   }
   if (isSandboxClosure(value) || isSandboxPromise(value)) {
+    if (options.proofFunctions !== void 0)
+      throw new TypeError(`Unsupported proof value at ${path}: sandbox capability`);
     return deepCopyToSandbox(value);
   }
   if (typeof value === "function") {
+    if (options.proofFunctions !== void 0) {
+      const sourceClosure2 = options.proofFunctions.get(value);
+      if (sourceClosure2 === void 0)
+        throw new TypeError(`Unsupported proof value at ${path}: function`);
+      return sourceClosure2;
+    }
     const sourceClosure = options.hostCalls?.nativeClosures.get(value);
     if (sourceClosure !== void 0) return sourceClosure;
     const callable = value;
@@ -22590,6 +22615,8 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path) {
     );
   }
   if (!options.errorData && isPromiseLike3(value)) {
+    if (options.proofFunctions !== void 0)
+      throw new TypeError(`Unsupported proof value at ${path}: promise`);
     const existing = state.seen.get(value);
     if (existing !== void 0) return existing;
     const promise = wrapHostPromiseWithSignal(Promise.resolve(value), options.signal).then(
@@ -29199,4 +29226,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-4TA6S7L6.js.map
+//# sourceMappingURL=chunk-FAAW5HF7.js.map