@opencode/codemode 0.0.0-dev-19607 → 0.0.0-dev-19611

package/dist/interpreter/limits.d.ts

@@ -0,0 +1,8 @@
+/** Longest string a built-in or operator may produce. */
+export declare const MAX_STRING_LENGTH: number;
+/** Longest array a built-in may create or grow to. */
+export declare const MAX_ARRAY_LENGTH = 10000000;
+/** Most promises that may be pending at once. */
+export declare const MAX_PENDING_PROMISES = 10000;
+export declare const checkStringLength: (length: number) => void;
+export declare const checkArrayLength: (length: number) => void;

package/dist/interpreter/limits.js

@@ -0,0 +1,17 @@
+import { rangeError } from "./model.js";
+// The timeout only fires between interpreter steps, so a single built-in must not be able to materialize an
+// unbounded value. These bound what one call may build; programs cannot reach such sizes any other way.
+/** Longest string a built-in or operator may produce. */
+export const MAX_STRING_LENGTH = 1 << 24;
+/** Longest array a built-in may create or grow to. */
+export const MAX_ARRAY_LENGTH = 10_000_000;
+/** Most promises that may be pending at once. */
+export const MAX_PENDING_PROMISES = 10_000;
+export const checkStringLength = (length) => {
+    if (length > MAX_STRING_LENGTH)
+        throw rangeError("Invalid string length");
+};
+export const checkArrayLength = (length) => {
+    if (length > MAX_ARRAY_LENGTH)
+        throw rangeError("Invalid array length");
+};

package/dist/interpreter/objects.js

@@ -1,3 +1,4 @@
+import { checkArrayLength } from "./limits.js";
 import { AsyncIteratorSymbol, IteratorSymbol, } from "./model.js";
 /** Ordinary assignment: writable, enumerable, configurable. */
 export const data = { writable: true, enumerable: true, configurable: true };
@@ -129,13 +130,13 @@ export const isWrapper = (value) => value instanceof ProgramDate ||
     value instanceof ProgramSet ||
     value instanceof ProgramURL ||
     value instanceof ProgramURLSearchParams;
-const MAX_ARRAY_LENGTH = 4_294_967_295;
+const MAX_ARRAY_INDEX = 4_294_967_295;
 export const parseArrayIndex = (key) => {
     const property = String(key);
     if (!/^(0|[1-9]\d*)$/.test(property))
         return undefined;
     const index = Number(property);
-    return index < MAX_ARRAY_LENGTH ? index : undefined;
+    return index < MAX_ARRAY_INDEX ? index : undefined;
 };
 const canonical = (key) => (typeof key === "symbol" ? key : String(key));
 const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
@@ -190,8 +191,9 @@ const writeArray = (target, name, value) => {
     if (name !== "length")
         return undefined;
     const length = typeof value === "number" ? value : Number(value);
-    if (!Number.isInteger(length) || length < 0 || length > MAX_ARRAY_LENGTH)
+    if (!Number.isInteger(length) || length < 0)
         return false;
+    checkArrayLength(length);
     target.items.length = length;
     return true;
 };

package/dist/interpreter/promises.js

@@ -1,5 +1,6 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
-import { CallSite, ProgramThrow, typeError } from "./model.js";
+import { MAX_PENDING_PROMISES } from "./limits.js";
+import { CallSite, ProgramThrow, rangeError, typeError } from "./model.js";
 import { Callable, define, get, hidden, ProgramArray, ProgramFunction, ProgramObject, ProgramPromise, record, } from "./objects.js";
 import { constructor, fn, methods, native, receiver, requiresNew } from "./native.js";
 import { createAggregateErrorValue, locate, materialize, normalizeError } from "./errors.js";
@@ -33,6 +34,9 @@ export class PromiseRuntime {
     }
     create(effect) {
         return Effect.flatMap(CallSite, (site) => {
+            if (this.active.size >= MAX_PENDING_PROMISES) {
+                throw rangeError(`Too many pending promises (limit ${MAX_PENDING_PROMISES}); await promises before creating more.`);
+            }
             // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
             const id = this.nextID++;
             const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site.node)));

package/dist/interpreter/runtime.js

@@ -2,6 +2,7 @@ import { Cause, Deferred, Effect, Exit } from "effect";
 import { toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
 import { AsyncIteratorSymbol, CallSite, GeneratorReturn, IteratorSymbol, OptionalShortCircuit, invalidData, ProgramThrow, rangeError, typeError, unsupportedSyntax, } from "./model.js";
+import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { globals } from "./globals.js";
 import { assign, Callable, define, get, has, hasPrototype, keys, NativeFunction, parseArrayIndex, ProgramArray, ProgramDate, ProgramFunction, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramSet, ProgramURLSearchParams, record, remove, set, } from "./objects.js";
@@ -1054,8 +1055,12 @@ class Frame {
         const l = coerceOperand(lhs);
         const r = coerceOperand(rhs);
         switch (operator) {
-            case "+":
-                return l + r;
+            case "+": {
+                const sum = l + r;
+                if (typeof sum === "string")
+                    checkStringLength(sum.length);
+                return sum;
+            }
             case "-":
                 return l - r;
             case "*":
@@ -1641,9 +1646,11 @@ class Frame {
                     throw typeError("Invalid template literal quasi.", quasi);
                 }
                 output += quasi.value.cooked;
+                checkStringLength(output.length);
                 if (index < expressions.length) {
                     const raw = yield* self.evaluateExpression(expressions[index]);
                     output += coerceToString(toProgram(self.runtime.prototypes, raw, "Template interpolation"));
+                    checkStringLength(output.length);
                 }
             }
             return output;

package/dist/stdlib/array.js

@@ -1,18 +1,17 @@
 import { Effect } from "effect";
 import { constructor, methods, prototypeFrom, receiver } from "../interpreter/native.js";
+import { checkArrayLength, checkStringLength, MAX_ARRAY_LENGTH } from "../interpreter/limits.js";
 import { invalidData, rangeError, typeError } from "../interpreter/model.js";
 import { get, ProgramArray, ProgramGenerator, ProgramObject } from "../interpreter/objects.js";
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
 import { compareText } from "../tool-runtime.js";
 import { coerceToNumber, coerceToString } from "./value.js";
-const MAX_LENGTH = 4_294_967_295;
 const arrayLikeSource = (source) => {
     if (source instanceof ProgramObject && typeof get(source, "length") === "number") {
         const length = get(source, "length");
         const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
-        if (normalized > MAX_LENGTH)
-            throw new RangeError("Invalid array length");
+        checkArrayLength(normalized);
         return { length: normalized, source };
     }
     throw invalidData(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`);
@@ -87,7 +86,7 @@ export const arrayGlobal = (runner) => {
         const first = args[0];
         if (typeof first !== "number")
             return new ProgramArray(into, [first]);
-        if (!Number.isInteger(first) || first < 0 || first > MAX_LENGTH)
+        if (!Number.isInteger(first) || first < 0 || first > MAX_ARRAY_LENGTH)
             throw rangeError("Invalid array length.");
         // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
         return new ProgramArray(into, new Array(first));
@@ -130,7 +129,11 @@ export const arrayGlobal = (runner) => {
                 if (args.length > 1 || (args.length === 1 && typeof args[0] !== "string")) {
                     throw typeError("Array.join expects zero arguments or one string separator.");
                 }
-                return target.map((item) => coerceToString(item ?? "")).join(args.length === 0 ? "," : args[0]);
+                const joined = target
+                    .map((item) => coerceToString(item ?? ""))
+                    .join(args.length === 0 ? "," : args[0]);
+                checkStringLength(joined.length);
+                return joined;
             },
         ],
         [
@@ -175,14 +178,20 @@ export const arrayGlobal = (runner) => {
         [
             "concat",
             1,
-            (thisValue, args) => wrap(self(thisValue, "concat").items.concat(...args.map((item) => (item instanceof ProgramArray ? item.items : item)))),
+            (thisValue, args) => {
+                const joined = self(thisValue, "concat").items.concat(...args.map((item) => (item instanceof ProgramArray ? item.items : item)));
+                checkArrayLength(joined.length);
+                return wrap(joined);
+            },
         ],
         [
             "flat",
             0,
             (thisValue, args) => {
                 const flatten = (items, depth) => items.flatMap((item) => (item instanceof ProgramArray && depth > 0 ? flatten(item.items, depth - 1) : [item]));
-                return wrap(flatten(self(thisValue, "flat").items, optNumber("flat", args[0], "depth") ?? 1));
+                const flattened = flatten(self(thisValue, "flat").items, optNumber("flat", args[0], "depth") ?? 1);
+                checkArrayLength(flattened.length);
+                return wrap(flattened);
             },
         ],
         [

package/dist/stdlib/json.js

@@ -1,6 +1,7 @@
 import { Effect } from "effect";
 import { methods } from "../interpreter/native.js";
 import { applyCollectionCallback } from "../interpreter/runner.js";
+import { checkStringLength } from "../interpreter/limits.js";
 import { syntaxError, typeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromData, toData, toProgram } from "../data.js";
@@ -54,7 +55,10 @@ const stringify = (runner, args) => {
                 .map(String)
             : null;
         // A string cannot pollute, so __proto__ stays: JSON.stringify includes own __proto__ keys, like JS.
-        return Effect.succeed(JSON.stringify(toData(args[0], "JSON.stringify value", "json", false), properties, indent));
+        const text = JSON.stringify(toData(args[0], "JSON.stringify value", "json", false), properties, indent);
+        if (text !== undefined)
+            checkStringLength(text.length);
+        return Effect.succeed(text);
     }
     // Validate up front; the replacer walk below reads the original value.
     toProgram(runner.prototypes, args[0], "JSON.stringify value");

package/dist/stdlib/string.js

@@ -1,6 +1,7 @@
 import { Effect } from "effect";
 import { toProgram } from "../data.js";
 import { constructor, methods } from "../interpreter/native.js";
+import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { invalidData, rangeError, typeError } from "../interpreter/model.js";
 import { ProgramArray, ProgramPromise, ProgramRegExp, record } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
@@ -156,9 +157,11 @@ export const stringGlobal = (runner) => {
             if (args[0] === undefined) {
                 return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]);
             }
-            if (args[0] instanceof ProgramRegExp)
-                return wrap(value.split(args[0].regex, requestedLimit));
-            return wrap(value.split(str("split", args, 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0));
+            const parts = args[0] instanceof ProgramRegExp
+                ? value.split(args[0].regex, requestedLimit)
+                : value.split(str("split", args, 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0);
+            checkArrayLength(parts.length);
+            return wrap(parts);
         }),
         simple("slice", 2, (value, args) => value.slice(optNum("slice", args, 0), optNum("slice", args, 1))),
         simple("includes", 1, (value, args) => {
@@ -192,7 +195,12 @@ export const stringGlobal = (runner) => {
             if (!pattern.global) {
                 throw typeError(`String.matchAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.match for a single match.`);
             }
-            return new ProgramArray(protos.Array, Array.from(value.matchAll(pattern), (match) => matchToValue(protos, match)));
+            const matches = [];
+            for (const match of value.matchAll(pattern)) {
+                checkArrayLength(matches.length + 1);
+                matches.push(matchToValue(protos, match));
+            }
+            return new ProgramArray(protos.Array, matches);
         }),
         simple("search", 1, (value, args) => value.search(toHostRegex(args[0], "search"))),
         simple("repeat", 1, (value, args) => {
@@ -200,10 +208,19 @@ export const stringGlobal = (runner) => {
             if (!Number.isFinite(count) || count < 0) {
                 throw rangeError("String.repeat expects a finite non-negative count.");
             }
+            checkStringLength(value.length * count);
             return value.repeat(count);
         }),
-        simple("padStart", 1, (value, args) => value.padStart(num("padStart", args, 0), optStr("padStart", args, 1))),
-        simple("padEnd", 1, (value, args) => value.padEnd(num("padEnd", args, 0), optStr("padEnd", args, 1))),
+        simple("padStart", 1, (value, args) => {
+            const length = num("padStart", args, 0);
+            checkStringLength(length);
+            return value.padStart(length, optStr("padStart", args, 1));
+        }),
+        simple("padEnd", 1, (value, args) => {
+            const length = num("padEnd", args, 0);
+            checkStringLength(length);
+            return value.padEnd(length, optStr("padEnd", args, 1));
+        }),
         simple("charAt", 1, (value, args) => value.charAt(optNum("charAt", args, 0) ?? 0)),
         simple("at", 1, (value, args) => value.at(optNum("at", args, 0) ?? 0)),
         simple("substring", 2, (value, args) => value.substring(optNum("substring", args, 0) ?? 0, optNum("substring", args, 1))),
@@ -212,7 +229,11 @@ export const stringGlobal = (runner) => {
         simple("toWellFormed", 0, (value) => value.toWellFormed()),
         simple("charCodeAt", 1, (value, args) => value.charCodeAt(optNum("charCodeAt", args, 0) ?? 0)),
         simple("codePointAt", 1, (value, args) => value.codePointAt(optNum("codePointAt", args, 0) ?? 0)),
-        simple("concat", 1, (value, args) => value.concat(...args.map((_, index) => str("concat", args, index)))),
+        simple("concat", 1, (value, args) => {
+            const joined = value.concat(...args.map((_, index) => str("concat", args, index)));
+            checkStringLength(joined.length);
+            return joined;
+        }),
     ]);
     return string;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-19607",
+  "version": "0.0.0-dev-19611",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",