poe-code 14.0.49 → 14.0.50

package/packages/safe-js/dist/chunks/{chunk-FO4UY5ZE.js → chunk-MQU3AETK.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-FV3SMFMZ.js";
+} from "./chunk-7AIY5C3F.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-FO4UY5ZE.js.map
+//# sourceMappingURL=chunk-MQU3AETK.js.map

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

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

package/packages/safe-js/dist/interp/data-checkpoint.d.ts

@@ -0,0 +1,3 @@
+import type { Budget } from "./budget.js";
+import { type SandboxCallContext, type SandboxValue } from "./values.js";
+export declare function createDataCheckpoint(budget: Budget, context?: SandboxCallContext): (value: SandboxValue, growth?: number, force?: boolean) => void;

package/packages/safe-js/dist/interp/data-checkpoint.js

@@ -0,0 +1,18 @@
+import { reconcileCompiledValues } from "./values.js";
+export function createDataCheckpoint(budget, context) {
+    let estimatedDataSize = 0;
+    return (value, growth = 0, force = false) => {
+        const limit = budget.limits.dataSize;
+        if (limit === undefined)
+            return;
+        estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
+        // Bounded growth estimates defer exact scans until they could exceed the limit.
+        if (!force && estimatedDataSize <= limit)
+            return;
+        if (context?.reconcileData !== undefined)
+            context.reconcileData(value);
+        else
+            reconcileCompiledValues(budget, [value], context?.compilation);
+        estimatedDataSize = budget.currentDataSize;
+    };
+}

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

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

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

@@ -1,5 +1,9 @@
+import { isFatalSandboxError } from "../budget.js";
+import { createDataCheckpoint } from "../data-checkpoint.js";
+import { isCapturedException } from "../exceptions.js";
 import { getSandboxIterator } from "../iteration.js";
-import { createSandboxClosure, createSandboxMap, createSandboxSet, isSandboxMap, isSandboxSet } from "../values.js";
+import { getSandboxDataProperty } from "../object-model.js";
+import { createSandboxClosure, createSandboxMap, createSandboxSet, measureSandboxData } from "../values.js";
 const mapConstructors = new WeakSet();
 const setConstructors = new WeakSet();
 export function createCollectionGlobals(options) {
@@ -8,12 +12,27 @@ export function createCollectionGlobals(options) {
         call: () => {
             throw new TypeError("Constructor Map requires 'new'.");
         },
-        construct: ([source]) => {
-            const entries = getMapEntries(source);
-            if (entries instanceof Promise) {
-                return entries.then((resolved) => createBudgetedMap(resolved, options.budget));
-            }
-            return createBudgetedMap(entries, options.budget);
+        construct: ([source], context) => {
+            const map = createSandboxMap([]);
+            let key;
+            let value;
+            return populateCollection(source, map, {
+                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;
+                }
+            });
         },
         name: "Map"
     });
@@ -22,12 +41,19 @@ export function createCollectionGlobals(options) {
         call: () => {
             throw new TypeError("Constructor Set requires 'new'.");
         },
-        construct: ([source]) => {
-            const values = getSetValues(source);
-            if (values instanceof Promise) {
-                return values.then((resolved) => createBudgetedSet(resolved, options.budget));
-            }
-            return createBudgetedSet(values, options.budget);
+        construct: ([source], context) => {
+            const set = createSandboxSet([]);
+            return populateCollection(source, set, {
+                name: "Set", budget: options.budget, context,
+                append: (value) => {
+                    const added = set.values.has(value) ? 0 : 1;
+                    const growth = added +
+                        (options.budget.limits.dataSize === undefined ? 0 : measureSandboxData([value]));
+                    options.budget.allocateCollectionEntries(set.values.size + added);
+                    set.values.add(value);
+                    return growth;
+                }
+            });
         },
         name: "Set"
     });
@@ -41,73 +67,72 @@ export function isSandboxMapConstructor(value) {
 export function isSandboxSetConstructor(value) {
     return (typeof value === "object" && value !== null && setConstructors.has(value));
 }
-function getMapEntries(source) {
-    if (source === undefined || source === null) {
-        return [];
-    }
-    if (isSandboxMap(source)) {
-        return [...source.entries];
-    }
-    if (Array.isArray(source)) {
-        return validateMapEntries(source);
-    }
+function populateCollection(source, collection, { name, budget, context, append, retainedValues }) {
+    budget.allocateCollectionEntries(0);
+    if (source === undefined || source === null)
+        return collection;
     const iterator = getSandboxIterator(source);
-    if (iterator?.generator !== true) {
-        throw new TypeError("Map constructor argument must be an array of pairs or a Map.");
-    }
-    return collectMapEntries(iterator);
-}
-async function collectMapEntries(iterator) {
-    const sourceEntries = [];
-    while (true) {
-        const result = await iterator.next();
+    if (iterator === undefined)
+        throw new TypeError(`${name} constructor requires an iterable.`);
+    let entry;
+    let failure;
+    const retained = {};
+    budget.setRetainedValues(retained, () => [source, collection, entry, failure, ...(retainedValues?.() ?? [])]);
+    const checkData = createDataCheckpoint(budget, context);
+    const closeOnThrow = (error) => {
+        failure = isCapturedException(error) ? error.reason : error;
+        const rethrow = (closeError) => {
+            if (!isFatalSandboxError(error) && isFatalSandboxError(closeError))
+                throw closeError;
+            throw error;
+        };
+        try {
+            const closing = iterator.return?.();
+            if (iterator.generator)
+                return Promise.resolve(closing).then(() => { throw error; }, rethrow);
+        }
+        catch (closeError) {
+            return rethrow(closeError);
+        }
+        throw error;
+    };
+    const consume = (result) => {
+        if (typeof result !== "object" || result === null)
+            throw new TypeError("Iterator result must be an object.");
         if (result.done)
-            break;
-        sourceEntries.push(result.value);
-    }
-    return validateMapEntries(sourceEntries);
-}
-function validateMapEntries(sourceEntries) {
-    return sourceEntries.map((entry) => {
-        if (!Array.isArray(entry)) {
-            throw new TypeError("Map constructor entries must be arrays.");
+            return true;
+        entry = result.value;
+        try {
+            budget.visitNode();
+            const growth = append(entry);
+            entry = undefined;
+            checkData(collection, growth);
         }
-        return [entry[0], entry[1]];
-    });
-}
-function getSetValues(source) {
-    if (source === undefined || source === null) {
-        return [];
+        catch (error) {
+            return closeOnThrow(error);
+        }
+        return false;
+    };
+    if (iterator.generator) {
+        return (async () => {
+            try {
+                checkData(collection, 0, true);
+                while (!(await consume(await iterator.next()))) { /* Consume each entry before advancing. */ }
+                checkData(collection, 0, true);
+                return collection;
+            }
+            finally {
+                budget.setRetainedValues(retained, undefined);
+            }
+        })();
     }
-    if (isSandboxSet(source)) {
-        return [...source.values];
+    try {
+        checkData(collection, 0, true);
+        while (!consume(iterator.next())) { /* Synchronous inputs stay synchronous. */ }
+        checkData(collection, 0, true);
+        return collection;
     }
-    if (typeof source === "string")
-        return [...source];
-    if (Array.isArray(source))
-        return [...source];
-    const iterator = getSandboxIterator(source);
-    if (iterator?.generator === true) {
-        return collectSetValues(iterator);
+    finally {
+        budget.setRetainedValues(retained, undefined);
     }
-    throw new TypeError("Set constructor argument must be an array, string, or Set.");
-}
-async function collectSetValues(iterator) {
-    const values = [];
-    while (true) {
-        const result = await iterator.next();
-        if (result.done)
-            break;
-        values.push(result.value);
-    }
-    return values;
-}
-function createBudgetedMap(entries, budget) {
-    const map = createSandboxMap(entries);
-    budget.allocateCollectionEntries(map.entries.size);
-    return map;
-}
-function createBudgetedSet(values, budget) {
-    budget.allocateCollectionEntries(new Set(values).size);
-    return createSandboxSet(values);
 }

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

@@ -1,5 +1,6 @@
 import { isFatalSandboxError } from "../budget.js";
 import { invokeBuiltinClosure } from "../builtin-call.js";
+import { createDataCheckpoint } from "../data-checkpoint.js";
 import { isCapturedException } from "../exceptions.js";
 import { isSandboxDate } from "../date.js";
 import { getDatePrototype } from "./date.js";
@@ -10,7 +11,7 @@ import { setSandboxProperty } from "../interpreter.js";
 import { getSandboxIterator } from "../iteration.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, measureSandboxData, ownEnumerableSandboxEntries as getOwnEnumerableEntries, reconcileCompiledValues } from "../values.js";
+import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, defineOwnDataProperty, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet, measureSandboxData, ownEnumerableSandboxEntries as getOwnEnumerableEntries } from "../values.js";
 export function createObjectArrayGlobals(options) {
     return {
         Object: createObjectGlobal({
@@ -487,23 +488,6 @@ async function arrayFromSandboxValues(args, budget, context) {
         budget.setRetainedValues(retained, undefined);
     }
 }
-function createDataCheckpoint(budget, context) {
-    let estimatedDataSize = 0;
-    return (value, growth = 0, force = false) => {
-        const limit = budget.limits.dataSize;
-        if (limit === undefined)
-            return;
-        estimatedDataSize = Math.max(estimatedDataSize, budget.currentDataSize) + growth;
-        // Bounded growth estimates defer exact scans until they could exceed the limit.
-        if (!force && estimatedDataSize <= limit)
-            return;
-        if (context?.reconcileData !== undefined)
-            context.reconcileData(value);
-        else
-            reconcileCompiledValues(budget, [value], context?.compilation);
-        estimatedDataSize = budget.currentDataSize;
-    };
-}
 function createArrayFromConstructorArgs(args, budget) {
     if (args.length !== 1) {
         return budgetSandboxValue(Reflect.apply(Array, Array, [...args]), budget);

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

@@ -1,4 +1,4 @@
-import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure } from "../values.js";
+import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxMap } from "../values.js";
 import { assertCollectionMutable } from "../running-state.js";
 import { enterKeyedCollectionCallback, updateKeyedCollectionCallbacks } from "./collection-callback.js";
 const mapMethodNames = new Set([
@@ -24,7 +24,12 @@ export function getMapMember(target, property, options) {
     }
     return createSandboxClosure({
         sandbox: true,
-        call: (args, context) => callMapMethod(target, property, args, options, context?.stack ?? []),
+        call: (args, context) => {
+            const receiver = context?.thisValue;
+            if (!isSandboxMap(receiver))
+                throw new TypeError(`Map#${property} requires a Map receiver.`);
+            return callMapMethod(receiver, property, args, options, context?.stack ?? []);
+        },
         name: property
     });
 }

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

@@ -1,4 +1,4 @@
-import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure } from "../values.js";
+import { allocateProducedSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxSet } from "../values.js";
 import { assertCollectionMutable } from "../running-state.js";
 import { enterKeyedCollectionCallback, updateKeyedCollectionCallbacks } from "./collection-callback.js";
 const setMethodNames = new Set([
@@ -23,7 +23,12 @@ export function getSetMember(target, property, options) {
     }
     return createSandboxClosure({
         sandbox: true,
-        call: (args, context) => callSetMethod(target, property, args, options, context?.stack ?? []),
+        call: (args, context) => {
+            const receiver = context?.thisValue;
+            if (!isSandboxSet(receiver))
+                throw new TypeError(`Set#${property} requires a Set receiver.`);
+            return callSetMethod(receiver, property, args, options, context?.stack ?? []);
+        },
         name: property
     });
 }