functionalscript 0.44.0 → 0.45.0

package/fjs/cas/evo/module.f.mjs

@@ -53,14 +53,13 @@
  * @import { Hash, Subject, RevisionData, SubjectState, Cache, Evo } from './types.ts'
  */
 
-import { pure, foldStep } from '../../effects/module.f.mjs'
-import { eff } from '../../effects/eff/module.f.mjs'
+import { pure, foldStep, mapStep, step } from '../../effects/module.f.mjs'
 import { create, read, write } from '../../effects/memory/module.f.mjs'
 import { collectRead } from '../module.f.mjs'
 import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.mjs'
 import { fromVec } from '../../text/utf8/module.f.mjs'
 import { tryUtf8 } from '../../text/module.f.mjs'
-import { ok, error } from '../../types/result/module.f.mjs'
+import { ok, error, okThen } from '../../types/result/module.f.mjs'
 import { nonEmpty, empty as elEmpty } from '../../effects/list/module.f.mjs'
 import { at, definedEntries } from '../../types/object/module.f.mjs'
 import { unwrap } from '../../types/nullable/module.f.mjs'
@@ -185,9 +184,9 @@ export const decodeRevisionVec = value => {
  * @returns {(hash: Vec) => Effect<O, Revision | null>}
  */
 export const decodeRevisionBlob = cas => hash =>
-    eff(collectRead(cas.read(hash)))
-        .map(([tag, value]) => tag === 'error' ? null : decodeRevisionVec(value))
-        .value
+    mapStep(
+        collectRead(cas.read(hash)),
+        ([tag, value]) => tag === 'error' ? null : decodeRevisionVec(value))
 
 /**
  * Scans every hash in `cas` and builds a fresh {@link Cache} from the
@@ -202,11 +201,10 @@ export const buildCache = cas =>
         cas.list(),
         emptyCache,
         hash => cache =>
-            eff(decodeRevisionBlob(cas)(hash))
-                .step(revision =>
-                    pure(revision === null ? cache : addRevisionToCache(vecToCBase32(hash), revision)(cache))
-                )
-                .value)
+            mapStep(
+                decodeRevisionBlob(cas)(hash),
+                revision =>
+                    revision === null ? cache : addRevisionToCache(vecToCBase32(hash), revision)(cache)))
 
 /**
  * Scans `cas` once and allocates a memory slot holding the resulting {@link Cache}.
@@ -216,17 +214,13 @@ export const buildCache = cas =>
  * @returns {Effect<O | MemOp, Key<Cache>>}
  */
 export const initEvo = cas =>
-    eff(buildCache(cas))
-        .step(cache => create(cache))
-        .value
+    step(buildCache(cas), cache => create(cache))
 
 /** Reads, then rewrites, the cache at `cacheKey` with `revision` folded in at `hash`.
  * @type {(cacheKey: Key<Cache>) => (hash: Hash) => (revision: Revision) => Effect<MemOp, void>}
  */
 const foldIntoCache = cacheKey => hash => revision =>
-    eff(read(cacheKey))
-        .step(cache => write(cacheKey, addRevisionToCache(hash, revision)(cache)))
-        .value
+    step(read(cacheKey), cache => write(cacheKey, addRevisionToCache(hash, revision)(cache)))
 
 /**
  * Folds `value` — bytes already written to a `Cas` at `hash` by some other
@@ -259,11 +253,9 @@ const resolveParent = cas => parentRef => {
     if (parentHash === null) {
         return pure(error(`invalid parent hash: ${parentRef}`))
     }
-    return eff(decodeRevisionBlob(cas)(parentHash))
-        .step(parent =>
-            pure(parent === null ? error(`parent is not a revision blob: ${parentRef}`) : ok(parent))
-        )
-        .value
+    return mapStep(
+        decodeRevisionBlob(cas)(parentHash),
+        parent => parent === null ? error(`parent is not a revision blob: ${parentRef}`) : ok(parent))
 }
 
 /**
@@ -281,12 +273,11 @@ const resolveParents = cas => parents => {
         init,
         parentRef => (/** @type {Result<readonly Revision[], string>} */ acc) => {
             if (acc[0] === 'error') { return pure(acc) }
-            return eff(resolveParent(cas)(parentRef))
-                .step((/** @type {Result<Revision, string>} */ parentResult) =>
-                    /** @type {Effect<never, Result<readonly Revision[], string>>} */
-                    (pure(parentResult[0] === 'error' ? parentResult : ok([...acc[1], parentResult[1]])))
-                )
-                .value
+            return mapStep(
+                resolveParent(cas)(parentRef),
+                (/** @type {Result<Revision, string>} */ parentResult) =>
+                    /** @type {Result<readonly Revision[], string>} */
+                    (parentResult[0] === 'error' ? parentResult : ok([...acc[1], parentResult[1]])))
         })
 }
 
@@ -366,21 +357,73 @@ const computeGeneration = parents =>
     parents.length === 0 ? 0 : 1 + parents.reduce((max, p) => Math.max(max, p.generation), 0)
 
 /**
- * Adds a new revision to `cas` and folds it into the cache at `cacheKey`.
+ * The pure half of {@link addRevision}: turns already-resolved `parents` into
+ * the exact `Revision` that will be stored, or the first reason it cannot be.
  *
- * Steps: resolve and validate every parent ({@link resolveParents}), resolve
- * `subject` from them ({@link resolveSubject}) and check every parent
- * actually belongs to it ({@link validateParentSubjects}), resolve `snapshot`
- * ({@link resolveSnapshot}) and compute `generation`
- * ({@link computeGeneration}), assemble a `Revision` and check its hash /
+ * Resolves `subject` ({@link resolveSubject}) and checks every parent belongs
+ * to it ({@link validateParentSubjects}), resolves `snapshot`
+ * ({@link resolveSnapshot}) and computes `generation`
+ * ({@link computeGeneration}), assembles the `Revision` and checks its hash /
  * generation semantics (`fjs/media/revision` `checkReferences` — the same rule
- * a reader applies; the shape itself is already guaranteed by this function's
- * own field types), encode and write it to `cas`, then fold the new revision
- * into the cache. Every failure — an invalid or missing parent, a
- * cross-subject parent, an unresolvable subject or snapshot, an invalid
- * revision, a blob too large to encode, or a store write failure — is
- * reported as `error(message)` rather than thrown, so a caller (e.g. an MCP
- * tool handler) can surface it without a `throw`/`catch`.
+ * a reader applies; the shape itself is already guaranteed by the field types
+ * here), then canonicalizes it.
+ *
+ * Canonicalizing parent/snapshot spellings is only safe once `checkReferences`
+ * has confirmed they decode, which makes the `unwrap` inside
+ * {@link canonicalHash} safe. It is not optional: two `add` calls describing
+ * the same logical revision but spelled differently (case, `i`/`l`/`o`
+ * aliases) must serialize identically, or they would produce two distinct CAS
+ * blobs that both remain heads — the point of `canonicalHash` (see the module
+ * doc) is defeated if this module itself writes non-canonical spellings.
+ *
+ * Separate from {@link addRevision} because none of it touches the store:
+ * everything up to the bytes is a plain `Result` pipeline, so `addRevision` is
+ * left holding only the encode, the write, and the cache fold. Each step also
+ * reads values resolved by earlier ones, which is why the guards are a flat
+ * sequence rather than an `okThen` chain — see `okThen`'s own note in
+ * [`fjs/types/result`](../../types/result/module.f.mjs).
+ *
+ * @param {RevisionData} input
+ * @returns {(parents: readonly Revision[]) => Result<Revision, string>}
+ */
+const buildRevision = input => parents => {
+    const subjectResult = resolveSubject(input)(parents)
+    if (subjectResult[0] === 'error') { return subjectResult }
+    const subject = subjectResult[1]
+    const parentSubjectsResult = validateParentSubjects(subject)(parents)
+    if (parentSubjectsResult[0] === 'error') { return parentSubjectsResult }
+    const snapshotResult = resolveSnapshot(input)(subject)(parents)
+    if (snapshotResult[0] === 'error') { return snapshotResult }
+    /** @type {Revision} */
+    const revision = {
+        dialect,
+        subject,
+        parents: input.parents,
+        snapshot: snapshotResult[1],
+        generation: computeGeneration(parents),
+        archived: input.archived,
+        lock: input.lock,
+    }
+    const referencesResult = checkReferences(revision)
+    if (referencesResult[0] === 'error') { return referencesResult }
+    return ok({
+        ...revision,
+        parents: revision.parents.map(canonicalHash),
+        snapshot: canonicalHash(revision.snapshot),
+        lock: revision.lock === undefined ? undefined : canonicalLock(revision.lock),
+    })
+}
+
+/**
+ * Adds a new revision to `cas` and folds it into the cache at `cacheKey`.
+ *
+ * Steps: resolve and validate every parent ({@link resolveParents}), derive
+ * the revision to store from them ({@link buildRevision}), then encode it,
+ * write it to `cas`, and fold it into the cache. Every failure — an invalid
+ * or missing parent, a cross-subject parent, an unresolvable subject or
+ * snapshot, an invalid revision, a blob too large to encode, or a store write
+ * failure — is reported as `error(message)` rather than thrown, so a caller
+ * (e.g. an MCP tool handler) can surface it without a `throw`/`catch`.
  *
  * `input.generation` is ignored: it exists on {@link RevisionData} only so a
  * value read back by {@link readRevision} round-trips into `add` unchanged,
@@ -392,58 +435,26 @@ const computeGeneration = parents =>
  * @returns {(cacheKey: Key<Cache>) => (input: RevisionData) => Effect<O | MemOp, Result<Hash, string>>}
  */
 export const addRevision = cas => cacheKey => input =>
-    eff(resolveParents(cas)(input.parents))
-        .step((/** @type {Result<readonly Revision[], string>} */ parentsResult) => {
-            if (parentsResult[0] === 'error') { return pure(parentsResult) }
-            const subjectResult = resolveSubject(input)(parentsResult[1])
-            if (subjectResult[0] === 'error') { return pure(subjectResult) }
-            const parentSubjectsResult = validateParentSubjects(subjectResult[1])(parentsResult[1])
-            if (parentSubjectsResult[0] === 'error') { return pure(parentSubjectsResult) }
-            const snapshotResult = resolveSnapshot(input)(subjectResult[1])(parentsResult[1])
-            if (snapshotResult[0] === 'error') { return pure(snapshotResult) }
-            /** @type {Revision} */
-            const revision = {
-                dialect,
-                subject: subjectResult[1],
-                parents: input.parents,
-                snapshot: snapshotResult[1],
-                generation: computeGeneration(parentsResult[1]),
-                archived: input.archived,
-                lock: input.lock,
-            }
-            const referencesResult = checkReferences(revision)
-            if (referencesResult[0] === 'error') { return pure(referencesResult) }
-            // Canonicalize parent/snapshot spellings now that checkReferences has
-            // confirmed they decode (`unwrap` inside `canonicalHash` is safe):
-            // two `add` calls describing the same logical revision but spelled
-            // differently (case, `i`/`l`/`o` aliases) must serialize identically,
-            // or they'd produce two distinct CAS blobs that both remain heads —
-            // the point of `canonicalHash` (see the module doc) is defeated if
-            // this module itself writes non-canonical spellings.
-            /** @type {Revision} */
-            const canonicalRevision = {
-                ...revision,
-                parents: revision.parents.map(canonicalHash),
-                snapshot: canonicalHash(revision.snapshot),
-                lock: revision.lock === undefined ? undefined : canonicalLock(revision.lock),
-            }
+    step(
+        resolveParents(cas)(input.parents),
+        (/** @type {Result<readonly Revision[], string>} */ parentsResult) => {
+            const revisionResult = okThen(buildRevision(input))(parentsResult)
+            if (revisionResult[0] === 'error') { return pure(revisionResult) }
+            const canonicalRevision = revisionResult[1]
             const bytes = tryUtf8(encodeText(canonicalRevision))
             if (bytes === null) {
                 return pure(error('revision too large to encode'))
             }
-            return eff(cas.write(nonEmpty(ok(bytes), /** @type {List<never, Ok<Vec>>} */ (elEmpty()))))
-                .step((/** @type {IoResult<Vec>} */ writeResult) => {
+            return step(
+                cas.write(nonEmpty(ok(bytes), /** @type {List<never, Ok<Vec>>} */ (elEmpty()))),
+                (/** @type {IoResult<Vec>} */ writeResult) => {
                     if (writeResult[0] === 'error') {
                         return /** @type {Effect<MemOp, Result<Hash, string>>} */ (pure(error('failed to write revision to CAS')))
                     }
                     const hash = vecToCBase32(writeResult[1])
-                    return eff(foldIntoCache(cacheKey)(hash)(canonicalRevision))
-                        .step(() => pure(ok(hash)))
-                        .value
+                    return mapStep(foldIntoCache(cacheKey)(hash)(canonicalRevision), () => ok(hash))
                 })
-                .value
         })
-        .value
 
 /**
  * Projects a decoded `Revision` into the shared {@link RevisionData}
@@ -525,9 +536,7 @@ export const readRevision = cas => hash => {
     const hashVec = cBase32ToVec(hash)
     return hashVec === null
         ? pure(error(`invalid hash: ${hash}`))
-        : eff(collectRead(cas.read(hashVec)))
-            .map(decodeReadRevision(hash))
-            .value
+        : mapStep(collectRead(cas.read(hashVec)), decodeReadRevision(hash))
 }
 
 /**
@@ -540,17 +549,15 @@ export const readRevision = cas => hash => {
 export const evo = cas => cacheKey => ({
     list: archived => {
         const listed = subjectListed(archived)
-        return eff(read(cacheKey))
-            .step(cache => pure(definedEntries(cache.bySubject)
-                .flatMap(([subject, state]) => listed(state) ? [subject] : [])))
-            .value
+        return mapStep(
+            read(cacheKey),
+            cache => definedEntries(cache.bySubject)
+                .flatMap(([subject, state]) => listed(state) ? [subject] : []))
     },
-    head: subject => eff(read(cacheKey))
-        .step(cache => {
-            const state = at(subject)(cache.bySubject)
-            return pure(state === null ? [] : headsOf(state))
-        })
-        .value,
+    head: subject => mapStep(read(cacheKey), cache => {
+        const state = at(subject)(cache.bySubject)
+        return state === null ? [] : headsOf(state)
+    }),
     add: input => addRevision(cas)(cacheKey)(input),
     revision: readRevision(cas),
 })

package/fjs/cas/evo/proof.f.mjs

@@ -7,7 +7,11 @@
  * @import { RevisionData } from './types.ts'
  */
 
-import { assert, assertEq } from '../../asserts/module.f.mjs'
+import {
+    assert,
+    assertEq,
+    assertStructurallySame,
+} from '../../asserts/module.f.mjs'
 import { pure } from '../../effects/module.f.mjs'
 import { fileCas } from '../module.f.mjs'
 import { sha256 } from '../../crypto/sha2/module.f.mjs'
@@ -18,7 +22,6 @@ import { unwrap } from '../../types/nullable/module.f.mjs'
 import { ok, error } from '../../types/result/module.f.mjs'
 import { nonEmpty, empty as elEmpty } from '../../effects/list/module.f.mjs'
 import { tryUtf8 } from '../../text/module.f.mjs'
-
 import { dialect as revisionDialect } from '../../media/revision/module.f.mjs'
 import {
     buildCache, decodeRevisionBlob, initEvo, evo, emptyCache, syncRevision,
@@ -65,7 +68,7 @@ export const proof = {
     buildCacheEmptyStoreYieldsEmptyCache: () => {
         const c = fileCas(sha256)(home)
         const [, cache] = virtual(emptyState)(buildCache(c))
-        assertEq(JSON.stringify(cache), JSON.stringify(emptyCache))
+        assertStructurallySame(cache, emptyCache)
     },
     buildCacheSkipsNonRevisionBlob: () => {
         const c = fileCas(sha256)(home)

package/fjs/cas/module.f.mjs

@@ -22,8 +22,7 @@ import { sha256 } from '../crypto/sha2/module.f.mjs'
 import { join, normalize, parse } from '../path/module.f.mjs'
 import { empty, length, maxLength, maxLengthBytes, msb, vec } from '../types/bit_vec/module.f.mjs'
 import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.mjs'
-import { foldStep, forEachStep, history, historyStep, okStep, pure, step } from '../effects/module.f.mjs'
-import { eff } from '../effects/eff/module.f.mjs'
+import { foldStep, forEachStep, history, historyStep, mapStep, okStep, pure, step } from '../effects/module.f.mjs'
 import {
     access,
     createExclusive,
@@ -74,18 +73,16 @@ export const toPath = key => {
 export const collectRead = stream => {
     /** @type {(acc: Vec) => (s: List<O, IoResult<Vec>>) => Effect<O, IoResult<Vec>>} */
     const loop = acc => s =>
-        eff(s)
-            .step((/** @type {*} */ node) => {
-                if (node === undefined) { return pure(ok(acc)) }
-                const { first, tail } = node
-                const [t, v] = first
-                if (t === 'error') { return pure(first) }
-                if (length(acc) + length(v) > maxLength) {
-                    return pure(error(`cas blob exceeds maximum vector length of ${maxLength} bits`))
-                }
-                return loop(msb.concat(acc)(v))(tail)
-            })
-            .value
+        step(s, node => {
+            if (node === undefined) { return pure(ok(acc)) }
+            const { first, tail } = node
+            const [t, v] = first
+            if (t === 'error') { return pure(first) }
+            if (length(acc) + length(v) > maxLength) {
+                return pure(error(`cas blob exceeds maximum vector length of ${maxLength} bits`))
+            }
+            return loop(msb.concat(acc)(v))(tail)
+        })
     return loop(empty)(stream)
 }
 
@@ -133,21 +130,24 @@ const deadlineOf = name => Number(name.slice(0, name.indexOf('-')))
  * @param {string} stageDir
  * @returns {Effect<O, void>}
  */
-const gcStage = stageDir =>
-    eff(now())
-        .step(() => readdir(stageDir, {}))
-        .step(([k, v], t) => {
+const gcStage = stageDir => {
+    // The `readdir` result and the `now()` timestamp are both needed by the last
+    // link, so the timestamp is carried forward in a history rather than closed
+    // over by a nested continuation.
+    const listed = historyStep(
+        history(now()),
+        () => readdir(stageDir, {}))
+    return step(
+        listed,
+        ([[k, v], t]) => {
             if (k === 'error') { return pure(undefined) }
             const expired = v.flatMap(d =>
                 d.isFile && deadlineOf(d.name) < t ? [d.name] : [])
             return forEachStep(
                 pure(expired),
-                name =>
-                    eff(rm(join(stageDir, name)))
-                        .step(() => pure(undefined))
-                        .value)
+                name => mapStep(rm(join(stageDir, name)), () => undefined))
         })
-        .value
+}
 
 // Lock-free staging upload (plan/staging-lease.md): stream each chunk straight
 // to a `_stage/<deadline>-<rand>` file via `writeBytes` while folding it into the
@@ -176,69 +176,61 @@ const writeImpl = (sha2, path, stageDir, payload) => {
         const rel = toPath(hash)
         const dst = join(path, rel)
         const dstDir = join(path, ...parse(rel).slice(0, -1))
-        return eff(mkdir(dstDir, { recursive: true }))
-            .step(() => rename(curPath, dst))
-            .step(() => rm(curPath))
-            .step(() => stat(dst))
-            .step(st => pure(st[0] === 'ok' && st[1].size === offset ? ok(hash) : error('publish size mismatch')))
-            .value
+        const created = step(mkdir(dstDir, { recursive: true }), () => rename(curPath, dst))
+        const removed = step(created, () => rm(curPath))
+        const stated = step(removed, () => stat(dst))
+        return mapStep(
+            stated,
+            st => st[0] === 'ok' && st[1].size === offset ? ok(hash) : error('publish size mismatch'))
     }
     // Any streaming error fails closed: delete the partial file, return the error.
     /** @type {(curPath: string, e: unknown) => Effect<FileCasOperation, IoResult<Vec>>} */
     const fail = (curPath, e) =>
-        eff(rm(curPath))
-            .step(() => pure(error(e)))
-            .value
-    return eff(gcStage(stageDir)).step(() =>
-        eff(random256).step(rnd => {
-            const rndStr = vecToCBase32(rnd)
-            /** @type {(state: Sha2State, offset: number, curPath: string) => (stream: List<O1, IoResult<Vec>>) => Effect<O1 | FileCasOperation, IoResult<Vec>>} */
-            const loop = (state, offset, curPath) =>
-                stream =>
-                    eff(stream)
-                        .step((node) => {
-                            if (node === undefined) {
-                                return publish(state, offset, curPath)
-                            }
-                            const { first, tail } = node
-                            if (first[0] === 'error') {
-                                return fail(curPath, first[1])
-                            }
-                            const chunk = first[1]
-                            return eff(writeBytes(curPath, offset, chunk))
-                                .step(wb => {
-                                    if (wb[0] === 'error') { return fail(curPath, wb[1]) }
-                                    const newState = sha2.append(chunk)(state)
-                                    const newOffset = offset + Number(length(chunk) / 8n)
-                                    // Renew the lease: rename to a fresh deadline (keeps `delta` constant).
-                                    // The new path is still needed after the rename, to recurse with,
-                                    // so the rename captures it rather than closing over it.
-                                    const nextPath = step(
-                                        now(),
-                                        t => pure(join(stageDir, stageName(t + leaseDelta, rndStr))))
-                                    const renamed = historyStep(
-                                        history(nextPath),
-                                        next => rename(curPath, next))
-                                    return step(
-                                        renamed,
-                                        ([[rt, v], next]) =>
-                                            rt === 'error'
-                                                ? fail(curPath, v)
-                                                : loop(newState, newOffset, next)(tail))
-                                })
-                                .value
-                        })
-                        .value
-            return eff(mkdir(stageDir, { recursive: true }))
-                .step(() => now())
-                .step(t0 => {
-                    const path0 = join(stageDir, stageName(t0 + leaseDelta, rndStr))
-                    return eff(createExclusive(path0))
-                        .step(okStep(() => loop(sha2.init, 0, path0)(payload)))
-                        .value
+        mapStep(rm(curPath), () => error(e))
+    const rndEffect = step(gcStage(stageDir), () => random256)
+    return step(rndEffect, rnd => {
+        const rndStr = vecToCBase32(rnd)
+        /** @type {(state: Sha2State, offset: number, curPath: string) => (stream: List<O1, IoResult<Vec>>) => Effect<O1 | FileCasOperation, IoResult<Vec>>} */
+        const loop = (state, offset, curPath) =>
+            stream =>
+                step(stream, node => {
+                    if (node === undefined) {
+                        return publish(state, offset, curPath)
+                    }
+                    const { first, tail } = node
+                    if (first[0] === 'error') {
+                        return fail(curPath, first[1])
+                    }
+                    const chunk = first[1]
+                    return step(writeBytes(curPath, offset, chunk), wb => {
+                        if (wb[0] === 'error') { return fail(curPath, wb[1]) }
+                        const newState = sha2.append(chunk)(state)
+                        const newOffset = offset + Number(length(chunk) / 8n)
+                        // Renew the lease: rename to a fresh deadline (keeps `delta` constant).
+                        // The new path is still needed after the rename, to recurse with,
+                        // so the rename captures it rather than closing over it.
+                        const nextPath = step(
+                            now(),
+                            t => pure(join(stageDir, stageName(t + leaseDelta, rndStr))))
+                        const renamed = historyStep(
+                            history(nextPath),
+                            next => rename(curPath, next))
+                        return step(
+                            renamed,
+                            ([[rt, v], next]) =>
+                                rt === 'error'
+                                    ? fail(curPath, v)
+                                    : loop(newState, newOffset, next)(tail))
+                    })
                 })
-                .value
-        }).value).value
+        const started = step(mkdir(stageDir, { recursive: true }), () => now())
+        return step(started, t0 => {
+            const path0 = join(stageDir, stageName(t0 + leaseDelta, rndStr))
+            return step(
+                createExclusive(path0),
+                okStep(() => loop(sha2.init, 0, path0)(payload)))
+        })
+    })
 }
 
 /**
@@ -255,8 +247,9 @@ export const fileCas = sha2 => path => {
             const p = join(path, toPath(hash))
             /** @type {(offset: number) => List<FileCasOperation, IoResult<Vec>>} */
             const loop = offset =>
-                eff(readBytes(p, offset, chunkBytes))
-                    .step(/** @type {(result: IoResult<Vec>) => List<FileCasOperation, IoResult<Vec>>} */ (result) => {
+                step(
+                    readBytes(p, offset, chunkBytes),
+                    /** @type {(result: IoResult<Vec>) => List<FileCasOperation, IoResult<Vec>>} */ (result) => {
                         const [t, v] = result
                         // A missing shard or read error is an explicit error item, never EOF.
                         if (t === 'error') {
@@ -268,7 +261,6 @@ export const fileCas = sha2 => path => {
                             ? elEmpty()
                             : nonEmpty(ok(v), loop(offset + chunkBytes))
                     })
-                    .value
             return loop(0)
         },
         write: payload => writeImpl(sha2, path, stageDir, payload),
@@ -277,20 +269,18 @@ export const fileCas = sha2 => path => {
             // empty store, mirroring how `read` maps a missing shard to an error item.
             // A `.cas` that exists but cannot be read (permissions, corruption) is a
             // genuine storage error and is surfaced, not masked as "no hashes".
-            eff(access(storePrefix))
-                .step(a => {
-                    if (a[0] === 'error') {
-                        if (isNotFound(a[1])) { return pure(/** @type {readonly Vec[]} */ ([])) }
-                        throw a[1]
-                    }
-                    return eff(readdir(storePrefix, { recursive: true }))
-                        .step(r => pure(unwrap(r).flatMap(({ name, parentPath, isFile }) =>
-                            toOption(isFile
-                                ? cBase32ToVec(normalize(parentPath).substring(normalizedStorePrefix.length).replaceAll('/', '') + name)
-                                : null))))
-                        .value
-                })
-                .value,
+            step(access(storePrefix), a => {
+                if (a[0] === 'error') {
+                    if (isNotFound(a[1])) { return pure(/** @type {readonly Vec[]} */ ([])) }
+                    throw a[1]
+                }
+                return mapStep(
+                    readdir(storePrefix, { recursive: true }),
+                    r => unwrap(r).flatMap(({ name, parentPath, isFile }) =>
+                        toOption(isFile
+                            ? cBase32ToVec(normalize(parentPath).substring(normalizedStorePrefix.length).replaceAll('/', '') + name)
+                            : null)))
+            }),
         url: hash =>
             join(path, toPath(hash))
     }
@@ -305,9 +295,7 @@ const random256 =
         pure([0, 1, 2, 3, 4, 5, 6, 7]),
         empty,
         () => (/** @type {Vec} */ acc) =>
-            eff(randomInt())
-                .step(r => pure(msb.concat(acc)(vec(32n)(BigInt(r)))))
-                .value)
+            mapStep(randomInt(), r => msb.concat(acc)(vec(32n)(BigInt(r)))))
 
 /** Streams any file at `filePath` in `<=128 KiB` chunks as a `ListEffect` of `ok` items.
  *
@@ -316,8 +304,9 @@ const random256 =
 const streamFile = filePath => {
     /** @type {(offset: number) => List<ReadBytes, IoResult<Vec>>} */
     const loop = offset =>
-        eff(readBytes(filePath, offset, chunkBytes))
-            .step(/** @type {(result: IoResult<Vec>) => List<ReadBytes, IoResult<Vec>>} */ (result) => {
+        step(
+            readBytes(filePath, offset, chunkBytes),
+            /** @type {(result: IoResult<Vec>) => List<ReadBytes, IoResult<Vec>>} */ (result) => {
                 if (result[0] === 'error') {
                     return nonEmpty(result, elEmpty())
                 }
@@ -326,7 +315,6 @@ const streamFile = filePath => {
                     ? elEmpty()
                     : nonEmpty(ok(chunk), loop(offset + chunkBytes))
             })
-            .value
     return loop(0)
 }
 
@@ -355,9 +343,8 @@ export const casAddFile = cas => path =>
 export const casUpload = home => fileName => {
     const src = join(home, 'cas_upload', fileName)
     const c = fileCas(sha256)(home)
-    return eff(casAddFile(c)(src))
-        .step(okStep(/** @type {(v: Vec) => Effect<Rm, IoResult<Vec>>} */ (v => eff(rm(src))
-            .step(() => pure(ok(v)))
-            .value)))
-        .value
+    return step(
+        casAddFile(c)(src),
+        okStep(/** @type {(v: Vec) => Effect<Rm, IoResult<Vec>>} */ (v =>
+            mapStep(rm(src), () => ok(v)))))
 }

package/fjs/ci/common/module.f.d.mts

@@ -1,4 +1,3 @@
-import type { Step, Job, MetaStep } from './types.ts';
 /**
  * Shared CI types and helpers: GitHub Actions step/job RTTI schemas, the
  * `MetaStep` representation used by tool-specific modules, and assemblers like
@@ -10,6 +9,7 @@ import type { Step, Job, MetaStep } from './types.ts';
  *
  * @import { Step, Job, MetaStep, StepType } from './types.ts'
  */
+import type { Step, Job, MetaStep } from './types.ts';
 import { actions } from '../config/module.f.mjs';
 export declare const os: readonly ['ubuntu', 'macos', 'windows'];
 export declare const architecture: readonly ['intel', 'arm'];

package/fjs/ci/common/module.f.mjs

@@ -9,6 +9,7 @@
  *
  * @import { Step, Job, MetaStep, StepType } from './types.ts'
  */
+
 import { actions, images } from '../config/module.f.mjs'
 import { option, array, record, string } from '../../types/rtti/module.f.mjs'
 import { parse as rttiParse } from '../../types/rtti/parse/module.f.mjs'