@cello-protocol/daemon 0.0.120 → 0.0.122

package/dist/document-lifecycle.js

@@ -0,0 +1,363 @@
+/**
+ * DOD-DOC-LIFECYCLE-1 — the verbs (§3.5 + §16.4).
+ *
+ * Three ways a document can end, and they are not interchangeable. Conflating any two of them
+ * makes a promise the protocol cannot keep:
+ *
+ *   close     BILATERAL. Both sides ack and the document is complete by agreement. One side's
+ *             close is a REQUEST — treating it as a conclusion would tell this operator the
+ *             collaboration ended while the peer is still writing into it.
+ *   kill      UNILATERAL. Stop accepting and publishing, notify the peer, and KEEP the local copy
+ *             and the log. The peer keeps what it holds, and that is said out loud: it is the one
+ *             thing an operator is most likely to assume a kill undoes, and the one thing it
+ *             cannot.
+ *   withdraw  ONE UNDELIVERED update. A local rollback plus a withdrawal record BESIDE the
+ *             original — marked, never deleted, because a hole in an append-only log is
+ *             indistinguishable from tampering. Once the peer has it, withdrawal is refused rather
+ *             than faked.
+ *
+ * ── THE KILL SWITCH (§16.7-11) ────────────────────────────────────────────────────────────────
+ *
+ * A platform-paused agent refuses OUTBOUND publishes loudly, still admits INBOUND mechanically,
+ * and suppresses notifications. The asymmetry is deliberate. Refusing inbound would surface the
+ * pause to the peer as a protocol fault and force a rejection round for something that is not
+ * their doing; refusing outbound silently would leave the operator writing into a document that is
+ * going nowhere, with their work piling up locally and no sign anything is wrong.
+ */
+const CREATE_LIFECYCLE_SQL = `
+  CREATE TABLE IF NOT EXISTS document_closes (
+    owner_agent_id TEXT    NOT NULL,
+    document_id    TEXT    NOT NULL,
+    -- WHO closed, not how many closes there were. Counting would let one party close a document
+    -- unilaterally by asking twice, which is precisely the bilateral guarantee gone.
+    closed_by      TEXT    NOT NULL,
+    created_at     INTEGER NOT NULL,
+    PRIMARY KEY (owner_agent_id, document_id, closed_by)
+  );
+
+  -- WITHDRAWALS live here, NOT in document_envelopes, and that placement is the fix for three
+  -- separate defects rather than a filing preference.
+  --
+  -- 1. CHAIN. A withdrawal is local-only by design: it is never delivered (the update it concerns
+  --    was never delivered, so the peer has nothing to act on). As an envelope it still advanced
+  --    our per-sender chain, so our NEXT update chained onto a node the peer will never hold and
+  --    the peer refused it with document_chain_broken — sending an operator to the chain layer for
+  --    a withdrawal-scoping bug, and leaving the document unopenable after their next restart.
+  --    Chaining it to the last DELIVERABLE envelope instead would fork our chain, since the next
+  --    update claims the same predecessor. It cannot be a node in that chain at all.
+  -- 2. CRYPTO. As an envelope it needed a signature and a state vector, and it had neither of its
+  --    own — the first version copied the ORIGINAL's, putting a real Ed25519 signature made over a
+  --    different record onto a permanent append-only row. document-rejection.ts states the rule
+  --    this violated in writing: required, never fabricated.
+  -- 3. REPLAY. An envelope row is something rebuildSnapshot must reason about; an audit row is not.
+  --
+  -- Same shape as document_quarantine, for the same reason: audit that must survive, must not be
+  -- replayed, and must not be chained.
+  CREATE TABLE IF NOT EXISTS document_withdrawals (
+    owner_agent_id TEXT    NOT NULL,
+    document_id    TEXT    NOT NULL,
+    envelope_hash  TEXT    NOT NULL,
+    created_at     INTEGER NOT NULL,
+    PRIMARY KEY (owner_agent_id, document_id, envelope_hash)
+  );
+
+  CREATE TABLE IF NOT EXISTS agent_platform_pause (
+    agent_id   TEXT    NOT NULL PRIMARY KEY,
+    paused     INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  );
+`;
+export class DocumentLifecycle {
+    #store;
+    #logger;
+    #notifier;
+    #rollback;
+    constructor(store, logger, notifier, 
+    /**
+     * Undo one envelope's operations on the LIVE document, as inverses. Injected because the live
+     * `Y.Doc` and its UndoManager belong to the engine, not here — and REQUIRED, because a default
+     * that quietly did nothing would restore exactly the defect this argument exists to fix.
+     */
+    rollback) {
+        this.#store = store;
+        this.#logger = logger;
+        this.#notifier = notifier;
+        this.#rollback = rollback;
+        this.#store.rawDb.exec(CREATE_LIFECYCLE_SQL);
+    }
+    list(ownerAgentId, nowMs) {
+        // Every pending envelope regardless of schedule: the operator is asking "what has not reached
+        // my peer", not "what is due for a retry in the next few seconds".
+        const pending = this.#store.pendingDeliveries(ownerAgentId, Number.MAX_SAFE_INTEGER);
+        const pendingByDocument = new Map();
+        for (const e of pending) {
+            pendingByDocument.set(e.documentId, (pendingByDocument.get(e.documentId) ?? 0) + 1);
+        }
+        void nowMs;
+        return this.#store.listDocuments(ownerAgentId).map((d) => ({
+            documentId: d.documentId,
+            peerAgentId: d.peerAgentId,
+            documentType: d.documentType,
+            assuranceTier: "authenticated",
+            epochId: 0,
+            status: d.status,
+            pendingDeliveries: pendingByDocument.get(d.documentId) ?? 0,
+            closePending: this.#hasClosed(ownerAgentId, d.documentId, ownerAgentId) &&
+                !this.#hasClosed(ownerAgentId, d.documentId, d.peerAgentId),
+        }));
+    }
+    /** Our half of a bilateral close. Completes only when the peer's half is also on record. */
+    async close(ownerAgentId, documentId, nowMs) {
+        const doc = this.#store.getDocument(ownerAgentId, documentId);
+        if (!doc) {
+            return { ok: false, reason: "document_unknown", detail: `no document ${documentId.slice(0, 16)}…` };
+        }
+        this.#recordClose(ownerAgentId, documentId, ownerAgentId, nowMs);
+        const notified = await this.#notifier.notifyPeer(documentId, "close");
+        if (!notified.ok) {
+            this.#logger.warn("document.close.peer_not_notified", { documentId, reason: notified.reason });
+        }
+        this.#settleClose(ownerAgentId, documentId, doc.peerAgentId);
+        this.#logger.info("document.close.requested", { documentId });
+        return { ok: true };
+    }
+    /** The peer's half, arriving over the session. */
+    recordPeerClose(ownerAgentId, documentId, peerAgentId, nowMs) {
+        const doc = this.#store.getDocument(ownerAgentId, documentId);
+        if (!doc) {
+            // Without this the row is written for a document that does not exist — there is no foreign
+            // key on this table — and `setDocumentStatus` updates zero rows and returns silently.
+            return {
+                ok: false,
+                reason: "document_unknown",
+                detail: `no document ${documentId.slice(0, 16)}… for this agent`,
+            };
+        }
+        if (peerAgentId !== doc.peerAgentId) {
+            // THE BILATERAL GUARANTEE. The closer id came from the caller and was written as `closed_by`
+            // and settled against ITSELF, so any second distinct string — a stale contact id, a
+            // pubkey-vs-name mismatch, a hostile session — plus our own close flipped the document to
+            // closed. The whole point of recording WHO closed is defeated if who is never checked.
+            this.#logger.warn("document.close.not_peer", {
+                documentId,
+                claimedBy: peerAgentId,
+                peerAgentId: doc.peerAgentId,
+            });
+            return {
+                ok: false,
+                reason: "document_close_not_peer",
+                detail: `${peerAgentId} is not this document's peer (${doc.peerAgentId}), so their close is not ` +
+                    `the other half of a bilateral close`,
+            };
+        }
+        this.#recordClose(ownerAgentId, documentId, doc.peerAgentId, nowMs);
+        this.#settleClose(ownerAgentId, documentId, doc.peerAgentId);
+        this.#logger.info("document.close.peer_requested", { documentId, peerAgentId: doc.peerAgentId });
+        return { ok: true };
+    }
+    /**
+     * Unilateral end. Local, and deliberately not contingent on the peer hearing about it — a
+     * decision to stop that depends on the other party being online is not a decision to stop.
+     */
+    async kill(ownerAgentId, documentId, nowMs) {
+        const doc = this.#store.getDocument(ownerAgentId, documentId);
+        if (!doc) {
+            return { ok: false, reason: "document_unknown", detail: `no document ${documentId.slice(0, 16)}…` };
+        }
+        void nowMs;
+        this.#store.setDocumentStatus(ownerAgentId, documentId, "killed");
+        const notified = await this.#notifier.notifyPeer(documentId, "kill");
+        if (!notified.ok) {
+            // Reported, not swallowed: a kill the peer never heard about leaves them publishing into a
+            // document that will never answer, and the operator is the one who needs to know that.
+            this.#logger.error("document.kill.peer_not_notified", {
+                documentId,
+                peerAgentId: doc.peerAgentId,
+                reason: notified.reason,
+            });
+        }
+        this.#logger.info("document.killed", { documentId, peerNotified: notified.ok });
+        return {
+            ok: true,
+            peerNotified: notified.ok,
+            note: "this document no longer accepts or publishes updates, and your local copy and log are " +
+                "retained. Your peer keeps what it holds — a kill stops the collaboration, it does not " +
+                "retract content they already have.",
+        };
+    }
+    /**
+     * Withdraw ONE undelivered update: a withdrawal record beside the original.
+     *
+     * Every refusal here is the same shape — say no rather than produce a record that claims
+     * something untrue about the log.
+     */
+    withdraw(ownerAgentId, documentId, envelopeHash, nowMs) {
+        const log = this.#store.getEnvelopeLog(ownerAgentId, documentId);
+        const original = log.find((e) => e.envelopeHash === envelopeHash);
+        if (!original) {
+            // A withdrawal record pointing at nothing is worse than a refusal: it is a permanent claim
+            // in an append-only store about an envelope that never existed.
+            return {
+                ok: false,
+                reason: "document_envelope_unknown",
+                detail: `no envelope ${envelopeHash.slice(0, 16)}… in this document's log`,
+            };
+        }
+        if (original.senderAgentId !== ownerAgentId) {
+            return {
+                ok: false,
+                reason: "document_not_author",
+                detail: `envelope ${envelopeHash.slice(0, 16)}… was authored by ${original.senderAgentId}, not by you`,
+            };
+        }
+        if (original.ackedAtMs != null) {
+            // The honest refusal. Withdrawing a delivered update would tell the operator their content
+            // was retracted while the peer is holding it — the promise this module refuses to make.
+            return {
+                ok: false,
+                reason: "document_already_delivered",
+                detail: `envelope ${envelopeHash.slice(0, 16)}… has already been delivered and acknowledged — ` +
+                    `your peer holds it, so it cannot be withdrawn. Publish a superseding update instead.`,
+            };
+        }
+        // THE LOCAL ROLLBACK — the half that was missing. Writing only the record left the original in
+        // the log WITH its payload, and replay applies every update payload in order, so the withdrawn
+        // text stayed in the operator's own document and came back on every rebuild. The operator was
+        // told their update was withdrawn while their file still contained it.
+        //
+        // Rolled back as INVERSES through the same undo path a rejection uses, never by dropping the
+        // payload: our own later work may be causally stacked on these operations, and REJECT-1
+        // measured what removing them costs — everything after stays pending forever and the document
+        // silently loses the legitimate work. The inverse enters the log on the next ordinary publish,
+        // computed from the live document, which is also why neither the original nor the inverse is
+        // ever delivered: the peer holds neither, and the next publish carries the net effect.
+        const rolledBack = this.#rollback(ownerAgentId, documentId, envelopeHash);
+        if (!rolledBack.ok) {
+            return {
+                ok: false,
+                reason: "document_withdraw_rollback_failed",
+                detail: `the local rollback did not happen (${rolledBack.reason}), so nothing was withdrawn — ` +
+                    `reporting success here would tell you your update was retracted while your file still ` +
+                    `contains it`,
+            };
+        }
+        const info = this.#store.rawDb
+            .prepare(`INSERT INTO document_withdrawals (owner_agent_id, document_id, envelope_hash, created_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT (owner_agent_id, document_id, envelope_hash) DO NOTHING`)
+            .run(ownerAgentId, documentId, envelopeHash, nowMs);
+        if (Number(info.changes) === 0) {
+            // Already withdrawn. Reported rather than inferred — the earlier version ignored the write's
+            // outcome and returned success for a no-op.
+            return {
+                ok: false,
+                reason: "document_already_withdrawn",
+                detail: `envelope ${envelopeHash.slice(0, 16)}… was already withdrawn`,
+            };
+        }
+        this.#logger.info("document.withdrawn", { documentId, envelopeHash });
+        return { ok: true };
+    }
+    // ─── the kill switch (§16.7-11) ───────────────────────────────────────────
+    setPlatformPaused(agentId, paused, nowMs) {
+        this.#store.rawDb
+            .prepare(`INSERT INTO agent_platform_pause (agent_id, paused, updated_at) VALUES (?, ?, ?)
+         ON CONFLICT (agent_id) DO UPDATE SET paused = excluded.paused, updated_at = excluded.updated_at`)
+            // Hard-wired to 0 before, so every row read 1970 — on the KILL SWITCH, where "when was this
+            // agent paused by the platform" is the audit fact of the whole feature. The tell was that it
+            // was the only method in the class taking no clock.
+            .run(agentId, paused ? 1 : 0, nowMs);
+        this.#logger.warn("agent.platform_pause.changed", { agentId, paused });
+    }
+    isPlatformPaused(agentId) {
+        const r = this.#store.rawDb
+            .prepare("SELECT paused FROM agent_platform_pause WHERE agent_id = ?")
+            .get(agentId);
+        return (r?.paused ?? 0) === 1;
+    }
+    /** Outbound. Refused loudly while paused, and while the document has ended. */
+    canPublish(ownerAgentId, documentId) {
+        if (this.isPlatformPaused(ownerAgentId)) {
+            return {
+                ok: false,
+                reason: "agent_platform_paused",
+                detail: `this agent is paused by the platform, so nothing can be published. Your work is kept ` +
+                    `locally and will publish once the agent is unpaused.`,
+            };
+        }
+        const doc = this.#store.getDocument(ownerAgentId, documentId);
+        if (!doc) {
+            return { ok: false, reason: "document_unknown", detail: `no document ${documentId.slice(0, 16)}…` };
+        }
+        if (doc.status === "closed") {
+            return { ok: false, reason: "document_closed", detail: "this document was closed by agreement" };
+        }
+        if (doc.status === "killed") {
+            return { ok: false, reason: "document_killed", detail: "this document was ended locally" };
+        }
+        if (doc.status === "stalled") {
+            // REJECT-1 stalls a document after its retry rounds. A stalled document has stopped
+            // converging, so publishing into it is the same lie as publishing into a killed one — and
+            // two partial gates that each know half the terminal states is how a caller ends up wrong
+            // about the other half.
+            return {
+                ok: false,
+                reason: "document_stalled",
+                detail: "this document stopped accepting updates after repeated rejections",
+            };
+        }
+        return { ok: true };
+    }
+    /** Inbound. A pause does NOT refuse it — see the header. */
+    canAdmit(ownerAgentId, documentId) {
+        const doc = this.#store.getDocument(ownerAgentId, documentId);
+        if (!doc) {
+            return { ok: false, reason: "document_unknown", detail: `no document ${documentId.slice(0, 16)}…` };
+        }
+        if (doc.status === "killed") {
+            return { ok: false, reason: "document_killed", detail: "this document was ended locally" };
+        }
+        if (doc.status === "closed") {
+            return { ok: false, reason: "document_closed", detail: "this document was closed by agreement" };
+        }
+        if (doc.status === "stalled") {
+            return {
+                ok: false,
+                reason: "document_stalled",
+                detail: "this document stopped accepting updates after repeated rejections",
+            };
+        }
+        return { ok: true };
+    }
+    shouldNotify(agentId) {
+        return !this.isPlatformPaused(agentId);
+    }
+    // ─── internals ────────────────────────────────────────────────────────────
+    #recordClose(ownerAgentId, documentId, closedBy, nowMs) {
+        this.#store.rawDb
+            .prepare(`INSERT INTO document_closes (owner_agent_id, document_id, closed_by, created_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT (owner_agent_id, document_id, closed_by) DO NOTHING`)
+            .run(ownerAgentId, documentId, closedBy, nowMs);
+    }
+    #hasClosed(ownerAgentId, documentId, who) {
+        const r = this.#store.rawDb
+            .prepare(`SELECT 1 AS present FROM document_closes
+          WHERE owner_agent_id = ? AND document_id = ? AND closed_by = ?`)
+            .get(ownerAgentId, documentId, who);
+        return r?.present === 1;
+    }
+    #settleClose(ownerAgentId, documentId, peerAgentId) {
+        // ONLY FROM ACTIVE. Unconditional, a peer close arriving after a unilateral kill overwrote
+        // `killed` with `closed` — the operator's own decision replaced by "closed by agreement", which
+        // is a different fact and the one they did not choose. Same for `stalled`.
+        if (this.#store.getDocument(ownerAgentId, documentId)?.status !== "active")
+            return;
+        if (this.#hasClosed(ownerAgentId, documentId, ownerAgentId) &&
+            this.#hasClosed(ownerAgentId, documentId, peerAgentId)) {
+            this.#store.setDocumentStatus(ownerAgentId, documentId, "closed");
+            this.#logger.info("document.closed", { documentId });
+        }
+    }
+}
+//# sourceMappingURL=document-lifecycle.js.map

package/dist/document-lifecycle.js.map

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

package/dist/document-notify.d.ts

@@ -0,0 +1,130 @@
+/**
+ * DOD-DOC-NOTIFY-1 — passive notification and the two read calls (§16.5, §4.1).
+ *
+ * ── WHY NO DOORBELL ───────────────────────────────────────────────────────────────────────────
+ *
+ * A document update raises NO doorbell (§11.3 — doorbell-on-update is parked). The notice sits in
+ * the inbox aggregation and the agent finds it the next time it looks. That is the whole design:
+ * a collaborator typing produces a stream of updates, and a doorbell per update would interrupt
+ * the operator's agent continuously for something that has no deadline. The one-line summary the
+ * agent eventually reads carries the same information at none of the cost.
+ *
+ * Following the `contact_rename_notices` precedent: there is no inbox store — the inbox is computed
+ * per call — so a derived section needs its own table and its own getter.
+ *
+ * The notice carries `document_id` and a PENDING COUNT, and nothing else. Not a preview, not the
+ * first line, not the author's words. Content reaches the agent only through the two read calls
+ * below, which are screened; a notification that carried content would be an unscreened path into
+ * the agent's context, which is the whole prompt-injection surface §3.1 exists to close.
+ *
+ * ── THE TWO READ CALLS (§4.1) ─────────────────────────────────────────────────────────────────
+ *
+ * `diffStats` is STRUCTURAL ONLY — counts, ranges, and the overlap flag. It exists so an agent can
+ * decide whether to read without reading, which is exactly what a cautious agent should be able to
+ * do. `diff` is the git-like diff itself and is an ordinary screened read.
+ *
+ * ── SUPPORTED TYPES FOR `diff`, DECIDED IN-UNIT ───────────────────────────────────────────────
+ *
+ * Markdown, plain text, and JSON. Markdown and plain text share one line-diff implementation (a
+ * markdown file IS lines); JSON gets a key-path diff because a line diff over re-serialized JSON
+ * reports the whole document as changed whenever a formatter touches it. Anything else returns a
+ * REFUSAL naming the type rather than a line diff over bytes that are not lines — a diff that is
+ * wrong is worse than no diff, because the agent cannot tell.
+ */
+import type { DocumentStore } from "./document-store.js";
+import type { Logger } from "./types.js";
+/** Types `diff` can render. Decided in-unit; see the header for why the list is closed. */
+export declare const DIFFABLE_DOCUMENT_TYPES: readonly ["markdown", "text", "json"];
+export type DiffableDocumentType = (typeof DIFFABLE_DOCUMENT_TYPES)[number];
+export interface DocumentNotice {
+    documentId: string;
+    pending: number;
+    noticedAtMs: number;
+}
+export interface DiffStats {
+    documentId: string;
+    linesAdded: number;
+    linesRemoved: number;
+    /** 1-based inclusive line ranges the change touches. Ranges, never the lines themselves. */
+    ranges: Array<{
+        start: number;
+        end: number;
+    }>;
+    /** For JSON: the key paths touched. Empty for line-oriented types. */
+    keyPaths: string[];
+    /**
+     * Whether the peer's change touches a region this operator also edited. The one field here that
+     * is a judgement rather than a count, and the reason an agent reads stats before deciding.
+     */
+    overlap: boolean | null;
+    /** Whether `keyPaths` was computed at all — an empty list is otherwise read as "none changed". */
+    keyPathsComputed: boolean;
+    /** The document exceeded the LCS limit, so the numbers above are bounds, not a measurement. */
+    truncated: boolean;
+}
+export type DiffResult = {
+    ok: true;
+    documentType: DiffableDocumentType;
+    diff: string;
+    /**
+     * Set when the renderer could not do what the type asked for. A notice inside the diff STRING
+     * is readable by a human and invisible to a caller branching on the result — and it travels
+     * as screened content, which is the wrong channel for a fact about the renderer.
+     */
+    fallback?: "unparseable_json_line_diff";
+} | {
+    ok: false;
+    reason: string;
+    detail: string;
+};
+export declare class DocumentNotifications {
+    #private;
+    constructor(store: DocumentStore, logger: Logger);
+    /**
+     * Note that a document has unread updates. Passive — this never pushes anything.
+     *
+     * The count is REPLACED rather than incremented, and is passed in by the caller from the log,
+     * so the notice cannot drift from the document. An incremented counter is a second tally of a
+     * fact the log already holds, and the two disagree the first time a notice write is missed.
+     */
+    notice(agentId: string, documentId: string, pending: number, nowMs: number): void;
+    /** The derived inbox section. Read-only — fetching is what clears, and that is explicit. */
+    pending(agentId: string): DocumentNotice[];
+    /**
+     * Cleared by the agent's EXPLICIT fetch, never by the aggregation that displays it.
+     *
+     * Reading the inbox and clearing the notice are different acts: an inbox render that cleared
+     * would drop the notice for an agent that merely glanced at a summary, and the update would then
+     * be unread and unannounced — invisible in both directions.
+     */
+    clear(agentId: string, documentId: string): boolean;
+    /**
+     * Structural counts and ranges — NO content. Lets an agent decide whether to read.
+     *
+     * `before` and `after` are the materialized text of the document at the two points; the caller
+     * holds the engine and therefore the materialization.
+     *
+     * Uses the SHARED line LCS, not a positional walk. The first version compared line i to line i,
+     * which is correct only while the line count is unchanged: inserting one line at the top of a
+     * three-line file reported `+4 -3` with a single range covering the whole document. The counts
+     * being wrong is the smaller half — `overlap` is derived from those ranges, so it became
+     * permanently true, and a flag that always says yes trains the agent to ignore it. Same defect
+     * class WRITE-1 measured, which is why there is now one LCS rather than two.
+     */
+    diffStats(documentId: string, before: string, after: string, 
+    /**
+     * The operator's own edited line numbers. REQUIRED — pass `null` to say "not computed".
+     * Defaulting to `[]` made a caller that simply forgot receive `overlap: false`, the reassuring
+     * answer, indistinguishable from "checked, and there is no conflict". This is the one
+     * judgement field in an otherwise structural result.
+     */
+    myEdits: readonly number[] | null, documentType?: string): DiffStats;
+    /**
+     * The git-like diff. An ordinary screened read — the caller screens it; this renders it.
+     *
+     * An unsupported type is REFUSED by name rather than line-diffed anyway. A diff that is silently
+     * wrong is worse than no diff, because the agent has no way to tell and will act on it.
+     */
+    diff(documentType: string, before: string, after: string, documentId: string): DiffResult;
+}
+//# sourceMappingURL=document-notify.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"document-notify.d.ts","sourceRoot":"","sources":["../src/document-notify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAazC,2FAA2F;AAC3F,eAAO,MAAM,uBAAuB,uCAAwC,CAAC;AAC7E,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5E,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,4FAA4F;IAC5F,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9C,sEAAsE;IACtE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;;OAGG;IACH,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,kGAAkG;IAClG,gBAAgB,EAAE,OAAO,CAAC;IAC1B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,UAAU,GAClB;IACE,EAAE,EAAE,IAAI,CAAC;IACT,YAAY,EAAE,oBAAoB,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,QAAQ,CAAC,EAAE,4BAA4B,CAAC;CACzC,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD,qBAAa,qBAAqB;;gBAIpB,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM;IAMhD;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAsBjF,4FAA4F;IAC5F,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE;IAc1C;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAWnD;;;;;;;;;;;;OAYG;IACH,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM;IACb;;;;;OAKG;IACH,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,EACjC,YAAY,CAAC,EAAE,MAAM,GACpB,SAAS;IA2DZ;;;;;OAKG;IACH,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,UAAU;CA8B1F"}