@cello-protocol/daemon 0.0.225 → 0.0.227

package/dist/document-json.d.ts

@@ -1,120 +0,0 @@
-/**
- * DOD-DOC-TYPES-1 — rendering a JSON document to the bytes both sides must agree on.
- *
- * ── THE PROBLEM THIS SOLVES ──────────────────────────────────────────────────────────────────────
- *
- * The CRDT determines the map STATE. It does not determine the STRING that map is printed as.
- * `Y.Map.toJSON()` returns keys in INSERTION order, so two peers who added the same keys in a
- * different order hold the same document and render different files:
- *
- *   Alice adds `owner` then `status`  →  {"owner": "a", "status": "open"}
- *   Bob   adds `status` then `owner`  →  {"status": "open", "owner": "a"}
- *
- * Both faithful, both correct, and everything downstream breaks. The write path diffs the FILE
- * against the recorded projection, so a re-serialization in a different order reads as a rewrite of
- * the entire document and is PUBLISHED to the peer as a real, signed edit. Two machines comparing
- * files disagree about a document they agree on. And pasting the rendered document to have a peer
- * confirm they hold the same thing — which is how values get attested — stops working.
- *
- * ── THE RULE ─────────────────────────────────────────────────────────────────────────────────────
- *
- * Object keys sorted, recursively, at every depth. **Arrays are never sorted:** an array's order is
- * content, and reordering a list of steps or a ranked set of options is a lie about what was agreed.
- *
- * Trailing newline, because most editors add one on save and its absence would make the first save
- * of an untouched file publish an edit nobody made.
- */
-export type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/**
- * The canonical text of a JSON document — the bytes written to the file, recorded as the diff
- * baseline, and compared against a peer's.
- *
- * Indented rather than compact: a human and an agent both have to read this file, and a line diff
- * needs nested values on their own lines to say anything useful about what changed.
- */
-export declare function serializeJsonDocument(value: JsonValue): string;
-/** A parsed JSON object, or the reason it could not be parsed. */
-export type ParsedJsonDocument = {
-    ok: true;
-    value: {
-        [key: string]: JsonValue;
-    };
-} | {
-    ok: false;
-    detail: string;
-};
-/**
- * Parse the text an agent supplied as a whole JSON document.
- *
- * A non-object top level is refused as firmly as a syntax error: the map root holds KEYS, so a bare
- * array or string has nowhere to go, and accepting one would silently empty the document.
- */
-export declare function parseJsonDocument(text: string): ParsedJsonDocument;
-/**
- * Apply `next` to `map` as the MINIMAL set of key operations, recursing into nested objects.
- *
- * **This is the per-key merge, and depth is the whole point of it.** Two actors editing two
- * different fields of a shared record must both survive. Storing a nested object as a plain value
- * makes it ONE item, so two writes to two fields inside it are two writes to the same item and last
- * writer wins — measured on the reference workflow: one actor raising `settlement_failed` and
- * another clearing `insufficient_funds` in the same minute ended with the raise gone from both
- * machines, silently.
- *
- * That was dangerous rather than merely limited, because `jsonDiff` reports full dotted paths. Every
- * surface said the structure was understood at path granularity, so a schema nests precisely where
- * several actors write — and afterwards the diff names the field that vanished.
- *
- * **Untouched keys are not written at all**, at any depth. Writing a key back with an identical
- * value is still a CRDT operation and would clobber a peer's concurrent edit to a field this author
- * never looked at. A nested object that already exists is REUSED rather than replaced, for the same
- * reason — replacing it is exactly the bug.
- *
- * **Arrays are stored whole, deliberately.** Element-level merge of two concurrent array edits
- * interleaves into an order neither party wrote, and an array's order is content: a ranked list, a
- * sequence of steps. Last-writer-wins on a whole array beats a silently reordered one. The
- * consequence, recorded rather than hidden: a JOURNAL must not be an array, because two concurrent
- * appends lose one. Key it as a map and this function carries it at any depth.
- *
- * Values are compared on their CANONICAL rendering. Plain `JSON.stringify` is order-sensitive for a
- * nested object, so re-ordering a nested block — which any formatter may do — would count as a
- * changed value, publish a change nobody made, and beat a peer's real edit to that key.
- *
- * Returns the dotted paths actually written, for the overlap flag.
- */
-export declare function applyJsonToMap(map: YMapLike, next: {
-    [key: string]: JsonValue;
-}, doc: {
-    transact(fn: () => void): void;
-}, prefix?: string): string[];
-/** A `Y.Map`-shaped thing, kept structural so this module does not import the engine. */
-export interface YMapLike {
-    get(key: string): unknown;
-    set(key: string, value: unknown): unknown;
-    delete(key: string): void;
-    keys(): Iterable<string>;
-    toJSON(): unknown;
-}
-/**
- * The document's content as the text an agent reads and writes back — whichever root it lives in.
- *
- * The three content verbs (`read`, `write`, `diff`) all called `doc.getText("content")` directly,
- * which is why `json` had to be refused at the door: its content is in the MAP root, so those verbs
- * saw an empty document and would have written that emptiness back over the peer's real content.
- *
- * Imported by both the handlers and the write path so one document has ONE textual form. Two
- * renderings of the same map would make the file diff fight the tool surface.
- */
-export declare function projectDocumentText(doc: YDocLike, documentType: string): string;
-/** The slice of `Y.Doc` this module needs, so it does not depend on the engine. */
-interface YDocLike {
-    getMap(name: string): {
-        toJSON(): unknown;
-    };
-    getText(name: string): {
-        toString(): string;
-    };
-}
-export {};
-//# sourceMappingURL=document-json.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"document-json.d.ts","sourceRoot":"","sources":["../src/document-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAMH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAiBtG;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAE9D;AAED,kEAAkE;AAClE,MAAM,MAAM,kBAAkB,GAC1B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAA;CAAE,GACjD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAWlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EAClC,GAAG,EAAE;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;CAAE,EACvC,MAAM,SAAK,GACV,MAAM,EAAE,CAsCV;AAED,yFAAyF;AACzF,MAAM,WAAW,QAAQ;IACvB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAC1C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;IACzB,MAAM,IAAI,OAAO,CAAC;CACnB;AAiCD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAK/E;AAMD,mFAAmF;AACnF,UAAU,QAAQ;IAChB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,MAAM,IAAI,OAAO,CAAA;KAAE,CAAC;IAC5C,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAAC;CAC/C"}

package/dist/document-json.js

@@ -1,191 +0,0 @@
-/**
- * DOD-DOC-TYPES-1 — rendering a JSON document to the bytes both sides must agree on.
- *
- * ── THE PROBLEM THIS SOLVES ──────────────────────────────────────────────────────────────────────
- *
- * The CRDT determines the map STATE. It does not determine the STRING that map is printed as.
- * `Y.Map.toJSON()` returns keys in INSERTION order, so two peers who added the same keys in a
- * different order hold the same document and render different files:
- *
- *   Alice adds `owner` then `status`  →  {"owner": "a", "status": "open"}
- *   Bob   adds `status` then `owner`  →  {"status": "open", "owner": "a"}
- *
- * Both faithful, both correct, and everything downstream breaks. The write path diffs the FILE
- * against the recorded projection, so a re-serialization in a different order reads as a rewrite of
- * the entire document and is PUBLISHED to the peer as a real, signed edit. Two machines comparing
- * files disagree about a document they agree on. And pasting the rendered document to have a peer
- * confirm they hold the same thing — which is how values get attested — stops working.
- *
- * ── THE RULE ─────────────────────────────────────────────────────────────────────────────────────
- *
- * Object keys sorted, recursively, at every depth. **Arrays are never sorted:** an array's order is
- * content, and reordering a list of steps or a ranked set of options is a lie about what was agreed.
- *
- * Trailing newline, because most editors add one on save and its absence would make the first save
- * of an untouched file publish an edit nobody made.
- */
-/** A value that can live in a JSON document. */
-import { rootForDocumentType } from "./document-types.js";
-import { extractErrorMessage } from "./error-message.js";
-/**
- * Return `value` with every object's keys in sorted order, at every depth.
- *
- * Arrays keep their order; only the objects INSIDE them are normalised. `JSON.stringify` walks
- * objects in own-property order, so sorting the keys into a fresh object is what makes its output
- * deterministic — there is no stringify option that does this.
- */
-function withSortedKeys(value) {
-    if (Array.isArray(value))
-        return value.map(withSortedKeys);
-    if (value === null || typeof value !== "object")
-        return value;
-    const sorted = {};
-    for (const key of Object.keys(value).sort())
-        sorted[key] = withSortedKeys(value[key]);
-    return sorted;
-}
-/**
- * The canonical text of a JSON document — the bytes written to the file, recorded as the diff
- * baseline, and compared against a peer's.
- *
- * Indented rather than compact: a human and an agent both have to read this file, and a line diff
- * needs nested values on their own lines to say anything useful about what changed.
- */
-export function serializeJsonDocument(value) {
-    return `${JSON.stringify(withSortedKeys(value), null, 2)}\n`;
-}
-/**
- * Parse the text an agent supplied as a whole JSON document.
- *
- * A non-object top level is refused as firmly as a syntax error: the map root holds KEYS, so a bare
- * array or string has nowhere to go, and accepting one would silently empty the document.
- */
-export function parseJsonDocument(text) {
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch (err) {
-        return { ok: false, detail: extractErrorMessage(err) };
-    }
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return { ok: false, detail: "the top level of a JSON document must be an object" };
-    }
-    return { ok: true, value: parsed };
-}
-/**
- * Apply `next` to `map` as the MINIMAL set of key operations, recursing into nested objects.
- *
- * **This is the per-key merge, and depth is the whole point of it.** Two actors editing two
- * different fields of a shared record must both survive. Storing a nested object as a plain value
- * makes it ONE item, so two writes to two fields inside it are two writes to the same item and last
- * writer wins — measured on the reference workflow: one actor raising `settlement_failed` and
- * another clearing `insufficient_funds` in the same minute ended with the raise gone from both
- * machines, silently.
- *
- * That was dangerous rather than merely limited, because `jsonDiff` reports full dotted paths. Every
- * surface said the structure was understood at path granularity, so a schema nests precisely where
- * several actors write — and afterwards the diff names the field that vanished.
- *
- * **Untouched keys are not written at all**, at any depth. Writing a key back with an identical
- * value is still a CRDT operation and would clobber a peer's concurrent edit to a field this author
- * never looked at. A nested object that already exists is REUSED rather than replaced, for the same
- * reason — replacing it is exactly the bug.
- *
- * **Arrays are stored whole, deliberately.** Element-level merge of two concurrent array edits
- * interleaves into an order neither party wrote, and an array's order is content: a ranked list, a
- * sequence of steps. Last-writer-wins on a whole array beats a silently reordered one. The
- * consequence, recorded rather than hidden: a JOURNAL must not be an array, because two concurrent
- * appends lose one. Key it as a map and this function carries it at any depth.
- *
- * Values are compared on their CANONICAL rendering. Plain `JSON.stringify` is order-sensitive for a
- * nested object, so re-ordering a nested block — which any formatter may do — would count as a
- * changed value, publish a change nobody made, and beat a peer's real edit to that key.
- *
- * Returns the dotted paths actually written, for the overlap flag.
- */
-export function applyJsonToMap(map, next, doc, prefix = "") {
-    const written = [];
-    const apply = () => {
-        for (const [key, value] of Object.entries(next)) {
-            const path = prefix === "" ? key : `${prefix}.${key}`;
-            const before = map.get(key);
-            const nestable = isPlainObject(value);
-            if (nestable && isYMap(before)) {
-                // RECURSE into the existing nested map. Never replace it — replacing is what destroys a
-                // peer's concurrent edit to a sibling key.
-                written.push(...applyJsonToMap(before, value, doc, path));
-                continue;
-            }
-            if (nestable) {
-                // Either absent, or a legacy PLAIN object written before nesting existed. Both become a
-                // nested map here; that is the whole migration, and it happens on first touch.
-                const child = newYMap(map);
-                map.set(key, child);
-                written.push(...applyJsonToMap(child, value, doc, path));
-                continue;
-            }
-            if (before === undefined || serializeJsonDocument(toJson(before)) !== serializeJsonDocument(value)) {
-                map.set(key, value);
-                written.push(path);
-            }
-        }
-        for (const key of [...map.keys()]) {
-            if (!(key in next)) {
-                map.delete(key);
-                written.push(prefix === "" ? key : `${prefix}.${key}`);
-            }
-        }
-    };
-    // One transaction for the whole tree, so the edit is a single update rather than one per depth.
-    if (prefix === "")
-        doc.transact(apply);
-    else
-        apply();
-    return written;
-}
-function isPlainObject(v) {
-    return v !== null && typeof v === "object" && !Array.isArray(v);
-}
-/** True for a Yjs map. Detected by shape — `toJSON` plus `keys` plus `delete`. */
-function isYMap(v) {
-    return (v !== null &&
-        typeof v === "object" &&
-        typeof v.get === "function" &&
-        typeof v.keys === "function" &&
-        typeof v.toJSON === "function");
-}
-/** A stored value as plain JSON, whether it is a nested map or an ordinary value. */
-function toJson(v) {
-    return (isYMap(v) ? v.toJSON() : v);
-}
-/**
- * A new nested map of the SAME class as its parent.
- *
- * Constructed from the parent's own constructor rather than importing `yjs` here, so this module
- * stays free of the engine and the write path keeps one source of the Yjs dependency.
- */
-function newYMap(sibling) {
-    const Ctor = sibling.constructor;
-    return new Ctor();
-}
-/**
- * The document's content as the text an agent reads and writes back — whichever root it lives in.
- *
- * The three content verbs (`read`, `write`, `diff`) all called `doc.getText("content")` directly,
- * which is why `json` had to be refused at the door: its content is in the MAP root, so those verbs
- * saw an empty document and would have written that emptiness back over the peer's real content.
- *
- * Imported by both the handlers and the write path so one document has ONE textual form. Two
- * renderings of the same map would make the file diff fight the tool surface.
- */
-export function projectDocumentText(doc, documentType) {
-    if (rootForDocumentType(documentType) === "map") {
-        return serializeJsonDocument(doc.getMap(MAP_ROOT).toJSON());
-    }
-    return doc.getText(TEXT_ROOT).toString();
-}
-/** Yjs roots a document projects from — must match `DocumentEngine`'s. */
-const TEXT_ROOT = "content";
-const MAP_ROOT = "data";
-//# sourceMappingURL=document-json.js.map

package/dist/document-json.js.map

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

package/dist/document-layer.d.ts

@@ -1,215 +0,0 @@
-/**
- * DOD-DOC-INBOUND-2 / DOD-DOC-DELIVERY-2 — the composition of the document layer.
- *
- * Everything M14 built is a unit with injected seams. This is where they become one thing, and it
- * is a module rather than a block inside `daemon.ts` for one reason: the assembly makes decisions.
- * Which verifier, which live-doc policy, and — the one that matters — whether the layer is present
- * at all.
- *
- * ── ALL OR NOTHING ────────────────────────────────────────────────────────────────────────────
- *
- * The layer is built completely or not built. There is no partially-wired mode, because every
- * half-wiring is a distinct silent failure: an inbound path with no ack producer leaves the peer
- * retrying until their document stalls; a delivery worker with no inbound counterpart publishes
- * envelopes nobody can answer. `DOD-DOC-DELIVERY-2` records that ordering constraint on its own
- * line, and this is where it is enforced instead of remembered.
- *
- * ── THE VERIFIER IS REQUIRED, AND RESOLVES THROUGH THE CALLER ─────────────────────────────────
- *
- * Signature verification needs an agent id → public key mapping, which lives with the daemon's
- * contact and session state rather than here. It is passed in, and there is no default: a default
- * would be a default answer to "is this authentic", and both inbound paths refuse rather than
- * admit when it says no.
- */
-import { DocumentStore } from "./document-store.js";
-import { DocumentEngine } from "./document-engine.js";
-import { DocumentRejections } from "./document-rejection.js";
-import { DocumentAmendmentStore } from "./document-amendment-store.js";
-import { DocumentFrameRouter } from "./document-frame-router.js";
-import { LiveDocuments } from "./document-live-docs.js";
-import { DocumentLifecycle } from "./document-lifecycle.js";
-import { DocumentNotifications } from "./document-notify.js";
-import { DocumentHandshake } from "./document-handshake.js";
-import { DocumentWritePath } from "./document-write-path.js";
-import type { DaemonDatabase } from "./sqlcipher-db.js";
-import type { Logger } from "./types.js";
-export interface DocumentLayerDeps {
-    db: DaemonDatabase;
-    logger: Logger;
-    /**
-     * DOD-DOC-SCREEN-CONTENT-1 — the semantic screen for document content, on the projected text.
-     * Threaded from the composition root to `DocumentInbound`; see its dep for why it lives there.
-     */
-    screenProjected?: (text: string, ctx: {
-        ownerAgentId: string;
-        documentId: string;
-        senderAgentId: string;
-        correlationId?: string;
-    }) => Promise<{
-        block: boolean;
-        reason?: string;
-    }>;
-    /**
-     * The public key an agent id signs with, or null when this daemon cannot resolve one.
-     *
-     * REQUIRED. Returning null means "cannot verify", which both inbound paths treat as a refusal —
-     * the same answer as a bad signature, because admitting an envelope we cannot authenticate is
-     * the outcome the whole verify step exists to prevent.
-     *
-     * Injected rather than computed here even though M14-D5 makes a remote agent id BE its pubkey
-     * hex, because the daemon may want to refuse a peer it has no contact for, or resolve through a
-     * different binding later. `agentPublicKeyFromId` below is the default implementation.
-     */
-    publicKeyFor(agentId: string): Uint8Array | null;
-    /**
-     * The stable owner key for a daemon agent NAME — our own K_local pubkey hex (M14-D5).
-     *
-     * The session content path knows agents by name; every document row is scoped by owner key. Both
-     * halves of the layer must agree, and the delivery sweep already uses the pubkey hex. See
-     * `DocumentFrameRouterDeps.ownerKeyFor` for what a disagreement hides.
-     */
-    ownerKeyFor(agentName: string): string | null;
-    /**
-     * DOD-DOC-WATCH-1 — ring the operator's agent because a path IT declared it was waiting on has
-     * moved. Injected: the doorbell is the daemon's, not this layer's.
-     *
-     * Called ONLY on a watch hit. A document update raises no doorbell otherwise (§11.3) and that
-     * stands — this is the narrow exception an agent asked for by name.
-     */
-    nudge?(ownerAgentId: string, documentId: string, paths: readonly string[]): void;
-    /**
-     * Sign as a given agent. Takes the agent id so a rejection cannot be signed with the wrong key —
-     * the first version took no arguments and the composition root reached for whichever key
-     * provider was first in a map, which is fabricated crypto wearing a real signature.
-     *
-     * ASYNC because signing goes through a key provider, and that async is what forced the router to
-     * split synchronous CLASSIFICATION from asynchronous HANDLING.
-     */
-    sign(ownerAgentId: string, tbs: Uint8Array): Promise<Uint8Array>;
-    /**
-     * Put an already-encoded frame on the wire to a peer — the ack, today.
-     *
-     * Injected because the transport is not this layer's, and REQUIRED for the same reason the layer
-     * is all-or-nothing: an inbound path that cannot answer leaves every sender retrying until their
-     * document stalls.
-     */
-    /**
-     * Where documents are materialized as files. Absent disables the file surface entirely — the
-     * content verbs still work, and nothing silently half-writes.
-     */
-    workspaceRoot?: string;
-    sendFrame(ownerAgentId: string, peerAgentId: string, bytes: Uint8Array, 
-    /**
-     * The witnessed leaf DOMAIN. Omitted means the document kind (0x04), which is right for an ack;
-     * a REFUSAL passes 0x05. The directory discriminates on it when it builds the seal certificate,
-     * so a refusal recorded as a message is a refusal the certificate reports as something said.
-     */
-    leafKind?: number): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        reason: string;
-    }>;
-    /**
-     * A PEER REFUSED OUR EXCHANGE. Wired to the scheduler so the refusal can slow the asking down.
-     *
-     * Without it the refusal is logged and dropped, and the sweep — which can only see whether the
-     * frame was SENT — retries at full speed forever. Optional so a layer built without a scheduler
-     * (every unit fixture) needs no wiring; the scheduler treats the signal as a DELAY, never a
-     * prohibition (R41).
-     */
-    onPeerRefusal?(ownerAgentId: string, peerAgentId: string, terminal: boolean): void;
-}
-export interface DocumentLayer {
-    /**
-     * DOD-M12B-SHUTDOWN-1 — refuse every further outbound reconcile, whichever caller asks.
-     *
-     * The reconcile scheduler is only one of four routes to `initiateReconcile`; `nudgeSeats` and the
-     * two invite notices reach it directly, and every document verb is still served while the daemon
-     * tears down, because the IPC server is the last thing stopped. Gating the scheduler alone left
-     * three paths dialling peers and opening sessions on the way out.
-     *
-     * Idempotent and one-way. The reconcile exchange is idempotent (R40), so a refused reconcile is
-     * deferred to the next process, never lost.
-     */
-    stopReconciling(): void;
-    store: DocumentStore;
-    /** The file projection, or null when no workspace root was configured. */
-    writePath: DocumentWritePath | null;
-    handshake: DocumentHandshake;
-    engine: DocumentEngine;
-    live: LiveDocuments;
-    lifecycle: DocumentLifecycle;
-    notifications: DocumentNotifications;
-    rejections: DocumentRejections;
-    /** M14B — the entry chain: the fork-tolerant store the fold derives from. */
-    amendments: DocumentAmendmentStore;
-    /** The layer's one Ed25519 verifier seam — for handlers that run the replay themselves. */
-    verifySignature(agentId: string, tbs: Uint8Array, signature: Uint8Array): boolean;
-    /** M14B / FANOUT-1 — current holders derived from the chain; null when underivable. */
-    holdersFor(ownerAgentId: string, documentId: string): string[] | null;
-    isCurrentHolder(ownerAgentId: string, documentId: string, agentId: string): boolean;
-    /** SYNC-P5 (R43) — the sweep's (party → shared active documents) map, seats from the fold. */
-    sweepTargets(ownerAgentId: string): Map<string, string[]>;
-    /** SYNC-R46 — one party's sync state from the display cache (never a correctness input). */
-    partySync(ownerAgentId: string, documentId: string, partyAgentId: string): {
-        sync: "in_sync" | "behind" | "unseen";
-        lastSyncedAtMs: number | null;
-        blockedBy?: string;
-    };
-    /**
-     * DOD-DOC-PUSH-NOT-POLL-1 — what we hold that this party has not confirmed receiving, as a
-     * comparable fingerprint; `null` when there is nothing. The sweep's ONLY reason to speak.
-     */
-    pendingFor(ownerAgentId: string, documentId: string, partyAgentId: string): string | null;
-    /** SYNC-D8 — the ONE derivation of an agent's standing (R17 + removed/unknown), from the fold. */
-    standingOf(ownerAgentId: string, documentId: string, agentId: string): "participant" | "invited" | "removed" | "stranger" | "unknown";
-    /**
-     * SYNC-P3 — step 1 of the reconcile exchange: send this holder's position for the named
-     * documents to a peer. Everything after that is symmetric and handled by the frame router.
-     */
-    initiateReconcile(ownerAgentId: string, peerAgentId: string, documentIds: readonly string[]): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        reason: string;
-    }>;
-    /**
-     * SYNC-G1 — the fold's governance frontier for a document, or null when it cannot be
-     * derived. Publish stamps this into every envelope's signed TBS as content's causal anchor.
-     */
-    governanceFrontierFor(ownerAgentId: string, documentId: string): string[] | null;
-    /**
-     * SYNC-P4 (R27/R28) — the DERIVED ending and who a pending close still waits on. Null when
-     * the document cannot be derived.
-     */
-    deriveEnded(ownerAgentId: string, documentId: string): {
-        ended: "closed" | "killed" | null;
-        waitingOn: string[];
-    } | null;
-    router: DocumentFrameRouter;
-    /**
-     * The hook `SessionNodeManager.setOnDocumentFrame` takes. Handed out ready-shaped so the
-     * composition root does not re-derive the adapter — and so the `consumed` contract has exactly
-     * one definition.
-     */
-    onDocumentFrame(agentName: string, sessionId: string, content: Uint8Array, senderPubkey: string, correlationId?: string): {
-        consumed: boolean;
-        kind?: string;
-    };
-}
-/**
- * The default `publicKeyFor`: a remote agent's id IS its K_local public key, hex-encoded (M14-D5).
- *
- * `agent_id` in this daemon is a LOCAL primary key on the `agents` table — it names rows in our own
- * database and cannot identify a remote peer. The pubkey is the only self-verifying identifier
- * available: the signature checks against it directly, with no lookup that could be stale, missing
- * or poisoned sitting on the critical path of every authentication.
- *
- * Malformed input returns null rather than throwing, and null is a refusal. An id that is not a
- * 32-byte hex key is not "a peer we have no key for" — it is a frame that does not follow the
- * protocol — but both must refuse, and refusing loudly at the verify step is where it belongs.
- */
-export declare function agentPublicKeyFromId(agentId: string): Uint8Array | null;
-export declare function createDocumentLayer(deps: DocumentLayerDeps): DocumentLayer;
-//# sourceMappingURL=document-layer.d.ts.map

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

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