poe-code 14.0.55 → 14.0.57

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

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

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

@@ -1,11 +1,12 @@
 import { isSandboxCollectionIterator } from "../collection-iterator.js";
 import { assertSandboxGraphDepth } from "../../graph-depth.js";
-import { allocateProducedSandboxValue, cloneSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet } from "../values.js";
+import { CompileScope } from "../regex/compile-guard.js";
+import { allocateProducedSandboxValue, cloneSandboxValue, createSandboxClosure, isSandboxClosure, isSandboxMap, isSandboxPromise, isSandboxSet, reconcileCompiledValues } from "../values.js";
 export function createMiscGlobals(options) {
     return {
         structuredClone: createSandboxClosure({
             sandbox: true,
-            call: ([value]) => structuredCloneSandboxValue(value, options.budget),
+            call: ([value], context) => structuredCloneSandboxValue(value, options.budget, context?.compilation),
             name: "structuredClone"
         }),
         parseInt: createSandboxClosure({
@@ -30,11 +31,23 @@ export function createMiscGlobals(options) {
         })
     };
 }
-function structuredCloneSandboxValue(value, budget) {
-    assertSandboxGraphDepth(value);
-    const clone = cloneSandboxValue(value);
-    assertStructuredCloneable(clone, new WeakSet());
-    return allocateProducedSandboxValue(clone, budget);
+function structuredCloneSandboxValue(value, budget, parent) {
+    const operation = budget.acquireCompileOwner(false, parent?.owner);
+    const compilation = parent?.owner === operation.owner ? parent : new CompileScope(operation.owner);
+    try {
+        const clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true });
+        assertSandboxGraphDepth(clone);
+        assertStructuredCloneable(clone, new WeakSet());
+        allocateProducedSandboxValue(clone, budget);
+        if (compilation !== parent)
+            reconcileCompiledValues(budget, [clone], compilation);
+        return clone;
+    }
+    finally {
+        if (compilation !== parent)
+            compilation.dispose();
+        operation.release();
+    }
 }
 function assertStructuredCloneable(value, seen) {
     if (isSandboxClosure(value) || isSandboxPromise(value) || isSandboxCollectionIterator(value)) {

package/packages/safe-js/dist/interp/methods/regex.d.ts

@@ -1,10 +1,10 @@
-import { type SandboxRegex, type SandboxValue } from "../values.js";
+import { type SandboxCallContext, type SandboxRegex, type SandboxValue } from "../values.js";
 import { type RegexMatch } from "../regex/engine.js";
 import type { Budget } from "../budget.js";
 export type RegexMethodName = "exec" | "test";
 export declare function isRegexMethodName(property: string | number): property is RegexMethodName;
-export declare function getRegexMember(target: SandboxRegex, property: string | number, budget?: Budget): SandboxValue | undefined;
+export declare function getRegexMember(target: SandboxRegex, property: string | number, budget: Budget): SandboxValue | undefined;
 export declare function setRegexMember(target: SandboxRegex, property: string | number, value: SandboxValue): void;
-export declare function callRegexMethod(target: SandboxRegex, methodName: RegexMethodName, args: readonly SandboxValue[]): SandboxValue;
-export declare function executeRegex(target: SandboxRegex, input: string): RegexMatch | null;
+export declare function callRegexMethod(target: SandboxValue, methodName: RegexMethodName, args: readonly SandboxValue[], budget: Budget, context?: SandboxCallContext): Promise<SandboxValue>;
+export declare function executeRegex(target: SandboxRegex, input: string, lastIndex: number): RegexMatch | null;
 export declare function toMatchArray(match: RegexMatch | null, input: string): SandboxValue;

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

@@ -1,6 +1,13 @@
-import { createSandboxClosure, getSandboxRegexPattern } from "../values.js";
+import { createSandboxClosure, getSandboxRegexPattern, isSandboxClosure, isSandboxRegex } from "../values.js";
 import { matchRegex } from "../regex/engine.js";
+import { invokeBuiltinClosure } from "../builtin-call.js";
+import { getSandboxDataProperty } from "../object-model.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
 const regexMethodNames = new Set(["exec", "test"]);
+const regexFlagProperties = {
+    hasIndices: "d", global: "g", ignoreCase: "i", multiline: "m",
+    dotAll: "s", unicode: "u", unicodeSets: "v", sticky: "y"
+};
 export function isRegexMethodName(property) {
     return typeof property === "string" && regexMethodNames.has(property);
 }
@@ -13,13 +20,15 @@ export function getRegexMember(target, property, budget) {
     }
     if (property === "lastIndex")
         return target.lastIndex;
+    if (Object.hasOwn(regexFlagProperties, property))
+        return target.flags.includes(regexFlagProperties[property]);
     if (!isRegexMethodName(property)) {
         return undefined;
     }
     return createSandboxClosure({
         sandbox: true,
         name: `RegExp#${property}`,
-        call: (args) => callRegexMethod(target, property, args)
+        call: (args, context) => callRegexMethod(context?.thisValue, property, args, budget, context)
     });
 }
 function escapeRegexSource(source, budget) {
@@ -61,15 +70,45 @@ export function setRegexMember(target, property, value) {
     if (property !== "lastIndex") {
         throw new TypeError(`RegExp#${String(property)} is not writable.`);
     }
-    target.lastIndex = Number(value);
+    target.lastIndex = value;
 }
-export function callRegexMethod(target, methodName, args) {
-    const match = executeRegex(target, String(args[0]));
-    return methodName === "test" ? match !== null : toMatchArray(match, String(args[0]));
+export async function callRegexMethod(target, methodName, args, budget, context) {
+    if (target === null || typeof target !== "object" || (methodName === "exec" && !isSandboxRegex(target))) {
+        throw new TypeError(`RegExp#${methodName} requires ${methodName === "exec" ? "a regex" : "an object"} receiver.`);
+    }
+    const retained = {};
+    let cursor;
+    let convertedInput;
+    budget.setRetainedValues(retained, () => [target, ...args, cursor, convertedInput]);
+    try {
+        const input = await sandboxString(args[0], budget, context);
+        if (methodName === "test") {
+            const exec = context?.getProperty === undefined
+                ? getSandboxDataProperty(target, "exec", budget) : context.getProperty(target, "exec");
+            if (isSandboxClosure(exec)) {
+                const result = await invokeBuiltinClosure(exec, [input], budget, context, target);
+                if (result !== null && typeof result !== "object") {
+                    throw new TypeError("RegExp#test exec must return an object or null.");
+                }
+                return result !== null;
+            }
+        }
+        if (!isSandboxRegex(target))
+            throw new TypeError("RegExp execution requires a regex receiver.");
+        if (typeof args[0] !== "string")
+            convertedInput = input;
+        cursor = target.lastIndex;
+        const lastIndex = await sandboxNumber(cursor, budget, context);
+        const match = executeRegex(target, input, lastIndex);
+        return methodName === "test" ? match !== null : toMatchArray(match, input);
+    }
+    finally {
+        budget.setRetainedValues(retained, undefined);
+    }
 }
-export function executeRegex(target, input) {
+export function executeRegex(target, input, lastIndex) {
     const pattern = getSandboxRegexPattern(target);
-    const match = matchRegex(pattern, input, target.lastIndex);
+    const match = matchRegex(pattern, input, lastIndex);
     if (pattern.flags.global) {
         target.lastIndex = match === null ? 0 : match.index + match.text.length;
     }

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

@@ -1,6 +1,7 @@
 import { invokeBuiltinClosure } from "../builtin-call.js";
 import { CompileScope } from "../regex/compile-guard.js";
-import { sandboxString } from "../string-coercion.js";
+import { normalizeLastIndex } from "../regex/engine.js";
+import { sandboxNumber, sandboxString } from "../string-coercion.js";
 import { createSandboxClosure, createSandboxRegex, deepCopyFromSandbox, isSandboxClosure, isSandboxRegex } from "../values.js";
 import { executeRegex, toMatchArray } from "./regex.js";
 const SPLIT_STRING_MESSAGE = "String#split only supports string separator values.";
@@ -120,7 +121,13 @@ export function callStringMethod(value, methodName, args, budget, callClosure =
         return budget.allocateString(result + value.slice(spanStart));
     }
     if (methodName === "replace" || methodName === "replaceAll") {
-        return callReplaceLikeMethod(value, methodName, args, budget, callClosure);
+        return callReplaceLikeMethod(value, methodName, args, budget, callClosure, context);
+    }
+    const regex = args[0];
+    if (isSandboxRegex(regex) && regex.lastIndex !== null && typeof regex.lastIndex === "object" &&
+        ((methodName === "match" && !regex.flags.includes("g")) ||
+            (methodName === "matchAll" && regex.flags.includes("g")))) {
+        return callStringRegexCursor(value, methodName, regex, budget, parent, context);
     }
     if ((methodName === "match" || methodName === "matchAll" || methodName === "search") && !isSandboxRegex(args[0])) {
         return callStringPattern(value, methodName, args[0], budget, parent, context);
@@ -232,7 +239,7 @@ export function callStringMethod(value, methodName, args, budget, callClosure =
         operation.release();
     }
 }
-function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
+function callReplaceLikeMethod(value, methodName, args, budget, callClosure, context) {
     const search = args[0];
     const replacement = args[1];
     if ((!isSandboxRegex(search) && typeof search !== "string") ||
@@ -243,7 +250,7 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
         if (methodName === "replaceAll" && !search.flags.includes("g")) {
             throw new TypeError("String#replaceAll requires a global regex.");
         }
-        return replaceRegex(value, search, replacement, methodName === "replaceAll", budget, callClosure);
+        return replaceRegex(value, search, replacement, methodName === "replaceAll", budget, callClosure, context);
     }
     if (typeof replacement === "string") {
         return budget.allocateString(methodName === "replace"
@@ -252,22 +259,31 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
     }
     return replaceWithClosure(value, search, replacement, methodName === "replaceAll", budget, callClosure);
 }
-async function replaceRegex(value, regex, replacement, replaceAll, budget, callClosure) {
+async function replaceRegex(value, regex, replacement, replaceAll, budget, callClosure, context) {
     if (regex.flags.includes("g"))
         regex.lastIndex = 0;
-    const matches = collectRegexMatches(regex, value, replaceAll || regex.flags.includes("g"));
-    let result = "";
-    let copiedThrough = 0;
-    for (const match of matches) {
-        result += value.slice(copiedThrough, match.index);
-        result +=
-            typeof replacement === "string"
-                ? expandReplacement(replacement, match.text, match.captures, value, match.index)
-                : String(await callClosure(replacement, [match.text, ...match.captures, match.index, value]));
-        copiedThrough = match.index + match.text.length;
+    const cursor = regex.lastIndex;
+    const retained = {};
+    budget.setRetainedValues(retained, () => [value, regex, cursor, replacement]);
+    try {
+        const lastIndex = await sandboxNumber(cursor, budget, context);
+        const matches = collectRegexMatches(regex, value, replaceAll || regex.flags.includes("g"), undefined, lastIndex);
+        let result = "";
+        let copiedThrough = 0;
+        for (const match of matches) {
+            result += value.slice(copiedThrough, match.index);
+            result +=
+                typeof replacement === "string"
+                    ? expandReplacement(replacement, match.text, match.captures, value, match.index)
+                    : String(await callClosure(replacement, [match.text, ...match.captures, match.index, value]));
+            copiedThrough = match.index + match.text.length;
+        }
+        result += value.slice(copiedThrough);
+        return budget.allocateString(result);
+    }
+    finally {
+        budget.setRetainedValues(retained, undefined);
     }
-    result += value.slice(copiedThrough);
-    return budget.allocateString(result);
 }
 function expandReplacement(replacement, match, captures, input, matchIndex) {
     let result = "";
@@ -386,7 +402,7 @@ async function callStringPattern(value, methodName, pattern, budget, parent, con
     const operation = budget.acquireCompileOwner(false, parent?.owner);
     const compilation = new CompileScope(operation.owner);
     const retainedPattern = {};
-    budget.setRetainedValues(retainedPattern, () => [pattern]);
+    budget.setRetainedValues(retainedPattern, () => [value, pattern]);
     try {
         const source = pattern === undefined ? "" : await sandboxString(pattern, budget, context);
         const regex = createSandboxRegex(source, methodName === "matchAll" ? "g" : "", 0, compilation);
@@ -398,7 +414,23 @@ async function callStringPattern(value, methodName, pattern, budget, parent, con
         operation.release();
     }
 }
-function callMatchLikeMethod(value, methodName, args, compilation) {
+async function callStringRegexCursor(value, methodName, regex, budget, parent, context) {
+    const operation = budget.acquireCompileOwner(false, parent?.owner);
+    const compilation = new CompileScope(operation.owner);
+    const cursor = regex.lastIndex;
+    const retained = {};
+    budget.setRetainedValues(retained, () => [value, regex, cursor]);
+    try {
+        const lastIndex = await sandboxNumber(cursor, budget, context);
+        return callMatchLikeMethod(value, methodName, [regex], compilation, lastIndex);
+    }
+    finally {
+        budget.setRetainedValues(retained, undefined);
+        compilation.dispose();
+        operation.release();
+    }
+}
+function callMatchLikeMethod(value, methodName, args, compilation, lastIndex) {
     const regex = args[0];
     if (!isSandboxRegex(regex))
         throw new TypeError(`String#${methodName} requires a regex argument.`);
@@ -406,7 +438,7 @@ function callMatchLikeMethod(value, methodName, args, compilation) {
         const lastIndex = regex.lastIndex;
         if (!Object.is(lastIndex, 0))
             regex.lastIndex = 0;
-        const match = executeRegex(regex, value);
+        const match = executeRegex(regex, value, 0);
         if (!Object.is(regex.lastIndex, lastIndex))
             regex.lastIndex = lastIndex;
         return match?.index ?? -1;
@@ -414,29 +446,30 @@ function callMatchLikeMethod(value, methodName, args, compilation) {
     if (methodName === "matchAll" && !regex.flags.includes("g"))
         throw new TypeError("String#matchAll requires a global regex.");
     if (methodName === "match" && !regex.flags.includes("g"))
-        return toMatchArray(executeRegex(regex, value), value);
+        return toMatchArray(executeRegex(regex, value, lastIndex ?? Number(regex.lastIndex)), value);
     if (methodName === "match")
         regex.lastIndex = 0;
     const matcher = methodName === "matchAll"
-        ? createSandboxRegex(regex.source, regex.flags, regex.lastIndex, compilation)
+        ? createSandboxRegex(regex.source, regex.flags, normalizeLastIndex(lastIndex ?? Number(regex.lastIndex)), compilation)
         : regex;
-    const matches = collectRegexMatches(matcher, value, true, compilation.owner?.budget);
+    const matches = collectRegexMatches(matcher, value, true, compilation.owner?.budget, Number(matcher.lastIndex));
     if (methodName === "match" && matches.length === 0)
         return null;
     return methodName === "match"
         ? matches.map((match) => match.text)
         : matches.map((match) => toMatchArray(match, value));
 }
-function collectRegexMatches(regex, value, all, budget) {
+function collectRegexMatches(regex, value, all, budget, lastIndex = 0) {
     const matches = [];
     do {
-        const match = executeRegex(regex, value);
+        const match = executeRegex(regex, value, lastIndex);
         if (match === null)
             break;
         budget?.allocateArrayLength(matches.length + 1);
         matches.push(match);
+        lastIndex = match.index + match.text.length;
         if (all && match.text.length === 0)
-            regex.lastIndex += 1;
+            regex.lastIndex = ++lastIndex;
     } while (all);
     return matches;
 }

package/packages/safe-js/dist/interp/regex/engine.d.ts

@@ -6,3 +6,4 @@ export type RegexMatch = {
 };
 export declare function matchRegex(pattern: RegexPattern, input: string, lastIndex?: number): RegexMatch | null;
 export declare function matchRegexFrom(pattern: RegexPattern, input: string, startIndex: number): RegexMatch | null;
+export declare function normalizeLastIndex(lastIndex: number): number;

package/packages/safe-js/dist/interp/regex/engine.js

@@ -202,11 +202,11 @@ function charge(context) {
     context.steps += 1;
     allocateRegexSteps(context.steps);
 }
-function normalizeLastIndex(lastIndex) {
-    if (!Number.isFinite(lastIndex) || lastIndex <= 0) {
+export function normalizeLastIndex(lastIndex) {
+    if (Number.isNaN(lastIndex) || lastIndex <= 0) {
         return 0;
     }
-    return Math.floor(lastIndex);
+    return Math.min(Math.floor(lastIndex), Number.MAX_SAFE_INTEGER);
 }
 function charactersEqual(left, right, ignoreCase) {
     return left !== undefined && foldCharacter(left, ignoreCase) === foldCharacter(right, ignoreCase);

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

@@ -32,7 +32,7 @@ export type SandboxRegex = {
     readonly kind: "regex";
     readonly source: string;
     readonly flags: string;
-    lastIndex: number;
+    lastIndex: SandboxValue;
     readonly [sandboxRegexBrand]: true;
     readonly [sandboxRegexPattern]: RegexPattern;
 };
@@ -121,14 +121,17 @@ export declare function createSandboxGenerator(channel: GeneratorChannel, metada
 } | undefined): SandboxGenerator;
 export declare function createSandboxMap(entries?: Iterable<readonly [SandboxValue, SandboxValue]>): SandboxMap;
 export declare function createSandboxSet(values?: Iterable<SandboxValue>): SandboxSet;
-export declare function createSandboxRegex(source: string, flags?: string, lastIndex?: number, compilation?: CompileScope): SandboxRegex;
+export declare function createSandboxRegex(source: string, flags?: string, lastIndex?: SandboxValue, compilation?: CompileScope): SandboxRegex;
 export declare function getSandboxRegexPattern(regex: SandboxRegex): RegexPattern;
 export declare function isSandboxClosure(value: unknown): value is SandboxClosure;
 export declare function isSandboxPromise(value: unknown): value is SandboxPromise;
 export declare function isSandboxGenerator(value: unknown): value is SandboxGenerator;
 export declare function isSandboxRegex(value: unknown): value is SandboxRegex;
 export declare function deepCopyToSandbox(value: unknown): SandboxValue;
-export declare function cloneSandboxValue(value: SandboxValue): SandboxValue;
+export declare function cloneSandboxValue(value: SandboxValue, options?: {
+    compilation?: CompileScope;
+    resetRegexLastIndex?: boolean;
+}): SandboxValue;
 export declare function allocateProducedSandboxValue(value: SandboxValue, budget: Budget): SandboxValue;
 export declare function measureSandboxData(values: Iterable<unknown>, options?: {
     ignoreClosures?: boolean;

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

@@ -210,11 +210,12 @@ export function deepCopyToSandbox(value) {
         seen: new WeakMap()
     });
 }
-export function cloneSandboxValue(value) {
+export function cloneSandboxValue(value, options = {}) {
     const initializeIterators = [];
     const copy = copyToSandbox(value, {
         seen: new WeakMap(),
-        initializeIterators
+        initializeIterators,
+        ...options
     }, "<root>", true);
     for (const initialize of initializeIterators)
         initialize();
@@ -324,7 +325,7 @@ export function measureSandboxData(values, options = {}) {
         if (isSandboxPromise(value))
             return;
         if (isSandboxRegex(value)) {
-            const { source, flags } = captureRegexData(value);
+            const { source, flags, lastIndex } = captureRegexData(value);
             const compiled = regexCompiledData(getSandboxRegexPattern(value));
             const staged = compiled.ticket === undefined
                 ? 0
@@ -332,6 +333,7 @@ export function measureSandboxData(values, options = {}) {
             usage += Math.max(6 + source.length + flags.length + compiled.units, staged - 1);
             if (compiled.ticket !== undefined)
                 options.compileTickets?.add(compiled.ticket);
+            visit(lastIndex, depth + 1);
             return;
         }
         if (isSandboxArguments(value)) {
@@ -412,9 +414,20 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     }
     if (isLiveCapability(value))
         throw new TypeError("Live capabilities require their owning realm bridge.");
+    if (isSandboxRegex(value)) {
+        if (!cloneSandboxCollections)
+            return value;
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const copy = createSandboxRegex(value.source, value.flags, 0, state.compilation);
+        state.seen.set(value, copy);
+        if (!state.resetRegexLastIndex)
+            copy.lastIndex = copyToSandbox(value.lastIndex, state, `${path}.lastIndex`, true, depth + 1);
+        return copy;
+    }
     if (isSandboxClosure(value) ||
         isSandboxGenerator(value) ||
-        isSandboxRegex(value) ||
         isSandboxPromise(value)) {
         return value;
     }
@@ -596,9 +609,9 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
                 return existing;
             guard.allocate(1 + source.length + flags.length);
             const regex = new RegExp(source, flags);
-            regex.lastIndex = lastIndex;
-            guard.retainScratch();
             state.seen.set(value, regex);
+            Reflect.set(regex, "lastIndex", copyFromSandbox(lastIndex, state, `${path}.lastIndex`, options, depth + 1));
+            guard.retainScratch();
             return regex;
         }
         finally {

package/packages/safe-js/dist/snapshot/replay-data.d.ts

@@ -63,7 +63,7 @@ type DataNode = {
     kind: "regex";
     source: string;
     flags: string;
-    lastIndex: number;
+    lastIndex: Atom;
 };
 export type ReplayData = {
     root: Atom;

package/packages/safe-js/dist/snapshot/replay-data.js

@@ -114,7 +114,7 @@ export function encodeReplayData(value, options = {}) {
                 kind: "regex",
                 source: entry.source,
                 flags: entry.flags,
-                lastIndex: entry.lastIndex
+                lastIndex: child(entry.lastIndex, "lastIndex")
             };
         }
         else if (isSandboxArguments(entry)) {
@@ -303,12 +303,12 @@ export function decodeReplayData(input, options = {}, parent) {
             if (kind === "regex") {
                 if (typeof node.source !== "string" ||
                     typeof node.flags !== "string" ||
-                    typeof node.lastIndex !== "number" ||
-                    !Number.isFinite(node.lastIndex)) {
+                    !Object.hasOwn(node, "lastIndex")) {
                     throw new TypeError("Invalid replay regular expression.");
                 }
-                const result = createSandboxRegex(node.source, node.flags, node.lastIndex, compilation);
+                const result = createSandboxRegex(node.source, node.flags, 0, compilation);
                 restored.set(id, result);
+                result.lastIndex = child(own(node, "lastIndex"));
                 return result;
             }
             if (kind === "arguments") {

package/packages/safe-js/dist/snapshot/restore.js

@@ -231,6 +231,8 @@ function deserializeValue(value, state) {
     }
     if (isSerializedNonFiniteNumberValue(value)) {
         switch (value.value) {
+            case "-0":
+                return -0;
             case "NaN":
                 return Number.NaN;
             case "Infinity":
@@ -351,6 +353,12 @@ function restoreHeapValue(id, state) {
         state.heapValueById.set(id, value);
         return value;
     }
+    if (serialized.kind === "regex-object") {
+        const value = createSandboxRegex(serialized.source, serialized.flags, 0, state.compilation);
+        state.heapValueById.set(id, value);
+        value.lastIndex = deserializeValue(serialized.lastIndex, state);
+        return value;
+    }
     if (serialized.kind === "float32array") {
         const value = decodeFloat32Storage(serialized, (reference) => deserializeValue(reference, state));
         state.heapValueById.set(id, value);

package/packages/safe-js/dist/snapshot/serialize.d.ts

@@ -10,7 +10,7 @@ type SerializedUndefinedValue = {
 };
 type SerializedNonFiniteNumber = {
     kind: "number";
-    value: "-Infinity" | "Infinity" | "NaN";
+    value: "-Infinity" | "Infinity" | "NaN" | "-0";
 };
 export type SerializedClosureValue = {
     kind: "fn";
@@ -42,6 +42,11 @@ export type SerializedReferenceValue = {
     id: number;
 };
 export type SerializedHeapValue = {
+    kind: "regex-object";
+    source: string;
+    flags: string;
+    lastIndex: SerializedSnapshotValue;
+} | {
     kind: "collection-iterator";
     collectionKind: "map" | "set";
     method: CollectionIterationMethod;

package/packages/safe-js/dist/snapshot/serialize.js

@@ -94,6 +94,8 @@ function serializeValue(value, path, state) {
         };
     }
     if (typeof value === "number") {
+        if (Object.is(value, -0))
+            return { kind: "number", value: "-0" };
         if (Number.isFinite(value)) {
             return value;
         }
@@ -161,6 +163,11 @@ function serializeValue(value, path, state) {
         };
     }
     if (isSandboxRegex(value)) {
+        const reference = serializeHeapReference(value, path, state);
+        if (reference !== undefined)
+            return reference;
+        if (typeof value.lastIndex !== "number")
+            throw new TypeError(`Missing regex heap reference at ${path}.`);
         return { kind: "regex", source: value.source, flags: value.flags, lastIndex: value.lastIndex };
     }
     if (isSandboxDate(value) || isSandboxMap(value) || isSandboxSet(value) || isSandboxCollectionIterator(value) || isFloat32Array(value)) {
@@ -192,7 +199,11 @@ function serializeHeapReference(value, path, state) {
     }
     if (!state.serializedHeapIds.has(id)) {
         state.serializedHeapIds.add(id);
-        if (isSandboxCollectionIterator(value)) {
+        if (isSandboxRegex(value)) {
+            state.heap[String(id)] = { kind: "regex-object", source: value.source, flags: value.flags,
+                lastIndex: serializeValue(value.lastIndex, `${path}.lastIndex`, state) };
+        }
+        else if (isSandboxCollectionIterator(value)) {
             const snapshot = snapshotCollectionIterator(value);
             const entries = Object.create(null);
             state.heap[String(id)] = {
@@ -313,6 +324,8 @@ function indexHeapContainers(input) {
     for (const [value, stat] of stats.entries()) {
         if (stat.count > 1 ||
             stat.cyclic ||
+            (isSandboxRegex(value) && (!Number.isSafeInteger(value.lastIndex) ||
+                (typeof value.lastIndex === "number" && value.lastIndex < 0) || Object.is(value.lastIndex, -0))) ||
             isSandboxDate(value) ||
             isFloat32Array(value) ||
             (Array.isArray(value) && requiresArrayEntries(value)) ||

package/packages/safe-js/dist/snapshot/validation.js

@@ -337,7 +337,7 @@ function validateTaggedValue(record, path, state) {
         case "undefined":
             return;
         case "number":
-            if (!["-Infinity", "Infinity", "NaN"].includes(String(record.value))) {
+            if (!["-Infinity", "Infinity", "NaN", "-0"].includes(String(record.value))) {
                 fail("invalidValue", `${path}.value`, "unknown non-finite number value");
             }
             return;
@@ -359,6 +359,12 @@ function validateTaggedValue(record, path, state) {
             requireString(record.flags, `${path}.flags`, state.limits);
             requireSafeInteger(record.lastIndex, `${path}.lastIndex`, 0);
             return;
+        case "regex-object":
+            requireString(record.source, `${path}.source`, state.limits);
+            requireString(record.flags, `${path}.flags`, state.limits);
+            if (!Object.hasOwn(record, "lastIndex"))
+                fail("invalidValue", `${path}.lastIndex`, "missing regex cursor");
+            return;
         case "array":
         case "arguments":
         case "object":
@@ -408,7 +414,7 @@ function validateGeneratorShape(record, path, state) {
 function validateHeapValue(value, path, state) {
     const record = requireRecord(value, path);
     validateErrorType(record, path);
-    if (!["arguments", "array", "object", "map", "set", "float32array", "date", "collection-iterator"].includes(String(record.kind)))
+    if (!["arguments", "array", "object", "map", "set", "float32array", "date", "collection-iterator", "regex-object"].includes(String(record.kind)))
         fail("unknownTag", `${path}.kind`, "unknown heap tag");
     validateValue(record, path, 1, state);
     if (record.kind === "arguments")