poe-code 5.0.4 → 6.0.0

package/packages/safejs/dist/interp/values.d.ts

@@ -52,6 +52,9 @@ export type SandboxCallContext = {
 };
 export type SandboxClosure = {
     readonly async?: true;
+    readonly sandbox?: true;
+    readonly boundTarget?: SandboxClosure;
+    readonly cancellationSignal?: AbortSignal;
     readonly kind: "fn";
     readonly name?: string;
     readonly properties?: SandboxObject;
@@ -82,6 +85,9 @@ type CopyFromSandboxOptions = {
 };
 export declare function createSandboxClosure(input: {
     async?: boolean;
+    sandbox?: boolean;
+    boundTarget?: SandboxClosure;
+    cancellationSignal?: AbortSignal;
     call: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
     construct?: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
     name?: string;

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

@@ -2,6 +2,7 @@ import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
 import { SandboxError } from "./budget.js";
 import { observeSandboxPromise, trackSandboxPromise } from "./promise-tracker.js";
 import { promiseReplayContext } from "./promise-replay.js";
+import { invokeCancelableClosure, readPromiseCancellation, registerPromiseCancellation } from "./cancel.js";
 import { parseRegex } from "./regex/parse.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { copySandboxArgumentProperties, createSandboxArguments, getSandboxArgumentEntries, isSandboxArguments } from "./arguments.js";
@@ -17,15 +18,30 @@ const sandboxRetainedValues = Symbol("SandboxRetainedValues");
 export function createSandboxClosure(input) {
     const closure = {
         kind: "fn",
-        call: input.call,
+        call: (args, context) => invokeCancelableClosure(closure, input.call, args, context),
         name: input.name,
-        ...(input.construct === undefined ? {} : { construct: input.construct }),
+        ...(input.construct === undefined
+            ? {}
+            : {
+                construct: (args, context) => invokeCancelableClosure(closure, input.construct, args, context, true)
+            }),
         ...(input.async === true ? { async: true } : {})
     };
     Object.defineProperty(closure, sandboxClosureBrand, {
         enumerable: false,
         value: true
     });
+    if (input.sandbox === true) {
+        Object.defineProperty(closure, "sandbox", { value: true });
+    }
+    if (input.boundTarget !== undefined) {
+        Object.defineProperty(closure, "boundTarget", { value: input.boundTarget });
+    }
+    if (input.cancellationSignal !== undefined) {
+        Object.defineProperty(closure, "cancellationSignal", {
+            value: input.cancellationSignal
+        });
+    }
     if (input.properties !== undefined) {
         Object.defineProperty(closure, "properties", {
             enumerable: false,
@@ -40,11 +56,14 @@ export function createSandboxClosure(input) {
     return Object.freeze(closure);
 }
 export function createSandboxPromise(promise, metadata = {}) {
+    const original = metadata.trackReplay === false
+        ? promise
+        : (promiseReplayContext.getStore()?.track(promise) ?? promise);
     const sandboxPromise = {
         kind: "promise",
-        promise: metadata.trackReplay === false
-            ? promise
-            : (promiseReplayContext.getStore()?.track(promise) ?? promise)
+        get promise() {
+            return readPromiseCancellation(sandboxPromise, original);
+        }
     };
     Object.defineProperty(sandboxPromise, sandboxPromiseBrand, {
         enumerable: false,
@@ -70,6 +89,7 @@ export function createSandboxPromise(promise, metadata = {}) {
         });
     }
     trackSandboxPromise(sandboxPromise);
+    registerPromiseCancellation(sandboxPromise);
     return Object.freeze(sandboxPromise);
 }
 export function createSandboxGenerator(channel, metadata = undefined) {

package/packages/safejs/dist/lint/rules/AS001.js

@@ -220,11 +220,6 @@ class AS001Scanner {
             case "with":
                 this.report(token.value, token.start, token.end);
                 return;
-            case "new":
-                if (!this.source.slice(this.skipTriviaFrom(token.end.offset)).startsWith("RegExp")) {
-                    this.report(token.value, token.start, token.end);
-                }
-                return;
             default:
                 return;
         }

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-v1";
+export declare const EXECUTION_SEMANTICS = "jobs-v2";
 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-v1";
+export const EXECUTION_SEMANTICS = "jobs-v2";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";
 import { serializeArguments } from "./arguments.js";

package/packages/safejs/dist/snapshot/replay-data.js

@@ -180,6 +180,9 @@ export function decodeReplayData(input, options = {}) {
             }
             return createSandboxClosure({
                 ...capability,
+                boundTarget: capability.boundTarget,
+                cancellationSignal: capability.cancellationSignal,
+                sandbox: capability.sandbox,
                 retainedValues: () => [capability],
                 properties: (closure) => {
                     restored.set(id, closure);