functionalscript 0.11.0 → 0.11.2

package/cas/module.f.d.ts

@@ -8,16 +8,37 @@ import type { Vec } from "../types/bit_vec/module.f.ts";
 import { type Effect, type Operation } from "../types/effects/module.f.ts";
 import { type Fs, type NodeOp } from "../types/effects/node/module.f.ts";
 export type KvStore<O extends Operation> = {
+    /** Reads a value by key; returns `undefined` when the key does not exist. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
+    /** Writes a key/value pair to the underlying storage. */
     readonly write: (key: Vec, value: Vec) => Effect<O, void>;
+    /** Lists all keys available in the store. */
     readonly list: () => Effect<O, readonly Vec[]>;
 };
+/** A key/value tuple where index `0` is the key and index `1` is the value. */
 export type Kv = readonly [Vec, Vec];
+/**
+ * Creates a filesystem-backed key/value store under the provided root path.
+ */
 export declare const fileKvStore: (path: string) => KvStore<Fs>;
 export type Cas<O extends Operation> = {
+    /** Reads content by hash; returns `undefined` when not found. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
+    /** Stores content and returns its computed hash. */
     readonly write: (value: Vec) => Effect<O, Vec>;
+    /** Lists all stored content hashes. */
     readonly list: () => Effect<O, readonly Vec[]>;
 };
+/**
+ * Builds a content-addressable storage facade from a SHA-2 implementation.
+ */
 export declare const cas: (sha2: Sha2) => <O extends Operation>(_: KvStore<O>) => Cas<O>;
+/**
+ * Runs the CAS CLI.
+ *
+ * Supported subcommands:
+ * - `add <path>`: stores file content and prints the hash.
+ * - `get <hash> <path>`: restores content by hash into a file.
+ * - `list`: prints all known hashes.
+ */
 export declare const main: (args: readonly string[]) => Effect<NodeOp, number>;

package/cas/module.f.js

@@ -13,12 +13,16 @@ import { unwrap } from "../types/result/module.f.js";
 const o = { withFileTypes: true };
 const split = (s) => [s.substring(0, 2), s.substring(2)];
 const prefix = '.cas';
+/** Converts a content key to its sharded relative CAS file path. */
 const toPath = (key) => {
     const s = vecToCBase32(key);
     const [a, bc] = split(s);
     const [b, c] = split(bc);
     return `${prefix}/${a}/${b}/${c}`;
 };
+/**
+ * Creates a filesystem-backed key/value store under the provided root path.
+ */
 export const fileKvStore = (path) => ({
     read: (key) => begin
         .step(() => readFile(toPath(key)))
@@ -41,6 +45,9 @@ export const fileKvStore = (path) => ({
         ? cBase32ToVec(parentPath.substring(prefix.length).replaceAll('/', '') + name)
         : null)))),
 });
+/**
+ * Builds a content-addressable storage facade from a SHA-2 implementation.
+ */
 export const cas = (sha2) => {
     const compute = computeSync(sha2);
     return ({ read, write, list }) => ({
@@ -54,9 +61,18 @@ export const cas = (sha2) => {
         list,
     });
 };
+/** Prints an error message and returns exit code `1`. */
 const e = (s) => begin
     .step(() => error(s))
     .step(() => pure(1));
+/**
+ * Runs the CAS CLI.
+ *
+ * Supported subcommands:
+ * - `add <path>`: stores file content and prints the hash.
+ * - `get <hash> <path>`: restores content by hash into a file.
+ * - `list`: prints all known hashes.
+ */
 export const main = (args) => {
     const c = cas(sha256)(fileKvStore('.'));
     const [cmd, ...options] = args;

package/crypto/sha2/module.f.d.ts

@@ -7,7 +7,9 @@ import type { Array16, Array8 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 import type { Fold } from '../../types/function/operator/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
+/** 8-word SHA-2 state vector. */
 export type V8 = Array8<bigint>;
+/** 16-word SHA-2 message schedule chunk. */
 export type V16 = Array16<bigint>;
 /**
  * Type definition for the state of the SHA-2 algorithm.
@@ -75,8 +77,16 @@ export type Sha2 = {
      */
     readonly end: (state: State) => Vec;
 };
+/**
+ * Computes a SHA-2 hash from a list of message chunks.
+ *
+ * @param sha2 A SHA-2 algorithm configuration.
+ * @returns A function that hashes the full list of chunks.
+ */
 export declare const computeSync: ({ append, init, end }: Sha2) => (list: List<Vec>) => Vec;
+/** 32-bit SHA-2 base configuration shared by SHA-224 and SHA-256. */
 export declare const base32: Base;
+/** 64-bit SHA-2 base configuration shared by SHA-384, SHA-512, SHA-512/224 and SHA-512/256. */
 export declare const base64: Base;
 /** SHA-256 */
 export declare const sha256: Sha2;

package/crypto/sha2/module.f.js

@@ -167,10 +167,17 @@ const sha2 = ({ append, end, chunkLength }, hash, hashLength) => ({
     append,
     end: end(hashLength),
 });
+/**
+ * Computes a SHA-2 hash from a list of message chunks.
+ *
+ * @param sha2 A SHA-2 algorithm configuration.
+ * @returns A function that hashes the full list of chunks.
+ */
 export const computeSync = ({ append, init, end }) => {
     const f = fold(append)(init);
     return (list) => end(f(list));
 };
+/** 32-bit SHA-2 base configuration shared by SHA-224 and SHA-256. */
 export const base32 = base({
     logBitLen: 5n,
     k: [
@@ -196,6 +203,7 @@ export const base32 = base({
     ss0: [7n, 18n, 3n],
     ss1: [17n, 19n, 10n],
 });
+/** 64-bit SHA-2 base configuration shared by SHA-384, SHA-512, SHA-512/224 and SHA-512/256. */
 export const base64 = base({
     logBitLen: 6n,
     k: [

package/crypto/sign/module.f.d.ts

@@ -14,10 +14,25 @@ export type All = {
     readonly int2octets: (x: bigint) => Vec;
     readonly bits2octets: (b: Vec) => Vec;
 };
+/**
+ * Builds RFC6979 helper conversions for a subgroup order.
+ *
+ * @param q - Subgroup order.
+ * @returns Conversion helpers used by deterministic nonce generation.
+ */
 export declare const all: (q: bigint) => All;
+/**
+ * Builds RFC6979 helper conversions from curve parameters.
+ */
 export declare const fromCurve: (c: Curve) => All;
 export declare const concat: (...x: readonly Vec[]) => Vec;
+/**
+ * Computes deterministic ECDSA nonce `k` as described by RFC6979.
+ */
 export declare const computeK: (_: All) => (_: Sha2) => (x: bigint) => (m: Vec) => bigint;
 type Signature = Array2<bigint>;
+/**
+ * Signs a message bit vector and returns an ECDSA `(r, s)` signature pair.
+ */
 export declare const sign: (c: Curve) => (hf: Sha2) => (x: bigint) => (m: Vec) => Signature;
 export {};

package/crypto/sign/module.f.js

@@ -5,6 +5,12 @@ import { computeSync } from "../sha2/module.f.js";
 // qlen to rlen
 const roundUp8 = roundUp(8n);
 const divUp8 = divUp(8n);
+/**
+ * Builds RFC6979 helper conversions for a subgroup order.
+ *
+ * @param q - Subgroup order.
+ * @returns Conversion helpers used by deterministic nonce generation.
+ */
 export const all = (q) => {
     const qlen = bitLength(q);
     const bits2int = (b) => {
@@ -22,11 +28,17 @@ export const all = (q) => {
         bits2octets: b => int2octets(bits2int(b) % q),
     };
 };
+/**
+ * Builds RFC6979 helper conversions from curve parameters.
+ */
 export const fromCurve = (c) => all(c.nf.p);
 const x01 = vec8(0x01n);
 const x00 = vec8(0x00n);
 const ltov = listToVec(msb);
 export const concat = (...x) => ltov(x);
+/**
+ * Computes deterministic ECDSA nonce `k` as described by RFC6979.
+ */
 export const computeK = ({ q, bits2int, qlen, int2octets, bits2octets }) => hf => {
     // TODO: Look at https://www.rfc-editor.org/rfc/rfc6979#section-3.3 to reformulate
     //       it using `HMAC_DRBG`.
@@ -96,6 +108,9 @@ export const computeK = ({ q, bits2int, qlen, int2octets, bits2octets }) => hf =
         }
     };
 };
+/**
+ * Signs a message bit vector and returns an ECDSA `(r, s)` signature pair.
+ */
 export const sign = (c) => (hf) => (x) => (m) => {
     // 2.4 Signature Generation
     const { nf: { p: q, div }, g } = c;

package/dev/index/module.f.d.ts

@@ -0,0 +1,2 @@
+import { index4 } from '../module.f.ts';
+export default index4;

package/dev/index/module.f.js

@@ -0,0 +1,2 @@
+import { index4 } from "../module.f.js";
+export default index4;

package/dev/module.f.d.ts

@@ -4,7 +4,7 @@
  * @module
  */
 import { type Io } from '../io/module.f.ts';
-import { type All, type Readdir } from '../types/effects/node/module.f.ts';
+import { type All, type NodeProgram, type Readdir } from '../types/effects/node/module.f.ts';
 import { type Effect } from '../types/effects/module.f.ts';
 export declare const todo: () => never;
 export type Module = {
@@ -15,6 +15,5 @@ export type ModuleMap = {
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
 export declare const allFiles2: (s: string) => Effect<Readdir | All, readonly string[]>;
-export declare const allFiles: (io: Io) => (s: string) => Promise<readonly string[]>;
 export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
-export declare const index: (io: Io) => Promise<number>;
+export declare const index4: NodeProgram;

package/dev/module.f.js

@@ -5,8 +5,7 @@
  */
 import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
-import { encodeUtf8 } from "../types/uint8array/module.f.js";
-import { all, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { all, both, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 import { begin, pure } from "../types/effects/module.f.js";
@@ -45,31 +44,7 @@ export const allFiles2 = (s) => {
         .step(v => pure(v.flat()));
     return load(s);
 };
-export const allFiles = (io) => (s) => {
-    const { fs: { promises: { readdir } } } = io;
-    const load = async (p) => {
-        let result = [];
-        for (const i of await readdir(p, { withFileTypes: true })) {
-            const { name } = i;
-            if (name.startsWith('.')) {
-                continue;
-            }
-            const file = `${p}/${name}`;
-            if (i.isDirectory()) {
-                if (name === 'node_modules') {
-                    continue;
-                }
-                result = [...result, ...await load(file)];
-                continue;
-            }
-            if (name.endsWith('.js') || name.endsWith('.ts')) {
-                result = [...result, file];
-            }
-        }
-        return result;
-    };
-    return load(s);
-};
+const allFiles = (io) => (s) => fromIo(io)(allFiles2(s));
 export const loadModuleMap = async (io) => {
     const { fs: { existsSync }, asyncImport } = io;
     let map = [];
@@ -89,19 +64,17 @@ const index2 = begin
     .step(() => updateVersion)
     .step(() => readFile(denoJson))
     .step(v => pure(JSON.parse(utf8ToString(unwrap(v)))));
-const allFiles2a = (jsr_json) => begin
+const allFiles2aa = begin
     .step(() => allFiles2('.'))
     .step(files => {
-    // console.log(files)
     const list = files.filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
     const exportsA = list.map(v => [v, `./${v.substring(2)}`]);
-    const exports = Object.fromEntries(exportsA);
+    return pure(Object.fromEntries(exportsA));
+});
+const index3 = both(index2)(allFiles2aa)
+    .step(([jsr_json, exports]) => {
     const json = JSON.stringify({ ...jsr_json, exports }, null, 2);
     return writeFile(denoJson, utf8(json));
 })
     .step(() => pure(0));
-export const index = async (io) => {
-    const runner = fromIo(io);
-    const jsr_json = await runner(index2);
-    return await runner(allFiles2a(jsr_json));
-};
+export const index4 = () => index3;

package/html/module.f.d.ts

@@ -2,12 +2,30 @@ import { type List } from '../types/list/module.f.ts';
 type Tag = string;
 type Element1 = readonly [Tag, ...Node[]];
 type Element2 = readonly [Tag, Attributes, ...Node[]];
+/**
+ * A FunctionalScript representation of an HTML element.
+ *
+ * - `[tag, ...children]` for elements without attributes.
+ * - `[tag, attributes, ...children]` for elements with attributes.
+ */
 export type Element = Element1 | Element2;
 type Attributes = {
     readonly [k in string]: string;
 };
 export type Node = Element | string;
+/**
+ * Converts a FunctionalScript element into a list of HTML string chunks.
+ *
+ * Chunks are returned instead of a single string to support composition with
+ * other list/string helpers in this codebase.
+ */
 export declare const element: (e: Element) => List<string>;
+/**
+ * Builds a complete HTML document by prepending `<!DOCTYPE html>`.
+ */
 export declare const html: (_: Element) => List<string>;
+/**
+ * Renders an HTML element tree to a final string.
+ */
 export declare const htmlToString: (_: Element) => string;
 export {};

package/html/module.f.js

@@ -62,6 +62,12 @@ const parseElement = (e) => {
             [tag, item1, list] :
             [tag, {}, [item1, ...list]];
 };
+/**
+ * Converts a FunctionalScript element into a list of HTML string chunks.
+ *
+ * Chunks are returned instead of a single string to support composition with
+ * other list/string helpers in this codebase.
+ */
 export const element = (e) => {
     const [tag, a, n] = parseElement(e);
     const open = flat([[`<`, tag], attributes(a), [`>`]]);
@@ -70,5 +76,11 @@ export const element = (e) => {
     }
     return flat([open, rawText.includes(tag) ? [rawMap(n)] : nodes(n), ['</', tag, '>']]);
 };
+/**
+ * Builds a complete HTML document by prepending `<!DOCTYPE html>`.
+ */
 export const html = compose(element)(listConcat(['<!DOCTYPE html>']));
+/**
+ * Renders an HTML element tree to a final string.
+ */
 export const htmlToString = compose(html)(stringConcat);

package/io/module.f.d.ts

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { NodeOp } from '../types/effects/node/module.f.ts';
+import type { NodeOp, RequestListener } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -79,6 +79,12 @@ export type Process = {
     readonly stderr: Writable;
 };
 export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
+export type Server = {
+    readonly listen: (port: number) => void;
+};
+export type Https = {
+    readonly createServer: (_: RequestListener) => Server;
+};
 /**
  * Core IO operations interface providing access to system resources
  */
@@ -91,6 +97,7 @@ export type Io = {
     readonly fetch: (url: string) => Promise<Response>;
     readonly tryCatch: TryCatch;
     readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
+    readonly https: Https;
 };
 /**
  * The environment variables.
@@ -106,4 +113,4 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }: Io) => EffectToPromise;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, https: { createServer }, }: Io) => EffectToPromise;

package/io/module.f.js

@@ -1,7 +1,8 @@
 import { todo } from "../dev/module.f.js";
 import { normalize } from "../path/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import {} from "../types/effects/module.f.js";
 import { asyncRun } from "../types/effects/module.js";
+import { asBase, asNominal } from "../types/nominal/module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec, toVec } from "../types/uint8array/module.f.js";
 /**
@@ -28,9 +29,9 @@ const tc = async (f) => {
         return error(e);
     }
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }) => {
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, https: { createServer }, }) => {
     const result = asyncRun({
-        all: async (effects) => await Promise.all(effects.map(v => result(v))),
+        all: async (effects) => await Promise.all(effects.map(result)),
         error: async (message) => error(message),
         log: async (message) => log(message),
         fetch: async (url) => tc(async () => {
@@ -45,6 +46,14 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
         readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
             .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
         writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
+        createServer: async (requestListener) => {
+            const server = asNominal(createServer(requestListener));
+            return server;
+        },
+        listen: async ([server, port]) => {
+            const s = asBase(server);
+            s.listen(port);
+        },
     });
     return result;
 };

package/io/module.js

@@ -6,6 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import https from 'node:https';
 import { fromIo, run } from "./module.f.js";
 import fs from 'node:fs';
 import process from "node:process";
@@ -39,6 +40,7 @@ export const io = {
             return error(e);
         }
     },
+    https
 };
 export const legacyRun = run(io);
 export const ioRun = (io) => {

package/io/virtual/module.f.js

@@ -1,4 +1,5 @@
 import { at } from "../../types/ordered_map/module.f.js";
+import { todo } from "../../dev/module.f.js";
 export const createVirtualIo = (files) => ({
     console: {
         log: (..._d) => { },
@@ -33,4 +34,7 @@ export const createVirtualIo = (files) => ({
     fetch: () => Promise.reject(),
     tryCatch: f => ['ok', f()],
     asyncTryCatch: async (f) => ['ok', await f()],
+    https: {
+        createServer: todo
+    }
 });

package/json/parser/module.f.d.ts

@@ -7,4 +7,10 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import { type JsonToken } from '../tokenizer/module.f.ts';
 import { type Unknown } from '../module.f.ts';
+/**
+ * Parses a list of JSON tokens into a JSON-compatible value.
+ *
+ * Returns `ok` with the parsed value on success, or `error` with a message
+ * when the token sequence is invalid or incomplete.
+ */
 export declare const parse: (tokenList: List<JsonToken>) => Result<Unknown, string>;

package/json/parser/module.f.js

@@ -156,6 +156,12 @@ const foldOp = token => state => {
         case '{,': return parseObjectCommaOp(token)(state);
     }
 };
+/**
+ * Parses a list of JSON tokens into a JSON-compatible value.
+ *
+ * Returns `ok` with the parsed value on success, or `error` with a message
+ * when the token sequence is invalid or incomplete.
+ */
 export const parse = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList);
     switch (state.status) {

package/json/serializer/module.f.d.ts

@@ -4,9 +4,21 @@
  * @module
  */
 import { type List } from '../../types/list/module.f.ts';
+/**
+ * Serializes a string as a JSON string literal.
+ */
 export declare const stringSerialize: (_: string) => List<string>;
+/**
+ * Serializes a number as a JSON number literal.
+ */
 export declare const numberSerialize: (_: number) => List<string>;
+/**
+ * Shared serialized representation for `null`.
+ */
 export declare const nullSerialize: string[];
 export declare const boolSerialize: (_: boolean) => List<string>;
 export declare const objectWrap: (input: List<List<string>>) => List<string>;
+/**
+ * Wraps serialized entries into a JSON array.
+ */
 export declare const arrayWrap: (input: List<List<string>>) => List<string>;

package/json/serializer/module.f.js

@@ -7,8 +7,17 @@ import { flat, reduce, empty } from "../../types/list/module.f.js";
 import {} from "../../types/object/module.f.js";
 import {} from "../../types/function/operator/module.f.js";
 const jsonStringify = JSON.stringify;
+/**
+ * Serializes a string as a JSON string literal.
+ */
 export const stringSerialize = input => [jsonStringify(input)];
+/**
+ * Serializes a number as a JSON number literal.
+ */
 export const numberSerialize = input => [jsonStringify(input)];
+/**
+ * Shared serialized representation for `null`.
+ */
 export const nullSerialize = ['null'];
 const trueSerialize = ['true'];
 const falseSerialize = ['false'];
@@ -22,4 +31,7 @@ const wrap = open => close => {
     return input => flat([seqOpen, join(input), seqClose]);
 };
 export const objectWrap = wrap('{')('}');
+/**
+ * Wraps serialized entries into a JSON array.
+ */
 export const arrayWrap = wrap('[')(']');

package/json/tokenizer/module.f.d.ts

@@ -5,4 +5,11 @@ export type JsonToken = {
 } | {
     readonly kind: '{' | '}' | ':' | ',' | '[' | ']';
 } | StringToken | NumberToken | ErrorToken | EofToken;
+/**
+ * Converts a stream of UTF-8 bytes into JSON tokens.
+ *
+ * The tokenizer accepts only JSON-compatible JavaScript tokens, ignores
+ * whitespace/newline tokens, and reports invalid token sequences as
+ * `{ kind: 'error' }` tokens.
+ */
 export declare const tokenize: (input: List<number>) => List<JsonToken>;

package/json/tokenizer/module.f.js

@@ -50,6 +50,13 @@ const scanToken = state => input => {
         default: return parseDefaultState(input);
     }
 };
+/**
+ * Converts a stream of UTF-8 bytes into JSON tokens.
+ *
+ * The tokenizer accepts only JSON-compatible JavaScript tokens, ignores
+ * whitespace/newline tokens, and reports invalid token sequences as
+ * `{ kind: 'error' }` tokens.
+ */
 export const tokenize = (input) => {
     const jsTokens = jsTokenize(input)('');
     return flat(stateScan(scanToken)({ kind: 'def' })(concat(jsTokens)([null])));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "type": "module",
   "files": [
     "**/*.js",
@@ -11,7 +11,7 @@
     "prepack": "tsc --NoEmit false",
     "test20": "npm run prepack && node --test",
     "test": "tsc && node --test --experimental-strip-types --experimental-test-coverage --test-coverage-include=**/module.f.ts",
-    "index": "node ./dev/index/module.ts",
+    "index": "node ./fjs/module.ts r ./dev/index/module.f.ts",
     "fst": "node ./fjs/module.ts t",
     "fjs": "node ./fjs/module.ts",
     "ci-update": "node ./fjs/module.ts r ./ci/module.f.ts",

package/path/module.f.d.ts

@@ -4,6 +4,19 @@
  * @module
  */
 import type { Reduce, Unary } from "../types/function/operator/module.f.ts";
+/**
+ * Splits a path into normalized segments.
+ *
+ * Empty (`""`) and current-directory (`"."`) segments are removed, parent-directory
+ * (`".."`) segments collapse the previous segment when possible, and Windows
+ * separators are converted to POSIX separators.
+ */
 export declare const parse: (path: string) => readonly string[];
+/**
+ * Normalizes a path string by parsing and rejoining it with POSIX separators.
+ */
 export declare const normalize: Unary<string, string>;
+/**
+ * Concatenates two path fragments and returns a normalized path.
+ */
 export declare const concat: Reduce<string>;

package/path/module.f.js

@@ -21,14 +21,27 @@ const foldNormalizeOp = input => state => {
         }
     }
 };
+/**
+ * Splits a path into normalized segments.
+ *
+ * Empty (`""`) and current-directory (`"."`) segments are removed, parent-directory
+ * (`".."`) segments collapse the previous segment when possible, and Windows
+ * separators are converted to POSIX separators.
+ */
 export const parse = (path) => {
     const split = path.replaceAll('\\', '/').split('/');
     return toArray(fold(foldNormalizeOp)([])(split));
 };
+/**
+ * Normalizes a path string by parsing and rejoining it with POSIX separators.
+ */
 export const normalize = path => {
     const foldResult = parse(path);
     return join('/')(foldResult);
 };
+/**
+ * Concatenates two path fragments and returns a normalized path.
+ */
 export const concat = a => b => {
     const s = stringConcat([a, '/', b]);
     return normalize(s);

package/text/ascii/module.f.d.ts

@@ -1,5 +1,12 @@
+/**
+ * Provides ASCII code point constants and helpers for creating numeric code points and inclusive ranges.
+ *
+ * @module
+ */
 import type { Range } from '../../types/range/module.f.ts';
+/** Returns the code point value of the first character in a string. */
 export declare const one: (s: string) => number;
+/** Returns an inclusive code point range from the first two characters in a string. */
 export declare const range: (s: string) => Range;
 /** 0x08 */
 export declare const backspace: number;

package/text/ascii/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Provides ASCII code point constants and helpers for creating numeric code points and inclusive ranges.
+ *
+ * @module
+ */
 const at = (s) => (i) => {
     const r = s.codePointAt(i);
     if (r === void 0) {
@@ -5,7 +10,9 @@ const at = (s) => (i) => {
     }
     return r;
 };
+/** Returns the code point value of the first character in a string. */
 export const one = (s) => at(s)(0);
+/** Returns an inclusive code point range from the first two characters in a string. */
 export const range = (s) => {
     const f = at(s);
     const f0 = f(0);

package/text/sgr/module.f.d.ts

@@ -1,3 +1,9 @@
+/**
+ * ANSI Control Sequence Introducer (CSI) and Select Graphic Rendition (SGR)
+ * helpers for writing formatted terminal output and TTY-aware console streams.
+ *
+ * @module
+ */
 import type { Io, Writable } from "../../io/module.f.ts";
 export declare const backspace: string;
 type End = 'm';

package/text/sgr/module.f.js

@@ -1,5 +1,9 @@
-// Co control codes
-// https://en.wikipedia.org/wiki/ANSI_escape_code#C0_control_codes
+/**
+ * ANSI Control Sequence Introducer (CSI) and Select Graphic Rendition (SGR)
+ * helpers for writing formatted terminal output and TTY-aware console streams.
+ *
+ * @module
+ */
 export const backspace = '\x08';
 const begin = '\x1b[';
 /**

package/types/effects/module.f.js

@@ -13,68 +13,3 @@ export const doFull = (cmd, param, cont) => ({
 });
 export const do_ = (cmd) => (param) => doFull(cmd, param, pure);
 export const begin = pure(undefined);
-//----------------------------------------------------------------------
-/*
-export type Operations = {
-    readonly [command in string]: readonly [input: unknown, output: unknown]
-}
-
-export type Effect<O extends Operations, T> = Pure<O, T> | Do<O, T>
-
-export type Pure<O, T> = readonly [T]
-
-export type One<O extends Operations, T, K extends keyof O & string> =
-    readonly [K, O[K][0], (input: O[K][1]) => Effect<O, T>]
-
-export type Do<O extends Operations, T> = { readonly [K in keyof O & string]: One<O, T, K> }[keyof O & string]
-
-export const pure = <O extends Operations, T>(value: T): Pure<O, T> => [value]
-
-const doFull = <O extends Operations, K extends keyof O & string, T>(
-    cmd: K,
-    payload: O[K][0],
-    cont: (input: O[K][1]) => Effect<O, T>
-): Do<O, T> =>
-    [cmd, payload, cont]
-
-export const do_ = <O extends Operations, K extends keyof O & string>(
-    cmd: K,
-    payload: O[K][0]
-): Do<O, O[K][1]> =>
-    doFull(cmd, payload, pure)
-
-export type ToAsyncOperationMap<O extends Operations> = {
-    readonly [K in keyof O]: (payload: O[K][0]) => Promise<O[K][1]>
-}
-
-export const step =
-    <O extends Operations, T>(e: Effect<O, T>) =>
-    <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>): Effect<O | O1, R> =>
-{
-    if (e.length === 1) {
-        const [value] = e
-        return f(value)
-    }
-    const [cmd, payload, cont] = e
-    return doFull(cmd, payload, x => step(cont(x))(f))
-}
-
-export const map =
-    <O extends Operations, T>(e: Effect<O, T>) =>
-    <R>(f: (_: T) => R): Effect<O, R> =>
-    step(e)(x => pure(f(x)))
-
-export type Fluent<O extends Operations, T> = {
-    readonly effect: Effect<O, T>
-    readonly step: <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Fluent<O | O1, R>
-}
-
-const wrap = <O extends Operations, T>(effect: Effect<O, T>): Fluent<O, T> => ({
-    effect,
-    step: x => wrap(step(effect)(x)),
-})
-
-export const fluent: Fluent<{}, void> = wrap(pure(undefined))
-
-const empty: Effect<{}, readonly never[]> = pure([])
-*/

package/types/effects/node/module.f.d.ts

@@ -1,4 +1,5 @@
 import type { Vec } from '../../bit_vec/module.f.ts';
+import type { Nominal } from '../../nominal/module.f.ts';
 import type { Result } from '../../result/module.f.ts';
 import { type Effect, type Func, type Operation, type ToAsyncOperationMap } from '../module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
@@ -11,6 +12,7 @@ export type All = ['all', <T>(_: readonly Effect<never, T>[]) => readonly T[]];
  * @returns
  */
 export declare const all: <O extends Operation, T>(...a: readonly Effect<O, T>[]) => Effect<O | All, readonly T[]>;
+export declare const both: <O0 extends Operation, T0>(a: Effect<O0, T0>) => <O1 extends Operation, T1>(b: Effect<O1, T1>) => Effect<O0 | O1 | All, readonly [T0, T1]>;
 export type Fetch = ['fetch', (_: string) => IoResult<Vec>];
 export declare const fetch: Func<Fetch>;
 export type MakeDirectoryOptions = {
@@ -45,7 +47,15 @@ export declare const error: Func<Error>;
 export type Log = ['log', (_: string) => void];
 export declare const log: Func<Log>;
 export type Console = Log | Error;
-export type NodeOp = All | Fetch | Console | Fs;
+export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
+export type IncomingMessage = {};
+export type ServerResponse = {};
+export type RequestListener = (_: IncomingMessage) => ServerResponse;
+export type CreateServer = ['createServer', (_: RequestListener) => Server];
+export declare const createServer: Func<CreateServer>;
+export type Listen = ['listen', (_: readonly [Server, number]) => void];
+export type Http = CreateServer | Listen;
+export type NodeOp = All | Fetch | Console | Fs | Http;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 export type NodeProgram = (argv: readonly string[]) => Effect<NodeOp, number>;

package/types/effects/node/module.f.js

@@ -6,10 +6,8 @@ import { do_ } from "../module.f.js";
  * @param a
  * @returns
  */
-export const all = (...a) => {
-    const result = do_('all')(a);
-    return result;
-};
+export const all = (...a) => do_('all')(a);
+export const both = (a) => (b) => all(a, b);
 export const fetch = do_('fetch');
 export const mkdir = (...p) => do_('mkdir')(p);
 export const readFile = do_('readFile');
@@ -17,3 +15,4 @@ export const readdir = (...p) => do_('readdir')(p);
 export const writeFile = (...p) => do_('writeFile')(p);
 export const error = do_('error');
 export const log = do_('log');
+export const createServer = do_('createServer');

package/types/effects/node/virtual/module.f.js

@@ -3,11 +3,11 @@
  *
  * @module
  */
+import { todo } from "../../../../dev/module.f.js";
 import { parse } from "../../../../path/module.f.js";
 import { isVec } from "../../../bit_vec/module.f.js";
 import { error, ok } from "../../../result/module.f.js";
 import { run } from "../../mock/module.f.js";
-import { pure } from "../../module.f.js";
 export const emptyState = {
     stdout: '',
     stderr: '',
@@ -115,5 +115,7 @@ const map = {
     readFile,
     readdir: (state, [path, { recursive }]) => readdir(path, recursive === true)(state, path),
     writeFile: (state, [path, payload]) => writeFile(payload)(state, path),
+    createServer: todo,
+    listen: todo,
 };
 export const virtual = run(map);

package/types/nominal/module.f.d.ts

@@ -3,8 +3,20 @@
  *
  * @module
  */
+/**
+ * Nominal type.
+ *
+ * It doesn't allow `===` between different nominal types.
+ * It doesn't allow `<`, `>`, `<=`, `>=` comparisons at all.
+ */
 export type Nominal<N extends string, R extends string, B> = symbol & {
     [k in N]: readonly [R, B];
 };
+/**
+ * note: It should compiles into `identity` and no-ops at runtime.
+ */
 export declare const asNominal: <N extends string, R extends string, B>(b: B) => Nominal<N, R, B>;
+/**
+ * note: It should compiles into `identity` and no-ops at runtime.
+ */
 export declare const asBase: <T extends string, R extends string, B>(n: Nominal<T, R, B>) => B;

package/types/nominal/module.f.js

@@ -1,4 +1,13 @@
-/// note: It should compiles into `identity` and no-ops at runtime.
+/**
+ * Nominal typing helpers for branded TypeScript types.
+ *
+ * @module
+ */
+/**
+ * note: It should compiles into `identity` and no-ops at runtime.
+ */
 export const asNominal = (b) => b;
-/// note: It should compiles into `identity` and no-ops at runtime.
+/**
+ * note: It should compiles into `identity` and no-ops at runtime.
+ */
 export const asBase = (n) => n;

package/dev/index/module.d.ts

@@ -1 +0,0 @@
-export {};

package/dev/index/module.js

@@ -1,3 +0,0 @@
-import { index } from "../module.f.js";
-import { legacyRun } from "../../io/module.js";
-legacyRun(index);