poe-code 14.0.47 → 14.0.48

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-WQY27BRL.js";
+} from "./chunks/chunk-6GXMEFMD.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-XC53RECY.js";
+} from "./chunks/chunk-PCHV72VT.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-XC53RECY.js";
+} from "./chunks/chunk-PCHV72VT.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-WQY27BRL.js";
+} from "./chunks/chunk-6GXMEFMD.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-XC53RECY.js";
+} from "./chunks/chunk-PCHV72VT.js";
 import "./chunks/chunk-UXMKEUH3.js";
 import "./chunks/chunk-5DYEOCT5.js";
 import "./chunks/chunk-4YIDX44G.js";

package/packages/safe-js/dist/interp/builtin-call.d.ts

@@ -0,0 +1,3 @@
+import type { Budget } from "./budget.js";
+import { type SandboxCallContext, type SandboxClosure, type SandboxValue } from "./values.js";
+export declare function invokeBuiltinClosure(closure: SandboxClosure, args: readonly SandboxValue[], budget: Budget, context: SandboxCallContext | undefined, thisValue: SandboxValue, construct?: boolean): Promise<SandboxValue>;

package/packages/safe-js/dist/interp/builtin-call.js

@@ -0,0 +1,24 @@
+import { isSandboxPromise } from "./values.js";
+export async function invokeBuiltinClosure(closure, args, budget, context, thisValue, construct = false) {
+    if (context?.invokeClosure !== undefined) {
+        return context.invokeClosure(closure, args, thisValue, construct);
+    }
+    const leaveCall = budget.enterCall();
+    try {
+        const invoke = construct ? closure.construct : closure.call;
+        if (invoke === undefined)
+            throw new TypeError("Value is not a constructor.");
+        const result = await invoke(args, {
+            ...context,
+            stack: context?.stack ?? [],
+            thisValue,
+            invokeClosure: (target, values, receiver, asConstructor) => invokeBuiltinClosure(target, values, budget, context, receiver, asConstructor)
+        });
+        if (isSandboxPromise(result))
+            await result.synchronousPrefix;
+        return result;
+    }
+    finally {
+        leaveCall();
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { Budget, CompileOwner } from "../budget.js";
+import { type Budget, type CompileOwner } from "../budget.js";
 import { type SandboxClosure } from "../values.js";
 export type ObjectArrayGlobals = {
     Object: SandboxClosure;

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

@@ -1,13 +1,16 @@
-import { dateTime, isSandboxDate } from "../date.js";
+import { isFatalSandboxError } from "../budget.js";
+import { invokeBuiltinClosure } from "../builtin-call.js";
+import { isCapturedException } from "../exceptions.js";
+import { isSandboxDate } from "../date.js";
 import { getDatePrototype } from "./date.js";
 import { createObjectGlobal, hasOwnSandboxProperty } from "./object.js";
 import { getHostObjectKeys, isGuestHostObject } from "../host-capabilities.js";
 import { isFloat32Array } from "../float32.js";
 import { setSandboxProperty } from "../interpreter.js";
 import { getSandboxIterator } from "../iteration.js";
-import { sandboxString } from "../string-coercion.js";
-import { getSandboxPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
-import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, ownEnumerableSandboxEntries as getOwnEnumerableEntries } from "../values.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
+import { getSandboxDataProperty, getSandboxPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties, setSandboxPrototype } from "../object-model.js";
+import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, defineOwnDataProperty, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, ownEnumerableSandboxEntries as getOwnEnumerableEntries, reconcileCompiledValues } from "../values.js";
 export function createObjectArrayGlobals(options) {
     return {
         Object: createObjectGlobal({
@@ -165,7 +168,7 @@ export function createObjectArrayGlobals(options) {
                 }),
                 from: createSandboxClosure({
                     sandbox: true,
-                    call: (args) => arrayFromSandboxValues(args, options.budget),
+                    call: (args, context) => arrayFromSandboxValues(args, options.budget, context),
                     name: "from"
                 }),
                 of: createSandboxClosure({
@@ -199,7 +202,7 @@ export function createObjectArrayGlobals(options) {
         }),
         Number: createSandboxClosure({
             sandbox: true,
-            call: ([value]) => isSandboxDate(value) ? dateTime(value) : Number(value),
+            call: (args, context) => sandboxNumber(args.length === 0 ? 0 : args[0], options.budget, context),
             name: "Number",
             properties: {
                 isFinite: createSandboxClosure({
@@ -365,45 +368,108 @@ function isAssignableSandboxTarget(value) {
         !isSandboxPromise(value) &&
         !isSandboxRegex(value));
 }
-async function arrayFromSandboxValues(args, budget) {
+async function arrayFromSandboxValues(args, budget, context) {
     const [items, mapFn, thisValue] = args;
+    if (mapFn !== undefined && !isSandboxClosure(mapFn)) {
+        throw new TypeError("Array.from mapping callback must be a function.");
+    }
+    if (items === null || items === undefined) {
+        throw new TypeError("Array.from requires a non-null input.");
+    }
+    const read = (property) => context?.getProperty !== undefined
+        ? context.getProperty(items, property)
+        : getSandboxDataProperty(items, property, budget);
     const iterator = getSandboxIterator(items);
-    if (isGuestHostObject(items) && iterator !== undefined) {
-        if (mapFn !== undefined && !isSandboxClosure(mapFn))
-            throw new TypeError("Array.from mapping callback must be a function.");
-        const values = [];
-        while (true) {
-            const next = await iterator.next();
-            if (next.done)
-                break;
-            budget.allocateArrayLength(values.length + 1);
-            const value = mapFn === undefined
-                ? next.value
-                : await mapFn.call([next.value, values.length], { stack: [], thisValue });
-            if (isSandboxPromise(value) && value.synchronousPrefix !== undefined)
-                await value.synchronousPrefix;
-            values.push(value);
+    const constructor = context?.thisValue;
+    let result;
+    let currentValue;
+    let failure;
+    let estimatedDataSize = 0;
+    const retained = {};
+    budget.setRetainedValues(retained, () => [items, mapFn, constructor, result, currentValue, failure]);
+    const checkData = (growth = 0, force = false) => {
+        const limit = budget.limits.dataSize;
+        if (limit === undefined)
+            return;
+        estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
+        // Primitive writes have bounded growth; changed graphs require an exact check.
+        if (!force && estimatedDataSize <= limit)
+            return;
+        if (context?.reconcileData !== undefined)
+            context.reconcileData(result);
+        else
+            reconcileCompiledValues(budget, [], context?.compilation);
+        estimatedDataSize = budget.currentDataSize;
+    };
+    const closeOnThrow = async (error) => {
+        failure = isCapturedException(error) ? error.reason : error;
+        try {
+            await iterator?.return?.();
         }
-        return allocateProducedSandboxValue(values, budget);
-    }
-    const values = iterator === undefined
-        ? Reflect.apply(Array.from, Array, [items])
-        : await collectIteratorValues(iterator);
-    if (mapFn === undefined || !isSandboxClosure(mapFn)) {
-        if (mapFn !== undefined) {
-            throw new TypeError("Array.from mapping callback must be a function.");
+        catch (closeError) {
+            if (!isFatalSandboxError(error) && isFatalSandboxError(closeError))
+                throw closeError;
         }
-        return budgetSandboxValue(values, budget);
-    }
-    const mappedValues = [];
-    for (const [index, value] of values.entries()) {
-        const result = await mapFn.call([value, index], { stack: [], thisValue });
-        if (isSandboxPromise(result) && result.synchronousPrefix !== undefined) {
-            await result.synchronousPrefix;
+        throw error;
+    };
+    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);
         }
-        mappedValues.push(result);
+        result = isSandboxClosure(constructor) && constructor.construct !== undefined
+            ? await invokeBuiltinClosure(constructor, iterator === undefined ? [length] : [], budget, context, undefined, true)
+            : createArrayFromConstructorArgs([length], budget);
+        checkData(0, true);
+        let index = 0;
+        while (iterator !== undefined || index < length) {
+            try {
+                budget.visitNode();
+                if (iterator !== undefined && index >= Number.MAX_SAFE_INTEGER)
+                    throw new TypeError("Array.from input is too long.");
+            }
+            catch (error) {
+                await closeOnThrow(error);
+            }
+            if (iterator !== undefined) {
+                const next = await iterator.next();
+                if (typeof next !== "object" || next === null)
+                    throw new TypeError("Iterator result must be an object.");
+                if (next.done)
+                    break;
+                currentValue = next.value;
+            }
+            else {
+                currentValue = read(index);
+            }
+            try {
+                if (Array.isArray(result))
+                    budget.allocateArrayLength(index + 1);
+                if (mapFn !== undefined)
+                    currentValue = await invokeBuiltinClosure(mapFn, [currentValue, index], budget, context, thisValue);
+                const key = String(index);
+                const growth = key.length + 1 +
+                    (Array.isArray(result) ? Math.max(0, index + 1 - result.length) : 0) +
+                    (typeof currentValue === "string" ? currentValue.length : 0);
+                const graphChanged = (typeof currentValue === "object" && currentValue !== null) || isSandboxClosure(result);
+                budget.visitNode();
+                defineOwnDataProperty(objectProperties(result, true), key, currentValue);
+                currentValue = undefined;
+                checkData(growth, graphChanged);
+            }
+            catch (error) {
+                await closeOnThrow(error);
+            }
+            index += 1;
+        }
+        setSandboxProperty(result, "length", index, budget);
+        checkData(0, true);
+        return allocateProducedSandboxValue(result, budget);
+    }
+    finally {
+        budget.setRetainedValues(retained, undefined);
     }
-    return budgetSandboxValue(mappedValues, budget);
 }
 function createArrayFromConstructorArgs(args, budget) {
     if (args.length !== 1) {
@@ -417,15 +483,12 @@ function createArrayFromConstructorArgs(args, budget) {
         throw new RangeError("Invalid array length.");
     }
     budget.allocateArrayLength(lengthOrValue);
-    return new Array(lengthOrValue);
-}
-async function collectIteratorValues(iterator) {
-    const values = [];
-    while (true) {
-        const result = await iterator.next();
-        if (result.done)
-            return values;
-        values.push(result.value);
+    const release = budget.provisionDataUsage(lengthOrValue + 1);
+    try {
+        return new Array(lengthOrValue);
+    }
+    finally {
+        release();
     }
 }
 function getOwnEnumerableKeys(value) {

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

@@ -231,7 +231,7 @@ async function evaluateNode(node, context) {
     }
 }
 function reconcileDataBudget(budget, stats, scope, transient, compilation, parent) {
-    reconcileCompiledValues(budget, [...scope.retainedValues(), ...budget.retainedValues(), transient], compilation, parent, [transient]);
+    reconcileCompiledValues(budget, [...scope.retainedValues(), transient], compilation, parent, [transient]);
     stats.currentDataSize = budget.currentDataSize;
     stats.peakDataSize = budget.peakDataSize;
 }
@@ -2127,7 +2127,9 @@ function createCoercionContext(context) {
         stack: context.callStack,
         thisValue: undefined,
         compilation: context.compilation,
-        invokeClosure: (closure, args, thisValue) => invokeSandboxClosure(closure, args, context, context.callStack, undefined, thisValue)
+        getProperty: (value, property) => getPropertyValue(value, property, context),
+        reconcileData: value => reconcileDataBudget(context.budget, context.stats, context.scope, value, context.compilation, context.compilation?.parent),
+        invokeClosure: (closure, args, thisValue, construct) => invokeSandboxClosure(closure, args, context, context.callStack, undefined, thisValue, construct)
     };
 }
 function hasSandboxProperty(value, key, context) {
@@ -2518,7 +2520,9 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
                 stack,
                 thisValue,
                 compilation: context.compilation,
-                invokeClosure: (closure, argumentsList, receiver) => invokeSandboxClosure(closure, argumentsList, context, stack, span, receiver),
+                getProperty: (value, property) => getPropertyValue(value, property, context),
+                reconcileData: (value) => reconcileDataBudget(context.budget, context.stats, context.scope, value, context.compilation, context.compilation?.parent),
+                invokeClosure: (closure, argumentsList, receiver, asConstructor) => invokeSandboxClosure(closure, argumentsList, context, stack, span, receiver, asConstructor),
                 ...(span === undefined ? {} : { span })
             }
         ]);

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

@@ -1,3 +1,4 @@
 import type { Budget } from "./budget.js";
 import { type SandboxCallContext, type SandboxValue } from "./values.js";
+export declare function sandboxNumber(value: SandboxValue, budget: Budget, context?: SandboxCallContext): number | Promise<number>;
 export declare function sandboxString(value: SandboxValue, budget: Budget, context?: SandboxCallContext, joining?: Set<object>): string | Promise<string>;

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

@@ -1,5 +1,6 @@
 import { sandboxErrorTypes } from "../error/shape.js";
-import { dateString, isSandboxDate } from "./date.js";
+import { dateString, dateTime, isSandboxDate } from "./date.js";
+import { invokeBuiltinClosure } from "./builtin-call.js";
 import { float32Storage, isFloat32Array } from "./float32.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { isGuestHostObject } from "./host-capabilities.js";
@@ -7,55 +8,46 @@ import { getGuestFunctionProperties, getSandboxPrototype, hasExplicitSandboxProt
 import { getRegexMember } from "./methods/regex.js";
 import { isSandboxClosure, isSandboxPromise, isSandboxMap, isSandboxSet, isSandboxRegex, isSandboxGenerator } from "./values.js";
 const defaultStringHook = Symbol("defaultStringHook");
+const defaultValueHook = Symbol("defaultValueHook");
+export function sandboxNumber(value, budget, context) {
+    if (value === null || typeof value !== "object") {
+        if (typeof value === "function")
+            throw new TypeError("Expected a sandbox value.");
+        return Number(value);
+    }
+    return objectToPrimitive(value, budget, context, new Set(), "number").then(Number);
+}
 export function sandboxString(value, budget, context, joining = new Set()) {
     if (value === null || typeof value !== "object") {
         if (typeof value === "function")
             throw new TypeError("Expected a sandbox value.");
         return budget.allocateString(String(value));
     }
-    const invocation = context?.invokeClosure !== undefined
-        ? context
-        : {
-            ...context,
-            stack: context?.stack ?? [],
-            thisValue: context?.thisValue,
-            invokeClosure: async (closure, args, thisValue) => {
-                const leaveCall = budget.enterCall();
-                try {
-                    const result = closure.call(args, { ...invocation, thisValue });
-                    if (isSandboxPromise(result)) {
-                        await result.synchronousPrefix;
-                        return result;
-                    }
-                    return await result;
-                }
-                finally {
-                    leaveCall();
-                }
-            }
-        };
-    return stringifyObject(value, budget, invocation, joining);
+    return objectToPrimitive(value, budget, context, joining, "string")
+        .then(primitive => budget.allocateString(String(primitive)));
 }
-async function stringifyObject(value, budget, context, joining) {
+async function objectToPrimitive(value, budget, context, joining, hint) {
     const leaveCall = budget.enterCall();
     try {
         budget.visitNode();
-        for (const name of ["toString", "valueOf"]) {
+        for (const name of hint === "string" ? ["toString", "valueOf"] : ["valueOf", "toString"]) {
             const hook = conversionHook(value, name, budget);
             let result;
             if (hook === defaultStringHook) {
                 result = await defaultToString(value, budget, context, joining);
             }
+            else if (hook === defaultValueHook) {
+                result = isSandboxDate(value) ? dateTime(value) : value;
+            }
             else {
                 if (!isSandboxClosure(hook))
                     continue;
-                if (context?.invokeClosure === undefined) {
-                    throw new TypeError("String hooks require a sandbox call context.");
-                }
-                result = await context.invokeClosure(hook, [], value);
+                result = await invokeBuiltinClosure(hook, [], budget, context, value);
             }
             if (result === null || typeof result !== "object") {
-                return sandboxString(result, budget, context, joining);
+                if (typeof result === "function")
+                    throw new TypeError("Expected a sandbox value.");
+                return result;
             }
         }
         throw new TypeError("Cannot convert object to primitive value");
@@ -90,7 +82,7 @@ function conversionHook(value, name, budget) {
         const parent = getSandboxPrototype(current, budget);
         if (current === value &&
             (implicitBuiltin || (parent === null && !hasExplicitSandboxPrototype(value)))) {
-            return name === "toString" ? defaultStringHook : undefined;
+            return name === "toString" ? defaultStringHook : defaultValueHook;
         }
         current = parent;
         if (current !== null) {
@@ -117,10 +109,7 @@ async function defaultToString(value, budget, context, joining) {
             const join = ownDataValue(value, "join");
             if (!isSandboxClosure(join))
                 return isFloat32Array(value) ? "[object Float32Array]" : "[object Array]";
-            if (context?.invokeClosure === undefined) {
-                throw new TypeError("String hooks require a sandbox call context.");
-            }
-            return context.invokeClosure(join, [], value);
+            return invokeBuiltinClosure(join, [], budget, context, value);
         }
         if (joining.has(value))
             return "";

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

@@ -51,7 +51,9 @@ export type SandboxCallContext = {
     };
     readonly stack: readonly string[];
     readonly thisValue: SandboxValue;
-    readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue) => Promise<SandboxValue>;
+    readonly getProperty?: (value: SandboxValue, property: string | number) => SandboxValue;
+    readonly reconcileData?: (value: SandboxValue) => void;
+    readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue, construct?: boolean) => Promise<SandboxValue>;
 };
 export type SandboxClosure = {
     readonly async?: true;