@earendil-works/chord 1.5.0 → 1.5.1

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-migration.js","sourceRoot":"","sources":["../../src/store/table-migration.ts"],"names":[],"mappings":"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","sourcesContent":["// Declared tables brought to their version at activation (slice 6a §9): a table the store does not have is created at\n// the newest version with its indexes (no replay); an older one is migrated eagerly, one version at a time, in its\n// commits. Per version N: (A) the edits before the data step and `table { version: N, state: \"migrating\" }`; the data\n// step's chunks; (Z) the last chunk (or the `update`) with the edits after the step and `state: \"ready\"`. Without a\n// data step (A) and (Z) are one commit. A version recorded `migrating` resumes after (A), skipping the rows already\n// stamped `$v >= N`. Its record holds the columns during the step but version N's fingerprint, not the fingerprint of\n// those columns: the fingerprint names the version being reached, which resume, export and import check.\n\nimport { type Context, withoutAbortSignal } from \"../context/index.ts\";\nimport type { SqliteValue } from \"../sqlite/index.ts\";\nimport type { Column } from \"./columns.ts\";\nimport type { SetNode, WhereNode } from \"./expression.ts\";\nimport { encodeCell, ROW_VERSION, type Scalar } from \"./rows.ts\";\nimport { type Order, TableSql } from \"./sql.ts\";\nimport type { StagedWrite } from \"./step.ts\";\nimport type { ChordStore, CommitFence } from \"./store.ts\";\nimport type { TableDefinition } from \"./table.ts\";\nimport { type DataStep, planTable, type TablePlan } from \"./table-history.ts\";\nimport {\n\tjsonVersions,\n\trecordedVersions,\n\tstageEdit,\n\tstageIndex,\n\tstageTable,\n\tstageUpdate,\n\tstageUpdateWhere,\n} from \"./table-writes.ts\";\n\n/** A declared table: its newest definition and its SQL name. */\nexport type DeclaredTable = { readonly definition: TableDefinition; readonly table: string };\n\n/** Where a migration runs: the store, the table's SQL name and the commits' fence. */\ntype MigrationTarget = { readonly store: ChordStore; readonly table: string; readonly fence: CommitFence };\n\n/**\n * Brings `tables` to their definitions: the ones the store does not have created in one commit, then each older one\n * migrated. A table the code cannot use (see `planTable`) throws before anything is written; `what` names the owner.\n */\nexport async function prepareTables(\n\ttables: readonly DeclaredTable[],\n\tstore: ChordStore,\n\tfence: CommitFence,\n\twhat: string,\n\tcontext: Context,\n): Promise<void> {\n\tconst created: StagedWrite[] = [];\n\tconst migrations: { readonly table: string; readonly plan: Extract<TablePlan, { readonly kind: \"migrate\" }> }[] = [];\n\tfor (const { definition, table } of tables) {\n\t\tconst plan = planTable(definition, store.table(table), `${what}: table \"${definition.name}\"`);\n\t\tif (plan.kind === \"create\") created.push(...creation(definition, table));\n\t\telse if (plan.kind === \"migrate\") migrations.push({ table, plan });\n\t}\n\tif (created.length > 0) await commit(created, { store, fence }, context);\n\tfor (const { table, plan } of migrations) {\n\t\tawait migrateTable(plan, { store, table, fence }, context);\n\t}\n}\n\n/** The writes creating `definition` fresh as `table`: at its version, `ready`, with its indexes. */\nfunction creation(definition: TableDefinition, table: string): StagedWrite[] {\n\tconst { version, record: columns, key, fingerprint } = definition;\n\treturn [\n\t\tstageTable({ kind: \"table\", table, version, state: \"ready\", columns, key, fingerprint }),\n\t\t...[...definition.indexes].map(([name, columns]) => stageIndex({ kind: \"index\", table, name, columns })),\n\t];\n}\n\n/**\n * Migrates the table through the plan's versions (oldest first, each with its migration), the first resumed after its\n * (A) commit when the plan says so. `context`'s abort is checked between chunks (a chunk admitted to the step completes); a data\n * step that throws, or returns a patch the version cannot take, rejects: the table stays `migrating` and the committed\n * chunks stay.\n */\nasync function migrateTable(\n\tplan: Extract<TablePlan, { readonly kind: \"migrate\" }>,\n\ttarget: MigrationTarget,\n\tcontext: Context,\n): Promise<void> {\n\tfor (const [index, version] of plan.versions.entries()) {\n\t\tawait migrateVersion(version, index === 0 ? plan.first : \"begin\", target, context);\n\t}\n}\n\n/** The size of a `rows` chunk: one commit each. */\nexport const MIGRATION_CHUNK = 100;\n\n/** Migrates to `definition`'s version from its (A) commit (`begin`) or after it (`resume`). */\nasync function migrateVersion(\n\tdefinition: TableDefinition,\n\tfrom: \"begin\" | \"resume\",\n\ttarget: MigrationTarget,\n\tcontext: Context,\n): Promise<void> {\n\tconst { table } = target;\n\t// Old handles are refused from now on: their SQL must never queue behind this version's DDL.\n\tconst withdraw = target.store.announceTable(table, definition.version);\n\ttry {\n\t\tawait migrateSteps(definition, from, target, context);\n\t} finally {\n\t\twithdraw();\n\t}\n}\n\n/** The commits of `migrateVersion`. */\nasync function migrateSteps(\n\tdefinition: TableDefinition,\n\tfrom: \"begin\" | \"resume\",\n\ttarget: MigrationTarget,\n\tcontext: Context,\n): Promise<void> {\n\tconst { before, step, after } = definition.evolution!.migration;\n\tconst { table } = target;\n\tconst edits = (list: typeof before): StagedWrite[] => list.map((edit) => stageEdit(table, definition.version, edit));\n\tconst ready = [...edits(after), recordOf(definition, definition, \"ready\", table)];\n\tif (step === undefined) return commit([...edits(before), ...ready], target, context);\n\tif (from === \"begin\")\n\t\tawait commit([...edits(before), recordOf(step.table, definition, \"migrating\", table)], target, context);\n\tif (step.kind === \"update\") return commit([updateStep(step, definition.version, table), ...ready], target, context);\n\tawait rowsStep(step, definition.version, ready, target, context);\n}\n\n/** The `table` write of `table`'s columns and key, with `definition`'s version and fingerprint, in `state`. */\nfunction recordOf(\n\tcolumns: TableDefinition,\n\tdefinition: TableDefinition,\n\tstate: \"ready\" | \"migrating\",\n\ttable: string,\n): StagedWrite {\n\tconst { version, fingerprint } = definition;\n\treturn stageTable({ kind: \"table\", table, version, state, columns: columns.record, key: columns.key, fingerprint });\n}\n\n/** The `update` step: one `updateWhere` over the rows below version `v`, stamping it, so it never applies twice. */\nfunction updateStep(step: Extract<DataStep, { readonly kind: \"update\" }>, v: number, table: string): StagedWrite {\n\tconst sql = sqlOf(step.table, table);\n\tconst below: WhereNode = { lt: [ROW_VERSION, v] };\n\tconst where: WhereNode = step.where === undefined ? below : { and: [step.where, below] };\n\tconst versions = jsonVersions(step.table, step.set);\n\tconst statement = sql.updateWhere(where, { ...step.set, [ROW_VERSION]: v }, versions);\n\treturn stageUpdateWhere(statement, table, where, step.set, recordedVersions(step.set, versions), v);\n}\n\n/**\n * The `rows` step: chunks of `MIGRATION_CHUNK` rows below version `v` in key order, paging forward by the last key;\n * each patched row stamped `v`; the last chunk commits with `ready`.\n */\nasync function rowsStep(\n\tstep: Extract<DataStep, { readonly kind: \"rows\" }>,\n\tv: number,\n\tready: readonly StagedWrite[],\n\ttarget: MigrationTarget,\n\tcontext: Context,\n): Promise<void> {\n\tconst { table: columns } = step;\n\tconst sql = sqlOf(columns, target.table);\n\tconst order: Order = { columns: columns.key, direction: \"asc\" };\n\tconst below: WhereNode = { lt: [ROW_VERSION, v] };\n\tlet after: SqliteValue[] | undefined;\n\t// The fallback yield between chunks (`macrotask`), made by the first yield that needs it, closed at the end.\n\tlet channel: InstanceType<typeof MessageChannel> | undefined;\n\ttry {\n\t\tfor (;;) {\n\t\t\tconst statement = sql.select(below, order, after, MIGRATION_CHUNK + 1);\n\t\t\tconst stored = await target.store.read(\n\t\t\t\t(executor) => executor.all<{ [column: string]: SqliteValue }>(statement.sql, ...statement.params),\n\t\t\t\tcontext,\n\t\t\t);\n\t\t\tconst last = stored.length <= MIGRATION_CHUNK;\n\t\t\tif (!last) stored.length = MIGRATION_CHUNK;\n\t\t\tconst writes = stored.map((row) => patchRow(step, row, v, sql, target.table, context));\n\t\t\tif (last) return await commit([...writes, ...ready], target, context);\n\t\t\tawait commit(writes, target, context);\n\t\t\tafter = columns.key.map((name) => stored[MIGRATION_CHUNK - 1]![name]!);\n\t\t\tawait macrotask(() => {\n\t\t\t\tchannel ??= new MessageChannel();\n\t\t\t\treturn channel;\n\t\t\t});\n\t\t\t// An abandoned activation stops here.\n\t\t\tcontext.abortSignal?.throwIfAborted();\n\t\t}\n\t} finally {\n\t\tchannel?.port1.close();\n\t}\n}\n\n/**\n * Resolves after one macrotask (other commits and timers run between chunks) without the 1 ms clamp of\n * `setTimeout(0)`: `setImmediate` where the runtime has it (Node), else a message through the channel `channel()`\n * gives (browsers, Workers). In Node a message costs 0.27 ms per yield against `setImmediate`'s 13 µs (the 10k-row\n * migration bench: 100 ms against 70 ms).\n */\nfunction macrotask(channel: () => InstanceType<typeof MessageChannel>): Promise<void> {\n\treturn new Promise((resolve) => {\n\t\t// A runtime feature check: Workers and browsers have no `setImmediate`. Read once from the global, and called only\n\t\t// when it is a function: a check by name (`in`) and a later lookup could disagree.\n\t\tconst immediate = (globalThis as { readonly setImmediate?: unknown }).setImmediate;\n\t\tif (typeof immediate === \"function\") {\n\t\t\timmediate(resolve);\n\t\t\treturn;\n\t\t}\n\t\tconst { port1, port2 } = channel();\n\t\tport1.addEventListener(\"message\", () => resolve(), { once: true });\n\t\t// A port listened to with `addEventListener` delivers only once started (browsers, Workers).\n\t\tport1.start();\n\t\tport2.postMessage(null);\n\t});\n}\n\n/**\n * The write of one row's patch: `patch` run on the decoded row, its result checked (an object of non-key columns of\n * the version, values of their types) and stamped `v` through the internal form of `update`.\n */\nfunction patchRow(\n\tstep: Extract<DataStep, { readonly kind: \"rows\" }>,\n\tstored: { readonly [column: string]: SqliteValue },\n\tv: number,\n\tsql: TableSql,\n\ttable: string,\n\tcontext: Context,\n): StagedWrite {\n\tconst { table: definition } = step;\n\tconst patch = step.patch(definition.rows.decode(stored, context));\n\tconst what = `${definition.name} version ${v}: rows`;\n\tif (typeof patch !== \"object\" || patch === null || Array.isArray(patch)) {\n\t\tthrow new Error(`${what}: expected an object of column values`);\n\t}\n\tconst set: { [column: string]: SetNode[string] } = {};\n\tfor (const [name, value] of Object.entries(patch)) {\n\t\tconst column = definition.byName.get(name);\n\t\tif (column === undefined) throw new Error(`${what}: no column \"${name}\"`);\n\t\tif (definition.key.includes(name)) throw new Error(`${what}: key column \"${name}\" cannot change`);\n\t\tset[name] = cellOf(column, value, `${what}: column \"${name}\"`);\n\t}\n\tconst key: { [column: string]: Scalar } = {};\n\t// Key columns are non-opt `str` or `int`: stored scalars.\n\tfor (const name of definition.key) key[name] = stored[name] as Scalar;\n\tconst versions = jsonVersions(definition, set);\n\tconst params = definition.key.map((name) => stored[name]!);\n\tconst statement = sql.update({ ...set, [ROW_VERSION]: v }, params, versions);\n\treturn stageUpdate(statement, table, key, set, recordedVersions(set, versions), v);\n}\n\n/**\n * A patch value as a `set` node: `undefined` clears an `opt(...)` column, `json(...)` cells as JSON literals (a JSON\n * `null` too); a scalar `null` is refused by `encodeCell`.\n */\nfunction cellOf(column: Column, value: unknown, what: string): SetNode[string] {\n\tif (value === undefined) {\n\t\tif (!column.optional) throw new Error(`${what} is not opt(...) and cannot be cleared`);\n\t\treturn null;\n\t}\n\tconst cell = encodeCell(column, value, what);\n\t// `encodeCell` returns a scalar for a scalar column.\n\treturn column.type === \"json\" ? { json: cell.stored } : (cell.stored as Scalar);\n}\n\nfunction sqlOf(definition: TableDefinition, table: string): TableSql {\n\treturn new TableSql(table, definition.columns, definition.rows.physical, definition.key);\n}\n\n/** Commits `writes` without the activation's abort: a commit admitted to the step completes (the fence refuses one). */\nasync function commit(writes: StagedWrite[], target: Omit<MigrationTarget, \"table\">, context: Context): Promise<void> {\n\tawait target.store.commit(writes, target.fence, withoutAbortSignal(context));\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-writes.d.ts","sourceRoot":"","sources":["../../src/store/table-writes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE/D,OAAO,EAAkE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1G,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/D,iEAAiE;AACjE,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAE9D,mEAAmE;AACnE,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAEnE,+DAA+D;AAC/D,MAAM,MAAM,UAAU,GACnB;IACA,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;KAAE,CAAC;IAC5D,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC5B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC9G;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAC/E,yEAAyE;GACvE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GACtG;IACA,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAChC,GACD;IACA,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,yGAAyG;IACzG,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CACzB,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpG;IACA,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CACzB,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE/G,6GAA6G;AAC7G,wBAAgB,YAAY,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAOnG;AAED,oHAAoH;AACpH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc,CAIpG;AAED,yBAAyB;AACzB,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAEnF,oHAAoH;AACpH,wBAAgB,UAAU,CAAC,KAAK,EAAE,oBAAoB,GAAG,WAAW,CAEnE;AAED,+BAA+B;AAC/B,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,GAAG,WAAW,CAE9F;AAED,6GAA6G;AAC7G,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,WAAW,CAatF;AAED,yGAAyG;AACzG,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAUlG;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAC1B,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,SAAS,EACd,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,MAAM,GACd,WAAW,CAGb;AAED,kEAAkE;AAClE,wBAAgB,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,GAAG,WAAW,CAE5F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC/B,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,MAAM,GACd,WAAW,CAGb;AAED,iEAAiE;AACjE,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,WAAW,CAEnG;AAaD,2GAA2G;AAC3G,wBAAsB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,CAM7F;AAED,uEAAuE;AACvE,wBAAsB,UAAU,CAC/B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,GACpD,OAAO,CAAC,UAAU,CAAC,CAKrB;AAED,2EAA2E;AAC3E,wBAAsB,cAAc,CACnC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC,GACxD,OAAO,CAAC,UAAU,CAAC,CAMrB;AAED,oHAAoH;AACpH,wBAAsB,UAAU,CAC/B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC,GACpD,OAAO,CAAC,UAAU,CAAC,CA0CrB"}

package/dist/store/table-writes.js

@@ -0,0 +1,170 @@
+// Table writes (slice 6a §5, §7, §9; S17; decisions "Writes carry their versions", "Index definitions are recorded"):
+// the recorded form of every table write, the staged writes a transaction or an activation hands the commit step
+// (their SQL rendered at staging, rule 8), and the appliers of the schema writes, which render DDL from the record.
+import { versionColumn } from "./rows.js";
+import { columnSql, createIndexSql, createTableSql, dropIndexSql, quote } from "./sql.js";
+/** The versions of the `json(...)` columns of `definition` that `set` writes, which its statement stamps. */
+export function jsonVersions(definition, set) {
+    const versions = new Map();
+    for (const name of Object.keys(set)) {
+        const column = definition.byName.get(name);
+        if (column.type === "json")
+            versions.set(name, column.json.version);
+    }
+    return versions;
+}
+/** The `columns` a write records: the versions of the `json(...)` columns it sets to a value (a clear has none). */
+export function recordedVersions(set, versions) {
+    const columns = {};
+    for (const [column, version] of versions)
+        if (set[column] !== null)
+            columns[column] = version;
+    return columns;
+}
+/** Stages a `table` write: the table created when the store does not have it yet, its record replaced otherwise. */
+export function stageTable(write) {
+    return { order: "write", apply: async (step) => [await applyTable(step, write)] };
+}
+/** Stages an `index` write. */
+export function stageIndex(write) {
+    return { order: "write", apply: async (step) => [await applyIndex(step, write)] };
+}
+/** Stages one edit of the migration of `table` to `version` as its `alter`, `index` or `dropIndex` write. */
+export function stageEdit(table, version, edit) {
+    switch (edit.kind) {
+        case "index":
+            return stageIndex({ kind: "index", table, name: edit.name, columns: edit.columns });
+        case "dropIndex": {
+            const write = { kind: "dropIndex", table, name: edit.name };
+            return { order: "write", apply: async (step) => [await applyDropIndex(step, write)] };
+        }
+        default: {
+            const write = { kind: "alter", table, version, edit };
+            return { order: "write", apply: async (step) => [await applyAlter(step, write)] };
+        }
+    }
+}
+/** Stages a `put` of an encoded row with its `INSERT OR REPLACE` (an upsert: the whole row replaced). */
+export function stagePut(sql, table, row, version) {
+    const write = { kind: "put", table, row: row.row, version, columns: row.columns };
+    return {
+        order: "write",
+        apply: async (step) => {
+            await step.run(sql, ...row.params);
+            step.rows++;
+            return [write];
+        },
+    };
+}
+/**
+ * Stages an `update` of one row by key; its count (0 for an absent key) is recorded, and `version` when the statement stamps
+ * the row's `$v` (a migration's `rows` step).
+ */
+export function stageUpdate(statement, table, key, set, columns, version) {
+    const stamped = version === undefined ? {} : { version };
+    return counted(statement, (count) => ({ kind: "update", table, key, set, columns, count, ...stamped }));
+}
+/** Stages a `delete` of one row by key; its count is recorded. */
+export function stageDelete(statement, table, key) {
+    return counted(statement, (count) => ({ kind: "delete", table, key, count }));
+}
+/**
+ * Stages an `updateWhere`: one statement, its count recorded (a replica affecting another count stops, S17), and `version`
+ * when it stamps the rows' `$v` (a migration's `update` step).
+ */
+export function stageUpdateWhere(statement, table, where, set, columns, version) {
+    const stamped = version === undefined ? {} : { version };
+    return counted(statement, (count) => ({ kind: "updateWhere", table, where, set, columns, count, ...stamped }));
+}
+/** Stages a `deleteWhere`: one statement, its count recorded. */
+export function stageDeleteWhere(statement, table, where) {
+    return counted(statement, (count) => ({ kind: "deleteWhere", table, where, count }));
+}
+function counted(statement, record) {
+    return {
+        order: "write",
+        apply: async (step) => {
+            const count = await step.runCounted(statement.sql, ...statement.params);
+            step.rows += count;
+            return [record(count)];
+        },
+    };
+}
+/** Applies a `table` write: `CREATE TABLE` when the store does not have the table yet, then its record. */
+export async function applyTable(step, write) {
+    const existing = step.table(write.table);
+    if (existing === undefined)
+        await step.run(createTableSql(write.table, write.columns, write.key));
+    const { table, version, state, columns, key, fingerprint } = write;
+    step.tables.set(table, { table, version, state, columns, key, fingerprint, indexes: existing?.indexes ?? {} });
+    return write;
+}
+/** Applies an `index` write: `CREATE INDEX` and the record's index. */
+export async function applyIndex(step, write) {
+    const existing = recorded(step, write.table);
+    await step.run(createIndexSql(write.table, write.name, write.columns, existing.key));
+    step.tables.set(write.table, { ...existing, indexes: { ...existing.indexes, [write.name]: write.columns } });
+    return write;
+}
+/** Applies a `dropIndex` write: `DROP INDEX` and the record without it. */
+export async function applyDropIndex(step, write) {
+    const existing = recorded(step, write.table);
+    await step.run(dropIndexSql(write.table, write.name));
+    const { [write.name]: _dropped, ...indexes } = existing.indexes;
+    step.tables.set(write.table, { ...existing, indexes });
+    return write;
+}
+/** Applies an `alter` write: its DDL (a `json(...)` column's version column follows it) and the record's change. */
+export async function applyAlter(step, write) {
+    const existing = recorded(step, write.table);
+    const { edit } = write;
+    const id = quote(write.table);
+    switch (edit.kind) {
+        case "rename": {
+            const json = existing.columns[edit.from]?.type === "json";
+            await step.run(`ALTER TABLE ${id} RENAME COLUMN ${quote(edit.from)} TO ${quote(edit.to)}`);
+            if (json) {
+                const [from, to] = [versionColumn(edit.from), versionColumn(edit.to)];
+                await step.run(`ALTER TABLE ${id} RENAME COLUMN ${quote(from)} TO ${quote(to)}`);
+            }
+            const rename = (column) => (column === edit.from ? edit.to : column);
+            const columns = Object.entries(existing.columns).map(([name, column]) => [rename(name), column]);
+            const indexes = Object.entries(existing.indexes).map(([name, on]) => [name, on.map(rename)]);
+            step.tables.set(write.table, {
+                ...existing,
+                columns: Object.fromEntries(columns),
+                key: existing.key.map(rename),
+                indexes: Object.fromEntries(indexes),
+            });
+            break;
+        }
+        case "add":
+            for (const definition of columnSql(edit.name, edit.column)) {
+                await step.run(`ALTER TABLE ${id} ADD COLUMN ${definition}`);
+            }
+            step.tables.set(write.table, { ...existing, columns: { ...existing.columns, [edit.name]: edit.column } });
+            break;
+        case "drop": {
+            const json = existing.columns[edit.name]?.type === "json";
+            await step.run(`ALTER TABLE ${id} DROP COLUMN ${quote(edit.name)}`);
+            if (json)
+                await step.run(`ALTER TABLE ${id} DROP COLUMN ${quote(versionColumn(edit.name))}`);
+            const { [edit.name]: _dropped, ...columns } = existing.columns;
+            step.tables.set(write.table, { ...existing, columns });
+            break;
+        }
+        case "json":
+            step.tables.set(write.table, { ...existing, columns: { ...existing.columns, [edit.name]: edit.column } });
+            break;
+    }
+    return write;
+}
+/** The record of `table` in `step`; a write for a table the store does not have fails the step. */
+function recorded(step, table) {
+    const record = step.table(table);
+    // Memory and disk disagree: the step fails, which stops the store.
+    if (record === undefined)
+        throw new Error(`table ${table}: not in the store`);
+    return record;
+}
+//# sourceMappingURL=table-writes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-writes.js","sourceRoot":"","sources":["../../src/store/table-writes.ts"],"names":[],"mappings":"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","sourcesContent":["// Table writes (slice 6a §5, §7, §9; S17; decisions \"Writes carry their versions\", \"Index definitions are recorded\"):\n// the recorded form of every table write, the staged writes a transaction or an activation hands the commit step\n// (their SQL rendered at staging, rule 8), and the appliers of the schema writes, which render DDL from the record.\n\nimport type { TableRecord } from \"./catalog.ts\";\nimport type { ColumnRecord } from \"./columns.ts\";\nimport type { SetNode, WhereNode } from \"./expression.ts\";\nimport type { EncodedRow, Scalar, StoredRow } from \"./rows.ts\";\nimport { versionColumn } from \"./rows.ts\";\nimport { columnSql, createIndexSql, createTableSql, dropIndexSql, quote, type Statement } from \"./sql.ts\";\nimport type { StagedWrite, Step } from \"./step.ts\";\nimport type { TableDefinition } from \"./table.ts\";\nimport type { AlterEdit, TableEdit } from \"./table-history.ts\";\n\n/** A key as writes record it: the key columns' stored values. */\nexport type StoredKey = { readonly [column: string]: Scalar };\n\n/** `json(...)` columns' versions written by a write, by column. */\nexport type ColumnVersions = { readonly [column: string]: number };\n\n/** The table writes as the outbox and archives record them. */\nexport type TableWrite =\n\t| {\n\t\t\treadonly kind: \"table\";\n\t\t\treadonly table: string;\n\t\t\treadonly version: number;\n\t\t\treadonly state: \"ready\" | \"migrating\";\n\t\t\treadonly columns: { readonly [name: string]: ColumnRecord };\n\t\t\treadonly key: readonly string[];\n\t\t\treadonly fingerprint: string;\n\t  }\n\t| { readonly kind: \"index\"; readonly table: string; readonly name: string; readonly columns: readonly string[] }\n\t| { readonly kind: \"dropIndex\"; readonly table: string; readonly name: string }\n\t/** A column edit of the migration to `version`; DDL rendered from it. */\n\t| { readonly kind: \"alter\"; readonly table: string; readonly version: number; readonly edit: AlterEdit }\n\t| {\n\t\t\treadonly kind: \"put\";\n\t\t\treadonly table: string;\n\t\t\treadonly row: StoredRow;\n\t\t\t/** The row's eager-step version (the table's version at the `put`). */\n\t\t\treadonly version: number;\n\t\t\treadonly columns: ColumnVersions;\n\t  }\n\t| {\n\t\t\treadonly kind: \"update\";\n\t\t\treadonly table: string;\n\t\t\treadonly key: StoredKey;\n\t\t\treadonly set: SetNode;\n\t\t\treadonly columns: ColumnVersions;\n\t\t\treadonly count: number;\n\t\t\t/** A migration's data step: the version it stamps as the row's `$v` (a plugin's `update` never does). */\n\t\t\treadonly version?: number;\n\t  }\n\t| { readonly kind: \"delete\"; readonly table: string; readonly key: StoredKey; readonly count: number }\n\t| {\n\t\t\treadonly kind: \"updateWhere\";\n\t\t\treadonly table: string;\n\t\t\treadonly where: WhereNode;\n\t\t\treadonly set: SetNode;\n\t\t\treadonly columns: ColumnVersions;\n\t\t\treadonly count: number;\n\t\t\t/** A migration's `update` step: the version it stamps as the rows' `$v`. */\n\t\t\treadonly version?: number;\n\t  }\n\t| { readonly kind: \"deleteWhere\"; readonly table: string; readonly where: WhereNode; readonly count: number };\n\n/** The versions of the `json(...)` columns of `definition` that `set` writes, which its statement stamps. */\nexport function jsonVersions(definition: TableDefinition, set: SetNode): ReadonlyMap<string, number> {\n\tconst versions = new Map<string, number>();\n\tfor (const name of Object.keys(set)) {\n\t\tconst column = definition.byName.get(name)!;\n\t\tif (column.type === \"json\") versions.set(name, column.json.version);\n\t}\n\treturn versions;\n}\n\n/** The `columns` a write records: the versions of the `json(...)` columns it sets to a value (a clear has none). */\nexport function recordedVersions(set: SetNode, versions: ReadonlyMap<string, number>): ColumnVersions {\n\tconst columns: { [column: string]: number } = {};\n\tfor (const [column, version] of versions) if (set[column] !== null) columns[column] = version;\n\treturn columns;\n}\n\n/** The `table` write. */\nexport type TableDefinitionWrite = Extract<TableWrite, { readonly kind: \"table\" }>;\n\n/** Stages a `table` write: the table created when the store does not have it yet, its record replaced otherwise. */\nexport function stageTable(write: TableDefinitionWrite): StagedWrite {\n\treturn { order: \"write\", apply: async (step) => [await applyTable(step, write)] };\n}\n\n/** Stages an `index` write. */\nexport function stageIndex(write: Extract<TableWrite, { readonly kind: \"index\" }>): StagedWrite {\n\treturn { order: \"write\", apply: async (step) => [await applyIndex(step, write)] };\n}\n\n/** Stages one edit of the migration of `table` to `version` as its `alter`, `index` or `dropIndex` write. */\nexport function stageEdit(table: string, version: number, edit: TableEdit): StagedWrite {\n\tswitch (edit.kind) {\n\t\tcase \"index\":\n\t\t\treturn stageIndex({ kind: \"index\", table, name: edit.name, columns: edit.columns });\n\t\tcase \"dropIndex\": {\n\t\t\tconst write = { kind: \"dropIndex\", table, name: edit.name } as const;\n\t\t\treturn { order: \"write\", apply: async (step) => [await applyDropIndex(step, write)] };\n\t\t}\n\t\tdefault: {\n\t\t\tconst write = { kind: \"alter\", table, version, edit } as const;\n\t\t\treturn { order: \"write\", apply: async (step) => [await applyAlter(step, write)] };\n\t\t}\n\t}\n}\n\n/** Stages a `put` of an encoded row with its `INSERT OR REPLACE` (an upsert: the whole row replaced). */\nexport function stagePut(sql: string, table: string, row: EncodedRow, version: number): StagedWrite {\n\tconst write: TableWrite = { kind: \"put\", table, row: row.row, version, columns: row.columns };\n\treturn {\n\t\torder: \"write\",\n\t\tapply: async (step) => {\n\t\t\tawait step.run(sql, ...row.params);\n\t\t\tstep.rows++;\n\t\t\treturn [write];\n\t\t},\n\t};\n}\n\n/**\n * Stages an `update` of one row by key; its count (0 for an absent key) is recorded, and `version` when the statement stamps\n * the row's `$v` (a migration's `rows` step).\n */\nexport function stageUpdate(\n\tstatement: Statement,\n\ttable: string,\n\tkey: StoredKey,\n\tset: SetNode,\n\tcolumns: ColumnVersions,\n\tversion?: number,\n): StagedWrite {\n\tconst stamped = version === undefined ? {} : { version };\n\treturn counted(statement, (count) => ({ kind: \"update\", table, key, set, columns, count, ...stamped }));\n}\n\n/** Stages a `delete` of one row by key; its count is recorded. */\nexport function stageDelete(statement: Statement, table: string, key: StoredKey): StagedWrite {\n\treturn counted(statement, (count) => ({ kind: \"delete\", table, key, count }));\n}\n\n/**\n * Stages an `updateWhere`: one statement, its count recorded (a replica affecting another count stops, S17), and `version`\n * when it stamps the rows' `$v` (a migration's `update` step).\n */\nexport function stageUpdateWhere(\n\tstatement: Statement,\n\ttable: string,\n\twhere: WhereNode,\n\tset: SetNode,\n\tcolumns: ColumnVersions,\n\tversion?: number,\n): StagedWrite {\n\tconst stamped = version === undefined ? {} : { version };\n\treturn counted(statement, (count) => ({ kind: \"updateWhere\", table, where, set, columns, count, ...stamped }));\n}\n\n/** Stages a `deleteWhere`: one statement, its count recorded. */\nexport function stageDeleteWhere(statement: Statement, table: string, where: WhereNode): StagedWrite {\n\treturn counted(statement, (count) => ({ kind: \"deleteWhere\", table, where, count }));\n}\n\nfunction counted(statement: Statement, record: (count: number) => TableWrite): StagedWrite {\n\treturn {\n\t\torder: \"write\",\n\t\tapply: async (step) => {\n\t\t\tconst count = await step.runCounted(statement.sql, ...statement.params);\n\t\t\tstep.rows += count;\n\t\t\treturn [record(count)];\n\t\t},\n\t};\n}\n\n/** Applies a `table` write: `CREATE TABLE` when the store does not have the table yet, then its record. */\nexport async function applyTable(step: Step, write: TableDefinitionWrite): Promise<TableWrite> {\n\tconst existing = step.table(write.table);\n\tif (existing === undefined) await step.run(createTableSql(write.table, write.columns, write.key));\n\tconst { table, version, state, columns, key, fingerprint } = write;\n\tstep.tables.set(table, { table, version, state, columns, key, fingerprint, indexes: existing?.indexes ?? {} });\n\treturn write;\n}\n\n/** Applies an `index` write: `CREATE INDEX` and the record's index. */\nexport async function applyIndex(\n\tstep: Step,\n\twrite: Extract<TableWrite, { readonly kind: \"index\" }>,\n): Promise<TableWrite> {\n\tconst existing = recorded(step, write.table);\n\tawait step.run(createIndexSql(write.table, write.name, write.columns, existing.key));\n\tstep.tables.set(write.table, { ...existing, indexes: { ...existing.indexes, [write.name]: write.columns } });\n\treturn write;\n}\n\n/** Applies a `dropIndex` write: `DROP INDEX` and the record without it. */\nexport async function applyDropIndex(\n\tstep: Step,\n\twrite: Extract<TableWrite, { readonly kind: \"dropIndex\" }>,\n): Promise<TableWrite> {\n\tconst existing = recorded(step, write.table);\n\tawait step.run(dropIndexSql(write.table, write.name));\n\tconst { [write.name]: _dropped, ...indexes } = existing.indexes;\n\tstep.tables.set(write.table, { ...existing, indexes });\n\treturn write;\n}\n\n/** Applies an `alter` write: its DDL (a `json(...)` column's version column follows it) and the record's change. */\nexport async function applyAlter(\n\tstep: Step,\n\twrite: Extract<TableWrite, { readonly kind: \"alter\" }>,\n): Promise<TableWrite> {\n\tconst existing = recorded(step, write.table);\n\tconst { edit } = write;\n\tconst id = quote(write.table);\n\tswitch (edit.kind) {\n\t\tcase \"rename\": {\n\t\t\tconst json = existing.columns[edit.from]?.type === \"json\";\n\t\t\tawait step.run(`ALTER TABLE ${id} RENAME COLUMN ${quote(edit.from)} TO ${quote(edit.to)}`);\n\t\t\tif (json) {\n\t\t\t\tconst [from, to] = [versionColumn(edit.from), versionColumn(edit.to)];\n\t\t\t\tawait step.run(`ALTER TABLE ${id} RENAME COLUMN ${quote(from)} TO ${quote(to)}`);\n\t\t\t}\n\t\t\tconst rename = (column: string): string => (column === edit.from ? edit.to : column);\n\t\t\tconst columns = Object.entries(existing.columns).map(([name, column]) => [rename(name), column] as const);\n\t\t\tconst indexes = Object.entries(existing.indexes).map(([name, on]) => [name, on.map(rename)] as const);\n\t\t\tstep.tables.set(write.table, {\n\t\t\t\t...existing,\n\t\t\t\tcolumns: Object.fromEntries(columns),\n\t\t\t\tkey: existing.key.map(rename),\n\t\t\t\tindexes: Object.fromEntries(indexes),\n\t\t\t});\n\t\t\tbreak;\n\t\t}\n\t\tcase \"add\":\n\t\t\tfor (const definition of columnSql(edit.name, edit.column)) {\n\t\t\t\tawait step.run(`ALTER TABLE ${id} ADD COLUMN ${definition}`);\n\t\t\t}\n\t\t\tstep.tables.set(write.table, { ...existing, columns: { ...existing.columns, [edit.name]: edit.column } });\n\t\t\tbreak;\n\t\tcase \"drop\": {\n\t\t\tconst json = existing.columns[edit.name]?.type === \"json\";\n\t\t\tawait step.run(`ALTER TABLE ${id} DROP COLUMN ${quote(edit.name)}`);\n\t\t\tif (json) await step.run(`ALTER TABLE ${id} DROP COLUMN ${quote(versionColumn(edit.name))}`);\n\t\t\tconst { [edit.name]: _dropped, ...columns } = existing.columns;\n\t\t\tstep.tables.set(write.table, { ...existing, columns });\n\t\t\tbreak;\n\t\t}\n\t\tcase \"json\":\n\t\t\tstep.tables.set(write.table, { ...existing, columns: { ...existing.columns, [edit.name]: edit.column } });\n\t\t\tbreak;\n\t}\n\treturn write;\n}\n\n/** The record of `table` in `step`; a write for a table the store does not have fails the step. */\nfunction recorded(step: Step, table: string): TableRecord {\n\tconst record = step.table(table);\n\t// Memory and disk disagree: the step fails, which stops the store.\n\tif (record === undefined) throw new Error(`table ${table}: not in the store`);\n\treturn record;\n}\n"]}

package/dist/store/table.d.ts

@@ -0,0 +1,80 @@
+import { type Column, type ColumnRecord, type Columns, type OrderColumn } from "./columns.ts";
+import { type ColumnRef } from "./expression.ts";
+import { RowCodec } from "./rows.ts";
+import type { Migration } from "./table-history.ts";
+/** What `defineTable` takes. */
+export type TableOptions<C extends Columns, K extends readonly OrderColumn<C>[], V extends number = number> = {
+    /** The table's version: a positive integer, raised by every change (`evolveTable`). */
+    readonly version: V;
+    readonly columns: C;
+    /** The primary key's columns, non-`opt` `str` or `int` ones. */
+    readonly key: K;
+    /** Secondary indexes by name (`[a-z0-9_]+`); each ends with the primary key. */
+    readonly indexes?: {
+        readonly [name: string]: readonly OrderColumn<C>[];
+    };
+};
+/** The key of a row of a table with columns `C` and key `K`: an object with exactly the key columns. */
+export type KeyOf<C extends Columns, K extends readonly string[]> = {
+    readonly [P in K[number]]: P extends keyof C ? (C[P] extends {
+        readonly type: "integer";
+    } ? number : string) : never;
+};
+/**
+ * Declares a table: a base version written in full, the first of its history. Later versions come from
+ * `evolveTable`; a new base starts a new history.
+ */
+export declare function defineTable<C extends Columns, const K extends readonly OrderColumn<C>[], const V extends number>(name: string, options: TableOptions<C, K, V>): TableDefinition<C, K, V>;
+/** The table form's version: the fingerprints of table definitions are persisted, so their input is versioned. */
+export declare const TABLE_FORM_VERSION = 1;
+/** The index name rule. */
+export declare const INDEX_NAME: RegExp;
+/** How a version came about: the version before it and the migration from there, for one `evolveTable`. */
+export type Evolution = {
+    readonly previous: TableDefinition;
+    readonly migration: Migration;
+};
+/**
+ * A declared table at one version: its columns in declaration order, key, indexes (declared columns; the key is
+ * appended when they are rendered), the fingerprint of all of it and the row codec. `C` and `K` type its rows and keys,
+ * `V` its version.
+ */
+export declare class TableDefinition<C extends Columns = Columns, K extends readonly string[] = readonly string[], V extends number = number> {
+    readonly name: string;
+    readonly version: V;
+    /** The column schemas as declared, which `evolveTable` edits into the next version's. */
+    readonly schemas: Columns;
+    readonly columns: readonly Column[];
+    readonly byName: ReadonlyMap<string, Column>;
+    readonly key: readonly string[];
+    readonly indexes: ReadonlyMap<string, readonly string[]>;
+    /** `hash64` of the columns, key and indexes in `TABLE_FORM_VERSION`'s form. */
+    readonly fingerprint: string;
+    /** The columns as the `table` write records them. */
+    readonly record: {
+        readonly [name: string]: ColumnRecord;
+    };
+    readonly rows: RowCodec;
+    /** One reference per column, for the `(t) => …` callbacks of queries and writes. */
+    readonly refs: {
+        readonly [column: string]: ColumnRef;
+    };
+    /** The version before this one and the migration from it; `undefined` for a base. */
+    readonly evolution: Evolution | undefined;
+    /** Type only: the columns and key. */
+    readonly "~columns"?: C;
+    readonly "~key"?: K;
+    constructor(name: string, options: TableOptions<C, K & readonly OrderColumn<C>[], V>, evolution?: Evolution);
+    /** The column `name`; an unknown one throws (`what` names the use). */
+    column(name: string, what: string): Column;
+}
+/**
+ * Checks `names` as key, index or order columns of a table whose columns are `byName`: existing, non-`opt` `str` or
+ * `int`, no column twice (declaration policy: JavaScript callers reach it); `what` names the use in errors.
+ */
+export declare function orderColumns(byName: ReadonlyMap<string, Column>, names: readonly string[], what: string): readonly string[];
+/** The fingerprint of a table's columns, key and indexes; column and index names sorted (their order is no change). */
+export declare function tableFingerprint(columns: {
+    readonly [name: string]: ColumnRecord;
+}, key: readonly string[], indexes: ReadonlyMap<string, readonly string[]>): string;
+//# sourceMappingURL=table.d.ts.map

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

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

package/dist/store/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sourceRoot":"","sources":["../../src/store/table.ts"],"names":[],"mappings":"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","sourcesContent":["// Table definitions (slice 6a §5, §9; decisions \"Flat columns\", \"Restricted names\", \"Index definitions are recorded\"):\n// `defineTable(name, { version, columns, key, indexes? })`, checked and materialized once at declaration: its columns,\n// its key, its indexes, its fingerprint and the compiled row codec its writes and reads use. A version `evolveTable`\n// appends links to the one before it and to the migration between them.\n\nimport { checkName, hash64 } from \"../contracts/internal.ts\";\nimport {\n\ttype Column,\n\ttype ColumnRecord,\n\ttype Columns,\n\tcolumnRecord,\n\tdescribeColumns,\n\ttype OrderColumn,\n} from \"./columns.ts\";\nimport { type ColumnRef, columnRefs } from \"./expression.ts\";\nimport { RowCodec } from \"./rows.ts\";\nimport type { Migration } from \"./table-history.ts\";\n\n/** What `defineTable` takes. */\nexport type TableOptions<C extends Columns, K extends readonly OrderColumn<C>[], V extends number = number> = {\n\t/** The table's version: a positive integer, raised by every change (`evolveTable`). */\n\treadonly version: V;\n\treadonly columns: C;\n\t/** The primary key's columns, non-`opt` `str` or `int` ones. */\n\treadonly key: K;\n\t/** Secondary indexes by name (`[a-z0-9_]+`); each ends with the primary key. */\n\treadonly indexes?: { readonly [name: string]: readonly OrderColumn<C>[] };\n};\n\n/** The key of a row of a table with columns `C` and key `K`: an object with exactly the key columns. */\nexport type KeyOf<C extends Columns, K extends readonly string[]> = {\n\treadonly [P in K[number]]: P extends keyof C ? (C[P] extends { readonly type: \"integer\" } ? number : string) : never;\n};\n\n/**\n * Declares a table: a base version written in full, the first of its history. Later versions come from\n * `evolveTable`; a new base starts a new history.\n */\nexport function defineTable<C extends Columns, const K extends readonly OrderColumn<C>[], const V extends number>(\n\tname: string,\n\toptions: TableOptions<C, K, V>,\n): TableDefinition<C, K, V> {\n\treturn new TableDefinition(name, options);\n}\n\n/** The table form's version: the fingerprints of table definitions are persisted, so their input is versioned. */\nexport const TABLE_FORM_VERSION = 1;\n\n/** The index name rule. */\nexport const INDEX_NAME = /^[a-z0-9_]+$/;\n\n/** How a version came about: the version before it and the migration from there, for one `evolveTable`. */\nexport type Evolution = { readonly previous: TableDefinition; readonly migration: Migration };\n\n/**\n * A declared table at one version: its columns in declaration order, key, indexes (declared columns; the key is\n * appended when they are rendered), the fingerprint of all of it and the row codec. `C` and `K` type its rows and keys,\n * `V` its version.\n */\nexport class TableDefinition<\n\tC extends Columns = Columns,\n\tK extends readonly string[] = readonly string[],\n\tV extends number = number,\n> {\n\treadonly name: string;\n\treadonly version: V;\n\t/** The column schemas as declared, which `evolveTable` edits into the next version's. */\n\treadonly schemas: Columns;\n\treadonly columns: readonly Column[];\n\treadonly byName: ReadonlyMap<string, Column>;\n\treadonly key: readonly string[];\n\treadonly indexes: ReadonlyMap<string, readonly string[]>;\n\t/** `hash64` of the columns, key and indexes in `TABLE_FORM_VERSION`'s form. */\n\treadonly fingerprint: string;\n\t/** The columns as the `table` write records them. */\n\treadonly record: { readonly [name: string]: ColumnRecord };\n\treadonly rows: RowCodec;\n\t/** One reference per column, for the `(t) => …` callbacks of queries and writes. */\n\treadonly refs: { readonly [column: string]: ColumnRef };\n\t/** The version before this one and the migration from it; `undefined` for a base. */\n\treadonly evolution: Evolution | undefined;\n\t/** Type only: the columns and key. */\n\tdeclare readonly \"~columns\"?: C;\n\tdeclare readonly \"~key\"?: K;\n\n\tconstructor(name: string, options: TableOptions<C, K & readonly OrderColumn<C>[], V>, evolution?: Evolution) {\n\t\tcheckName(name, \"table\");\n\t\tconst { version, columns, key, indexes = {} } = options;\n\t\t// Declaration policy: JavaScript callers reach these checks.\n\t\tif (!Number.isSafeInteger(version) || version < 1)\n\t\t\tthrow new Error(`${name}: version ${version} is not a positive integer`);\n\t\tthis.name = name;\n\t\tthis.version = version;\n\t\tthis.schemas = columns;\n\t\tthis.columns = describeColumns(columns, name);\n\t\tthis.byName = new Map(this.columns.map((column) => [column.name, column]));\n\t\tthis.key = orderColumns(this.byName, key, `${name}: the key`);\n\t\tif (this.key.length === 0) throw new Error(`${name}: the key has no column`);\n\t\tthis.indexes = new Map(\n\t\t\tObject.entries(indexes).map(([index, columns]) => {\n\t\t\t\tif (!INDEX_NAME.test(index)) throw new Error(`${name}: index \"${index}\": expected [a-z0-9_]+`);\n\t\t\t\treturn [index, orderColumns(this.byName, columns, `${name}: index \"${index}\"`)] as const;\n\t\t\t}),\n\t\t);\n\t\tthis.record = Object.fromEntries(this.columns.map((column) => [column.name, columnRecord(column)]));\n\t\tthis.fingerprint = tableFingerprint(this.record, this.key, this.indexes);\n\t\tthis.rows = new RowCodec(this.columns, this.key, name);\n\t\tthis.refs = columnRefs(this.columns);\n\t\tthis.evolution = evolution;\n\t}\n\n\t/** The column `name`; an unknown one throws (`what` names the use). */\n\tcolumn(name: string, what: string): Column {\n\t\tconst column = this.byName.get(name);\n\t\tif (column === undefined) throw new Error(`${this.name}: ${what}: no column \"${name}\"`);\n\t\treturn column;\n\t}\n}\n\n/**\n * Checks `names` as key, index or order columns of a table whose columns are `byName`: existing, non-`opt` `str` or\n * `int`, no column twice (declaration policy: JavaScript callers reach it); `what` names the use in errors.\n */\nexport function orderColumns(\n\tbyName: ReadonlyMap<string, Column>,\n\tnames: readonly string[],\n\twhat: string,\n): readonly string[] {\n\tif (!Array.isArray(names)) throw new Error(`${what}: expected an array of column names`);\n\tif (new Set(names).size !== names.length) throw new Error(`${what}: a column occurs twice`);\n\tfor (const name of names) {\n\t\tconst column = byName.get(name);\n\t\tif (column === undefined) throw new Error(`${what}: no column \"${name}\"`);\n\t\tif (column.optional || (column.type !== \"str\" && column.type !== \"int\")) {\n\t\t\tthrow new Error(`${what}: column \"${name}\" is not a non-opt str() or int() column`);\n\t\t}\n\t}\n\treturn [...names];\n}\n\n/** The fingerprint of a table's columns, key and indexes; column and index names sorted (their order is no change). */\nexport function tableFingerprint(\n\tcolumns: { readonly [name: string]: ColumnRecord },\n\tkey: readonly string[],\n\tindexes: ReadonlyMap<string, readonly string[]>,\n): string {\n\tconst value = { columns: sorted(Object.entries(columns)), key, indexes: sorted([...indexes]) };\n\treturn hash64(JSON.stringify({ tableFormVersion: TABLE_FORM_VERSION, value }));\n}\n\nfunction sorted<T>(entries: [string, T][]): { [name: string]: T } {\n\treturn Object.fromEntries(entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));\n}\n"]}

package/dist/store/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/store/text.ts"],"names":[],"mappings":"AAMA,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAQxD;AAWD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAUnE"}

package/dist/store/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../src/store/text.ts"],"names":[],"mappings":"AAAA,oHAAoH;AACpH,qHAAqH;AACrH,mFAAmF;AAEnF,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,sEAAsE;AACtE,MAAM,UAAU,WAAW,CAAC,CAAS,EAAE,CAAS;IAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACjC,MAAM,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC1B,MAAM,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC1B,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;AAC5B,CAAC;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,IAAY;IAClC,IAAI,IAAI,GAAG,MAAM;QAAE,OAAO,IAAI,CAAC;IAC/B,OAAO,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,KAAK,CAAC;AACrD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,IAAY;IACpD,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,MAAM,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,4BAA4B,CAAC,CAAC;IACpF,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;AACzD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC9C,MAAM,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;IAC3B,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,EAAG,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC;QAC3C,IAAI,IAAI,KAAK,QAAQ;YAAE,SAAS;QAChC,oFAAoF;QACpF,MAAM,IAAI,GAAG,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;QACjD,OAAO,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,SAAS,CAAC;AAClB,CAAC","sourcesContent":["// Text in the store (decision \"Text is plain UTF-8, in code point order\"): Chord compares strings by code point, as\n// SQLite's BINARY collation compares their UTF-8 bytes, never by JavaScript's UTF-16 code units; every stored string\n// is well-formed and free of NUL, and a prefix becomes a range by its upper bound.\n\nimport { invalid } from \"../data/internal.ts\";\n\n/** Compares `a` and `b` by code point: negative, zero or positive. */\nexport function compareText(a: string, b: string): number {\n\tconst length = Math.min(a.length, b.length);\n\tfor (let i = 0; i < length; i++) {\n\t\tconst x = a.charCodeAt(i);\n\t\tconst y = b.charCodeAt(i);\n\t\tif (x !== y) return codePointRank(x) - codePointRank(y);\n\t}\n\treturn a.length - b.length;\n}\n\n/**\n * A UTF-16 code unit's rank in code point order: a surrogate starts a code point above U+FFFF, so it ranks above every\n * unit from U+E000 on.\n */\nfunction codePointRank(unit: number): number {\n\tif (unit < 0xd800) return unit;\n\treturn unit < 0xe000 ? unit + 0x2000 : unit - 0x800;\n}\n\n/**\n * `text` as the store keeps it: a lone surrogate replaced by U+FFFD (copied only when one occurs), NUL refused\n * `invalid/args` (`what` names the value). Plugin strings are a trust boundary.\n */\nexport function storedText(text: string, what: string): string {\n\tif (text.includes(\"\\0\")) throw invalid(\"args\", `${what}: text may not contain NUL`);\n\treturn text.isWellFormed() ? text : text.toWellFormed();\n}\n\n/**\n * The smallest string above every string starting with `prefix`, in code point order: the next code point after its\n * last, carrying past U+10FFFF; `undefined` when there is none (`\"\"` and all-U+10FFFF prefixes). `prefix` is\n * well-formed.\n */\nexport function prefixUpperBound(prefix: string): string | undefined {\n\tconst points = [...prefix];\n\twhile (points.length > 0) {\n\t\tconst last = points.pop()!.codePointAt(0)!;\n\t\tif (last === 0x10ffff) continue;\n\t\t// The surrogates are no code points of well-formed text: after U+D7FF comes U+E000.\n\t\tconst next = last === 0xd7ff ? 0xe000 : last + 1;\n\t\treturn points.join(\"\") + String.fromCodePoint(next);\n\t}\n\treturn undefined;\n}\n"]}

package/dist/store/writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writes.d.ts","sourceRoot":"","sources":["../../src/store/writes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,iDAAiD;AACjD,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,UAAU,CAAC"}

package/dist/store/writes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writes.js","sourceRoot":"","sources":["../../src/store/writes.ts"],"names":[],"mappings":"AAAA,sHAAsH;AACtH,wDAAwD","sourcesContent":["// The store's write vocabulary (`StoreWrite`, slice 6a §7, §8; decision \"Writes carry their versions\"): one change of\n// the store each, as the outbox and archives record it.\n\nimport type { DocumentWrite } from \"./engine.ts\";\nimport type { TableWrite } from \"./table-writes.ts\";\n\n/** One change of the store, tagged by `kind`. */\nexport type StoreWrite = DocumentWrite | TableWrite;\n"]}