functionalscript 0.44.0 → 0.46.0

package/fjs/effects/node/module.mjs

@@ -1,5 +1,5 @@
 /**
- * Node.js effect runner: interprets `Effect<NodeOp, T>` directly against the
+ * Node.js effect runner: interprets `Effect<NodeOp, T, E>` directly against the
  * Node globals and built-in modules (`fs`, `http`, `child_process`, `process`,
  * `fetch`, …).
  *
@@ -11,6 +11,11 @@
  * globals directly instead.
  *
  * @module
+ *
+ * @import { Effect } from '../types.ts'
+ * @import { IoResult, Server as EffectServer, Headers, Module, NodeOp, RequestListener as Erl, NodeProgram, NodeProgramOptions, WriteConsoles, TestContext, TestFn, } from './types.ts'
+ * @import { Result } from '../../types/result/types.ts'
+ * @import { StringMap } from '../../types/object/types.ts'
  */
 
 import http from 'node:http'
@@ -23,30 +28,13 @@ import { once } from 'node:events'
 import * as testContext from 'node:test'
 
 import { concat, normalize, toPosix } from '../../path/module.f.mjs'
-/** @import { Effect } from '../types.ts' */
 import { asyncRun } from '../module.mjs'
 import { memoryOperationMap } from './memory/module.mjs'
-import { usesInlineTestContext } from './module.f.mjs'
-/**
- * @import {
- *   Server as EffectServer,
- *   Headers,
- *   Module,
- *   NodeOp,
- *   RequestListener as Erl,
- *   NodeProgram,
- *   NodeProgramOptions,
- *   WriteConsoles,
- *   TestContext,
- *   TestFn,
- * } from './types.ts'
- */
+import { exitCode, toIoError, usesInlineTestContext } from './module.f.mjs'
 import { asBase, asNominal } from '../../types/nominal/module.f.mjs'
-/** @import { Result } from '../../types/result/types.ts' */
-import { error, ok } from '../../types/result/module.f.mjs'
+import { error, ok, unwrap } from '../../types/result/module.f.mjs'
 import { asyncTryCatch } from '../../types/result/module.mjs'
 import { fromVec, listToVec, toVec } from '../../types/uint8array/module.f.mjs'
-/** @import { StringMap } from '../../types/object/types.ts' */
 import { maxLengthBytes } from '../../types/bit_vec/module.f.mjs'
 
 /** @typedef {{ readonly listen: (port: number) => void }} _Server */
@@ -79,7 +67,23 @@ import { maxLengthBytes } from '../../types/bit_vec/module.f.mjs'
  */
 const createServer = http.createServer
 
-/** @typedef {<T>(effect: Effect<NodeOp, T>) => Promise<T>} _EffectToPromise */
+/** @typedef {<T, E>(effect: Effect<NodeOp, T, E>) => Promise<Result<T, E>>} _EffectToPromise */
+
+/**
+ * Performs host IO, reporting a thrown failure as an {@link IoResult} error.
+ *
+ * Every filesystem, network, and subprocess handler below goes through it, so
+ * the `catch` that turns an exception into effect data — and the normalization
+ * that keeps the channel serializable — happens in exactly one place.
+ *
+ * @template T
+ * @param {() => Promise<T>} f
+ * @returns {Promise<IoResult<T>>}
+ */
+const io = async f => {
+    const r = await asyncTryCatch(f)
+    return r[0] === 'ok' ? r : error(toIoError(r[1]))
+}
 
 /**
  * @template T
@@ -127,7 +131,7 @@ const sandbox = async f => {
             p = await p
             after = performance.now()
         }
-        result = ok(/** @type {T} */ (p))
+        result = ok(p)
     } catch (e) {
         after = performance.now()
         result = error(e)
@@ -202,7 +206,7 @@ const waitReadableOrEnd = stdin =>
 const readStdinByte = async () => {
     const stdin = process.stdin
     while (true) {
-        const chunk = /** @type {Uint8Array | null} */ (stdin.read(1))
+        const chunk = stdin.read(1)
         if (chunk !== null) {
             return chunk[0]
         }
@@ -222,16 +226,16 @@ const { randomInt } = crypto
 /** @type {_EffectToPromise} */
 const runNodeEffect = asyncRun({
     ...memoryOperationMap(),
-    all: async (...effects) => await Promise.all(effects.map(runNodeEffect)),
-    fetch: async url => asyncTryCatch(async () => {
+    all: async (...effects) => ok(await Promise.all(effects.map(runNodeEffect))),
+    fetch: url => io(async () => {
         const response = await fetch(url)
         if (!response.ok) {
             throw new Error(`Fetch error: ${response.status} ${response.statusText}`)
         }
         return toVec(new Uint8Array(await response.arrayBuffer()))
     }),
-    mkdir: (path, options) => asyncTryCatch(async () => { await mkdir(path, options) }),
-    readFile: path => asyncTryCatch(async () => {
+    mkdir: (path, options) => io(async () => { await mkdir(path, options) }),
+    readFile: path => io(async () => {
         const fileStats = await stat(path)
         // if the file is too big, toVec should fail anyway but in this case we don't want to load the file.
         if (fileStats.size > maxFileSizeBytes) {
@@ -239,7 +243,7 @@ const runNodeEffect = asyncRun({
         }
         return toVec(await readFile(path))
     }),
-    readdir: (path, r) => asyncTryCatch(async () =>
+    readdir: (path, r) => io(async () =>
         (await readdir(path, { ...r, withFileTypes: true }))
         .map(v => ({
             name: v.name,
@@ -247,10 +251,10 @@ const runNodeEffect = asyncRun({
             isFile: v.isFile()
         }))
     ),
-    writeFile: (path, data) => asyncTryCatch(() => writeFile(path, fromVec(data))),
-    rm: path => asyncTryCatch(() => rm(path)),
-    rename: (src, dst) => asyncTryCatch(() => rename(src, dst)),
-    readBytes: (path, offset, size) => asyncTryCatch(async () => {
+    writeFile: (path, data) => io(() => writeFile(path, fromVec(data))),
+    rm: path => io(() => rm(path)),
+    rename: (src, dst) => io(() => rename(src, dst)),
+    readBytes: (path, offset, size) => io(async () => {
         if (offset < 0) {
             throw new Error(`Offset ${offset} is negative`)
         }
@@ -266,13 +270,13 @@ const runNodeEffect = asyncRun({
             await fh.close()
         }
     }),
-    randomInt: async () => randomInt(randomMax),
-    access: path => asyncTryCatch(() => access(path)),
-    createExclusive: path => asyncTryCatch(async () => {
+    randomInt: async () => ok(randomInt(randomMax)),
+    access: path => io(() => access(path)),
+    createExclusive: path => io(async () => {
         const fh = await open(path, 'wx')
         await fh.close()
     }),
-    writeBytes: (path, offset, data) => asyncTryCatch(async () => {
+    writeBytes: (path, offset, data) => io(async () => {
         const fh = await open(path, 'r+')
         try {
             const buffer = fromVec(data)
@@ -287,11 +291,11 @@ const runNodeEffect = asyncRun({
             await fh.close()
         }
     }),
-    stat: path => asyncTryCatch(async () => ({ size: (await stat(path)).size })),
-    import: path => asyncTryCatch(() => asyncImport(path)),
+    stat: path => io(async () => ({ size: (await stat(path)).size })),
+    import: path => io(() => asyncImport(path)),
     exec: (command, stdin) => new Promise(resolve => {
         const child = exec(command, (e, stdout, stderr) =>
-            resolve(e !== null ? /** @type {const} */ (['error', e]) : ok({ stdout, stderr }))
+            resolve(e !== null ? error(toIoError(e)) : ok({ stdout, stderr }))
         )
         child.stdin?.end(stdin)
     }),
@@ -301,30 +305,37 @@ const runNodeEffect = asyncRun({
         const nodeRl = async (req, res) => {
             const reqBody = await collect(req)
             const { method, url, headers } = req
-            const { status, headers: outHeaders, body: outBody } = await runNodeEffect(erl({
+            // `RequestListener` answers `Effect<…, ServerResponse, never>` —
+            // the response frame is where a listener puts its failures — so
+            // this unwrap is total.
+            const { status, headers: outHeaders, body: outBody } = unwrap(await runNodeEffect(erl({
                 method,
                 url,
                 headers,
                 body: listToVec(reqBody)
-            }))
+            })))
             res
                 .writeHead(status, outHeaders)
                 .end(fromVec(outBody))
         }
-        return /** @satisfies {EffectServer} */ (asNominal(createServer(nodeRl)))
+        return ok(/** @satisfies {EffectServer} */ (asNominal(createServer(nodeRl))))
     },
     listen: async (server, port) => {
         const s = /** @type {_Server} */ (asBase(server))
         s.listen(port)
+        return ok(undefined)
     },
     forever: () => new Promise(() => {}),
-    now: async () => now(),
-    sandbox,
-    await: awaitPromise,
-    write: (stream, data) => writeAll(streams[stream], fromVec(data)),
-    read: readStdinByte,
+    now: async () => ok(now()),
+    sandbox: async f => ok(await sandbox(f)),
+    await: async p => ok(await awaitPromise(p)),
+    write: async (stream, data) => ok(await writeAll(streams[stream], fromVec(data))),
+    read: async () => ok(await readStdinByte()),
     test: async (ctx, name, expectFailure, test) =>
-        ctx.test(name, { expectFailure }, async t => runNodeEffect(test(t))),
+        // The body's answer is `ok(undefined)` — a `Test` callback absorbs its
+        // own failures by panicking, which is the only signal these frameworks
+        // read — so it is awaited and discarded rather than returned.
+        ok(await ctx.test(name, { expectFailure }, async t => { await runNodeEffect(test(t)) })),
 })
 
 /** @type {TestFn} */
@@ -377,8 +388,8 @@ const options = {
  * the program's code, use {@link run} instead.
  * @type {(p: NodeProgram) => Promise<number>}
  */
-export const runEffect = program =>
-    runNodeEffect(program(options))
+export const runEffect = async program =>
+    exitCode(await runNodeEffect(program(options)))
 
 /**
  * CLI entry point: runs a `NodeProgram` via {@link runEffect}, then calls

package/fjs/effects/node/proof.f.d.mts

@@ -1,11 +1,37 @@
 /**
  * @import { Vec } from "../../types/bit_vec/types.ts"
- * @import { IoResult, ReadFile } from "./types.ts"
- * @import { Dir } from "./virtual/types.ts"
+ * @import { IoChannel, IoError, IoResult, ReadFile } from "./types.ts"
+ * @import { Result } from "../../types/result/types.ts"
  * @import { List } from "../list/types.ts"
  * @import { OperationMap } from "../types.ts"
  */
 export declare const proof: {
+    toIoError: {
+        error: () => void;
+        withCode: () => void;
+        string: () => void;
+        null: () => void;
+        nonStringCode: () => void;
+        noCode: () => void;
+    };
+    isNotFound: {
+        enoent: () => void;
+        otherCode: () => void;
+        notImplemented: () => void;
+    };
+    errorMessage: {
+        io: () => void;
+        notImplemented: () => void;
+    };
+    errorSummary: {
+        io: () => void;
+        ioWithoutCode: () => void;
+        notImplemented: () => void;
+    };
+    exitStep: {
+        ok: () => void;
+        error: () => void;
+    };
     externalTestContext: () => void;
     map: () => void;
     fetch: () => void;

package/fjs/effects/node/proof.f.mjs

@@ -1,15 +1,16 @@
 /**
  * @import { Vec } from "../../types/bit_vec/types.ts"
- * @import { IoResult, ReadFile } from "./types.ts"
- * @import { Dir } from "./virtual/types.ts"
+ * @import { IoChannel, IoError, IoResult, ReadFile } from "./types.ts"
+ * @import { Result } from "../../types/result/types.ts"
  * @import { List } from "../list/types.ts"
  * @import { OperationMap } from "../types.ts"
  */
 
 import { empty, isVec, uint, vec, vec8 } from "../../types/bit_vec/module.f.mjs"
 import { utf8, utf8ToString } from "../../text/module.f.mjs"
-import { match, pure, step } from "../module.f.mjs"
-import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream, usesInlineTestContext, versionLessThan } from "./module.f.mjs"
+import { match } from "../module.f.mjs"
+import { mapStep, step as ioStep } from "../module.f.mjs"
+import { both, errorMessage, errorSummary, exitStep, fetch, ioError, isNotFound, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, toIoError, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream, usesInlineTestContext, versionLessThan } from "./module.f.mjs"
 import { create as memCreate, read as memRead, write as memWrite } from "../memory/module.f.mjs"
 import { empty as listEmpty, nonEmpty as listNonEmpty } from "../list/module.f.mjs"
 import { emptyState, virtual } from "./virtual/module.f.mjs"
@@ -29,7 +30,115 @@ const readHelloMap = {
 
 const readHello = match(readHelloMap)
 
+/**
+ * Asserts that a channel error is a host failure carrying `message`. Every
+ * runner reports through the same normalized {@link IoError}, so a proof
+ * against the virtual filesystem names the message rather than the shape.
+ * @type {(e: IoChannel, message: string) => void}
+ */
+const assertIoMessage = (e, message) => {
+    assert(e[0] === 'ioError', e)
+    assertEq(e[1].message, message)
+}
+
+/** Asserts that an operation succeeded with `expected`.
+ * @type {<T, E>(r: Result<T, E>, expected: T) => void}
+ */
+const assertOk = (r, expected) => {
+    assert(r[0] === 'ok', r)
+    assertEq(r[1], expected)
+}
+
 export const proof = {
+    // The one boundary where a runner's `catch` becomes effect data: whatever
+    // was thrown is reduced to a code (when the host attached a string one)
+    // and a message.
+    toIoError: {
+        error: () => {
+            assertIoMessage(toIoError(new Error('boom')), 'boom')
+        },
+        withCode: () => {
+            const e = toIoError(Object.assign(new Error('missing'), { code: 'ENOENT' }))
+            assert(e[0] === 'ioError', e)
+            assertEq(e[1].code, 'ENOENT', e)
+            assertEq(e[1].message, 'missing', e)
+        },
+        // A thrown non-`Error` still normalizes: the value's string form is the
+        // message, and there is no code to carry.
+        string: () => {
+            const e = toIoError('plain')
+            assert(e[0] === 'ioError', e)
+            assertEq(e[1].code, undefined, e)
+            assertEq(e[1].message, 'plain', e)
+        },
+        null: () => {
+            assertIoMessage(toIoError(null), 'null')
+        },
+        // An object whose `code` is not a string is not an OS error code, so it
+        // is dropped rather than carried as one.
+        nonStringCode: () => {
+            const e = toIoError({ code: 42 })
+            assert(e[0] === 'ioError', e)
+            assertEq(e[1].code, undefined, e)
+        },
+        noCode: () => {
+            const e = toIoError({})
+            assert(e[0] === 'ioError', e)
+            assertEq(e[1].code, undefined, e)
+        },
+    },
+    isNotFound: {
+        enoent: () => {
+            assert(isNotFound(ioError({ code: 'ENOENT', message: 'no such file or directory' })))
+        },
+        otherCode: () => {
+            assert(!isNotFound(ioError({ code: 'EACCES', message: 'permission denied' })))
+        },
+        // A runner that cannot perform the operation has not looked for the
+        // path at all, so a missing handler is never "not found".
+        notImplemented: () => {
+            assert(!isNotFound(['notImplemented', 'readFile']))
+        },
+    },
+    errorMessage: {
+        io: () => {
+            assertEq(errorMessage(ioError({ message: 'disk full' })), 'disk full')
+        },
+        notImplemented: () => {
+            assertEq(errorMessage(['notImplemented', 'readFile']), 'operation not implemented: readFile')
+        },
+    },
+    errorSummary: {
+        // The distinction that matters: `errorMessage` hands back the host's
+        // words, which is where the path lives; `errorSummary` never does.
+        io: () => {
+            assertEq(errorSummary(ioError({ code: 'ENOENT', message: "no such file or directory, scandir '/home/u/.cas'" })), 'io error: ENOENT')
+        },
+        ioWithoutCode: () => {
+            assertEq(errorSummary(ioError({ message: "cannot read '/home/u/.cas'" })), 'io error')
+        },
+        notImplemented: () => {
+            assertEq(errorSummary(['notImplemented', 'readdir']), 'operation not implemented: readdir')
+        },
+    },
+    exitStep: {
+        // The exit-code policy a `NodeProgram` ends with: success is `0`...
+        ok: () => {
+            const [state, code] = virtual(emptyState)(exitStep(writeFile('hello', vec8(0x2An))))
+            assertEq(code[0], 'ok')
+            assertEq(code[1], 0)
+            assertEq(state.stderr, '')
+        },
+        // ...and a failure is reported on `stderr` and exits `1`.
+        // ...and the code is `[1]` either way, which is what lets a runner
+        // read it without asking which branch it came from.
+        error: () => {
+            const [state, code] = virtual(emptyState)(exitStep(readFile('missing')))
+            assertEq(code[0], 'error')
+            assertEq(code[1], 1)
+            assertEq(state.stderr, 'no such file or directory\n')
+        },
+    },
     externalTestContext: () => {
         assert(usesInlineTestContext('node', 'v22.20.0'))
         assert(usesInlineTestContext('node', '25.99.99'))
@@ -44,18 +153,15 @@ export const proof = {
         assert(!versionLessThan('26.1.1', '26.1.1'))
     },
     map: () => {
-        const e = step(
-            readFile('hello'),
-            ([k, v]) => {
-                assert(k !== 'error', v)
-                return pure(uint(v) * 2n)
-            })
+        const e = mapStep(readFile('hello'), v => uint(v) * 2n)
         //
         let r = readHello(e)
         while (r[0] === 'cont') {
             r = readHello(r[2](r[1]))
         }
-        assertEq(r[1], 0x2An)
+        // `done` carries the whole `Result`: an interpreter never separates the
+        // channels, so the projection's value is inside the `ok`.
+        assertEq(r[1][1], 0x2An)
     },
     fetch: () => {
         const [_, [t, result]] = virtual({
@@ -81,8 +187,11 @@ export const proof = {
             )
             assert(t === 'ok', result)
             const tmp = state.root.tmp
-            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root)
-            const cache = (/** @type {Dir} */ (tmp)).cache
+            // `instanceof Array`, not `Array.isArray`: only the former's negative
+            // branch removes a `readonly` array from a union, so only it narrows
+            // `_Entity` to `Dir`.
+            assert(!(typeof tmp !== 'object' || tmp instanceof Array), state.root)
+            const cache = tmp.cache
             assert(!(typeof cache !== 'object' || Array.isArray(cache)), tmp)
         },
         nonRec: () => {
@@ -122,7 +231,8 @@ export const proof = {
         nestedPath: () => {
             const [_, [t, result]] = virtual(emptyState)(readFile('tmp/cache'))
             assert(t === 'error', result)
-            if ((/** @type {{ code?: unknown }} */ (result)).code !== 'ENOENT') { throw result }
+            assert(result[0] === 'ioError', result)
+            assertEq(result[1].code, 'ENOENT', result)
         },
         withinLimit: () => {
             // Test with a small file well within the 131,072 byte limit
@@ -197,7 +307,7 @@ export const proof = {
         noSuchDir: () => {
             const [_, [t, result]] = virtual(emptyState)(readdir('tmp', { recursive: true }))
             assert(t === 'error', result)
-            assertEq(result, 'invalid path')
+            assertIoMessage(result, 'invalid path')
         },
     },
     writeFile: {
@@ -229,7 +339,7 @@ export const proof = {
                 writeFile('tmp/cache', vec8(0x2An))
             )
             assert(t === 'error', result)
-            assertEq(result, 'invalid file')
+            assertIoMessage(result, 'invalid file')
             assertEq(state.root.tmp, undefined, state.root)
         },
         directory: () => {
@@ -242,7 +352,7 @@ export const proof = {
                 writeFile('tmp', vec8(0x2An))
             )
             assert(t === 'error', result)
-            assertEq(result, 'invalid file')
+            assertIoMessage(result, 'invalid file')
             const tmp = state.root.tmp
             assert(!(tmp === undefined || Array.isArray(tmp)), tmp)
         },
@@ -272,13 +382,13 @@ export const proof = {
             })(rm('tmp/cache'))
             assert(t === 'ok', result)
             const tmp = state.root.tmp
-            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root)
-            assertEq((/** @type {Dir} */ (tmp)).cache, undefined, tmp)
+            assert(!(typeof tmp !== 'object' || tmp instanceof Array), state.root)
+            assertEq(tmp.cache, undefined, tmp)
         },
         noSuchFile: () => {
             const [_, [t, result]] = virtual(emptyState)(rm('hello'))
             assert(t === 'error', result)
-            assertEq(result, 'no such file')
+            assertIoMessage(result, 'no such file')
         },
         isDirectory: () => {
             const [state, [t, result]] = virtual({
@@ -286,18 +396,20 @@ export const proof = {
                 root: { tmp: {} },
             })(rm('tmp'))
             assert(t === 'error', result)
-            assertEq(result, 'invalid path')
+            assertIoMessage(result, 'invalid path')
             assert(state.root.tmp !== undefined, state.root)
         },
     },
     both: () => {
-        const [_, results] = virtual({
+        const [_, both2] = virtual({
             ...emptyState,
             root: {
                 a: [vec8(0x2An)],
                 b: [vec8(0x15n)],
             },
         })(both(readFile('a'))(readFile('b')))
+        assert(both2[0] === 'ok', both2)
+        const results = both2[1]
         assert(results[0][0] === 'ok', results[0])
         assert(results[1][0] === 'ok', results[1])
         assertEq(uint(results[0][1]), 0x2An, results[0][1])
@@ -305,41 +417,48 @@ export const proof = {
     },
     now: () => {
         const [_, result] = virtual({ ...emptyState, epochNs: 1_000_000 })(now())
-        assertEq(result, 1_000_000)
+        assertOk(result, 1_000_000)
     },
     sandbox: {
         // Virtual `sandbox` is now a pass-through: the function is expected
         // to return a `SandboxResult` directly. Fixtures dictate the result
         // (and `duration`) instead of the runner measuring.
         ok: () => {
-            const [_, { result, duration }] = virtual(emptyState)(
-                sandbox(() => /** @type {never} */ ({ result: ['ok', 42], duration: 0 })))
+            const [_, sandboxed] = virtual(emptyState)(
+                sandbox(() => ({ result: ['ok', 42], duration: 0 })))
+            // Two `Result`s, one inside the other on purpose: the outer one is
+            // the operation's own status, the inner one is the sandboxed
+            // function's outcome — returned data, not effect status.
+            assert(sandboxed[0] === 'ok', sandboxed)
+            const { result, duration } = sandboxed[1]
             assert(result[0] === 'ok', result)
             assertEq(result[1], 42)
             assertEq(duration, 0)
         },
         error: () => {
             const err = new Error('fail')
-            const [_, { result }] = virtual(emptyState)(
-                sandbox(() => /** @type {never} */ ({ result: ['error', err], duration: 0 })))
+            const [_, sandboxed] = virtual(emptyState)(
+                sandbox(() => ({ result: ['error', err], duration: 0 })))
+            assert(sandboxed[0] === 'ok', sandboxed)
+            const { result } = sandboxed[1]
             assert(result[0] === 'error', result)
             assertEq(result[1], err)
         },
     },
     memory: {
         createAndRead: () => {
-            const effect = step(memCreate(42), key => memRead(key))
+            const effect = ioStep(memCreate(42), key => memRead(key))
             const [_, value] = virtual(emptyState)(effect)
-            assertEq(value, 42)
+            assertOk(value, 42)
         },
         createAndWrite: () => {
-            const effect = step(
+            const effect = ioStep(
                     memCreate(1),
-                    key => step(
+                    key => ioStep(
                         memWrite(key, 99),
                         () => memRead(key)))
             const [_, value] = virtual(emptyState)(effect)
-            assertEq(value, 99)
+            assertOk(value, 99)
         },
     },
     rename: {
@@ -351,7 +470,7 @@ export const proof = {
             assert(t === 'ok', result)
             assertEq(state.root.src, undefined, state.root)
             assert(Array.isArray(state.root.dst), state.root)
-            assertEq(uint((/** @type {readonly Vec[]} */ (state.root.dst))[0]), 0x2An, state.root)
+            assertEq(uint(state.root.dst[0]), 0x2An, state.root)
         },
         nestedRename: () => {
             const [state, [t, result]] = virtual({
@@ -360,8 +479,8 @@ export const proof = {
             })(rename('tmp/src', 'tmp/dst'))
             assert(t === 'ok', result)
             const tmp = state.root.tmp
-            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root)
-            assertEq((/** @type {Dir} */ (tmp)).src, undefined, tmp)
+            assert(!(typeof tmp !== 'object' || tmp instanceof Array), state.root)
+            assertEq(tmp.src, undefined, tmp)
         },
         dirOverFile: () => {
             const [state, [t, result]] = virtual({
@@ -408,18 +527,18 @@ export const proof = {
     randomInt: {
         increments: () => {
             const [state1, r1] = virtual(emptyState)(randomInt())
-            assertEq(r1, 0)
+            assertOk(r1, 0)
             const [state2, r2] = virtual(state1)(randomInt())
-            assertEq(r2, 1)
+            assertOk(r2, 1)
             const [_, r3] = virtual(state2)(randomInt())
-            assertEq(r3, 2)
+            assertOk(r3, 2)
         },
     },
     writeFromStream: {
         createExclusiveFails: () => {
             // The destination already exists, so `createExclusive` fails (EEXIST) and
             // the error propagates without ever touching `writeBytes`.
-            /** @type {List<never, IoResult<Vec>>} */
+            /** @type {List<never, Vec, IoChannel>} */
             const chunks = listEmpty()
             const [state, [t, result]] = virtual({
                 ...emptyState,
@@ -432,13 +551,13 @@ export const proof = {
         invalidBufferSize: () => {
             // A chunk whose bit length isn't a multiple of 8 trips the
             // byte-alignment guard before `writeBytes` is ever called.
-            /** @type {List<never, IoResult<Vec>>} */
-            const chunks = listNonEmpty(['ok', vec(4n)(0b1010n)], listEmpty())
+            /** @type {List<never, Vec, IoChannel>} */
+            const chunks = listNonEmpty(vec(4n)(0b1010n), listEmpty())
             const [_, [t, result]] = virtual(emptyState)(
                 writeFromStream('hello', chunks)
             )
             assert(t === 'error', result)
-            assertEq(result, 'invalid buffer size')
+            assertIoMessage(result, 'invalid buffer size')
         },
     },
 }