@minnowdb/core 0.1.1 → 0.2.1

package/dist/engine/database.js

@@ -9,7 +9,7 @@ import { cachedQueryTerms, FTS_TOKENIZER_VERSION, renderDocumentValue, tokenize
 import { simpleDataTypes, floorWholeNumberProduct, validateColumnDefault, validateEnumValues, CompactionJobConflictError, GarbageCollectionJobConflictError, decodeSnapshot, encodeSnapshot, SnapshotManifestMissingError, TableRecordConflictError, TransactionRecordConflictError, UniqueKeyConflictError, WriteConflictError, } from "../storage/index.js";
 import { Snapshot, TransactionManager, } from "../transactions/index.js";
 import { applyWindowFunctions, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, compileStatement, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, expressionColumnNames, inferBlockSchema, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, windowOutputType, } from "./query.js";
-import { copyQueryResult, queryResultMemoKey, queryResultRetainedBytes, RESULT_MEMO_MAX_BYTES, } from "./query-cache.js";
+import { copyQueryResult, planMemoKey, queryResultMemoKey, queryResultRetainedBytes, RESULT_MEMO_MAX_BYTES, } from "./query-cache.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, } from "./memory.js";
 import { LiveQuerySet } from "./live.js";
 import { chooseJoinOrder, renderPlan } from "./optimizer.js";
@@ -25,20 +25,60 @@ const FTS_FOLD_DELTA_CHUNKS = 16;
 const DEFAULT_COMPACTION_TARGET_BLOCK_BYTES = 2 * 1024 * 1024;
 const DEFAULT_COMPACTION_MEMORY_BUDGET_BYTES = 32 * 1024 * 1024;
 const DEFAULT_COMPACTION_MINIMUM_LEVEL_ZERO_SEGMENTS = 2;
-const DEFAULT_COMPACTION_MAXIMUM_LEVEL_ZERO_SEGMENTS = 16;
+const DEFAULT_COMPACTION_MAXIMUM_LEVEL_ZERO_SEGMENTS = 64;
 const DEFAULT_COMPACTION_MAXIMUM_LEVEL_ZERO_STORED_BYTES = 64 * 1024 * 1024;
+/**
+ * Rows a keyed fold aims to keep in one level-one partition. A fold rewrites only the
+ * partitions its deltas touch, so this bounds how much one touched key costs to absorb; the
+ * table's partition count, and with it the per-query block count, grows as rows divided by it.
+ */
+const DEFAULT_COMPACTION_PARTITION_ROWS = 16_384;
 const DEFAULT_LEVEL_TWO_MAX_WRITE_AMPLIFICATION = 16;
 const MAX_COMPACTION_TARGET_BLOCK_BYTES = 64 * 1024 * 1024;
 const MAX_BLOCK_ENVELOPE_BYTES = 1024;
 const INTERNAL_READ_LEASE_TTL_MS = 60_000;
+/** Live proof windows kept resident; a sweep uses one, concurrent sets a few. */
+const LIVE_PROOF_CONTEXT_LIMIT = 4;
 /** Distinct table-name sets whose catalog state stays resident; entries are tiny (records only). */
 const CATALOG_STATE_CACHE_LIMIT = 64;
 /** Blocks fetched per round trip when a streamed scan window needs more data. */
 const STREAMED_SCAN_LOOKAHEAD_BLOCKS = 8;
-/** Visible segments per table at which a streamed scan schedules a compaction step. */
+/** Visible segments per table at which a scan or a commit schedules a compaction step. */
 const AUTO_COMPACT_SCAN_SEGMENTS = 48;
-/** Visible delete/update segments at which a streamed scan schedules a compaction step. */
-const AUTO_COMPACT_DELTA_SEGMENTS = 8;
+/** Visible delete/update segments at which a scan or a commit schedules a compaction step. */
+const AUTO_COMPACT_DELTA_SEGMENTS = 32;
+/** Commits to one table between auto-compaction checks on the write path. */
+const AUTO_COMPACT_COMMIT_CHECK_INTERVAL = 8;
+/** Quiet time after a write burst before checking its final, sub-interval tail. */
+const AUTO_COMPACT_IDLE_CHECK_MS = 25;
+/** Commits between background collection passes; each prunes the manifests they wrote. */
+const AUTO_COLLECT_COMMIT_INTERVAL = 64;
+/**
+ * Manifest versions background collection leaves readable behind the current one, and how
+ * old one may be before it is collected regardless. A version is kept only while both hold: the
+ * count serves a reader that names a version it was just handed, the age keeps a burst of
+ * commits from pinning everything it superseded until the next burst — an idle tab reclaims
+ * within a minute.
+ */
+const AUTO_COLLECT_RETAINED_VERSIONS = 64;
+const AUTO_COLLECT_RETAINED_VERSION_MS = 60_000;
+/** A commit this long after the last collection pass starts one, whatever the commit count. */
+const AUTO_COLLECT_QUIET_MS = 60_000;
+/** Candidates one background collection step examines before yielding to the event loop. */
+const AUTO_COLLECT_STEP_ITEMS = 64;
+/** Passes one background collection run makes before handing the rest to the next trigger. */
+const AUTO_COLLECT_MAX_PASSES = 32;
+/** Finished job records of each kind a background run leaves for inspection. */
+const AUTO_COLLECT_RETAINED_JOB_RECORDS = 8;
+/** Output blocks one background compaction step writes before yielding to the event loop. */
+const AUTO_COMPACT_STEP_BLOCKS = 4;
+/**
+ * Level-zero segments one background fold may absorb. A fold rewrites every partition its
+ * deltas touch, and a partition touched by several deltas is rewritten once, so absorbing
+ * everything pending in one pass costs one rewrite of those partitions where the default would
+ * cost several; the stored-bytes ceiling still bounds the pass.
+ */
+const AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS = 256;
 /** Modeled retained bytes for one cached block description (header metadata, no payload). */
 const ZONE_DESCRIPTION_CACHE_BYTES = 160;
 /** Overlay logical order for a write scope's staged segments: after all committed data. */
@@ -70,8 +110,15 @@ const GZIP_WORTHWHILE_RATIO = 1.2;
  * bounds how long a wrong observation can persist if the data changes underneath it.
  */
 const GZIP_REPROBE_BLOCKS = 32;
-/** Blocks smaller than this are written with the configured codec; the choice cannot repay. */
-const GZIP_DECISION_MIN_BYTES = 64 * 1024;
+/** Failed per-column probes retained in one database session. */
+const GZIP_VERDICT_CACHE_LIMIT = 256;
+/**
+ * Below this many logical bytes a block is written raw: the compression pass on the write and
+ * the decompression pass on every read would cost more than the bytes they save, and a point
+ * update's or delete's one-row block is the common case — it used to pay a CompressionStream
+ * round trip to shrink a few dozen bytes.
+ */
+const GZIP_MINIMUM_INPUT_BYTES = 4 * 1024;
 /** Bounds concurrent compression work without serializing independent column blocks. */
 const WRITE_ENCODE_CONCURRENCY = 6;
 export { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MissingKeyError, SqlCompileError, UniqueConstraintError, };
@@ -87,11 +134,6 @@ class TransactionRollback extends Error {
         this.name = "TransactionRollback";
     }
 }
-/**
- * Whether a statement may run inside a statement-level transaction. Reads and row writes stage
- * into the scope; schema changes do not, because the catalog commits outside it and a rollback
- * could not take them back.
- */
 function isTransactionalStatement(statement) {
     return (statement.kind === "insert" ||
         statement.kind === "update" ||
@@ -109,19 +151,24 @@ function boundInsertValue(value) {
 function quoteSqlIdentifier(identifier) {
     return `"${identifier.replaceAll('"', '""')}"`;
 }
+/**
+ * Snapshots are optional members of `BlockStore` — a store can be a complete database backend
+ * without being able to copy itself out — so the database checks at the call and says plainly
+ * when the capability is absent rather than failing as a missing property.
+ */
 function exportingStore(store) {
-    const candidate = store;
-    if (typeof candidate.exportSnapshot !== "function") {
+    const exportSnapshot = store.exportSnapshot?.bind(store);
+    if (exportSnapshot === undefined) {
         throw new Error("This database's block store cannot export snapshots");
     }
-    return candidate;
+    return { exportSnapshot };
 }
 function importingStore(store) {
-    const candidate = store;
-    if (typeof candidate.importSnapshot !== "function") {
+    const importSnapshot = store.importSnapshot?.bind(store);
+    if (importSnapshot === undefined) {
         throw new Error("This database's block store cannot load snapshots");
     }
-    return candidate;
+    return { importSnapshot };
 }
 export class MinnowDatabase {
     store;
@@ -137,7 +184,7 @@ export class MinnowDatabase {
     /** The scope a statement-level BEGIN opened, held until COMMIT, ROLLBACK, or the idle sweep. */
     #openTransaction;
     #compression;
-    /** Per-column record of whether gzip repaid itself, and how many blocks ago that was seen. */
+    /** Per-column count since gzip last failed to repay itself; successful probes need no entry. */
     #gzipVerdicts = new Map();
     #rowsPerBlock;
     #maxCommitRetries;
@@ -146,16 +193,51 @@ export class MinnowDatabase {
     #createId;
     #internalLeaseOwnerId = `minnow/${crypto.randomUUID()}`;
     #liveSets = new Set();
+    /** Live proof inputs per commit window, keyed `after:until`; see #liveProofContext. */
+    #liveProofContexts = new Map();
     #internalLeaseSequence = 0;
     #artifactCache;
     #ftsAutoIndexRows;
     #autoCompact;
+    #compactionPartitionRows;
+    #autoCollect;
+    /** Data commits since the last background collection pass. */
+    #commitsSinceCollection = 0;
+    /**
+     * The highest manifest version below which everything is known to be collected — pruned,
+     * with no block left behind; a collection plan starts its walk there. In memory only: a
+     * fresh instance walks the whole history once and learns it again.
+     */
+    #collectionWatermark = null;
+    #autoCollectionInFlight = false;
+    /** A trigger that arrived while a run was in flight; honoured when the run ends. */
+    #autoCollectionRequested = false;
+    #autoCollectionBackoffUntilCommit = 0;
+    /** When the last background collection pass started, by the database clock. */
+    #lastCollectionAt;
+    /** The idle pass scheduled after the last commit; reset by the next commit. */
+    #idleCollectionTimer;
+    /** The garbage-collection step in flight, so steps run one at a time: see #serializedCollectionStep. */
+    #collectionSteps = Promise.resolve();
     /** One background build attempt per (table, column) per session; misses just stay scans. */
     #ftsBuildsInFlight = new Set();
     /** Tables with a fire-and-forget compaction step already running. */
     #autoCompactionsInFlight = new Set();
+    /** Tables whose maintenance threshold was observed again while their fold was still running. */
+    #autoCompactionsRequested = new Set();
+    /** Changed tables awaiting the debounced check that closes a write burst. */
+    #idleCompactionTableIds = new Set();
+    #idleCompactionTimer;
+    /** Tables whose drop is retiring data; prevents a new background fold from starting. */
+    #droppingTables = new Set();
     /** Per table: the visible segment count a failed auto-compaction must see before retrying. */
     #autoCompactionBackoff = new Map();
+    /** Data commits per table since its last write-path auto-compaction check. */
+    #commitsSinceCompactionCheck = new Map();
+    /** The compaction step in flight per table, so steps on one table run one at a time. */
+    #compactionSteps = new Map();
+    /** The simple writes in flight, chained so they commit one after another: see #runWrite. */
+    #writeChain = Promise.resolve();
     /**
      * SQL text to optimized plan, LRU by insertion order. Compiled plans are never mutated after
      * optimization — subquery resolution and CTE expansion clone before rewriting and join
@@ -169,6 +251,8 @@ export class MinnowDatabase {
     #ftsCandidatesMemo = new WeakMap();
     #sharedLease;
     #sharedLeaseRenewal;
+    /** An in-flight re-pin of the shared lease; acquirers wait for it, never join it. */
+    #sharedLeaseMove;
     /**
      * Catalog states keyed by requested table-name set, valid only at #catalogStateEpoch.
      * The (version, epoch) probe is the sole validity signal: a matched epoch proves a cached
@@ -200,6 +284,8 @@ export class MinnowDatabase {
         this.#artifactCache = new ArtifactCache(options.bufferPoolBytes ?? 64 * 1024 * 1024);
         this.#ftsAutoIndexRows = options.ftsAutoIndexRows ?? 4096;
         this.#autoCompact = options.autoCompact ?? true;
+        this.#autoCollect = options.autoCollect ?? this.#autoCompact;
+        this.#compactionPartitionRows = positiveWholeNumber(options.compaction?.partitionRows ?? DEFAULT_COMPACTION_PARTITION_ROWS, "Compaction partition rows");
         if (!Number.isSafeInteger(this.#ftsAutoIndexRows) || this.#ftsAutoIndexRows < 0) {
             throw new RangeError("Full-text auto-index row threshold must be a non-negative whole number");
         }
@@ -300,7 +386,6 @@ export class MinnowDatabase {
             ...(input.managed === true ? { managed: true } : {}),
             ...(uniqueKeyColumn === undefined ? {} : { uniqueKeyColumnId: uniqueKeyColumn.id }),
             ...(uniqueKeyColumn === undefined ? {} : { uniqueKeyLookupReady: true }),
-            ...(uniqueKeyColumn === undefined ? {} : { uniqueKeyStorage: "chunks-v2" }),
             createdAt: this.#now().toISOString(),
         });
     }
@@ -333,17 +418,42 @@ export class MinnowDatabase {
      * conflict: unlike the plain rebase-and-retry, a restart re-reads pre-images and re-runs
      * trigger bodies at the fresh state, so derivations can never publish stale values.
      */
-    async #withTriggerRestarts(run) {
-        for (let attempt = 0;; attempt += 1) {
-            try {
-                return await run();
-            }
-            catch (error) {
-                if (!(error instanceof StaleTriggerDerivationsError))
-                    throw error;
-                if (attempt >= this.#maxCommitRetries)
-                    throw error.conflict;
+    /**
+     * Runs one simple write — insert, upsert, update, or delete — after every simple write this
+     * database already has in flight, restarting it when its trigger derivations went stale.
+     *
+     * Commits are optimistic: a writer reads the manifest version, stages, and publishes only if
+     * the version has not moved, rebasing and retrying otherwise up to `maxCommitRetries`.
+     * Writers issued concurrently from one database used to all read the same version and spend
+     * a retry per rival that landed first, so past `maxCommitRetries + 1` of them the rest failed
+     * for nothing — contention this database need not create, and the queue does not. Writers in
+     * other instances and other tabs still contend, and the retry loop is still what resolves
+     * them. Write scopes are not queued: a scope's callback may issue a plain write of its own,
+     * which must not wait on the scope that contains it.
+     */
+    async #runWrite(run) {
+        const restarting = async () => {
+            for (let attempt = 0;; attempt += 1) {
+                try {
+                    return await run();
+                }
+                catch (error) {
+                    if (!(error instanceof StaleTriggerDerivationsError))
+                        throw error;
+                    if (attempt >= this.#maxCommitRetries)
+                        throw error.conflict;
+                }
             }
+        };
+        const previous = this.#writeChain;
+        const current = previous.then(restarting, restarting);
+        this.#writeChain = current;
+        try {
+            return await current;
+        }
+        finally {
+            if (this.#writeChain === current)
+                this.#writeChain = Promise.resolve();
         }
     }
     /**
@@ -449,39 +559,57 @@ export class MinnowDatabase {
                 }
             }
         }
-        // Retiring the blocks is a commit like any other, and background compaction publishes
-        // underneath it: a block this table owned a moment ago can already have been rewritten. The
-        // list is therefore taken from the transaction's own snapshot — the manifest its commit will
-        // be validated against — and a scope that loses the race simply runs again.
-        for (let attempt = 0;; attempt += 1) {
-            const transaction = await this.#transactions.begin();
-            try {
-                const segments = await this.store.listSegments(table.id);
-                const snapshot = transaction.snapshotVersion === null
-                    ? undefined
-                    : await this.store.getManifest(transaction.snapshotVersion);
-                const live = new Set(snapshot?.blockIds ?? []);
-                const blockIds = [
-                    ...new Set(segments.flatMap((segment) => Object.values(segment.columnBlockIds).flat())),
-                ].filter((id) => live.has(id));
-                transaction.markTableChanged(table.id);
-                if (blockIds.length > 0)
-                    transaction.supersedeBlocks(blockIds);
-                await transaction.commit();
-                break;
-            }
-            catch (error) {
-                await transaction.abort();
-                if (!(error instanceof WriteConflictError) || attempt >= this.#maxCommitRetries)
-                    throw error;
+        this.#droppingTables.add(table.id);
+        try {
+            // Stop every fold already attached to the table before its catalog record disappears.
+            // Otherwise an unpublished job can no longer resume or be cancelled by table name, and
+            // its transaction and staged output become permanent roots.
+            await this.#cancelTableCompactions(table.id);
+            // Retiring the blocks is a commit like any other, and background compaction publishes
+            // underneath it: a block this table owned a moment ago can already have been rewritten. The
+            // list is therefore taken from the transaction's own snapshot — the manifest its commit will
+            // be validated against — and a scope that loses the race simply runs again.
+            for (let attempt = 0;; attempt += 1) {
+                const transaction = await this.#transactions.begin();
+                try {
+                    const segments = await this.store.listSegments(table.id);
+                    const snapshot = transaction.snapshotVersion === null
+                        ? undefined
+                        : await this.store.getManifest(transaction.snapshotVersion);
+                    const live = new Set(snapshot?.blockIds ?? []);
+                    const blockIds = [
+                        ...new Set(segments.flatMap((segment) => Object.values(segment.columnBlockIds).flat())),
+                    ].filter((id) => live.has(id));
+                    transaction.markTableChanged(table.id);
+                    if (blockIds.length > 0)
+                        transaction.supersedeBlocks(blockIds);
+                    await transaction.commit();
+                    break;
+                }
+                catch (error) {
+                    await transaction.abort();
+                    if (!(error instanceof WriteConflictError) || attempt >= this.#maxCommitRetries)
+                        throw error;
+                }
             }
+            // The catalog goes last: until it does, the table is merely empty of live blocks, and a
+            // crash in between leaves a table whose rows are gone rather than a segment pointing at a
+            // table that is not there.
+            // Catch a fold that was already between its scheduling check and job creation when the
+            // drop began. The dropping marker prevents another one from starting after this point.
+            await this.#cancelTableCompactions(table.id);
+            await this.store.removeTable(table.id, table.revision ?? 0);
+            for (const column of table.columns)
+                this.#gzipVerdicts.delete(column.id);
+            this.#autoCompactionBackoff.delete(table.id);
+            this.#commitsSinceCompactionCheck.delete(table.id);
+            this.#idleCompactionTableIds.delete(table.id);
+            this.#planCache.clear();
+            return true;
+        }
+        finally {
+            this.#droppingTables.delete(table.id);
         }
-        // The catalog goes last: until it does, the table is merely empty of live blocks, and a
-        // crash in between leaves a table whose rows are gone rather than a segment pointing at a
-        // table that is not there.
-        await this.store.removeTable(table.id, table.revision ?? 0);
-        this.#planCache.clear();
-        return true;
     }
     async insertBatch(tableName, input) {
         const table = await this.#findTable(tableName);
@@ -490,7 +618,7 @@ export class MinnowDatabase {
         const keys = autoIncrement === undefined || autoIncrement.missingIndexes.length === 0
             ? batchKeys(table, batch)
             : undefined;
-        const result = await this.#withTriggerRestarts(() => this.#writeBatch(table, batch, "insert", keys, autoIncrement));
+        const result = await this.#runWrite(() => this.#writeBatch(table, batch, "insert", keys, autoIncrement));
         collectAutoIncrementGenerated(batch, generated, autoIncrement);
         return {
             tableName: result.tableName,
@@ -525,7 +653,7 @@ export class MinnowDatabase {
         await this.#assertForeignKeysPresent(table, (column) => batch.columns[column] ?? [], (sql, params) => this.query(sql, { params, memoize: false }));
         const deferred = autoIncrement !== undefined && autoIncrement.missingIndexes.length > 0;
         const keys = deferred ? undefined : batchKeys(table, batch);
-        const result = await this.#withTriggerRestarts(() => this.#writeBatch(table, batch, "upsert", keys, autoIncrement));
+        const result = await this.#runWrite(() => this.#writeBatch(table, batch, "upsert", keys, autoIncrement));
         collectAutoIncrementGenerated(batch, generated, autoIncrement);
         return {
             ...result,
@@ -544,7 +672,7 @@ export class MinnowDatabase {
         }
         const keys = validateUpdateBatch(table, keyColumn, input);
         await this.#assertForeignKeysPresent(table, (column) => input.changes[column] ?? [], (sql, params) => this.query(sql, { params, memoize: false }));
-        return this.#withTriggerRestarts(() => this.#writeUpdateBatch(table, keyColumn, input, keys));
+        return this.#runWrite(() => this.#writeUpdateBatch(table, keyColumn, input, keys));
     }
     async update(tableName, key, changes) {
         return this.updateBatch(tableName, {
@@ -555,7 +683,7 @@ export class MinnowDatabase {
     async deleteBatch(tableName, input) {
         const dependents = await this.#childForeignKeys(tableName);
         if (dependents.length === 0) {
-            return this.#withTriggerRestarts(() => this.#deleteBatchOnce(tableName, input));
+            return this.#runWrite(() => this.#deleteBatchOnce(tableName, input));
         }
         // E141-04: the referential actions and the delete itself publish as one commit, so no tab
         // can observe a parent gone while its children still point at it.
@@ -606,14 +734,15 @@ export class MinnowDatabase {
             keys.set(token, value);
         });
         const logicalBytes = estimateValuesBytes(input.keys);
-        const transaction = await this.#transactions.begin();
+        // Deferred: the record is written only if something stages in two steps (trigger rows),
+        // and otherwise rides the single-shot commit below — or never exists, for a no-op delete.
+        const transaction = await this.#transactions.beginDeferred();
         const segmentId = this.#createId();
         transaction.setUniqueKeyChanges({
             tableId: table.id,
             keyTokens: [...keys.keys()],
             requireAbsent: false,
             remove: true,
-            ...(table.uniqueKeyStorage === undefined ? {} : { storageMode: table.uniqueKeyStorage }),
         });
         let deletedRowCount;
         let storedBytes = 0;
@@ -674,11 +803,7 @@ export class MinnowDatabase {
             const deletePreImages = (await this.#triggerPreImages(table, keyColumn, [...keys.values()], "delete")).filter((row) => row !== undefined);
             const deleteValueAt = (source, column, rowIndex) => (source === "old" ? (deletePreImages[rowIndex]?.[column] ?? null) : null);
             await this.#stageTriggerDerivedInserts(transaction, table, "delete", deletePreImages.length, deleteValueAt, "before");
-            let stageStarted = performance.now();
-            await transaction.stageBlocks(blockWrites);
-            stageMs += performance.now() - stageStarted;
-            stageStarted = performance.now();
-            await transaction.stageSegment({
+            const segment = {
                 id: segmentId,
                 tableId: table.id,
                 transactionId: transaction.id,
@@ -690,15 +815,24 @@ export class MinnowDatabase {
                 keyColumnId: keyColumn.id,
                 level: 0,
                 createdAt: this.#now().toISOString(),
-            });
-            await this.#stageTriggerDerivedInserts(transaction, table, "delete", deletePreImages.length, deleteValueAt, "after");
+            };
+            // AFTER triggers stage derived rows between the segment and the commit, which keeps the
+            // two apart; without them the stage and the commit collapse into one storage write.
+            const stagesAfter = firesAfterTriggers(table, "delete");
+            const stageStarted = performance.now();
+            if (stagesAfter) {
+                await transaction.stageArtifacts(blockWrites, [segment]);
+                await this.#stageTriggerDerivedInserts(transaction, table, "delete", deletePreImages.length, deleteValueAt, "after");
+            }
             stageMs += performance.now() - stageStarted;
             for (let attempt = 0; attempt <= this.#maxCommitRetries; attempt += 1) {
                 const commitStarted = performance.now();
                 try {
-                    const manifest = await transaction.commit();
+                    const manifest = stagesAfter
+                        ? await transaction.commit()
+                        : await transaction.stageArtifactsAndCommit(blockWrites, [segment]);
                     commitMs += performance.now() - commitStarted;
-                    this.#notifyLiveCommit();
+                    this.#afterCommit(manifest);
                     return {
                         tableName: table.name,
                         segmentId,
@@ -745,7 +879,8 @@ export class MinnowDatabase {
         const started = performance.now();
         const logicalBytes = estimateValuesBytes(input.keys) +
             Object.values(input.changes).reduce((total, values) => total + estimateValuesBytes(values), 0);
-        const transaction = await this.#transactions.begin();
+        // Deferred: the record rides the single-shot commit below unless trigger rows stage first.
+        const transaction = await this.#transactions.beginDeferred();
         const segmentId = this.#createId();
         const columnBlockIds = {};
         const changedColumns = Object.keys(input.changes).sort();
@@ -810,30 +945,36 @@ export class MinnowDatabase {
                 }
             }
             await this.#stageTriggerDerivedInserts(transaction, table, "update", input.keys.length, updateValueAt, "before");
+            const segment = {
+                id: segmentId,
+                tableId: table.id,
+                transactionId: transaction.id,
+                rowCount: input.keys.length,
+                rowIdStart: 0n,
+                rowIdEndExclusive: 0n,
+                columnBlockIds,
+                kind: "update",
+                keyColumnId: keyColumn.id,
+                level: 0,
+                createdAt: this.#now().toISOString(),
+            };
+            // AFTER triggers stage derived rows between the segment and the commit, which keeps the
+            // two apart; without them the stage and the commit collapse into one storage write.
+            const stagesAfter = firesAfterTriggers(table, "update");
             const stageStarted = performance.now();
-            await transaction.stageArtifacts(batchBlockWrites, [
-                {
-                    id: segmentId,
-                    tableId: table.id,
-                    transactionId: transaction.id,
-                    rowCount: input.keys.length,
-                    rowIdStart: 0n,
-                    rowIdEndExclusive: 0n,
-                    columnBlockIds,
-                    kind: "update",
-                    keyColumnId: keyColumn.id,
-                    level: 0,
-                    createdAt: this.#now().toISOString(),
-                },
-            ]);
-            await this.#stageTriggerDerivedInserts(transaction, table, "update", input.keys.length, updateValueAt, "after");
+            if (stagesAfter) {
+                await transaction.stageArtifacts(batchBlockWrites, [segment]);
+                await this.#stageTriggerDerivedInserts(transaction, table, "update", input.keys.length, updateValueAt, "after");
+            }
             stageMs += performance.now() - stageStarted;
             for (let attempt = 0; attempt <= this.#maxCommitRetries; attempt += 1) {
                 const commitStarted = performance.now();
                 try {
-                    const manifest = await transaction.commit();
+                    const manifest = stagesAfter
+                        ? await transaction.commit()
+                        : await transaction.stageArtifactsAndCommit(batchBlockWrites, [segment]);
                     commitMs += performance.now() - commitStarted;
-                    this.#notifyLiveCommit();
+                    this.#afterCommit(manifest);
                     return {
                         tableName: table.name,
                         segmentId,
@@ -927,7 +1068,6 @@ export class MinnowDatabase {
                     tableId: table.id,
                     keyTokens: [...resolvedKeys.keys()],
                     requireAbsent: kind === "insert",
-                    ...(table.uniqueKeyStorage === undefined ? {} : { storageMode: table.uniqueKeyStorage }),
                 });
             }
             counts =
@@ -1008,20 +1148,29 @@ export class MinnowDatabase {
             else if (upsertFirings !== undefined) {
                 await this.#stageUpsertTriggerFirings(transaction, table, input, upsertFirings, "before");
             }
-            await transaction.stageArtifacts(batchBlockWrites, [segment]);
-            if (kind === "insert") {
-                await this.#stageTriggerDerivedInserts(transaction, table, "insert", rowCount, insertValueAt, "after");
-            }
-            else if (upsertFirings !== undefined) {
-                await this.#stageUpsertTriggerFirings(transaction, table, input, upsertFirings, "after");
+            // AFTER triggers stage derived rows between the segment and the commit, which keeps the
+            // two apart; without them the stage and the commit collapse into one storage write.
+            const stagesAfter = kind === "insert"
+                ? firesAfterTriggers(table, "insert")
+                : upsertFirings !== undefined && firesAfterTriggers(table, "insert", "update");
+            if (stagesAfter) {
+                await transaction.stageArtifacts(batchBlockWrites, [segment]);
+                if (kind === "insert") {
+                    await this.#stageTriggerDerivedInserts(transaction, table, "insert", rowCount, insertValueAt, "after");
+                }
+                else if (upsertFirings !== undefined) {
+                    await this.#stageUpsertTriggerFirings(transaction, table, input, upsertFirings, "after");
+                }
             }
             stageMs += performance.now() - stageStarted;
             for (let attempt = 0; attempt <= this.#maxCommitRetries; attempt += 1) {
                 const commitStarted = performance.now();
                 try {
-                    const manifest = await transaction.commit();
+                    const manifest = stagesAfter
+                        ? await transaction.commit()
+                        : await transaction.stageArtifactsAndCommit(batchBlockWrites, [segment]);
                     commitMs += performance.now() - commitStarted;
-                    this.#notifyLiveCommit();
+                    this.#afterCommit(manifest);
                     return {
                         tableName: table.name,
                         segmentId,
@@ -1125,13 +1274,13 @@ export class MinnowDatabase {
         }
         return plan;
     }
-    async #prepareCompiledPlan(plan, options = {}) {
+    async #prepareCompiledPlan(plan, options = {}, probe) {
         // The ORDER-BY-expression desugar's wrapper is projection-only: prepare the inner block
         // directly (no derived materialization) and project each result to the visible aliases,
         // so `.search()` costs the same whether or not the caller also selects the score.
         const wrapper = transparentProjectionSource(plan);
         if (wrapper !== undefined) {
-            const prepared = await this.#prepareCompiledPlan(wrapper.inner, options);
+            const prepared = await this.#prepareCompiledPlan(wrapper.inner, options, probe);
             return {
                 sql: prepared.sql,
                 tables: prepared.tables,
@@ -1179,7 +1328,7 @@ export class MinnowDatabase {
                 });
             }
             else {
-                await this.#withSharedCatalogSnapshot(collectRealTableNames(plan), prepareAtSnapshot);
+                await this.#withSharedCatalogSnapshot(collectRealTableNames(plan), prepareAtSnapshot, probe);
             }
             return createPreparedColumnarQuery(chooseJoinOrder(resolvedPlan, columnarTables), columnarTables, memory, ftsStats === undefined ? {} : { ftsStats });
         }
@@ -1196,9 +1345,9 @@ export class MinnowDatabase {
      * write transactions. If the manifest is pruned between the read and the lease, the
      * state is re-read.
      */
-    async #withSharedCatalogSnapshot(names, action) {
+    async #withSharedCatalogSnapshot(names, action, probe) {
         for (;;) {
-            const state = await this.#cachedCatalogState(names);
+            const state = await this.#cachedCatalogState(names, probe);
             const realTables = new Map();
             names.forEach((name, index) => {
                 const table = state.tables[index];
@@ -1239,11 +1388,13 @@ export class MinnowDatabase {
      * cached state was read, so reuse is exact, not heuristic. Stores without a probe are never
      * cached. Entries key on the requested table-name set; a changed epoch clears them all.
      */
-    async #cachedCatalogState(names) {
-        const probe = this.store.getCatalogProbe?.bind(this.store);
-        if (probe === undefined)
+    async #cachedCatalogState(names, probe) {
+        // A probe the caller read moments earlier in the same statement serves: a state read under
+        // it is at least as fresh, and the cache is only consulted under its epoch.
+        const read = this.store.getCatalogProbe?.bind(this.store);
+        if (read === undefined)
             return this.#queryCatalogState(names);
-        const { catalogEpoch } = await probe();
+        const { catalogEpoch } = probe ?? (await read());
         // Table names are only trimmed, never charset-restricted, so no join separator is
         // collision-free; JSON encoding is.
         const key = JSON.stringify(names);
@@ -1292,45 +1443,83 @@ export class MinnowDatabase {
     }
     /**
      * Reuses the shared internal reader lease when it targets the requested version and has
-     * not expired; otherwise opens a fresh lease at that exact version and retires the old
-     * one once its readers drain. Returns undefined when the version's manifest disappeared
-     * between the catalog read and the lease, so the caller can re-read.
+     * not expired. Otherwise the pin has to move: with no reader left on the old version the
+     * one lease record is re-pinned in place (one storage write, instead of a create now and a
+     * remove once the old one drains); while readers remain, a fresh lease opens at the exact
+     * version and the old one retires as they finish. Returns undefined when the version's
+     * manifest disappeared between the catalog read and the lease, so the caller can re-read.
      */
     async #acquireSharedLease(version) {
-        const current = this.#sharedLease;
-        if (current?.version === version &&
-            current.lease.expiresAt.getTime() - this.#now().getTime() > 0) {
-            current.refCount += 1;
-            try {
-                await this.#renewInternalLeaseIfNeeded(current.lease);
-                return current;
+        for (;;) {
+            // A move in flight is closing the shared snapshot it re-pins; wait for it rather than
+            // hand that snapshot out, then look again.
+            if (this.#sharedLeaseMove !== undefined) {
+                await this.#sharedLeaseMove;
+                continue;
             }
-            catch (error) {
-                this.#releaseSharedLease(current);
-                throw error;
+            const current = this.#sharedLease;
+            if (current?.version === version &&
+                current.lease.expiresAt.getTime() - this.#now().getTime() > 0) {
+                current.refCount += 1;
+                try {
+                    await this.#renewInternalLeaseIfNeeded(current.lease);
+                    return current;
+                }
+                catch (error) {
+                    this.#releaseSharedLease(current);
+                    throw error;
+                }
             }
-        }
-        let lease;
-        try {
-            lease = await this.#transactions.openLeasedSnapshot({
+            const options = {
                 id: `${this.#internalLeaseOwnerId}/${String(this.#internalLeaseSequence++)}`,
                 ownerId: this.#internalLeaseOwnerId,
                 ttlMs: INTERNAL_READ_LEASE_TTL_MS,
                 version,
-            });
-        }
-        catch (error) {
-            if (error instanceof SnapshotManifestMissingError)
-                return undefined;
-            throw error;
-        }
-        const entry = { lease, version, refCount: 1 };
-        const previous = this.#sharedLease;
-        this.#sharedLease = entry;
-        if (previous?.refCount === 0) {
-            void previous.lease.release().catch(() => undefined);
+            };
+            let lease;
+            try {
+                if (current?.refCount === 0) {
+                    const move = this.#transactions.moveLeasedSnapshot(current.lease, options);
+                    this.#sharedLeaseMove = move.then(() => undefined, () => undefined);
+                    try {
+                        lease = await move;
+                    }
+                    finally {
+                        this.#sharedLeaseMove = undefined;
+                    }
+                }
+                else {
+                    lease = await this.#transactions.openLeasedSnapshot(options);
+                }
+            }
+            catch (error) {
+                if (error instanceof SnapshotManifestMissingError)
+                    return undefined;
+                throw error;
+            }
+            const entry = { lease, version, refCount: 1 };
+            const previous = this.#sharedLease;
+            this.#sharedLease = entry;
+            if (previous?.refCount === 0) {
+                // Already closed when it was the one just moved; a remove otherwise.
+                void previous.lease.release().catch(() => undefined);
+            }
+            return entry;
         }
-        return entry;
+    }
+    /**
+     * Drops the shared reader lease when nothing holds it and it has fallen behind the current
+     * version. The lease outlives the query that took it so the next query at the same version
+     * reuses it — but after a burst of writes and a fold, an idle database's last lease sits at a
+     * pre-fold version and roots every block that version referenced, which is exactly what a
+     * collection pass is trying to reclaim. The next query simply takes a fresh lease.
+     */
+    #releaseIdleSharedLease() {
+        const current = this.#sharedLease;
+        if (current?.refCount !== 0)
+            return;
+        this.#sharedLease = undefined;
+        void current.lease.release().catch(() => undefined);
     }
     #releaseSharedLease(entry) {
         entry.refCount -= 1;
@@ -1439,7 +1628,9 @@ export class MinnowDatabase {
                     }
                 }
                 const { result: inner, schema: innerSchema } = await this.#executeBlockWithSchemaCached(source.windowed.block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults);
-                const windowed = applyWindowFunctions(inner, source.windowed.windows);
+                const windowed = applyWindowFunctions(inner, source.windowed.windows, {
+                    copyRows: cacheResults,
+                });
                 const schema = [
                     ...innerSchema,
                     ...source.windowed.windows.map((window) => ({
@@ -1522,12 +1713,20 @@ export class MinnowDatabase {
             probe !== undefined;
         if (probe === undefined || !memoizable)
             return this.#queryCompiled(plan, options);
-        const key = `res ${queryResultMemoKey(sql, options.params ?? [])}`;
+        return this.#memoizedQuery(plan, `res ${queryResultMemoKey(sql, options.params ?? [])}`, options, probe);
+    }
+    /**
+     * The result memo: a pure cache over the freshness probe, keyed by the statement and the
+     * catalog epoch it was answered at. The probe read before execution is handed down to the
+     * execution itself — the view lookup and the catalog state would otherwise each probe again,
+     * and on IndexedDB every probe is a read transaction, a floor under every small query.
+     */
+    async #memoizedQuery(plan, key, options, probe) {
         const before = await probe();
         const cached = this.#cacheGet(`${key}\u0001${String(before.catalogEpoch)}`);
         if (cached !== undefined)
             return copyQueryResult(cached);
-        const result = await this.#queryCompiled(plan, options);
+        const result = await this.#queryCompiled(plan, options, before);
         const bytes = queryResultRetainedBytes(result);
         if (bytes <= RESULT_MEMO_MAX_BYTES) {
             // Cache only when the epoch did not move during execution: the result is then exactly
@@ -1545,14 +1744,14 @@ export class MinnowDatabase {
      * (E051-09), and a NATURAL join becomes the equality over the columns its sides share
      * (F401-01). Reads the catalog only for the statements that ask for one of them.
      */
-    async #applyCatalogRewrites(plan) {
+    async #applyCatalogRewrites(plan, probe) {
         const aliased = planHasSourceColumnAliases(plan);
         const natural = planHasNaturalJoins(plan);
         // Whether a name is a view cannot be read off the statement, so this is the one thing every
         // read has to ask the catalog. It asks by epoch — an O(1) probe the store already serves for
         // result memoization — and only re-reads the view set when the catalog has actually moved.
         // A database with no views therefore pays one probe, not a catalog scan per query.
-        const { views } = await this.#catalogFacts();
+        const { views } = await this.#catalogFacts(probe);
         let rewritten = plan;
         if (views.size > 0 && planReadsViews(plan, (name) => views.has(name))) {
             const bodies = new Map();
@@ -1587,8 +1786,8 @@ export class MinnowDatabase {
      * the steady state has to be one epoch probe and no allocation; the facts are rebuilt only
      * when a catalog mutation — anywhere, including another tab — moves the epoch.
      */
-    async #catalogFacts() {
-        const probe = await this.store.getCatalogProbe?.();
+    async #catalogFacts(probe) {
+        probe ??= await this.store.getCatalogProbe?.();
         const epoch = probe?.catalogEpoch;
         const cached = this.#catalogCache;
         if (cached !== undefined && epoch !== undefined && cached.epoch === epoch)
@@ -1620,13 +1819,16 @@ export class MinnowDatabase {
      * re-runs — routes through the same streaming-first execution, so builder/SQL parity holds
      * for the execution path as well as the plan.
      */
-    async #queryCompiled(plan, options = {}) {
-        plan = await this.#applyCatalogRewrites(plan);
+    async #queryCompiled(plan, options = {}, probe) {
+        // One freshness probe per query: read here unless the caller already has one, and handed
+        // to the view lookup and the catalog state below, which would otherwise probe again each.
+        probe ??= await this.store.getCatalogProbe?.();
+        plan = await this.#applyCatalogRewrites(plan, probe);
         const spillPageRows = options.spillPageRows === undefined
             ? undefined
             : positiveWholeNumber(options.spillPageRows, "Query spill page rows");
         if (this.#canStreamPlanShape(plan, options)) {
-            const streamed = await this.#queryStreamed(plan, options, spillPageRows);
+            const streamed = await this.#queryStreamed(plan, options, spillPageRows, probe);
             if (streamed !== undefined)
                 return streamed;
         }
@@ -1636,12 +1838,12 @@ export class MinnowDatabase {
             // query its streaming eligibility.
             const wrapper = transparentProjectionSource(plan);
             if (wrapper !== undefined && this.#canStreamPlanShape(wrapper.inner, options)) {
-                const streamed = await this.#queryStreamed(wrapper.inner, options, spillPageRows);
+                const streamed = await this.#queryStreamed(wrapper.inner, options, spillPageRows, probe);
                 if (streamed !== undefined)
                     return projectResultColumns(streamed, wrapper.aliases);
             }
         }
-        const prepared = await this.#prepareCompiledPlan(plan, options);
+        const prepared = await this.#prepareCompiledPlan(plan, options, probe);
         // Read the peak before close(): closing releases the context and zeroes what it tracked.
         const report = (result) => {
             options.onStats?.({ peakMemoryBytes: prepared.memoryUsage.peakBytes });
@@ -1695,11 +1897,22 @@ export class MinnowDatabase {
             const renewed = await this.store.renewTempOwner(ownerId, lease.revision, new Date(expiresAtMs).toISOString());
             leases.set(ownerId, { revision: renewed.revision, expiresAtMs });
         };
+        const batched = this.store.putTempRunPages?.bind(this.store);
         return {
             putPage: async (ownerId, runId, pageIndex, bytes) => {
                 await ensureLease(ownerId);
                 await this.store.putTempRunPage({ ownerId, runId, pageIndex, bytes });
             },
+            ...(batched === undefined
+                ? {}
+                : {
+                    putPages: async (pages) => {
+                        for (const owner of new Set(pages.map((page) => page.ownerId))) {
+                            await ensureLease(owner);
+                        }
+                        await batched(pages);
+                    },
+                }),
             getPage: async (ownerId, runId, pageIndex) => {
                 await ensureLease(ownerId);
                 return this.store.getTempRunPage(ownerId, runId, pageIndex);
@@ -1751,17 +1964,30 @@ export class MinnowDatabase {
      * refresh but never produce a stale result. Subscriptions retain a result digest, not rows.
      */
     liveQueries(options = {}) {
+        const compileLiveQuery = (query) => {
+            if (typeof query === "string")
+                return this.#compileCached(query);
+            if (query.kind === "typed-query")
+                return query.plan;
+            return bindPlanParameters(this.#compileCached(query.sql), query.params);
+        };
         const set = new LiveQuerySet({
             currentVersion: () => this.store.getCurrentManifestVersion(),
             manifestPage: (afterVersion, limit) => this.store.listManifestPage(afterVersion, limit),
             dependencyTableIds: async (query) => {
-                const compiled = typeof query === "string" ? this.#compileCached(query) : query.plan;
+                const compiled = compileLiveQuery(query);
                 // A live query over a view depends on the tables behind it, not on the view's name.
                 const plan = await this.#applyCatalogRewrites(compiled);
                 const tables = await this.#findRealBlockTables(plan);
                 return new Set([...tables.values()].map((record) => record.id));
             },
-            execute: async (query) => typeof query === "string" ? this.query(query) : this.#queryCompiled(query.plan),
+            execute: async (query) => {
+                if (typeof query === "string")
+                    return this.query(query);
+                if (query.kind === "typed-query")
+                    return this.#queryCompiled(query.plan);
+                return this.query(query.sql, { params: query.params });
+            },
             changeCanAffect: (query, tableIds, after, until) => this.#liveChangeCanAffect(query, tableIds, after, until),
         }, {
             ...options,
@@ -1774,15 +2000,20 @@ export class MinnowDatabase {
         return set;
     }
     /**
-     * Data-layer live-query selectivity: proves, when it can, that the commits in
-     * (after, until] to the given tables cannot change the query's result. Pure compaction
-     * rewrites are data-neutral; a pure-insert commit whose every new block's zone statistics
-     * reject the plan's predicates for that table cannot add a matching row. Everything else —
-     * updates, deletes, upserts (which can remove rows from a result), missing statistics,
-     * full-text plans, tables without zone-analyzable predicates — answers true.
+     * The data-layer proof behind a live sweep's zone skips: whether the commits in
+     * (after, until] to these tables can change this query's result. False only on proof —
+     * every segment the window introduced to the table is a compaction rewrite or an insert
+     * whose zone maps reject the query's predicates, and every version that changed the table
+     * left a segment to inspect.
+     *
+     * Its inputs come from `#liveProofContext`, shared by every subscription in the sweep.
      */
     async #liveChangeCanAffect(query, tableIds, after, until) {
-        const plan = typeof query === "string" ? this.#compileCached(query) : query.plan;
+        const plan = typeof query === "string"
+            ? this.#compileCached(query)
+            : query.kind === "typed-query"
+                ? query.plan
+                : bindPlanParameters(this.#compileCached(query.sql), query.params);
         if (planContainsFts(plan))
             return true;
         // Base-scan zone proofs are unsound when the plan reads the table anywhere else — a
@@ -1790,44 +2021,13 @@ export class MinnowDatabase {
         // predicates reject (e.g. `value > (SELECT AVG(value) FROM t)`).
         if (planReadsBeyondSingleScan(plan))
             return true;
-        // Versions in (after, until] that recorded a change to each table. Proof requires every
-        // one of them to be accounted for by a surviving, inspected segment: garbage collection
-        // deletes reclaimed segments outright, so "no segment in the window" is absence of
-        // evidence, not evidence of neutrality.
-        const changedVersions = new Map();
-        {
-            let cursor = after;
-            pages: for (;;) {
-                const page = await this.store.listManifestPage(cursor, 64);
-                for (const manifest of page.records) {
-                    if (manifest.version > until)
-                        break pages;
-                    for (const tableId of manifest.changedTableIds ?? []) {
-                        const versions = changedVersions.get(tableId) ?? new Set();
-                        versions.add(manifest.version);
-                        changedVersions.set(tableId, versions);
-                    }
-                    if (manifest.version === until)
-                        break pages;
-                }
-                if (page.nextCursor === null)
-                    break;
-                cursor = page.nextCursor;
-            }
-        }
+        const context = await this.#liveProofContext(after, until);
         for (const tableId of tableIds) {
-            const table = await this.store.getTable(tableId);
-            if (table === undefined)
+            const entry = await this.#liveProofTable(context, tableId);
+            if (entry === undefined)
                 return true;
-            const predicates = zonePredicates(plan, table);
-            const segments = await this.store.listSegments(tableId);
-            const transactions = new Map((await this.#transactionRecordsForSegments(segments)).map((record) => [record.id, record]));
-            const coveredVersions = new Set();
-            for (const segment of segments) {
-                const committed = transactions.get(segment.transactionId)?.committedVersion ?? null;
-                if (committed === null || committed <= (after ?? -1) || committed > until)
-                    continue;
-                coveredVersions.add(committed);
+            const predicates = zonePredicates(plan, entry.table);
+            for (const segment of entry.windowSegments) {
                 const kind = segment.kind ?? "insert";
                 // Compaction rewrites are visible-data-neutral by construction.
                 if (kind === "base")
@@ -1884,13 +2084,85 @@ export class MinnowDatabase {
             }
             // A version that changed this table but left no surviving segment to inspect (its
             // segments were compacted away and reclaimed) cannot be proven neutral.
-            for (const version of changedVersions.get(tableId) ?? []) {
-                if (!coveredVersions.has(version))
+            for (const version of context.changedVersions.get(tableId) ?? []) {
+                if (!entry.coveredVersions.has(version))
                     return true;
             }
         }
         return false;
     }
+    /**
+     * The inputs every live proof over one commit window shares: the versions in (after, until]
+     * that recorded a change to each table, and — filled in per table as proofs ask — the table
+     * record, its segments committed in the window, and the versions those segments account
+     * for. A sweep proves each subscription separately, and twenty subscriptions on one table
+     * used to list its segments and transactions twenty times, a readonly transaction each on
+     * IndexedDB and a cross-tab round trip each on an OPFS follower. A few recent windows stay
+     * resident so concurrent sets sweeping different windows do not evict each other.
+     */
+    async #liveProofContext(after, until) {
+        const key = `${String(after)}:${String(until)}`;
+        const cached = this.#liveProofContexts.get(key);
+        if (cached !== undefined)
+            return cached;
+        const context = (async () => {
+            // Proof requires every version to be accounted for by a surviving, inspected segment:
+            // garbage collection deletes reclaimed segments outright, so "no segment in the window"
+            // is absence of evidence, not evidence of neutrality.
+            const changedVersions = new Map();
+            let cursor = after;
+            pages: for (;;) {
+                const page = await this.store.listManifestPage(cursor, 64);
+                for (const manifest of page.records) {
+                    if (manifest.version > until)
+                        break pages;
+                    for (const tableId of manifest.changedTableIds ?? []) {
+                        const versions = changedVersions.get(tableId) ?? new Set();
+                        versions.add(manifest.version);
+                        changedVersions.set(tableId, versions);
+                    }
+                    if (manifest.version === until)
+                        break pages;
+                }
+                if (page.nextCursor === null)
+                    break;
+                cursor = page.nextCursor;
+            }
+            return { after, until, changedVersions, tables: new Map() };
+        })();
+        this.#liveProofContexts.set(key, context);
+        if (this.#liveProofContexts.size > LIVE_PROOF_CONTEXT_LIMIT) {
+            const oldest = this.#liveProofContexts.keys().next().value;
+            if (oldest !== undefined)
+                this.#liveProofContexts.delete(oldest);
+        }
+        return context;
+    }
+    #liveProofTable(context, tableId) {
+        const cached = context.tables.get(tableId);
+        if (cached !== undefined)
+            return cached;
+        const entry = (async () => {
+            const table = await this.store.getTable(tableId);
+            if (table === undefined)
+                return undefined;
+            const segments = await this.store.listSegments(tableId);
+            const transactions = new Map((await this.#transactionRecordsForSegments(segments)).map((record) => [record.id, record]));
+            const windowSegments = [];
+            const coveredVersions = new Set();
+            for (const segment of segments) {
+                const committed = transactions.get(segment.transactionId)?.committedVersion ?? null;
+                if (committed === null || committed <= (context.after ?? -1) || committed > context.until) {
+                    continue;
+                }
+                coveredVersions.add(committed);
+                windowSegments.push(segment);
+            }
+            return { table, windowSegments, coveredVersions };
+        })();
+        context.tables.set(tableId, entry);
+        return entry;
+    }
     /**
      * True when every manifest published in (after, until] changed no row in any table: the
      * explicitly empty `changedTableIds` that compaction publishes through
@@ -1942,29 +2214,168 @@ export class MinnowDatabase {
     #maybeScheduleAutoCompaction(table, segments) {
         if (!this.#autoCompact)
             return;
-        const deltas = segments.filter((segment) => {
-            const kind = segment.kind ?? "insert";
-            return kind !== "insert" && kind !== "base";
-        }).length;
-        if (segments.length < AUTO_COMPACT_SCAN_SEGMENTS && deltas < AUTO_COMPACT_DELTA_SEGMENTS) {
+        if (this.#droppingTables.has(table.id))
+            return;
+        if (!autoCompactionDue(segments))
             return;
-        }
         if (segments.length < (this.#autoCompactionBackoff.get(table.id) ?? 0))
             return;
-        if (this.#autoCompactionsInFlight.has(table.id))
+        if (this.#autoCompactionsInFlight.has(table.id)) {
+            // A final burst can cross the threshold while the prior fold is still planning or
+            // running. Remember it: otherwise no later commit or scan may arrive to trigger the fold
+            // that the final state still needs.
+            this.#autoCompactionsRequested.add(table.id);
             return;
+        }
         this.#autoCompactionsInFlight.add(table.id);
-        void this.compactTableStep(table.name, { maxBlocks: 4 })
-            .then(() => {
-            this.#autoCompactionBackoff.delete(table.id);
+        void this.#runAutoCompaction(table)
+            .then((folded) => {
+            if (folded)
+                this.#autoCompactionBackoff.delete(table.id);
+            else {
+                this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, segments.length * 2)));
+            }
         })
             .catch(() => {
-            this.#autoCompactionBackoff.set(table.id, Math.max(2, segments.length * 2));
+            // Back off deterministic failures, but never beyond the maximum L0 prefix a fold can
+            // consume. A transient conflict near the end of a burst must not strand hundreds of
+            // segments waiting for a segment count the idle database can never reach.
+            this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, segments.length * 2)));
         })
             .finally(() => {
             this.#autoCompactionsInFlight.delete(table.id);
+            if (this.#autoCompactionsRequested.delete(table.id)) {
+                void yieldToEventLoop().then(() => this.#checkAutoCompaction(table.id));
+            }
         });
     }
+    /**
+     * Plans a compaction job and drives it to publication in small steps, yielding to the event
+     * loop between them so queries and writes interleave with the maintenance; then, while the
+     * table is still due, plans the next. A job that only advanced when the next scan happened
+     * to trigger it would sit half-written in an idle tab, its output staged and its sources
+     * still read on every query, and the deltas that landed while it ran would wait for a scan
+     * that may never come. Returns whether anything was folded: a table compaction cannot help
+     * (an unsupported layout, keys living in published partitions) must not be re-planned on
+     * every trigger, so the caller backs it off as it would a failure.
+     */
+    async #runAutoCompaction(table) {
+        const options = {
+            maxBlocks: AUTO_COMPACT_STEP_BLOCKS,
+            maxLevel0Segments: AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS,
+        };
+        let folded = false;
+        for (;;) {
+            if (this.#droppingTables.has(table.id))
+                return folded;
+            let progress = await this.compactTableStep(table.name, options);
+            while (progress.result === null) {
+                if (progress.jobId === null)
+                    throw new Error("Compaction progress lost its job ID");
+                await yieldToEventLoop();
+                progress = await this.resumeCompactionJob(progress.jobId, options);
+            }
+            if (!progress.result.compacted)
+                return folded;
+            folded = true;
+            // The fold's sources are garbage now; collect before planning the next fold.
+            this.#maybeScheduleAutoCollection();
+            await yieldToEventLoop();
+            const current = await this.store.getTable(table.id);
+            if (current === undefined ||
+                !autoCompactionDue(await this.#currentVisibleSegments(current))) {
+                return folded;
+            }
+        }
+    }
+    /** The table's visible segments at the current manifest. */
+    async #currentVisibleSegments(table) {
+        // This is an optimistic metadata read, not a user snapshot: taking a durable reader lease
+        // here would add a readwrite transaction to whichever foreground write happened to trigger
+        // maintenance. Verify the manifest did not move while its segment records were loaded; the
+        // current manifest itself cannot be pruned, so a matching version is the same stability proof
+        // without persistent state. Do not chase a busy writer forever: this probe is only a hint,
+        // periodic checks keep arriving during the burst, and the quiet-tail check gets a stable view
+        // once it ends.
+        let segments = [];
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const manifest = await this.store.getCurrentManifest();
+            segments = await this.#visibleSegmentRecords(table, new Snapshot(this.store, manifest?.version ?? null, manifest?.blockIds ?? []));
+            if ((await this.store.getCurrentManifestVersion()) === (manifest?.version ?? null)) {
+                return segments;
+            }
+        }
+        return segments;
+    }
+    /**
+     * What every data commit shares: live sets learn of it, and the tables it changed count
+     * toward their next write-path auto-compaction check.
+     */
+    #afterCommit(manifest) {
+        this.#notifyLiveCommit();
+        this.#commitsSinceCollection += 1;
+        const now = this.#now().getTime();
+        if (this.#commitsSinceCollection >= AUTO_COLLECT_COMMIT_INTERVAL ||
+            (this.#lastCollectionAt !== undefined &&
+                now - this.#lastCollectionAt >= AUTO_COLLECT_QUIET_MS)) {
+            this.#maybeScheduleAutoCollection();
+        }
+        this.#armIdleCollection();
+        if (!this.#autoCompact)
+            return;
+        for (const tableId of manifest.changedTableIds ?? []) {
+            this.#idleCompactionTableIds.add(tableId);
+            const commits = (this.#commitsSinceCompactionCheck.get(tableId) ?? 0) + 1;
+            if (commits < AUTO_COMPACT_COMMIT_CHECK_INTERVAL) {
+                this.#commitsSinceCompactionCheck.set(tableId, commits);
+                continue;
+            }
+            this.#commitsSinceCompactionCheck.delete(tableId);
+            void this.#checkAutoCompaction(tableId);
+        }
+        this.#armIdleCompactionCheck();
+    }
+    /**
+     * Debounces the final write-path check for a burst. Sampling every few commits keeps the hot
+     * path cheap, but the last one through seven commits can be the ones that cross a fold
+     * threshold. Without this check an idle table can remain due forever because no later write or
+     * scan arrives to notice it.
+     */
+    #armIdleCompactionCheck() {
+        if (this.#idleCompactionTableIds.size === 0)
+            return;
+        if (this.#idleCompactionTimer !== undefined)
+            clearTimeout(this.#idleCompactionTimer);
+        const timer = setTimeout(() => {
+            this.#idleCompactionTimer = undefined;
+            const tableIds = [...this.#idleCompactionTableIds];
+            this.#idleCompactionTableIds.clear();
+            for (const tableId of tableIds) {
+                this.#commitsSinceCompactionCheck.delete(tableId);
+                void this.#checkAutoCompaction(tableId);
+            }
+        }, AUTO_COMPACT_IDLE_CHECK_MS);
+        timer.unref?.();
+        this.#idleCompactionTimer = timer;
+    }
+    /**
+     * The write-path auto-compaction check: the table's visible segments at the current manifest,
+     * judged by the same thresholds a streamed scan applies. Without it a write-heavy phase with
+     * no reads in between piles deltas up unfolded, and the next query pays for all of them at
+     * once. Background maintenance never surfaces through a write; a failed check waits for the
+     * next one.
+     */
+    async #checkAutoCompaction(tableId) {
+        try {
+            const table = await this.store.getTable(tableId);
+            if (table === undefined)
+                return;
+            this.#maybeScheduleAutoCompaction(table, await this.#currentVisibleSegments(table));
+        }
+        catch {
+            // Deliberately silent: the next commit or scan checks again.
+        }
+    }
     /**
      * Persists one AFTER trigger on its table record (compare-and-swap with retry, like
      * migration). Validation is CREATE-time so firing can trust the record: events bind only
@@ -2429,7 +2840,25 @@ export class MinnowDatabase {
                 open();
                 return this.#sessionQuery(transaction, sql, options);
             },
-            insertBatch: async (tableName, input) => {
+            execute: async (sql, params) => {
+                open();
+                const compiled = compileStatement(sql);
+                if (compiled.kind === "select") {
+                    return {
+                        kind: "rows",
+                        result: await this.#sessionQuery(transaction, compiled.sql, params === undefined ? {} : { params }),
+                    };
+                }
+                const statement = bindStatementParameters(compiled, params);
+                if (!isTransactionalStatement(statement)) {
+                    throw new TypeError(`${statement.kind.toUpperCase().replace("-", " ")} is not allowed inside a write scope`);
+                }
+                // Guard the whole SQL statement as one stage. Some INSERT forms perform more than one
+                // batch operation; if a later step fails after an earlier one staged work, the caller
+                // must not be able to catch the error and commit only part of the statement.
+                return writer.executeStatement(statement);
+            },
+            insertBatch: async (tableName, input) => {
                 open();
                 staged += 1;
                 return guarded(() => this.#sessionInsert(transaction, tableName, input, "insert"));
@@ -2450,8 +2879,16 @@ export class MinnowDatabase {
                 return guarded(() => this.#sessionDelete(transaction, tableName, input));
             },
         };
+        const writer = {
+            ...session,
+            queryPlan: (plan) => this.#sessionQueryPlan(transaction, plan),
+            executeStatement: (statement) => {
+                open();
+                return guarded(() => this.runStatement(statement, { writer }));
+            },
+        };
         try {
-            const result = await action(session, transaction);
+            const result = await action(session, transaction, writer);
             closed = true;
             if (poisoned !== undefined) {
                 // The outer catch aborts the transaction.
@@ -2464,7 +2901,7 @@ export class MinnowDatabase {
             for (let attempt = 0; attempt <= this.#maxCommitRetries; attempt += 1) {
                 try {
                     const manifest = await transaction.commit();
-                    this.#notifyLiveCommit();
+                    this.#afterCommit(manifest);
                     return { result, version: manifest.version };
                 }
                 catch (error) {
@@ -2600,7 +3037,7 @@ export class MinnowDatabase {
     }
     async #sessionInsert(transaction, tableName, input, kind, cascadeBudget = 1) {
         const table = await this.#findTable(tableName);
-        const { batch, autoIncrement, rowCount } = this.#fillDefaults(table, input);
+        const { batch, generated, autoIncrement, rowCount } = this.#fillDefaults(table, input);
         await this.#assertForeignKeysPresent(table, (column) => batch.columns[column] ?? [], (sql, params) => this.#sessionQuery(transaction, sql, { params }), transaction);
         if (autoIncrement !== undefined && autoIncrement.missingIndexes.length > 0) {
             const values = await this.store.reserveAutoIncrement(table.id, autoIncrement.column.id, autoIncrement.missingIndexes.length, autoIncrement.atLeast);
@@ -2616,7 +3053,6 @@ export class MinnowDatabase {
                 tableId: table.id,
                 keyTokens: [...keys.keys()],
                 requireAbsent: kind === "insert",
-                ...(table.uniqueKeyStorage === undefined ? {} : { storageMode: table.uniqueKeyStorage }),
             });
         }
         const rowIds = await this.store.reserveRowIds(table.id, rowCount);
@@ -2646,7 +3082,13 @@ export class MinnowDatabase {
         else if (sessionUpsertFirings !== undefined) {
             await this.#stageUpsertTriggerFirings(transaction, table, batch, sessionUpsertFirings, "after", cascadeBudget);
         }
-        return { tableName: table.name, segmentId, rowCount };
+        collectAutoIncrementGenerated(batch, generated, autoIncrement);
+        return {
+            tableName: table.name,
+            segmentId,
+            rowCount,
+            ...(generated.size === 0 ? {} : { generatedColumns: Object.fromEntries(generated) }),
+        };
     }
     async #sessionUpdate(transaction, tableName, input, cascadeBudget = 1) {
         const table = await this.#findTable(tableName);
@@ -2765,7 +3207,6 @@ export class MinnowDatabase {
             keyTokens: [...keys.keys()],
             requireAbsent: false,
             remove: true,
-            ...(table.uniqueKeyStorage === undefined ? {} : { storageMode: table.uniqueKeyStorage }),
         });
         // Fire only per existing row (session-visible state included): missing keys must not
         // produce phantom all-null OLD images.
@@ -2815,7 +3256,14 @@ export class MinnowDatabase {
     }
     /** Executes a built ORM query through the same streaming-first pipeline as compiled SQL. */
     async run(query) {
-        return (await this.#queryCompiled(query.plan)).rows;
+        const probe = this.store.getCatalogProbe?.bind(this.store);
+        // The same memo a SQL query gets, keyed by the plan: a typed query is compiled once by the
+        // builder and run many times, and it used to re-execute on every run.
+        if (probe === undefined || query.plan.usesStatementDatetime === true) {
+            return (await this.#queryCompiled(query.plan)).rows;
+        }
+        return (await this.#memoizedQuery(query.plan, `typed ${planMemoKey(query.plan)}`, {}, probe))
+            .rows;
     }
     /**
      * Applies a schema definition to the catalog through metadata-only steps: creating missing
@@ -3209,10 +3657,11 @@ export class MinnowDatabase {
             // together or not at all. Schema changes are refused rather than silently auto-committed:
             // the catalog is not part of the scope, so a DDL statement inside one would land even if
             // the transaction rolled back.
-            if (!isTransactionalStatement(statement)) {
-                throw new TypeError(`${statement.kind.toUpperCase().replace("-", " ")} is not allowed inside a transaction`);
+            const boundStatement = bindStatementParameters(statement, params);
+            if (!isTransactionalStatement(boundStatement)) {
+                throw new TypeError(`${boundStatement.kind.toUpperCase().replace("-", " ")} is not allowed inside a transaction`);
             }
-            return this.#duringTransaction(open, () => this.runStatement(bindStatementParameters(statement, params), { writer: open.session }));
+            return this.#duringTransaction(open, () => open.session.executeStatement(boundStatement));
         }
         return this.runStatement(bindStatementParameters(statement, params));
     }
@@ -3367,11 +3816,8 @@ export class MinnowDatabase {
             const decided = new Promise((resolve) => {
                 settle = resolve;
             });
-            const finished = this.#openWriteScope(async (session, transaction) => {
-                start({
-                    ...session,
-                    queryPlan: (plan) => this.#sessionQueryPlan(transaction, plan),
-                });
+            const finished = this.#openWriteScope(async (_session, _transaction, writer) => {
+                start(writer);
                 if ((await decided) === "rollback")
                     throw new TransactionRollback();
                 return null;
@@ -3455,7 +3901,7 @@ export class MinnowDatabase {
         }
         const assigned = statement.onConflict.columns ?? [];
         const keyToken = (value) => value instanceof Date ? `d${value.toISOString()}` : `${typeof value} ${String(value)}`;
-        const { result: returnedRows, version } = await this.write(async (transaction) => {
+        const apply = async (transaction) => {
             const existing = await this.#existingInsertKeys(table, keyColumn, statement, (sql, params) => transaction.query(sql, { params }));
             const freshRows = [];
             const conflictingRows = [];
@@ -3506,12 +3952,22 @@ export class MinnowDatabase {
                 const row = rowsByKey.get(keyToken(key)) ?? {};
                 return Object.fromEntries(returningColumns.map((name) => [name, row[name] ?? null]));
             });
-        });
+        };
+        let returnedRows;
+        let version;
+        if (options.writer === undefined) {
+            const completed = await this.write(apply);
+            returnedRows = completed.result;
+            version = completed.version;
+        }
+        else {
+            returnedRows = await apply(options.writer);
+        }
         return {
             kind: "insert",
             table: statement.table,
             rowCount: statement.rows.length,
-            ...(version === null ? {} : { version }),
+            ...(version === null || version === undefined ? {} : { version }),
             ...(returnedRows === undefined ? {} : { returnedRows }),
         };
     }
@@ -3528,7 +3984,7 @@ export class MinnowDatabase {
         return new Set(result.rows.map((row) => keyToken(row.key ?? null)));
     }
     /** ON CONFLICT DO NOTHING: drops insert rows whose unique key already exists at a snapshot. */
-    async #filterConflictingInsertRows(statement) {
+    async #filterConflictingInsertRows(statement, writer) {
         const table = await this.#findTable(statement.table);
         const keyColumn = getUniqueKeyColumn(table);
         if (keyColumn === undefined || statement.onConflict?.column !== keyColumn.name) {
@@ -3554,17 +4010,13 @@ export class MinnowDatabase {
             having: [],
             orderBy: [],
         };
-        const prepared = await this.#prepareCompiledPlan(plan);
-        let existing;
-        try {
-            existing = new Set(prepared.execute().rows.map((row) => {
-                const value = row.key ?? null;
-                return value instanceof Date ? value.toISOString() : value;
-            }));
-        }
-        finally {
-            prepared.close();
-        }
+        // The streaming-first pipeline: a keyed IN list narrows to the blocks that can hold the
+        // keys, where the prepared path materialized the table's columns first.
+        const existingRows = writer === undefined ? await this.#queryCompiled(plan) : await writer.queryPlan(plan);
+        const existing = new Set(existingRows.rows.map((row) => {
+            const value = row.key ?? null;
+            return value instanceof Date ? value.toISOString() : value;
+        }));
         return {
             ...statement,
             rows: statement.rows.filter((row) => {
@@ -3657,16 +4109,22 @@ export class MinnowDatabase {
             ...(version === null ? {} : { version }),
         };
     }
-    async #materializeInsertSelect(statement) {
+    async #materializeInsertSelect(statement, writer) {
         if (statement.query === undefined)
             return statement;
-        const prepared = await this.#prepareCompiledPlan(statement.query);
         let result;
-        try {
-            result = prepared.execute();
+        if (writer === undefined) {
+            const prepared = await this.#prepareCompiledPlan(statement.query);
+            try {
+                result = prepared.execute();
+            }
+            finally {
+                prepared.close();
+            }
         }
-        finally {
-            prepared.close();
+        else {
+            const plan = await this.#applyCatalogRewrites(statement.query);
+            result = await writer.queryPlan(plan);
         }
         const { query, ...rest } = statement;
         void query;
@@ -3789,10 +4247,10 @@ export class MinnowDatabase {
             options = { ...options, returning: statement.returning };
         }
         if (statement.kind === "insert" && statement.query !== undefined) {
-            statement = await this.#materializeInsertSelect(statement);
+            statement = await this.#materializeInsertSelect(statement, options.writer);
         }
         if (statement.kind === "insert" && statement.onConflict?.action === "nothing") {
-            statement = await this.#filterConflictingInsertRows(statement);
+            statement = await this.#filterConflictingInsertRows(statement, options.writer);
         }
         if (statement.kind === "insert" && statement.onConflict?.action === "update") {
             return this.#mergeConflictingInsertRows(statement, options);
@@ -3907,13 +4365,10 @@ export class MinnowDatabase {
             rows = (await options.writer.queryPlan(plan)).rows;
         }
         else {
-            const prepared = await this.#prepareCompiledPlan(plan);
-            try {
-                rows = prepared.execute().rows;
-            }
-            finally {
-                prepared.close();
-            }
+            // The same streaming-first pipeline a SELECT takes: its zone pruning and ascending-range
+            // narrowing find the rows to touch, where the prepared path materialized the table's
+            // columns first — most of a bulk delete's cost, at 200k rows.
+            rows = (await this.#queryCompiled(plan)).rows;
         }
         const keys = rows.map((row) => row[keyColumn.name]);
         if (keys.some((key) => key === null || key === undefined)) {
@@ -4011,13 +4466,13 @@ export class MinnowDatabase {
      * Returns undefined when the base table's visible shape is ineligible (keyed mutation replay),
      * so the caller falls back to the materialized path.
      */
-    async #queryStreamed(plan, options, spillPageRows) {
+    async #queryStreamed(plan, options, spillPageRows, probe) {
         const tableNames = [plan.base.table, ...plan.joins.map((join) => join.table)];
         const uniqueTableNames = [...new Set(tableNames)];
         if (options.version === undefined) {
             // The common path shares the probe-gated catalog state and the shared reader lease
             // with every other statement at the current version.
-            return this.#withSharedCatalogSnapshot(uniqueTableNames, (snapshot, realTables, visibility) => this.#queryStreamedAtSnapshot(plan, options, spillPageRows, snapshot, [...realTables.values()], visibility));
+            return this.#withSharedCatalogSnapshot(uniqueTableNames, (snapshot, realTables, visibility) => this.#queryStreamedAtSnapshot(plan, options, spillPageRows, snapshot, [...realTables.values()], visibility), probe);
         }
         // Explicit time travel keeps the per-call lease and version-anchored reads.
         const tables = await Promise.all(uniqueTableNames.map((name) => this.#findTable(name)));
@@ -4620,19 +5075,6 @@ export class MinnowDatabase {
             load,
         };
     }
-    /**
-     * Builds a streamed view of a keyed table whose visible history contains update and delete
-     * segments (no upserts — those interleave new rows into slot order and keep the materialized
-     * path). Mutation deltas are the small part of such a history, so they replay into resident
-     * state — a dead-row bitmap over the base rows plus per-slot column patches referencing the
-     * resident update vectors — while the base rows stream through the existing block-aligned
-     * inner window. The outer view compacts dead rows and overlays patches per window, producing
-     * exactly the materialized replay's rows in exactly its order.
-     *
-     * The replay tracks only mutation-touched key tokens, so its memory is bounded by the
-     * mutation size, not the table; the duplicate-key corruption guard consequently only fires
-     * for touched keys on this path.
-     */
     /**
      * Block header/metadata descriptions, cached and fetched in one round trip: no decompress and
      * no payload validation. Descriptions are immutable per block id, so a repeated query pays
@@ -4664,24 +5106,232 @@ export class MinnowDatabase {
         }
         return descriptions;
     }
+    /**
+     * Builds a streamed view of a keyed table whose visible history contains update and delete
+     * segments (no upserts — those interleave new rows into slot order and keep the materialized
+     * path). Mutation deltas are the small part of such a history, so they replay into resident
+     * state — a dead-row bitmap over the base rows plus per-slot column patches referencing the
+     * resident update vectors — while the base rows stream through the block-aligned inner
+     * window. The outer view compacts dead rows and overlays patches per window, producing
+     * exactly the materialized replay's rows in exactly its order.
+     *
+     * The replay is a pure function of the visible segment set, so it is built once per commit
+     * and shared by every query until the next one (`#streamedOverlayState`). The outer loader
+     * serves whole inner windows: one whose rows nothing touched is installed by reference, the
+     * difference between a copy per window and none; one with a dead or patched row is compacted
+     * once, in runs rather than cells.
+     *
+     * The replay tracks only mutation-touched keys, so its memory is bounded by the mutation
+     * size, not the table; the duplicate-key corruption guard consequently only fires for
+     * touched keys on this path.
+     */
     async #createStreamedMutationTable(table, keyColumn, projectedColumns, baseSegments, snapshot, memory, zonePruned = false, storedBlocks) {
         const scanSegments = baseSegments.filter((segment) => {
             const kind = segment.kind ?? "insert";
             return kind === "insert" || kind === "base";
         });
-        // Phase A: materialize each mutation segment's key vector (and an update's changed
-        // projected columns) — resident and reserved, bounded by the mutation history's size.
+        const overlay = await this.#streamedOverlayState(table, keyColumn, baseSegments, scanSegments, snapshot, memory, zonePruned);
+        const { baseRows, dead, deadCount, patches, patchedSlots } = overlay;
+        const hasPatches = patchedSlots.length > 0;
+        const outputRows = baseRows - deadCount;
+        const inner = this.#createStreamedTable(table, projectedColumns, scanSegments, snapshot, baseRows, memory, storedBlocks);
+        // Deltas that touch no row this scan reads — every one of them eliminated with its row
+        // group, or aimed at keys this table no longer holds — leave the scan exactly as it was.
+        if (deadCount === 0 && !hasPatches)
+            return inner;
+        const states = projectedColumns.map((column) => ({
+            column,
+            vector: createStreamedColumnVector(column.type, outputRows),
+            reservations: [],
+        }));
+        // Forward-only cursor: cursorOutput live rows exist strictly before base row cursorBase.
+        let cursorOutput = 0;
+        let cursorBase = 0;
+        const load = async (start, length) => {
+            const end = Math.min(start + length, outputRows);
+            // COUNT(*) and friends project nothing: the replay already knows how many rows survive,
+            // so there is no window to build and no reason to walk the base rows to build it.
+            if (states.length === 0)
+                return end;
+            const window = states[0]?.vector.window;
+            if (window !== undefined && start >= window.start && start < window.start + window.length) {
+                return window.start + window.length;
+            }
+            if (window !== undefined && start < window.start) {
+                throw new Error(`Streamed scan moved backward: ${table.name}`);
+            }
+            // The cursor stops at the end of the window it last served, which can sit past a start
+            // that falls before it. Rewinding costs one pass over the dead-row bitmap.
+            if (cursorOutput > start) {
+                cursorOutput = 0;
+                cursorBase = 0;
+            }
+            while (cursorOutput < start && cursorBase < baseRows) {
+                if (!bitmapHasValue(dead, cursorBase))
+                    cursorOutput += 1;
+                cursorBase += 1;
+            }
+            // Skip the dead rows in front of the first live one, so a window never starts dead.
+            while (cursorBase < baseRows && bitmapHasValue(dead, cursorBase))
+                cursorBase += 1;
+            if (cursorOutput !== start || cursorBase >= baseRows) {
+                throw new Error(`Column row count mismatch: ${table.name}`);
+            }
+            const baseStart = cursorBase;
+            // The inner loader serves whole blocks; the outer window covers the suffix of the inner
+            // window from baseStart, however long, and the caller clamps to what it asked for.
+            const innerEnd = await inner.load(baseStart, baseRows - baseStart);
+            const baseEnd = typeof innerEnd === "number" ? Math.min(innerEnd, baseRows) : baseRows;
+            if (baseEnd <= baseStart)
+                throw new Error(`Column row count mismatch: ${table.name}`);
+            const deadInWindow = bitmapCountRange(dead, baseStart, baseEnd);
+            const patchedInWindow = hasPatches ? sortedCountRange(patchedSlots, baseStart, baseEnd) : 0;
+            const liveRows = baseEnd - baseStart - deadInWindow;
+            const untouched = deadInWindow === 0 && patchedInWindow === 0;
+            const runs = untouched
+                ? undefined
+                : overlayWindowRuns(dead, patchedSlots, baseStart, baseEnd, patchedInWindow);
+            const targets = [];
+            try {
+                for (const state of states) {
+                    const innerVector = inner.table.columns.get(state.column.name);
+                    const innerWindow = innerVector?.window;
+                    if (innerVector === undefined || innerWindow === undefined) {
+                        throw new Error(`Streamed column is missing: ${state.column.name}`);
+                    }
+                    const offset = baseStart - innerWindow.start;
+                    if (offset < 0 || offset + (baseEnd - baseStart) > innerWindow.length) {
+                        throw new Error(`Column row count mismatch: ${state.column.name}`);
+                    }
+                    const replacements = [];
+                    const fields = runs === undefined
+                        ? overlayWindowView(innerVector, offset, liveRows, memory, state.column, replacements)
+                        : overlayWindowCompacted(innerVector, innerWindow.start, runs, liveRows, hasPatches ? patches : undefined, state.column, memory, replacements);
+                    fields.window = { start, length: liveRows };
+                    targets.push({ state, fields, replacements });
+                }
+                // Every fallible byte is reserved above; the installs below cannot throw, so a budget
+                // overflow leaves every state's previous window and reservations intact.
+                for (const { state, fields, replacements } of targets) {
+                    const mutable = state.vector;
+                    mutable.validity = fields.validity;
+                    if (fields.values !== undefined)
+                        mutable.values = fields.values;
+                    if (fields.codes !== undefined) {
+                        mutable.codes = fields.codes;
+                        mutable.dictionary = fields.dictionary ?? [];
+                    }
+                    mutable.window = fields.window;
+                    for (const previous of state.reservations)
+                        previous.release();
+                    state.reservations = replacements;
+                }
+            }
+            catch (error) {
+                for (const entry of targets) {
+                    for (const replacement of entry.replacements)
+                        replacement.release();
+                }
+                throw error;
+            }
+            cursorOutput = start + liveRows;
+            cursorBase = baseEnd;
+            return start + liveRows;
+        };
+        return {
+            table: {
+                name: table.name,
+                rowCount: outputRows,
+                columns: new Map(states.map((state) => [state.column.name, state.vector])),
+            },
+            load,
+        };
+    }
+    /**
+     * The replayed mutation state for one visible segment set: which base rows are dead, and
+     * which columns of which slots an update replaced. Cached under the segment ids in the
+     * artifact LRU, because nothing about it changes between commits — before this, every query
+     * over a table with so much as one deleted row rebuilt it, which made COUNT(*) on such a
+     * table cost twenty times what it costs on a clean one. A cache hit is charged to the
+     * query's memory as a tally, the same bytes a build reserves.
+     */
+    async #streamedOverlayState(table, keyColumn, baseSegments, scanSegments, snapshot, memory, zonePruned) {
+        // A zone-pruned scan keeps a segment's id with a subset of its blocks, and the slots the
+        // replay addresses are the key blocks' rows in order — so the key blocks, not the segment
+        // ids alone, are what identify the state.
+        const key = [
+            "overlay",
+            table.id,
+            zonePruned ? "pruned" : "full",
+            baseSegments
+                .map((segment) => mutationSegmentKind(segment)
+                ? segment.id
+                : `${segment.id}:${(segment.columnBlockIds[keyColumn.id] ?? []).join("+")}`)
+                .join(","),
+        ].join(" ");
+        const cached = this.#cacheGet(key);
+        if (cached !== undefined) {
+            memory.tally(cached.bytes, "Streamed mutation replay");
+            return cached;
+        }
+        const state = await this.#buildStreamedOverlayState(table, keyColumn, baseSegments, scanSegments, snapshot, memory, zonePruned);
+        this.#cachePut(key, state, state.bytes);
+        return state;
+    }
+    async #buildStreamedOverlayState(table, keyColumn, baseSegments, scanSegments, snapshot, memory, zonePruned) {
+        // Phase A: each mutation segment's key vector, and every column an update changed —
+        // resident and reserved, bounded by the mutation history's size. All of an update's
+        // columns, not only the ones this query projects: the state outlives the query. The
+        // history's blocks come out of the buffer pool in one round trip, as block vectors: one
+        // await per segment is what made a table with a few hundred deltas pay ten milliseconds
+        // to rebuild this state after every commit.
+        const deltaSegments = baseSegments.filter(mutationSegmentKind);
+        const deltaBlockIds = new Set();
+        for (const segment of deltaSegments) {
+            for (const column of table.columns) {
+                for (const blockId of segment.columnBlockIds[column.id] ?? [])
+                    deltaBlockIds.add(blockId);
+            }
+        }
+        const decodedDeltaBlocks = new Map();
+        if (deltaBlockIds.size > 0) {
+            const ids = [...deltaBlockIds];
+            const decoded = await this.#decodedBlocksThroughCache(ids, snapshot);
+            ids.forEach((id, index) => {
+                const block = decoded[index];
+                if (block !== undefined)
+                    decodedDeltaBlocks.set(id, block);
+            });
+        }
+        const deltaVector = async (column, segment) => {
+            const blockIds = segment.columnBlockIds[column.id] ?? [];
+            const blockId = blockIds[0];
+            if (blockIds.length !== 1 || blockId === undefined) {
+                // A delta written in more than one block — a bulk update past rowsPerBlock — concatenates.
+                return this.#materializeAppendColumnVector(column, [segment], snapshot, segment.rowCount);
+            }
+            const decoded = decodedDeltaBlocks.get(blockId);
+            if (decoded === undefined)
+                throw new Error(`Visible block is missing: ${blockId}`);
+            if (decoded.column.type !== column.type) {
+                throw new Error(`Column type mismatch: ${column.name}`);
+            }
+            const vector = this.#blockColumnVector(blockId, decoded);
+            if (vector.length !== segment.rowCount) {
+                throw new Error(`Column row count mismatch: ${column.name}`);
+            }
+            return vector;
+        };
         const mutationKeyVectors = new Map();
         const mutationChangedVectors = new Map();
         // Keys as the primitives the vectors already hold. The replay used to build one string
         // token per row on both sides, which made a single deleted row cost an allocation and a
         // hash of every key in the table.
         const touched = new Set();
-        for (const segment of baseSegments) {
+        let retainedBytes = 0;
+        for (const segment of deltaSegments) {
             const kind = segment.kind ?? "insert";
-            if (kind !== "update" && kind !== "delete")
-                continue;
-            const keyVector = await this.#materializeAppendColumnVector(keyColumn, [segment], snapshot, segment.rowCount);
+            const keyVector = await deltaVector(keyColumn, segment);
             memory.reserve(columnVectorRetainedBytes(keyVector), "Streamed mutation replay");
             mutationKeyVectors.set(segment.id, keyVector);
             const readMutationKey = requiredColumnVectorKeyReader(keyVector);
@@ -4690,20 +5340,22 @@ export class MinnowDatabase {
             }
             if (kind === "update") {
                 const changed = new Map();
-                for (const column of projectedColumns) {
+                for (const column of table.columns) {
                     if (column.id === keyColumn.id)
                         continue;
                     if ((segment.columnBlockIds[column.id]?.length ?? 0) === 0)
                         continue;
-                    const vector = await this.#materializeAppendColumnVector(column, [segment], snapshot, segment.rowCount);
-                    memory.reserve(columnVectorRetainedBytes(vector), "Streamed mutation replay");
+                    const vector = await deltaVector(column, segment);
+                    const bytes = columnVectorRetainedBytes(vector);
+                    memory.reserve(bytes, "Streamed mutation replay");
+                    retainedBytes += bytes;
                     changed.set(column.id, vector);
                 }
                 mutationChangedVectors.set(segment.id, changed);
             }
         }
         // Phase B: one bounded pass over the scan segments' key blocks — a single block resident
-        // at a time — recording, per scan segment, the touched tokens and their absolute slots.
+        // at a time — recording, per scan segment, the touched keys and their absolute slots.
         const touchedByScanSegment = new Map();
         // A mutation history is small, and a unique key is usually written in order, so most key
         // blocks cannot hold any touched key at all. Their zone maps say so from the header alone,
@@ -4734,26 +5386,10 @@ export class MinnowDatabase {
                 if (decoded.column.type !== keyColumn.type) {
                     throw new Error(`Column type mismatch: ${keyColumn.name}`);
                 }
-                const rows = decoded.column.rowCount;
-                const validity = new Uint8Array(Math.ceil(rows / 8));
-                const values = keyColumn.type === "boolean"
-                    ? new Uint8Array(rows)
-                    : keyColumn.type === "string"
-                        ? undefined
-                        : new Float64Array(rows);
-                const codes = keyColumn.type === "string" ? new Uint32Array(rows) : undefined;
-                codes?.fill(NULL_STRING_VECTOR_CODE);
-                const builder = new StringDictionaryBuilder();
-                appendPhysicalColumnToVector(decoded.column, 0, validity, values, codes, builder);
-                const blockVector = (codes !== undefined
-                    ? {
-                        kind: "string",
-                        length: rows,
-                        validity,
-                        codes,
-                        dictionary: builder.dictionary,
-                    }
-                    : { kind: keyColumn.type, length: rows, validity, values });
+                // The block's vector form is what a scan of this table reads anyway, so it comes from
+                // (and stays in) the buffer pool rather than being rebuilt for the replay.
+                const blockVector = this.#blockColumnVector(blockId, decoded);
+                const rows = blockVector.length;
                 const readBlockKey = requiredColumnVectorKeyReader(blockVector);
                 for (let row = 0; row < rows; row += 1) {
                     const key = readBlockKey(row);
@@ -4825,195 +5461,22 @@ export class MinnowDatabase {
                     slotPatches.set(columnId, { vector, row });
             }
         }
-        memory.tally(patches.size * 96 + slotByKey.size * 64, "Streamed mutation replay");
-        const hasPatches = patches.size > 0;
-        const outputRows = baseRows - deadCount;
-        const inner = this.#createStreamedTable(table, projectedColumns, scanSegments, snapshot, baseRows, memory, storedBlocks);
-        // Deltas that touch no row this scan reads — every one of them eliminated with its row
-        // group, or aimed at keys this table no longer holds — leave the scan exactly as it was.
-        // The plain streamed scan hands decoded blocks straight through, so skipping the overlay
-        // here is the difference between a copy per window and none.
-        if (deadCount === 0 && !hasPatches)
-            return inner;
-        const states = projectedColumns.map((column) => ({
-            column,
-            vector: createStreamedColumnVector(column.type, outputRows),
-            reservations: [],
-        }));
-        // Forward-only cursor: cursorOutput live rows exist strictly before base row cursorBase.
-        let cursorOutput = 0;
-        let cursorBase = 0;
-        const load = async (start, length) => {
-            const end = Math.min(start + length, outputRows);
-            // COUNT(*) and friends project nothing: the replay already knows how many rows survive,
-            // so there is no window to build and no reason to walk the base rows to build it.
-            if (states.length === 0)
-                return end;
-            const window = states[0]?.vector.window;
-            if (window !== undefined && start >= window.start && end <= window.start + window.length) {
-                return window.start + window.length;
-            }
-            if (window !== undefined && start < window.start) {
-                throw new Error(`Streamed scan moved backward: ${table.name}`);
-            }
-            // The cursor stops at the end of the window it last built, which can sit past a start
-            // that falls inside that window. Rewinding costs one pass over the dead-row bitmap and
-            // keeps the window aligned with what was asked for, rather than with where the cursor
-            // happened to stop.
-            if (cursorOutput > start) {
-                cursorOutput = 0;
-                cursorBase = 0;
-            }
-            while (cursorOutput < start && cursorBase < baseRows) {
-                if (!bitmapHasValue(dead, cursorBase))
-                    cursorOutput += 1;
-                cursorBase += 1;
-            }
-            let scanBase = cursorBase;
-            let scanOutput = cursorOutput;
-            const liveBaseRows = [];
-            while (scanOutput < end && scanBase < baseRows) {
-                if (!bitmapHasValue(dead, scanBase)) {
-                    liveBaseRows.push(scanBase);
-                    scanOutput += 1;
-                }
-                scanBase += 1;
-            }
-            if (scanOutput < end)
-                throw new Error(`Column row count mismatch: ${table.name}`);
-            const windowRows = end - start;
-            const targets = [];
-            try {
-                for (const state of states) {
-                    const innerVector = inner.table.columns.get(state.column.name);
-                    if (innerVector === undefined) {
-                        throw new Error(`Streamed column is missing: ${state.column.name}`);
-                    }
-                    const validityBytes = Math.ceil(windowRows / 8);
-                    const typedBytes = validityBytes +
-                        (state.column.type === "boolean"
-                            ? windowRows
-                            : state.column.type === "string"
-                                ? windowRows * Uint32Array.BYTES_PER_ELEMENT
-                                : windowRows * Float64Array.BYTES_PER_ELEMENT);
-                    const replacements = [];
-                    replacements.push(memory.reserve(typedBytes, `Streamed window ${state.column.name}`));
-                    const validity = new Uint8Array(validityBytes);
-                    const values = state.column.type === "boolean"
-                        ? new Uint8Array(windowRows)
-                        : state.column.type === "string"
-                            ? undefined
-                            : new Float64Array(windowRows);
-                    const codes = state.column.type === "string" ? new Uint32Array(windowRows) : undefined;
-                    codes?.fill(NULL_STRING_VECTOR_CODE);
-                    const dictionary = [];
-                    const target = (codes !== undefined
-                        ? { kind: "string", length: windowRows, validity, codes, dictionary }
-                        : { kind: state.column.type, length: windowRows, validity, values });
-                    targets.push({
-                        state,
-                        innerVector,
-                        validity,
-                        ...(values === undefined ? {} : { values }),
-                        ...(codes === undefined ? {} : { codes }),
-                        dictionary,
-                        dictionaryIndex: new Map(),
-                        replacements,
-                        target,
-                    });
-                }
-                // The inner loader serves whole blocks, so the copy walks live rows one inner window
-                // at a time: patched slots read the resident mutation vectors, everything else reads
-                // the inner window at its own offset.
-                let index = 0;
-                while (index < liveBaseRows.length) {
-                    const chunkStart = liveBaseRows[index] ?? 0;
-                    const innerEnd = await inner.load(chunkStart, scanBase - chunkStart);
-                    const usable = typeof innerEnd === "number" ? Math.min(innerEnd, scanBase) : scanBase;
-                    if (usable <= chunkStart) {
-                        throw new Error(`Column row count mismatch: ${table.name}`);
-                    }
-                    let chunkEndIndex = index;
-                    while (chunkEndIndex < liveBaseRows.length &&
-                        (liveBaseRows[chunkEndIndex] ?? 0) < usable) {
-                        chunkEndIndex += 1;
-                    }
-                    for (const entry of targets) {
-                        const innerWindow = entry.innerVector.window;
-                        if (innerWindow === undefined) {
-                            throw new Error(`Streamed column is missing: ${entry.state.column.name}`);
-                        }
-                        // Live rows are consecutive except where a delete cut them, so the copy walks runs:
-                        // one typed-array slice each, with patched slots taken out individually. Copying
-                        // cell by cell here is what made a table with one deleted row scan like a replay.
-                        const columnId = entry.state.column.id;
-                        const remap = entry.innerVector.kind === "string"
-                            ? remapDictionary(entry.innerVector.dictionary, entry.dictionary, entry.dictionaryIndex)
-                            : undefined;
-                        let live = index;
-                        while (live < chunkEndIndex) {
-                            const baseRow = liveBaseRows[live] ?? 0;
-                            const patch = hasPatches ? patches.get(baseRow)?.get(columnId) : undefined;
-                            if (patch !== undefined) {
-                                copyColumnVectorValue(patch.vector, patch.row, entry.target, live, entry.dictionaryIndex);
-                                live += 1;
-                                continue;
-                            }
-                            let runEnd = live + 1;
-                            while (runEnd < chunkEndIndex &&
-                                (liveBaseRows[runEnd] ?? 0) === baseRow + (runEnd - live) &&
-                                (!hasPatches || patches.get(liveBaseRows[runEnd] ?? 0)?.get(columnId) === undefined)) {
-                                runEnd += 1;
-                            }
-                            copyVectorSpan(entry.innerVector, baseRow - innerWindow.start, runEnd - live, entry.target, live, remap);
-                            live = runEnd;
-                        }
-                    }
-                    index = chunkEndIndex;
-                }
-                // Reserve every fallible byte first; the installs below cannot throw, so a budget
-                // overflow here leaves every state's previous window and reservations intact.
-                for (const entry of targets) {
-                    let dictionaryBytes = 0;
-                    for (const value of entry.dictionary)
-                        dictionaryBytes += value.length;
-                    if (dictionaryBytes > 0) {
-                        entry.replacements.push(memory.reserve(dictionaryBytes, `Streamed window ${entry.state.column.name}`));
-                    }
-                }
-                for (const entry of targets) {
-                    const mutable = entry.state.vector;
-                    mutable.validity = entry.validity;
-                    if (entry.values !== undefined)
-                        mutable.values = entry.values;
-                    if (entry.codes !== undefined) {
-                        mutable.codes = entry.codes;
-                        mutable.dictionary = entry.dictionary;
-                    }
-                    mutable.window = { start, length: windowRows };
-                    for (const previous of entry.state.reservations)
-                        previous.release();
-                    entry.state.reservations = entry.replacements;
-                }
-            }
-            catch (error) {
-                for (const entry of targets) {
-                    for (const replacement of entry.replacements)
-                        replacement.release();
-                }
-                throw error;
-            }
-            cursorOutput = end;
-            cursorBase = scanBase;
-            return end;
-        };
+        let patchCells = 0;
+        for (const slotPatches of patches.values())
+            patchCells += slotPatches.size;
+        memory.tally(patches.size * 96 + patchCells * 48, "Streamed mutation replay");
+        const patchedSlots = Uint32Array.from(patches.keys()).sort();
         return {
-            table: {
-                name: table.name,
-                rowCount: outputRows,
-                columns: new Map(states.map((state) => [state.column.name, state.vector])),
-            },
-            load,
+            baseRows,
+            deadCount,
+            dead,
+            patches,
+            patchedSlots,
+            bytes: dead.byteLength +
+                retainedBytes +
+                patchedSlots.byteLength +
+                patches.size * 96 +
+                patchCells * 48,
         };
     }
     /** Prepares one block's inputs and executes it, returning the caller-owned result. */
@@ -5174,15 +5637,17 @@ export class MinnowDatabase {
     /** Plans or advances one restart-safe physical compaction job. */
     async compactTableStep(tableName, options = {}) {
         const table = await this.#findTable(tableName);
-        const active = (await this.store.listCompactionJobs(table.id)).find((job) => isActiveCompactionState(job.state));
-        let job = active;
-        if (job === undefined) {
-            const planned = await this.#planCompaction(table, options);
-            if ("compacted" in planned)
-                return compactionSkippedProgress(planned);
-            job = planned;
-        }
-        return this.#runCompactionJob(table, job, positiveWholeNumber(options.maxBlocks ?? options.maxBlocksPerStep ?? 1, "Compaction step block limit"));
+        return this.#serializedCompactionStep(table.id, async () => {
+            const active = (await this.store.listCompactionJobs(table.id)).find((job) => isActiveCompactionState(job.state));
+            let job = active;
+            if (job === undefined) {
+                const planned = await this.#planCompaction(table, options);
+                if ("compacted" in planned)
+                    return compactionSkippedProgress(planned);
+                job = planned;
+            }
+            return this.#runCompactionJob(table, job, positiveWholeNumber(options.maxBlocks ?? options.maxBlocksPerStep ?? 1, "Compaction step block limit"));
+        });
     }
     /** Continues a persisted compaction job after a cooperative yield or restart. */
     async resumeCompactionJob(jobId, options = {}) {
@@ -5192,7 +5657,26 @@ export class MinnowDatabase {
         const table = await this.store.getTable(job.tableId);
         if (table === undefined)
             throw new Error(`Compaction table not found: ${job.tableId}`);
-        return this.#runCompactionJob(table, job, positiveWholeNumber(options.maxBlocks ?? 1, "Compaction step block limit"));
+        return this.#serializedCompactionStep(table.id, () => this.#runCompactionJob(table, job, positiveWholeNumber(options.maxBlocks ?? 1, "Compaction step block limit")));
+    }
+    /**
+     * One compaction step at a time per table within this database: background compaction
+     * drives a job in steps, and a caller stepping the same table explicitly must take turns with
+     * it rather than advance the same job concurrently, which would write its output blocks
+     * twice. Each step loads the job record fresh, so alternating drivers simply continue where
+     * the other left off. Between instances and tabs the job's revision is the guard.
+     */
+    async #serializedCompactionStep(tableId, step) {
+        const previous = this.#compactionSteps.get(tableId) ?? Promise.resolve();
+        const run = previous.then(step, step);
+        this.#compactionSteps.set(tableId, run);
+        try {
+            return await run;
+        }
+        finally {
+            if (this.#compactionSteps.get(tableId) === run)
+                this.#compactionSteps.delete(tableId);
+        }
     }
     async listCompactionJobs(tableName) {
         if (tableName === undefined)
@@ -5219,6 +5703,13 @@ export class MinnowDatabase {
             }
         }
     }
+    async #cancelTableCompactions(tableId) {
+        for (const job of await this.store.listCompactionJobs(tableId)) {
+            if (job.state === "planned" || job.state === "running" || job.state === "ready") {
+                await this.cancelCompactionJob(job.id);
+            }
+        }
+    }
     /** Runs restart-safe lease-aware reclamation to completion in bounded durable steps. */
     async collectGarbage(options = {}) {
         const maxItems = positiveWholeNumber(options.maxItemsPerStep ?? 64, "Garbage collection items per step");
@@ -5227,38 +5718,201 @@ export class MinnowDatabase {
             ...(options.maxPlanningItems === undefined
                 ? {}
                 : { maxPlanningItems: options.maxPlanningItems }),
+            ...(options.retainRecentVersions === undefined
+                ? {}
+                : { retainRecentVersions: options.retainRecentVersions }),
         });
         while (progress.result === null) {
             progress = await this.resumeGarbageCollectionJob(progress.jobId, { maxItems });
         }
+        await this.#pruneFinishedJobRecords();
         return progress.result;
     }
     /** Plans or advances one durable garbage-collection pass. */
     async collectGarbageStep(options = {}) {
-        const active = (await this.store.listGarbageCollectionJobs()).find((job) => job.state === "planned" || job.state === "running");
-        const job = active ??
-            (await this.#planGarbageCollection(positiveWholeNumber(options.maxPlanningItems ?? 1_024, "Garbage collection planning limit")));
-        return this.#runGarbageCollectionJob(job, positiveWholeNumber(options.maxItems ?? 1, "Garbage collection item limit"));
+        return this.#collectGarbageStep(options);
+    }
+    /** `collectGarbageStep`, with the age bound background collection adds to its retention. */
+    async #collectGarbageStep(options, retainedVersionMaxAgeMs = Number.POSITIVE_INFINITY) {
+        return this.#serializedCollectionStep(async () => {
+            const active = (await this.store.listGarbageCollectionJobs()).find((job) => job.state === "planned" || job.state === "running");
+            const job = active ??
+                (await this.#planGarbageCollection(positiveWholeNumber(options.maxPlanningItems ?? 1_024, "Garbage collection planning limit"), nonNegativeWholeNumber(options.retainRecentVersions ?? 0, "Garbage collection retained versions"), retainedVersionMaxAgeMs));
+            return this.#runGarbageCollectionJob(job, positiveWholeNumber(options.maxItems ?? 1, "Garbage collection item limit"));
+        });
     }
     /** Continues a persisted reclamation pass after a cooperative yield or restart. */
     async resumeGarbageCollectionJob(jobId, options = {}) {
         const job = await this.store.getGarbageCollectionJob(jobId);
         if (job === undefined)
             throw new Error(`Garbage collection job not found: ${jobId}`);
-        return this.#runGarbageCollectionJob(job, positiveWholeNumber(options.maxItems ?? 1, "Garbage collection item limit"));
+        return this.#serializedCollectionStep(() => this.#runGarbageCollectionJob(job, positiveWholeNumber(options.maxItems ?? 1, "Garbage collection item limit")));
     }
-    async listGarbageCollectionJobs() {
-        return this.store.listGarbageCollectionJobs();
-    }
-    async #planGarbageCollection(maxPlanningItems) {
-        const current = await this.store.getCurrentManifest();
+    /**
+     * One garbage-collection step at a time within this database, for the same reason
+     * compaction steps take turns (`#serializedCompactionStep`): background collection drives
+     * a job in steps, and a caller stepping collection explicitly continues the same job rather
+     * than racing it.
+     */
+    async #serializedCollectionStep(step) {
+        const previous = this.#collectionSteps;
+        const run = previous.then(step, step);
+        this.#collectionSteps = run;
+        try {
+            return await run;
+        }
+        finally {
+            if (this.#collectionSteps === run)
+                this.#collectionSteps = Promise.resolve();
+        }
+    }
+    /**
+     * Background collection: plans one pass and drives it to completion in yielding steps.
+     * Runs after a background fold, whose superseded blocks are what a pass reclaims, and every
+     * AUTO_COLLECT_COMMIT_INTERVAL commits, since every commit writes a manifest that stays on
+     * disk until pruned. Keeps the most recent versions readable. Never surfaces through a
+     * write or a scan; a failed pass backs off for an interval of commits.
+     */
+    #maybeScheduleAutoCollection() {
+        if (!this.#autoCollect)
+            return;
+        if (this.#autoCollectionInFlight) {
+            // A fold finishing or a quiet minute passing while a run is under way is a reason for
+            // one more run once this one ends — a dropped trigger after the last commit of a burst
+            // would otherwise leave the burst's leftovers until the next one.
+            this.#autoCollectionRequested = true;
+            return;
+        }
+        if (this.#commitsSinceCollection < this.#autoCollectionBackoffUntilCommit)
+            return;
+        this.#autoCollectionInFlight = true;
+        this.#autoCollectionRequested = false;
+        this.#commitsSinceCollection = 0;
+        this.#lastCollectionAt = this.#now().getTime();
+        void this.#runAutoCollection()
+            .then(() => {
+            this.#autoCollectionBackoffUntilCommit = 0;
+        })
+            .catch(() => {
+            this.#autoCollectionBackoffUntilCommit = AUTO_COLLECT_COMMIT_INTERVAL * 2;
+        })
+            .finally(() => {
+            this.#autoCollectionInFlight = false;
+            if (this.#autoCollectionRequested) {
+                this.#autoCollectionRequested = false;
+                void yieldToEventLoop().then(() => {
+                    this.#maybeScheduleAutoCollection();
+                });
+            }
+        });
+    }
+    /**
+     * A pass a quiet period after the last commit, for a tab that stops writing: the retained
+     * window's age bound lets that pass reclaim what the last burst superseded, which no commit
+     * would otherwise arrive to trigger. Re-armed by every commit; unreferenced, so it never
+     * keeps a process alive.
+     */
+    #armIdleCollection() {
+        if (!this.#autoCollect)
+            return;
+        if (this.#idleCollectionTimer !== undefined)
+            clearTimeout(this.#idleCollectionTimer);
+        const timer = setTimeout(() => {
+            this.#idleCollectionTimer = undefined;
+            this.#maybeScheduleAutoCollection();
+        }, AUTO_COLLECT_QUIET_MS);
+        timer.unref?.();
+        this.#idleCollectionTimer = timer;
+    }
+    async #runAutoCollection() {
+        // One pass plans a bounded number of candidates, so a backlog — a burst of commits that
+        // outran the passes between them — takes several. Keep passing while a pass still finds
+        // something, up to a ceiling that keeps a pathological store from pinning the loop.
+        for (let pass = 0; pass < AUTO_COLLECT_MAX_PASSES; pass += 1) {
+            this.#releaseIdleSharedLease();
+            let progress = await this.#collectGarbageStep({
+                maxItems: AUTO_COLLECT_STEP_ITEMS,
+                retainRecentVersions: AUTO_COLLECT_RETAINED_VERSIONS,
+            }, AUTO_COLLECT_RETAINED_VERSION_MS);
+            while (progress.result === null) {
+                await yieldToEventLoop();
+                progress = await this.resumeGarbageCollectionJob(progress.jobId, {
+                    maxItems: AUTO_COLLECT_STEP_ITEMS,
+                });
+            }
+            const result = progress.result;
+            if (result.prunedManifestCount === 0 &&
+                result.reclaimedBlockCount === 0 &&
+                result.reclaimedSegmentCount === 0 &&
+                result.reclaimedTransactionCount === 0) {
+                break;
+            }
+            await yieldToEventLoop();
+        }
+        await this.#pruneFinishedJobRecords();
+    }
+    /** Drops finished maintenance records while preserving the state needed for safe L2 retries. */
+    async #pruneFinishedJobRecords() {
+        const newestFirst = (jobs) => jobs.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        const terminalCompactions = newestFirst((await this.store.listCompactionJobs()).filter((job) => job.state === "published" || job.state === "cancelled" || job.state === "aborted"));
+        const retainedCompactionIds = new Set(terminalCompactions.slice(0, AUTO_COLLECT_RETAINED_JOB_RECORDS).map((job) => job.id));
+        // A retry persists the cumulative bytes written by earlier attempts. Keep only the newest
+        // failure for each still-readable source snapshot; it carries the whole lifetime budget.
+        // Once the source manifest is pruned, that exact retry can never be planned again.
+        const retainedFailureBases = new Set();
+        const manifestReadable = new Map();
+        for (const job of terminalCompactions) {
+            if (job.state !== "cancelled" && job.state !== "aborted")
+                continue;
+            const baseId = job.id.split("/retry/", 1)[0] ?? job.id;
+            if (retainedFailureBases.has(baseId))
+                continue;
+            let readable = manifestReadable.get(job.sourceManifestVersion);
+            if (readable === undefined) {
+                const manifest = await this.store.getManifest(job.sourceManifestVersion);
+                readable = manifest !== undefined && manifest.prunedAt === undefined;
+                manifestReadable.set(job.sourceManifestVersion, readable);
+            }
+            if (!readable)
+                continue;
+            retainedFailureBases.add(baseId);
+            retainedCompactionIds.add(job.id);
+        }
+        for (const job of terminalCompactions) {
+            if (!retainedCompactionIds.has(job.id))
+                await this.store.removeCompactionJob(job.id);
+        }
+        const collections = newestFirst((await this.store.listGarbageCollectionJobs()).filter((job) => job.state === "completed"));
+        for (const job of collections.slice(AUTO_COLLECT_RETAINED_JOB_RECORDS)) {
+            await this.store.removeGarbageCollectionJob(job.id);
+        }
+    }
+    async listGarbageCollectionJobs() {
+        return this.store.listGarbageCollectionJobs();
+    }
+    async #planGarbageCollection(maxPlanningItems, retainRecentVersions, retainedVersionMaxAgeMs = Number.POSITIVE_INFINITY) {
+        // Crashed readers and query spill owners are metadata roots too. Sweep their expired
+        // records as part of every explicit or background collection so callers never need a
+        // separate maintenance loop to keep either family bounded.
+        await this.#transactions.removeExpiredLeases(this.#now());
+        await this.cleanupQuerySpill();
+        const current = await this.store.getCurrentManifest();
         const currentBlockIds = new Set(current?.blockIds ?? []);
+        // Manifest versions are consecutive, so the retained window is a version floor; a version
+        // inside it is still collected once it is older than the window's age.
+        const retainAbove = (current?.version ?? 0) - retainRecentVersions;
+        const retainAfter = this.#now().getTime() - retainedVersionMaxAgeMs;
+        const retained = (manifest) => manifest.version > retainAbove && Date.parse(manifest.createdAt) > retainAfter;
         const candidateManifestVersions = [];
         const candidateBlockIds = [];
         const candidateSegmentIds = [];
+        const candidateTransactionIds = [];
         const candidateBlockIdSet = new Set();
         const candidateSegmentIdSet = new Set();
-        const remaining = () => maxPlanningItems - candidateBlockIds.length - candidateSegmentIds.length;
+        const remaining = () => maxPlanningItems -
+            candidateBlockIds.length -
+            candidateSegmentIds.length -
+            candidateTransactionIds.length;
         const addBlocks = (ids) => {
             for (const id of ids) {
                 if (remaining() <= 0)
@@ -5279,33 +5933,81 @@ export class MinnowDatabase {
                 candidateSegmentIds.push(id);
             }
         };
-        let manifestCursor = null;
-        do {
+        // The walk starts past the prefix of history this database has already seen fully
+        // collected — every manifest pruned and none of its blocks left — and extends that prefix
+        // as it goes. A pruned manifest's blocks can only disappear, and a block it shares with a
+        // later manifest is found through that manifest or the job that superseded it, so skipping
+        // the dead prefix loses nothing; it is what keeps a pass proportional to the live history
+        // rather than to everything the database ever committed.
+        let manifestCursor = this.#collectionWatermark;
+        let deadPrefixEnd = this.#collectionWatermark;
+        let prefixContiguous = true;
+        walk: do {
             const page = await this.store.listManifestPage(manifestCursor, 64);
             for (const manifest of page.records) {
                 if (manifest.version === current?.version)
+                    break walk;
+                if (retained(manifest)) {
+                    prefixContiguous = false;
                     continue;
+                }
                 const existing = await this.#existingGarbageBlockCandidates(manifest.blockIds, currentBlockIds, remaining());
-                if (manifest.prunedAt === undefined || existing.length > 0) {
-                    candidateManifestVersions.push(manifest.version);
-                    addBlocks(existing);
+                if (manifest.prunedAt === undefined) {
+                    // Only an unpruned manifest is a pruning candidate: one already pruned would spend a
+                    // step's capacity confirming it, and with enough of them in front, the unpruned ones
+                    // behind them were never reached at all. Their leftover blocks still count.
+                    if (candidateManifestVersions.length < 64)
+                        candidateManifestVersions.push(manifest.version);
+                    prefixContiguous = false;
                 }
-                if (remaining() <= 0 || candidateManifestVersions.length === 64)
-                    break;
+                else if (prefixContiguous && existing.length === 0) {
+                    deadPrefixEnd = manifest.version;
+                }
+                else {
+                    prefixContiguous = false;
+                }
+                addBlocks(existing);
+                if (remaining() <= 0)
+                    break walk;
             }
-            if (remaining() <= 0 || candidateManifestVersions.length === 64)
-                break;
             manifestCursor = page.nextCursor;
         } while (manifestCursor !== null);
+        this.#collectionWatermark = deadPrefixEnd;
         if (remaining() > 0) {
+            const segmentOwnerIds = new Set((await this.store.listSegments()).map((segment) => segment.transactionId));
+            const manifestEligibility = new Map();
+            const candidateManifestSet = new Set(candidateManifestVersions);
             let transactionCursor = null;
             do {
                 const page = await this.store.listTransactionPage(transactionCursor, 64);
                 for (const transaction of page.records) {
-                    if (transaction.status !== "aborted")
-                        continue;
-                    addBlocks(await this.#existingGarbageBlockCandidates(transaction.pendingBlockIds, currentBlockIds, remaining()));
-                    addSegments(await this.#existingGarbageSegmentCandidates(transaction.pendingSegmentIds, remaining()));
+                    if (transaction.status === "aborted") {
+                        const pendingBlocks = await this.#existingGarbageBlockCandidates(transaction.pendingBlockIds, currentBlockIds, remaining());
+                        addBlocks(pendingBlocks);
+                        const pendingSegments = await this.#existingGarbageSegmentCandidates(transaction.pendingSegmentIds, remaining());
+                        addSegments(pendingSegments);
+                        // The artifacts are deleted before transaction candidates within a job. A later
+                        // pass sees the empty journal and removes the aborted record itself.
+                        if (pendingBlocks.length === 0 && pendingSegments.length === 0 && remaining() > 0) {
+                            candidateTransactionIds.push(transaction.id);
+                        }
+                    }
+                    else if (transaction.status === "committed" &&
+                        transaction.committedVersion !== null &&
+                        !segmentOwnerIds.has(transaction.id) &&
+                        remaining() > 0) {
+                        let eligible = manifestEligibility.get(transaction.committedVersion);
+                        if (eligible === undefined) {
+                            const manifest = await this.store.getManifest(transaction.committedVersion);
+                            eligible =
+                                manifest === undefined ||
+                                    manifest.prunedAt !== undefined ||
+                                    candidateManifestSet.has(transaction.committedVersion);
+                            manifestEligibility.set(transaction.committedVersion, eligible);
+                        }
+                        if (eligible)
+                            candidateTransactionIds.push(transaction.id);
+                    }
                     if (remaining() <= 0)
                         break;
                 }
@@ -5323,10 +6025,7 @@ export class MinnowDatabase {
                         continue;
                     }
                     addBlocks(await this.#existingGarbageBlockCandidates([...job.sourceBlockIds, ...job.outputBlockIds], currentBlockIds, remaining()));
-                    addSegments(await this.#existingGarbageSegmentCandidates([
-                        ...job.sourceSegmentIds,
-                        ...(job.outputSegmentId === null ? [] : [job.outputSegmentId]),
-                    ], remaining()));
+                    addSegments(await this.#existingGarbageSegmentCandidates([...job.sourceSegmentIds, ...compactionOutputSegmentIds(job)], remaining()));
                     if (remaining() <= 0)
                         break;
                 }
@@ -5341,22 +6040,35 @@ export class MinnowDatabase {
             candidateManifestVersions,
             candidateSegmentIds,
             candidateBlockIds,
+            candidateTransactionIds,
             leaseCutoff: timestamp,
             createdAt: timestamp,
         });
     }
     async #existingGarbageBlockCandidates(ids, currentBlockIds, limit) {
-        const candidates = [];
+        if (limit <= 0)
+            return [];
+        // A block the current manifest still carries is not garbage, whatever else references it,
+        // and an unpruned manifest shares nearly all of its blocks with the current one. Deciding
+        // that from the set first leaves the store lookups to the few blocks that might be gone —
+        // reading every block of every manifest to find them made a planning pass cost the table
+        // times the history.
+        const possible = [];
         const seen = new Set();
-        for (let start = 0; start < ids.length && candidates.length < limit; start += 64) {
-            const page = ids.slice(start, start + 64);
+        for (const id of ids) {
+            if (currentBlockIds.has(id) || seen.has(id))
+                continue;
+            seen.add(id);
+            possible.push(id);
+        }
+        const candidates = [];
+        for (let start = 0; start < possible.length && candidates.length < limit; start += 64) {
+            const page = possible.slice(start, start + 64);
             const blocks = await this.store.getBlocks(page);
             for (let index = 0; index < page.length && candidates.length < limit; index += 1) {
                 const id = page[index] ?? "";
-                if (blocks[index] !== undefined && !currentBlockIds.has(id) && !seen.has(id)) {
-                    seen.add(id);
+                if (blocks[index] !== undefined)
                     candidates.push(id);
-                }
             }
         }
         return candidates;
@@ -5377,8 +6089,10 @@ export class MinnowDatabase {
     async #runGarbageCollectionJob(initialJob, maxItems) {
         let job = initialJob;
         for (;;) {
-            if (job.state === "completed")
+            if (job.state === "completed") {
+                await this.store.removePrunedManifestRecords();
                 return garbageCollectionProgress(job);
+            }
             try {
                 const step = await this.store.runGarbageCollectionStep({
                     jobId: job.id,
@@ -5386,6 +6100,8 @@ export class MinnowDatabase {
                     maxItems,
                     updatedAt: this.#now().toISOString(),
                 });
+                if (step.job.state === "completed")
+                    await this.store.removePrunedManifestRecords();
                 return garbageCollectionProgress(step.job);
             }
             catch (error) {
@@ -5440,31 +6156,52 @@ export class MinnowDatabase {
         const levelTwoMaxWriteAmplification = targetLevel === 2
             ? positiveFiniteNumber(options.maxWriteAmplification ?? DEFAULT_LEVEL_TWO_MAX_WRITE_AMPLIFICATION, "Compaction maximum write amplification")
             : undefined;
-        let anchor;
+        const targetBlockBytes = positiveWholeNumber(options.targetBlockBytes ?? DEFAULT_COMPACTION_TARGET_BLOCK_BYTES, "Compaction target block bytes");
+        if (targetBlockBytes > MAX_COMPACTION_TARGET_BLOCK_BYTES) {
+            throw new RangeError(`Compaction target block bytes cannot exceed ${String(MAX_COMPACTION_TARGET_BLOCK_BYTES)}`);
+        }
+        const outputCompression = validateCompression(options.outputCompression ?? "gzip", "Compaction output compression");
+        if (getCompressionMemoryBound(outputCompression, targetBlockBytes).maximumOutputBytes >
+            MAX_COMPACTION_TARGET_BLOCK_BYTES) {
+            throw new RangeError(`Compaction target block bytes exceed the ${outputCompression} worst-case format limit`);
+        }
+        const memoryBudgetBytes = positiveWholeNumber(options.memoryBudgetBytes ?? DEFAULT_COMPACTION_MEMORY_BUDGET_BYTES, "Compaction memory budget");
+        const partitionRows = positiveWholeNumber(options.partitionRows ?? this.#compactionPartitionRows, "Compaction partition rows");
+        let anchors = [];
         let level0Segments;
         let effectiveMinimumLevel0Segments;
         let outputPartitionOrdinal;
         let keyedLevelTwo = false;
-        if (targetLevel === 1) {
-            const firstLevel = visibleSegments[0]?.level ?? 0;
-            const hasAnchor = firstLevel === 1;
-            const level0Offset = hasAnchor ? 1 : 0;
-            const supportedLevelLayout = firstLevel <= 1 &&
-                visibleSegments.slice(level0Offset).every((segment) => (segment.level ?? 0) === 0);
-            if (!supportedLevelLayout) {
+        let keyedLevelOne;
+        let keylessLevelOne;
+        if (targetLevel === 1 && table.uniqueKeyColumnId !== undefined) {
+            // Keyed L1: a prefix of level-one partitions, then level-zero history. A fold rewrites
+            // only the partitions the selected deltas touch (and the tail partition new rows join),
+            // so which partitions it sources is decided after the level-zero selection below.
+            const layout = keyedLevelOneLayout(visibleSegments);
+            if (layout === null) {
+                return compactTableSkipped(table.name, "unsupported-level-layout", visibleSegments, visibleBlockIds, version);
+            }
+            keyedLevelOne = layout;
+            level0Segments = layout.level0Segments;
+            effectiveMinimumLevel0Segments =
+                layout.partitions.length > 0 ? minimumLevel0Segments : Math.max(2, minimumLevel0Segments);
+        }
+        else if (targetLevel === 1) {
+            const layout = keylessLevelOneLayout(visibleSegments);
+            if (layout === null) {
                 return compactTableSkipped(table.name, "unsupported-level-layout", visibleSegments, visibleBlockIds, version);
             }
-            anchor = hasAnchor ? visibleSegments[0] : undefined;
-            level0Segments = visibleSegments.slice(level0Offset);
-            effectiveMinimumLevel0Segments = hasAnchor
-                ? minimumLevel0Segments
-                : Math.max(2, minimumLevel0Segments);
+            keylessLevelOne = layout;
+            level0Segments = layout.level0Segments;
+            effectiveMinimumLevel0Segments =
+                layout.partitions.length > 0 ? minimumLevel0Segments : Math.max(2, minimumLevel0Segments);
         }
         else if (table.uniqueKeyColumnId !== undefined ||
             visibleSegments.some((segment) => (segment.kind ?? "insert") !== "insert" || segment.rowIdSpans !== undefined)) {
-            // Keyed multi-range L2: merge (optional anchor + oldest level-zero prefix) into a new
-            // span-carrying partition. Published partitions are never rewritten; mutation kinds
-            // without a unique key cannot merge and keep the materialized skip.
+            // Keyed multi-range L2: merge (the level-one partitions + oldest level-zero prefix) into
+            // a new span-carrying partition. Published partitions are never rewritten; mutation
+            // kinds without a unique key cannot merge and keep the materialized skip.
             if (table.uniqueKeyColumnId === undefined) {
                 return compactTableSkipped(table.name, "contains-mutation-segments", visibleSegments, visibleBlockIds, version);
             }
@@ -5472,7 +6209,7 @@ export class MinnowDatabase {
             if (layout === null) {
                 return compactTableSkipped(table.name, "unsupported-level-layout", visibleSegments, visibleBlockIds, version);
             }
-            anchor = layout.anchor;
+            anchors = layout.anchors;
             level0Segments = layout.level0Segments;
             effectiveMinimumLevel0Segments = minimumLevel0Segments;
             outputPartitionOrdinal = layout.levelTwoSegments.length;
@@ -5490,38 +6227,70 @@ export class MinnowDatabase {
         if (level0Segments.length < effectiveMinimumLevel0Segments) {
             return compactTableSkipped(table.name, "below-segment-threshold", visibleSegments, visibleBlockIds, version);
         }
-        const selection = await this.#selectCompactionSources(anchor, level0Segments, effectiveMinimumLevel0Segments, maxLevel0Segments, maxLevel0StoredBytes, snapshot);
+        if (version === null)
+            throw new Error("Visible compaction segments require a manifest");
+        const level0Selection = await this.#selectLevelZeroSources(level0Segments, effectiveMinimumLevel0Segments, maxLevel0Segments, maxLevel0StoredBytes, snapshot);
+        let partitioning;
+        let rechunkPartitioning;
+        if (keyedLevelOne !== undefined) {
+            const keyColumn = getUniqueKeyColumn(table);
+            if (keyColumn === undefined) {
+                throw new Error(`Mutation compaction requires a unique key: ${table.name}`);
+            }
+            const touched = await this.#touchedPartitionIds(keyColumn, keyedLevelOne.partitions, level0Selection.segments, memoryBudgetBytes, snapshot);
+            // New rows join the last partition while it is small, or when it is being rewritten
+            // anyway; otherwise they open a new partition behind it and it stays untouched.
+            const last = keyedLevelOne.partitions[keyedLevelOne.partitions.length - 1];
+            const bearsNewRows = level0Selection.segments.some((segment) => mergeSourceBearsRows(segment.kind ?? "insert"));
+            const absorbsTail = last !== undefined &&
+                bearsNewRows &&
+                (touched.has(last.id) || last.rowCount < partitionRows);
+            anchors = keyedLevelOne.partitions.filter((partition) => partition.rowCount > partitionRows ||
+                touched.has(partition.id) ||
+                (absorbsTail && partition.id === last.id));
+            partitioning = {
+                partitions: keyedLevelOne.partitions,
+                partitionRows,
+                absorbsTail,
+                nextLevelZeroOrder: level0Selection.nextLogicalOrder ?? version + 1,
+            };
+        }
+        else if (keylessLevelOne !== undefined) {
+            const last = keylessLevelOne.partitions.at(-1);
+            // A partial tail is extended. An oversized legacy anchor is included once so this fold
+            // heals it into bounded partitions; a full tail stays immutable and new rows start after it.
+            const absorbsTail = last !== undefined && (last.rowCount < partitionRows || last.rowCount > partitionRows);
+            anchors = absorbsTail ? [last] : [];
+            rechunkPartitioning = {
+                partitionRows,
+                nextLevelZeroOrder: level0Selection.nextLogicalOrder ?? version + 1,
+            };
+        }
+        const anchorMeasurement = await this.#measureCompactionSources(anchors, level0Selection.blockIds, snapshot);
+        const selection = {
+            sourceSegments: [...anchors, ...level0Selection.segments],
+            level0SourceStoredBytes: level0Selection.storedBytes,
+            anchorSourceStoredBytes: anchorMeasurement.storedBytes,
+        };
         const sourceSegments = selection.sourceSegments;
         const sourceBlockIds = uniqueSegmentBlockIds(sourceSegments);
         const hasContiguousSourceRowIds = hasContiguousRowIds(sourceSegments);
         const hasPositiveSourceRowIds = (sourceSegments[0]?.rowIdStart ?? 0n) > 0n;
-        // A keyed L2 promotion always merges: one uniform partition shape (a full-row base with
-        // row-ID spans) regardless of whether the selected prefix happens to be pure inserts.
-        const requiresMerge = keyedLevelTwo
+        // A keyed fold always merges: one uniform partition shape (a full-row base with row-ID
+        // spans, bounded by `partitionRows`) regardless of whether the selected prefix happens to
+        // be pure inserts.
+        const requiresMerge = keyedLevelTwo || keyedLevelOne !== undefined
             ? true
             : targetLevel === 1 &&
-                (sourceSegments.some((segment) => (segment.kind ?? "insert") !== "insert" || segment.rowIdSpans !== undefined) ||
-                    (!hasContiguousSourceRowIds && table.uniqueKeyColumnId !== undefined));
+                sourceSegments.some((segment) => (segment.kind ?? "insert") !== "insert" || segment.rowIdSpans !== undefined);
         if (!requiresMerge &&
             (!hasContiguousSourceRowIds || (targetLevel === 2 && !hasPositiveSourceRowIds))) {
             return compactTableSkipped(table.name, "non-contiguous-row-ids", sourceSegments, sourceBlockIds, version);
         }
-        if (version === null)
-            throw new Error("Visible compaction segments require a manifest");
-        const targetBlockBytes = positiveWholeNumber(options.targetBlockBytes ?? DEFAULT_COMPACTION_TARGET_BLOCK_BYTES, "Compaction target block bytes");
-        if (targetBlockBytes > MAX_COMPACTION_TARGET_BLOCK_BYTES) {
-            throw new RangeError(`Compaction target block bytes cannot exceed ${String(MAX_COMPACTION_TARGET_BLOCK_BYTES)}`);
-        }
-        const outputCompression = validateCompression(options.outputCompression ?? "gzip", "Compaction output compression");
-        if (getCompressionMemoryBound(outputCompression, targetBlockBytes).maximumOutputBytes >
-            MAX_COMPACTION_TARGET_BLOCK_BYTES) {
-            throw new RangeError(`Compaction target block bytes exceed the ${outputCompression} worst-case format limit`);
-        }
-        const memoryBudgetBytes = positiveWholeNumber(options.memoryBudgetBytes ?? DEFAULT_COMPACTION_MEMORY_BUDGET_BYTES, "Compaction memory budget");
         let mergePlan;
         if (requiresMerge) {
             try {
-                mergePlan = await this.#createMergeCompactionPlan(table, sourceSegments, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot);
+                mergePlan = await this.#createMergeCompactionPlan(table, sourceSegments, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot, partitioning);
             }
             catch (error) {
                 // A keyed L2 prefix whose mutations reference keys living in already-published
@@ -5534,7 +6303,7 @@ export class MinnowDatabase {
             }
         }
         const rewritePlan = mergePlan ??
-            (await this.#createRechunkCompactionPlan(table, sourceSegments, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot));
+            (await this.#createRechunkCompactionPlan(table, sourceSegments, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot, rechunkPartitioning));
         const minimumMemoryBytes = compactionMinimumMemoryBytes(rewritePlan);
         if (minimumMemoryBytes > memoryBudgetBytes) {
             throw new CompactionMemoryBudgetError(memoryBudgetBytes, minimumMemoryBytes);
@@ -5560,7 +6329,7 @@ export class MinnowDatabase {
             const priorAttemptOutputStoredBytes = (await this.store.listCompactionJobs(table.id))
                 .filter((candidate) => (candidate.state === "cancelled" || candidate.state === "aborted") &&
                 (candidate.id === baseJobId || candidate.id.startsWith(`${baseJobId}/retry/`)))
-                .reduce((total, candidate) => total + candidate.outputStoredBytes, 0);
+                .reduce((largest, candidate) => Math.max(largest, safeWholeNumberSum([candidate.priorAttemptOutputStoredBytes ?? 0, candidate.outputStoredBytes], "Compaction prior-attempt output stored bytes")), 0);
             const maximumOutputStoredBytes = Math.max(0, floorWholeNumberProduct(selection.level0SourceStoredBytes, maxWriteAmplification, "Compaction maximum output stored bytes") - priorAttemptOutputStoredBytes);
             const plannedOutputStoredBytesUpperBound = await this.#plannedPhysicalOutputStoredBytesUpperBound(rewritePlan, snapshot);
             levelTwoBudget = {
@@ -5646,11 +6415,40 @@ export class MinnowDatabase {
             throw error;
         }
     }
-    async #selectCompactionSources(anchor, level0Segments, minimumLevel0Segments, maxLevel0Segments, maxLevel0StoredBytes, snapshot) {
-        const transactions = new Map((await this.#transactionRecordsForSegments([
-            ...(anchor === undefined ? [] : [anchor]),
-            ...level0Segments,
-        ])).map((record) => [record.id, record]));
+    /**
+     * Sums the stored bytes of the given segments' blocks, refusing a block that appears twice
+     * among them or in `seenBlockIds` — a source block may only be superseded once.
+     */
+    async #measureCompactionSources(segments, seenBlockIds, snapshot) {
+        let total = 0;
+        const blockIds = [];
+        const measuredBlockIds = new Set();
+        for (const segment of segments) {
+            for (const blockId of Object.values(segment.columnBlockIds).flat()) {
+                if (seenBlockIds.has(blockId) || measuredBlockIds.has(blockId)) {
+                    throw new Error(`Compaction source block is referenced more than once: ${blockId}`);
+                }
+                measuredBlockIds.add(blockId);
+                blockIds.push(blockId);
+                await this.#renewInternalLeaseIfNeeded(snapshot);
+                const bytes = await this.store.getBlock(blockId);
+                if (bytes === undefined)
+                    throw new Error(`Compaction source block is missing: ${blockId}`);
+                total = safeWholeNumberSum([total, bytes.byteLength], "Compaction selected stored bytes");
+            }
+        }
+        return { storedBytes: total, blockIds };
+    }
+    /**
+     * The oldest level-zero prefix one job promotes: whole equal-order groups, at least the
+     * minimum, and past it no more than the segment and stored-byte ceilings allow. Also reports
+     * the order of the first segment left behind, which bounds the orders a fold may publish.
+     */
+    async #selectLevelZeroSources(level0Segments, minimumLevel0Segments, maxLevel0Segments, maxLevel0StoredBytes, snapshot) {
+        const transactions = new Map((await this.#transactionRecordsForSegments(level0Segments)).map((record) => [
+            record.id,
+            record,
+        ]));
         const logicalOrder = (segment) => {
             const owner = transactions.get(segment.transactionId);
             if (owner?.status !== "committed" || owner.committedVersion === null) {
@@ -5659,42 +6457,10 @@ export class MinnowDatabase {
             return segment.logicalOrder ?? owner.committedVersion;
         };
         const seenBlockIds = new Set();
-        const measureStoredBytes = async (segments) => {
-            let total = 0;
-            const blockIds = [];
-            const measuredBlockIds = new Set();
-            let duplicateBlockId = null;
-            for (const segment of segments) {
-                for (const blockId of Object.values(segment.columnBlockIds).flat()) {
-                    if (seenBlockIds.has(blockId) || measuredBlockIds.has(blockId)) {
-                        duplicateBlockId ??= blockId;
-                    }
-                    measuredBlockIds.add(blockId);
-                    blockIds.push(blockId);
-                    await this.#renewInternalLeaseIfNeeded(snapshot);
-                    const bytes = await this.store.getBlock(blockId);
-                    if (bytes === undefined)
-                        throw new Error(`Compaction source block is missing: ${blockId}`);
-                    total = safeWholeNumberSum([total, bytes.byteLength], "Compaction selected stored bytes");
-                }
-            }
-            return { storedBytes: total, blockIds, duplicateBlockId };
-        };
-        const acceptMeasurement = (measurement) => {
-            if (measurement.duplicateBlockId !== null) {
-                throw new Error(`Compaction source block is referenced more than once: ${measurement.duplicateBlockId}`);
-            }
-            measurement.blockIds.forEach((blockId) => seenBlockIds.add(blockId));
-        };
-        let anchorSourceStoredBytes = 0;
-        if (anchor !== undefined) {
-            const anchorMeasurement = await measureStoredBytes([anchor]);
-            acceptMeasurement(anchorMeasurement);
-            anchorSourceStoredBytes = anchorMeasurement.storedBytes;
-        }
-        const selectedLevel0 = [];
-        let level0SourceStoredBytes = 0;
-        for (let start = 0; start < level0Segments.length;) {
+        const selected = [];
+        let storedBytes = 0;
+        let start = 0;
+        while (start < level0Segments.length) {
             const first = level0Segments[start];
             if (first === undefined)
                 throw new Error("Compaction L0 source selection is unavailable");
@@ -5707,30 +6473,109 @@ export class MinnowDatabase {
                 end += 1;
             }
             const group = level0Segments.slice(start, end);
-            if (selectedLevel0.length >= minimumLevel0Segments &&
-                selectedLevel0.length + group.length > maxLevel0Segments) {
+            if (selected.length >= minimumLevel0Segments &&
+                selected.length + group.length > maxLevel0Segments) {
                 break;
             }
-            const groupMeasurement = await measureStoredBytes(group);
-            if (selectedLevel0.length >= minimumLevel0Segments &&
-                groupMeasurement.storedBytes > maxLevel0StoredBytes - level0SourceStoredBytes) {
+            const measurement = await this.#measureCompactionSources(group, seenBlockIds, snapshot);
+            if (selected.length >= minimumLevel0Segments &&
+                measurement.storedBytes > maxLevel0StoredBytes - storedBytes) {
                 break;
             }
-            acceptMeasurement(groupMeasurement);
-            selectedLevel0.push(...group);
-            level0SourceStoredBytes = safeWholeNumberSum([level0SourceStoredBytes, groupMeasurement.storedBytes], "Compaction selected L0 stored bytes");
+            measurement.blockIds.forEach((blockId) => seenBlockIds.add(blockId));
+            selected.push(...group);
+            storedBytes = safeWholeNumberSum([storedBytes, measurement.storedBytes], "Compaction selected L0 stored bytes");
             start = end;
         }
-        if (selectedLevel0.length < minimumLevel0Segments) {
+        if (selected.length < minimumLevel0Segments) {
             throw new Error("Compaction source selection did not satisfy its minimum L0 segment count");
         }
+        const next = level0Segments[start];
         return {
-            sourceSegments: anchor === undefined ? selectedLevel0 : [anchor, ...selectedLevel0],
-            level0SourceStoredBytes,
-            anchorSourceStoredBytes,
+            segments: selected,
+            storedBytes,
+            blockIds: seenBlockIds,
+            nextLogicalOrder: next === undefined ? null : logicalOrder(next),
         };
     }
-    async #createRechunkCompactionPlan(table, sourceSegments, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot) {
+    /**
+     * Which level-one partitions the selected deltas reach into: those holding a key that some
+     * delete, update, or upsert among them names. Inserts and upserts of new keys touch nothing;
+     * their rows join the tail. Key blocks whose zone map rules every referenced key out are
+     * skipped from the header, so a sorted key costs one decoded block per partition at most and
+     * usually none; the referenced-key set is the same size the merge planner's is.
+     */
+    async #touchedPartitionIds(keyColumn, partitions, level0Segments, memoryBudgetBytes, snapshot) {
+        const touched = new Set();
+        if (partitions.length === 0)
+            return touched;
+        const deltas = level0Segments.filter((segment) => mergeSourceReferencesKeys(segment.kind ?? "insert"));
+        if (deltas.length === 0)
+            return touched;
+        const referencedBytes = safeWholeNumberProduct(deltas.reduce((total, segment) => total + segment.rowCount, 0), MERGE_PLANNER_KEY_BYTES, "Compaction referenced keys");
+        if (referencedBytes > memoryBudgetBytes) {
+            throw new CompactionMemoryBudgetError(memoryBudgetBytes, referencedBytes);
+        }
+        const referenced = new Set();
+        for (const segment of deltas) {
+            await this.#forEachSegmentKey(segment, keyColumn, snapshot, (value) => {
+                referenced.add(overlayKeyOf(keyColumn.type, value));
+            });
+        }
+        const predicate = touchedKeyPredicate(keyColumn, referenced);
+        const descriptions = predicate === undefined
+            ? new Map()
+            : await this.#zoneDescriptions(partitions.flatMap((partition) => partition.columnBlockIds[keyColumn.id] ?? []), snapshot);
+        for (const partition of partitions) {
+            const blockIds = partition.columnBlockIds[keyColumn.id] ?? [];
+            if (blockIds.length === 0) {
+                throw new Error(`Partition has no key column blocks: ${partition.id}`);
+            }
+            for (const blockId of blockIds) {
+                const description = descriptions.get(blockId);
+                if (predicate !== undefined &&
+                    description !== undefined &&
+                    !zoneMapCanMatch(description, predicate)) {
+                    continue;
+                }
+                await this.#renewInternalLeaseIfNeeded(snapshot);
+                const bytes = await this.store.getBlock(blockId);
+                if (bytes === undefined)
+                    throw new Error(`Compaction source block is missing: ${blockId}`);
+                const decoded = await decodeBlock(bytes);
+                if (decoded.column.type !== keyColumn.type) {
+                    throw new Error(`Compaction source block differs from table schema: ${blockId}`);
+                }
+                if (decoded.column.values.some((value) => referenced.has(overlayKeyOf(keyColumn.type, value)))) {
+                    touched.add(partition.id);
+                    break;
+                }
+            }
+        }
+        return touched;
+    }
+    /** Decodes a segment's key column in row order, one block resident at a time. */
+    async #forEachSegmentKey(segment, keyColumn, snapshot, action) {
+        let rowIndex = 0;
+        for (const blockId of segment.columnBlockIds[keyColumn.id] ?? []) {
+            await this.#renewInternalLeaseIfNeeded(snapshot);
+            const bytes = await this.store.getBlock(blockId);
+            if (bytes === undefined)
+                throw new Error(`Compaction source block is missing: ${blockId}`);
+            const decoded = await decodeBlock(bytes);
+            if (decoded.column.type !== keyColumn.type) {
+                throw new Error(`Compaction source block differs from table schema: ${blockId}`);
+            }
+            for (const value of decoded.column.values) {
+                action(value, rowIndex);
+                rowIndex += 1;
+            }
+        }
+        if (rowIndex !== segment.rowCount) {
+            throw new Error(`Mutation segment key rows differ: ${segment.id}`);
+        }
+    }
+    async #createRechunkCompactionPlan(table, sourceSegments, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot, partitioning) {
         const first = sourceSegments[0];
         const last = sourceSegments[sourceSegments.length - 1];
         if (first === undefined || last === undefined) {
@@ -5784,12 +6629,20 @@ export class MinnowDatabase {
             throw new Error("Compaction could not estimate an output block size");
         }
         const rowsPerOutput = Math.max(1, Math.min(0xffff_ffff, Math.floor(targetBlockBytes / maximumEncodedBytesPerRow)));
+        const logicalOrder = await this.#firstLogicalOrder(sourceSegments);
+        const partitions = partitioning === undefined
+            ? undefined
+            : planLinearOutputPartitions(totalRows, partitioning.partitionRows, logicalOrder, partitioning.nextLevelZeroOrder);
         const estimatedOutputs = [];
-        for (let rowStart = 0; rowStart < totalRows; rowStart += rowsPerOutput) {
-            estimatedOutputs.push({
-                rowStart,
-                rowCount: Math.min(rowsPerOutput, totalRows - rowStart),
-            });
+        const outputRegions = partitions ?? [{ rowStart: 0, rowCount: totalRows }];
+        for (const region of outputRegions) {
+            const regionEnd = region.rowStart + region.rowCount;
+            for (let rowStart = region.rowStart; rowStart < regionEnd; rowStart += rowsPerOutput) {
+                estimatedOutputs.push({
+                    rowStart,
+                    rowCount: Math.min(rowsPerOutput, regionEnd - rowStart),
+                });
+            }
         }
         const outputs = await this.#refinePhysicalOutputWindows(rechunkPhysicalColumns(columns), estimatedOutputs, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot);
         return {
@@ -5799,12 +6652,19 @@ export class MinnowDatabase {
             totalRows,
             rowIdStart: first.rowIdStart,
             rowIdEndExclusive: last.rowIdEndExclusive,
-            logicalOrder: await this.#firstLogicalOrder(sourceSegments),
+            logicalOrder,
             columns,
             outputs,
+            ...(partitions === undefined ? {} : { partitions }),
         };
     }
-    async #createMergeCompactionPlan(table, sourceSegments, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot) {
+    /**
+     * Plans a merge of the sources into one canonical output. With `partitioning`, the output
+     * is also cut into level-one partitions: each rewritten source partition keeps its rows (and
+     * its logical order) in place, new rows form the tail, and every run is chunked to at most
+     * `partitionRows`, using fractional orders between unchanged neighbours.
+     */
+    async #createMergeCompactionPlan(table, sourceSegments, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot, partitioning) {
         const keyColumn = getUniqueKeyColumn(table);
         if (keyColumn === undefined) {
             throw new Error(`Mutation compaction requires a unique key: ${table.name}`);
@@ -5886,6 +6746,9 @@ export class MinnowDatabase {
         const resolved = await this.#resolveMergeOutput(table, describedSegments, keyColumn, memoryBudgetBytes, snapshot);
         const { columns, rowIdSpans, totalRows } = resolved;
         const rowIdEnvelope = rowIdSpanEnvelope(rowIdSpans);
+        const partitions = partitioning === undefined
+            ? undefined
+            : planOutputPartitions(partitioning, describedSegments, resolved.sourceOutputRowStarts, totalRows);
         let outputs = [];
         if (totalRows > 0) {
             let maximumEncodedBytesPerRow = 0;
@@ -5902,12 +6765,16 @@ export class MinnowDatabase {
                 throw new Error("Compaction could not estimate an output block size");
             }
             const rowsPerOutput = Math.max(1, Math.min(0xffff_ffff, Math.floor(targetBlockBytes / maximumEncodedBytesPerRow)));
+            // Windows never straddle a partition: each partition's blocks are its own.
             const estimatedOutputs = [];
-            for (let rowStart = 0; rowStart < totalRows; rowStart += rowsPerOutput) {
-                estimatedOutputs.push({
-                    rowStart,
-                    rowCount: Math.min(rowsPerOutput, totalRows - rowStart),
-                });
+            for (const region of partitions ?? [{ rowStart: 0, rowCount: totalRows }]) {
+                const regionEnd = region.rowStart + region.rowCount;
+                for (let rowStart = region.rowStart; rowStart < regionEnd; rowStart += rowsPerOutput) {
+                    estimatedOutputs.push({
+                        rowStart,
+                        rowCount: Math.min(rowsPerOutput, regionEnd - rowStart),
+                    });
+                }
             }
             outputs = await this.#refinePhysicalOutputWindows(mergePhysicalColumns(columns, describedSegments), estimatedOutputs, targetBlockBytes, outputCompression, memoryBudgetBytes, snapshot);
         }
@@ -5924,97 +6791,165 @@ export class MinnowDatabase {
             sourceSegments: describedSegments,
             columns,
             outputs,
+            ...(partitions === undefined ? {} : { partitions }),
         };
     }
+    /**
+     * Replays the source segments' mutations into one canonical output order, in memory that
+     * scales with the deltas rather than with the table.
+     *
+     * Every row of every row-bearing source (base, insert, upsert) gets a slot, numbered in
+     * canonical source order, and the output is the live slots in slot order. A row can only be
+     * referenced later through its key, and only delete, update, and upsert sources reference
+     * keys, so the first pass collects those keys — the touched set — and the replay then tracks
+     * slots for touched keys alone. An untouched row can never be deleted, patched, or replaced:
+     * it passes through as part of a run, one output range per source block rather than one per
+     * row. Memory is O(delta rows + touched rows) plus two bytes per slot.
+     *
+     * The semantics are those of a per-row replay:
+     * - delete: the key's live slot dies; a later insert of the key takes a new slot.
+     * - update: the named columns of the key's live slot come from the update row; the key must
+     *   be live.
+     * - upsert: when the key is live, every column of that slot comes from the upsert row and the
+     *   upsert row's own slot dies, so the row keeps its position and row ID; otherwise the
+     *   upsert row is a new live row.
+     * - insert/base: a new live row; a second live occurrence of a touched key is an error.
+     */
     async #resolveMergeOutput(table, segments, keyColumn, memoryBudgetBytes, snapshot) {
         const plannerMemoryBytes = mergePlannerMemoryBound(table, segments, keyColumn.id);
         if (plannerMemoryBytes > memoryBudgetBytes) {
             throw new CompactionMemoryBudgetError(memoryBudgetBytes, plannerMemoryBytes);
         }
         const columnIndexById = new Map(table.columns.map((column, index) => [column.id, index]));
-        const rows = [];
-        const rowIndexByKey = new Map();
+        // Pass 1: the keys any delta references, and each delta's keys in row order.
+        const touched = new Set();
+        const deltaKeys = new Map();
+        for (const segment of segments) {
+            if (!mergeSourceReferencesKeys(segment.kind))
+                continue;
+            const keys = [];
+            await this.#forEachMergeSourceKey(segment, keyColumn, snapshot, (value) => {
+                const key = overlayKeyOf(keyColumn.type, value);
+                keys.push(key);
+                touched.add(key);
+            });
+            deltaKeys.set(segment.segmentId, keys);
+        }
+        // Pass 2: replay into slot state.
+        let slotCount = 0;
+        for (const segment of segments) {
+            if (mergeSourceBearsRows(segment.kind))
+                slotCount += segment.rowCount;
+        }
+        const dead = new Uint8Array(slotCount);
+        const patched = new Uint8Array(slotCount);
+        const patches = new Map();
+        const liveSlotByKey = new Map();
+        let slotBase = 0;
         for (const segment of segments) {
             if (segment.kind === "delete") {
-                await this.#forEachMergeSourceKey(segment, keyColumn, snapshot, (value) => {
-                    const token = keyToken(keyColumn.type, value);
-                    const existingIndex = rowIndexByKey.get(token);
-                    if (existingIndex !== undefined)
-                        rows[existingIndex] = undefined;
-                    rowIndexByKey.delete(token);
-                });
+                for (const key of deltaKeys.get(segment.segmentId) ?? []) {
+                    const slot = liveSlotByKey.get(key);
+                    if (slot === undefined)
+                        continue;
+                    dead[slot] = 1;
+                    patched[slot] = 0;
+                    patches.delete(slot);
+                    liveSlotByKey.delete(key);
+                }
                 continue;
             }
             if (segment.kind === "update") {
-                const changedColumnIds = segment.columns
+                const changedColumns = segment.columns
                     .map((column) => column.columnId)
-                    .filter((columnId) => columnId !== keyColumn.id);
-                await this.#forEachMergeSourceKey(segment, keyColumn, snapshot, (value, rowIndex) => {
-                    const token = keyToken(keyColumn.type, value);
-                    const existingIndex = rowIndexByKey.get(token);
-                    const existing = existingIndex === undefined ? undefined : rows[existingIndex];
-                    if (existingIndex === undefined || existing === undefined) {
+                    .filter((columnId) => columnId !== keyColumn.id)
+                    .map((columnId) => {
+                    const columnIndex = columnIndexById.get(columnId);
+                    if (columnIndex === undefined) {
+                        throw new Error(`Mutation compaction column is missing: ${columnId}`);
+                    }
+                    return { columnId, columnIndex };
+                });
+                const keys = deltaKeys.get(segment.segmentId) ?? [];
+                for (let rowIndex = 0; rowIndex < keys.length; rowIndex += 1) {
+                    const key = keys[rowIndex];
+                    const slot = key === undefined ? undefined : liveSlotByKey.get(key);
+                    if (slot === undefined) {
                         throw new Error(`Update segment references a missing key: ${segment.segmentId}`);
                     }
-                    for (const columnId of changedColumnIds) {
-                        const columnIndex = columnIndexById.get(columnId);
-                        if (columnIndex === undefined) {
-                            throw new Error(`Mutation compaction column is missing: ${columnId}`);
-                        }
-                        existing.sources[columnIndex] = mergeSourceAt(segment, columnId, rowIndex);
+                    let patch = patches.get(slot);
+                    if (patch === undefined) {
+                        patch = new Array(table.columns.length).fill(undefined);
+                        patches.set(slot, patch);
+                        patched[slot] = 1;
                     }
-                });
+                    for (const { columnId, columnIndex } of changedColumns) {
+                        patch[columnIndex] = mergeSourceAt(segment, columnId, rowIndex);
+                    }
+                }
                 continue;
             }
-            await this.#forEachMergeSourceKey(segment, keyColumn, snapshot, (value, rowIndex) => {
-                const token = keyToken(keyColumn.type, value);
-                const existingIndex = rowIndexByKey.get(token);
-                const sources = table.columns.map((column) => mergeSourceAt(segment, column.id, rowIndex));
-                if (segment.kind === "upsert" && existingIndex !== undefined) {
-                    const existing = rows[existingIndex];
-                    if (existing === undefined) {
-                        throw new Error(`Upsert segment references an invalid row slot: ${segment.segmentId}`);
-                    }
-                    rows[existingIndex] = { rowId: existing.rowId, sources };
+            // A row-bearing source: base, insert, or upsert.
+            const base = slotBase;
+            const visit = (key, rowIndex) => {
+                if (!touched.has(key))
+                    return;
+                const slot = base + rowIndex;
+                const existing = liveSlotByKey.get(key);
+                if (existing === undefined) {
+                    liveSlotByKey.set(key, slot);
                     return;
                 }
-                if (existingIndex !== undefined) {
+                if (segment.kind !== "upsert") {
                     throw new Error(`Insert segment contains a duplicate unique key: ${segment.segmentId}`);
                 }
-                rowIndexByKey.set(token, rows.length);
-                rows.push({ rowId: rowIdAt(segment.rowIdSpans, rowIndex), sources });
-            });
+                patches.set(existing, table.columns.map((column) => mergeSourceAt(segment, column.id, rowIndex)));
+                patched[existing] = 1;
+                dead[slot] = 1;
+            };
+            const keys = deltaKeys.get(segment.segmentId);
+            if (keys !== undefined) {
+                keys.forEach(visit);
+            }
+            else if (touched.size > 0) {
+                // With nothing referencing keys there is nothing to track: every row passes through.
+                await this.#forEachMergeSourceKey(segment, keyColumn, snapshot, (value, rowIndex) => {
+                    visit(overlayKeyOf(keyColumn.type, value), rowIndex);
+                });
+            }
+            slotBase += segment.rowCount;
         }
-        const rowIdSpans = [];
-        const sourceRangesByColumn = table.columns.map(() => []);
-        let totalRows = 0;
-        for (const row of rows) {
-            if (row === undefined)
+        touched.clear();
+        liveSlotByKey.clear();
+        deltaKeys.clear();
+        // Pass 3: the live slots in slot order, as runs wherever nothing touched them.
+        const output = new MergeOutputBuilder(table.columns);
+        const sourceOutputRowStarts = new Map();
+        slotBase = 0;
+        for (const segment of segments) {
+            if (!mergeSourceBearsRows(segment.kind))
                 continue;
-            appendRowIdSpan(rowIdSpans, totalRows, row.rowId);
-            for (let columnIndex = 0; columnIndex < table.columns.length; columnIndex += 1) {
-                const column = table.columns[columnIndex];
-                const source = row.sources[columnIndex];
-                if (column === undefined || source === undefined) {
-                    throw new Error("Mutation compaction row is missing a column source");
-                }
-                const sourceRanges = sourceRangesByColumn[columnIndex];
-                if (sourceRanges === undefined)
-                    throw new Error("Mutation output column is missing");
-                appendMergeOutputRange(sourceRanges, totalRows, source);
+            sourceOutputRowStarts.set(segment.segmentId, output.totalRows);
+            let runStart = -1;
+            for (let rowIndex = 0; rowIndex < segment.rowCount; rowIndex += 1) {
+                const slot = slotBase + rowIndex;
+                if (dead[slot] === 1 || patched[slot] === 1) {
+                    if (runStart >= 0) {
+                        output.appendRun(segment, runStart, rowIndex - runStart);
+                        runStart = -1;
+                    }
+                    if (patched[slot] === 1)
+                        output.appendPatchedRow(segment, rowIndex, patches.get(slot));
+                    continue;
+                }
+                if (runStart < 0)
+                    runStart = rowIndex;
             }
-            totalRows += 1;
+            if (runStart >= 0)
+                output.appendRun(segment, runStart, segment.rowCount - runStart);
+            slotBase += segment.rowCount;
         }
-        return {
-            rowIdSpans,
-            columns: table.columns.map((column, columnIndex) => {
-                const sourceRanges = sourceRangesByColumn[columnIndex];
-                if (sourceRanges === undefined)
-                    throw new Error("Mutation output column is missing");
-                return { columnId: column.id, type: column.type, sourceRanges };
-            }),
-            totalRows,
-        };
+        return { ...output.finish(), sourceOutputRowStarts };
     }
     async #forEachMergeSourceKey(segment, column, snapshot, action) {
         const planned = segment.columns.find((candidate) => candidate.columnId === column.id);
@@ -6264,56 +7199,32 @@ export class MinnowDatabase {
             else {
                 if (outputSegmentId === null)
                     throw new Error("Compaction output segment ID is missing");
-                const desiredOutputSegment = {
-                    id: outputSegmentId,
-                    tableId: table.id,
-                    transactionId: transaction.id,
-                    rowCount: outputRowCount,
-                    rowIdStart: rewritePlan.kind === "copy-v1" ? (first?.rowIdStart ?? 0n) : rewritePlan.rowIdStart,
-                    rowIdEndExclusive: rewritePlan.kind === "copy-v1"
-                        ? (last?.rowIdEndExclusive ?? 0n)
-                        : rewritePlan.rowIdEndExclusive,
-                    columnBlockIds: rewritePlan.kind === "copy-v1"
-                        ? compactionOutputColumns(table, sourceSegments, job.id)
-                        : physicalOutputColumns(job.id, rewritePlan),
-                    kind: rewritePlan.kind === "merge-v1" ? "base" : "insert",
-                    ...(table.uniqueKeyColumnId === undefined
-                        ? {}
-                        : { keyColumnId: table.uniqueKeyColumnId }),
-                    level: job.targetLevel,
-                    ...(job.outputPartitionOrdinal === undefined
-                        ? {}
-                        : { partitionOrdinal: job.outputPartitionOrdinal }),
-                    logicalOrder: rewritePlan.kind === "copy-v1"
-                        ? await this.#firstLogicalOrder(sourceSegments)
-                        : rewritePlan.logicalOrder,
-                    ...(rewritePlan.kind === "merge-v1"
-                        ? { rowIdSpans: structuredClone(rewritePlan.rowIdSpans) }
-                        : {}),
-                    createdAt: this.#now().toISOString(),
-                };
-                const outputSegment = await this.store.getSegment(outputSegmentId);
-                if (outputSegment === undefined) {
-                    await transaction.stageSegment(desiredOutputSegment);
-                }
-                else if (outputSegment.transactionId === transaction.id) {
-                    if (!sameCompactionSegment(outputSegment, desiredOutputSegment)) {
-                        throw new Error(`A resumed compaction segment differs: ${outputSegmentId}`);
-                    }
-                    await transaction.stageExistingSegment(outputSegmentId);
-                }
-                else {
-                    const owner = await this.store.getTransaction(outputSegment.transactionId);
-                    if ((owner !== undefined && owner.status !== "aborted") ||
-                        !sameCompactionSegment(outputSegment, desiredOutputSegment)) {
-                        throw new Error(`Compaction output segment cannot be adopted: ${outputSegmentId}`);
-                    }
-                    const visible = await this.#unprunedManifestContainsAll(expectedOutputIds);
-                    if (visible) {
-                        throw new Error(`Compaction output segment is already visible: ${outputSegmentId}`);
-                    }
-                    await this.store.removeSegment(outputSegmentId);
-                    await transaction.stageSegment(desiredOutputSegment);
+                const createdAt = this.#now().toISOString();
+                const desiredOutputSegments = rewritePlan.kind === "copy-v1"
+                    ? [
+                        {
+                            id: outputSegmentId,
+                            tableId: table.id,
+                            transactionId: transaction.id,
+                            rowCount: outputRowCount,
+                            rowIdStart: first?.rowIdStart ?? 0n,
+                            rowIdEndExclusive: last?.rowIdEndExclusive ?? 0n,
+                            columnBlockIds: compactionOutputColumns(table, sourceSegments, job.id),
+                            kind: "insert",
+                            ...(table.uniqueKeyColumnId === undefined
+                                ? {}
+                                : { keyColumnId: table.uniqueKeyColumnId }),
+                            level: job.targetLevel,
+                            ...(job.outputPartitionOrdinal === undefined
+                                ? {}
+                                : { partitionOrdinal: job.outputPartitionOrdinal }),
+                            logicalOrder: await this.#firstLogicalOrder(sourceSegments),
+                            createdAt,
+                        },
+                    ]
+                    : compactionOutputSegments(table, job, rewritePlan, transaction.id, createdAt);
+                for (const desiredOutputSegment of desiredOutputSegments) {
+                    await this.#stageCompactionOutputSegment(transaction, desiredOutputSegment, expectedOutputIds);
                 }
             }
             if (job.state !== "ready") {
@@ -6327,19 +7238,30 @@ export class MinnowDatabase {
             transaction.supersedeBlocks(job.sourceBlockIds);
             transaction.markLogicallyUnchanged();
             let manifest;
-            try {
-                manifest = await transaction.commit();
-            }
-            catch (error) {
-                if (!(error instanceof WriteConflictError))
-                    throw error;
+            for (;;) {
+                let publicationConflict;
+                try {
+                    manifest = await transaction.commit();
+                    break;
+                }
+                catch (error) {
+                    if (!(error instanceof WriteConflictError))
+                        throw error;
+                    publicationConflict = error;
+                }
+                // Publication is logically neutral, so it may follow any number of concurrent data
+                // commits while every source remains visible and in the same logical position. A single
+                // retry is not sufficient: another tab (or this database's write queue) can win the
+                // manifest CAS again between rebase and commit, leaving an otherwise complete job stuck
+                // in `ready` after the last write. Keep rebasing until publication wins or a source
+                // genuinely changes.
                 const current = await this.store.getCurrentManifest();
                 const currentIds = new Set(current?.blockIds ?? []);
                 if (job.sourceBlockIds.some((id) => !currentIds.has(id))) {
                     if (transaction.status === "active")
                         await transaction.abort();
                     job = await this.#abortCompactionJob(job, "Compaction sources changed before publication");
-                    throw new Error(job.error, { cause: error });
+                    throw new Error(job.error, { cause: publicationConflict });
                 }
                 const rebased = await transaction.rebase();
                 try {
@@ -6356,11 +7278,11 @@ export class MinnowDatabase {
                     if (transaction.status === "active")
                         await transaction.abort();
                     job = await this.#abortCompactionJob(job, `Compaction source is no longer visible: ${missingSourceId}`);
-                    throw new Error(job.error, { cause: error });
+                    throw new Error(job.error, { cause: publicationConflict });
                 }
                 transaction.supersedeBlocks(job.sourceBlockIds);
                 transaction.markLogicallyUnchanged();
-                manifest = await transaction.commit();
+                await yieldToEventLoop();
             }
             job = await this.#markCompactionPublished(job, manifest.version);
             return compactionProgress(table.name, job, this.#compactionResult(table, job, manifest.version));
@@ -6423,12 +7345,12 @@ export class MinnowDatabase {
             const existing = await this.store.getBlock(outputBlockId);
             let outputBytes;
             if (existing === undefined) {
-                outputBytes = await encodePhysicalBlock(built.physical, plan.outputCompression);
+                outputBytes = await this.#encodePreferredBlock(column.columnId, plan.outputCompression, built.physical.bytes.byteLength < GZIP_MINIMUM_INPUT_BYTES, (compression) => encodePhysicalBlock(built.physical, compression));
             }
             else {
                 const decoded = await decodePhysicalBlock(existing);
                 if (decoded.description.type !== column.type ||
-                    decoded.description.compression !== plan.outputCompression ||
+                    (plan.outputCompression === "raw" && decoded.description.compression !== "raw") ||
                     decoded.description.rowCount !== output.rowCount ||
                     !sameBytes(decoded.column.bytes, built.physical.bytes)) {
                     throw new Error(`A resumed compaction block differs: ${outputBlockId}`);
@@ -6542,7 +7464,17 @@ export class MinnowDatabase {
                 throw new Error(`Concurrent segment shares a compaction source block: ${segment.id}`);
             }
         }
-        if (job.outputPartitionOrdinal !== undefined) {
+        if (job.outputPartitionOrdinal === undefined &&
+            job.targetLevel === 1 &&
+            plan.kind !== "copy-v1" &&
+            plan.partitions !== undefined) {
+            const table = await this.store.getTable(job.tableId);
+            if (table === undefined)
+                throw new Error(`Compaction table is missing: ${job.tableId}`);
+            await this.#assertPartitionedLevelOneSnapshotOrder(job, plan, table, visibleSegments, transactions);
+            return;
+        }
+        if (job.outputPartitionOrdinal !== undefined) {
             if (plan.kind === "rechunk-v1") {
                 await this.#assertLevelTwoSnapshotOrder(job, plan, snapshot, transactions);
                 return;
@@ -6559,8 +7491,11 @@ export class MinnowDatabase {
             const visibleById = new Map(visibleSegments.map((segment) => [segment.id, segment]));
             for (const planned of plan.sourceSegments) {
                 const actual = visibleById.get(planned.segmentId);
-                const owner = actual === undefined ? undefined : transactions.get(actual.transactionId);
-                if (actual === undefined || !sameMergeSourceSegment(actual, owner, planned)) {
+                if (actual === undefined) {
+                    throw new Error(`Compaction source is no longer visible: ${planned.segmentId}`);
+                }
+                const owner = transactions.get(actual.transactionId);
+                if (!sameMergeSourceSegment(actual, owner, planned)) {
                     throw new Error(`Compaction source segment differs from its plan: ${planned.segmentId}`);
                 }
             }
@@ -6623,6 +7558,93 @@ export class MinnowDatabase {
             }
         }
     }
+    /**
+     * The partitioned level-one rebase rule, shared by keyed merges and keyless rechunks. The
+     * sources must be exactly as planned. Every partition the plan left alone must still be visible
+     * and unchanged — they are read back from the planning snapshot's manifest, which the job
+     * roots until it ends, so the check needs no record of its own. Every other visible segment
+     * must be level-zero history committed after the latest source and ordered after every
+     * partition the job publishes, so the output slots into the same place relative to the deltas
+     * it did not absorb.
+     */
+    async #assertPartitionedLevelOneSnapshotOrder(job, plan, table, visibleSegments, transactions) {
+        const sourceIds = new Set(job.sourceSegmentIds);
+        const visibleById = new Map(visibleSegments.map((segment) => [segment.id, segment]));
+        const sourceManifest = await this.store.getManifest(job.sourceManifestVersion);
+        if (sourceManifest === undefined || sourceManifest.prunedAt !== undefined) {
+            throw new Error(`Compaction source manifest is unavailable: ${String(job.sourceManifestVersion)}`);
+        }
+        const plannedVisible = await this.#visibleSegmentRecords(table, new Snapshot(this.store, sourceManifest.version, sourceManifest.blockIds));
+        const plannedById = new Map(plannedVisible.map((segment) => [segment.id, segment]));
+        const plannedLayout = table.uniqueKeyColumnId === undefined
+            ? keylessLevelOneLayout(plannedVisible)
+            : keyedLevelOneLayout(plannedVisible);
+        if (plannedLayout === null)
+            throw new Error("Compaction planned layout is no longer valid");
+        let latestSource = null;
+        if (plan.kind === "merge-v1") {
+            for (const planned of plan.sourceSegments) {
+                const actual = visibleById.get(planned.segmentId);
+                if (actual === undefined) {
+                    throw new Error(`Compaction source is no longer visible: ${planned.segmentId}`);
+                }
+                const owner = transactions.get(actual.transactionId);
+                if (!sameMergeSourceSegment(actual, owner, planned)) {
+                    throw new Error(`Compaction source segment differs from its plan: ${planned.segmentId}`);
+                }
+            }
+            latestSource = plan.sourceSegments[plan.sourceSegments.length - 1] ?? null;
+        }
+        else {
+            for (const id of job.sourceSegmentIds) {
+                const actual = visibleById.get(id);
+                const planned = plannedById.get(id);
+                if (actual === undefined)
+                    throw new Error(`Compaction source is no longer visible: ${id}`);
+                if (actual.transactionId !== planned?.transactionId ||
+                    !sameCompactionSegment(actual, planned)) {
+                    throw new Error(`Compaction source segment differs from its plan: ${id}`);
+                }
+                const tuple = sourceOrderTuple(actual, transactions, "Compaction source");
+                if (latestSource === null || compareMergeSourceOrder(latestSource, tuple) < 0) {
+                    latestSource = tuple;
+                }
+            }
+        }
+        if (latestSource === null)
+            throw new Error("Compaction source order is unavailable");
+        const maxOutputOrder = plan.partitions === undefined
+            ? plan.logicalOrder
+            : Math.max(plan.logicalOrder, ...plan.partitions.map((partition) => partition.logicalOrder));
+        const retained = new Map(plannedLayout.partitions
+            .filter((partition) => !sourceIds.has(partition.id))
+            .map((partition) => [partition.id, partition]));
+        for (const segment of visibleSegments) {
+            if (sourceIds.has(segment.id))
+                continue;
+            if ((segment.level ?? 0) === 1) {
+                const planned = retained.get(segment.id);
+                if (planned?.transactionId !== segment.transactionId ||
+                    !sameCompactionSegment(segment, planned)) {
+                    throw new Error(`Concurrent segment is not a retained partition: ${segment.id}`);
+                }
+                continue;
+            }
+            if ((segment.level ?? 0) !== 0) {
+                throw new Error(`Concurrent segment has an unsupported compaction level: ${segment.id}`);
+            }
+            const tuple = sourceOrderTuple(segment, transactions, "Concurrent compaction segment");
+            if (tuple.logicalOrder <= maxOutputOrder ||
+                compareMergeSourceOrder(latestSource, tuple) >= 0) {
+                throw new Error(`Concurrent segment would reorder compaction output: ${segment.id}`);
+            }
+        }
+        for (const id of retained.keys()) {
+            if (!visibleById.has(id)) {
+                throw new Error(`Retained compaction partition is no longer visible: ${id}`);
+            }
+        }
+    }
     async #assertLevelTwoSnapshotOrder(job, plan, snapshot, transactions) {
         const table = await this.store.getTable(job.tableId);
         if (table === undefined)
@@ -6777,6 +7799,35 @@ export class MinnowDatabase {
             throw error;
         }
     }
+    /**
+     * Stages one output segment, reconciling with what a previous attempt left: the same
+     * segment staged by this transaction is reused, one left by an aborted transaction is
+     * adopted when it matches and was never published, anything else is an error.
+     */
+    async #stageCompactionOutputSegment(transaction, desired, expectedOutputIds) {
+        const existing = await this.store.getSegment(desired.id);
+        if (existing === undefined) {
+            await transaction.stageSegment(desired);
+            return;
+        }
+        if (existing.transactionId === transaction.id) {
+            if (!sameCompactionSegment(existing, desired)) {
+                throw new Error(`A resumed compaction segment differs: ${desired.id}`);
+            }
+            await transaction.stageExistingSegment(desired.id);
+            return;
+        }
+        const owner = await this.store.getTransaction(existing.transactionId);
+        if ((owner !== undefined && owner.status !== "aborted") ||
+            !sameCompactionSegment(existing, desired)) {
+            throw new Error(`Compaction output segment cannot be adopted: ${desired.id}`);
+        }
+        if (await this.#unprunedManifestContainsAll(expectedOutputIds)) {
+            throw new Error(`Compaction output segment is already visible: ${desired.id}`);
+        }
+        await this.store.removeSegment(desired.id);
+        await transaction.stageSegment(desired);
+    }
     async #abortCompactionJob(job, error) {
         return this.store.updateCompactionJob(job.id, job.revision, {
             state: "aborted",
@@ -6803,6 +7854,7 @@ export class MinnowDatabase {
             sourceSegmentCount: job.sourceSegmentIds.length,
             sourceBlockCount: job.sourceBlockIds.length,
             outputSegmentId: job.outputSegmentId,
+            outputSegmentIds: compactionOutputSegmentIds(job),
             outputBlockCount: job.outputBlockIds.length,
             rowCount,
             sourceStoredBytes: job.sourceStoredBytes,
@@ -8062,26 +9114,42 @@ export class MinnowDatabase {
      * bytes and never correctness.
      */
     async #encodeColumnBlock(columnId, input) {
-        if (this.#compression !== "gzip")
-            return encodeBlock(input, this.#compression);
+        return this.#encodePreferredBlock(columnId, this.#compression, columnInputBytesBelow(input, GZIP_MINIMUM_INPUT_BYTES), (compression) => encodeBlock(input, compression));
+    }
+    /**
+     * Applies the same adaptive gzip rule to ordinary writes and compaction output. `gzip` is a
+     * preference, not a promise: tiny inputs and probes that save less than 20% stay raw. Only a
+     * failed verdict is cached, so successful columns do not leave one map entry behind forever.
+     */
+    async #encodePreferredBlock(columnId, preferred, belowMinimum, encode) {
+        if (preferred !== "gzip")
+            return encode(preferred);
+        if (belowMinimum)
+            return encode("raw");
         const verdict = this.#gzipVerdicts.get(columnId);
-        if (verdict !== undefined && !verdict.worthwhile) {
-            if (verdict.blocksSince < GZIP_REPROBE_BLOCKS) {
-                verdict.blocksSince += 1;
-                return encodeBlock(input, "raw");
+        if (verdict !== undefined) {
+            if (verdict < GZIP_REPROBE_BLOCKS) {
+                this.#gzipVerdicts.set(columnId, verdict + 1);
+                return encode("raw");
             }
             this.#gzipVerdicts.delete(columnId);
         }
-        const bytes = await encodeBlock(input, "gzip");
+        const bytes = await encode("gzip");
         const description = inspectBlock(bytes);
-        if (description.encodedLength >= GZIP_DECISION_MIN_BYTES) {
-            const worthwhile = description.encodedLength >= bytes.byteLength * GZIP_WORTHWHILE_RATIO;
-            this.#gzipVerdicts.set(columnId, { worthwhile, blocksSince: 0 });
+        const worthwhile = description.encodedLength >= bytes.byteLength * GZIP_WORTHWHILE_RATIO;
+        if (!worthwhile) {
+            if (!this.#gzipVerdicts.has(columnId) &&
+                this.#gzipVerdicts.size >= GZIP_VERDICT_CACHE_LIMIT) {
+                const oldest = this.#gzipVerdicts.keys().next().value;
+                if (oldest !== undefined)
+                    this.#gzipVerdicts.delete(oldest);
+            }
+            this.#gzipVerdicts.set(columnId, 0);
             // Nothing was gained, so hand back the uncompressed form rather than make every read of
             // this block pay to inflate it.
-            if (!worthwhile)
-                return encodeBlock(input, "raw");
+            return encode("raw");
         }
+        this.#gzipVerdicts.delete(columnId);
         return bytes;
     }
     async #findTable(name) {
@@ -8542,6 +9610,22 @@ function batchKeys(table, input) {
     }
     return keys;
 }
+/**
+ * Whether a column block's logical payload is under `limit` bytes: strings by length (two
+ * bytes a code unit, stopping as soon as the limit is reached), everything else eight bytes a
+ * value. An estimate, for the write path's codec choice — not an encoded size.
+ */
+function columnInputBytesBelow(input, limit) {
+    if (input.type !== "string")
+        return input.values.length * 8 < limit;
+    let bytes = 0;
+    for (const value of input.values) {
+        bytes += 8 + (value === null ? 0 : value.length * 2);
+        if (bytes >= limit)
+            return false;
+    }
+    return true;
+}
 /** `keyToken` for values that may not encode: undefined instead of a thrown encoding error. */
 function tryKeyToken(type, value) {
     try {
@@ -8551,6 +9635,34 @@ function tryKeyToken(type, value) {
         return undefined;
     }
 }
+/**
+ * Whether a table's visible segments warrant a background fold: enough segments for a scan to
+ * pay per-segment overhead, or enough deltas that every query replays a history. Counted in
+ * segments, not rows — a handful of deltas costs little however many rows they hold, and
+ * folding rewrites the table's anchor, so it is reserved for when the count has built up.
+ */
+/**
+ * Whether a table's visible history warrants a background fold: enough level-zero segments to
+ * fragment a scan, or enough deltas to cost one. Partitions compaction itself published
+ * (level one and above) are the folded state, not fragmentation, and do not count — a large
+ * keyed table is many partitions by design.
+ */
+function autoCompactionDue(segments) {
+    let levelZero = 0;
+    let deltas = 0;
+    for (const segment of segments) {
+        if ((segment.level ?? 0) === 0)
+            levelZero += 1;
+        const kind = segment.kind ?? "insert";
+        if (kind !== "insert" && kind !== "base")
+            deltas += 1;
+    }
+    return levelZero >= AUTO_COMPACT_SCAN_SEGMENTS || deltas >= AUTO_COMPACT_DELTA_SEGMENTS;
+}
+/** A macrotask boundary, so background work lets queued queries and writes run between steps. */
+function yieldToEventLoop() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
 function keyToken(type, value) {
     if (value === null)
         throw new TypeError("Unique key cannot be null");
@@ -8578,6 +9690,12 @@ function keyToken(type, value) {
 function formatValue(value) {
     return value instanceof Date ? value.toISOString() : String(value);
 }
+function nonNegativeWholeNumber(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative whole number`);
+    }
+    return value;
+}
 function positiveWholeNumber(value, name) {
     if (!Number.isSafeInteger(value) || value <= 0) {
         throw new RangeError(`${name} must be a positive whole number`);
@@ -9087,6 +10205,229 @@ function estimatedColumnarBytes(segments, columns) {
         rowWidth += column.type === "string" ? 32 : 8;
     return rows * Math.max(rowWidth, 1);
 }
+/** Whether a visible segment is a delete or update delta rather than appended rows. */
+function mutationSegmentKind(segment) {
+    const kind = segment.kind ?? "insert";
+    return kind !== "insert" && kind !== "base";
+}
+const BYTE_POPCOUNT = new Uint8Array(256).map((_, byte) => {
+    let count = 0;
+    for (let value = byte; value !== 0; value &= value - 1)
+        count += 1;
+    return count;
+});
+/** Set bits in `bitmap` over bit indexes `[from, to)`. */
+function bitmapCountRange(bitmap, from, to) {
+    let count = 0;
+    let index = from;
+    while (index < to && (index & 7) !== 0) {
+        if (bitmapHasValue(bitmap, index))
+            count += 1;
+        index += 1;
+    }
+    while (index + 8 <= to) {
+        count += BYTE_POPCOUNT[bitmap[index >>> 3] ?? 0] ?? 0;
+        index += 8;
+    }
+    while (index < to) {
+        if (bitmapHasValue(bitmap, index))
+            count += 1;
+        index += 1;
+    }
+    return count;
+}
+/** The first index in ascending `sorted` whose value is at least `value`. */
+function sortedLowerBound(sorted, value) {
+    let low = 0;
+    let high = sorted.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if ((sorted[middle] ?? 0) < value)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+/** Members of ascending `sorted` in `[from, to)`. */
+function sortedCountRange(sorted, from, to) {
+    return sortedLowerBound(sorted, to) - sortedLowerBound(sorted, from);
+}
+function overlayWindowRuns(dead, patchedSlots, from, to, patchedInWindow) {
+    const steps = [];
+    let nextPatched = patchedInWindow > 0 ? sortedLowerBound(patchedSlots, from) : -1;
+    let row = from;
+    while (row < to) {
+        // Dead rows, eight at a time where a whole byte is dead.
+        if (bitmapHasValue(dead, row)) {
+            row += 1;
+            while (row < to && (row & 7) === 0 && dead[row >>> 3] === 0xff && row + 8 <= to)
+                row += 8;
+            while (row < to && bitmapHasValue(dead, row))
+                row += 1;
+            continue;
+        }
+        const patchedRow = nextPatched >= 0 ? (patchedSlots[nextPatched] ?? to) : to;
+        if (row === patchedRow) {
+            steps.push(row, 0);
+            row += 1;
+            nextPatched += 1;
+            if (nextPatched >= patchedSlots.length)
+                nextPatched = -1;
+            continue;
+        }
+        // A live run: up to the next patched row, the window end, or the next dead row — live
+        // rows are consecutive except where a delete cut them, and whole live bytes skip in one.
+        const limit = Math.min(to, patchedRow);
+        const runStart = row;
+        row += 1;
+        while (row < limit && (row & 7) === 0 && row + 8 <= limit && dead[row >>> 3] === 0)
+            row += 8;
+        while (row < limit && !bitmapHasValue(dead, row))
+            row += 1;
+        steps.push(runStart, row - runStart);
+    }
+    return steps;
+}
+/**
+ * Copies `length` bits from `source` at bit `sourceStart` to `target` at bit `targetStart`,
+ * whole bytes at a time once the target is byte-aligned: the target bytes it overwrites lie
+ * entirely inside the copied range, so the target's other bits are left alone. This is what
+ * makes a validity copy proportional to bytes rather than to cells.
+ */
+function copyBitRun(source, sourceStart, target, targetStart, length) {
+    let remaining = length;
+    let from = sourceStart;
+    let to = targetStart;
+    while (remaining > 0 && (to & 7) !== 0) {
+        if (bitmapHasValue(source, from))
+            setBitmapValue(target, to);
+        from += 1;
+        to += 1;
+        remaining -= 1;
+    }
+    const shift = from & 7;
+    if (shift === 0) {
+        const bytes = remaining >>> 3;
+        if (bytes > 0) {
+            target.set(source.subarray(from >>> 3, (from >>> 3) + bytes), to >>> 3);
+            from += bytes * 8;
+            to += bytes * 8;
+            remaining -= bytes * 8;
+        }
+    }
+    else {
+        while (remaining >= 8) {
+            const sourceByte = from >>> 3;
+            target[to >>> 3] =
+                (((source[sourceByte] ?? 0) >>> shift) | ((source[sourceByte + 1] ?? 0) << (8 - shift))) &
+                    0xff;
+            from += 8;
+            to += 8;
+            remaining -= 8;
+        }
+    }
+    while (remaining > 0) {
+        if (bitmapHasValue(source, from))
+            setBitmapValue(target, to);
+        from += 1;
+        to += 1;
+        remaining -= 1;
+    }
+}
+/**
+ * An outer window that is the inner window's rows from `offset` on, by reference: typed-array
+ * views over the resident block, and its dictionary as-is. Validity is a view too when the
+ * offset falls on a byte, and otherwise the one small copy a bit offset forces.
+ */
+function overlayWindowView(inner, offset, rows, memory, column, reservations) {
+    let validity;
+    if ((offset & 7) === 0) {
+        validity = inner.validity.subarray(offset >>> 3, (offset >>> 3) + Math.ceil(rows / 8));
+    }
+    else {
+        validity = new Uint8Array(Math.ceil(rows / 8));
+        reservations.push(memory.reserve(validity.byteLength, `Streamed window ${column.name}`));
+        copyBitRun(inner.validity, offset, validity, 0, rows);
+    }
+    const fields = { validity, window: { start: 0, length: rows } };
+    if (inner.kind === "string") {
+        fields.codes = inner.codes.subarray(offset, offset + rows);
+        fields.dictionary = inner.dictionary;
+    }
+    else {
+        fields.values = inner.values.subarray(offset, offset + rows);
+    }
+    return fields;
+}
+/**
+ * An outer window compacted from an inner window: live runs copied as slices, patched rows
+ * read from their update vectors. A string window shares the inner dictionary unless a patch
+ * has to add to it, in which case it copies the dictionary first.
+ */
+function overlayWindowCompacted(inner, innerWindowStart, steps, rows, patches, column, memory, reservations) {
+    const validityBytes = Math.ceil(rows / 8);
+    const typedBytes = validityBytes +
+        (inner.kind === "boolean"
+            ? rows
+            : inner.kind === "string"
+                ? rows * Uint32Array.BYTES_PER_ELEMENT
+                : rows * Float64Array.BYTES_PER_ELEMENT);
+    reservations.push(memory.reserve(typedBytes, `Streamed window ${column.name}`));
+    const validity = new Uint8Array(validityBytes);
+    const values = inner.kind === "boolean"
+        ? new Uint8Array(rows)
+        : inner.kind === "string"
+            ? undefined
+            : new Float64Array(rows);
+    const codes = inner.kind === "string" ? new Uint32Array(rows) : undefined;
+    codes?.fill(NULL_STRING_VECTOR_CODE);
+    let dictionary = inner.kind === "string" ? inner.dictionary : undefined;
+    let dictionaryIndex;
+    let dictionaryCopied = false;
+    const target = (codes !== undefined
+        ? { kind: "string", length: rows, validity, codes, dictionary: dictionary ?? [] }
+        : { kind: inner.kind, length: rows, validity, values });
+    let out = 0;
+    for (let index = 0; index < steps.length; index += 2) {
+        const start = steps[index] ?? 0;
+        const length = steps[index + 1] ?? 0;
+        const patch = length === 0 ? patches?.get(start)?.get(column.id) : undefined;
+        if (patch === undefined) {
+            const count = Math.max(1, length);
+            copyVectorSpan(inner, start - innerWindowStart, count, target, out);
+            out += count;
+            continue;
+        }
+        if (target.kind === "string" && !dictionaryCopied) {
+            // A patch value may be new to this window's dictionary, and the inner's belongs to the
+            // buffer pool: copy before the first append, and index the copy for the lookups.
+            dictionary = [...(dictionary ?? [])];
+            target.dictionary = dictionary;
+            dictionaryIndex = new Map(dictionary.map((value, code) => [value, code]));
+            dictionaryCopied = true;
+        }
+        copyColumnVectorValue(patch.vector, patch.row, target, out, dictionaryIndex);
+        out += 1;
+    }
+    if (out !== rows)
+        throw new Error(`Column row count mismatch: ${column.name}`);
+    if (dictionaryCopied && dictionary !== undefined) {
+        let dictionaryBytes = 0;
+        for (const value of dictionary)
+            dictionaryBytes += 16 + value.length * 2;
+        reservations.push(memory.reserve(dictionaryBytes, `Streamed window ${column.name}`));
+    }
+    const fields = { validity, window: { start: 0, length: rows } };
+    if (codes !== undefined) {
+        fields.codes = codes;
+        fields.dictionary = dictionary ?? [];
+    }
+    else if (values !== undefined) {
+        fields.values = values;
+    }
+    return fields;
+}
 /**
  * Reads a key column's values as primitives. Dictionary-coded strings resolve through the
  * dictionary the vector already holds, so a string key costs one array index and no encoding.
@@ -9140,9 +10481,10 @@ function touchedKeyPredicate(keyColumn, touched) {
     return { column: keyColumn, operator: "IN", value: members[0] ?? 0, members };
 }
 /**
- * Copies a run of rows between vectors: values as one typed-array slice, validity bit by bit.
+ * Copies a run of rows between vectors: values as one typed-array slice, validity as a bit run.
  * A string run needs `remap` unless both sides share a dictionary — the codes mean nothing on
- * their own. This is what keeps a copy proportional to bytes rather than to cells.
+ * their own. This is what keeps a copy proportional to bytes rather than to cells. The target
+ * validity bits of the run must be clear beforehand, as a fresh window's are.
  */
 function copyVectorSpan(source, sourceStart, length, target, targetStart, remap) {
     if (source.kind === "string") {
@@ -9172,26 +10514,7 @@ function copyVectorSpan(source, sourceStart, length, target, targetStart, remap)
         }
         target.values.set(source.values.subarray(sourceStart, sourceStart + length), targetStart);
     }
-    for (let index = 0; index < length; index += 1) {
-        if (bitmapHasValue(source.validity, sourceStart + index)) {
-            setBitmapValue(target.validity, targetStart + index);
-        }
-    }
-}
-/** Source dictionary code -> target dictionary code, built once per source window. */
-function remapDictionary(source, targetDictionary, targetIndex) {
-    const remap = new Uint32Array(source.length);
-    for (let code = 0; code < source.length; code += 1) {
-        const value = source[code] ?? "";
-        let mapped = targetIndex.get(value);
-        if (mapped === undefined) {
-            mapped = targetDictionary.length;
-            targetDictionary.push(value);
-            targetIndex.set(value, mapped);
-        }
-        remap[code] = mapped;
-    }
-    return remap;
+    copyBitRun(source.validity, sourceStart, target.validity, targetStart, length);
 }
 /**
  * The live rows of a vector, in order. Runs between deletions copy as typed-array slices and
@@ -9568,13 +10891,356 @@ function sourceOrderTuple(segment, transactions, label) {
         segmentId: segment.id,
     };
 }
+/** Modeled bytes per referenced key the merge planner and the partition probe hold resident. */
+const MERGE_PLANNER_KEY_BYTES = 96;
+function planLinearOutputPartitions(totalRows, partitionRows, firstOrder, nextOrder) {
+    const count = Math.max(1, Math.ceil(totalRows / partitionRows));
+    const orders = fractionalLogicalOrders(firstOrder, nextOrder, count);
+    const partitions = [];
+    for (let index = 0, rowStart = 0; index < count; index += 1) {
+        const rowCount = Math.min(partitionRows, totalRows - rowStart);
+        const logicalOrder = orders[index];
+        if (rowCount <= 0 || logicalOrder === undefined) {
+            throw new Error("Rechunk partition layout is incomplete");
+        }
+        partitions.push({ rowStart, rowCount, logicalOrder });
+        rowStart += rowCount;
+    }
+    return partitions;
+}
+/**
+ * Cuts the canonical merged output into the partitions a keyed fold publishes.
+ *
+ * Each rewritten source partition's surviving rows form one region that keeps the partition's
+ * logical order, and so its place among the partitions the fold leaves alone. The rows of the
+ * level-zero sources — the tail — form a region behind every existing partition, or extend
+ * the last partition's region when the fold absorbs them into it. A region is then chunked to
+ * at most `partitionRows` rows per published partition. The first chunk keeps the source
+ * partition's order and every further chunk takes an evenly spaced fractional order before
+ * the unchanged successor;
+ * a fresh tail starts at its earliest source's order. Fractional orders make room independent
+ * of adjacent commit versions, so every output is bounded by `partitionRows`. The order is
+ * stable: a published partition sorts strictly between its neighbours and below every
+ * level-zero segment, so a later fold rewrites it alone without moving a row.
+ */
+function planOutputPartitions(partitioning, sources, sourceOutputRowStarts, totalRows) {
+    const { partitions, partitionRows, absorbsTail, nextLevelZeroOrder } = partitioning;
+    const startOf = (segmentId) => {
+        const start = sourceOutputRowStarts.get(segmentId);
+        if (start === undefined)
+            throw new Error(`Merge source has no output position: ${segmentId}`);
+        return start;
+    };
+    const levelZeroRowSources = sources.filter((source) => source.level === 0 && mergeSourceBearsRows(source.kind));
+    const tailStart = levelZeroRowSources.length === 0 ? totalRows : startOf(levelZeroRowSources[0]?.segmentId ?? "");
+    const sourceIds = new Set(sources.map((source) => source.segmentId));
+    const sourcedPartitionIndexes = partitions.flatMap((partition, index) => sourceIds.has(partition.id) ? [index] : []);
+    const regions = [];
+    for (const [position, index] of sourcedPartitionIndexes.entries()) {
+        const partition = partitions[index];
+        const order = partition?.logicalOrder;
+        if (partition === undefined || order === undefined) {
+            throw new Error("Partitioned merge source is not a level-one partition");
+        }
+        const nextSourced = sourcedPartitionIndexes[position + 1];
+        const isLast = index === partitions.length - 1;
+        const rowStart = startOf(partition.id);
+        const rowEnd = isLast && absorbsTail
+            ? totalRows
+            : nextSourced === undefined
+                ? tailStart
+                : startOf(partitions[nextSourced]?.id ?? "");
+        const successorOrder = partitions[index + 1]?.logicalOrder ?? nextLevelZeroOrder;
+        regions.push({
+            rowStart,
+            rowCount: rowEnd - rowStart,
+            anchorOrder: order,
+            roomStart: order,
+            roomEnd: successorOrder,
+            preferredOrder: order,
+        });
+    }
+    if (!(absorbsTail && partitions.length > 0)) {
+        const lastOrder = partitions[partitions.length - 1]?.logicalOrder ?? -1;
+        regions.push({
+            rowStart: tailStart,
+            rowCount: totalRows - tailStart,
+            anchorOrder: null,
+            roomStart: lastOrder,
+            roomEnd: nextLevelZeroOrder,
+            preferredOrder: Math.min(...sources.filter((source) => source.level === 0).map((source) => source.logicalOrder)),
+        });
+    }
+    const output = [];
+    for (const region of regions) {
+        if (region.rowCount <= 0)
+            continue;
+        const chunks = Math.max(1, Math.ceil(region.rowCount / partitionRows));
+        const firstOrder = region.anchorOrder ?? region.preferredOrder;
+        if (!validLogicalOrder(firstOrder) ||
+            firstOrder >= region.roomEnd ||
+            (region.anchorOrder === null && firstOrder <= region.roomStart)) {
+            throw new Error("Partitioned merge has no logical-order interval for its output");
+        }
+        const logicalOrders = fractionalLogicalOrders(firstOrder, region.roomEnd, chunks);
+        const baseRows = Math.floor(region.rowCount / chunks);
+        const extraRows = region.rowCount % chunks;
+        let rowStart = region.rowStart;
+        for (let chunk = 0; chunk < chunks; chunk += 1) {
+            const rowCount = baseRows + (chunk < extraRows ? 1 : 0);
+            const logicalOrder = logicalOrders[chunk];
+            if (logicalOrder === undefined)
+                throw new Error("Partition logical order is unavailable");
+            output.push({ rowStart, rowCount, logicalOrder });
+            rowStart += rowCount;
+        }
+    }
+    let coveredRows = 0;
+    for (const [index, partition] of output.entries()) {
+        const previous = output[index - 1];
+        if (partition.rowStart !== coveredRows ||
+            partition.rowCount <= 0 ||
+            partition.logicalOrder >= nextLevelZeroOrder ||
+            (previous !== undefined && previous.logicalOrder >= partition.logicalOrder)) {
+            throw new Error("Partitioned merge produced an invalid partition layout");
+        }
+        coveredRows += partition.rowCount;
+    }
+    if (coveredRows !== totalRows) {
+        throw new Error("Partitioned merge partitions do not cover the merged output");
+    }
+    return output;
+}
+/** `count` increasing doubles in [first, upper), retaining `first` exactly. */
+function fractionalLogicalOrders(first, upper, count) {
+    if (!validLogicalOrder(first) || !Number.isFinite(upper) || upper <= first || count < 1) {
+        throw new Error("Partition logical-order interval is invalid");
+    }
+    const orders = [];
+    for (let index = 0; index < count; index += 1) {
+        const order = index === 0 ? first : first + ((upper - first) * index) / count;
+        const previous = orders[index - 1];
+        if (!validLogicalOrder(order) ||
+            order >= upper ||
+            (previous !== undefined && order <= previous)) {
+            throw new Error("Partition logical-order precision is exhausted");
+        }
+        orders.push(order);
+    }
+    return orders;
+}
+/**
+ * The planner's working memory, as `#resolveMergeOutput` allocates it: two bytes per slot, the
+ * touched-key set and live-slot map over the delta keys, one patch array per patched row, one
+ * decoded key block at a time, and the output ranges themselves — which number the source
+ * blocks plus one per patched cell, not one per row. Deliberately generous per element; this
+ * bound is what a caller's `memoryBudgetBytes` is judged against, so it must not be optimistic.
+ */
 function mergePlannerMemoryBound(table, segments, keyColumnId) {
-    const candidateRows = safeWholeNumberSum(segments
-        .filter((segment) => segment.kind === "insert" || segment.kind === "upsert" || segment.kind === "base")
-        .map((segment) => segment.rowCount), "Mutation compaction candidate rows");
-    const keyEncodedBytes = safeWholeNumberSum(segments.flatMap((segment) => (segment.columns.find((column) => column.columnId === keyColumnId)?.sourceBlocks ?? []).map((block) => block.encodedBytes)), "Mutation compaction key bytes");
-    const rowMetadataBytes = safeWholeNumberProduct(candidateRows, safeWholeNumberSum([256, safeWholeNumberProduct(table.columns.length, 256, "Mutation compaction row cells")], "Mutation compaction row metadata"), "Mutation compaction row metadata");
-    return safeWholeNumberSum([rowMetadataBytes, safeWholeNumberProduct(keyEncodedBytes, 4, "Mutation compaction keys")], "Mutation compaction planner memory");
+    const SLOT_BYTES = 2;
+    const KEY_BYTES = MERGE_PLANNER_KEY_BYTES;
+    const PATCH_ROW_BYTES = 64;
+    const PATCH_CELL_BYTES = 48;
+    const RANGE_BYTES = 80;
+    const DECODED_KEY_BLOCK_FACTOR = 4;
+    let slotRows = 0;
+    let deltaKeys = 0;
+    let patchRows = 0;
+    let sourceBlocks = 0;
+    let largestKeyBlockBytes = 0;
+    for (const segment of segments) {
+        if (mergeSourceBearsRows(segment.kind))
+            slotRows += segment.rowCount;
+        if (mergeSourceReferencesKeys(segment.kind))
+            deltaKeys += segment.rowCount;
+        if (segment.kind === "update" || segment.kind === "upsert")
+            patchRows += segment.rowCount;
+        for (const column of segment.columns) {
+            sourceBlocks += column.sourceBlocks.length;
+            if (column.columnId !== keyColumnId)
+                continue;
+            for (const block of column.sourceBlocks) {
+                largestKeyBlockBytes = Math.max(largestKeyBlockBytes, block.encodedBytes);
+            }
+        }
+    }
+    const columns = table.columns.length;
+    return safeWholeNumberSum([
+        safeWholeNumberProduct(slotRows, SLOT_BYTES, "Mutation compaction slots"),
+        safeWholeNumberProduct(deltaKeys, KEY_BYTES, "Mutation compaction keys"),
+        safeWholeNumberProduct(patchRows, safeWholeNumberSum([
+            PATCH_ROW_BYTES,
+            safeWholeNumberProduct(columns, PATCH_CELL_BYTES, "Mutation patch cells"),
+        ], "Mutation compaction patch row"), "Mutation compaction patches"),
+        safeWholeNumberProduct(safeWholeNumberSum([sourceBlocks, safeWholeNumberProduct(patchRows, columns, "Mutation patched cells")], "Mutation compaction ranges"), RANGE_BYTES, "Mutation compaction range bytes"),
+        safeWholeNumberProduct(largestKeyBlockBytes, DECODED_KEY_BLOCK_FACTOR, "Mutation compaction decoded key block"),
+    ], "Mutation compaction planner memory");
+}
+/** Whether a source of this kind contributes rows to the merged output. */
+function mergeSourceBearsRows(kind) {
+    return kind === "insert" || kind === "upsert" || kind === "base";
+}
+/** Whether a source of this kind names existing rows by key. */
+function mergeSourceReferencesKeys(kind) {
+    return kind === "delete" || kind === "update" || kind === "upsert";
+}
+/**
+ * A decoded key value as the primitive the overlay replay keys on (`OverlayKey`): equal keys
+ * are equal primitives, and one table's key has one type, so nothing can collide.
+ */
+function overlayKeyOf(type, value) {
+    if (value === null)
+        throw new TypeError("Unique key cannot be null");
+    switch (type) {
+        case "boolean":
+            if (typeof value !== "boolean")
+                throw new TypeError("Invalid boolean unique key");
+            return value;
+        case "number":
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                throw new TypeError("Invalid number unique key");
+            }
+            return value;
+        case "string":
+            if (typeof value !== "string")
+                throw new TypeError("Invalid string unique key");
+            return value;
+        case "datetime":
+            if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+                throw new TypeError("Invalid datetime unique key");
+            }
+            return value.getTime();
+    }
+}
+/**
+ * Accumulates the merged output as coalesced row-ID spans and per-column source ranges. A run
+ * of untouched rows appends at most one range per source block it crosses, whatever its
+ * length; a patched row appends one range per column. Adjacent ranges over the same block
+ * merge in place, so the finished plan is proportional to blocks plus patched cells.
+ */
+class MergeOutputBuilder {
+    #columns;
+    #rowIdSpans = [];
+    #rangesByColumn;
+    #blocksBySegment = new Map();
+    #totalRows = 0;
+    constructor(columns) {
+        this.#columns = columns;
+        this.#rangesByColumn = columns.map(() => []);
+    }
+    /** Output rows appended so far. */
+    get totalRows() {
+        return this.#totalRows;
+    }
+    /** Rows `[rowStart, rowStart + rowCount)` of a row-bearing source, unchanged. */
+    appendRun(segment, rowStart, rowCount) {
+        if (rowCount <= 0)
+            return;
+        this.#appendRowIds(segment, rowStart, rowCount);
+        const blocksByColumn = this.#sourceBlocks(segment);
+        for (let columnIndex = 0; columnIndex < this.#columns.length; columnIndex += 1) {
+            const blocks = blocksByColumn[columnIndex];
+            const ranges = this.#rangesByColumn[columnIndex];
+            if (blocks === undefined || ranges === undefined) {
+                throw new Error("Mutation output column is missing");
+            }
+            let outputRow = this.#totalRows;
+            let remaining = rowCount;
+            let rowIndex = rowStart;
+            while (remaining > 0) {
+                const block = rowRangeAt(blocks, rowIndex);
+                if (block === undefined) {
+                    throw new Error(`Mutation source row is missing: ${segment.segmentId}`);
+                }
+                const count = Math.min(remaining, block.rowStart + block.rowCount - rowIndex);
+                appendMergeOutputRange(ranges, outputRow, block.blockId, rowIndex - block.rowStart, count);
+                outputRow += count;
+                rowIndex += count;
+                remaining -= count;
+            }
+        }
+        this.#totalRows += rowCount;
+    }
+    /** One row of a row-bearing source whose columns may come from later mutations. */
+    appendPatchedRow(segment, rowIndex, patch) {
+        this.#appendRowIds(segment, rowIndex, 1);
+        for (let columnIndex = 0; columnIndex < this.#columns.length; columnIndex += 1) {
+            const column = this.#columns[columnIndex];
+            const ranges = this.#rangesByColumn[columnIndex];
+            if (column === undefined || ranges === undefined) {
+                throw new Error("Mutation output column is missing");
+            }
+            const source = patch?.[columnIndex] ?? mergeSourceAt(segment, column.id, rowIndex);
+            appendMergeOutputRange(ranges, this.#totalRows, source.blockId, source.sourceRowIndex, 1);
+        }
+        this.#totalRows += 1;
+    }
+    finish() {
+        return {
+            rowIdSpans: this.#rowIdSpans,
+            columns: this.#columns.map((column, columnIndex) => {
+                const sourceRanges = this.#rangesByColumn[columnIndex];
+                if (sourceRanges === undefined)
+                    throw new Error("Mutation output column is missing");
+                return { columnId: column.id, type: column.type, sourceRanges };
+            }),
+            totalRows: this.#totalRows,
+        };
+    }
+    #sourceBlocks(segment) {
+        let blocks = this.#blocksBySegment.get(segment.segmentId);
+        if (blocks === undefined) {
+            blocks = this.#columns.map((column) => {
+                const source = segment.columns.find((candidate) => candidate.columnId === column.id);
+                if (source === undefined) {
+                    throw new Error(`Mutation source row is missing: ${segment.segmentId}:${column.id}`);
+                }
+                return source.sourceBlocks;
+            });
+            this.#blocksBySegment.set(segment.segmentId, blocks);
+        }
+        return blocks;
+    }
+    #appendRowIds(segment, rowStart, rowCount) {
+        let outputRow = this.#totalRows;
+        let remaining = rowCount;
+        let rowIndex = rowStart;
+        while (remaining > 0) {
+            const span = rowRangeAt(segment.rowIdSpans, rowIndex);
+            if (span === undefined) {
+                throw new Error(`Mutation source row ID is missing: ${String(rowIndex)}`);
+            }
+            const count = Math.min(remaining, span.rowStart + span.rowCount - rowIndex);
+            appendRowIdSpan(this.#rowIdSpans, outputRow, span.rowIdStart + BigInt(rowIndex - span.rowStart), count);
+            outputRow += count;
+            rowIndex += count;
+            remaining -= count;
+        }
+    }
+}
+/** Appends `rowCount` consecutive row IDs from `rowId`, extending the last span when contiguous. */
+function appendRowIdSpan(spans, rowStart, rowId, rowCount) {
+    const previous = spans[spans.length - 1];
+    if (previous !== undefined &&
+        previous.rowStart + previous.rowCount === rowStart &&
+        previous.rowIdStart + BigInt(previous.rowCount) === rowId) {
+        previous.rowCount += rowCount;
+    }
+    else {
+        spans.push({ rowStart, rowCount, rowIdStart: rowId });
+    }
+}
+/** Appends `rowCount` output rows read from one source block, extending the last range when contiguous. */
+function appendMergeOutputRange(ranges, outputRowStart, sourceBlockId, sourceRowStart, rowCount) {
+    const previous = ranges[ranges.length - 1];
+    if (previous?.sourceBlockId === sourceBlockId &&
+        previous.outputRowStart + previous.rowCount === outputRowStart &&
+        previous.sourceRowStart + previous.rowCount === sourceRowStart) {
+        previous.rowCount += rowCount;
+    }
+    else {
+        ranges.push({ outputRowStart, sourceBlockId, sourceRowStart, rowCount });
+    }
 }
 function mergeSourceAt(segment, columnId, rowIndex) {
     const column = segment.columns.find((candidate) => candidate.columnId === columnId);
@@ -9584,12 +11250,6 @@ function mergeSourceAt(segment, columnId, rowIndex) {
     }
     return { blockId: block.blockId, sourceRowIndex: rowIndex - block.rowStart };
 }
-function rowIdAt(spans, rowIndex) {
-    const span = rowRangeAt(spans, rowIndex);
-    if (span === undefined)
-        throw new Error(`Mutation source row ID is missing: ${String(rowIndex)}`);
-    return span.rowIdStart + BigInt(rowIndex - span.rowStart);
-}
 function rowRangeAt(ranges, rowIndex) {
     let low = 0;
     let high = ranges.length - 1;
@@ -9610,17 +11270,6 @@ function rowRangeAt(ranges, rowIndex) {
     }
     return undefined;
 }
-function appendRowIdSpan(spans, rowStart, rowId) {
-    const previous = spans[spans.length - 1];
-    if (previous !== undefined &&
-        previous.rowStart + previous.rowCount === rowStart &&
-        previous.rowIdStart + BigInt(previous.rowCount) === rowId) {
-        spans[spans.length - 1] = { ...previous, rowCount: previous.rowCount + 1 };
-    }
-    else {
-        spans.push({ rowStart, rowCount: 1, rowIdStart: rowId });
-    }
-}
 function rowIdSpanEnvelope(spans) {
     if (spans.length === 0)
         return { start: 0n, endExclusive: 0n };
@@ -9635,22 +11284,6 @@ function rowIdSpanEnvelope(spans) {
     }
     return { start, endExclusive };
 }
-function appendMergeOutputRange(ranges, outputRowStart, source) {
-    const previous = ranges[ranges.length - 1];
-    if (previous?.sourceBlockId === source.blockId &&
-        previous.outputRowStart + previous.rowCount === outputRowStart &&
-        previous.sourceRowStart + previous.rowCount === source.sourceRowIndex) {
-        ranges[ranges.length - 1] = { ...previous, rowCount: previous.rowCount + 1 };
-    }
-    else {
-        ranges.push({
-            outputRowStart,
-            sourceBlockId: source.blockId,
-            sourceRowStart: source.sourceRowIndex,
-            rowCount: 1,
-        });
-    }
-}
 function validatePhysicalTablePlan(table, plan) {
     if (table.columns.length !== plan.columns.length ||
         table.columns.some((column, index) => {
@@ -9779,12 +11412,108 @@ function physicalOutputBlockId(jobId, outputIndex, columnIndex) {
 function physicalOutputBlockIds(jobId, plan) {
     return plan.outputs.flatMap((_output, outputIndex) => plan.columns.map((_column, columnIndex) => physicalOutputBlockId(jobId, outputIndex, columnIndex)));
 }
-function physicalOutputColumns(jobId, plan) {
+function physicalOutputColumns(jobId, plan, window = {
+    rowStart: 0,
+    rowCount: plan.totalRows,
+}) {
+    const windowEnd = window.rowStart + window.rowCount;
     return Object.fromEntries(plan.columns.map((column, columnIndex) => [
         column.columnId,
-        plan.outputs.map((_output, outputIndex) => physicalOutputBlockId(jobId, outputIndex, columnIndex)),
+        plan.outputs.flatMap((output, outputIndex) => output.rowStart >= window.rowStart && output.rowStart + output.rowCount <= windowEnd
+            ? [physicalOutputBlockId(jobId, outputIndex, columnIndex)]
+            : []),
     ]));
 }
+/** The segment ID partition `index` of a partitioned merge publishes under. */
+function partitionOutputSegmentId(outputSegmentId, index) {
+    return index === 0 ? outputSegmentId : `${outputSegmentId}/${String(index)}`;
+}
+/** Every segment a job publishes: one per output partition, or the single output segment. */
+function compactionOutputSegmentIds(job) {
+    if (job.outputSegmentId === null)
+        return [];
+    const plan = job.rewritePlan;
+    if ((plan?.kind !== "merge-v1" && plan?.kind !== "rechunk-v1") || plan.partitions === undefined) {
+        return [job.outputSegmentId];
+    }
+    const outputSegmentId = job.outputSegmentId;
+    return plan.partitions.map((_partition, index) => partitionOutputSegmentId(outputSegmentId, index));
+}
+/**
+ * The segments a physical compaction publishes, with the blocks of the windows each covers.
+ * A partitioned rewrite publishes one level-one segment per planned partition. A merge carries
+ * the slice of its row-ID spans; a rechunk carries the corresponding contiguous interval.
+ */
+function compactionOutputSegments(table, job, plan, transactionId, createdAt) {
+    const outputSegmentId = job.outputSegmentId;
+    if (outputSegmentId === null)
+        throw new Error("Compaction output segment ID is missing");
+    const keyColumn = table.uniqueKeyColumnId === undefined ? {} : { keyColumnId: table.uniqueKeyColumnId };
+    const partitionOrdinal = job.outputPartitionOrdinal === undefined
+        ? {}
+        : { partitionOrdinal: job.outputPartitionOrdinal };
+    if (plan.partitions !== undefined) {
+        return plan.partitions.map((partition, index) => {
+            const rowIdSpans = plan.kind === "merge-v1"
+                ? sliceRowIdSpans(plan.rowIdSpans, partition.rowStart, partition.rowCount)
+                : undefined;
+            const envelope = rowIdSpans === undefined
+                ? {
+                    start: plan.rowIdStart + BigInt(partition.rowStart),
+                    endExclusive: plan.rowIdStart + BigInt(partition.rowStart + partition.rowCount),
+                }
+                : rowIdSpanEnvelope(rowIdSpans);
+            return {
+                id: partitionOutputSegmentId(outputSegmentId, index),
+                tableId: table.id,
+                transactionId,
+                rowCount: partition.rowCount,
+                rowIdStart: envelope.start,
+                rowIdEndExclusive: envelope.endExclusive,
+                columnBlockIds: physicalOutputColumns(job.id, plan, partition),
+                kind: plan.kind === "merge-v1" ? "base" : "insert",
+                ...keyColumn,
+                level: job.targetLevel,
+                ...partitionOrdinal,
+                logicalOrder: partition.logicalOrder,
+                ...(rowIdSpans === undefined ? {} : { rowIdSpans }),
+                createdAt,
+            };
+        });
+    }
+    return [
+        {
+            id: outputSegmentId,
+            tableId: table.id,
+            transactionId,
+            rowCount: plan.totalRows,
+            rowIdStart: plan.rowIdStart,
+            rowIdEndExclusive: plan.rowIdEndExclusive,
+            columnBlockIds: physicalOutputColumns(job.id, plan),
+            kind: plan.kind === "merge-v1" ? "base" : "insert",
+            ...keyColumn,
+            level: job.targetLevel,
+            ...partitionOrdinal,
+            logicalOrder: plan.logicalOrder,
+            ...(plan.kind === "merge-v1" ? { rowIdSpans: structuredClone(plan.rowIdSpans) } : {}),
+            createdAt,
+        },
+    ];
+}
+/** The spans of output rows `[rowStart, rowStart + rowCount)`, rebased to start at row zero. */
+function sliceRowIdSpans(spans, rowStart, rowCount) {
+    const sliced = [];
+    const rowEnd = rowStart + rowCount;
+    for (const span of spans) {
+        const spanEnd = span.rowStart + span.rowCount;
+        if (spanEnd <= rowStart || span.rowStart >= rowEnd)
+            continue;
+        const start = Math.max(span.rowStart, rowStart);
+        const end = Math.min(spanEnd, rowEnd);
+        appendRowIdSpan(sliced, start - rowStart, span.rowIdStart + BigInt(start - span.rowStart), end - start);
+    }
+    return sliced;
+}
 function isActiveCompactionState(state) {
     return state === "planned" || state === "running" || state === "ready";
 }
@@ -9889,6 +11618,9 @@ function garbageCollectionProgress(job) {
             reclaimedBlockCount: job.reclaimedBlockCount,
             retainedBlockCount: job.retainedBlockCount,
             missingBlockCount: job.missingBlockCount,
+            reclaimedTransactionCount: job.reclaimedTransactionCount,
+            retainedTransactionCount: job.retainedTransactionCount,
+            missingTransactionCount: job.missingTransactionCount,
             physicallyReclaimedBytes: job.reclaimedBlockBytes,
         }
         : null;
@@ -9898,9 +11630,14 @@ function garbageCollectionProgress(job) {
         examinedManifestCount: job.cursor.manifestIndex,
         examinedSegmentCount: job.cursor.segmentIndex,
         examinedBlockCount: job.cursor.blockIndex,
+        examinedTransactionCount: job.cursor.transactionIndex,
         result,
     };
 }
+/** Whether any of the table's triggers for these events fire AFTER the write, staging rows. */
+function firesAfterTriggers(table, ...events) {
+    return (table.triggers ?? []).some((trigger) => trigger.timing === "after" && events.includes(trigger.event));
+}
 /** Collects every real table name referenced by a block, its derived sources, or its subqueries. */
 function collectRealTableNames(plan) {
     const names = new Set();
@@ -10090,22 +11827,19 @@ function hasContiguousRowIds(segments) {
         return previous === undefined || previous.rowIdEndExclusive === segment.rowIdStart;
     });
 }
+function validLogicalOrder(value) {
+    return value !== undefined && Number.isFinite(value) && value >= 0;
+}
 function appendLevelTwoLayout(segments) {
-    let index = 0;
+    const levelOneSegments = levelOnePartitionPrefix(segments);
+    if (levelOneSegments === null ||
+        levelOneSegments.some((segment) => (segment.kind ?? "insert") !== "insert" || segment.rowIdSpans !== undefined)) {
+        return null;
+    }
+    let index = levelOneSegments.length;
     const retainedPrefix = [];
     const levelTwoSegments = [];
-    const first = segments[0];
-    if (first !== undefined && (first.level ?? 0) === 1) {
-        if ((first.kind ?? "insert") !== "insert" ||
-            first.rowIdSpans !== undefined ||
-            first.partitionOrdinal !== undefined ||
-            (first.logicalOrder !== undefined &&
-                (!Number.isSafeInteger(first.logicalOrder) || first.logicalOrder < 0))) {
-            return null;
-        }
-        retainedPrefix.push(first);
-        index += 1;
-    }
+    retainedPrefix.push(...levelOneSegments);
     for (;;) {
         const segment = segments[index];
         if (segment === undefined || (segment.level ?? 0) !== 2)
@@ -10113,8 +11847,7 @@ function appendLevelTwoLayout(segments) {
         if ((segment.kind ?? "insert") !== "insert" ||
             segment.rowIdSpans !== undefined ||
             segment.partitionOrdinal !== levelTwoSegments.length ||
-            !Number.isSafeInteger(segment.logicalOrder) ||
-            (segment.logicalOrder ?? -1) < 0 ||
+            !validLogicalOrder(segment.logicalOrder) ||
             segment.rowIdEndExclusive - segment.rowIdStart !== BigInt(segment.rowCount)) {
             return null;
         }
@@ -10127,8 +11860,7 @@ function appendLevelTwoLayout(segments) {
         segment.partitionOrdinal !== undefined ||
         (segment.kind ?? "insert") !== "insert" ||
         segment.rowIdSpans !== undefined ||
-        (segment.logicalOrder !== undefined &&
-            (!Number.isSafeInteger(segment.logicalOrder) || segment.logicalOrder < 0)))) {
+        (segment.logicalOrder !== undefined && !validLogicalOrder(segment.logicalOrder)))) {
         return null;
     }
     const rowIdIntervals = segments
@@ -10148,46 +11880,67 @@ function appendLevelTwoLayout(segments) {
     return { retainedPrefix, levelTwoSegments, level0Segments };
 }
 /**
- * Validates a keyed table's visible history for multi-range L2 promotion: existing partitions
- * (append-shaped inserts or merged bases carrying row-ID spans) with ordinals exactly 0..N-1,
- * then an optional single level-one anchor, then level-zero segments of any mutation kind. Every
- * row footprint — a partition's spans or interval, the anchor's, and each level-zero
- * insert/upsert interval — must be pairwise disjoint; update and delete deltas carry no
- * footprint. Returns null when the shape does not hold so the planner skips explicitly.
+ * Validates a keyed table's visible history for a partitioned level-one fold: a prefix of
+ * level-one partitions — merged bases carrying row-ID spans, or append-shaped inserts — each
+ * with an explicit logical order, strictly increasing along the prefix; then level-zero
+ * segments of any mutation kind. Every row footprint must be pairwise disjoint. Returns null
+ * when the shape does not hold so the planner skips explicitly.
  */
-function keyedLevelTwoLayout(segments) {
-    let index = 0;
-    const levelTwoSegments = [];
-    for (;;) {
-        const segment = segments[index];
-        if (segment === undefined || (segment.level ?? 0) !== 2)
+function keyedLevelOneLayout(segments) {
+    const partitions = levelOnePartitionPrefix(segments);
+    if (partitions === null)
+        return null;
+    const level0Segments = segments.slice(partitions.length);
+    if (level0Segments.some((segment) => (segment.level ?? 0) !== 0 || segment.partitionOrdinal !== undefined)) {
+        return null;
+    }
+    if (!disjointRowIdFootprints(segments))
+        return null;
+    return { partitions, level0Segments };
+}
+/** The append-only counterpart: bounded L1 partitions followed by contiguous insert deltas. */
+function keylessLevelOneLayout(segments) {
+    const partitions = levelOnePartitionPrefix(segments);
+    if (partitions === null ||
+        partitions.some((segment) => (segment.kind ?? "insert") !== "insert")) {
+        return null;
+    }
+    const level0Segments = segments.slice(partitions.length);
+    if (level0Segments.some((segment) => (segment.level ?? 0) !== 0 ||
+        segment.partitionOrdinal !== undefined ||
+        (segment.kind ?? "insert") !== "insert" ||
+        segment.rowIdSpans !== undefined) ||
+        !hasContiguousRowIds(segments)) {
+        return null;
+    }
+    return { partitions, level0Segments };
+}
+/**
+ * The leading level-one segments, when they form a valid partition prefix: insert or base
+ * kinds, no L2 ordinal, and explicit strictly increasing logical orders. Null otherwise.
+ */
+function levelOnePartitionPrefix(segments) {
+    const partitions = [];
+    for (const segment of segments) {
+        if ((segment.level ?? 0) !== 1)
             break;
         const kind = segment.kind ?? "insert";
-        if (segment.partitionOrdinal !== levelTwoSegments.length ||
-            !Number.isSafeInteger(segment.logicalOrder) ||
-            (segment.logicalOrder ?? -1) < 0 ||
-            (kind !== "insert" && kind !== "base") ||
-            (kind === "insert" && segment.rowIdSpans !== undefined) ||
-            (kind === "base" && (segment.rowIdSpans?.length ?? 0) === 0)) {
-            return null;
-        }
-        levelTwoSegments.push(segment);
-        index += 1;
-    }
-    let anchor;
-    const maybeAnchor = segments[index];
-    if (maybeAnchor !== undefined && (maybeAnchor.level ?? 0) === 1) {
-        const kind = maybeAnchor.kind ?? "insert";
-        if ((kind !== "insert" && kind !== "base") || maybeAnchor.partitionOrdinal !== undefined) {
+        const previousOrder = partitions[partitions.length - 1]?.logicalOrder ?? -1;
+        if ((kind !== "insert" && kind !== "base") ||
+            segment.partitionOrdinal !== undefined ||
+            !validLogicalOrder(segment.logicalOrder) ||
+            (segment.logicalOrder ?? -1) <= previousOrder) {
             return null;
         }
-        anchor = maybeAnchor;
-        index += 1;
-    }
-    const level0Segments = segments.slice(index);
-    if (level0Segments.some((segment) => (segment.level ?? 0) !== 0 || segment.partitionOrdinal !== undefined)) {
-        return null;
+        partitions.push(segment);
     }
+    return partitions;
+}
+/**
+ * Whether the segments' row footprints — spans where present, otherwise the contiguous
+ * interval — are positive and pairwise disjoint. Update and delete deltas carry no footprint.
+ */
+function disjointRowIdFootprints(segments) {
     const intervals = [];
     for (const segment of segments) {
         if (segment.rowIdSpans !== undefined) {
@@ -10199,18 +11952,56 @@ function keyedLevelTwoLayout(segments) {
         if (segment.rowIdEndExclusive <= segment.rowIdStart)
             continue;
         if (segment.rowIdEndExclusive - segment.rowIdStart !== BigInt(segment.rowCount))
-            return null;
+            return false;
         intervals.push({ start: segment.rowIdStart, end: segment.rowIdEndExclusive });
     }
     intervals.sort((left, right) => left.start < right.start ? -1 : left.start > right.start ? 1 : 0);
     for (const [intervalIndex, interval] of intervals.entries()) {
         if (interval.start <= 0n)
-            return null;
+            return false;
         const previous = intervals[intervalIndex - 1];
         if (previous !== undefined && interval.start < previous.end)
+            return false;
+    }
+    return true;
+}
+/**
+ * Validates a keyed table's visible history for multi-range L2 promotion: existing partitions
+ * (append-shaped inserts or merged bases carrying row-ID spans) with ordinals exactly 0..N-1,
+ * then the level-one partitions, then level-zero segments of any mutation kind. Every row
+ * footprint — a partition's spans or interval, the anchors', and each level-zero insert/upsert
+ * interval — must be pairwise disjoint; update and delete deltas carry no footprint. Returns
+ * null when the shape does not hold so the planner skips explicitly.
+ */
+function keyedLevelTwoLayout(segments) {
+    let index = 0;
+    const levelTwoSegments = [];
+    for (;;) {
+        const segment = segments[index];
+        if (segment === undefined || (segment.level ?? 0) !== 2)
+            break;
+        const kind = segment.kind ?? "insert";
+        if (segment.partitionOrdinal !== levelTwoSegments.length ||
+            !validLogicalOrder(segment.logicalOrder) ||
+            (kind !== "insert" && kind !== "base") ||
+            (kind === "insert" && segment.rowIdSpans !== undefined) ||
+            (kind === "base" && (segment.rowIdSpans?.length ?? 0) === 0)) {
             return null;
+        }
+        levelTwoSegments.push(segment);
+        index += 1;
+    }
+    const anchors = levelOnePartitionPrefix(segments.slice(index));
+    if (anchors === null)
+        return null;
+    index += anchors.length;
+    const level0Segments = segments.slice(index);
+    if (level0Segments.some((segment) => (segment.level ?? 0) !== 0 || segment.partitionOrdinal !== undefined)) {
+        return null;
     }
-    return { levelTwoSegments, anchor, level0Segments };
+    if (!disjointRowIdFootprints(segments))
+        return null;
+    return { levelTwoSegments, anchors, level0Segments };
 }
 function compactionWriteAmplificationSkipped(input) {
     return {