cursedbelt 2.6.1 → 2.7.0

package/dist/server/sync/index.js

@@ -0,0 +1,42 @@
+/**
+ * `cursedbelt/sync` — the op-log replication engine, shared rather than forked.
+ *
+ * ## Why it is here and not in the app
+ *
+ * The retired tree had FOUR consumers of this engine: `apps/vault` (8 files),
+ * `apps/station` (6), `apps/notes` (4) and `packages/feedback-kit` (5). `vault`
+ * graduated first and carried all 3,245 lines in whole, as
+ * `apps/vault/src/kit/sync/`, because a Phase A that also publishes a library is a
+ * Phase A that does not land. This is the other half of that trade, and it had a
+ * DEADLINE rather than a backlog slot: the moment `apps/station` graduates with the
+ * copy still in `vault`, the generation owns two divergent forks of a replication
+ * engine — the exact shape the owner ruled against on 2026-09-13, *"if we don't
+ * adapt to this at the right time then it will be hard to remember to keep updating
+ * multiple copies as the apps move and grow."*
+ *
+ * ## 🔴 A LEAF export, and it must stay one
+ *
+ * `cursedbelt/sync` resolves straight to this directory. It is deliberately NOT
+ * reachable through the `cursedbelt/server` barrel, which drags `kysely` and
+ * `otplib` behind it — an app that wants an op-log should not install two
+ * databases to get one. The only runtime dependency beneath this subpath is
+ * `hono` (for the receiver routes in `http.ts` and `commands.ts`); everything else
+ * is `bun:sqlite`, `node:crypto` and `node:fs`.
+ *
+ * It lives under `src/server/` because that is where this package's two typecheck
+ * projects put Bun's ambient types: the root `tsconfig.json` runs `types: []` to
+ * keep the browser/React surface pristine and EXCLUDES `src/server`, so
+ * `bun:sqlite` and `node:crypto` only resolve on this side of the split. The
+ * directory decides the types; the `exports` key decides the spelling.
+ */
+export { StopBatch, } from "./types";
+export { createOpLog } from "./opLog";
+export { createTokenStore } from "./tokens";
+export { createSyncApplier, pushToRemote, pullFromRemote, runSync, } from "./engine";
+export { capPageBytes, createHttpRemote, createSyncReceiver, } from "./http";
+export { DEFAULT_LOOP, isUnreachable, planNextSync, } from "./planner";
+export { OFFLINE_STATUS, PEER_CONTACT_WRITE_MS, createSyncStatusReporter, } from "./status";
+export { REQUEST_POLL_MS, startSyncTimer } from "./timer";
+export { createSyncAlarm } from "./alarm";
+export { DEFAULT_HOLD_MS, createCommandQueue, createCommandReceiver, createCommandRemote, startCommandWorker, } from "./commands";
+//# sourceMappingURL=index.js.map

package/dist/server/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/server/sync/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EACN,SAAS,GAQT,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,WAAW,EAAc,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAqC,MAAM,UAAU,CAAC;AAC/E,OAAO,EACN,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,OAAO,GAIP,MAAM,UAAU,CAAC;AAClB,OAAO,EACN,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,GAGlB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACN,YAAY,EACZ,aAAa,EACb,YAAY,GAGZ,MAAM,WAAW,CAAC;AACnB,OAAO,EACN,cAAc,EACd,qBAAqB,EACrB,wBAAwB,GAIxB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,eAAe,EAAE,cAAc,EAA4C,MAAM,SAAS,CAAC;AACpG,OAAO,EAAE,eAAe,EAA4D,MAAM,SAAS,CAAC;AACpG,OAAO,EACN,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,GAQlB,MAAM,YAAY,CAAC"}

package/dist/server/sync/opLog.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The durable op log + cursor bookkeeping, over the app's own `bun:sqlite` handle.
+ * Fixed table names (`sync_ops`, `sync_cursors`, `sync_meta`) — a consumer of this
+ * engine is expected to give sync its own tables rather than remap; the notes/vault
+ * retrofit maps their legacy tables behind this interface, not the other way round.
+ *
+ * Identity: `(origin, origin_seq)` UNIQUE — exactly-once application with no peer
+ * coordination (the notes ledger shape). `seq` is this instance's own monotonic
+ * stream every peer pages over.
+ */
+import type { Database } from "bun:sqlite";
+import type { SyncOp } from "./types";
+export interface OpLog {
+    /** This instance's stable id (minted once, persisted in sync_meta). */
+    instanceId(): string;
+    /** Record a locally-born op; returns it with seq/originSeq assigned. */
+    recordLocal(kind: string, payload: unknown, ts?: number): SyncOp;
+    /** Record a remote op into the ledger (dedupe identity kept). Caller applies state
+     *  FIRST in the same transaction scope; see `createSyncApplier`. */
+    recordRemote(op: SyncOp): void;
+    /** Is this (origin, originSeq) already in the ledger? */
+    has(origin: string, originSeq: number): boolean;
+    /** Page of ops with seq > after, excluding one origin (the peer's own — it already
+     *  has them), oldest first. `cursor` = last row's seq served (or `after`). */
+    listAfter(after: number, excludeOrigin: string, limit: number): {
+        ops: SyncOp[];
+        cursor: number;
+        head: number;
+    };
+    /** Highest local seq (0 when empty). */
+    head(): number;
+    /** Durable per-peer cursors. `direction`: what WE track about the peer. */
+    cursor(peerId: string, direction: "push" | "pull" | "served"): number;
+    setCursor(peerId: string, direction: "push" | "pull" | "served", seq: number): void;
+    /** Compaction for STATE-shaped kinds (a snapshot is not history): delete this
+     *  origin's OWN earlier ops of `kind` matching `payloadWhere` below `keepSeq`.
+     *  Safe under the exactly-once ledger — peers dedupe by (origin, originSeq),
+     *  pull pages tolerate seq gaps, and a deleted op is simply never sent. */
+    compactOwn(kind: string, keepSeq: number, payloadLike: string): number;
+    /** The same compaction, for a state kind that arrived from a PEER.
+     *
+     *  `compactOwn` is scoped to `origin = instanceId`, so a pure RECEIVER of a
+     *  state kind matches zero rows and its log grows without bound — prod
+     *  station reached 5,537 revisions of one `overview` snapshot (963 MB, ~160
+     *  MB/day) because every one of them originated on the Mac. The safety
+     *  argument on `compactOwn` never depended on who minted the op, only on the
+     *  kind being STATE rather than history, so it carries over verbatim.
+     *
+     *  Keyed on `origin_seq`, not local `seq`: a receiver compacts while
+     *  applying, which happens BEFORE the incoming row is inserted, so there is
+     *  no local seq yet to compare against. `(origin, origin_seq)` is the
+     *  ledger's own identity and is monotonic per origin, so it orders the
+     *  origin's stream exactly as well. */
+    compactOrigin(origin: string, kind: string, keepOriginSeq: number, payloadLike: string): number;
+    /** Arbitrary sync-scoped metadata (instance id lives here too). */
+    getMeta(key: string): string | null;
+    setMeta(key: string, value: string): void;
+    /** Run `fn` inside one sqlite transaction (apply + ledger-insert atomicity). */
+    transaction<T>(fn: () => T): T;
+}
+export declare function createOpLog(db: Database): OpLog;
+//# sourceMappingURL=opLog.d.ts.map

package/dist/server/sync/opLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opLog.d.ts","sourceRoot":"","sources":["../../../src/server/sync/opLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,MAAM,WAAW,KAAK;IACrB,uEAAuE;IACvE,UAAU,IAAI,MAAM,CAAC;IACrB,wEAAwE;IACxE,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjE;wEACoE;IACpE,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,yDAAyD;IACzD,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAChD;kFAC8E;IAC9E,SAAS,CACR,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,GACX;QAAE,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,wCAAwC;IACxC,IAAI,IAAI,MAAM,CAAC;IACf,2EAA2E;IAC3E,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACpF;;;+EAG2E;IAC3E,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IACvE;;;;;;;;;;;;;2CAauC;IACvC,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAChG,mEAAmE;IACnE,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,gFAAgF;IAChF,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;CAC/B;AAID,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,GAAG,KAAK,CA2H/C"}

package/dist/server/sync/opLog.js

@@ -0,0 +1,97 @@
+import { randomUUID } from "node:crypto";
+const INSTANCE_KEY = "sync.instance_id";
+export function createOpLog(db) {
+    db.exec(`
+		CREATE TABLE IF NOT EXISTS sync_ops (
+			seq INTEGER PRIMARY KEY AUTOINCREMENT,
+			origin TEXT NOT NULL,
+			origin_seq INTEGER NOT NULL,
+			ts INTEGER NOT NULL,
+			kind TEXT NOT NULL,
+			payload TEXT NOT NULL,
+			UNIQUE(origin, origin_seq)
+		);
+		CREATE INDEX IF NOT EXISTS idx_sync_ops_origin ON sync_ops(origin, seq);
+		CREATE TABLE IF NOT EXISTS sync_cursors (
+			peer_id TEXT NOT NULL,
+			direction TEXT NOT NULL,
+			seq INTEGER NOT NULL DEFAULT 0,
+			PRIMARY KEY(peer_id, direction)
+		);
+		CREATE TABLE IF NOT EXISTS sync_meta (
+			key TEXT PRIMARY KEY,
+			value TEXT NOT NULL
+		);
+	`);
+    const getMetaStmt = db.prepare("SELECT value FROM sync_meta WHERE key = ?");
+    const setMetaStmt = db.prepare("INSERT INTO sync_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+    const getMeta = (key) => getMetaStmt.get(key)?.value ?? null;
+    const setMeta = (key, value) => {
+        setMetaStmt.run(key, value);
+    };
+    let cachedId = getMeta(INSTANCE_KEY);
+    if (cachedId === null) {
+        // Short + url/label safe; uniqueness across a two-or-three instance fleet is
+        // what matters, not global collision resistance.
+        cachedId = `i-${randomUUID().slice(0, 12)}`;
+        setMeta(INSTANCE_KEY, cachedId);
+    }
+    const instanceId = cachedId;
+    const insertOp = db.prepare("INSERT INTO sync_ops (origin, origin_seq, ts, kind, payload) VALUES (?, ?, ?, ?, ?)");
+    const hasStmt = db.prepare("SELECT 1 FROM sync_ops WHERE origin = ? AND origin_seq = ? LIMIT 1");
+    const headStmt = db.prepare("SELECT COALESCE(MAX(seq), 0) AS head FROM sync_ops");
+    const maxOriginSeqStmt = db.prepare("SELECT COALESCE(MAX(origin_seq), 0) AS m FROM sync_ops WHERE origin = ?");
+    const listStmt = db.prepare("SELECT seq, origin, origin_seq, ts, kind, payload FROM sync_ops WHERE seq > ? AND origin != ? ORDER BY seq ASC LIMIT ?");
+    const compactStmt = db.prepare("DELETE FROM sync_ops WHERE origin = ? AND kind = ? AND seq < ? AND payload LIKE ?");
+    const compactOriginStmt = db.prepare("DELETE FROM sync_ops WHERE origin = ? AND kind = ? AND origin_seq < ? AND payload LIKE ?");
+    const cursorStmt = db.prepare("SELECT seq FROM sync_cursors WHERE peer_id = ? AND direction = ?");
+    const setCursorStmt = db.prepare("INSERT INTO sync_cursors (peer_id, direction, seq) VALUES (?, ?, ?) ON CONFLICT(peer_id, direction) DO UPDATE SET seq = excluded.seq");
+    const rowToOp = (row) => ({
+        seq: row.seq,
+        origin: row.origin,
+        originSeq: row.origin_seq,
+        ts: row.ts,
+        kind: row.kind,
+        payload: JSON.parse(row.payload),
+    });
+    return {
+        instanceId: () => instanceId,
+        recordLocal(kind, payload, ts) {
+            const at = ts ?? Date.now();
+            const originSeq = maxOriginSeqStmt.get(instanceId).m + 1;
+            insertOp.run(instanceId, originSeq, at, kind, JSON.stringify(payload ?? null));
+            const seq = headStmt.get().head;
+            return { seq, origin: instanceId, originSeq, ts: at, kind, payload };
+        },
+        recordRemote(op) {
+            insertOp.run(op.origin, op.originSeq, op.ts, op.kind, JSON.stringify(op.payload ?? null));
+        },
+        has: (origin, originSeq) => hasStmt.get(origin, originSeq) !== null,
+        listAfter(after, excludeOrigin, limit) {
+            const rows = listStmt.all(after, excludeOrigin, limit);
+            const ops = rows.map(rowToOp);
+            const head = headStmt.get().head;
+            // An all-excluded page must still advance the peer past what it skipped, or a
+            // log dominated by the peer's own reflected ops would page forever. Serve the
+            // true high-water mark of the WINDOW scanned: when the page is short, we
+            // reached head; otherwise the last row's seq.
+            const cursor = rows.length === 0 ? Math.max(after, head) : rows[rows.length - 1].seq;
+            return { ops, cursor, head };
+        },
+        head: () => headStmt.get().head,
+        compactOwn(kind, keepSeq, payloadLike) {
+            return compactStmt.run(instanceId, kind, keepSeq, payloadLike).changes;
+        },
+        compactOrigin(origin, kind, keepOriginSeq, payloadLike) {
+            return compactOriginStmt.run(origin, kind, keepOriginSeq, payloadLike).changes;
+        },
+        cursor: (peerId, direction) => cursorStmt.get(peerId, direction)?.seq ?? 0,
+        setCursor(peerId, direction, seq) {
+            setCursorStmt.run(peerId, direction, seq);
+        },
+        getMeta,
+        setMeta,
+        transaction: (fn) => db.transaction(fn)(),
+    };
+}
+//# sourceMappingURL=opLog.js.map

package/dist/server/sync/opLog.js.map

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

package/dist/server/sync/planner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The pure loop planner — vault's `planNextSync`, unchanged in spirit: back off after
+ * a failure, else honor a debounced dirty flag, else the steady interval. Pure so
+ * the timer is a thin wrapper and this is fake-clock testable.
+ */
+export interface SyncLoopConfig {
+    /** Steady poll cadence when reachable and idle. */
+    intervalMs: number;
+    /** How long after a local write to wait before syncing, so a burst coalesces. */
+    debounceMs: number;
+    /** First backoff step after a failure. */
+    backoffBaseMs: number;
+    /** Backoff ceiling — an unreachable peer (the nightly window) settles here. */
+    backoffMaxMs: number;
+}
+export declare const DEFAULT_LOOP: SyncLoopConfig;
+export interface SyncLoopState {
+    /** When the last sync attempt STARTED (0 if never). */
+    lastAttempt: number;
+    /** Consecutive failed attempts — drives exponential backoff. */
+    consecutiveFailures: number;
+    /** When the oldest un-synced local write happened, or null if clean. */
+    dirtySince: number | null;
+}
+export declare function planNextSync(state: SyncLoopState, now: number, cfg?: SyncLoopConfig): {
+    runNow: boolean;
+    waitMs: number;
+};
+/** A peer that is asleep (the nightly EC2 window) or an internet-less Mac is NORMAL,
+ *  not an error. It still feeds the backoff. */
+export declare function isUnreachable(err: unknown): boolean;
+//# sourceMappingURL=planner.d.ts.map

package/dist/server/sync/planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../../src/server/sync/planner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,cAAc;IAC9B,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,UAAU,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,YAAY,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,YAAY,EAAE,cAK1B,CAAC;AAEF,MAAM,WAAW,aAAa;IAC7B,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,wBAAgB,YAAY,CAC3B,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,MAAM,EACX,GAAG,GAAE,cAA6B,GAChC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAerC;AAED;gDACgD;AAChD,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKnD"}

package/dist/server/sync/planner.js

@@ -0,0 +1,31 @@
+/**
+ * The pure loop planner — vault's `planNextSync`, unchanged in spirit: back off after
+ * a failure, else honor a debounced dirty flag, else the steady interval. Pure so
+ * the timer is a thin wrapper and this is fake-clock testable.
+ */
+export const DEFAULT_LOOP = {
+    intervalMs: 5 * 60_000,
+    debounceMs: 3_000,
+    backoffBaseMs: 30_000,
+    backoffMaxMs: 30 * 60_000,
+};
+export function planNextSync(state, now, cfg = DEFAULT_LOOP) {
+    if (state.consecutiveFailures > 0) {
+        const step = Math.min(cfg.backoffMaxMs, cfg.backoffBaseMs * 2 ** (state.consecutiveFailures - 1));
+        const due = state.lastAttempt + step;
+        return now >= due ? { runNow: true, waitMs: 0 } : { runNow: false, waitMs: due - now };
+    }
+    if (state.dirtySince !== null) {
+        const due = state.dirtySince + cfg.debounceMs;
+        return now >= due ? { runNow: true, waitMs: 0 } : { runNow: false, waitMs: due - now };
+    }
+    const due = state.lastAttempt + cfg.intervalMs;
+    return now >= due ? { runNow: true, waitMs: 0 } : { runNow: false, waitMs: due - now };
+}
+/** A peer that is asleep (the nightly EC2 window) or an internet-less Mac is NORMAL,
+ *  not an error. It still feeds the backoff. */
+export function isUnreachable(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|fetch failed|timed out|The operation was aborted|network/i.test(msg);
+}
+//# sourceMappingURL=planner.js.map

package/dist/server/sync/planner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../../src/server/sync/planner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAaH,MAAM,CAAC,MAAM,YAAY,GAAmB;IAC3C,UAAU,EAAE,CAAC,GAAG,MAAM;IACtB,UAAU,EAAE,KAAK;IACjB,aAAa,EAAE,MAAM;IACrB,YAAY,EAAE,EAAE,GAAG,MAAM;CACzB,CAAC;AAWF,MAAM,UAAU,YAAY,CAC3B,KAAoB,EACpB,GAAW,EACX,MAAsB,YAAY;IAElC,IAAI,KAAK,CAAC,mBAAmB,GAAG,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CACpB,GAAG,CAAC,YAAY,EAChB,GAAG,CAAC,aAAa,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,GAAG,CAAC,CAAC,CACxD,CAAC;QACF,MAAM,GAAG,GAAG,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC;QACrC,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,CAAC;IACxF,CAAC;IACD,IAAI,KAAK,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,KAAK,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;QAC9C,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,CAAC;IACxF,CAAC;IACD,MAAM,GAAG,GAAG,KAAK,CAAC,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC;IAC/C,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,CAAC;AACxF,CAAC;AAED;gDACgD;AAChD,MAAM,UAAU,aAAa,CAAC,GAAY;IACzC,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC7D,OAAO,sGAAsG,CAAC,IAAI,CACjH,GAAG,CACH,CAAC;AACH,CAAC"}

package/dist/server/sync/status.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The status surface — vault's `SyncStatus` generalized verbatim, because its shape
+ * is the product of a real defect: `enabled: false` alone was read as "not syncing"
+ * on a receiving half that was in step the whole time. `role` is what tells the
+ * receiving half apart from a scratch instance, and anything reasoning about "is
+ * this instance syncing" must read `role`, not `enabled`.
+ */
+export interface SyncStatus {
+    /** Does THIS instance dial out at all? */
+    enabled: boolean;
+    /** dialer — runs the loop · receiver — answers the sync surface for a dialer ·
+     *  none — neither (a dev shell on its own scratch database). */
+    role: "dialer" | "receiver" | "none";
+    /** The peer's ORIGIN — never the bearer token. Null when unlinked. */
+    peer: string | null;
+    lastAttemptAt: number | null;
+    lastSuccessAt: number | null;
+    lastOutcome: "ok" | "unreachable" | "paused" | "error" | null;
+    /** Set while the push is version-skew paused (`blockedBy`) — names the op kind the
+     *  peer cannot take yet, i.e. "the peer needs deploying", the true statement. */
+    pausedOn: string | null;
+    consecutiveFailures: number;
+    /** Local writes the peer has not acknowledged yet — 0 means "fully in step". */
+    pending: number;
+    /** RECEIVER: when a dialing peer last authenticated against the sync surface. */
+    lastPeerContactAt: number | null;
+    /** RECEIVER: when someone last pressed "Sync now" here (the dialer polls it). */
+    syncRequestedAt: number | null;
+}
+export declare const OFFLINE_STATUS: SyncStatus;
+export interface SyncStatusReporter {
+    read(): SyncStatus;
+    /** The timer's / receiver hooks' writer half — nothing else should call it. */
+    update(patch: Partial<SyncStatus>): void;
+}
+/**
+ * Somewhere to keep the ONE field that is a fact about the DATA rather than about
+ * this process.
+ *
+ * 🔴 Why only `lastPeerContactAt`. Every other field describes the live process and
+ * SHOULD reset with it: a dialer that has not attempted anything since boot has
+ * genuinely not attempted anything, and a restored `consecutiveFailures: 3` would be
+ * a claim about failures that did not happen. But "a peer authenticated here" is
+ * something that happened to the database, and forgetting it produced the owner's
+ * 2026-08-16 report — prod saying *"Awaiting first sync"* over a vault he had used
+ * for weeks. The badge's own words are "your Mac has not dialled since this server
+ * last restarted", which is true and which nobody reads as anything but "this has
+ * never synced". A receiver restarts on every deploy, and the dialer runs every 5
+ * minutes only while the Mac is awake — so the window in which a perfectly converged
+ * pair reads as never-synced is wide. It was wider still when the receiver was the
+ * `prod-ec2` box (decommissioned since), which also slept 12am–10am CT: most of a
+ * morning, every morning. In-memory was the wrong home for it.
+ */
+export interface SyncStatusStore {
+    /** The stored contact stamp, or null if a peer has genuinely never called. */
+    loadPeerContactAt(): number | null;
+    /** Persist a newer stamp. Called at most once per {@link PEER_CONTACT_WRITE_MS}. */
+    savePeerContactAt(at: number): void;
+}
+/** A dialer makes several requests per run; one durable write per this window is
+ *  enough to answer "when did a peer last call" to the nearest half-minute. */
+export declare const PEER_CONTACT_WRITE_MS = 30000;
+export declare function createSyncStatusReporter(initial?: Partial<SyncStatus>, store?: SyncStatusStore): SyncStatusReporter;
+//# sourceMappingURL=status.d.ts.map

package/dist/server/sync/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/server/sync/status.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,UAAU;IAC1B,0CAA0C;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB;oEACgE;IAChE,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;IACrC,sEAAsE;IACtE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,IAAI,GAAG,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,IAAI,CAAC;IAC9D;qFACiF;IACjF,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gFAAgF;IAChF,OAAO,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,iFAAiF;IACjF,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,eAAO,MAAM,cAAc,EAAE,UAY5B,CAAC;AAEF,MAAM,WAAW,kBAAkB;IAClC,IAAI,IAAI,UAAU,CAAC;IACnB,+EAA+E;IAC/E,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,eAAe;IAC/B,8EAA8E;IAC9E,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAAC;IACnC,oFAAoF;IACpF,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED;+EAC+E;AAC/E,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C,wBAAgB,wBAAwB,CACvC,OAAO,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,EAC7B,KAAK,CAAC,EAAE,eAAe,GACrB,kBAAkB,CAwBpB"}

package/dist/server/sync/status.js

@@ -0,0 +1,50 @@
+/**
+ * The status surface — vault's `SyncStatus` generalized verbatim, because its shape
+ * is the product of a real defect: `enabled: false` alone was read as "not syncing"
+ * on a receiving half that was in step the whole time. `role` is what tells the
+ * receiving half apart from a scratch instance, and anything reasoning about "is
+ * this instance syncing" must read `role`, not `enabled`.
+ */
+export const OFFLINE_STATUS = {
+    enabled: false,
+    role: "none",
+    peer: null,
+    lastAttemptAt: null,
+    lastSuccessAt: null,
+    lastOutcome: null,
+    pausedOn: null,
+    consecutiveFailures: 0,
+    pending: 0,
+    lastPeerContactAt: null,
+    syncRequestedAt: null,
+};
+/** A dialer makes several requests per run; one durable write per this window is
+ *  enough to answer "when did a peer last call" to the nearest half-minute. */
+export const PEER_CONTACT_WRITE_MS = 30_000;
+export function createSyncStatusReporter(initial, store) {
+    const restored = store?.loadPeerContactAt() ?? null;
+    let current = {
+        ...OFFLINE_STATUS,
+        ...(restored === null ? {} : { lastPeerContactAt: restored }),
+        ...initial,
+    };
+    let lastWrittenAt = restored ?? 0;
+    return {
+        read: () => ({ ...current }),
+        update: (patch) => {
+            current = { ...current, ...patch };
+            const at = patch.lastPeerContactAt;
+            if (store && typeof at === "number" && at - lastWrittenAt >= PEER_CONTACT_WRITE_MS) {
+                lastWrittenAt = at;
+                // A status write must never be able to fail the sync request it rode in on.
+                try {
+                    store.savePeerContactAt(at);
+                }
+                catch {
+                    /* the in-memory value still answers; the next contact retries the write */
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=status.js.map

package/dist/server/sync/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../src/server/sync/status.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAyBH,MAAM,CAAC,MAAM,cAAc,GAAe;IACzC,OAAO,EAAE,KAAK;IACd,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,IAAI;IACV,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,IAAI;IACnB,WAAW,EAAE,IAAI;IACjB,QAAQ,EAAE,IAAI;IACd,mBAAmB,EAAE,CAAC;IACtB,OAAO,EAAE,CAAC;IACV,iBAAiB,EAAE,IAAI;IACvB,eAAe,EAAE,IAAI;CACrB,CAAC;AAiCF;+EAC+E;AAC/E,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C,MAAM,UAAU,wBAAwB,CACvC,OAA6B,EAC7B,KAAuB;IAEvB,MAAM,QAAQ,GAAG,KAAK,EAAE,iBAAiB,EAAE,IAAI,IAAI,CAAC;IACpD,IAAI,OAAO,GAAe;QACzB,GAAG,cAAc;QACjB,GAAG,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,QAAQ,EAAE,CAAC;QAC7D,GAAG,OAAO;KACV,CAAC;IACF,IAAI,aAAa,GAAG,QAAQ,IAAI,CAAC,CAAC;IAClC,OAAO;QACN,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC;QAC5B,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;YACjB,OAAO,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,KAAK,EAAE,CAAC;YACnC,MAAM,EAAE,GAAG,KAAK,CAAC,iBAAiB,CAAC;YACnC,IAAI,KAAK,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,EAAE,GAAG,aAAa,IAAI,qBAAqB,EAAE,CAAC;gBACpF,aAAa,GAAG,EAAE,CAAC;gBACnB,4EAA4E;gBAC5E,IAAI,CAAC;oBACJ,KAAK,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;gBAC7B,CAAC;gBAAC,MAAM,CAAC;oBACR,2EAA2E;gBAC5E,CAAC;YACF,CAAC;QACF,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/server/sync/timer.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The in-process dialer loop — vault's `syncTimer` generalized. Runs on the dialing
+ * half only; a failure NEVER takes the host daemon down (an unsynced instance still
+ * serves and still accepts writes — that is the point of two independently-writable
+ * instances). The timer is `unref`'d so it never holds the process open.
+ *
+ * The peer is re-resolved on EVERY tick, so linking (or revoking) a peer takes
+ * effect without a restart. The "Sync now" fast lane polls the receiver's request
+ * stamp every ~20s while healthy, so a button press on the far side means seconds,
+ * not "sometime in the next interval".
+ */
+import { type SyncLoopConfig } from "./planner";
+import type { SyncStatusReporter } from "./status";
+import type { SyncSummary } from "./types";
+export declare const REQUEST_POLL_MS = 20000;
+export interface SyncTimerDeps {
+    /** Re-read every tick: null = not linked (quiet no-op, re-checked next tick). */
+    resolvePeer: () => {
+        basePath: string;
+        token: string;
+    } | null;
+    /** Run one full reconciliation against the resolved peer. */
+    sync: (peer: {
+        basePath: string;
+        token: string;
+    }) => Promise<SyncSummary>;
+    /** The local op-log head — a head beyond the last synced one marks dirty. */
+    head: () => number;
+    /** Ask the peer whether its "Sync now" was pressed; null on any failure. */
+    checkRequest?: (peer: {
+        basePath: string;
+        token: string;
+    }) => Promise<number | null>;
+    status?: SyncStatusReporter;
+    loop?: SyncLoopConfig;
+    requestPollMs?: number;
+    now?: () => number;
+    setTimer?: (fn: () => void, ms: number) => unknown;
+    clearTimer?: (handle: unknown) => void;
+    log?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    /** Display origin for the status line; defaults to URL origin parsing. */
+    peerLabel?: (basePath: string) => string | null;
+}
+export interface SyncTimerHandle {
+    stop(): void;
+    /** Run the next tick immediately (the "Sync now" button on the dialing half). */
+    syncNow(): void;
+    /** Mark local writes pending (call after any local op) — debounces a burst. */
+    markDirty(): void;
+}
+export declare function startSyncTimer(deps: SyncTimerDeps): SyncTimerHandle;
+//# sourceMappingURL=timer.d.ts.map

package/dist/server/sync/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../../src/server/sync/timer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAIN,KAAK,cAAc,EAEnB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,eAAO,MAAM,eAAe,QAAS,CAAC;AAGtC,MAAM,WAAW,aAAa;IAC7B,iFAAiF;IACjF,WAAW,EAAE,MAAM;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC9D,6DAA6D;IAC7D,IAAI,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1E,6EAA6E;IAC7E,IAAI,EAAE,MAAM,MAAM,CAAC;IACnB,4EAA4E;IAC5E,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACrF,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IACnD,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,0EAA0E;IAC1E,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CAChD;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,IAAI,IAAI,CAAC;IACb,iFAAiF;IACjF,OAAO,IAAI,IAAI,CAAC;IAChB,+EAA+E;IAC/E,SAAS,IAAI,IAAI,CAAC;CAClB;AAUD,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,eAAe,CAiJnE"}

package/dist/server/sync/timer.js

@@ -0,0 +1,171 @@
+/**
+ * The in-process dialer loop — vault's `syncTimer` generalized. Runs on the dialing
+ * half only; a failure NEVER takes the host daemon down (an unsynced instance still
+ * serves and still accepts writes — that is the point of two independently-writable
+ * instances). The timer is `unref`'d so it never holds the process open.
+ *
+ * The peer is re-resolved on EVERY tick, so linking (or revoking) a peer takes
+ * effect without a restart. The "Sync now" fast lane polls the receiver's request
+ * stamp every ~20s while healthy, so a button press on the far side means seconds,
+ * not "sometime in the next interval".
+ */
+import { isUnreachable, DEFAULT_LOOP, planNextSync, } from "./planner";
+export const REQUEST_POLL_MS = 20_000;
+const KICKOFF_MS = 5_000;
+function defaultPeerLabel(basePath) {
+    try {
+        return new URL(basePath).origin;
+    }
+    catch {
+        return null;
+    }
+}
+export function startSyncTimer(deps) {
+    const now = deps.now ?? Date.now;
+    const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    const clearTimer = deps.clearTimer ?? ((h) => clearTimeout(h));
+    const loop = deps.loop ?? DEFAULT_LOOP;
+    const log = deps.log ?? ((m) => console.log(m));
+    const warn = deps.warn ?? ((m) => console.error(m));
+    const status = deps.status;
+    const peerLabel = deps.peerLabel ?? defaultPeerLabel;
+    const requestPollMs = deps.requestPollMs ?? REQUEST_POLL_MS;
+    status?.update({ enabled: true, role: "dialer" });
+    const state = { lastAttempt: 0, consecutiveFailures: 0, dirtySince: null };
+    let syncedHead = deps.head();
+    let stopped = false;
+    let handle = null;
+    let reportedUnreachable = false;
+    let forceRun = false;
+    let handledRequestAt = 0;
+    let probing = false;
+    let inFlight = false;
+    const schedule = (ms) => {
+        if (stopped)
+            return;
+        if (handle !== null)
+            clearTimer(handle);
+        handle = setTimer(tick, ms);
+        handle?.unref?.();
+    };
+    const sleepFor = (waitMs) => {
+        const healthy = state.consecutiveFailures === 0 && requestPollMs > 0;
+        return Math.max(1, healthy ? Math.min(waitMs, requestPollMs) : waitMs);
+    };
+    const probeRequest = (peer) => {
+        if (probing || requestPollMs === 0 || !deps.checkRequest)
+            return;
+        probing = true;
+        void deps
+            .checkRequest(peer)
+            .then((requestedAt) => {
+            if (stopped || requestedAt === null || requestedAt <= handledRequestAt)
+                return;
+            handledRequestAt = requestedAt;
+            log("[sync] sync requested from the peer — running now.");
+            forceRun = true;
+            schedule(1);
+        })
+            .finally(() => {
+            probing = false;
+        });
+    };
+    const tick = () => {
+        if (stopped)
+            return;
+        if (inFlight)
+            return; // two concurrent runs share cursors and would double-push
+        const head = deps.head();
+        if (head > syncedHead && state.dirtySince === null)
+            state.dirtySince = now();
+        const peer = deps.resolvePeer();
+        status?.update({
+            peer: peer === null ? null : peerLabel(peer.basePath),
+            pending: Math.max(0, head - syncedHead),
+        });
+        if (peer === null) {
+            schedule(loop.intervalMs);
+            return;
+        }
+        const plan = planNextSync(state, now(), loop);
+        if (!plan.runNow && !forceRun) {
+            const linkedAndHealthy = state.consecutiveFailures === 0 && requestPollMs > 0;
+            schedule(sleepFor(plan.waitMs));
+            if (linkedAndHealthy)
+                probeRequest(peer);
+            return;
+        }
+        forceRun = false;
+        state.lastAttempt = now();
+        status?.update({ lastAttemptAt: state.lastAttempt });
+        const headAtAttempt = head;
+        inFlight = true;
+        deps
+            .sync(peer)
+            .then((s) => {
+            state.consecutiveFailures = 0;
+            state.dirtySince = null;
+            syncedHead = headAtAttempt;
+            reportedUnreachable = false;
+            status?.update({
+                lastSuccessAt: now(),
+                lastOutcome: s.blockedBy ? "paused" : "ok",
+                pausedOn: s.blockedBy ?? null,
+                consecutiveFailures: 0,
+                pending: Math.max(0, deps.head() - syncedHead),
+            });
+            if (s.pushed > 0 || s.pulled > 0 || s.conflicts > 0) {
+                log(`[sync] ↑${s.pushed} ↓${s.pulled}` +
+                    (s.conflicts > 0 ? ` (${s.conflicts} conflicts)` : ""));
+            }
+            if (s.blockedBy) {
+                log(`[sync] push paused before "${s.blockedBy}" — the peer cannot take it yet (deploy pending?).`);
+            }
+        })
+            .catch((err) => {
+            state.consecutiveFailures += 1;
+            status?.update({
+                lastOutcome: isUnreachable(err) ? "unreachable" : "error",
+                consecutiveFailures: state.consecutiveFailures,
+            });
+            if (isUnreachable(err)) {
+                if (!reportedUnreachable) {
+                    log(`[sync] peer unreachable — will retry. This is normal (nightly window / offline).`);
+                    reportedUnreachable = true;
+                }
+            }
+            else {
+                warn(`[sync] failed (ignored): ${err instanceof Error ? err.message : err}`);
+            }
+        })
+            .finally(() => {
+            inFlight = false;
+            if (forceRun)
+                schedule(1);
+            else
+                schedule(sleepFor(Math.max(1_000, planNextSync(state, now(), loop).waitMs)));
+        });
+    };
+    schedule(KICKOFF_MS);
+    return {
+        stop: () => {
+            stopped = true;
+            if (handle !== null)
+                clearTimer(handle);
+        },
+        syncNow: () => {
+            if (stopped)
+                return;
+            forceRun = true;
+            schedule(1);
+        },
+        markDirty: () => {
+            if (stopped)
+                return;
+            if (state.dirtySince === null)
+                state.dirtySince = now();
+            schedule(1);
+        },
+    };
+}
+//# sourceMappingURL=timer.js.map