poe-code 14.0.64 → 14.0.66

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

@@ -1,20 +1,22 @@
 import { isFatalSandboxError } from "../budget.js";
+import { accessorAdapter, accessorClosure, retainedAccessorClosures } from "../accessors.js";
 import { invokeBuiltinClosure } from "../builtin-call.js";
 import { createDataCheckpoint } from "../data-checkpoint.js";
+import { retainValues } from "../resources.js";
 import { isCapturedException } from "../exceptions.js";
 import { isSandboxDate } from "../date.js";
 import { createSandboxBox } from "../boxed.js";
 import { getDatePrototype } from "./date.js";
 import { createObjectGlobal, hasOwnSandboxProperty } from "./object.js";
-import { getHostObjectKeys, isGuestHostObject } from "../host-capabilities.js";
+import { isGuestHostObject } from "../host-capabilities.js";
 import { isFloat32Array } from "../float32.js";
 import { setSandboxProperty } from "../interpreter.js";
 import { getSandboxIterator } from "../iteration.js";
 import { sandboxNumber, sandboxString } from "../string-coercion.js";
 import { createNumericParsers } from "./numeric-parsers.js";
 import { createPrimitiveConstructor } from "./primitives.js";
-import { getSandboxDataProperty, getSandboxPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
-import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, defineOwnDataProperty, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, measureSandboxData, ownEnumerableSandboxEntries as getOwnEnumerableEntries } from "../values.js";
+import { getSandboxDataProperty, getSandboxPropertyDescriptor, getSandboxPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
+import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, defineOwnDataProperty, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, measureSandboxData, ownEnumerableSandboxKeys as getOwnEnumerableKeys, ownEnumerableSandboxEntries as getDirectEntries } from "../values.js";
 export function createObjectArrayGlobals(options) {
     return {
         Object: createObjectGlobal({
@@ -25,12 +27,16 @@ export function createObjectArrayGlobals(options) {
             }),
             values: createSandboxClosure({
                 sandbox: true,
-                call: ([value]) => allocateProducedSandboxValue(getOwnEnumerableValues(value), options.budget),
+                call: ([value], context) => context === undefined
+                    ? allocateProducedSandboxValue(getDirectEntries(value).map(([, entry]) => entry), options.budget)
+                    : getOwnEnumerableEntries(value, options.budget, context).then((entries) => allocateProducedSandboxValue(entries.map(([, entry]) => entry), options.budget)),
                 name: "values"
             }),
             entries: createSandboxClosure({
                 sandbox: true,
-                call: ([value]) => allocateProducedSandboxValue(getOwnEnumerableEntries(value), options.budget),
+                call: ([value], context) => context === undefined
+                    ? allocateProducedSandboxValue(getDirectEntries(value), options.budget)
+                    : getOwnEnumerableEntries(value, options.budget, context).then((entries) => allocateProducedSandboxValue(entries, options.budget)),
                 name: "entries"
             }),
             hasOwn: createSandboxClosure({
@@ -41,7 +47,7 @@ export function createObjectArrayGlobals(options) {
                     const name = sandboxString(key, options.budget, context);
                     return typeof name === "string"
                         ? hasOwnSandboxProperty(value, name, false)
-                        : name.then(property => hasOwnSandboxProperty(value, property, false));
+                        : name.then((property) => hasOwnSandboxProperty(value, property, false));
                 },
                 name: "hasOwn"
             }),
@@ -49,12 +55,22 @@ export function createObjectArrayGlobals(options) {
                 sandbox: true,
                 call: async ([value, key], context) => {
                     const descriptor = Object.getOwnPropertyDescriptor(objectProperties(value), await sandboxString(key, options.budget, context));
-                    if (descriptor !== undefined && !("value" in descriptor))
-                        throw new TypeError("Only data property descriptors are supported.");
-                    return descriptor === undefined ? undefined : allocateProducedSandboxValue(descriptor, options.budget);
+                    if (descriptor === undefined)
+                        return undefined;
+                    return allocateProducedSandboxValue(exposePropertyDescriptor(descriptor), options.budget);
                 },
                 name: "getOwnPropertyDescriptor"
             }),
+            getOwnPropertyDescriptors: createSandboxClosure({
+                sandbox: true,
+                call: ([value]) => {
+                    const descriptors = Object.create(null);
+                    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(objectProperties(value))))
+                        defineOwnDataProperty(descriptors, key, exposePropertyDescriptor(descriptor));
+                    return allocateProducedSandboxValue(descriptors, options.budget);
+                },
+                name: "getOwnPropertyDescriptors"
+            }),
             getOwnPropertyNames: createSandboxClosure({
                 sandbox: true,
                 call: ([value]) => budgetSandboxValue(Object.getOwnPropertyNames(objectProperties(value)), options.budget),
@@ -63,18 +79,17 @@ export function createObjectArrayGlobals(options) {
             defineProperty: createSandboxClosure({
                 sandbox: true,
                 call: async ([value, key, descriptor], context) => {
-                    defineDataProperty(value, await sandboxString(key, options.budget, context), dataDescriptor(descriptor), options.budget);
+                    objectProperties(value, true);
+                    const property = await sandboxString(key, options.budget, context);
+                    defineDataProperty(value, property, await propertyDescriptor(descriptor, options.budget, context), options.budget);
                     return value;
                 },
                 name: "defineProperty"
             }),
             defineProperties: createSandboxClosure({
                 sandbox: true,
-                call: ([value, descriptors]) => {
-                    const properties = getOwnEnumerableEntries(descriptors).map(([key, descriptor]) => [key, dataDescriptor(descriptor)]);
-                    for (const [key, descriptor] of properties) {
-                        defineDataProperty(value, key, descriptor, options.budget);
-                    }
+                call: async ([value, descriptors], context) => {
+                    await definePropertiesFromObject(value, descriptors, options.budget, context);
                     return value;
                 },
                 name: "defineProperties"
@@ -104,16 +119,13 @@ export function createObjectArrayGlobals(options) {
             }),
             create: createSandboxClosure({
                 sandbox: true,
-                call: ([prototype, descriptors]) => {
+                call: async ([prototype, descriptors], context) => {
                     if (prototype !== null)
                         objectProperties(prototype);
                     const value = Object.create(null);
                     setSandboxPrototype(value, prototype, options.budget);
                     if (descriptors !== undefined) {
-                        const properties = getOwnEnumerableEntries(descriptors).map(([key, descriptor]) => [key, dataDescriptor(descriptor)]);
-                        for (const [key, descriptor] of properties) {
-                            defineDataProperty(value, key, descriptor, options.budget);
-                        }
+                        await definePropertiesFromObject(value, descriptors, options.budget, context);
                     }
                     return allocateProducedSandboxValue(value, options.budget);
                 },
@@ -133,7 +145,9 @@ export function createObjectArrayGlobals(options) {
                     }
                     if (context === undefined && !iterator.generator && !iterator.asynchronous) {
                         // The direct host adapter preserves synchronous results and native hooks.
-                        return allocateProducedSandboxValue(Object.setPrototypeOf(Reflect.apply(Object.fromEntries, Object, [{ [Symbol.iterator]: () => iterator }]), null), options.budget);
+                        return allocateProducedSandboxValue(Object.setPrototypeOf(Reflect.apply(Object.fromEntries, Object, [
+                            { [Symbol.iterator]: () => iterator }
+                        ]), null), options.budget);
                     }
                     return objectFromSandboxEntries(value, iterator, options.budget, context);
                 },
@@ -158,7 +172,7 @@ export function createObjectArrayGlobals(options) {
             }),
             assign: createSandboxClosure({
                 sandbox: true,
-                call: ([target, ...sources]) => assignSandboxValues(target, sources, options.budget),
+                call: ([target, ...sources], context) => assignSandboxValues(target, sources, options.budget, context),
                 name: "assign"
             })
         }, options.budget),
@@ -191,7 +205,7 @@ export function createObjectArrayGlobals(options) {
             properties: {
                 raw: createSandboxClosure({
                     sandbox: true,
-                    call: (args) => stringRaw(args, options.budget),
+                    call: (args, context) => stringRaw(args, options.budget, context),
                     name: "raw"
                 }),
                 fromCharCode: createSandboxClosure({
@@ -254,7 +268,15 @@ async function objectFromSandboxEntries(items, iterator, budget, context) {
     let value;
     let failure;
     const retained = {};
-    budget.setRetainedValues(retained, () => [items, iterator.retainedValue, object, entry, key, value, failure]);
+    budget.setRetainedValues(retained, () => [
+        items,
+        iterator.retainedValue,
+        object,
+        entry,
+        key,
+        value,
+        failure
+    ]);
     const checkData = createDataCheckpoint(budget, context);
     const closeOnThrow = async (error) => {
         failure = isCapturedException(error) ? error.reason : error;
@@ -287,14 +309,17 @@ async function objectFromSandboxEntries(items, iterator, budget, context) {
                 if (typeof entry !== "object" || entry === null) {
                     throw new TypeError("Object.fromEntries requires entry objects.");
                 }
-                key = context?.getProperty !== undefined
-                    ? context.getProperty(entry, 0)
-                    : getSandboxDataProperty(entry, 0, budget);
-                value = context?.getProperty !== undefined
-                    ? context.getProperty(entry, 1)
-                    : getSandboxDataProperty(entry, 1, budget);
+                key =
+                    context?.getProperty !== undefined
+                        ? await context.getProperty(entry, 0)
+                        : getSandboxDataProperty(entry, 0, budget);
+                value =
+                    context?.getProperty !== undefined
+                        ? await context.getProperty(entry, 1)
+                        : getSandboxDataProperty(entry, 1, budget);
                 const property = await sandboxString(key, budget, context);
-                const growth = property.length + 1 +
+                const growth = property.length +
+                    1 +
                     (budget.limits.dataSize === undefined ? 0 : measureSandboxData([value]));
                 budget.visitNode();
                 defineOwnDataProperty(object, property, value);
@@ -312,7 +337,7 @@ async function objectFromSandboxEntries(items, iterator, budget, context) {
         budget.setRetainedValues(retained, undefined);
     }
 }
-function assignSandboxValues(target, sources, budget) {
+function assignSandboxValues(target, sources, budget, context) {
     if (target === null || target === undefined) {
         throw new TypeError("Object.assign(target, ...sources) requires a non-null target.");
     }
@@ -323,15 +348,36 @@ function assignSandboxValues(target, sources, budget) {
     if (!isGuestClosure(target) && !isAssignableSandboxTarget(target)) {
         throw new TypeError("Object.assign(target, ...sources) requires an object or array target.");
     }
-    for (const source of sources) {
-        if (source === null || source === undefined) {
-            continue;
-        }
-        for (const [key, value] of getOwnEnumerableEntries(source)) {
-            setSandboxProperty(target, key, value, budget);
+    if (context === undefined) {
+        for (const source of sources) {
+            if (source === null || source === undefined)
+                continue;
+            for (const [key, value] of getDirectEntries(source))
+                setSandboxProperty(target, key, value, budget);
         }
+        return target;
     }
-    return target;
+    return (async () => {
+        const release = retainValues(budget, () => [target, ...sources]);
+        try {
+            for (const source of sources) {
+                if (source === null || source === undefined)
+                    continue;
+                for (const key of getOwnEnumerableKeys(source)) {
+                    if (!hasOwnSandboxProperty(source, key, true))
+                        continue;
+                    const value = await (context.getProperty !== undefined
+                        ? context.getProperty(source, key)
+                        : getSandboxDataProperty(source, key, budget));
+                    await setSandboxProperty(target, key, value, budget, true, context);
+                }
+            }
+            return target;
+        }
+        finally {
+            release();
+        }
+    })();
 }
 function objectProperties(value, mutable = false) {
     if (isSandboxDate(value)) {
@@ -352,24 +398,87 @@ function objectProperties(value, mutable = false) {
         throw new TypeError("Expected a sandbox object or function.");
     return value;
 }
-function dataDescriptor(input) {
-    const source = objectProperties(input);
+function exposePropertyDescriptor(descriptor) {
+    return ("value" in descriptor
+        ? descriptor
+        : {
+            get: accessorClosure(descriptor.get),
+            set: accessorClosure(descriptor.set),
+            enumerable: descriptor.enumerable,
+            configurable: descriptor.configurable
+        });
+}
+async function propertyDescriptor(input, budget, context) {
+    objectProperties(input);
     const descriptor = {};
-    for (const field of ["get", "set", "value", "writable", "enumerable", "configurable"]) {
-        const entry = Object.getOwnPropertyDescriptor(source, field);
-        if (entry === undefined)
-            continue;
-        if (!("value" in entry) || field === "get" || field === "set") {
-            throw new TypeError("Only data property descriptors are supported.");
+    const release = retainValues(budget, () => [
+        input,
+        descriptor.value,
+        ...retainedAccessorClosures(descriptor)
+    ]);
+    try {
+        for (const field of [
+            "enumerable",
+            "configurable",
+            "value",
+            "writable",
+            "get",
+            "set"
+        ]) {
+            if (getSandboxPropertyDescriptor(input, field, budget) === undefined &&
+                !hasOwnSandboxProperty(input, field, false))
+                continue;
+            const value = await (context?.getProperty !== undefined
+                ? context.getProperty(input, field)
+                : getSandboxDataProperty(input, field, budget));
+            if (field === "get" || field === "set") {
+                if (value !== undefined && !isSandboxClosure(value))
+                    throw new TypeError("Accessor must be a function or undefined.");
+                descriptor[field] =
+                    value === undefined ? undefined : accessorAdapter(value, field);
+            }
+            else if (field === "value") {
+                descriptor.value = value;
+            }
+            else {
+                descriptor[field] = Boolean(value);
+            }
+        }
+        if (("get" in descriptor || "set" in descriptor) &&
+            ("value" in descriptor || "writable" in descriptor))
+            throw new TypeError("A property cannot be both a data property and an accessor.");
+        return descriptor;
+    }
+    finally {
+        release();
+    }
+}
+async function definePropertiesFromObject(target, descriptors, budget, context) {
+    objectProperties(target, true);
+    const properties = [];
+    const release = retainValues(budget, () => [
+        target,
+        descriptors,
+        properties,
+        ...properties.flatMap(([, descriptor]) => retainedAccessorClosures(descriptor))
+    ]);
+    try {
+        for (const key of getOwnEnumerableKeys(descriptors)) {
+            if (!hasOwnSandboxProperty(descriptors, key, true))
+                continue;
+            const descriptor = await (context?.getProperty !== undefined
+                ? context.getProperty(descriptors, key)
+                : getSandboxDataProperty(descriptors, key, budget));
+            properties.push([key, await propertyDescriptor(descriptor, budget, context)]);
         }
-        if (field === "value")
-            descriptor.value = entry.value;
-        else
-            descriptor[field] = Boolean(entry.value);
+        for (const [key, descriptor] of properties)
+            defineDataProperty(target, key, descriptor, budget);
+    }
+    finally {
+        release();
     }
-    return descriptor;
 }
-function defineDataProperty(target, key, descriptor, budget) {
+export function defineDataProperty(target, key, descriptor, budget) {
     budget.visitNode();
     if (isFloat32Array(target))
         throw new TypeError("Typed array property descriptors are not supported.");
@@ -414,7 +523,15 @@ async function arrayFromSandboxValues(args, budget, context) {
     let currentValue;
     let failure;
     const retained = {};
-    budget.setRetainedValues(retained, () => [items, iterator?.retainedValue, mapFn, constructor, result, currentValue, failure]);
+    budget.setRetainedValues(retained, () => [
+        items,
+        iterator?.retainedValue,
+        mapFn,
+        constructor,
+        result,
+        currentValue,
+        failure
+    ]);
     const checkData = createDataCheckpoint(budget, context);
     const closeOnThrow = async (error) => {
         failure = isCapturedException(error) ? error.reason : error;
@@ -430,12 +547,16 @@ async function arrayFromSandboxValues(args, budget, context) {
     try {
         let length = 0;
         if (iterator === undefined) {
-            const number = await sandboxNumber(read("length"), budget, context);
-            length = Number.isNaN(number) || number <= 0 ? 0 : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+            const number = await sandboxNumber(await read("length"), budget, context);
+            length =
+                Number.isNaN(number) || number <= 0
+                    ? 0
+                    : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
         }
-        result = isSandboxClosure(constructor) && constructor.construct !== undefined
-            ? await invokeBuiltinClosure(constructor, iterator === undefined ? [length] : [], budget, context, undefined, true)
-            : createArrayFromConstructorArgs([length], budget);
+        result =
+            isSandboxClosure(constructor) && constructor.construct !== undefined
+                ? await invokeBuiltinClosure(constructor, iterator === undefined ? [length] : [], budget, context, undefined, true)
+                : createArrayFromConstructorArgs([length], budget);
         checkData(result, 0, true);
         let index = 0;
         while (iterator !== undefined || index < length) {
@@ -456,7 +577,7 @@ async function arrayFromSandboxValues(args, budget, context) {
                 currentValue = next.value;
             }
             else {
-                currentValue = read(index);
+                currentValue = await read(index);
             }
             try {
                 if (Array.isArray(result))
@@ -464,7 +585,8 @@ async function arrayFromSandboxValues(args, budget, context) {
                 if (mapFn !== undefined)
                     currentValue = await invokeBuiltinClosure(mapFn, [currentValue, index], budget, context, thisValue);
                 const key = String(index);
-                const growth = key.length + 1 +
+                const growth = key.length +
+                    1 +
                     (Array.isArray(result) ? Math.max(0, index + 1 - result.length) : 0) +
                     (budget.limits.dataSize === undefined ? 0 : measureSandboxData([currentValue]));
                 budget.visitNode();
@@ -505,20 +627,59 @@ function createArrayFromConstructorArgs(args, budget) {
         release();
     }
 }
-function getOwnEnumerableKeys(value) {
-    if (isGuestHostObject(value))
-        return getHostObjectKeys(value);
-    return getOwnEnumerableEntries(value).map(([key]) => key);
-}
-function getOwnEnumerableValues(value) {
-    return getOwnEnumerableEntries(value).map(([, entryValue]) => entryValue);
+async function getOwnEnumerableEntries(value, budget, context) {
+    const entries = [];
+    const release = retainValues(budget, () => [value, entries]);
+    try {
+        for (const key of getOwnEnumerableKeys(value)) {
+            if (!hasOwnSandboxProperty(value, key, true))
+                continue;
+            entries.push([
+                key,
+                await (context?.getProperty !== undefined
+                    ? context.getProperty(value, key)
+                    : getSandboxDataProperty(value, key, budget))
+            ]);
+        }
+        return entries;
+    }
+    finally {
+        release();
+    }
 }
 function budgetSandboxValue(value, budget) {
     const sandboxValue = deepCopyToSandbox(value);
     return allocateProducedSandboxValue(sandboxValue, budget);
 }
-function stringRaw(args, budget) {
+function stringRaw(args, budget, context) {
     const [template, ...substitutions] = args;
+    if (context?.getProperty !== undefined)
+        return (async () => {
+            if (template === null || template === undefined)
+                throw new TypeError("String.raw requires a template object.");
+            const raw = await context.getProperty(template, "raw");
+            if (raw === null || raw === undefined)
+                throw new TypeError("String.raw requires raw strings.");
+            const number = await sandboxNumber(await context.getProperty(raw, "length"), budget, context);
+            const length = Number.isNaN(number) || number <= 0
+                ? 0
+                : Math.min(Math.trunc(number), Number.MAX_SAFE_INTEGER);
+            let result = "";
+            const retained = {};
+            budget.setRetainedValues(retained, () => [raw, result]);
+            try {
+                for (let index = 0; index < length; index++) {
+                    budget.visitNode();
+                    result = budget.allocateString(result + (await sandboxString(await context.getProperty(raw, index), budget, context)));
+                    if (index + 1 < length && index < substitutions.length)
+                        result = budget.allocateString(result + (await sandboxString(substitutions[index], budget, context)));
+                }
+                return result;
+            }
+            finally {
+                budget.setRetainedValues(retained, undefined);
+            }
+        })();
     const raw = getTemplateRawParts(template);
     let result = "";
     for (let index = 0; index < raw.length; index += 1) {

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

@@ -5,7 +5,7 @@ import { isSandboxErrorConstructorInstance } from "../exceptions.js";
 import { isFloat32Array } from "../float32.js";
 import { hasHostObjectMember, isGuestHostObject } from "../host-capabilities.js";
 import { collectionIteratorState, isSandboxCollectionIterator } from "../collection-iterator.js";
-import { getSandboxPrototype, installObjectPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties } from "../object-model.js";
+import { getSandboxPrototype, installObjectPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
 import { sandboxString } from "../string-coercion.js";
 import { createSandboxClosure, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "../values.js";
 import { measureSandboxData } from "../values.js";
@@ -28,7 +28,18 @@ export function createObjectGlobal(methods, budget) {
         name: "Object",
         length: 1,
         call: construct,
-        construct
+        construct: (args, context) => {
+            if (context?.newTarget === undefined || context.newTarget === constructor)
+                return construct(args);
+            const value = construct([]);
+            const prototype = context.getProperty(context.newTarget, "prototype");
+            const finish = (prototype) => {
+                if (typeof prototype === "object" && prototype !== null)
+                    setSandboxPrototype(value, prototype, budget);
+                return value;
+            };
+            return prototype instanceof Promise ? prototype.then(finish) : finish(prototype);
+        }
     });
     const properties = materializeFunctionProperties(constructor);
     const prototype = properties.prototype;

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

@@ -1,5 +1,5 @@
 import { createSandboxBox, primitiveReceiver } from "../boxed.js";
-import { installBoxedPrototype, materializeFunctionProperties } from "../object-model.js";
+import { installBoxedPrototype, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
 import { getNumberMember, numberMethodNames } from "../methods/number.js";
 import { getStringMember, stringMethodNames } from "../methods/string.js";
 import { createSandboxClosure, isSandboxClosure, measureSandboxData } from "../values.js";
@@ -7,10 +7,19 @@ export function createPrimitiveConstructor(options, budget) {
     const initial = { Number: 0, String: "", Boolean: false }[options.name];
     const kind = typeof initial;
     const prototype = createSandboxBox(initial);
-    const allocate = (value) => {
+    const allocate = (value, context) => {
         const box = createSandboxBox(value);
-        budget.chargeDataUsage(measureSandboxData([box]));
-        return box;
+        const finish = (prototype) => {
+            if (typeof prototype === "object" && prototype !== null)
+                setSandboxPrototype(box, prototype, budget);
+            budget.chargeDataUsage(measureSandboxData([box]));
+            return box;
+        };
+        if (context?.newTarget !== undefined && context.newTarget !== constructor) {
+            const prototype = context.getProperty(context.newTarget, "prototype");
+            return prototype instanceof Promise ? prototype.then(finish) : finish(prototype);
+        }
+        return finish(undefined);
     };
     const constructor = createSandboxClosure({
         guest: true,
@@ -20,7 +29,9 @@ export function createPrimitiveConstructor(options, budget) {
         call: options.call,
         construct: (args, context) => {
             const value = options.call(args, context);
-            return value instanceof Promise ? value.then(allocate) : allocate(value);
+            return value instanceof Promise
+                ? value.then((result) => allocate(result, context))
+                : allocate(value, context);
         }
     });
     const properties = materializeFunctionProperties(constructor);

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

@@ -5,7 +5,7 @@ import type { GeneratorCompletion } from "./generator.js";
 import { Budget, type CompileOwner } from "./budget.js";
 import { CompileScope } from "./regex/compile-guard.js";
 import { type PatternContext } from "./patterns.js";
-import { type SandboxValue } from "./values.js";
+import { type SandboxCallContext, type SandboxValue } from "./values.js";
 import { Scope } from "./scope.js";
 export type InterpreterValue = SandboxValue;
 export type InterpreterStats = {
@@ -71,4 +71,4 @@ export declare function interpret(node: ParseResult, options?: InterpretOptions)
 export { Scope } from "./scope.js";
 declare function evaluateNode(node: ParseResult, context: EvaluationContext): Promise<EvaluationResult>;
 export declare function createPatternContext(context: AsyncEvaluationContext, scope?: Scope, evaluate?: typeof evaluateNode): PatternContext;
-export declare function setSandboxProperty(target: SandboxValue, property: string | number, value: SandboxValue, budget: Budget): void;
+export declare function setSandboxProperty(target: SandboxValue, property: string | number, value: SandboxValue, budget: Budget, checkInherited?: boolean, context?: SandboxCallContext): void | Promise<void>;