poe-code 11.0.12 → 11.0.14

package/packages/safejs/dist/chunks/{chunk-WV23C6SS.js → chunk-X745DTOB.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-5BWI6HAZ.js";
+} from "./chunk-DZH7JZC4.js";
 
 // packages/safejs/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8055,4 +8055,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-WV23C6SS.js.map
+//# sourceMappingURL=chunk-X745DTOB.js.map

package/packages/safejs/dist/cli.js

@@ -20,7 +20,7 @@ import {
   parseMcpConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-WV23C6SS.js";
+} from "./chunks/chunk-X745DTOB.js";
 import {
   Budget,
   SandboxError,
@@ -32,7 +32,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-5BWI6HAZ.js";
+} from "./chunks/chunk-DZH7JZC4.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-5BWI6HAZ.js";
+} from "./chunks/chunk-DZH7JZC4.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/packages/safejs/dist/index.js

@@ -27,7 +27,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-WV23C6SS.js";
+} from "./chunks/chunk-X745DTOB.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -49,7 +49,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-5BWI6HAZ.js";
+} from "./chunks/chunk-DZH7JZC4.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safejs/src/runner/run-harness.ts

package/packages/safejs/dist/interp/async.js

@@ -5,7 +5,7 @@ import { getThenable, resolveSandboxValue } from "./promise.js";
 import { runAsyncPrefix, suspendJob } from "./jobs.js";
 import { awaitSandboxValue } from "./cancel.js";
 import { hoistVarDeclarations } from "./var-hoist.js";
-import { boundIdentifiers, containsParameterExpression, hoistedVarDeclarations } from "../parse/bindings.js";
+import { boundIdentifiers, containsParameterExpression, getFunctionLength, hoistedVarDeclarations } from "../parse/bindings.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxPromise, allocateProducedSandboxValue, isSandboxPromise } from "./values.js";
 export function emitResumeBreakpoint(context, breakpoint) {
     context.onYield?.({
@@ -55,6 +55,7 @@ export function createInterpretedClosure(node, context, evaluateNode) {
         : undefined;
     return createSandboxClosure({
         sandbox: true,
+        length: getFunctionLength(node.params),
         ...(node.async ? { async: true } : {}),
         ...(node.type === "FunctionDeclaration" || node.type === "FunctionExpression"
             ? node.id === undefined
@@ -102,6 +103,7 @@ export function createInterpretedClosure(node, context, evaluateNode) {
 function createGeneratorClosure(node, context, evaluateNode) {
     return createSandboxClosure({
         sandbox: true,
+        length: getFunctionLength(node.params),
         ...(node.id === undefined ? {} : { name: node.id.name }),
         retainedValues: () => context.scope.retainedValues(),
         call: async (args, callContext) => {

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

@@ -5,6 +5,9 @@ export function getFunctionMember(target, property, options) {
     if (propertyValue !== undefined || Object.hasOwn(target.properties ?? {}, String(property))) {
         return propertyValue;
     }
+    if (property === "length") {
+        return target.length;
+    }
     if (!isFunctionMethodName(property)) {
         return undefined;
     }
@@ -24,6 +27,7 @@ function callFunctionMethod(target, methodName, args, options, stack) {
         return createSandboxClosure({
             sandbox: true,
             name: `bound ${target.name ?? ""}`,
+            length: target.length === undefined ? undefined : Math.max(0, target.length - boundArgs.length),
             boundTarget: target,
             retainedValues: () => [target, thisValue, ...boundArgs],
             call: (callArgs, context) => options.callClosure(target, [...boundArgs, ...callArgs], context?.stack ?? [], thisValue),

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

@@ -1,5 +1,4 @@
-import { createSandboxClosure, getSandboxRegexPattern, isSandboxClosure, isSandboxRegex } from "../values.js";
-import { matchRegexFrom } from "../regex/engine.js";
+import { createSandboxClosure, createSandboxRegex, isSandboxClosure, isSandboxRegex } from "../values.js";
 import { executeRegex, toMatchArray } from "./regex.js";
 const SPLIT_STRING_MESSAGE = "String#split only supports string separator values.";
 const stringMethodNames = new Set([
@@ -143,6 +142,8 @@ 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) {
+    if (regex.flags.includes("g"))
+        regex.lastIndex = 0;
     const matches = collectRegexMatches(regex, value, replaceAll || regex.flags.includes("g"));
     let result = "";
     let copiedThrough = 0;
@@ -237,11 +238,13 @@ function callSplit(value, args, budget) {
     if (args.some(isSandboxClosure))
         throw new TypeError("String#split does not support function arguments.");
     if (isSandboxRegex(args[0])) {
+        const regex = args[0];
+        const splitter = createSandboxRegex(regex.source, regex.flags.includes("g") ? regex.flags : `${regex.flags}g`);
         const limit = asNumberOrUndefined(args[1]) ?? 2 ** 32 - 1;
         const result = [];
         let copiedThrough = 0;
         let endedWithZeroWidthMatch = false;
-        for (const match of collectRegexMatches(args[0], value, true)) {
+        for (const match of collectRegexMatches(splitter, value, true)) {
             endedWithZeroWidthMatch = match.text.length === 0 && match.index === value.length;
             if (match.text.length === 0 && match.index === 0)
                 continue;
@@ -282,21 +285,25 @@ function callMatchLikeMethod(value, methodName, args) {
         throw new TypeError("String#matchAll requires a global regex.");
     if (methodName === "match" && !regex.flags.includes("g"))
         return toMatchArray(executeRegex(regex, value), value);
-    const matches = collectRegexMatches(regex, value, true);
+    if (methodName === "match")
+        regex.lastIndex = 0;
+    const matcher = methodName === "matchAll"
+        ? createSandboxRegex(regex.source, regex.flags, regex.lastIndex)
+        : regex;
+    const matches = collectRegexMatches(matcher, value, true);
     return methodName === "match"
         ? matches.map((match) => match.text)
         : matches.map((match) => toMatchArray(match, value));
 }
 function collectRegexMatches(regex, value, all) {
     const matches = [];
-    const pattern = getSandboxRegexPattern(regex);
-    let startIndex = 0;
     do {
-        const match = matchRegexFrom(pattern, value, startIndex);
+        const match = executeRegex(regex, value);
         if (match === null)
             break;
         matches.push(match);
-        startIndex = match.index + Math.max(match.text.length, 1);
+        if (all && match.text.length === 0)
+            regex.lastIndex += 1;
     } while (all);
     return matches;
 }

package/packages/safejs/dist/interp/values.d.ts

@@ -56,6 +56,7 @@ export type SandboxClosure = {
     readonly boundTarget?: SandboxClosure;
     readonly cancellationSignal?: AbortSignal;
     readonly kind: "fn";
+    readonly length?: number;
     readonly name?: string;
     readonly properties?: SandboxObject;
     readonly call: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
@@ -91,6 +92,7 @@ export declare function createSandboxClosure(input: {
     call: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
     construct?: (args: readonly SandboxValue[], context?: SandboxCallContext) => SandboxValue | Promise<SandboxValue>;
     name?: string;
+    length?: number;
     properties?: SandboxObject | ((closure: SandboxClosure) => SandboxObject);
     retainedValues?: () => Iterable<SandboxValue>;
 }): SandboxClosure;

package/packages/safejs/dist/interp/values.js

@@ -35,6 +35,9 @@ export function createSandboxClosure(input) {
     if (input.sandbox === true) {
         Object.defineProperty(closure, "sandbox", { value: true });
     }
+    if (input.length !== undefined) {
+        Object.defineProperty(closure, "length", { value: input.length });
+    }
     if (input.boundTarget !== undefined) {
         Object.defineProperty(closure, "boundTarget", { value: input.boundTarget });
     }

package/packages/safejs/dist/parse/bindings.d.ts

@@ -1,5 +1,6 @@
-import type { ArrayPattern, AssignmentPattern, Identifier, MemberExpression, ObjectPattern, ParseResult, RestElement, VariableDeclaration } from "./parser.js";
+import type { ArrowFunctionExpression, ArrayPattern, AssignmentPattern, Identifier, MemberExpression, ObjectPattern, ParseResult, RestElement, VariableDeclaration } from "./parser.js";
 type BindingPattern = Identifier | ArrayPattern | ObjectPattern | AssignmentPattern | RestElement | MemberExpression;
+export declare function getFunctionLength(params: ArrowFunctionExpression["params"]): number;
 export declare function boundIdentifiers(pattern: BindingPattern): Iterable<Identifier>;
 export declare function containsParameterExpression(pattern: BindingPattern): boolean;
 export declare function hoistedVarDeclarations(nodes: readonly ParseResult[]): Iterable<VariableDeclaration>;

package/packages/safejs/dist/parse/bindings.js

@@ -1,3 +1,7 @@
+export function getFunctionLength(params) {
+    const firstOptional = params.findIndex((param) => param.type === "AssignmentPattern" || param.type === "RestElement");
+    return firstOptional === -1 ? params.length : firstOptional;
+}
 export function* boundIdentifiers(pattern) {
     switch (pattern.type) {
         case "Identifier":

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

@@ -6,6 +6,7 @@ import { wrapCallerInjectedBindings } from "../interp/host-bridge.js";
 import { createSandboxArguments, createSandboxClosure, createSandboxGenerator, createSandboxMap, createSandboxPromise, createSandboxRegex, createSandboxSet, measureSandboxData } from "../interp/values.js";
 import { createGeneratorChannel, restoreGeneratorChannel } from "../interp/generator.js";
 import { hashSource } from "../parse/hash.js";
+import { getFunctionLength } from "../parse/bindings.js";
 import { parseModule } from "../parse/parser.js";
 import { createUnknownModuleMessage } from "../modules/registry.js";
 import { interpret } from "../interp/interpreter.js";
@@ -386,6 +387,7 @@ function restoreClosureValue(astNodeId, capturedScopeId, state) {
     }
     const baseClosure = createSandboxClosure({
         async: true,
+        length: getFunctionLength(node.params),
         ...(node.type !== "ArrowFunctionExpression" &&
             !(node.type === "FunctionExpression" && node.method === true) &&
             !node.async