poe-code 14.0.55 → 14.0.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "14.0.55",
+  "version": "14.0.57",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/safe-js/dist/chunks/{chunk-G5LQ37D4.js → chunk-H4O5OPM2.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-6LFWVA64.js";
+} from "./chunk-N3CN2ACZ.js";
 import {
   createFileSystem,
   createNodeFileSystemAdapterRegistry,
@@ -8245,4 +8245,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-G5LQ37D4.js.map
+//# sourceMappingURL=chunk-H4O5OPM2.js.map

package/packages/safe-js/dist/chunks/{chunk-6LFWVA64.js → chunk-N3CN2ACZ.js}

@@ -7623,7 +7623,7 @@ function validateTaggedValue(record2, path, state) {
     case "undefined":
       return;
     case "number":
-      if (!["-Infinity", "Infinity", "NaN"].includes(String(record2.value))) {
+      if (!["-Infinity", "Infinity", "NaN", "-0"].includes(String(record2.value))) {
         fail("invalidValue", `${path}.value`, "unknown non-finite number value");
       }
       return;
@@ -7645,6 +7645,11 @@ function validateTaggedValue(record2, path, state) {
       requireString(record2.flags, `${path}.flags`, state.limits);
       requireSafeInteger(record2.lastIndex, `${path}.lastIndex`, 0);
       return;
+    case "regex-object":
+      requireString(record2.source, `${path}.source`, state.limits);
+      requireString(record2.flags, `${path}.flags`, state.limits);
+      if (!Object.hasOwn(record2, "lastIndex")) fail("invalidValue", `${path}.lastIndex`, "missing regex cursor");
+      return;
     case "array":
     case "arguments":
     case "object":
@@ -8472,10 +8477,10 @@ function charge(context) {
   allocateRegexSteps(context.steps);
 }
 function normalizeLastIndex(lastIndex) {
-  if (!Number.isFinite(lastIndex) || lastIndex <= 0) {
+  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 !== void 0 && foldCharacter(left, ignoreCase) === foldCharacter(right, ignoreCase);
@@ -8508,6 +8513,16 @@ function isLineTerminator(character) {
 
 // packages/safe-js/src/interp/methods/regex.ts
 var regexMethodNames = /* @__PURE__ */ new Set(["exec", "test"]);
+var regexFlagProperties = {
+  hasIndices: "d",
+  global: "g",
+  ignoreCase: "i",
+  multiline: "m",
+  dotAll: "s",
+  unicode: "u",
+  unicodeSets: "v",
+  sticky: "y"
+};
 function isRegexMethodName(property) {
   return typeof property === "string" && regexMethodNames.has(property);
 }
@@ -8518,13 +8533,14 @@ function getRegexMember(target, property, budget) {
     return budget === void 0 ? flags : budget.allocateString(flags);
   }
   if (property === "lastIndex") return target.lastIndex;
+  if (Object.hasOwn(regexFlagProperties, property)) return target.flags.includes(regexFlagProperties[property]);
   if (!isRegexMethodName(property)) {
     return void 0;
   }
   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) {
@@ -8552,15 +8568,41 @@ function setRegexMember(target, property, value) {
   if (property !== "lastIndex") {
     throw new TypeError(`RegExp#${String(property)} is not writable.`);
   }
-  target.lastIndex = Number(value);
+  target.lastIndex = value;
 }
-function callRegexMethod(target, methodName, args) {
-  const match = executeRegex(target, String(args[0]));
-  return methodName === "test" ? match !== null : toMatchArray(match, String(args[0]));
+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 === void 0 ? 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, void 0);
+  }
 }
-function executeRegex(target, input) {
+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;
   }
@@ -10484,13 +10526,14 @@ function deepCopyToSandbox(value) {
     seen: /* @__PURE__ */ new WeakMap()
   });
 }
-function cloneSandboxValue(value) {
+function cloneSandboxValue(value, options = {}) {
   const initializeIterators = [];
   const copy = copyToSandbox(
     value,
     {
       seen: /* @__PURE__ */ new WeakMap(),
-      initializeIterators
+      initializeIterators,
+      ...options
     },
     "<root>",
     true
@@ -10589,11 +10632,12 @@ 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 === void 0 ? 0 : compiled.ticket.owner.budget.compileTicketUsage(compiled.ticket);
       usage += Math.max(6 + source.length + flags.length + compiled.units, staged - 1);
       if (compiled.ticket !== void 0) options.compileTickets?.add(compiled.ticket);
+      visit(lastIndex, depth + 1);
       return;
     }
     if (isSandboxArguments(value)) {
@@ -10674,7 +10718,16 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     return value;
   }
   if (isLiveCapability(value)) throw new TypeError("Live capabilities require their owning realm bridge.");
-  if (isSandboxClosure(value) || isSandboxGenerator(value) || isSandboxRegex(value) || isSandboxPromise(value)) {
+  if (isSandboxRegex(value)) {
+    if (!cloneSandboxCollections) return value;
+    const existing = state.seen.get(value);
+    if (existing !== void 0) 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) || isSandboxPromise(value)) {
     return value;
   }
   if (isSandboxCollectionIterator(value)) {
@@ -10883,9 +10936,9 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
       if (existing !== void 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 {
       guard.close();
@@ -11272,7 +11325,7 @@ function encodeReplayData(value, options = {}) {
         kind: "regex",
         source: entry.source,
         flags: entry.flags,
-        lastIndex: entry.lastIndex
+        lastIndex: child(entry.lastIndex, "lastIndex")
       };
     } else if (isSandboxArguments(entry)) {
       nodes[id] = { kind: "arguments", data: serializeArguments(entry, child) };
@@ -11439,11 +11492,12 @@ function decodeReplayData(input, options = {}, parent) {
         return result3;
       }
       if (kind === "regex") {
-        if (typeof node.source !== "string" || typeof node.flags !== "string" || typeof node.lastIndex !== "number" || !Number.isFinite(node.lastIndex)) {
+        if (typeof node.source !== "string" || typeof node.flags !== "string" || !Object.hasOwn(node, "lastIndex")) {
           throw new TypeError("Invalid replay regular expression.");
         }
-        const result3 = createSandboxRegex(node.source, node.flags, node.lastIndex, compilation);
+        const result3 = createSandboxRegex(node.source, node.flags, 0, compilation);
         restored.set(id, result3);
+        result3.lastIndex = child(own(node, "lastIndex"));
         return result3;
       }
       if (kind === "arguments") {
@@ -25008,7 +25062,11 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
     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);
@@ -25123,7 +25181,7 @@ function callStringMethod(value, methodName, args, budget, callClosure = async (
     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" || typeof replacement !== "string" && !isSandboxClosure(replacement)) {
@@ -25141,7 +25199,8 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
       replacement,
       methodName === "replaceAll",
       budget,
-      callClosure
+      callClosure,
+      context
     );
   }
   if (typeof replacement === "string") {
@@ -25158,20 +25217,28 @@ function callReplaceLikeMethod(value, methodName, args, budget, callClosure) {
     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"), void 0, 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, void 0);
   }
-  result += value.slice(copiedThrough);
-  return budget.allocateString(result);
 }
 function expandReplacement(replacement, match, captures, input, matchIndex) {
   let result = "";
@@ -25287,7 +25354,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 === void 0 ? "" : await sandboxString(pattern, budget, context);
     const regex = createSandboxRegex(source, methodName === "matchAll" ? "g" : "", 0, compilation);
@@ -25298,35 +25365,51 @@ 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, void 0);
+    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.`);
   if (methodName === "search") {
-    const lastIndex = regex.lastIndex;
-    if (!Object.is(lastIndex, 0)) regex.lastIndex = 0;
-    const match = executeRegex(regex, value);
-    if (!Object.is(regex.lastIndex, lastIndex)) regex.lastIndex = lastIndex;
+    const lastIndex2 = regex.lastIndex;
+    if (!Object.is(lastIndex2, 0)) regex.lastIndex = 0;
+    const match = executeRegex(regex, value, 0);
+    if (!Object.is(regex.lastIndex, lastIndex2)) regex.lastIndex = lastIndex2;
     return match?.index ?? -1;
   }
   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) : regex;
-  const matches = collectRegexMatches(matcher, value, true, compilation.owner?.budget);
+  const matcher = methodName === "matchAll" ? createSandboxRegex(regex.source, regex.flags, normalizeLastIndex(lastIndex ?? Number(regex.lastIndex)), compilation) : regex;
+  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);
-    if (all && match.text.length === 0) regex.lastIndex += 1;
+    lastIndex = match.index + match.text.length;
+    if (all && match.text.length === 0) regex.lastIndex = ++lastIndex;
   } while (all);
   return matches;
 }
@@ -30657,7 +30740,7 @@ 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({
@@ -30682,11 +30765,20 @@ function createMiscGlobals(options) {
     })
   };
 }
-function structuredCloneSandboxValue(value, budget) {
-  assertSandboxGraphDepth(value);
-  const clone = cloneSandboxValue(value);
-  assertStructuredCloneable(clone, /* @__PURE__ */ 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, /* @__PURE__ */ 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)) {
@@ -33328,4 +33420,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-6LFWVA64.js.map
+//# sourceMappingURL=chunk-N3CN2ACZ.js.map