@substrat-run/kernel 0.126.0 → 0.128.0

package/dist/spine-restore.d.ts

@@ -0,0 +1,82 @@
+/**
+ * How a restore, fork or carry loads a dump's `_substrat_*` spine tables (#1883). One
+ * definition for both adapters' loaders, so the DO and the pure host build the same tables
+ * from the same dump.
+ *
+ * A dump used to be replayed table by table, `CREATE TABLE` from the dump and then its rows,
+ * spine included; the kernel's `CREATE TABLE IF NOT EXISTS` afterwards filled only the gaps.
+ * So a dump could decide the schema of the tables the permission checker reads. A dump that
+ * declared `_substrat_tuples.object` as `COLLATE NOCASE` made every `=` the checker and the
+ * spine SQL wrote on it ignore case: a grant on `aiTurn:x` answered for `aiturn:x`.
+ *
+ * Now the loader builds every spine table from its own kernel DDL, and the dump contributes
+ * rows only, inserted by column name:
+ * - a column the kernel's table does not have (a dump from a newer kernel) is added as a plain
+ *   untyped column, unless it is named for SQLite's rowid (refused, since it would shadow it), with no type, collation, constraint or default, and keeps its values
+ *   (`spineColumnAdditions`). It is not one the checker reads, and it carries nothing that
+ *   could change how the columns the checker does read compare. When a later kernel adds the
+ *   column for real, its additive ALTER meets it and tolerates it as a duplicate;
+ * - a column the dump lacks takes the kernel's default (NULL for every additive column), so
+ *   a dump taken before a column existed still restores. The one column that is not additive,
+ *   `_substrat_schedule_state.kind` (#1288, part of the key), is derived from the row the way
+ *   the #1288 rebuild derives it;
+ * - a spine table the kernel does not build is refused (`assertSpineTablesBuilt`), every such
+ *   table named at once.
+ *
+ * Tables outside the spine keep the dump's own DDL: a vertical's schema is the dump's to say.
+ */
+/**
+ * A kernel-owned table, which a restore builds from the kernel's DDL rather than the dump's.
+ * The prefix is the spine guard's, compared the way SQLite compares table names, without case:
+ * a dump's `_Substrat_tuples` IS the tuples table, and read as a vertical one its DDL would be
+ * replayed and the kernel's `IF NOT EXISTS` would skip its own.
+ */
+export declare function isSpineTable(name: string): boolean;
+/**
+ * Refuse a dump carrying `_substrat_*` tables this host's kernel does not build, naming every
+ * one of them. Called before any spine row goes in, inside the load's transaction; `columnsOf`
+ * is the same lookup `dumpRowsInsert` takes, `undefined` for a table the kernel did not build.
+ *
+ * The usual cause is a dump from the other kind of host: a Durable Object's scope builds spine
+ * tables (`_substrat_roles`, `_substrat_tenant_tuples`, …) that a node scope keeps in its
+ * directory instead. Loading one anyway would mean dropping its rows, which a restore does not
+ * do silently.
+ */
+export declare function assertSpineTablesBuilt(names: readonly string[], columnsOf: KernelColumnsOf): void;
+/** A table's columns as the kernel built it here, or `undefined` when it built no such table. */
+export type KernelColumnsOf = (name: string) => readonly string[] | undefined;
+/**
+ * The `INSERT` that loads one dumped table's rows, one row of positional parameters per
+ * execution, in the dump's column order: `spineRowsInsert` for a spine table, and the dump's
+ * own columns for a vertical one. The names are quoted as given: the loader has already passed
+ * the dump through `assertReplayableDump`.
+ */
+export declare function dumpRowsInsert(table: {
+    name: string;
+    columns: readonly string[];
+}, columnsOf: KernelColumnsOf): string;
+/**
+ * The statements that add to a kernel-built spine table each column the dump carries and the
+ * kernel does not, as a plain untyped column: `ADD COLUMN "<name>"`, lowercased, and nothing after it, so it
+ * has no type, collation, constraint or default. Run after `assertSpineTablesBuilt` and before
+ * the table's rows go in, inside the load's transaction. The names are the dump's, which
+ * `assertReplayableDump` has already held to the identifier rule. Empty for a table the kernel
+ * did not build, which `assertSpineTablesBuilt` has refused.
+ */
+export declare function spineColumnAdditions(table: {
+    name: string;
+    columns: readonly string[];
+}, kernelColumns: readonly string[] | undefined): string[];
+/**
+ * The `INSERT` that loads one dumped spine table's rows into the table the kernel built.
+ *
+ * `kernelColumns` is the kernel table's column list as the loader reads it back after
+ * `spineColumnAdditions`, or `undefined` when the kernel built no such table. Either refusal
+ * below is a backstop the loader's order makes unreachable, and throws `validation_failed`
+ * inside the load's transaction, so the target keeps what it held.
+ */
+export declare function spineRowsInsert(table: {
+    name: string;
+    columns: readonly string[];
+}, kernelColumns: readonly string[] | undefined): string;
+//# sourceMappingURL=spine-restore.d.ts.map

package/dist/spine-restore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spine-restore.d.ts","sourceRoot":"","sources":["../src/spine-restore.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIlD;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,SAAS,EAAE,eAAe,GAAG,IAAI,CAGjG;AAED,iGAAiG;AACjG,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;AAmB9E;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,SAAS,EAAE,eAAe,GAAG,MAAM,CAEtH;AASD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EACnD,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GAC3C,MAAM,EAAE,CAkBV;AAKD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EACnD,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GAC3C,MAAM,CAyBR"}

package/dist/spine-restore.js

@@ -0,0 +1,138 @@
+import { substratError } from '@substrat-run/contracts';
+import { SCHEDULE_STATE_KIND_OF_OP } from './platform-sweep.js';
+import { isSearchIndexTable } from './search-index.js';
+import { SPINE_PREFIX } from './spine-guard.js';
+/**
+ * How a restore, fork or carry loads a dump's `_substrat_*` spine tables (#1883). One
+ * definition for both adapters' loaders, so the DO and the pure host build the same tables
+ * from the same dump.
+ *
+ * A dump used to be replayed table by table, `CREATE TABLE` from the dump and then its rows,
+ * spine included; the kernel's `CREATE TABLE IF NOT EXISTS` afterwards filled only the gaps.
+ * So a dump could decide the schema of the tables the permission checker reads. A dump that
+ * declared `_substrat_tuples.object` as `COLLATE NOCASE` made every `=` the checker and the
+ * spine SQL wrote on it ignore case: a grant on `aiTurn:x` answered for `aiturn:x`.
+ *
+ * Now the loader builds every spine table from its own kernel DDL, and the dump contributes
+ * rows only, inserted by column name:
+ * - a column the kernel's table does not have (a dump from a newer kernel) is added as a plain
+ *   untyped column, unless it is named for SQLite's rowid (refused, since it would shadow it), with no type, collation, constraint or default, and keeps its values
+ *   (`spineColumnAdditions`). It is not one the checker reads, and it carries nothing that
+ *   could change how the columns the checker does read compare. When a later kernel adds the
+ *   column for real, its additive ALTER meets it and tolerates it as a duplicate;
+ * - a column the dump lacks takes the kernel's default (NULL for every additive column), so
+ *   a dump taken before a column existed still restores. The one column that is not additive,
+ *   `_substrat_schedule_state.kind` (#1288, part of the key), is derived from the row the way
+ *   the #1288 rebuild derives it;
+ * - a spine table the kernel does not build is refused (`assertSpineTablesBuilt`), every such
+ *   table named at once.
+ *
+ * Tables outside the spine keep the dump's own DDL: a vertical's schema is the dump's to say.
+ */
+/**
+ * A kernel-owned table, which a restore builds from the kernel's DDL rather than the dump's.
+ * The prefix is the spine guard's, compared the way SQLite compares table names, without case:
+ * a dump's `_Substrat_tuples` IS the tuples table, and read as a vertical one its DDL would be
+ * replayed and the kernel's `IF NOT EXISTS` would skip its own.
+ */
+export function isSpineTable(name) {
+    const lower = name.toLowerCase();
+    // The search index is spine-prefixed too, but derived: a loader rebuilds it, never loads it.
+    return lower.startsWith(SPINE_PREFIX) && !isSearchIndexTable(lower);
+}
+/**
+ * Refuse a dump carrying `_substrat_*` tables this host's kernel does not build, naming every
+ * one of them. Called before any spine row goes in, inside the load's transaction; `columnsOf`
+ * is the same lookup `dumpRowsInsert` takes, `undefined` for a table the kernel did not build.
+ *
+ * The usual cause is a dump from the other kind of host: a Durable Object's scope builds spine
+ * tables (`_substrat_roles`, `_substrat_tenant_tuples`, …) that a node scope keeps in its
+ * directory instead. Loading one anyway would mean dropping its rows, which a restore does not
+ * do silently.
+ */
+export function assertSpineTablesBuilt(names, columnsOf) {
+    const missing = names.filter((n) => isSpineTable(n) && columnsOf(n) === undefined);
+    if (missing.length > 0)
+        throw unbuiltSpineTables(missing);
+}
+const unbuiltSpineTables = (names) => substratError('validation_failed', `restore refused: the dump carries spine table(s) this host's kernel does not build: ${names.join(', ')}. ` +
+    'It was exported by a different kind of host (a Durable Object scope holds spine tables a node scope ' +
+    'keeps in its directory) or by a newer kernel, and its rows would have nowhere to go. Nothing was changed.');
+/**
+ * Columns the kernel's table requires that a dump taken before them lacks, with the
+ * expression that derives each from the dumped row. Every other spine column is additive
+ * and defaults, so it needs no entry.
+ */
+const DERIVED_COLUMNS = {
+    _substrat_schedule_state: { kind: SCHEDULE_STATE_KIND_OF_OP },
+};
+/**
+ * The `INSERT` that loads one dumped table's rows, one row of positional parameters per
+ * execution, in the dump's column order: `spineRowsInsert` for a spine table, and the dump's
+ * own columns for a vertical one. The names are quoted as given: the loader has already passed
+ * the dump through `assertReplayableDump`.
+ */
+export function dumpRowsInsert(table, columnsOf) {
+    return isSpineTable(table.name) ? spineRowsInsert(table, columnsOf(table.name)) : plainInsert(table);
+}
+const plainInsert = (table) => `INSERT INTO "${table.name}" (${table.columns.map((c) => `"${c}"`).join(', ')}) ` +
+    `VALUES (${table.columns.map(() => '?').join(', ')})`;
+/** Column names as SQLite resolves them, without case. */
+const lowered = (columns) => new Set(columns.map((c) => c.toLowerCase()));
+/**
+ * The statements that add to a kernel-built spine table each column the dump carries and the
+ * kernel does not, as a plain untyped column: `ADD COLUMN "<name>"`, lowercased, and nothing after it, so it
+ * has no type, collation, constraint or default. Run after `assertSpineTablesBuilt` and before
+ * the table's rows go in, inside the load's transaction. The names are the dump's, which
+ * `assertReplayableDump` has already held to the identifier rule. Empty for a table the kernel
+ * did not build, which `assertSpineTablesBuilt` has refused.
+ */
+export function spineColumnAdditions(table, kernelColumns) {
+    if (kernelColumns === undefined)
+        return [];
+    const known = lowered(kernelColumns);
+    const unknown = table.columns.filter((c) => !known.has(c.toLowerCase()));
+    // A real column named for the rowid shadows SQLite's alias. On the outbox, `rowid` is the mark
+    // the #1705 and #1746 since-queries read (`OUTBOX_MARK_SQL`), so a dump's value would silence
+    // them from then on, and survive every later export.
+    const aliased = unknown.filter((c) => ROWID_ALIASES.has(c.toLowerCase()));
+    if (aliased.length > 0) {
+        throw substratError('validation_failed', `restore refused: the dump's ${table.name} has column(s) named for SQLite's rowid: ${aliased.join(', ')}. ` +
+            'A real column by that name would shadow the rowid the kernel reads. Nothing was changed.');
+    }
+    // Lowercased, as every kernel column is spelled: a later kernel adding the column for real
+    // then meets the name it expects, whatever case the dump used.
+    return unknown.map((c) => `ALTER TABLE "${table.name}" ADD COLUMN "${c.toLowerCase()}"`);
+}
+/** The names SQLite resolves to a table's rowid, unless a real column takes one. */
+const ROWID_ALIASES = new Set(['rowid', 'oid', '_rowid_']);
+/**
+ * The `INSERT` that loads one dumped spine table's rows into the table the kernel built.
+ *
+ * `kernelColumns` is the kernel table's column list as the loader reads it back after
+ * `spineColumnAdditions`, or `undefined` when the kernel built no such table. Either refusal
+ * below is a backstop the loader's order makes unreachable, and throws `validation_failed`
+ * inside the load's transaction, so the target keeps what it held.
+ */
+export function spineRowsInsert(table, kernelColumns) {
+    // `assertSpineTablesBuilt` has refused this already, naming every such table.
+    if (kernelColumns === undefined)
+        throw unbuiltSpineTables([table.name]);
+    const known = lowered(kernelColumns);
+    // `spineColumnAdditions` has added every such column already.
+    const unknown = table.columns.filter((c) => !known.has(c.toLowerCase()));
+    if (unknown.length > 0) {
+        throw substratError('validation_failed', `restore refused: the dump's ${table.name} has column(s) that were not added to this host's table: ` +
+            `${unknown.join(', ')}. Nothing was changed.`);
+    }
+    const dumped = lowered(table.columns);
+    const derived = Object.entries(DERIVED_COLUMNS[table.name.toLowerCase()] ?? {}).filter(([c]) => known.has(c) && !dumped.has(c));
+    if (derived.length === 0)
+        return plainInsert(table);
+    const quoted = table.columns.map((c) => `"${c}"`);
+    // The derivation reads the dumped row by name, so the row is a one-row SELECT to read from.
+    const row = table.columns.map((c, i) => `? AS ${quoted[i]}`).join(', ');
+    return (`INSERT INTO "${table.name}" (${[...quoted, ...derived.map(([c]) => `"${c}"`)].join(', ')}) ` +
+        `SELECT ${[...quoted, ...derived.map(([, expr]) => expr)].join(', ')} FROM (SELECT ${row})`);
+}
+//# sourceMappingURL=spine-restore.js.map

package/dist/spine-restore.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@substrat-run/kernel",
-  "version": "0.126.0",
+  "version": "0.128.0",
   "description": "Substrat kernel contracts and services — pure TypeScript, no platform imports (D-14)",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -22,7 +22,7 @@
     "dist"
   ],
   "dependencies": {
-    "@substrat-run/contracts": "^0.126.0"
+    "@substrat-run/contracts": "^0.128.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.4",