functionalscript 0.45.0 → 0.46.0

package/fjs/protocol/mcp/stdio/proof.f.d.mts

@@ -1,11 +1,13 @@
 /**
  * @import { Unknown } from '../../../media/json/types.ts'
- * @import { Effect } from '../../../effects/types.ts'
  * @import { State } from '../../../effects/node/virtual/types.ts'
- * @import { Id, Response } from '../../json_rpc/types.ts'
+ * @import { Id } from '../../json_rpc/types.ts'
  * @import { Step } from './types.ts'
+ * @import { Read, Write } from '../../../effects/node/types.ts'
  */
 export declare const proof: {
+    readFailurePropagates: () => void;
+    readFailureAfterALinePropagates: () => void;
     eofImmediately: () => void;
     requestWritesResponse: () => void;
     requestWithoutTrailingNewline: () => void;

package/fjs/protocol/mcp/stdio/proof.f.mjs

@@ -1,13 +1,14 @@
 /**
  * @import { Unknown } from '../../../media/json/types.ts'
- * @import { Effect } from '../../../effects/types.ts'
  * @import { State } from '../../../effects/node/virtual/types.ts'
- * @import { Id, Response } from '../../json_rpc/types.ts'
+ * @import { Id } from '../../json_rpc/types.ts'
  * @import { Step } from './types.ts'
+ * @import { Read, Write } from '../../../effects/node/types.ts'
  */
 
-import { assertEq } from '../../../asserts/module.f.mjs'
+import { assert, assertEq } from '../../../asserts/module.f.mjs'
 import { pure } from '../../../effects/module.f.mjs'
+import { pureOk } from '../../../effects/module.f.mjs'
 import { emptyState, virtual } from '../../../effects/node/virtual/module.f.mjs'
 import { stringify } from '../../../media/json/module.f.mjs'
 import { utf8 } from '../../../text/module.f.mjs'
@@ -16,6 +17,8 @@ import { maxLengthBytes } from '../../../types/bit_vec/module.f.mjs'
 import { sort } from '../../../types/object/module.f.mjs'
 import { internalError, jsonrpc, parseError } from '../../json_rpc/module.f.mjs'
 import { stdioTransport } from './module.f.mjs'
+import { run as mockRun } from '../../../effects/mock/module.f.mjs'
+import { error, ok } from '../../../types/result/module.f.mjs'
 
 const stringifyJson = stringify(sort)
 
@@ -32,7 +35,7 @@ const idOf = value =>
 /** @type {Step<never>} */
 const echoStep = value => {
     const id = idOf(value)
-    return pure(id === undefined
+    return pureOk(id === undefined
         ? null
         : { jsonrpc, result: { ok: true }, id })
 }
@@ -51,15 +54,15 @@ const run = runStep(echoStep)
 
 /** @type {(id: Id) => string} */
 const okResponse = id =>
-    stringifyJson(/** @type {Unknown} */ ({ jsonrpc, result: { ok: true }, id })) + '\n'
+    stringifyJson({ jsonrpc, result: { ok: true }, id }) + '\n'
 
 /** @type {string} */
 const parseErrorLine =
-    stringifyJson(/** @type {Unknown} */ ({ jsonrpc, error: parseError, id: null })) + '\n'
+    stringifyJson({ jsonrpc, error: parseError, id: null }) + '\n'
 
 /** @type {(id: Id) => string} */
 const internalErrorLine = id =>
-    stringifyJson(/** @type {Unknown} */ ({ jsonrpc, error: internalError, id })) + '\n'
+    stringifyJson({ jsonrpc, error: internalError, id }) + '\n'
 
 /** @type {(id: number) => string} */
 const ping = id => `{"jsonrpc":"2.0","method":"ping","id":${id}}`
@@ -71,6 +74,36 @@ const oversizedString = 'a'.repeat(Number(maxLengthBytes) + 1)
 const notification = '{"jsonrpc":"2.0","method":"notifications/initialized"}'
 
 export const proof = {
+    // A stdin that cannot be read ends the loop and hands the failure back,
+    // where it used to panic. EOF is not this case: that is `ok(null)`, and
+    // `eofImmediately` above pins it as the clean shutdown it should be.
+    readFailurePropagates: () => {
+        const runner = mockRun(/** @type {Parameters<typeof mockRun<Read | Write, undefined>>[0]} */ ({
+            read: () => (/** @type {undefined} */ s) => [s, error(/** @type {const} */ (['notImplemented', 'read']))],
+            write: () => (/** @type {undefined} */ s) => [s, ok(undefined)],
+        }))
+        const [, result] = runner(undefined)(stdioTransport(echoStep))
+        assert(result[0] === 'error', result)
+    },
+
+    // The same, one turn of the loop later. The proof above only reaches the
+    // *first* read, so a tail that swallowed the failure on recursion would
+    // still pass it: here stdin yields one complete line, the handler answers
+    // it, and the read after that fails.
+    readFailureAfterALinePropagates: () => {
+        const bytes = toBytes(ping(1) + '\n')
+        const runner = mockRun(/** @type {Parameters<typeof mockRun<Read | Write, readonly number[]>>[0]} */ ({
+            read: () => (/** @type {readonly number[]} */ s) =>
+                s.length === 0
+                    ? [s, error(/** @type {const} */ (['notImplemented', 'read']))]
+                    : [s.slice(1), ok(s[0])],
+            write: () => (/** @type {readonly number[]} */ s) => [s, ok(undefined)],
+        }))
+        const [rest, result] = runner(bytes)(stdioTransport(echoStep))
+        assertEq(rest.length, 0, 'expected the line to be consumed before the failure')
+        assert(result[0] === 'error', result)
+    },
+
     // EOF on the very first read: clean shutdown, nothing written, no further reads.
     eofImmediately: () => {
         const state = run('')
@@ -120,9 +153,9 @@ export const proof = {
         /** @type {Step<never>} */
         const step = value => {
             const id = idOf(value)
-            return pure(id === undefined
+            return pureOk(id === undefined
                 ? null
-                : /** @type {Response} */ (/** @type {unknown} */ ({ jsonrpc, result: { ok: true, nextCursor: undefined }, id })))
+                : { jsonrpc, result: { ok: true, nextCursor: undefined }, id })
         }
         const state = runStep(step)(ping(1) + '\n')
         assertEq(state.stdout, okResponse(1))
@@ -137,7 +170,7 @@ export const proof = {
         /** @type {Step<never>} */
         const step = value => {
             const id = idOf(value)
-            return pure(id === undefined
+            return pureOk(id === undefined
                 ? null
                 : { jsonrpc, result: { big: oversizedString }, id })
         }
@@ -151,7 +184,7 @@ export const proof = {
         /** @type {Step<never>} */
         const step = value => {
             const id = idOf(value)
-            return pure(id === undefined
+            return pureOk(id === undefined
                 ? null
                 : id === 1
                     ? { jsonrpc, result: { big: oversizedString }, id }
@@ -171,7 +204,7 @@ export const proof = {
         /** @type {Step<never>} */
         const step = value => {
             const id = idOf(value)
-            return pure(id === undefined
+            return pureOk(id === undefined
                 ? null
                 : { jsonrpc, result: { ok: true }, id: oversizedString })
         }

package/fjs/protocol/mcp/stdio/types.d.ts

@@ -11,4 +11,4 @@ import type { Response } from '../../json_rpc/types.ts';
  * for a notification that needs no reply. The shape of
  * `mcpStep(config)(handlers)(key)`.
  */
-export type Step<O extends Operation> = (value: Unknown) => Effect<O, Response | null>;
+export type Step<O extends Operation> = (value: Unknown) => Effect<O, Response | null, never>;

package/fjs/protocol/mcp/types.d.ts

@@ -7,7 +7,7 @@
  */
 import type { Ts } from '../../types/rtti/ts/types.ts';
 import type { Unknown } from '../../media/json/types.ts';
-import type { Operation, Effect } from '../../effects/types.ts';
+import type { Effect, Operation } from '../../effects/types.ts';
 import type { Type } from '../../types/rtti/types.ts';
 import type { Response } from '../json_rpc/types.ts';
 import type { implementation, serverCapabilities, initializeParams, initializeResult, textContent, blobResource, embeddedResource, contentItem, tool, toolsListParams, toolsListResult, toolsCallParams, toolsCallResult } from './module.f.mjs';
@@ -26,8 +26,8 @@ export type ToolsCallParams = Ts<typeof toolsCallParams>;
 export type ToolsCallResult = Ts<typeof toolsCallResult>;
 /** Per-method handlers for a hello-world MCP tool server. */
 export type McpHandlers<O extends Operation> = {
-    readonly toolsList: (params: ToolsListParams) => Effect<O, ToolsListResult>;
-    readonly toolsCall: (params: ToolsCallParams) => Effect<O, ToolsCallResult>;
+    readonly toolsList: (params: ToolsListParams) => Effect<O, ToolsListResult, never>;
+    readonly toolsCall: (params: ToolsCallParams) => Effect<O, ToolsCallResult, never>;
 };
 /**
  * A single declarative tool entry combining metadata, input schema, and type-safe handler.
@@ -39,10 +39,21 @@ export type ToolEntry<O extends Operation> = {
     readonly name: string;
     readonly description: string;
     readonly inputRtti: Type;
-    readonly handle: (args: Unknown) => Effect<O, ToolsCallResult>;
+    readonly handle: (args: Unknown) => Effect<O, ToolsCallResult, never>;
 };
-/** Top-level handler: maps a raw JSON value to a JSON-RPC response (or `null` for notifications). */
-export type Handle<O extends Operation> = (value: Unknown) => Effect<O, Response | null>;
+/**
+ * A JSON-RPC step: given a decoded message, produce the response to write, or
+ * `null` for a notification.
+ *
+ * **`never` is a claim, not an absence.** The handler behind this does perform
+ * effects and they can fail — a session-state read is dispatched by a runner
+ * that may decline it. It says `never` because it has *absorbed* those: a
+ * request's failure becomes `_errResponse(id)(internalError)` and a
+ * notification's is dropped, there being no frame to put it in. Spelling that
+ * as `Effect<…, never>` puts the decision in the type where a reader can
+ * disagree with it, which an opaque payload could not.
+ */
+export type Handle<O extends Operation> = (value: Unknown) => Effect<O, Response | null, never>;
 /** State carried before the peer sends `initialize`. */
 export type Uninitialized = readonly ['uninitialized'];
 /** State after `initialize` response was sent but before `notifications/initialized` arrives. */

package/fjs/sul/id/module.f.d.mts

@@ -7,7 +7,6 @@
  * @module
  *
  * @import { Vec } from '../../types/bit_vec/types.ts'
- * @import { Point2D } from '../../crypto/secp/types.ts'
  * @import { V8 } from '../../crypto/sha2/types.ts'
  * @import { Id } from './types.ts'
  */

package/fjs/sul/id/module.f.mjs

@@ -7,14 +7,13 @@
  * @module
  *
  * @import { Vec } from '../../types/bit_vec/types.ts'
- * @import { Point2D } from '../../crypto/secp/types.ts'
  * @import { V8 } from '../../crypto/sha2/types.ts'
  * @import { Id } from './types.ts'
  */
 
 import { toArray } from '../../types/list/module.f.mjs'
 import { length, msb, uint, uintChunkList, unpack, vec } from '../../types/bit_vec/module.f.mjs'
-import { assertEq } from '../../asserts/module.f.mjs'
+import { assertEq, assertNotNullish } from '../../asserts/module.f.mjs'
 import { utf8 } from '../../text/module.f.mjs'
 import { secp256r1 } from '../../crypto/secp/module.f.mjs'
 import { base32 } from '../../crypto/sha2/module.f.mjs'
@@ -33,7 +32,7 @@ const utf8IvSeed = utf8(ivSeed)
 const c = secp256r1
 
 /** @type {bigint} */
-const ivUint = /** @type {Point2D} */ (c.mul(uint(utf8IvSeed))(c.g))[0]
+const ivUint = assertNotNullish(c.mul(uint(utf8IvSeed))(c.g))[0]
 
 // 64 hex = 256 bits = 32 bytes:
 assertEq(

package/fjs/sul/level/hash/module.f.mjs

@@ -9,6 +9,7 @@
  * @import { Add, EncodeState } from './types.ts'
  */
 
+import { assertNotNullish } from '../../../asserts/module.f.mjs'
 import { emptyState, patriciaTrie } from '../../../types/patricia_trie/module.f.mjs'
 import { compress } from '../../id/module.f.mjs'
 import { asBase } from '../../../types/nominal/module.f.mjs'
@@ -49,7 +50,7 @@ export const encode =
                 return [undefined, push([asBase(symbol), symbol], state)]
             }
             const [root1, storage1] = end(state)
-            const [root2, storage2] = rootCreate(/** @type {Id} */ (root1), symbol, storage1)
+            const [root2, storage2] = rootCreate(assertNotNullish(root1), symbol, storage1)
             return [root2, [storage2, []]]
         }
     }

package/fjs/sul/level/hash/proof.f.mjs

@@ -3,7 +3,7 @@
  * @import { EncodeState } from './types.ts'
  */
 
-import { assert, assertEq } from '../../../asserts/module.f.mjs'
+import { assert, assertEq, assertNotNullish } from '../../../asserts/module.f.mjs'
 import { compress, level3Id } from '../../id/module.f.mjs'
 import { emptyEncodeState, encode } from './module.f.mjs'
 
@@ -80,7 +80,7 @@ export const proof = {
     // Output equals the merged value in the last add call
     output_is_last_add: () => {
         const [out, storage] = runWord([s1, s0, s1])
-        assertEq(out, /** @type {_NodeList[number]} */ (storage.at(-1))[2])
+        assertEq(out, assertNotNullish(storage.at(-1))[2])
     },
 
     // Stack is empty after flush; storage is preserved

package/fjs/sul/module.f.mjs

@@ -32,22 +32,27 @@ export const encode =
 
         /** @typedef {readonly [Id | undefined, S, readonly _HashState[]]} _CascadeResult */
 
-        /** @type {(id0: Id, storage0: S, stacks0: readonly _HashState[]) => _CascadeResult} */
-        const cascade = (id0, storage0, stacks0) => {
-            let id = id0, storage = storage0, stacks = stacks0
-            for (let index = 0; ; index++) {
-                if (index >= stacks.length) {
-                    const [, [newStorage, newStack]] = step(id, [storage, []])
-                    return [id, newStorage, [...stacks, newStack]]
-                }
-                const [out, [newStorage, newStack]] = step(id, [storage, stacks[index]])
-                stacks = [...stacks.slice(0, index), newStack, ...stacks.slice(index + 1)]
-                storage = newStorage
-                if (out === undefined) return [undefined, storage, stacks]
-                id = out
+        // Recursive rather than a `for(;;)` loop: every exit is one of the two
+        // `return`s below, so a bare `for(;;)` picks up a phantom "loop falls
+        // through" branch that V8's coverage instrumentation can never mark
+        // taken — there is no third way out to take it. Recursion has no such
+        // branch to begin with.
+        /** @type {(id: Id, storage: S, stacks: readonly _HashState[], index: number) => _CascadeResult} */
+        const cascadeFrom = (id, storage, stacks, index) => {
+            if (index >= stacks.length) {
+                const [, [newStorage, newStack]] = step(id, [storage, []])
+                return [id, newStorage, [...stacks, newStack]]
             }
+            const [out, [newStorage, newStack]] = step(id, [storage, stacks[index]])
+            const newStacks = [...stacks.slice(0, index), newStack, ...stacks.slice(index + 1)]
+            return out === undefined
+                ? [undefined, newStorage, newStacks]
+                : cascadeFrom(out, newStorage, newStacks, index + 1)
         }
 
+        /** @type {(id0: Id, storage0: S, stacks0: readonly _HashState[]) => _CascadeResult} */
+        const cascade = (id0, storage0, stacks0) => cascadeFrom(id0, storage0, stacks0, 0)
+
         /** @type {(bit: bigint, state: EncodeState<S>) => readonly [Id | undefined, EncodeState<S>]} */
         const literalStep = (bit, state) => {
             const [ps, storage, stacks] = state

package/fjs/text/code_point/module.f.d.mts

@@ -49,6 +49,14 @@ export declare const decoder: <Unit, S, Cp>(byteOp: StateScan<Unit, S | null, Li
  * @returns {(state: S | null) => readonly [List<Cp>, S | null]} The end-of-input step.
  */
 export declare const eofFlush: <S, Cp>(toError: (state: S) => Cp) => (state: S | null) => readonly [List<Cp>, S | null];
+/**
+ * The last code point of the Basic Multilingual Plane. Exported because the
+ * UTF-8 encoder needs the boundary itself — its 3-byte form covers the BMP up
+ * to here — where the predicates below only answer membership. `maxCodePoint`
+ * stays private: `isSupplementaryPlane` already expresses the one range a
+ * caller has wanted it for.
+ */
+export declare const bmpMax = /** @type {const} */ 65535;
 /**
  * Checks whether the 16-bit word (U16) is a high surrogate.
  * Range: 0xD800 - 0xDBFF.

package/fjs/text/code_point/module.f.mjs

@@ -76,7 +76,14 @@ export const eofFlush = toError => state =>
 const surrogateMin = /** @type {const} */ 0xd800
 const lowSurrogateMin = /** @type {const} */ 0xdc00
 const surrogateMax = /** @type {const} */ 0xdfff
-const bmpMax = /** @type {const} */ 0xffff
+/**
+ * The last code point of the Basic Multilingual Plane. Exported because the
+ * UTF-8 encoder needs the boundary itself — its 3-byte form covers the BMP up
+ * to here — where the predicates below only answer membership. `maxCodePoint`
+ * stays private: `isSupplementaryPlane` already expresses the one range a
+ * caller has wanted it for.
+ */
+export const bmpMax = /** @type {const} */ 0xffff
 const maxCodePoint = /** @type {const} */ 0x10_ffff
 
 /**

package/fjs/text/code_point/proof.f.d.mts

@@ -3,6 +3,7 @@ export declare const proof: {
     isHighSurrogate: (() => void)[];
     isLowSurrogate: (() => void)[];
     isBmpCodePoint: (() => void)[];
+    bmpMax: (() => void)[];
     isSupplementaryPlane: (() => void)[];
     isValidCodePoint: (() => void)[];
     isTextCodePoint: (() => void)[];

package/fjs/text/code_point/proof.f.mjs

@@ -1,6 +1,7 @@
 import { assertEq } from '../../asserts/module.f.mjs'
 import { toArray } from '../../types/list/module.f.mjs'
 import {
+    bmpMax,
     eofFlush,
     isBmpCodePoint,
     isHighSurrogate,
@@ -64,6 +65,16 @@ export const proof = {
         () => check(isBmpCodePoint(0xd800), false),
         () => check(isBmpCodePoint(0x10000), false),
     ],
+    bmpMax: [
+        // The exported boundary and the predicates derived from it must agree:
+        // `bmpMax` is the last BMP code point, and the next one starts the
+        // supplementary planes. This is the pairing the UTF-8 encoder relies
+        // on to split its 3-byte and 4-byte forms.
+        () => check(isBmpCodePoint(bmpMax), true),
+        () => check(isSupplementaryPlane(bmpMax), false),
+        () => check(isSupplementaryPlane(bmpMax + 1), true),
+        () => check(isBmpCodePoint(bmpMax + 1), false),
+    ],
     isSupplementaryPlane: [
         () => check(isSupplementaryPlane(0x10000), true),
         () => check(isSupplementaryPlane(0x10ffff), true),

package/fjs/text/sgr/module.f.d.mts

@@ -6,12 +6,10 @@
  *
  * @module
  *
- * @import { Write, WriteConsoles, NodeProgramOptions } from '../../effects/node/types.ts'
- * @import { Effect } from '../../effects/types.ts'
+ * @import { Console, Write, WriteConsoles, NodeProgramOptions } from '../../effects/node/types.ts'
  * @import { Stdout, WriteText, CsiConsole } from './types.ts'
  */
-import type { Write, WriteConsoles, NodeProgramOptions } from '../../effects/node/types.ts';
-import type { Effect } from '../../effects/types.ts';
+import type { Console, WriteConsoles, NodeProgramOptions } from '../../effects/node/types.ts';
 import type { Stdout, WriteText } from './types.ts';
 /** @type {string} */
 export declare const backspace: string;
@@ -56,6 +54,6 @@ export declare const createConsoleText: (stdout: Stdout) => WriteText;
  * stream is not a TTY, then encodes to UTF-8 and emits a `Write` effect.
  * Does NOT append `\n` — callers are responsible for line termination.
  *
- * @type {(options: NodeProgramOptions) => (stream: WriteConsoles) => (s: string) => Effect<Write, void>}
+ * @type {(options: NodeProgramOptions) => (stream: WriteConsoles) => Console}
  */
-export declare const csiWrite: (options: NodeProgramOptions) => (stream: WriteConsoles) => (s: string) => Effect<Write, void>;
+export declare const csiWrite: (options: NodeProgramOptions) => (stream: WriteConsoles) => Console;

package/fjs/text/sgr/module.f.mjs

@@ -6,8 +6,7 @@
  *
  * @module
  *
- * @import { Write, WriteConsoles, NodeProgramOptions } from '../../effects/node/types.ts'
- * @import { Effect } from '../../effects/types.ts'
+ * @import { Console, Write, WriteConsoles, NodeProgramOptions } from '../../effects/node/types.ts'
  * @import { Stdout, WriteText, CsiConsole } from './types.ts'
  */
 
@@ -49,13 +48,13 @@ export const csi = end => code =>
 export const sgr = csi('m')
 
 /** Resets all SGR styles to terminal defaults. */
-export const reset = /** @type {string} */ (sgr(0))
+export const reset = sgr(0)
 /** Enables bold/intense text rendering when supported by the terminal. */
-export const bold = /** @type {string} */ (sgr(1))
+export const bold = sgr(1)
 /** Applies red foreground color to subsequent text. */
-export const fgRed = /** @type {string} */ (sgr(31))
+export const fgRed = sgr(31)
 /** Applies green foreground color to subsequent text. */
-export const fgGreen = /** @type {string} */ (sgr(32))
+export const fgGreen = sgr(32)
 
 const { max } = Math
 
@@ -92,7 +91,7 @@ const str = isTTY => s =>
  * stream is not a TTY, then encodes to UTF-8 and emits a `Write` effect.
  * Does NOT append `\n` — callers are responsible for line termination.
  *
- * @type {(options: NodeProgramOptions) => (stream: WriteConsoles) => (s: string) => Effect<Write, void>}
+ * @type {(options: NodeProgramOptions) => (stream: WriteConsoles) => Console}
  */
 export const csiWrite = ({ std }) => stream => {
     const toStr = str(std[stream].isTTY)

package/fjs/text/utf16/module.f.mjs

@@ -160,7 +160,9 @@ const u16 = i => Number.isInteger(i) && isInU16Range(i)
  *               This can be either `null` (no state) or the previous high surrogate value.
  * @param word - The current UTF-16 word (U16) to process.
  * @returns A tuple where the first element is a list of decoded Unicode code points (`CodePoint`), and
- *          the second element is the updated state. If the word is invalid, an error code `0xffffffff` is returned.
+ *          the second element is the updated state. A word outside the `U16`
+ *          domain is reported as one bare `errorMask` unit, the same shape the
+ *          UTF-8 decoder's out-of-range guard emits.
  *
  * @example
  *
@@ -182,7 +184,10 @@ const u16 = i => Number.isInteger(i) && isInU16Range(i)
  */
 const utf16ByteToCodePointOp = (word, state) => {
     if (!u16(word)) {
-        return [[0xffffffff], state]
+        // Out of domain, so there is no payload to tag: emit the bare mask,
+        // matching `utf8ByteToCodePointOp`'s guard. Every other error path
+        // below tags a real code unit with `| errorMask`.
+        return [[errorMask], state]
     }
     if (state === null) {
         if (isBmpCodePoint(word)) { return [[word], null] }

package/fjs/text/utf16/proof.f.mjs

@@ -24,7 +24,7 @@ export const proof = {
     toCodePointList: [
         () => {
             const result = stringify(toArray(toCodePointList([-1, 65536])))
-            assertEq(result, '[4294967295,4294967295]')
+            assertEq(result, '[2147483648,2147483648]')
         },
         () => {
             const result = stringify(toArray(toCodePointList([0, 36, 8364, 55295, 57344, 65535])))
@@ -60,14 +60,14 @@ export const proof = {
         // partition the integers in that range.
         () => {
             const result = stringify(toArray(toCodePointList([56319.5])))
-            assertEq(result, '[4294967295]')
+            assertEq(result, '[2147483648]')
         },
         // A non-integer word doesn't disturb a pending high surrogate: it is
         // reported invalid on its own, and the surrogate is still flagged
         // unpaired at EOF.
         () => {
             const result = stringify(toArray(toCodePointList([55296, 56319.5])))
-            assertEq(result, '[4294967295,-2147428352]')
+            assertEq(result, '[2147483648,-2147428352]')
         }
     ],
     fromCodePointList: [

package/fjs/text/utf8/module.f.mjs

@@ -11,9 +11,11 @@
 
 import { flatMap, toArray } from '../../types/list/module.f.mjs'
 import {
+    bmpMax,
     decoder,
     eofFlush,
     errorMask,
+    isSupplementaryPlane,
     isValidCodePoint,
 } from '../code_point/module.f.mjs'
 import { msb, u8List, length } from '../../types/bit_vec/module.f.mjs'
@@ -94,14 +96,14 @@ const codePointToUtf8 = input => {
     if (input >= 0x0080 && input <= 0x07ff) {
         return [input >> 6 | lead2Tag, contByte(input)]
     }
-    if (input >= 0x0800 && input <= 0xffff) {
+    if (input >= 0x0800 && input <= bmpMax) {
         return [
             input >> 12 | lead3Tag,
             contByte(input >> 6),
             contByte(input),
         ]
     }
-    if (input >= 0x10000 && input <= 0x10ffff) {
+    if (isSupplementaryPlane(input)) {
         return [
             input >> 18 | lead4Tag,
             contByte(input >> 12),

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

@@ -53,10 +53,22 @@ export const first = at(0)
  */
 export const last = a => at(a.length - 1)(a)
 
+/**
+ * Applies `f` to a non-empty array, answering `null` for an empty one — the
+ * shared shape of the whole-array accessors below.
+ *
+ * The guard is `a.length === 0` and not `first(a) === null`: `first` goes
+ * through `fromUndefined`, so it reads a *stored* `null` or `undefined`
+ * element as absence. `[null]` is not empty, but `first` says it is.
+ *
+ * @type {<T, R>(f: (a: readonly T[]) => R) => (a: readonly T[]) => R | null}
+ */
+const onNonEmpty = f => a => a.length === 0 ? null : f(a)
+
 /**
  * @type {<T>(a: readonly T[]) => readonly T[] | null}
  */
-export const tail = a => a.length === 0 ? null : uncheckTail(a)
+export const tail = onNonEmpty(uncheckTail)
 
 /**
  * @type {<T>(a: readonly T[]) => readonly [T, readonly T[]] | null}
@@ -69,7 +81,7 @@ export const splitFirst = a => {
 }
 
 /** @type {<T>(a: readonly T[]) => readonly T[] | null} */
-export const head = a => a.length === 0 ? null : uncheckHead(a)
+export const head = onNonEmpty(uncheckHead)
 
 /** @type {<T>(a: readonly T[]) => readonly [readonly T[], T] | null} */
 export const splitLast = a => {

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

@@ -120,8 +120,6 @@ export declare const pack: ({ length, uint }: Unpacked) => Vec;
 /** @type {({ uint }: Unpacked) => bigint} */
 export declare const unpackedUint: ({ uint }: Unpacked) => bigint;
 export type _Base = {
-    readonly front: (len: bigint) => (v: Vec) => bigint;
-    readonly removeFront: (len: bigint) => (v: Vec) => Vec;
     readonly norm: _NormOp;
     readonly uintCmp: (a: bigint) => (b: bigint) => Sign;
     readonly unpackSplit: (len: bigint) => (u: Unpacked) => readonly [bigint, bigint];