poe-code 14.0.82 → 14.0.84

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

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-7LGBDF56.js";
+} from "./chunks/chunk-2EZQJQ2C.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-V6LQP64H.js";
+} from "./chunks/chunk-CYVI4ZUK.js";
 import "./chunks/chunk-M2DLCGEF.js";
 import "./chunks/chunk-Q7USUEL7.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-V6LQP64H.js";
+} from "./chunks/chunk-CYVI4ZUK.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-7LGBDF56.js";
+} from "./chunks/chunk-2EZQJQ2C.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-V6LQP64H.js";
+} from "./chunks/chunk-CYVI4ZUK.js";
 import "./chunks/chunk-M2DLCGEF.js";
 import "./chunks/chunk-Q7USUEL7.js";
 import "./chunks/chunk-4YIDX44G.js";

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

@@ -0,0 +1,12 @@
+import type { Budget } from "./budget.js";
+import type { SandboxObject } from "./values.js";
+export declare const arrayBufferPrototypes: WeakMap<Budget, SandboxObject>;
+export declare function isSandboxArrayBuffer(value: unknown): value is ArrayBuffer;
+export declare function arrayBufferLength(value: ArrayBuffer): number;
+export declare function arrayBufferOptions(value: ArrayBuffer): {
+    maxByteLength: number;
+} | undefined;
+export declare function copyArrayBufferStorage(value: ArrayBuffer, state: {
+    float32Buffers?: WeakMap<ArrayBuffer, ArrayBuffer>;
+}): ArrayBuffer;
+export declare function arrayBufferDataProperties(value: ArrayBuffer): Array<[string | symbol, PropertyDescriptor]>;

package/packages/safe-js/dist/interp/array-buffer.js

@@ -0,0 +1,33 @@
+import { types } from "node:util";
+const readLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+const readResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get;
+const readMaxLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "maxByteLength")?.get;
+export const arrayBufferPrototypes = new WeakMap();
+export function isSandboxArrayBuffer(value) {
+    return types.isArrayBuffer(value) && Object.getPrototypeOf(value) === ArrayBuffer.prototype;
+}
+export function arrayBufferLength(value) {
+    return Reflect.apply(readLength, value, []);
+}
+export function arrayBufferOptions(value) {
+    return readResizable !== undefined && Reflect.apply(readResizable, value, [])
+        ? { maxByteLength: Reflect.apply(readMaxLength, value, []) } : undefined;
+}
+export function copyArrayBufferStorage(value, state) {
+    state.float32Buffers ??= new WeakMap();
+    let copy = state.float32Buffers.get(value);
+    if (copy === undefined) {
+        copy = Reflect.construct(ArrayBuffer, [arrayBufferLength(value), arrayBufferOptions(value)]);
+        new Uint8Array(copy).set(new Uint8Array(value));
+        state.float32Buffers.set(value, copy);
+    }
+    return copy;
+}
+export function arrayBufferDataProperties(value) {
+    return Reflect.ownKeys(value).map(key => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!("value" in descriptor))
+            throw new TypeError("ArrayBuffer accessors cannot be copied as data.");
+        return [key, descriptor];
+    });
+}

package/packages/safe-js/dist/interp/float32-prototypes.d.ts

@@ -0,0 +1,3 @@
+import type { Budget } from "./budget.js";
+import type { SandboxObject } from "./values.js";
+export declare const float32Prototypes: WeakMap<Budget, SandboxObject>;

package/packages/safe-js/dist/interp/float32-prototypes.js

@@ -0,0 +1 @@
+export const float32Prototypes = new WeakMap();

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

@@ -1,11 +1,17 @@
 import type { Budget } from "./budget.js";
+export declare const float32ViewLayouts: WeakMap<Float32Array<ArrayBufferLike>, {
+    byteOffset: number;
+    length?: number;
+}>;
+export declare function restoreFloat32View(buffer: ArrayBuffer, byteOffset: number, length?: number, budget?: Budget): Float32Array;
 export declare function isFloat32Array(value: unknown): value is Float32Array;
-export declare function float32Storage(value: Float32Array): {
+export declare function float32Storage(value: Float32Array, requireInBounds?: boolean): {
     buffer: ArrayBuffer;
     byteOffset: number;
     length: number;
     byteLength: number;
 };
+export declare function float32Properties(value: Float32Array): Array<[PropertyKey, PropertyDescriptor]>;
 export declare function float32DataProperties(value: Float32Array): Array<[string, PropertyDescriptor]>;
 export declare function isFloat32Index(key: string): boolean;
 export declare function float32Number(value: unknown): number;

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

@@ -1,20 +1,48 @@
+import { arrayBufferLength, arrayBufferOptions, copyArrayBufferStorage } from "./array-buffer.js";
 const typedArrayPrototype = Object.getPrototypeOf(Float32Array.prototype);
 const readLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "length").get;
 const readOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
 const readBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
 const readTag = Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag).get;
+const createValuesIterator = Object.getOwnPropertyDescriptor(typedArrayPrototype, "values").value;
 const bufferLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
 const bufferResizable = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resizable")?.get;
+export const float32ViewLayouts = new WeakMap();
+const resizeBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize").value;
+export function restoreFloat32View(buffer, byteOffset, length, budget) {
+    const originalLength = arrayBufferLength(buffer);
+    const required = byteOffset + (length ?? 0) * 4;
+    const options = arrayBufferOptions(buffer);
+    const grow = required > originalLength;
+    if (grow) {
+        if (options === undefined || required > options.maxByteLength)
+            throw new RangeError("Float32Array layout exceeds backing capacity.");
+        budget?.allocateArrayLength(Math.ceil(required / 4));
+        budget?.provisionDataUsage(required - originalLength)();
+        Reflect.apply(resizeBuffer, buffer, [required]);
+    }
+    try {
+        const view = new Float32Array(buffer, byteOffset, length);
+        if (options !== undefined)
+            float32ViewLayouts.set(view, { byteOffset, ...(length === undefined ? {} : { length }) });
+        return view;
+    }
+    finally {
+        if (grow)
+            Reflect.apply(resizeBuffer, buffer, [originalLength]);
+    }
+}
 export function isFloat32Array(value) {
     return (ArrayBuffer.isView(value) &&
         Object.getPrototypeOf(value) === Float32Array.prototype &&
         Reflect.apply(readTag, value, []) === "Float32Array");
 }
-export function float32Storage(value) {
+export function float32Storage(value, requireInBounds = false) {
+    if (requireInBounds)
+        Reflect.apply(createValuesIterator, value, []);
     const buffer = Reflect.apply(readBuffer, value, []);
-    if (Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype ||
-        (bufferResizable !== undefined && Reflect.apply(bufferResizable, buffer, []))) {
-        throw new TypeError("Float32Array requires a fixed, non-shared ArrayBuffer.");
+    if (Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype) {
+        throw new TypeError("Float32Array requires a non-shared ArrayBuffer.");
     }
     return {
         buffer,
@@ -23,14 +51,22 @@ export function float32Storage(value) {
         byteLength: Reflect.apply(bufferLength, buffer, [])
     };
 }
+export function float32Properties(value) {
+    const properties = [];
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key === "string" && isFloat32Index(key))
+            continue;
+        properties.push([key, Object.getOwnPropertyDescriptor(value, key)]);
+    }
+    return properties;
+}
 export function float32DataProperties(value) {
     if (Object.getOwnPropertySymbols(value).length > 0)
         throw new TypeError("Float32Array symbol properties are not supported.");
     const properties = [];
-    for (const key of Object.getOwnPropertyNames(value)) {
-        if (isFloat32Index(key))
-            continue;
-        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    for (const [key, descriptor] of float32Properties(value)) {
+        if (typeof key !== "string")
+            throw new TypeError("Float32Array symbol properties are not supported.");
         if (!("value" in descriptor))
             throw new TypeError(`Float32Array accessor property '${key}' is not supported.`);
         properties.push([key, descriptor]);
@@ -55,12 +91,12 @@ export function checkFloat32Allocation(length, budget) {
 }
 export function copyFloat32Storage(value, state) {
     const storage = float32Storage(value);
-    state.float32Buffers ??= new WeakMap();
-    let buffer = state.float32Buffers.get(storage.buffer);
-    if (buffer === undefined) {
-        buffer = new ArrayBuffer(storage.byteLength);
-        new Uint8Array(buffer).set(new Uint8Array(storage.buffer));
-        state.float32Buffers.set(storage.buffer, buffer);
+    const buffer = copyArrayBufferStorage(storage.buffer, state);
+    if (bufferResizable !== undefined && Reflect.apply(bufferResizable, storage.buffer, [])) {
+        const layout = float32ViewLayouts.get(value);
+        if (layout === undefined)
+            throw new TypeError("Resizable Float32Array copies require known view layout.");
+        return restoreFloat32View(buffer, layout.byteOffset, layout.length);
     }
     return new Float32Array(buffer, storage.byteOffset, storage.length);
 }

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

@@ -0,0 +1,3 @@
+import type { Budget } from "../budget.js";
+import { type SandboxClosure } from "../values.js";
+export declare function createArrayBufferGlobal(budget: Budget): SandboxClosure;

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

@@ -0,0 +1,112 @@
+import { arrayBufferLength, arrayBufferOptions, arrayBufferPrototypes, isSandboxArrayBuffer } from "../array-buffer.js";
+import { accessorAdapter, readPropertyDescriptor } from "../accessors.js";
+import { createSandboxClosure } from "../values.js";
+import { getSandboxDataProperty, getSandboxPropertyDescriptor, getSandboxPrototype, materializeFunctionProperties, registerIntrinsicFunction, registerIntrinsicObject, setSandboxPrototype } from "../object-model.js";
+import { invokeBuiltinClosure } from "../builtin-call.js";
+import { registerBuiltinIdentities } from "../intrinsics.js";
+import { sandboxNumber } from "../string-coercion.js";
+import { retainValues } from "../resources.js";
+const resizeBuffer = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "resize").value;
+export function createArrayBufferGlobal(budget) {
+    const prototype = Object.create(null);
+    const constructor = createSandboxClosure({
+        guest: true, sandbox: true, name: "ArrayBuffer", length: 1,
+        call: () => { throw new TypeError("ArrayBuffer requires new."); },
+        construct: async (args, context) => {
+            let selected;
+            let current;
+            const bridge = {
+                ...context, stack: context?.stack ?? [], thisValue: undefined,
+                getProperty: context?.getProperty ?? ((value, key) => {
+                    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+                    return descriptor === undefined ? getSandboxDataProperty(value, key, budget)
+                        : readPropertyDescriptor(descriptor, value, bridge);
+                }),
+                invokeClosure: context?.invokeClosure ?? ((callee, values, receiver, construct) => invokeBuiltinClosure(callee, values, budget, context, receiver, construct))
+            };
+            const release = retainValues(budget, () => [selected, current, ...args]);
+            try {
+                const number = await sandboxNumber(args[0], budget, bridge);
+                const length = Number.isNaN(number) ? 0 : Math.trunc(number);
+                if (length < 0 || !Number.isSafeInteger(length))
+                    throw new RangeError("Invalid ArrayBuffer length.");
+                let maxByteLength;
+                if (args[1] !== null && typeof args[1] === "object") {
+                    current = await bridge.getProperty(args[1], "maxByteLength");
+                    if (current !== undefined) {
+                        const maximum = await sandboxNumber(current, budget, bridge);
+                        maxByteLength = Number.isNaN(maximum) ? 0 : Math.trunc(maximum);
+                        if (!Number.isSafeInteger(maxByteLength) || maxByteLength < length)
+                            throw new RangeError("Invalid ArrayBuffer maximum length.");
+                    }
+                }
+                const target = context?.newTarget ?? constructor;
+                selected = await bridge.getProperty(target, "prototype");
+                budget.allocateArrayLength(maxByteLength ?? length);
+                budget.provisionDataUsage(length + 1)();
+                const result = Reflect.construct(ArrayBuffer, [length, maxByteLength === undefined ? undefined : { maxByteLength }]);
+                setSandboxPrototype(result, selected !== null && typeof selected === "object" ? selected : prototype, budget);
+                return result;
+            }
+            finally {
+                release();
+            }
+        }
+    });
+    Object.defineProperty(materializeFunctionProperties(constructor), "prototype", { value: prototype, writable: false });
+    Object.defineProperty(materializeFunctionProperties(constructor), "isView", {
+        writable: true, configurable: true,
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "isView", length: 1,
+            call: args => ArrayBuffer.isView(args[0]) })
+    });
+    Object.defineProperties(prototype, {
+        constructor: { value: constructor, writable: true, configurable: true },
+        [Symbol.toStringTag]: { value: "ArrayBuffer", configurable: true }
+    });
+    const getters = [];
+    Object.defineProperty(prototype, "resize", { writable: true, configurable: true,
+        value: createSandboxClosure({ guest: true, sandbox: true, name: "resize", length: 1,
+            call: async (args, context) => {
+                const receiver = context?.thisValue;
+                if (!isSandboxArrayBuffer(receiver) || arrayBufferOptions(receiver) === undefined)
+                    throw new TypeError("ArrayBuffer resize requires a resizable buffer receiver.");
+                const release = retainValues(budget, () => [receiver, ...args]);
+                try {
+                    const number = await sandboxNumber(args[0], budget, context);
+                    const length = Number.isNaN(number) ? 0 : Math.trunc(number);
+                    if (!Number.isSafeInteger(length) || length < 0 || length > arrayBufferOptions(receiver).maxByteLength)
+                        throw new RangeError("Invalid ArrayBuffer resize length.");
+                    budget.allocateArrayLength(length);
+                    budget.provisionDataUsage(Math.max(length - arrayBufferLength(receiver), 0))();
+                    Reflect.apply(resizeBuffer, receiver, [length]);
+                    return undefined;
+                }
+                finally {
+                    release();
+                }
+            }
+        })
+    });
+    for (const key of ["byteLength", "maxByteLength", "resizable"]) {
+        const getter = createSandboxClosure({ guest: true, sandbox: true, name: `get ${key}`, length: 0,
+            call: (_args, context) => {
+                if (!isSandboxArrayBuffer(context?.thisValue))
+                    throw new TypeError(`ArrayBuffer ${key} requires a buffer receiver.`);
+                if (key === "byteLength")
+                    return arrayBufferLength(context.thisValue);
+                const options = arrayBufferOptions(context.thisValue);
+                return key === "resizable" ? options !== undefined : options?.maxByteLength ?? arrayBufferLength(context.thisValue);
+            }
+        });
+        Object.defineProperty(prototype, key, { get: accessorAdapter(getter, "get"), configurable: true });
+        getters.push(getter);
+    }
+    setSandboxPrototype(prototype, getSandboxPrototype(Object.create(null), budget));
+    arrayBufferPrototypes.set(budget, prototype);
+    registerBuiltinIdentities(budget, { ArrayBuffer: constructor });
+    registerIntrinsicFunction(budget, constructor);
+    for (const getter of getters)
+        registerIntrinsicFunction(budget, getter);
+    registerIntrinsicObject(budget, prototype);
+    return constructor;
+}

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

@@ -1,6 +1,7 @@
 import type { Budget } from "../budget.js";
 import { type SandboxClosure, type SandboxValue } from "../values.js";
-export declare function createFloat32ArrayGlobal(budget: Budget): SandboxClosure;
+export declare function createFloat32ArrayGlobal(budget: Budget, nativePrototype?: boolean): SandboxClosure;
+export declare function createFloat32ArrayPrototypes(budget: Budget, constructor: SandboxClosure): void;
 export declare function isFloat32ArrayConstructor(value: unknown): boolean;
-export declare function getFloat32Member(value: Float32Array, property: string | number, budget: Budget): SandboxValue;
-export declare function setFloat32Member(value: Float32Array, property: string | number, entry: SandboxValue): void;
+export declare function getFloat32Member(value: Float32Array, property: string | number, budget: Budget, defaultConstructor?: SandboxClosure): SandboxValue;
+export declare function setFloat32Member(value: Float32Array, property: PropertyKey, entry: SandboxValue, budget?: Budget): void;