@cello-protocol/daemon 0.0.120 → 0.0.122

package/dist/document-store.d.ts

@@ -0,0 +1,269 @@
+/**
+ * DOD-DOC-STORE-1 — the daemon's three document tables (§16.7-12).
+ *
+ * TWO LAYERS, NOT ONE (§14). Storing only a merged Yjs binary would discard the signed envelope
+ * chain that makes a seal verifiable, so both are kept:
+ *
+ *   `document_envelopes`  — the IMMUTABLE log: signatures, provenance, the per-document chain.
+ *                           This is the truth.
+ *   `document_snapshots`  — a MATERIALIZATION for fast start. Disposable by construction:
+ *                           delete it and it rebuilds from the log, byte-identical.
+ *
+ * The distinction is load-bearing rather than stylistic. Live Yjs state deliberately does NOT
+ * survive a daemon restart — CELLO's invariant is daemon-up-is-CELLO-on — and that is only safe
+ * because the log makes rebuilding a lookup rather than an archaeology exercise.
+ *
+ * THIS MODULE PERSISTS; IT DOES NOT APPLY. Replay is INJECTED (`rebuildSnapshot`), so the store
+ * owns *what to replay and in what order* while the engine (DOD-DOC-ENGINE-1) owns *how to
+ * apply*. That keeps `yjs` out of this file's imports entirely and keeps the P0/P1 boundary
+ * honest — a store that quietly grew a Y.Doc would be the engine wearing a store's name.
+ *
+ * WHAT IS NEVER STORED HERE: a Yjs clientID. §14's one-line rule is "let Yjs mint its own per
+ * live Y.Doc; never derive it from agent identity, never persist and restore one." DOD-DOC-FUZZ-1
+ * measured the cost of getting this wrong — two live docs sharing a clientID means the colliding
+ * writer silently wins, the honest client's update is accepted-and-dropped, and the result is a
+ * splice of two authors with an EMPTY pending set and no error on any path. So the snapshot
+ * stores a binary and a state vector, and nothing that could be restored into a live document as
+ * an identity.
+ *
+ * KEYED ON STABLE IDS ONLY. `agent_id` and `document_id`, never `agent_name` — it is a mutable
+ * display label and reusable after retirement. The M7 session tables join on `agent_name`; that
+ * is a known defect (`DOD-AGENT-ID-JOINKEY-1`), not a precedent to copy.
+ */
+import type { DaemonDatabase } from "./sqlcipher-db.js";
+import type { Logger } from "./types.js";
+/** Lifecycle states a document can hold (§3.5). `stalled` is DOD-DOC-REJECT-1's terminal state. */
+export type DocumentStatus = "active" | "closed" | "killed" | "stalled";
+/**
+ * What an envelope IS, as opposed to what it says. A withdrawal or a rejection is a NEW ROW that
+ * references an earlier envelope — never an edit to it. The log is append-only, so the only way
+ * to say "that one no longer counts" is to add a record saying so.
+ */
+export type DocumentEnvelopeKind = "update" | "withdrawal" | "rejection";
+export interface DocumentProperties {
+    /** V1 accepts only `authenticated` — the Tier-2 seam (§16.1). */
+    assurance_tier?: string;
+    /** V1 accepts only `false` — the Tier-2 seam (§16.1). */
+    schema_enforcement?: boolean;
+    append_only?: boolean;
+    [key: string]: unknown;
+}
+export interface DocumentRow {
+    documentId: string;
+    ownerAgentId: string;
+    peerAgentId: string;
+    documentType: string;
+    properties: DocumentProperties;
+    status: DocumentStatus;
+    createdAtMs: number;
+}
+export interface DocumentEnvelopeRow {
+    /** Content hash of the envelope — the stable identity, and the log's primary key. */
+    envelopeHash: string;
+    documentId: string;
+    /** WHO authored it. The chain is per-sender, so this is what partitions it. */
+    senderAgentId: string;
+    /** The sender's previous envelope for this document, or null at genesis (§9.1). */
+    docPrevHash: string | null;
+    /** Constant 0 in V1 and NEVER omitted — after a compaction an update that does not state its
+     *  epoch cannot be verified unambiguously (§14, §16.1 seam). */
+    epochId: number;
+    signature: Uint8Array;
+    /** The sender's Yjs state vector at publish time (§7). */
+    stateVector: Uint8Array;
+    /** NULLABLE — a purged envelope keeps its hash and signature, proving it existed (§16.7-12). */
+    payload: Uint8Array | null;
+    kind: DocumentEnvelopeKind;
+    /** For a withdrawal or rejection: the envelope it concerns. */
+    referencesEnvelopeHash?: string | null;
+    createdAtMs: number;
+    /** Position in this document's log. Assigned on append; absent until then. */
+    logIndex?: number;
+    /** DELIVERY bookkeeping, read back from the log. Absent on a row being appended. */
+    deliveredAtMs?: number | null;
+    ackedAtMs?: number | null;
+    attempts?: number;
+    nextAttemptAtMs?: number | null;
+}
+export interface QuarantineRow {
+    documentId: string;
+    /** The 0x05 leaf this row belongs to — the PK. One leaf, one row; see the table comment. */
+    rejectionEnvelopeHash: string;
+    rejectedEnvelopeHash: string;
+    /** The refused envelope's own author and chain link, so the chain verifier can bridge it. */
+    rejectedSenderAgentId: string;
+    rejectedDocPrevHash: string | null;
+    payload: Uint8Array;
+    reason: string;
+    detail?: string;
+    /** Which pluggable rule refused, when one did — the gate produces this and it must not be lost. */
+    rule?: string;
+    limitName?: string;
+    limitValue?: number;
+    limitActual?: number;
+    createdAtMs: number;
+}
+export interface DocumentSnapshot {
+    binary: Uint8Array;
+    stateVector: Uint8Array;
+    /**
+     * The `log_index` of the last envelope this snapshot reflects. §14 is explicit about why it is
+     * stored rather than derived: with it, "where does the snapshot sit relative to the log" is a
+     * lookup; without it, every rebuild works it out from scratch.
+     *
+     * **-1 means nothing has been applied.** The resume point is ALWAYS `lastAppliedIndex + 1`,
+     * so an empty log yields 0 and `getEnvelopesSince(0)` reads the whole log — the sentinel and
+     * the convention are chosen to agree.
+     */
+    lastAppliedIndex: number;
+}
+/** Thrown when a read path refuses to materialize over a chain that does not verify. */
+export declare class DocumentChainError extends Error {
+    readonly reason: "document_chain_broken" | "document_chain_forked";
+    readonly detail: string;
+    constructor(reason: "document_chain_broken" | "document_chain_forked", detail: string);
+}
+export type ChainVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "document_chain_broken" | "document_chain_forked";
+    detail: string;
+};
+/**
+ * Injected by the engine: fold an ordered envelope list into a materialized state.
+ *
+ * Takes ROWS, not bare payloads. The engine has to distinguish an update from a withdrawal or a
+ * rejection to fold correctly — a withdrawn envelope's payload must not be applied — and it
+ * cannot do that from `Uint8Array[]`. The store supplies the WHOLE log in order — withdrawal and
+ * rejection records included, payload-free though they are; deciding what counts is the engine's
+ * call, not the store's.
+ */
+export type ReplayFn = (envelopes: DocumentEnvelopeRow[]) => {
+    binary: Uint8Array;
+    stateVector: Uint8Array;
+};
+export declare class DocumentStore {
+    #private;
+    /**
+     * The underlying handle, for modules that own their OWN tables alongside this one
+     * (DocumentLifecycle). Deliberately not a licence to query this store's tables from outside —
+     * every one of them has a method here, and a second query path is a second set of rules about
+     * scoping that nobody remembers to keep in step.
+     */
+    get rawDb(): DaemonDatabase;
+    constructor(db: DaemonDatabase, logger: Logger);
+    createDocument(row: DocumentRow): void;
+    getDocument(ownerAgentId: string, documentId: string): DocumentRow | null;
+    listDocuments(ownerAgentId: string): DocumentRow[];
+    setDocumentStatus(ownerAgentId: string, documentId: string, status: DocumentStatus): void;
+    /**
+     * Append an envelope at the next log position.
+     *
+     * IMMUTABLE AT A HASH: the conflict clause is scoped to the envelope hash ALONE, so a
+     * re-delivery — or a peer replaying the same hash with different bytes — cannot overwrite what
+     * was recorded. Returns whether a new row was written, so the caller can tell a genuine append
+     * from a duplicate rather than inferring it.
+     *
+     * Scoped deliberately, not written as a bare `OR IGNORE`: that form suppresses CHECK, UNIQUE
+     * and NOT NULL as well, which on an append-only log means a malformed `kind` or a colliding
+     * `log_index` would be DROPPED and reported to the caller as an already-seen duplicate. Every
+     * constraint except the hash conflict must throw, or `false` means three different things the
+     * caller cannot tell apart.
+     */
+    appendEnvelope(ownerAgentId: string, envelope: DocumentEnvelopeRow): boolean;
+    /**
+     * Envelopes at or after `fromIndex`, in log order. This is what makes `lastAppliedIndex` the
+     * lookup §14 asks for: resume an incremental rebuild at `lastAppliedIndex + 1` without reading
+     * the whole log.
+     */
+    getEnvelopesSince(ownerAgentId: string, documentId: string, fromIndex: number): DocumentEnvelopeRow[];
+    getEnvelopeLog(ownerAgentId: string, documentId: string): DocumentEnvelopeRow[];
+    /**
+     * Verify each sender's `doc_prev_hash` chain independently.
+     *
+     * The log interleaves both parties' envelopes, so there is no single total order to check —
+     * §16.7-5 defines replay set-based per epoch for exactly this reason. What must hold is that
+     * every sender's own links form one unbroken chain from a single genesis.
+     *
+     * A break REFUSES and names the sender and the missing predecessor. Skipping the leaf and
+     * carrying on would leave a document that reads as complete while missing operations, which is
+     * the silent-divergence failure the chain exists to prevent.
+     *
+     * LINKAGE ONLY — the name says so deliberately. This verifies no signature and does not check
+     * that `envelope_hash` hashes the content; neither is possible here (no key, no encoder). A
+     * caller must not read `ok: true` as authenticity — that belongs to the engine.
+     */
+    verifyChainLinkage(ownerAgentId: string, documentId: string): ChainVerdict;
+    /**
+     * Hold a refused update's bytes. Idempotent per REJECTION (per 0x05 leaf), not per refused
+     * envelope — one envelope may be refused across several retry rounds and each round's reason,
+     * rule and limit are distinct facts an operator needs.
+     *
+     * Returns whether a row was written, so a caller never has to infer it. The previous signature
+     * returned void and the conflict clause silently dropped every round after the first.
+     */
+    holdQuarantined(ownerAgentId: string, row: QuarantineRow): boolean;
+    listQuarantined(ownerAgentId: string, documentId: string): QuarantineRow[];
+    /**
+     * Release every entry for a refused envelope once its superseding update has been admitted.
+     * Returns whether anything was released. Keyed by the REFUSED envelope rather than the rejection
+     * leaf, because admitting the supersession resolves all of that envelope's rounds at once.
+     */
+    releaseQuarantined(ownerAgentId: string, documentId: string, rejectedEnvelopeHash: string): boolean;
+    /** The rejecting agent's most recent envelope for this document, for chain linkage. */
+    lastEnvelopeHashBySender(ownerAgentId: string, documentId: string, senderAgentId: string): string | null;
+    /**
+     * Envelopes this agent authored that the peer has not acknowledged, and whose next attempt is
+     * due. DERIVED — there is no queue. Survives a restart because the log does.
+     *
+     * Scoped to `senderAgentId = ownerAgentId`: an envelope we RECEIVED is not ours to deliver, and
+     * without the scope a receiver would helpfully re-send the sender's own updates back at it.
+     */
+    pendingDeliveries(ownerAgentId: string, nowMs: number, limit?: number): DocumentEnvelopeRow[];
+    /** Mark an attempt: bumps the counter and schedules the next one. Returns the new count. */
+    recordDeliveryAttempt(ownerAgentId: string, documentId: string, envelopeHash: string, nextAttemptAtMs: number): number;
+    /** Record that the envelope left. Not an ack — the peer has not answered yet. */
+    markDelivered(ownerAgentId: string, documentId: string, envelopeHash: string, nowMs: number): boolean;
+    /** Record that the peer acknowledged. Idempotent — a redelivered ack must not move the clock. */
+    markAcked(ownerAgentId: string, documentId: string, envelopeHash: string, nowMs: number): boolean;
+    /** Record a rejection the PEER sent us. Returns whether a row was written (idempotent by leaf). */
+    recordRejectionReceived(ownerAgentId: string, row: {
+        documentId: string;
+        rejectionEnvelopeHash: string;
+        rejectedEnvelopeHash: string;
+        fromAgentId: string;
+        reason: string;
+        detail?: string;
+        createdAtMs: number;
+    }): boolean;
+    /** How many rejections this document has RECEIVED — the publishing side's retry round. */
+    countRejectionsReceived(ownerAgentId: string, documentId: string): number;
+    /** The most recently received rejection, for the reason an operator is shown on a stall. */
+    latestRejectionReceived(ownerAgentId: string, documentId: string): {
+        reason: string;
+        detail?: string;
+        fromAgentId: string;
+    } | null;
+    /**
+     * How many rejection records this document carries, PER REJECTING AGENT — the retry round.
+     *
+     * Scoped by author, because a mutual exchange puts both directions' 0x05 leaves in one document
+     * log. Counting across senders conflated them, so two peers each rejecting once read as round 2
+     * and the document stalled at half the intended rounds.
+     */
+    countRejections(ownerAgentId: string, documentId: string, rejectingAgentId: string): number;
+    getSnapshot(ownerAgentId: string, documentId: string): DocumentSnapshot | null;
+    /** REPLACES — a snapshot is a cache of the log, not a second log. */
+    putSnapshot(ownerAgentId: string, documentId: string, snapshot: DocumentSnapshot): void;
+    deleteSnapshot(ownerAgentId: string, documentId: string): void;
+    /**
+     * Rebuild a snapshot from the envelope log alone, using the caller's replay function.
+     *
+     * Payload-stripped envelopes (purged, or withdrawal/rejection records that carry none)
+     * contribute nothing to replay but STILL COUNT toward `lastAppliedIndex` — otherwise the next
+     * incremental rebuild would start behind them and replay them forever.
+     */
+    rebuildSnapshot(ownerAgentId: string, documentId: string, replay: ReplayFn): DocumentSnapshot;
+}
+//# sourceMappingURL=document-store.d.ts.map

package/dist/document-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-store.d.ts","sourceRoot":"","sources":["../src/document-store.ts"],"names":[],"mappings":"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"}