poe-code 14.0.44 → 14.0.46

package/packages/safe-js/dist/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-2GJ635AB.js";
+} from "./chunks/chunk-WQY27BRL.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-JZXAWFPL.js";
+} from "./chunks/chunk-XC53RECY.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/core.js

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-JZXAWFPL.js";
+} from "./chunks/chunk-XC53RECY.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safe-js/dist/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-2GJ635AB.js";
+} from "./chunks/chunk-WQY27BRL.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-JZXAWFPL.js";
+} from "./chunks/chunk-XC53RECY.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/budget.d.ts

@@ -34,6 +34,7 @@ type BudgetLimits = {
     arrayLength?: number;
     dataSize?: number;
 };
+export declare function isFatalSandboxError(error: unknown): error is SandboxError;
 export type CompileOwner = {
     readonly budget: Budget;
     readonly generation: number;

package/packages/safe-js/dist/interp/budget.js

@@ -34,6 +34,9 @@ export class SandboxError extends Error {
         this.limit = input.limit;
     }
 }
+export function isFatalSandboxError(error) {
+    return (error instanceof SandboxError && (error.code === "budgetExceeded" || error.code === "reentry"));
+}
 export class Budget {
     deadline;
     limits;

package/packages/safe-js/dist/interp/exceptions.d.ts

@@ -2,6 +2,7 @@ import type { BreakStatement, ContinueStatement, ParseResult, ThrowStatement, Tr
 import { type SandboxErrorName, type ErrorSourceSpan } from "../error/shape.js";
 import { type Budget } from "./budget.js";
 import type { Scope } from "./scope.js";
+import type { InterpreterError } from "./interpreter.js";
 import { type SandboxObject, type SandboxValue } from "./values.js";
 declare const capturedExceptionBrand: unique symbol;
 export type { SandboxErrorName } from "../error/shape.js";
@@ -30,10 +31,13 @@ type ExceptionContext = {
     callStack: readonly string[];
     scope: Scope;
     toPropertyKey?: (value: SandboxValue) => Promise<string>;
+    getProperty?: (value: SandboxValue, key: string | number) => SandboxValue;
 };
 type EvaluateExceptionNode<TContext, TError> = (node: ParseResult, context: TContext) => Promise<EvaluationResult<TError>>;
 export declare function evaluateThrowStatement<TContext extends ExceptionContext, TError>(node: ThrowStatement, context: TContext, evaluateNode: EvaluateExceptionNode<TContext, TError>): Promise<EvaluationResult<TError>>;
 export declare function evaluateTryStatement<TContext extends ExceptionContext, TError>(node: TryStatement, context: TContext, evaluateNode: EvaluateExceptionNode<TContext, TError>): Promise<EvaluationResult<TError>>;
+export declare function createThrowCompletion(error: unknown, budget: Budget, stackFrames: readonly string[], span?: ErrorSourceSpan): CompletionResult;
+export declare function isInterpreterError(value: unknown): value is InterpreterError;
 export declare function createCapturedException(reason: unknown, stackFrames: readonly string[], sandbox?: boolean): CapturedException;
 export declare function isCapturedException(value: unknown): value is CapturedException;
 export declare function coerceThrownValue(reason: unknown, budget: Budget, stackFrames: readonly string[], span?: ErrorSourceSpan, sandbox?: boolean): SandboxValue;

package/packages/safe-js/dist/interp/exceptions.js

@@ -1,8 +1,9 @@
 import { attachErrorSpan, attachWrappedErrorCause, describeThrownValue, formatErrorStack, readErrorCause, readErrorSpan, sandboxErrorNames, sandboxErrorTypes } from "../error/shape.js";
-import { SandboxError } from "./budget.js";
+import { isFatalSandboxError, SandboxError } from "./budget.js";
 import { HostCallResumabilityError } from "./host-call.js";
 import { withFatalPromiseCleanup } from "./promise-tracker.js";
-import { deepCopyToSandbox } from "./values.js";
+import { deepCopyToSandbox, ownEnumerableSandboxEntries } from "./values.js";
+import { getSandboxDataProperty } from "./object-model.js";
 import { toPropertyKey } from "./property-key.js";
 const capturedExceptionBrand = Symbol("CapturedException");
 export async function evaluateThrowStatement(node, context, evaluateNode) {
@@ -35,25 +36,70 @@ export async function evaluateTryStatement(node, context, evaluateNode) {
             value: undefined
         };
     }
-    const tryOrCatchResult = fatalBudgetError === undefined && tryResult.kind === "throw" && node.handler !== undefined
-        ? await evaluateCatchClause(node.handler, tryResult.value, context, evaluateNode)
-        : tryResult;
+    let tryOrCatchResult = tryResult;
+    let catchFailure;
+    if (fatalBudgetError === undefined && tryResult.kind === "throw" && node.handler !== undefined) {
+        try {
+            tryOrCatchResult = await evaluateCatchClause(node.handler, tryResult.value, context, evaluateNode);
+        }
+        catch (error) {
+            if (isFatalSandboxError(error) || isInterpreterError(error) || error instanceof HostCallResumabilityError) {
+                throw error;
+            }
+            catchFailure = createThrowCompletion(error, context.budget, context.callStack, node.span);
+            tryOrCatchResult = catchFailure;
+        }
+    }
     if (node.finalizer === undefined || tryOrCatchResult.kind === "error") {
         return tryOrCatchResult;
     }
     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;
+    if (catchFailure !== undefined) {
+        const value = catchFailure.value;
+        context.budget.setRetainedValues(catchFailure, () => [value]);
     }
-    if (finalizerResult.kind === "normal") {
-        return tryOrCatchResult;
+    try {
+        const finalizerResult = await (fatalBudgetError === undefined
+            ? evaluateFinalizer()
+            : withFatalPromiseCleanup(evaluateFinalizer));
+        if (fatalBudgetError !== undefined) {
+            throw fatalBudgetError;
+        }
+        if (finalizerResult.kind === "normal") {
+            return tryOrCatchResult;
+        }
+        return finalizerResult;
+    }
+    finally {
+        if (catchFailure !== undefined)
+            context.budget.setRetainedValues(catchFailure, undefined);
     }
-    return finalizerResult;
+}
+export function createThrowCompletion(error, budget, stackFrames, span) {
+    const value = isCapturedException(error)
+        ? coerceThrownValue(error.reason, budget, error.stackFrames, span, error.sandbox)
+        : coerceThrownValue(error, budget, stackFrames, span, true);
+    return {
+        kind: "throw",
+        hasValue: true,
+        span: readErrorSpan(value) ?? span,
+        stackFrames: isCapturedException(error) ? error.stackFrames : stackFrames,
+        value
+    };
+}
+export function isInterpreterError(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        hasOwnProperty(value, "code") &&
+        hasOwnProperty(value, "message") &&
+        hasOwnProperty(value, "nodeType") &&
+        hasOwnProperty(value, "span") &&
+        (value.code === "UNBOUND_IDENTIFIER" || value.code === "UNSUPPORTED_NODE"));
+}
+function hasOwnProperty(value, name) {
+    return Object.prototype.hasOwnProperty.call(value, name);
 }
 export function createCapturedException(reason, stackFrames, sandbox = false) {
     return {
@@ -240,6 +286,9 @@ async function evaluateCatchClause(node, thrownValue, context, evaluateNode) {
         scope
     };
     if (node.param !== undefined) {
+        for (const name of getPatternBindingNames(node.param)) {
+            scope.predeclare(name, "let");
+        }
         const binding = await bindPattern(node.param, thrownValue, catchContext, evaluateNode);
         if (!binding.ok) {
             return binding.result;
@@ -351,8 +400,8 @@ async function bindArrayPattern(pattern, value, context, evaluateNode) {
     return { ok: true };
 }
 async function bindObjectPattern(pattern, value, context, evaluateNode) {
-    if ((typeof value !== "object" && !Array.isArray(value)) || value === null) {
-        throw new TypeError("Object catch bindings require a non-null object value.");
+    if (value === null || value === undefined) {
+        throw new TypeError("Object catch bindings require a non-nullish value.");
     }
     const excludedKeys = new Set();
     for (const property of pattern.properties) {
@@ -369,7 +418,9 @@ async function bindObjectPattern(pattern, value, context, evaluateNode) {
             return key;
         }
         excludedKeys.add(String(key.value));
-        const binding = await bindPattern(property.value, getObjectPatternValue(value, key.value), context, evaluateNode);
+        const binding = await bindPattern(property.value, context.getProperty === undefined
+            ? getSandboxDataProperty(value, key.value, context.budget)
+            : context.getProperty(value, key.value), context, evaluateNode);
         if (!binding.ok) {
             return binding;
         }
@@ -406,15 +457,9 @@ function getStaticPropertyKey(property) {
             throw new TypeError(`Unsupported catch binding property key '${property.type}'.`);
     }
 }
-function getObjectPatternValue(value, key) {
-    return value[key];
-}
 function copyObjectRest(value, excludedKeys) {
     const rest = Object.create(null);
-    for (const [key, entryValue] of Object.entries(value)) {
-        if (excludedKeys.has(key)) {
-            continue;
-        }
+    for (const [key, entryValue] of ownEnumerableSandboxEntries(value, excludedKeys)) {
         rest[key] = entryValue;
     }
     return rest;

package/packages/safe-js/dist/interp/interpreter.js

@@ -4,12 +4,12 @@ import { toPropertyKey } from "./property-key.js";
 import { assertPromiseExecutionAllowed } from "./promise-tracker.js";
 import { SandboxJobQueue, runAsyncPrefix, suspendJob } from "./jobs.js";
 import { withCancellationSignal } from "./cancel.js";
-import { attachErrorSpan, formatErrorStack, readErrorSpan, replaceErrorStack } from "../error/shape.js";
+import { attachErrorSpan, formatErrorStack, replaceErrorStack } from "../error/shape.js";
 import { evaluateArrowFunctionExpression, evaluateFunctionExpression, evaluateAwaitExpression, emitResumeBreakpoint, createInterpretedClosure, normalizeClosureResult } from "./async.js";
 import { HostCallResumabilityError } from "./host-call.js";
-import { Budget, SandboxError } from "./budget.js";
+import { Budget, isFatalSandboxError, SandboxError } from "./budget.js";
 import { CompileScope, RegexCompileGuard } from "./regex/compile-guard.js";
-import { coerceThrownValue, createCapturedException, evaluateThrowStatement as evaluateThrowStatementResult, evaluateTryStatement as evaluateTryStatementResult, isCapturedException, surfaceThrownValue } from "./exceptions.js";
+import { createCapturedException, createThrowCompletion, evaluateThrowStatement as evaluateThrowStatementResult, evaluateTryStatement as evaluateTryStatementResult, isCapturedException, isInterpreterError, surfaceThrownValue } from "./exceptions.js";
 import { callArrayMethod, getArrayMember, isArrayMethodName } from "./methods/array.js";
 import { getFunctionMember } from "./methods/function.js";
 import { getGuestFunctionProperty, getSandboxPrototype, isGuestClosure, materializeFunctionProperties, setSandboxPrototype } from "./object-model.js";
@@ -222,17 +222,9 @@ async function evaluateNode(node, context) {
                 error
             };
         }
-        const exception = isCapturedException(error)
-            ? coerceThrownValue(error.reason, context.budget, error.stackFrames, node.span, error.sandbox)
-            : coerceThrownValue(error, context.budget, context.callStack, node.span, true);
-        reconcileDataBudget(context.budget, context.stats, context.scope, exception, compilation, context.compilation);
-        return {
-            kind: "throw",
-            hasValue: true,
-            span: readErrorSpan(exception) ?? node.span,
-            stackFrames: isCapturedException(error) ? error.stackFrames : context.callStack,
-            value: exception
-        };
+        const completion = createThrowCompletion(error, context.budget, context.callStack, node.span);
+        reconcileDataBudget(context.budget, context.stats, context.scope, completion.value, compilation, context.compilation);
+        return completion;
     }
     finally {
         compilation.dispose();
@@ -1537,7 +1529,8 @@ async function evaluateThrowStatement(node, context) {
 async function evaluateTryStatement(node, context) {
     return evaluateTryStatementResult(node, {
         ...context,
-        toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(context))
+        toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(context)),
+        getProperty: (value, key) => getPropertyValue(value, key, context)
     }, evaluateNode);
 }
 async function evaluateUnaryExpression(node, context) {
@@ -2666,18 +2659,6 @@ function defineSandboxProperty(target, key, value) {
         writable: true
     });
 }
-function isInterpreterError(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        hasOwnProperty(value, "code") &&
-        hasOwnProperty(value, "message") &&
-        hasOwnProperty(value, "nodeType") &&
-        hasOwnProperty(value, "span") &&
-        (value.code === "UNBOUND_IDENTIFIER" || value.code === "UNSUPPORTED_NODE"));
-}
-function hasOwnProperty(value, name) {
-    return Object.prototype.hasOwnProperty.call(value, name);
-}
 function wrapHostResult(result, stack, sandbox) {
     if (!isPromiseLikeResult(result)) {
         return result;
@@ -2689,9 +2670,6 @@ function wrapHostResult(result, stack, sandbox) {
 function captureException(error, stack, sandbox) {
     return isCapturedException(error) ? error : createCapturedException(error, stack, sandbox);
 }
-function isFatalSandboxError(error) {
-    return (error instanceof SandboxError && (error.code === "budgetExceeded" || error.code === "reentry"));
-}
 function isPromiseLikeResult(value) {
     return typeof value === "object" && value !== null && "then" in value;
 }

package/packages/safe-js/dist/interp/methods/function.js

@@ -1,4 +1,4 @@
-import { createSandboxClosure } from "../values.js";
+import { createSandboxClosure, isSandboxClosure } from "../values.js";
 import { getGuestFunctionProperty, isGuestClosure } from "../object-model.js";
 const functionMethodNames = new Set(["apply", "bind", "call"]);
 export function getFunctionMember(target, property, options) {
@@ -22,13 +22,16 @@ export function getFunctionMember(target, property, options) {
     return createSandboxClosure({
         sandbox: true,
         name: `Function#${property}`,
-        call: (args, context) => callFunctionMethod(target, property, args, options, context?.stack ?? [])
+        call: (args, context) => callFunctionMethod(context?.thisValue, property, args, options, context?.stack ?? [])
     });
 }
 function isFunctionMethodName(property) {
     return typeof property === "string" && functionMethodNames.has(property);
 }
 function callFunctionMethod(target, methodName, args, options, stack) {
+    if (!isSandboxClosure(target)) {
+        throw new TypeError(`Function#${methodName} requires a callable receiver.`);
+    }
     const thisValue = args[0];
     if (methodName === "bind") {
         const boundArgs = args.slice(1);

package/packages/safe-js/dist/interp/patterns.js

@@ -161,10 +161,8 @@ function describeRuntimeValue(value) {
 }
 function copyObjectRestValue(value, excludedKeys) {
     const rest = Object.create(null);
-    for (const [key, entryValue] of ownEnumerableSandboxEntries(value)) {
-        if (!excludedKeys.has(key)) {
-            defineProperty(rest, key, entryValue);
-        }
+    for (const [key, entryValue] of ownEnumerableSandboxEntries(value, excludedKeys)) {
+        defineProperty(rest, key, entryValue);
     }
     return rest;
 }

package/packages/safe-js/dist/interp/values.d.ts

@@ -104,7 +104,7 @@ export declare function createSandboxClosure(input: {
     properties?: SandboxObject | ((closure: SandboxClosure) => SandboxObject);
     retainedValues?: () => Iterable<SandboxValue>;
 }): SandboxClosure;
-export declare function ownEnumerableSandboxEntries(value: SandboxValue): Array<[string, SandboxValue]>;
+export declare function ownEnumerableSandboxEntries(value: SandboxValue, excludedKeys?: ReadonlySet<string>): Array<[string, SandboxValue]>;
 export declare function createSandboxPromise(promise: Promise<SandboxValue>, metadata?: {
     trackReplay?: boolean;
     synchronousPrefix?: Promise<void>;

package/packages/safe-js/dist/interp/values.js

@@ -73,10 +73,12 @@ export function createSandboxClosure(input) {
     }
     return Object.freeze(closure);
 }
-export function ownEnumerableSandboxEntries(value) {
+export function ownEnumerableSandboxEntries(value, excludedKeys) {
     if (isGuestHostObject(value)) {
         const entries = [];
         for (const key of getHostObjectKeys(value)) {
+            if (excludedKeys?.has(key))
+                continue;
             if (hasHostObjectMember(value, key, true))
                 entries.push([key, getHostObjectMember(value, key)]);
         }
@@ -84,11 +86,14 @@ export function ownEnumerableSandboxEntries(value) {
     }
     if (value === null || value === undefined)
         throw new TypeError("Cannot convert undefined or null to object.");
+    let entries;
     if (isGuestClosure(value))
-        return Object.entries(value.properties ?? {});
-    if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value))
+        entries = Object.entries(value.properties ?? {});
+    else if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxPromise(value) || isSandboxRegex(value))
         return [];
-    return Object.entries(Object(value));
+    else
+        entries = Object.entries(Object(value));
+    return excludedKeys === undefined ? entries : entries.filter(([key]) => !excludedKeys.has(key));
 }
 export function createSandboxPromise(promise, metadata = {}) {
     const original = metadata.trackReplay === false