poe-code 14.0.65 → 14.0.66

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-4VT2M7WL.js";
+} from "./chunks/chunk-MKTUVVEB.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-WBWD7ZCM.js";
+} from "./chunks/chunk-YKISHTWT.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-WBWD7ZCM.js";
+} from "./chunks/chunk-YKISHTWT.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-4VT2M7WL.js";
+} from "./chunks/chunk-MKTUVVEB.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-WBWD7ZCM.js";
+} from "./chunks/chunk-YKISHTWT.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -0,0 +1,9 @@
+import type { SandboxCallContext, SandboxClosure, SandboxValue } from "./values.js";
+type NativeAccessor = (...args: never[]) => unknown;
+/** Native descriptors store identity only. Guest code runs through invokeClosure. */
+export declare function accessorAdapter(closure: SandboxClosure, kind: "get" | "set"): NativeAccessor;
+export declare function accessorClosure(adapter: NativeAccessor | undefined): SandboxClosure | undefined;
+export declare function retainedAccessorClosures(descriptor: PropertyDescriptor): SandboxClosure[];
+export declare function readPropertyDescriptor(descriptor: PropertyDescriptor, receiver: SandboxValue, context?: SandboxCallContext, allowNativeGetter?: boolean): SandboxValue | Promise<SandboxValue>;
+export declare function writePropertyDescriptor(descriptor: PropertyDescriptor, receiver: SandboxValue, value: SandboxValue, context?: SandboxCallContext): Promise<void>;
+export {};

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

@@ -0,0 +1,68 @@
+const accessorClosures = new WeakMap();
+const getterAdapters = new WeakMap();
+const setterAdapters = new WeakMap();
+/** Native descriptors store identity only. Guest code runs through invokeClosure. */
+export function accessorAdapter(closure, kind) {
+    if (kind === "get") {
+        let adapter = getterAdapters.get(closure);
+        if (adapter === undefined) {
+            // In particular, native Promise transport must not execute a guest `then`
+            // getter when carrying an ordinary interpreter result between async frames.
+            adapter = () => undefined;
+            getterAdapters.set(closure, adapter);
+            accessorClosures.set(adapter, closure);
+        }
+        return adapter;
+    }
+    let adapter = setterAdapters.get(closure);
+    if (adapter === undefined) {
+        adapter = () => {
+            throw new TypeError("Accessor writes require sandbox execution.");
+        };
+        setterAdapters.set(closure, adapter);
+        accessorClosures.set(adapter, closure);
+    }
+    return adapter;
+}
+export function accessorClosure(adapter) {
+    if (adapter === undefined)
+        return undefined;
+    const closure = accessorClosures.get(adapter);
+    if (closure === undefined)
+        throw new TypeError("Native accessors cannot execute in the sandbox.");
+    return closure;
+}
+export function retainedAccessorClosures(descriptor) {
+    const closures = [];
+    for (const adapter of [descriptor.get, descriptor.set]) {
+        const closure = adapter === undefined ? undefined : accessorClosures.get(adapter);
+        if (closure !== undefined)
+            closures.push(closure);
+    }
+    return closures;
+}
+export function readPropertyDescriptor(descriptor, receiver, context, allowNativeGetter = false) {
+    if ("value" in descriptor)
+        return descriptor.value;
+    if (descriptor.get === undefined)
+        return undefined;
+    const getter = accessorClosures.get(descriptor.get);
+    // Low-level interpreter callers can supply trusted native getters. Public
+    // host admission still rejects them; preserve that existing internal route.
+    if (getter === undefined) {
+        if (!allowNativeGetter)
+            throw new TypeError("Native accessors cannot execute in the sandbox.");
+        return Reflect.apply(descriptor.get, receiver, []);
+    }
+    if (context?.invokeClosure === undefined)
+        throw new TypeError("Accessor reads require sandbox execution.");
+    return context.invokeClosure(getter, [], receiver);
+}
+export function writePropertyDescriptor(descriptor, receiver, value, context) {
+    const setter = accessorClosure(descriptor.set);
+    if (setter === undefined)
+        throw new TypeError("Cannot assign to a getter-only property.");
+    if (context?.invokeClosure === undefined)
+        throw new TypeError("Accessor writes require sandbox execution.");
+    return context.invokeClosure(setter, [value], receiver).then(() => undefined);
+}

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

@@ -1,7 +1,7 @@
 import { createGeneratorChannel } from "./generator.js";
 import { getBoundOtelSpan } from "../observability/otel.js";
 import { bindPattern } from "./patterns.js";
-import { getThenable, resolveSandboxValue } from "./promise.js";
+import { requiresPromiseResolution, resolveSandboxValue } from "./promise.js";
 import { runAsyncPrefix, suspendJob } from "./jobs.js";
 import { CompileScope } from "./regex/compile-guard.js";
 import { awaitSandboxValue } from "./cancel.js";
@@ -29,7 +29,7 @@ export async function evaluateFunctionExpression(node, context, evaluateNode) {
         return {
             kind: "normal",
             hasValue: true,
-            value: createInterpretedClosure(node, context, evaluateNode)
+            value: createInterpretedClosure(node, context, evaluateNode, node.method === true ? context.functionEnvironment?.homeObject : undefined)
         };
     }
     const wrapperScope = context.scope.child();
@@ -102,7 +102,7 @@ export function executeAsyncFunction(execute, budget, signal) {
         runAsyncPrefix(async () => {
             try {
                 const value = await execute(completePrefix);
-                resolve(isSandboxPromise(value) || getThenable(value) !== undefined
+                resolve(requiresPromiseResolution(value, budget)
                     ? awaitSandboxValue(createSandboxPromise(resolveSandboxValue(value, { budget }), {
                         trackReplay: false
                     }), signal, budget)

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

@@ -1,5 +1,6 @@
 import { getFunctionLength } from "../parse/bindings.js";
 import { functionSources } from "../parse/function-source.js";
+import { accessorAdapter } from "./accessors.js";
 import { createInterpretedClosure, executeClosure } from "./async.js";
 import { retainValues } from "./resources.js";
 import { getSandboxPrototype, materializeFunctionProperties, setSandboxPrototype } from "./object-model.js";
@@ -26,7 +27,7 @@ export async function evaluateClass(node, context, evaluateNode, callContext) {
             parent = result.value;
             if (parent !== null && (!isSandboxClosure(parent) || parent.construct === undefined))
                 throw new TypeError("Class extends value is not a constructor or null.");
-            prototypeParent = parent === null ? null : callContext.getProperty(parent, "prototype");
+            prototypeParent = parent === null ? null : await callContext.getProperty(parent, "prototype");
             if (prototypeParent !== null && typeof prototypeParent !== "object")
                 throw new TypeError("Class extends value has an invalid prototype.");
         }
@@ -66,7 +67,7 @@ export async function evaluateClass(node, context, evaluateNode, callContext) {
                 };
                 if (!derived) {
                     thisValue = {};
-                    const targetPrototype = invocation.getProperty(newTarget, "prototype");
+                    const targetPrototype = await invocation.getProperty(newTarget, "prototype");
                     if (typeof targetPrototype === "object" && targetPrototype !== null)
                         setSandboxPrototype(thisValue, targetPrototype, context.budget);
                 }
@@ -136,8 +137,13 @@ export async function evaluateClass(node, context, evaluateNode, callContext) {
             else {
                 const home = element.static ? constructor : prototype;
                 const method = createInterpretedClosure(element.value, classContext, evaluateNode, home);
-                Object.defineProperty(materializeFunctionProperties(method), "name", { value: key });
-                Object.defineProperty(element.static ? properties : prototype, key, { value: method, configurable: true, writable: true, enumerable: false });
+                const accessor = element.kind === "get" || element.kind === "set" ? element.kind : undefined;
+                Object.defineProperty(materializeFunctionProperties(method), "name", {
+                    value: accessor === undefined ? key : `${accessor} ${key}`
+                });
+                Object.defineProperty(element.static ? properties : prototype, key, accessor === undefined
+                    ? { value: method, configurable: true, writable: true, enumerable: false }
+                    : { [accessor]: accessorAdapter(method, accessor), configurable: true, enumerable: false });
             }
         }
         if (node.id !== undefined)

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

@@ -31,7 +31,7 @@ type ExceptionContext = {
     callStack: readonly string[];
     scope: Scope;
     toPropertyKey?: (value: SandboxValue) => Promise<string>;
-    getProperty?: (value: SandboxValue, key: string | number) => SandboxValue;
+    getProperty?: (value: SandboxValue, key: string | number) => SandboxValue | Promise<SandboxValue>;
 };
 type EvaluateExceptionNode<TContext, TError> = (node: ParseResult, context: TContext) => Promise<EvaluationResult<TError>>;
 export declare function evaluateThrowStatement<TContext extends ExceptionContext, TError>(node: ThrowStatement, context: TContext, evaluateNode: EvaluateExceptionNode<TContext, TError>): Promise<EvaluationResult<TError>>;

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

@@ -2,7 +2,9 @@ import { attachErrorSpan, attachWrappedErrorCause, describeThrownValue, formatEr
 import { isFatalSandboxError, SandboxError } from "./budget.js";
 import { HostCallResumabilityError } from "./host-call.js";
 import { withFatalPromiseCleanup } from "./promise-tracker.js";
-import { deepCopyToSandbox, ownEnumerableSandboxEntries } from "./values.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 { toPropertyKey } from "./property-key.js";
 const capturedExceptionBrand = Symbol("CapturedException");
@@ -389,12 +391,38 @@ async function bindArrayPattern(pattern, value, context, evaluateNode) {
     if (!Array.isArray(value)) {
         throw new TypeError("Array catch bindings require an array value.");
     }
+    let cursor = 0;
+    let done = false;
+    const next = async () => {
+        if (done || cursor >= value.length) {
+            done = true;
+            return { done: true, value: undefined };
+        }
+        const key = cursor++;
+        return {
+            done: false,
+            value: context.getProperty === undefined
+                ? getSandboxDataProperty(value, key, context.budget)
+                : await context.getProperty(value, key)
+        };
+    };
     for (let index = 0; index < pattern.elements.length; index += 1) {
         const element = pattern.elements[index];
         if (element === null) {
+            await next();
             continue;
         }
-        const elementValue = element.type === "RestElement" ? value.slice(index) : value[index];
+        let elementValue;
+        if (element.type === "RestElement") {
+            const rest = [];
+            for (let entry = await next(); !entry.done; entry = await next()) {
+                context.budget.allocateArrayLength(rest.length + 1);
+                rest.push(entry.value);
+            }
+            elementValue = rest;
+        }
+        else
+            elementValue = (await next()).value;
         const binding = await bindPattern(element, elementValue, context, evaluateNode);
         if (!binding.ok) {
             return binding;
@@ -409,7 +437,7 @@ async function bindObjectPattern(pattern, value, context, evaluateNode) {
     const excludedKeys = new Set();
     for (const property of pattern.properties) {
         if (property.type === "RestElement") {
-            const restValue = copyObjectRest(value, excludedKeys);
+            const restValue = await copyObjectRest(value, excludedKeys, context);
             const binding = await bindPattern(property, restValue, context, evaluateNode);
             if (!binding.ok) {
                 return binding;
@@ -423,7 +451,7 @@ async function bindObjectPattern(pattern, value, context, evaluateNode) {
         excludedKeys.add(String(key.value));
         const binding = await bindPattern(property.value, context.getProperty === undefined
             ? getSandboxDataProperty(value, key.value, context.budget)
-            : context.getProperty(value, key.value), context, evaluateNode);
+            : await context.getProperty(value, key.value), context, evaluateNode);
         if (!binding.ok) {
             return binding;
         }
@@ -460,10 +488,21 @@ function getStaticPropertyKey(property) {
             throw new TypeError(`Unsupported catch binding property key '${property.type}'.`);
     }
 }
-function copyObjectRest(value, excludedKeys) {
+async function copyObjectRest(value, excludedKeys, context) {
     const rest = Object.create(null);
-    for (const [key, entryValue] of ownEnumerableSandboxEntries(value, excludedKeys)) {
-        rest[key] = entryValue;
+    const release = retainValues(context.budget, () => [value, rest]);
+    try {
+        for (const key of ownEnumerableSandboxKeys(value)) {
+            if (excludedKeys.has(key) || !hasOwnSandboxProperty(value, key, true))
+                continue;
+            rest[key] =
+                context.getProperty === undefined
+                    ? getSandboxDataProperty(value, key, context.budget)
+                    : await context.getProperty(value, key);
+        }
+        return rest;
+    }
+    finally {
+        release();
     }
-    return rest;
 }

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

@@ -17,20 +17,34 @@ export function createCollectionGlobals(options) {
             let key;
             let value;
             return populateCollection(source, map, {
-                name: "Map", budget: options.budget, context,
+                name: "Map",
+                budget: options.budget,
+                context,
                 retainedValues: () => [key, value],
                 append: (entry) => {
                     if (typeof entry !== "object" || entry === null)
                         throw new TypeError("Map constructor requires entry objects.");
-                    key = context?.getProperty !== undefined ? context.getProperty(entry, 0) : getSandboxDataProperty(entry, 0, options.budget);
-                    value = context?.getProperty !== undefined ? context.getProperty(entry, 1) : getSandboxDataProperty(entry, 1, options.budget);
-                    const added = map.entries.has(key) ? 0 : 1;
-                    const growth = added +
-                        (options.budget.limits.dataSize === undefined ? 0 : measureSandboxData([key, value]));
-                    options.budget.allocateCollectionEntries(map.entries.size + added);
-                    map.entries.set(key, value);
-                    key = value = undefined;
-                    return growth;
+                    const store = (entryValue) => {
+                        value = entryValue;
+                        const added = map.entries.has(key) ? 0 : 1;
+                        const growth = added +
+                            (options.budget.limits.dataSize === undefined ? 0 : measureSandboxData([key, value]));
+                        options.budget.allocateCollectionEntries(map.entries.size + added);
+                        map.entries.set(key, value);
+                        key = value = undefined;
+                        return growth;
+                    };
+                    const readValue = (entryKey) => {
+                        key = entryKey;
+                        const result = context?.getProperty !== undefined
+                            ? context.getProperty(entry, 1)
+                            : getSandboxDataProperty(entry, 1, options.budget);
+                        return result instanceof Promise ? result.then(store) : store(result);
+                    };
+                    const result = context?.getProperty !== undefined
+                        ? context.getProperty(entry, 0)
+                        : getSandboxDataProperty(entry, 0, options.budget);
+                    return result instanceof Promise ? result.then(readValue) : readValue(result);
                 }
             });
         },
@@ -44,7 +58,9 @@ export function createCollectionGlobals(options) {
         construct: ([source], context) => {
             const set = createSandboxSet([]);
             return populateCollection(source, set, {
-                name: "Set", budget: options.budget, context,
+                name: "Set",
+                budget: options.budget,
+                context,
                 append: (value) => {
                     const added = set.values.has(value) ? 0 : 1;
                     const growth = added +
@@ -77,7 +93,14 @@ function populateCollection(source, collection, { name, budget, context, append,
     let entry;
     let failure;
     const retained = {};
-    budget.setRetainedValues(retained, () => [source, iterator.retainedValue, collection, entry, failure, ...(retainedValues?.() ?? [])]);
+    budget.setRetainedValues(retained, () => [
+        source,
+        iterator.retainedValue,
+        collection,
+        entry,
+        failure,
+        ...(retainedValues?.() ?? [])
+    ]);
     const checkData = createDataCheckpoint(budget, context);
     const closeOnThrow = (error) => {
         failure = isCapturedException(error) ? error.reason : error;
@@ -89,7 +112,9 @@ function populateCollection(source, collection, { name, budget, context, append,
         try {
             const closing = iterator.return?.();
             if (iterator.generator || iterator.asynchronous)
-                return Promise.resolve(closing).then(() => { throw error; }, rethrow);
+                return Promise.resolve(closing).then(() => {
+                    throw error;
+                }, rethrow);
         }
         catch (closeError) {
             return rethrow(closeError);
@@ -105,6 +130,14 @@ function populateCollection(source, collection, { name, budget, context, append,
         try {
             budget.visitNode();
             const growth = append(entry);
+            if (growth instanceof Promise)
+                return growth
+                    .then((size) => {
+                    entry = undefined;
+                    checkData(collection, size);
+                    return false;
+                })
+                    .catch(closeOnThrow);
             entry = undefined;
             checkData(collection, growth);
         }
@@ -113,11 +146,13 @@ function populateCollection(source, collection, { name, budget, context, append,
         }
         return false;
     };
-    if (iterator.generator || iterator.asynchronous) {
+    if (iterator.generator || iterator.asynchronous || context !== undefined) {
         return (async () => {
             try {
                 checkData(collection, 0, true);
-                while (!(await consume(await iterator.next()))) { /* Consume each entry before advancing. */ }
+                while (!(await consume(await iterator.next()))) {
+                    /* Consume each entry before advancing. */
+                }
                 checkData(collection, 0, true);
                 return collection;
             }
@@ -128,7 +163,9 @@ function populateCollection(source, collection, { name, budget, context, append,
     }
     try {
         checkData(collection, 0, true);
-        while (!consume(iterator.next())) { /* Synchronous inputs stay synchronous. */ }
+        while (!consume(iterator.next())) {
+            /* Synchronous inputs stay synchronous. */
+        }
         checkData(collection, 0, true);
         return collection;
     }

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

@@ -1,3 +1,6 @@
+import { retainValues } from "../resources.js";
+import { readPropertyDescriptor } from "../accessors.js";
+import { getSandboxPropertyDescriptor } from "../object-model.js";
 import { dateMethods, isSandboxDate } from "../date.js";
 import { boxedValue, isSandboxBox } from "../boxed.js";
 import { sandboxNumber, sandboxString } from "../string-coercion.js";
@@ -96,27 +99,36 @@ async function stringifyJson(value, replacer, indent, budget, context) {
     return budget.allocateString(output);
 }
 async function stringifyProperty(key, holder, state, indent = "") {
-    let value = getOwnDataValue(holder, key);
-    if (isSandboxDate(value)) {
-        value = dateMethods.get("toJSON").invoke(value, []);
-    }
-    else if (isStringifyContainer(value)) {
-        const toJSON = getOwnDataValue(value, "toJSON");
-        if (isSandboxClosure(toJSON)) {
-            value = await callStringifyClosure(toJSON, [key], value, state);
+    let value = await getStringifyProperty(holder, key, state);
+    const release = retainValues(state.budget, () => [holder, value]);
+    try {
+        if (isSandboxDate(value)) {
+            value = dateMethods.get("toJSON").invoke(value, []);
+        }
+        else if (isStringifyContainer(value)) {
+            const toJSON = await getStringifyProperty(value, "toJSON", state);
+            if (isSandboxClosure(toJSON)) {
+                value = await callStringifyClosure(toJSON, [key], value, state);
+            }
+        }
+        if (state.replacer !== undefined) {
+            value = await callStringifyClosure(state.replacer, [key, toSandboxValue(value)], holder, state);
         }
+        return await stringifyValue(value, state, indent);
     }
-    if (state.replacer !== undefined) {
-        value = await callStringifyClosure(state.replacer, [key, toSandboxValue(value)], holder, state);
+    finally {
+        release();
     }
-    return stringifyValue(value, state, indent);
 }
 async function stringifyValue(value, state, indent) {
     if (isSandboxBox(value)) {
         const primitive = boxedValue(value);
-        value = typeof primitive === "number" ? await sandboxNumber(value, state.budget, state.context)
-            : typeof primitive === "string" ? await sandboxString(value, state.budget, state.context)
-                : primitive;
+        value =
+            typeof primitive === "number"
+                ? await sandboxNumber(value, state.budget, state.context)
+                : typeof primitive === "string"
+                    ? await sandboxString(value, state.budget, state.context)
+                    : primitive;
     }
     if (value === null) {
         return "null";
@@ -148,10 +160,12 @@ async function stringifyValue(value, state, indent) {
 }
 async function stringifyArray(value, state, indent) {
     enterStringifyObject(value, state);
+    const entries = [];
+    const release = retainValues(state.budget, () => entries);
     try {
         const nextIndent = indent + state.gap;
-        const entries = [];
-        for (let index = 0; index < value.length; index += 1) {
+        const length = value.length;
+        for (let index = 0; index < length; index += 1) {
             entries.push((await stringifyProperty(String(index), value, state, nextIndent)) ?? "null");
         }
         if (entries.length === 0) {
@@ -163,14 +177,16 @@ async function stringifyArray(value, state, indent) {
         return `[\n${nextIndent}${entries.join(`,\n${nextIndent}`)}\n${indent}]`;
     }
     finally {
+        release();
         leaveStringifyObject(value, state);
     }
 }
 async function stringifyObject(value, state, indent) {
     enterStringifyObject(value, state);
+    const entries = [];
+    const release = retainValues(state.budget, () => entries);
     try {
         const nextIndent = indent + state.gap;
-        const entries = [];
         for (const key of Object.keys(value)) {
             const serialized = await stringifyProperty(key, value, state, nextIndent);
             if (serialized !== undefined) {
@@ -186,6 +202,7 @@ async function stringifyObject(value, state, indent) {
         return `{\n${nextIndent}${entries.join(`,\n${nextIndent}`)}\n${indent}}`;
     }
     finally {
+        release();
         leaveStringifyObject(value, state);
     }
 }
@@ -250,15 +267,13 @@ function toSandboxValue(value) {
     }
     throw new TypeError(`JSON.stringify(value) produced an unsupported value of type ${typeof value}.`);
 }
-function getOwnDataValue(target, key) {
-    const descriptor = Object.getOwnPropertyDescriptor(target, key);
-    if (descriptor === undefined) {
-        return undefined;
-    }
-    if ("get" in descriptor || "set" in descriptor) {
-        throw new TypeError(`JSON.stringify(value) cannot serialize accessor property ${key}.`);
-    }
-    return descriptor.value;
+function getStringifyProperty(target, key, state) {
+    if (state.context?.getProperty !== undefined)
+        return state.context.getProperty(target, key);
+    const descriptor = getSandboxPropertyDescriptor(target, key, state.budget);
+    return descriptor === undefined
+        ? undefined
+        : readPropertyDescriptor(descriptor, target, state.context);
 }
 function copyJsonToSandbox(value, budget) {
     if (value === null ||