@earendil-works/chord 1.4.0 → 1.5.1

package/dist/store/table-evolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-evolve.js","sourceRoot":"","sources":["../../src/store/table-evolve.ts"],"names":[],"mappings":"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","sourcesContent":["// `evolveTable(previous, (t) => t…)` (slice 6a §9; decision \"Second spec review: the majority\"): the next version of a\n// table from the edits of one migration. The editor's types order the edits (`rename`, `add` and `json` before the\n// data step, `drop`, `index` and `dropIndex` after it) and track the columns and key through the chain; at runtime one\n// editor records the edits, checks each as it is made, and materializes the new version at the end.\n\nimport { opt } from \"../contracts/index.ts\";\nimport { editWith, type Increment } from \"../contracts/internal.ts\";\nimport { isOptional, type Optional } from \"../contracts/schema.ts\";\nimport {\n\ttype ColumnSchema,\n\ttype Columns,\n\ttype ColumnTypeOf,\n\tcheckColumnName,\n\tcolumnRecord,\n\tdescribeColumns,\n\ttype OrderColumn,\n\ttype RowOf,\n\ttype ValueOf,\n} from \"./columns.ts\";\nimport { type Condition, compileSet, compileWhere, type SetOf } from \"./expression.ts\";\nimport type { ColumnRefs } from \"./query.ts\";\nimport { INDEX_NAME, orderColumns, TableDefinition, type TableOptions } from \"./table.ts\";\nimport type { DataStep, TableEdit } from \"./table-history.ts\";\n\n/** The edits after the data step: `drop`, `index` and `dropIndex`; `C` and `K` are the columns and key so far. */\nexport interface TableTailEditor<C extends Columns, K extends readonly string[]> {\n\t/** Drops a non-key column; its indexes are dropped first, in the same commit. */\n\tdrop<N extends Exclude<keyof C & string, K[number]>>(name: N): TableTailEditor<Without<C, N>, K>;\n\t/** Adds an index (`[a-z0-9_]+`) over non-`opt` `str` or `int` columns; it ends with the key. */\n\tindex(name: string, columns: readonly OrderColumn<C>[]): TableTailEditor<C, K>;\n\t/** Drops an index. */\n\tdropIndex(name: string): TableTailEditor<C, K>;\n\t/** Type only: the columns and key so far. */\n\treadonly \"~columns\"?: C;\n\treadonly \"~key\"?: K;\n}\n\n/** The editor `evolveTable`'s edit gets: every edit; the column edits only before the data step. */\nexport interface TableEditor<C extends Columns, K extends readonly string[]> extends TableTailEditor<C, K> {\n\t/** Renames a column; the key, the indexes and a `json(...)` column's version column follow. */\n\trename<F extends keyof C & string, T extends string>(\n\t\tfrom: F,\n\t\tto: T,\n\t): TableEditor<Renamed<C, F, T>, RenamedKey<K, F, T>>;\n\t/** Adds a column: `opt(...)`, or a scalar one with a `default` (existing rows get it). */\n\tadd<N extends string, S extends AddedColumn>(name: N, column: S): TableEditor<With<C, N, S>, K>;\n\t/** A `json(...)` column's new version (its nullability kept): no DDL, no data step, cells migrate on access. */\n\tjson<N extends JsonNames<C>, S extends ColumnSchema>(name: N, column: S): TableEditor<WithJson<C, N, S>, K>;\n\t/**\n\t * The data step: `patch` gets each row as the columns stand here and returns new values of non-key columns (`{}`\n\t * stamps the row only); synchronous and pure, run in chunks of 100 in key order.\n\t */\n\trows(patch: (row: RowOf<C>) => PatchOf<C, K>): TableTailEditor<C, K>;\n\t/** The data step as one `updateWhere` over the rows not migrated yet. */\n\tupdate(step: {\n\t\treadonly where?: (row: ColumnRefs<C>) => Condition;\n\t\treadonly set: SetOf<C, K> | ((row: ColumnRefs<C>) => SetOf<C, K>);\n\t}): TableTailEditor<C, K>;\n}\n\n/** A column `add` takes: `opt(...)` or one with a `default`. */\nexport type AddedColumn = ColumnSchema & (Optional | { readonly default: unknown });\n\n/** A `rows` patch: new values of non-key columns; `undefined` clears an `opt(...)` one. */\nexport type PatchOf<C extends Columns, K extends readonly string[]> = {\n\treadonly [P in Exclude<keyof C & string, K[number]>]?: ValueOf<C[P]>;\n};\n\ntype Renamed<C extends Columns, F extends keyof C, T extends string> = {\n\treadonly [P in keyof C as P extends F ? T : P]: C[P];\n};\n\ntype RenamedKey<K extends readonly string[], F, T extends string> = {\n\treadonly [I in keyof K]: K[I] extends F ? T : K[I];\n};\n\ntype With<C extends Columns, N extends string, S extends ColumnSchema> = {\n\treadonly [P in keyof C | N]: P extends N ? S : C[P & keyof C];\n};\n\ntype Without<C extends Columns, N extends keyof C> = { readonly [P in Exclude<keyof C, N>]: C[P] };\n\ntype JsonNames<C extends Columns> = { [P in keyof C]: ColumnTypeOf<C[P]> extends \"json\" ? P : never }[keyof C] & string;\n\ntype WithJson<C extends Columns, N extends keyof C & string, S extends ColumnSchema> = With<\n\tC,\n\tN,\n\tC[N] extends Optional ? Optional<Exclude<S, Optional>> : S\n>;\n\n/** `V + 1` for a literal version (contracts' `Increment<N>`); `number` stays `number`. */\ntype Next<V extends number> = number extends V\n\t? number\n\t: `${Increment<`${V}`>}` extends `${infer N extends number}`\n\t\t? N\n\t\t: number;\n\n/**\n * Appends the next version (`previous.version + 1`) with the edits `edit` makes; `edit` must return the editor it was\n * given. Every version is materialized and fingerprinted here; the object serves the newest, and its activation\n * migrates a store at an older version through each one.\n */\nexport function evolveTable<\n\tC extends Columns,\n\tK extends readonly string[],\n\tV extends number,\n\tE extends { readonly \"~columns\"?: Columns; readonly \"~key\"?: readonly string[] },\n>(\n\tprevious: TableDefinition<C, K, V>,\n\tedit: (t: TableEditor<C, K>) => E,\n): TableDefinition<NonNullable<E[\"~columns\"]>, NonNullable<E[\"~key\"]>, Next<V>> {\n\t// The runtime editor works on untyped definitions; the types live in the editor interfaces.\n\tconst editor = new Editor(previous as unknown as TableDefinition);\n\t// The editor interfaces track the edits in the types; at runtime every edit returns the same editor.\n\teditWith(editor as unknown as TableEditor<C, K>, edit, `${previous.name}: evolveTable`);\n\treturn editor.finish() as unknown as TableDefinition<NonNullable<E[\"~columns\"]>, NonNullable<E[\"~key\"]>, Next<V>>;\n}\n\n/**\n * The editor at runtime: the columns, key and indexes as the edits leave them, the edits before and after the data\n * step, and the step. Each edit is checked as it is made (declaration policy: JavaScript callers reach the checks).\n */\nclass Editor {\n\treadonly #previous: TableDefinition;\n\treadonly #what: string;\n\t#schemas: { [name: string]: ColumnSchema };\n\t#key: string[];\n\treadonly #indexes: Map<string, readonly string[]>;\n\t/** `before` until the data step or the first `drop`, `index` or `dropIndex`. */\n\t#phase: \"before\" | \"after\" = \"before\";\n\treadonly #before: TableEdit[] = [];\n\t#step: DataStep | undefined;\n\treadonly #after: TableEdit[] = [];\n\n\tconstructor(previous: TableDefinition) {\n\t\tthis.#previous = previous;\n\t\tthis.#what = `${previous.name} version ${previous.version + 1}`;\n\t\tthis.#schemas = { ...previous.schemas };\n\t\tthis.#key = [...previous.key];\n\t\tthis.#indexes = new Map(previous.indexes);\n\t}\n\n\trename(from: string, to: string): this {\n\t\tthis.#assertBefore(\"rename\");\n\t\tthis.#assertColumn(from, \"rename\");\n\t\t// Checked here, not by the final definition: a later edit may rename it again, but this one runs as DDL.\n\t\tcheckColumnName(to, `${this.#what}: rename`);\n\t\tthis.#assertNewName(to, \"rename\", from);\n\t\tconst rename = (column: string): string => (column === from ? to : column);\n\t\tthis.#schemas = Object.fromEntries(Object.entries(this.#schemas).map(([name, schema]) => [rename(name), schema]));\n\t\tthis.#key = this.#key.map(rename);\n\t\tfor (const [name, columns] of this.#indexes) this.#indexes.set(name, columns.map(rename));\n\t\tthis.#before.push({ kind: \"rename\", from, to });\n\t\treturn this;\n\t}\n\n\tadd(name: string, column: ColumnSchema): this {\n\t\tthis.#assertBefore(\"add\");\n\t\tthis.#assertNewName(name, \"add\");\n\t\tconst [described] = describeColumns({ [name]: column }, `${this.#what}: add`);\n\t\tif (!described!.optional && (described!.type === \"json\" || described!.default === undefined)) {\n\t\t\tthrow new Error(`${this.#what}: add: column \"${name}\" needs opt(...) or a default (existing rows get it)`);\n\t\t}\n\t\tthis.#schemas[name] = column;\n\t\tthis.#before.push({ kind: \"add\", name, column: columnRecord(described!) });\n\t\treturn this;\n\t}\n\n\tjson(name: string, column: ColumnSchema): this {\n\t\tthis.#assertBefore(\"json\");\n\t\tconst existing = describeColumns({ [name]: this.#assertColumn(name, \"json\") }, this.#what)[0]!;\n\t\tif (existing.type !== \"json\") throw new Error(`${this.#what}: json: column \"${name}\" is not a json(...) column`);\n\t\tif (isOptional(column)) {\n\t\t\tthrow new Error(`${this.#what}: json: pass json(...) itself; the column keeps its nullability`);\n\t\t}\n\t\tconst schema = existing.optional ? opt(column) : column;\n\t\tconst described = describeColumns({ [name]: schema }, `${this.#what}: json`)[0]!;\n\t\tif (described.type !== \"json\") throw new Error(`${this.#what}: json: expected a json(...) column`);\n\t\tconst [before, after] = [existing.json, described.json];\n\t\t// D9 across table versions: a cell's version says which schema it was written with.\n\t\tif (after.version < before.version) {\n\t\t\tthrow new Error(`${this.#what}: json: column \"${name}\" goes back from version ${before.version}`);\n\t\t}\n\t\tif (after.version === before.version && after.fingerprint !== before.fingerprint) {\n\t\t\tthrow new Error(\n\t\t\t\t`${this.#what}: json: column \"${name}\" changes its schema at version ${before.version} (raise its version)`,\n\t\t\t);\n\t\t}\n\t\tthis.#schemas[name] = schema;\n\t\tthis.#before.push({ kind: \"json\", name, column: columnRecord(described) });\n\t\treturn this;\n\t}\n\n\trows(patch: (row: { readonly [column: string]: unknown }) => unknown): this {\n\t\tthis.#assertBefore(\"rows\");\n\t\tif (typeof patch !== \"function\") throw new Error(`${this.#what}: rows: expected a function`);\n\t\tthis.#step = { kind: \"rows\", table: this.#current(), patch };\n\t\tthis.#phase = \"after\";\n\t\treturn this;\n\t}\n\n\tupdate(step: { readonly where?: unknown; readonly set: unknown }): this {\n\t\tthis.#assertBefore(\"update\");\n\t\tconst table = this.#current();\n\t\tconst what = `version ${table.version} update`;\n\t\tconst where = typeof step.where === \"function\" ? step.where(table.refs) : step.where;\n\t\tconst set = typeof step.set === \"function\" ? step.set(table.refs) : step.set;\n\t\tthis.#step = {\n\t\t\tkind: \"update\",\n\t\t\ttable,\n\t\t\twhere: where === undefined ? undefined : compileWhere(table, where, what),\n\t\t\tset: compileSet(table, set, what),\n\t\t};\n\t\tthis.#phase = \"after\";\n\t\treturn this;\n\t}\n\n\tdrop(name: string): this {\n\t\tthis.#phase = \"after\";\n\t\tthis.#assertColumn(name, \"drop\");\n\t\tif (this.#key.includes(name)) throw new Error(`${this.#what}: drop: \"${name}\" is a key column`);\n\t\tfor (const [index, columns] of this.#indexes) {\n\t\t\tif (!columns.includes(name)) continue;\n\t\t\tthis.#indexes.delete(index);\n\t\t\tthis.#after.push({ kind: \"dropIndex\", name: index });\n\t\t}\n\t\tconst { [name]: _dropped, ...schemas } = this.#schemas;\n\t\tthis.#schemas = schemas;\n\t\tthis.#after.push({ kind: \"drop\", name });\n\t\treturn this;\n\t}\n\n\tindex(name: string, columns: readonly string[]): this {\n\t\tthis.#phase = \"after\";\n\t\tconst what = `${this.#what}: index \"${name}\"`;\n\t\tif (!INDEX_NAME.test(name)) throw new Error(`${what}: expected [a-z0-9_]+`);\n\t\tif (this.#indexes.has(name)) throw new Error(`${what} exists`);\n\t\t// Checked against the columns at this edit: the migration creates the index here, whatever later edits do.\n\t\tconst byName = new Map(describeColumns(this.#schemas, this.#what).map((column) => [column.name, column]));\n\t\tconst checked = orderColumns(byName, columns, what);\n\t\tthis.#indexes.set(name, checked);\n\t\tthis.#after.push({ kind: \"index\", name, columns: checked });\n\t\treturn this;\n\t}\n\n\tdropIndex(name: string): this {\n\t\tthis.#phase = \"after\";\n\t\tif (!this.#indexes.delete(name)) throw new Error(`${this.#what}: dropIndex: no index \"${name}\"`);\n\t\tthis.#after.push({ kind: \"dropIndex\", name });\n\t\treturn this;\n\t}\n\n\t/** The new version, materialized and fingerprinted, linked to the previous one and the migration from it. */\n\tfinish(): TableDefinition {\n\t\tconst migration = { before: this.#before, step: this.#step, after: this.#after };\n\t\treturn new TableDefinition(this.#previous.name, this.#options(), { previous: this.#previous, migration });\n\t}\n\n\t/** The table as the edits so far leave it, at the new version: what a data step reads and writes. */\n\t#current(): TableDefinition {\n\t\treturn new TableDefinition(this.#previous.name, this.#options());\n\t}\n\n\t#options(): TableOptions<Columns, readonly never[]> {\n\t\tconst version = this.#previous.version + 1;\n\t\tconst options = {\n\t\t\tversion,\n\t\t\tcolumns: { ...this.#schemas },\n\t\t\tkey: [...this.#key],\n\t\t\tindexes: Object.fromEntries(this.#indexes),\n\t\t};\n\t\t// The key and indexes are names the edits kept; the constructor checks them as it checks a base's.\n\t\treturn options as unknown as TableOptions<Columns, readonly never[]>;\n\t}\n\n\t#assertBefore(edit: string): void {\n\t\tif (this.#phase === \"after\") {\n\t\t\tthrow new Error(`${this.#what}: ${edit} comes before the data step and before drop, index and dropIndex`);\n\t\t}\n\t}\n\n\t/**\n\t * `name` names no column yet, also ignoring ASCII case (SQLite's column names do): checked per edit, since a later\n\t * `drop` cannot take back an `add` the migration runs first. A rename may change only the case of `from`.\n\t */\n\t#assertNewName(name: string, edit: string, from?: string): void {\n\t\tconst folded = foldAscii(name);\n\t\tfor (const existing of Object.keys(this.#schemas)) {\n\t\t\tif (existing !== from && foldAscii(existing) === folded) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`${this.#what}: ${edit}: column \"${existing}\" exists (names differing only in case collide)`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\t#assertColumn(name: string, edit: string): ColumnSchema {\n\t\tif (!Object.hasOwn(this.#schemas, name)) throw new Error(`${this.#what}: ${edit}: no column \"${name}\"`);\n\t\treturn this.#schemas[name]!;\n\t}\n}\n\n/** `name` with ASCII letters lowercased and nothing else changed, as SQLite folds identifiers. */\nfunction foldAscii(name: string): string {\n\treturn name.replace(/[A-Z]+/g, (letters) => letters.toLowerCase());\n}\n"]}

package/dist/store/table-handle.d.ts

@@ -0,0 +1,73 @@
+import type { Context } from "../context/index.ts";
+import { ChordError } from "../data/index.ts";
+import type { SqliteValue } from "../sqlite/index.ts";
+import type { Columns, RowOf } from "./columns.ts";
+import type { LiveQueries } from "./live-query.ts";
+import { type Query } from "./query.ts";
+import { TableSql } from "./sql.ts";
+import type { ChordStore } from "./store.ts";
+import type { KeyOf, TableDefinition } from "./table.ts";
+/** One page of rows (`items`, as Durable's pages) and, when more follow, the cursor to continue after it. */
+export type Page<T> = {
+    readonly items: T[];
+    readonly next?: string;
+};
+/** What `page` takes besides the query, the limit and the context. */
+export type PageOptions = {
+    /** A cursor from an earlier page of the same order. */
+    readonly after?: string;
+};
+/** A table of this object: reads of committed state, the context last. Writes go through `self.tx`. */
+export interface Table<C extends Columns, K extends readonly string[]> {
+    /** Up to `limit` rows of `q` (after `options.after`), and the cursor of the next page when there is one. */
+    page(q: Query<C, K>, limit: number, context: Context, options?: PageOptions): Promise<Page<RowOf<C>>>;
+    /** Every row of `q`, read a page of 100 at a time. */
+    rows(q: Query<C, K>, context: Context): AsyncIterable<RowOf<C>>;
+    /** The row with `key`, `undefined` when absent. */
+    get(key: KeyOf<C, K>, context: Context): Promise<RowOf<C> | undefined>;
+    /** The number of rows of `q`. */
+    count(q: Query<C, K>, context: Context): Promise<number>;
+}
+/** The handle type of table definition `D`: what `self.table(D)` returns. */
+export type TableOf<D> = D extends TableDefinition<infer C, infer K> ? Table<C, K> : never;
+/**
+ * Who owns a table handle: its object (whose transactions alone write it), its live queries, liveness check and live
+ * failure.
+ */
+export type TableOwner = {
+    readonly label: string;
+    /** The object's documents: a transaction of another object refuses the handle. */
+    readonly scope: object;
+    /** The object's live queries, across its attempts: what a commit writing the table re-runs. */
+    readonly queries: LiveQueries;
+    /** Throws `released` once the object ended. */
+    assertLive(): void;
+    /** A row the code cannot read (a `json(...)` cell, slice 6a §9) fails the owner `broken` (§1.4). */
+    fail(error: ChordError): void;
+};
+/** The rows `rows()` reads per page (rule 17). */
+export declare const ROWS_PAGE = 100;
+/** A table handle: the definition the attempt declared, the table's SQL name and statements, the store. */
+export declare class TableHandle implements Table<Columns, readonly string[]> {
+    #private;
+    readonly definition: TableDefinition;
+    readonly sql: TableSql;
+    readonly store: ChordStore;
+    readonly owner: TableOwner;
+    constructor(definition: TableDefinition, sqlName: string, store: ChordStore, owner: TableOwner);
+    page(q: Query, limit: number, context: Context, options?: PageOptions): Promise<Page<RowOf<Columns>>>;
+    rows(q: Query, context: Context): AsyncIterable<RowOf<Columns>>;
+    get(key: unknown, context: Context): Promise<RowOf<Columns> | undefined>;
+    count(q: Query, context: Context): Promise<number>;
+    /**
+     * The version fence of old table handles (R15): once the store's table is at a newer version than this handle's
+     * definition (a reload's new code migrated it), old code still running (a call cut off at its restart's seal) reads
+     * and writes it no more (`released/version`), so it never issues SQL for a dropped column.
+     */
+    assertVersion(): void;
+    /** A stored row as reads return it; one the code cannot read fails the owner and throws. */
+    decode(stored: {
+        readonly [column: string]: SqliteValue;
+    }, context: Context): RowOf<Columns>;
+}
+//# sourceMappingURL=table-handle.d.ts.map

package/dist/store/table-handle.d.ts.map

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

package/dist/store/table-handle.js

@@ -0,0 +1,101 @@
+// Table handles (slice 6a §6; decision "Query runner"): what `self.table(Def)` returns, one per attempt and table: reads
+// of committed rows (`page`, `rows`, `get`, `count`) through the store's guarded reads, and what a transaction's
+// writes to the table are staged with; a handle of an older version than the stored table is refused (R15, slice 7b).
+import { ChordError } from "../data/index.js";
+import { invalid } from "../data/internal.js";
+import { decodeCursor, encodeCursor } from "./query.js";
+import { TableSql } from "./sql.js";
+/** The rows `rows()` reads per page (rule 17). */
+export const ROWS_PAGE = 100;
+/** A table handle: the definition the attempt declared, the table's SQL name and statements, the store. */
+export class TableHandle {
+    definition;
+    sql;
+    store;
+    owner;
+    constructor(definition, sqlName, store, owner) {
+        this.definition = definition;
+        this.sql = new TableSql(sqlName, definition.columns, definition.rows.physical, definition.key);
+        this.store = store;
+        this.owner = owner;
+    }
+    async page(q, limit, context, options = {}) {
+        this.owner.assertLive();
+        this.assertVersion();
+        this.#assertQuery(q);
+        if (!Number.isSafeInteger(limit) || limit < 1)
+            throw invalid("args", `${this.definition.name}: limit is a positive integer`);
+        const order = q.order;
+        const after = options.after === undefined ? undefined : decodeCursor(this.definition, this.sql.table, order, options.after);
+        const statement = this.sql.select(q.condition, order, after, limit + 1);
+        const stored = await this.store.read((executor) => executor.all(statement.sql, ...statement.params), context);
+        const more = stored.length > limit;
+        if (more)
+            stored.length = limit;
+        const items = stored.map((row) => this.decode(row, context));
+        if (!more)
+            return { items };
+        const last = stored[limit - 1];
+        return {
+            items,
+            next: encodeCursor(this.sql.table, order, order.columns.map((column) => last[column])),
+        };
+    }
+    async *rows(q, context) {
+        let after;
+        do {
+            const page = await this.page(q, ROWS_PAGE, context, after === undefined ? {} : { after });
+            yield* page.items;
+            after = page.next;
+        } while (after !== undefined);
+    }
+    async get(key, context) {
+        this.owner.assertLive();
+        this.assertVersion();
+        const encoded = this.definition.rows.key(key, "get");
+        const stored = await this.store.read((executor) => executor.get(this.sql.get, ...encoded.params), context);
+        return stored === undefined ? undefined : this.decode(stored, context);
+    }
+    async count(q, context) {
+        this.owner.assertLive();
+        this.assertVersion();
+        this.#assertQuery(q);
+        const statement = this.sql.count(q.condition);
+        const row = await this.store.read((executor) => executor.get(statement.sql, ...statement.params), context);
+        return row?.count ?? 0;
+    }
+    /**
+     * The version fence of old table handles (R15): once the store's table is at a newer version than this handle's
+     * definition (a reload's new code migrated it), old code still running (a call cut off at its restart's seal) reads
+     * and writes it no more (`released/version`), so it never issues SQL for a dropped column.
+     */
+    assertVersion() {
+        const stored = this.store.tableVersion(this.sql.table);
+        if (stored === undefined || stored <= this.definition.version)
+            return;
+        const { name, version } = this.definition;
+        const message = `${this.owner.label}: table "${name}" of version ${version}; the store has version ${stored}`;
+        throw new ChordError({ code: "released", reason: "version", message });
+    }
+    /** A stored row as reads return it; one the code cannot read fails the owner and throws. */
+    decode(stored, context) {
+        try {
+            // The codec decodes by the definition's columns: a row of them.
+            return this.definition.rows.decode(stored, context);
+        }
+        catch (error) {
+            const failure = error instanceof ChordError
+                ? error
+                : new ChordError({ code: "unavailable", message: String(error) }, { cause: error });
+            this.owner.fail(failure);
+            throw failure;
+        }
+    }
+    /** A query of another table is refused (`invalid/args`). */
+    #assertQuery(q) {
+        if (q.table !== this.definition) {
+            throw invalid("args", `${this.owner.label}: a query of table "${q.table.name}" run on "${this.definition.name}"`);
+        }
+    }
+}
+//# sourceMappingURL=table-handle.js.map

package/dist/store/table-handle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-handle.js","sourceRoot":"","sources":["../../src/store/table-handle.ts"],"names":[],"mappings":"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","sourcesContent":["// Table handles (slice 6a §6; decision \"Query runner\"): what `self.table(Def)` returns, one per attempt and table: reads\n// of committed rows (`page`, `rows`, `get`, `count`) through the store's guarded reads, and what a transaction's\n// writes to the table are staged with; a handle of an older version than the stored table is refused (R15, slice 7b).\n\nimport type { Context } from \"../context/index.ts\";\nimport { ChordError } from \"../data/index.ts\";\nimport { invalid } from \"../data/internal.ts\";\nimport type { SqliteValue } from \"../sqlite/index.ts\";\nimport type { Columns, RowOf } from \"./columns.ts\";\nimport type { LiveQueries } from \"./live-query.ts\";\nimport { decodeCursor, encodeCursor, type Query } from \"./query.ts\";\nimport { TableSql } from \"./sql.ts\";\nimport type { ChordStore } from \"./store.ts\";\nimport type { KeyOf, TableDefinition } from \"./table.ts\";\n\n/** One page of rows (`items`, as Durable's pages) and, when more follow, the cursor to continue after it. */\nexport type Page<T> = { readonly items: T[]; readonly next?: string };\n\n/** What `page` takes besides the query, the limit and the context. */\nexport type PageOptions = {\n\t/** A cursor from an earlier page of the same order. */\n\treadonly after?: string;\n};\n\n/** A table of this object: reads of committed state, the context last. Writes go through `self.tx`. */\nexport interface Table<C extends Columns, K extends readonly string[]> {\n\t/** Up to `limit` rows of `q` (after `options.after`), and the cursor of the next page when there is one. */\n\tpage(q: Query<C, K>, limit: number, context: Context, options?: PageOptions): Promise<Page<RowOf<C>>>;\n\t/** Every row of `q`, read a page of 100 at a time. */\n\trows(q: Query<C, K>, context: Context): AsyncIterable<RowOf<C>>;\n\t/** The row with `key`, `undefined` when absent. */\n\tget(key: KeyOf<C, K>, context: Context): Promise<RowOf<C> | undefined>;\n\t/** The number of rows of `q`. */\n\tcount(q: Query<C, K>, context: Context): Promise<number>;\n}\n\n/** The handle type of table definition `D`: what `self.table(D)` returns. */\nexport type TableOf<D> = D extends TableDefinition<infer C, infer K> ? Table<C, K> : never;\n\n/**\n * Who owns a table handle: its object (whose transactions alone write it), its live queries, liveness check and live\n * failure.\n */\nexport type TableOwner = {\n\treadonly label: string;\n\t/** The object's documents: a transaction of another object refuses the handle. */\n\treadonly scope: object;\n\t/** The object's live queries, across its attempts: what a commit writing the table re-runs. */\n\treadonly queries: LiveQueries;\n\t/** Throws `released` once the object ended. */\n\tassertLive(): void;\n\t/** A row the code cannot read (a `json(...)` cell, slice 6a §9) fails the owner `broken` (§1.4). */\n\tfail(error: ChordError): void;\n};\n\n/** The rows `rows()` reads per page (rule 17). */\nexport const ROWS_PAGE = 100;\n\n/** A table handle: the definition the attempt declared, the table's SQL name and statements, the store. */\nexport class TableHandle implements Table<Columns, readonly string[]> {\n\treadonly definition: TableDefinition;\n\treadonly sql: TableSql;\n\treadonly store: ChordStore;\n\treadonly owner: TableOwner;\n\n\tconstructor(definition: TableDefinition, sqlName: string, store: ChordStore, owner: TableOwner) {\n\t\tthis.definition = definition;\n\t\tthis.sql = new TableSql(sqlName, definition.columns, definition.rows.physical, definition.key);\n\t\tthis.store = store;\n\t\tthis.owner = owner;\n\t}\n\n\tasync page(q: Query, limit: number, context: Context, options: PageOptions = {}): Promise<Page<RowOf<Columns>>> {\n\t\tthis.owner.assertLive();\n\t\tthis.assertVersion();\n\t\tthis.#assertQuery(q);\n\t\tif (!Number.isSafeInteger(limit) || limit < 1)\n\t\t\tthrow invalid(\"args\", `${this.definition.name}: limit is a positive integer`);\n\t\tconst order = q.order;\n\t\tconst after =\n\t\t\toptions.after === undefined ? undefined : decodeCursor(this.definition, this.sql.table, order, options.after);\n\t\tconst statement = this.sql.select(q.condition, order, after, limit + 1);\n\t\tconst stored = await this.store.read(\n\t\t\t(executor) => executor.all<{ [column: string]: SqliteValue }>(statement.sql, ...statement.params),\n\t\t\tcontext,\n\t\t);\n\t\tconst more = stored.length > limit;\n\t\tif (more) stored.length = limit;\n\t\tconst items = stored.map((row) => this.decode(row, context));\n\t\tif (!more) return { items };\n\t\tconst last = stored[limit - 1]!;\n\t\treturn {\n\t\t\titems,\n\t\t\tnext: encodeCursor(\n\t\t\t\tthis.sql.table,\n\t\t\t\torder,\n\t\t\t\torder.columns.map((column) => last[column]!),\n\t\t\t),\n\t\t};\n\t}\n\n\tasync *rows(q: Query, context: Context): AsyncIterable<RowOf<Columns>> {\n\t\tlet after: string | undefined;\n\t\tdo {\n\t\t\tconst page = await this.page(q, ROWS_PAGE, context, after === undefined ? {} : { after });\n\t\t\tyield* page.items;\n\t\t\tafter = page.next;\n\t\t} while (after !== undefined);\n\t}\n\n\tasync get(key: unknown, context: Context): Promise<RowOf<Columns> | undefined> {\n\t\tthis.owner.assertLive();\n\t\tthis.assertVersion();\n\t\tconst encoded = this.definition.rows.key(key, \"get\");\n\t\tconst stored = await this.store.read(\n\t\t\t(executor) => executor.get<{ [column: string]: SqliteValue }>(this.sql.get, ...encoded.params),\n\t\t\tcontext,\n\t\t);\n\t\treturn stored === undefined ? undefined : this.decode(stored, context);\n\t}\n\n\tasync count(q: Query, context: Context): Promise<number> {\n\t\tthis.owner.assertLive();\n\t\tthis.assertVersion();\n\t\tthis.#assertQuery(q);\n\t\tconst statement = this.sql.count(q.condition);\n\t\tconst row = await this.store.read(\n\t\t\t(executor) => executor.get<{ readonly count: number }>(statement.sql, ...statement.params),\n\t\t\tcontext,\n\t\t);\n\t\treturn row?.count ?? 0;\n\t}\n\n\t/**\n\t * The version fence of old table handles (R15): once the store's table is at a newer version than this handle's\n\t * definition (a reload's new code migrated it), old code still running (a call cut off at its restart's seal) reads\n\t * and writes it no more (`released/version`), so it never issues SQL for a dropped column.\n\t */\n\tassertVersion(): void {\n\t\tconst stored = this.store.tableVersion(this.sql.table);\n\t\tif (stored === undefined || stored <= this.definition.version) return;\n\t\tconst { name, version } = this.definition;\n\t\tconst message = `${this.owner.label}: table \"${name}\" of version ${version}; the store has version ${stored}`;\n\t\tthrow new ChordError({ code: \"released\", reason: \"version\", message });\n\t}\n\n\t/** A stored row as reads return it; one the code cannot read fails the owner and throws. */\n\tdecode(stored: { readonly [column: string]: SqliteValue }, context: Context): RowOf<Columns> {\n\t\ttry {\n\t\t\t// The codec decodes by the definition's columns: a row of them.\n\t\t\treturn this.definition.rows.decode(stored, context) as RowOf<Columns>;\n\t\t} catch (error) {\n\t\t\tconst failure =\n\t\t\t\terror instanceof ChordError\n\t\t\t\t\t? error\n\t\t\t\t\t: new ChordError({ code: \"unavailable\", message: String(error) }, { cause: error });\n\t\t\tthis.owner.fail(failure);\n\t\t\tthrow failure;\n\t\t}\n\t}\n\n\t/** A query of another table is refused (`invalid/args`). */\n\t#assertQuery(q: Query): void {\n\t\tif (q.table !== this.definition) {\n\t\t\tthrow invalid(\n\t\t\t\t\"args\",\n\t\t\t\t`${this.owner.label}: a query of table \"${q.table.name}\" run on \"${this.definition.name}\"`,\n\t\t\t);\n\t\t}\n\t}\n}\n"]}

package/dist/store/table-history.d.ts

@@ -0,0 +1,75 @@
+import type { TableRecord } from "./catalog.ts";
+import type { ColumnRecord } from "./columns.ts";
+import type { SetNode, WhereNode } from "./expression.ts";
+import type { TableDefinition } from "./table.ts";
+/** One edit of a migration as its writes record it (`alter`, `index`, `dropIndex`); the table is named when applied. */
+export type TableEdit = {
+    readonly kind: "rename";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly kind: "add";
+    readonly name: string;
+    readonly column: ColumnRecord;
+} | {
+    readonly kind: "drop";
+    readonly name: string;
+} | {
+    readonly kind: "json";
+    readonly name: string;
+    readonly column: ColumnRecord;
+} | {
+    readonly kind: "index";
+    readonly name: string;
+    readonly columns: readonly string[];
+} | {
+    readonly kind: "dropIndex";
+    readonly name: string;
+};
+/** The column edits an `alter` write records. */
+export type AlterEdit = Extract<TableEdit, {
+    readonly kind: "rename" | "add" | "drop" | "json";
+}>;
+/**
+ * A version's data step over `table`, the columns between the edits before it and after it: `rows` patches each row
+ * (synchronous and pure), `update` is one `updateWhere`.
+ */
+export type DataStep = {
+    readonly kind: "rows";
+    readonly table: TableDefinition;
+    readonly patch: (row: {
+        readonly [column: string]: unknown;
+    }) => unknown;
+} | {
+    readonly kind: "update";
+    readonly table: TableDefinition;
+    readonly where: WhereNode | undefined;
+    readonly set: SetNode;
+};
+/** What one `evolveTable` changed: the edits before the data step, the step, the edits after it. */
+export type Migration = {
+    readonly before: readonly TableEdit[];
+    readonly step: DataStep | undefined;
+    readonly after: readonly TableEdit[];
+};
+/**
+ * What an activation does with a declared table: create it at the newest version, use it as recorded, or migrate it
+ * through `versions` (oldest first), the first one from its start (`begin`) or, recorded `migrating`, after its (A)
+ * commit (`resume`).
+ */
+export type TablePlan = {
+    readonly kind: "create";
+} | {
+    readonly kind: "ready";
+} | {
+    readonly kind: "migrate";
+    readonly versions: readonly TableDefinition[];
+    readonly first: "begin" | "resume";
+};
+/**
+ * The plan for `definition` (the code's newest version) against `recorded`. A recorded version newer than the newest,
+ * older than the history's base, or the same version with another fingerprint (a history edited in place) throws:
+ * the object fails `broken`, the data stays.
+ */
+export declare function planTable(definition: TableDefinition, recorded: TableRecord | undefined, what: string): TablePlan;
+//# sourceMappingURL=table-history.d.ts.map

package/dist/store/table-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-history.d.ts","sourceRoot":"","sources":["../../src/store/table-history.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,wHAAwH;AACxH,MAAM,MAAM,SAAS,GAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACvE;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GAC9E;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACtF;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD,iDAAiD;AACjD,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC,CAAC;AAElG;;;GAGG;AACH,MAAM,MAAM,QAAQ,GACjB;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC;CACxE,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;CACrB,CAAC;AAEL,oGAAoG;AACpG,MAAM,MAAM,SAAS,GAAG;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;CACrC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC;CAClC,CAAC;AAEL;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAwBjH"}

package/dist/store/table-history.js

@@ -0,0 +1,42 @@
+// A table's history (slice 6a §9; decision "Second spec review: the majority"): the versions from a base
+// `defineTable` through each `evolveTable`, the migration each version recorded, and what an activation does with the
+// version the store recorded: create the table, use it, migrate it from there, or refuse it.
+/**
+ * The plan for `definition` (the code's newest version) against `recorded`. A recorded version newer than the newest,
+ * older than the history's base, or the same version with another fingerprint (a history edited in place) throws:
+ * the object fails `broken`, the data stays.
+ */
+export function planTable(definition, recorded, what) {
+    if (recorded === undefined)
+        return { kind: "create" };
+    const { version, state, fingerprint } = recorded;
+    if (version > definition.version) {
+        throw new Error(`${what}: the store has version ${version}, newer than the code's ${definition.version}`);
+    }
+    const versions = historyOf(definition);
+    const at = versions.find((each) => each.version === version);
+    if (at === undefined) {
+        throw new Error(`${what}: the store has version ${version}, older than the history's base ${versions[0].version}`);
+    }
+    if (at.fingerprint !== fingerprint) {
+        throw new Error(`${what}: version ${version} is recorded with another definition (a history edited in place)`);
+    }
+    if (state === "ready" && version === definition.version)
+        return { kind: "ready" };
+    if (state === "migrating" && at.evolution?.migration.step === undefined) {
+        throw new Error(`${what}: version ${version} is recorded migrating, but has no data step to resume`);
+    }
+    if (state === "migrating") {
+        return { kind: "migrate", versions: versions.filter((each) => each.version >= version), first: "resume" };
+    }
+    return { kind: "migrate", versions: versions.filter((each) => each.version > version), first: "begin" };
+}
+/** Every version of `definition`'s history, the base first. */
+function historyOf(definition) {
+    const versions = [];
+    for (let at = definition; at !== undefined; at = at.evolution?.previous) {
+        versions.unshift(at);
+    }
+    return versions;
+}
+//# sourceMappingURL=table-history.js.map

package/dist/store/table-history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-history.js","sourceRoot":"","sources":["../../src/store/table-history.ts"],"names":[],"mappings":"AAAA,yGAAyG;AACzG,sHAAsH;AACtH,6FAA6F;AAyD7F;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,UAA2B,EAAE,QAAiC,EAAE,IAAY;IACrG,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IACtD,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,GAAG,QAAQ,CAAC;IACjD,IAAI,OAAO,GAAG,UAAU,CAAC,OAAO,EAAE,CAAC;QAClC,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,2BAA2B,OAAO,2BAA2B,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;IAC3G,CAAC;IACD,MAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;IACvC,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC;IAC7D,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CACd,GAAG,IAAI,2BAA2B,OAAO,mCAAmC,QAAQ,CAAC,CAAC,CAAE,CAAC,OAAO,EAAE,CAClG,CAAC;IACH,CAAC;IACD,IAAI,EAAE,CAAC,WAAW,KAAK,WAAW,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,aAAa,OAAO,kEAAkE,CAAC,CAAC;IAChH,CAAC;IACD,IAAI,KAAK,KAAK,OAAO,IAAI,OAAO,KAAK,UAAU,CAAC,OAAO;QAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAClF,IAAI,KAAK,KAAK,WAAW,IAAI,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QACzE,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,aAAa,OAAO,wDAAwD,CAAC,CAAC;IACtG,CAAC;IACD,IAAI,KAAK,KAAK,WAAW,EAAE,CAAC;QAC3B,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAC3G,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AACzG,CAAC;AAED,+DAA+D;AAC/D,SAAS,SAAS,CAAC,UAA2B;IAC7C,MAAM,QAAQ,GAAsB,EAAE,CAAC;IACvC,KAAK,IAAI,EAAE,GAAgC,UAAU,EAAE,EAAE,KAAK,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,CAAC;QACtG,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACtB,CAAC;IACD,OAAO,QAAQ,CAAC;AACjB,CAAC","sourcesContent":["// A table's history (slice 6a §9; decision \"Second spec review: the majority\"): the versions from a base\n// `defineTable` through each `evolveTable`, the migration each version recorded, and what an activation does with the\n// version the store recorded: create the table, use it, migrate it from there, or refuse it.\n\nimport type { TableRecord } from \"./catalog.ts\";\nimport type { ColumnRecord } from \"./columns.ts\";\nimport type { SetNode, WhereNode } from \"./expression.ts\";\nimport type { TableDefinition } from \"./table.ts\";\n\n/** One edit of a migration as its writes record it (`alter`, `index`, `dropIndex`); the table is named when applied. */\nexport type TableEdit =\n\t| { readonly kind: \"rename\"; readonly from: string; readonly to: string }\n\t| { readonly kind: \"add\"; readonly name: string; readonly column: ColumnRecord }\n\t| { readonly kind: \"drop\"; readonly name: string }\n\t| { readonly kind: \"json\"; readonly name: string; readonly column: ColumnRecord }\n\t| { readonly kind: \"index\"; readonly name: string; readonly columns: readonly string[] }\n\t| { readonly kind: \"dropIndex\"; readonly name: string };\n\n/** The column edits an `alter` write records. */\nexport type AlterEdit = Extract<TableEdit, { readonly kind: \"rename\" | \"add\" | \"drop\" | \"json\" }>;\n\n/**\n * A version's data step over `table`, the columns between the edits before it and after it: `rows` patches each row\n * (synchronous and pure), `update` is one `updateWhere`.\n */\nexport type DataStep =\n\t| {\n\t\t\treadonly kind: \"rows\";\n\t\t\treadonly table: TableDefinition;\n\t\t\treadonly patch: (row: { readonly [column: string]: unknown }) => unknown;\n\t  }\n\t| {\n\t\t\treadonly kind: \"update\";\n\t\t\treadonly table: TableDefinition;\n\t\t\treadonly where: WhereNode | undefined;\n\t\t\treadonly set: SetNode;\n\t  };\n\n/** What one `evolveTable` changed: the edits before the data step, the step, the edits after it. */\nexport type Migration = {\n\treadonly before: readonly TableEdit[];\n\treadonly step: DataStep | undefined;\n\treadonly after: readonly TableEdit[];\n};\n\n/**\n * What an activation does with a declared table: create it at the newest version, use it as recorded, or migrate it\n * through `versions` (oldest first), the first one from its start (`begin`) or, recorded `migrating`, after its (A)\n * commit (`resume`).\n */\nexport type TablePlan =\n\t| { readonly kind: \"create\" }\n\t| { readonly kind: \"ready\" }\n\t| {\n\t\t\treadonly kind: \"migrate\";\n\t\t\treadonly versions: readonly TableDefinition[];\n\t\t\treadonly first: \"begin\" | \"resume\";\n\t  };\n\n/**\n * The plan for `definition` (the code's newest version) against `recorded`. A recorded version newer than the newest,\n * older than the history's base, or the same version with another fingerprint (a history edited in place) throws:\n * the object fails `broken`, the data stays.\n */\nexport function planTable(definition: TableDefinition, recorded: TableRecord | undefined, what: string): TablePlan {\n\tif (recorded === undefined) return { kind: \"create\" };\n\tconst { version, state, fingerprint } = recorded;\n\tif (version > definition.version) {\n\t\tthrow new Error(`${what}: the store has version ${version}, newer than the code's ${definition.version}`);\n\t}\n\tconst versions = historyOf(definition);\n\tconst at = versions.find((each) => each.version === version);\n\tif (at === undefined) {\n\t\tthrow new Error(\n\t\t\t`${what}: the store has version ${version}, older than the history's base ${versions[0]!.version}`,\n\t\t);\n\t}\n\tif (at.fingerprint !== fingerprint) {\n\t\tthrow new Error(`${what}: version ${version} is recorded with another definition (a history edited in place)`);\n\t}\n\tif (state === \"ready\" && version === definition.version) return { kind: \"ready\" };\n\tif (state === \"migrating\" && at.evolution?.migration.step === undefined) {\n\t\tthrow new Error(`${what}: version ${version} is recorded migrating, but has no data step to resume`);\n\t}\n\tif (state === \"migrating\") {\n\t\treturn { kind: \"migrate\", versions: versions.filter((each) => each.version >= version), first: \"resume\" };\n\t}\n\treturn { kind: \"migrate\", versions: versions.filter((each) => each.version > version), first: \"begin\" };\n}\n\n/** Every version of `definition`'s history, the base first. */\nfunction historyOf(definition: TableDefinition): TableDefinition[] {\n\tconst versions: TableDefinition[] = [];\n\tfor (let at: TableDefinition | undefined = definition; at !== undefined; at = at.evolution?.previous) {\n\t\tversions.unshift(at);\n\t}\n\treturn versions;\n}\n"]}

package/dist/store/table-migration.d.ts

@@ -0,0 +1,16 @@
+import { type Context } from "../context/index.ts";
+import type { ChordStore, CommitFence } from "./store.ts";
+import type { TableDefinition } from "./table.ts";
+/** A declared table: its newest definition and its SQL name. */
+export type DeclaredTable = {
+    readonly definition: TableDefinition;
+    readonly table: string;
+};
+/**
+ * Brings `tables` to their definitions: the ones the store does not have created in one commit, then each older one
+ * migrated. A table the code cannot use (see `planTable`) throws before anything is written; `what` names the owner.
+ */
+export declare function prepareTables(tables: readonly DeclaredTable[], store: ChordStore, fence: CommitFence, what: string, context: Context): Promise<void>;
+/** The size of a `rows` chunk: one commit each. */
+export declare const MIGRATION_CHUNK = 100;
+//# sourceMappingURL=table-migration.d.ts.map

package/dist/store/table-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-migration.d.ts","sourceRoot":"","sources":["../../src/store/table-migration.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,OAAO,EAAsB,MAAM,qBAAqB,CAAC;AAOvE,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAYlD,gEAAgE;AAChE,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAK7F;;;GAGG;AACH,wBAAsB,aAAa,CAClC,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC,CAYf;AA2BD,mDAAmD;AACnD,eAAO,MAAM,eAAe,MAAM,CAAC"}

package/dist/store/table-migration.js

@@ -0,0 +1,202 @@
+// Declared tables brought to their version at activation (slice 6a §9): a table the store does not have is created at
+// the newest version with its indexes (no replay); an older one is migrated eagerly, one version at a time, in its
+// commits. Per version N: (A) the edits before the data step and `table { version: N, state: "migrating" }`; the data
+// step's chunks; (Z) the last chunk (or the `update`) with the edits after the step and `state: "ready"`. Without a
+// data step (A) and (Z) are one commit. A version recorded `migrating` resumes after (A), skipping the rows already
+// stamped `$v >= N`. Its record holds the columns during the step but version N's fingerprint, not the fingerprint of
+// those columns: the fingerprint names the version being reached, which resume, export and import check.
+import { withoutAbortSignal } from "../context/index.js";
+import { encodeCell, ROW_VERSION } from "./rows.js";
+import { TableSql } from "./sql.js";
+import { planTable } from "./table-history.js";
+import { jsonVersions, recordedVersions, stageEdit, stageIndex, stageTable, stageUpdate, stageUpdateWhere, } from "./table-writes.js";
+/**
+ * Brings `tables` to their definitions: the ones the store does not have created in one commit, then each older one
+ * migrated. A table the code cannot use (see `planTable`) throws before anything is written; `what` names the owner.
+ */
+export async function prepareTables(tables, store, fence, what, context) {
+    const created = [];
+    const migrations = [];
+    for (const { definition, table } of tables) {
+        const plan = planTable(definition, store.table(table), `${what}: table "${definition.name}"`);
+        if (plan.kind === "create")
+            created.push(...creation(definition, table));
+        else if (plan.kind === "migrate")
+            migrations.push({ table, plan });
+    }
+    if (created.length > 0)
+        await commit(created, { store, fence }, context);
+    for (const { table, plan } of migrations) {
+        await migrateTable(plan, { store, table, fence }, context);
+    }
+}
+/** The writes creating `definition` fresh as `table`: at its version, `ready`, with its indexes. */
+function creation(definition, table) {
+    const { version, record: columns, key, fingerprint } = definition;
+    return [
+        stageTable({ kind: "table", table, version, state: "ready", columns, key, fingerprint }),
+        ...[...definition.indexes].map(([name, columns]) => stageIndex({ kind: "index", table, name, columns })),
+    ];
+}
+/**
+ * Migrates the table through the plan's versions (oldest first, each with its migration), the first resumed after its
+ * (A) commit when the plan says so. `context`'s abort is checked between chunks (a chunk admitted to the step completes); a data
+ * step that throws, or returns a patch the version cannot take, rejects: the table stays `migrating` and the committed
+ * chunks stay.
+ */
+async function migrateTable(plan, target, context) {
+    for (const [index, version] of plan.versions.entries()) {
+        await migrateVersion(version, index === 0 ? plan.first : "begin", target, context);
+    }
+}
+/** The size of a `rows` chunk: one commit each. */
+export const MIGRATION_CHUNK = 100;
+/** Migrates to `definition`'s version from its (A) commit (`begin`) or after it (`resume`). */
+async function migrateVersion(definition, from, target, context) {
+    const { table } = target;
+    // Old handles are refused from now on: their SQL must never queue behind this version's DDL.
+    const withdraw = target.store.announceTable(table, definition.version);
+    try {
+        await migrateSteps(definition, from, target, context);
+    }
+    finally {
+        withdraw();
+    }
+}
+/** The commits of `migrateVersion`. */
+async function migrateSteps(definition, from, target, context) {
+    const { before, step, after } = definition.evolution.migration;
+    const { table } = target;
+    const edits = (list) => list.map((edit) => stageEdit(table, definition.version, edit));
+    const ready = [...edits(after), recordOf(definition, definition, "ready", table)];
+    if (step === undefined)
+        return commit([...edits(before), ...ready], target, context);
+    if (from === "begin")
+        await commit([...edits(before), recordOf(step.table, definition, "migrating", table)], target, context);
+    if (step.kind === "update")
+        return commit([updateStep(step, definition.version, table), ...ready], target, context);
+    await rowsStep(step, definition.version, ready, target, context);
+}
+/** The `table` write of `table`'s columns and key, with `definition`'s version and fingerprint, in `state`. */
+function recordOf(columns, definition, state, table) {
+    const { version, fingerprint } = definition;
+    return stageTable({ kind: "table", table, version, state, columns: columns.record, key: columns.key, fingerprint });
+}
+/** The `update` step: one `updateWhere` over the rows below version `v`, stamping it, so it never applies twice. */
+function updateStep(step, v, table) {
+    const sql = sqlOf(step.table, table);
+    const below = { lt: [ROW_VERSION, v] };
+    const where = step.where === undefined ? below : { and: [step.where, below] };
+    const versions = jsonVersions(step.table, step.set);
+    const statement = sql.updateWhere(where, { ...step.set, [ROW_VERSION]: v }, versions);
+    return stageUpdateWhere(statement, table, where, step.set, recordedVersions(step.set, versions), v);
+}
+/**
+ * The `rows` step: chunks of `MIGRATION_CHUNK` rows below version `v` in key order, paging forward by the last key;
+ * each patched row stamped `v`; the last chunk commits with `ready`.
+ */
+async function rowsStep(step, v, ready, target, context) {
+    const { table: columns } = step;
+    const sql = sqlOf(columns, target.table);
+    const order = { columns: columns.key, direction: "asc" };
+    const below = { lt: [ROW_VERSION, v] };
+    let after;
+    // The fallback yield between chunks (`macrotask`), made by the first yield that needs it, closed at the end.
+    let channel;
+    try {
+        for (;;) {
+            const statement = sql.select(below, order, after, MIGRATION_CHUNK + 1);
+            const stored = await target.store.read((executor) => executor.all(statement.sql, ...statement.params), context);
+            const last = stored.length <= MIGRATION_CHUNK;
+            if (!last)
+                stored.length = MIGRATION_CHUNK;
+            const writes = stored.map((row) => patchRow(step, row, v, sql, target.table, context));
+            if (last)
+                return await commit([...writes, ...ready], target, context);
+            await commit(writes, target, context);
+            after = columns.key.map((name) => stored[MIGRATION_CHUNK - 1][name]);
+            await macrotask(() => {
+                channel ??= new MessageChannel();
+                return channel;
+            });
+            // An abandoned activation stops here.
+            context.abortSignal?.throwIfAborted();
+        }
+    }
+    finally {
+        channel?.port1.close();
+    }
+}
+/**
+ * Resolves after one macrotask (other commits and timers run between chunks) without the 1 ms clamp of
+ * `setTimeout(0)`: `setImmediate` where the runtime has it (Node), else a message through the channel `channel()`
+ * gives (browsers, Workers). In Node a message costs 0.27 ms per yield against `setImmediate`'s 13 µs (the 10k-row
+ * migration bench: 100 ms against 70 ms).
+ */
+function macrotask(channel) {
+    return new Promise((resolve) => {
+        // A runtime feature check: Workers and browsers have no `setImmediate`. Read once from the global, and called only
+        // when it is a function: a check by name (`in`) and a later lookup could disagree.
+        const immediate = globalThis.setImmediate;
+        if (typeof immediate === "function") {
+            immediate(resolve);
+            return;
+        }
+        const { port1, port2 } = channel();
+        port1.addEventListener("message", () => resolve(), { once: true });
+        // A port listened to with `addEventListener` delivers only once started (browsers, Workers).
+        port1.start();
+        port2.postMessage(null);
+    });
+}
+/**
+ * The write of one row's patch: `patch` run on the decoded row, its result checked (an object of non-key columns of
+ * the version, values of their types) and stamped `v` through the internal form of `update`.
+ */
+function patchRow(step, stored, v, sql, table, context) {
+    const { table: definition } = step;
+    const patch = step.patch(definition.rows.decode(stored, context));
+    const what = `${definition.name} version ${v}: rows`;
+    if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
+        throw new Error(`${what}: expected an object of column values`);
+    }
+    const set = {};
+    for (const [name, value] of Object.entries(patch)) {
+        const column = definition.byName.get(name);
+        if (column === undefined)
+            throw new Error(`${what}: no column "${name}"`);
+        if (definition.key.includes(name))
+            throw new Error(`${what}: key column "${name}" cannot change`);
+        set[name] = cellOf(column, value, `${what}: column "${name}"`);
+    }
+    const key = {};
+    // Key columns are non-opt `str` or `int`: stored scalars.
+    for (const name of definition.key)
+        key[name] = stored[name];
+    const versions = jsonVersions(definition, set);
+    const params = definition.key.map((name) => stored[name]);
+    const statement = sql.update({ ...set, [ROW_VERSION]: v }, params, versions);
+    return stageUpdate(statement, table, key, set, recordedVersions(set, versions), v);
+}
+/**
+ * A patch value as a `set` node: `undefined` clears an `opt(...)` column, `json(...)` cells as JSON literals (a JSON
+ * `null` too); a scalar `null` is refused by `encodeCell`.
+ */
+function cellOf(column, value, what) {
+    if (value === undefined) {
+        if (!column.optional)
+            throw new Error(`${what} is not opt(...) and cannot be cleared`);
+        return null;
+    }
+    const cell = encodeCell(column, value, what);
+    // `encodeCell` returns a scalar for a scalar column.
+    return column.type === "json" ? { json: cell.stored } : cell.stored;
+}
+function sqlOf(definition, table) {
+    return new TableSql(table, definition.columns, definition.rows.physical, definition.key);
+}
+/** Commits `writes` without the activation's abort: a commit admitted to the step completes (the fence refuses one). */
+async function commit(writes, target, context) {
+    await target.store.commit(writes, target.fence, withoutAbortSignal(context));
+}
+//# sourceMappingURL=table-migration.js.map