poe-code 5.0.4 → 7.0.0

package/package.json

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

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

@@ -1,4 +1,4 @@
-import type { ArrowFunctionExpression, AwaitExpression, FunctionDeclaration, FunctionExpression, ParseResult, SourceSpan } from "../parse.js";
+import type { ArrowFunctionExpression, AwaitExpression, BlockStatement, FunctionDeclaration, FunctionExpression, ParseResult, SourceSpan } from "../parse.js";
 import { type GeneratorCompletion } from "./generator.js";
 import { type OtelSpan } from "../observability/otel.js";
 import type { Budget } from "./budget.js";
@@ -25,6 +25,7 @@ export type AsyncEvaluationContext = {
     onSuspend?: () => void;
     captureReplayState?: () => unknown;
     rootNode?: ParseResult;
+    functionBody?: BlockStatement;
     restoredLoopIterations: Map<number, LoopIterationSnapshot>;
     resumeTarget?: {
         nodeId?: number;

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

@@ -5,7 +5,8 @@ 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 { boundIdentifiers, containsParameterExpression, hoistedVarDeclarations } from "../parse/bindings.js";
+import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxPromise, allocateProducedSandboxValue, isSandboxPromise } from "./values.js";
 export function emitResumeBreakpoint(context, breakpoint) {
     context.onYield?.({
         ...breakpoint,
@@ -53,6 +54,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 +74,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) => {
@@ -93,6 +113,7 @@ function createGeneratorClosure(node, context, evaluateNode) {
             const channel = createGeneratorChannel(async (generatorYield) => {
                 const result = await evaluateNode(node.body, {
                     ...closureContext,
+                    functionBody: node.body,
                     generatorYield: (value, yieldNodeId) => {
                         generator.state = "suspended";
                         return generatorYield(value, yieldNodeId);
@@ -136,7 +157,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 {
@@ -147,6 +168,7 @@ async function executeClosure(node, args, thisValue, context, evaluateNode) {
     const scope = await createClosureScope(node, args, thisValue, context, evaluateNode);
     const result = await evaluateNode(node.body, {
         ...context,
+        functionBody: node.body.type === "BlockStatement" ? node.body : undefined,
         scope
     });
     if (result.kind === "error") {
@@ -168,16 +190,32 @@ async function createClosureScope(node, args, thisValue, context, evaluateNode)
         scope.declare("arguments", "let", createSandboxArguments(args));
     }
     await bindParameters(node.params, args, scope, context, evaluateNode);
-    hoistVarDeclarations(node.body, scope);
-    return scope;
+    const bodyScope = node.params.some(containsParameterExpression)
+        ? scope.child({}, { functionBoundary: true })
+        : scope;
+    hoistVarDeclarations(node.body, bodyScope);
+    if (bodyScope !== scope) {
+        for (const declaration of hoistedVarDeclarations([node.body])) {
+            for (const declarator of declaration.declarations) {
+                for (const identifier of boundIdentifiers(declarator.id)) {
+                    if (!scope.hasOwnBinding(identifier.name))
+                        continue;
+                    const parameter = scope.lookup(identifier.name);
+                    if (parameter.found)
+                        bodyScope.assign(identifier.name, parameter.value);
+                }
+            }
+        }
+    }
+    return bodyScope;
 }
 function isBlockBody(body) {
     return body.type === "BlockStatement";
 }
 async function bindParameters(params, args, scope, context, evaluateNode) {
     for (const param of params) {
-        for (const name of getParameterBindingNames(param)) {
-            scope.predeclare(name, "let");
+        for (const identifier of boundIdentifiers(param)) {
+            scope.predeclare(identifier.name, "var");
         }
     }
     for (let index = 0; index < params.length; index += 1) {
@@ -185,7 +223,7 @@ async function bindParameters(params, args, scope, context, evaluateNode) {
         if (param.type === "RestElement") {
             const rest = args.slice(index);
             context.budget.allocateArrayLength(rest.length);
-            const binding = await bindPattern(param, rest, { kind: "let" }, scope, {
+            const binding = await bindPattern(param, rest, { kind: "var", initialize: true }, scope, {
                 evaluate: (defaultNode) => evaluateNode(defaultNode, { ...context, scope })
             });
             if (!binding.ok) {
@@ -198,7 +236,7 @@ async function bindParameters(params, args, scope, context, evaluateNode) {
             }
             return;
         }
-        const binding = await bindPattern(param, args[index], { kind: "let" }, scope, {
+        const binding = await bindPattern(param, args[index], { kind: "var", initialize: true }, scope, {
             evaluate: (defaultNode) => evaluateNode(defaultNode, { ...context, scope })
         });
         if (!binding.ok) {
@@ -211,27 +249,12 @@ async function bindParameters(params, args, scope, context, evaluateNode) {
         }
     }
 }
-function getParameterBindingNames(pattern) {
-    switch (pattern.type) {
-        case "Identifier":
-            return [pattern.name];
-        case "MemberExpression":
-            return [];
-        case "AssignmentPattern":
-            return getParameterBindingNames(pattern.left);
-        case "RestElement":
-            return getParameterBindingNames(pattern.argument);
-        case "ArrayPattern":
-            return pattern.elements.flatMap((element) => element === null ? [] : getParameterBindingNames(element));
-        case "ObjectPattern":
-            return pattern.properties.flatMap((property) => property.type === "RestElement"
-                ? getParameterBindingNames(property)
-                : getParameterBindingNames(property.value));
-    }
-}
 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"
         })