@opencode/codemode 0.0.0-dev-19483 → 0.0.0-dev-19485

package/dist/stdlib/array.js

@@ -1,26 +1,24 @@
 import { Effect } from "effect";
 import { HostFunction, sync, syncCall } from "../interpreter/host.js";
 import { CodeModeGenerator, InterpreterRuntimeError } from "../interpreter/model.js";
+import { get, ProgramArray, ProgramObject } from "../interpreter/objects.js";
 import { describeValue } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
 const constructArray = (args, node) => {
     if (args.length !== 1)
-        return [...args];
+        return new ProgramArray([...args]);
     const first = args[0];
     if (typeof first !== "number")
-        return [first];
+        return new ProgramArray([first]);
     if (!Number.isInteger(first) || first < 0 || first > 4294967295) {
         throw new InterpreterRuntimeError("Invalid array length.", node).as("RangeError");
     }
     // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
-    return new Array(first);
+    return new ProgramArray(new Array(first));
 };
 const arrayLikeSource = (source, node) => {
-    if (source !== null &&
-        typeof source === "object" &&
-        (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) &&
-        typeof source.length === "number") {
-        const length = source.length;
+    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 > 4_294_967_295)
             throw new RangeError("Invalid array length");
@@ -40,17 +38,17 @@ const arrayFrom = (runner, args, node) => {
             const arrayLike = arrayLikeSource(source, node);
             const values = [];
             for (let index = 0; index < arrayLike.length; index += 1) {
-                const item = Reflect.get(arrayLike.source, index);
+                const item = get(arrayLike.source, index);
                 values.push(apply === undefined ? item : yield* apply([item, index]));
             }
-            return values;
+            return new ProgramArray(values);
         }
         const values = [];
         let index = 0;
         while (true) {
             const step = yield* cursor.next;
             if (step.done)
-                return values;
+                return new ProgramArray(values);
             values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])));
             index += 1;
         }
@@ -61,10 +59,10 @@ export const arrayGlobal = (runner) => new HostFunction({
     name: "Array",
     call: syncCall(constructArray),
     construct: syncCall(constructArray),
-    instanceOf: (value) => Array.isArray(value),
+    instanceOf: (value) => value instanceof ProgramArray,
     members: {
-        isArray: sync("Array.isArray", (args) => Array.isArray(args[0])),
-        of: sync("Array.of", (args) => [...args]),
+        isArray: sync("Array.isArray", (args) => args[0] instanceof ProgramArray),
+        of: sync("Array.of", (args) => new ProgramArray([...args])),
         from: new HostFunction({ name: "Array.from", call: (args, node) => arrayFrom(runner, args, node) }),
     },
 });

package/dist/stdlib/collections.js

@@ -1,6 +1,7 @@
 import { Effect } from "effect";
 import { HostFunction, requiresNew } from "../interpreter/host.js";
-import { InterpreterRuntimeError, isRecord } from "../interpreter/model.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { getOwn, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
 import { describeValue, isRuntimeReference } from "../interpreter/references.js";
 import { applyCollectionCallback, preserveConsumerError, toPrimitive } from "../interpreter/runner.js";
 import { Values } from "../values.js";
@@ -94,13 +95,13 @@ export const groupBy = (runner, namespace) => new HostFunction({
                     const key = yield* preserveConsumerError(cursor, apply([item, index]));
                     const group = result.map.get(key);
                     if (group === undefined)
-                        result.map.set(key, [item]);
+                        result.map.set(key, new ProgramArray([item]));
                     else
-                        group.push(item);
+                        group.items.push(item);
                     index += 1;
                 }
             }
-            const result = Object.create(null);
+            const result = new ProgramObject();
             let index = 0;
             while (true) {
                 const step = yield* cursor.next;
@@ -108,11 +109,11 @@ export const groupBy = (runner, namespace) => new HostFunction({
                     return result;
                 const item = step.value;
                 const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
-                const group = result[key];
+                const group = getOwn(result, key);
                 if (group === undefined)
-                    result[key] = [item];
+                    set(result, key, new ProgramArray([item]));
                 else
-                    group.push(item);
+                    group.items.push(item);
                 index += 1;
             }
         });
@@ -132,10 +133,10 @@ const constructMap = (runner, init, node) => {
             if (step.done)
                 return target;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (!isRecord(step.value) || isRuntimeReference(step.value)) {
+                if (!(step.value instanceof ProgramObject)) {
                     throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
                 }
-                target.map.set(step.value[0], step.value[1]);
+                target.map.set(getOwn(step.value, 0), getOwn(step.value, 1));
             }));
         }
     });

package/dist/stdlib/console.js

@@ -1,5 +1,6 @@
 import { toData, toProgram } from "../data.js";
 import { HostNamespace, sync } from "../interpreter/host.js";
+import { get, ownEntries, ProgramArray, ProgramObject } from "../interpreter/objects.js";
 import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
 import { Values } from "../values.js";
 import { coerceToString } from "./value.js";
@@ -54,8 +55,8 @@ const formatConsoleValue = (value, seen, depth) => {
     if (value instanceof Values.Map) {
         seen.add(value);
         try {
-            const entries = Array.from(value.map.entries(), ([key, item]) => [key, item]);
-            return `Map(${value.map.size}) ${formatConsoleValue(entries, seen, depth + 1)}`;
+            const entries = Array.from(value.map.entries(), ([key, item]) => new ProgramArray([key, item]));
+            return `Map(${value.map.size}) ${formatConsoleValue(new ProgramArray(entries), seen, depth + 1)}`;
         }
         finally {
             seen.delete(value);
@@ -64,7 +65,7 @@ const formatConsoleValue = (value, seen, depth) => {
     if (value instanceof Values.Set) {
         seen.add(value);
         try {
-            return `Set(${value.set.size}) ${formatConsoleValue(Array.from(value.set.values()), seen, depth + 1)}`;
+            return `Set(${value.set.size}) ${formatConsoleValue(new ProgramArray([...value.set.values()]), seen, depth + 1)}`;
         }
         finally {
             seen.delete(value);
@@ -74,10 +75,12 @@ const formatConsoleValue = (value, seen, depth) => {
         return "[opaque reference]";
     seen.add(value);
     try {
-        if (Array.isArray(value)) {
-            return `[${value.map((item) => formatConsoleValue(item, seen, depth + 1)).join(",")}]`;
+        if (value instanceof ProgramArray) {
+            return `[${value.items.map((item) => formatConsoleValue(item, seen, depth + 1)).join(",")}]`;
         }
-        return `{${Object.entries(value)
+        if (!(value instanceof ProgramObject))
+            return "[object Object]";
+        return `{${ownEntries(value)
             .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
             .join(",")}}`;
     }
@@ -109,20 +112,19 @@ const consoleTableColumns = (value) => {
     return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined;
 };
 const consoleTableRows = (data, columns) => {
-    if (Array.isArray(data)) {
-        return data.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
+    if (data instanceof ProgramArray) {
+        return data.items.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
     }
-    if (data !== null && typeof data === "object" && !Values.isValue(data)) {
-        return Object.entries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
+    if (data instanceof ProgramObject) {
+        return ownEntries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
     }
     return [{ index: "0", values: { Value: data } }];
 };
 const consoleTableValues = (value, columns) => {
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && !Values.isValue(value)) {
-        const source = value;
+    if (value instanceof ProgramObject && !(value instanceof ProgramArray)) {
         if (columns !== undefined)
-            return Object.fromEntries(columns.map((column) => [column, source[column]]));
-        return Object.fromEntries(Object.entries(source));
+            return Object.fromEntries(columns.map((column) => [column, get(value, column)]));
+        return Object.fromEntries(ownEntries(value));
     }
     return { Value: value };
 };

package/dist/stdlib/json.js

@@ -4,6 +4,7 @@ import { applyCollectionCallback } from "../interpreter/runner.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { typeofValue } from "../interpreter/references.js";
 import { fromData, toData, toProgram } from "../data.js";
+import { get, ownKeys, ProgramArray, ProgramObject, record, remove, set } from "../interpreter/objects.js";
 import { Values } from "../values.js";
 export const jsonGlobal = (runner) => new HostNamespace("JSON", {
     parse: new HostFunction({ name: "JSON.parse", call: (args, node) => parse(runner, args, node) }),
@@ -24,40 +25,28 @@ const parse = (runner, args, node) => {
     if (typeofValue(args[1]) !== "function")
         return Effect.succeed(parsed);
     const apply = applyCollectionCallback(runner, args[1], "JSON.parse", node);
-    const root = Object.create(null);
-    root[""] = parsed;
     const visit = (holder, key) => Effect.gen(function* () {
-        const value = holder[key];
-        if (Array.isArray(value)) {
-            const length = value.length;
-            for (let index = 0; index < length; index += 1) {
-                const revived = yield* visit(value, String(index));
-                if (revived === undefined)
-                    Reflect.deleteProperty(value, index);
-                else
-                    value[index] = revived;
-            }
-        }
-        else if (isPlainObject(value)) {
-            for (const name of Object.keys(value)) {
+        const value = get(holder, key);
+        if (value instanceof ProgramObject) {
+            for (const name of ownKeys(value)) {
                 const revived = yield* visit(value, name);
                 if (revived === undefined)
-                    Reflect.deleteProperty(value, name);
+                    remove(value, name);
                 else
-                    value[name] = revived;
+                    set(value, name, revived);
             }
         }
         return yield* apply([key, value]);
     });
-    return visit(root, "");
+    return visit(record({ "": parsed }), "");
 };
 const stringify = (runner, args, node) => {
     const space = args[2];
     const indent = typeof space === "number" || typeof space === "string" ? space : undefined;
     const replacer = args[1];
     if (typeofValue(replacer) !== "function") {
-        const properties = Array.isArray(replacer)
-            ? replacer
+        const properties = replacer instanceof ProgramArray
+            ? replacer.items
                 .filter((item) => typeof item === "string" || typeof item === "number")
                 .map(String)
             : null;
@@ -66,11 +55,9 @@ const stringify = (runner, args, node) => {
     // Validate up front; the replacer walk below reads the original value.
     toProgram(args[0], "JSON.stringify value");
     const apply = applyCollectionCallback(runner, replacer, "JSON.stringify", node);
-    const root = Object.create(null);
-    root[""] = args[0];
     const stack = new Set();
     const visit = (holder, key) => Effect.gen(function* () {
-        const value = yield* apply([key, toJSONValue(holder[key])]);
+        const value = yield* apply([key, toJSONValue(get(holder, key))]);
         if (value === undefined || typeofValue(value) === "function")
             return undefined;
         toProgram(value, "JSON.stringify replacer result");
@@ -78,24 +65,23 @@ const stringify = (runner, args, node) => {
             return Number.isFinite(value) ? value : null;
         if (value === null || typeof value === "string" || typeof value === "boolean")
             return value;
-        if (Array.isArray(value)) {
-            if (stack.has(value))
-                throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
-            stack.add(value);
+        if (!(value instanceof ProgramObject))
+            return {};
+        if (stack.has(value))
+            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
+        stack.add(value);
+        if (value instanceof ProgramArray) {
             const result = [];
-            for (let index = 0; index < value.length; index += 1) {
+            for (let index = 0; index < value.items.length; index += 1) {
                 result.push((yield* visit(value, String(index))) ?? null);
             }
             stack.delete(value);
             return result;
         }
-        if (!isPlainObject(value))
-            return {};
-        if (stack.has(value))
-            throw new InterpreterRuntimeError("Converting circular structure to JSON.", node).as("TypeError");
-        stack.add(value);
         const result = Object.create(null);
-        for (const name of Object.keys(value)) {
+        for (const name of ownKeys(value)) {
+            if (typeof name !== "string")
+                continue;
             const item = yield* visit(value, name);
             if (item !== undefined)
                 result[name] = item;
@@ -103,7 +89,7 @@ const stringify = (runner, args, node) => {
         stack.delete(value);
         return result;
     });
-    return Effect.map(visit(root, ""), (value) => JSON.stringify(value, null, indent));
+    return Effect.map(visit(record({ "": args[0] }), ""), (value) => JSON.stringify(value, null, indent));
 };
 const toJSONValue = (value) => {
     if (value instanceof Values.Date) {
@@ -113,4 +99,3 @@ const toJSONValue = (value) => {
         return value.url.href;
     return value;
 };
-const isPlainObject = (value) => value !== null && typeof value === "object" && !Values.isValue(value);

package/dist/stdlib/object.d.ts

@@ -1,6 +1,7 @@
 import { HostFunction } from "../interpreter/host.js";
 import { type AstNode } from "../interpreter/model.js";
+import { ProgramObject } from "../interpreter/objects.js";
 import { type Runner } from "../interpreter/runner.js";
-export declare const enumerableSource: (label: string, value: unknown, node: AstNode) => Record<string, unknown>;
+export declare const enumerableSource: (label: string, value: unknown, node: AstNode) => ProgramObject;
 export declare const objectAssign: (args: Array<unknown>, node: AstNode) => unknown;
 export declare const objectGlobal: <R>(runner: Runner<R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>) => HostFunction<R>;

package/dist/stdlib/object.js

@@ -2,14 +2,14 @@ import { Effect } from "effect";
 import { toProgram } from "../data.js";
 import { HostFunction, sync, syncCall } from "../interpreter/host.js";
 import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "../interpreter/model.js";
-import { containsOpaqueReference, describeValue, isRuntimeReference, parseArrayIndex, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
+import { getOwn, hasOwn, ownEntries, ownKeys, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
+import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue, } from "../interpreter/references.js";
 import { preserveConsumerError } from "../interpreter/runner.js";
 import { ToolReference } from "../tool-runtime.js";
 import { Values } from "../values.js";
 import { groupBy } from "./collections.js";
 import { coerceToString } from "./value.js";
-// ToObject for enumeration. Strings return themselves: the host's Object.keys/entries/hasOwn index a
-// primitive string directly. Numbers, booleans, wrappers, and functions have no own enumerable keys.
+// ToObject for enumeration.
 export const enumerableSource = (label, value, node) => {
     if (value === null || value === undefined) {
         throw new InterpreterRuntimeError(`${label} cannot convert ${describeValue(value)} to an object.`, node).as("TypeError");
@@ -21,49 +21,35 @@ export const enumerableSource = (label, value, node) => {
         throw new InterpreterRuntimeError(`${label} cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
     }
     if (typeof value === "string")
+        return new ProgramArray([...value]);
+    if (value instanceof ProgramObject)
         return value;
-    if (typeof value !== "object" || Values.isValue(value) || isRuntimeReference(value))
-        return {};
-    return value;
+    return new ProgramObject();
 };
 export const objectAssign = (args, node) => {
     const target = args[0];
     // JS would box a primitive target; wrappers and primitives cannot hold fields here.
-    if (target === null || typeof target !== "object" || Values.isValue(target) || isRuntimeReference(target)) {
+    if (!(target instanceof ProgramObject)) {
         throw new InterpreterRuntimeError(`Object.assign expects a data object or array target, received ${describeValue(target)}.`, node).as("TypeError");
     }
-    const out = target;
     const seen = new Set();
-    const guardedSet = (key, item) => {
-        // Arrays hold only indexed elements, as with direct assignment; Reflect.set would otherwise
-        // reach Array's length and Object.prototype's __proto__ setter.
-        if (Array.isArray(out) && (typeof key === "symbol" || parseArrayIndex(key) === undefined)) {
-            throw new InterpreterRuntimeError(`Object.assign cannot assign '${String(key)}' to an array: only array indexes may be assigned.`, node).as("TypeError");
-        }
-        rejectCircularInsertion(out, item, "Object.assign result", node, seen);
-        if (!Reflect.set(out, key, item))
-            throw new InterpreterRuntimeError(`Object.assign could not assign property '${String(key)}'.`, node).as("TypeError");
-    };
     for (const source of args.slice(1)) {
         if (source === null || source === undefined)
             continue;
         const from = enumerableSource("Object.assign(...)", source, node);
-        if (typeof from !== "object") {
-            for (const [key, item] of Object.entries(from))
-                guardedSet(key, item);
-            continue;
-        }
-        for (const key of Reflect.ownKeys(from)) {
+        for (const key of ownKeys(from)) {
             if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol)
                 continue;
-            if (Object.prototype.propertyIsEnumerable.call(from, key))
-                guardedSet(key, Reflect.get(from, key));
+            rejectCircularInsertion(target, getOwn(from, key), "Object.assign result", node, seen);
+            if (!set(target, key, getOwn(from, key))) {
+                throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
+            }
         }
     }
-    return out;
+    return target;
 };
 const objectFromEntries = (runner, source, node) => {
-    const out = Object.create(null);
+    const out = new ProgramObject();
     return Effect.gen(function* () {
         const cursor = yield* runner.syncIterator(source, node);
         if (cursor === undefined) {
@@ -74,17 +60,10 @@ const objectFromEntries = (runner, source, node) => {
             if (step.done)
                 return out;
             yield* preserveConsumerError(cursor, Effect.sync(() => {
-                if (step.value === null ||
-                    typeof step.value !== "object" ||
-                    Values.isValue(step.value) ||
-                    containsOpaqueReference(step.value)) {
+                if (!(step.value instanceof ProgramObject) || containsOpaqueReference(step.value)) {
                     throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
                 }
-                const entry = step.value;
-                toProgram(entry[0], "Object.fromEntries key");
-                toProgram(entry[1], "Object.fromEntries value");
-                const key = coerceToString(entry[0]);
-                out[key] = entry[1];
+                set(out, coerceToString(getOwn(step.value, 0)), getOwn(step.value, 1));
             }));
         }
     });
@@ -92,7 +71,7 @@ const objectFromEntries = (runner, source, node) => {
 const constructObject = (args, node) => {
     const first = args[0];
     if (first === null || first === undefined)
-        return Object.create(null);
+        return new ProgramObject();
     if (typeof first === "object")
         return first;
     throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);
@@ -107,10 +86,10 @@ export const objectGlobal = (runner, toolKeys) => new HostFunction({
     members: {
         keys: sync("Object.keys", (args, node) => toProgram(args[0] instanceof ToolReference
             ? [...toolKeys(args[0].path)]
-            : Object.keys(enumerableSource("Object.keys(...)", args[0], node)), "Object.keys result")),
-        values: sync("Object.values", (args, node) => Object.values(enumerableSource("Object.values(...)", args[0], node))),
-        entries: sync("Object.entries", (args, node) => Object.entries(enumerableSource("Object.entries(...)", args[0], node)).map(([key, item]) => [key, item])),
-        hasOwn: sync("Object.hasOwn", (args, node) => Object.hasOwn(enumerableSource("Object.hasOwn(...)", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
+            : ownKeys(enumerableSource("Object.keys(...)", args[0], node)).filter((key) => typeof key === "string"), "Object.keys result")),
+        values: sync("Object.values", (args, node) => new ProgramArray(ownEntries(enumerableSource("Object.values(...)", args[0], node)).map((entry) => entry[1]))),
+        entries: sync("Object.entries", (args, node) => new ProgramArray(ownEntries(enumerableSource("Object.entries(...)", args[0], node)).map((entry) => new ProgramArray(entry)))),
+        hasOwn: sync("Object.hasOwn", (args, node) => hasOwn(enumerableSource("Object.hasOwn(...)", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
         is: sync("Object.is", (args, node) => {
             if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
                 throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");

package/dist/stdlib/regexp.d.ts

@@ -1,9 +1,10 @@
 import { type AstNode } from "../interpreter/model.js";
+import { ProgramArray } from "../interpreter/objects.js";
 import { Values } from "../values.js";
 export declare const regexpMethods: Set<string>;
 export declare const regexpProperties: Set<string>;
 export declare const toHostRegex: (arg: unknown, method: string, node: AstNode, extraFlags?: string) => RegExp;
-export declare const matchToValue: (match: RegExpMatchArray) => Array<unknown>;
+export declare const matchToValue: (match: RegExpMatchArray) => ProgramArray;
 export declare const constructRegExp: (args: Array<unknown>, node: AstNode) => Values.RegExp;
 export declare const regexpGlobal: import("../interpreter/host.js").HostFunction<never>;
 export declare const invokeRegExpMethod: (value: Values.RegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;

package/dist/stdlib/regexp.js

@@ -1,5 +1,6 @@
 import { sync, syncCall } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { ProgramArray, record, set } from "../interpreter/objects.js";
 import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 export const regexpMethods = new Set(["test", "exec", "toString"]);
@@ -35,18 +36,15 @@ export const toHostRegex = (arg, method, node, extraFlags = "") => {
     throw new InterpreterRuntimeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`, node);
 };
 export const matchToValue = (match) => {
-    const result = Array.from(match, (group) => group);
+    const result = new ProgramArray(Array.from(match, (group) => group));
     if (match.index !== undefined)
-        result.index = match.index;
-    if (match.groups) {
-        const groups = Object.create(null);
-        for (const [key, group] of Object.entries(match.groups)) {
-            groups[key] = group;
-        }
-        result.groups = groups;
-    }
+        set(result, "index", match.index);
+    if (match.input !== undefined)
+        set(result, "input", match.input);
+    if (match.groups)
+        set(result, "groups", record(match.groups));
     if (match.indices)
-        result.indices = indicesToValue(match.indices);
+        set(result, "indices", indicesToValue(match.indices));
     return result;
 };
 export const constructRegExp = (args, node) => {
@@ -112,15 +110,11 @@ const toLength = (value) => {
     return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER);
 };
 const indicesToValue = (indices) => {
-    const result = Array.from(indices, (range) => (range === undefined ? undefined : [...range]));
-    if (indices.groups) {
-        const groups = Object.create(null);
-        for (const [key, range] of Object.entries(indices.groups)) {
-            groups[key] = range === undefined ? undefined : [...range];
-        }
-        result.groups = groups;
-        return result;
-    }
-    result.groups = undefined;
+    const range = (pair) => (pair === undefined ? undefined : new ProgramArray([...pair]));
+    const result = new ProgramArray(Array.from(indices, range));
+    const groups = indices.groups;
+    set(result, "groups", groups === undefined
+        ? undefined
+        : record(Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
     return result;
 };

package/dist/stdlib/url.js

@@ -2,6 +2,7 @@ import { Effect } from "effect";
 import { toProgram } from "../data.js";
 import { HostFunction, requiresNew, sync, syncCall } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { ownEntries, ProgramObject } from "../interpreter/objects.js";
 import { isRuntimeReference } from "../interpreter/references.js";
 import { preserveConsumerError } from "../interpreter/runner.js";
 import { Values } from "../values.js";
@@ -141,11 +142,10 @@ const constructURLSearchParams = (runner, init, node) => {
         }
         if (Values.isValue(init))
             return new Values.URLSearchParams(new URLSearchParams());
-        const data = toProgram(init, "new URLSearchParams input");
-        if (data === null || typeof data !== "object") {
+        if (!(init instanceof ProgramObject)) {
             throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node).as("TypeError");
         }
-        return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(Object.entries(data).map(([key, value]) => [key, coerceToString(value)]))));
+        return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(ownEntries(init).map(([key, value]) => [key, coerceToString(value)]))));
     });
 };
 export const urlSearchParamsGlobal = (runner) => new HostFunction({

package/dist/stdlib/value.d.ts

@@ -1,9 +1,9 @@
 import { type HostFunction, type SyncOptions } from "../interpreter/host.js";
-import { type SafeObject } from "../data.js";
+import { ProgramError } from "../interpreter/objects.js";
 export declare const errorConstructors: Set<string>;
 export declare const compoundOperators: Set<string>;
-export declare const createErrorValue: (name: string, message: string) => SafeObject;
-export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => SafeObject;
+export declare const createErrorValue: (name: string, message: string) => ProgramError;
+export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => ProgramError;
 export declare const errorBrandName: (value: unknown) => string | undefined;
 export declare const coerceToString: (value: unknown) => string;
 export declare const coerceToNumber: (value: unknown) => number;