@tensorix/metahub 0.1.10 → 0.2.0

package/dist/core/blobs-core.d.ts

@@ -0,0 +1,106 @@
+import type { DbDriver } from "./driver.ts";
+export declare const POLICY_ID = "default";
+export type Redundancy = "all" | "any";
+export interface BlobPolicy {
+    fullNodes: string[];
+    redundancy: Redundancy;
+}
+export interface CachedBlob {
+    hash: string;
+    size: number;
+    content_type: string | null;
+    last_access: number | null;
+    /** Node-local pin: 1 = never auto-evicted / cleared (does not sync). */
+    pinned: number;
+    /** 1 = bytes produced here, not yet flushed to a durable anchor — protected. */
+    pending: number;
+    /** Node-local: 1 = the last presence verify confirmed a designated anchor holds
+     *  this blob (per redundancy). Drives isClearable; reset to 0 on policy change. */
+    anchored: number;
+}
+export interface CacheStats {
+    /** Total bytes currently held in the node-local cache. */
+    totalBytes: number;
+    /** Bytes safe to clear (durable on the required full set). */
+    clearableBytes: number;
+    /** Bytes that cannot be cleared (sole copy / no anchor / this is a full node). */
+    retainedBytes: number;
+    count: number;
+    clearableCount: number;
+}
+export declare function readPolicy(db: DbDriver): BlobPolicy;
+/** Designate the full-blob anchors (synced workspace policy). Each entry is
+ *  either a node id (a device that keeps everything) OR a bucket url `s3://…`
+ *  (object storage as a durable full library). Bucket urls never match a node id,
+ *  so isFullBlobNode()/isClearable() are unaffected — they're a visible guardrail. */
+export declare const setFullNodes: (db: DbDriver, nodeIds: string[]) => void;
+export declare const setRedundancy: (db: DbDriver, redundancy: Redundancy) => void;
+/** Is `node` (default: this device) a designated full-blob library? */
+export declare function isFullBlobNode(db: DbDriver, node?: string): boolean;
+/**
+ * Whether this device may safely drop `hash`'s local bytes — a purely LOCAL,
+ * offline decision read from local flags. Clearable requires ALL of:
+ *  1. This node is not itself the full-blob library (a full node keeps everything).
+ *  2. The blob is not a `pending` production (bytes produced here, not yet flushed
+ *     to an anchor) — the only locally-unique copy.
+ *  3. `anchored == 1`: the last presence verify confirmed a designated anchor holds
+ *     this blob, per redundancy(any/all). Until a verify runs (or after a policy
+ *     change resets it), anchored is 0 → nothing is clearable (conservative). This
+ *     replaces the earlier coarse "an anchor is designated" floor with a per-blob,
+ *     freshly-verified fact. See verifyAnchorPresence (blobs.ts) and
+ *     docs/impl-context/22-blob-sync (D4, on-demand presence verify).
+ */
+export declare function isClearable(db: DbDriver, hash: string): boolean;
+/** Record/clear the per-blob "a designated anchor verifiably holds this" flag. */
+export declare function setAnchored(db: DbDriver, hash: string, anchored: boolean): void;
+export declare function isAnchored(db: DbDriver, hash: string): boolean;
+/** Drop every verified verdict (after a policy change) — forces a re-verify before
+ *  anything is clearable again. Also clears the last-verified stamp. */
+export declare function invalidateAnchored(db: DbDriver): void;
+/** Epoch-ms of the last successful presence verify, or null if never / invalidated. */
+export declare function readBlobVerifiedAt(db: DbDriver): number | null;
+export declare function writeBlobVerifiedAt(db: DbDriver, ts: number): void;
+/** Blob hashes referenced by a `/blob/<hash>` URL inside a markdown/text value. */
+export declare function blobRefsIn(text: string | null): string[];
+/**
+ * Every blob hash a live document or site still points at. Union of:
+ *  - site_files rows stored as a blob (content = hash), and
+ *  - `/blob/<hash>` references inside live doc_blocks markdown (doc images).
+ * Drives GC (orphan = not in this set) and a full node's byte acquisition.
+ */
+export declare function referencedHashes(db: DbDriver): Set<string>;
+/** Record/refresh a blob's ledger row after its bytes land in the cache. */
+/** Record/refresh a cached blob. `pending`: 1 for bytes PRODUCED here (must flush
+ *  to an anchor before they're clearable), 0 for an ACQUIRED cache copy (already
+ *  durable at its source). */
+export declare function recordBlob(db: DbDriver, hash: string, size: number, contentType?: string | null, pending?: number): void;
+/** Mark a blob flushed (0) or pending (1). Flush is set after the bytes are
+ *  confirmed at the durable anchor (see blobs.ts blobMaintenance). */
+export declare function setPending(db: DbDriver, hash: string, pending: boolean): void;
+/** Bump last_access on a cache hit (LRU signal for stats/future eviction). */
+export declare function touchBlob(db: DbDriver, hash: string): void;
+export declare function forgetBlob(db: DbDriver, hash: string): void;
+export declare function cachedBlobs(db: DbDriver): CachedBlob[];
+/** Blobs produced here that are not yet flushed to a durable anchor (the upload
+ *  worklist; steady state is empty). */
+export declare function pendingBlobs(db: DbDriver): {
+    hash: string;
+    size: number;
+}[];
+/** Pin/unpin a cached blob (node-local; never synced). Returns true when a row
+ *  was updated (false when the hash isn't in the ledger). */
+export declare function setPinned(db: DbDriver, hash: string, pinned: boolean): boolean;
+/** Is a cached blob pinned? (false when not in the ledger). */
+export declare function isPinned(db: DbDriver, hash: string): boolean;
+/** Recorded content type for a cached blob (null when unknown / not cached). */
+export declare function blobContentType(db: DbDriver, hash: string): string | null;
+export declare function cacheStats(db: DbDriver): CacheStats;
+export interface KnownNode {
+    nodeId: string;
+    label: string | null;
+    self: boolean;
+}
+/** Distinct node ids this device knows about (self + outbound peers + grantees),
+ *  for the "pick a full-blob device" selector in Settings / CLI. */
+export declare function knownNodes(db: DbDriver): KnownNode[];
+//# sourceMappingURL=blobs-core.d.ts.map

package/dist/core/blobs-core.d.ts.map

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

package/dist/core/blobs.d.ts

@@ -0,0 +1,100 @@
+import type { DbDriver } from "./driver.ts";
+export * from "./blobs-core.ts";
+export interface KnownBucket {
+    url: string;
+    label: string | null;
+    bucket: string | null;
+}
+/** Attached object-storage buckets (s3 peers), for the "pick a full-blob anchor"
+ *  selector in Settings. A bucket is a durable full-blob library but is NOT a node
+ *  (1:N store-and-forward, no single node id), so it lives alongside knownNodes()
+ *  rather than inside it — designated by its synthetic url, not a node_id. */
+export declare function knownBuckets(db: DbDriver): KnownBucket[];
+/**
+ * Resolve a blob's bytes by content hash: local cache → each enabled HTTP peer's
+ * `GET /blob/<hash>?local=1` (local=1 keeps the peer from re-resolving, so there
+ * are no fetch loops) → each attached bucket's `blobs/<hash>`. Content-addressed,
+ * so every source is verified by re-hashing and any source is interchangeable.
+ * The first verified hit is cached locally and returned; null when unreachable.
+ */
+export declare function resolveBlob(db: DbDriver, hash: string): Promise<Uint8Array | null>;
+export interface VerifyResult {
+    /** Blobs confirmed durable on the anchor set (per redundancy) → clearable. */
+    anchoredCount: number;
+    anchoredBytes: number;
+    /** Designated anchors (bucket urls / device node ids) we could not reach to
+     *  check. Under `all`, any unreachable anchor makes everything un-clearable. */
+    unreachable: string[];
+    /** Epoch-ms this verify ran. */
+    at: number;
+}
+/**
+ * Verify, right now, which locally-cached blobs a designated anchor durably holds,
+ * and record the per-blob `anchored` flag that `isClearable` reads. Buckets are
+ * checked with one paginated LIST (listBucketBlobHashes); device anchors with a
+ * `POST /api/blobs/has`. An anchor we can't reach (offline / no stored url+token /
+ * bad creds) goes into `unreachable` and is treated as NOT holding anything —
+ * conservative, so a transient outage defers clearing rather than risking loss.
+ *
+ * Redundancy: `any` → present on ≥1 reachable anchor; `all` → every designated
+ * anchor reachable AND holding it. Run on demand only (panel open / refresh /
+ * pre-eviction when over quota), never in the steady-state maintenance loop.
+ */
+export declare function verifyAnchorPresence(db: DbDriver): Promise<VerifyResult>;
+export interface BlobMaintenanceResult {
+    /** Referenced blobs a full library pulled in this round. */
+    acquired: number;
+    /** Pending productions confirmed flushed to the bucket(s) this round. */
+    flushed: number;
+    /** Blobs auto-evicted to stay under the configured cache quota. */
+    evicted: number;
+}
+/**
+ * Background blob upkeep, run from the sync tick (throttled). Cheap in steady
+ * state — it only touches work that actually exists:
+ *  1. A full blob library pulls every referenced blob it is still MISSING
+ *     (resolveBlob); self-limiting, a no-op once caught up.
+ *  2. This node flushes its own PENDING productions to each attached bucket, then
+ *     marks them flushed (→ clearable). It iterates ONLY pending blobs (empty in
+ *     steady state), so — unlike the old design — it does NOT re-read/encrypt/HEAD
+ *     every already-uploaded blob each round.
+ *  3. Evicts to stay under the cache quota.
+ */
+export declare function blobMaintenance(db: DbDriver): Promise<BlobMaintenanceResult>;
+export interface EvictResult {
+    evicted: number;
+    freedBytes: number;
+}
+/**
+ * Auto-evict clearable, unpinned blobs by least-recently-accessed order until the
+ * local cache total is at/under the low-water mark. No-op when quotaBytes <= 0
+ * (disabled) or the cache is already under quota. Only touches blobs `isClearable`
+ * marks safe (durable on the full set) and never a pinned blob — bytes stay
+ * re-fetchable, so this is loss-free.
+ */
+export declare function evictToQuota(db: DbDriver, quotaBytes: number): Promise<EvictResult>;
+export interface ClearResult {
+    /** Blobs whose bytes were dropped. */
+    cleared: number;
+    /** Actual bytes freed on disk. */
+    freedBytes: number;
+    /** Blobs left in place (sole copy / no anchor / this is a full node). */
+    skipped: number;
+}
+export interface GcResult {
+    removed: number;
+    freedBytes: number;
+}
+/**
+ * Fold on-disk cache files into the blob_cache ledger so stats/clear/gc also see
+ * blobs written before the ledger existed. content_type is unknown for these
+ * (left null — serve falls back to the URL suffix).
+ */
+export declare function reconcileCache(db: DbDriver): void;
+/** Drop the bytes of every locally-cached blob that is safe to clear (durable on
+ *  the designated full set). Reference + hash stay in the oplog, re-fetchable. */
+export declare function clearCache(db: DbDriver): Promise<ClearResult>;
+/** Drop bytes for blobs no live site_files / doc image still references (true
+ *  garbage, distinct from clearable cache). */
+export declare function gcOrphans(db: DbDriver): Promise<GcResult>;
+//# sourceMappingURL=blobs.d.ts.map

package/dist/core/blobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobs.d.ts","sourceRoot":"","sources":["../../src/core/blobs.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAsB5C,cAAc,iBAAiB,CAAC;AAEhC,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED;;;8EAG8E;AAC9E,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,GAAG,WAAW,EAAE,CAYxD;AAWD;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAgCxF;AAID,MAAM,WAAW,YAAY;IAC3B,8EAA8E;IAC9E,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB;oFACgF;IAChF,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;CACZ;AAqBD;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAoD9E;AAED,MAAM,WAAW,qBAAqB;IACpC,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAsClF;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAMD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CA4BzF;AAED,MAAM,WAAW,WAAW;IAC1B,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAiBjD;AAED;kFACkF;AAClF,wBAAsB,UAAU,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,CAgBnE;AAED;+CAC+C;AAC/C,wBAAsB,SAAS,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAY/D"}

package/dist/core/cache.d.ts

@@ -4,7 +4,24 @@ export interface BlobInfo {
     size: number;
 }
 export declare function blobPath(hash: string): string;
-/** Store bytes content-addressed (sha256) under cache/. Returns its hash + path. */
+/** Content key length: sha256 truncated to 128 bits (32 hex). Shorter keys keep
+ *  doc markdown (`![](/blob/<hash>.png)`) readable; collision is negligible.
+ *  Addressing stays length-agnostic, so legacy full 64-hex refs still resolve. */
+export declare const BLOB_HASH_HEX = 32;
+/** Full sha256 hex of the bytes. */
+export declare function sha256Hex(bytes: Uint8Array): string;
+/** Canonical content hash for new blobs: sha256 of the bytes, truncated. */
+export declare function blobHash(bytes: Uint8Array): string;
+/** Verify fetched bytes match a content reference of either length (canonical
+ *  32-hex or legacy 64-hex) — the ref is always a prefix of the full sha256. */
+export declare function verifyBlobBytes(bytes: Uint8Array, hash: string): boolean;
+/** Store bytes content-addressed under cache/. Returns its hash + path. */
 export declare function putBlob(data: ArrayBuffer | Uint8Array | string): Promise<BlobInfo>;
 export declare function getBlob(hash: string): Promise<Uint8Array | null>;
+/** Store bytes under a GIVEN content hash (not recomputed) — for caching a blob
+ *  fetched from a peer/bucket by its reference, which may be a legacy 64-hex hash
+ *  that putBlob's truncation would not reproduce. Returns the byte length. */
+export declare function putBlobAt(hash: string, bytes: Uint8Array): Promise<number>;
+/** Remove a blob's bytes from the cache. Returns its size, or 0 if absent. */
+export declare function deleteBlob(hash: string): Promise<number>;
 //# sourceMappingURL=cache.d.ts.map

package/dist/core/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/core/cache.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,oFAAoF;AACpF,wBAAsB,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAaxF;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAItE"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/core/cache.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;kFAEkF;AAClF,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,oCAAoC;AACpC,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAInD;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAElD;AAED;gFACgF;AAChF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAExE;AAED,2EAA2E;AAC3E,wBAAsB,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAWxF;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAItE;AAED;;8EAE8E;AAC9E,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAIhF;AAED,8EAA8E;AAC9E,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAM9D"}

package/dist/core/compact.d.ts

@@ -0,0 +1,43 @@
+import type { Database } from "bun:sqlite";
+export interface CompactResult {
+    /** HLC cutoff actually used — history at or before this collapses to a baseline. */
+    cutoff: string;
+    deleted_changes: number;
+    kept_changes: number;
+    blobs_deleted: number;
+    blob_bytes_freed: number;
+    db_bytes_before: number;
+    db_bytes_after: number;
+    dry_run: boolean;
+}
+export interface CompactOptions {
+    /** Keep full history for this many days; 0 keeps only the head state. */
+    keepDays: number;
+    /** Report what would be removed without changing anything. */
+    dryRun?: boolean;
+    /** Run VACUUM afterwards to return the freed pages to the filesystem. */
+    vacuum?: boolean;
+    /** Test hook: "now" in epoch millis. */
+    now?: number;
+}
+export declare function compactOplog(db: Database, opts: CompactOptions): CompactResult;
+/**
+ * Delete cache blobs no longer referenced by any remaining oplog value, a
+ * materialized site file, or a `/blob/<hash>` doc image reference. Conservative:
+ * only files named like a content hash (canonical 32-hex or legacy 64-hex) are
+ * candidates; anything else in the cache dir is left alone.
+ */
+export declare function gcBlobs(db: Database, opts?: {
+    dryRun?: boolean;
+}): {
+    deleted: number;
+    bytes: number;
+};
+/** Dry-run quick stats for doctor: total oplog rows and how many compaction
+ *  with the given window would remove. */
+export declare function compactEstimate(db: Database, keepDays: number, now?: number): {
+    total_changes: number;
+    compactable_changes: number;
+    db_bytes: number;
+};
+//# sourceMappingURL=compact.d.ts.map

package/dist/core/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../src/core/compact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AA0B3C,MAAM,WAAW,aAAa;IAC5B,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,wCAAwC;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAqBD,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,cAAc,GAAG,aAAa,CAkD9E;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CACrB,EAAE,EAAE,QAAQ,EACZ,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9B;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CA2DpC;AAED;0CAC0C;AAC1C,wBAAgB,eAAe,CAC7B,EAAE,EAAE,QAAQ,EACZ,QAAQ,EAAE,MAAM,EAChB,GAAG,SAAa,GACf;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAa1E"}

package/dist/core/config.d.ts

@@ -1,14 +1,17 @@
-import type { Database } from "bun:sqlite";
+import type { DbDriver } from "./driver.ts";
 export interface ServerConfig {
     host: string;
     port: number;
     /** Auto-sync poll interval in ms; <= 0 disables the timer. */
     syncIntervalMs: number;
     autoSync: boolean;
+    /** Local blob cache quota in bytes. When the cache exceeds it, the sync tick
+     *  auto-evicts clearable, unpinned blobs (LRU). <= 0 disables eviction. */
+    blobCacheQuotaBytes: number;
 }
 export declare const DEFAULT_CONFIG: ServerConfig;
 /** Persisted server config, falling back to DEFAULT_CONFIG per field. */
-export declare function getServerConfig(db: Database): ServerConfig;
+export declare function getServerConfig(db: DbDriver): ServerConfig;
 /** Persist a partial config update. Only provided fields are written. */
-export declare function setServerConfig(db: Database, partial: Partial<ServerConfig>): ServerConfig;
+export declare function setServerConfig(db: DbDriver, partial: Partial<ServerConfig>): ServerConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/core/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/core/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAQ3C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,cAAc,EAAE,YAK5B,CAAC;AAeF,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,GAAG,YAAY,CAW1D;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAO1F"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/core/config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAS5C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB;+EAC2E;IAC3E,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,cAAc,EAAE,YAM5B,CAAC;AAeF,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,GAAG,YAAY,CAc1D;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAS1F"}

package/dist/core/context.d.ts

@@ -1,11 +1,11 @@
-import type { Database } from "bun:sqlite";
+import type { DbDriver } from "./driver.ts";
 import { type DatabaseRow } from "./databases.ts";
 /**
  * The current database, or null. Validated on read: if it points at a database
  * that no longer exists (deleted, or gone after a snapshot restore), the stale
  * pointer is cleared and null returned — no coupling to delete/restore paths.
  */
-export declare function getCurrentDatabase(db: Database): DatabaseRow | null;
-export declare function setCurrentDatabase(db: Database, id: string): void;
-export declare function clearCurrentDatabase(db: Database): void;
+export declare function getCurrentDatabase(db: DbDriver): DatabaseRow | null;
+export declare function setCurrentDatabase(db: DbDriver, id: string): void;
+export declare function clearCurrentDatabase(db: DbDriver): void;
 //# sourceMappingURL=context.d.ts.map

package/dist/core/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/core/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAO/D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,GAAG,WAAW,GAAG,IAAI,CAWnE;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAIjE;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAEvD"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/core/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAO/D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,GAAG,WAAW,GAAG,IAAI,CAWnE;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAIjE;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAEvD"}

package/dist/core/crdt.d.ts

@@ -1,4 +1,4 @@
-import type { Database } from "bun:sqlite";
+import type { DbDriver } from "./driver.ts";
 export interface Change {
     hlc: string;
     node_id: string;
@@ -6,6 +6,29 @@ export interface Change {
     row_id: string;
     col: string;
     value: string | null;
+    txn?: string | null;
+}
+/** Oplog SELECT list, locked to the Change interface (also reused by history). */
+export declare const CHANGE_COLS: readonly ["hlc", "node_id", "dataset", "row_id", "col", "value", "txn"];
+export declare const CHANGE_SELECT: string;
+/**
+ * Run `fn` with all emits stamped with one shared txn id. Nested calls keep the
+ * outermost group (a revert that calls updateDocument is ONE revision). `label`
+ * prefixes the id ("repair:", "revert:") so history can classify the source.
+ */
+export declare function withChangeGroup<T>(label: string | null, fn: () => T): T;
+/** Wrap a mutator so its body runs inside one change group. */
+export declare function grouped<A extends unknown[], R>(fn: (...args: A) => R, label?: string | null): (...args: A) => R;
+/** Outcome of applying one change to the oplog. `inserted` reports whether the
+ *  oplog actually gained a NEW row (false when we already had this exact change —
+ *  the INSERT OR IGNORE was a no-op); it is the honest "did we receive new data"
+ *  signal, distinct from `winner` (whether this change now wins its register and
+ *  was materialized). Re-applying a change we already hold still returns
+ *  `winner:true` if it's the current max-HLC, so callers that want progress (not
+ *  re-materialization) must key off `inserted`. */
+export interface ApplyResult {
+    inserted: boolean;
+    winner: boolean;
 }
 /**
  * Record a change in the oplog (idempotent) and, if it is the latest write for
@@ -13,23 +36,46 @@ export interface Change {
  * of the order changes are applied, because the winner is recomputed as the max
  * HLC over the full oplog for that register.
  */
-export declare function applyChange(db: Database, c: Change): boolean;
+export declare function applyChange(db: DbDriver, c: Change): ApplyResult;
 /** Apply a local write: assign a fresh HLC, append to oplog, materialize. */
-export declare function emit(db: Database, dataset: string, rowId: string, col: string, value: unknown): Change;
+export declare function emit(db: DbDriver, dataset: string, rowId: string, col: string, value: unknown): Change;
 /** Apply multiple local field writes to the same row. */
-export declare function emitFields(db: Database, dataset: string, rowId: string, fields: Record<string, unknown>): Change[];
-/** Apply remote changes from a sync peer (advances clock, then merges). */
-export declare function ingest(db: Database, changes: Change[]): number;
+export declare function emitFields(db: DbDriver, dataset: string, rowId: string, fields: Record<string, unknown>): Change[];
+/** Apply remote changes from a sync peer (advances clock, then merges). Returns
+ *  the number of changes that were NEW to our oplog (rows actually inserted) —
+ *  the honest "received" count. Re-ingesting data we already hold returns 0, so
+ *  this is a reliable progress signal for the auto-sync backoff (a round that
+ *  only re-reads known data must not count as activity). */
+export declare function ingest(db: DbDriver, changes: Change[]): number;
 /** All oplog changes with HLC strictly greater than `since` (test/debug helper). */
-export declare function changesSince(db: Database, since: string): Change[];
+export declare function changesSince(db: DbDriver, since: string): Change[];
 export interface ChangeBatch {
     changes: Change[];
     cursor: number;
 }
+export interface ChangesAfterOpts {
+    /** Max rows to return — pagination for large pulls (initial hydration). */
+    limit?: number;
+    /** Datasets to omit (partial replicas, e.g. a phone skipping site_files). */
+    excludeDatasets?: string[];
+    /**
+     * Return only changes this node produced itself. Storage-sync (see
+     * sync/storage.ts) publishes each node's own ops under its own bucket prefix,
+     * so it must not re-upload ops it merely ingested from peers. The cursor still
+     * advances over the filtered-out rows (high-water on exhaustion), so ingested
+     * ops are skipped once, not rescanned every round.
+     */
+    onlyNode?: string;
+}
 /**
  * Changes inserted after `seq` (a local rowid), in insertion order, plus the
  * new high-water cursor. Used for replication: insertion order never skips a
  * change even when clocks are skewed.
+ *
+ * With `limit`, the cursor stops at the last returned row so the next pull
+ * resumes there; when the scan is exhausted (fewer rows than the limit, or no
+ * limit) the cursor jumps to the table's high-water rowid so excluded-dataset
+ * tails aren't rescanned every round.
  */
-export declare function changesAfterSeq(db: Database, seq: number): ChangeBatch;
+export declare function changesAfterSeq(db: DbDriver, seq: number, opts?: ChangesAfterOpts): ChangeBatch;
 //# sourceMappingURL=crdt.d.ts.map

package/dist/core/crdt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crdt.d.ts","sourceRoot":"","sources":["../../src/core/crdt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAO3C,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AA0ID;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAc5D;AAED,6EAA6E;AAC7E,wBAAgB,IAAI,CAClB,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,GACb,MAAM,CAYR;AAED,yDAAyD;AACzD,wBAAgB,UAAU,CACxB,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,EAAE,CAMV;AAED,2EAA2E;AAC3E,wBAAgB,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAW9D;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAMlE;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAStE"}
+{"version":3,"file":"crdt.d.ts","sourceRoot":"","sources":["../../src/core/crdt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAW5C,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB;AAED,kFAAkF;AAClF,eAAO,MAAM,WAAW,yEAA0E,CAAC;AAEnG,eAAO,MAAM,aAAa,QAAyB,CAAC;AAMpD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQvE;AAED,+DAA+D;AAC/D,wBAAgB,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAC5C,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,EACrB,KAAK,GAAE,MAAM,GAAG,IAAW,GAC1B,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAEnB;AAkJD;;;;;;mDAMmD;AACnD,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,CAiBhE;AAED,6EAA6E;AAC7E,wBAAgB,IAAI,CAClB,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,GACb,MAAM,CAaR;AAED,yDAAyD;AACzD,wBAAgB,UAAU,CACxB,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,EAAE,CAMV;AAED;;;;4DAI4D;AAC5D,wBAAgB,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAW9D;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAIlE;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,QAAQ,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,gBAAqB,GAC1B,WAAW,CAkCb"}

package/dist/core/databases.d.ts

@@ -1,19 +1,33 @@
-import type { Database } from "bun:sqlite";
+import type { DbDriver } from "./driver.ts";
 export interface DatabaseRow {
     id: string;
     name: string;
     icon: string | null;
     created_hlc: string;
 }
-export declare function createDatabase(db: Database, opts: {
+export declare const DATABASE_COLS: readonly ["id", "name", "icon", "created_hlc"];
+export declare const createDatabase: (db: DbDriver, opts: {
     name: string;
     icon?: string;
-}): DatabaseRow;
-export declare function updateDatabase(db: Database, id: string, fields: {
+}) => DatabaseRow;
+export declare const updateDatabase: (db: DbDriver, id: string, fields: {
     name?: string;
     icon?: string | null;
-}): DatabaseRow;
-export declare function getDatabase(db: Database, id: string): DatabaseRow | null;
-export declare function listDatabases(db: Database): DatabaseRow[];
-export declare function deleteDatabase(db: Database, id: string): boolean;
+}) => DatabaseRow;
+/**
+ * Copy a database whole — name, icon, every property (type/config/position
+ * preserved) and every record (in order, cells carried via an old→new property
+ * id map, so duplicate property names copy losslessly). A relation column
+ * pointing back at the *source* database is remapped to the copy so it stays
+ * self-referential; relations to other databases keep their target.
+ * `name`/`icon` override the defaults; the locale "copy" suffix is the
+ * caller's job. All emits share one txn, so the copy syncs as one revision.
+ */
+export declare const duplicateDatabase: (db: DbDriver, id: string, opts?: {
+    name?: string;
+    icon?: string;
+} | undefined) => DatabaseRow;
+export declare function getDatabase(db: DbDriver, id: string): DatabaseRow | null;
+export declare function listDatabases(db: DbDriver): DatabaseRow[];
+export declare const deleteDatabase: (db: DbDriver, id: string) => boolean;
 //# sourceMappingURL=databases.d.ts.map

package/dist/core/databases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"databases.d.ts","sourceRoot":"","sources":["../../src/core/databases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK3C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,cAAc,CAC5B,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACpC,WAAW,CAMb;AAED,wBAAgB,cAAc,CAC5B,EAAE,EAAE,QAAQ,EACZ,EAAE,EAAE,MAAM,EACV,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAC9C,WAAW,CAKb;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAMxE;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,GAAG,WAAW,EAAE,CAMzD;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAqBhE"}
+{"version":3,"file":"databases.d.ts","sourceRoot":"","sources":["../../src/core/databases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAQ5C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,aAAa,gDAAiD,CAAC;AAI5E,eAAO,MAAM,cAAc;UAEX,MAAM;WAAS,MAAM;iBAOnC,CAAC;AAEH,eAAO,MAAM,cAAc;WAGR,MAAM;WAAS,MAAM,GAAG,IAAI;iBAM7C,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;WAGb,MAAM;WAAS,MAAM;6BAwBpC,CAAC;AAEH,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAIxE;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,GAAG,WAAW,EAAE,CAIzD;AAED,eAAO,MAAM,cAAc,uCAqBzB,CAAC"}

package/dist/core/db.d.ts

@@ -1,32 +1,6 @@
 import { Database } from "bun:sqlite";
+export { runSchema, ftsAvailable, migrateRecords, migratePeers, migrateDocBlocks, migrateDocuments, migrateOplog, initSchema, } from "./schema-init.ts";
 export declare function ensureDirs(): void;
-export declare function runSchema(db: Database): void;
-export declare function ftsAvailable(db: Database): boolean;
-/**
- * Migrate legacy EAV records (record_values: one row per cell) to the JSON
- * layout (records.data: one row per record). Idempotent — keyed off schema
- * shape, no version flag. A no-op for fresh databases.
- */
-export declare function migrateRecords(db: Database): void;
-/**
- * Add the peer-pairing columns to a legacy `peers` table (token/label/node_id/
- * enabled/last_sync_at/last_status/last_error). Idempotent — guarded per column,
- * never drops the table so existing replication cursors survive.
- */
-export declare function migratePeers(db: Database): void;
-/**
- * Add the `blank_after` column to a legacy `doc_blocks` table. Idempotent —
- * guarded by hasColumn; existing blocks default to 0 (canonical single-blank-line
- * separators), so the migration never changes an existing document's body.
- */
-export declare function migrateDocBlocks(db: Database): void;
-/**
- * Add the `order_key` column to a legacy `documents` table and backfill it.
- * Idempotent — guarded by hasColumn; backfill only touches rows with a NULL key,
- * assigning per-parent fractional indices in current created_hlc order, so the
- * displayed document order is unchanged until the user first drags something.
- */
-export declare function migrateDocuments(db: Database): void;
 /** Open (and migrate) the on-disk metahub database for the resolved home. */
 export declare function openMetahub(): Database;
 //# sourceMappingURL=db.d.ts.map

package/dist/core/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/core/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAOtC,wBAAgB,UAAU,IAAI,IAAI,CAGjC;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAO5C;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAKlD;AAeD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAuBjD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAa/C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAGnD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAInD;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,IAAI,QAAQ,CAUtC"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/core/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAOtC,OAAO,EACL,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACZ,UAAU,GACX,MAAM,kBAAkB,CAAC;AAE1B,wBAAgB,UAAU,IAAI,IAAI,CAGjC;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,IAAI,QAAQ,CAMtC"}

package/dist/core/documents.d.ts

@@ -1,4 +1,4 @@
-import type { Database } from "bun:sqlite";
+import type { DbDriver } from "./driver.ts";
 export interface DocumentRow {
     id: string;
     title: string;
@@ -9,35 +9,48 @@ export interface DocumentRow {
     order_key: string | null;
 }
 export type DocumentSummary = Omit<DocumentRow, "body">;
+export declare const DOCUMENT_COLS: readonly ["id", "title", "body", "database_id", "parent_id", "created_hlc", "order_key"];
 /** Max HLC over a document's own register and all its blocks — a read/edit token. */
-export declare function documentVersion(db: Database, id: string): string;
-export declare function createDocument(db: Database, opts: {
+export declare function documentVersion(db: DbDriver, id: string): string;
+export declare const createDocument: (db: DbDriver, opts: {
     title: string;
     body?: string;
     database_id?: string;
     parent_id?: string;
-}): DocumentRow;
-export declare function getDocument(db: Database, id: string): DocumentRow | null;
-export declare function listDocuments(db: Database, opts?: {
+}) => DocumentRow;
+export declare function getDocument(db: DbDriver, id: string): DocumentRow | null;
+export declare function listDocuments(db: DbDriver, opts?: {
     database_id?: string;
     parent_id?: string;
 }): DocumentSummary[];
 /** Backfill order_key for every parent group that has un-keyed live documents. */
-export declare function backfillDocumentOrderKeys(db: Database): void;
+export declare const backfillDocumentOrderKeys: (db: DbDriver) => void;
 /**
  * Move a document next to / into another, atomically updating both its parent
  * and its order_key. `into` nests it as the last child of `targetId`;
  * `before`/`after` re-orders (and reparents if needed) among the target's siblings.
  */
-export declare function moveDocument(db: Database, id: string, targetId: string, where: "before" | "after" | "into"): DocumentRow;
-export declare function updateDocument(db: Database, id: string, fields: {
+export declare const moveDocument: (db: DbDriver, id: string, targetId: string, where: "before" | "after" | "into") => DocumentRow;
+/**
+ * Copy a document — title, every block (verbatim, with fresh block ids so the
+ * copy edits independently) and its `database_id`/`parent_id`. The copy lands
+ * right after its source in the same sibling scope. Blocks are cloned at the
+ * block level (not via a markdown round-trip) so empty list items / blank-line
+ * runs survive losslessly. `title`/`parentId` override the defaults; the locale
+ * "copy" suffix is the caller's job. `created_hlc` is the copy's own birth time.
+ */
+export declare const duplicateDocument: (db: DbDriver, id: string, opts?: {
+    title?: string;
+    parentId?: string | null;
+} | undefined) => DocumentRow;
+export declare const updateDocument: (db: DbDriver, id: string, fields: {
     title?: string;
     body?: string;
     database_id?: string;
     parent_id?: string | null;
 }, opts?: {
     ifMatch?: string;
-}): DocumentRow;
+} | undefined) => DocumentRow;
 export interface EditDocResult {
     id: string;
     changed: boolean;
@@ -50,13 +63,13 @@ export interface EditDocResult {
  * cannot author it without current content, and drift surfaces as "not found".
  * `ifMatch` is an optional staleness backstop (a version from documentVersion).
  */
-export declare function editDocument(db: Database, id: string, opts: {
+export declare const editDocument: (db: DbDriver, id: string, opts: {
     old: string;
     new: string;
     replaceAll?: boolean;
     ifMatch?: string;
-}): EditDocResult;
-export declare function appendDocument(db: Database, id: string, body: string): EditDocResult;
-export declare function prependDocument(db: Database, id: string, body: string): EditDocResult;
-export declare function deleteDocument(db: Database, id: string): boolean;
+}) => EditDocResult;
+export declare const appendDocument: (db: DbDriver, id: string, body: string) => EditDocResult;
+export declare const prependDocument: (db: DbDriver, id: string, body: string) => EditDocResult;
+export declare const deleteDocument: (db: DbDriver, id: string) => boolean;
 //# sourceMappingURL=documents.d.ts.map