@4fu/arbor-notes-sqlite 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4fuu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,188 @@
-# Temporary Holding Version
+# arbor
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+arbor is a framework for an agent without sessions: many context windows run
+at once over one shared record, so work moves in parallel, replies come fast,
+and every window can find everything that was ever done.
+
+A deployment composes the pieces it wants and registers plugins for the domains
+it serves. The framework guarantees what an agent cannot guarantee for itself -
+the record, isolation, exactly-once effects, the checks, dispatch - and leaves
+everything that takes judgment, such as git, merges and conflicts, to the agent.
+
+## Core ideas
+
+- **No sessions to manage.** Work runs in disposable context windows. Any
+  number run at the same time; none of them owns anything, and a window that
+  ends loses nothing. The model looks up what it needs instead of carrying it.
+- **One record, shared live.** Every input, tool call, result, send and note
+  revision goes into one journal and is visible to every window as
+  soon as it is written. Records never merge and are never lost.
+- **Dispatch by a judge.** A judge (Jev by default, replaceable) decides which
+  live window takes a new input, or opens a new one. There is no router session
+  and no main line.
+- **Current without locks.** Windows run in parallel. New events on a
+  conversation a window is in are steered into it as they arrive; only a note
+  write is checked against the revision the window read.
+- **Mechanisms in the framework, policy in the agent.** The framework
+  guarantees what an agent cannot guarantee for itself - the record, isolation,
+  exactly-once effects, the checks, dispatch. Everything that takes judgment,
+  such as git, merges and conflicts, is the agent's.
+- **A directory per window.** Each window gets its own directory, and a
+  continuation keeps working in its predecessor's directory in place. It is not
+  bound to a repository; the agent clones and pushes what it needs.
+- **A self-changing environment.** The model adds and changes skills, MCP
+  servers and resident services itself; a `reload` validates the change and
+  broadcasts it to every live window as a delta of names and descriptions.
+- **Minimal limits.** The framework sets no policy. Permissions, privacy
+  review, budgets and approvals belong to deployments built on it, through
+  hooks.
+- **Direct tools plus code mode.** Decisions are direct tools; everything else
+  is a module called from `code_exec`. There is no CLI.
+- **Every module is replaceable.** The agent backend (pi by default), the
+  journal, notes, workspaces, the judge, channels and the rest are interfaces
+  ([docs/architecture.md](docs/architecture.md#interfaces)).
+
+## Install
+
+Node 24 or newer. Every package is published separately, so a deployment
+installs the core and the defaults it wants:
+
+```sh
+npm install @4fu/arbor-core @4fu/arbor-journal-sqlite @4fu/arbor-notes-sqlite \
+  @4fu/arbor-environment-dir @4fu/arbor-supervisor-process @4fu/arbor-agent-pi \
+  @4fu/arbor-workspace-dir
+```
+
+`@4fu/arbor-plugin-http` is optional; it is the example plugin below.
+`@4fu/arbor-segmenter-jieba` is an optional peer of the journal.
+
+## A minimal host
+
+The smallest host needs a journal and a backend. Adding the defaults and one
+plugin is what a deployment usually starts from:
+
+```js
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Arbor } from "@4fu/arbor-core";
+import { DirectoryEnvironment } from "@4fu/arbor-environment-dir";
+import { SqliteJournal } from "@4fu/arbor-journal-sqlite";
+import { SqliteNoteStore } from "@4fu/arbor-notes-sqlite";
+import { ProcessSupervisor } from "@4fu/arbor-supervisor-process";
+import { DirectoryWorkspace } from "@4fu/arbor-workspace-dir";
+import { PiAgentBackend } from "@4fu/arbor-agent-pi";
+import { HttpChannel, httpPlugin } from "@4fu/arbor-plugin-http";
+
+const root = await mkdtemp(join(tmpdir(), "arbor-"));
+
+// Every module below is a default implementation of an interface. Replace any
+// one by passing your own; the host does not change.
+const journal = new SqliteJournal({ path: join(root, "journal.sqlite") });
+const notes = new SqliteNoteStore({ path: join(root, "notes.sqlite"), journal });
+const supervisor = new ProcessSupervisor({ root: join(root, "services") });
+const environment = new DirectoryEnvironment({ root: join(root, "env"), supervisor });
+const workspace = new DirectoryWorkspace({ root: join(root, "workspaces") });
+
+// A plugin adds; it never patches the core. This one is a chat channel: a
+// webhook in, a window's sends out, and a page that drives the whole host.
+let arbor;
+const channel = new HttpChannel({ host: "127.0.0.1", port: 8787, board: () => arbor.boardLines() });
+arbor = new Arbor({
+  journal,
+  notes,
+  backend: new PiAgentBackend(),
+  workspace,
+  environment,
+  supervisor,
+  plugins: [httpPlugin({ channel })],
+});
+
+await arbor.start();
+await channel.listen();
+```
+
+`arbor.open(task)` dispatches one task, and the journal is where everything that
+happened can be read back ([docs/journal.md](docs/journal.md)). The workspace a
+window gets, and how a continuation keeps working in it, are in
+[docs/workspaces.md](docs/workspaces.md).
+
+## Packages
+
+| Package | What it is |
+| --- | --- |
+| [`@4fu/arbor-interfaces`](packages/interfaces) | every replaceable interface, plus the core's own shapes. Types only. |
+| [`@4fu/arbor-errors`](packages/errors) | the error shape every refusal uses: the rule and the next action |
+| [`@4fu/arbor-prompt`](packages/prompt) | typed blocks, the one deterministic renderer and the replaceable text table |
+| [`@4fu/arbor-tools`](packages/tools) | the entry points: direct tools, code mode modules, the host API |
+| [`@4fu/arbor-journal-sqlite`](packages/journal-sqlite) | the default `Journal` and `BlobStore` on SQLite |
+| [`@4fu/arbor-notes-sqlite`](packages/notes-sqlite) | the default `NoteStore` on SQLite, beside the journal |
+| [`@4fu/arbor-segmenter-jieba`](packages/segmenter-jieba) | the default `Segmenter`: jieba's dictionary segmentation for the word index, optional |
+| [`@4fu/arbor-workspace-dir`](packages/workspace-dir) | the default `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place |
+| [`@4fu/arbor-environment-dir`](packages/environment-dir) | the default `Environment`: one `/env` directory, a revision per item, validation and deltas |
+| [`@4fu/arbor-supervisor-process`](packages/supervisor-process) | the default `Supervisor`: one host process per service, restart with backoff, logs |
+| [`@4fu/arbor-judge-jev`](packages/judge-jev) | the default `Judge`: Jev, TypeSafe AI's System One classifier, answering the dispatch decisions |
+| [`@4fu/arbor-agent-pi`](packages/agent-pi) | the default `AgentBackend`: pi-agent-core in process |
+| [`@4fu/arbor-plugin-http`](packages/plugin-http) | the HTTP test channel: a webhook in, sends out, a page that drives the whole host |
+| [`@4fu/arbor-core`](packages/core) | the service layer: one implementation of every operation - the window lifecycle, dispatch, coordination, the board, notes access, workspaces, effects and schedules |
+
+### Defaults are examples
+
+Every default above is a reference implementation of its interface, written to
+be read and replaced. A real deployment is expected to swap out the ones that do
+not fit: the SQLite journal and notes, the directory workspace, the process
+supervisor, the environment directory, the HTTP test plugin and the Jev judge
+are all examples of what an interface can be satisfied by, not commitments.
+What a deployment keeps is its own choice, and the interfaces are the contract
+([docs/architecture.md](docs/architecture.md#interfaces)).
+
+Each package's own documentation holds the limits of that default, so a
+deployment can see what it would be taking on before it adopts one.
+
+## Documents
+
+| Page | Contents |
+| --- | --- |
+| [docs/overview.md](docs/overview.md) | goals, concepts, principles, routes considered |
+| [docs/architecture.md](docs/architecture.md) | layers, interfaces, stack, models, plugins, hooks, data placement |
+| [docs/journal.md](docs/journal.md) | events and their order, targets, watermarks, external ids, refs, tracing, media, redaction |
+| [docs/windows.md](docs/windows.md) | window lifecycle, prompt layout, reminders, continuation |
+| [docs/dispatch.md](docs/dispatch.md) | task sources, judge decisions, insertion timing, backpressure, scheduled tasks |
+| [docs/coordination.md](docs/coordination.md) | the board, expectations, deliveries and broadcasts, staying current, effects |
+| [docs/environment.md](docs/environment.md) | skills, MCP servers and services: using, changing, reload, built-in skills, deltas |
+| [docs/memory.md](docs/memory.md) | notes, the active set, anchors, links |
+| [docs/workspaces.md](docs/workspaces.md) | per-window directories: isolation, continuity, what the agent does |
+| [docs/tools.md](docs/tools.md) | direct tools and code mode modules |
+| [docs/prompting.md](docs/prompting.md) | how every model-facing text is written: layers, notes, deliveries, errors, judge questions, terms |
+| [docs/release.md](docs/release.md) | calendar versioning, the manual release steps, how a package is published |
+
+## Repository layout
+
+`pnpm check` typechecks and tests every package on its TypeScript sources.
+`pnpm build` emits the `dist` publishing needs, and `pnpm pack` shows what each
+tarball would contain ([docs/release.md](docs/release.md)).
+
+| Path | Layer |
+| --- | --- |
+| `packages/interfaces` | the interfaces layer: every replaceable interface, plus the core's own shapes. Types only. |
+| `packages/errors` | the error shape every refusal uses: the rule and the next action |
+| `packages/journal-sqlite` | the default `Journal` and `BlobStore` on SQLite |
+| `packages/segmenter-jieba` | the default `Segmenter`: jieba's dictionary segmentation for the word index, optional |
+| `packages/notes-sqlite` | the default `NoteStore` on SQLite, beside the journal |
+| `packages/judge-jev` | the default `Judge`: Jev, TypeSafe AI's System One classifier, answering the dispatch decisions |
+| `packages/workspace-dir` | the default `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place, and the lookup of another window's directory it contributes to the catalog |
+| `packages/environment-dir` | the default `Environment`: one `/env` directory, a revision per item, validation and deltas |
+| `packages/supervisor-process` | the default `Supervisor`: one host process per service, restart with backoff, logs |
+| `packages/plugin-http` | the HTTP test channel: a webhook in, sends out, a page that drives the whole host |
+| `packages/prompt` | typed blocks, the one deterministic renderer and the replaceable text table |
+| `packages/agent-pi` | the default `AgentBackend`: pi-agent-core in process |
+| `packages/tools` | the entry points: direct tools, code mode modules, the host API |
+| `packages/core` | the service layer: one implementation of every operation - the window lifecycle, dispatch, coordination, the board, notes access, workspaces, effects, schedules and the snapshot epochs |
+
+`mise.toml` pins the toolchain - Node and pnpm - installed under
+`~/.local/share/mise`, and `.agents/setup` prepares a machine from it. A machine
+without mise is expected to carry Node 24 or newer and pnpm 12 already.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

package/diff.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The difference between two bodies, for a note conflict (docs/memory.md).
+ *
+ * A refused write carries what changed since the revision it read: the
+ * revisions in between, their windows and the differences. The differences are
+ * a unified diff of the body the writer read against the body that is there
+ * now, so the model merges them and writes again without reading the whole note
+ * twice. A body too large to diff is reported as such; the revisions it has to
+ * read are named in the same refusal.
+ */
+/** The unified diff of `from` against `to`, or `null` when nothing changed. */
+export declare function bodyDiff(from: string, to: string): string | null;

package/diff.js

@@ -0,0 +1,106 @@
+/**
+ * The difference between two bodies, for a note conflict (docs/memory.md).
+ *
+ * A refused write carries what changed since the revision it read: the
+ * revisions in between, their windows and the differences. The differences are
+ * a unified diff of the body the writer read against the body that is there
+ * now, so the model merges them and writes again without reading the whole note
+ * twice. A body too large to diff is reported as such; the revisions it has to
+ * read are named in the same refusal.
+ */
+/** Lines of unchanged context each hunk keeps. */
+const CONTEXT = 3;
+/** Beyond this many cells the diff is dropped for a line that says so. */
+const CELL_LIMIT = 4_000_000;
+/** The unified diff of `from` against `to`, or `null` when nothing changed. */
+export function bodyDiff(from, to) {
+    const before = from === "" ? [] : from.split("\n");
+    const after = to === "" ? [] : to.split("\n");
+    if (before.length * after.length > CELL_LIMIT) {
+        return "the body is too large to diff; read both revisions";
+    }
+    const edits = diffLines(before, after);
+    if (edits.every((edit) => edit.kind === " "))
+        return null;
+    return render(edits);
+}
+function diffLines(before, after) {
+    const rows = before.length;
+    const columns = after.length;
+    // The longest common subsequence, from the end backwards.
+    const table = Array.from({ length: rows + 1 }, () => new Array(columns + 1).fill(0));
+    for (let i = rows - 1; i >= 0; i -= 1) {
+        for (let j = columns - 1; j >= 0; j -= 1) {
+            const same = before[i] === after[j];
+            const down = table[i + 1]?.[j] ?? 0;
+            const right = table[i]?.[j + 1] ?? 0;
+            table[i][j] = same ? (table[i + 1]?.[j + 1] ?? 0) + 1 : Math.max(down, right);
+        }
+    }
+    const edits = [];
+    let i = 0;
+    let j = 0;
+    while (i < rows && j < columns) {
+        if (before[i] === after[j]) {
+            edits.push({ kind: " ", line: i + 1, text: before[i] });
+            i += 1;
+            j += 1;
+        }
+        else if ((table[i + 1]?.[j] ?? 0) >= (table[i]?.[j + 1] ?? 0)) {
+            edits.push({ kind: "-", line: i + 1, text: before[i] });
+            i += 1;
+        }
+        else {
+            edits.push({ kind: "+", line: j + 1, text: after[j] });
+            j += 1;
+        }
+    }
+    while (i < rows) {
+        edits.push({ kind: "-", line: i + 1, text: before[i] });
+        i += 1;
+    }
+    while (j < columns) {
+        edits.push({ kind: "+", line: j + 1, text: after[j] });
+        j += 1;
+    }
+    return edits;
+}
+/** The edits worth showing: every change with its context, as unified hunks. */
+function render(edits) {
+    const keep = new Set();
+    edits.forEach((edit, index) => {
+        if (edit.kind === " ")
+            return;
+        for (let near = Math.max(0, index - CONTEXT); near <= Math.min(edits.length - 1, index + CONTEXT); near += 1) {
+            keep.add(near);
+        }
+    });
+    const lines = [];
+    let index = 0;
+    while (index < edits.length) {
+        if (!keep.has(index)) {
+            index += 1;
+            continue;
+        }
+        let end = index;
+        while (end < edits.length && keep.has(end))
+            end += 1;
+        lines.push(...hunk(edits.slice(index, end)));
+        index = end;
+    }
+    return lines.join("\n");
+}
+function hunk(edits) {
+    const from = edits.filter((edit) => edit.kind !== "+");
+    const to = edits.filter((edit) => edit.kind !== "-");
+    // A hunk that only adds lines starts where the first added line is, one line
+    // earlier on the side it was added to; a hunk that only removes lines the
+    // same way the other way round.
+    const firstFrom = from[0]?.line ?? (to[0].line ?? 1) - 1;
+    const firstTo = to[0]?.line ?? (from[0].line ?? 1) - 1;
+    const lines = [`@@ -${firstFrom},${from.length} +${firstTo},${to.length} @@`];
+    for (const edit of edits) {
+        lines.push(`${edit.kind}${edit.text}`);
+    }
+    return lines;
+}

package/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @4fu/arbor-notes-sqlite - the default `NoteStore`.
+ */
+export { SqliteNoteStore, SUMMARY_LIMIT, DEFAULT_BODY_LIMIT, MAX_BODY_LIMIT } from "./notes.ts";
+export { DEFAULT_MIN_INTERVAL_MS, DEFAULT_ACTIVE_BUDGET, DEFAULT_JUDGE_SHARE, DEFAULT_HALF_LIFE_MS, deriveSummary, } from "./notes.ts";
+export type { SqliteNoteStoreOptions } from "./notes.ts";
+export { SCHEMA_VERSION, FTS_TABLE, createSchema } from "./schema.ts";
+export { noteIdOf, noteRefOf, parseNoteId, parseNoteRef, noteRefForms, storedWindowRef, storedEventRef, } from "./refs.ts";
+export { USE_WEIGHTS, MAX_CREDIT_HOPS, decay, estimateTokens, linkedCredit, loadCredit, loadEdges, pickByBudget, applyJudgeShare, scoreNotes, } from "./score.ts";
+export type { ScoredNote } from "./score.ts";
+export { MIN_TRIGRAM_CHARS, substringClause, holdingIds, escapeLike, likePattern, quoteFts, } from "./search.ts";
+export type { SubstringClause } from "./search.ts";
+export { bodyDiff } from "./diff.ts";

package/index.js

@@ -0,0 +1,10 @@
+/**
+ * @4fu/arbor-notes-sqlite - the default `NoteStore`.
+ */
+export { SqliteNoteStore, SUMMARY_LIMIT, DEFAULT_BODY_LIMIT, MAX_BODY_LIMIT } from "./notes.js";
+export { DEFAULT_MIN_INTERVAL_MS, DEFAULT_ACTIVE_BUDGET, DEFAULT_JUDGE_SHARE, DEFAULT_HALF_LIFE_MS, deriveSummary, } from "./notes.js";
+export { SCHEMA_VERSION, FTS_TABLE, createSchema } from "./schema.js";
+export { noteIdOf, noteRefOf, parseNoteId, parseNoteRef, noteRefForms, storedWindowRef, storedEventRef, } from "./refs.js";
+export { USE_WEIGHTS, MAX_CREDIT_HOPS, decay, estimateTokens, linkedCredit, loadCredit, loadEdges, pickByBudget, applyJudgeShare, scoreNotes, } from "./score.js";
+export { MIN_TRIGRAM_CHARS, substringClause, holdingIds, escapeLike, likePattern, quoteFts, } from "./search.js";
+export { bodyDiff } from "./diff.js";

package/notes.d.ts

@@ -0,0 +1,126 @@
+/**
+ * The default `NoteStore`: SQLite beside the journal (docs/memory.md).
+ *
+ * Notes are the long-term memory: one copy of each, shared by every window,
+ * written only through the note tools. What this implementation owns:
+ *
+ * - the one copy, and the checked write: a write, replace or delete names the
+ *   revision it read, and a stale one is refused with what changed since -
+ *   the revisions in between, their windows and the differences - so the model
+ *   merges and writes again. A refused call changes nothing.
+ * - revisions, append-only, with the anchor the host recorded and the refs the
+ *   write named, so an anchor keeps working after the note is edited, archived
+ *   or deleted;
+ * - the active set, picked at each snapshot epoch by usage score within a
+ *   count and token budget, and frozen with the epoch's version, so every
+ *   window opened in one epoch has the same prefix and later windows see the
+ *   changes as a delta;
+ * - every write recorded in the journal as a `note_revision` event.
+ *
+ * It is synchronous inside: one `DatabaseSync`, one transaction per write, so
+ * the revision a write checks and the revision it writes are one atomic step.
+ * Writes are serialised in process as well, because a write spans the notes
+ * database and the journal. The interface is asynchronous because a `NoteStore`
+ * may live behind a process boundary.
+ */
+import type { ActiveCandidate, ActiveSetBudget, Journal, Note, NoteBody, NoteContext, NoteDelta, NoteQuery, NoteRef, NoteRevision, NoteSummary, NoteUseInput, NoteWriteInput, NotesSnapshot, NoteStore, Page, SnapshotOptions } from "@4fu/arbor-interfaces";
+/** A summary is at most this many characters (docs/memory.md). */
+export declare const SUMMARY_LIMIT = 200;
+/** How many characters of a body one read returns. */
+export declare const DEFAULT_BODY_LIMIT = 7000;
+export declare const MAX_BODY_LIMIT = 20000;
+/** The system prompt and memory snapshot rebuild at most this often. 10 min. */
+export declare const DEFAULT_MIN_INTERVAL_MS = 600000;
+/** The active set's budget, which bounds every prefix. */
+export declare const DEFAULT_ACTIVE_BUDGET: ActiveSetBudget;
+/** The share of the budget the judge may add, which never outweighs the model's own use. */
+export declare const DEFAULT_JUDGE_SHARE = 0.15;
+/** Usage loses half of its weight this often. */
+export declare const DEFAULT_HALF_LIFE_MS = 86400000;
+export interface SqliteNoteStoreOptions {
+    /** A file path, or `:memory:`. */
+    path?: string;
+    /** The journal every note revision is recorded in, as a `note_revision` event. */
+    journal: Journal;
+    /** The clock. Tests pass a fixed one. */
+    now?: () => number;
+    /** Usage loses half of its weight this often. 24 hours. */
+    usageHalfLifeMs?: number;
+}
+/** The opening of a body, when a write carries no summary of its own. */
+export declare function deriveSummary(body: string): string;
+export declare class SqliteNoteStore implements NoteStore {
+    readonly path: string;
+    private readonly db;
+    private readonly journal;
+    private readonly clock;
+    private readonly halfLifeMs;
+    /** One write at a time: a write spans the notes database and the journal. */
+    private writeQueue;
+    private closed;
+    constructor(options: SqliteNoteStoreOptions);
+    write(input: NoteWriteInput): Promise<Note>;
+    private writeOne;
+    /** The rules a write has to meet before it touches the one copy. */
+    private checkWrite;
+    /** The one atomic step: check the revision, then place the revision. */
+    private place;
+    /** Undo a placed revision whose journal event was refused. */
+    private takeBack;
+    /**
+     * The refusal a stale write gets: what changed since the revision it read -
+     * the revisions in between, their windows and the differences - so the model
+     * merges them and writes again against the current revision.
+     */
+    private conflict;
+    read(ref: NoteRef, options?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<NoteBody | null>;
+    revisions(ref: NoteRef): Promise<Page<NoteRevision>>;
+    search(query?: NoteQuery): Promise<Page<NoteSummary>>;
+    active(): Promise<Page<NoteSummary>>;
+    context(ref: NoteRef): Promise<NoteContext | null>;
+    snapshot(options?: SnapshotOptions): Promise<NotesSnapshot>;
+    delta(since: number, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<NoteDelta>;
+    score(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Page<ActiveCandidate>>;
+    recordUse(input: NoteUseInput): Promise<void>;
+    close(): Promise<void>;
+    private ensureOpen;
+    private noteRow;
+    private revisionRow;
+    private latestRevisionRow;
+    private recordRead;
+    /** The current summary and revision of several notes, in one read. */
+    private noteStatesFor;
+    private summaryPageBySql;
+    private summaryPageByIds;
+    /**
+     * The notes about a target, or linked to a ref: the notes the events on that
+     * target name, and the notes whose revisions name that ref. A note the store
+     * has never heard of is skipped, so a hallucinated ref costs nothing.
+     */
+    private linkedNoteIds;
+    /** The notes the events on a target name, strongest link first. */
+    private notesAbout;
+    /** The notes whose revisions name a ref, whichever revision named it. */
+    private notesLinkedTo;
+    private latestEpoch;
+    private epochRow;
+    private newestWriteSeq;
+    /**
+     * The epoch a window freezes its prefix at. A new one is built at most every
+     * `minIntervalMs`, and only when a note was written since the last one or the
+     * budget changed, so every window opened in one epoch has the same prefix and
+     * the changes since reach it as a delta.
+     */
+    private epochAt;
+    /** The active notes one epoch froze, by summary, sorted by id. */
+    private epochSummaries;
+}