functionalscript 0.43.0 → 0.44.0

package/fjs/bnf/token_symbol/proof.f.mjs

@@ -0,0 +1,43 @@
+import { assertEq } from '../../asserts/module.f.mjs'
+import { capacity, encoding } from './module.f.mjs'
+
+const names = /** @type {const} */ (['>>', '>>>=', 'instanceof'])
+
+export const proof = {
+    encode: () => {
+        const { encode } = encoding(names)
+        assertEq(encode('>>'), 0x110000)
+        assertEq(encode('instanceof'), 0x110002)
+    },
+    decode: [
+        () => {
+            const { decode } = encoding(names)
+            assertEq(decode(0x110000), '>>')
+            assertEq(decode(0x110002), 'instanceof')
+        },
+        () => {
+            const { decode } = encoding(names)
+            // past the end of the alphabet, a code point, and `eof`
+            assertEq(decode(0x110003), null)
+            assertEq(decode(0x10FFFF), null)
+            assertEq(decode(0xFFFFFF), null)
+        },
+    ],
+    roundTrip: () => {
+        const { encode, decode } = encoding(names)
+        for (const name of names) {
+            assertEq(decode(encode(name)), name)
+        }
+    },
+    throw: {
+        duplicateName: () => { encoding(['a', 'b', 'a']) },
+        unregisteredName: () => {
+            /** @type {readonly string[]} */
+            const names = ['a']
+            encoding(names).encode('b')
+        },
+        // `capacity` names fit, so one more is the smallest list that doesn't.
+        // The array is sparse, so this costs a length, not the strings.
+        tooManyNames: () => { encoding(new Array(capacity + 1)) },
+    },
+}

package/fjs/bnf/token_symbol/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Types for encoding multi-character token names as single BNF input symbols.
+ *
+ * @module
+ */
+import type { Nullable } from '../../types/nullable/types.ts';
+/**
+ * A bidirectional map between a fixed alphabet of token names and the symbol
+ * range reserved for them.
+ */
+export type Encoding<T extends string> = {
+    /**
+     * The input symbol standing for `name`.
+     *
+     * The result is a bare symbol, the form a tokenizer emits. Wrap it in
+     * `oneEncode` to use it as a terminal of a grammar rule — a symbol and a
+     * `TerminalRange` are both plain numbers, so passing one where the other
+     * belongs is not a type error.
+     */
+    readonly encode: (name: T) => number;
+    /**
+     * The name a symbol stands for, or `null` when the symbol belongs to no
+     * registered name — a code point, `eof`, or a symbol past the end of the
+     * alphabet.
+     */
+    readonly decode: (symbol: number) => Nullable<T>;
+};

package/fjs/bnf/token_symbol/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for encoding multi-character token names as single BNF input symbols.
+ *
+ * @module
+ */
+export {};

package/fjs/bnf/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Type-level API for BNF grammar primitives and helpers.
+ *
+ * @module
+ */
+import type { StringMap } from '../types/object/types.ts';
+/**
+ * A range of symbols. Two 24-bit numbers are stored in one JS number (48 bits).
+ *
+ * For example: 0xBBBBBB_EEEEEE
+ * - 0xBBBBBB is the first symbol (24 bits)
+ * - 0xEEEEEE is the last symbol (24 bits)
+ *
+ * 24 bits per half, not 26 (the most `float64`'s 52-bit safe-integer mantissa
+ * could fit two of): 24 is divisible by 4, so each half is exactly 6 hex
+ * digits, and the packed pair reads as a plain `0xYYYYYY_ZZZZZZ` literal with
+ * no partial hex digit at either boundary. 26 bits would still be safe to
+ * store but wouldn't align to hex nibbles, making the packed literal harder
+ * to read and split by eye.
+ *
+ * Not 16 bits (32 bits total) either, even though a 32-bit pair would fit in
+ * a JS bitwise operator's native 32-bit range (JS `|`/`&`/`<<`/etc. operate on
+ * 32-bit ints, whereas the 48-bit pair used here, and even a 52-bit one,
+ * would need converting to `BigInt` for bitwise operations). 16 bits per
+ * symbol can't hold a full Unicode code point: the max scalar value `0x10FFFF`
+ * needs 21 bits, well past `0xFFFF`. So the bitwise-op convenience of 16 loses
+ * to the requirement of representing every Unicode code point in one half.
+ */
+export type TerminalRange = number;
+/** A sequence of rules. */
+export type Sequence = readonly Rule[];
+/** A variant */
+export type Variant = {
+    readonly [k in string]?: Rule;
+};
+/**
+ * Data-only grammar rule.
+ */
+export type DataRule = Variant | Sequence | TerminalRange | string;
+/**
+ * Lazily evaluated grammar rule.
+ */
+export type LazyRule = () => DataRule;
+/**
+ * Grammar rule, either immediate data or lazy rule factory.
+ */
+export type Rule = DataRule | LazyRule;
+/**
+ * A set of terminal ranges compatible with the `Variant` rule.
+ */
+export type RangeVariant = StringMap<TerminalRange>;
+/**
+ * Empty sequence type for optional grammar branches.
+ */
+export type None = readonly [];
+/**
+ * Optional grammar branch.
+ */
+export type Option<S> = {
+    some: S;
+    none: None;
+};
+export type Repeat0Plus<T> = () => Option<readonly [T, Repeat0Plus<T>]>;
+export type Repeat1Plus<T> = readonly [T, Repeat0Plus<T>];
+export type Join1Plus<T, S> = readonly [T, Repeat0Plus<readonly [S, T]>];
+export type Join0Plus<T, S> = Option<readonly [T, Repeat0Plus<readonly [S, T]>]>;
+export type Repeat<T> = readonly T[];

package/fjs/bnf/types.js

@@ -0,0 +1,6 @@
+/**
+ * Type-level API for BNF grammar primitives and helpers.
+ *
+ * @module
+ */
+export {};

package/fjs/cas/cli/module.f.d.mts

@@ -0,0 +1,17 @@
+/**
+ * CAS CLI command handlers.
+ *
+ * @module
+ *
+ * @import { All, Read, Write, WriteFile } from '../../effects/node/types.ts'
+ * @import { Commands } from '../../cli/types.ts'
+ * @import { MemOp } from '../../effects/memory/types.ts'
+ * @import { FileCasOperation } from '../types.ts'
+ */
+import type { All, Read, Write, WriteFile } from '../../effects/node/types.ts';
+import type { Commands } from '../../cli/types.ts';
+import type { MemOp } from '../../effects/memory/types.ts';
+import type { FileCasOperation } from '../types.ts';
+/** @type {Commands<FileCasOperation | WriteFile | Write | All | MemOp | Read>} */
+export declare const commands: Commands<FileCasOperation | WriteFile | Write | All | MemOp | Read>;
+export declare const main: (options: import("../../effects/node/types.ts").NodeProgramOptions) => import("../../effects/types.ts").Effect<All | Read | Write | WriteFile | FileCasOperation | MemOp, number>;

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

@@ -0,0 +1,73 @@
+/**
+ * CAS CLI command handlers.
+ *
+ * @module
+ *
+ * @import { All, Read, Write, WriteFile } from '../../effects/node/types.ts'
+ * @import { Commands } from '../../cli/types.ts'
+ * @import { MemOp } from '../../effects/memory/types.ts'
+ * @import { FileCasOperation } from '../types.ts'
+ */
+
+import { sha256 } from '../../crypto/sha2/module.f.mjs'
+import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.mjs'
+import { forEachStep, pure, step } from '../../effects/module.f.mjs'
+import { errorExit, log, writeFromStream } from '../../effects/node/module.f.mjs'
+import { dispatch } from '../../cli/module.f.mjs'
+import { casAddFile, fileCas } from '../module.f.mjs'
+
+/** @type {Commands<FileCasOperation | WriteFile | Write | All | MemOp | Read>} */
+export const commands = [
+    {
+        names: ['add'],
+        description: 'Store file content and print its hash',
+        handler: ({ home, args: [path, ...rest] }) => {
+            if (path === undefined || rest.length !== 0) {
+                return errorExit("'cas add' expects one parameter")
+            }
+            const c = fileCas(sha256)(home)
+            return step(
+                casAddFile(c)(path),
+                hashResult => hashResult[0] === 'error'
+                    ? pure(1)
+                    : step(
+                        log(vecToCBase32(hashResult[1])),
+                        () => pure(0)
+                    )
+            )
+        },
+    },
+    {
+        names: ['get'],
+        description: 'Restore content by hash into a file',
+        handler: ({ home, args: [hashCBase32, path, ...rest] }) => {
+            if (hashCBase32 === undefined || path === undefined || rest.length !== 0) {
+                return errorExit("'cas get' expects two parameters")
+            }
+            const hash = cBase32ToVec(hashCBase32)
+            if (hash === null) {
+                return errorExit(`invalid hash format: ${hashCBase32}`)
+            }
+            const c = fileCas(sha256)(home)
+            const x = c.read(hash)
+            return step(
+                writeFromStream(path, x),
+                ([r, v]) => r === 'error' ? errorExit(`e: ` + String(v)) : pure(0),
+            )
+        },
+    },
+    {
+        names: ['list'],
+        description: 'List all stored content hashes',
+        handler: ({ home }) => {
+            const c = fileCas(sha256)(home)
+            const x0 = forEachStep(c.list(), j => log(vecToCBase32(j)))
+            return step(
+                x0,
+                () => pure(0)
+            )
+        },
+    },
+]
+
+export const main = dispatch(commands)

package/fjs/cas/cli/proof.f.d.mts

@@ -0,0 +1,18 @@
+/** @import { NodeProgramOptions } from '../../effects/node/types.ts' */
+export declare const proof: {
+    mainAdd: () => void;
+    mainAddGetBig: () => void;
+    mainAddWrongArgs: () => void;
+    mainAddMissingFile: () => void;
+    mainGetFound: () => void;
+    mainGetNotFound: () => void;
+    mainGetWrongArgs: () => void;
+    mainGetInvalidHash: () => void;
+    mainList: () => void;
+    mainListEmptyStore: () => void;
+    mainNoCmd: () => void;
+    mainUnknownCmd: () => void;
+    throw: {
+        mainListCorruptStore: () => readonly [import("../../effects/node/virtual/types.ts").State, number];
+    };
+};

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

@@ -0,0 +1,118 @@
+/** @import { NodeProgramOptions } from '../../effects/node/types.ts' */
+
+import { commands } from './module.f.mjs'
+import { computeSync, sha256 } from '../../crypto/sha2/module.f.mjs'
+import { maxLength, vec, vec8 } from '../../types/bit_vec/module.f.mjs'
+import { defaultNodeProgramOptions, emptyState, virtual } from '../../effects/node/virtual/module.f.mjs'
+import { dispatch } from '../../cli/module.f.mjs'
+import { vecToCBase32 } from '../../basen/cbase32/module.f.mjs'
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+
+/** @type {(args: readonly string[]) => NodeProgramOptions} */
+const makeOptions = args =>
+    ({ ...defaultNodeProgramOptions, args })
+
+const main = dispatch(commands)
+
+export const proof = {
+    mainAdd: () => {
+        const content = vec8(0x2An)
+        const state = { ...emptyState, root: { myfile: [content] } }
+        const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        assertEq(exitCode, 0, ['expected exit 0', exitCode])
+        assert(finalState.stdout.length !== 0, 'expected hash in stdout')
+    },
+    mainAddGetBig: () => {
+        const chunk = vec(maxLength)(1n)
+        const content = [chunk, chunk]
+        const state = { ...emptyState, root: { myfile: content } }
+        //
+        const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        assertEq(exitCode, 0)
+        const stdout = finalState.stdout
+        assert(stdout.length !== 0)
+        //
+        const h = computeSync(sha256)(content)
+        const hs = vecToCBase32(h)
+        assertEq(stdout, `${hs}\n`)
+        //
+        const [finalState2, exitCode2] = virtual(finalState)(main(makeOptions(['get', hs, 'myfile2'])))
+        // console.log(finalState2.stderr)
+        assertEq(exitCode2, 0, 'e2')
+        const { myfile2 } = finalState2.root
+        assert(myfile2 instanceof Array)
+        const h2 = computeSync(sha256)(myfile2)
+        assertEq(h, h2, 'h')
+    },
+    mainAddWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['add'])))
+        assertEq(exitCode, 1)
+        assert(finalState.stderr.length !== 0)
+    },
+    mainAddMissingFile: () => {
+        // The source path doesn't exist, so `streamFile`'s first read comes back as an
+        // error item; `write` fails closed with that error and the handler exits 1
+        // without ever calling `log` — covers the `hashResult[0] === 'error'` branch.
+        const [, exitCode] = virtual(emptyState)(main(makeOptions(['add', 'missing'])))
+        assertEq(exitCode, 1)
+    },
+    mainGetFound: () => {
+        const content = vec8(0x2An)
+        const state = { ...emptyState, root: { myfile: [content] } }
+        const [state1, exitCode1] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        assertEq(exitCode1, 0, ['expected add exit 0', exitCode1])
+        const hashStr = state1.stdout.trim()
+        const [, exitCode2] = virtual(state1)(main(makeOptions(['get', hashStr, 'output'])))
+        assertEq(exitCode2, 0, ['expected get exit 0', exitCode2])
+    },
+    mainGetNotFound: () => {
+        // valid cBase32 hash that has not been stored
+        const content = vec8(0x2An)
+        const state = { ...emptyState, root: { myfile: [content] } }
+        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        const hashStr = state1.stdout.trim()
+        // use an empty store so the hash is not found
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', hashStr, 'output'])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    mainGetWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get'])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    mainGetInvalidHash: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', 'not-a-valid-hash', 'output'])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    mainList: () => {
+        const content = vec8(0x2An)
+        const state = { ...emptyState, root: { myfile: [content] } }
+        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        const [, exitCode] = virtual(state1)(main(makeOptions(['list'])))
+        assertEq(exitCode, 0, ['expected exit 0', exitCode])
+    },
+    mainListEmptyStore: () => {
+        // A fresh directory has no `.cas` yet; listing must succeed (empty),
+        // not crash unwrapping a readdir ENOENT.
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['list'])))
+        assertEq(exitCode, 0, ['expected exit 0', exitCode])
+        assertEq(finalState.stdout, '', ['expected empty stdout', finalState.stdout])
+    },
+    mainNoCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions([])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    mainUnknownCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['bogus'])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    throw: {
+        // `.cas` exists but is a file, not a directory: a real storage error
+        // that must surface, not be masked as an empty list.
+        mainListCorruptStore: () => virtual({ ...emptyState, root: { '.cas': [vec8(0x2An)] } })(main(makeOptions(['list']))),
+    },
+}

package/fjs/cas/evo/module.f.d.mts

@@ -0,0 +1,163 @@
+/**
+ * Evo API: subjects and revision heads, cached in memory over an immutable
+ * content-addressable store.
+ *
+ * A `Cas<O>` stores `vnd.fjs.revision` blobs ([`fjs/media/revision`](../../media/revision/module.f.mjs))
+ * like any other content: as immutable bytes under a hash. Resolving "what
+ * are the current heads of subject X" from that store means walking every
+ * stored revision and reversing the parent links — too expensive to redo on
+ * every query. This module scans the store once into an in-memory `Cache`
+ * ([`fjs/effects/memory`](../../effects/memory/module.f.mjs)) mapping subject →
+ * head hashes, then keeps the cache current as new revisions are `add`ed
+ * through it — or, for a revision stored some other way (e.g. the generic
+ * `cas_add` MCP tool), via {@link syncRevision}.
+ *
+ * A **head** of a subject is any stored revision of that subject whose hash
+ * is not referenced as a `parents` entry by another revision of the same
+ * subject (see [`fjs/media/revision/README.md`](../../media/revision/README.md)).
+ * `Cache` therefore tracks, per subject, every revision hash seen and every
+ * hash referenced as somebody's parent; heads are the set difference between
+ * the two, computed at read time ({@link headsOf}). Alongside them it records
+ * which of the seen revisions are `archived`, so {@link Evo.list} can classify
+ * a subject as active or archived from its heads' flags
+ * ({@link subjectListed}) without touching the store. Storing both sets rather
+ * than a running head list is what makes folding revisions truly order
+ * independent: `cas.list()` (used by {@link buildCache} to scan an existing
+ * store) returns hashes in hash order, not revision ancestry, so a child can
+ * be seen before its parent — an incremental "drop this hash from the head
+ * set, then re-add whichever hash we just saw" would wrongly resurrect the
+ * parent as a head once it is scanned after its child. Tracking the two sets
+ * separately and only subtracting at read time has no such ordering
+ * dependency: whichever order revisions are folded in, `hashes − parents`
+ * converges to the same result. {@link buildCache} and {@link addRevision}
+ * both fold through the same {@link addRevisionToCache}, the former over the
+ * whole store at once, the latter incrementally for one new revision.
+ *
+ * Not everything here is cache-backed: {@link readRevision} answers "what is
+ * the revision at this hash" straight from the store, decoded, validated, and
+ * with every hash canonicalized ({@link toRevisionData}). It is the typed
+ * counterpart of a raw blob read — {@link addRevision} validates on the way
+ * in, {@link readRevision} on the way out — and both speak the same
+ * {@link RevisionData} vocabulary.
+ *
+ * @module
+ *
+ * @import { Effect, Operation } from '../../effects/types.ts'
+ * @import { Key, MemOp } from '../../effects/memory/types.ts'
+ * @import { Cas } from '../types.ts'
+ * @import { Ok, Result } from '../../types/result/types.ts'
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ * @import { IoResult } from '../../effects/node/types.ts'
+ * @import { List } from '../../effects/list/types.ts'
+ * @import { LockMap, Revision } from '../../media/revision/types.ts'
+ * @import { Hash, Subject, RevisionData, SubjectState, Cache, Evo } from './types.ts'
+ */
+import type { Effect, Operation } from '../../effects/types.ts';
+import type { Key, MemOp } from '../../effects/memory/types.ts';
+import type { Cas } from '../types.ts';
+import type { Result } from '../../types/result/types.ts';
+import type { Vec } from '../../types/bit_vec/types.ts';
+import type { Revision } from '../../media/revision/types.ts';
+import type { Hash, RevisionData, Cache, Evo } from './types.ts';
+/** A cache with no known subjects yet — the starting point for {@link buildCache}. */
+export declare const emptyCache: Cache;
+/**
+ * Decodes already-read bytes as a `vnd.fjs.revision`. Returns `null` for
+ * anything that is not a valid revision — bytes that are not valid UTF-8, or
+ * text that does not parse/validate as the dialect.
+ * @type {(value: Vec) => Revision | null}
+ */
+export declare const decodeRevisionVec: (value: Vec) => Revision | null;
+/**
+ * Reads and decodes the blob at `hash` as a `vnd.fjs.revision`. Returns
+ * `null` for anything that is not a valid revision — a missing hash, or (via
+ * {@link decodeRevisionVec}) bytes that are not valid UTF-8 or do not
+ * parse/validate as the dialect — so a store containing arbitrary other
+ * content can be scanned without failing the whole cache build.
+ *
+ * @template {Operation} O
+ * @param {Cas<O>} cas
+ * @returns {(hash: Vec) => Effect<O, Revision | null>}
+ */
+export declare const decodeRevisionBlob: <O extends Operation>(cas: Cas<O>) => (hash: Vec) => Effect<O, Revision | null>;
+/**
+ * Scans every hash in `cas` and builds a fresh {@link Cache} from the
+ * `vnd.fjs.revision` blobs found among them. Non-revision blobs are ignored.
+ *
+ * @template {Operation} O
+ * @param {Cas<O>} cas
+ * @returns {Effect<O, Cache>}
+ */
+export declare const buildCache: <O extends Operation>(cas: Cas<O>) => Effect<O, Cache>;
+/**
+ * Scans `cas` once and allocates a memory slot holding the resulting {@link Cache}.
+ *
+ * @template {Operation} O
+ * @param {Cas<O>} cas
+ * @returns {Effect<O | MemOp, Key<Cache>>}
+ */
+export declare const initEvo: <O extends Operation>(cas: Cas<O>) => Effect<O | MemOp, Key<Cache>>;
+/**
+ * Folds `value` — bytes already written to a `Cas` at `hash` by some other
+ * caller — into the cache at `cacheKey` if it decodes as a `vnd.fjs.revision`
+ * ({@link decodeRevisionVec}); a no-op otherwise. `cas_add`/`evo_add`
+ * (`fjs/mcp`) are two ways to reach the same store — a plain `cas_add`
+ * call can store a revision blob without going through {@link addRevision},
+ * and this is what keeps the cache honest about it without rescanning the
+ * whole store.
+ * @type {(cacheKey: Key<Cache>) => (hash: Vec) => (value: Vec) => Effect<MemOp, void>}
+ */
+export declare const syncRevision: (cacheKey: Key<Cache>) => (hash: Vec) => (value: Vec) => Effect<MemOp, void>;
+/**
+ * Adds a new revision to `cas` and folds it into the cache at `cacheKey`.
+ *
+ * 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 /
+ * 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`.
+ *
+ * `input.generation` is ignored: it exists on {@link RevisionData} only so a
+ * value read back by {@link readRevision} round-trips into `add` unchanged,
+ * and {@link computeGeneration} always derives the stored value from the
+ * resolved parents.
+ *
+ * @template {Operation} O
+ * @param {Cas<O>} cas
+ * @returns {(cacheKey: Key<Cache>) => (input: RevisionData) => Effect<O | MemOp, Result<Hash, string>>}
+ */
+export declare const addRevision: <O extends Operation>(cas: Cas<O>) => (cacheKey: Key<Cache>) => (input: RevisionData) => Effect<O | MemOp, Result<Hash, string>>;
+/**
+ * Reads the revision at `hash`: decoded, validated, and canonicalized
+ * ({@link toRevisionData}). The typed counterpart of a raw `cas.read` — the
+ * store's generic "bytes by hash" read stays available for arbitrary content
+ * (snapshots and everything else that is not a revision), while this is the
+ * view for revisions specifically: `add` validates on the way in, this
+ * validates on the way out, so no caller re-implements JSON parsing, schema
+ * validation, the `dialect` check, or hash canonicalization.
+ *
+ * Every way to fail is its own message: `hash` is not cBase32, the store has
+ * nothing under it, the store has it but could not deliver it, or what it
+ * holds is not a `vnd.fjs.revision` (see {@link decodeReadRevision}).
+ *
+ * @template {Operation} O
+ * @param {Cas<O>} cas
+ * @returns {(hash: Hash) => Effect<O, Result<RevisionData, string>>}
+ */
+export declare const readRevision: <O extends Operation>(cas: Cas<O>) => (hash: Hash) => Effect<O, Result<RevisionData, string>>;
+/**
+ * Builds the {@link Evo} API over `cas`, backed by the cache at `cacheKey` (see {@link initEvo}).
+ *
+ * @template {Operation} O
+ * @param {Cas<O>} cas
+ * @returns {(cacheKey: Key<Cache>) => Evo<O>}
+ */
+export declare const evo: <O extends Operation>(cas: Cas<O>) => (cacheKey: Key<Cache>) => Evo<O>;