poe-code 5.0.4 → 6.0.0

package/package.json

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

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

@@ -5,7 +5,7 @@ import { getThenable, resolveSandboxValue } from "./promise.js";
 import { runAsyncPrefix, suspendJob } from "./jobs.js";
 import { awaitSandboxValue } from "./cancel.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
-import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxPromise, isSandboxPromise } from "./values.js";
+import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxPromise, allocateProducedSandboxValue, isSandboxPromise } from "./values.js";
 export function emitResumeBreakpoint(context, breakpoint) {
     context.onYield?.({
         ...breakpoint,
@@ -53,6 +53,7 @@ export function createInterpretedClosure(node, context, evaluateNode) {
         }
         : undefined;
     return createSandboxClosure({
+        sandbox: true,
         ...(node.async ? { async: true } : {}),
         ...(node.type === "FunctionDeclaration" || node.type === "FunctionExpression"
             ? node.id === undefined
@@ -72,16 +73,34 @@ export function createInterpretedClosure(node, context, evaluateNode) {
             const synchronousPrefix = new Promise((resolve) => {
                 completePrefix = resolve;
             });
-            const execution = runAsyncPrefix(() => executeClosure(node, args, callContext?.thisValue, { ...invocationContext, onSuspend: completePrefix }, evaluateNode));
-            execution.then(completePrefix, completePrefix);
-            return createSandboxPromise(resolveSandboxValue(execution.then((value) => isSandboxPromise(value) || getThenable(value) !== undefined
-                ? awaitSandboxValue(value, context.signal)
-                : value), { budget: context.budget }), { synchronousPrefix });
+            const promise = new Promise((resolve, reject) => {
+                runAsyncPrefix(async () => {
+                    try {
+                        const value = await executeClosure(node, args, callContext?.thisValue, { ...invocationContext, onSuspend: completePrefix }, evaluateNode);
+                        resolve(isSandboxPromise(value) || getThenable(value) !== undefined
+                            ? awaitSandboxValue(createSandboxPromise(resolveSandboxValue(value, { budget: context.budget }), {
+                                trackReplay: false
+                            }), context.signal, context.budget)
+                            : allocateProducedSandboxValue(value, context.budget));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                    finally {
+                        completePrefix();
+                    }
+                }).catch((error) => {
+                    reject(error);
+                    completePrefix();
+                });
+            });
+            return createSandboxPromise(promise, { synchronousPrefix });
         }
     });
 }
 function createGeneratorClosure(node, context, evaluateNode) {
     return createSandboxClosure({
+        sandbox: true,
         ...(node.id === undefined ? {} : { name: node.id.name }),
         retainedValues: () => context.scope.retainedValues(),
         call: async (args, callContext) => {
@@ -136,7 +155,7 @@ export async function evaluateAwaitExpression(node, context, evaluateNode) {
         return {
             kind: "normal",
             hasValue: true,
-            value: await suspendJob(awaitSandboxValue(argument.value, context.signal))
+            value: await suspendJob(awaitSandboxValue(argument.value, context.signal, context.budget))
         };
     }
     finally {
@@ -230,8 +249,11 @@ function getParameterBindingNames(pattern) {
     }
 }
 export function normalizeClosureResult(result, budget) {
-    if (isSandboxPromise(result)) {
+    if (isSandboxPromise(result) &&
+        (result.synchronousPrefix !== undefined || result.hostCall !== undefined)) {
         return result;
     }
-    return createSandboxPromise(resolveSandboxValue(result, { budget }));
+    return createSandboxPromise(resolveSandboxValue(result, { budget }), {
+        ...(isSandboxPromise(result) ? { synchronousPrefix: Promise.resolve() } : {})
+    });
 }

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

@@ -1,3 +1,8 @@
-import { type SandboxValue } from "./values.js";
+import { type SandboxCallContext, type SandboxClosure, type SandboxPromise, type SandboxValue } from "./values.js";
+import type { Budget } from "./budget.js";
+export declare function withCancellationSignal<T>(signal: AbortSignal | undefined, task: () => T): T;
+export declare function invokeCancelableClosure(closure: SandboxClosure, operation: SandboxClosure["call"], args: readonly SandboxValue[], context?: SandboxCallContext, construct?: boolean): SandboxValue | Promise<SandboxValue>;
 export declare function wrapCancelableBindings(bindings: Record<string, SandboxValue>, signal?: AbortSignal): Record<string, SandboxValue>;
-export declare function awaitSandboxValue(value: SandboxValue, signal?: AbortSignal): Promise<SandboxValue>;
+export declare function registerPromiseCancellation(promise: SandboxPromise): void;
+export declare function readPromiseCancellation(promise: SandboxPromise, original: Promise<SandboxValue>): Promise<SandboxValue>;
+export declare function awaitSandboxValue(value: SandboxValue, signal?: AbortSignal, budget?: Budget): Promise<SandboxValue>;

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

@@ -1,90 +1,139 @@
-import { createSandboxClosure, createSandboxPromise, isSandboxClosure, isSandboxPromise } from "./values.js";
-import { observeSandboxPromise } from "./promise-tracker.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createSandboxPromise, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "./values.js";
+import { assertPromiseExecutionAllowed, interruptOnFatalPromiseRejection, onFatalPromiseRejection, observeSandboxPromise, trackSandboxPromise } from "./promise-tracker.js";
 import { replaceErrorStack } from "../error/shape.js";
-import { resolveSandboxValue } from "./promise.js";
-const cancellationSignals = new WeakMap();
-export function wrapCancelableBindings(bindings, signal) {
-    if (signal === undefined) {
-        return bindings;
-    }
-    return wrapCancelableValue(bindings, signal, new WeakMap());
+import { consumeSettledHostCall, resolveSandboxValue } from "./promise.js";
+const activeCancellation = new AsyncLocalStorage();
+const sandboxPromises = new WeakSet();
+const cancelableOutcomes = new WeakMap();
+export function withCancellationSignal(signal, task) {
+    return activeCancellation.run({ signal, host: false }, task);
 }
-function wrapCancelableValue(value, signal, seen) {
-    if (typeof value !== "object" || value === null) {
-        return value;
+export function invokeCancelableClosure(closure, operation, args, context, construct = false) {
+    assertPromiseExecutionAllowed();
+    const active = activeCancellation.getStore();
+    if (active === undefined)
+        return operation(args, context);
+    if (closure.sandbox === true) {
+        return activeCancellation.run({ signal: active.signal, host: false }, () => operation(args, context));
     }
-    const existing = seen.get(value);
-    if (existing !== undefined) {
-        return existing;
+    const signal = active.signal;
+    const managed = signal !== undefined && closure.cancellationSignal === signal;
+    if (signal?.aborted && !managed) {
+        if (!construct && closure.async === true)
+            return createRejectedSandboxPromise(readAbortReason(signal));
+        throw readAbortReason(signal);
     }
-    if (isSandboxClosure(value)) {
-        const wrapped = createSandboxClosure({
-            ...(value.async === true ? { async: true } : {}),
-            call: (args, context) => {
-                if (signal.aborted) {
-                    if (value.async === true) {
-                        return createRejectedSandboxPromise(readAbortReason(signal));
-                    }
-                    throw readAbortReason(signal);
-                }
-                return wrapCancelableResult(value.call(args, context), signal, seen);
-            },
-            name: value.name
-        });
-        seen.set(value, wrapped);
-        return wrapped;
+    return activeCancellation.run({ signal, host: true }, () => {
+        const result = operation(args, context);
+        if (signal === undefined || managed)
+            return result;
+        if (isPromiseLike(result))
+            return awaitWithSignal(result, signal).then((value) => {
+                registerCancelablePromises(value, signal);
+                return value;
+            });
+        registerCancelablePromises(result, signal);
+        return result;
+    });
+}
+export function wrapCancelableBindings(bindings, signal) {
+    if (signal !== undefined)
+        registerCancelablePromises(bindings, signal);
+    return bindings;
+}
+export function registerPromiseCancellation(promise) {
+    const active = activeCancellation.getStore();
+    if (active?.host === false)
+        sandboxPromises.add(promise);
+    else if (active?.signal !== undefined)
+        managePromiseCancellation(promise, active.signal);
+}
+export function readPromiseCancellation(promise, original) {
+    const signal = activeCancellation.getStore()?.signal;
+    return signal === undefined
+        ? original
+        : (cancelableOutcomes.get(promise)?.get(signal) ?? original);
+}
+function managePromiseCancellation(promise, signal) {
+    let outcomes = cancelableOutcomes.get(promise);
+    if (outcomes?.has(signal))
+        return;
+    if (outcomes === undefined) {
+        outcomes = new WeakMap();
+        cancelableOutcomes.set(promise, outcomes);
+    }
+    const outcome = awaitWithSignal(promise.promise, signal);
+    outcomes.set(signal, outcome);
+    trackSandboxPromise(promise, outcome);
+}
+function registerCancelablePromises(value, signal) {
+    const seen = new WeakSet();
+    const pending = [value];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (typeof current !== "object" || current === null || seen.has(current))
+            continue;
+        seen.add(current);
+        if (isSandboxPromise(current)) {
+            if (!sandboxPromises.has(current))
+                managePromiseCancellation(current, signal);
+            continue;
+        }
+        if (isSandboxClosure(current)) {
+            if (current.properties !== undefined)
+                pending.push(current.properties);
+        }
+        else if (isSandboxMap(current)) {
+            for (const [key, entry] of current.entries)
+                pending.push(key, entry);
+        }
+        else if (isSandboxSet(current)) {
+            for (const entry of current.values)
+                pending.push(entry);
+        }
+        else {
+            for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(current))) {
+                if ("value" in descriptor)
+                    pending.push(descriptor.value);
+            }
+        }
     }
+}
+export function awaitSandboxValue(value, signal, budget) {
+    let resolved;
     if (isSandboxPromise(value)) {
-        // The wrapper delivers this promise's rejection to the sandbox in its place, so
-        // the sandbox never awaits the original and it would otherwise read as unhandled.
         observeSandboxPromise(value);
-        const wrapped = createSandboxPromise(wrapCancelablePromise(value.promise, signal, seen), {
-            trackReplay: false,
-            ...(value.synchronousPrefix === undefined
-                ? {}
-                : { synchronousPrefix: value.synchronousPrefix }),
-            ...(value.hostCall === undefined ? {} : { hostCall: value.hostCall }),
-            ...(value.hostCallJournal === undefined ? {} : { hostCallJournal: value.hostCallJournal }),
-            ...(value.span === undefined ? {} : { span: value.span })
+        const outcome = signal === undefined
+            ? value.promise
+            : (cancelableOutcomes.get(value)?.get(signal) ?? value.promise);
+        resolved = new Promise((resolve, reject) => {
+            const detach = onFatalPromiseRejection(reject);
+            const complete = (state, result) => {
+                detach?.();
+                try {
+                    consumeSettledHostCall(value);
+                    if (state === "fulfilled")
+                        resolve(result);
+                    else
+                        reject(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            outcome.then((result) => complete("fulfilled", result), (reason) => complete("rejected", reason));
         });
-        seen.set(value, wrapped);
-        cancellationSignals.set(wrapped, signal);
-        return wrapped;
-    }
-    if (Array.isArray(value)) {
-        const wrapped = new Array(value.length);
-        seen.set(value, wrapped);
-        for (let index = 0; index < value.length; index += 1) {
-            wrapped[index] = wrapCancelableValue(value[index], signal, seen);
-        }
-        return wrapped;
     }
-    const wrapped = Object.create(Object.getPrototypeOf(value));
-    seen.set(value, wrapped);
-    for (const [key, entry] of Object.entries(value)) {
-        wrapped[key] = wrapCancelableValue(entry, signal, seen);
+    else {
+        resolved = resolveSandboxValue(value, { budget });
     }
-    return wrapped;
-}
-function wrapCancelableResult(result, signal, seen) {
-    if (!isPromiseLike(result)) {
-        return wrapCancelableValue(result, signal, seen);
-    }
-    return wrapCancelablePromise(result, signal, seen);
-}
-function wrapCancelablePromise(promise, signal, seen) {
-    return awaitWithSignal(promise, signal).then((value) => wrapCancelableValue(value, signal, seen), (reason) => {
-        if (signal.aborted && reason === signal.reason)
-            throw reason;
-        throw wrapCancelableUnknown(reason, signal, seen);
-    });
-}
-export function awaitSandboxValue(value, signal) {
-    const resolved = resolveSandboxValue(value);
-    return isSandboxPromise(value) &&
-        (value.synchronousPrefix !== undefined || cancellationSignals.get(value) === signal)
+    const pending = isSandboxPromise(value) &&
+        (value.synchronousPrefix !== undefined ||
+            (signal !== undefined && cancelableOutcomes.get(value)?.has(signal)))
         ? resolved
         : awaitWithSignal(resolved, signal);
+    return isSandboxPromise(value) ? pending : interruptOnFatalPromiseRejection(pending);
 }
 function awaitWithSignal(promise, signal) {
     if (signal === undefined)
@@ -125,22 +174,6 @@ function awaitWithSignal(promise, signal) {
         });
     });
 }
-function wrapCancelableUnknown(value, signal, seen) {
-    if (value === null ||
-        value === undefined ||
-        typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean") {
-        return value;
-    }
-    if (isSandboxClosure(value) ||
-        isSandboxPromise(value) ||
-        Array.isArray(value) ||
-        (typeof value === "object" && value !== null)) {
-        return wrapCancelableValue(value, signal, seen);
-    }
-    return value;
-}
 function readAbortReason(signal) {
     return signal.reason ?? createAbortError();
 }
@@ -161,5 +194,8 @@ function createRejectedSandboxPromise(reason) {
     return createSandboxPromise(promise);
 }
 function isPromiseLike(value) {
-    return typeof value === "object" && value !== null && "then" in value;
+    return (typeof value === "object" &&
+        value !== null &&
+        "then" in value &&
+        typeof value.then === "function");
 }

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

@@ -1,6 +1,7 @@
 import { attachErrorSpan, attachWrappedErrorCause, describeThrownValue, formatErrorStack, readErrorCause, readErrorSpan } from "../error/shape.js";
 import { SandboxError } from "./budget.js";
 import { HostCallResumabilityError } from "./host-call.js";
+import { withFatalPromiseCleanup } from "./promise-tracker.js";
 import { deepCopyToSandbox } from "./values.js";
 const capturedExceptionBrand = Symbol("CapturedException");
 const sandboxErrorBrand = Symbol("SandboxError");
@@ -50,9 +51,12 @@ export async function evaluateTryStatement(node, context, evaluateNode) {
     if (node.finalizer === undefined || tryOrCatchResult.kind === "error") {
         return tryOrCatchResult;
     }
-    const finalizerResult = fatalBudgetError?.budget === "deadline"
-        ? await evaluateWithoutDeadlineChecks(context, () => evaluateBlockCompletion(node.finalizer, context, evaluateNode))
-        : await evaluateBlockCompletion(node.finalizer, context, evaluateNode);
+    const evaluateFinalizer = () => fatalBudgetError?.budget === "deadline"
+        ? evaluateWithoutDeadlineChecks(context, () => evaluateBlockCompletion(node.finalizer, context, evaluateNode))
+        : evaluateBlockCompletion(node.finalizer, context, evaluateNode);
+    const finalizerResult = await (fatalBudgetError === undefined
+        ? evaluateFinalizer()
+        : withFatalPromiseCleanup(evaluateFinalizer));
     if (fatalBudgetError !== undefined) {
         throw fatalBudgetError;
     }

package/packages/safejs/dist/interp/globals/collections.js

@@ -4,6 +4,7 @@ const mapConstructors = new WeakSet();
 const setConstructors = new WeakSet();
 export function createCollectionGlobals(options) {
     const mapConstructor = createSandboxClosure({
+        sandbox: true,
         call: () => {
             throw new TypeError("Constructor Map requires 'new'.");
         },
@@ -17,6 +18,7 @@ export function createCollectionGlobals(options) {
         name: "Map"
     });
     const setConstructor = createSandboxClosure({
+        sandbox: true,
         call: () => {
             throw new TypeError("Constructor Set requires 'new'.");
         },

package/packages/safejs/dist/interp/globals/console-json.js

@@ -5,10 +5,12 @@ export function createConsoleJsonGlobals(options) {
     return {
         JSON: {
             parse: createSandboxClosure({
+                sandbox: true,
                 call: async ([text]) => parseJson(text, options.budget),
                 name: "parse"
             }),
             stringify: createSandboxClosure({
+                sandbox: true,
                 call: async ([value, replacer, indent]) => stringifyJson(value, replacer, indent, options.budget),
                 name: "stringify"
             })
@@ -16,6 +18,7 @@ export function createConsoleJsonGlobals(options) {
         console: options.hostCalls === undefined
             ? {
                 error: createSandboxClosure({
+                    sandbox: true,
                     call: async (args) => {
                         sink.error(...args.map((value) => deepCopyFromSandbox(value)));
                         return undefined;
@@ -23,6 +26,7 @@ export function createConsoleJsonGlobals(options) {
                     name: "error"
                 }),
                 log: createSandboxClosure({
+                    sandbox: true,
                     call: async (args) => {
                         sink.log(...args.map((value) => deepCopyFromSandbox(value)));
                         return undefined;

package/packages/safejs/dist/interp/globals/error.js

@@ -27,11 +27,7 @@ export function isSandboxErrorConstructor(value) {
 }
 function createErrorConstructor(name, budget) {
     const call = (args, context) => createSubsetError(name, args, context?.stack ?? [], budget);
-    const closure = createSandboxClosure({
-        call,
-        construct: call,
-        name
-    });
+    const closure = createSandboxClosure({ sandbox: true, call, construct: call, name });
     errorConstructorNames.set(closure, name);
     return closure;
 }

package/packages/safejs/dist/interp/globals/math.js

@@ -46,13 +46,11 @@ export function createMathGlobals(options = {}) {
         PI: Math.PI,
         SQRT1_2: Math.SQRT1_2,
         SQRT2: Math.SQRT2,
-        random: createSandboxClosure({
-            call: () => random(),
-            name: "random"
-        })
+        random: createSandboxClosure({ sandbox: true, call: () => random(), name: "random" })
     };
     for (const [name, method] of Object.entries(mathMethods)) {
         mathObject[name] = createSandboxClosure({
+            sandbox: true,
             call: (args) => Reflect.apply(method, Math, args),
             name
         });

package/packages/safejs/dist/interp/globals/misc.js

@@ -3,22 +3,27 @@ import { allocateProducedSandboxValue, cloneSandboxValue, createSandboxClosure,
 export function createMiscGlobals(options) {
     return {
         structuredClone: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => structuredCloneSandboxValue(value, options.budget),
             name: "structuredClone"
         }),
         parseInt: createSandboxClosure({
+            sandbox: true,
             call: (args) => Reflect.apply(globalThis.parseInt, globalThis, [...args]),
             name: "parseInt"
         }),
         parseFloat: createSandboxClosure({
+            sandbox: true,
             call: (args) => Reflect.apply(globalThis.parseFloat, globalThis, [...args]),
             name: "parseFloat"
         }),
         isNaN: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => globalThis.isNaN(value),
             name: "isNaN"
         }),
         isFinite: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => globalThis.isFinite(value),
             name: "isFinite"
         })

package/packages/safejs/dist/interp/globals/object-array.js

@@ -4,30 +4,37 @@ export function createObjectArrayGlobals(options) {
     return {
         Object: {
             keys: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => budgetSandboxValue(getOwnEnumerableKeys(value), options.budget),
                 name: "keys"
             }),
             values: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => budgetSandboxValue(getOwnEnumerableValues(value), options.budget),
                 name: "values"
             }),
             entries: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => budgetSandboxValue(getOwnEnumerableEntries(value), options.budget),
                 name: "entries"
             }),
             hasOwn: createSandboxClosure({
+                sandbox: true,
                 call: ([value, key]) => Reflect.apply(Object.hasOwn, Object, [value, key]),
                 name: "hasOwn"
             }),
             is: createSandboxClosure({
+                sandbox: true,
                 call: ([left, right]) => Reflect.apply(Object.is, Object, [left, right]),
                 name: "is"
             }),
             fromEntries: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => budgetSandboxValue(Reflect.apply(Object.fromEntries, Object, [value]), options.budget),
                 name: "fromEntries"
             }),
             freeze: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => {
                     if (typeof value === "object" && value !== null) {
                         Object.freeze(value);
@@ -37,76 +44,93 @@ export function createObjectArrayGlobals(options) {
                 name: "freeze"
             }),
             isFrozen: createSandboxClosure({
+                sandbox: true,
                 call: ([value]) => Object.isFrozen(value),
                 name: "isFrozen"
             }),
             assign: createSandboxClosure({
+                sandbox: true,
                 call: ([target, ...sources]) => assignSandboxValues(target, sources),
                 name: "assign"
             })
         },
         Array: createSandboxClosure({
+            sandbox: true,
             call: (args) => createArrayFromConstructorArgs(args, options.budget),
             construct: (args) => createArrayFromConstructorArgs(args, options.budget),
             name: "Array",
             properties: {
                 isArray: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => Array.isArray(value),
                     name: "isArray"
                 }),
                 from: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => arrayFromSandboxValues(args, options.budget),
                     name: "from"
                 }),
                 of: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => budgetSandboxValue(Reflect.apply(Array.of, Array, [...args]), options.budget),
                     name: "of"
                 })
             }
         }),
         String: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => options.budget.allocateString(String(value)),
             name: "String",
             properties: {
                 raw: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => stringRaw(args, options.budget),
                     name: "raw"
                 }),
                 fromCharCode: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => options.budget.allocateString(Reflect.apply(String.fromCharCode, String, [...args])),
                     name: "fromCharCode"
                 }),
                 fromCodePoint: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => options.budget.allocateString(Reflect.apply(String.fromCodePoint, String, [...args])),
                     name: "fromCodePoint"
                 })
             }
         }),
         Number: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => Number(value),
             name: "Number",
             properties: {
                 isFinite: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isFinite(value),
                     name: "isFinite"
                 }),
                 isNaN: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isNaN(value),
                     name: "isNaN"
                 }),
                 isInteger: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isInteger(value),
                     name: "isInteger"
                 }),
                 parseInt: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => Reflect.apply(Number.parseInt, Number, [...args]),
                     name: "parseInt"
                 }),
                 parseFloat: createSandboxClosure({
+                    sandbox: true,
                     call: (args) => Reflect.apply(Number.parseFloat, Number, [...args]),
                     name: "parseFloat"
                 }),
                 isSafeInteger: createSandboxClosure({
+                    sandbox: true,
                     call: ([value]) => typeof value === "number" && Number.isSafeInteger(value),
                     name: "isSafeInteger"
                 }),
@@ -118,6 +142,7 @@ export function createObjectArrayGlobals(options) {
             }
         }),
         Boolean: createSandboxClosure({
+            sandbox: true,
             call: ([value]) => Boolean(value),
             name: "Boolean"
         })

package/packages/safejs/dist/interp/globals/regex.js

@@ -2,6 +2,6 @@ import { createSandboxClosure, createSandboxRegex } from "../values.js";
 export function createRegexGlobals() {
     const construct = (args) => createSandboxRegex(String(args[0] ?? ""), String(args[1] ?? ""));
     return {
-        RegExp: createSandboxClosure({ name: "RegExp", call: construct, construct })
+        RegExp: createSandboxClosure({ sandbox: true, name: "RegExp", call: construct, construct })
     };
 }