@quereus/sync 3.2.1 → 4.0.0

package/dist/src/sync/sync-manager-impl.d.ts

@@ -4,18 +4,29 @@
  * Coordinates CRDT metadata tracking and sync operations.
  * Delegates to focused sub-modules for snapshot, streaming, and change application.
  */
-import type { KVStore, StoreEventEmitter } from '@quereus/store';
-import type { GetTableSchemaCallback } from '../create-sync-module.js';
+import type { KVStore } from '@quereus/store';
+import type { Database, LensDeploymentSnapshot } from '@quereus/quereus';
+import type { GetTableSchemaCallback, TransactionCommitSource } from '../create-sync-module.js';
 import { HLCManager, type HLC } from '../clock/hlc.js';
 import { type SiteId } from '../clock/site.js';
 import { ColumnVersionStore } from '../metadata/column-version.js';
 import { TombstoneStore } from '../metadata/tombstones.js';
 import { SchemaMigrationStore } from '../metadata/schema-migration.js';
 import { ChangeLogStore } from '../metadata/change-log.js';
+import { QuarantineStore } from '../metadata/quarantine.js';
+import { BasisLifecycleStore, type BasisTableLifecycleRecord } from '../metadata/basis-lifecycle.js';
 import type { SyncManager, SnapshotCheckpoint } from './manager.js';
-import type { SyncConfig, ChangeSet, ApplyResult, Snapshot, SnapshotChunk, SnapshotProgress, ApplyToStoreCallback } from './protocol.js';
+import type { SyncConfig, ChangeSet, ApplyResult, Snapshot, SnapshotChunk, SnapshotProgress, ApplyToStoreCallback, DropLocalTableCallback, UnknownTableDisposition } from './protocol.js';
 import { SyncEventEmitterImpl } from './events.js';
 import type { SyncContext } from './sync-context.js';
+/**
+ * Guard a transaction's running `opSeq` against the uint32 bound. `opSeq` is
+ * serialized as a big-endian uint32 in the HLC comparison key, so a fact count
+ * exceeding {@link MAX_OPSEQ} would silently wrap and corrupt ordering — throw
+ * instead. Practically unreachable (4 billion facts in one transaction); the
+ * write side telemeters the throw via an error sync-state event.
+ */
+export declare function assertOpSeqInRange(opSeq: number): void;
 /**
  * Implementation of SyncManager.
  *
@@ -31,45 +42,268 @@ export declare class SyncManagerImpl implements SyncManager, SyncContext {
     private readonly peerStates;
     readonly changeLog: ChangeLogStore;
     readonly schemaMigrations: SchemaMigrationStore;
+    readonly quarantine: QuarantineStore;
+    readonly basisLifecycle: BasisLifecycleStore;
     readonly syncEvents: SyncEventEmitterImpl;
     readonly applyToStore?: ApplyToStoreCallback;
     private readonly getTableSchema?;
-    private pendingChanges;
-    private currentTransactionId;
+    /** Reclaim-by-name callback for the eviction sweep; absent ⇒ sweep is a no-op. */
+    private readonly dropLocalTable?;
+    private readonly lastBasisHash;
+    private unknownTableIgnored;
+    private unknownTableQuarantined;
+    private unknownTableForwarded;
+    private unknownTableRelayed;
+    private readonly unknownTableByTable;
     private constructor();
     /**
      * Create a new SyncManager, initializing or loading site identity.
      *
      * @param kv - KV store for sync metadata
-     * @param storeEvents - Store event emitter to subscribe to local changes
+     * @param transactionSource - Engine transaction-commit source for local change
+     *   capture (a `Database`, or any `onTransactionCommit` emitter). When provided,
+     *   sync subscribes to `onTransactionCommit` and records CRDT metadata for each
+     *   committed local transaction — one HLC per transaction. Pass `undefined` for a
+     *   relay-only deployment (e.g. a coordinator) that captures no local DML.
      * @param config - Sync configuration
      * @param syncEvents - Sync event emitter for UI integration
      * @param applyToStore - Optional callback for applying remote changes to the store
      * @param getTableSchema - Optional callback for getting table schema by name
+     * @param dropLocalTable - Optional reclaim-by-name callback for the basis-table
+     *   eviction sweep; when absent (e.g. a relay-only coordinator) the sweep is a no-op.
      */
-    static create(kv: KVStore, storeEvents: StoreEventEmitter, config: SyncConfig, syncEvents: SyncEventEmitterImpl, applyToStore?: ApplyToStoreCallback, getTableSchema?: GetTableSchemaCallback): Promise<SyncManagerImpl>;
+    static create(kv: KVStore, transactionSource: TransactionCommitSource | undefined, config: SyncConfig, syncEvents: SyncEventEmitterImpl, applyToStore?: ApplyToStoreCallback, getTableSchema?: GetTableSchemaCallback, dropLocalTable?: DropLocalTableCallback): Promise<SyncManagerImpl>;
     getSiteId(): SiteId;
     getCurrentHLC(): HLC;
     /**
-     * Handle a data change event from the store.
-     * Records CRDT metadata for the change.
+     * Basis-membership oracle for unknown-table detection. `getTableSchema(s,t)
+     * === undefined` ⇒ the table is outside the local basis. When no oracle was
+     * provided (e.g. a relay-only coordinator), detection is inert: every table
+     * reports in-basis and the store adapter's defensive throw governs.
+     */
+    isTableInBasis(schema: string, table: string): boolean;
+    /**
+     * Current column names for an in-basis table via the `getTableSchema` oracle, or
+     * `undefined` when the table is outside the basis (oracle returns nothing) OR no
+     * oracle was wired. Backs the drain path's basis gate + schema-drift filter (see
+     * {@link SyncContext.getTableColumnNames}). The no-oracle `undefined` makes drain
+     * a clean no-op on a relay-only coordinator, exactly as detection is inert there.
      */
-    private handleDataChange;
+    getTableColumnNames(schema: string, table: string): readonly string[] | undefined;
     /**
-     * Handle a schema change event from the store.
-     * Records schema migrations for sync.
+     * Accumulate unknown-table disposition stats (called by the apply path after a
+     * diverted group is successfully admitted).
      */
-    private handleSchemaChange;
+    recordUnknownTable(disposition: UnknownTableDisposition, schema: string, table: string, changeCount: number): void;
+    getUnknownTableStats(): {
+        ignored: number;
+        quarantined: number;
+        forwarded: number;
+        relayed: number;
+        byTable: Map<string, number>;
+    };
+    /**
+     * Record one logical schema's lens deployment over its basis, recomputing the
+     * durable per-basis-table lifecycle classification (`docs/migration.md`
+     * § 2 Converge). See {@link SyncManager.recordLensDeployment}.
+     *
+     * The snapshot is scoped to ONE logical schema, so this schema's directly-mapped
+     * contribution is stored per-schema (`mappedBy`) and the aggregate state ORs all
+     * schemas — a basis table stays `directly-mapped` until the last mapper drops it.
+     * The classification is a pure function of `(snapshot, basis schema)`, both
+     * reachable from `db`: the directly-mapped set is the union of every table
+     * snapshot's `relationBacking` keys (plus deferred surrogate-split members), and
+     * the basis membership / derivation sources come from enumerating the basis
+     * schema's tables.
+     */
+    recordLensDeployment(db: Database, logicalSchemaName: string, snapshot: LensDeploymentSnapshot): Promise<void>;
+    getBasisTableLifecycle(): Promise<BasisTableLifecycleRecord[]>;
+    /**
+     * Reclaim the local storage of every detached basis table that has been quiet
+     * past its effective retention horizon (`docs/migration.md` § 4 Contract).
+     * Host-driven (like {@link pruneTombstones} / {@link pruneQuarantine}) — the
+     * host schedules it; the library adds no timer. Returns the number of tables
+     * evicted.
+     *
+     * No-op when no `dropLocalTable` reclaim callback is wired (e.g. a relay-only
+     * coordinator with no store). For each evictable record it re-reads the record
+     * and re-checks eligibility immediately before dropping — guarding against a
+     * concurrent re-deploy that re-mapped the table between the scan and the drop —
+     * then drops the storage, emits `onBasisTableEvicted`, and clears the record. A
+     * `dropLocalTable` throw leaves the record in place to retry next sweep (the
+     * drop is idempotent).
+     */
+    evictExpiredBasisTables(now?: number): Promise<number>;
+    /**
+     * Record CRDT metadata for one committed local transaction.
+     *
+     * Driven by the engine's `onTransactionCommit` group — the authoritative
+     * "one transaction = one HLC" boundary. The clock is ticked exactly **once**;
+     * every fact of the transaction shares that base `(wallTime, counter, siteId)`
+     * and differs only in `opSeq` (a contiguous, 0-based sub-order). DDL is recorded
+     * before DML so migrations sort below the same transaction's data facts
+     * (docs/sync.md § DDL Application Order). All metadata for the transaction —
+     * schema migrations, column versions, tombstones, change-log entries, and the
+     * HLC clock state — lands in a single KV batch.
+     */
+    private handleTransactionCommit;
+    /**
+     * Record one local schema-change event as a migration. Allocates an `opSeq`
+     * (via `nextHlc`) only when the event maps to a tracked migration, so
+     * unsupported object types consume no sub-order. `versionCounters` carries the
+     * running per-table schema version across this transaction's migrations.
+     */
+    private recordSchemaMigration;
+    /**
+     * Record one local data-change event: a tombstone (delete) or the changed
+     * column versions (insert/update). Each recorded fact consumes one `opSeq`.
+     */
+    private recordDataEvent;
     private recordColumnVersions;
+    /**
+     * Extract changes for a peer as **one {@link ChangeSet} per source
+     * transaction** (grouped by HLC identity `(wallTime, counter, siteId)`),
+     * bounded at transaction granularity by `config.batchSize`. A transaction is
+     * never split across ChangeSets and two transactions are never merged, so a
+     * consumer that advances `lastSyncHLC = ChangeSet.hlc` always lands on a real
+     * commit boundary (docs/sync.md § Transaction-Based Change Grouping → Read side).
+     */
     getChangesSince(peerSiteId: SiteId, sinceHLC?: HLC): Promise<ChangeSet[]>;
+    /**
+     * Delta extraction: facts after `sinceHLC`, in change-log (HLC) order, bounded
+     * at **scan time** to whole transactions whose cumulative data-change count
+     * reaches `batchSize`.
+     *
+     * The change-log scan is keyed by `(wallTime, counter, siteId, opSeq)`, so a
+     * transaction's facts arrive contiguously and transactions arrive in commit
+     * order. That lets us stop scanning as soon as enough WHOLE transactions have
+     * accumulated, instead of draining the entire iterator into memory and letting
+     * {@link buildTransactionChangeSets} truncate afterward (the pre-
+     * `sync-getchangessince-bounded-extraction` behavior, where `batchSize` capped
+     * the response but not the scan). The bound here mirrors that grouping step
+     * exactly — whole transactions accumulate until the cumulative data-change count
+     * reaches `batchSize`, never splitting a transaction — so the grouped response
+     * is byte-identical; only the scan footprint shrinks.
+     *
+     * LOAD-BEARING INVARIANT: boundary detection keys off `logEntry.hlc`, but the
+     * grouper keys off the *resolved* version's HLC ({@link resolveLogEntry} returns
+     * `cv.hlc` / `tombstone.hlc`). These agree only when each non-null-resolving log
+     * entry's HLC equals its resolved version's HLC, which holds for BOTH entry types
+     * because each is deduped on overwrite — at most one entry survives per key, and
+     * its HLC equals the current version's:
+     *   - COLUMN: an overwrite deletes the prior `(pk, column)` entry (see
+     *     {@link recordColumnVersions} and `commitChangeMetadata`), so the survivor's
+     *     HLC is the current `cv.hlc`.
+     *   - DELETE: a newer tombstone deletes the prior `pk` delete entry (see
+     *     {@link recordDataEvent} and `commitChangeMetadata`), so a
+     *     delete→reinsert→delete key reuse no longer leaves a stale entry that
+     *     re-attributes to a later tombstone HLC; the survivor's HLC is the current
+     *     `tombstone.hlc`.
+     *
+     * The overwrite dedup above covers entries written across SEPARATE writes/applies
+     * (each later one sees the prior committed version). The apply path additionally
+     * collapses in-batch repeats: two versions of one key inside a single
+     * `applyChanges` call resolve against the SAME pre-batch prior version, so neither
+     * sees the other — `commitChangeMetadata` keeps only the max-HLC winner per key and
+     * writes a single entry, preserving the invariant regardless of how many versions
+     * of a key were batched.
+     *
+     * (Schema migrations are still fully scanned by {@link collectSchemaMigrations};
+     * the `sm:` range is not HLC-ordered, but migrations are few and the grouping
+     * step drops any that sort past the bounded fact watermark.)
+     */
+    private collectChangesSince;
+    /**
+     * Resolve a change-log entry to the live {@link Change} it references, or
+     * `null` when the underlying column version / tombstone is gone — a stale log
+     * entry (e.g. a column overwritten, or a row deleted after the entry was
+     * written). The authoritative HLC and value come from the current version, not
+     * the log key.
+     */
+    private resolveLogEntry;
+    /**
+     * Full extraction (initial sync / delta-from-zero): every column version and
+     * tombstone not originating from the peer. Ordering is owned by
+     * {@link buildTransactionChangeSets}, so no pre-sort is needed here.
+     *
+     * Unlike {@link collectChangesSince}, this path cannot early-exit at scan time:
+     * the `cv:`/`tb:` scans are keyed by table/pk, NOT by HLC, so transactions are
+     * interleaved arbitrarily and no transaction boundary is reachable without a
+     * full scan + sort. It is left unbounded because it is the from-zero path: a
+     * large initial range is expected to be served by a snapshot rather than this
+     * delta path (docs/sync.md).
+     */
     private collectAllChanges;
+    /**
+     * Collect forwardable held changes to re-offer to a peer — the outbound half of
+     * the `store-and-forward` unknown-table disposition. Source is
+     * {@link QuarantineStore.listForwardable}: straggler changes this peer held
+     * because it has retired the table, marked forwardable. Each is re-offered with
+     * its ORIGINAL `hlc` + `siteId` (the straggler's fact, not a new local one) — the
+     * identity that makes the relay loop-free and convergent across hops with NO
+     * per-table peer-membership oracle (none exists): a peer that already holds the
+     * change re-holds it idempotently (HLC-keyed) and the per-peer watermark stops
+     * re-send after one exchange.
+     *
+     * Two filters, mirroring {@link collectChangesSince} / {@link collectAllChanges}:
+     *  - **Echo exclusion** — drop a change whose origin (`change.hlc.siteId`) is the
+     *    peer itself, so a straggler's fact is never echoed back to its own author.
+     *  - **Watermark filter** — when `sinceHLC` is defined (delta path), keep only
+     *    `compareHLC(change.hlc, sinceHLC) > 0`. REQUIRED: the consumer advances its
+     *    per-peer `lastSyncHLC` to `max(returned ChangeSet.hlc)`, so a round that
+     *    returned a forwarded change with HLC ≤ the watermark would REGRESS it and
+     *    trigger a re-scan/re-deliver flood. Filtering `> sinceHLC` keeps the merged
+     *    response a safe contiguous prefix — exactly the change-log contract. When
+     *    `sinceHLC` is undefined (from-zero / {@link collectAllChanges} path) there is
+     *    no lower bound, so all (origin ≠ peer) are kept.
+     *
+     * Accepted limitation (documented intent, not a defect): a straggler whose change
+     * is causally older than the holder's sync recency with a peer (`HLC ≤ sinceHLC`)
+     * is NOT relayed via this delta path — the same scalar-watermark limitation the
+     * base delta layer already has. store-and-forward targets the transitional
+     * uneven-retirement window, where the straggler's writes are recent enough to
+     * exceed holder watermarks; quarantine already prevents write loss outside it.
+     *
+     * Snapshot carve-out: forwardable entries are DELTA-ONLY. The snapshot collectors
+     * scan only `cv:`/`tb:`/`sm:` (never `qt:`), since a snapshot transfers the
+     * offering peer's OWN basis and a forwarded change is for a table that peer does
+     * not have.
+     *
+     * Full horizon-bounded scan (no early-exit), paralleling {@link collectAllChanges}:
+     * the forwardable set is bounded by the retention horizon and is EMPTY — so this
+     * is zero-cost — in the no-straggler case.
+     */
+    private collectForwardableChanges;
+    /**
+     * Collect schema migrations after `sinceHLC` not originating from the peer.
+     * Each migration shares its transaction's base HLC, so the grouping step
+     * rejoins it with that transaction's data facts (or forms a DDL-only ChangeSet).
+     *
+     * The `sm:` range is keyed by `{schema}.{table}:{version}`, not by HLC, so this
+     * scan cannot early-exit the way {@link collectChangesSince} does — it is drained
+     * in full even when the fact side stops early. That is acceptable because
+     * migrations are few, and {@link buildTransactionChangeSets} drops any migration
+     * that sorts past the bounded fact watermark (its DDL-only group falls beyond the
+     * `batchSize` cut), so over-scanning here costs work but never correctness. A
+     * peer with a pathological volume of un-synced DDL is the one case this leaves
+     * unbounded; see the bounded-extraction ticket's handoff.
+     */
+    private collectSchemaMigrations;
     applyChanges(changes: ChangeSet[]): Promise<ApplyResult>;
+    drainHeldChanges(schema?: string, table?: string): Promise<number>;
     canDeltaSync(peerSiteId: SiteId, sinceHLC: HLC): Promise<boolean>;
     getSnapshot(): Promise<Snapshot>;
     applySnapshot(snapshot: Snapshot): Promise<void>;
     updatePeerSyncState(peerSiteId: SiteId, hlc: HLC): Promise<void>;
     getPeerSyncState(peerSiteId: SiteId): Promise<HLC | undefined>;
     pruneTombstones(): Promise<number>;
+    /**
+     * GC quarantined out-of-basis straggler changes past the retention horizon —
+     * the quarantine sibling of {@link pruneTombstones}, keyed off the same
+     * `retentionHorizonMs`. A held change older than the horizon was already
+     * outside the delivery guarantee.
+     */
+    pruneQuarantine(): Promise<number>;
     getEventEmitter(): SyncEventEmitterImpl;
     getSnapshotStream(chunkSize?: number): AsyncIterable<SnapshotChunk>;
     applySnapshotStream(chunks: AsyncIterable<SnapshotChunk>, onProgress?: (progress: SnapshotProgress) => void): Promise<void>;

package/dist/src/sync/sync-manager-impl.d.ts.map

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