functionalscript 0.43.1 → 0.45.0

package/fjs/cas/evo/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Type-level API for `fjs/cas/evo/module.f.mjs`: the Evo cache shape and the
+ * `Evo<O>` API surface it builds.
+ *
+ * @module
+ */
+import type { Operation, Effect } from '../../effects/types.ts';
+import type { MemOp } from '../../effects/memory/types.ts';
+import type { Result } from '../../types/result/types.ts';
+import type { StringMap } from '../../types/object/types.ts';
+import type { LockMap } from '../../media/revision/types.ts';
+/** A cBase32 content hash, as accepted/returned by `Cas<O>`. */
+export type Hash = string;
+/** The identity of a mutable object whose revisions are being evolved. */
+export type Subject = string;
+/**
+ * The semantic content of a revision: the media-level `Revision`
+ * (`fjs/media/revision`) minus `dialect`, which is a serialization tag
+ * carrying no information once decoding has validated it. One structure is
+ * the vocabulary of both directions — {@link addRevision} takes it,
+ * {@link readRevision} returns it — so what you add is what you get back, and
+ * a value read back can be fed to `add` unchanged, without stripping fields.
+ * Every direction-specific field is therefore optional, with the guarantees
+ * documented per field rather than typed:
+ *
+ * - `parents` — required in both directions; index 0 is the mainline parent.
+ *   On output the entries are canonical cBase32 spellings
+ *   ({@link canonicalHash}), so they compare directly against {@link Evo.head}
+ *   output.
+ * - `subject` — input: absent means "inherit from my single parent" (see
+ *   {@link resolveSubject}); output: always present.
+ * - `snapshot` — input: absent is a write-boundary convenience resolved from
+ *   the parents (see {@link resolveSnapshot}), because the stored blob
+ *   requires it explicitly; output: always present, canonical, and exactly
+ *   what the stored blob names.
+ * - `archived` — genuinely optional in both directions; the only field that
+ *   can be absent from a read.
+ * - `generation` — input: **ignored**, {@link computeGeneration} derives the
+ *   authoritative value from the parents; output: always present. It exists as
+ *   an input field only so a read value round-trips into `add` as-is.
+ *
+ * Relaxing what the format requires is the point, not an oversight. The stored
+ * `vnd.fjs.revision` blob requires `subject`, `snapshot` and `generation`, and
+ * {@link readRevision} does return all three — but this is not that blob's
+ * type. It is the type of the API that *reads and constructs* revisions, and
+ * its purpose is to make both easy: `add` asks only for what a caller can
+ * actually know, resolving or computing the rest at the write boundary, and a
+ * read hands back a value that goes straight into `add` again. A separate
+ * output type with `subject`/`snapshot`/`generation` required would state that
+ * one direction more precisely, at the cost of splitting the one vocabulary
+ * into two — the trade this API declines, deliberately and not by omission.
+ * `fjs/media/revision`'s `Revision` remains the all-required type of the
+ * stored blob for anyone who wants it.
+ */
+export type RevisionData = {
+    readonly parents: readonly Hash[];
+    readonly snapshot?: Hash | undefined;
+    readonly subject?: Subject | undefined;
+    readonly archived?: true | undefined;
+    readonly generation?: number | undefined;
+    readonly lock?: LockMap | undefined;
+};
+/**
+ * Per-subject bookkeeping: every revision hash seen for the subject, every
+ * hash any of those revisions names as a parent, and which of the seen
+ * revisions are `archived`. See the module doc for why the first two sets are
+ * kept (rather than a running head list), {@link headsOf} for how heads are
+ * derived from them, and {@link subjectListed} for how `archived` classifies a
+ * subject once its heads are known.
+ *
+ * `archived` is keyed by revision hash, not by subject, for the same reason
+ * heads are computed at read time: which revisions are heads is only known
+ * once the whole store has been folded in, so a per-subject archived flag
+ * would have to be revised every time a later fold changes the head set.
+ */
+export type SubjectState = {
+    readonly hashes: readonly Hash[];
+    readonly parents: readonly Hash[];
+    readonly archived: readonly Hash[];
+};
+/** In-memory index: subject → its {@link SubjectState}. */
+export type Cache = {
+    readonly bySubject: StringMap<SubjectState>;
+};
+/** The Evo API described in `fjs/cas/evo/README.md`, bound to a `Cas<O>` and its cache slot. */
+export type Evo<O extends Operation> = {
+    /**
+     * Returns the subjects matching a status filter: the active ones by
+     * default, the archived ones when `archived` is `true`. A subject's status
+     * is derived from its current heads — see {@link subjectListed}, which
+     * also explains why a subject with no current heads is in neither result.
+     *
+     * There is deliberately no all-subjects mode: nothing needs one yet, and
+     * adding it later is a compatible extension of this parameter, while
+     * removing it would not be.
+     */
+    readonly list: (archived?: true) => Effect<MemOp, readonly Subject[]>;
+    /** Returns the current head hashes of `subject` (empty if unknown). */
+    readonly head: (subject: Subject) => Effect<MemOp, readonly Hash[]>;
+    /** Adds a new head; see {@link addRevision}. */
+    readonly add: (input: RevisionData) => Effect<O | MemOp, Result<Hash, string>>;
+    /**
+     * The revision at `hash`, decoded, validated, and canonicalized; see
+     * {@link readRevision}. Served from the store today, so the `MemOp` in the
+     * declared operation set is unused — it is there because a revision is
+     * immutable and therefore memoizable in the same cache slot the other
+     * operations read, which must not become a breaking change to this type
+     * when it happens.
+     */
+    readonly revision: (hash: Hash) => Effect<O | MemOp, Result<RevisionData, string>>;
+};

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

@@ -0,0 +1,68 @@
+/**
+ * Content-addressable storage utilities for hashing, addressing, and path parsing.
+ *
+ * @module
+ *
+ * @import { Sha2, State as Sha2State } from '../crypto/sha2/types.ts'
+ * @import { Vec } from '../types/bit_vec/types.ts'
+ * @import { Effect, Operation } from '../effects/types.ts'
+ * @import {
+ *  IoResult,
+ *  Now,
+ *  RandomInt,
+ *  ReadBytes,
+ *  Readdir,
+ *  Rm,
+ * } from '../effects/node/types.ts'
+ *  @import { List } from '../effects/list/types.ts'
+ * @import { Cas, FileCas, FileCasOperation } from './types.ts'
+ */
+import type { Sha2 } from '../crypto/sha2/types.ts';
+import type { Vec } from '../types/bit_vec/types.ts';
+import type { Effect, Operation } from '../effects/types.ts';
+import type { IoResult, ReadBytes } from '../effects/node/types.ts';
+import type { List } from '../effects/list/types.ts';
+import type { Cas, FileCas, FileCasOperation } from './types.ts';
+/** Converts a content key to its sharded relative CAS file path.
+ *
+ * @type {(key: Vec) => string}
+ */
+export declare const toPath: (key: Vec) => string;
+/**
+ * Drains a `Cas<O>.read` chunk stream into a single `Vec`. Used by any caller
+ * that needs the whole blob at once (an MCP `content: true` fetch, an Evo
+ * revision decode): the chunk stream is concatenated and an error item is
+ * surfaced as the result. A single `Vec` cannot exceed `maxLength` bits;
+ * concatenating past it would overflow the runtime's `bigint` constraint, so
+ * that case is surfaced as an error item too, rather than crashing the
+ * process.
+ *
+ * @template {Operation} O
+ * @param {List<O, IoResult<Vec>>} stream
+ * @returns {Effect<O, IoResult<Vec>>}
+ */
+export declare const collectRead: <O extends Operation>(stream: List<O, IoResult<Vec>>) => Effect<O, IoResult<Vec>>;
+/**
+ * Builds a content-addressable storage facade from a SHA-2 implementation.
+ *
+ * @type {(sha2: Sha2) => (path: string) => FileCas}
+ */
+export declare const fileCas: (sha2: Sha2) => (path: string) => FileCas;
+/**
+ * Streams the file at `path` through `cas.write`, returning the content hash.
+ * Both the CLI `cas add` and the MCP `add` delegate to this; the MCP layer
+ * additionally deletes the source file on success.
+ *
+ * @template {Operation} O
+ * @param {Cas<O>} cas
+ * @returns {(path: string) => Effect<O | ReadBytes, IoResult<Vec>>}
+ */
+export declare const casAddFile: <O extends Operation>(cas: Cas<O>) => (path: string) => Effect<O | ReadBytes, IoResult<Vec>>;
+/**
+ * Upload pipeline: streams `fileName` from `~/cas_upload/` through `casAddFile`,
+ * then deletes the source on success. On failure the source is left in place so
+ * the upload can be retried; `write` already cleans up its own partial staging file.
+ *
+ * @type {(home: string) => (fileName: string) => Effect<FileCasOperation, IoResult<Vec>>}
+ */
+export declare const casUpload: (home: string) => (fileName: string) => Effect<FileCasOperation, IoResult<Vec>>;

package/fjs/cas/module.f.mjs

@@ -0,0 +1,350 @@
+/**
+ * Content-addressable storage utilities for hashing, addressing, and path parsing.
+ *
+ * @module
+ *
+ * @import { Sha2, State as Sha2State } from '../crypto/sha2/types.ts'
+ * @import { Vec } from '../types/bit_vec/types.ts'
+ * @import { Effect, Operation } from '../effects/types.ts'
+ * @import {
+ *  IoResult,
+ *  Now,
+ *  RandomInt,
+ *  ReadBytes,
+ *  Readdir,
+ *  Rm,
+ * } from '../effects/node/types.ts'
+ *  @import { List } from '../effects/list/types.ts'
+ * @import { Cas, FileCas, FileCasOperation } from './types.ts'
+ */
+
+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, mapStep, okStep, pure, step } from '../effects/module.f.mjs'
+import {
+    access,
+    createExclusive,
+    isNotFound,
+    mkdir,
+    now,
+    randomInt,
+    readBytes,
+    readdir,
+    rename,
+    rm,
+    stat,
+    writeBytes,
+} from '../effects/node/module.f.mjs'
+import { toOption } from '../types/nullable/module.f.mjs'
+import { error, ok, unwrap } from '../types/result/module.f.mjs'
+import { splitAt } from '../types/string/module.f.mjs'
+import { nonEmpty, empty as elEmpty } from '../effects/list/module.f.mjs'
+
+const split2 = splitAt(2)
+
+const prefix = '.cas'
+
+/** Converts a content key to its sharded relative CAS file path.
+ *
+ * @type {(key: Vec) => string}
+ */
+export const toPath = key => {
+    const s = vecToCBase32(key)
+    const [a, bc] = split2(s)
+    const [b, c] = split2(bc)
+    return join(prefix, a, b, c)
+}
+
+/**
+ * Drains a `Cas<O>.read` chunk stream into a single `Vec`. Used by any caller
+ * that needs the whole blob at once (an MCP `content: true` fetch, an Evo
+ * revision decode): the chunk stream is concatenated and an error item is
+ * surfaced as the result. A single `Vec` cannot exceed `maxLength` bits;
+ * concatenating past it would overflow the runtime's `bigint` constraint, so
+ * that case is surfaced as an error item too, rather than crashing the
+ * process.
+ *
+ * @template {Operation} O
+ * @param {List<O, IoResult<Vec>>} stream
+ * @returns {Effect<O, IoResult<Vec>>}
+ */
+export const collectRead = stream => {
+    /** @type {(acc: Vec) => (s: List<O, IoResult<Vec>>) => Effect<O, IoResult<Vec>>} */
+    const loop = acc => s =>
+        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)
+}
+
+/** Maximum chunk size for streaming reads: the largest `Vec` the runtime allows. */
+const chunkBytes = Number(maxLengthBytes)
+
+/** Staging directory under the store root; GC and every uploader share it. */
+const stageRel = '_stage'
+
+/**
+ * Lease duration in ms: a staging file's deadline is `now() + leaseDelta`.
+ * Renewed after every chunk, so it only has to cover the gap between two
+ * consecutive chunks (see [staging-lease.md](./plan/staging-lease.md)).
+ */
+const leaseDelta = 30_000
+
+/**
+ * Fixed width for the zero-padded epoch-ms deadline embedded in a staging name,
+ * so names sort lexically exactly as they sort chronologically. 19 digits keeps
+ * epoch-ms (13 digits today) padded with headroom well past year 2286.
+ */
+const deadlineWidth = 19
+
+/** Builds a `<deadline>-<random256>` staging file name.
+ *
+ * @type {(deadline: number, rnd: string) => string}
+ */
+const stageName = (deadline, rnd) =>
+    `${String(deadline).padStart(deadlineWidth, '0')}-${rnd}`
+
+/** Recovers the deadline (epoch ms) from a `<deadline>-<random256>` name.
+ *
+ * @type {(name: string) => number}
+ */
+const deadlineOf = name => Number(name.slice(0, name.indexOf('-')))
+
+/**
+ * Reclaims expired staging files: any `_stage/<deadline>-<rand>` whose deadline
+ * is already in the past. Lazy and piggy-backed on `write`. Best-effort — a
+ * missing `_stage/` (fresh store) or any `readdir`/`rm` error is ignored, and a
+ * still-live lease is left alone; the fencing rename keeps even a misjudged
+ * reclaim fail-safe (worst case: that upload restarts).
+ *
+ * @template {Now | Readdir | Rm} O
+ * @param {string} stageDir
+ * @returns {Effect<O, void>}
+ */
+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 => mapStep(rm(join(stageDir, name)), () => undefined))
+        })
+}
+
+// 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
+// running SHA-2 state — the payload never lives in memory as a whole. The lease is
+// renewed (rename to a fresh deadline) after every chunk; any error deletes the
+// partial file and fails. On end-of-stream the file is published to its hash-derived
+// shard path by a replace-`rename` (which also dedups/repairs a same-content shard),
+// and success is confirmed by a `stat` size check. GC of expired staging files is
+// piggy-backed at the start.
+/**
+ * @template {Operation} O1
+ * @param {Sha2} sha2
+ * @param {string} path
+ * @param {string} stageDir
+ * @param {List<O1, IoResult<Vec>>} payload
+ * @returns {Effect<O1 | FileCasOperation, IoResult<Vec>>}
+ */
+const writeImpl = (sha2, path, stageDir, payload) => {
+    // Publish the finished staging file to its content-addressed shard. The three
+    // filesystem steps run best-effort with their results ignored; success is decided
+    // afterward by observing the target's size (see staging-lease.md "Publish ignores
+    // results and checks the end state").
+    /** @type {(state: Sha2State, offset: number, curPath: string) => Effect<FileCasOperation, IoResult<Vec>>} */
+    const publish = (state, offset, curPath) => {
+        const hash = sha2.end(state)
+        const rel = toPath(hash)
+        const dst = join(path, rel)
+        const dstDir = join(path, ...parse(rel).slice(0, -1))
+        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) =>
+        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))
+                    })
+                })
+        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)))
+        })
+    })
+}
+
+/**
+ * Builds a content-addressable storage facade from a SHA-2 implementation.
+ *
+ * @type {(sha2: Sha2) => (path: string) => FileCas}
+ */
+export const fileCas = sha2 => path => {
+    const storePrefix = join(path, prefix)
+    const normalizedStorePrefix = normalize(storePrefix)
+    const stageDir = join(storePrefix, stageRel)
+    return {
+        read: hash => {
+            const p = join(path, toPath(hash))
+            /** @type {(offset: number) => List<FileCasOperation, IoResult<Vec>>} */
+            const loop = offset =>
+                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') {
+                            return nonEmpty(result, elEmpty())
+                        }
+                        // End the stream only on an empty read; every non-empty read — including a
+                        // final short (`< CHUNK_BYTES`) chunk — is emitted as an `ok` item.
+                        return length(v) === 0n
+                            ? elEmpty()
+                            : nonEmpty(ok(v), loop(offset + chunkBytes))
+                    })
+            return loop(0)
+        },
+        write: payload => writeImpl(sha2, path, stageDir, payload),
+        list: () =>
+            // A fresh store has no `.cas` directory yet. Treat *only* that case as an
+            // 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".
+            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))
+    }
+}
+
+/** 256-bit random `Vec` built from 8 sequential `randomInt` (32-bit) calls.
+ *
+ * @type {Effect<RandomInt, Vec>}
+ */
+const random256 =
+    foldStep(
+        pure([0, 1, 2, 3, 4, 5, 6, 7]),
+        empty,
+        () => (/** @type {Vec} */ acc) =>
+            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.
+ *
+ * @type {(filePath: string) => List<ReadBytes, IoResult<Vec>>}
+ */
+const streamFile = filePath => {
+    /** @type {(offset: number) => List<ReadBytes, IoResult<Vec>>} */
+    const loop = offset =>
+        step(
+            readBytes(filePath, offset, chunkBytes),
+            /** @type {(result: IoResult<Vec>) => List<ReadBytes, IoResult<Vec>>} */ (result) => {
+                if (result[0] === 'error') {
+                    return nonEmpty(result, elEmpty())
+                }
+                const chunk = result[1]
+                return length(chunk) === 0n
+                    ? elEmpty()
+                    : nonEmpty(ok(chunk), loop(offset + chunkBytes))
+            })
+    return loop(0)
+}
+
+/**
+ * Streams the file at `path` through `cas.write`, returning the content hash.
+ * Both the CLI `cas add` and the MCP `add` delegate to this; the MCP layer
+ * additionally deletes the source file on success.
+ *
+ * @template {Operation} O
+ * @param {Cas<O>} cas
+ * @returns {(path: string) => Effect<O | ReadBytes, IoResult<Vec>>}
+ */
+export const casAddFile = cas => path =>
+    // streamFile produces only ReadBytes effects. TypeScript can't prove ListEffect<ReadBytes,T>
+    // ≤ ListEffect<O,T> for generic O (recursive type), but the cast is sound: every concrete
+    // caller passes a Cas<O> where ReadBytes ⊆ O (e.g. FileCasOperation).
+    cas.write(streamFile(path))
+
+/**
+ * Upload pipeline: streams `fileName` from `~/cas_upload/` through `casAddFile`,
+ * then deletes the source on success. On failure the source is left in place so
+ * the upload can be retried; `write` already cleans up its own partial staging file.
+ *
+ * @type {(home: string) => (fileName: string) => Effect<FileCasOperation, IoResult<Vec>>}
+ */
+export const casUpload = home => fileName => {
+    const src = join(home, 'cas_upload', fileName)
+    const c = fileCas(sha256)(home)
+    return step(
+        casAddFile(c)(src),
+        okStep(/** @type {(v: Vec) => Effect<Rm, IoResult<Vec>>} */ (v =>
+            mapStep(rm(src), () => ok(v)))))
+}

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

@@ -0,0 +1,29 @@
+/**
+ * @import { Vec } from '../types/bit_vec/types.ts'
+ * @import { FileCasOperation } from './types.ts'
+ * @import { Effect } from '../effects/types.ts'
+ * @import { ReadFile, WriteFile, Rm, Mkdir, IoResult } from '../effects/node/types.ts'
+ * @import { Ok } from '../types/result/types.ts'
+ * @import { List } from '../effects/list/types.ts'
+ */
+import type { FileCasOperation } from './types.ts';
+import type { ReadFile, WriteFile, Rm, Mkdir } from '../effects/node/types.ts';
+export type _TestOp = FileCasOperation | WriteFile | ReadFile | Rm | Mkdir;
+export declare const proof: {
+    addBigFile: () => void;
+    addAndGetBigFile: () => void;
+    casWriteRead: () => void;
+    casReadMissingShard: () => void;
+    casWriteMultiChunk: () => void;
+    casWriteDedup: () => void;
+    casWriteErrorItemAborts: () => void;
+    casWriteReadExceedsMaxLength: () => void;
+    casWriteGcReclaimsExpired: () => void;
+    casWriteGcSkipsLiveLease: () => void;
+    casUploadSuccess: () => void;
+    casUploadFailureKeepsSource: () => void;
+    collectReadDrainsChunks: () => void;
+    collectReadPropagatesErrorItem: () => void;
+    collectReadOverflow: () => void;
+    casListPropagatesNonNotFoundAccessError: () => void;
+};