@mason-data/cli 0.8.0 → 0.10.0

package/dist/src/duck/generated.js

@@ -0,0 +1,906 @@
+/**
+ * GENERATED TABLES: TABLES DECLARED IN SQL, KEPT CURRENT BY MASON (issue 124, docs/DESIGN.md "Generated tables"). A file in
+ * `mason/generated_tables/` (src/cli/generated-files.ts) names a table and the SELECT that gives it, and a dashboard reads
+ * that table by name instead of repeating the work. This is `kind: scheduled`, by the whole re-run: the SELECT run over
+ * one snapshot into a table beside the old one, swapped in, up to `target_lag:` behind its bases. `kind: live` is refused
+ * until its write path exists; nothing here ever moves a table from one kind to the other.
+ *
+ * - WHAT IS CHECKED, AND WHEN: the file's shape when it is read; its SQL (src/duck/generated-plan.ts) once the listener's
+ *   catalog holds its bases, again whenever that catalog moves, and before anything is built. A refusal stops nothing
+ *   else: the other tables run on, and a table already deployed keeps serving AND being re-run under the definition it
+ *   was built from, which the ledger holds (`Deployed`), so a bad edit costs no freshness.
+ * - A RUN (`run`), ONE AT A TIME IN THE ONE REBUILD QUEUE, on a connection of its own set up as a session in UTC (a plan
+ *   read on a connection with DuckDB's own null order sorts otherwise): its snapshot taken on a writer's turn, the table
+ *   beside the old one written there, then swapped in on another writer's turn, as a copy's swap is. The source is never
+ *   touched. A failed run leaves the old table serving, says why (never quoting a row: `withoutValues`), and is tried
+ *   again after the same back-off as a failed copy.
+ * - LAG IS THE AGE OF THE OLDEST BASE CHANGE NOT REFLECTED, never the age of the snapshot: over an idle base nothing is
+ *   behind. Each commit that changed a base marks it (`changed`), in memory and after that commit, so nothing is added to
+ *   a batch's transaction. A run takes the marks on the same writer's turn it takes its snapshot, so a commit is either
+ *   in the snapshot or marked for the next run: DuckDB's snapshot is the transaction's first read of a table, never its
+ *   BEGIN (measured). Marks die with the process: at a start, a base last synced after the table was built counts as
+ *   changed since then, which at worst costs one re-run. A run starts early enough to end inside its target, by the last
+ *   run's length; one that outlasts its target is followed by the next at once, and `mason status` says the target is
+ *   missed.
+ * - A CATALOG TABLE, A TABLE TO ROLES: in the catalog as a copy of its output's types (`served`), so statements, EXPLAIN and
+ *   a role's `tables:` treat it as any other, with no key. Before it is built the catalog has no such relation, and a
+ *   statement is told so by name (gap `generated-not-built`, src/duck/plan.ts).
+ * - A CHAIN (issue 124 stage 2): a table may read another. Parents are built first, and a run of a parent builds every
+ *   child after it in the same transaction, each child planned over its parents' SIDE tables (src/duck/plan.ts
+ *   swapRelations), never the served ones, so parent and child are one snapshot; they swap in on ONE writer's turn. A
+ *   child that comes due while a parent has changes not in it hands its run to that parent (`rootOf`). A child of a
+ *   parent failed, or refused with nothing deployed, is not run, and says why (`blocker`); a deployed parent refused in its
+ *   file is re-run from what it was built from, and its children with it. A cycle is refused by name: from the SQL's names when
+ *   the folder is read (`findCycles`), else from the plan's reads at the check.
+ */
+import { createHash } from "node:crypto";
+import { cycleRefusal, isNumeric, planDefinition, readsByName, refusalOf, refusalText, storedColumns, uncheckedRefusal } from "./generated-plan.js";
+import { MASON_SCHEMA, pgErrorOf } from "./store.js";
+import { StatementError } from "./statement.js";
+export const GENERATED_LEDGER = `${MASON_SCHEMA}.generated_tables`;
+const LEDGER_DDL = `CREATE TABLE IF NOT EXISTS ${GENERATED_LEDGER} (name VARCHAR PRIMARY KEY, file VARCHAR, sql VARCHAR, order_by VARCHAR, target_every VARCHAR, target_seconds BIGINT, comment VARCHAR, ` +
+    `fingerprint VARCHAR, columns VARCHAR, bases VARCHAR, snapshot_at TIMESTAMPTZ, built_at TIMESTAMPTZ, "rows" BIGINT, seconds DOUBLE, bases_synced VARCHAR)`;
+/** the table a run writes, beside the one served until the swap */
+const SIDE_SUFFIX = "__mason_generated";
+/** how often the folder is read and each table's due time looked at */
+export const REVIEW_MS = 5_000;
+const ident = (name) => `"${name.replaceAll('"', '""')}"`;
+const literal = (s) => `'${s.replaceAll("'", "''")}'`;
+/** A row's values taken out of an error: what a table's failure says is kept and shown, and a value in it would be a row
+ *  quoted (`invalid input syntax for type integer: "abc"`): quoted text and every number go. */
+export function withoutValues(message) {
+    return message.split("\n")[0].replace(/'(?:[^']|'')*'/g, "…").replace(/"(?:[^"]|"")*"/g, "…").replace(/\b\d[\d.:,-]*\b/g, "…");
+}
+/** a definition the write's engine types refuse (`storedColumns`): the table's refusal, with its ways out */
+class RefusedAtWrite extends Error {
+    entry;
+    refused;
+    constructor(entry, refused) { super(refused.map((r) => r.message).join("; ")); this.entry = entry; this.refused = refused; }
+}
+/**
+ * A RUN'S FAILURE IN POSTGRES'S WORDS, never the engine's (CLAUDE.md "Nothing a user sees is named for DuckDB"): the ONE
+ * mapping a statement on the wire gets (src/duck/store.ts `pgErrorOf`) gives its SQLSTATE, message and Postgres's own
+ * DETAIL, and nothing here reads an engine spelling. Said without the run's values (`withoutValues`: Postgres's message
+ * may quote one), with no name Mason keeps for itself (`__mason_cell_0`), and the way out its SQLSTATE has.
+ */
+export function failureWords(err) {
+    const { code, message, detail } = pgErrorOf(err, "").fields;
+    // the mapping's own DETAIL is Postgres's; one that carries the engine's text is the engine's, and stays out
+    const theirs = detail === undefined || detail.startsWith("the engine") ? "" : ` ${detail}`;
+    const way = WAY_OUT[code];
+    return `${withoutValues(message)} (SQLSTATE ${code}).${theirs}${way === undefined ? "" : ` ${way}`}`.replace(/__mason_\w+/g, "a value it computes");
+}
+/** what to do about a run's failure, by its SQLSTATE: the data's, so the run is tried again on the back-off meanwhile */
+const WAY_OUT = {
+    "22003": "Give the value more digits (a wider type or typmod), cast it to double precision if it need not be exact, or compute it in the statement that reads the synced table.",
+    "22012": "Guard the divisor (x / nullif(y, 0)), or compute it in the statement that reads the synced table.",
+    "22P02": "Cast only the values that are of that type (a CASE over the text), or compute it in the statement that reads the synced table.",
+};
+/** the engine type of each column a plan's SQL computes, as DuckDB says when it prepares it (`EngineTypes`) */
+async function engineTypes(c, sql) {
+    const p = await c.prepare(sql);
+    try {
+        return new Map(Array.from({ length: p.columnCount }, (_, i) => { const type = p.columnType(i).toString(); return [[p.columnName(i), type], [`#${i}`, type]]; }).flat());
+    }
+    finally {
+        p.destroySync();
+    }
+}
+export class GeneratedTables {
+    store;
+    host;
+    reviewMs;
+    onStep;
+    entries = new Map();
+    reader = null;
+    planner = null;
+    timer = null;
+    reviewing = null;
+    /** a run's planning in flight: it plans on the listener's catalog, so a stop waits for it before the listener closes */
+    planning = null;
+    stopped = false;
+    /** the run in flight, ended or not (`run`): the next starts after it */
+    runs = Promise.resolve();
+    constructor(store, host, options = {}) {
+        this.store = store;
+        this.host = host;
+        this.reviewMs = options.reviewMs ?? REVIEW_MS;
+        this.onStep = options.onStep ?? (() => undefined);
+    }
+    /** the ledger read and what a crash left beside it dropped, before the catalog serves anything */
+    async open() {
+        const w = this.store.writer;
+        await w.run(LEDGER_DDL);
+        const rows = (await w.runAndReadAll(`SELECT name, file, sql, order_by, target_every, target_seconds, comment, fingerprint, columns, bases, epoch_ms(snapshot_at), epoch_ms(built_at), "rows", seconds, bases_synced FROM ${GENERATED_LEDGER}`)).getRowsJS();
+        for (const [name, file, sql, orderBy, every, seconds, comment, fingerprint, columns, bases, snapshotAt, builtAt, count, took, basesSynced] of rows) {
+            const at = name.indexOf(".");
+            this.entry(name).deployed = { definition: { name, schema: name.slice(0, at), table: name.slice(at + 1), file, sql, orderBy, targetLag: { every, seconds: Number(seconds) }, comment },
+                fingerprint, columns: JSON.parse(columns), bases: JSON.parse(bases), basesSynced: basesSynced === null ? {} : JSON.parse(basesSynced), snapshotAt: Number(snapshotAt), builtAt: Number(builtAt), rows: Number(count), seconds: took };
+        }
+        // marks die with a run: a base whose last sync is not the one the snapshot saw may have changed since. Never "synced
+        // after the snapshot": a poll's time is its start, so one that began before the snapshot and committed after it would
+        // be missed. A generated base's "last sync" is its own snapshot (`baseSynced`): a parent swapped in alone since the
+        // child's run, a new definition's included, leaves the child stale; one built with the child leaves it current
+        for (const entry of this.entries.values()) {
+            const d = entry.deployed;
+            if (d === null)
+                continue;
+            if (d.bases.some((b) => { const s = this.baseSynced(b); return s === null || d.basesSynced[b] === undefined || d.basesSynced[b] !== s; }))
+                entry.dirtySince = d.snapshotAt;
+        }
+        const left = (await w.runAndReadAll(`SELECT schema_name, table_name FROM duckdb_tables() WHERE database_name = current_database() AND ends_with(table_name, '${SIDE_SUFFIX}')`)).getRowsJS();
+        for (const [schema, table] of left)
+            await w.run(`DROP TABLE ${ident(schema)}.${ident(table)}`);
+        // the run's connection was set up as a session is, by the one set-up (src/duck/store.ts `SessionSetup`)
+        await this.host.settle();
+    }
+    /** a base's last sync, ms; null: not known */
+    syncedMs(base) { const s = this.host.syncedAt(base); return s === null ? null : Date.parse(s); }
+    /** what a child's ledger row records of a base: a synced table's last sync, a generated table's snapshot (ms, as served
+     *  now); null: not known */
+    baseSynced(base) {
+        const p = this.host.added(base) === null ? this.entries.get(base) : undefined;
+        return p === undefined ? this.syncedMs(base) : p.deployed?.snapshotAt ?? null;
+    }
+    /** From here on the folder is read (`read`) and each definition held to the listener's catalog (`planner`). Resolves once
+     *  they have been looked at, so a start can say what is refused. */
+    async start(read, planner) {
+        this.reader = read;
+        this.planner = planner;
+        await this.review();
+        this.arm();
+    }
+    arm() {
+        if (this.stopped || this.reviewMs === 0)
+            return;
+        this.timer = setTimeout(() => { void this.review().finally(() => this.arm()); }, this.reviewMs);
+        this.timer.unref();
+    }
+    /** the timer stopped, and what it was doing ended: the review, and a run's planning, the two that read the listener's
+     *  catalog (a run past its plan sees `stopped` and ends; its build is the sync's stop to interrupt) */
+    async stop() {
+        this.stopped = true;
+        if (this.timer !== null)
+            clearTimeout(this.timer);
+        await this.reviewing;
+        // settled, not awaited: its failure is the run's to say, or not, as stopped
+        if (this.planning !== null)
+            await Promise.allSettled([this.planning]);
+    }
+    entry(name) {
+        let e = this.entries.get(name);
+        if (e === undefined) {
+            e = { name, wanted: null, fileRefused: null, checked: null, reads: [], cycle: null, blocked: null, seen: null, refusals: [], said: null, warnings: [], warned: null, waitingFor: null, deployed: null, dirtySince: null, taken: null, queued: false, running: false, failures: 0, retryAt: 0, error: null };
+            this.entries.set(name, e);
+        }
+        return e;
+    }
+    // ------------------------------------------------------------------------------------------- what the sync reads
+    /** the tables served, as the catalog declares them (src/duck/sync.ts `schemaBuilt`), but one a copy holds the name of */
+    served() {
+        return [...this.entries.values()].flatMap((e) => e.deployed === null || this.host.added(e.name) !== null ? [] :
+            [{ schema: e.deployed.definition.schema, table: e.deployed.definition.table, columns: e.deployed.columns, comment: e.deployed.definition.comment }]);
+    }
+    /** the tables a role may name, built or not: `columns` none until they are known (src/cli/roles.ts) */
+    named() {
+        return [...this.entries.values()].filter((e) => this.defines(e.name)).map((e) => e.deployed !== null ? { source: e.name, columns: e.deployed.columns } : { source: e.name, columns: [], pending: true });
+    }
+    /** `name` is a generated table this folder defines: a file that names it, or a table built from one; never a name
+     *  whose file is gone and was never built, nor one a file names that is refused before its SQL is read */
+    defines(name) {
+        const e = this.entries.get(name);
+        return e !== undefined && (e.wanted !== null || e.deployed !== null);
+    }
+    /** a base's commit changed its rows: called on the writer's turn, after that commit */
+    changed(base) {
+        const now = Date.now();
+        for (const e of this.entries.values())
+            if (e.dirtySince === null && e.deployed?.bases.includes(base))
+                e.dirtySince = now;
+    }
+    /** how far behind its bases a table is, seconds, across its chain: 0 when nothing is unreflected */
+    behind(e, now) {
+        const oldest = this.chainOldest(e);
+        return oldest === null ? 0 : Math.max(0, (now - oldest) / 1000);
+    }
+    /** LAG ACROSS A CHAIN: the oldest base change not in `e`'s rows, its own or one a table it is built from has not
+     *  reflected yet (that one is not in `e` either), anywhere below it; null: none. Measured against the base, never
+     *  summed: a `1m` table over a `1m` table aims to be 1 minute behind the base, not 2 */
+    chainOldest(e, seen = new Set()) {
+        seen.add(e.name);
+        let oldest = this.oldest(e);
+        for (const n of e.deployed?.bases ?? []) {
+            const p = this.entries.get(n);
+            if (p === undefined || seen.has(n) || this.host.added(n) !== null)
+                continue;
+            const o = this.chainOldest(p, seen);
+            if (o !== null && (oldest === null || o < oldest))
+                oldest = o;
+        }
+        return oldest;
+    }
+    /** the oldest change not in the table: a run's, until its swap, or one since */
+    oldest(e) { return e.taken === null ? e.dirtySince : e.dirtySince === null ? e.taken : Math.min(e.taken, e.dirtySince); }
+    stateOf(e) {
+        if (e.fileRefused !== null || e.refusals.length > 0)
+            return "refused";
+        if (e.deployed === null)
+            return e.running || e.queued ? "building" : e.error !== null ? "failed" : e.waitingFor !== null || e.blocked !== null ? "waiting" : "building";
+        if (e.error !== null)
+            return "failed";
+        return this.chainOldest(e) !== null ? "behind" : "current";
+    }
+    status(now = Date.now()) {
+        return [...this.entries.values()].map((e) => {
+            const d = e.wanted ?? e.deployed?.definition ?? null;
+            const refusals = e.fileRefused?.refusals ?? e.refusals;
+            const file = e.fileRefused?.file ?? d?.file ?? e.name;
+            const target = e.deployed?.definition.targetLag ?? d?.targetLag ?? null;
+            const behindSeconds = this.behind(e, now), since = this.chainOldest(e);
+            return { table: e.name, file, kind: e.fileRefused !== null ? e.fileRefused.kind : "scheduled", method: "whole", state: this.stateOf(e), targetLag: target?.every ?? null, behindSeconds,
+                behindSince: since === null ? null : new Date(since).toISOString(),
+                missingTarget: target !== null && behindSeconds > target.seconds, serving: e.deployed !== null,
+                lastRun: e.deployed === null ? null : { at: new Date(e.deployed.builtAt).toISOString(), seconds: e.deployed.seconds, rows: e.deployed.rows },
+                error: e.error, retryAt: e.error === null ? null : new Date(e.retryAt).toISOString(), refusals: refusals.map((r) => ({ ...r, text: refusalText(file, r) })), waitingFor: this.waitingWords(e), warnings: e.warnings.map((w) => `${file}: ${w}`) };
+        }).sort((a, b) => a.table.localeCompare(b.table));
+    }
+    /** what `e` waits for, as `GeneratedStatus.waitingFor` says it: the table's name, with why it blocks as that table is
+     *  NOW (refused with nothing deployed, or its last run failed), read here and never stored, so `mason wait` decides
+     *  from what is so when it reads (src/cli/readiness.ts `generatedReadiness`) */
+    waitingWords(e) {
+        if (e.waitingFor !== null) {
+            const why = this.refusedOrFailed(e.waitingFor);
+            return why === null ? e.waitingFor : `${e.waitingFor}, which ${why}`;
+        }
+        if (e.blocked !== null) {
+            const why = this.refusedOrFailed(e.blocked);
+            return why === null ? e.blocked : `${e.blocked} ${why}`;
+        }
+        return null;
+    }
+    /** the tables as the listener takes the sync's states (`Sync.state`): how EXPLAIN says each is kept current, and what a
+     *  statement is told of one not built yet (src/duck/plan.ts `missingRelationHint`) */
+    copies(now = Date.now()) {
+        return this.status(now).map((s) => {
+            const lag = s.behindSeconds === 0 ? "nothing behind" : `${Math.round(s.behindSeconds)} s behind`;
+            const last = s.lastRun === null ? "never built" : `last re-run ${s.lastRun.at}`;
+            const words = s.serving ? `generated from ${s.file}: scheduled, re-run whole, target ${s.targetLag}, ${lag}; ${last}${s.error === null ? "" : `; its last run failed: ${s.error}`}` :
+                s.state === "refused" ? `refused: ${s.refusals[0]?.message ?? ""}` : s.state === "failed" ? `its first build failed: ${s.error ?? ""}` : s.state === "waiting" ? `waiting for ${s.waitingFor ?? "a table"}` : "being built";
+            return { source: s.table, phase: s.serving ? "copied" : "copying", rows: s.lastRun?.rows ?? null, bytes: null, seconds: s.lastRun?.seconds ?? null, copiedAt: s.lastRun?.at ?? null, error: s.error, kept: { by: "generated", text: words } };
+        });
+    }
+    // ---------------------------------------------------------------------------------------------------- the review
+    /** The folder read, each definition held to the catalog, and what is due queued: every `reviewMs`, one at a time. */
+    review() {
+        this.reviewing ??= this.reviewed().catch((e) => {
+            this.host.log(`generated tables: the review failed, and runs again (Mason bug: report it): ${e instanceof Error ? e.stack ?? e.message : String(e)}`);
+        }).finally(() => { this.reviewing = null; });
+        return this.reviewing;
+    }
+    async reviewed() {
+        if (this.reader === null || this.stopped)
+            return;
+        const read = this.reader();
+        const wanted = new Map(read.definitions.map((d) => [d.name, d])), refused = new Map(read.refused.map((r) => [r.name, r]));
+        for (const name of new Set([...wanted.keys(), ...refused.keys()]))
+            this.entry(name);
+        for (const e of this.entries.values()) {
+            e.wanted = wanted.get(e.name) ?? null;
+            e.fileRefused = refused.get(e.name) ?? null;
+            e.reads = e.wanted === null ? [] : await readsByName(e.wanted.sql);
+        }
+        this.findCycles();
+        for (const e of [...this.entries.values()]) {
+            // a stop mid-review: the listener's catalog may be closing, and nothing is planned on it
+            if (this.stopped)
+                return;
+            this.say(e);
+            if (e.wanted === null && e.fileRefused === null) {
+                await this.remove(e);
+                continue;
+            }
+            await this.check(e);
+            if (!e.running)
+                this.schedule(e);
+        }
+    }
+    /** a refusal said once, when it starts or changes */
+    say(e) {
+        const file = e.fileRefused?.file ?? e.wanted?.file ?? e.name, list = e.fileRefused?.refusals ?? e.refusals;
+        const words = list.length === 0 ? null : list.map((r) => refusalText(file, r)).join("\n");
+        if (words !== e.said) {
+            if (words !== null)
+                this.host.log(`${words}${e.deployed !== null ? `\n  ${e.name} keeps serving what it was last built from.` : ""}`);
+            else
+                this.host.log(`${file}: no longer refused`);
+            e.said = words;
+        }
+        const warned = e.warnings.length === 0 ? null : e.warnings.map((w) => `${file}: ${w}`).join("\n");
+        if (warned !== null && warned !== e.warned)
+            this.host.log(warned);
+        e.warned = warned;
+    }
+    /** its file gone: the table goes, unless a run has it (the run's end looks again) or a copy now holds its name */
+    async remove(e) {
+        if (e.running || e.queued)
+            return;
+        this.entries.delete(e.name);
+        if (e.deployed === null)
+            return;
+        const d = e.deployed.definition;
+        const copy = this.host.added(e.name) !== null;
+        await this.host.onWriter(async () => {
+            const w = this.store.writer;
+            await w.run("BEGIN TRANSACTION");
+            try {
+                if (!copy)
+                    await w.run(`DROP TABLE IF EXISTS ${ident(d.schema)}.${ident(d.table)}`);
+                await w.run(`DELETE FROM ${GENERATED_LEDGER} WHERE name = ${literal(e.name)}`);
+                await w.run("COMMIT");
+            }
+            catch (x) {
+                await w.run("ROLLBACK");
+                throw x;
+            }
+        });
+        this.host.log(`${e.name}: its file is gone, so the generated table is dropped`);
+        await this.host.rebuildCatalog();
+    }
+    /** the generated tables `n` reads: by its SQL's names, and by what the plan said where it was checked; what it was
+     *  built from where its file is gone or refused */
+    readsOf(n, names) {
+        const e = this.entries.get(n);
+        if (e === undefined)
+            return [];
+        // what the plan read, only while `wanted` is the definition it planned: an edit's reads are its names until checked
+        const planned = e.checked !== null && e.wanted !== null && e.seen?.json === JSON.stringify(e.wanted) ? e.checked.bases : [];
+        return [...new Set([...e.reads, ...planned, ...(e.wanted === null ? e.deployed?.bases ?? [] : [])])].filter((x) => names.has(x));
+    }
+    /** the shortest way from `self` through what each reads back to `self`, as the tables in order (self first and last) */
+    cycleOf(self, reads) {
+        const from = new Map(), queue = [self];
+        while (queue.length > 0) {
+            const n = queue.shift();
+            for (const d of reads(n)) {
+                if (d === self) {
+                    const back = [];
+                    for (let at = n; at !== self; at = from.get(at))
+                        back.push(at);
+                    return [self, ...back.reverse(), self];
+                }
+                if (!from.has(d)) {
+                    from.set(d, n);
+                    queue.push(d);
+                }
+            }
+        }
+        return null;
+    }
+    /** each definition whose SQL's names read itself, through others or not: refused before its check */
+    findCycles() {
+        const names = this.names("");
+        for (const e of this.entries.values()) {
+            const cycle = e.wanted === null || !names.has(e.name) ? null : this.cycleOf(e.name, (n) => this.readsOf(n, names));
+            e.cycle = cycle === null ? null : cycleRefusal(cycle);
+        }
+    }
+    /** `wanted` held to the catalog as it is now: once per definition and per catalog */
+    async check(e) {
+        const planner = this.planner, schema = this.host.schema();
+        if (planner === null)
+            return;
+        const def = e.wanted;
+        if (def === null) {
+            e.checked = null;
+            e.seen = null;
+            e.refusals = [];
+            e.waitingFor = null;
+            return;
+        }
+        const held = this.host.added(e.name);
+        if (held !== null) {
+            e.checked = null;
+            e.seen = null;
+            e.waitingFor = null;
+            await this.release(e);
+            e.refusals = [{ key: null, message: `${e.name} is a ${held === "view" ? "view of the database" : "table the sources file syncs"}`, why: "A name holds one table.", options: ["rename this file", "or take the table out of the sources file"] }];
+            this.say(e);
+            return;
+        }
+        if (e.cycle !== null) {
+            e.checked = null;
+            e.seen = null;
+            e.waitingFor = null;
+            e.refusals = [e.cycle];
+            this.say(e);
+            return;
+        }
+        // a parent's target_lag is held against this one's: looked at again when any table's target moves
+        const json = JSON.stringify([def, [...this.entries.values()].map((p) => [p.name, this.targetOf(p)?.seconds ?? null])]);
+        if (e.seen?.json === json && e.seen.schema === schema)
+            return;
+        e.seen = { json, schema };
+        try {
+            // on the check's own connection: a run may hold the run's in a transaction now (`checkConnection`)
+            const c = this.host.checkConnection();
+            await this.host.settleCheck();
+            const r = await planDefinition(planner, def.sql, def.orderBy, undefined, (sql) => engineTypes(c, sql));
+            e.waitingFor = null;
+            e.warnings = "refused" in r ? [] : r.definition.warnings;
+            // what its names did not show (a name the plan resolved otherwise): a cycle by what the plan reads
+            const names = this.names(e.name);
+            const cycle = "refused" in r ? null : this.cycleOf(e.name, (n) => n === e.name ? r.definition.bases.filter((x) => names.has(x)) : this.readsOf(n, names));
+            if ("refused" in r) {
+                e.checked = null;
+                e.refusals = r.refused;
+            }
+            else if (cycle !== null) {
+                e.checked = null;
+                e.refusals = [cycleRefusal(cycle)];
+            }
+            else if (this.fresherThan(def, r.definition.bases, names) !== null) {
+                e.checked = null;
+                e.refusals = [this.fresherThan(def, r.definition.bases, names)];
+            }
+            else {
+                const fingerprint = createHash("sha256").update(JSON.stringify([def.sql, def.orderBy, r.definition.columns.map((c) => [c.name, c.type, c.duck])])).digest("hex");
+                e.checked = { definition: def, fingerprint, bases: r.definition.bases };
+                e.refusals = [];
+            }
+        }
+        catch (x) {
+            // NO DEFINITION LEAVES THE CHECK WITHOUT A VERDICT: what Mason did not expect while checking one is that table's
+            // refusal, in words a user reads, and the review goes on to the others. Thrown up, it stopped the review at this
+            // table, ran it again for ever, and left the table `building` with no reason (PR 202 round 8). What it said goes to
+            // the log once, for the report; the refusal stands until the definition or the catalog changes (`seen`)
+            if (!(x instanceof StatementError)) {
+                e.checked = null;
+                e.waitingFor = null;
+                e.warnings = [];
+                e.refusals = [uncheckedRefusal()];
+                this.host.log(`${def.file}: Mason could not check this definition (Mason bug: report it, with this line and the file's SQL): ${x instanceof Error ? x.stack ?? x.message : String(x)}`);
+                this.say(e);
+                return;
+            }
+            e.checked = null;
+            const missing = x.fields.code === "42P01" ? /^relation "([^"]+)" does not exist$/.exec(x.fields.message)?.[1] : undefined;
+            const base = missing === undefined ? undefined : missing.includes(".") ? missing : `public.${missing}`;
+            const adding = base === undefined ? null : this.host.added(base);
+            // A 42P01 IS THE CATALOG'S IT WAS PLANNED ON (issue 387): a table the sources file adds is waited for until the
+            // catalog holds it (`adding`), and also when the catalog moved while this was planned, since the host's answer is
+            // the new catalog's, which may hold a table the plan's did not (the demo's start: orders synced and in the catalog
+            // while the check's plan, begun before, waited for the catalog Postgres to start without it). `seen` keeps the
+            // schema the plan was made on, so the next review checks it again over the one that holds it
+            const moved = this.host.schema() !== schema;
+            // a parent not built yet: waited for by name; why it is refused or its build failed is read when it is said
+            const parent = x.gap === "generated-not-built" ? /the generated table (\S+) is not built yet/.exec(x.fields.message)?.[1] : undefined;
+            // A GENERATED BASE IS THERE WHEN THE CATALOG HOLDS IT TOO (issue 474): a run sets its table deployed, so serving,
+            // BEFORE its rebuild of the catalog (which reads `served()`, so it must), and that rebuild waits behind any other.
+            // A 42P01 for a table this folder defines is the catalog the plan was made on lacking it, whatever its state:
+            // waited for by name, and the parent's own trouble read where it is said (`waitingWords`). A name nobody defines
+            // (no file, or its file gone) stays Postgres's refusal
+            const generated = base !== undefined && adding === null && base !== e.name && this.defines(base);
+            if (adding === "adding" || (adding === "copied" && moved)) {
+                e.waitingFor = base;
+                e.refusals = [];
+            }
+            else if (parent !== undefined) {
+                e.waitingFor = parent;
+                e.refusals = [];
+            }
+            else if (generated) {
+                e.waitingFor = base;
+                e.refusals = [];
+            }
+            else {
+                e.waitingFor = null;
+                e.refusals = [refusalOf(x)];
+            }
+        }
+        this.say(e);
+    }
+    /** the `target_lag` a table is kept to: its file's, else what it was built from. A table refused in its file but
+     *  deployed runs at what it was built from, so that is what a child is held to, never the refused file's */
+    targetOf(e) {
+        const running = e.fileRefused !== null || e.refusals.length > 0 ? e.deployed?.definition.targetLag : undefined;
+        return running ?? e.wanted?.targetLag ?? e.deployed?.definition.targetLag ?? null;
+    }
+    /** A CHILD'S TARGET AGAINST ITS PARENT'S: a table can be no fresher than a generated table it reads, so a `target_lag`
+     *  shorter than a parent's is refused by name, with the way out; null: none is */
+    fresherThan(def, bases, names) {
+        for (const n of bases) {
+            const p = this.entries.get(n), target = p === undefined || !names.has(n) ? null : this.targetOf(p);
+            if (target === null || def.targetLag.seconds >= target.seconds)
+                continue;
+            return { key: "target_lag", message: `target_lag ${def.targetLag.every} is shorter than that of ${n}, which it reads (${target.every})`,
+                why: "A table can be no fresher than a generated table it reads: its rows wait for the parent's run.",
+                options: [`set target_lag: ${target.every} or longer`, `or shorten ${n}'s target_lag to ${def.targetLag.every}`] };
+        }
+        return null;
+    }
+    /** the generated tables' names, itself among them: a file refused for holding a synced table's name names no generated
+     *  table */
+    names(self) { return new Set([...this.entries.keys(), self].filter((n) => n !== "" && this.host.added(n) === null)); }
+    /** why a parent blocks what reads it: refused with nothing deployed, or its last run failed; null: neither. A parent
+     *  refused in its file but deployed is re-run from what it was built from, and feeds its children from that */
+    refusedOrFailed(name) {
+        const p = this.entries.get(name);
+        if (p === undefined)
+            return null;
+        if ((p.fileRefused !== null || p.refusals.length > 0) && p.deployed === null)
+            return "is refused";
+        return p.error === null ? null : "failed its last run";
+    }
+    /** the generated tables `e` is built from now */
+    parentsOf(e) {
+        const b = this.buildable(e);
+        return b === null ? [] : b.bases.filter((x) => this.entries.has(x) && this.host.added(x) === null);
+    }
+    /** the table that keeps `e` from being run: a parent, or a parent's parent, refused or failed; null: nothing blocks it */
+    blocker(e, seen = new Set()) {
+        seen.add(e.name);
+        for (const p of this.parentsOf(e)) {
+            if (seen.has(p))
+                continue;
+            if (this.refusedOrFailed(p) !== null)
+                return p;
+            const up = this.blocker(this.entries.get(p), seen);
+            if (up !== null)
+                return up;
+        }
+        return null;
+    }
+    /** `e` not run because of the table `by`, said once per table */
+    block(e, by) {
+        if (e.blocked !== by)
+            this.host.log(`${e.name}: not run, because ${by} ${this.refusedOrFailed(by) ?? "is not ready"}`);
+        e.blocked = by;
+    }
+    /** a base is there to read: a synced table synced, or a generated table built */
+    ready(name) {
+        const held = this.host.added(name);
+        return held === "copied" || (held === null && this.entries.get(name)?.deployed != null);
+    }
+    /** whom a run of `e` belongs to: the farthest parent with changes not in it, which builds `e` after it */
+    rootOf(e, seen = new Set()) {
+        seen.add(e.name);
+        for (const n of this.parentsOf(e)) {
+            const p = this.entries.get(n);
+            if (seen.has(n) || p.deployed === null || this.oldest(p) === null || p.running || Date.now() < p.retryAt)
+                continue;
+            return this.rootOf(p, seen);
+        }
+        return e;
+    }
+    /** what a run of `root` builds, parents before children: `root`, then every table that reads one of them whose other
+     *  parents are built and blocked by nothing. Not the children of a new definition: theirs is a plan over what the
+     *  catalog says once it is swapped in. A parent refused in its file runs its deployed definition, and carries them */
+    unitOf(root) {
+        const now = Date.now(), set = new Map([[root.name, root]]);
+        // a table of this run feeds its children unless it is a new definition: refused in its file, it is re-run from what it
+        // was built from, which the catalog and its children already hold (its own failure is what this run tries again)
+        const feeds = (p) => p.deployed !== null && p.deployed.fingerprint === this.buildable(p)?.fingerprint;
+        for (let grew = true; grew;) {
+            grew = false;
+            for (const c of this.entries.values()) {
+                if (set.has(c.name) || c.running || this.buildable(c) === null || now < c.retryAt)
+                    continue;
+                const parents = this.parentsOf(c);
+                if (!parents.some((x) => set.has(x)))
+                    continue;
+                if (parents.some((x) => set.has(x) ? !feeds(set.get(x)) : !this.ready(x) || this.refusedOrFailed(x) !== null))
+                    continue;
+                set.set(c.name, c);
+                grew = true;
+            }
+        }
+        const order = [], placed = new Set(), members = [...set.values()];
+        for (;;) {
+            const next = members.find((m) => !placed.has(m.name) && this.parentsOf(m).every((x) => !set.has(x) || placed.has(x)));
+            if (next === undefined)
+                break;
+            order.push(next);
+            placed.add(next.name);
+        }
+        return order;
+    }
+    /**
+     * A NAME A SYNCED TABLE NOW HOLDS (`mason add` of the generated table's name): the synced table wins, so what was deployed
+     * is forgotten, its ledger row with it, and the table under that name, now the copy's, is never touched. Not while a run
+     * has it: the run's end looks again, and its swap looks on the writer's turn and abandons the run if a synced table
+     * holds the name (`swap`).
+     */
+    async release(e) {
+        if (e.deployed === null || e.running || e.queued)
+            return;
+        e.deployed = null;
+        e.dirtySince = null;
+        e.taken = null;
+        e.error = null;
+        await this.host.onWriter(() => this.store.writer.run(`DELETE FROM ${GENERATED_LEDGER} WHERE name = ${literal(e.name)}`));
+        this.host.log(`${e.name}: a synced table now holds its name, so the generated table is no longer kept`);
+    }
+    /** what to build from now: the file's definition where the catalog passed it, else what was deployed; nothing where a
+     *  synced table holds the name */
+    buildable(e) {
+        if (this.host.added(e.name) !== null)
+            return null;
+        if (e.checked !== null && e.refusals.length === 0 && e.fileRefused === null)
+            return { definition: e.checked.definition, fingerprint: e.checked.fingerprint, bases: e.checked.bases };
+        return e.deployed === null ? null : { definition: e.deployed.definition, fingerprint: e.deployed.fingerprint, bases: e.deployed.bases };
+    }
+    /** queued when it is due: never built, a new definition, or the oldest change near its target */
+    schedule(e, now = Date.now()) {
+        const b = this.buildable(e);
+        if (b === null || e.queued || e.running || now < e.retryAt || this.stopped)
+            return;
+        if (e.deployed === null || e.deployed.fingerprint !== b.fingerprint) {
+            this.queue(e);
+            return;
+        }
+        if (e.dirtySince === null || e.deployed.bases.some((x) => !this.ready(x)))
+            return;
+        if (now - e.dirtySince >= (b.definition.targetLag.seconds * 1000) - (e.deployed.seconds * 1000))
+            this.queue(e);
+    }
+    queue(e) { e.queued = true; this.host.enqueue(e.name); }
+    // ------------------------------------------------------------------------------------------------------ the run
+    /** ONE RUN, in the rebuild queue: never throws but `Stopping`; its failure is its own to say. A run of a table is its
+     *  chain's: a parent's builds its children after it, and a child's is its dirty parent's (`rootOf`, `unitOf`). A table
+     *  that fails takes the tables built from it out of the run, which is tried again without them.
+     *  ONE RUN AT A TIME, whoever asks: a run asked while another is in flight waits for it to end. `rootOf` and `unitOf`
+     *  leave out a table a run has (`running`), so a run beside another would build a parent and leave its child over the
+     *  old one; the rebuild queue asks one at a time, and this holds it for any other caller too (issue 195). */
+    run(name) {
+        const ran = this.runs.then(() => this.runAlone(name));
+        // the next waits for this one's end, not its outcome: its Stopping is its caller's
+        this.runs = ran.then(() => undefined, () => undefined);
+        return ran;
+    }
+    async runAlone(name) {
+        const asked = this.entries.get(name), planner = this.planner;
+        if (asked === undefined)
+            return;
+        asked.queued = false;
+        if (this.buildable(asked) === null || planner === null || this.stopped)
+            return;
+        const why = this.blocker(asked);
+        if (why !== null) {
+            this.block(asked, why);
+            return;
+        }
+        const root = this.rootOf(asked);
+        let members = this.unitOf(root);
+        // a child the run leaves out because a parent in it is refused, or is a new definition: said or looked at again
+        for (const c of this.entries.values()) {
+            if (members.includes(c) || !this.parentsOf(c).some((x) => members.some((m) => m.name === x)))
+                continue;
+            const blocked = this.blocker(c);
+            if (blocked !== null)
+                this.block(c, blocked);
+        }
+        while (members.length > 0) {
+            const failed = await this.build(members, planner);
+            if (failed === null)
+                return;
+            const gone = new Set([failed.name]);
+            for (const m of members)
+                if (this.parentsOf(m).some((x) => gone.has(x))) {
+                    gone.add(m.name);
+                    this.block(m, failed.name);
+                }
+            members = members.filter((m) => !gone.has(m.name));
+        }
+    }
+    /** `members` built, parents first, in ONE transaction over one snapshot, each child over its parents' side tables, and
+     *  swapped in on ONE writer's turn. The table that failed, its failure said; null when built or abandoned */
+    async build(members, planner) {
+        const started = Date.now();
+        let open = false, at = members[0];
+        // what each builds, read now, before anything awaits: a sources file reloaded while it plans changes nothing of this
+        // run. One with nothing to build now (its name taken since the run was asked): nothing is built, the review looks again
+        const buildables = members.map((m) => this.buildable(m));
+        if (buildables.some((b) => b === null))
+            return null;
+        const c = this.host.connection();
+        for (const m of members)
+            m.running = true;
+        try {
+            const sides = new Map();
+            const plans = [];
+            for (const [i, m] of members.entries()) {
+                at = m;
+                const b = buildables[i], d = b.definition;
+                // planned now, for what it reads as of now (a stored JSON path may have come or gone since it was checked), a
+                // parent built in this run read as its side table
+                const relations = new Map(b.bases.filter((x) => sides.has(x)).map((x) => [x, sides.get(x)]));
+                const planning = planDefinition(planner, d.sql, d.orderBy, relations);
+                this.planning = planning;
+                const planned = await planning.finally(() => { if (this.planning === planning)
+                    this.planning = null; });
+                // a stop came while it planned: nothing is built, and nothing failed
+                if (this.stopped)
+                    return null;
+                if ("refused" in planned)
+                    throw new Error(planned.refused[0].message);
+                sides.set(m.name, `${d.table}${SIDE_SUFFIX}`);
+                plans.push({ e: m, b, plan: planned.definition, target: `${ident(d.schema)}.${ident(d.table)}`, side: `${ident(d.schema)}.${ident(`${d.table}${SIDE_SUFFIX}`)}` });
+            }
+            at = members[0];
+            await this.host.settle();
+            for (const s of new Set(plans.map((p) => p.b.definition.schema)))
+                await c.run(`CREATE SCHEMA IF NOT EXISTS ${ident(s)}`);
+            await c.run("BEGIN TRANSACTION");
+            open = true;
+            const bases = [...new Set(plans.flatMap((p) => p.plan.bases))];
+            // THE SNAPSHOT AND THE MARKS, TOGETHER: this read takes the snapshot on the writer's turn, so a commit before it is
+            // in the snapshot and a commit after it marks the next run. Every table of the chain reads this one snapshot
+            const clock = await this.host.onWriter(async () => {
+                await c.runAndReadAll(`SELECT count(*) FROM ${GENERATED_LEDGER}`);
+                for (const m of members) {
+                    m.taken = m.dirtySince;
+                    m.dirtySince = null;
+                }
+                // a parent of this run is recorded at this snapshot, one served at its own, read on this turn as its swap is
+                const now = Date.now();
+                return { at: now, synced: Object.fromEntries(bases.map((x) => [x, members.some((m) => m.name === x) ? now : this.baseSynced(x)])) };
+            });
+            for (const m of members)
+                await this.onStep("snapshot", m.name);
+            const written = [];
+            for (const p of plans) {
+                at = p.e;
+                const { plan } = p.plan;
+                // a computed numeric's DECIMAL arithmetic, over the engine types of the SQL that runs (a parent's side table now
+                // there), never assumed: what the check held, the write holds again
+                const stored = !p.plan.columns.some(isNumeric) ? { columns: p.plan.columns, layers: [] } : storedColumns(p.plan, await engineTypes(c, plan.sql.text));
+                // refused here, it is a refusal as the check's are, with its options: never a failure retried on a timer
+                if ("refused" in stored)
+                    throw new RefusedAtWrite(p.e, stored.refused);
+                const { columns, layers } = stored;
+                const params = [];
+                if (plan.clock?.exec !== undefined)
+                    params[plan.clock.exec - 1] = new Date(clock.at).toISOString();
+                const aliases = columns.map((_, i) => `__mason_c${i}`);
+                // a computed numeric's shared nodes, each written once as a column of its own, a layer over the one before
+                // (src/duck/generated-plan.ts `storedProgram`): the columns' expressions read them by name
+                const from = layers.reduce((inner, layer) => `(SELECT *, ${layer} FROM ${inner}) AS __mason_output`, `(${plan.sql.text}) AS __mason_output(${aliases.join(", ")})`);
+                const sql = `CREATE OR REPLACE TABLE ${p.side} (${columns.map((x) => ident(x.name)).join(", ")}) AS SELECT ${columns.map((x, i) => { const v = x.expr ?? aliases[i]; return x.duck === null ? v : `CAST(${v} AS ${x.duck})`; }).join(", ")} ` +
+                    `FROM ${from}`;
+                const { rowsChanged } = await this.host.interruptible(() => c.run(sql, params.length > 0 ? params : undefined));
+                await this.onStep("written", p.e.name);
+                written.push({ e: p.e, side: p.side, target: p.target, n: { definition: p.b.definition, fingerprint: p.b.fingerprint, columns, bases: p.plan.bases,
+                        basesSynced: Object.fromEntries(p.plan.bases.map((x) => [x, clock.synced[x] ?? null])), snapshotAt: clock.at, builtAt: 0, rows: Number(rowsChanged), seconds: 0 } });
+            }
+            at = members[0];
+            await c.run("COMMIT");
+            open = false;
+            for (const m of members)
+                await this.onStep("committed", m.name);
+            const seconds = (Date.now() - started) / 1000, builtAt = Date.now();
+            for (const w of written) {
+                w.n.seconds = seconds;
+                w.n.builtAt = builtAt;
+            }
+            if (!await this.host.onWriter(() => this.swap(written))) {
+                // a synced table took a name while it ran: what it built is dropped, and the next review lets the name go; what
+                // this run took is still not in the table, so it stays dirty should the name come back (the sources file reverted)
+                for (const m of members) {
+                    m.dirtySince = this.oldest(m);
+                    m.taken = null;
+                }
+                this.host.log(`${members.map((m) => m.name).join(", ")}: a synced table now holds ${members.length === 1 ? "its name" : "one of their names"}, so what this run built was dropped`);
+                return null;
+            }
+            for (const m of members)
+                await this.onStep("swapped", m.name);
+            // what each swap brought, across the run: the oldest change any member at or below it took (parents come first in
+            // `written`), so a child left out under a member that took nothing itself is marked at the base change, never at
+            // the swap
+            const chainTook = new Map();
+            for (const w of written) {
+                let t = w.e.taken;
+                for (const p of w.n.bases) {
+                    const q = chainTook.get(p);
+                    if (q !== undefined && q !== null && (t === null || q < t))
+                        t = q;
+                }
+                chainTook.set(w.e.name, t);
+            }
+            for (const w of written) {
+                const e = w.e, was = e.error;
+                e.deployed = w.n;
+                e.taken = null;
+                e.error = null;
+                e.failures = 0;
+                e.retryAt = 0;
+                e.blocked = null;
+                // what reads it and was not built with it is behind it, whatever its definition: a new one, a child this run
+                // left out, or one whose own build failed and was taken out of the run (its marks were the parent's)
+                this.changedGenerated(e.name, members, chainTook.get(e.name) ?? null);
+                if (was !== null)
+                    this.host.event({ kind: "recovered", table: e.name, message: `its re-run succeeded (it had failed: ${was})` });
+            }
+            await this.host.rebuildCatalog();
+            for (const w of written)
+                this.host.log(`generated ${w.e.name}: ${w.n.rows.toLocaleString("en-US")} row(s) in ${seconds.toFixed(1)} s`);
+            return null;
+        }
+        catch (x) {
+            if (open)
+                await c.run("ROLLBACK");
+            // what this run took is still not in the tables
+            for (const m of members) {
+                m.dirtySince = this.oldest(m);
+                m.taken = null;
+            }
+            if (this.host.stopping(x))
+                throw x;
+            if (x instanceof RefusedAtWrite) {
+                // what the write's engine types refuse is the table's refusal, with its ways out, as at a check: it keeps serving
+                // what it holds and is not run again until its definition or the schema changes (the check's `seen`)
+                const e = x.entry;
+                e.checked = null;
+                e.refusals = x.refused;
+                this.say(e);
+                this.host.log(`${e.name}: refused at its run: ${x.refused.map((r) => r.message).join("; ")}`);
+                return null;
+            }
+            at.failures++;
+            const attempt = Date.now() - started;
+            at.retryAt = Date.now() + this.host.retryDelayMs(at.failures, attempt);
+            // a numeric past the 38 digits a stored DECIMAL holds is the data's, not the definition's: said with its way out,
+            // and run again on the back-off, since a change to the rows can bring it back within them
+            at.error = failureWords(x);
+            const m = `its re-run failed (it serves what it last held; tried again after ${new Date(at.retryAt).toISOString()}): ${at.error}`;
+            this.host.log(`${at.name}: ${m}`);
+            this.host.event({ kind: "generated_failed", table: at.name, message: m });
+            return at;
+        }
+        finally {
+            for (const m of members)
+                m.running = false;
+        }
+        // a file gone, or changed, while it ran: the next review looks
+    }
+    /** a generated table swapped in: what reads it and was not built with it is marked, as a base's commit marks, at the
+     *  oldest base change the swap brought (`took`), so its lag is still measured against the base; now for a new
+     *  definition, which no base change brought */
+    changedGenerated(name, built, took) {
+        const at = took ?? Date.now();
+        for (const e of this.entries.values()) {
+            if (built.includes(e) || !e.deployed?.bases.includes(name))
+                continue;
+            if (e.dirtySince === null || at < e.dirtySince)
+                e.dirtySince = at;
+        }
+    }
+    /** THE SWAP, ON THE WRITER'S TURN, as a copy's is: every side table of the run replaces its table, with its ledger
+     *  row, in ONE transaction, never beside a write, so a chain swaps in at one moment. The ledger row is what the table
+     *  is re-run from after a restart. False, and the side tables dropped, when a synced table now holds a name: on this
+     *  turn, so no copy's swap comes between. */
+    async swap(built) {
+        const w = this.store.writer;
+        if (built.some((b) => this.host.added(b.e.name) !== null)) {
+            for (const b of built)
+                await w.run(`DROP TABLE IF EXISTS ${b.side}`);
+            return false;
+        }
+        await w.run("BEGIN TRANSACTION");
+        try {
+            for (const { e, n, side, target } of built) {
+                const d = n.definition;
+                await w.run(`DROP TABLE IF EXISTS ${target}`);
+                await w.run(`ALTER TABLE ${side} RENAME TO ${ident(d.table)}`);
+                await w.run(`INSERT OR REPLACE INTO ${GENERATED_LEDGER} VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11::TIMESTAMPTZ, $12::TIMESTAMPTZ, $13, $14, $15)`, [e.name, d.file, d.sql, d.orderBy, d.targetLag.every, d.targetLag.seconds, d.comment, n.fingerprint, JSON.stringify(n.columns), JSON.stringify(n.bases),
+                    new Date(n.snapshotAt).toISOString(), new Date(n.builtAt).toISOString(), n.rows, n.seconds, JSON.stringify(n.basesSynced)]);
+            }
+            await w.run("COMMIT");
+        }
+        catch (x) {
+            await w.run("ROLLBACK");
+            throw x;
+        }
+        return true;
+    }
+}