functionalscript 0.39.0 → 0.41.0

package/fjs/protocol/mcp/proof.f.js

@@ -0,0 +1,208 @@
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { pure, step } from '../../effects/module.f.js';
+import { eff } from '../../effects/eff/module.f.js';
+import { run } from '../../effects/mock/module.f.js';
+import { asBase, asNominal, create, read } from '../../effects/memory/module.f.js';
+import { uninitializedState, mcpStep, notInitialized, } from './module.f.js';
+const initial = { next: 0, values: {} };
+const mock = {
+    memCreate: value => state => {
+        const id = `k${state.next}`;
+        const key = asNominal(id);
+        return [{ next: state.next + 1, values: { ...state.values, [id]: value } }, key];
+    },
+    memRead: key => state => [state, state.values[asBase(key)]],
+    memWrite: (key, value) => state => {
+        const id = asBase(key);
+        return [{ ...state, values: { ...state.values, [id]: value } }, undefined];
+    },
+};
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+const config = {
+    serverInfo: { name: 'test-server', version: '0.1.0' },
+    capabilities: { tools: {} },
+    protocolVersion: '2024-11-05',
+};
+const configNoTools = { ...config, capabilities: {} };
+const handlers = {
+    // Echoes a received cursor as `nextCursor` so tests can observe pagination params.
+    toolsList: (p) => pure(p.cursor === undefined
+        ? { tools: [{ name: 'greet', inputSchema: {} }] }
+        : { tools: [], nextCursor: p.cursor }),
+    toolsCall: (_p) => pure({ content: [{ type: 'text', text: 'hello' }] }),
+};
+// Run a memory effect against the mock, return the result.
+const runMem = (effect) => run(mock)(initial)(effect)[1];
+// TypeScript infers O = Operation (the upper bound) rather than O = never when
+// O flows through McpHandlers<never>, so we cast the widened type down to MemOp.
+const asMemEffect = (e) => e;
+// Run one step from uninitializedState, return [response, newState].
+const step1 = (cfg) => (msg) => runMem(asMemEffect(step(create(uninitializedState), key => step(mcpStep(cfg)(handlers)(key)(msg), resp => step(read(key), state => pure([resp, state]))))));
+// Run initialize then a second step, return [response, newState] of the second.
+const step2 = (cfg) => (msg1) => (msg2) => runMem(asMemEffect(eff(create(uninitializedState)).step(key => eff(mcpStep(cfg)(handlers)(key)(msg1)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg2)).step(resp => step(read(key), state => pure([resp, state]))).value).value).value));
+// Run initialize, notifications/initialized, then a third step; return [response, newState] of the third.
+const step3 = (cfg) => (msg1) => (msg2) => (msg3) => runMem(asMemEffect(eff(create(uninitializedState)).step(key => eff(mcpStep(cfg)(handlers)(key)(msg1)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg2)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg3)).step(resp => eff(read(key)).step(state => pure([resp, state])).value).value).value).value).value));
+// ── Test messages ─────────────────────────────────────────────────────────────
+const initMsg = { jsonrpc: '2.0', method: 'initialize', id: 1,
+    params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'client', version: '0.0.1' } } };
+const initNotif = { jsonrpc: '2.0', method: 'notifications/initialized' };
+// ── Tests ─────────────────────────────────────────────────────────────────────
+export const proof = {
+    lifecycle: {
+        initialStateIsUninitialized: () => {
+            assert(uninitializedState[0] === 'uninitialized');
+        },
+        initializeTransitionsToInitializing: () => {
+            const [, newState] = step1(config)(initMsg);
+            assert(newState[0] === 'initializing');
+        },
+        initializedNotificationTransitionsToInitialized: () => {
+            const [resp, newState] = step2(config)(initMsg)(initNotif);
+            assertEq(resp, null);
+            assert(newState[0] === 'initialized');
+        },
+        initializeReturnsResult: () => {
+            const [resp] = step1(config)(initMsg);
+            assert(resp !== null && typeof resp === 'object' && 'result' in resp);
+            const r = resp.result;
+            assertEq(r.protocolVersion, '2024-11-05');
+        },
+        initializeWithBadParamsReturnsInvalidParams: () => {
+            const bad = { jsonrpc: '2.0', method: 'initialize', id: 2, params: { wrong: true } };
+            const [resp, newState] = step1(config)(bad);
+            assert(newState[0] === 'uninitialized');
+            assertEq(resp.error.code, -32602);
+        },
+        notificationBeforeInitReturnNull: () => {
+            const [resp, newState] = step1(config)(initNotif);
+            assert(newState[0] === 'uninitialized');
+            assertEq(resp, null);
+        },
+        unknownNotificationReturnNull: () => {
+            const notif = { jsonrpc: '2.0', method: 'notifications/unknown' };
+            const [resp] = step2(config)(initMsg)(notif);
+            assertEq(resp, null);
+        },
+        doubleInitializeReturnsInvalidRequest: () => {
+            const [resp, newState] = step2(config)(initMsg)(initMsg);
+            assert(newState[0] === 'initializing');
+            assertEq(resp.error.code, -32600);
+        },
+        pingBeforeInitSucceeds: () => {
+            const msg = { jsonrpc: '2.0', method: 'ping', id: 11 };
+            const [resp, newState] = step1(config)(msg);
+            assert(newState[0] === 'uninitialized');
+            assert(!('error' in resp));
+        },
+        pingDuringInitializingSucceeds: () => {
+            const msg = { jsonrpc: '2.0', method: 'ping', id: 12 };
+            const [resp, newState] = step2(config)(initMsg)(msg);
+            assert(newState[0] === 'initializing');
+            assert(!('error' in resp));
+        },
+        pingAfterInitSucceeds: () => {
+            const msg = { jsonrpc: '2.0', method: 'ping', id: 15 };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assert(!('error' in resp));
+        },
+        pingWithObjectParamsSucceeds: () => {
+            const msg = { jsonrpc: '2.0', method: 'ping', id: 19, params: {} };
+            const [resp] = step1(config)(msg);
+            assert(!('error' in resp));
+        },
+        pingInvalidParamsReturnsInvalidParams: () => {
+            const msg = { jsonrpc: '2.0', method: 'ping', id: 20, params: 1 };
+            const [resp] = step1(config)(msg);
+            assertEq(resp.error.code, -32602);
+        },
+        initializedNotificationObjectParamsTransitions: () => {
+            const notif = { jsonrpc: '2.0', method: 'notifications/initialized', params: {} };
+            const [resp, newState] = step2(config)(initMsg)(notif);
+            assertEq(resp, null);
+            assert(newState[0] === 'initialized');
+        },
+        initializedNotificationBadParamsIgnored: () => {
+            const notif = { jsonrpc: '2.0', method: 'notifications/initialized', params: 1 };
+            const [resp, newState] = step2(config)(initMsg)(notif);
+            assertEq(resp, null);
+            assert(newState[0] === 'initializing');
+        },
+        methodBeforeInitReturnsNotInitialized: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 3 };
+            const [resp, newState] = step1(config)(msg);
+            assert(newState[0] === 'uninitialized');
+            assertEq(resp.error.code, notInitialized.code);
+        },
+        methodDuringInitializingReturnsNotInitialized: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 16 };
+            const [resp, newState] = step2(config)(initMsg)(msg);
+            assert(newState[0] === 'initializing');
+            assertEq(resp.error.code, notInitialized.code);
+        },
+        invalidEnvelopeReturnsInvalidRequest: () => {
+            const bad = { jsonrpc: '1.0', method: 'ping', id: 4 };
+            const [resp] = step1(config)(bad);
+            assertEq(resp.error.code, -32600);
+            assertEq(resp.id, null);
+        },
+    },
+    tools: {
+        toolsListSucceeds: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 5 };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assertEq(resp.result.tools.length, 1);
+            assertEq(resp.result.tools[0].name, 'greet');
+        },
+        toolsListPassesCursorToHandler: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 17,
+                params: { cursor: 'page-2' } };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assertEq(resp.result.nextCursor, 'page-2');
+        },
+        toolsListInvalidCursorReturnsInvalidParams: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 18,
+                params: { cursor: 42 } };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assertEq(resp.error.code, -32602);
+        },
+        toolsCallSucceeds: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 6,
+                params: { name: 'greet', arguments: {} } };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assertEq(resp.result.content[0].text, 'hello');
+        },
+        toolsCallBadParamsReturnsInvalidParams: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 7, params: { missing: true } };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assertEq(resp.error.code, -32602);
+        },
+        toolsCallAbsentArgumentsSucceeds: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 13,
+                params: { name: 'greet' } };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assertEq(resp.result.content[0].text, 'hello');
+        },
+        toolsCallNullArgumentsReturnsInvalidParams: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 14,
+                params: { name: 'greet', arguments: null } };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assertEq(resp.error.code, -32602);
+        },
+        toolsListWithoutCapabilityReturnsMethodNotFound: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 8 };
+            const [resp] = step3(configNoTools)(initMsg)(initNotif)(msg);
+            assertEq(resp.error.code, -32601);
+        },
+        toolsCallWithoutCapabilityReturnsMethodNotFound: () => {
+            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 9,
+                params: { name: 'greet', arguments: {} } };
+            const [resp] = step3(configNoTools)(initMsg)(initNotif)(msg);
+            assertEq(resp.error.code, -32601);
+        },
+        unknownMethodReturnsMethodNotFound: () => {
+            const msg = { jsonrpc: '2.0', method: 'resources/list', id: 10 };
+            const [resp] = step3(config)(initMsg)(initNotif)(msg);
+            assertEq(resp.error.code, -32601);
+        },
+    },
+};

package/fjs/{mcp → protocol/mcp}/stdio/module.f.d.ts

@@ -2,7 +2,7 @@
  * stdio transport for JSON-RPC / MCP servers.
  *
  * `stdioTransport` wraps a step function — the `mcpStep`-shaped
- * `(value) => Effect<O, Response | null>` from `fjs/mcp/module.f.ts` — in the
+ * `(value) => Effect<O, Response | null>` from `fjs/protocol/mcp/module.f.ts` — in the
  * canonical read → parse → dispatch → write loop, expressed as a recursive
  * effect so it stays in the pure effect model and is fully testable against a
  * mock stdin / stdout (see `fjs/effects/node/virtual`) with no real process.
@@ -29,10 +29,10 @@
  *
  * @module
  */
-import { type Effect, type Operation } from '../../effects/module.f.ts';
-import { type Read, type Write } from '../../effects/node/module.f.ts';
-import { type Unknown } from '../../media/json/module.f.ts';
-import { type Response } from '../../media/json/rpc/module.f.ts';
+import { type Effect, type Operation } from '../../../effects/module.f.ts';
+import { type Read, type Write } from '../../../effects/node/module.f.ts';
+import { type Unknown } from '../../../media/json/module.f.ts';
+import { type Response } from '../../json_rpc/module.f.ts';
 /**
  * A transport step: maps one parsed JSON-RPC message to a response, or `null`
  * for a notification that needs no reply. The shape of `mcpStep(config)(handlers)(key)`.

package/fjs/{mcp → protocol/mcp}/stdio/module.f.js

@@ -2,7 +2,7 @@
  * stdio transport for JSON-RPC / MCP servers.
  *
  * `stdioTransport` wraps a step function — the `mcpStep`-shaped
- * `(value) => Effect<O, Response | null>` from `fjs/mcp/module.f.ts` — in the
+ * `(value) => Effect<O, Response | null>` from `fjs/protocol/mcp/module.f.ts` — in the
  * canonical read → parse → dispatch → write loop, expressed as a recursive
  * effect so it stays in the pure effect model and is fully testable against a
  * mock stdin / stdout (see `fjs/effects/node/virtual`) with no real process.
@@ -29,16 +29,16 @@
  *
  * @module
  */
-import { pure, step } from '../../effects/module.f.js';
-import { readLine, write } from '../../effects/node/module.f.js';
-import { tryUtf8 } from '../../text/module.f.js';
-import { stringToList } from '../../text/utf16/module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { tokenize } from '../../media/json/tokenizer/module.f.js';
-import { parse } from '../../media/json/parser/module.f.js';
-import { sort } from '../../types/object/module.f.js';
-import { internalError, jsonrpc, parseError } from '../../media/json/rpc/module.f.js';
-import { error, ok } from '../../types/result/module.f.js';
+import { pure, step } from '../../../effects/module.f.js';
+import { readLine, write } from '../../../effects/node/module.f.js';
+import { tryUtf8 } from '../../../text/module.f.js';
+import { stringToList } from '../../../text/utf16/module.f.js';
+import { stringify } from '../../../media/json/module.f.js';
+import { tokenize } from '../../../media/json/tokenizer/module.f.js';
+import { parse } from '../../../media/json/parser/module.f.js';
+import { sort } from '../../../types/object/module.f.js';
+import { internalError, jsonrpc, parseError } from '../../json_rpc/module.f.js';
+import { error, ok } from '../../../types/result/module.f.js';
 const stringifyJson = stringify(sort);
 /** The parse-error response (`-32700`, `id: null`) for a malformed input line. */
 const parseErrorResponse = { jsonrpc, error: parseError, id: null };

package/fjs/{mcp → protocol/mcp}/stdio/proof.f.js

@@ -1,12 +1,12 @@
-import { assertEq } from '../../asserts/module.f.js';
-import { pure } from '../../effects/module.f.js';
-import { emptyState, virtual } from '../../effects/node/virtual/module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { utf8 } from '../../text/module.f.js';
-import { fromVec } from '../../types/uint8array/module.f.js';
-import { maxLengthBytes } from '../../types/bit_vec/module.f.js';
-import { sort } from '../../types/object/module.f.js';
-import { internalError, jsonrpc, parseError } from '../../media/json/rpc/module.f.js';
+import { assertEq } from '../../../asserts/module.f.js';
+import { pure } from '../../../effects/module.f.js';
+import { emptyState, virtual } from '../../../effects/node/virtual/module.f.js';
+import { stringify } from '../../../media/json/module.f.js';
+import { utf8 } from '../../../text/module.f.js';
+import { fromVec } from '../../../types/uint8array/module.f.js';
+import { maxLengthBytes } from '../../../types/bit_vec/module.f.js';
+import { sort } from '../../../types/object/module.f.js';
+import { internalError, jsonrpc, parseError } from '../../json_rpc/module.f.js';
 import { stdioTransport } from './module.f.js';
 const stringifyJson = stringify(sort);
 // Extracts the request `id` (a request has one; a notification does not).

package/fjs/types/range_map/module.f.d.ts

@@ -13,25 +13,26 @@
  * })
  *
  * // Create range maps
- * const range1 = rmOps.fromRange([0, 10])(2)
- * const range2 = rmOps.fromRange([5, 15])(5)
+ * const range1 = rmOps.fromRange(2)([0, 10])
+ * const range2 = rmOps.fromRange(5)([5, 15])
  *
  * // Merge range maps
  * const merged = toArray(rmOps.merge(range1)(range2))
  *
  * // Retrieve values from the merged range map
+ * const get = rmOps.get(merged)
  * //
- * if (rmOps.get(-1)(merged) !== 0) { throw 'error' }
+ * if (get(-1) !== 0) { throw 'error' }
  * //
- * if (rmOps.get(0)(merged) !== 2) { throw 'error' }
- * if (rmOps.get(2)(merged) !== 2) { throw 'error' }
+ * if (get(0) !== 2) { throw 'error' }
+ * if (get(2) !== 2) { throw 'error' }
  * // overlapped: 2 | 5 = 7
- * if (rmOps.get(7)(merged) !== 7) { throw 'error' }
+ * if (get(7) !== 7) { throw 'error' }
  * //
- * if (rmOps.get(12)(merged) !== 5) { throw 'error' }
- * if (rmOps.get(15)(merged) !== 5) { throw 'error' }
+ * if (get(12) !== 5) { throw 'error' }
+ * if (get(15) !== 5) { throw 'error' }
  * //
- * if (rmOps.get(16)(merged) !== 0) { throw 'error' }
+ * if (get(16) !== 0) { throw 'error' }
  * ```
  */
 import { type SortedList } from '../sorted_list/module.f.ts';
@@ -63,8 +64,8 @@ export type Properties<T> = {
 };
 export type RangeMerge<T> = Reduce<RangeMap<T>>;
 export declare const merge: <T>(op: Properties<T>) => RangeMerge<T>;
-export declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
-export declare const fromRange: <T>(def: T) => (r: Range) => (value: T) => RangeMapArray<T>;
+export declare const get: <T>(def: T) => (rm: RangeMapArray<T>) => (value: number) => T;
+export declare const fromRange: <T>(def: T) => (value: T) => (r: Range) => RangeMapArray<T>;
 /**
  * Represents a set of operations for managing range maps.
  */
@@ -76,11 +77,11 @@ export type RangeMapOp<T> = {
     /**
      * Retrieves the value associated with a given numeric range.
      */
-    readonly get: (value: number) => (rm: RangeMapArray<T>) => T;
+    readonly get: (rm: RangeMapArray<T>) => (value: number) => T;
     /**
      * Constructs a range map for a single numeric range and value.
      */
-    readonly fromRange: (r: Range) => (value: T) => RangeMapArray<T>;
+    readonly fromRange: (value: T) => (r: Range) => RangeMapArray<T>;
 };
 /**
  * Creates a set of operations for managing range maps using the specified properties.

package/fjs/types/range_map/module.f.js

@@ -13,25 +13,26 @@
  * })
  *
  * // Create range maps
- * const range1 = rmOps.fromRange([0, 10])(2)
- * const range2 = rmOps.fromRange([5, 15])(5)
+ * const range1 = rmOps.fromRange(2)([0, 10])
+ * const range2 = rmOps.fromRange(5)([5, 15])
  *
  * // Merge range maps
  * const merged = toArray(rmOps.merge(range1)(range2))
  *
  * // Retrieve values from the merged range map
+ * const get = rmOps.get(merged)
  * //
- * if (rmOps.get(-1)(merged) !== 0) { throw 'error' }
+ * if (get(-1) !== 0) { throw 'error' }
  * //
- * if (rmOps.get(0)(merged) !== 2) { throw 'error' }
- * if (rmOps.get(2)(merged) !== 2) { throw 'error' }
+ * if (get(0) !== 2) { throw 'error' }
+ * if (get(2) !== 2) { throw 'error' }
  * // overlapped: 2 | 5 = 7
- * if (rmOps.get(7)(merged) !== 7) { throw 'error' }
+ * if (get(7) !== 7) { throw 'error' }
  * //
- * if (rmOps.get(12)(merged) !== 5) { throw 'error' }
- * if (rmOps.get(15)(merged) !== 5) { throw 'error' }
+ * if (get(12) !== 5) { throw 'error' }
+ * if (get(15) !== 5) { throw 'error' }
  * //
- * if (rmOps.get(16)(merged) !== 0) { throw 'error' }
+ * if (get(16) !== 0) { throw 'error' }
  * ```
  */
 import { genericMerge } from '../sorted_list/module.f.js';
@@ -59,11 +60,15 @@ const tailReduce = equal => state => tail => {
     return { first: state, tail: tailResult };
 };
 export const merge = op => genericMerge({ reduceOp: reduceOp(op), tailReduce: tailReduce(op.equal) })(null);
-export const get = def => value => rm => {
-    const pos = bsearch(rm.length)(mid => value <= rm[mid][1] ? -1 : 1);
-    return pos < rm.length ? rm[pos][0] : def;
+export const get = def => rm => {
+    const length = rm.length;
+    const search = bsearch(length);
+    return value => {
+        const pos = search(mid => value <= rm[mid][1] ? -1 : 1);
+        return pos < length ? rm[pos][0] : def;
+    };
 };
-export const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]];
+export const fromRange = def => v => ([a, b]) => [[def, a - 1], [v, b]];
 /**
  * Creates a set of operations for managing range maps using the specified properties.
  *

package/fjs/types/range_map/proof.f.js

@@ -20,23 +20,24 @@ export const proof = {
             def: 0,
         });
         // Create range maps
-        const range1 = rmOps.fromRange([0, 10])(2);
-        const range2 = rmOps.fromRange([5, 15])(5);
+        const range1 = rmOps.fromRange(2)([0, 10]);
+        const range2 = rmOps.fromRange(5)([5, 15]);
         // Merge range maps
         const merged = toArray(rmOps.merge(range1)(range2));
         // Retrieve values from the merged range map
         //
-        assertEq(rmOps.get(-1)(merged), 0, 'error');
+        const get = rmOps.get(merged);
+        assertEq(get(-1), 0, 'error');
         //
-        assertEq(rmOps.get(0)(merged), 2, 'error');
-        assertEq(rmOps.get(2)(merged), 2, 'error');
+        assertEq(get(0), 2, 'error');
+        assertEq(get(2), 2, 'error');
         // 2 | 5 = 7
-        assertEq(rmOps.get(7)(merged), 7, 'error');
+        assertEq(get(7), 7, 'error');
         //
-        assertEq(rmOps.get(12)(merged), 5, 'error');
-        assertEq(rmOps.get(15)(merged), 5, 'error');
+        assertEq(get(12), 5, 'error');
+        assertEq(get(15), 5, 'error');
         //
-        assertEq(rmOps.get(16)(merged), 0, 'error');
+        assertEq(get(16), 0, 'error');
     },
     merge: [
         () => {
@@ -95,70 +96,56 @@ export const proof = {
         return [
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(5)(rm));
+                const result = str(at(rm)(5));
                 assertEq(result, '["a"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(10)(rm));
+                const result = str(at(rm)(10));
                 assertEq(result, '["a"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(15)(rm));
+                const result = str(at(rm)(15));
                 assertEq(result, '["b"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(20)(rm));
+                const result = str(at(rm)(20));
                 assertEq(result, '["b"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(25)(rm));
+                const result = str(at(rm)(25));
                 assertEq(result, '["c"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(30)(rm));
+                const result = str(at(rm)(30));
                 assertEq(result, '["c"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(35)(rm));
+                const result = str(at(rm)(35));
                 assertEq(result, '[]');
             },
             () => {
                 const rm = [];
-                const result = str(at(10)(rm));
+                const result = str(at(rm)(10));
                 assertEq(result, '[]');
             }
         ];
     },
     fromRange: () => {
         const def = -1;
-        const rm = fromRange(def)([1, 7])(42);
+        const rm = fromRange(def)(42)([1, 7]);
+        const g = get(def)(rm);
         return [
-            () => {
-                const result = get(def)(0)(rm);
-                assertEq(result, -1);
-            },
-            () => {
-                const result = get(def)(1)(rm);
-                assertEq(result, 42);
-            },
-            () => {
-                const result = get(def)(3)(rm);
-                assertEq(result, 42);
-            },
-            () => {
-                const result = get(def)(7)(rm);
-                assertEq(result, 42);
-            },
-            () => {
-                const result = get(def)(9)(rm);
-                assertEq(result, -1);
-            },
+            () => assertEq(g(0), -1),
+            () => assertEq(g(1), 42),
+            () => assertEq(g(3), 42),
+            () => assertEq(g(7), 42),
+            () => assertEq(g(9), -1),
         ];
-    }
+    },
 };

package/fjs/types/range_set/module.f.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Constructs a range set containing a single numeric range.
+ */
+export declare const fromRange: (r: import("../range/module.f.ts").Range) => import("../range_map/module.f.ts").RangeMapArray<boolean>;
+export declare const merge: import("../range_map/module.f.ts").RangeMerge<boolean>, get: (rm: import("../range_map/module.f.ts").RangeMapArray<boolean>) => (value: number) => boolean;

package/fjs/types/range_set/module.f.js

@@ -0,0 +1,16 @@
+/**
+ * A set of numeric ranges, represented as a `range_map` of `boolean`.
+ *
+ * @module
+ */
+import { rangeMap } from '../range_map/module.f.js';
+const map = rangeMap({
+    union: a => b => a || b,
+    equal: a => b => a === b,
+    def: false,
+});
+/**
+ * Constructs a range set containing a single numeric range.
+ */
+export const fromRange = map.fromRange(true);
+export const { merge, get } = map;

package/fjs/types/range_set/proof.f.d.ts

@@ -0,0 +1 @@
+export declare const proof: () => void;

package/fjs/types/range_set/proof.f.js

@@ -0,0 +1,19 @@
+import { assert } from "../../asserts/module.f.js";
+import { toArray } from "../list/module.f.js";
+import { fromRange, merge, get } from "./module.f.js";
+import {} from '../range/module.f.js';
+const c = (a) => a.charCodeAt(0);
+const range = ([a, b]) => [c(a), c(b)];
+export const proof = () => {
+    const digit = fromRange(range('09'));
+    const initial = toArray(merge(fromRange(range('AZ')))(fromRange(range('az'))));
+    const isInitial = get(initial);
+    assert(!isInitial(0));
+    assert(isInitial(c('a')));
+    assert(!isInitial(c('1')));
+    assert(isInitial(c('Z')));
+    const isNext = get(toArray(merge(initial)(digit)));
+    assert(isNext(c('0')));
+    assert(isNext(c('A')));
+    assert(!isNext(c('@')));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -13,7 +13,8 @@
     "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts",
     "start": "node ./fjs/module.ts",
     "ci-update": "node ./fjs/module.ts ci",
-    "update": "npx npm-check-updates -u && npm install && deno install && bun install && npm run ci-update",
+    "dev-update": "node ./fjs/module.ts r ./fjs/dev/update/module.f.ts",
+    "update": "npm run ci-update && npm install && deno install && bun install",
     "index-html": "node ./fjs/module.ts r ./fjs/website/module.f.ts",
     "website": "npm run prepack && npm run index-html"
   },
@@ -43,8 +44,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@playwright/test": "1.62.0",
-    "@types/node": "26.1.2",
-    "typescript": "7.0.2"
+    "@types/node": "=26.0.0",
+    "typescript": "=7.0.2"
   }
 }

package/fjs/cas/evo/mcp/module.f.d.ts

@@ -1,27 +0,0 @@
-import { type Operation } from '../../../effects/module.f.ts';
-import { type MemOp } from '../../../effects/memory/module.f.ts';
-import { type ToolEntry } from '../../../mcp/module.f.ts';
-import { type Evo } from '../module.f.ts';
-/** Arguments for `evo_list`: none. */
-export declare const evoListArgs: {};
-/** Arguments for `evo_head`: the subject whose current heads are requested. */
-export declare const evoHeadArgs: {
-    readonly subject: import("../../../types/rtti/module.f.ts").String;
-};
-/** Arguments for `evo_revision`: the hash of the revision to read. */
-export declare const evoRevisionArgs: {
-    readonly hash: import("../../../types/rtti/module.f.ts").String;
-};
-/**
- * Arguments for `evo_add`: a new revision, per `fjs/cas/evo`'s
- * `RevisionData` — every field of it the caller supplies, i.e. all but
- * `generation`, which the server computes.
- */
-export declare const evoAddArgs: {
-    readonly parents: import("../../../types/rtti/module.f.ts").Type1<"array", import("../../../types/rtti/module.f.ts").String>;
-    readonly snapshot: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").String, undefined]>;
-    readonly subject: import("../../../types/rtti/module.f.ts").Or<readonly [import("../../../types/rtti/module.f.ts").String, undefined]>;
-    readonly archived: import("../../../types/rtti/module.f.ts").Or<readonly [true, undefined]>;
-};
-/** Registry of all Evo tools, bound to an `Evo<O>`. */
-export declare const evoToolRegistry: <O extends Operation>(e: Evo<O>) => readonly ToolEntry<O | MemOp>[];