poe-code 14.0.79 → 14.0.80

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-B3AL4KJ3.js";
+} from "./chunks/chunk-34G5WW2O.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-BGSPSHLP.js";
+} from "./chunks/chunk-M4L3EZHL.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-BGSPSHLP.js";
+} from "./chunks/chunk-M4L3EZHL.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safe-js/dist/graph-depth.js

@@ -7,6 +7,7 @@ import { regexpIteratorState, isSandboxRegExpIterator } from "./interp/regexp-it
 import { isSandboxMap, isSandboxSet } from "./interp/collection-brands.js";
 import { boxedDataProperties, isSandboxBox } from "./interp/boxed.js";
 import { regexGuestProperties } from "./interp/regexp-properties.js";
+import { generatorGuestProperties } from "./interp/generator-properties.js";
 export const MAX_DATA_DEPTH = 1_024;
 export class SnapshotBudgetError extends Error {
     code = "budgetExceeded";
@@ -67,7 +68,7 @@ function walkGraphDepth(root, rootPath, assertDepth) {
     }
 }
 function graphEntries(value) {
-    const properties = regexGuestProperties.get(value);
+    const properties = regexGuestProperties.get(value) ?? generatorGuestProperties.get(value);
     if (properties !== undefined)
         return Reflect.ownKeys(properties).flatMap(key => {
             const descriptor = Object.getOwnPropertyDescriptor(properties, key);

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

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-B3AL4KJ3.js";
+} from "./chunks/chunk-34G5WW2O.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-BGSPSHLP.js";
+} from "./chunks/chunk-M4L3EZHL.js";
 import "./chunks/chunk-M2DLCGEF.js";
 import "./chunks/chunk-Q7USUEL7.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -0,0 +1,3 @@
+import type { SandboxGenerator, SandboxObject } from "./values.js";
+export declare const generatorGuestProperties: WeakMap<object, SandboxObject>;
+export declare function getGeneratorProperties(value: SandboxGenerator): SandboxObject;

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

@@ -0,0 +1,9 @@
+export const generatorGuestProperties = new WeakMap();
+export function getGeneratorProperties(value) {
+    let properties = generatorGuestProperties.get(value);
+    if (properties === undefined) {
+        properties = Object.create(null);
+        generatorGuestProperties.set(value, properties);
+    }
+    return properties;
+}

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

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

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

@@ -0,0 +1,24 @@
+import { invokeBuiltinClosure } from "../builtin-call.js";
+import { callFunctionMethod } from "../methods/function.js";
+import { getSandboxPrototype, installFunctionPrototype, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
+import { createSandboxClosure } from "../values.js";
+export function createFunctionPrototype(budget) {
+    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.
+    Object.defineProperty(properties, "constructor", { value: undefined, writable: true, configurable: true });
+    for (const [name, length] of [["call", 1], ["apply", 2], ["bind", 1], ["toString", 0]]) {
+        Object.defineProperty(properties, name, { writable: true, configurable: true,
+            value: createSandboxClosure({ guest: true, sandbox: true, name, length,
+                call: (args, context) => callFunctionMethod(context?.thisValue, name, args, {
+                    budget,
+                    callClosure: (target, values, stack, thisValue, construct, newTarget) => context?.invokeClosure !== undefined
+                        ? context.invokeClosure(target, values, thisValue, construct, newTarget)
+                        : invokeBuiltinClosure(target, values, budget, { ...context, stack, thisValue, newTarget }, thisValue, construct)
+                }, context?.stack ?? [], context)
+            })
+        });
+    }
+    setSandboxPrototype(prototype, getSandboxPrototype(Object.create(null), budget));
+    installFunctionPrototype(budget, prototype);
+}

package/packages/safe-js/dist/interp/globals/object-array.js

@@ -1,4 +1,5 @@
 import { isFatalSandboxError } from "../budget.js";
+import { getGeneratorProperties } from "../generator-properties.js";
 import { accessorAdapter, accessorClosure, readPropertyDescriptor, retainedAccessorClosures } from "../accessors.js";
 import { invokeBuiltinClosure } from "../builtin-call.js";
 import { createDataCheckpoint } from "../data-checkpoint.js";
@@ -180,14 +181,14 @@ export function createObjectArrayGlobals(options) {
                 call: ([value]) => {
                     if (isGuestHostObject(value))
                         throw new TypeError("Live host objects cannot be made non-extensible.");
-                    Object.preventExtensions(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+                    Object.preventExtensions(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
                     return value;
                 },
                 name: "preventExtensions"
             }),
             isExtensible: createSandboxClosure({
                 sandbox: true,
-                call: ([value]) => Object.isExtensible(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+                call: ([value]) => Object.isExtensible(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
                 name: "isExtensible"
             }),
             seal: createSandboxClosure({
@@ -195,14 +196,14 @@ export function createObjectArrayGlobals(options) {
                 call: ([value]) => {
                     if (isGuestHostObject(value))
                         throw new TypeError("Live host objects cannot be sealed.");
-                    Object.seal(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+                    Object.seal(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
                     return value;
                 },
                 name: "seal"
             }),
             isSealed: createSandboxClosure({
                 sandbox: true,
-                call: ([value]) => Object.isSealed(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+                call: ([value]) => Object.isSealed(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
                 name: "isSealed"
             }),
             freeze: createSandboxClosure({
@@ -211,7 +212,7 @@ export function createObjectArrayGlobals(options) {
                     if (isGuestHostObject(value))
                         throw new TypeError("Live host objects cannot be frozen.");
                     if (typeof value === "object" && value !== null) {
-                        Object.freeze(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
+                        Object.freeze(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value);
                     }
                     return value;
                 },
@@ -219,7 +220,7 @@ export function createObjectArrayGlobals(options) {
             }),
             isFrozen: createSandboxClosure({
                 sandbox: true,
-                call: ([value]) => Object.isFrozen(isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
+                call: ([value]) => Object.isFrozen(isSandboxGenerator(value) ? getGeneratorProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value),
                 name: "isFrozen"
             }),
             assign: createSandboxClosure({
@@ -556,6 +557,8 @@ function reflectionProperties(value) {
     return objectProperties(value);
 }
 export function objectProperties(value, mutable = false) {
+    if (isSandboxGenerator(value))
+        return getGeneratorProperties(value);
     if (isSandboxPromise(value))
         return getPromiseProperties(value);
     if (isSandboxMap(value) || isSandboxSet(value))

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

@@ -1,4 +1,5 @@
 import { assertSandboxDataDepth } from "../../graph-depth.js";
+import { getGeneratorProperties } from "../generator-properties.js";
 import { readPropertyDescriptor } from "../accessors.js";
 import { isSandboxArguments } from "../arguments.js";
 import { isSandboxDate } from "../date.js";
@@ -153,7 +154,7 @@ export function hasOwnSandboxProperty(value, key, enumerable) {
     else if (isSandboxPromise(value))
         properties = getPromiseProperties(value);
     else if (isSandboxGenerator(value))
-        return false;
+        properties = getGeneratorProperties(value);
     else if (isSandboxRegex(value))
         properties = getRegexProperties(value);
     else

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

@@ -7,6 +7,7 @@ import { createRegexGlobals } from "./globals/regex.js";
 import { createMiscGlobals } from "./globals/misc.js";
 import { createUriGlobals } from "./globals/uri.js";
 import { createObjectArrayGlobals } from "./globals/object-array.js";
+import { createFunctionPrototype } from "./globals/function.js";
 import { createPromiseGlobals } from "./promise.js";
 import { createDateGlobal } from "./globals/date.js";
 import { createSymbolGlobal } from "./globals/symbol.js";
@@ -28,6 +29,7 @@ export function createBuiltinBindings(options) {
         ...createPromiseGlobals(options),
         ...createRegexGlobals(options)
     };
+    createFunctionPrototype(options.budget);
     registerBuiltinIdentities(options.budget, bindings);
     return bindings;
 }

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

@@ -29,6 +29,7 @@ import { getPromiseMember } from "./promise.js";
 import { acquireSandboxIterator, closeIterator, readIteratorResult, restoreSandboxIterator } from "./iteration.js";
 import { assertCollectionMutable } from "./running-state.js";
 import { getGeneratorMember } from "./methods/generator.js";
+import { getGeneratorProperties } from "./generator-properties.js";
 import { getRegexMember, setRegexMember } from "./methods/regex.js";
 import { bindPattern } from "./patterns.js";
 import { callStringMethod, getStringMember, isStringMethodName, validateStringMethodArguments } from "./methods/string.js";
@@ -1494,7 +1495,7 @@ function forInKeys(object, budget) {
         if (depth > 0)
             budget.visitNode();
         assertSandboxDataDepth(depth++);
-        const properties = isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
+        const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
         for (const key of Object.getOwnPropertyNames(properties)) {
             if (seen.has(key))
                 continue;
@@ -1515,7 +1516,7 @@ function hasForInProperty(object, key, budget) {
         if (depth > 0)
             budget.visitNode();
         assertSandboxDataDepth(depth++);
-        const properties = isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
+        const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? materializeFunctionProperties(current) : isSandboxClosure(current) ? current.properties ?? {} : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
         if (Object.hasOwn(properties, key))
             return true;
     }
@@ -2097,7 +2098,8 @@ function getPropertyValue(target, property, context, receiver = target) {
     if (isSandboxCollectionIterator(target))
         return getCollectionIteratorMember(target, property, context.budget);
     if (isSandboxGenerator(target))
-        return getGeneratorMember(target, property, context.budget);
+        return hasExplicitSandboxPrototype(target)
+            ? undefined : getGeneratorMember(target, property, context.budget);
     if (isSandboxClosure(target))
         return getClosureMemberValue(target, property, context);
     if (isSandboxPromise(target))
@@ -2384,7 +2386,7 @@ async function evaluateMemberCallExpression(node, context) {
             return evaluatePrimitiveMemberCall(node, "Set", member.property, getSetMember(member.object, member.property, createSetMethodOptions(context)), context);
         }
         if (isSandboxGenerator(member.object)) {
-            const memberValue = getGeneratorMember(member.object, member.property, context.budget);
+            const memberValue = await getPropertyValue(member.object, member.property, context);
             if (memberValue === undefined) {
                 throw new TypeError(`Generator#${String(member.property)} is not a supported method.`);
             }
@@ -2662,7 +2664,7 @@ function hasSandboxProperty(value, key, context) {
             return typeof key === "symbol" ? false : hasHostObjectMember(current, String(key));
         if (hasOwnSandboxProperty(current, key, false))
             return true;
-        if (!isSandboxDate(current) && !isSandboxRegex(current) && !isSandboxMap(current) && !isSandboxSet(current) && !((isGuestClosure(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) &&
+        if (!isSandboxDate(current) && !isSandboxRegex(current) && !isSandboxMap(current) && !isSandboxSet(current) && !((isGuestClosure(current) || isSandboxGenerator(current) || Array.isArray(current)) && hasExplicitSandboxPrototype(current)) &&
             (Array.isArray(current) || !isPlainSandboxObject(current) ||
                 isSandboxDate(current) || isFloat32Array(current) || isSandboxGenerator(current) || isSandboxCollectionIterator(current) || isSandboxRegExpIterator(current))) {
             return getPropertyValue(current, key, context) !== undefined;
@@ -2941,6 +2943,8 @@ export function setSandboxProperty(target, property, value, budget, checkInherit
         target = materializeFunctionProperties(target);
     if (isSandboxPromise(target))
         target = getPromiseProperties(target);
+    if (isSandboxGenerator(target))
+        target = getGeneratorProperties(target);
     if (isSandboxMap(target) || isSandboxSet(target))
         target = getCollectionProperties(target);
     if (isFloat32Array(target)) {
@@ -2977,7 +2981,7 @@ export function setSandboxProperty(target, property, value, budget, checkInherit
             for (let prototype = getSandboxPrototype(prototypeOwner, budget); prototype !== null; prototype = getSandboxPrototype(prototype, budget)) {
                 budget.visitNode();
                 assertSandboxDataDepth(depth++);
-                const properties = isSandboxClosure(prototype) ? prototype.properties : prototype;
+                const properties = isSandboxGenerator(prototype) ? getGeneratorProperties(prototype) : isSandboxClosure(prototype) ? prototype.properties : prototype;
                 const inherited = properties === undefined ? undefined : Object.getOwnPropertyDescriptor(properties, key);
                 if (inherited === undefined)
                     continue;
@@ -2997,7 +3001,7 @@ function setSuperProperty(base, receiver, key, value, context) {
     for (let current = base; current !== null; current = getSandboxPrototype(current, budget)) {
         budget.visitNode();
         assertSandboxDataDepth(depth++);
-        const properties = isSandboxClosure(current) ? current.properties : current;
+        const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxClosure(current) ? current.properties : current;
         const descriptor = properties === undefined ? undefined : Object.getOwnPropertyDescriptor(properties, key);
         if (descriptor === undefined)
             continue;
@@ -3020,6 +3024,8 @@ export function deleteSandboxProperty(target, property) {
         target = getRegexProperties(target);
     if (isSandboxPromise(target))
         target = getPromiseProperties(target);
+    if (isSandboxGenerator(target))
+        target = getGeneratorProperties(target);
     if (isSandboxMap(target) || isSandboxSet(target))
         target = getCollectionProperties(target);
     if (Array.isArray(target)) {

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

@@ -31,8 +31,9 @@ export async function restoreSandboxIterator(snapshot, budget, context, signal)
         return asyncFromSyncIterator(await restoreSandboxIterator(snapshot.inner, budget, context, signal), budget, signal, context);
     if (Array.isArray(snapshot.value))
         return arrayIterator(snapshot.value, context, budget, snapshot.index);
-    const iterator = isSandboxGenerator(snapshot.value) && snapshot.value.async
-        ? getSandboxAsyncIterator(snapshot.value, budget, context, signal)
+    const iterator = isSandboxGenerator(snapshot.value)
+        ? { ...generatorObjectIterator(snapshot.value, budget, context),
+            ...(snapshot.value.async ? { asyncProtocol: true } : {}) }
         : getSandboxIterator(snapshot.value, budget, context);
     if (iterator === undefined)
         throw new TypeError("Invalid builtin iterator snapshot.");
@@ -49,6 +50,12 @@ export async function acquireSandboxIterator(value, budget, context, asyncProtoc
             : getSandboxIterator(value, budget, context);
     if (getSandboxPropertyDescriptor(value, key, budget) === undefined &&
         !(isSandboxRegExpIterator(value) && !asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== undefined)) {
+        if (isSandboxGenerator(value)) {
+            if (hasExplicitSandboxPrototype(value))
+                return undefined;
+            if ((value.async === true) === asyncProtocol && getSandboxPropertyDescriptor(value, "next", budget) !== undefined)
+                return guestIterator(value, await context.getProperty(value, "next"), asyncProtocol, budget, context, signal);
+        }
         if (!asyncProtocol && Array.isArray(value) && getSandboxPrototype(value, budget) !== null)
             return undefined;
         if (!asyncProtocol)
@@ -130,7 +137,8 @@ export async function readIteratorResult(iterator, result, property) {
 }
 export function getSandboxAsyncIterator(value, budget, context, signal) {
     if (isSandboxGenerator(value) && value.async) {
-        return { ...generatorIterator(value, budget, context), asyncProtocol: true };
+        return hasExplicitSandboxPrototype(value) ? undefined
+            : { ...generatorObjectIterator(value, budget, context), asyncProtocol: true };
     }
     if (value !== null &&
         (typeof value === "object" || typeof value === "function") &&
@@ -288,7 +296,7 @@ export function getSandboxIterator(value, budget, context) {
         return syncIterator(Float32Array.prototype.values.call(value));
     }
     if (isSandboxGenerator(value)) {
-        return value.async ? undefined : generatorIterator(value);
+        return value.async || hasExplicitSandboxPrototype(value) ? undefined : generatorObjectIterator(value, budget, context);
     }
     if (typeof value === "string") {
         const iterator = value[Symbol.iterator]();
@@ -373,6 +381,31 @@ function collectionIterator(collection, value) {
     return adapter;
 }
 const asyncGeneratorRequests = new WeakMap();
+function generatorObjectIterator(generator, budget, context) {
+    const iterator = generatorIterator(generator, budget, context);
+    if (context?.getProperty === undefined)
+        return iterator;
+    return {
+        ...iterator,
+        getOperation: async (method) => {
+            if (method === "next" || (!hasExplicitSandboxPrototype(generator) &&
+                getSandboxPropertyDescriptor(generator, method, budget) === undefined))
+                return iterator[method];
+            const operation = await context.getProperty(generator, method);
+            if (operation === undefined || operation === null)
+                return undefined;
+            if (!isSandboxClosure(operation))
+                throw new TypeError("Iterator operation must be callable.");
+            return async (...args) => {
+                const result = await invokeBuiltinClosure(operation, args, budget ?? new Budget(), context, generator);
+                return (generator.async ? await awaitSandboxValue(result, undefined, budget, context) : result);
+            };
+        },
+        readResultProperty: async (result, property) => ({
+            value: await context.getProperty(result, property)
+        })
+    };
+}
 export function generatorIterator(generator, budget, context) {
     const invoke = async (method, value) => {
         const leaveRunning = enterRunningState(generator);

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

@@ -1,7 +1,10 @@
-import { type SandboxClosure, type SandboxValue } from "../values.js";
+import { type SandboxCallContext, type SandboxClosure, type SandboxValue } from "../values.js";
 import type { Budget } from "../budget.js";
 export type FunctionMethodOptions = {
     budget?: Budget;
     callClosure: (closure: SandboxClosure, args: readonly SandboxValue[], stack: readonly string[], thisValue: SandboxValue, construct?: boolean, newTarget?: SandboxClosure) => Promise<SandboxValue> | SandboxValue;
 };
+type FunctionMethodName = "apply" | "bind" | "call" | "toString";
 export declare function getFunctionMember(target: SandboxClosure, property: string | number, options: FunctionMethodOptions): SandboxValue | undefined;
+export declare function callFunctionMethod(target: SandboxValue, methodName: FunctionMethodName, args: readonly SandboxValue[], options: FunctionMethodOptions, stack: readonly string[], context?: SandboxCallContext): Promise<SandboxValue> | SandboxValue;
+export {};

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

@@ -22,7 +22,7 @@ export function getFunctionMember(target, property, options) {
         else if (Object.hasOwn(current, String(property))) {
             return current[String(property)];
         }
-        if (isSandboxClosure(current) && !hasExplicitSandboxPrototype(current))
+        if (isSandboxClosure(current) && !hasExplicitSandboxPrototype(current) && getSandboxPrototype(current, options.budget) === null)
             break;
         current = getSandboxPrototype(current, options.budget);
         if (current !== null) {
@@ -47,7 +47,7 @@ export function getFunctionMember(target, property, options) {
 function isFunctionMethodName(property) {
     return typeof property === "string" && functionMethodNames.has(property);
 }
-function callFunctionMethod(target, methodName, args, options, stack, context) {
+export function callFunctionMethod(target, methodName, args, options, stack, context) {
     if (!isSandboxClosure(target)) {
         throw new TypeError(`Function#${methodName} requires a callable receiver.`);
     }

package/packages/safe-js/dist/interp/object-model.d.ts

@@ -7,6 +7,7 @@ export declare function getGuestFunctionProperties(closure: SandboxClosure): San
 export declare function materializeFunctionProperties(closure: SandboxClosure): SandboxObject;
 export declare function getGuestFunctionProperty(closure: SandboxClosure, key: PropertyKey): SandboxValue;
 export declare function installObjectPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure): void;
+export declare function installFunctionPrototype(budget: Budget, prototype: SandboxClosure): void;
 export declare function installBoxedPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure, kind?: BoxedKind): void;
 export declare function getBoxedPrototype(value: BoxedPrimitive, budget: Budget): SandboxObject | undefined;
 export declare function installRegexPrototype(budget: Budget, prototype: SandboxObject, constructor: SandboxClosure): void;

package/packages/safe-js/dist/interp/object-model.js

@@ -1,4 +1,6 @@
 import { assertSandboxDataDepth } from "../graph-depth.js";
+import { getGeneratorProperties } from "./generator-properties.js";
+import { runResources } from "./resources.js";
 import { getIntrinsicIdentity, registerBuiltinIdentities, releaseIntrinsicIdentities } from "./intrinsics.js";
 import { releaseTemplateObjects } from "./template-objects.js";
 import { isSandboxDate } from "./date.js";
@@ -8,6 +10,7 @@ import { boxedValue, isSandboxBox } from "./boxed.js";
 import { isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, getPromiseProperties, isSandboxRegex, getRegexProperties, getCollectionProperties, isSandboxSet } from "./values.js";
 const guestClosures = new WeakSet();
 const functionProperties = new WeakMap();
+const functionPropertyRevisions = new WeakMap();
 const prototypes = new WeakMap();
 const intrinsicPrototypes = new WeakMap();
 const boxedPrototypes = new WeakMap();
@@ -16,6 +19,7 @@ const collectionPrototypes = new WeakMap();
 const promisePrototypes = new WeakMap();
 const datePrototypes = new WeakMap();
 const arrayPrototypes = new WeakMap();
+const functionPrototypes = new WeakMap();
 const initialArrayMethods = new WeakMap();
 const initialRegexDescriptors = new WeakMap();
 const intrinsicPrototypeRoots = new WeakMap();
@@ -53,9 +57,26 @@ export function materializeFunctionProperties(closure) {
         descriptorObjects.add(prototype);
         Object.defineProperty(properties, "prototype", { value: prototype, writable: true });
     }
-    descriptorObjects.add(properties);
-    functionProperties.set(closure, properties);
-    return properties;
+    // Never expose the raw table: native callers must invalidate captures too.
+    const state = { revision: 0 };
+    const tracked = new Proxy(properties, {
+        defineProperty(target, key, descriptor) {
+            const changed = Reflect.defineProperty(target, key, descriptor);
+            if (changed)
+                state.revision++;
+            return changed;
+        },
+        deleteProperty(target, key) {
+            const changed = Reflect.deleteProperty(target, key);
+            if (changed)
+                state.revision++;
+            return changed;
+        }
+    });
+    functionPropertyRevisions.set(tracked, state);
+    descriptorObjects.add(tracked);
+    functionProperties.set(closure, tracked);
+    return tracked;
 }
 export function getGuestFunctionProperty(closure, key) {
     let properties = functionProperties.get(closure);
@@ -79,6 +100,12 @@ export function installObjectPrototype(budget, prototype, constructor) {
     intrinsicPrototypes.set(budget, prototype);
     registerIntrinsicPrototype(budget, prototype, constructor);
 }
+export function installFunctionPrototype(budget, prototype) {
+    functionPrototypes.set(budget, prototype);
+    registerBuiltinIdentities(budget, { "%FunctionPrototype%": prototype });
+    registerIntrinsicFunction(budget, prototype);
+    registerIntrinsicObject(budget, materializeFunctionProperties(prototype));
+}
 export function installBoxedPrototype(budget, prototype, constructor, kind = typeof boxedValue(prototype)) {
     let state = boxedPrototypes.get(budget);
     if (state === undefined)
@@ -181,6 +208,9 @@ function trackIntrinsicState(budget, root, owner, targets) {
     }))
         .map((record) => ({
         ...record,
+        revision: functionPropertyRevisions.get(record.value),
+        capturedRevision: -1,
+        captured: [],
         extensible: Object.isExtensible(record.value),
         descriptors: new Map(Reflect.ownKeys(record.value).map(key => [key, Object.getOwnPropertyDescriptor(record.value, key)]))
     }));
@@ -206,16 +236,24 @@ function trackIntrinsicState(budget, root, owner, targets) {
     budget.setRetainedValues(root, () => {
         // Capture every change before measurement invokes retained-value callbacks.
         const retained = [];
-        for (const { target, value, descriptors, prototype: parent } of records) {
+        for (const record of records) {
+            const { target, value, descriptors, prototype: parent, revision } = record;
             const currentPrototype = getSandboxPrototype(target);
             if (currentPrototype !== parent)
                 retained.push(currentPrototype);
-            for (const key of Reflect.ownKeys(value)) {
-                const descriptor = Object.getOwnPropertyDescriptor(value, key);
-                if (unchanged(descriptors.get(key), descriptor))
-                    continue;
-                retained.push(key, descriptor.value, ...retainedAccessorClosures(descriptor));
+            if (revision === undefined || revision.revision !== record.capturedRevision) {
+                const captured = [];
+                for (const key of Reflect.ownKeys(value)) {
+                    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                    if (unchanged(descriptors.get(key), descriptor))
+                        continue;
+                    captured.push(key, descriptor.value, ...retainedAccessorClosures(descriptor));
+                }
+                record.captured = captured;
+                record.capturedRevision = revision?.revision ?? -1;
             }
+            for (const item of record.captured)
+                retained.push(item);
         }
         return retained;
     });
@@ -232,12 +270,15 @@ export function releaseObjectPrototype(budget) {
     promisePrototypes.delete(budget);
     datePrototypes.delete(budget);
     arrayPrototypes.delete(budget);
+    functionPrototypes.delete(budget);
     initialRegexDescriptors.delete(budget);
     intrinsicPrototypes.delete(budget);
 }
 export function getSandboxPrototype(value, budget) {
     if (prototypes.has(value))
         return prototypes.get(value) ?? null;
+    if (budget !== undefined && isGuestClosure(value) && runResources.getStore()?.functionSourceText !== false)
+        return functionPrototypes.get(budget) ?? null;
     if (budget !== undefined && Array.isArray(value))
         return arrayPrototypes.get(budget) ?? null;
     if (budget !== undefined && isSandboxDate(value))
@@ -273,9 +314,14 @@ export function getSandboxPropertyDescriptor(value, key, budget) {
     let depth = 0;
     while (typeof current === "object" &&
         current !== null &&
-        (Array.isArray(current) || isSandboxDate(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
-        const properties = isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? getGuestFunctionProperties(current)
+        (Array.isArray(current) || isSandboxGenerator(current) || isSandboxDate(current) || isSandboxPromise(current) || isSandboxRegex(current) || isSandboxMap(current) || isSandboxSet(current) || isPrototypeRecord(current))) {
+        const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current)
+            ? key === "prototype" && current.construct !== undefined && current.boundTarget === undefined
+                ? materializeFunctionProperties(current) : getGuestFunctionProperties(current)
             : isSandboxRegex(current) ? getRegexProperties(current) : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
+        if (properties === undefined && isGuestClosure(current) && (key === "name" || key === "length"))
+            return { value: key === "name" ? current.name ?? "" : current.length ?? 0,
+                writable: false, enumerable: false, configurable: true };
         const descriptor = properties === undefined ? undefined : Object.getOwnPropertyDescriptor(properties, key);
         if (descriptor !== undefined)
             return descriptor;
@@ -297,6 +343,11 @@ export function getSandboxDataProperty(value, key, budget) {
             return Object.getOwnPropertyDescriptor(getRegexProperties(current), key)?.value;
         if (isSandboxPromise(current))
             return Object.getOwnPropertyDescriptor(getPromiseProperties(current), key)?.value;
+        if (isSandboxGenerator(current)) {
+            const descriptor = Object.getOwnPropertyDescriptor(getGeneratorProperties(current), key);
+            if (descriptor !== undefined)
+                return descriptor.value;
+        }
         if (isSandboxMap(current) || isSandboxSet(current))
             return Object.getOwnPropertyDescriptor(getCollectionProperties(current), key)?.value;
         if (isGuestClosure(current)) {
@@ -313,10 +364,9 @@ export function getSandboxDataProperty(value, key, budget) {
         if (isSandboxMap(current) ||
             isSandboxSet(current) ||
             isSandboxPromise(current) ||
-            isSandboxRegex(current) ||
-            isSandboxGenerator(current))
+            isSandboxRegex(current))
             return undefined;
-        if (!isSandboxClosure(current) && Object.hasOwn(current, key))
+        if (!isSandboxClosure(current) && !isSandboxGenerator(current) && Object.hasOwn(current, key))
             return current[key];
         current = getSandboxPrototype(current, budget);
         if (current !== null) {
@@ -330,8 +380,8 @@ export function setSandboxPrototype(value, prototype, budget) {
     if (budget !== undefined && intrinsicPrototypes.get(budget) === value && prototype !== null) {
         throw new TypeError("Object.prototype has an immutable null prototype.");
     }
-    if ((!Array.isArray(value) && !isSandboxDate(value) && !isSandboxPromise(value) && !isSandboxRegex(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isPrototypeRecord(value)) ||
-        (prototype !== null && !Array.isArray(prototype) && !isSandboxDate(prototype) && !isSandboxPromise(prototype) && !isSandboxRegex(prototype) && !isSandboxMap(prototype) && !isSandboxSet(prototype) && !isPrototypeRecord(prototype))) {
+    if ((!Array.isArray(value) && !isSandboxGenerator(value) && !isSandboxDate(value) && !isSandboxPromise(value) && !isSandboxRegex(value) && !isSandboxMap(value) && !isSandboxSet(value) && !isPrototypeRecord(value)) ||
+        (prototype !== null && !Array.isArray(prototype) && !isSandboxGenerator(prototype) && !isSandboxDate(prototype) && !isSandboxPromise(prototype) && !isSandboxRegex(prototype) && !isSandboxMap(prototype) && !isSandboxSet(prototype) && !isPrototypeRecord(prototype))) {
         throw new TypeError("Prototype links require supported sandbox objects.");
     }
     if (getSandboxPrototype(value, budget) === prototype) {
@@ -340,7 +390,7 @@ export function setSandboxPrototype(value, prototype, budget) {
             prototypes.set(value, null);
         return;
     }
-    if (!Object.isExtensible(isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value)) {
+    if (!Object.isExtensible(isSandboxGenerator(value) ? getGeneratorProperties(value) : isGuestClosure(value) ? materializeFunctionProperties(value) : isSandboxPromise(value) ? getPromiseProperties(value) : isSandboxRegex(value) ? getRegexProperties(value) : isSandboxMap(value) || isSandboxSet(value) ? getCollectionProperties(value) : value)) {
         throw new TypeError("Cannot change the prototype of a non-extensible object.");
     }
     let depth = 0;

package/packages/safe-js/dist/interp/string-coercion.js

@@ -1,4 +1,5 @@
 import { sandboxErrorTypes } from "../error/shape.js";
+import { getGeneratorProperties } from "./generator-properties.js";
 import { readPropertyDescriptor } from "./accessors.js";
 import { dateString, dateTime, isSandboxDate } from "./date.js";
 import { invokeBuiltinClosure } from "./builtin-call.js";
@@ -115,7 +116,7 @@ function conversionHook(value, name, budget, context) {
         ((Array.isArray(value) && getSandboxPrototype(value, budget) === null) ||
             isFloat32Array(value) ||
             sandboxErrorTypes.has(value) ||
-            isSandboxClosure(value) ||
+            (isSandboxClosure(value) && getSandboxPrototype(value, budget) === null) ||
             isSandboxMap(value) ||
             isSandboxSet(value) ||
             isSandboxCollectionIterator(value) ||
@@ -127,7 +128,7 @@ function conversionHook(value, name, budget, context) {
     let current = value;
     let depth = 0;
     while (current !== null) {
-        const properties = isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? getGuestFunctionProperties(current)
+        const properties = isSandboxGenerator(current) ? getGeneratorProperties(current) : isSandboxPromise(current) ? getPromiseProperties(current) : isGuestClosure(current) ? getGuestFunctionProperties(current)
             : isSandboxRegex(current) ? getRegexProperties(current)
                 : isSandboxMap(current) || isSandboxSet(current) ? getCollectionProperties(current) : current;
         const descriptor = properties === undefined ? undefined : Object.getOwnPropertyDescriptor(properties, name);