poe-code 13.0.1 → 13.0.2

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-EL23VF23.js";
+} from "./chunks/chunk-JP474LP7.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-DALBPQDZ.js";
+} from "./chunks/chunk-RIQRHKCB.js";
 import "./chunks/chunk-ZRX5HT5L.js";
 import "./chunks/chunk-WVN5MMDR.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -3,7 +3,7 @@ import {
   createReplayableRandom,
   lint,
   run
-} from "./chunks/chunk-DALBPQDZ.js";
+} from "./chunks/chunk-RIQRHKCB.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

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

@@ -29,7 +29,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-EL23VF23.js";
+} from "./chunks/chunk-JP474LP7.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -51,7 +51,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-DALBPQDZ.js";
+} from "./chunks/chunk-RIQRHKCB.js";
 import "./chunks/chunk-ZRX5HT5L.js";
 import "./chunks/chunk-WVN5MMDR.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -1,7 +1,7 @@
-import { sandboxErrorTypes } from "../../error/shape.js";
 import { isFloat32Array } from "../float32.js";
 import { setFloat32Member } from "./float32array.js";
 import { getSandboxIterator } from "../iteration.js";
+import { sandboxString } from "../string-coercion.js";
 import { allocateProducedSandboxValue, createSandboxClosure, deepCopyToSandbox, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "../values.js";
 export function createObjectArrayGlobals(options) {
     return {
@@ -91,12 +91,7 @@ export function createObjectArrayGlobals(options) {
         }),
         String: createSandboxClosure({
             sandbox: true,
-            call: ([value]) => options.budget.allocateString(typeof value === "object" &&
-                value !== null &&
-                sandboxErrorTypes.has(value) &&
-                !Object.hasOwn(value, "toString")
-                ? Error.prototype.toString.call(value)
-                : String(value)),
+            call: (args, context) => sandboxString(args.length === 0 ? "" : args[0], options.budget, context),
             name: "String",
             properties: {
                 raw: createSandboxClosure({

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

@@ -2333,6 +2333,7 @@ async function invokeSandboxClosure(callee, args, context, stack, span, thisValu
             {
                 stack,
                 thisValue,
+                invokeClosure: (closure, argumentsList, receiver) => invokeSandboxClosure(closure, argumentsList, context, stack, span, receiver),
                 ...(span === undefined ? {} : { span })
             }
         ]);

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

@@ -0,0 +1,3 @@
+import type { Budget } from "./budget.js";
+import { type SandboxCallContext, type SandboxValue } from "./values.js";
+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

@@ -0,0 +1,89 @@
+import { sandboxErrorTypes } from "../error/shape.js";
+import { float32Storage, isFloat32Array } from "./float32.js";
+import { isSandboxClosure, isSandboxPromise } from "./values.js";
+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));
+    }
+    return stringifyObject(value, budget, context, joining);
+}
+async function stringifyObject(value, budget, context, joining) {
+    const leaveCall = budget.enterCall();
+    try {
+        budget.visitNode();
+        for (const name of ["toString", "valueOf"]) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, name);
+            let result;
+            if (descriptor === undefined) {
+                if (name === "valueOf")
+                    continue;
+                result = await defaultToString(value, budget, context, joining);
+            }
+            else {
+                const hook = ownDataValue(value, name);
+                if (!isSandboxClosure(hook))
+                    continue;
+                if (context?.invokeClosure === undefined) {
+                    throw new TypeError("String hooks require a sandbox call context.");
+                }
+                result = await context.invokeClosure(hook, [], value);
+            }
+            if (result === null || typeof result !== "object") {
+                return sandboxString(result, budget, context, joining);
+            }
+        }
+        throw new TypeError("Cannot convert object to primitive value");
+    }
+    finally {
+        leaveCall();
+    }
+}
+async function defaultToString(value, budget, context, joining) {
+    if (Array.isArray(value) || isFloat32Array(value)) {
+        if (Object.hasOwn(value, "join")) {
+            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);
+        }
+        if (joining.has(value))
+            return "";
+        joining.add(value);
+        try {
+            const length = isFloat32Array(value) ? float32Storage(value).length : value.length;
+            let text = "";
+            for (let index = 0; index < length; index++) {
+                budget.visitNode();
+                const element = ownDataValue(value, String(index));
+                const part = element === null || element === undefined
+                    ? ""
+                    : await sandboxString(element, budget, context, joining);
+                text = budget.allocateString(text + (index === 0 ? "" : ",") + part);
+            }
+            return text;
+        }
+        finally {
+            joining.delete(value);
+        }
+    }
+    if (sandboxErrorTypes.has(value)) {
+        const nameValue = ownDataValue(value, "name");
+        const name = nameValue === undefined ? "Error" : await sandboxString(nameValue, budget, context, joining);
+        const messageValue = ownDataValue(value, "message");
+        const message = messageValue === undefined ? "" : await sandboxString(messageValue, budget, context, joining);
+        return name === "" ? message : message === "" ? name : `${name}: ${message}`;
+    }
+    return isSandboxPromise(value) ? "[object Promise]" : "[object Object]";
+}
+function ownDataValue(value, name) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, name);
+    if (descriptor !== undefined && !Object.hasOwn(descriptor, "value")) {
+        throw new TypeError("String conversion requires sandbox data properties.");
+    }
+    return descriptor?.value;
+}

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

@@ -49,6 +49,7 @@ export type SandboxCallContext = {
     };
     readonly stack: readonly string[];
     readonly thisValue: SandboxValue;
+    readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue) => Promise<SandboxValue>;
 };
 export type SandboxClosure = {
     readonly async?: true;