poe-code 14.0.80 → 14.0.82

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-34G5WW2O.js";
+} from "./chunks/chunk-7LGBDF56.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-M4L3EZHL.js";
+} from "./chunks/chunk-V6LQP64H.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-M4L3EZHL.js";
+} from "./chunks/chunk-V6LQP64H.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-34G5WW2O.js";
+} from "./chunks/chunk-7LGBDF56.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-M4L3EZHL.js";
+} from "./chunks/chunk-V6LQP64H.js";
 import "./chunks/chunk-M2DLCGEF.js";
 import "./chunks/chunk-Q7USUEL7.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -70,7 +70,7 @@ export type EvaluateAsyncNode = (node: ParseResult, context: AsyncEvaluationCont
 export declare function emitResumeBreakpoint(context: AsyncEvaluationContext, breakpoint: ResumeBreakpoint): void;
 export declare function evaluateArrowFunctionExpression(node: ArrowFunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
 export declare function evaluateFunctionExpression(node: FunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
-export declare function createInterpretedClosure(node: ArrowFunctionExpression | FunctionDeclaration | FunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode, homeObject?: SandboxObject | SandboxClosure): SandboxClosure;
+export declare function createInterpretedClosure(node: ArrowFunctionExpression | FunctionDeclaration | FunctionExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode, homeObject?: SandboxObject | SandboxClosure, initializeGeneratorPrototype?: boolean): SandboxClosure;
 export declare function executeAsyncFunction(execute: (onSuspend: () => void) => Promise<SandboxValue>, budget: Budget, signal?: AbortSignal, callContext?: SandboxCallContext): import("./values.js").SandboxPromise;
 export declare function evaluateAwaitExpression(node: AwaitExpression, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<AsyncEvaluationResult>;
 export declare function executeClosure(node: ArrowFunctionExpression | FunctionDeclaration | FunctionExpression, args: readonly SandboxValue[], thisValue: SandboxValue, context: AsyncEvaluationContext, evaluateNode: EvaluateAsyncNode): Promise<SandboxValue>;

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

@@ -7,7 +7,9 @@ import { CompileScope } from "./regex/compile-guard.js";
 import { awaitSandboxValue } from "./cancel.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
 import { createCoercionContext, createPatternContext } from "./interpreter.js";
-import { getGuestFunctionProperty, setSandboxPrototype } from "./object-model.js";
+import { getGuestFunctionProperty, markDescriptorObject, materializeFunctionProperties, setSandboxPrototype } from "./object-model.js";
+import { generatorPrototypes } from "./generator-prototypes.js";
+import { retainValues, runResources } from "./resources.js";
 import { functionSources } from "../parse/function-source.js";
 import { registerClosureOrigin, registerGeneratorOrigin } from "./closure-origin.js";
 import { boundIdentifiers, containsParameterExpression, getFunctionLength, hoistedVarDeclarations } from "../parse/bindings.js";
@@ -42,12 +44,12 @@ export async function evaluateFunctionExpression(node, context, evaluateNode) {
         value: closure
     };
 }
-export function createInterpretedClosure(node, context, evaluateNode, homeObject) {
+export function createInterpretedClosure(node, context, evaluateNode, homeObject, initializeGeneratorPrototype = true) {
     if (node.type !== "ArrowFunctionExpression") {
         context = { ...context, functionEnvironment: { homeObject } };
     }
     if (node.type !== "ArrowFunctionExpression" && node.generator) {
-        return createGeneratorClosure(node, context, evaluateNode);
+        return createGeneratorClosure(node, context, evaluateNode, initializeGeneratorPrototype);
     }
     const construct = node.type !== "ArrowFunctionExpression" &&
         !(node.type === "FunctionExpression" && node.method === true) &&
@@ -123,7 +125,9 @@ export function executeAsyncFunction(execute, budget, signal, callContext) {
     });
     return createSandboxPromise(promise, { synchronousPrefix });
 }
-function createGeneratorClosure(node, context, evaluateNode) {
+function createGeneratorClosure(node, context, evaluateNode, initializePrototype) {
+    const prototypes = !initializePrototype || runResources.getStore()?.functionSourceText === false ? undefined
+        : generatorPrototypes.get(context.budget)?.get(node.async === true);
     const closure = createSandboxClosure({
         sourceRange: functionSources.get(node),
         guest: true,
@@ -133,48 +137,66 @@ function createGeneratorClosure(node, context, evaluateNode) {
         ...(node.id === undefined ? { name: context.inferredName } : { name: node.id.name }),
         retainedValues: () => [...context.scope.retainedValues(), context.functionEnvironment?.homeObject, context.functionEnvironment?.newTarget],
         call: async (args, callContext) => {
-            const closureContext = {
-                ...context,
-                compilation: callContext?.compilation ?? context.compilation,
-                callStack: [...(callContext?.stack ?? context.callStack)]
-            };
-            const scope = await createClosureScope(node, args, callContext?.thisValue, closureContext, evaluateNode);
-            const channel = createGeneratorChannel((generatorYield) => {
-                const execute = async () => {
-                    const result = await evaluateNode(node.body, {
-                        ...closureContext,
-                        functionBody: node.body,
-                        asyncGenerator: node.async,
-                        generatorBlockScopes: new Map(),
-                        generatorExpressionStates: new Map(),
-                        captureGeneratorScope: (suspendedScope, blocks, completions, expressions) => {
-                            origin.suspendedScope = suspendedScope;
-                            origin.blockScopes = blocks;
-                            origin.finallyCompletions = completions;
-                            origin.expressionStates = expressions;
-                        },
-                        generatorYield: (value, yieldNodeId) => {
-                            generator.state = "suspended";
-                            return generatorYield(value, yieldNodeId);
-                        },
-                        scope
-                    });
-                    if (result.kind === "error") {
-                        throw result.error;
-                    }
-                    if (result.kind === "throw") {
-                        throw result.value;
-                    }
-                    const value = result.hasValue ? result.value : undefined;
-                    return node.async ? awaitSandboxValue(value, context.signal, context.budget, createCoercionContext(context)) : value;
+            // Native generators select their instance prototype before initializing parameters.
+            const candidate = prototypes === undefined ? undefined : getGuestFunctionProperty(closure, "prototype");
+            const prototype = typeof candidate === "object" && candidate !== null ? candidate : prototypes?.instancePrototype;
+            const releasePrototype = prototype === undefined ? undefined : retainValues(context.budget, () => [prototype]);
+            try {
+                const closureContext = {
+                    ...context,
+                    compilation: callContext?.compilation ?? context.compilation,
+                    callStack: [...(callContext?.stack ?? context.callStack)]
                 };
-                return node.async ? runAsyncPrefix(execute) : execute();
-            });
-            const generator = createSandboxGenerator(channel, { async: node.async });
-            const origin = registerGeneratorOrigin(generator, node, scope, closureContext);
-            return generator;
+                const scope = await createClosureScope(node, args, callContext?.thisValue, closureContext, evaluateNode);
+                const channel = createGeneratorChannel((generatorYield) => {
+                    const execute = async () => {
+                        const result = await evaluateNode(node.body, {
+                            ...closureContext,
+                            functionBody: node.body,
+                            asyncGenerator: node.async,
+                            generatorBlockScopes: new Map(),
+                            generatorExpressionStates: new Map(),
+                            captureGeneratorScope: (suspendedScope, blocks, completions, expressions) => {
+                                origin.suspendedScope = suspendedScope;
+                                origin.blockScopes = blocks;
+                                origin.finallyCompletions = completions;
+                                origin.expressionStates = expressions;
+                            },
+                            generatorYield: (value, yieldNodeId) => {
+                                generator.state = "suspended";
+                                return generatorYield(value, yieldNodeId);
+                            },
+                            scope
+                        });
+                        if (result.kind === "error") {
+                            throw result.error;
+                        }
+                        if (result.kind === "throw") {
+                            throw result.value;
+                        }
+                        const value = result.hasValue ? result.value : undefined;
+                        return node.async ? awaitSandboxValue(value, context.signal, context.budget, createCoercionContext(context)) : value;
+                    };
+                    return node.async ? runAsyncPrefix(execute) : execute();
+                });
+                const generator = createSandboxGenerator(channel, { async: node.async });
+                if (prototype !== undefined)
+                    setSandboxPrototype(generator, prototype, context.budget);
+                const origin = registerGeneratorOrigin(generator, node, scope, closureContext);
+                return generator;
+            }
+            finally {
+                releasePrototype?.();
+            }
         }
     });
+    if (prototypes !== undefined) {
+        const prototype = Object.create(null);
+        markDescriptorObject(prototype);
+        setSandboxPrototype(prototype, prototypes.instancePrototype);
+        Object.defineProperty(materializeFunctionProperties(closure), "prototype", { value: prototype, writable: true });
+        setSandboxPrototype(closure, prototypes.functionPrototype);
+    }
     registerClosureOrigin(closure, node, context);
     return closure;
 }

package/packages/safe-js/dist/interp/bound-function-state.d.ts

@@ -0,0 +1,7 @@
+import type { SandboxClosure, SandboxValue } from "./values.js";
+export type BoundFunctionState = {
+    target: SandboxClosure;
+    thisValue: SandboxValue;
+    args: SandboxValue[];
+};
+export declare const boundFunctionStates: WeakMap<object, BoundFunctionState>;

package/packages/safe-js/dist/interp/bound-function-state.js

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

package/packages/safe-js/dist/interp/bound-function.d.ts

@@ -0,0 +1,4 @@
+import { type SandboxClosure } from "./values.js";
+import { type BoundFunctionState } from "./bound-function-state.js";
+import type { FunctionMethodOptions } from "./methods/function.js";
+export declare function createBoundFunction(state: BoundFunctionState, name: string | undefined, length: number | undefined, callClosure: FunctionMethodOptions["callClosure"]): SandboxClosure;

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

@@ -0,0 +1,18 @@
+import { createSandboxClosure } from "./values.js";
+import { boundFunctionStates } from "./bound-function-state.js";
+export function createBoundFunction(state, name, length, callClosure) {
+    const bound = createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name,
+        length,
+        boundTarget: state.target,
+        retainedValues: () => [state.target, state.thisValue, ...state.args, bound.name],
+        call: (args, context) => callClosure(state.target, [...state.args, ...args], context?.stack ?? [], state.thisValue),
+        ...(state.target.construct === undefined ? {} : {
+            construct: (args, context) => callClosure(state.target, [...state.args, ...args], context?.stack ?? [], undefined, true, context?.newTarget === bound ? state.target : context?.newTarget)
+        })
+    });
+    boundFunctionStates.set(bound, state);
+    return bound;
+}

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/generator-prototypes.d.ts

@@ -0,0 +1,6 @@
+import type { Budget } from "./budget.js";
+import type { SandboxObject } from "./values.js";
+export declare const generatorPrototypes: WeakMap<Budget, Map<boolean, {
+    functionPrototype: SandboxObject;
+    instancePrototype: SandboxObject;
+}>>;

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

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

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/function.d.ts

@@ -1,2 +1,2 @@
 import type { Budget } from "../budget.js";
-export declare function createFunctionPrototype(budget: Budget): void;
+export declare function createFunctionPrototype(budget: Budget, installHasInstance?: boolean): void;

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

@@ -1,8 +1,9 @@
 import { invokeBuiltinClosure } from "../builtin-call.js";
 import { callFunctionMethod } from "../methods/function.js";
-import { getSandboxPrototype, installFunctionPrototype, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
+import { getSandboxPrototype, installFunctionPrototype, materializeFunctionProperties, registerIntrinsicFunction, setSandboxPrototype } from "../object-model.js";
 import { createSandboxClosure } from "../values.js";
-export function createFunctionPrototype(budget) {
+import { ordinaryHasInstance } from "../instanceof.js";
+export function createFunctionPrototype(budget, installHasInstance = true) {
     const prototype = createSandboxClosure({ guest: true, sandbox: true, name: "", length: 0, call: () => undefined });
     const properties = materializeFunctionProperties(prototype);
     // Invocation support does not grant the host's dynamic source constructor.
@@ -19,6 +20,13 @@ export function createFunctionPrototype(budget) {
             })
         });
     }
+    const hasInstance = installHasInstance ? createSandboxClosure({ guest: true, sandbox: true, name: "[Symbol.hasInstance]", length: 1,
+        call: ([value], context) => ordinaryHasInstance(value, context?.thisValue, budget, context)
+    }) : undefined;
+    if (hasInstance !== undefined)
+        Object.defineProperty(properties, Symbol.hasInstance, { value: hasInstance });
     setSandboxPrototype(prototype, getSandboxPrototype(Object.create(null), budget));
     installFunctionPrototype(budget, prototype);
+    if (hasInstance !== undefined)
+        registerIntrinsicFunction(budget, hasInstance);
 }

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

@@ -0,0 +1,2 @@
+import type { Budget } from "../budget.js";
+export declare function createGeneratorPrototypes(budget: Budget): void;

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

@@ -0,0 +1,51 @@
+import { generatorPrototypes } from "../generator-prototypes.js";
+import { registerBuiltinIdentities, resolveIntrinsicIdentity } from "../intrinsics.js";
+import { callGeneratorMethod } from "../methods/generator.js";
+import { getSandboxPrototype, registerIntrinsicFunction, registerIntrinsicObject, setSandboxPrototype } from "../object-model.js";
+import { createSandboxClosure } from "../values.js";
+export function createGeneratorPrototypes(budget) {
+    const asyncIteratorPrototype = Object.create(null);
+    const asyncIterator = createSandboxClosure({ guest: true, sandbox: true,
+        name: "[Symbol.asyncIterator]", length: 0, call: (_args, context) => context?.thisValue });
+    Object.defineProperty(asyncIteratorPrototype, Symbol.asyncIterator, {
+        value: asyncIterator, writable: true, configurable: true
+    });
+    setSandboxPrototype(asyncIteratorPrototype, getSandboxPrototype(Object.create(null), budget));
+    registerBuiltinIdentities(budget, { "%AsyncIteratorPrototype%": asyncIteratorPrototype });
+    registerIntrinsicObject(budget, asyncIteratorPrototype);
+    registerIntrinsicFunction(budget, asyncIterator);
+    const state = new Map();
+    for (const async of [false, true]) {
+        const tag = async ? "AsyncGenerator" : "Generator";
+        const functionPrototype = Object.create(null);
+        const instancePrototype = Object.create(null);
+        setSandboxPrototype(functionPrototype, resolveIntrinsicIdentity(budget, JSON.stringify(["%FunctionPrototype%"])));
+        setSandboxPrototype(instancePrototype, async ? asyncIteratorPrototype
+            : resolveIntrinsicIdentity(budget, JSON.stringify(["%IteratorPrototype%"])));
+        Object.defineProperties(functionPrototype, {
+            prototype: { value: instancePrototype, configurable: true },
+            // Do not expose native dynamic-source constructors through this graph.
+            constructor: { value: undefined, configurable: true },
+            [Symbol.toStringTag]: { value: `${tag}Function`, configurable: true }
+        });
+        Object.defineProperties(instancePrototype, {
+            constructor: { value: functionPrototype, configurable: true },
+            [Symbol.toStringTag]: { value: tag, configurable: true }
+        });
+        for (const method of ["next", "return", "throw"]) {
+            Object.defineProperty(instancePrototype, method, { writable: true, configurable: true,
+                value: createSandboxClosure({ guest: true, sandbox: true, name: method, length: 1,
+                    call: ([value], context) => callGeneratorMethod(context?.thisValue, method, value, budget, context, async)
+                })
+            });
+        }
+        registerBuiltinIdentities(budget, {
+            [`%${tag}Prototype%`]: instancePrototype,
+            [`%${tag}FunctionPrototype%`]: functionPrototype
+        });
+        registerIntrinsicObject(budget, functionPrototype);
+        registerIntrinsicObject(budget, instancePrototype);
+        state.set(async, { functionPrototype, instancePrototype });
+    }
+    generatorPrototypes.set(budget, state);
+}