@opencode/codemode 0.0.0-dev-19366 → 0.0.0-dev-19367

package/dist/stdlib/collections.js

@@ -1,3 +1,11 @@
+import { Effect } from "effect";
+import { isBlockedMember } from "../data.js";
+import { HostFunction, requiresNew } from "../interpreter/host.js";
+import { InterpreterRuntimeError, isRecord } from "../interpreter/model.js";
+import { isRuntimeReference } from "../interpreter/references.js";
+import { applyCollectionCallback, preserveConsumerError, toPrimitive } from "../interpreter/runner.js";
+import { Values } from "../values.js";
+import { coerceToString } from "./value.js";
 export const arrayMethods = new Set([
     "map",
     "filter",
@@ -37,7 +45,6 @@ export const arrayMethods = new Set([
     "entries",
 ]);
 export const mapMethods = new Set(["get", "set", "has", "delete", "clear", "forEach", "keys", "values", "entries"]);
-export const mapStatics = new Set(["groupBy"]);
 export const setMethods = new Set([
     "add",
     "has",
@@ -55,3 +62,115 @@ export const setMethods = new Set([
     "isSupersetOf",
     "isDisjointFrom",
 ]);
+const coerceGroupByPropertyKey = (runner, value, node) => {
+    if (value instanceof Values.Promise)
+        return Effect.succeed("[object Promise]");
+    if (!Values.isValue(value) && isRuntimeReference(value)) {
+        throw new InterpreterRuntimeError("Object.groupBy callback must return a data value.", node, "InvalidDataValue");
+    }
+    return Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
+};
+/** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
+export const groupBy = (runner, namespace) => new HostFunction({
+    name: `${namespace}.groupBy`,
+    call: (args, node) => {
+        const source = args[0];
+        if (source === null || source === undefined) {
+            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
+        }
+        const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node);
+        return Effect.gen(function* () {
+            const cursor = yield* runner.syncIterator(source, node);
+            if (cursor === undefined) {
+                throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
+            }
+            if (namespace === "Map") {
+                const result = new Values.Map();
+                let index = 0;
+                while (true) {
+                    const step = yield* cursor.next;
+                    if (step.done)
+                        return result;
+                    const item = step.value;
+                    const key = yield* preserveConsumerError(cursor, apply([item, index]));
+                    const group = result.map.get(key);
+                    if (group === undefined)
+                        result.map.set(key, [item]);
+                    else
+                        group.push(item);
+                    index += 1;
+                }
+            }
+            const result = Object.create(null);
+            let index = 0;
+            while (true) {
+                const step = yield* cursor.next;
+                if (step.done)
+                    return result;
+                const item = step.value;
+                const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
+                if (isBlockedMember(key)) {
+                    return yield* preserveConsumerError(cursor, Effect.fail(new InterpreterRuntimeError(`Property '${key}' is not available.`, node)));
+                }
+                const group = result[key];
+                if (group === undefined)
+                    result[key] = [item];
+                else
+                    group.push(item);
+                index += 1;
+            }
+        });
+    },
+});
+const constructMap = (runner, init, node) => {
+    const target = new Values.Map();
+    if (init === undefined || init === null)
+        return Effect.succeed(target);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(init, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node).as("TypeError");
+        }
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return target;
+            yield* preserveConsumerError(cursor, Effect.sync(() => {
+                if (!isRecord(step.value) || isRuntimeReference(step.value)) {
+                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
+                }
+                target.map.set(step.value[0], step.value[1]);
+            }));
+        }
+    });
+};
+const constructSet = (runner, init, node) => {
+    const target = new Values.Set();
+    if (init === undefined || init === null)
+        return Effect.succeed(target);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(init, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node).as("TypeError");
+        }
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return target;
+            target.set.add(step.value);
+        }
+    });
+};
+export const mapGlobal = (runner) => new HostFunction({
+    name: "Map",
+    call: requiresNew("Map"),
+    construct: (args, node) => constructMap(runner, args[0], node),
+    instanceOf: (value) => value instanceof Values.Map,
+    members: { groupBy: groupBy(runner, "Map") },
+});
+export const setGlobal = (runner) => new HostFunction({
+    name: "Set",
+    call: requiresNew("Set"),
+    construct: (args, node) => constructSet(runner, args[0], node),
+    instanceOf: (value) => value instanceof Values.Set,
+});

package/dist/stdlib/console.d.ts

@@ -1,2 +1,3 @@
-export declare const consoleMethods: Set<string>;
-export declare const formatConsoleMessage: (name: string, args: Array<unknown>) => string;
+import { HostNamespace } from "../interpreter/host.js";
+/** Captured console: every method appends one formatted line to `logs`. */
+export declare const consoleGlobal: (logs: Array<string>) => HostNamespace;

package/dist/stdlib/console.js

@@ -1,10 +1,19 @@
 import { toData, toProgram } from "../data.js";
+import { HostNamespace, sync } from "../interpreter/host.js";
 import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
 import { Values } from "../values.js";
 import { coerceToString } from "./value.js";
-export const consoleMethods = new Set(["log", "info", "debug", "warn", "error", "dir", "table"]);
+const consoleMethods = ["log", "info", "debug", "warn", "error", "dir", "table"];
+/** Captured console: every method appends one formatted line to `logs`. */
+export const consoleGlobal = (logs) => new HostNamespace("console", Object.fromEntries(consoleMethods.map((name) => [
+    name,
+    sync(`console.${name}`, (args) => {
+        logs.push(formatConsoleMessage(name, args));
+        return undefined;
+    }),
+])));
 const MAX_CONSOLE_DEPTH = 32;
-export const formatConsoleMessage = (name, args) => {
+const formatConsoleMessage = (name, args) => {
     if (name === "dir")
         return args.length === 0 ? "undefined" : formatConsoleArgument(args[0]);
     if (name === "table")

package/dist/stdlib/date.d.ts

@@ -1,7 +1,8 @@
+import { HostFunction } from "../interpreter/host.js";
 import { type AstNode } from "../interpreter/model.js";
+import { type Runner } from "../interpreter/runner.js";
 import { Values } from "../values.js";
 export declare const dateMethods: Set<string>;
-export declare const dateStatics: Set<string>;
-export declare const invokeDateStatic: (name: string, args: Array<unknown>, node: AstNode) => number;
+export declare const dateGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
 export declare const dateSetterArgumentCount: (name: string) => number | undefined;
 export declare const invokeDateMethod: (value: Values.Date, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;

package/dist/stdlib/date.js

@@ -1,4 +1,7 @@
+import { Effect } from "effect";
+import { HostFunction, sync } from "../interpreter/host.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { toPrimitive } from "../interpreter/runner.js";
 import { Values } from "../values.js";
 import { coerceToNumber, coerceToString } from "./value.js";
 const dateSetterArguments = new Map([
@@ -45,19 +48,32 @@ export const dateMethods = new Set([
     "getTimezoneOffset",
     ...dateSetterArguments.keys(),
 ]);
-export const dateStatics = new Set(["now", "parse", "UTC"]);
-export const invokeDateStatic = (name, args, node) => {
-    switch (name) {
-        case "now":
-            return Date.now();
-        case "parse":
-            return Date.parse(coerceToString(args[0]));
-        case "UTC":
-            return Date.UTC(...args.map((arg) => coerceToNumber(arg)));
-        default:
-            throw new InterpreterRuntimeError(`Date.${name} is not available.`, node);
+const constructDate = (runner, args, node) => {
+    if (args.length === 0)
+        return Effect.succeed(new Values.Date(Date.now()));
+    if (args.length === 1) {
+        const arg = args[0];
+        if (arg instanceof Values.Date)
+            return Effect.succeed(new Values.Date(arg.time));
+        return Effect.map(toPrimitive(runner, arg, "number", node), (value) => typeof value === "string"
+            ? new Values.Date(Date.parse(value))
+            : new Values.Date(new Date(coerceToNumber(value)).getTime()));
     }
+    const parts = args.map((arg) => coerceToNumber(arg));
+    return Effect.succeed(new Values.Date(new Date(...parts).getTime()));
 };
+export const dateGlobal = (runner) => new HostFunction({
+    name: "Date",
+    // ISO instead of the host's locale string: date strings are deterministic and must not leak the host timezone.
+    call: () => Effect.sync(() => new Date().toISOString()),
+    construct: (args, node) => constructDate(runner, args, node),
+    instanceOf: (value) => value instanceof Values.Date,
+    members: {
+        now: sync("Date.now", () => Date.now()),
+        parse: sync("Date.parse", (args) => Date.parse(coerceToString(args[0]))),
+        UTC: sync("Date.UTC", (args) => Date.UTC(...args.map((arg) => coerceToNumber(arg)))),
+    },
+});
 export const dateSetterArgumentCount = (name) => dateSetterArguments.get(name);
 export const invokeDateMethod = (value, name, args, node, initialTime = value.time) => {
     const hosted = new Date(initialTime);

package/dist/stdlib/json.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
-import type { CallbackRunner } from "../interpreter/methods.js";
+import { HostNamespace } from "../interpreter/host.js";
+import { type Runner } from "../interpreter/runner.js";
 import { type AstNode } from "../interpreter/model.js";
-export declare const jsonStatics: Set<string>;
-export type JsonMethodName = "parse" | "stringify";
-export declare const invokeJsonMethod: <R>(runner: CallbackRunner<R>, name: JsonMethodName, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const invokeJsonMethod: <R>(runner: Runner<R>, name: "parse" | "stringify", args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const jsonGlobal: <R>(runner: Runner<R>) => HostNamespace;

package/dist/stdlib/json.js

@@ -1,13 +1,17 @@
 import { Effect } from "effect";
-import { applyCollectionCallback } from "../interpreter/methods.js";
+import { HostFunction, HostNamespace } from "../interpreter/host.js";
+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 { Values } from "../values.js";
-export const jsonStatics = new Set(["parse", "stringify"]);
 export const invokeJsonMethod = (runner, name, args, node) => {
     return name === "parse" ? parse(runner, args, node) : stringify(runner, args, node);
 };
+export const jsonGlobal = (runner) => new HostNamespace("JSON", {
+    parse: new HostFunction({ name: "JSON.parse", call: (args, node) => parse(runner, args, node) }),
+    stringify: new HostFunction({ name: "JSON.stringify", call: (args, node) => stringify(runner, args, node) }),
+});
 const parse = (runner, args, node) => {
     const text = args[0];
     if (typeof text !== "string")

package/dist/stdlib/math.d.ts

@@ -1,12 +1,8 @@
-import { Effect } from "effect";
-import { type SyncIteratorRunner } from "../interpreter/iterator.js";
-import { type AstNode } from "../interpreter/model.js";
+import { HostNamespace } from "../interpreter/host.js";
+import { type Runner } from "../interpreter/runner.js";
 declare global {
     interface Math {
         sumPrecise(values: Iterable<number>): number;
     }
 }
-export declare const mathConstants: Set<string>;
-export declare const mathMethods: Set<string>;
-export declare const invokeMathMethod: (name: string, args: Array<unknown>, node: AstNode) => number;
-export declare const invokeMathSumPrecise: <R>(runner: SyncIteratorRunner<R>, source: unknown, node: AstNode) => Effect.Effect<number, unknown, R>;
+export declare const mathGlobal: <R>(runner: Runner<R>) => HostNamespace;

package/dist/stdlib/math.js

@@ -1,157 +1,89 @@
 import { Effect } from "effect";
-import { preserveConsumerError } from "../interpreter/iterator.js";
+import { HostFunction, HostNamespace, sync } from "../interpreter/host.js";
+import { preserveConsumerError } from "../interpreter/runner.js";
 import { InterpreterRuntimeError } from "../interpreter/model.js";
-export const mathConstants = new Set(["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"]);
-export const mathMethods = new Set([
-    "random",
-    "max",
-    "min",
-    "abs",
-    "acos",
-    "acosh",
-    "asin",
-    "asinh",
-    "atan",
-    "atan2",
-    "atanh",
-    "floor",
-    "ceil",
-    "round",
-    "trunc",
-    "sign",
-    "sqrt",
-    "cbrt",
-    "pow",
-    "hypot",
-    "cos",
-    "cosh",
-    "sin",
-    "sinh",
-    "tan",
-    "tanh",
-    "log",
-    "log2",
-    "log10",
-    "log1p",
-    "exp",
-    "expm1",
-    "f16round",
-    "fround",
-    "clz32",
-    "imul",
-    "sumPrecise",
-]);
-export const invokeMathMethod = (name, args, node) => {
-    if (!mathMethods.has(name))
-        throw new InterpreterRuntimeError(`Math.${name} is not available.`, node);
-    if (name === "random")
-        return Math.random();
-    // Validate only the arguments the method consumes; like JS, extras are ignored
-    // (so built-ins work as callbacks receiving (element, index, array)).
-    const num = (index) => {
-        if (index >= args.length)
-            return Number.NaN;
-        const arg = args[index];
-        if (typeof arg !== "number")
-            throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
-        return arg;
-    };
-    const nums = () => args.map((arg) => {
-        if (typeof arg !== "number")
-            throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
-        return arg;
-    });
-    const a = num(0);
-    const b = () => num(1);
-    switch (name) {
-        case "max":
-            return Math.max(...nums());
-        case "min":
-            return Math.min(...nums());
-        case "abs":
-            return Math.abs(a);
-        case "acos":
-            return Math.acos(a);
-        case "acosh":
-            return Math.acosh(a);
-        case "asin":
-            return Math.asin(a);
-        case "asinh":
-            return Math.asinh(a);
-        case "atan":
-            return Math.atan(a);
-        case "atan2":
-            return Math.atan2(a, b());
-        case "atanh":
-            return Math.atanh(a);
-        case "floor":
-            return Math.floor(a);
-        case "ceil":
-            return Math.ceil(a);
-        case "round":
-            return Math.round(a);
-        case "trunc":
-            return Math.trunc(a);
-        case "sign":
-            return Math.sign(a);
-        case "sqrt":
-            return Math.sqrt(a);
-        case "cbrt":
-            return Math.cbrt(a);
-        case "pow":
-            return Math.pow(a, b());
-        case "hypot":
-            return Math.hypot(...nums());
-        case "cos":
-            return Math.cos(a);
-        case "cosh":
-            return Math.cosh(a);
-        case "sin":
-            return Math.sin(a);
-        case "sinh":
-            return Math.sinh(a);
-        case "tan":
-            return Math.tan(a);
-        case "tanh":
-            return Math.tanh(a);
-        case "log":
-            return Math.log(a);
-        case "log2":
-            return Math.log2(a);
-        case "log10":
-            return Math.log10(a);
-        case "log1p":
-            return Math.log1p(a);
-        case "exp":
-            return Math.exp(a);
-        case "expm1":
-            return Math.expm1(a);
-        case "f16round":
-            return Math.f16round(a);
-        case "fround":
-            return Math.fround(a);
-        case "clz32":
-            return Math.clz32(a);
-        case "imul":
-            return Math.imul(a, b());
-    }
-    throw new InterpreterRuntimeError(`Math.${name} is not available.`, node);
+// Validate only the arguments a method consumes; like JS, extras are ignored
+// (so built-ins work as callbacks receiving (element, index, array)).
+const number = (name, args, index, node) => {
+    if (index >= args.length)
+        return Number.NaN;
+    const arg = args[index];
+    if (typeof arg !== "number")
+        throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+    return arg;
 };
-export const invokeMathSumPrecise = (runner, source, node) => Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(source, node);
-    if (cursor === undefined) {
-        throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node).as("TypeError");
-    }
-    const numbers = [];
-    while (true) {
-        const step = yield* cursor.next;
-        if (step.done)
-            return Math.sumPrecise(numbers);
-        yield* preserveConsumerError(cursor, Effect.sync(() => {
-            if (typeof step.value !== "number") {
-                throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError");
-            }
-            numbers.push(step.value);
-        }));
-    }
+const unary = (name, op) => sync(`Math.${name}`, (args, node) => op(number(name, args, 0, node)));
+const binary = (name, op) => sync(`Math.${name}`, (args, node) => op(number(name, args, 0, node), number(name, args, 1, node)));
+const variadic = (name, op) => sync(`Math.${name}`, (args, node) => op(...args.map((arg) => {
+    if (typeof arg !== "number")
+        throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+    return arg;
+})));
+const sumPrecise = (runner) => new HostFunction({
+    name: "Math.sumPrecise",
+    call: (args, node) => Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(args[0], node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node).as("TypeError");
+        }
+        const numbers = [];
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return Math.sumPrecise(numbers);
+            yield* preserveConsumerError(cursor, Effect.sync(() => {
+                if (typeof step.value !== "number") {
+                    throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError");
+                }
+                numbers.push(step.value);
+            }));
+        }
+    }),
+});
+export const mathGlobal = (runner) => new HostNamespace("Math", {
+    PI: Math.PI,
+    E: Math.E,
+    LN2: Math.LN2,
+    LN10: Math.LN10,
+    LOG2E: Math.LOG2E,
+    LOG10E: Math.LOG10E,
+    SQRT2: Math.SQRT2,
+    SQRT1_2: Math.SQRT1_2,
+    random: sync("Math.random", () => Math.random()),
+    max: variadic("max", Math.max),
+    min: variadic("min", Math.min),
+    hypot: variadic("hypot", Math.hypot),
+    abs: unary("abs", Math.abs),
+    acos: unary("acos", Math.acos),
+    acosh: unary("acosh", Math.acosh),
+    asin: unary("asin", Math.asin),
+    asinh: unary("asinh", Math.asinh),
+    atan: unary("atan", Math.atan),
+    atan2: binary("atan2", Math.atan2),
+    atanh: unary("atanh", Math.atanh),
+    floor: unary("floor", Math.floor),
+    ceil: unary("ceil", Math.ceil),
+    round: unary("round", Math.round),
+    trunc: unary("trunc", Math.trunc),
+    sign: unary("sign", Math.sign),
+    sqrt: unary("sqrt", Math.sqrt),
+    cbrt: unary("cbrt", Math.cbrt),
+    pow: binary("pow", Math.pow),
+    cos: unary("cos", Math.cos),
+    cosh: unary("cosh", Math.cosh),
+    sin: unary("sin", Math.sin),
+    sinh: unary("sinh", Math.sinh),
+    tan: unary("tan", Math.tan),
+    tanh: unary("tanh", Math.tanh),
+    log: unary("log", Math.log),
+    log2: unary("log2", Math.log2),
+    log10: unary("log10", Math.log10),
+    log1p: unary("log1p", Math.log1p),
+    exp: unary("exp", Math.exp),
+    expm1: unary("expm1", Math.expm1),
+    f16round: unary("f16round", Math.f16round),
+    fround: unary("fround", Math.fround),
+    clz32: unary("clz32", Math.clz32),
+    imul: binary("imul", Math.imul),
+    sumPrecise: sumPrecise(runner),
 });

package/dist/stdlib/number.d.ts

@@ -1,6 +1,4 @@
 import { type AstNode } from "../interpreter/model.js";
 export declare const numberMethods: Set<string>;
-export declare const numberConstants: Set<string>;
-export declare const numberStatics: Set<string>;
 export declare const invokeNumberMethod: (value: number, name: string, args: Array<unknown>, node: AstNode) => unknown;
-export declare const invokeNumberStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const numberGlobal: import("../interpreter/host.js").HostFunction<never>;

package/dist/stdlib/number.js

@@ -1,18 +1,8 @@
-import { InterpreterRuntimeError } from "../interpreter/model.js";
 import { toProgram } from "../data.js";
-import { coerceToString } from "./value.js";
+import { sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { coercion, coerceToString } from "./value.js";
 export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"]);
-export const numberConstants = new Set([
-    "MAX_SAFE_INTEGER",
-    "MIN_SAFE_INTEGER",
-    "MAX_VALUE",
-    "MIN_VALUE",
-    "EPSILON",
-    "NaN",
-    "POSITIVE_INFINITY",
-    "NEGATIVE_INFINITY",
-]);
-export const numberStatics = new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"]);
 export const invokeNumberMethod = (value, name, args, node) => {
     const optNum = (index) => {
         const arg = args[index];
@@ -51,27 +41,29 @@ export const invokeNumberMethod = (value, name, args, node) => {
     }
     return toProgram(result, `Number.${name} result`);
 };
-export const invokeNumberStatic = (name, args, node) => {
-    const value = args[0];
-    switch (name) {
-        case "isInteger":
-            return Number.isInteger(value);
-        case "isFinite":
-            return Number.isFinite(value);
-        case "isNaN":
-            return Number.isNaN(value);
-        case "isSafeInteger":
-            return Number.isSafeInteger(value);
-        case "parseInt": {
-            const radix = args[1];
-            if (radix !== undefined && typeof radix !== "number") {
-                throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node);
-            }
-            return parseInt(coerceToString(value), radix);
-        }
-        case "parseFloat":
-            return parseFloat(coerceToString(value));
-        default:
-            throw new InterpreterRuntimeError(`Number.${name} is not available.`, node);
+const parseIntStatic = sync("Number.parseInt", (args, node) => {
+    const radix = args[1];
+    if (radix !== undefined && typeof radix !== "number") {
+        throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node);
     }
-};
+    return parseInt(coerceToString(args[0]), radix);
+});
+export const numberGlobal = coercion("Number", {
+    instanceOf: () => false,
+    members: {
+        MAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
+        MIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,
+        MAX_VALUE: Number.MAX_VALUE,
+        MIN_VALUE: Number.MIN_VALUE,
+        EPSILON: Number.EPSILON,
+        NaN: Number.NaN,
+        POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
+        NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
+        isInteger: sync("Number.isInteger", (args) => Number.isInteger(args[0])),
+        isFinite: sync("Number.isFinite", (args) => Number.isFinite(args[0])),
+        isNaN: sync("Number.isNaN", (args) => Number.isNaN(args[0])),
+        isSafeInteger: sync("Number.isSafeInteger", (args) => Number.isSafeInteger(args[0])),
+        parseInt: parseIntStatic,
+        parseFloat: sync("Number.parseFloat", (args) => parseFloat(coerceToString(args[0]))),
+    },
+});

package/dist/stdlib/object.d.ts

@@ -1,7 +1,5 @@
-import { Effect } from "effect";
+import { HostFunction } from "../interpreter/host.js";
 import { type AstNode } from "../interpreter/model.js";
-import { type SyncIteratorRunner } from "../interpreter/iterator.js";
-export declare const objectMethodsPreservingIdentity: Set<string>;
-export declare const objectStatics: Set<string>;
-export declare const invokeObjectMethod: (name: string, args: Array<unknown>, node: AstNode) => unknown;
-export declare const invokeObjectFromEntries: <R>(runner: SyncIteratorRunner<R>, source: unknown, node: AstNode) => Effect.Effect<Record<string, unknown>, unknown, R>;
+import { type Runner } from "../interpreter/runner.js";
+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>;