poe-code 14.0.81 → 14.0.83

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-2LNBLFJ3.js";
+} from "./chunks/chunk-37V6Q4K3.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-ZSYBRZU6.js";
+} from "./chunks/chunk-PT7PBLVT.js";
 import "./chunks/chunk-M2DLCGEF.js";
 import "./chunks/chunk-Q7USUEL7.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-ZSYBRZU6.js";
+} from "./chunks/chunk-PT7PBLVT.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-2LNBLFJ3.js";
+} from "./chunks/chunk-37V6Q4K3.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-ZSYBRZU6.js";
+} from "./chunks/chunk-PT7PBLVT.js";
 import "./chunks/chunk-M2DLCGEF.js";
 import "./chunks/chunk-Q7USUEL7.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/error-prototypes.d.ts

@@ -0,0 +1,3 @@
+import type { Budget } from "./budget.js";
+import type { SandboxObject } from "./values.js";
+export declare const errorPrototypes: WeakMap<Budget, Map<"Error" | "TypeError" | "RangeError" | "ReferenceError" | "SyntaxError" | "URIError" | "EvalError" | "AbortError" | "AggregateError" | "HarnessFailure", SandboxObject>>;

package/packages/safe-js/dist/interp/error-prototypes.js

@@ -0,0 +1 @@
+export const errorPrototypes = new WeakMap();

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

@@ -55,5 +55,6 @@ export declare function createSubsetErrorValue(name: string, message: SandboxVal
     cause?: unknown;
     chargeBudget?: boolean;
     span?: ErrorSourceSpan;
+    transport?: boolean;
 }): SandboxObject;
 export declare function isSandboxErrorConstructorInstance(value: SandboxValue, name: SandboxErrorName): boolean;

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

@@ -5,7 +5,8 @@ import { withFatalPromiseCleanup } from "./promise-tracker.js";
 import { deepCopyToSandbox, ownEnumerableSandboxKeys } from "./values.js";
 import { hasOwnSandboxProperty } from "./globals/object.js";
 import { retainValues } from "./resources.js";
-import { getSandboxDataProperty } from "./object-model.js";
+import { getSandboxDataProperty, setSandboxPrototype } from "./object-model.js";
+import { errorPrototypes } from "./error-prototypes.js";
 import { toPropertyKey } from "./property-key.js";
 import { internalSymbols } from "./internal-symbols.js";
 import { containsResumeTarget } from "./resume-target.js";
@@ -162,8 +163,7 @@ export function surfaceThrownValue(reason, budget, stackFrames = [], span) {
         throw reason;
     }
     if (isSubsetErrorValue(reason)) {
-        normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
-        return reason;
+        return normalizeSurfacedSubsetError(reason, budget, stackFrames, span);
     }
     if (reason instanceof Error) {
         const error = createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
@@ -171,8 +171,7 @@ export function surfaceThrownValue(reason, budget, stackFrames = [], span) {
             chargeBudget: false,
             span
         });
-        normalizeSurfacedSubsetError(error, budget, stackFrames, span);
-        return error;
+        return normalizeSurfacedSubsetError(error, budget, stackFrames, span);
     }
     if (isErrorLikeValue(reason)) {
         const error = createSubsetErrorValue(reason.name || "Error", reason.message, stackFrames, budget, {
@@ -180,13 +179,13 @@ export function surfaceThrownValue(reason, budget, stackFrames = [], span) {
             chargeBudget: false,
             span
         });
-        normalizeSurfacedSubsetError(error, budget, stackFrames, span);
-        return error;
+        return normalizeSurfacedSubsetError(error, budget, stackFrames, span);
     }
-    return createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
+    const error = createSubsetErrorValue("Error", describeThrownValue(reason), stackFrames, budget, {
         chargeBudget: false,
         span
     });
+    return normalizeSurfacedSubsetError(error, budget, stackFrames, span);
 }
 export function createSubsetErrorValue(name, message, stackFrames, budget, options = {}) {
     const resumeChecks = options.chargeBudget === false ? budget.suspendChecks() : undefined;
@@ -195,11 +194,16 @@ export function createSubsetErrorValue(name, message, stackFrames, budget, optio
         const errorMessage = budget.allocateString(coerceErrorMessage(message));
         const header = errorMessage === "" ? errorName : `${errorName}: ${errorMessage}`;
         const stack = budget.allocateString([header, ...[...stackFrames].reverse()].join("\n"));
-        const error = {
-            name: errorName,
-            message: errorMessage,
-            stack
-        };
+        const prototype = options.transport ? undefined : errorPrototypes.get(budget)?.get(toSandboxErrorName(errorName));
+        const error = prototype === undefined ? { name: errorName, message: errorMessage, stack } : {};
+        if (prototype !== undefined) {
+            if (message !== undefined)
+                Object.defineProperty(error, "message", { value: errorMessage, writable: true, configurable: true });
+            if (!errorPrototypes.get(budget).has(errorName))
+                Object.defineProperty(error, "name", { value: errorName, writable: true, configurable: true });
+            Object.defineProperty(error, "stack", { value: stack, writable: true, configurable: true });
+            setSandboxPrototype(error, prototype, budget);
+        }
         sandboxErrorTypes.set(error, toSandboxErrorName(errorName));
         attachErrorSpan(error, options.span);
         attachWrappedErrorCause(error, options.cause);
@@ -224,6 +228,8 @@ function isSubsetErrorValue(value) {
     if (typeof value !== "object" || value === null) {
         return false;
     }
+    if (sandboxErrorTypes.has(value))
+        return true;
     const prototype = Object.getPrototypeOf(value);
     return ((prototype === Object.prototype || prototype === null) &&
         typeof value.name === "string" &&
@@ -236,20 +242,38 @@ function normalizeSurfacedSubsetError(error, budget, stackFrames, span) {
         const name = budget.allocateString(toSandboxErrorName(readErrorName(error)));
         const message = budget.allocateString(readSurfacedErrorMessage(error, name));
         const frames = readSandboxStackFrames(error.stack);
+        if (!Object.isExtensible(error) || ["name", "message", "stack"].some(key => {
+            const descriptor = Object.getOwnPropertyDescriptor(error, key);
+            return descriptor !== undefined && (!("value" in descriptor) || !descriptor.writable);
+        })) {
+            // Public diagnostics must not mutate frozen guest state or invoke setters.
+            const original = error;
+            const descriptors = Object.getOwnPropertyDescriptors(original);
+            delete descriptors.name;
+            delete descriptors.message;
+            delete descriptors.stack;
+            error = Object.defineProperties({}, descriptors);
+            const errorType = sandboxErrorTypes.get(original);
+            if (errorType !== undefined)
+                sandboxErrorTypes.set(error, errorType);
+        }
         error.name = name;
         error.message = message;
         error.stack = budget.allocateString(formatErrorStack(name, message, frames.length > 0 ? frames : [...stackFrames].reverse()));
         attachErrorSpan(error, readErrorSpan(error) ?? span);
+        return error;
     }
     finally {
         resumeChecks();
     }
 }
 function readErrorName(error) {
-    return typeof error.name === "string" && error.name.length > 0 ? error.name : "Error";
+    const name = getSandboxDataProperty(error, "name");
+    return typeof name === "string" && name.length > 0 ? name : sandboxErrorTypes.get(error) ?? "Error";
 }
 function readSurfacedErrorMessage(error, name) {
-    const message = typeof error.message === "string" ? error.message : "";
+    const value = getSandboxDataProperty(error, "message");
+    const message = typeof value === "string" ? value : "";
     if (message === "") {
         return `${name} thrown`;
     }

package/packages/safe-js/dist/interp/float32-prototypes.d.ts

@@ -0,0 +1,3 @@
+import type { Budget } from "./budget.js";
+import type { SandboxObject } from "./values.js";
+export declare const float32Prototypes: WeakMap<Budget, SandboxObject>;

package/packages/safe-js/dist/interp/float32-prototypes.js

@@ -0,0 +1 @@
+export const float32Prototypes = new WeakMap();

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

@@ -6,6 +6,7 @@ export declare function float32Storage(value: Float32Array): {
     length: number;
     byteLength: number;
 };
+export declare function float32Properties(value: Float32Array): Array<[PropertyKey, PropertyDescriptor]>;
 export declare function float32DataProperties(value: Float32Array): Array<[string, PropertyDescriptor]>;
 export declare function isFloat32Index(key: string): boolean;
 export declare function float32Number(value: unknown): number;

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

@@ -23,14 +23,22 @@ export function float32Storage(value) {
         byteLength: Reflect.apply(bufferLength, buffer, [])
     };
 }
+export function float32Properties(value) {
+    const properties = [];
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key === "string" && isFloat32Index(key))
+            continue;
+        properties.push([key, Object.getOwnPropertyDescriptor(value, key)]);
+    }
+    return properties;
+}
 export function float32DataProperties(value) {
     if (Object.getOwnPropertySymbols(value).length > 0)
         throw new TypeError("Float32Array symbol properties are not supported.");
     const properties = [];
-    for (const key of Object.getOwnPropertyNames(value)) {
-        if (isFloat32Index(key))
-            continue;
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    for (const [key, descriptor] of float32Properties(value)) {
+        if (typeof key !== "string")
+            throw new TypeError("Float32Array symbol properties are not supported.");
         if (!("value" in descriptor))
             throw new TypeError(`Float32Array accessor property '${key}' is not supported.`);
         properties.push([key, descriptor]);

package/packages/safe-js/dist/interp/globals/error.d.ts

@@ -5,7 +5,9 @@ export type ErrorName = (typeof errorNames)[number];
 export type ErrorGlobals = Record<ErrorName, ReturnType<typeof createSandboxClosure>>;
 export declare function createErrorGlobals(options: {
     budget: Budget;
+    errorPrototypes?: boolean;
 }): ErrorGlobals;
 export declare function isSandboxErrorConstructorInstance(value: SandboxValue, constructor: SandboxValue): boolean;
 export declare function isSandboxErrorConstructor(value: SandboxValue): value is SandboxClosure;
+export declare function createErrorPrototypes(budget: Budget, constructors: ErrorGlobals): void;
 export {};

package/packages/safe-js/dist/interp/globals/error.js

@@ -1,3 +1,10 @@
+import { errorPrototypes } from "../error-prototypes.js";
+import { getSandboxPropertyDescriptor, getSandboxPrototype, materializeFunctionProperties, registerIntrinsicFunction, registerIntrinsicObject, setSandboxPrototype } from "../object-model.js";
+import { registerBuiltinIdentities } from "../intrinsics.js";
+import { sandboxString } from "../string-coercion.js";
+import { retainValues } from "../resources.js";
+import { readPropertyDescriptor } from "../accessors.js";
+import { acquireSandboxIterator, getSandboxIterator, readIteratorResult } from "../iteration.js";
 import { createSubsetErrorValue, isSandboxErrorConstructorInstance as isNamedSandboxErrorConstructorInstance } from "../exceptions.js";
 import { createSandboxClosure, isSandboxClosure } from "../values.js";
 const errorConstructorNames = new WeakMap();
@@ -12,7 +19,7 @@ const errorNames = [
     "AggregateError"
 ];
 export function createErrorGlobals(options) {
-    return Object.fromEntries(errorNames.map((name) => [name, createErrorConstructor(name, options.budget)]));
+    return Object.fromEntries(errorNames.map((name) => [name, createErrorConstructor(name, options.budget, options.errorPrototypes === true)]));
 }
 export function isSandboxErrorConstructorInstance(value, constructor) {
     if (!isSandboxClosure(constructor)) {
@@ -27,12 +34,105 @@ export function isSandboxErrorConstructorInstance(value, constructor) {
 export function isSandboxErrorConstructor(value) {
     return isSandboxClosure(value) && errorConstructorNames.has(value);
 }
-function createErrorConstructor(name, budget) {
-    const call = (args, context) => createSubsetError(name, args, context?.stack ?? [], budget);
-    const closure = createSandboxClosure({ sandbox: true, call, construct: call, name });
+function createErrorConstructor(name, budget, guest) {
+    const call = (args, context) => errorPrototypes.has(budget) ? createNativeError(name, args, budget, context, closure)
+        : createSubsetError(name, args, context?.stack ?? [], budget);
+    const closure = createSandboxClosure({ guest, sandbox: true, call, construct: call, name, length: name === "AggregateError" ? 2 : 1 });
     errorConstructorNames.set(closure, name);
     return closure;
 }
+export function createErrorPrototypes(budget, constructors) {
+    const prototypes = new Map();
+    for (const name of errorNames)
+        prototypes.set(name, Object.create(null));
+    errorPrototypes.set(budget, prototypes);
+    for (const name of errorNames) {
+        const constructor = constructors[name];
+        const prototype = prototypes.get(name);
+        Object.defineProperties(prototype, {
+            name: { value: name, writable: true, configurable: true },
+            message: { value: "", writable: true, configurable: true },
+            constructor: { value: constructor, writable: true, configurable: true }
+        });
+        Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+        setSandboxPrototype(prototype, name === "Error" ? getSandboxPrototype(Object.create(null), budget) : prototypes.get("Error"));
+        if (name !== "Error")
+            setSandboxPrototype(constructor, constructors.Error);
+    }
+    Object.defineProperty(prototypes.get("Error"), "toString", {
+        writable: true, configurable: true,
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "toString", length: 0,
+            call: async (_args, context) => {
+                const receiver = context?.thisValue;
+                if (receiver === null || typeof receiver !== "object")
+                    throw new TypeError("Error.prototype.toString requires an object.");
+                let name;
+                const release = retainValues(budget, () => [receiver, name]);
+                try {
+                    const rawName = await readErrorProperty(receiver, "name", budget, context);
+                    name = rawName === undefined ? "Error" : await sandboxString(rawName, budget, context);
+                    const rawMessage = await readErrorProperty(receiver, "message", budget, context);
+                    const message = rawMessage === undefined ? "" : await sandboxString(rawMessage, budget, context);
+                    return budget.allocateString(name === "" ? message : message === "" ? name : `${name}: ${message}`);
+                }
+                finally {
+                    release();
+                }
+            }
+        })
+    });
+    registerBuiltinIdentities(budget, Object.fromEntries(errorNames.map(name => [name, constructors[name]])));
+    for (const name of errorNames) {
+        registerIntrinsicFunction(budget, constructors[name]);
+        registerIntrinsicObject(budget, prototypes.get(name));
+    }
+}
+async function readErrorProperty(value, key, budget, context) {
+    if (context?.getProperty !== undefined)
+        return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    return descriptor === undefined ? undefined : readPropertyDescriptor(descriptor, value, context);
+}
+async function createNativeError(name, args, budget, context, constructor) {
+    const newTarget = context?.newTarget ?? constructor;
+    const candidate = await readErrorProperty(newTarget, "prototype", budget, context);
+    const prototype = candidate !== null && typeof candidate === "object" ? candidate : errorPrototypes.get(budget).get(name);
+    let error;
+    let iterator;
+    const errors = [];
+    const release = retainValues(budget, () => [prototype, error, iterator?.retainedValue, ...errors, ...args]);
+    try {
+        const message = name === "AggregateError" ? args[1] : args[0];
+        const options = name === "AggregateError" ? args[2] : args[1];
+        const text = message === undefined ? undefined : await sandboxString(message, budget, context);
+        error = createSubsetErrorValue(name, text, context?.stack ?? [], budget);
+        setSandboxPrototype(error, prototype, budget);
+        if (options !== null && typeof options === "object" && getSandboxPropertyDescriptor(options, "cause", budget) !== undefined) {
+            const cause = await readErrorProperty(options, "cause", budget, context);
+            Object.defineProperty(error, "cause", { value: cause, writable: true, configurable: true });
+        }
+        if (name === "AggregateError") {
+            iterator = context === undefined ? getSandboxIterator(args[0], budget) : await acquireSandboxIterator(args[0], budget, context);
+            if (iterator === undefined)
+                throw new TypeError("AggregateError errors must be iterable.");
+            while (true) {
+                budget.visitNode();
+                const result = await iterator.next();
+                if (result === null || typeof result !== "object")
+                    throw new TypeError("Iterator result must be an object.");
+                if ((await readIteratorResult(iterator, result, "done")).value)
+                    break;
+                budget.allocateArrayLength(errors.length + 1);
+                errors.push((await readIteratorResult(iterator, result, "value")).value);
+            }
+            Object.defineProperty(error, "errors", { value: errors, writable: true, configurable: true });
+        }
+        return error;
+    }
+    finally {
+        release();
+    }
+}
 function createSubsetError(name, args, stackFrames, budget) {
     const message = name === "AggregateError" ? args[1] : args[0];
     const options = name === "AggregateError" ? args[2] : args[1];

package/packages/safe-js/dist/interp/globals/float32array.d.ts

@@ -1,6 +1,7 @@
 import type { Budget } from "../budget.js";
 import { type SandboxClosure, type SandboxValue } from "../values.js";
-export declare function createFloat32ArrayGlobal(budget: Budget): SandboxClosure;
+export declare function createFloat32ArrayGlobal(budget: Budget, nativePrototype?: boolean): SandboxClosure;
+export declare function createFloat32ArrayPrototypes(budget: Budget, constructor: SandboxClosure): void;
 export declare function isFloat32ArrayConstructor(value: unknown): boolean;
 export declare function getFloat32Member(value: Float32Array, property: string | number, budget: Budget): SandboxValue;
-export declare function setFloat32Member(value: Float32Array, property: string | number, entry: SandboxValue): void;
+export declare function setFloat32Member(value: Float32Array, property: PropertyKey, entry: SandboxValue, budget?: Budget): void;