functionalscript 0.38.0 → 0.40.0

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/fjs/types/string/module.f.js

@@ -18,10 +18,18 @@
 import { reduce as listReduce, repeat as listRepeat } from '../list/module.f.js';
 import { compose } from '../function/module.f.js';
 import { cmp as uCmp } from '../function/compare/module.f.js';
-import { join as joinOp, concat as concatOp } from '../function/operator/module.f.js';
+import { join as joinOp } from '../function/operator/module.f.js';
+import { fold } from '../../common/monoid/module.f.js';
+// `join`'s per-separator reduction is seeded at `''` but is *not* a monoid fold:
+// `joinOp(sep)` has no identity (`joinOp(sep)('')(x)` prepends a separator), so
+// it stays a hand-seeded `reduce` rather than going through `monoid.fold`.
 const reduce = o => listReduce(o)('');
 export const join = compose(joinOp)(reduce);
-export const concat = reduce(concatOp);
+// String concatenation with identity `''` is a lawful monoid, so `concat` is a
+// monoid fold. The operation is accumulator-first (`a` on the left), matching
+// `monoid.fold`'s convention — unlike the element-first `concat` in
+// `function/operator`, which is written for `list.reduce`.
+export const concat = fold({ identity: '', operation: a => b => a + b });
 export const repeat = v => compose(listRepeat(v))(concat);
 export const cmp = uCmp;
 export const splitAt = (p) => (v) => [v.substring(0, p), v.substring(p)];

package/fjs/website/module.f.js

@@ -5,11 +5,10 @@
  */
 import { htmlUtf8 } from '../media/html/module.f.js';
 import { writeFile } from '../effects/node/module.f.js';
-import { pure } from '../effects/module.f.js';
+import { pure, step } from '../effects/module.f.js';
 const html = htmlUtf8()(['a',
     { href: 'https://github.com/functionalscript/functionalscript' },
     'GitHub Repository'
 ]);
-const program = writeFile('index.html', html)
-    .step(() => pure(0));
+const program = step(writeFile('index.html', html), () => pure(0));
 export const main = () => program;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.38.0",
+  "version": "0.40.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.61.1",
-    "@types/node": "26.1.1",
-    "typescript": "7.0.2"
+    "@types/node": "=26.0.0",
+    "typescript": "=7.0.2"
   }
 }

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

@@ -1,19 +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_add`: a new revision, per `fjs/cas/evo`'s `AddRevision`. */
-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>[];

package/fjs/cas/evo/mcp/module.f.js

@@ -1,56 +0,0 @@
-/**
- * MCP tool definitions for the Evo API (`fjs/cas/evo/module.f.ts`): subjects
- * and revision heads over the content-addressable store, backed by the
- * in-memory cache the core module maintains.
- *
- * ## Tools
- *
- * | Tool        | args                                     | action        | result                    |
- * |-------------|-------------------------------------------|---------------|---------------------------|
- * | `evo_list`  | `{}`                                       | `e.list()`    | subjects, as a JSON array of strings |
- * | `evo_head`  | `{ subject }`                              | `e.head(...)` | head hashes, one per line |
- * | `evo_add`   | `{ parents, snapshot?, subject?, archived? }` | `e.add(...)`  | hash (cBase32)            |
- *
- * These tools are not served by their own process: `fjs/cas/mcp` (the same
- * server as `cas_add`/`cas_get`/`cas_list`) builds one `Evo<O>` from its own
- * `Cas<O>` and cache slot, concatenates `evoToolRegistry` onto its own
- * registry, and serves everything from that single process — one `~/.cas/`
- * store, one Evo cache, one server.
- *
- * @module
- */
-import { string, option, array } from '../../../types/rtti/module.f.js';
-import { pure } from '../../../effects/module.f.js';
-import {} from '../../../effects/memory/module.f.js';
-import { toolEntry, errorResult, okResult, } from '../../../mcp/module.f.js';
-import { stringify } from '../../../media/json/module.f.js';
-import { identity } from '../../../types/function/module.f.js';
-import {} from '../module.f.js';
-// ── Argument schemas (declared once, used for both inputSchema and validate) ─────
-/** Arguments for `evo_list`: none. */
-export const evoListArgs = {};
-/** Arguments for `evo_head`: the subject whose current heads are requested. */
-export const evoHeadArgs = {
-    subject: string,
-};
-/** Arguments for `evo_add`: a new revision, per `fjs/cas/evo`'s `AddRevision`. */
-export const evoAddArgs = {
-    parents: array(string),
-    snapshot: option(string),
-    subject: option(string),
-    archived: option(true),
-};
-// ── Tool registry ────────────────────────────────────────────────────────────────
-/** Canonical JSON encoder for `evo_list`'s result. */
-const toJson = stringify(identity);
-/** Registry of all Evo tools, bound to an `Evo<O>`. */
-export const evoToolRegistry = (e) => [
-    toolEntry('evo_list', 'List all subjects with at least one stored revision, as a JSON array of strings.', evoListArgs, 
-    // Subjects are arbitrary caller-supplied strings (unlike hashes, not
-    // constrained to a newline-free alphabet), so a `join('\n')` line
-    // format could not represent an empty subject or one containing a
-    // newline without ambiguity — JSON encoding can.
-    () => e.list().step(subjects => pure(okResult(toJson(subjects))))),
-    toolEntry('evo_head', 'List the current head hashes (cBase32) of a subject, one per line. Empty when the subject is unknown.', evoHeadArgs, ({ subject }) => e.head(subject).step(heads => pure(okResult(heads.join('\n'))))),
-    toolEntry('evo_add', 'Add a new revision (a `vnd.fjs.revision` blob) and return its hash (cBase32). `subject` is required unless there is exactly one parent, from which it is inherited. `snapshot`, when omitted, is resolved from the parents (zero parents → `subject`, one parent → the parent\'s snapshot; a merge requires an explicit `snapshot`) and written explicitly. `generation` is computed by the server.', evoAddArgs, (input) => e.add(input).step(result => pure(result[0] === 'error' ? errorResult(result[1]) : okResult(result[1])))),
-];

package/fjs/cas/mcp/proof.f.d.ts

@@ -1,45 +0,0 @@
-export declare const proof: {
-    getMetaLargeMultiChunkBlobNoError: () => void;
-    getMetaLargeMultiChunkUtf8Symbols: () => void;
-    getMetaLargeMultiChunkTextThenBinary: () => void;
-    getContentLargeBlobTooLargeError: () => void;
-    getContentMissingHashIsError: () => void;
-    getContentBase64InflationOverflowWritesInternalError: () => void;
-    getContentBase64NearBoundarySucceeds: () => void;
-    getContentDoubleEscapedOverflowWritesInternalError: () => void;
-    toolsListAdvertisesSixTools: () => void;
-    evoAddListHeadRoundTripsThroughCasServer: () => void;
-    evoAddDomainErrorIsErrorThroughCasServer: () => void;
-    casAddSyncsEvoCacheForRevisionContent: () => void;
-    addReturnsHash: () => void;
-    textAddGetMetaRoundTrips: () => void;
-    textAddGetContentRoundTrips: () => void;
-    binaryAddGetMetaRoundTrips: () => void;
-    binaryAddGetContentRoundTrips: () => void;
-    addGetRoundTrips: () => void;
-    getUntypedReturnsText: () => void;
-    getTypedReturnsBinaryJson: () => void;
-    getMetaRecognizesRevisionDialect: () => void;
-    getContentRecognizesRevisionDialect: () => void;
-    listEnumeratesStoredHashes: () => void;
-    addInvalidContentIsError: () => void;
-    addBadLengthContentIsError: () => void;
-    addBase64OverLimitIsError: () => void;
-    addTextOverLimitIsError: () => void;
-    addTextAtLimitSucceeds: () => void;
-    addBase64AtLimitSucceeds: () => void;
-    getUnterminatedHashIsError: () => void;
-    addMissingContentIsError: () => void;
-    getMissingHashArgumentIsError: () => void;
-    getInvalidHashIsError: () => void;
-    getMissingHashIsError: () => void;
-    unknownToolIsError: () => void;
-    toolErrorIsNotJsonRpcError: () => void;
-    getMetaReturnsLengthAndMimeType: () => void;
-    getMetaBinaryBlob: () => void;
-    getMetaOctetStreamForUnknownBinary: () => void;
-    getMetaOctetStreamForNulBlob: () => void;
-    getMetaMissingHashIsError: () => void;
-    getMetaInvalidHashIsError: () => void;
-    getOctetStreamWithContentIncludesBase64: () => void;
-};