functionalscript 0.43.1 → 0.44.0

package/fjs/path/proof.f.js

@@ -1,119 +0,0 @@
-import { concat, isProperPrefix, join, normalize, relativize, toPosix } from "./module.f.js";
-import { assertEq } from '../asserts/module.f.js';
-const normalizeTest = [
-    () => {
-        const norm = normalize("dir/file.json");
-        assertEq(norm, "dir/file.json");
-    },
-    () => {
-        const norm = normalize("dir//file.json");
-        assertEq(norm, "dir/file.json");
-    },
-    () => {
-        const norm = normalize("../../dir/file.json");
-        assertEq(norm, "../../dir/file.json");
-    },
-    () => {
-        const norm = normalize("../../dir/../file.json");
-        assertEq(norm, "../../file.json");
-    },
-];
-const concatTest = [
-    () => {
-        const c = concat("a")("b");
-        assertEq(c, "a/b");
-    },
-    () => {
-        const c = concat("a///b/")("c");
-        assertEq(c, "a/b/c");
-    },
-    () => {
-        const c = concat("a/../b/..")("c");
-        assertEq(c, "c");
-    },
-];
-const joinTest = [
-    () => {
-        const r = join('a', 'b');
-        assertEq(r, 'a/b');
-    },
-    () => {
-        const r = join('/abs/root', 'x');
-        assertEq(r, '/abs/root/x');
-    },
-    () => {
-        const r = join('a', 'b', 'c', 'd');
-        assertEq(r, 'a/b/c/d');
-    },
-    () => {
-        const r = join('', 'x');
-        assertEq(r, '/x');
-    },
-    () => {
-        const r = join();
-        assertEq(r, '');
-    },
-    () => {
-        const r = join('only');
-        assertEq(r, 'only');
-    },
-];
-const relativizeTest = [
-    () => {
-        const r = relativize('/repo', '/repo/fs/a.ts');
-        assertEq(r, './fs/a.ts');
-    },
-    () => {
-        const r = relativize('/repo', '/other/a.ts');
-        assertEq(r, '/other/a.ts');
-    },
-    () => {
-        const r = relativize('', './fs/a.ts');
-        assertEq(r, './fs/a.ts');
-    },
-];
-const toPosixTest = [
-    () => {
-        const p = toPosix('a\\b\\c');
-        assertEq(p, 'a/b/c');
-    },
-    () => {
-        const p = toPosix('a/b/c');
-        assertEq(p, 'a/b/c');
-    },
-    () => {
-        const p = toPosix('C:\\Users\\x');
-        assertEq(p, 'C:/Users/x');
-    },
-    () => {
-        const p = toPosix('');
-        assertEq(p, '');
-    },
-];
-const isProperPrefixTest = [
-    () => {
-        const r = isProperPrefix(['a', 'b'], ['a', 'b', 'c']);
-        assertEq(r, true);
-    },
-    () => {
-        const r = isProperPrefix(['a', 'b'], ['a', 'b']);
-        assertEq(r, false);
-    },
-    () => {
-        const r = isProperPrefix(['a', 'x'], ['a', 'b', 'c']);
-        assertEq(r, false);
-    },
-    () => {
-        const r = isProperPrefix(['a', 'b', 'c'], ['a', 'b']);
-        assertEq(r, false);
-    },
-    () => {
-        const r = isProperPrefix([], ['a']);
-        assertEq(r, true);
-    },
-    () => {
-        const r = isProperPrefix([], []);
-        assertEq(r, false);
-    },
-];
-export const proof = { normalizeTest, concatTest, joinTest, relativizeTest, toPosixTest, isProperPrefixTest };

package/fjs/proof.f.js

@@ -1,38 +0,0 @@
-import { assert, assertEq } from './asserts/module.f.js';
-import { pure } from './effects/module.f.js';
-import { defaultNodeProgramOptions, emptyState, virtual } from './effects/node/virtual/module.f.js';
-import { main } from './module.f.js';
-const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
-const run = (root) => (args) => virtual({ ...emptyState, root })(main(makeOptions(args)));
-const appMain = ({ args }) => pure(args.length);
-export const proof = {
-    help: () => {
-        const [state, code] = run({})(['help']);
-        assertEq(code, 0);
-        assert(state.stdout.includes('compile'), 'expected command list in stdout');
-    },
-    compileRequiresArgs: () => {
-        const [state, code] = run({})(['compile']);
-        assertEq(code, 1);
-        assert(state.stderr.length !== 0, 'expected error in stderr');
-    },
-    runModule: () => {
-        const root = { 'app.f.ts': () => ({ main: appMain }) };
-        const [, code] = run(root)(['run', 'app.f.ts', 'x', 'y']);
-        // `run` strips the command and file name, so `main` sees two arguments
-        assertEq(code, 2);
-    },
-    mcp: () => {
-        // stdin is empty in the virtual environment, so the server sees EOF
-        // immediately and shuts down cleanly, exercising the `mcp` handler.
-        // The store is empty too, so `casMcpServer`'s Evo cache scan
-        // (`initEvo`) also runs and finds nothing.
-        const [, code] = run({})(['mcp']);
-        assertEq(code, 0);
-    },
-    throw: {
-        runImportError: () => {
-            run({})(['run', 'missing.f.ts']);
-        },
-    },
-};

package/fjs/protocol/json_rpc/module.f.d.ts

@@ -1,114 +0,0 @@
-import type { Ts } from '../../types/rtti/ts/module.f.ts';
-import type { Result } from '../../types/result/module.f.ts';
-import { unknown, type Unknown } from '../../media/json/module.f.ts';
-export declare const jsonrpc: '2.0';
-/** Request/response identifier: a string, a number, or `null`. */
-declare const id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
-/**
- * A request or notification envelope. `id` present → request (a response is
- * expected); `id` absent → notification (no response). `params` is optional.
- *
- * https://www.jsonrpc.org/specification#request_object
- */
-export declare const request: {
-    readonly jsonrpc: "2.0";
-    readonly method: import("../../types/rtti/module.f.ts").String;
-    readonly params: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-    readonly id: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>, undefined]>;
-};
-/** The JSON-RPC error object. */
-export declare const error: {
-    readonly code: import("../../types/rtti/module.f.ts").Number;
-    readonly message: import("../../types/rtti/module.f.ts").String;
-    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-};
-export type Id = Ts<typeof id>;
-export type Request = Ts<typeof request>;
-export type RpcError = Ts<typeof error>;
-export declare const successResponse: {
-    readonly jsonrpc: "2.0";
-    readonly result: typeof unknown;
-    readonly id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
-};
-export declare const errorResponse: {
-    readonly jsonrpc: "2.0";
-    readonly error: {
-        readonly code: import("../../types/rtti/module.f.ts").Number;
-        readonly message: import("../../types/rtti/module.f.ts").String;
-        readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-    };
-    readonly id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
-};
-/**
- * A response envelope: either a success (`result`) or an error (`error`).
- * Derived from the rtti schema via `Ts<>` — the same declaration is the
- * runtime decoder and the static type, with no drift. rtti structs are open
- * (extra keys allowed), so "result XOR error" is not enforced at runtime; in
- * practice the dispatcher only ever constructs one or the other.
- *
- * https://www.jsonrpc.org/specification#response_object
- */
-export declare const response: import("../../types/rtti/module.f.ts").Or<[{
-    readonly jsonrpc: "2.0";
-    readonly result: typeof unknown;
-    readonly id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
-}, {
-    readonly jsonrpc: "2.0";
-    readonly error: {
-        readonly code: import("../../types/rtti/module.f.ts").Number;
-        readonly message: import("../../types/rtti/module.f.ts").String;
-        readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-    };
-    readonly id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
-}]>;
-export type Response = Ts<typeof response>;
-/** Decodes an untrusted value as a JSON-RPC request / notification. */
-export declare const decodeRequest: import("../../types/rtti/common/module.f.ts").Validate<{
-    readonly jsonrpc: "2.0";
-    readonly method: import("../../types/rtti/module.f.ts").String;
-    readonly params: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-    readonly id: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>, undefined]>;
-}>;
-/** A method implementation: maps `params` to a result or an `RpcError`. */
-export type Handler = (params: Unknown | undefined) => Result<Unknown, RpcError>;
-/** A `method` name → `Handler` map. */
-export type Handlers = {
-    readonly [method: string]: Handler;
-};
-/** Builds an `RpcError` with the given `code` and `message` (no `data`). */
-export declare const rpcError: (code: number) => (message: string) => RpcError;
-export declare const parseError: import("../../types/rtti/ts/module.f.ts").StructTs<{
-    readonly code: import("../../types/rtti/module.f.ts").Number;
-    readonly message: import("../../types/rtti/module.f.ts").String;
-    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-}>;
-export declare const invalidRequest: import("../../types/rtti/ts/module.f.ts").StructTs<{
-    readonly code: import("../../types/rtti/module.f.ts").Number;
-    readonly message: import("../../types/rtti/module.f.ts").String;
-    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-}>;
-export declare const methodNotFound: import("../../types/rtti/ts/module.f.ts").StructTs<{
-    readonly code: import("../../types/rtti/module.f.ts").Number;
-    readonly message: import("../../types/rtti/module.f.ts").String;
-    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-}>;
-export declare const invalidParams: import("../../types/rtti/ts/module.f.ts").StructTs<{
-    readonly code: import("../../types/rtti/module.f.ts").Number;
-    readonly message: import("../../types/rtti/module.f.ts").String;
-    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-}>;
-export declare const internalError: import("../../types/rtti/ts/module.f.ts").StructTs<{
-    readonly code: import("../../types/rtti/module.f.ts").Number;
-    readonly message: import("../../types/rtti/module.f.ts").String;
-    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [typeof unknown, undefined]>;
-}>;
-/**
- * Dispatches an already-parsed JSON-RPC value against `handlers`.
- *
- * - invalid envelope → `Invalid Request` (`-32600`) with `id: null`
- * - notification (no `id`) → `null` (never a response)
- * - unknown method → `Method not found` (`-32601`)
- * - otherwise the handler's `ok` / `error` result becomes a success / error response
- */
-export declare const dispatch: (handlers: Handlers) => (value: Unknown) => Response | null;
-export {};

package/fjs/protocol/json_rpc/module.f.js

@@ -1,89 +0,0 @@
-/**
- * JSON-RPC 2.0 envelopes and a pure dispatcher.
- *
- * The envelopes are rtti schemas, so one declaration yields both a runtime
- * decoder (`validate(request)`) and the static type (`Ts<typeof request>`) — no
- * drift between them. The dispatcher is pure: it maps an already-parsed request
- * value to a response value (or `null` for a notification) and performs no I/O.
- *
- * Out of scope here (follow-ups): transports — stdio / HTTP framing — over
- * `fjs/effects/node`, and concrete method sets such as MCP (i665-mcp), which layer
- * on top of `dispatch`.
- *
- * https://www.jsonrpc.org/specification
- *
- * @module
- */
-import { number, string, or, option } from '../../types/rtti/module.f.js';
-import { validate } from '../../types/rtti/validate/module.f.js';
-import { unknown } from '../../media/json/module.f.js';
-export const jsonrpc = '2.0';
-/** Request/response identifier: a string, a number, or `null`. */
-const id = or(string, number, null);
-/**
- * A request or notification envelope. `id` present → request (a response is
- * expected); `id` absent → notification (no response). `params` is optional.
- *
- * https://www.jsonrpc.org/specification#request_object
- */
-export const request = {
-    jsonrpc,
-    method: string,
-    params: option(unknown),
-    id: option(id),
-};
-/** The JSON-RPC error object. */
-export const error = {
-    code: number,
-    message: string,
-    data: option(unknown),
-};
-export const successResponse = { jsonrpc, result: unknown, id };
-export const errorResponse = { jsonrpc, error, id };
-/**
- * A response envelope: either a success (`result`) or an error (`error`).
- * Derived from the rtti schema via `Ts<>` — the same declaration is the
- * runtime decoder and the static type, with no drift. rtti structs are open
- * (extra keys allowed), so "result XOR error" is not enforced at runtime; in
- * practice the dispatcher only ever constructs one or the other.
- *
- * https://www.jsonrpc.org/specification#response_object
- */
-export const response = or(successResponse, errorResponse);
-/** Decodes an untrusted value as a JSON-RPC request / notification. */
-export const decodeRequest = validate(request);
-/** Builds an `RpcError` with the given `code` and `message` (no `data`). */
-export const rpcError = (code) => (message) => ({ code, message });
-// The standard JSON-RPC 2.0 errors.
-export const parseError = rpcError(-32700)('Parse error');
-export const invalidRequest = rpcError(-32600)('Invalid Request');
-export const methodNotFound = rpcError(-32601)('Method not found');
-export const invalidParams = rpcError(-32602)('Invalid params');
-export const internalError = rpcError(-32603)('Internal error');
-const errorResponseOf = (id) => (error) => ({ jsonrpc, error, id });
-/**
- * Dispatches an already-parsed JSON-RPC value against `handlers`.
- *
- * - invalid envelope → `Invalid Request` (`-32600`) with `id: null`
- * - notification (no `id`) → `null` (never a response)
- * - unknown method → `Method not found` (`-32601`)
- * - otherwise the handler's `ok` / `error` result becomes a success / error response
- */
-export const dispatch = (handlers) => (value) => {
-    const [t, message] = decodeRequest(value);
-    if (t === 'error') {
-        return errorResponseOf(null)(invalidRequest);
-    }
-    const { id, method, params } = message;
-    if (id === undefined) {
-        return null;
-    }
-    const handler = handlers[method];
-    if (handler === undefined) {
-        return errorResponseOf(id)(methodNotFound);
-    }
-    const [t2, result] = handler(params);
-    return t2 === 'ok'
-        ? { jsonrpc, result, id }
-        : errorResponseOf(id)(result);
-};

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

@@ -1,68 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { ok, error } from '../../types/result/module.f.js';
-import { validate } from '../../types/rtti/validate/module.f.js';
-import { error as errorSchema, decodeRequest, dispatch, rpcError, parseError, invalidRequest, methodNotFound, invalidParams, internalError, } from './module.f.js';
-const isOk = (r) => r[0] === 'ok';
-const handlers = {
-    ping: () => ok('pong'),
-    echo: params => ok(params ?? null),
-    boom: () => error(invalidParams),
-};
-const d = dispatch(handlers);
-export const proof = {
-    schema: {
-        request: {
-            full: () => assert(isOk(decodeRequest({ jsonrpc: '2.0', method: 'm', params: [1], id: 1 }))),
-            notification: () => assert(isOk(decodeRequest({ jsonrpc: '2.0', method: 'm' }))),
-            nullId: () => assert(isOk(decodeRequest({ jsonrpc: '2.0', method: 'm', id: null }))),
-            stringId: () => assert(isOk(decodeRequest({ jsonrpc: '2.0', method: 'm', id: 'abc' }))),
-            badVersion: () => assert(!isOk(decodeRequest({ jsonrpc: '1.0', method: 'm', id: 1 }))),
-            missingMethod: () => assert(!isOk(decodeRequest({ jsonrpc: '2.0', id: 1 }))),
-            badId: () => assert(!isOk(decodeRequest({ jsonrpc: '2.0', method: 'm', id: true }))),
-            notObject: () => assert(!isOk(decodeRequest(42))),
-        },
-        error: {
-            ok: () => assert(isOk(validate(errorSchema)({ code: -1, message: 'x' }))),
-            withData: () => assert(isOk(validate(errorSchema)({ code: -1, message: 'x', data: [1, 2] }))),
-            missingMessage: () => assert(!isOk(validate(errorSchema)({ code: -1 }))),
-        },
-    },
-    errors: {
-        factory: () => {
-            const e = rpcError(-7)('boom');
-            assertEq(e.code, -7);
-            assertEq(e.message, 'boom');
-        },
-        parseError: () => { assertEq(parseError.code, -32700); assertEq(parseError.message, 'Parse error'); },
-        invalidRequest: () => { assertEq(invalidRequest.code, -32600); assertEq(invalidRequest.message, 'Invalid Request'); },
-        methodNotFound: () => { assertEq(methodNotFound.code, -32601); assertEq(methodNotFound.message, 'Method not found'); },
-        invalidParams: () => { assertEq(invalidParams.code, -32602); assertEq(invalidParams.message, 'Invalid params'); },
-        internalError: () => { assertEq(internalError.code, -32603); assertEq(internalError.message, 'Internal error'); },
-    },
-    dispatch: {
-        success: () => {
-            const r = d({ jsonrpc: '2.0', method: 'ping', id: 1 });
-            assert(r !== null && 'result' in r && r.result === 'pong' && r.id === 1);
-        },
-        paramsPassed: () => {
-            const r = d({ jsonrpc: '2.0', method: 'echo', params: 'hi', id: 2 });
-            assert(r !== null && 'result' in r && r.result === 'hi');
-        },
-        handlerError: () => {
-            const r = d({ jsonrpc: '2.0', method: 'boom', id: 3 });
-            assert(r !== null && 'error' in r && r.error.code === -32602 && r.id === 3);
-        },
-        methodNotFound: () => {
-            const r = d({ jsonrpc: '2.0', method: 'nope', id: 4 });
-            assert(r !== null && 'error' in r && r.error.code === -32601);
-        },
-        invalidRequest: () => {
-            const r = d({ jsonrpc: '1.0', method: 'ping', id: 5 });
-            assert(r !== null && 'error' in r && r.error.code === -32600 && r.id === null);
-        },
-        notification: () => {
-            const r = d({ jsonrpc: '2.0', method: 'ping' });
-            assertEq(r, null);
-        },
-    },
-};