poe-code 11.0.18 → 11.0.20

package/packages/safejs/dist/chunks/{chunk-BIGMX2WV.js → chunk-JFP4YVY2.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-6BCUWJFF.js";
+} from "./chunk-7IOZFASL.js";
 
 // packages/safejs/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8055,4 +8055,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-BIGMX2WV.js.map
+//# sourceMappingURL=chunk-JFP4YVY2.js.map

package/packages/safejs/dist/cli.js

@@ -20,7 +20,7 @@ import {
   parseMcpConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-BIGMX2WV.js";
+} from "./chunks/chunk-JFP4YVY2.js";
 import {
   Budget,
   SandboxError,
@@ -32,7 +32,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-6BCUWJFF.js";
+} from "./chunks/chunk-7IOZFASL.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/cli.ts

package/packages/safejs/dist/core.js

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

package/packages/safejs/dist/graph-depth.js

@@ -64,8 +64,6 @@ function graphEntries(value) {
     if (isSandboxArguments(value)) {
         return getSandboxArgumentEntries(value).map(([key, entry]) => [`.${key}`, entry]);
     }
-    if (Array.isArray(value))
-        return value.map((entry, index) => [`[${index}]`, entry]);
     if (value instanceof Map) {
         return [...value.entries()].flatMap(([key, entry], index) => [
             [`.<map>[${index}].key`, key],
@@ -79,7 +77,7 @@ function graphEntries(value) {
     for (const key of Object.keys(value)) {
         const descriptor = Object.getOwnPropertyDescriptor(value, key);
         if (descriptor !== undefined && "value" in descriptor)
-            entries.push([`.${key}`, descriptor.value]);
+            entries.push([Array.isArray(value) ? `[${key}]` : `.${key}`, descriptor.value]);
     }
     return entries;
 }

package/packages/safejs/dist/index.js

@@ -27,7 +27,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-BIGMX2WV.js";
+} from "./chunks/chunk-JFP4YVY2.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -49,7 +49,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-6BCUWJFF.js";
+} from "./chunks/chunk-7IOZFASL.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/runner/run-harness.ts

package/packages/safejs/dist/interp/methods/string.js

@@ -291,6 +291,8 @@ function callMatchLikeMethod(value, methodName, args) {
         ? createSandboxRegex(regex.source, regex.flags, regex.lastIndex)
         : regex;
     const matches = collectRegexMatches(matcher, value, true);
+    if (methodName === "match" && matches.length === 0)
+        return null;
     return methodName === "match"
         ? matches.map((match) => match.text)
         : matches.map((match) => toMatchArray(match, value));

package/packages/safejs/dist/snapshot/arrays.d.ts

@@ -0,0 +1,10 @@
+export type SerializedArray<TValue> = {
+    kind: "array";
+    items: TValue[];
+} | {
+    kind: "array";
+    length: number;
+    entries: Record<string, TValue>;
+};
+export declare function requiresArrayEntries(value: unknown[]): boolean;
+export declare function serializeArray<TValue>(value: unknown[], serializeValue: (entry: unknown, key: string) => TValue): SerializedArray<TValue>;

package/packages/safejs/dist/snapshot/arrays.js

@@ -0,0 +1,24 @@
+export function requiresArrayEntries(value) {
+    const keys = Object.keys(value);
+    return keys.length !== value.length || keys.some((key, index) => key !== String(index));
+}
+export function serializeArray(value, serializeValue) {
+    if (!requiresArrayEntries(value)) {
+        return {
+            kind: "array",
+            items: Array.from({ length: value.length }, (_, index) => {
+                const key = String(index);
+                const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                return serializeValue(descriptor !== undefined && "value" in descriptor ? descriptor.value : undefined, key);
+            })
+        };
+    }
+    const entries = Object.create(null);
+    for (const key of Object.keys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor !== undefined && "value" in descriptor) {
+            entries[key] = serializeValue(descriptor.value, key);
+        }
+    }
+    return { kind: "array", length: value.length, entries };
+}

package/packages/safejs/dist/snapshot/dump-format.js

@@ -4,6 +4,7 @@ import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { getSandboxArgumentEntries, isSandboxArguments } from "../interp/arguments.js";
 import { serializeArguments } from "./arguments.js";
+import { requiresArrayEntries, serializeArray } from "./arrays.js";
 const SKIP_VALUE = Symbol("SafeJS.skip-dump-value");
 export function serializeSafeJSSnapshot(snapshot) {
     const replayError = Object.getOwnPropertyDescriptor(snapshot, "replayError");
@@ -94,10 +95,10 @@ function serializeHeapReference(value, path, state) {
             });
         }
         else if (Array.isArray(value)) {
-            state.heap[String(id)] = {
-                kind: "array",
-                items: serializeArrayItems(value, path, state)
-            };
+            state.heap[String(id)] = serializeArray(value, (entry, key) => {
+                const serialized = serializeDumpValue(entry, `${path}[${key}]`, state);
+                return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
+            });
         }
         else {
             const errorType = sandboxErrorTypes.get(value);
@@ -137,6 +138,7 @@ function indexHeapContainers(snapshot) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            (Array.isArray(value) && requiresArrayEntries(value)) ||
             isSandboxArguments(value) ||
             sandboxErrorTypes.has(value)) {
             heapIds.set(value, nextId);
@@ -173,9 +175,7 @@ function collectContainerStats(value, stats, ancestors) {
     ancestors.add(value);
     const entries = isSandboxArguments(value)
         ? getSandboxArgumentEntries(value).map(([, entry]) => entry)
-        : Array.isArray(value)
-            ? getArrayDataItems(value)
-            : getEnumerableDataValues(value);
+        : getEnumerableDataValues(value);
     for (const entry of entries) {
         collectContainerStats(entry, stats, ancestors);
     }

package/packages/safejs/dist/snapshot/restore.js

@@ -322,10 +322,16 @@ function restoreHeapValue(id, state) {
         throw new Error(`Snapshot references unknown heap value ${id}.`);
     }
     if (serialized.kind === "array") {
-        const array = [];
+        const array = new Array("items" in serialized ? serialized.items.length : serialized.length);
         state.heapValueById.set(id, array);
-        for (const entry of serialized.items) {
-            array.push(deserializeValue(entry, state));
+        const entries = "items" in serialized ? Object.entries(serialized.items) : Object.entries(serialized.entries);
+        for (const [key, entry] of entries) {
+            Object.defineProperty(array, key, {
+                value: deserializeValue(entry, state),
+                configurable: true,
+                enumerable: true,
+                writable: true
+            });
         }
         return array;
     }

package/packages/safejs/dist/snapshot/serialize.d.ts

@@ -1,5 +1,6 @@
 import { type SandboxErrorName } from "../error/shape.js";
 import { type SerializedArguments } from "./arguments.js";
+import { type SerializedArray } from "./arrays.js";
 import { type SandboxMap, type SandboxGenerator, type SandboxRegex, type SandboxSet } from "../interp/values.js";
 type SnapshotId = number | string;
 type SerializedUndefinedValue = {
@@ -38,10 +39,7 @@ export type SerializedReferenceValue = {
     kind: "ref";
     id: number;
 };
-export type SerializedHeapValue = SerializedArguments<SerializedSnapshotValue> | {
-    kind: "array";
-    items: SerializedSnapshotValue[];
-} | {
+export type SerializedHeapValue = SerializedArguments<SerializedSnapshotValue> | SerializedArray<SerializedSnapshotValue> | {
     kind: "object";
     entries: Record<string, SerializedSnapshotValue>;
     errorType?: SandboxErrorName;

package/packages/safejs/dist/snapshot/serialize.js

@@ -2,6 +2,7 @@ import { hashSource } from "../parse/hash.js";
 import { sandboxErrorTypes } from "../error/shape.js";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { serializeArguments } from "./arguments.js";
+import { requiresArrayEntries, serializeArray } from "./arrays.js";
 import { isSandboxArguments, isSandboxGenerator, isSandboxMap, isSandboxRegex, isSandboxSet } from "../interp/values.js";
 export class UnsnapshotableValueError extends Error {
     path;
@@ -201,10 +202,7 @@ function serializeHeapReference(value, path, state) {
             };
         }
         else if (Array.isArray(value)) {
-            state.heap[String(id)] = {
-                kind: "array",
-                items: value.map((entry, index) => serializeValue(entry, `${path}[${index}]`, state))
-            };
+            state.heap[String(id)] = serializeArray(value, (entry, key) => serializeValue(entry, `${path}[${key}]`, state));
         }
         else {
             const entries = Object.create(null);
@@ -282,6 +280,7 @@ function indexHeapContainers(input) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            (Array.isArray(value) && requiresArrayEntries(value)) ||
             sandboxErrorTypes.has(value) ||
             isSandboxArguments(value) ||
             isSandboxMap(value) ||
@@ -331,9 +330,7 @@ function collectContainerStats(value, stats, ancestors) {
             ? [...value.entries].flatMap(([key, entry]) => [key, entry])
             : isSandboxSet(value)
                 ? [...value.values]
-                : Array.isArray(value)
-                    ? value
-                    : Object.values(value);
+                : Object.values(value);
     for (const entry of entries) {
         collectContainerStats(entry, stats, ancestors);
     }

package/packages/safejs/dist/snapshot/validation.js

@@ -83,7 +83,7 @@ function validateDumpHeap(root, state) {
             continue;
         }
         if (entry.kind === "array") {
-            requireArray(entry.items, `${path}.items`, state);
+            validateArrayHeap(entry, path, state);
             continue;
         }
         if (entry.kind === "object") {
@@ -401,7 +401,7 @@ function validateHeapValue(value, path, state) {
     if (record.kind === "arguments")
         validateArgumentsProperties(record, path);
     if (record.kind === "array")
-        requireArray(record.items, `${path}.items`, state);
+        validateArrayHeap(record, path, state);
     if (record.kind === "object")
         requireRecord(record.entries, `${path}.entries`);
     if (record.kind === "map") {
@@ -414,6 +414,31 @@ function validateHeapValue(value, path, state) {
     if (record.kind === "set")
         requireArray(record.values, `${path}.values`, state);
 }
+function validateArrayHeap(record, path, state) {
+    if (Object.hasOwn(record, "items")) {
+        requireArray(record.items, `${path}.items`, state);
+        if (Object.hasOwn(record, "length") || Object.hasOwn(record, "entries"))
+            fail("invalidValue", path, "array must use either items or length and entries");
+        return;
+    }
+    const length = requireSafeInteger(record.length, `${path}.length`, 0);
+    if (length > 0xffff_ffff)
+        fail("invalidValue", `${path}.length`, "exceeds maximum array length");
+    if (length > state.limits.maxEntries)
+        fail("budgetExceeded", `${path}.length`, `exceeds collection entry limit ${state.limits.maxEntries}`);
+    const entries = requireRecord(record.entries, `${path}.entries`);
+    for (const key of Object.keys(entries)) {
+        if (key === "length")
+            fail("invalidValue", `${path}.entries.length`, "array length is stored separately");
+        const index = Number(key);
+        if (String(index) === key &&
+            Number.isInteger(index) &&
+            index >= 0 &&
+            index < 0xffff_ffff &&
+            index >= length)
+            fail("invalidValue", `${path}.entries${formatKey(key)}`, "array index exceeds its length");
+    }
+}
 function validateErrorType(record, path) {
     if (!Object.hasOwn(record, "errorType"))
         return;