poe-code 14.0.45 → 14.0.47

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-WQQANSWB.js";
+} from "./chunks/chunk-WQY27BRL.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-T3NC5O24.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-T3NC5O24.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-WQQANSWB.js";
+} from "./chunks/chunk-WQY27BRL.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-T3NC5O24.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";
@@ -35,6 +36,8 @@ type ExceptionContext = {
 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,5 +1,5 @@
 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, ownEnumerableSandboxEntries } from "./values.js";
@@ -36,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 {

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();
@@ -2667,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;
@@ -2690,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);