functionalscript 0.44.0 → 0.46.0

package/fjs/types/rtti/ts/types.d.ts

@@ -1,3 +1,14 @@
+/**
+ * TypeScript type transformers for RTTI schemas.
+ *
+ * Each `*Ts` type maps a schema (or schema fragment) to its corresponding TypeScript type.
+ * The main entry point is `Ts<T>`.
+ *
+ * The runtime `toTs` function (`printer` in `./module.f.mjs`) mirrors `Ts<T>` at value
+ * level, returning a TypeScript type expression string for a given RTTI schema.
+ *
+ * @module
+ */
 import type { Tag0, Tag1, Struct, Tuple, Type } from '../types.ts';
 import type { phantomKey } from '../../phantom/types.ts';
 import type { StringMap } from '../../object/types.ts';
@@ -40,7 +51,20 @@ export type ArrayTs<T extends Type> = ReadonlyArray<Ts<T>>;
 export type RecordTs<T extends Type> = {
     readonly [K in string]?: Ts<T>;
 };
-/** Maps a tuple schema to a readonly tuple of resolved types. */
+/**
+ * Maps a tuple schema to a readonly tuple of resolved types.
+ *
+ * **The commented-out line is the accurate mapping.** A tuple schema is *open*
+ * — a longer array is a member of the set it describes (see "Structs and
+ * tuples are open" in `../README.md`) — and the open form below says so. It is
+ * commented out because TypeScript could not handle it, so this renders the
+ * closed approximation instead.
+ *
+ * That is a limitation of this renderer, **not** a statement about the value
+ * model. Do not cite the exact mapping as evidence that tuples are closed and
+ * add a length check to `../parse/module.f.mjs`; that inference is what
+ * produced #1622.
+ */
 export type TupleTs<T extends Tuple> = {
     readonly [K in keyof T]: Ts<T[K]>;
 };

package/fjs/types/rtti/types.d.ts

@@ -1,3 +1,43 @@
+/**
+ * Type-level API for runtime type information (RTTI) — a type-safe schema
+ * system for describing and converting TypeScript types.
+ *
+ * ## Core concepts
+ *
+ * A `Type` is either a `Const` (used directly as its own schema) or a `Thunk`
+ * (a zero-argument function returning an `Info` descriptor). Thunks are the
+ * primary building block: they enable lazy evaluation and recursive type definitions.
+ *
+ * ```
+ * Type = Const | Thunk
+ * Thunk = () => Info
+ * Info = ['const', Const] | Info0<Tag0> | Info1<Tag1, Type>
+ * ```
+ *
+ * ## Nullary schemas (no type parameter)
+ *
+ * `boolean`, `number`, `string`, `bigint`, `unknown` are pre-built `Thunk` values
+ * that describe primitive types. Each is a `_Type0<Tag0>` — a thunk returning a
+ * single-element tag tuple.
+ *
+ * ## Unary schemas (one type parameter)
+ *
+ * `array(t)` and `record(t)` construct `Thunk` values parameterized by an inner
+ * `Type`. They return `Type1` thunks wrapping an `Info1` tuple.
+ *
+ * ## Const schemas
+ *
+ * Any `Primitive`, `Struct` (plain object), or `Tuple` (readonly array) can be
+ * used directly as a schema — it describes exactly the shape of that value.
+ * Inside a recursive `Thunk`-based definition, wrap consts with `() => ['const', c]`
+ * to keep the schema uniform.
+ *
+ * ## Converting to TypeScript types
+ *
+ * See `./ts/module.f.ts` for `Ts<T>` and the `*Ts` transformer types.
+ *
+ * @module
+ */
 import type { StringMap } from '../object/types.ts';
 import type { tag0List } from './module.f.mjs';
 /** A constant schema: a primitive literal, a struct object, or a tuple. */

package/fjs/types/sorted_list/module.f.d.mts

@@ -2,12 +2,15 @@
  * Sorted immutable list helpers and merge operations.
  *
  * @module
+ *
+ * @import { Cmp } from '../function/compare/types.ts'
+ * @import { List } from '../list/types.ts'
+ * @import { ReduceOp, SortedList, _MergeReduce } from './types.ts'
  */
 import type { Cmp } from '../function/compare/types.ts';
 import type { List } from '../list/types.ts';
 import type { ReduceOp, SortedList, _MergeReduce } from './types.ts';
 export type _SortedArray<T> = readonly T[];
-/** @import { ReduceOp, SortedList, TailReduce, _MergeReduce } from './types.ts' */
 /** @template T @typedef {readonly T[]} _SortedArray */
 /**
  * Two-way sorted-list merge.

package/fjs/types/sorted_list/module.f.mjs

@@ -2,14 +2,15 @@
  * Sorted immutable list helpers and merge operations.
  *
  * @module
+ *
+ * @import { Cmp } from '../function/compare/types.ts'
+ * @import { List } from '../list/types.ts'
+ * @import { ReduceOp, SortedList, _MergeReduce } from './types.ts'
  */
 
 import { bsearch } from '../function/compare/module.f.mjs'
-/** @import { Cmp } from '../function/compare/types.ts' */
 import { next } from '../list/module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 import { identity } from '../function/module.f.mjs'
-/** @import { ReduceOp, SortedList, TailReduce, _MergeReduce } from './types.ts' */
 
 /** @template T @typedef {readonly T[]} _SortedArray */
 
@@ -53,11 +54,7 @@ export const merge =
      * @param {Cmp<T>} cmp
      * @returns {(a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>}
      */
-    cmp => {
-        /** @type {TailReduce<T, null>} */
-        const tailReduce = mergeTail
-        return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null)
-    }
+    cmp => genericMerge({ reduceOp: cmpReduce(cmp), tailReduce: keepTail })(null)
 
 const cmpReduce =
     /**
@@ -70,10 +67,22 @@ const cmpReduce =
         return [sign === 1 ? b : a, sign, null]
     }
 
-/** @type {() => <T>(tail: List<T>) => List<T>} */
-const mergeTail = () => identity
+/**
+ * The two tail policies `genericMerge` takes, named for what they do with the
+ * list that has not been exhausted yet: `merge` keeps it, because everything
+ * still there belongs in the union, and `intersect` drops it, because with one
+ * side exhausted nothing remaining can be matched.
+ *
+ * Both are left to inference deliberately. An explicit
+ * `() => <T>(tail: List<T>) => List<T>` compiles here but introduces its own
+ * type parameter, which `genericMerge` then collects as an inference candidate
+ * alongside `reduceOp`'s; the best common supertype of the two is `unknown`, so
+ * `T` widens and both call sites fail to match their declared return type. With
+ * no annotation there is no second candidate and `reduceOp` alone fixes `T`.
+ */
+const keepTail = () => identity
 
-const tailReduce = () => () => null
+const dropTail = () => () => null
 
 const intersectReduce =
     /**
@@ -92,7 +101,7 @@ export const intersect =
      * @param {Cmp<T>} cmp
      * @returns {(a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>}
      */
-    cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce })(null)
+    cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce: dropTail })(null)
 
 export const find =
     /**

package/fjs/types/sorted_list/proof.f.d.mts

@@ -1,4 +1,6 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ */
 export declare const proof: {
     sortedMergre: (() => void)[];
     find: (() => void)[];

package/fjs/types/sorted_list/proof.f.mjs

@@ -1,4 +1,6 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ */
 
 import { find, merge } from './module.f.mjs'
 import { stringify } from '../../media/json/module.f.mjs'

package/fjs/types/sorted_set/module.f.d.mts

@@ -1,6 +1,36 @@
+/**
+ * A sorted set, implemented as a sorted array.
+ *
+ * @module
+ *
+ * @note
+ *
+ * All input arrays must be pre-sorted according to the provided comparison function (`Cmp<T>`).
+ * The correctness of these functions depend on this requirement.
+ *
+ * @example
+ *
+ * ```js
+ * import { union, intersect, has } from './module.f.mjs'
+ *
+ * const cmp = (a: number) => (b: number) => a < b ? -1 : a > b ? 1 : 0
+ *
+ * const setA = [1, 3, 5]
+ * const setB = [3, 4, 5]
+ *
+ * const unionSet = union(cmp)(setA)(setB) // [1, 3, 4, 5]
+ *
+ * const intersectionSet = intersect(cmp)(setA)(setB) // [3, 5]
+ *
+ * has(cmp)(3)(setA) // true
+ * has(cmp)(2)(setA) // false
+ * ```
+ *
+ * @import { Cmp } from '../function/compare/types.ts'
+ * @import { SortedSet } from './types.ts'
+ */
 import type { Cmp } from '../function/compare/types.ts';
 import type { SortedSet } from './types.ts';
-/** @import { SortedSet } from './types.ts' */
 export declare const union: <T>(
 /**
  * @template T
@@ -22,3 +52,21 @@ export declare const has: <T>(
  * @returns {(value: T) => (set: SortedSet<T>) => boolean}
  */
 cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;
+/**
+ * A canonical key for a set of strings: equal sets always produce the same
+ * key, and unequal sets never produce the same one. Useful wherever a set has
+ * to index a `StringMap` — the subset construction in `fjs/fsm`, say.
+ *
+ * Each element is written length-prefixed (`3:abc`) and the parts are
+ * concatenated. Joining on a separator would **not** be canonical: elements
+ * are arbitrary strings, so `['a,b']` and `['a', 'b']` would both produce
+ * `a,b` and two different sets would share one key. A length prefix is
+ * readable back — take the digits, the `:`, then exactly that many code
+ * units — so the encoding is injective without an escaping table.
+ *
+ * The key is canonical for the *set* only because `SortedSet` is sorted:
+ * element order is fixed by the set's own invariant, not by this function.
+ *
+ * @type {(set: SortedSet<string>) => string}
+ */
+export declare const toKey: (set: SortedSet<string>) => string;

package/fjs/types/sorted_set/module.f.mjs

@@ -25,11 +25,13 @@
  * has(cmp)(3)(setA) // true
  * has(cmp)(2)(setA) // false
  * ```
+ *
+ * @import { Cmp } from '../function/compare/types.ts'
+ * @import { SortedSet } from './types.ts'
  */
-/** @import { Cmp } from '../function/compare/types.ts' */
+
 import { toArray } from "../list/module.f.mjs"
 import { merge, intersect as listIntersect, find } from '../sorted_list/module.f.mjs'
-/** @import { SortedSet } from './types.ts' */
 
 export const union =
     /**
@@ -54,3 +56,25 @@ export const has =
      * @returns {(value: T) => (set: SortedSet<T>) => boolean}
      */
     cmp => value => set => find(cmp)(value)(set) === value
+
+/** @type {(s: string) => string} */
+const lengthPrefixed = s => `${s.length}:${s}`
+
+/**
+ * A canonical key for a set of strings: equal sets always produce the same
+ * key, and unequal sets never produce the same one. Useful wherever a set has
+ * to index a `StringMap` — the subset construction in `fjs/fsm`, say.
+ *
+ * Each element is written length-prefixed (`3:abc`) and the parts are
+ * concatenated. Joining on a separator would **not** be canonical: elements
+ * are arbitrary strings, so `['a,b']` and `['a', 'b']` would both produce
+ * `a,b` and two different sets would share one key. A length prefix is
+ * readable back — take the digits, the `:`, then exactly that many code
+ * units — so the encoding is injective without an escaping table.
+ *
+ * The key is canonical for the *set* only because `SortedSet` is sorted:
+ * element order is fixed by the set's own invariant, not by this function.
+ *
+ * @type {(set: SortedSet<string>) => string}
+ */
+export const toKey = set => set.map(lengthPrefixed).join('')

package/fjs/types/sorted_set/proof.f.d.mts

@@ -1,5 +1,8 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ */
 export declare const proof: {
+    toKey: (() => void)[];
     example: () => void;
     union: (() => void)[];
     intersect: (() => void)[];

package/fjs/types/sorted_set/proof.f.mjs

@@ -1,6 +1,8 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ */
 
-import { has, intersect, union } from './module.f.mjs'
+import { has, intersect, toKey, union } from './module.f.mjs'
 import { stringify } from '../../media/json/module.f.mjs'
 import { sort } from '../object/module.f.mjs'
 import { toArray, countdown, length } from '../list/module.f.mjs'
@@ -14,6 +16,21 @@ const str = a => stringify(sort)(a)
 const reverseCmp = flip(cmp)
 
 export const proof = {
+    toKey: [
+        () => assertEq(toKey([]), ''),
+        () => assertEq(toKey(['']), '0:'),
+        () => assertEq(toKey(['a']), '1:a'),
+        () => assertEq(toKey(['a', 'b']), '1:a1:b'),
+        // The reason the key is length-prefixed rather than separator-joined:
+        // these two sets are different and must not share a key, but any
+        // fixed separator that can occur in an element collapses them.
+        () => assert(toKey(['a,b']) !== toKey(['a', 'b']), 'comma'),
+        () => assert(toKey(['a:b']) !== toKey(['a', 'b']), 'colon'),
+        () => assert(toKey(['a\nb']) !== toKey(['a', 'b']), 'newline'),
+        // A prefix of one element must not be confused with a shorter one.
+        () => assert(toKey(['ab']) !== toKey(['a']), 'prefix'),
+        () => assert(toKey(['']) !== toKey([]), 'empty element vs empty set'),
+    ],
     example: () => {
         const cmp = (/** @type {number} */ a) => (/** @type {number} */ b) => a < b ? -1 : a > b ? 1 : 0
 

package/fjs/types/string/module.f.d.mts

@@ -14,6 +14,10 @@
  * repeat('abc')(3) // 'abcabcabc'
  * cmp('apple')('banana') // -1
  * ```
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Reduce } from '../function/operator/types.ts'
  */
 import type { List } from '../list/types.ts';
 import type { Sign } from '../function/compare/types.ts';

package/fjs/types/string/module.f.mjs

@@ -14,14 +14,15 @@
  * repeat('abc')(3) // 'abcabcabc'
  * cmp('apple')('banana') // -1
  * ```
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Reduce } from '../function/operator/types.ts'
  */
 
-/** @import { List } from '../list/types.ts' */
 import { reduce as listReduce, repeat as listRepeat } from '../list/module.f.mjs'
 import { compose } from '../function/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
 import { cmp as uCmp } from '../function/compare/module.f.mjs'
-/** @import { Reduce } from '../function/operator/types.ts' */
 import { join as joinOp } from '../function/operator/module.f.mjs'
 import { fold } from '../../common/monoid/module.f.mjs'
 

package/fjs/types/string_set/module.f.d.mts

@@ -19,10 +19,12 @@
  * mySet = remove('banana')(mySet);
  * if (contains('banana')(mySet)) { throw '4' }
  * ```
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { StringSet } from './types.ts'
  */
 import type { List } from '../list/types.ts';
 import type { StringSet } from './types.ts';
-/** @import { StringSet } from './types.ts' */
 /** @type {(s: StringSet) => List<string>} */
 export declare const values: (s: StringSet) => List<string>;
 /** @type {null} */

package/fjs/types/string_set/module.f.mjs

@@ -19,6 +19,9 @@
  * mySet = remove('banana')(mySet);
  * if (contains('banana')(mySet)) { throw '4' }
  * ```
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { StringSet } from './types.ts'
  */
 
 import { empty as btEmpty, values as btValues } from '../btree/module.f.mjs'
@@ -26,10 +29,8 @@ import { find, isFound } from '../btree/find/module.f.mjs'
 import { remove as btreeRemove } from '../btree/remove/module.f.mjs'
 import { set as btreeSet } from '../btree/set/module.f.mjs'
 import { cmp } from "../string/module.f.mjs"
-/** @import { List } from '../list/types.ts' */
 import { fold } from '../list/module.f.mjs'
 import { compose } from '../function/module.f.mjs'
-/** @import { StringSet } from './types.ts' */
 
 /** @type {(s: StringSet) => List<string>} */
 export const values = btValues

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

@@ -4,6 +4,8 @@
  * primitive literals, and unions as TypeScript type expressions.
  *
  * @module
+ *
+ * @import { Printer } from './types.ts'
  */
 import type { Printer } from './types.ts';
 /**

package/fjs/types/ts/module.f.mjs

@@ -4,10 +4,10 @@
  * primitive literals, and unions as TypeScript type expressions.
  *
  * @module
+ *
+ * @import { Printer } from './types.ts'
  */
 
-/** @import { Printer } from './types.ts' */
-
 /** @type {(open: string, close: string) => (i: readonly string[]) => string} */
 const complex = (open, close) => i =>
     `${open}${i.join(',')}${close}`
@@ -24,7 +24,7 @@ export const printer = (mut = undefined) => {
     return {
         tuple: (mut ? complex('[', ']') : complex('readonly[', ']')),
         struct: fields =>
-            structX(fields.map(([k, v]) => `${ro}${JSON.stringify(k)}:${v}`)),
+            structX(fields.map(([k, v, opt]) => `${ro}${JSON.stringify(k)}${opt === true ? '?' : ''}:${v}`)),
         array: type => `${ro}(${type})[]`,
         // `[k:string]?:` is invalid TypeScript — optional keys on an infinite
         // key set require mapped-type syntax.

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

@@ -10,6 +10,7 @@ export declare const unionSingle: () => void;
 export declare const unionMulti: () => void;
 export declare const printerReadonlyTuple: () => void;
 export declare const printerReadonlyStruct: () => void;
+export declare const printerOptionalField: () => void;
 export declare const printerReadonlyArray: () => void;
 export declare const printerReadonlyRecord: () => void;
 export declare const printerMutableTuple: () => void;

package/fjs/types/ts/proof.f.mjs

@@ -64,6 +64,11 @@ export const printerReadonlyStruct = () => {
     if (r !== '{readonly"x":number,readonly"y":string}') { throw r }
 }
 
+export const printerOptionalField = () => {
+    const r = ro.struct([['x', 'number', true], ['y', 'string']])
+    if (r !== '{readonly"x"?:number,readonly"y":string}') { throw r }
+}
+
 export const printerReadonlyArray = () => {
     const r = ro.array('string')
     assertEq(r, 'readonly(string)[]')

package/fjs/types/ts/types.d.ts

@@ -5,12 +5,17 @@
  * @module
  */
 export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+/**
+ * A `struct` field: the key, its type expression, and — when the third
+ * element is `true` — an optional-key marker (`"key"?: type`).
+ */
+export type StructField = readonly [string, string, true?];
 /**
  * Functions for emitting TypeScript type expression strings.
  */
 export type Printer = {
     readonly tuple: (types: readonly string[]) => string;
-    readonly struct: (fields: readonly (readonly [string, string])[]) => string;
+    readonly struct: (fields: readonly StructField[]) => string;
     readonly array: (type: string) => string;
     readonly record: (type: string) => string;
 };

package/fjs/types/uint8array/module.f.d.mts

@@ -8,17 +8,28 @@
  * (e.g. `fromVec`/`toVec` when reading or writing files).
  *
  * @module
+ *
+ * @import { Vec } from '../bit_vec/types.ts'
+ * @import { List } from '../list/types.ts'
  */
 import type { Vec } from '../bit_vec/types.ts';
 import type { List } from '../list/types.ts';
+/**
+ * Concatenates a list of `Uint8Array` values into one MSB-first bit vector.
+ *
+ * Throws if the result would exceed `maxLength`. The bound is not precomputed:
+ * `tryU8ListToVec` attempts the real conversion and reports `null` when it does
+ * not fit (`DESIGN.md` §6).
+ *
+ * @type {(input: List<Uint8Array>) => Vec}
+ */
+export declare const listToVec: (input: List<Uint8Array>) => Vec;
 /**
  * Converts a Uint8Array into an MSB-first bit vector.
  *
  * @type {(input: Uint8Array) => Vec}
  */
 export declare const toVec: (input: Uint8Array) => Vec;
-/** @type {(input: List<Uint8Array>) => Vec} */
-export declare const listToVec: (input: List<Uint8Array>) => Vec;
 /**
  * Converts an MSB-first bit vector into a Uint8Array.
  *

package/fjs/types/uint8array/module.f.mjs

@@ -8,36 +8,41 @@
  * (e.g. `fromVec`/`toVec` when reading or writing files).
  *
  * @module
+ *
+ * @import { Vec } from '../bit_vec/types.ts'
+ * @import { List } from '../list/types.ts'
  */
 
-import { assert, assertNotNullish } from '../../asserts/module.f.mjs'
+import { assertNotNullish } from '../../asserts/module.f.mjs'
 import { utf8, utf8ToString } from '../../text/module.f.mjs'
-import { maxLengthBytes, msb, tryU8ListToVec, u8List, u8ListToVec } from '../bit_vec/module.f.mjs'
-/** @import { Vec } from '../bit_vec/types.ts' */
+import { msb, tryU8ListToVec, u8List } from '../bit_vec/module.f.mjs'
 import { compose } from '../function/module.f.mjs'
 import { flat, fromArrayLike, iterable, map } from '../list/module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 
-const u8ListToVecMsb = u8ListToVec(msb)
 const tryU8ListToVecMsb = tryU8ListToVec(msb)
 const u8ListMsb = u8List(msb)
 
+const m = map(fromArrayLike)
+
 /**
- * Converts a Uint8Array into an MSB-first bit vector.
+ * Concatenates a list of `Uint8Array` values into one MSB-first bit vector.
  *
- * @type {(input: Uint8Array) => Vec}
+ * Throws if the result would exceed `maxLength`. The bound is not precomputed:
+ * `tryU8ListToVec` attempts the real conversion and reports `null` when it does
+ * not fit (`DESIGN.md` §6).
+ *
+ * @type {(input: List<Uint8Array>) => Vec}
  */
-export const toVec = input => {
-    assert(input.length <= maxLengthBytes, "the array is too big")
-    return u8ListToVecMsb(fromArrayLike(input))
-}
-
-const m = map(fromArrayLike)
-
-/** @type {(input: List<Uint8Array>) => Vec} */
 export const listToVec = input =>
     assertNotNullish(tryU8ListToVecMsb(flat(m(input))), "the array is too big")
 
+/**
+ * Converts a Uint8Array into an MSB-first bit vector.
+ *
+ * @type {(input: Uint8Array) => Vec}
+ */
+export const toVec = input => listToVec([input])
+
 /**
  * Converts an MSB-first bit vector into a Uint8Array.
  *

package/fjs/website/module.f.d.mts

@@ -2,7 +2,10 @@
  * Static website generation program for project landing content.
  *
  * @module
+ *
+ * @import { Write, WriteFile } from '../effects/node/types.ts'
+ * @import { Effect } from '../effects/types.ts'
  */
-import type { WriteFile } from '../effects/node/types.ts';
+import type { Write, WriteFile } from '../effects/node/types.ts';
 import type { Effect } from '../effects/types.ts';
-export declare const main: () => Effect<WriteFile, number>;
+export declare const main: () => Effect<Write | WriteFile, 0, number>;

package/fjs/website/module.f.mjs

@@ -2,13 +2,13 @@
  * Static website generation program for project landing content.
  *
  * @module
+ *
+ * @import { Write, WriteFile } from '../effects/node/types.ts'
+ * @import { Effect } from '../effects/types.ts'
  */
 
 import { htmlUtf8 } from '../media/html/module.f.mjs'
-import { writeFile } from '../effects/node/module.f.mjs'
-/** @import { WriteFile } from '../effects/node/types.ts' */
-import { pure, step } from '../effects/module.f.mjs'
-/** @import { Effect } from '../effects/types.ts' */
+import { exitStep, writeFile } from '../effects/node/module.f.mjs'
 
 const html = htmlUtf8()(
     ['a',
@@ -16,9 +16,7 @@ const html = htmlUtf8()(
         'GitHub Repository'
     ])
 
-/** @type {Effect<WriteFile, number>} */
-const program = step(
-    writeFile('index.html', html),
-    () => pure(0))
+/** @type {Effect<WriteFile | Write, 0, number>} */
+const program = exitStep(writeFile('index.html', html))
 
 export const main = () => program

package/fjs/website/proof.f.mjs

@@ -1,3 +1,4 @@
+import { exitCode } from '../effects/node/module.f.mjs'
 import { main } from './module.f.mjs'
 import { emptyState, virtual } from '../effects/node/virtual/module.f.mjs'
 import { assertEq, assertNotNullish } from '../asserts/module.f.mjs'
@@ -9,6 +10,6 @@ export const proof = {
     run: () => {
         const state = { ...emptyState, root: { '.github': { workflows: {} } } }
         const [_, result] = virtual(state)(main())
-        assertEq(result, 0)
+        assertEq(exitCode(result), 0)
     },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.44.0",
+  "version": "0.46.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -10,9 +10,9 @@
   ],
   "description": "FunctionalScript is a purely functional subset of JavaScript",
   "scripts": {
-    "prepack": "tsc --noEmit false --emitDeclarationOnly && tsc --noEmit false --declaration false",
+    "prepack": "tsc --noEmit false --emitDeclarationOnly && tsc",
     "test": "tsc && node ./fjs/module.mjs t",
-    "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.mjs fjs/emergent_testing/all.test.ts",
+    "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.mjs --test-coverage-lines=100 --test-coverage-branches=100 --test-coverage-functions=100",
     "start": "node ./fjs/module.mjs",
     "ci-update": "node ./fjs/module.mjs ci && node ./fjs/module.mjs r ./fjs/nanvm/update/module.f.mjs",
     "dev-update": "node ./fjs/module.mjs r ./fjs/dev/update/module.f.mjs",

package/fjs/asn.1/types.js

@@ -1,6 +0,0 @@
-/**
- * Types for ASN.1 BER/DER encoding and decoding over bit vectors.
- *
- * @module
- */
-export {};

package/fjs/asserts/types.js

@@ -1,6 +0,0 @@
-/**
- * Type-level assertion helpers.
- *
- * @module
- */
-export {};