poe-code 14.0.58 → 14.0.60

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

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

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

@@ -273,89 +273,114 @@ async function evaluateEmptyStatement(_node, _context) {
 }
 async function evaluateArrayExpression(node, context) {
     const values = [];
-    for (const element of node.elements) {
-        if (element.type === "UndefinedLiteral" && element.elision === true) {
-            values.length += 1;
-            context.budget.allocateArrayLength(values.length);
-            continue;
-        }
-        if (element.type === "SpreadElement") {
-            const spreadValues = await evaluateSpreadElement(element, context);
-            if (!spreadValues.ok) {
-                return spreadValues.result;
+    const release = retainValues(context.budget, () => [values]);
+    try {
+        for (const element of node.elements) {
+            if (element.type === "UndefinedLiteral" && element.elision === true) {
+                values.length += 1;
+                context.budget.allocateArrayLength(values.length);
+                continue;
+            }
+            if (element.type === "SpreadElement") {
+                const spreadValues = await evaluateSpreadElement(element, context);
+                if (!spreadValues.ok) {
+                    return spreadValues.result;
+                }
+                appendArrayValues(values, spreadValues.value);
+                context.budget.allocateArrayLength(values.length);
+                continue;
+            }
+            const result = await evaluateNode(element, context);
+            if (result.kind !== "normal") {
+                return result;
             }
-            appendArrayValues(values, spreadValues.value);
+            values.push(result.value);
             context.budget.allocateArrayLength(values.length);
-            continue;
-        }
-        const result = await evaluateNode(element, context);
-        if (result.kind !== "normal") {
-            return result;
         }
-        values.push(result.value);
-        context.budget.allocateArrayLength(values.length);
+        return {
+            kind: "normal",
+            hasValue: true,
+            value: values
+        };
+    }
+    finally {
+        release();
     }
-    return {
-        kind: "normal",
-        hasValue: true,
-        value: values
-    };
 }
 async function evaluateObjectExpression(node, context) {
     const object = Object.create(null);
-    for (const property of node.properties) {
-        if (property.type === "SpreadElement") {
-            const spreadEntries = await evaluateObjectSpread(property, context);
-            if (!spreadEntries.ok) {
-                return spreadEntries.result;
+    const release = retainValues(context.budget, () => [object]);
+    try {
+        for (const property of node.properties) {
+            if (property.type === "SpreadElement") {
+                const spreadEntries = await evaluateObjectSpread(property, context);
+                if (!spreadEntries.ok) {
+                    return spreadEntries.result;
+                }
+                for (const [key, value] of spreadEntries.value) {
+                    defineSandboxProperty(object, key, value);
+                }
+                continue;
             }
-            for (const [key, value] of spreadEntries.value) {
-                defineSandboxProperty(object, key, value);
+            const key = await evaluateObjectPropertyKey(property, context);
+            if (!key.ok) {
+                return key.result;
             }
-            continue;
-        }
-        const key = await evaluateObjectPropertyKey(property, context);
-        if (!key.ok) {
-            return key.result;
-        }
-        const value = await evaluateNode(property.value, context);
-        if (value.kind !== "normal") {
-            return value;
-        }
-        if (isObjectPrototypeSetterProperty(property, key.value)) {
-            if (value.value === null || typeof value.value === "object") {
-                setSandboxPrototype(object, value.value, context.budget);
+            const releaseKey = retainValues(context.budget, () => [key.value]);
+            let value;
+            try {
+                value = await evaluateNode(property.value, context);
             }
-            continue;
+            finally {
+                releaseKey();
+            }
+            if (value.kind !== "normal") {
+                return value;
+            }
+            if (isObjectPrototypeSetterProperty(property, key.value)) {
+                if (value.value === null || typeof value.value === "object") {
+                    setSandboxPrototype(object, value.value, context.budget);
+                }
+                continue;
+            }
+            defineSandboxProperty(object, String(key.value), value.value);
         }
-        defineSandboxProperty(object, String(key.value), value.value);
+        return {
+            kind: "normal",
+            hasValue: true,
+            value: object
+        };
+    }
+    finally {
+        release();
     }
-    return {
-        kind: "normal",
-        hasValue: true,
-        value: object
-    };
 }
 function isObjectPrototypeSetterProperty(property, key) {
     return !property.computed && !property.shorthand && key === "__proto__";
 }
 async function evaluateTemplateLiteral(node, context) {
     let value = context.budget.allocateString(node.quasis[0]?.value.cooked ?? "");
-    for (let index = 0; index < node.expressions.length; index += 1) {
-        const expression = await evaluateNode(node.expressions[index], context);
-        if (expression.kind !== "normal") {
-            return expression;
+    const release = retainValues(context.budget, () => [value]);
+    try {
+        for (let index = 0; index < node.expressions.length; index += 1) {
+            const expression = await evaluateNode(node.expressions[index], context);
+            if (expression.kind !== "normal") {
+                return expression;
+            }
+            const expressionText = context.budget.allocateString(String(expression.value));
+            value = context.budget.allocateString(value + expressionText);
+            const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
+            value = context.budget.allocateString(value + quasiText);
         }
-        const expressionText = context.budget.allocateString(String(expression.value));
-        value = context.budget.allocateString(value + expressionText);
-        const quasiText = context.budget.allocateString(node.quasis[index + 1]?.value.cooked ?? "");
-        value = context.budget.allocateString(value + quasiText);
+        return {
+            kind: "normal",
+            hasValue: true,
+            value
+        };
+    }
+    finally {
+        release();
     }
-    return {
-        kind: "normal",
-        hasValue: true,
-        value
-    };
 }
 async function evaluateTaggedTemplateExpression(node, context) {
     const tag = await evaluateNode(node.tag, context);
@@ -377,20 +402,26 @@ async function evaluateTaggedTemplateExpression(node, context) {
 }
 async function evaluateTemplateExpressionValues(node, context) {
     const values = [];
-    for (const expressionNode of node.expressions) {
-        const expression = await evaluateNode(expressionNode, context);
-        if (expression.kind !== "normal") {
-            return {
-                ok: false,
-                result: expression
-            };
+    const release = retainValues(context.budget, () => values);
+    try {
+        for (const expressionNode of node.expressions) {
+            const expression = await evaluateNode(expressionNode, context);
+            if (expression.kind !== "normal") {
+                return {
+                    ok: false,
+                    result: expression
+                };
+            }
+            values.push(expression.value);
         }
-        values.push(expression.value);
+        return {
+            ok: true,
+            value: values
+        };
+    }
+    finally {
+        release();
     }
-    return {
-        ok: true,
-        value: values
-    };
 }
 function createTaggedTemplateStrings(node, context) {
     context.budget.allocateArrayLength(node.quasis.length);
@@ -430,23 +461,31 @@ async function evaluateBinaryExpression(node, context) {
     if (left.kind !== "normal") {
         return left;
     }
-    const right = await evaluateNode(node.right, context);
-    if (right.kind !== "normal") {
-        return right;
-    }
-    let leftValue = left.value;
-    if (node.operator === "in") {
-        if (typeof right.value !== "object" || right.value === null) {
-            throw new TypeError("Right-hand side of 'in' must be an object.");
+    let rightValue;
+    const release = retainValues(context.budget, () => [left.value, rightValue]);
+    try {
+        const right = await evaluateNode(node.right, context);
+        if (right.kind !== "normal") {
+            return right;
         }
-        leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
+        rightValue = right.value;
+        let leftValue = left.value;
+        if (node.operator === "in") {
+            if (typeof right.value !== "object" || right.value === null) {
+                throw new TypeError("Right-hand side of 'in' must be an object.");
+            }
+            leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
+        }
+        const value = applyBinaryOperator(node, leftValue, right.value, context);
+        return {
+            kind: "normal",
+            hasValue: true,
+            value
+        };
+    }
+    finally {
+        release();
     }
-    const value = applyBinaryOperator(node, leftValue, right.value, context);
-    return {
-        kind: "normal",
-        hasValue: true,
-        value
-    };
 }
 async function evaluateAssignmentExpression(node, context) {
     if (node.left.type === "ArrayPattern" || node.left.type === "ObjectPattern") {
@@ -554,26 +593,35 @@ async function evaluateMemberAssignmentExpression(node, context) {
                 value: current
             };
         }
-        const right = await evaluateNode(node.right, context);
-        if (right.kind !== "normal") {
-            return right;
+        let operands = [current, property];
+        const release = retainValues(context.budget, () => operands);
+        try {
+            const right = await evaluateNode(node.right, context);
+            if (right.kind !== "normal") {
+                return right;
+            }
+            operands.push(right.value);
+            const value = node.operator === "=" ||
+                node.operator === "&&=" ||
+                node.operator === "||=" ||
+                node.operator === "??="
+                ? right.value
+                : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
+            if (member.object === null || member.object === undefined) {
+                throw new TypeError("Cannot assign properties of null or undefined.");
+            }
+            operands = [value];
+            property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
+            setSandboxProperty(member.object, property, value, context.budget);
+            return {
+                kind: "normal",
+                hasValue: true,
+                value
+            };
         }
-        const value = node.operator === "=" ||
-            node.operator === "&&=" ||
-            node.operator === "||=" ||
-            node.operator === "??="
-            ? right.value
-            : await applyCompoundAssignmentOperator(node.operator, current, right.value, context);
-        if (member.object === null || member.object === undefined) {
-            throw new TypeError("Cannot assign properties of null or undefined.");
+        finally {
+            release();
         }
-        property ??= await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-        setSandboxProperty(member.object, property, value, context.budget);
-        return {
-            kind: "normal",
-            hasValue: true,
-            value
-        };
     });
 }
 async function evaluateLogicalExpression(node, context) {
@@ -1768,12 +1816,8 @@ async function evaluateMemberAccess(node, context, consume) {
     if ((object.value === null || object.value === undefined) && node.optional) {
         return consume({ kind: "nullish" });
     }
-    const retained = {};
     let property;
-    context.budget.setRetainedValues(retained, () => [object.value, property]);
-    const release = () => context.budget.setRetainedValues(retained, undefined);
-    const pending = runResources.getStore()?.referenceReleases;
-    pending?.add(release);
+    const release = retainValues(context.budget, () => [object.value, property]);
     try {
         const result = node.computed
             ? await evaluateNode(node.property, context)
@@ -1785,9 +1829,19 @@ async function evaluateMemberAccess(node, context, consume) {
     }
     finally {
         release();
-        pending?.delete(release);
     }
 }
+function retainValues(budget, values) {
+    const retained = {};
+    budget.setRetainedValues(retained, values);
+    const pending = runResources.getStore()?.referenceReleases;
+    const release = () => {
+        budget.setRetainedValues(retained, undefined);
+        pending?.delete(release);
+    };
+    pending?.add(release);
+    return release;
+}
 async function evaluateMemberProperty(node, context) {
     const property = await evaluateNode(node, context);
     if (property.kind !== "normal") {
@@ -2538,30 +2592,36 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
 }
 async function evaluateCallArguments(args, context) {
     const values = [];
-    for (const arg of args) {
-        if (arg.type === "SpreadElement") {
-            const spreadValues = await evaluateSpreadElement(arg, context);
-            if (!spreadValues.ok) {
-                return spreadValues;
+    const release = retainValues(context.budget, () => values);
+    try {
+        for (const arg of args) {
+            if (arg.type === "SpreadElement") {
+                const spreadValues = await evaluateSpreadElement(arg, context);
+                if (!spreadValues.ok) {
+                    return spreadValues;
+                }
+                appendArrayValues(values, spreadValues.value);
+                context.budget.allocateArrayLength(values.length);
+                continue;
+            }
+            const result = await evaluateNode(arg, context);
+            if (result.kind !== "normal") {
+                return {
+                    ok: false,
+                    result
+                };
             }
-            appendArrayValues(values, spreadValues.value);
+            values.push(result.value);
             context.budget.allocateArrayLength(values.length);
-            continue;
-        }
-        const result = await evaluateNode(arg, context);
-        if (result.kind !== "normal") {
-            return {
-                ok: false,
-                result
-            };
         }
-        values.push(result.value);
-        context.budget.allocateArrayLength(values.length);
+        return {
+            ok: true,
+            value: values
+        };
+    }
+    finally {
+        release();
     }
-    return {
-        ok: true,
-        value: values
-    };
 }
 async function evaluateSpreadElement(node, context) {
     const value = await evaluateNode(node.argument, context);
@@ -2576,21 +2636,27 @@ async function evaluateSpreadElement(node, context) {
         throw new TypeError("Spread arguments must evaluate to an iterable.");
     }
     const spreadValues = [];
-    while (true) {
-        const next = await iterator.next();
-        if (typeof next !== "object" || next === null) {
-            throw new TypeError("Iterator result must be an object.");
-        }
-        if (next.done === true) {
-            break;
+    const release = retainValues(context.budget, () => [value.value, ...spreadValues]);
+    try {
+        while (true) {
+            const next = await iterator.next();
+            if (typeof next !== "object" || next === null) {
+                throw new TypeError("Iterator result must be an object.");
+            }
+            if (next.done === true) {
+                break;
+            }
+            spreadValues.push(next.value);
+            context.budget.allocateArrayLength(spreadValues.length);
         }
-        spreadValues.push(next.value);
-        context.budget.allocateArrayLength(spreadValues.length);
+        return {
+            ok: true,
+            value: spreadValues
+        };
+    }
+    finally {
+        release();
     }
-    return {
-        ok: true,
-        value: spreadValues
-    };
 }
 async function evaluateObjectSpread(node, context) {
     const value = await evaluateNode(node.argument, context);