@mason-data/cli 0.6.2 → 0.8.0

package/dist/src/duck/sync.js

@@ -11,6 +11,8 @@ import { createSlot, currentLsn, dropSlot, readSlot } from "../cdc/source.js";
 import { addCounts, countsText, duckValue, foldInto, noChanges, noCounts, ReplicationStream } from "./stream.js";
 import { didYouMean } from "../lib/did-you-mean.js";
 import { namedPublicationVerdict, readNamedPublication } from "./publication.js";
+import { extensionFailure, loadPostgresSql } from "./extensions.js";
+import { BIG_TABLE_ROWS, intervalOf, syncedText, syncText, syncWords } from "../lib/table-sync.js";
 export function syncModeOf(env) {
     const v = env.MASON_DUCK_SYNC || "poll";
     if (v !== "poll" && v !== "recopy")
@@ -18,17 +20,22 @@ export function syncModeOf(env) {
     return v;
 }
 /**
- * THE POLL'S ROW LIMIT: in poll mode a table the source estimates at more than this many rows
- * (`AddedTable.rows`, the catalog's estimate; unknown counts as small) is copied and served, but the passes do not poll
- * it. A poll scans its table whole (no index covers xmin) and counts it, and when the counts differ reads every key over
- * the wire: on a test server a 22 M-row table cost the production replica 12 s of scan and 2 s of count at every poll.
- * `mason sync <table>` polls one now (`Sync.pollNow`); `mason start --replication` keeps every table current, whatever
- * its size.
+ * WHEN A POLLED TABLE IS POLLED NEXT: its interval after its last poll ended, stretched to four times that poll's own
+ * time (`nextPollDelayMs`) — so one table's polls never take more than a fifth of the source's time, whatever its
+ * `sync: poll <interval>` says (a 20 s poll of a table set to `poll 5s` waits 80 s).
  */
-export const POLL_ROW_LIMIT = 1_000_000;
-/** why the passes do not keep a table over the limit current (`CopyState.unsynced`) */
-export const OVER_POLL_LIMIT = `over the ${POLL_ROW_LIMIT.toLocaleString("en-US")}-row sync limit`;
-const overPollLimit = (t) => t.rows !== null && t.rows > POLL_ROW_LIMIT;
+export function nextPollAt(endedMs, intervalSeconds, pollMs) {
+    return endedMs + nextPollDelayMs(intervalSeconds * 1000, pollMs);
+}
+/**
+ * HOW LONG THE NEXT PASS WAITS: until the first polled table is due — and at least four times what the last pass took
+ * (its polls, one after another on the writer), so ALL the tables' polls together never take more than a fifth of the
+ * source's time, however many are due at once. Bounded by setTimeout's 2^31 - 1 ms: a later poll is waited for in
+ * steps, a pass that finds nothing due polling nothing.
+ */
+export function passDelayMs(earliestDueMs, nowMs, lastPassMs) {
+    return Math.min(2 ** 31 - 1, Math.max(0, earliestDueMs - nowMs, 4 * lastPassMs));
+}
 /** a poll asked for that cannot run (`Sync.pollNow`), its reason in the asker's words: `code` is the CLI's failure code */
 export class PollRefused extends Error {
     code;
@@ -38,6 +45,19 @@ export class PollRefused extends Error {
 export class Stopping extends Error {
     constructor() { super("Mason is stopping"); }
 }
+/** How often the slot's WAL is read at most (`streamStatus`): a catalog view's row, on the connection the database's
+ *  position is read on, so never a connection of its own — and never per poll or per batch. */
+export const SLOT_READ_MS = 30_000;
+/** The slot as `readSlot` read it, as `SlotWal` says it. */
+export function slotWalOf(s, name, at) {
+    if (!s.exists)
+        return { error: `replication slot ${name} does not exist on the database (the next pass makes it again)` };
+    const status = s.walStatus === "reserved" || s.walStatus === "extended" || s.walStatus === "unreserved" || s.walStatus === "lost" ? s.walStatus : null;
+    // a lost slot's WAL was freed by Postgres (its restart_lsn is null): it holds none; any other null is not known
+    if (s.retainedBytes === null && status !== "lost")
+        return { error: `replication slot ${name} has no restart position yet: the WAL it holds is not known` };
+    return { walHeldBytes: s.retainedBytes === null ? 0 : Number(s.retainedBytes), walStatus: status, safeWalSizeBytes: s.safeBytes === null ? null : Number(s.safeBytes), at: new Date(at).toISOString() };
+}
 export const ident = (name) => `"${name.replaceAll('"', '""')}"`;
 export const literal = (s) => `'${s.replaceAll("'", "''")}'`;
 export const SRC = "_mason_source";
@@ -90,7 +110,7 @@ export async function writeStaged(w, t, target, stage, where, kept) {
  * never converted in place, but copied again through the normal path (`needsCopy`), serving as it was meanwhile. Found
  * by its constraint (`duckdb_constraints()`), which every copy of that layout carries and no copy of this one does.
  */
-export const RETIRED_LAYOUT = "stored in key order with an index, by an older Mason: copied again in heap order";
+export const RETIRED_LAYOUT = "stored in key order with an index, by an older Mason: read again whole, in heap order";
 /**
  * How long a failed copy waits before it is tried again: four times the attempt, at least 5 minutes, doubled for each
  * failure in a row, at most 6 hours (a copy whose sort failed for good read a production replica whole for
@@ -115,16 +135,16 @@ export function copyOrder(tables) {
  * of a copy that is not coming (the test server: every start said `added <all four tables>: they are copied at the
  * next pass` while all four were copied and streamed from the acknowledged position — read as a long re-copy that never
  * came). ONE line: the tables grouped by state, each group `<n> table(s) <state>: <tables>`, the current ones first,
- * those copied at the next pass last, each with its reason. `kept` is how a current copy is kept so (`keptWords`).
+ * those copied at the next pass last, each with its reason, a current copy with how it is kept so (`keptWords`).
  */
-export function addedText(tables, kept) {
+export function addedText(tables) {
     const groups = new Map();
     for (const t of tables) {
-        const [rank, state] = "copy" in t ? [3, `copied at the next pass (${t.copy})`]
-            : "behind" in t ? [2, `already copied, caught up by one poll first (${t.behind})`]
-                : "refused" in t ? [4, `not copied or streamed (${t.refused})`]
-                    : t.unsynced ? [1, `already copied, NOT kept current (${OVER_POLL_LIMIT}: mason sync polls one now, mason start --replication keeps it current)`]
-                        : [0, `already copied and ${kept}`];
+        const [rank, state] = "copy" in t ? [3, `synced at the next pass (${t.copy})`]
+            : "behind" in t ? [2, `already synced, caught up by one poll first (${t.behind})`]
+                : "refused" in t ? [4, `not synced or streamed (${t.refused})`]
+                    : t.off ? [1, `already synced, ${t.kept}`]
+                        : [0, `already synced and ${t.kept}`];
         const g = groups.get(state) ?? { rank, sources: [] };
         g.sources.push(t.source);
         groups.set(state, g);
@@ -163,8 +183,8 @@ export function copyChunkSecondsOf(env) {
         return COPY_CHUNK_SECONDS;
     const n = Number(v);
     if (!/^\d+(\.\d+)?$/.test(v.trim()) || n < COPY_CHUNK_SECONDS_MIN || n > COPY_CHUNK_SECONDS_MAX) {
-        throw new Error(`MASON_COPY_CHUNK_SECONDS=${JSON.stringify(v)} is not a number of seconds from ${COPY_CHUNK_SECONDS_MIN} to ${COPY_CHUNK_SECONDS_MAX}: each of a copy's chunks is sized to take ` +
-            `about that long to read, and a stop reads at most that much again, so set it lower for a copy that moves more often or higher for fewer, larger chunks, or unset it for ${COPY_CHUNK_SECONDS}`);
+        throw new Error(`MASON_COPY_CHUNK_SECONDS=${JSON.stringify(v)} is not a number of seconds from ${COPY_CHUNK_SECONDS_MIN} to ${COPY_CHUNK_SECONDS_MAX}: each of a first sync's chunks is sized to take ` +
+            `about that long to read, and a stop reads at most that much again, so set it lower for a first sync that moves more often or higher for fewer, larger chunks, or unset it for ${COPY_CHUNK_SECONDS}`);
     }
     return n;
 }
@@ -345,7 +365,7 @@ export function copyParallelOf(env) {
         return COPY_PARALLEL;
     const n = Number(v);
     if (!/^\d+$/.test(v.trim()) || n < 1 || n > COPY_PARALLEL_MAX) {
-        throw new Error(`MASON_COPY_PARALLEL=${JSON.stringify(v)} is not a number of readers from 1 to ${COPY_PARALLEL_MAX}: each reads a copy's chunks on a backend of the database's own, ` +
+        throw new Error(`MASON_COPY_PARALLEL=${JSON.stringify(v)} is not a number of readers from 1 to ${COPY_PARALLEL_MAX}: each reads a first sync's chunks on a backend of the database's own, ` +
             `so set it to 1 (one at a time, the lightest on the database) up to ${COPY_PARALLEL_MAX}, or unset it for ${COPY_PARALLEL}`);
     }
     return n;
@@ -384,7 +404,7 @@ const pq = (sql) => `postgres_query(${literal(SRC)}, ${literal(sql)})`;
  * differ (`1` beside `1.50`); the copy answers them all with s decimals, also said.
  */
 const NUMERIC_TYPE = /^numeric(?:\((\d+)(?:,\s*(\d+))?\))?$/;
-const WIDER = "mason: a numeric value wider than its copy";
+const WIDER = "mason: a numeric value wider than its synced column";
 /** a source numeric the extension reads as a DOUBLE: no precision, or more than DuckDB's 38 digits */
 function readsAsDouble(type) {
     const m = NUMERIC_TYPE.exec(type);
@@ -429,8 +449,20 @@ export class Sync {
     mode;
     /** each polled table's watermark: the snapshot of the last poll that stored it */
     snapshots = new Map();
-    /** how long the last pass took: the next waits four times that, at least the interval */
+    /** how long the last pass took: the next waits at least four times that (its polls' share of the source's time) */
     lastPassMs = 0;
+    /** each polled table's next poll (ms since the epoch: its last poll's end plus its interval, stretched to four times
+     *  that poll — `nextPollDelayMs`); absent: from its last poll's time in the ledger (`dueAt`). One pass polls the
+     *  tables due and the timer waits for the next one due (`nextPassDelay`), never a timer per table: a pass also
+     *  queues the copies and drops removed tables, and attaches the source once for all of it — timers of their own would
+     *  each attach it, and race those for the writer's turn */
+    due = new Map();
+    /** each table's sync as its last poll or copy recorded it (`_mason.poll_state.sync`; null: recorded before syncs were) */
+    recordedSync = new Map();
+    /** the tables whose sync changed since they were last polled (`setTables`): kept, and caught up by ONE poll now */
+    switched = new Set();
+    /** how long each table's last poll took, this run (ms): its next waits four times that, and mason add estimates by it */
+    lastPollMs = new Map();
     /** each table whose copy failed: the failures in a row, and when it is tried again (`copyRetryDelayMs`) */
     retries = new Map();
     /** each copied table in a layout this Mason no longer keeps (`RETIRED_LAYOUT`), found at `open`: copied again */
@@ -455,10 +487,17 @@ export class Sync {
     attached = false;
     loaded = false;
     stopped = false;
-    /** REPLICATION MODE: the publication and slot it reads (`owned`: the publication is Mason's own, made and kept equal
-     *  to the added tables; else the operator named it, and it is only read — src/duck/publication.ts), the stream while it
-     *  runs, the last commit DuckDB applied */
+    /** REPLICATION: the publication and slot the `replication` tables are read through (`owned`: the publication is
+     *  Mason's own, made and kept equal to the replicated tables; else the operator named it, and it is only read —
+     *  src/duck/publication.ts), null in a run that cannot stream (the demo's); the stream while it runs, the last commit
+     *  DuckDB applied */
     replication;
+    /** told when the slot is made (true) and when it is dropped, verified gone (false): the run records it, so `mason
+     *  destroy` drops what was made by its own name (src/cli/dev.ts) */
+    onReplication;
+    /** the last moment the stream had everything the database wrote (a keepalive with nothing pending, a batch applied):
+     *  a streamed table's copy is current as of then (`keptOf`'s syncedAt) */
+    streamCurrentAt = null;
     stream = null;
     appliedLsn = 0n;
     /** the slot has a row in `_mason.stream_state`: what this copy applied of it is known */
@@ -472,8 +511,13 @@ export class Sync {
     held = new Map();
     /** REPLICATION: what the stream applies, by source — the tables joined, and those held — read at each change */
     streamed = new Map();
+    /** the last `StreamedTable.stay` given (`refreshStreamed`) */
+    lastStay = 0;
     /** a NAMED publication's gaps: each added table it does not carry, with the refusal (neither copied nor streamed) */
     unpublished = new Map();
+    /** the error each table a named publication did not carry was given (`settlePrepared`): cleared by the pass that finds
+     *  it carried again, and by nothing else that pass */
+    gapErrors = new Map();
     /** a named publication that does not publish TRUNCATE has been said (once a run) */
     truncateSaid = false;
     /** the last pass failed: in replication mode it is tried again after the interval, the stream started by it */
@@ -486,12 +530,16 @@ export class Sync {
      *  (a pass kicked sooner leaves it stopped) */
     streamFailures = 0;
     streamAt = 0;
-    /** when each streamed table's rows were last counted for the ledger */
-    countedAt = new Map();
-    /** when each table was last copied or polled (`_mason.poll_state.polled_at`), as an unsynced table's state says it */
+    /** when each copy was last brought current, and how (`Synced`): seeded at `open` from the ledger, moved by every
+     *  swap, poll commit and stream batch */
+    synced = new Map();
+    /** where the sync's failures and notable events go (src/duck/events.ts `SyncEvents.record`): never the writer's turn */
+    onEvent;
+    /** when each table was last copied or polled, its `syncedAt`: `_mason.poll_state.polled_at` and nothing else — the
+     *  value `pollStateSql` wrote is the one set here once its transaction commits, and `readPolledAt` only moves a time
+     *  forward, so nothing moves it back (a time read at the commit stood until that read replaced it: a `syncedAt` that
+     *  went backwards). A copy's is its watermark's, taken before the swap; `copied_at`, after it, is `Synced.at`'s */
     polledAt = new Map();
-    /** the tables over the poll's row limit already said in the log (said once, when first left out) */
-    leftOut = new Set();
     /** the store's writer: the stream's batches, the polls, the source's attachment and every swap, one turn at a time */
     writerLane;
     /** the rebuilds' own connection (`open`): a copy or a catch-up, beside the writer's work */
@@ -505,7 +553,6 @@ export class Sync {
     /** the source attached for this many users (a pass, a rebuild): DETACHed when the last ends (`detach`) */
     sourceUsers = 0;
     currentSchema;
-    database;
     /** what the catalog last built from: replaced (a new object) only when it changes */
     schemaKey = "";
     /** REPLICATION, WHERE THE STREAM IS (`streamStatus`, the stream's log): the changes it applied this run by table, and
@@ -540,15 +587,21 @@ export class Sync {
     catchingUp = null;
     /** the stream's last failure and when it starts again; cleared when it starts */
     streamFailure = null;
+    /** A WHOLE-SYNC FAILURE NOT YET OVER, as its event said it (`table: null`): the stream stopped, over when it next applies
+     *  a batch; the publication and slot could not be made ready, over when a pass makes them so; the database's attach,
+     *  over when an attach succeeds. Its end is a `recovered` event of no table, which lets the next such failure be said again
+     *  (src/duck/events.ts: a failure said word for word within an hour is one event unless it recovered between) */
+    wholeFailure = { stream: null, prepare: null, attach: null };
     /** the database's position as last read (`databasePosition`), and the read in flight */
     dbPosition = null;
+    /** the slot's WAL as last read (`databasePosition`, at most every SLOT_READ_MS), and when */
+    slotWal = null;
     dbPositionRead = null;
     /** THE STORED JSON PATHS (src/duck/kept.ts): every write below computes them; the plans read them */
     kept;
     constructor(store, source, database, log, intervalMs, mode = "poll", replication = null, options = {}) {
         this.store = store;
         this.source = source;
-        this.database = database;
         this.log = log;
         this.intervalMs = intervalMs;
         this.mode = mode;
@@ -556,16 +609,18 @@ export class Sync {
         this.copyChunkRows = options.copyChunkRows ?? COPY_CHUNK_ROWS;
         this.copyParallel = options.copyParallel ?? COPY_PARALLEL;
         if (!Number.isInteger(this.copyParallel) || this.copyParallel < 1 || this.copyParallel > COPY_PARALLEL_MAX) {
-            throw new Error(`a copy reads with 1 to ${COPY_PARALLEL_MAX} readers, not ${this.copyParallel} (Mason bug: report it; copyParallelOf reads MASON_COPY_PARALLEL)`);
+            throw new Error(`a first sync reads with 1 to ${COPY_PARALLEL_MAX} readers, not ${this.copyParallel} (Mason bug: report it; copyParallelOf reads MASON_COPY_PARALLEL)`);
         }
         this.copyChunkSeconds = options.copyChunkSeconds ?? COPY_CHUNK_SECONDS;
         if (!(this.copyChunkSeconds > 0))
-            throw new Error(`a copy's chunk takes a positive number of seconds, not ${this.copyChunkSeconds} (Mason bug: report it; copyChunkSecondsOf reads MASON_COPY_CHUNK_SECONDS)`);
+            throw new Error(`a first sync's chunk takes a positive number of seconds, not ${this.copyChunkSeconds} (Mason bug: report it; copyChunkSecondsOf reads MASON_COPY_CHUNK_SECONDS)`);
         this.onChunk = options.onChunk;
+        this.onEvent = options.onEvent ?? (() => undefined);
         this.diskFree = options.diskFree ?? ((dir) => { const st = fs.statfsSync(dir); return st.bavail * st.bsize; });
         if (mode === "replication" && replication === null)
             throw new Error("replication mode needs its slot and publication (Mason bug: report it)");
         this.replication = replication;
+        this.onReplication = options.onReplication;
         this.currentSchema = { database, tables: [] };
         this.writerLane = { conn: store.writer, inFlight: false };
         this.kept = new KeptJsonPaths(store, {
@@ -583,6 +638,24 @@ export class Sync {
             throw new Error("the sync's rebuild connection is not open (Mason bug: report it)");
         return this.rebuilderLane;
     }
+    /** an event of the sync, to its record (src/duck/events.ts), which never throws into the sync; a sink that does is
+     *  said, and the sync goes on (its state and its log line hold what happened) */
+    event(e) {
+        try {
+            this.onEvent(e);
+        }
+        catch (x) {
+            this.log(`the sync's event (${e.kind}${e.table ? ` ${e.table}` : ""}) could not be recorded: ${x instanceof Error ? x.message : String(x)}`);
+        }
+    }
+    /** a whole-sync failure (`wholeFailure`) is over: said once, as a `recovered` event of no table */
+    recovered(what, words) {
+        const was = this.wholeFailure[what];
+        if (was === null)
+            return;
+        this.wholeFailure[what] = null;
+        this.event({ kind: "recovered", table: null, message: `${words} (it had failed: ${was.split("\n")[0]})` });
+    }
     /** `f` on the writer's next turn: once every job queued before it has ended, so no other job's statement lands inside
      *  its transaction. A job never queues another and waits for it (it would wait for itself) */
     onWriter(f) {
@@ -597,7 +670,9 @@ export class Sync {
         // the re-sort's count of rows written out of key order (in the earlier layout): gone with the key order
         for (const gone of ["written", "counted"])
             await this.store.writer.run(`ALTER TABLE ${MASON_SCHEMA}.copy_state DROP COLUMN IF EXISTS ${gone}`);
-        await this.store.writer.run(`CREATE TABLE IF NOT EXISTS ${MASON_SCHEMA}.poll_state (source VARCHAR PRIMARY KEY, snapshot VARCHAR, polled_at TIMESTAMPTZ)`);
+        await this.store.writer.run(`CREATE TABLE IF NOT EXISTS ${MASON_SCHEMA}.poll_state (source VARCHAR PRIMARY KEY, snapshot VARCHAR, polled_at TIMESTAMPTZ, sync VARCHAR)`);
+        // the sync each table was last polled or copied under (src/lib/table-sync.ts syncText): a change is caught up by one poll
+        await this.store.writer.run(`ALTER TABLE ${MASON_SCHEMA}.poll_state ADD COLUMN IF NOT EXISTS sync VARCHAR`);
         // replication mode's record: per slot, the end of the last commit applied, in the same transaction as its rows
         await this.store.writer.run(`CREATE TABLE IF NOT EXISTS ${MASON_SCHEMA}.stream_state (slot VARCHAR PRIMARY KEY, lsn VARCHAR, applied_at TIMESTAMPTZ)`);
         // the tables copied (or under a new slot) and not yet caught up by their one poll (`behind`), written
@@ -619,13 +694,16 @@ export class Sync {
             this.slotKnown = r.length > 0;
             this.appliedLsn = r.length > 0 ? parseLsn(String(r[0][0])) : 0n;
         }
-        for (const [source, snapshot] of (await this.store.writer.runAndReadAll(`SELECT source, snapshot FROM ${MASON_SCHEMA}.poll_state`)).getRowsJS()) {
+        for (const [source, snapshot, sync] of (await this.store.writer.runAndReadAll(`SELECT source, snapshot, sync FROM ${MASON_SCHEMA}.poll_state`)).getRowsJS()) {
             this.snapshots.set(source, snapshot);
+            this.recordedSync.set(source, sync);
         }
         await this.readPolledAt();
-        const r = await this.store.writer.runAndReadAll(`SELECT source, phase, "rows", bytes, seconds, copied_at::VARCHAR, error, columns::VARCHAR FROM ${MASON_SCHEMA}.copy_state`);
+        const r = await this.store.writer.runAndReadAll(`SELECT source, phase, "rows", bytes, seconds, epoch_ms(copied_at), error, columns::VARCHAR FROM ${MASON_SCHEMA}.copy_state`);
         for (const row of r.getRowsJS()) {
-            const [source, phase, rows, bytes, seconds, copiedAt, error, columns] = row;
+            const [source, phase, rows, bytes, seconds, copiedMs, error, columns] = row;
+            // an instant as a run writes it (ISO, UTC), never DuckDB's text of it in the connection's zone
+            const copiedAt = copiedMs === null ? null : new Date(Number(copiedMs)).toISOString();
             if (columns !== null) {
                 const c = JSON.parse(columns);
                 this.copiedAs.set(source, columnsKey(c));
@@ -633,6 +711,7 @@ export class Sync {
             }
             this.states.set(source, { source, phase: phase === "copying" ? "waiting" : phase, rows: rows === null ? null : Number(rows), bytes: bytes === null ? null : Number(bytes), seconds, copiedAt, error });
         }
+        await this.readSynced();
         await this.findRetired();
         this.removeStageLeftovers();
         // the stored JSON paths, before the catalog serves anything: each served copy's view, what the file holds
@@ -644,6 +723,8 @@ export class Sync {
      *  here and current (said as its records say it, `addedText`), a removed one dropped.
      *  What it returns is the catalog rebuilt over them (never rejected: a failure is said in the log) */
     setTables(tables) {
+        // (called at mason start and at mason add / remove only: the catalog's keys and constraints are the source's as of
+        // then — docs/DESIGN.md "A count of distinct keys")
         const before = this.tables;
         this.tables = new Map(tables.map((t) => [t.source, t]));
         // said as it happens: what is added, each table as its records say it is (`addedText`), and what is no longer
@@ -651,11 +732,51 @@ export class Sync {
         const added = tables.filter((t) => !before.has(t.source));
         const removed = [...before.keys()].filter((s) => !this.tables.has(s));
         if (added.length)
-            this.log(addedText(added.map((t) => this.addedStatus(t)), this.keptWords()));
+            this.log(addedText(added.map((t) => this.addedStatus(t))));
+        // A TABLE WHOSE SYNC CHANGED — by mason add --sync now, or by hand since its last poll (the ledger's record) — keeps
+        // its copy and is caught up by ONE poll now, whatever it changed to, then kept as it says: never copied again
+        for (const t of tables) {
+            const now = syncText(this.syncOf(t)), prev = before.get(t.source);
+            const was = prev !== undefined ? syncText(this.syncOf(prev)) : this.recordedSync.get(t.source) ?? null;
+            if (was === null || was === now)
+                continue;
+            this.due.delete(t.source);
+            // recopy copies every table again whatever its sync, and a table whose columns changed too is copied again with
+            // them, its new sync recorded at that copy's swap
+            const copied = this.states.get(t.source)?.phase === "copied" && this.snapshots.has(t.source) && this.copiedAs.get(t.source) === columnsKey(t.columns);
+            if (this.mode === "recopy" || !copied)
+                continue;
+            if (this.replicated(t)) {
+                // INTO THE STREAM (poll or off → replication): caught up by ONE poll with the stream's changes of it held from
+                // just before that poll (`catchUp`), as a slot new to the copy is — once the pass has the publication carry it
+                // (`prepareReplication` runs before the pass queues the catch-up). Marked in `_mason.catch_up`, on the writer's
+                // turn and so before the catch-up starts: the stream acknowledges what it holds, so a run that dies between
+                // the catch-up's poll and the held changes' apply must catch it up again (its recorded sync is already the new)
+                this.switched.delete(t.source);
+                const why = `after its sync changed from ${was}`;
+                if (!this.behind.has(t.source)) {
+                    const mark = { why };
+                    this.behind.set(t.source, mark);
+                    void this.onWriter(() => this.store.writer.run(`INSERT OR REPLACE INTO ${MASON_SCHEMA}.catch_up VALUES (${literal(t.source)}, ${literal(why)}, now())`)).catch((e) => {
+                        // its next start catches it up again only by this row: said, and the mark kept for this run's own catch-up
+                        this.log(`${t.source}: its catch-up could not be recorded (a stop before it ends catches it up again only if its sync changes): ${e instanceof Error ? e.message : String(e)}`);
+                    });
+                }
+            }
+            else {
+                // OUT OF THE STREAM, or between off and poll: it leaves the stream at its next batch (`refreshStreamed`) and the
+                // next pass polls it from its watermark, which every change since is at or past
+                this.switched.add(t.source);
+            }
+            // said, and recorded as the sync's event (src/duck/events.ts): what a table's sync was is history the log alone loses
+            const switched = `sync: ${was} → ${now}: its synced data is kept, and caught up by one poll now${this.replicated(t) ? ", then streamed" : ""}`;
+            this.log(`${t.source}: ${switched}`);
+            this.event({ kind: "sync_changed", table: t.source, message: switched });
+        }
         // loud: the copy goes with the table's entry, and comes back only by reading the source again (the test server: a 53 GB
         // copy, 21 minutes of a production replica, dropped by a project file moved aside)
         if (removed.length)
-            this.log(`removed ${removed.join(", ")}: no longer added, so ${removed.length === 1 ? "its copy is" : "their copies are"} DROPPED at the next pass — mason add copies ${removed.length === 1 ? "it" : "them"} again from the source, whole`);
+            this.log(`removed ${removed.join(", ")}: no longer added, so ${removed.length === 1 ? "its synced data is" : "their synced data is"} DROPPED at the next pass — mason add syncs ${removed.length === 1 ? "it" : "them"} again from the source, whole`);
         for (const t of tables)
             if (!this.states.has(t.source))
                 this.states.set(t.source, { source: t.source, phase: "waiting", rows: null, bytes: t.bytes, seconds: null, copiedAt: null, error: null });
@@ -680,27 +801,107 @@ export class Sync {
         // a named publication's gap is said again by the pass, which refuses the table by name until its owner adds it
         if (st?.error?.startsWith("replication: "))
             return { source: t.source, refused: firstLine(st.error.slice("replication: ".length)) };
-        const copy = st === undefined ? "never copied"
-            : st.phase === "failed" ? `its last copy failed: ${firstLine(st.error)}`
-                : st.phase !== "copied" ? "its copy has not finished"
-                    : this.retired.has(t.source) ? "its copy is in an older Mason's layout, key order with an index"
-                        : this.copiedAs.get(t.source) !== columnsKey(t.columns) ? "its columns changed"
-                            : !this.snapshots.has(t.source) ? "a numeric value outgrew its copy's DECIMAL"
-                                : null;
+        const copy = st === undefined ? "never synced"
+            : st.phase === "failed" ? `its first sync failed: ${firstLine(st.error)}`
+                : st.phase !== "copied" ? "its first sync has not finished"
+                    : this.retired.has(t.source) ? "it is in an older Mason's layout, key order with an index"
+                        : this.readAgainWhy(t);
         if (copy !== null)
             return { source: t.source, copy };
         const b = this.behind.get(t.source);
         if (b !== undefined)
             return { source: t.source, behind: b.why };
-        if (this.replication !== null && !this.slotKnown)
-            return { source: t.source, behind: `slot ${this.replication.slot} is new to this copy` };
-        return { source: t.source, unsynced: this.mode === "poll" && overPollLimit(t) };
+        if (this.replicated(t) && this.replication !== null && !this.slotKnown)
+            return { source: t.source, behind: `slot ${this.replication.slot} is new to the synced data` };
+        const off = this.mode !== "recopy" && this.syncOf(t).mode === "off";
+        return { source: t.source, kept: this.keptWords(t), off };
     }
-    /** how a copy that is current is kept so, in this run's mode: the start line's words (`addedText`) */
-    keptWords() {
+    /** how a copy that is current is kept so, in this run's mode and by its sync: the start line's words (`addedText`) */
+    keptWords(t) {
         const every = `${Number((this.intervalMs / 1000).toFixed(1))} s`;
-        return this.mode === "replication" ? `streamed from ${formatLsn(this.appliedLsn)}`
-            : this.mode === "poll" ? `polled every ${every}` : `copied again whole every ${every}`;
+        const s = this.syncOf(t);
+        return this.mode === "recopy" ? `read again whole every ${every}`
+            : s.mode === "replication" ? `streamed from ${formatLsn(this.appliedLsn)}`
+                : s.mode === "off" ? `sync: off (read again only by mason sync ${t.source})` : syncWords(s);
+    }
+    /** how a table is kept current, as the sources file says (`AddedTable.sync`); a table with none — a test's — polled at
+     *  the sync's own interval */
+    syncOf(t) {
+        if (t.sync !== undefined)
+            return t.sync;
+        return this.mode === "replication" ? { mode: "replication" } : { mode: "poll", every: intervalOf(this.intervalMs / 1000), seconds: this.intervalMs / 1000 };
+    }
+    /** a table the stream keeps current: its sync is `replication` (never in a run that copies every table again whole) */
+    replicated(t) {
+        return this.mode !== "recopy" && this.syncOf(t).mode === "replication";
+    }
+    /** the added tables the stream keeps current, in the project's order */
+    replicatedTables() {
+        return [...this.tables.values()].filter((t) => this.replicated(t));
+    }
+    /** THE RUN STREAMS NOW: a table's sync is `replication` (the slot is made, or kept, and the stream runs) */
+    streams() {
+        return this.replication !== null && this.replicatedTables().length > 0;
+    }
+    /**
+     * WHEN A TABLE'S NEXT POLL IS DUE (ms since the epoch), or null when none is: a table whose sync changed at once
+     * (`switched`), unless a failed attempt set its next; an `off` one never; a polled one at `due`, else its last poll's
+     * time in the ledger plus its interval (a restart does not poll a table before its interval), else now.
+     */
+    dueAt(t) {
+        const s = this.syncOf(t), d = this.due.get(t.source);
+        if (s.mode !== "poll" && !this.switched.has(t.source))
+            return null;
+        if (d !== undefined)
+            return d;
+        if (this.switched.has(t.source) || s.mode !== "poll")
+            return 0;
+        const at = this.polledAt.get(t.source);
+        return at === undefined ? 0 : Date.parse(at) + s.seconds * 1000;
+    }
+    /** a table polled (by a pass, `mason sync` or its catch-up) in `ms`: its next poll after its interval, stretched to four
+     *  times that poll (`nextPollDelayMs`), and its sync now the one recorded (the poll wrote it, `poll`) */
+    polledNow(t, ms) {
+        const s = this.syncOf(t);
+        this.switched.delete(t.source);
+        this.lastPollMs.set(t.source, ms);
+        this.recordedSync.set(t.source, syncText(s));
+        if (s.mode === "poll")
+            this.due.set(t.source, nextPollAt(Date.now(), s.seconds, ms));
+        else
+            this.due.delete(t.source);
+    }
+    /**
+     * WHAT THIS RUN MEASURED OF A TABLE, for `mason add`'s estimate of what polling it costs the database
+     * (src/cli/source-edit.ts pollCost): its last poll's time, and ONE reader's rate at its copy — the copy reading now,
+     * else the last copy's rows over its time and its readers. Null when nothing of it is measured.
+     */
+    measured(source) {
+        const st = this.states.get(source);
+        const live = this.copyLive.get(source)?.rate?.rowsPerSecond ?? null;
+        const copied = st?.phase === "copied" && st.rows && st.seconds ? st.rows / st.seconds / this.copyParallel : null;
+        const last = this.lastPollMs.get(source) ?? null;
+        return last === null && live === null && copied === null ? null : { lastPollMs: last, copyRowsPerSecond: live ?? copied };
+    }
+    /**
+     * HOW LONG UNTIL THE NEXT PASS, in poll mode (null: none until something kicks one — every table `off`, or nothing
+     * copied yet): a pass that failed, or a table waiting for a copy nothing queued, after the sync's interval; else when
+     * the first polled table is due — and at least four times the last pass took, so the passes' polls together never
+     * take more than a fifth of the source's time. `recopy` copies every table again every interval, stretched the same.
+     */
+    nextPassDelay() {
+        if (this.passFailed || this.waiting())
+            return this.intervalMs;
+        if (this.mode === "recopy")
+            return nextPollDelayMs(this.intervalMs, this.lastPassMs);
+        // a table copying, queued, or owed its catch-up is not polled by a pass (its catch-up polls it, then `rearm`): counted
+        // as due it would run a pass every few ms that polls nothing and attaches the source each time
+        const dues = [...this.tables.values()].filter((t) => this.pollable(t)).flatMap((t) => this.dueAt(t) ?? []);
+        return dues.length ? passDelayMs(Math.min(...dues), Date.now(), this.lastPassMs) : null;
+    }
+    /** a table a pass would poll now if it were due: copied, not queued or rebuilt, and not owed its catch-up */
+    pollable(t) {
+        return !this.needsCopy(t) && !this.behind.has(t.source) && !this.queued.has(t.source) && this.rebuildingNow?.source !== t.source;
     }
     /** the source's views (src/cli/preflight.ts VIEWS_SQL), served over the copied tables: in the catalog from the next
      *  pass. A view over a table that is not copied is left out of it (said in the catalog's log) */
@@ -715,19 +916,144 @@ export class Sync {
             this.snapshots.set(s, "0:0:");
     }
     state() {
+        const now = Date.now();
         // in the project's order, whatever order the copies ran and were recorded in (`copyOrder`)
         return [...this.tables.keys()].flatMap((source) => this.states.get(source) ?? [])
             .map((s) => this.retired.has(s.source) ? { ...s, retired: RETIRED_LAYOUT } : s)
             // a copy's chunks as they are NOW: the rows the ones in flight have read by now at the measured rate
             .map((s) => { const l = this.copyLive.get(s.source); return s.phase === "copying" && l !== undefined ? { ...s, progress: copyProgressNow(l, Date.now()) } : s; })
-            .map((s) => this.mode === "poll" && overPollLimit(this.tables.get(s.source)) ? { ...s, unsynced: { reason: OVER_POLL_LIMIT, asOf: this.polledAt.get(s.source) ?? null } } : s);
+            // how it is kept current, and a table the passes leave as copied, from ONE derivation (`keptOf`)
+            .map((s) => {
+            const t = this.tables.get(s.source);
+            if (t === undefined)
+                return s;
+            const kept = this.keptOf(t, now);
+            return { ...s, kept };
+        })
+            // when it was last brought current, whether it waits for its catch-up, and whether it is being rebuilt now
+            .map((s) => {
+            const synced = this.synced.get(s.source), behind = this.behind.get(s.source)?.why;
+            const rebuilding = this.rebuildingNow?.source === s.source ? this.rebuildingNow.kind : undefined;
+            return { ...s, ...(synced ? { synced } : {}), ...(behind !== undefined ? { behind } : {}), ...(rebuilding ? { rebuilding } : {}) };
+        });
+    }
+    /**
+     * HOW AN ADDED TABLE IS KEPT CURRENT, NOW (`KeptCurrent`): the run's mode, then in replication mode its part in the
+     * stream (`streamTable`, what `streamStatus` says of it) and where the stream is; in poll mode its sync, its last copy
+     * or poll and its next. The one place it is derived: `state` carries it to `mason status` and the listener's EXPLAIN
+     * alike.
+     */
+    keptOf(t, now) {
+        const st = this.states.get(t.source);
+        const sync = this.syncOf(t);
+        if (this.mode !== "recopy" && sync.mode !== "replication") {
+            const polledAt = this.polledAt.get(t.source) ?? null;
+            // a copy the passes do not keep current now, and why, from what a poll of it asks (`pollable`): not copied (waiting,
+            // being copied, its copy failed: `needsCopy` holds for every phase but copied), to be copied again (its columns
+            // changed, a numeric outgrew it, a retired layout), caught up first, or its rebuild not ended yet: the moment this
+            // says nothing is pending, `mason sync` of it runs
+            const pending = this.pollable(t) ? null : this.notStreamedWhy(t.source);
+            const next = pending === null ? this.dueAt(t) : null;
+            return { by: "poll", sync, syncedAt: polledAt, nextAt: next === null ? null : new Date(Math.max(next, now)).toISOString(), ...(pending !== null ? { pending } : {}) };
+        }
+        // copied again whole every pass, whatever its watermark: only a table not copied now (waiting, being copied, its copy
+        // failed) is not kept current
+        if (this.mode === "recopy")
+            return { by: "recopy", copiedAt: st?.copiedAt ?? null, ...(st?.phase !== "copied" ? { pending: this.notStreamedWhy(t.source) } : {}) };
+        const s = this.stream;
+        const part = this.streamTable(t, now, s);
+        // current as of its last copy or poll, or — streamed — the last moment the stream had all the database wrote
+        const polled = this.polledAt.get(t.source) ?? null;
+        const streamed = part.state === "streamed" && this.streamCurrentAt !== null ? new Date(this.streamCurrentAt).toISOString() : null;
+        const syncedAt = streamed !== null && (polled === null || streamed > polled) ? streamed : polled;
+        return { by: "replication", slot: this.replication?.slot ?? "", state: part.state, why: part.why, position: formatLsn(s?.position() ?? this.appliedLsn),
+            lastCommit: this.lastBatch === null ? null : new Date(this.lastBatch.committedAt).toISOString(), notRunning: this.streamDownWhy(s, st), syncedAt };
+    }
+    /** why the stream is not running, in the reader's words (null: it runs): its last failure and when it starts again; the
+     *  replication check a pass failed (`prepareReplication`, recorded on each copy's state); a slot not made yet; a sync
+     *  stopping; else it starts at the next pass */
+    streamDownWhy(s, st) {
+        if (s !== null)
+            return null;
+        const firstLine = (e) => e.replace(/^replication: /, "").split("\n")[0];
+        if (this.streamFailure !== null)
+            return `${firstLine(this.streamFailure.error)} · it starts again after ${clock(this.streamFailure.retryAt)} UTC`;
+        if (st?.error?.startsWith("replication: "))
+            return firstLine(st.error);
+        if (this.replication === null)
+            return "this run reads no slot, so nothing streams it (the demo database has no change log): give its entry sync: poll <interval>";
+        if (!this.slotKnown)
+            return `slot ${this.replication.slot} is not made yet: it starts once it is`;
+        if (this.stopped)
+            return "Mason is stopping";
+        return "it has not started yet: it starts at the next pass";
+    }
+    /** an added table's part in the stream (`StreamTableStatus` but what it applied): streamed, being caught up, waiting
+     *  for its copy, or left out of the publication, and why — what `streamStatus` and `keptOf` both say, each of the
+     *  stream `s` it read once */
+    streamTable(t, now, s) {
+        const iso = (ms) => new Date(ms).toISOString();
+        if (this.unpublished.has(t.source))
+            return { state: "left-out", why: this.notStreamedWhy(t.source) };
+        const b = this.behind.get(t.source);
+        if (!this.needsCopy(t) && b !== undefined) {
+            const c = this.catchingUp?.source === t.source ? this.catchingUp : null;
+            const held = this.held.get(t.source)?.counts;
+            const at = this.retries.get(t.source)?.at ?? 0;
+            return { state: "catching-up", why: `caught up by one poll ${b.why}${at > now ? ` — its last catch-up failed, tried again after ${clock(at)} UTC` : ""}`,
+                catchUp: { phase: c?.phase ?? "queued", from: this.polledAt.get(t.source) ?? null, startedAt: c ? iso(c.startedAt) : null, held: held ? held.inserts + held.updates + held.deletes + held.truncates : 0,
+                    retryAt: c === null && at > now ? iso(at) : null } };
+        }
+        if (this.joinedNow.has(t.source) || (s === null && !this.needsCopy(t)))
+            return { state: "streamed", why: null };
+        return { state: "waiting", why: this.notStreamedWhy(t.source) };
     }
-    /** each table's last copy or poll, from the ledger (a copy writes its watermark there too) */
+    /**
+     * Each table's last copy or poll, from the ledger (a copy writes its watermark there too), ONLY EVER FORWARD: this
+     * SELECT's snapshot may be older than a commit on the rebuilds' connection whose time is set while it is answered
+     * (`committed`, `swap`), so what it read never replaces a later time, and a table it does not hold is dropped (removed:
+     * nothing else drops it) only when no such commit gave it a time meanwhile.
+     */
     async readPolledAt() {
+        const asked = new Map(this.polledAt);
         const r = await this.store.writer.runAndReadAll(`SELECT source, epoch_ms(polled_at) FROM ${MASON_SCHEMA}.poll_state WHERE polled_at IS NOT NULL`);
-        this.polledAt.clear();
-        for (const [source, ms] of r.getRowsJS())
-            this.polledAt.set(source, new Date(Number(ms)).toISOString());
+        const ledger = new Map(r.getRowsJS().map(([source, ms]) => [source, new Date(Number(ms)).toISOString()]));
+        for (const [source, at] of this.polledAt)
+            if (!ledger.has(source) && at === asked.get(source))
+                this.polledAt.delete(source);
+        for (const [source, at] of ledger) {
+            const now = this.polledAt.get(source);
+            if (now === undefined || at > now)
+                this.polledAt.set(source, at);
+        }
+    }
+    /**
+     * EACH COPY'S LAST SYNC AS THE LEDGER KEEPS IT, at a start (`Synced`): the swap and every poll write
+     * `poll_state.polled_at` in their own transaction, and a copy's `copied_at` is recorded right after its swap — so a
+     * copy recorded at or after its table's `polled_at` was last brought current by that copy (its time the copy's
+     * `seconds`), else by a poll (its time unknown: null). In replication mode the stream's last batch
+     * (`stream_state.applied_at`) is newer for a table it streamed; a table not caught up is left at its copy, and one the
+     * named publication does not carry (`unpublished`: never streamed, so the stream's time is not its own) at its copy
+     * or poll. `only`: those tables alone, read again (the pass that found them out of the publication), the others'
+     * last sync kept as it is.
+     */
+    async readSynced(only) {
+        const r = await this.store.writer.runAndReadAll(`SELECT p.source, epoch_ms(p.polled_at), epoch_ms(c.copied_at), c.seconds FROM ${MASON_SCHEMA}.poll_state p ` +
+            `LEFT JOIN ${MASON_SCHEMA}.copy_state c USING (source) WHERE p.polled_at IS NOT NULL`);
+        const streamed = this.replication === null ? [] : (await this.store.writer.runAndReadAll(`SELECT epoch_ms(applied_at) FROM ${MASON_SCHEMA}.stream_state ` +
+            `WHERE slot = $1 AND applied_at IS NOT NULL`, [this.replication.slot])).getRowsJS();
+        const streamMs = streamed.length ? Number(streamed[0][0]) : null;
+        if (only === undefined)
+            this.synced.clear();
+        for (const [source, polled, copied, seconds] of r.getRowsJS()) {
+            if (only !== undefined && !only.has(source))
+                continue;
+            const at = Number(polled);
+            const s = copied !== null && Number(copied) >= at ? { at: new Date(Number(copied)).toISOString(), seconds, by: "copy" }
+                : { at: new Date(at).toISOString(), seconds: null, by: "poll" };
+            const streamedIt = !this.behind.has(source) && !this.unpublished.has(source);
+            this.synced.set(source, streamMs !== null && streamMs > Date.parse(s.at) && streamedIt ? { at: new Date(streamMs).toISOString(), seconds: null, by: "stream" } : s);
+        }
     }
     schema() { return this.currentSchema; }
     start() { this.kick(); }
@@ -750,13 +1076,12 @@ export class Sync {
             this.running = null;
             if (this.stopped)
                 return;
-            // replication mode: the stream keeps the copies current between passes, and a pass runs when the tables change —
-            // or after the interval, when it failed or a table waits for a copy or catch-up nothing has queued (a copy that
-            // failed waits its turn, `copyRetryDelayMs`)
-            if (this.mode !== "replication")
-                this.timer = setTimeout(() => this.kick(), nextPollDelayMs(this.intervalMs, this.lastPassMs));
-            else if (this.passFailed || this.waiting())
-                this.timer = setTimeout(() => this.kick(), this.intervalMs);
+            // when the next polled table is due (`nextPassDelay`) — the stream keeps a replicated table current between passes,
+            // and a pass runs for it when the tables change — or after the interval, when it failed or a table waits for a copy
+            // or catch-up nothing has queued (a copy that failed waits its turn, `copyRetryDelayMs`)
+            const d = this.nextPassDelay();
+            if (d !== null)
+                this.timer = setTimeout(() => this.kick(), d);
         });
     }
     /** an added table needs a copy or a catch-up that is neither queued nor running: a later pass must queue it */
@@ -799,19 +1124,42 @@ export class Sync {
      */
     followUp(source) {
         const t = this.tables.get(source);
-        if (t === undefined || this.stopped || this.unpublished.has(source) || (!this.needsCopy(t) && !this.behind.has(source)))
+        if (t === undefined || this.stopped || this.unpublished.has(source))
+            return;
+        // copied and caught up: polled from now on, so the next pass is timed again (`rearm`)
+        if (!this.needsCopy(t) && !this.behind.has(source)) {
+            this.rearm();
             return;
+        }
         const at = this.retries.get(source)?.at ?? 0;
         if (at > Date.now())
             this.wakeAt(at);
         else
             this.kick();
     }
-    /** one pass, now, and its end awaited (the one running first, if any), and the copies and catch-ups it queued: what
-     *  a test or a reread waits on */
+    /**
+     * THE NEXT PASS TIMED AGAIN, in poll mode, once a table is copied and caught up: a pass that ended while every table
+     * still copied found none due (`nextPassDelay` skips a table that needs its copy) and set no timer, so without this a
+     * table's polls never began. A pass running sets its own when it ends, from the state then.
+     */
+    rearm() {
+        if (this.stopped || this.running !== null)
+            return;
+        const d = this.nextPassDelay();
+        if (d === null)
+            return;
+        if (this.timer !== null)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => this.kick(), d);
+    }
+    /** one pass, now, every polled table taken as due (an `off` one is not: it is polled only when asked), and its end
+     *  awaited (the one running first, if any), and the copies and catch-ups it queued: what a test waits on */
     async once() {
         while (this.running !== null)
             await this.running;
+        for (const t of this.tables.values())
+            if (this.syncOf(t).mode === "poll")
+                this.due.set(t.source, 0);
         this.kick();
         if (this.running !== null)
             await this.running;
@@ -819,34 +1167,43 @@ export class Sync {
             await this.rebuilding;
     }
     /**
-     * A POLL OF EXACTLY THESE TABLES, NOW, whatever their size (`mason sync`; a table over POLL_ROW_LIMIT is polled only
-     * so): a pass of its own, queued behind the one running, in one source snapshot as every poll is. Refused by name
-     * (`PollRefused`) for a table not added or not copied yet, and in a run whose copies are kept current another way.
-     * Its failure is its caller's to say: the copies serve as they were, and the passes go on.
+     * A POLL OF EXACTLY THESE TABLES, NOW, whatever their sync says (`mason sync`: an `off` table is read again only so):
+     * a pass of its own, queued behind the one running, in one source snapshot as every poll is; a polled table's next
+     * poll waits its interval from this one. A replicated table is not polled: its answer is where the stream is
+     * (`streamed`), beside the polled ones'. Refused by name (`PollRefused`) for a table not added or not copied yet, and in a run that copies
+     * every table again whole. Its failure is its caller's to say: the copies serve as they were, and the passes go on.
      */
     async pollNow(sources) {
-        if (this.mode !== "poll") {
-            throw new PollRefused("refused", this.mode === "replication" ? "this run keeps every table current by logical replication, so there is nothing to poll"
-                : "this run copies every table again whole at each pass (MASON_DUCK_SYNC=recopy), so there is nothing to poll");
-        }
+        if (this.mode === "recopy")
+            throw new PollRefused("refused", "this run reads every table again whole at each pass (MASON_DUCK_SYNC=recopy), so there is nothing to poll");
         const tables = sources.map((s) => {
             const t = this.tables.get(s);
             if (t === undefined)
                 throw new PollRefused("not_found", `${s} is not added (mason add adds it)${didYouMean(s, [...this.tables.keys()])}`);
             return t;
         });
+        // a replicated table: the stream keeps it current, so nothing to poll — its answer is where the stream is, and its part
+        const said = () => {
+            const now = Date.now(), position = formatLsn(this.stream?.position() ?? this.appliedLsn);
+            return tables.filter((t) => this.replicated(t)).map((t) => { const p = this.streamTable(t, now, this.stream); return { table: t.source, position, state: p.state, why: p.why }; });
+        };
+        const polled = tables.filter((t) => !this.replicated(t));
+        if (polled.length === 0)
+            return { at: new Date().toISOString(), tables: [], streamed: said() };
         while (this.running !== null)
             await this.running;
         if (this.stopped)
             throw new Stopping();
         // asked after the pass ahead of it: that pass may have copied it, or failed its copy
-        for (const t of tables) {
+        for (const t of polled) {
             const st = this.states.get(t.source);
-            if (st?.phase !== "copied" || !this.snapshots.has(t.source) || this.copiedAs.get(t.source) !== columnsKey(t.columns)) {
-                throw new PollRefused("nothing_yet", `${t.source} is not copied yet (${st?.phase === "failed" ? `its copy failed: ${st.error ?? "mason logs says why"}` : "its copy has not finished"}): mason wait waits for it`);
-            }
+            if (st?.phase !== "copied")
+                throw new PollRefused("nothing_yet", `${t.source} is not synced yet (${st?.phase === "failed" ? `its first sync failed: ${st.error ?? "mason logs says why"}` : "its first sync has not finished"}): mason wait waits for it`);
+            const again = this.readAgainWhy(t);
+            if (again !== null)
+                throw new PollRefused("nothing_yet", `${t.source} is being read again whole (${again}): mason wait waits for it`);
             if (this.retired.has(t.source))
-                throw new PollRefused("nothing_yet", `${t.source} is ${RETIRED_LAYOUT} (its copy serves as it was): it is current once copied — mason wait waits for it`);
+                throw new PollRefused("nothing_yet", `${t.source} is ${RETIRED_LAYOUT} (its synced data serves as it was): it is current once read again — mason wait waits for it`);
             this.refuseRebuilding(t);
         }
         const poll = (async () => {
@@ -854,8 +1211,12 @@ export class Sync {
             try {
                 // a transaction per table, as the passes poll; a table whose rebuild started since it was asked is refused
                 const found = [];
-                for (const t of tables)
-                    found.push(...await this.onWriter(async () => { this.refuseRebuilding(t); return this.poll(this.writerLane, [t]); }));
+                for (const t of polled) {
+                    const f = await this.onWriter(async () => { this.refuseRebuilding(t); return this.poll(this.writerLane, [t]); });
+                    for (const x of f)
+                        this.polledNow(t, x.ms);
+                    found.push(...f);
+                }
                 return found;
             }
             finally {
@@ -863,12 +1224,21 @@ export class Sync {
             }
         })();
         // the pass slot is held until it ends (kick and once queue behind it); its failure reaches the caller through `poll`
-        this.running = poll.then(() => undefined, () => undefined).finally(() => { this.running = null; });
+        // and the next pass timed again as a pass's end times it (`rearm`): a copy that ended meanwhile found the slot held,
+        // and a polled table's next poll moved past the timer set before
+        this.running = poll.then(() => undefined, () => undefined).finally(() => { this.running = null; this.rearm(); });
         const found = await poll;
-        const missing = tables.filter((t) => !found.some((f) => f.table === t.source));
+        // A SYNC BY HAND IS AN EVENT (src/duck/events.ts `synced`), in the words mason sync and the page's Sync now say:
+        // a scheduled poll that succeeds records nothing (one every few seconds would bury the failures), so without it a
+        // person who synced and then read the events found only an older copy, and read it as a sync lost. A replicated
+        // table asked for is answered with the stream's position and records none: nothing was read for it
+        for (const x of found)
+            this.event({ kind: "synced", table: x.table, message: `synced by hand: ${syncedText(x)}` });
+        const missing = polled.filter((t) => !found.some((f) => f.table === t.source));
         if (missing.length)
-            throw new Error(`${missing.map((t) => t.source).join(", ")} has a numeric value wider than its copy's DECIMAL: it is copied again at the next pass, and current once copied`);
-        return { at: new Date().toISOString(), tables: found };
+            throw new Error(`${missing.map((t) => t.source).join(", ")} has a numeric value wider than its synced DECIMAL column: it is read again whole at the next pass, and current once read`);
+        const streamed = said();
+        return { at: new Date().toISOString(), tables: found, ...(streamed.length ? { streamed } : {}) };
     }
     /**
      * The sync stopped: no pass starts, and the one running ends at once — its long statement (a copy's scan, a poll's
@@ -916,8 +1286,8 @@ export class Sync {
         const now = this.rebuildingNow?.source === t.source ? this.rebuildingNow.kind : null;
         if (now === null && !this.behind.has(t.source))
             return;
-        const doing = now === "copy" ? "being copied again" : `being caught up by one poll ${this.behind.get(t.source)?.why ?? ""}`.trimEnd();
-        throw new PollRefused("nothing_yet", `${t.source} is ${doing} (its copy serves as it was): it is caught up by one poll when that ends, so there is nothing to poll — mason wait waits for it`);
+        const doing = now === "copy" ? "being read again whole" : `being caught up by one poll ${this.behind.get(t.source)?.why ?? ""}`.trimEnd();
+        throw new PollRefused("nothing_yet", `${t.source} is ${doing} (its synced data serves as it was): it is caught up by one poll when that ends, so there is nothing to poll — mason wait waits for it`);
     }
     /** the source's connection, as the sync's own reads and replication make it (never DuckDB's: that is `attach`) */
     pgOptions() {
@@ -941,7 +1311,7 @@ export class Sync {
         return columns === undefined ? t : { ...t, columns };
     }
     /**
-     * REPLICATION, BEFORE A PASS COPIES: the publication carries every added table, and the slot exists — so a table
+     * REPLICATION, BEFORE A PASS COPIES: the publication carries every replicated table, and the slot exists — so a table
      * copied now has its changes in the stream from before it joins (src/duck/stream.ts "why replaying is safe"). A slot
      * made now, or one this copy has no record of, carries nothing from before it: the tables already copied are caught
      * up by one poll each before the stream applies their changes (`behind`, recorded with the slot in one transaction).
@@ -950,7 +1320,7 @@ export class Sync {
      */
     async prepareReplication() {
         const r = this.replication;
-        const tables = [...this.tables.values()];
+        const tables = this.replicatedTables();
         const pg = await PgConnection.connect(this.pgOptions());
         try {
             const identities = new Map((await pg.query(`SELECT n.nspname || '.' || c.relname, c.relreplident FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace ` +
@@ -960,7 +1330,8 @@ export class Sync {
             const nothing = tables.filter((t) => identities.get(t.source) === "n").map((t) => t.source);
             if (nothing.length) {
                 throw new Error(`${nothing.join(", ")} ${nothing.length === 1 ? "has" : "have"} REPLICA IDENTITY NOTHING: a publication carrying ${nothing.length === 1 ? "it" : "them"} ` +
-                    `would make the app's own UPDATEs and DELETEs fail, so Mason does not add ${nothing.length === 1 ? "it" : "them"}. ALTER TABLE … REPLICA IDENTITY DEFAULT, or mason start --poll`);
+                    `would make the app's own UPDATEs and DELETEs fail, so Mason does not replicate ${nothing.length === 1 ? "it" : "them"}. Give ${nothing.length === 1 ? "its entry" : "their entries"} ` +
+                    `sync: poll <interval> (poll 5m) in the sources file, or ALTER TABLE … REPLICA IDENTITY DEFAULT on the database`);
             }
             if (r.owned)
                 await this.ensurePublication(pg, tables, identities);
@@ -969,7 +1340,7 @@ export class Sync {
             const slot = await readSlot(pg, r.slot);
             let made = false;
             if (slot.exists && slot.walStatus === "lost") {
-                this.log(`replication slot ${r.slot} was invalidated by the database (wal_status lost: it held more WAL than max_slot_wal_keep_size), so changes are missing from it: made again, and the copies caught up by one poll`);
+                this.log(`replication slot ${r.slot} was invalidated by the database (wal_status lost: it held more WAL than max_slot_wal_keep_size), so changes are missing from it: made again, and the synced tables caught up by one poll`);
                 if (slot.active)
                     throw new Error(`replication slot ${r.slot} is lost and still in use by pid ${slot.activePid}`);
                 await dropSlot(pg, r.slot);
@@ -980,14 +1351,16 @@ export class Sync {
             if (!slot.exists || slot.walStatus === "lost") {
                 const repl = await PgConnection.connect({ ...this.pgOptions(), replication: true });
                 try {
-                    this.log(`made replication slot ${r.slot} at ${await createSlot(repl, r.slot)} (it holds the database's WAL until Mason reads it: mason destroy, or mason start --poll, drops it)`);
+                    this.log(`made replication slot ${r.slot} at ${await createSlot(repl, r.slot)} (it holds the database's WAL until Mason reads it: mason destroy drops it, and so does a sources file in which no table's sync is replication)`);
                 }
                 finally {
                     repl.close();
                 }
                 made = true;
+                this.onReplication?.(true);
             }
             if (made || !this.slotKnown) {
+                // the replicated tables already copied: the slot carries nothing from before it (a polled one is the poll's)
                 const copied = tables.filter((t) => this.states.get(t.source)?.phase === "copied" && this.snapshots.has(t.source));
                 await this.onWriter(async () => {
                     const w = this.store.writer;
@@ -1013,24 +1386,44 @@ export class Sync {
         finally {
             pg.close();
         }
-        // what the last stream's failure said is the past once the publication and slot are as they should be; a table a
-        // named publication does not carry is refused on its own line (a copy it never had is failed), the others go on
-        await this.onWriter(async () => {
-            for (const t of tables) {
-                const st = this.states.get(t.source);
-                const gap = this.unpublished.get(t.source);
-                if (gap !== undefined) {
-                    const error = `replication: ${gap}`;
-                    if (st.error !== error)
-                        this.log(`${t.source} is not copied or streamed: ${error}`);
-                    await this.record({ ...st, phase: st.phase === "copied" ? "copied" : "failed", error });
+        await this.onWriter(() => this.settlePrepared(tables));
+    }
+    /**
+     * WHAT A PASS'S PUBLICATION CHECK SETTLES, ON THE WRITER'S TURN (`prepareReplication`, once the publication and slot are
+     * as they should be): a table a named publication does not carry is refused on its own line (a copy it never had is
+     * failed), the others go on; a table it carries AGAIN has that gap's error cleared, and a table never copied the last
+     * pass's failure to prepare. NOTHING ELSE: a copy whose stream failed, or that the failed preparation left behind, is
+     * current again only once the stream applies a batch with a position (`applyChanges`) — the publication being right
+     * says nothing of whether its changes are in the copy, and a pass runs while the stream waits out its back-off.
+     */
+    async settlePrepared(tables) {
+        for (const t of tables) {
+            const st = this.states.get(t.source);
+            const gap = this.unpublished.get(t.source);
+            if (gap !== undefined) {
+                const error = `replication: ${gap}`;
+                if (st.error !== error) {
+                    this.log(`${t.source} is not synced or streamed: ${error}`);
+                    this.event({ kind: "stream_failed", table: t.source, message: `not synced or streamed: ${error}` });
                 }
-                else if (st.error?.startsWith("replication: "))
-                    await this.record({ ...st, error: null });
+                this.gapErrors.set(t.source, error);
+                await this.record({ ...st, phase: st.phase === "copied" ? "copied" : "failed", error });
+                continue;
             }
-            // a table the publication stopped carrying leaves the stream; one it carries now may join
-            this.refreshStreamed();
-        });
+            const gapClosed = this.gapErrors.get(t.source);
+            this.gapErrors.delete(t.source);
+            if (st.error === null)
+                continue;
+            if (st.error === gapClosed || (st.phase !== "copied" && st.error === this.wholeFailure.prepare))
+                await this.record({ ...st, error: null });
+        }
+        // a table the publication does not carry was never streamed: its last sync is its copy's or its poll's, never
+        // the stream's time a start credited it with (`readSynced` at `open`, before the publication was read)
+        const credited = tables.filter((t) => this.unpublished.has(t.source) && this.synced.get(t.source)?.by === "stream").map((t) => t.source);
+        if (credited.length)
+            await this.readSynced(new Set(credited));
+        // a table the publication stopped carrying leaves the stream; one it carries now may join
+        this.refreshStreamed();
     }
     /**
      * A publication the operator NAMED: read as it is, verified, never created, altered or dropped (src/duck/publication.ts).
@@ -1039,14 +1432,14 @@ export class Sync {
      */
     async verifyPublication(pg, tables, identities) {
         const name = this.replication.publication;
-        const v = namedPublicationVerdict(await readNamedPublication(pg, name, tables, this.database), tables, identities);
+        const v = namedPublicationVerdict(await readNamedPublication(pg, name, tables), tables, identities);
         if (v.refused !== null)
             throw new Error(v.refused);
         this.unpublished.clear();
         for (const [source, m] of v.tables)
             this.unpublished.set(source, m);
         if (v.noTruncate && !this.truncateSaid) {
-            this.log(`publication ${name} does not publish truncate: a TRUNCATE on the database does not reach the copy (the poll's count would see it; mason start --poll)`);
+            this.log(`publication ${name} does not publish truncate: a TRUNCATE on the database does not reach the synced data (the poll's count would see it: sync: poll <interval> on its entry)`);
             this.truncateSaid = true;
         }
     }
@@ -1080,8 +1473,68 @@ export class Sync {
                 throw new Error(`publication ${name} is FOR ALL TABLES: it is not the one Mason made (drop it, or name another project)`);
             await pg.query(`ALTER PUBLICATION ${pgIdent(name)} SET TABLE ${list}`);
             await pg.query(`ALTER PUBLICATION ${pgIdent(name)} SET (publish = 'insert, update, delete, truncate')`);
-            this.log(`re-pointed publication ${name} at ${tables.map((t) => t.source).join(", ")}`);
+            this.log(`re-pointed publication ${name} at ${tables.map((t) => t.source).join(", ")}: the tables whose sync is replication`);
+        }
+        // VERIFIED, never assumed: what the publication carries is what the database says it does
+        const carried = (await pg.query(`SELECT schemaname || '.' || tablename FROM pg_publication_tables WHERE pubname = ${pgLiteral(name)}`)).rows.map((x) => x[0]).sort();
+        const wanted = tables.map((t) => t.source).sort();
+        if (carried.join("\n") !== wanted.join("\n")) {
+            throw new Error(`publication ${name} carries ${carried.join(", ") || "no table"} after it was set to ${wanted.join(", ")} (Mason bug: report it, with mason logs)`);
+        }
+    }
+    /**
+     * NO TABLE'S SYNC IS REPLICATION ANY MORE (at the start that finds none, or live when the last one leaves): the stream
+     * stopped, the slot dropped — it holds the database's WAL while it exists, read or not — and Mason's own publication
+     * with it (a named one is its owner's: left as it is), each VERIFIED gone; then this copy's record of the slot goes,
+     * so a table replicated again later is caught up by one poll under the slot made anew. Idempotent: what is already
+     * gone is not an error. A failure is the pass's, said, and tried again at the next.
+     */
+    async retireReplication() {
+        const r = this.replication;
+        const s = this.stream;
+        if (s !== null) {
+            await s.stop();
+            if (this.stream === s)
+                this.stream = null;
+        }
+        const pg = await PgConnection.connect(this.pgOptions());
+        const dropped = [];
+        try {
+            // the walsender a stop ended lets the slot go a moment later: waited for, at most 10 s
+            let slot = await readSlot(pg, r.slot);
+            for (let i = 0; slot.exists && slot.active && i < 100; i++) {
+                await new Promise((res) => setTimeout(res, 100));
+                slot = await readSlot(pg, r.slot);
+            }
+            if (slot.exists) {
+                if (slot.active)
+                    throw new Error(`replication slot ${r.slot} is in use by pid ${slot.activePid ?? "?"}, so it cannot be dropped (another Mason over the same project? stop it)`);
+                await dropSlot(pg, r.slot);
+                dropped.push(`replication slot ${r.slot}`);
+            }
+            const hasPub = async () => (await pg.query(`SELECT 1 FROM pg_publication WHERE pubname = ${pgLiteral(r.publication)}`)).rows.length > 0;
+            if (r.owned && await hasPub()) {
+                await pg.query(`DROP PUBLICATION IF EXISTS ${pgIdent(r.publication)}`);
+                dropped.push(`publication ${r.publication}`);
+            }
+            if ((await readSlot(pg, r.slot)).exists)
+                throw new Error(`replication slot ${r.slot} is still there after pg_drop_replication_slot`);
+            if (r.owned && await hasPub())
+                throw new Error(`publication ${r.publication} is still there after DROP PUBLICATION`);
+        }
+        finally {
+            pg.close();
         }
+        await this.onWriter(async () => {
+            await this.store.writer.run(`DELETE FROM ${MASON_SCHEMA}.stream_state WHERE slot = $1`, [r.slot]);
+            this.slotKnown = false;
+            this.appliedLsn = 0n;
+            this.streamCurrentAt = null;
+            this.refreshStreamed();
+        });
+        this.log(`no table's sync is replication now: ${dropped.length ? `dropped ${dropped.join(" and ")} from ${this.source.database}, verified gone` : `replication slot ${r.slot} was already gone`}` +
+            ` (the slot held the database's WAL)${r.owned ? "" : `; publication ${r.publication} is its owner's, left as it is`} — a table set to sync: replication makes the slot again`);
+        this.onReplication?.(false);
     }
     /**
      * The stream started from the slot's acknowledged position, once the slot is known (a pass's `prepareReplication`),
@@ -1089,14 +1542,15 @@ export class Sync {
      * joins once caught up and leaves when copied again without a restart.
      */
     startStream() {
-        if (this.stream !== null || this.stopped || this.mode !== "replication" || !this.slotKnown || Date.now() < this.streamAt)
+        if (this.stream !== null || this.stopped || !this.streams() || !this.slotKnown || Date.now() < this.streamAt)
             return;
         const r = this.replication;
         this.refreshStreamed();
         const s = new ReplicationStream({
             connect: () => PgConnection.connect({ ...this.pgOptions(), replication: true }), slot: r.slot, publication: r.publication, log: (l) => this.log(l),
             target: { tables: () => this.streamed, apply: (batch, lsn, committedAt) => this.applyStreamed(batch, lsn, committedAt), applied: () => this.appliedLsn,
-                refuse: (source, missing) => this.refuseStreamed(source, missing) },
+                refuse: (source, missing) => this.refuseStreamed(source, missing), current: () => { if (this.stream === s)
+                    this.streamCurrentAt = Date.now(); } },
         });
         this.stream = s;
         this.streamFailure = null;
@@ -1108,7 +1562,7 @@ export class Sync {
         }
         const joined = [...this.streamed.keys()].filter((x) => !this.held.has(x));
         this.log(`streaming ${joined.length ? joined.join(", ") : "no table yet"} from slot ${r.slot} (publication ${r.publication}), applied through ${formatLsn(this.appliedLsn)}` +
-            `${joined.length < this.tables.size ? "; a table copied or caught up meanwhile joins it once current" : ""}`);
+            `${joined.length < this.replicatedTables().length ? "; a table synced or caught up meanwhile joins it once current" : ""}`);
         void s.done.then(async (e) => {
             if (this.stream === s)
                 this.stream = null;
@@ -1122,7 +1576,7 @@ export class Sync {
             if (wider !== undefined && n <= 3) {
                 this.widened.set(wider.source, n);
                 await this.onWriter(async () => { this.snapshots.delete(wider.source); this.refreshStreamed(); });
-                this.log(`replication: ${wider.source} has a numeric value wider than its copy's DECIMAL: it is copied again, then streamed`);
+                this.log(`replication: ${wider.source} has a numeric value wider than its synced DECIMAL column: it is read again whole, then streamed`);
                 this.startStream();
                 this.kick();
                 return;
@@ -1135,7 +1589,11 @@ export class Sync {
             // a timer may fire a little early: the pass it kicks starts the stream
             this.streamAt = Date.now() + wait - 50;
             this.streamFailure = { error: m, retryAt: this.streamAt };
-            this.log(`${m} (the stream starts again in ${wait / 1000} s, failure ${this.streamFailures} in a row; the copies serve as they are)`);
+            this.log(`${m} (the stream starts again in ${wait / 1000} s, failure ${this.streamFailures} in a row; the synced tables serve as they are)`);
+            // one event for the stream, never one per table it kept current (each table's error says it); its failures in a
+            // row are left out of the words, so a stream failing for good is one event, not one per restart
+            this.event({ kind: "stream_failed", table: null, message: `${m} (the stream starts again by itself; the synced tables serve as they are)` });
+            this.wholeFailure.stream = m;
             // on the tables the stream kept current when it failed (one being caught up says its own)
             await this.onWriter(async () => { for (const source of this.streamed.keys())
                 if (!this.held.has(source))
@@ -1164,10 +1622,11 @@ export class Sync {
             this.held.delete(source);
             const when = this.backOff(source, 0);
             const pub = this.replication.publication;
-            const m = `replication: the stream no longer carries ${source}'s ${cols}, which its copy holds (a column dropped or renamed on the database, or the publication's column list narrowed), ` +
+            const m = `replication: the stream no longer carries ${source}'s ${cols}, which its synced table holds (a column dropped or renamed on the database, or the publication's column list narrowed), ` +
                 `so its changes are not applied: it is caught up by one poll again after ${when}. The way out: remove ${cols} from its columns in the sources file (mason add ${source} --columns … ` +
-                `picks the columns it has; it is copied again at once)${this.replication.owned ? "" : `, or publish ${missing.length === 1 ? "it" : "them"} again (ALTER PUBLICATION ${pub} …)`}`;
+                `picks the columns it has; it is read again whole at once)${this.replication.owned ? "" : `, or publish ${missing.length === 1 ? "it" : "them"} again (ALTER PUBLICATION ${pub} …)`}`;
             this.log(`${source}: ${m}`);
+            this.event({ kind: "stream_failed", table: source, message: m });
             await this.record({ ...this.states.get(source), error: m });
             this.refreshStreamed();
         });
@@ -1176,18 +1635,22 @@ export class Sync {
      * What the stream applies, made again from the tables' state (on the writer's turn, or before the stream exists): a
      * table copied at its present columns and caught up, and a table being caught up (its changes held, `held`). A table
      * that is not — never copied, being copied again, or not caught up — is skipped: its copy's snapshot, or its catch-up,
-     * covers what the stream passes over (src/duck/stream.ts "why replaying is safe").
+     * covers what the stream passes over (src/duck/stream.ts "why replaying is safe"). A table here since the last refresh
+     * keeps its STAY, a table new here gets one, and `swap` ends it: changes decoded in a stay that ended committed before
+     * what came next, so that copy and its catch-up hold them, and only that stay's are applied (`applyStreamed`).
      */
     refreshStreamed() {
+        const before = new Map(this.streamed);
         this.streamed.clear();
         const now = new Set();
         for (const t of this.tables.values()) {
-            // a table a named publication does not carry is never streamed (`unpublished`): its changes are not in the slot
-            const joined = !this.behind.has(t.source) && !this.needsCopy(t) && !this.unpublished.has(t.source);
+            // a table a named publication does not carry is never streamed (`unpublished`): its changes are not in the slot;
+            // nor one whose sync is not replication (it is polled, or off)
+            const joined = this.replicated(t) && !this.behind.has(t.source) && !this.needsCopy(t) && !this.unpublished.has(t.source);
             // in the COPY's columns: a held table's columns may have changed since its copy began (`asCopied`)
             const c = this.asCopied(t).columns;
             if (joined || this.held.has(t.source)) {
-                this.streamed.set(t.source, { columns: c.map((x) => x.name), key: t.key, generated: c.filter((x) => x.generated).map((x) => x.name), big: t.rows !== null && t.rows > POLL_ROW_LIMIT });
+                this.streamed.set(t.source, { stay: before.get(t.source)?.stay ?? ++this.lastStay, columns: c.map((x) => x.name), key: t.key, generated: c.filter((x) => x.generated).map((x) => x.name), big: t.rows !== null && t.rows > BIG_TABLE_ROWS });
             }
             if (joined)
                 now.add(t.source);
@@ -1196,11 +1659,18 @@ export class Sync {
         // while a stream runs: its start names what it streams. What it returns is the tables whose join was said
         const said = [];
         const s = this.stream;
-        if (s !== null && this.mode === "replication") {
+        if (s !== null) {
             const at = formatLsn(s.position());
-            for (const source of this.joinedNow)
-                if (!now.has(source))
-                    this.log(`${source} leaves the stream at ${at}: ${this.notStreamedWhy(source)}`);
+            for (const source of this.joinedNow) {
+                if (now.has(source))
+                    continue;
+                const t = this.tables.get(source);
+                // its sync changed: what keeps it current now, in the words of the switch
+                const why = t !== undefined && !this.replicated(t)
+                    ? `its sync is ${syncText(this.syncOf(t))} now, so it is caught up by one poll from its watermark${this.syncOf(t).mode === "off" ? ", then read again only by mason sync" : ", then polled"}`
+                    : this.notStreamedWhy(source);
+                this.log(`${source} leaves the stream at ${at}: ${why}`);
+            }
             for (const source of now) {
                 if (this.joinedNow.has(source))
                     continue;
@@ -1222,63 +1692,71 @@ export class Sync {
             return `${why} — after a failure, tried again after ${clock(at)} UTC`;
         const ahead = this.rebuildingNow;
         if (this.queued.has(source) && ahead !== null && ahead.source !== source)
-            return `${why} — queued behind ${ahead.source}'s ${ahead.kind === "copy" ? "copy" : "catch-up"} (one rebuild at a time)`;
+            return `${why} — queued behind ${ahead.source}'s ${ahead.kind === "copy" ? "whole read" : "catch-up"} (one rebuild at a time)`;
         return why;
     }
+    /** why a table whose first sync finished is to be read again whole, or null: what the start's line and mason sync say */
+    readAgainWhy(t) {
+        if (this.copiedAs.get(t.source) !== columnsKey(t.columns))
+            return "its columns changed";
+        return this.snapshots.has(t.source) ? null : "a numeric value outgrew its synced DECIMAL column";
+    }
     notStreamedReason(source) {
         const t = this.tables.get(source);
         if (t === undefined)
-            return "it is no longer added (its copy is dropped)";
+            return "it is no longer added (its synced data is dropped)";
         const gap = this.unpublished.get(source);
         if (gap !== undefined)
             return gap.split("\n")[0];
         const st = this.states.get(source);
         if (this.copiedAs.has(source) && this.copiedAs.get(source) !== columnsKey(t.columns))
-            return "its columns changed: it is copied again, then caught up by one poll";
+            return "its columns changed: it is read again whole, then caught up by one poll";
         if (st?.phase === "copied" && !this.snapshots.has(source))
-            return "a numeric value outgrew its copy's DECIMAL: it is copied again, wider, then caught up by one poll";
+            return "a numeric value outgrew its synced DECIMAL column: it is read again whole, wider, then caught up by one poll";
+        if (st?.phase === "copied" && this.retired.has(source))
+            return "it is in an older Mason's layout, key order with an index: it is read again whole, then caught up by one poll";
+        // what follows the copy: a catch-up poll, then the stream or the polls; copied again whole, nothing (`keptOf`'s recopy)
+        const joins = this.mode === "recopy" ? "it is kept current once synced" : "it joins once synced and caught up by one poll";
         if (st?.phase === "copying" || this.rebuildingNow?.source === source && this.rebuildingNow.kind === "copy")
-            return "it is being copied: it joins once copied and caught up by one poll";
+            return `it is being read whole: ${joins}`;
         if (st?.phase === "failed")
-            return `its copy failed (${(st.error ?? "").split("\n")[0]}): it joins once copied and caught up by one poll`;
+            return `its first sync failed (${(st.error ?? "").split("\n")[0]}): ${joins}`;
         const b = this.behind.get(source);
         if (!this.needsCopy(t) && b !== undefined)
             return `it is caught up by one poll ${b.why} first`;
-        return "it waits for its copy: it joins once copied and caught up by one poll";
+        // synced, caught up, and not yet polled (`pollable`): its rebuild's last writer's turn, or a rebuild still queued
+        if (st?.phase === "copied") {
+            if (this.rebuildingNow?.source === source)
+                return "its sync is ending: it is kept current from then on";
+            const queued = this.queued.get(source)?.kind;
+            if (queued !== undefined)
+                return queued === "copy" ? `it is queued to be read whole: ${joins}` : "it is queued to be caught up by one poll";
+        }
+        return `it waits for its first sync: ${joins}`;
     }
     /**
      * WHERE THE STREAM IS (`StreamStatus`): its position, the database's, the lag, the last batch, and each added table's
      * part in it with what it applied this run. Null outside replication mode. The database's position costs a
      * connection at most every 5 s (`databasePosition`); everything else is the run's own.
+     *
+     * `refresh: false` NEVER REACHES THE DATABASE: the position and the slot as last read (`database.at`, `slotWal.at` say
+     * when), or "not read yet". What an unauthenticated reader asks with (`GET /metrics`, src/cli/run-server.ts
+     * `metricsFacts`): a scraper's rate, or anyone's loop on the health port, must never become connections and SELECTs
+     * on the source; the usage sampler, `mason status` and `mason wait` keep the reads fresh.
      */
-    async streamStatus() {
-        if (this.mode !== "replication")
+    async streamStatus({ refresh = true } = {}) {
+        if (!this.streams())
             return null;
         const r = this.replication;
         const s = this.stream;
         const position = s?.position() ?? this.appliedLsn;
-        const db = await this.databasePosition();
+        const db = refresh ? await this.databasePosition() : this.dbPosition ?? { error: "not read yet: nothing has asked where the database is since the run began", at: Date.now() };
         const now = Date.now();
         const iso = (ms) => new Date(ms).toISOString();
-        const tables = [...this.tables.values()].map((t) => {
-            const applied = { ...(this.appliedCounts.get(t.source) ?? noCounts()) };
-            if (this.unpublished.has(t.source))
-                return { table: t.source, state: "left-out", why: this.notStreamedWhy(t.source), applied };
-            const b = this.behind.get(t.source);
-            if (!this.needsCopy(t) && b !== undefined) {
-                const c = this.catchingUp?.source === t.source ? this.catchingUp : null;
-                const held = this.held.get(t.source)?.counts;
-                const at = this.retries.get(t.source)?.at ?? 0;
-                return { table: t.source, state: "catching-up", why: `caught up by one poll ${b.why}${at > now ? ` — its last catch-up failed, tried again after ${clock(at)} UTC` : ""}`,
-                    catchUp: { phase: c?.phase ?? "queued", from: this.polledAt.get(t.source) ?? null, startedAt: c ? iso(c.startedAt) : null, held: held ? held.inserts + held.updates + held.deletes + held.truncates : 0,
-                        retryAt: c === null && at > now ? iso(at) : null }, applied };
-            }
-            if (this.joinedNow.has(t.source) || (s === null && !this.needsCopy(t)))
-                return { table: t.source, state: "streamed", why: null, applied };
-            return { table: t.source, state: "waiting", why: this.notStreamedWhy(t.source), applied };
-        });
+        // each table's part, as `keptOf` says it for EXPLAIN (`streamTable`), with what it applied this run
+        const tables = this.replicatedTables().map((t) => ({ table: t.source, ...this.streamTable(t, now, s), applied: { ...(this.appliedCounts.get(t.source) ?? noCounts()) } }));
         return {
-            slot: r.slot, publication: r.publication, running: s !== null,
+            slot: r.slot, slotWal: this.slotWal?.wal ?? { error: "not read yet: the database did not answer within 3 s" }, publication: r.publication, running: s !== null,
             failure: s === null && this.streamFailure !== null ? { error: this.streamFailure.error, retryAt: iso(this.streamFailure.retryAt) } : null,
             position: formatLsn(position), applied: formatLsn(this.appliedLsn),
             database: "lsn" in db ? { lsn: formatLsn(db.lsn), at: iso(db.at) } : { error: db.error },
@@ -1293,15 +1771,28 @@ export class Sync {
      * wait` asks every second), waited for at most 3 s (the last read is answered meanwhile, with its time). Not the
      * stream's keepalive: that carries the walsender's own read position, not the database's, so it cannot say how far
      * behind the stream is when that matters — while it decodes a backlog. A read that fails is answered as its error.
+     * THE SLOT'S WAL (`SlotWal`) is read on the same connection, at most every SLOT_READ_MS (one row of
+     * pg_replication_slots): what the slot holds on the database's disk, said by `mason status` and sampled by usage.
      */
     async databasePosition() {
         const fresh = this.dbPosition !== null && Date.now() - this.dbPosition.at < 5_000;
         if (!fresh && this.dbPositionRead === null) {
+            const slotDue = this.slotWal === null || Date.now() - this.slotWal.at >= SLOT_READ_MS;
+            const slot = this.replication.slot;
             this.dbPositionRead = (async () => {
                 try {
                     const pg = await PgConnection.connect(this.pgOptions());
                     try {
                         this.dbPosition = { lsn: await currentLsn(pg), at: Date.now() };
+                        if (slotDue) {
+                            // its own failure is the slot's line alone: the position read above stands
+                            try {
+                                this.slotWal = { wal: slotWalOf(await readSlot(pg, slot), slot, Date.now()), at: Date.now() };
+                            }
+                            catch (e) {
+                                this.slotWal = { wal: { error: `the slot could not be read: ${e instanceof Error ? e.message : String(e)}` }, at: Date.now() };
+                            }
+                        }
                     }
                     finally {
                         pg.close();
@@ -1309,7 +1800,10 @@ export class Sync {
                 }
                 catch (e) {
                     // answered as the status's (and the log line's) own words: the position could not be read, and why
-                    this.dbPosition = { error: e instanceof Error ? e.message : String(e), at: Date.now() };
+                    const m = e instanceof Error ? e.message : String(e);
+                    this.dbPosition = { error: m, at: Date.now() };
+                    if (slotDue)
+                        this.slotWal = { wal: { error: `the database could not be reached: ${m}` }, at: Date.now() };
                 }
                 finally {
                     this.dbPositionRead = null;
@@ -1350,10 +1844,10 @@ export class Sync {
             this.refreshStreamed();
             const applied = new Map();
             for (const [name, changes] of batch) {
-                const now = this.streamed.get(name);
-                // decoded in another shape than the copy's now (before it was copied again, a stream left it): what they changed
-                // committed before the new copy's snapshot, so it is in that copy — never written in a shape it does not have
-                if (now === undefined || changes.columns === null || changes.columns.join("\0") !== now.columns.join("\0"))
+                // decoded in a stay that ended (before its table was copied again, or left the stream): what they changed
+                // committed before the next copy's catch-up, so that copy or its catch-up holds it — never written over them, in
+                // a shape the copy may not have, or as an old change after the poll that read a newer one
+                if (this.streamed.get(name)?.stay !== changes.stay)
                     continue;
                 const held = this.held.get(name);
                 if (held !== undefined) {
@@ -1362,7 +1856,7 @@ export class Sync {
                 }
                 applied.set(name, changes);
             }
-            await this.applyChanges(applied, lsn, committedAt);
+            await this.applyChanges(applied, { lsn, committedAt });
         });
     }
     /**
@@ -1373,12 +1867,26 @@ export class Sync {
      * index each of those is a scan of the table's key column, so a batch costs a few scans per table, never one per row. A numeric wider than its copy's DECIMAL is the table's to copy
      * again (`WIDER`), never rounded. A null `lsn` is a piece of a large transaction (src/duck/stream.ts): committed, the
      * position left as it was, so a run that dies before the transaction's last piece applies it again whole. What it
-     * applied is counted by table (`streamStatus`), and the batch's newest commit time kept (null: changes held during a
-     * catch-up, whose time is the batches' that held them).
+     * applied is counted by table (`streamStatus`), and the batch's newest commit time kept.
+     *
+     * `"held"` is THE CHANGES A CATCH-UP HELD, replayed after its poll (`catchUp`): written, and counted, as a batch's are,
+     * but NOT A POSITION of the stream — no `stream_state` row (its LSN and `applied_at` are the batches' that held them),
+     * no table's `synced`, no commit time, and not the stream working again (`streamFailures`): the replay ran on the
+     * writer, whatever the stream is doing (it may be failing).
      */
-    async applyChanges(batch, lsn, committedAt = null) {
+    async applyChanges(batch, from) {
+        const lsn = from === "held" ? null : from.lsn;
+        const committedAt = from === "held" ? null : from.committedAt;
         const w = this.store.writer;
         let source = null;
+        const started = Date.now();
+        // EACH TABLE'S ROWS AFTER THE BATCH, kept current at every batch (it was counted at most every 5 s, so a table's
+        // count missed the batches after one until another came): what its writes added and removed, which DuckDB says
+        // (`rowsChanged`) — never a count(*), which a write by key's deletes make a scan (12 ms on 20 M rows, measured) —
+        // written to the ledger IN the batch's transaction, so a run that dies keeps a count equal to its rows
+        const rowsAfter = new Map();
+        // a batch with a position: its time in the ledger and in this run, ONE value (`Synced`)
+        const position = lsn === null ? null : { lsn, at: new Date().toISOString() };
         await w.run("BEGIN TRANSACTION");
         try {
             for (const [name, changes] of batch) {
@@ -1398,8 +1906,7 @@ export class Sync {
                         throw new Error(`${WIDER} [${name}]: ${c} = ${v}`);
                     return duckValue(v, types.get(c));
                 };
-                if (changes.truncated)
-                    await w.run(`DELETE FROM ${target}`);
+                let delta = changes.truncated ? -Number((await w.run(`DELETE FROM ${target}`)).rowsChanged) : 0;
                 const whole = [];
                 const fetch = [];
                 const gone = [];
@@ -1429,10 +1936,16 @@ export class Sync {
                     source ??= await PgConnection.connect(this.pgOptions());
                     whole.push(...await this.sourceRows(source, t, fetch));
                 }
-                await this.writeByKey(t, target, gone, whole, value);
+                delta += await this.writeByKey(t, target, gone, whole, value);
+                // a copy whose rows the ledger does not know (none should be: its copy counts them) is counted, once
+                const known = this.states.get(name)?.rows ?? null;
+                const rows = known === null ? Number((await w.runAndReadAll(`SELECT count(*) FROM ${target}`)).getRowsJS()[0][0]) : known + delta;
+                if (rows !== known)
+                    await w.run(`UPDATE ${MASON_SCHEMA}.copy_state SET "rows" = $1 WHERE source = $2`, [rows, name]);
+                rowsAfter.set(name, rows);
             }
-            if (lsn !== null)
-                await w.run(`INSERT OR REPLACE INTO ${MASON_SCHEMA}.stream_state VALUES ($1, $2, now())`, [this.replication.slot, formatLsn(lsn)]);
+            if (position !== null)
+                await w.run(`INSERT OR REPLACE INTO ${MASON_SCHEMA}.stream_state VALUES ($1, $2, $3::TIMESTAMPTZ)`, [this.replication.slot, formatLsn(position.lsn), position.at]);
             await w.run("COMMIT");
         }
         catch (e) {
@@ -1444,7 +1957,12 @@ export class Sync {
         }
         if (lsn !== null)
             this.appliedLsn = lsn;
-        this.streamFailures = 0;
+        if (from !== "held")
+            this.streamFailures = 0;
+        // THE STREAM'S FAILURE IS OVER when it applies a batch WITH A POSITION: every table it keeps current is current as of
+        // it. A piece of a large transaction (no position) is not that yet, nor the changes a catch-up held
+        if (lsn !== null)
+            this.recovered("stream", "the stream applies changes again");
         let moved = false;
         for (const [name, changes] of batch) {
             if (!this.tables.has(name))
@@ -1458,17 +1976,30 @@ export class Sync {
         }
         if (moved && committedAt !== null && committedAt.getTime() > 0)
             this.lastBatch = { appliedAt: Date.now(), committedAt: committedAt.getTime() };
-        // the ledger's row counts, for mason status: each changed table counted at most every 5 s
-        for (const name of batch.keys()) {
+        // the rows, as the ledger has them now; with a position, a table the batch wrote is current again (its error, if
+        // any, cleared), and so is every table the stream keeps current whose error was the replication's (the stream's
+        // failure, the preparation's): the position covers each of them, changed in the batch or not
+        for (const [name, rows] of rowsAfter) {
             const st = this.states.get(name);
-            if (st === undefined || Date.now() - (this.countedAt.get(name) ?? 0) < 5_000)
+            if (st === undefined)
                 continue;
-            const t = this.tables.get(name);
-            const rows = Number((await w.runAndReadAll(`SELECT count(*) FROM ${ident(t.schema)}.${ident(t.table)}`)).getRowsJS()[0][0]);
-            this.countedAt.set(name, Date.now());
-            if (rows !== st.rows || st.error !== null)
+            if (st.error !== null && lsn !== null)
                 await this.record({ ...st, rows, error: null });
+            else
+                this.states.set(name, { ...st, rows });
         }
+        if (lsn !== null) {
+            for (const source of this.joinedNow) {
+                const st = this.states.get(source);
+                if (st !== undefined && st.phase === "copied" && st.error?.startsWith("replication: "))
+                    await this.record({ ...st, error: null });
+            }
+        }
+        // every table the stream keeps current is current as of this batch's position (`Synced`); a piece of a large
+        // transaction (no position) and the changes a catch-up held are not a position
+        if (position !== null)
+            for (const source of this.joinedNow)
+                this.synced.set(source, { at: position.at, seconds: (Date.now() - started) / 1000, by: "stream" });
     }
     /**
      * Rows an UPDATE left a large value unchanged in, every one carrying the same columns (`carried`, the key among them):
@@ -1498,11 +2029,13 @@ export class Sync {
      * join against the table's key column (`deleteKeys`), then the rows inserted. No copy has a primary key,
      * so there is no `INSERT OR REPLACE`; a key's row is the source's at the batch's end
      * whatever the table held, as replaying needs (src/duck/stream.ts). A table with no key (none can be added:
-     * src/cli/preflight.ts) is only appended to.
+     * src/cli/preflight.ts) is only appended to. Answers what it did to the table's count: the rows inserted less the rows
+     * its deletes removed (DuckDB's own count of each).
      */
     async writeByKey(t, target, gone, whole, value) {
         if (gone.length === 0 && whole.length === 0)
-            return;
+            return 0;
+        let delta = 0;
         const w = this.store.writer;
         const cols = t.columns.map((c) => c.name);
         const list = cols.map(ident).join(", ");
@@ -1520,15 +2053,16 @@ export class Sync {
             }
             if (whole.length)
                 await w.run(`INSERT INTO ${WRITE_KEYS} SELECT ${keys} FROM ${WRITE_ROWS}`);
-            await deleteKeys(w, t, target, WRITE_KEYS, t.key);
+            delta -= await deleteKeys(w, t, target, WRITE_KEYS, t.key);
             await w.run(`DROP TABLE ${WRITE_KEYS}`);
         }
         if (whole.length) {
             // and its stored JSON paths, computed from the rows' JSON (src/duck/kept.ts)
             const stored = this.kept.stored(t.source, ident);
-            await w.run(`INSERT INTO ${target} (${[list, ...stored.names.map(ident)].join(", ")}) SELECT ${[list, ...stored.values].join(", ")} FROM ${WRITE_ROWS}`);
+            delta += Number((await w.run(`INSERT INTO ${target} (${[list, ...stored.names.map(ident)].join(", ")}) SELECT ${[list, ...stored.values].join(", ")} FROM ${WRITE_ROWS}`)).rowsChanged);
             await w.run(`DROP TABLE ${WRITE_ROWS}`);
         }
+        return delta;
     }
     /** a copied table's columns' DuckDB types, as DESCRIBE spells them (what `duckValue` casts a value's text to) */
     async columnTypes(t, target) {
@@ -1604,15 +2138,18 @@ export class Sync {
      *  whose attach throws is not one: it never detaches */
     async attach() {
         if (!this.attached) {
-            // INSTALL fetches the extension from DuckDB's repository the first time on a machine (then ~/.duckdb/extensions):
-            // offline, the first copy fails here saying so — bundling it is the plan's step 3
+            // the extension ships with Mason (src/duck/extensions.ts): a LOAD from the platform's package, nothing downloaded;
+            // without the package, INSTALL fetches it the first time on a machine (then ~/.duckdb/extensions), said once,
+            // and offline the first copy fails here saying why
             if (!this.loaded) {
+                const x = this.store.extensions;
+                if (!x.shipped)
+                    this.log(`Mason's extensions are not installed with it here: ${x.why}. The first sync on this machine downloads its postgres extension`);
                 try {
-                    await this.store.writer.run("INSTALL postgres; LOAD postgres;");
+                    await this.store.writer.run(loadPostgresSql(x));
                 }
                 catch (e) {
-                    throw new Error(`DuckDB could not load its postgres extension: ${e.message}. The first copy on a machine downloads it from ` +
-                        "DuckDB's extension repository (then ~/.duckdb/extensions): connect to the internet once, and the copy is tried again at the next pass");
+                    throw new Error(extensionFailure(x, e.message));
                 }
                 this.loaded = true;
             }
@@ -1663,40 +2200,76 @@ export class Sync {
             });
             this.snapshots.delete(source);
             this.retries.delete(source);
+            this.due.delete(source);
+            this.lastPollMs.delete(source);
+            this.recordedSync.delete(source);
+            this.switched.delete(source);
             this.retired.delete(source);
             this.copiedAs.delete(source);
             this.copiedColumns.delete(source);
             this.states.delete(source);
-            this.log(`dropped ${source}'s copy: it is no longer added (mason add ${source} copies it again from the source, whole)`);
-        }
-        if (this.tables.size === 0) {
-            await this.rebuildSchema();
-            return;
+            this.synced.delete(source);
+            this.log(`dropped ${source}'s synced data: it is no longer added (mason add ${source} syncs it again from the source, whole)`);
+        }
+        // REPLICATION, as the tables' syncs say: the publication and slot made ready for the replicated tables and the stream
+        // started — or, when none is replicated any more, the slot dropped (verified gone). Its failure is the replicated
+        // tables' alone (not copied, not caught up: `work`), and the pass's, said once the polled tables are polled
+        let replicationFailed = null;
+        let replicationReady = false;
+        for (const source of [...this.unpublished.keys()]) {
+            const t = this.tables.get(source);
+            if (t === undefined || !this.replicated(t))
+                this.unpublished.delete(source);
         }
-        if (this.mode === "replication") {
+        if (this.streams()) {
             try {
                 await this.prepareReplication();
+                replicationReady = true;
             }
             catch (e) {
-                const m = `replication: ${e instanceof Error ? e.message : String(e)}`;
+                // the way out on the table's own line: a failure that names none (a slot the database will not make, a role that
+                // may not replicate) says the line that keeps the tables polled meanwhile — never a bare SQLSTATE's text
+                const said = e instanceof Error ? e.message : String(e);
+                const names = this.replicatedTables().map((t) => t.source);
+                const m = `replication: ${said}${/sync: poll/.test(said) ? "" : ` — ${names.join(", ")} ${names.length === 1 ? "is" : "are"} NOT kept current until it is fixed: ` +
+                    `give ${names.length === 1 ? "its entry" : "their entries"} sync: poll <interval> (poll 5m) in the sources file to poll ${names.length === 1 ? "it" : "them"} instead`}`;
+                this.event({ kind: "stream_failed", table: null, message: m });
+                this.wholeFailure.prepare = m;
                 // a table copied before keeps serving its copy; one never copied is failed, so mason status says why
                 await this.onWriter(async () => {
-                    for (const t of this.tables.values()) {
+                    for (const t of this.replicatedTables()) {
                         const st = this.states.get(t.source);
                         await this.record({ ...st, phase: st.phase === "copied" ? "copied" : "failed", error: m });
                     }
                 });
-                await this.rebuildSchema();
-                throw e;
+                replicationFailed = e;
             }
+            this.recovered("prepare", "the publication and the slot are ready again");
             // the stream starts once the slot is known, and runs from then on whatever the passes and rebuilds do
-            this.startStream();
+            if (replicationReady)
+                this.startStream();
+        }
+        else if (this.replication !== null && (this.slotKnown || this.stream !== null)) {
+            try {
+                await this.retireReplication();
+            }
+            catch (e) {
+                replicationFailed = new Error(`no table's sync is replication now, but replication slot ${this.replication.slot} could not be dropped (it holds the database's WAL; tried again at the next pass): ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        if (this.tables.size === 0) {
+            await this.rebuildSchema();
+            if (replicationFailed !== null)
+                throw replicationFailed;
+            return;
         }
         try {
             await this.onWriter(() => this.attach());
         }
         catch (e) {
             const m = e instanceof Error ? e.message : String(e);
+            this.event({ kind: "source_unreachable", table: null, message: `could not attach the database: ${m}` });
+            this.wholeFailure.attach = m;
             // a table copied before keeps serving its copy (and its place in the catalog): the source being away is its error,
             // not a reason to copy it whole again when the source is back; one never copied is failed
             await this.onWriter(async () => {
@@ -1707,18 +2280,22 @@ export class Sync {
             });
             // the copies serve while the source is away: the catalog lists them (on a fresh start, nothing else has)
             await this.rebuildSchema();
-            throw new Error(`DuckDB could not attach ${this.source.database} on ${this.source.host}:${this.source.port}: ${m}`);
+            throw new Error(`Mason could not attach ${this.source.database} on ${this.source.host}:${this.source.port}: ${m}`);
         }
+        this.recovered("attach", "the database is attached again");
         try {
-            await this.work();
+            await this.work(replicationReady);
         }
         finally {
             await this.onWriter(() => this.detach());
         }
         await this.rebuildSchema();
+        if (replicationFailed !== null)
+            throw replicationFailed;
     }
-    /** a pass's queueing and polls, the source attached */
-    async work() {
+    /** a pass's queueing and polls, the source attached; a replicated table is copied or caught up only once the publication
+     *  carries it and the slot exists (`replicationReady`): its changes are in the stream from before it joins */
+    async work(replicationReady) {
         const started = Date.now();
         // a table never copied (or whose copy failed, or whose copy is out of date) is copied whole, beside the rest: the
         // smallest first (`copyOrder`)
@@ -1731,33 +2308,27 @@ export class Sync {
             // a table the named publication does not carry: copied, nothing would keep it current (prepareReplication)
             if (this.unpublished.has(t.source))
                 continue;
+            if (this.replicated(t) && !replicationReady)
+                continue;
             if (this.mode !== "recopy" && !this.needsCopy(t))
                 continue;
             if (this.queued.has(t.source) || this.rebuildingNow?.source === t.source)
                 continue;
             if (this.states.get(t.source)?.phase === "copied" && this.copiedAs.get(t.source) !== columnsKey(t.columns))
-                this.log(`${t.source}: its columns are not the ones it was copied with: it is copied again`);
+                this.log(`${t.source}: its columns are not the ones it was synced with: it is read again whole`);
             this.enqueue(t.source, { kind: "copy" });
         }
         // a table copied and not yet caught up (a slot new to the copy, or a run that stopped first): its one poll
         for (const source of this.behind.keys()) {
             const t = this.tables.get(source);
             // a failed catch-up waits its turn as a failed copy does (`backOff`); the error it recorded says when
-            if (t !== undefined && !this.needsCopy(t) && (this.retries.get(source)?.at ?? 0) <= Date.now())
+            if (t !== undefined && !this.needsCopy(t) && (this.retries.get(source)?.at ?? 0) <= Date.now() && (!this.replicated(t) || replicationReady))
                 this.enqueue(source, { kind: "catch-up" });
         }
-        // a table whose new columns could not be copied (its copy failed above) is not polled with them
-        const polled = [...this.tables.values()].filter((t) => !this.needsCopy(t));
-        // POLL MODE: a table over the row limit is served as copied and polled only when asked (POLL_ROW_LIMIT, pollNow)
-        const big = this.mode === "poll" ? polled.filter(overPollLimit) : [];
-        for (const t of big.filter((x) => !this.leftOut.has(x.source))) {
-            this.log(`${t.source} (about ${t.rows.toLocaleString("en-US")} rows) is ${OVER_POLL_LIMIT}: it is served as copied, NOT kept current by the poll ` +
-                `(each poll would scan it whole on the database) — mason sync ${t.source} syncs it now; mason start --replication keeps every table current`);
-            this.leftOut.add(t.source);
-        }
-        for (const s of [...this.leftOut].filter((x) => !big.some((t) => t.source === x)))
-            this.leftOut.delete(s);
-        const kept = this.mode === "poll" ? polled.filter((t) => !big.includes(t)) : [];
+        // POLL MODE: the tables due (`dueAt`: a polled one past its interval, one whose sync changed), and not a table whose
+        // new columns could not be copied (its copy failed above): it is not polled with them
+        const now = Date.now();
+        const kept = this.mode !== "recopy" ? [...this.tables.values()].filter((t) => !this.replicated(t) && this.pollable(t) && (this.dueAt(t) ?? Infinity) <= now) : [];
         for (const t of kept) {
             if (this.stopped)
                 break;
@@ -1765,22 +2336,27 @@ export class Sync {
             // or a swap may run between two. A table rebuilt or not yet caught up is not polled (decided on the turn itself);
             // its catch-up polls it
             try {
-                await this.onWriter(async () => { if (this.rebuildingNow?.source !== t.source && !this.behind.has(t.source))
-                    await this.poll(this.writerLane, [t]); });
+                const found = await this.onWriter(async () => this.rebuildingNow?.source !== t.source && !this.behind.has(t.source) ? this.poll(this.writerLane, [t]) : []);
+                for (const f of found)
+                    this.polledNow(t, f.ms);
             }
             catch (e) {
                 if (e instanceof Stopping) {
-                    this.log("poll stopped: Mason is stopping (rolled back; the copies serve as they were)");
+                    this.log("poll stopped: Mason is stopping (rolled back; the synced tables serve as they were)");
                     return;
                 }
+                // tried again after its interval (an `off` table whose sync changed: after the sync's), never at every pass
+                const s = this.syncOf(t);
+                this.due.set(t.source, Date.now() + (s.mode === "poll" ? s.seconds * 1000 : this.intervalMs));
                 // the table serves its copy as it was, and says why it is not current (mason status reads the ledger); the other
                 // tables are polled as ever
-                const m = `the poll failed, and is tried again at the next one (the copy serves as it was): ${e instanceof Error ? e.message : String(e)}`;
+                const m = `the poll failed, and is tried again at the next one (the synced data serves as it was): ${e instanceof Error ? e.message : String(e)}`;
                 this.log(`${t.source}: ${m}`);
+                this.event({ kind: "poll_failed", table: t.source, message: m });
                 await this.onWriter(() => this.record({ ...this.states.get(t.source), error: m }));
             }
         }
-        if (this.mode === "poll")
+        if (this.mode !== "recopy")
             await this.onWriter(() => this.readPolledAt());
         this.lastPassMs = Date.now() - started;
     }
@@ -1843,12 +2419,16 @@ export class Sync {
                 // the next pass says the same of every table, and queues it again
                 const m = `could not attach the database: ${e instanceof Error ? e.message : String(e)}`;
                 this.log(`${r.kind} of ${t.source} waits: ${m}`);
+                this.event({ kind: "source_unreachable", table: t.source, message: `its ${r.kind} waits: ${m}` });
                 const st = this.states.get(t.source);
                 await this.onWriter(() => this.record({ ...st, phase: st.phase === "copied" ? "copied" : "failed", error: m }));
                 return null;
             }
             if (r.kind === "copy")
                 await this.copy(t);
+            // the whole read is over, whatever comes next: what the table is said to be doing from here (`notStreamedReason`,
+            // `refuseRebuilding`, `state`'s `rebuilding`)
+            this.rebuildingNow = { source: t.source, kind: "catch-up" };
             // a table its copy left behind (`swap`), or one marked so before: one poll, unless a copy of it comes first — the
             // table as it is added NOW, which may have changed while it was copied (then copied again at once: `followUp`)
             const now = this.tables.get(t.source);
@@ -1873,11 +2453,11 @@ export class Sync {
      * copy (the copy's snapshot), or a slot new to the copy — on the rebuilds'
      * connection, so the stream and the other tables' polls go on meanwhile. In replication mode the stream holds the
      * table's changes from before the poll's snapshot and applies them after it (src/duck/stream.ts "why replaying is
-     * safe"). A table over POLL_ROW_LIMIT is caught up too: the one scan its rebuild costs, not the periodic poll.
+     * safe"). A table whose sync is `off` is caught up too: the one scan its rebuild costs, then nothing until asked.
      */
     async catchUp(t) {
         const mark = this.behind.get(t.source);
-        const replication = this.mode === "replication";
+        const replication = this.replicated(t);
         // J: from the writer's turn on, every batch's changes of this table are held (`applyStreamed`)
         if (replication)
             await this.onWriter(async () => { if (!this.held.has(t.source))
@@ -1890,8 +2470,9 @@ export class Sync {
         // mason status — and is caught up again then: what was held is read again by that poll (still behind, nothing lost)
         const failed = (what, e) => {
             const when = this.backOff(t.source, Date.now() - started);
-            const m = `${what} (the copy serves as it was; it is caught up by one poll again after ${when}): ${e instanceof Error ? e.message : String(e)}`;
+            const m = `${what} (the synced data serves as it was; it is caught up by one poll again after ${when}): ${e instanceof Error ? e.message : String(e)}`;
             this.log(`${t.source}: ${m}`);
+            this.event({ kind: "catch_up_failed", table: t.source, message: m });
             return this.onWriter(() => this.record({ ...this.states.get(t.source), error: m }));
         };
         // the catch-up's poll reads the columns the copy holds (`asCopied`)
@@ -1914,6 +2495,7 @@ export class Sync {
             await release();
             return "copy again";
         }
+        this.polledNow(t, found[0].ms);
         let saidJoin = false;
         if (this.catchingUp?.source === t.source)
             this.catchingUp.phase = "applying";
@@ -1924,7 +2506,7 @@ export class Sync {
             this.held.delete(t.source);
             if (held !== undefined && (held.truncated || held.keys.size > 0)) {
                 try {
-                    await this.applyChanges(new Map([[t.source, held]]), this.appliedLsn);
+                    await this.applyChanges(new Map([[t.source, held]]), "held");
                 }
                 catch (e) {
                     const m = e instanceof Error ? e.message : String(e);
@@ -1932,7 +2514,7 @@ export class Sync {
                     // a numeric wider than its copy: copied again (`needsCopy`), and caught up after that copy
                     if (m.includes(`${WIDER} [${t.source}]`)) {
                         this.snapshots.delete(t.source);
-                        this.log(`${t.source}: the changes the stream held during its catch-up could not be applied: it is copied again, wider (${m})`);
+                        this.log(`${t.source}: the changes the stream held during its catch-up could not be applied: it is read again whole, wider (${m})`);
                         return "copy again";
                     }
                     heldFailure = e;
@@ -1961,9 +2543,10 @@ export class Sync {
             return joined || null;
         if (saidJoin)
             return null;
+        const s = this.syncOf(t);
         const tail = replication ? (this.behind.has(t.source) ? "it is caught up again first (the slot was made again meanwhile)" : "the stream carries what follows once it runs again")
-            : this.mode === "poll" && overPollLimit(t) ? `it is ${OVER_POLL_LIMIT}, so that was one scan for its rebuild, not the periodic poll: served as of now, mason sync ${t.source} syncs it again`
-                : "the poll keeps it current";
+            : s.mode === "off" ? `its sync is off, so it is served as of now: mason sync ${t.source} syncs it again`
+                : `the poll keeps it current (${syncWords(s)})`;
         this.log(`caught up ${t.source} by one poll ${mark.why}: ${tail}`);
         return null;
     }
@@ -1977,12 +2560,15 @@ export class Sync {
     async swap(t, side, o) {
         const w = this.store.writer;
         const target = `${ident(t.schema)}.${ident(t.table)}`;
+        // the copy's time in the ledger and in this run, ONE value, and before `copied_at`, recorded after the swap
+        // (`readSynced`: a copy recorded at or after its polled_at was last brought current by that copy)
+        const at = new Date().toISOString();
         await w.run("BEGIN TRANSACTION");
         try {
             await w.run(`DROP TABLE IF EXISTS ${target}`);
             await w.run(`ALTER TABLE ${side} RENAME TO ${ident(t.table)}`);
             if (o.snapshot !== null)
-                await w.run(`INSERT OR REPLACE INTO ${MASON_SCHEMA}.poll_state VALUES (${literal(t.source)}, ${literal(o.snapshot)}, now())`);
+                await w.run(this.pollStateSql(t, o.snapshot, at));
             if (o.behind !== null)
                 await w.run(`INSERT OR REPLACE INTO ${MASON_SCHEMA}.catch_up VALUES (${literal(t.source)}, ${literal(o.behind)}, now())`);
             // the copy is whole: nothing of it is left to continue
@@ -1998,19 +2584,33 @@ export class Sync {
         }
         // the copy's view of its visible columns, made again (its own transaction: DuckDB writes one database a transaction)
         await this.kept.swapped(t.source);
-        if (o.snapshot !== null)
+        if (o.snapshot !== null) {
             this.snapshots.set(t.source, o.snapshot);
+            this.recordedSync.set(t.source, syncText(this.syncOf(t)));
+            this.switched.delete(t.source);
+            this.due.delete(t.source);
+            // synced as of its copy, said at once (a review finding: until the next pass re-read the ledger, a table just
+            // copied said "never synced"), and the value the ledger holds, so that read moves nothing
+            this.polledAt.set(t.source, at);
+        }
         // the columns this copy holds, from its swap on: what every write to it is shaped by (`asCopied`)
         this.copiedColumns.set(t.source, [...t.columns]);
         if (o.behind !== null) {
             this.behind.set(t.source, { why: o.behind });
-            if (this.mode === "replication")
+            if (this.replicated(t))
                 this.held.set(t.source, noChanges());
         }
         this.retired.delete(t.source);
         this.duckTypes.delete(t.source);
+        // a new copy, a new stay, whatever the columns: what the stream decoded before this moment is not for it
+        this.streamed.delete(t.source);
         this.refreshStreamed();
     }
+    /** a table's watermark, the time and the sync it is polled or copied under (`recordedSync`): ONE row of `_mason.poll_state`.
+     *  `at` is the caller's, an ISO instant (`toISOString`, as `copied_at`), the very value it remembers (`polledAt`) */
+    pollStateSql(t, snapshot, at) {
+        return `INSERT OR REPLACE INTO ${MASON_SCHEMA}.poll_state (source, snapshot, polled_at, sync) VALUES (${literal(t.source)}, ${literal(snapshot)}, ${literal(at)}::TIMESTAMPTZ, ${literal(syncText(this.syncOf(t)))})`;
+    }
     /**
      * One poll of the tables given (the passes and `pollNow` give one at a time), in ONE DuckDB transaction over ONE
      * source snapshot (the module's header), on the lane's connection — the writer's, or the rebuilds' for a catch-up —
@@ -2048,12 +2648,12 @@ export class Sync {
         // (`adds`: the keys a stage still to be written adds to DuckDB's count)
         const reconcile = async (t, target, from, adds = 0n) => {
             const c0 = Date.now();
-            doing = `${t.source}: counting its rows on the source and in DuckDB`;
+            doing = `${t.source}: counting its rows on the source and in the synced table`;
             const counts = (await w.runAndReadAll(`SELECT (SELECT count FROM ${pq(`SELECT count(*) AS count FROM ${from}`)}), (SELECT count(*) FROM ${target})`)).getRowsJS()[0];
             const countMs = Date.now() - c0;
             let deleted = 0;
             if (counts[0] !== counts[1] + adds) {
-                doing = `${t.source}: deleting the keys the source no longer holds (its keys anti-joined with DuckDB's)`;
+                doing = `${t.source}: deleting the keys the source no longer holds (its keys anti-joined with the synced table's)`;
                 const on = t.key.map((k) => `t.${ident(k)} = k.${ident(k)}`).join(" AND ");
                 const gone = await w.run(`DELETE FROM ${target} WHERE rowid IN (SELECT t.rowid FROM ${target} t ANTI JOIN ${pq(`SELECT ${t.key.map(pgIdent).join(", ")} FROM ${from}`)} k ON ${on})`);
                 deleted = Number(gone.rowsChanged);
@@ -2061,6 +2661,9 @@ export class Sync {
             return { rows: Number(counts[0]), deleted, countMs };
         };
         let snapshot = "";
+        // THE POLL'S TIME, ONE VALUE: taken before its snapshot, so `syncedAt` never says more than the rows hold, written
+        // with its watermark (`pollStateSql`) and remembered as written once that commits (`committed`, `polledAt`)
+        const polledAt = new Date().toISOString();
         await w.run("BEGIN TRANSACTION");
         try {
             await this.interruptible(lane, async () => {
@@ -2086,7 +2689,7 @@ export class Sync {
                         `${pq(`SELECT ${pgCols} FROM ${from} WHERE ${xmin8Sql(xmax)} >= ${watermark}`)}) AS polled(${t.columns.map((_, i) => `c${i}`).join(", ")})`)).rowsChanged);
                     if (staged > POLL_PIECE_ROWS) {
                         const c1 = Date.now();
-                        doing = `${t.source}: counting the keys its ${staged} changed row(s) add to DuckDB (the stage anti-joined with DuckDB's keys)`;
+                        doing = `${t.source}: counting the keys its ${staged} changed row(s) add to the synced table (the stage anti-joined with its keys)`;
                         const on = t.key.map((k) => `s.${ident(`c${t.columns.findIndex((c) => c.name === k)}`)} = t.${ident(k)}`).join(" AND ");
                         const adds = (await w.runAndReadAll(`SELECT count(*) FROM ${stage} s ANTI JOIN ${target} t ON ${on}`)).getRowsJS()[0][0];
                         const { rows, deleted, countMs } = await reconcile(t, target, from, adds);
@@ -2099,7 +2702,7 @@ export class Sync {
                     await writeStaged(w, t, target, stage, "", this.kept);
                     const c1 = Date.now();
                     const { rows, deleted, countMs } = await reconcile(t, target, from);
-                    await w.run(`INSERT OR REPLACE INTO ${MASON_SCHEMA}.poll_state VALUES (${literal(t.source)}, ${literal(snapshot)}, now())`);
+                    await w.run(this.pollStateSql(t, snapshot, polledAt));
                     await w.run(`DROP TABLE ${stage}`);
                     timed.push(`${t.source} ${staged} changed in ${c1 - c0} ms, counted in ${countMs} ms${deleted ? `, ${deleted} deleted in ${Date.now() - c1 - countMs} ms` : ""}`);
                     found.push({ table: t.source, changed: staged, deleted, rows, ms: Date.now() - c0 });
@@ -2122,22 +2725,25 @@ export class Sync {
             // matched against the tables' own names (a name may hold a space)
             const wider = e instanceof Error ? tables.find((t) => e.message.includes(`${WIDER} [${t.source}]`))?.source : undefined;
             if (wider !== undefined && this.snapshots.delete(wider)) {
-                this.log(`poll: ${wider} has a numeric value wider than its copy's DECIMAL: it is copied again at the next pass`);
+                this.log(`poll: ${wider} has a numeric value wider than its synced DECIMAL column: it is read again whole at the next pass`);
                 return [];
             }
             throw named(e);
         }
         // committed: the watermarks and the row counts move together (a pieced table's with its last piece)
-        const committed = async (source, rows) => {
+        // and the table's last sync (`Synced`): the poll's time as the ledger now holds it, and how long THIS table's poll took
+        const committed = async (source, rows, ms) => {
+            this.polledAt.set(source, polledAt);
             const st = this.states.get(source);
             if (st.rows !== rows || st.error !== null)
                 await this.record({ ...st, rows, error: null }, undefined, w);
             this.snapshots.set(source, snapshot);
+            this.synced.set(source, { at: polledAt, seconds: ms / 1000, by: lane === this.writerLane ? "poll" : "catch-up" });
         };
         try {
             for (const [source, rows] of pending)
                 if (!pieced.some((p) => p.t.source === source))
-                    await committed(source, rows);
+                    await committed(source, rows, found.find((f) => f.table === source)?.ms ?? 0);
             this.log(`poll: ${timed.join("; ")}`);
             for (const { t, target, stage, staged, deleted, started } of pieced) {
                 const p0 = Date.now();
@@ -2148,7 +2754,7 @@ export class Sync {
                         doing = `${t.source}: writing piece ${i + 1} of ${n} of its ${staged} changed row(s) by key`;
                         await this.interruptible(lane, () => writeStaged(w, t, target, stage, ` WHERE rowid >= ${i * POLL_PIECE_ROWS} AND rowid < ${(i + 1) * POLL_PIECE_ROWS}`, this.kept));
                         if (i === n - 1) {
-                            await w.run(`INSERT OR REPLACE INTO ${MASON_SCHEMA}.poll_state VALUES (${literal(t.source)}, ${literal(snapshot)}, now())`);
+                            await w.run(this.pollStateSql(t, snapshot, polledAt));
                         }
                         doing = `${t.source}: committing piece ${i + 1} of ${n}`;
                         await w.run("COMMIT");
@@ -2159,7 +2765,7 @@ export class Sync {
                     }
                 }
                 const rows = pending.get(t.source);
-                await committed(t.source, rows);
+                await committed(t.source, rows, Date.now() - started);
                 found.push({ table: t.source, changed: staged, deleted, rows, ms: Date.now() - started });
                 this.log(`poll: ${t.source}: ${staged.toLocaleString("en-US")} changed row(s), written in ${n} pieces in ${Date.now() - p0} ms`);
             }
@@ -2232,10 +2838,10 @@ export class Sync {
             if (resumed === null) {
                 // the stream (or the other tables' polls) goes on: the slot holds no WAL for this copy, and the table joins once
                 // caught up from the copy's snapshot
-                const beside = this.mode === "replication" ? "beside the stream, which goes on keeping the other tables current: it is streamed once caught up by one poll from the copy's snapshot"
-                    : this.mode === "poll" ? "beside the other tables' polls: it is caught up by one poll from the copy's snapshot once copied" : "beside the other tables";
-                const again = this.retired.has(t.source) ? `, again (its copy is ${RETIRED_LAYOUT})` : "";
-                this.log(`copying ${t.source}${again}: ${t.rows === null ? "rows unknown" : `about ${t.rows} row(s)`}, ${t.bytes} source bytes, ${beside}`);
+                const beside = this.replicated(t) ? "beside the stream, which goes on keeping the other tables current: it is streamed once caught up by one poll from the snapshot it was read at"
+                    : this.mode !== "recopy" ? "beside the other tables' polls: once read, it is caught up by one poll from the snapshot it was read at" : "beside the other tables";
+                const again = this.retired.has(t.source) ? `, again (it is ${RETIRED_LAYOUT})` : "";
+                this.log(`syncing ${t.source}${again}: ${t.rows === null ? "rows unknown" : `about ${t.rows} row(s)`}, ${t.bytes} source bytes, ${beside}`);
             }
             let read;
             try {
@@ -2245,7 +2851,7 @@ export class Sync {
                 if (!(e instanceof StartOver))
                     throw e;
                 // once: a second reason to start over is the copy's failure
-                this.log(`starting the copy of ${t.source} over, from its first page: ${e.message}`);
+                this.log(`starting the sync of ${t.source} over, from its first page: ${e.message}`);
                 kept = await this.forgetCopy(t, side);
                 read = await this.readChunks(t, side, null, (p) => { kept = p; });
             }
@@ -2257,7 +2863,7 @@ export class Sync {
                 const [rows, keys] = (await w.runAndReadAll(`SELECT count(*), count(DISTINCT (${t.key.map(ident).join(", ")})) FROM ${side}`)).getRowsJS()[0];
                 if (rows !== keys) {
                     kept = await this.forgetCopy(t, side);
-                    throw new Error(`its copy holds ${rows} rows but ${keys} distinct keys (Mason bug: report it, with mason logs): it was not swapped in, and is copied again from its first page`);
+                    throw new Error(`its synced data holds ${rows} rows but ${keys} distinct keys (Mason bug: report it, with mason logs): it was not swapped in, and is read again from its first page`);
                 }
             }
             // its stored JSON paths filled, so the table swapped in has every one whole (src/duck/kept.ts fillSide)
@@ -2265,14 +2871,17 @@ export class Sync {
             // THE SWAP, on the writer's turn: one transaction, between two of the stream's or the polls'. It carries the copy's
             // watermark (its first snapshot), removes its progress, and leaves the table behind until its catch-up (none in
             // recopy mode: no poll)
-            await this.onWriter(() => this.swap(t, side, { snapshot: p.snapshot, behind: p.snapshot === null ? null : "after its copy" }));
+            await this.onWriter(() => this.swap(t, side, { snapshot: p.snapshot, behind: p.snapshot === null ? null : "after its whole read" }));
             this.copyLive.delete(t.source);
             kept = null;
             this.retries.delete(t.source);
             const seconds = (Date.now() - started) / 1000;
-            this.log(`copied ${t.source}: ${p.rows} row(s), ${t.bytes} source bytes, in ${seconds.toFixed(2)} s (read in ${read.seconds.toFixed(2)} s` +
+            this.log(`synced ${t.source}: ${p.rows} row(s), ${t.bytes} source bytes, in ${seconds.toFixed(2)} s (read in ${read.seconds.toFixed(2)} s` +
                 `${resumed === null ? "" : `, resumed at page ${readThrough(resumed.done) ?? p.pages} of ${resumed.pages}${pastPages(resumed.done)} with ${resumed.rows} row(s) in`}), stored as the source's scan delivered them, with no index`);
-            await this.record({ source: t.source, phase: "copied", rows: p.rows, bytes: t.bytes, seconds, copiedAt: new Date().toISOString(), error: null }, t.columns, w);
+            const copiedAt = new Date().toISOString();
+            await this.record({ source: t.source, phase: "copied", rows: p.rows, bytes: t.bytes, seconds, copiedAt, error: null }, t.columns, w);
+            this.synced.set(t.source, { at: copiedAt, seconds, by: "copy" });
+            this.event({ kind: "copied", table: t.source, message: `synced: ${p.rows.toLocaleString("en-US")} row(s) in ${seconds.toFixed(2)} s` });
             this.copiedAs.set(t.source, columnsKey(t.columns));
             // in the catalog at once: a pass's other copies may take hours
             await this.rebuildSchema();
@@ -2288,7 +2897,7 @@ export class Sync {
                     k = await this.forgetCopy(t, side);
                 }
                 catch (f) {
-                    this.log(`the copy of ${t.source} could not drop what it began (its next attempt continues it): ${f instanceof Error ? f.message : String(f)}`);
+                    this.log(`the sync of ${t.source} could not drop what it began (its next attempt continues it): ${f instanceof Error ? f.message : String(f)}`);
                 }
             }
             const through = k === null ? null : readThrough(k.done);
@@ -2296,7 +2905,7 @@ export class Sync {
             if (e instanceof Stopping) {
                 // the chunks in flight rolled back: a table never copied continues at the next start, one copied before serves its
                 // copy as it was meanwhile
-                this.log(`copy of ${t.source} stopped: Mason is stopping (${where === null ? "rolled back; it is copied at the next start" : `the chunks in flight rolled back; it continues ${where} at the next start`})`);
+                this.log(`sync of ${t.source} stopped: Mason is stopping (${where === null ? "rolled back; it is synced at the next start" : `the chunks in flight rolled back; it continues ${where} at the next start`})`);
                 if (first)
                     await this.record({ ...was, phase: "waiting", error: null }, undefined, w);
                 return;
@@ -2310,11 +2919,24 @@ export class Sync {
             this.retries.set(t.source, { failures, at });
             const when = `tried again after ${new Date(at).toISOString().slice(11, 16)} UTC (failure ${failures} in a row), or at once when Mason starts again or its columns or key change` +
                 (where === null ? "" : `; it continues ${where}`);
-            this.log(`copy of ${t.source} failed: ${m}; ${when}`);
+            this.log(`sync of ${t.source} failed: ${m}; ${when}`);
+            this.event({ kind: "copy_failed", table: t.source, message: `${m}; ${when}` });
             // a table that was copied keeps serving its last copy; one never copied is failed
             await this.record({ ...this.states.get(t.source), phase: first ? "failed" : "copied", error: `${m} (${when})` }, undefined, w);
         }
     }
+    /** Where the copy's file is, the bytes free there, and what the copies running are projected to add (`DiskStatus`). */
+    diskStatus() {
+        const dir = path.dirname(this.store.file);
+        const needed = [...this.copyLive.values()].map((l) => l.diskNeeded).filter((n) => n !== null);
+        const projectedBytes = needed.length ? Math.round(needed.reduce((a, b) => a + b, 0)) : null;
+        try {
+            return { path: dir, freeBytes: this.diskFree(dir), projectedBytes };
+        }
+        catch (e) {
+            return { path: dir, freeBytes: null, projectedBytes, error: `the free space where the synced data is could not be read: ${e instanceof Error ? e.message : String(e)}` };
+        }
+    }
     /** The DuckDB file's bytes with its write-ahead log's (what a copy adds lands in the log until a checkpoint). */
     fileBytes() {
         let n = 0;
@@ -2329,16 +2951,18 @@ export class Sync {
         }
         return n;
     }
-    /** Why the copy of `t` must stop now — what its pages left would add is more than the disk has free — or null. */
-    diskShort(t, p, disk) {
+    /** Why the copy of `t` must stop now — what its pages left would add is more than the disk has free — or null. What
+     *  it projects is kept on the copy's `live` (`diskStatus` says it). */
+    diskShort(t, p, disk, live) {
         const bytesNow = this.fileBytes();
         const projected = copyDiskProjection({ pages: p.pages, done: p.done, doneAtStart: disk.doneAtStart, bytesAtStart: disk.bytesAtStart, bytesNow });
+        live.diskNeeded = projected?.needed ?? null;
         if (projected === null)
             return null;
         const free = this.diskFree(path.dirname(this.store.file));
         if (projected.needed <= free)
             return null;
-        return `the copy of ${t.source} would need about ${humanBytes(projected.needed)} more on disk than is free (${humanBytes(free)} free where ${this.store.file} is; ` +
+        return `the sync of ${t.source} would need about ${humanBytes(projected.needed)} more on disk than is free (${humanBytes(free)} free where ${this.store.file} is; ` +
             `${pagesRead(p.done, p.pages)} of ${p.pages} pages read, ${humanBytes(bytesNow - disk.bytesAtStart)} added): free some disk, mason remove ${t.source}, or mason add ${t.source} --columns … with fewer columns`;
     }
     /**
@@ -2417,7 +3041,7 @@ export class Sync {
             const pagesDone = pagesRead(p.done, p.pages);
             const live = { pages: p.pages, chunksDone: p.done.length, pagesDone, rowsDone: p.rows, untaken: gapPages(gaps, p.pages),
                 chunkPages: nextChunkPages(ceiling, null, this.copyChunkSeconds), readers, reading: [], rate: null,
-                rowsPerPage: pagesDone > 0 ? p.rows / pagesDone : t.rows !== null && t.rows > 0 && p.pages > 0 ? t.rows / p.pages : null };
+                rowsPerPage: pagesDone > 0 ? p.rows / pagesDone : t.rows !== null && t.rows > 0 && p.pages > 0 ? t.rows / p.pages : null, diskNeeded: null };
             this.copyLive.set(t.source, live);
             for (let i = 1; i < readers; i++) {
                 const lane = { conn: await this.store.instance.connect(), inFlight: false };
@@ -2472,7 +3096,7 @@ export class Sync {
                             const node = Number((await c.runAndReadAll(`SELECT * FROM ${pq(`SELECT pg_relation_filenode(${pgLiteral(pgFrom)}::regclass)::bigint`)}`)).getRowsJS()[0][0]);
                             filenode ??= node;
                             if (node !== filenode) {
-                                throw new StartOver(`the source rewrote ${t.source} since its copy began (its file changed: a VACUUM FULL, CLUSTER, TRUNCATE or column type change), so its rows moved between pages`);
+                                throw new StartOver(`the source rewrote ${t.source} since its sync began (its file changed: a VACUUM FULL, CLUSTER, TRUNCATE or column type change), so its rows moved between pages`);
                             }
                             const n = Number(r.rowsChanged);
                             await this.onChunk?.({ ...told, rows: n, phase: "read" });
@@ -2514,7 +3138,7 @@ export class Sync {
                                 await c.run("ROLLBACK");
                             }
                             catch (r) {
-                                this.log(`a chunk of ${t.source}'s copy could not be rolled back after it failed (its connection is closed with the copy): ${r instanceof Error ? r.message : String(r)}`);
+                                this.log(`a chunk of ${t.source}'s sync could not be rolled back after it failed (its connection is closed with the sync): ${r instanceof Error ? r.message : String(r)}`);
                             }
                         }
                         fail(e);
@@ -2522,14 +3146,14 @@ export class Sync {
                     }
                     // STOPPED BEFORE THE DISK FILLS: the chunks committed are kept, the copy fails with the way out and is tried
                     // again as a failed copy is (freed disk is used at the retry, or at once at the next start)
-                    const short = recopy ? null : this.diskShort(t, p, disk);
+                    const short = recopy ? null : this.diskShort(t, p, disk, live);
                     if (short !== null) {
                         fail(new Error(short));
                         return;
                     }
                     const at = readThrough(p.done);
                     if (Date.now() - lineAt >= 60_000 && at !== null) {
-                        this.log(`copying ${t.source}: page ${at} of ${p.pages}${pastPages(p.done)}, ${p.rows.toLocaleString("en-US")} row(s) in; ${chunks} chunk(s) in the last minute on ${readers} reader(s), ` +
+                        this.log(`syncing ${t.source}: page ${at} of ${p.pages}${pastPages(p.done)}, ${p.rows.toLocaleString("en-US")} row(s) in; ${chunks} chunk(s) in the last minute on ${readers} reader(s), ` +
                             `${(chunkMs / chunks / 1000).toFixed(1)} s each` + (rate === null ? "" : `; a reader reads ~${Math.round(rate.rowsPerSecond).toLocaleString("en-US")} rows/s ` +
                             `(${humanBytes(rate.bytesPerSecond)}/s of the table's pages), so the next chunk is ${live.chunkPages} page(s), ~${this.copyChunkSeconds} s (MASON_COPY_CHUNK_SECONDS; at most ${ceiling})`));
                         lineAt = Date.now();
@@ -2587,7 +3211,7 @@ export class Sync {
         const ceiling = chunkPages(pages, t.rows, this.copyChunkRows);
         const firstSize = nextChunkPages(ceiling, null, this.copyChunkSeconds);
         const readers = this.mode === "recopy" ? 1 : Math.min(this.copyParallel, Math.max(1, Math.ceil(pages / firstSize)));
-        this.log(`copying ${t.source}${snapshot === null ? "" : ` as of the source's snapshot ${snapshot}: what commits after it is caught up by one poll once copied`}; ` +
+        this.log(`syncing ${t.source}${snapshot === null ? "" : ` as of the source's snapshot ${snapshot}: what commits after it is caught up by one poll once read`}; ` +
             `${pages} page(s) in chunks sized to ~${this.copyChunkSeconds} s of reading each at the rate measured here (MASON_COPY_CHUNK_SECONDS; at most ${ceiling} page(s)), ` +
             `the first of ${firstSize} page(s) to measure it, ${readers === 1 ? "one at a time" : `${readers} at a time (MASON_COPY_PARALLEL), each a backend on the database`}`);
         return { snapshot, columns: columnsKey(t.columns), exact, filenode: null, pages, done: [], rows: 0 };
@@ -2613,7 +3237,7 @@ export class Sync {
         const row = r[0];
         if (row === undefined || row[0] === null || row[1] !== columnsKey(t.columns) || !there) {
             if (row !== undefined)
-                this.log(`starting the copy of ${t.source} over, from its first page: ${!there ? "the table it was filling is gone" : row[0] === null ? "it was begun as a recopy" : "its columns are not the ones its copy was begun with"}`);
+                this.log(`starting the sync of ${t.source} over, from its first page: ${!there ? "the table it was filling is gone" : row[0] === null ? "it was begun as a recopy" : "its columns are not the ones its sync was begun with"}`);
             return this.forgetCopy(t, side);
         }
         const chunks = (await w.runAndReadAll(`SELECT first_page, end_page, "rows", filenode FROM ${MASON_SCHEMA}.copy_chunks WHERE source = ${literal(t.source)} ORDER BY first_page`)).getRowsJS();
@@ -2621,8 +3245,8 @@ export class Sync {
         const rows = chunks.reduce((n, c) => n + Number(c[2]), 0);
         const p = { snapshot: row[0], columns: row[1], exact: new Map(JSON.parse(row[2])), filenode: chunks.length ? Number(chunks[0][3]) : null, pages: Number(row[3]), done, rows };
         const at = readThrough(done);
-        this.log(at === null ? `resuming the copy of ${t.source} with every page read (${rows} row(s) in): its swap is next`
-            : `resuming the copy of ${t.source} at page ${at} of ${p.pages}${pastPages(done)}, ${rows} row(s) in, held to its first snapshot ${p.snapshot}: the pages read before are not read again`);
+        this.log(at === null ? `resuming the sync of ${t.source} with every page read (${rows} row(s) in): its swap is next`
+            : `resuming the sync of ${t.source} at page ${at} of ${p.pages}${pastPages(done)}, ${rows} row(s) in, held to its first snapshot ${p.snapshot}: the pages read before are not read again`);
         const now = this.states.get(t.source);
         if (now !== undefined && now.phase === "copying")
             this.states.set(t.source, { ...now, rowsSoFar: rows, rowsEstimate: t.rows });
@@ -2647,7 +3271,7 @@ export class Sync {
                 await w.run(`ALTER TABLE ${MASON_SCHEMA}.copy_progress DROP COLUMN IF EXISTS ${ident(gone)}`);
             await w.run("COMMIT");
             if (moved > 0)
-                this.log(`${moved} copy(ies) in progress were begun by a Mason that read one chunk at a time: each continues where it was`);
+                this.log(`${moved} sync(s) in progress were begun by a Mason that read one chunk at a time: each continues where it was`);
         }
         catch (e) {
             await w.run("ROLLBACK");
@@ -2675,7 +3299,7 @@ export class Sync {
             if (this.states.get(source)?.phase !== "copied")
                 continue;
             this.retired.add(source);
-            this.log(`${source}: its copy is ${RETIRED_LAYOUT} — its rows are sorted on disk, and only the source has them in its own order, so it is read again whole; the copy serves as it was until then`);
+            this.log(`${source}: it is ${RETIRED_LAYOUT} — its rows are sorted on disk, and only the source has them in its own order, so it is read again whole; its synced data serves as it was until then`);
         }
     }
     /** what a copy of the retired layout left beside the file (in that layout a copy was staged in a file of its own,
@@ -2684,7 +3308,7 @@ export class Sync {
         const dir = path.dirname(this.store.file), base = `${path.basename(this.store.file)}.stage-`;
         for (const f of fs.readdirSync(dir).filter((x) => x.startsWith(base))) {
             fs.rmSync(path.join(dir, f), { recursive: true, force: true });
-            this.log(`removed ${f}: a copy's stage, from an older Mason (a copy now reads the source once, straight into its table)`);
+            this.log(`removed ${f}: a sync's stage, from an older Mason (a sync now reads the source once, straight into its table)`);
         }
     }
     /** The table's numerics the extension would read as doubles, each with the DECIMAL(38, s) scale that holds every value
@@ -2708,11 +3332,11 @@ export class Sync {
             const scale = declared[1] !== undefined ? used ?? 0 : maxScale ?? 0;
             const width = (digits ?? 1) + scale;
             if ((special ?? 0) > 0) {
-                this.log(`${t.source}.${c.name}: ${special} value(s) NaN or Infinity, which DuckDB's DECIMAL cannot hold: copied as a double`);
+                this.log(`${t.source}.${c.name}: ${special} value(s) NaN or Infinity, which the synced table's DECIMAL cannot hold: synced as a double`);
                 return;
             }
             if (scale > 38 || width > 38) {
-                this.log(`${t.source}.${c.name}: values of ${digits ?? 1} digit(s) and ${scale} decimal(s) do not fit DuckDB's DECIMAL(38): copied as a double (15 significant digits)`);
+                this.log(`${t.source}.${c.name}: values of ${digits ?? 1} digit(s) and ${scale} decimal(s) do not fit the synced table's DECIMAL(38): synced as a double (15 significant digits)`);
                 return;
             }
             if (declared[1] === undefined && minScale !== null && minScale !== maxScale)
@@ -2732,6 +3356,12 @@ export class Sync {
      *  writer only on its turn: a statement on a connection lands inside the transaction open there). The table's row is
      *  that flow's alone while it writes it (a rebuild's table is not polled or streamed until caught up) */
     async record(s, columns, c = this.store.writer) {
+        // A COPY CURRENT AGAIN after its poll, catch-up or stream failed (its error cleared by the flow that keeps it current,
+        // never by a copy of it: that is its own `copied` event) — the one place an error is cleared, so the one place said
+        const was = this.states.get(s.source);
+        if (was !== undefined && was.error !== null && s.error === null && was.phase === "copied" && s.phase === "copied" && was.copiedAt === s.copiedAt) {
+            this.event({ kind: "recovered", table: s.source, message: `current again (it had failed: ${was.error.split("\n")[0]})` });
+        }
         this.states.set(s.source, s);
         const v = (x) => x === null ? "NULL" : typeof x === "number" ? String(x) : literal(x);
         const sql = `INSERT OR REPLACE INTO ${MASON_SCHEMA}.copy_state (source, phase, "rows", bytes, seconds, copied_at, error, columns) VALUES (${literal(s.source)}, ${literal(s.phase)}, ${v(s.rows)}, ${v(s.bytes)}, ${v(s.seconds)}, ` +
@@ -2741,7 +3371,7 @@ export class Sync {
             await c.run(sql);
         }
         catch (e) {
-            this.log(`recording ${s.source}'s copy state failed: ${e instanceof Error ? e.message : String(e)}`);
+            this.log(`recording ${s.source}'s sync state failed: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
     /** the catalog rebuilt (`schemaBuilt`), after any rebuild already under way */
@@ -2765,8 +3395,10 @@ export class Sync {
             const types = await c.prepare(`SELECT * FROM ${ident(t.schema)}.${ident(t.table)} LIMIT 0`);
             const duckTypes = new Map(Array.from({ length: types.columnCount }, (_, i) => [types.columnName(i), types.columnType(i)]));
             types.destroySync();
-            // the column's constraints and default as the source has them NOW (its catalog is read every poll): what the copy
-            // recorded describes its types, which a change of recopies
+            // the column's constraints and default — and below the table's keys and unique indexes — as the source had them
+            // when the tables were last set (`setTables`: at mason start, and at mason add / remove; the run's 10-second
+            // catalog read reaches the commands' facts, not this): what the copy recorded describes its types, which a
+            // change of recopies
             const now = new Map(t.columns.map((c) => [c.name, c]));
             const columns = cols.filter((c) => duckTypes.has(c.name)).map((c) => pgColumn(c, duckTypes.get(c.name), now.get(c.name)));
             const joins = t.foreignKeys.filter((f) => this.tables.has(f.target) && columns.some((c) => c.name === f.column))
@@ -2781,7 +3413,7 @@ export class Sync {
         const key = JSON.stringify([tables, views]);
         if (key !== this.schemaKey) {
             this.schemaKey = key;
-            this.currentSchema = { database: this.database, tables, ...(views.length > 0 ? { views } : {}) };
+            this.currentSchema = { database: this.currentSchema.database, tables, ...(views.length > 0 ? { views } : {}) };
         }
     }
 }