@poe-platform/safe-js 0.1.724 → 0.1.726

package/README.md

@@ -53,6 +53,18 @@ console.log(result.returnValue);
 
 Scripts have no ambient `process`, `require`, `fetch`, or filesystem access. Host functions still execute with the host's privileges. Register only the capabilities the script needs; this is not OS or process isolation.
 
+`new Promise(executor)` is supported, as are the Promise static helpers and
+`then`, `catch`, and `finally`. The executor runs synchronously with `resolve`
+and `reject`; its return value is ignored, thrown errors reject the promise,
+and the first resolve or reject call wins. Resolving adopts promises and
+thenables; resolving a promise with itself rejects with a `TypeError`.
+Executor work uses the interpreter's existing budgets, and budget exhaustion
+remains fatal even after settlement. For example,
+`await run("return await new Promise(resolve => resolve(42));")` returns a
+successful result with `returnValue: 42`. Browser event and timer adapters
+require the host to grant those capabilities; Promise construction does not
+provide ambient browser APIs.
+
 ```js
 const result = await run(`
   function Counter(value) { this.value = value; }
@@ -324,6 +336,7 @@ Supply your own bounded `journal`; this does not add browser console behavior. W
 | `invokeCallback(callback, { thisValue?, args? })` | Invoke a captured guest function with the realm's state, cancellation and budgets. Same operation as on the realm. |
 | `startCallback(callback, { thisValue?, args? })` | Return separate `synchronous` and `result` promises for the same realm-owned invocation. Also available on the realm. |
 | `releaseCallback(callback)` | Revoke the callback and release its retained guest state. |
+| `retainCallbackArguments(operation)` | During setup, give each call independent callback wrappers in its copied arguments. Requires declared and granted `guest:retain`. The host owns these wrappers and releases each with `releaseCallback`; aliases within one call still share a wrapper. |
 | `retainGuestArguments(operation, from)` | During setup, opt an operation into opaque argument references starting at the zero-based index `from`. Requires declared and granted `guest:retain`. Earlier arguments keep normal conversion; live host methods preserve the declaration. |
 | `releaseGuestReference(reference)` | Revoke one reference and release its retained state. Also available on the realm. |
 | `nestedOperation(fn)` | During setup, mark a host operation authorized to run nested source. Requires declared and granted `source:nested`. |
@@ -333,6 +346,8 @@ Use `expandos: { maxKeys, maxKeyCodeUnits, assertActive? }` to allow guest assig
 
 For a timer-shaped `schedule(callback, delay, ...args)`, register `context.retainGuestArguments(schedule, 2)`. The host receives normal callback/delay values and opaque `GuestReference` handles for the remaining arguments. Pass those handles to `context.invokeCallback(callback, { args })` to recover the original guest objects and observe mutations made after scheduling. References also work as callback receivers and host return values, including cycles, closures, primitives and live host objects.
 
+Also register `context.retainCallbackArguments(schedule)` when each scheduled task owns its callback. Different calls then receive independently releasable wrappers, even for the same guest function; normal exports keep their shared callback identity. Release a timer's wrapper after cancellation or after all its invocation phases settle. Copied callbacks count against `limits.callbacks` and data budgets. Argument-copy failure or synchronous host failure revokes that call's owned wrappers; asynchronous operations must release theirs in host cleanup. Returning a wrapper to guest code preserves the original function identity and does not release it.
+
 For a trusted native buffer such as WebAssembly memory, use `context.createArrayBufferReference(buffer)` and return the handle from a host property or operation. Guest ArrayBuffer views then share its bytes with the host, preserving identity and bidirectional writes. Ordinary host buffers still copy. Shared, resizable, detached, subclassed and proxy buffers reject, as do buffers with own properties or symbols. After native memory growth detaches the old buffer, create a new reference to the new buffer; the old reference continues to denote the detached buffer.
 
 Release each reference when the host no longer needs it; returning it does not release it. Retained graphs count against data budgets and `limits.guestReferences`. Synchronous native failure releases references captured for that call; asynchronous operations must release theirs in host cleanup. Close revokes all remaining references. Handles cannot be inspected, used in another realm, or serialized into replay/error data. Unmarked operations still copy values.

package/dist/safe-js/chunks/{chunk-ZHJPXLUJ.js → chunk-4VWGTW5F.js}

@@ -39,7 +39,7 @@ import {
   sandboxErrorTypes,
   syntaxDiagnostics,
   templateRealms
-} from "./chunk-KOO6YGQG.js";
+} from "./chunk-T2HKPVB3.js";
 
 // packages/safe-js/src/interp/native-promise-properties.ts
 import { types } from "node:util";
@@ -6440,11 +6440,30 @@ async function evaluateFunctionExpression(node, context, evaluateNode2) {
     value: closure
   };
 }
+var captureContextHasOwn = Object.hasOwn;
+function createOwnedCaptureCollector(scope, sourceReference, environment, constructionState) {
+  return (append) => {
+    visitScopeDataRoots(scope, append);
+    append(sourceReference);
+    append(environment?.homeObject);
+    append(environment?.newTarget);
+    if (constructionState !== void 0) {
+      append(constructionState.constructor);
+      append(constructionState.newTarget);
+      append(constructionState.prototype);
+      append(constructionState.thisValue);
+      if (constructionState.thisScope !== void 0)
+        visitScopeDataRoots(constructionState.thisScope, append);
+    }
+  };
+}
 function createInterpretedClosure(node, context, evaluateNode2, homeObject, initializeGeneratorPrototype = true) {
+  let ownsCaptureContext = false;
   if (context.callee !== void 0 || context.evalCompletion)
     context = { ...context, callee: void 0, evalCompletion: void 0 };
   if (node.type !== "ArrowFunctionExpression") {
     context = { ...context, functionEnvironment: { homeObject } };
+    ownsCaptureContext = true;
   }
   if (node.type !== "ArrowFunctionExpression" && node.generator) {
     return createGeneratorClosure(node, context, evaluateNode2, initializeGeneratorPrototype);
@@ -6560,10 +6579,13 @@ function createInterpretedClosure(node, context, evaluateNode2, homeObject, init
       }, context.budget, callContext, context.signal);
     }
   });
-  registerIndexedClosureCaptures(closure, (append) => {
-    visitScopeDataRoots(context.scope, append);
-    appendCapturedValues(append);
-  });
+  registerIndexedClosureCaptures(
+    closure,
+    ownsCaptureContext && captureContextHasOwn(context, "scope") && captureContextHasOwn(context, "sourceReference") && captureContextHasOwn(context, "functionEnvironment") ? createOwnedCaptureCollector(context.scope, context.sourceReference, context.functionEnvironment, constructionState) : (append) => {
+      visitScopeDataRoots(context.scope, append);
+      appendCapturedValues(append);
+    }
+  );
   registerClosureOrigin(closure, node, context);
   return closure;
 }
@@ -21993,19 +22015,19 @@ function wrapCallerInjectedFunction(name, value, options, state) {
           restored: []
         };
         const exportedSharedArguments = [];
-        const copyArguments = (values) => deepCopyFromSandbox([...values], {
+        const copyArguments = (values, wrapClosure) => deepCopyFromSandbox([...values], {
           compilation,
           onSharedBuffer: (value2) => {
             exportedSharedArguments.push(value2);
           },
           unwrapHostObject: options.realm === void 0 ? void 0 : (object) => exportHostCapability(object, options.realm.owner),
-          wrapClosure: (closure) => options.realm?.wrapCallback(closure) ?? wrapSandboxClosureForHost(
+          wrapClosure: wrapClosure ?? ((closure) => options.realm?.wrapCallback(closure) ?? wrapSandboxClosureForHost(
             closure,
             stackFrames,
             options.budget,
             operationLease.owner,
             callbacks
-          )
+          ))
         });
         const captured = options.realm?.captureArguments(callable, args, copyArguments);
         const hostArgs = captured?.args ?? copyArguments(args);
@@ -46493,11 +46515,35 @@ function measureSandboxDataWithSeen(values, options, seen, retainCode = false) {
   let secondSeenCapture;
   let thirdSeenCapture;
   let fourthSeenCapture;
+  let fifthSeenCapture;
+  let sixthSeenCapture;
+  let seventhSeenCapture;
+  let eighthSeenCapture;
+  let ninthSeenCapture;
+  let tenthSeenCapture;
+  let eleventhSeenCapture;
+  let twelfthSeenCapture;
+  let thirteenthSeenCapture;
+  let fourteenthSeenCapture;
+  let fifteenthSeenCapture;
+  let sixteenthSeenCapture;
   const appendNativeCapture = (value) => {
     if (value === void 0) return;
     if (typeof value === "object" && value !== null) {
-      if (value === firstSeenCapture || value === secondSeenCapture || value === thirdSeenCapture || value === fourthSeenCapture) return;
+      if (value === firstSeenCapture || value === secondSeenCapture || value === thirdSeenCapture || value === fourthSeenCapture || value === fifthSeenCapture || value === sixthSeenCapture || value === seventhSeenCapture || value === eighthSeenCapture || value === ninthSeenCapture || value === tenthSeenCapture || value === eleventhSeenCapture || value === twelfthSeenCapture || value === thirteenthSeenCapture || value === fourteenthSeenCapture || value === fifteenthSeenCapture || value === sixteenthSeenCapture) return;
       if (seen.has(value)) {
+        sixteenthSeenCapture = fifteenthSeenCapture;
+        fifteenthSeenCapture = fourteenthSeenCapture;
+        fourteenthSeenCapture = thirteenthSeenCapture;
+        thirteenthSeenCapture = twelfthSeenCapture;
+        twelfthSeenCapture = eleventhSeenCapture;
+        eleventhSeenCapture = tenthSeenCapture;
+        tenthSeenCapture = ninthSeenCapture;
+        ninthSeenCapture = eighthSeenCapture;
+        eighthSeenCapture = seventhSeenCapture;
+        seventhSeenCapture = sixthSeenCapture;
+        sixthSeenCapture = fifthSeenCapture;
+        fifthSeenCapture = fourthSeenCapture;
         fourthSeenCapture = thirdSeenCapture;
         thirdSeenCapture = secondSeenCapture;
         secondSeenCapture = firstSeenCapture;
@@ -47300,6 +47346,18 @@ function measureSandboxDataWithSeen(values, options, seen, retainCode = false) {
     secondSeenCapture = void 0;
     thirdSeenCapture = void 0;
     fourthSeenCapture = void 0;
+    fifthSeenCapture = void 0;
+    sixthSeenCapture = void 0;
+    seventhSeenCapture = void 0;
+    eighthSeenCapture = void 0;
+    ninthSeenCapture = void 0;
+    tenthSeenCapture = void 0;
+    eleventhSeenCapture = void 0;
+    twelfthSeenCapture = void 0;
+    thirteenthSeenCapture = void 0;
+    fourteenthSeenCapture = void 0;
+    fifteenthSeenCapture = void 0;
+    sixteenthSeenCapture = void 0;
     while (pendingCount > 0) {
       const frame = pending[--pendingCount];
       if (frame.capture !== void 0) releaseCaptures(frame.capture);
@@ -48603,7 +48661,7 @@ function materializeFunctionProperties(closure, initialProperties) {
     name: { value: closure.name ?? "", configurable: true }
   });
   if (isGuestClosure(closure) && closure.construct !== void 0 && closure.boundTarget === void 0) {
-    const prototype = nativePropertyCreate(null);
+    const prototype = createIntrinsicObject();
     nativePropertyDefineOne(prototype, "constructor", {
       value: closure,
       writable: true,
@@ -49280,4 +49338,4 @@ authorization of the copyright holder.
 SPDX-License-Identifier: Unicode-3.0
 
 */
-//# sourceMappingURL=chunk-ZHJPXLUJ.js.map
+//# sourceMappingURL=chunk-4VWGTW5F.js.map