@minnowdb/core 0.5.0 → 0.6.0

package/dist/engine/database.js

@@ -1,8 +1,10 @@
 import { toColumnarBatch, } from "./batch.js";
 import { ArtifactCache } from "./artifact-cache.js";
+import { throwIfAborted } from "./cancellation.js";
 import { BufferedTableWriter } from "./buffered-writer.js";
 export { attachLifecycleFlush, BufferedTableWriter, MAX_BUFFERED_WRITER_PENDING_ADDS, } from "./buffered-writer.js";
-import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, UnknownTableError, UniqueConstraintError, VisibleSegmentCursorStaleError, } from "./errors.js";
+import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, DatabaseReadBacklogError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, UnknownTableError, UniqueConstraintError, VisibleSegmentCursorStaleError, } from "./errors.js";
+export { DatabaseReadBacklogError } from "./errors.js";
 import { BLOCK_HEADER_LENGTH, buildPhysicalColumnFromRanges, decodeBlock, decodePhysicalBlock, encodeBlock, encodePhysicalBlock, getCompressionMemoryBound, inspectBlock, maximumPhysicalBlockByteLength, MAX_BLOCK_METADATA_BYTE_LENGTH, MAX_BLOCK_ROW_COUNT, MAX_PHYSICAL_COLUMN_BYTE_LENGTH, MAX_STORED_BLOCK_BYTE_LENGTH, measurePhysicalColumnRanges, physicalColumnByteLength, slicePhysicalColumn, StoredBlockPayloadTooLargeError, wellFormedUtf8ByteLength, } from "../block-format/index.js";
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
 import { estimateCompactionRowsPerOutput, planAlignedWriteBlockRanges as writeBlockRanges, } from "./write-block-planner.js";
@@ -20,7 +22,7 @@ import { chooseJoinOrder, renderPlan } from "./optimizer.js";
 import { encodeSqlEqualityValue } from "./sql-semantics.js";
 import { externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
 import { toCatalog } from "./catalog.js";
-import { applyColumnSteps, assertColumnDroppable, declaredForeignKeys, isDestructiveStep, planMigration, } from "./schema.js";
+import { applyColumnSteps, assertColumnDroppable, compileGeneratedColumnExpression, declaredForeignKeys, isDestructiveStep, planMigration, } from "./schema.js";
 import { columnarTableFromRows, createColumnarTable, vectorValue, } from "./vector.js";
 // The on-disk format is little-endian; the bulk Float64 copy reads platform order.
 const PLATFORM_LITTLE_ENDIAN = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
@@ -103,14 +105,6 @@ export const MAX_TRANSACTION_SAVEPOINT_BYTES = 8 * 1024 * 1024;
 export const MAX_DATABASE_PENDING_WRITES = 64;
 /** Concurrent direct reads retained by one database instance. Reads still execute in parallel. */
 export const MAX_DATABASE_ACTIVE_READS = 256;
-export class DatabaseReadBacklogError extends Error {
-    limit;
-    name = "DatabaseReadBacklogError";
-    constructor(limit = MAX_DATABASE_ACTIVE_READS) {
-        super(`A database cannot retain more than ${String(limit)} active reads; await a read`);
-        this.limit = limit;
-    }
-}
 /** Commits tolerated while collection fails before foreground writes assist and backpressure. */
 const AUTO_COLLECT_MAX_DEBT_COMMITS = 4_096;
 /** Failed background passes retry without another write, with bounded exponential backoff. */
@@ -291,17 +285,29 @@ function isTransactionalStatement(statement) {
         statement.kind === "delete" ||
         statement.kind === "select");
 }
+function returningExecuteFields(table, columns, rows) {
+    return {
+        returnedRows: rows,
+        returnedColumns: [...columns],
+        returnedColumnDomains: columns.map((name) => table.columns.find((column) => column.name === name)?.sqlDomain ?? null),
+    };
+}
 function externalizeExecuteResult(result) {
     if (!("returnedRows" in result) || !Array.isArray(result.returnedRows))
         return result;
-    const columns = [...new Set(result.returnedRows.flatMap((row) => Object.keys(row)))];
+    const columns = result.returnedColumns ?? [
+        ...new Set(result.returnedRows.flatMap((row) => Object.keys(row))),
+    ];
+    const columnDomains = result.returnedColumnDomains ?? unknownColumnDomains(columns);
     return {
         ...result,
         returnedRows: externalizeQueryResult({
             columns,
-            columnDomains: unknownColumnDomains(columns),
+            columnDomains,
             rows: result.returnedRows,
         }).rows,
+        returnedColumns: [...columns],
+        returnedColumnDomains: structuredClone(columnDomains),
     };
 }
 /** Rejects an INSERT value that is still an unbound `?`/`$n` slot. */
@@ -571,6 +577,8 @@ export class MinnowDatabase {
     #droppingTables = new Set();
     /** Per table: the visible segment count a failed auto-compaction must see before retrying. */
     #autoCompactionBackoff = new Map();
+    /** Exact current-layout counters; local commits advance them without rescanning history. */
+    #autoCompactionHints = 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. */
@@ -749,6 +757,7 @@ export class MinnowDatabase {
         this.#autoCompactionsRequested.clear();
         this.#idleCompactionTableIds.clear();
         this.#autoCompactionBackoff.clear();
+        this.#autoCompactionHints.clear();
         this.#commitsSinceCompactionCheck.clear();
         this.#artifactCache.clear();
     }
@@ -813,6 +822,9 @@ export class MinnowDatabase {
                 ...(sqlDomain === undefined ? {} : { sqlDomain: structuredClone(sqlDomain) }),
                 nullable: column.nullable ?? false,
                 ...(column.defaultValue === undefined ? {} : { defaultValue: column.defaultValue }),
+                ...(column.generatedValue === undefined
+                    ? {}
+                    : { generatedValue: structuredClone(column.generatedValue) }),
                 ...(column.enumValues === undefined
                     ? {}
                     : { enumValues: validateEnumValues(column.enumValues, columnName) }),
@@ -871,6 +883,15 @@ export class MinnowDatabase {
             throw new TypeError(`Unique key cannot be nullable: ${uniqueKeyColumn.name}`);
         }
         for (const column of columns) {
+            if (column.generatedValue !== undefined) {
+                if (column.defaultValue !== undefined || column.backfill !== undefined) {
+                    throw new TypeError(`A generated column cannot also have a default or backfill: ${name}.${column.name}`);
+                }
+                compileGeneratedColumnExpression(name, column.name, column.generatedValue.sql, columns);
+                if (column === uniqueKeyColumn || compositePrimaryColumns.includes(column)) {
+                    throw new TypeError(`Generated columns cannot be row-addressing keys: ${name}.${column.name}`);
+                }
+            }
             if (column.defaultValue !== undefined) {
                 validateColumnDefault({ ...column, isUniqueKey: column === uniqueKeyColumn }, column.defaultValue);
                 if (column.defaultValue.kind === "literal" && column.sqlDomain !== undefined) {
@@ -1059,6 +1080,9 @@ export class MinnowDatabase {
                         : { sqlDomain: structuredClone(column.sqlDomain) }),
                     nullable: column.nullable,
                     ...(column.defaultValue === undefined ? {} : { defaultValue: column.defaultValue }),
+                    ...(column.generatedValue === undefined
+                        ? {}
+                        : { generatedValue: column.generatedValue }),
                     ...(column.enumValues === undefined ? {} : { enumValues: [...column.enumValues] }),
                 })),
                 ...(uniqueKey === undefined ? {} : { uniqueKey }),
@@ -1129,7 +1153,7 @@ export class MinnowDatabase {
     }
     async #withReadReservation(run) {
         if (this.#activeReadReservations >= MAX_DATABASE_ACTIVE_READS) {
-            throw new DatabaseReadBacklogError();
+            throw new DatabaseReadBacklogError(MAX_DATABASE_ACTIVE_READS);
         }
         this.#activeReadReservations += 1;
         try {
@@ -1140,7 +1164,9 @@ export class MinnowDatabase {
         }
     }
     async #queryWithReadReservation(sql, options) {
+        throwIfAborted(options.signal);
         await this.#settleExpiredStatementTransaction();
+        throwIfAborted(options.signal);
         // An open statement transaction routes through its session, which owns the reservation for
         // the actual execution. Avoid charging the same query twice at this public boundary.
         return this.#openTransaction === undefined
@@ -1569,6 +1595,7 @@ export class MinnowDatabase {
                 for (const column of table.columns)
                     this.#gzipVerdicts.delete(column.id);
                 this.#autoCompactionBackoff.delete(table.id);
+                this.#autoCompactionHints.delete(table.id);
                 this.#commitsSinceCompactionCheck.delete(table.id);
                 this.#idleCompactionTableIds.delete(table.id);
                 const postingPrefix = `${table.id}/`;
@@ -1634,6 +1661,7 @@ export class MinnowDatabase {
             Object.values(pivoted.columns).find((values) => values.length > 0)?.length ??
             0;
         normalizeDomainBatch(table, filled.batch);
+        fillStoredGeneratedColumns(table, filled.batch, inputRowCount, filled.generated);
         for (const name of filled.generated.keys()) {
             const column = table.columns.find((candidate) => candidate.name === name);
             const values = filled.batch.columns[name];
@@ -1720,6 +1748,7 @@ export class MinnowDatabase {
                 throw new TypeError(`Table needs a unique key before rows can be updated: ${table.name}`);
             }
             const normalizedInput = normalizeDomainUpdate(table, input);
+            rejectGeneratedUpdateAssignments(table, normalizedInput);
             const keys = validateUpdateBatch(table, keyColumn, normalizedInput);
             const current = await this.store.getTable(table.id);
             if (current === undefined)
@@ -1737,6 +1766,10 @@ export class MinnowDatabase {
             changes: Object.fromEntries(Object.entries(changes).map(([name, value]) => [name, [value]])),
         });
     }
+    /** Deletes one row by the table's unique key. */
+    async delete(tableName, key) {
+        return this.deleteBatch(tableName, { keys: [key] });
+    }
     deleteBatch(tableName, input) {
         return this.#withWriteReservation(() => this.#deleteBatchReserved(tableName, input));
     }
@@ -1972,15 +2005,13 @@ export class MinnowDatabase {
     async #writeUpdateBatch(table, keyColumn, input, keys) {
         await this.#assertCompactionCapacity(table);
         const started = performance.now();
-        const logicalBytes = estimateValuesBytes(input.keys) +
-            Object.values(input.changes).reduce((total, values) => total + estimateValuesBytes(values), 0);
+        let logicalBytes;
         // Deferred: the record rides the single-shot commit below unless trigger rows stage first.
         const transaction = await this.#transactions.beginDeferred({ durableSnapshot: false });
         transaction.limitLevelZeroSegments(table.id, MAX_LEVEL_ZERO_SEGMENTS);
         const blockStager = new BoundedWriteBlockStager(transaction);
         const segmentId = this.#createId();
         const columnBlockIds = {};
-        const changedColumns = Object.keys(input.changes).sort();
         let storedBytes = 0;
         let blockCount = 0;
         let encodeMs = 0;
@@ -1989,6 +2020,22 @@ export class MinnowDatabase {
         let retries = 0;
         try {
             await this.#assertKeysExist(table, keyColumn, transaction.snapshotVersion, keys);
+            const checks = table.checks ?? [];
+            let changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
+                foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
+            const preImages = await this.#triggerPreImages(table, keyColumn, input.keys.filter((key) => key !== null), "update", (sql, params) => this.#sessionQuery(transaction, sql, { params }), checks.length > 0 ||
+                changedForeignKey ||
+                tableGeneratedExpressions(table).length > 0 ||
+                secondaryIndexUpdateNeedsPreImages(table, input) ||
+                readyUniqueSecondaryIndexes(table).some(({ columns }) => columns.some((column) => input.changes[column.name] !== undefined)));
+            input = applyStoredGeneratedUpdateChanges(table, input, preImages);
+            validateUpdateBatch(table, keyColumn, input);
+            changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
+                foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
+            logicalBytes =
+                estimateValuesBytes(input.keys) +
+                    Object.values(input.changes).reduce((total, values) => total + estimateValuesBytes(values), 0);
+            const changedColumns = Object.keys(input.changes).sort();
             const columns = [keyColumn, ...changedColumns.map((name) => findColumn(table, name))];
             const plannedColumns = columns.map((column) => writeColumnValues(column.type, column.id === keyColumn.id ? input.keys : (input.changes[column.name] ?? [])));
             const ranges = writeBlockRanges(plannedColumns, input.keys.length, this.#rowsPerBlock, this.#targetBlockBytes);
@@ -2022,13 +2069,6 @@ export class MinnowDatabase {
                 }
                 columnBlockIds[column.id] = blockIds;
             }
-            const checks = table.checks ?? [];
-            const changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
-                foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
-            const preImages = await this.#triggerPreImages(table, keyColumn, input.keys.filter((key) => key !== null), "update", (sql, params) => this.#sessionQuery(transaction, sql, { params }), checks.length > 0 ||
-                changedForeignKey ||
-                secondaryIndexUpdateNeedsPreImages(table, input) ||
-                readyUniqueSecondaryIndexes(table).some(({ columns }) => columns.some((column) => input.changes[column.name] !== undefined)));
             stageSecondaryUniqueMutationChanges(transaction, table, input, preImages);
             const secondaryDeltas = buildSecondaryUpdateDeltas(table, input, preImages);
             if (secondaryDeltas.length > 0) {
@@ -2101,6 +2141,14 @@ export class MinnowDatabase {
                         blockCount,
                         storedBytes,
                         version: manifest.version,
+                        ...(tableGeneratedExpressions(table).length === 0
+                            ? {}
+                            : {
+                                generatedColumns: Object.fromEntries(tableGeneratedExpressions(table).map(({ column }) => [
+                                    column.name,
+                                    (input.changes[column.name] ?? []).map((value) => externalSqlDomainValue(value)),
+                                ])),
+                            }),
                         metrics: createWriteMetrics({
                             logicalBytes,
                             storedBytes,
@@ -2554,12 +2602,14 @@ export class MinnowDatabase {
     }
     async #prepareCompiledPlan(plan, options = {}, probe) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         // 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, probe);
+            throwIfAborted(options.signal);
             return {
                 sql: prepared.sql,
                 tables: prepared.tables,
@@ -2580,6 +2630,7 @@ export class MinnowDatabase {
             let outputNeedsExternalization = true;
             let outputColumnDomains = [];
             const prepareAtSnapshot = async (snapshot, realTables, visibility) => {
+                throwIfAborted(options.signal);
                 const typedSchemas = new Map([...realTables.values()].map((table) => [
                     table.name,
                     table.columns.map(({ name, type, integer, sqlDomain }) => ({
@@ -2595,30 +2646,37 @@ export class MinnowDatabase {
                 const expandedPlan = expandFtsColumns(plan, (tableName) => searchableFtsColumns(realTables.get(tableName)));
                 const resolution = subqueryResolutionSteps(expandedPlan);
                 for (const step of resolution.steps) {
-                    step.substitute(await this.#executeBlockCached(step.block, snapshot, visibility, memory, realTables, typedSchemas, options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows));
+                    throwIfAborted(options.signal);
+                    step.substitute(await this.#executeBlockCached(step.block, snapshot, visibility, memory, realTables, typedSchemas, options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows, options.signal));
+                    throwIfAborted(options.signal);
                 }
                 resolvedPlan = resolution.plan;
                 // Index-served BM25 statistics, computed against the same catalog snapshot the pruner
                 // reads, so a pruned scoring scan always carries exact corpus numbers.
                 ftsStats = await this.#ftsIndexStats(resolvedPlan, realTables, snapshot, visibility);
+                throwIfAborted(options.signal);
                 columnarTables = await this.#prepareBlockInputs(resolvedPlan, snapshot, visibility, memory, realTables, typedSchemas, undefined, 
                 // memoize: false means "compute this statement's results" — that covers the
                 // columnar forms of derived and windowed sources too, not just the result memo.
-                options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows);
+                options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows, options.signal);
+                throwIfAborted(options.signal);
                 outputNeedsExternalization = queryResultNeedsExternalization(resolvedPlan, typedSchemas);
                 outputColumnDomains = inferResultColumnDomains(resolvedPlan, typedSchemas);
             };
             if (options.version !== undefined) {
                 // Explicit time travel keeps the per-call lease and version-anchored reads.
                 const realTables = await this.#findRealBlockTables(plan);
+                throwIfAborted(options.signal);
                 await this.#withLeasedSnapshot(options.version, async (snapshot) => {
                     const visibility = await this.#blockSegmentVisibility(realTables);
+                    throwIfAborted(options.signal);
                     await prepareAtSnapshot(snapshot, realTables, visibility);
                 });
             }
             else {
                 await this.#withSharedCatalogSnapshot(collectRealTableNames(plan), prepareAtSnapshot, probe);
             }
+            throwIfAborted(options.signal);
             return createPreparedColumnarQuery(chooseJoinOrder(resolvedPlan, columnarTables), columnarTables, memory, {
                 ...(ftsStats === undefined ? {} : { ftsStats }),
                 outputNeedsExternalization,
@@ -2909,18 +2967,21 @@ export class MinnowDatabase {
      * materialize their referenced columns. Each block resolves its own inputs, so one real table
      * projected differently by two blocks never collides.
      */
-    async #prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows) {
+    async #prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
+        throwIfAborted(signal);
         const inputs = new Map(extraInputs ?? []);
         const sources = [block.base, ...block.joins];
         for (const source of sources) {
+            throwIfAborted(signal);
             if (inputs.has(source.table))
                 continue;
             if (source.recursive !== undefined) {
                 const { reference, base, step, all } = source.recursive;
-                const { result: baseResult, schema } = await this.#executeBlockWithSchemaCached(base, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows);
+                const { result: baseResult, schema } = await this.#executeBlockWithSchemaCached(base, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
                 typedSchemas.set(reference, schema);
                 const state = createRecursiveCteState(baseResult, all);
                 while (state.frontier.length > 0) {
+                    throwIfAborted(signal);
                     // Each iteration's inputs release with its own context, so only the accumulated rows
                     // and the final columnar table hold memory across the fixpoint loop.
                     const iterationMemory = memory.createChild();
@@ -2930,7 +2991,7 @@ export class MinnowDatabase {
                             columnDomains: schema.map(({ sqlDomain }) => sqlDomain ?? null),
                             rows: state.frontier,
                         }, schema);
-                        state.absorb(await this.#executeBlock(step, snapshot, visibility, iterationMemory, realTables, typedSchemas, new Map([[reference, frontierTable]]), cacheResults, allowSpill, forceSpill, spillPageRows));
+                        state.absorb(await this.#executeBlock(step, snapshot, visibility, iterationMemory, realTables, typedSchemas, new Map([[reference, frontierTable]]), cacheResults, allowSpill, forceSpill, spillPageRows, signal));
                     }
                     finally {
                         iterationMemory.close();
@@ -2948,7 +3009,8 @@ export class MinnowDatabase {
                 const results = [];
                 let schema;
                 for (const member of source.union.blocks) {
-                    const { result, schema: memberSchema } = await this.#executeBlockWithSchemaCached(member, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows);
+                    throwIfAborted(signal);
+                    const { result, schema: memberSchema } = await this.#executeBlockWithSchemaCached(member, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
                     if (schema === undefined)
                         schema = memberSchema;
                     else {
@@ -2977,6 +3039,7 @@ export class MinnowDatabase {
                 // key plus the window spec, so a warm repeat skips the window pass and the
                 // rows-to-columnar conversion entirely.
                 const innerKey = await this.#blockResultCacheKey(source.windowed.block, snapshot, visibility, realTables, cacheResults);
+                throwIfAborted(signal);
                 const columnarKey = innerKey === undefined
                     ? undefined
                     : `ctw|${JSON.stringify(source.windowed.windows)}|${innerKey}`;
@@ -2988,7 +3051,7 @@ export class MinnowDatabase {
                         continue;
                     }
                 }
-                const { result: inner, schema: innerSchema } = await this.#executeBlockWithSchemaCached(source.windowed.block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows);
+                const { result: inner, schema: innerSchema } = await this.#executeBlockWithSchemaCached(source.windowed.block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
                 const windowed = applyWindowFunctions(inner, source.windowed.windows, {
                     copyRows: cacheResults,
                 });
@@ -3015,6 +3078,7 @@ export class MinnowDatabase {
             if (derived === undefined)
                 continue;
             const derivedKey = await this.#blockResultCacheKey(derived, snapshot, visibility, realTables, cacheResults);
+            throwIfAborted(signal);
             const columnarKey = derivedKey === undefined ? undefined : `ctd|${derivedKey}`;
             if (columnarKey !== undefined) {
                 const hit = this.#cacheGet(columnarKey);
@@ -3024,7 +3088,7 @@ export class MinnowDatabase {
                     continue;
                 }
             }
-            const { result, schema } = await this.#executeBlockWithSchemaCached(derived, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows);
+            const { result, schema } = await this.#executeBlockWithSchemaCached(derived, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
             typedSchemas.set(source.table, schema);
             const derivedTable = derivedColumnarTable(source.table, result, schema);
             if (columnarKey !== undefined) {
@@ -3039,6 +3103,7 @@ export class MinnowDatabase {
         const columns = referencedColumns(block, nameSchemas);
         const onlyRealSource = sources.length === 1 && sources[0]?.derived === undefined ? block : undefined;
         for (const source of sources) {
+            throwIfAborted(signal);
             if (source.derived !== undefined || inputs.has(source.table))
                 continue;
             if (source.table === DUAL_TABLE) {
@@ -3050,6 +3115,7 @@ export class MinnowDatabase {
                 throw new UnknownTableError(source.table);
             const requestedColumns = columns.get(table.name) ?? [];
             inputs.set(table.name, await this.#materializeColumnarTableAtSnapshot(table, snapshot, requestedColumns.length === 0 ? [] : resolveReadColumns(table, requestedColumns), visibility, onlyRealSource));
+            throwIfAborted(signal);
         }
         return inputs;
     }
@@ -3066,6 +3132,7 @@ export class MinnowDatabase {
         return this.#queryWithReadReservation(sql, options);
     }
     async #queryUnreserved(sql, options) {
+        throwIfAborted(options.signal);
         const open = this.#openTransaction;
         if (open !== undefined) {
             // Read-your-writes: inside BEGIN … COMMIT a read sees the pre-scope snapshot plus what
@@ -3091,6 +3158,7 @@ export class MinnowDatabase {
         const result = !memoizable
             ? await this.#queryCompiled(plan, options)
             : await this.#memoizedQuery(plan, `res ${queryResultMemoKey(sql, options.params ?? [])}`, options, probe);
+        throwIfAborted(options.signal);
         return externalizeQueryResult(result);
     }
     /**
@@ -3155,7 +3223,8 @@ export class MinnowDatabase {
         };
     }
     async #queryBatches(sql, options, cursor) {
-        options = this.#effectiveQueryOptions(options);
+        options = this.#effectiveQueryOptions({ ...options, signal: cursor.signal });
+        cursor.signal.throwIfAborted();
         // A transaction's staged overlay has its own executor. Keep its read-your-writes semantics
         // and page the materialized result; native scan batching is for durable snapshots.
         if (this.#openTransaction === undefined) {
@@ -3196,16 +3265,22 @@ export class MinnowDatabase {
      * and on IndexedDB every probe is a read transaction, a floor under every small query.
      */
     async #memoizedQuery(plan, key, options, probe) {
+        throwIfAborted(options.signal);
         const before = await probe();
+        throwIfAborted(options.signal);
         const cached = this.#cacheGet(`${key}\u0001${String(before.catalogEpoch)}`);
-        if (cached !== undefined)
+        if (cached !== undefined) {
+            options.onStats?.({ peakMemoryBytes: 0 });
             return copyQueryResult(cached);
+        }
         const result = await this.#queryCompiled(plan, options, before);
+        throwIfAborted(options.signal);
         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
             // that epoch's answer. A moved epoch simply skips the cache — never mis-files.
             const after = await probe();
+            throwIfAborted(options.signal);
             if (after.catalogEpoch === before.catalogEpoch) {
                 this.#cachePut(`${key}\u0001${String(before.catalogEpoch)}`, copyQueryResult(result), bytes);
             }
@@ -3385,10 +3460,13 @@ export class MinnowDatabase {
      */
     async #queryCompiled(plan, options = {}, probe) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         // 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();
+        throwIfAborted(options.signal);
         plan = await this.#applyCatalogRewrites(plan, probe);
+        throwIfAborted(options.signal);
         const spillPageRows = options.spillPageRows === undefined
             ? undefined
             : positiveWholeNumber(options.spillPageRows, "Query spill page rows");
@@ -3409,6 +3487,7 @@ export class MinnowDatabase {
             }
         }
         const prepared = await this.#prepareCompiledPlan(plan, options, probe);
+        throwIfAborted(options.signal);
         // Read the peak before close(): closing releases the context and zeroes what it tracked.
         const report = (result) => {
             options.onStats?.({ peakMemoryBytes: prepared.memoryUsage.peakBytes });
@@ -3416,11 +3495,16 @@ export class MinnowDatabase {
         };
         try {
             const spill = options.spillToStorage ?? options.executionMemoryBudgetBytes !== undefined;
-            if (!spill)
-                return report(prepared.execute());
+            if (!spill) {
+                const result = prepared.execute();
+                throwIfAborted(options.signal);
+                return report(result);
+            }
             if (options.spillToStorage !== true) {
                 try {
-                    return report(prepared.execute());
+                    const result = prepared.execute();
+                    throwIfAborted(options.signal);
+                    return report(result);
                 }
                 catch (error) {
                     if (!(error instanceof QueryMemoryBudgetError))
@@ -3430,12 +3514,33 @@ export class MinnowDatabase {
             return report(await prepared.executeAsync({
                 ...(spillPageRows === undefined ? {} : { spillPageRows }),
                 spillStore: this.#leasedSpillStore(),
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
             }));
         }
         finally {
             prepared.close();
         }
     }
+    /**
+     * Streams a one-column snapshot projection into bounded pages. DELETE uses this before its
+     * first staged write: selection keeps all ordinary pruning/predicate semantics without
+     * retaining every QueryRow object until the key array is complete. Undefined means the shape
+     * or physical history needs the established row-shaped executor.
+     */
+    async #queryCompiledFirstColumn(plan, probe) {
+        const options = this.#effectiveQueryOptions({ memoize: false });
+        plan = await this.#applyCatalogRewrites(plan, probe);
+        const values = [];
+        const streamed = await this.#queryStreamed(plan, options, undefined, probe, {
+            batchRows: 2_048,
+            signal: new AbortController().signal,
+            consumeFirstColumn: async (batch) => {
+                values.push(...batch);
+            },
+            consume: async () => undefined,
+        });
+        return streamed === undefined ? undefined : values;
+    }
     /**
      * Backs the executor's spill pages with durable owner leases: each owner registers a lease
      * before its first page write and renews it while pages are read or written, so an abandoned
@@ -3823,15 +3928,18 @@ export class MinnowDatabase {
      * one, so a table that cannot be compacted today costs one attempt, not one per query.
      */
     #maybeScheduleAutoCompaction(table, segments) {
+        this.#maybeScheduleAutoCompactionFromHint(table, autoCompactionHint(null, segments));
+    }
+    #maybeScheduleAutoCompactionFromHint(table, hint) {
         if (this.#closed)
             return;
         if (!this.#autoCompact)
             return;
         if (this.#droppingTables.has(table.id))
             return;
-        if (!autoCompactionDue(segments))
+        if (!autoCompactionDueHint(hint))
             return;
-        if (segments.length < (this.#autoCompactionBackoff.get(table.id) ?? 0))
+        if (hint.visible < (this.#autoCompactionBackoff.get(table.id) ?? 0))
             return;
         if (this.#autoCompactionsInFlight.has(table.id)) {
             // A final burst can cross the threshold while the prior fold is still planning or
@@ -3845,14 +3953,14 @@ export class MinnowDatabase {
             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)));
+                this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, hint.visible * 2)));
             }
         })
             .catch(() => {
             // 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)));
+            this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, hint.visible * 2)));
         })
             .finally(() => {
             if (this.#autoCompactionsInFlight.get(table.id) === run) {
@@ -3872,6 +3980,10 @@ export class MinnowDatabase {
         // every write and let the commit return the identical CompactionBacklogError at the CAS.
         if (!this.#autoCompact)
             return;
+        const hintVersion = transaction?.snapshotVersion ?? (await this.store.getCurrentManifestVersion());
+        const hint = this.#autoCompactionHints.get(table.id);
+        if (hint?.version === hintVersion && hint.levelZero < MAX_LEVEL_ZERO_SEGMENTS)
+            return;
         let segments = await this.#currentVisibleSegments(table);
         let levelZero = 0;
         for (const segment of segments) {
@@ -3945,9 +4057,11 @@ export class MinnowDatabase {
             const version = await this.store.getCurrentManifestVersion();
             segments = await this.#visibleSegmentRecords(table, new Snapshot(this.store, version));
             if ((await this.store.getCurrentManifestVersion()) === version) {
+                this.#autoCompactionHints.set(table.id, autoCompactionHint(version, segments));
                 return segments;
             }
         }
+        this.#autoCompactionHints.delete(table.id);
         return segments;
     }
     /**
@@ -3958,6 +4072,7 @@ export class MinnowDatabase {
         if (this.#closed)
             return;
         const contribution = transaction?.committedCatalogContribution;
+        this.#advanceAutoCompactionHints(manifest, contribution?.segments);
         const initial = contribution?.initialCatalogProbe;
         const contributedTableIds = new Set(contribution?.segments.map((segment) => segment.tableId) ?? []);
         if (contribution !== undefined &&
@@ -4051,7 +4166,7 @@ export class MinnowDatabase {
         this.#armIdleCompactionCheck();
     }
     /** Counts one physical rewrite version once in this engine, including lost-ack recovery. */
-    #afterCompactionCommit(manifest) {
+    #afterCompactionCommit(manifest, tableId) {
         if (this.#accountedCompactionVersions.has(manifest.version))
             return;
         this.#accountedCompactionVersions.add(manifest.version);
@@ -4060,8 +4175,49 @@ export class MinnowDatabase {
             if (oldest !== undefined)
                 this.#accountedCompactionVersions.delete(oldest);
         }
+        // A fold replaces source segments with a different physical layout. Its manifest is
+        // logically unchanged and therefore carries no changed-table ID, so invalidate explicitly;
+        // #runAutoCompaction's stable post-fold probe seeds the replacement counters.
+        this.#autoCompactionHints.delete(tableId);
         this.#afterCommit(manifest);
     }
+    /** Advances exact local hints, or discards them when a commit's provenance is incomplete. */
+    #advanceAutoCompactionHints(manifest, contributedSegments) {
+        for (const [tableId, hint] of this.#autoCompactionHints) {
+            if (hint.version !== manifest.previousVersion) {
+                // Another database committed since this instance last proved the layout.
+                this.#autoCompactionHints.delete(tableId);
+                continue;
+            }
+            this.#autoCompactionHints.set(tableId, { ...hint, version: manifest.version });
+        }
+        const additionsByTable = new Map();
+        for (const segment of contributedSegments ?? []) {
+            const additions = additionsByTable.get(segment.tableId);
+            if (additions === undefined)
+                additionsByTable.set(segment.tableId, [segment]);
+            else
+                additions.push(segment);
+        }
+        for (const tableId of manifest.changedTableIds) {
+            const hint = this.#autoCompactionHints.get(tableId);
+            if (hint === undefined)
+                continue;
+            const additions = additionsByTable.get(tableId);
+            if (additions === undefined) {
+                // DDL and future write paths without an exact segment contribution fail closed.
+                this.#autoCompactionHints.delete(tableId);
+                continue;
+            }
+            const contribution = autoCompactionHint(manifest.version, additions);
+            this.#autoCompactionHints.set(tableId, {
+                version: manifest.version,
+                visible: hint.visible + contribution.visible,
+                levelZero: hint.levelZero + contribution.levelZero,
+                deltas: hint.deltas + contribution.deltas,
+            });
+        }
+    }
     /**
      * 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
@@ -4099,6 +4255,12 @@ export class MinnowDatabase {
             const table = await this.store.getTable(tableId);
             if (table === undefined)
                 return;
+            const version = await this.store.getCurrentManifestVersion();
+            const hint = this.#autoCompactionHints.get(tableId);
+            if (hint?.version === version) {
+                this.#maybeScheduleAutoCompactionFromHint(table, hint);
+                return;
+            }
             this.#maybeScheduleAutoCompaction(table, await this.#currentVisibleSegments(table));
         }
         catch {
@@ -4379,6 +4541,7 @@ export class MinnowDatabase {
         const statementNow = this.#now();
         const filled = await fillColumnDefaults(target, input, (sql) => this.#evaluateDefaultExpression(sql, statementNow), derivedRows.length);
         normalizeDomainBatch(target, filled.batch);
+        fillStoredGeneratedColumns(target, filled.batch, derivedRows.length, filled.generated);
         fillCompositePrimaryKey(target, filled.batch, derivedRows.length);
         validateBatch(target, filled.batch, filled.autoIncrement?.column.name);
         if (filled.autoIncrement !== undefined && filled.autoIncrement.missingIndexes.length > 0) {
@@ -4651,6 +4814,15 @@ export class MinnowDatabase {
                     ? this.#queryCompiled(plan, {}, probe)
                     : this.#sessionQueryPlan(transaction, await this.#applyCatalogRewrites(plan));
             }),
+            queryFirstColumn: (plan) => this.#withReadReservation(async () => {
+                // A staged overlay can add, replace, or remove keys without changing the pinned
+                // manifest. Keep that case on the read-your-writes row executor; before the first
+                // stage, the transaction's exact catalog probe makes the streamed snapshot safe.
+                const probe = transaction.initialCatalogProbe;
+                return transaction.stagedWorkCount === 0 && probe !== undefined
+                    ? this.#queryCompiledFirstColumn(plan, probe)
+                    : undefined;
+            }),
             executeStatement: (statement) => {
                 open();
                 return guarded(() => this.runStatement(statement, { writer }));
@@ -4719,21 +4891,26 @@ export class MinnowDatabase {
      */
     async #sessionQuery(transaction, sql, options = {}) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         const bound = bindPlanParameters(this.#compileCached(sql), options.params);
         // The same catalog rewrites a read outside a scope gets: a scope that could not see a view
         // would make the scope's reads a different language from everyone else's.
         const plan = await this.#applyCatalogRewrites(bound);
+        throwIfAborted(options.signal);
         return this.#sessionQueryPlan(transaction, plan, options);
     }
     /** #sessionQuery for an already-bound plan: trigger bodies resolve their reads through it. */
     async #sessionQueryPlan(transaction, plan, options = {}) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         const names = collectRealTableNames(plan);
         const tables = await Promise.all(names.map((name) => this.#findTable(name)));
+        throwIfAborted(options.signal);
         const realTables = new Map(tables.map((table) => [table.name, table]));
         const pendingIds = new Set(transaction.pendingSegmentIds);
         const pendingBlocks = new Set(transaction.pendingBlockIds);
         const ourRecord = await this.store.getTransaction(transaction.id);
+        throwIfAborted(options.signal);
         // Pinned to the scope's own snapshot, not the current manifest: the documented contract
         // is "the pre-scope snapshot plus everything this scope staged", and #assertKeysExist
         // already validates against transaction.snapshotVersion — reading the current version
@@ -4757,6 +4934,7 @@ export class MinnowDatabase {
                 getBlocks: async (blockIds) => {
                     const blocks = [];
                     for (let start = 0; start < blockIds.length; start += 64) {
+                        throwIfAborted(options.signal);
                         const window = blockIds.slice(start, start + 64);
                         const committedIds = [];
                         const committedIndexes = [];
@@ -4781,6 +4959,7 @@ export class MinnowDatabase {
                             this.#getBlocksWindowed(committedIds),
                             Promise.all(stagedIds.map((blockId) => transaction.getBlock(blockId))),
                         ]);
+                        throwIfAborted(options.signal);
                         const ordered = new Array(window.length);
                         committedIndexes.forEach((index, offset) => {
                             ordered[index] = committed[offset];
@@ -4799,10 +4978,12 @@ export class MinnowDatabase {
             const transactionRecords = new Map();
             const deferredSegments = transaction.deferredSegments;
             for (const table of tables) {
+                throwIfAborted(options.signal);
                 const segments = [
                     ...(await listTableSegmentsPaged(this.store, table.id)),
                     ...deferredSegments.filter((segment) => segment.tableId === table.id),
                 ];
+                throwIfAborted(options.signal);
                 // Staged segments sort after every committed one; commitOrdinal keeps their
                 // staging order (the journal's id list is sorted, so it cannot).
                 const doctored = segments.map((segment) => pendingIds.has(segment.id)
@@ -4812,6 +4993,7 @@ export class MinnowDatabase {
                 for (const record of await this.#transactionRecordsForSegments(doctored)) {
                     transactionRecords.set(record.id, record);
                 }
+                throwIfAborted(options.signal);
             }
             if (ourRecord !== undefined) {
                 transactionRecords.set(transaction.id, {
@@ -4831,6 +5013,7 @@ export class MinnowDatabase {
     /** Executes one plan at an explicit snapshot and visibility, covering every plan shape. */
     async #queryAtVisibility(plan, snapshot, visibility, realTables, cacheResults = true, options = {}) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         plan = expandFtsColumns(plan, (name) => searchableFtsColumns(realTables.get(name)));
         const typedSchemas = new Map([...realTables.values()].map((table) => [
             table.name,
@@ -4847,16 +5030,22 @@ export class MinnowDatabase {
         const spillPageRows = options.spillPageRows === undefined
             ? undefined
             : positiveWholeNumber(options.spillPageRows, "Query spill page rows");
+        const report = (result) => {
+            throwIfAborted(options.signal);
+            options.onStats?.({ peakMemoryBytes: memory.usage.peakBytes });
+            return result;
+        };
         try {
             const resolution = subqueryResolutionSteps(plan);
             for (const step of resolution.steps) {
-                step.substitute(await this.#executeBlock(step.block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows));
+                throwIfAborted(options.signal);
+                step.substitute(await this.#executeBlock(step.block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, options.signal));
             }
             const wrapper = transparentProjectionSource(resolution.plan);
             if (wrapper !== undefined) {
-                return projectResultColumns(await this.#executeBlock(wrapper.inner, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows), wrapper.aliases);
+                return report(projectResultColumns(await this.#executeBlock(wrapper.inner, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, options.signal), wrapper.aliases));
             }
-            return await this.#executeBlock(resolution.plan, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows);
+            return report(await this.#executeBlock(resolution.plan, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, options.signal));
         }
         finally {
             memory.close();
@@ -4941,6 +5130,7 @@ export class MinnowDatabase {
             throw new TypeError(`Table needs a unique key before rows can be updated: ${table.name}`);
         }
         input = normalizeDomainUpdate(table, input);
+        rejectGeneratedUpdateAssignments(table, input);
         const keys = validateUpdateBatch(table, keyColumn, input);
         // Read-your-writes membership: keys staged by this scope pass, keys the scope removed
         // fail, and everything else checks against the committed snapshot as usual.
@@ -4955,12 +5145,17 @@ export class MinnowDatabase {
             await this.#assertKeysExist(table, keyColumn, transaction.snapshotVersion, committedKeys);
         }
         const sessionChecks = table.checks ?? [];
-        const changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
+        let changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
             foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
         const preImages = await this.#triggerPreImages(table, keyColumn, input.keys.filter((key) => key !== null), "update", (preImageSql, params) => this.#sessionQuery(transaction, preImageSql, { params }), sessionChecks.length > 0 ||
             changedForeignKey ||
+            tableGeneratedExpressions(table).length > 0 ||
             secondaryIndexUpdateNeedsPreImages(table, input) ||
             readyUniqueSecondaryIndexes(table).some(({ columns }) => columns.some((column) => input.changes[column.name] !== undefined)));
+        input = applyStoredGeneratedUpdateChanges(table, input, preImages);
+        validateUpdateBatch(table, keyColumn, input);
+        changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
+            foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
         stageSecondaryUniqueMutationChanges(transaction, table, input, preImages);
         const secondaryDeltas = buildSecondaryUpdateDeltas(table, input, preImages);
         if (secondaryDeltas.length > 0) {
@@ -5042,7 +5237,19 @@ export class MinnowDatabase {
             },
         ]);
         await this.#stageTriggerDerivedInserts(transaction, table, "update", input.keys.length, sessionUpdateValueAt, "after", cascadeBudget);
-        return { tableName: table.name, segmentId, rowCount: input.keys.length };
+        return {
+            tableName: table.name,
+            segmentId,
+            rowCount: input.keys.length,
+            ...(tableGeneratedExpressions(table).length === 0
+                ? {}
+                : {
+                    generatedColumns: Object.fromEntries(tableGeneratedExpressions(table).map(({ column }) => [
+                        column.name,
+                        (input.changes[column.name] ?? []).map((value) => externalSqlDomainValue(value)),
+                    ])),
+                }),
+        };
     }
     async #sessionDelete(transaction, tableName, input, cascadeBudget = 1, referentialBudget = REFERENTIAL_CASCADES) {
         const table = await this.#findTable(tableName);
@@ -5379,6 +5586,9 @@ export class MinnowDatabase {
                         ...(columnDefinition.defaultSpec === undefined
                             ? {}
                             : { defaultValue: columnDefinition.defaultSpec }),
+                        ...(columnDefinition.generatedSpec === undefined
+                            ? {}
+                            : { generatedValue: columnDefinition.generatedSpec }),
                         ...(columnDefinition.enumValues === undefined
                             ? {}
                             : { enumValues: columnDefinition.enumValues }),
@@ -5516,6 +5726,28 @@ export class MinnowDatabase {
                     }
                 }
             }
+            // Adopting generation on an existing physical column is metadata-only only when every
+            // stored value already equals the declared expression. This supports migrations from an
+            // application-maintained column without silently blessing stale historical rows.
+            for (const step of steps) {
+                if (step.kind !== "alter-generated" || step.generatedValue === null)
+                    continue;
+                const target = record.columns.find(({ name }) => name === step.columnName);
+                if (target === undefined)
+                    continue;
+                const expression = compileGeneratedColumnExpression(record.name, target.name, step.generatedValue.sql, record.columns);
+                const rows = (await this.query(`SELECT * FROM ${quoteSqlIdentifier(record.name)}`, { memoize: false })).rows;
+                for (const [rowIndex, row] of rows.entries()) {
+                    const expected = normalizeGeneratedColumnValue(target, evaluateRowExpression(expression, record.name, generatedEvaluationRow(record, row)), rowIndex);
+                    const actual = normalizeGeneratedColumnValue(target, row[target.name] ?? null, rowIndex);
+                    const equal = expected instanceof Date && actual instanceof Date
+                        ? dateMilliseconds(expected) === dateMilliseconds(actual)
+                        : Object.is(expected, actual);
+                    if (!equal) {
+                        throw new TypeError(`Generated column cannot be adopted: ${record.name}.${target.name} differs from its expression at row ${String(rowIndex)}`);
+                    }
+                }
+            }
             // The remaining metadata-only steps share one catalog/manifest CAS. Physical drops ran
             // above because segment rewriting and payload retirement have a stronger atomic boundary.
             const columns = applyColumnSteps(record, steps, this.#createId);
@@ -6067,6 +6299,7 @@ export class MinnowDatabase {
         const statementNow = this.#now();
         const filledProposed = await fillColumnDefaults(table, proposedBatch, (sql) => this.#evaluateDefaultExpression(sql, statementNow), statement.rows.length);
         normalizeDomainBatch(table, filledProposed.batch);
+        fillStoredGeneratedColumns(table, filledProposed.batch, statement.rows.length, filledProposed.generated);
         fillCompositePrimaryKey(table, filledProposed.batch, statement.rows.length);
         const proposed = filledProposed.batch;
         // UPSERT only handles a uniqueness conflict. Other INSERT-domain failures are still errors,
@@ -6137,7 +6370,10 @@ export class MinnowDatabase {
             // and UUID defaults twice and could even change which row conflicts.
             const columns = visibleTableColumns(table).map(({ name }) => name);
             const deferredAutoIncrement = new Set(filledProposed.autoIncrement?.missingIndexes ?? []);
-            const rows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => name === filledProposed.autoIncrement?.column.name && deferredAutoIncrement.has(rowIndex)
+            const generatedColumns = new Set(table.columns.flatMap((column) => column.generatedValue === undefined ? [] : [column.name]));
+            const rows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => generatedColumns.has(name) ||
+                (name === filledProposed.autoIncrement?.column.name &&
+                    deferredAutoIncrement.has(rowIndex))
                 ? { default: true }
                 : (proposed.columns[name]?.[rowIndex] ?? null)));
             return this.runStatement({
@@ -6231,6 +6467,8 @@ export class MinnowDatabase {
             if (freshRows.length > 0) {
                 const columns = {};
                 for (const column of table.columns) {
+                    if (column.generatedValue !== undefined)
+                        continue;
                     columns[column.name] = freshRows.map((rowIndex) => proposed.columns[column.name]?.[rowIndex] ?? null);
                 }
                 await transaction.insertBatch(table.name, { columns });
@@ -6269,7 +6507,9 @@ export class MinnowDatabase {
             table: statement.table,
             rowCount: outcome.affectedRows.length,
             ...(version === null || version === undefined ? {} : { version }),
-            ...(outcome.returnedRows === undefined ? {} : { returnedRows: outcome.returnedRows }),
+            ...(outcome.returnedRows === undefined || returningColumns === undefined
+                ? {}
+                : returningExecuteFields(table, returningColumns, outcome.returnedRows)),
         };
     }
     /** ON CONFLICT DO NOTHING: drops insert rows whose unique key already exists at a snapshot. */
@@ -6292,10 +6532,13 @@ export class MinnowDatabase {
         const statementNow = this.#now();
         const filled = await fillColumnDefaults(table, proposed, (sql) => this.#evaluateDefaultExpression(sql, statementNow), statement.rows.length);
         normalizeDomainBatch(table, filled.batch);
+        fillStoredGeneratedColumns(table, filled.batch, statement.rows.length, filled.generated);
         fillCompositePrimaryKey(table, filled.batch, statement.rows.length);
         const columns = visibleTableColumns(table).map(({ name }) => name);
         const deferredAutoIncrement = new Set(filled.autoIncrement?.missingIndexes ?? []);
-        const materializedRows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => name === filled.autoIncrement?.column.name && deferredAutoIncrement.has(rowIndex)
+        const generatedColumns = new Set(table.columns.flatMap((column) => (column.generatedValue === undefined ? [] : [column.name])));
+        const materializedRows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => generatedColumns.has(name) ||
+            (name === filled.autoIncrement?.column.name && deferredAutoIncrement.has(rowIndex))
             ? { default: true }
             : (filled.batch.columns[name]?.[rowIndex] ?? null)));
         const keys = filled.batch.columns[keyColumn.name] ?? [];
@@ -6754,6 +6997,9 @@ export class MinnowDatabase {
                     if (record.columns.some(({ name }) => name === added.name)) {
                         throw new TypeError(`Column already exists: ${addColumnStatement.table}.${added.name}`);
                     }
+                    if (added.generatedValue !== undefined) {
+                        throw new TypeError("ALTER TABLE cannot add a generated column without rewriting existing rows");
+                    }
                     if (added.defaultValue !== undefined) {
                         validateColumnDefault({
                             name: added.name,
@@ -6912,11 +7158,19 @@ export class MinnowDatabase {
             return this.#mergeConflictingInsertRows(statement, options);
         }
         if (statement.kind === "insert" && statement.rows.length === 0) {
+            const table = await this.#findTable(statement.table);
+            const returningColumns = options.returning === undefined
+                ? undefined
+                : options.returning === "*"
+                    ? visibleTableColumns(table).map(({ name }) => name)
+                    : [...options.returning];
             return {
                 kind: "insert",
                 table: statement.table,
                 rowCount: 0,
-                ...(options.returning === undefined ? {} : { returnedRows: [] }),
+                ...(returningColumns === undefined
+                    ? {}
+                    : returningExecuteFields(table, returningColumns, [])),
             };
         }
         if (statement.kind === "insert") {
@@ -6978,7 +7232,7 @@ export class MinnowDatabase {
                 ...(returningColumns === undefined
                     ? {}
                     : {
-                        returnedRows: statement.rows.map((row, rowIndex) => Object.fromEntries(returningColumns.map((name) => {
+                        ...returningExecuteFields(table, returningColumns, statement.rows.map((row, rowIndex) => Object.fromEntries(returningColumns.map((name) => {
                             const column = table.columns.find((candidate) => candidate.name === name);
                             const position = statement.columns.indexOf(name);
                             const inserted = position < 0 ? undefined : row[position];
@@ -6988,7 +7242,7 @@ export class MinnowDatabase {
                                     ? null
                                     : boundInsertValue(inserted));
                             return [name, executionSqlValueFromInput(column, value)];
-                        }))),
+                        })))),
                     }),
             };
         }
@@ -7050,6 +7304,32 @@ export class MinnowDatabase {
             having: [],
             orderBy: [],
         };
+        if (statement.kind === "delete" && returningColumns === undefined) {
+            const internalWriter = options.writer;
+            if (internalWriter.queryFirstColumn !== undefined) {
+                const selectedKeys = await internalWriter.queryFirstColumn(plan);
+                if (selectedKeys !== undefined) {
+                    const keys = selectedKeys;
+                    if (keyColumn.type === "string" && keyColumn.sqlDomain === undefined) {
+                        for (let index = 0; index < keys.length; index += 1) {
+                            keys[index] = storedSqlValueFromExecution(keyColumn, keys[index] ?? null);
+                        }
+                    }
+                    if (keys.some((key) => key === null)) {
+                        throw new TypeError(`Unique key values must not be null: ${keyColumn.name}`);
+                    }
+                    if (keys.length === 0) {
+                        return { kind: "delete", table: table.name, rowCount: 0 };
+                    }
+                    const deleted = await internalWriter.deleteBatch(table.name, { keys });
+                    return {
+                        kind: "delete",
+                        table: table.name,
+                        rowCount: deleted.rowCount,
+                    };
+                }
+            }
+        }
         let rows;
         if (options.writer !== undefined) {
             // Inside a scope the rows to touch are the ones the scope can see, which includes what it
@@ -7077,7 +7357,9 @@ export class MinnowDatabase {
                     kind: "delete",
                     table: table.name,
                     rowCount: 0,
-                    ...(returnedRows === undefined ? {} : { returnedRows }),
+                    ...(returnedRows === undefined || returningColumns === undefined
+                        ? {}
+                        : returningExecuteFields(table, returningColumns, returnedRows)),
                 };
             }
             const deleted = options.writer === undefined
@@ -7090,7 +7372,9 @@ export class MinnowDatabase {
                 ...(deleted.version === undefined || deleted.version === null
                     ? {}
                     : { version: deleted.version }),
-                ...(returnedRows === undefined ? {} : { returnedRows }),
+                ...(returnedRows === undefined || returningColumns === undefined
+                    ? {}
+                    : returningExecuteFields(table, returningColumns, returnedRows)),
             };
         }
         if (keys.length === 0) {
@@ -7098,7 +7382,9 @@ export class MinnowDatabase {
                 kind: "update",
                 table: table.name,
                 rowCount: 0,
-                ...(returningColumns === undefined ? {} : { returnedRows: [] }),
+                ...(returningColumns === undefined
+                    ? {}
+                    : returningExecuteFields(table, returningColumns, [])),
             };
         }
         const changes = {};
@@ -7131,7 +7417,9 @@ export class MinnowDatabase {
                 name,
                 returnedChanges !== undefined && name in returnedChanges
                     ? (returnedChanges[name]?.[index] ?? null)
-                    : (row[name] ?? null),
+                    : updated.generatedColumns?.[name] !== undefined
+                        ? (updated.generatedColumns[name][index] ?? null)
+                        : (row[name] ?? null),
             ])));
         return {
             kind: "update",
@@ -7140,7 +7428,9 @@ export class MinnowDatabase {
             ...(updated.version === undefined || updated.version === null
                 ? {}
                 : { version: updated.version }),
-            ...(returnedRows === undefined ? {} : { returnedRows }),
+            ...(returnedRows === undefined || returningColumns === undefined
+                ? {}
+                : returningExecuteFields(table, returningColumns, returnedRows)),
         };
     }
     /**
@@ -7175,6 +7465,7 @@ export class MinnowDatabase {
      */
     async #queryStreamed(plan, options, spillPageRows, probe, cursor) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         const tableNames = [plan.base.table, ...plan.joins.map((join) => join.table)];
         const uniqueTableNames = [...new Set(tableNames)];
         if (options.version === undefined) {
@@ -7204,6 +7495,7 @@ export class MinnowDatabase {
         });
     }
     async #queryStreamedAtSnapshot(plan, options, spillPageRows, snapshot, tables, visibility, cursor) {
+        throwIfAborted(options.signal);
         // Copy-on-write: expansion clones only full-text plans, leaving the compile cache's copy
         // untouched.
         plan = expandFtsColumns(plan, (tableName) => searchableFtsColumns(tables.find((table) => table.name === tableName)));
@@ -7224,7 +7516,9 @@ export class MinnowDatabase {
         const visibleByTable = new Map();
         const rowCounts = new Map();
         for (const table of tables) {
+            throwIfAborted(options.signal);
             const segments = await this.#visibleSegmentRecords(table, snapshot, visibility);
+            throwIfAborted(options.signal);
             visibleByTable.set(table.name, segments);
             if (segments.every((segment) => {
                 const kind = segment.kind;
@@ -7258,6 +7552,7 @@ export class MinnowDatabase {
                 record.name,
                 record.id === freshBaseTable.id ? freshBaseTable : record,
             ])), snapshot, visibility);
+            throwIfAborted(options.signal);
             if (planContainsFts(plan, "bm25") && ftsStats === undefined)
                 return undefined;
             // The streamed scan honors the same index pruning as the materialized path; a budgeted
@@ -7266,11 +7561,14 @@ export class MinnowDatabase {
                 (await this.#visibleSegmentRecords(freshBaseTable, snapshot, visibility));
             this.#maybeScheduleAutoCompaction(freshBaseTable, visibleBaseSegments);
             const ftsSegments = await this.#ftsPrunedSegments(freshBaseTable, visibleBaseSegments, plan, snapshot);
+            throwIfAborted(options.signal);
             const indexed = await this.#secondaryIndexPrunedSegments(freshBaseTable, ftsSegments, plan, snapshot);
+            throwIfAborted(options.signal);
             const baseSegments = indexed.segments;
             // Zone-map elimination composes after index pruning: whole row groups whose statistics
             // reject the plan's predicates never stream at all.
             const zonePruned = await this.#zonePrunedStreamSegments(plan, freshBaseTable, projectedBaseColumns, baseSegments, snapshot);
+            throwIfAborted(options.signal);
             const baseView = this.#streamedViewFactory(baseTable, projectedBaseColumns, zonePruned?.segments ?? baseSegments, snapshot, zonePruned?.storedBlocks, zonePruned !== undefined || indexed.pruned);
             if (baseView === undefined)
                 return undefined;
@@ -7292,22 +7590,26 @@ export class MinnowDatabase {
                         const budget = options.executionMemoryBudgetBytes;
                         const estimate = estimatedColumnarBytes(buildSegments, projectedBuildColumns);
                         if (buildView !== undefined && estimate > budget / 4) {
-                            return this.#runPartitionedJoin(plan, budget, estimate, baseView, buildView, buildTable.name, partitionedShape.buildKeyName);
+                            return this.#runPartitionedJoin(plan, budget, estimate, baseView, buildView, buildTable.name, partitionedShape.buildKeyName, options.signal);
                         }
                     }
                 }
             }
             const runStreamedExecution = async (attempt) => {
+                throwIfAborted(options.signal);
                 const memory = new QueryMemoryContext(options.executionMemoryBudgetBytes);
                 let prepared;
                 try {
                     const streamed = await baseView.create(memory);
+                    throwIfAborted(options.signal);
                     const inputTables = new Map([[baseTable.name, streamed.table]]);
                     for (const table of tables) {
+                        throwIfAborted(options.signal);
                         if (table.name === baseTable.name)
                             continue;
                         const requestedColumns = columns.get(table.name) ?? [];
                         inputTables.set(table.name, await this.#materializeColumnarTableAtSnapshot(table, snapshot, requestedColumns.length === 0 ? [] : resolveReadColumns(table, requestedColumns), visibility));
+                        throwIfAborted(options.signal);
                     }
                     prepared = createPreparedColumnarQuery(plan, inputTables, memory, {
                         ...(ftsStats === undefined ? {} : { ftsStats }),
@@ -7320,6 +7622,14 @@ export class MinnowDatabase {
                             batchRows: cursor.batchRows,
                             signal: cursor.signal,
                             loadScanWindow: streamed.load,
+                            ...(cursor.consumeFirstColumn === undefined
+                                ? {}
+                                : {
+                                    consumeFirstColumn: async (values) => {
+                                        emission.happened = true;
+                                        await cursor.consumeFirstColumn?.(values);
+                                    },
+                                }),
                         }, async (batch) => {
                             emission.happened = true;
                             await cursor.consume(externalizeQueryResult(batch));
@@ -7342,6 +7652,7 @@ export class MinnowDatabase {
                         try {
                             const streamedResult = await prepared.executeAsync({
                                 loadScanWindow: streamed.load,
+                                ...(options.signal === undefined ? {} : { signal: options.signal }),
                             });
                             options.onStats?.({ peakMemoryBytes: memory.usage.peakBytes });
                             return streamedResult;
@@ -7356,6 +7667,7 @@ export class MinnowDatabase {
                         ...(spillPageRows === undefined ? {} : { spillPageRows }),
                         spillStore: this.#leasedSpillStore(),
                         loadScanWindow: streamed.load,
+                        ...(options.signal === undefined ? {} : { signal: options.signal }),
                     });
                     options.onStats?.({ peakMemoryBytes: memory.usage.peakBytes });
                     return spilledResult;
@@ -7605,7 +7917,8 @@ export class MinnowDatabase {
      * like any unordered query. The rescans trade time for bounded memory; the decoded-block
      * cache keeps repeat decodes cheap.
      */
-    async #runPartitionedJoin(plan, budgetBytes, estimatedBuildBytes, baseView, buildView, buildTableName, buildKeyName) {
+    async #runPartitionedJoin(plan, budgetBytes, estimatedBuildBytes, baseView, buildView, buildTableName, buildKeyName, signal) {
+        throwIfAborted(signal);
         // One partition should fit in an eighth of the budget: the resident partition briefly
         // exists twice (boxed rows, then their vectors) and shares the budget with both streamed
         // windows and the accumulating result.
@@ -7618,6 +7931,7 @@ export class MinnowDatabase {
         try {
             const combined = [];
             for (let partition = 0; partition < partitions; partition += 1) {
+                throwIfAborted(signal);
                 if (combined.length >= wantedRows)
                     break;
                 const passMemory = root.createChild();
@@ -7628,6 +7942,7 @@ export class MinnowDatabase {
                     const collectMemory = passMemory.createChild();
                     const buildScanMemory = collectMemory.createChild();
                     const build = await buildView.create(buildScanMemory);
+                    throwIfAborted(signal);
                     let buildRows = [];
                     const buildColumns = [...build.table.columns.entries()];
                     // Small steps keep the collection windows a minor budget term next to the resident
@@ -7635,8 +7950,10 @@ export class MinnowDatabase {
                     // consumed length clamps to the returned resident end.
                     const step = 1_024;
                     for (let start = 0; start < build.table.rowCount;) {
+                        throwIfAborted(signal);
                         let length = Math.min(step, build.table.rowCount - start);
                         const residentEnd = await build.load(start, length);
+                        throwIfAborted(signal);
                         if (typeof residentEnd === "number" && residentEnd > start) {
                             length = Math.min(length, residentEnd - start);
                         }
@@ -7667,13 +7984,17 @@ export class MinnowDatabase {
                     const buildInput = columnarTableFromRows(buildTableName, buildRows, undefined, false);
                     buildRows = [];
                     const streamedBase = await baseView.create(passMemory);
+                    throwIfAborted(signal);
                     const inputTables = new Map([
                         [buildTableName, buildInput],
                         [streamedBase.table.name, streamedBase.table],
                     ]);
                     prepared = createPreparedColumnarQuery(strippedPlan, inputTables, passMemory);
                     collectMemory.close();
-                    const result = await prepared.executeAsync({ loadScanWindow: streamedBase.load });
+                    const result = await prepared.executeAsync({
+                        loadScanWindow: streamedBase.load,
+                        ...(signal === undefined ? {} : { signal }),
+                    });
                     for (const row of result.rows) {
                         if (combined.length >= wantedRows)
                             break;
@@ -8237,17 +8558,24 @@ export class MinnowDatabase {
         };
     }
     /** Prepares one block's inputs and executes it, returning the caller-owned result. */
-    async #executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows) {
+    async #executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
+        throwIfAborted(signal);
         const ftsStats = await this.#ftsIndexStats(block, realTables, snapshot, visibility);
-        const inputs = await this.#prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults, allowSpill, forceSpill, spillPageRows);
+        throwIfAborted(signal);
+        const inputs = await this.#prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
+        throwIfAborted(signal);
         const prepared = createPreparedColumnarQuery(block, inputs, memory.createChild(), ftsStats === undefined ? {} : { ftsStats });
         try {
             if (!allowSpill || memory.usage.budgetBytes === Number.MAX_SAFE_INTEGER) {
-                return prepared.execute();
+                const result = prepared.execute();
+                throwIfAborted(signal);
+                return result;
             }
             if (!forceSpill) {
                 try {
-                    return prepared.execute();
+                    const result = prepared.execute();
+                    throwIfAborted(signal);
+                    return result;
                 }
                 catch (error) {
                     if (!(error instanceof QueryMemoryBudgetError))
@@ -8257,6 +8585,7 @@ export class MinnowDatabase {
             return await prepared.executeAsync({
                 spillStore: this.#leasedSpillStore(),
                 ...(spillPageRows === undefined ? {} : { spillPageRows }),
+                ...(signal === undefined ? {} : { signal }),
             });
         }
         finally {
@@ -8270,14 +8599,17 @@ export class MinnowDatabase {
      * real tables it references, so an identical block over identical table states reuses
      * the previous result instead of re-reading and re-executing.
      */
-    async #executeBlockCached(block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows) {
+    async #executeBlockCached(block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
+        throwIfAborted(signal);
         const key = await this.#blockResultCacheKey(block, snapshot, visibility, realTables, cacheResults);
+        throwIfAborted(signal);
         if (key !== undefined) {
             const cached = this.#cacheGet(key);
             if (cached !== undefined)
                 return cached;
         }
-        const result = await this.#executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows);
+        const result = await this.#executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
+        throwIfAborted(signal);
         if (key !== undefined)
             this.#cachePut(key, result, queryResultRetainedBytes(result));
         return result;
@@ -8288,15 +8620,18 @@ export class MinnowDatabase {
      * synthetic sources in typedSchemas, and a later cache hit skips that registration, so
      * re-inferring the schema at hit time would find those names missing.
      */
-    async #executeBlockWithSchemaCached(block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows) {
+    async #executeBlockWithSchemaCached(block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
+        throwIfAborted(signal);
         const key = await this.#blockResultCacheKey(block, snapshot, visibility, realTables, cacheResults);
+        throwIfAborted(signal);
         const schemaKey = key === undefined ? undefined : `s${key}`;
         if (schemaKey !== undefined) {
             const cached = this.#cacheGet(schemaKey);
             if (cached !== undefined)
                 return cached;
         }
-        const result = await this.#executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows);
+        const result = await this.#executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
+        throwIfAborted(signal);
         const schema = inferBlockSchema(block, typedSchemas);
         const entry = { result, schema };
         if (schemaKey !== undefined) {
@@ -10669,7 +11004,7 @@ export class MinnowDatabase {
             if (recoveredManifest === undefined) {
                 throw new Error(`Compaction manifest is missing: ${String(linkedTransaction.committedVersion)}`);
             }
-            this.#afterCompactionCommit(recoveredManifest);
+            this.#afterCompactionCommit(recoveredManifest, table.id);
             return this.#publishedCompactionProgress(table, job);
         }
         const rewritePlan = job.rewritePlan;
@@ -10855,7 +11190,7 @@ export class MinnowDatabase {
                 let publicationConflict;
                 try {
                     manifest = await transaction.commit();
-                    this.#afterCompactionCommit(manifest);
+                    this.#afterCompactionCommit(manifest, table.id);
                     break;
                 }
                 catch (error) {
@@ -14096,13 +14431,27 @@ function assertTriggerBodyTargetSchema(compiled, target) {
                 if (column !== undefined &&
                     isDefaultInsertValue(value) &&
                     !column.nullable &&
-                    column.defaultValue === undefined) {
+                    column.defaultValue === undefined &&
+                    column.generatedValue === undefined) {
                     throw new TypeError(`Trigger body INSERT uses DEFAULT for a non-nullable column without a default: ${column.name}`);
                 }
             }
         }
+        for (const [index, column] of insertColumns.entries()) {
+            if (column.generatedValue === undefined)
+                continue;
+            for (const row of compiled.rows) {
+                const value = row[index];
+                if (value === undefined || !isDefaultInsertValue(value)) {
+                    throw new TypeError(`Trigger body INSERT assigns generated column: ${column.name}`);
+                }
+            }
+        }
         for (const column of columns) {
-            if (!provided.has(column.name) && !column.nullable && column.defaultValue === undefined) {
+            if (!provided.has(column.name) &&
+                !column.nullable &&
+                column.defaultValue === undefined &&
+                column.generatedValue === undefined) {
                 throw new TypeError(`Trigger body INSERT omits a non-nullable column without a default: ${column.name}`);
             }
         }
@@ -14124,6 +14473,9 @@ function assertTriggerBodyTargetSchema(compiled, target) {
             if (assignedColumn === undefined) {
                 throw new TypeError(`Trigger body UPDATE assignment column does not exist: ${assignment.column}`);
             }
+            if (assignedColumn.generatedValue !== undefined) {
+                throw new TypeError(`Trigger body UPDATE assigns generated column: ${assignment.column}`);
+            }
             if (assignedColumn.id === target.uniqueKeyColumnId ||
                 (target.primaryKeyColumnIds ?? []).includes(assignedColumn.id)) {
                 throw new TypeError(`Trigger body UPDATE cannot update a key column: ${assignment.column}`);
@@ -14273,6 +14625,7 @@ function visibleSegmentManifestVersion(value, label) {
  */
 const compiledChecks = new Map();
 const COMPILED_CHECK_CACHE_LIMIT = 64;
+const compiledGeneratedColumns = new Map();
 function tableChecks(table) {
     const key = `${table.id}/${String(table.revision)}`;
     const cached = compiledChecks.get(key);
@@ -14295,6 +14648,84 @@ function tableChecks(table) {
     compiledChecks.set(key, compiled);
     return compiled;
 }
+function tableGeneratedExpressions(table) {
+    const key = `${table.id}/${String(table.revision)}`;
+    const cached = compiledGeneratedColumns.get(key);
+    if (cached !== undefined)
+        return cached;
+    const compiled = table.columns.flatMap((column) => column.generatedValue === undefined
+        ? []
+        : [
+            {
+                column,
+                expression: compileGeneratedColumnExpression(table.name, column.name, column.generatedValue.sql, table.columns),
+            },
+        ]);
+    if (compiledGeneratedColumns.size >= COMPILED_CHECK_CACHE_LIMIT) {
+        const oldest = compiledGeneratedColumns.keys().next().value;
+        if (oldest !== undefined)
+            compiledGeneratedColumns.delete(oldest);
+    }
+    compiledGeneratedColumns.set(key, compiled);
+    return compiled;
+}
+function normalizeGeneratedColumnValue(column, value, rowIndex) {
+    const stored = column.sqlDomain === undefined
+        ? storedSqlValueFromExecution(column, value)
+        : normalizeSqlDomainValue(column.sqlDomain, value);
+    validateValue(column, stored, rowIndex);
+    return stored;
+}
+/** Computes every stored generated column after defaults/domains have produced the base row. */
+function fillStoredGeneratedColumns(table, batch, rowCount, generated) {
+    for (const { column, expression } of tableGeneratedExpressions(table)) {
+        const values = new Array(rowCount);
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+            const row = batchRowAt(table, batch, rowIndex);
+            const value = evaluateRowExpression(expression, table.name, row);
+            values[rowIndex] = normalizeGeneratedColumnValue(column, value, rowIndex);
+        }
+        batch.columns[column.name] = values;
+        generated?.set(column.name, values.map((value) => externalSqlDomainValue(value)));
+    }
+}
+function rejectGeneratedUpdateAssignments(table, input) {
+    for (const column of table.columns) {
+        if (column.generatedValue !== undefined && input.changes[column.name] !== undefined) {
+            throw new TypeError(`Generated column cannot be assigned: ${column.name}`);
+        }
+    }
+}
+function generatedEvaluationRow(table, source) {
+    const row = {};
+    for (const column of table.columns) {
+        const value = source[column.name] ?? null;
+        row[column.name] =
+            column.sqlDomain === undefined
+                ? executionSqlValueFromStorage(column, value)
+                : normalizeSqlDomainValue(column.sqlDomain, value);
+    }
+    return row;
+}
+function applyStoredGeneratedUpdateChanges(table, input, preImages) {
+    const generated = tableGeneratedExpressions(table);
+    if (generated.length === 0)
+        return input;
+    const changes = { ...input.changes };
+    for (const { column, expression } of generated) {
+        changes[column.name] = input.keys.map((_, rowIndex) => {
+            const old = preImages[rowIndex];
+            if (old === undefined)
+                throw new Error(`Generated-column pre-image is missing: ${table.name}`);
+            const row = generatedEvaluationRow(table, old);
+            for (const [name, values] of Object.entries(input.changes)) {
+                row[name] = values[rowIndex] ?? null;
+            }
+            return normalizeGeneratedColumnValue(column, evaluateRowExpression(expression, table.name, row), rowIndex);
+        });
+    }
+    return { keys: input.keys, changes };
+}
 /**
  * Applies a table's CHECK constraints to one row (E141-06). A constraint fails only when it
  * evaluates to false: SQL's three-valued logic lets an unknown pass, which is why a NULL column
@@ -15414,7 +15845,7 @@ function tryKeyToken(type, value) {
  * (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) {
+function autoCompactionHint(version, segments) {
     let levelZero = 0;
     let deltas = 0;
     for (const segment of segments) {
@@ -15424,7 +15855,18 @@ function autoCompactionDue(segments) {
         if (kind !== "insert" && kind !== "base")
             deltas += 1;
     }
-    return levelZero >= AUTO_COMPACT_SCAN_SEGMENTS || deltas >= AUTO_COMPACT_DELTA_SEGMENTS;
+    return {
+        version,
+        visible: segments.length,
+        levelZero,
+        deltas,
+    };
+}
+function autoCompactionDueHint(hint) {
+    return hint.levelZero >= AUTO_COMPACT_SCAN_SEGMENTS || hint.deltas >= AUTO_COMPACT_DELTA_SEGMENTS;
+}
+function autoCompactionDue(segments) {
+    return autoCompactionDueHint(autoCompactionHint(null, segments));
 }
 /** A macrotask boundary, so background work lets queued queries and writes run between steps. */
 function yieldToEventLoop() {