@telorun/sqlite 0.2.1 → 0.4.0

package/dist/schema/enum-controller.d.ts

@@ -0,0 +1,18 @@
+import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
+import { type DeclaredEnum, type RawEnum } from "@telorun/sql";
+/**
+ * `SQLite.Enum` — one declared set of permitted values.
+ *
+ * SQLite has no named types, so nothing in the database corresponds to this
+ * resource: the values are rendered as a `CHECK` on every column that references
+ * it. The DECLARATION is still a ledger object like any other, which is what
+ * lets a change to it be detected at all.
+ */
+export declare class SqliteEnumResource implements ResourceInstance {
+    readonly declaration: DeclaredEnum;
+    constructor(raw: RawEnum);
+    get typeName(): string;
+    snapshot(): Record<string, unknown>;
+}
+export declare function register(): void;
+export declare function create(resource: RawEnum, _ctx: ResourceContext): Promise<SqliteEnumResource>;

package/dist/schema/enum-controller.js

@@ -0,0 +1,25 @@
+import { normalizeEnum } from "@telorun/sql";
+/**
+ * `SQLite.Enum` — one declared set of permitted values.
+ *
+ * SQLite has no named types, so nothing in the database corresponds to this
+ * resource: the values are rendered as a `CHECK` on every column that references
+ * it. The DECLARATION is still a ledger object like any other, which is what
+ * lets a change to it be detected at all.
+ */
+export class SqliteEnumResource {
+    declaration;
+    constructor(raw) {
+        this.declaration = normalizeEnum(raw);
+    }
+    get typeName() {
+        return this.declaration.typeName;
+    }
+    snapshot() {
+        return { typeName: this.declaration.typeName, values: [...this.declaration.values] };
+    }
+}
+export function register() { }
+export async function create(resource, _ctx) {
+    return new SqliteEnumResource(resource);
+}

package/dist/schema/schema-controller.d.ts

@@ -1,5 +1,6 @@
 import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
 import { type MigrationMap, type ReclaimPolicy, type SqlConnection } from "@telorun/sql";
+import type { SqliteEnumResource } from "./enum-controller.js";
 import type { SqliteTableResource } from "./table-controller.js";
 interface SqliteSchemaManifest {
     metadata: {
@@ -10,7 +11,8 @@ interface SqliteSchemaManifest {
     version?: string;
     ledger?: string;
     tables?: SqliteTableResource[];
-    beforeMigrations?: MigrationMap;
+    enums?: SqliteEnumResource[];
+    prepare?: MigrationMap;
     migrations?: MigrationMap;
     reclaim?: ReclaimPolicy;
 }

package/dist/schema/schema-controller.js

@@ -31,7 +31,8 @@ class SqliteSchemaResource {
             ledger: this.manifest.ledger,
             version: this.manifest.version,
             tables: (this.manifest.tables ?? []).map((table) => table.declaration),
-            beforeMigrations: this.manifest.beforeMigrations ?? {},
+            enums: (this.manifest.enums ?? []).map((declared) => declared.declaration),
+            prepare: this.manifest.prepare ?? {},
             migrations: this.manifest.migrations ?? {},
             reclaim: this.manifest.reclaim,
         });

package/dist/schema/sqlite-schema-driver.d.ts

@@ -1,4 +1,4 @@
-import { type ChangeSafety, type DeclaredColumn, type DeclaredForeignKey, type DeclaredIndex, type DeclaredTable, type LiveColumn, type SchemaObjectId, type LiveTable, type LedgerTables, type LiveForeignKey, type SchemaDriver, type SqlConnection } from "@telorun/sql";
+import { type ChangeSafety, type DeclaredCheck, type DeclaredColumn, type DeclaredEnum, type DeclaredForeignKey, type DeclaredIndex, type DeclaredTable, type LiveCheck, type LiveColumn, type LiveEnum, type SchemaObjectId, type LiveTable, type LedgerTables, type LiveForeignKey, type SchemaDriver, type SqlConnection } from "@telorun/sql";
 /**
  * SQLite's half of declarative schema.
  *
@@ -44,6 +44,11 @@ export declare class SqliteSchemaDriver implements SchemaDriver {
     ledgerStatements(_schema: string, tables: LedgerTables): string[];
     now(): Promise<string>;
     runAtomically(statements: readonly string[]): Promise<void>;
+    /** SQLite has no DDL this design must keep out of a transaction, so this is
+     *  `runAtomically` under the name the contract asks for. */
+    runSequentially(statements: readonly string[]): Promise<void>;
+    /** All of them: SQLite has no DDL this design must keep out of a transaction. */
+    transactionalPhase(): boolean;
     introspect(_schema: string, tables: readonly string[]): Promise<LiveTable[]>;
     typeSignature(column: DeclaredColumn): string;
     /** An index is dropped and recreated, which SQLite does support. */
@@ -70,7 +75,59 @@ export declare class SqliteSchemaDriver implements SchemaDriver {
     addForeignKey(_schema: string, table: string, fk: DeclaredForeignKey): string[];
     /** Unreachable: `canReclaim` refuses a foreign key before the drop is planned. */
     dropForeignKey(_schema: string, table: string, name: string): string[];
+    /** SQLite has no `ADD CONSTRAINT`, so a check exists only as part of the table
+     *  it was created with — the same place its foreign keys are. */
+    readonly checksInCreateTable = true;
+    /** Compared against the RECORDED declaration rather than live state, so this
+     *  is declaration against declaration and the text is the whole comparison. */
+    checkDiffers(live: LiveCheck, declared: DeclaredCheck): boolean;
+    classifyCheckChange(_live: LiveCheck, declared: DeclaredCheck): ChangeSafety;
+    addCheck(_schema: string, table: string, check: DeclaredCheck): string[];
+    dropCheck(_schema: string, table: string, name: string): string[];
+    /** Unreachable: nothing on SQLite is ever added `NOT VALID`, so nothing is
+     *  waiting to be proven. */
+    validateCheck(_schema: string, table: string, name: string): string[];
+    /**
+     * SQLite has no named types, so a domain has no database object behind it: the
+     * values are rendered as a `CHECK` on every column that references the enum.
+     *
+     * The DECLARATION is still a ledger object like any other, which is what lets a
+     * change to it be detected at all — see `classifyEnumChange`.
+     */
+    readonly namedEnumTypes = false;
+    /** Nothing to read back: there is no type to introspect. */
+    introspectEnums(): Promise<LiveEnum[]>;
+    /** Unreachable: the shared half asks only when `namedEnumTypes` holds. */
+    createEnum(_schema: string, declared: DeclaredEnum): string[];
+    addEnumValues(_schema: string, declared: DeclaredEnum): string[];
+    /** No statement at all — the `CHECK`s on referencing tables never named the
+     *  type, so the ledger key rewrite IS the rename. */
+    renameEnum(): string[];
+    /** The one part of renaming where the two engines need no separate story:
+     *  SQLite renames a table with the same statement PostgreSQL does. */
+    renameTable(schema: string, from: string, to: string): string[];
+    /**
+     * A domain reaches the database inside the tables that use it, so changing one
+     * would mean rebuilding every referencing table — which is where SQLite's
+     * foreign keys and column alterations already are.
+     *
+     * The comparison is against the RECORDED declaration rather than live state,
+     * because there is no live state: nothing in the database corresponds to the
+     * type. That is exactly what makes snapshotting the whole enum declaration
+     * load-bearing rather than decorative.
+     */
+    classifyEnumChange(_live: LiveEnum | undefined, declared: DeclaredEnum, owned: DeclaredEnum | undefined): ChangeSafety;
+    dropEnum(): string[];
+    /** SQLite has no installable extensions in the sense this declares — a
+     *  loadable extension is a build-time or connection-time concern, not a schema
+     *  object a pass can create. */
+    readonly namedExtensions = false;
+    introspectExtensions(): Promise<string[]>;
+    createExtension(_schema: string, name: string): string[];
+    dropExtension(_schema: string, name: string): string[];
     canReclaim(id: SchemaObjectId): ChangeSafety;
     dropColumn(schema: string, table: string, column: string): string[];
     dropTable(schema: string, table: string): string[];
+    upsertRow(schema: string, table: string, key: readonly string[], row: Record<string, unknown>): string[];
+    deleteRow(schema: string, table: string, key: readonly string[], row: Record<string, unknown>): string[];
 }

package/dist/schema/sqlite-schema-driver.js

@@ -1,4 +1,4 @@
-import { quoteAnsiIdentifier, } from "@telorun/sql";
+import { quoteAnsiIdentifier, deleteRowStatements, upsertRowStatements, } from "@telorun/sql";
 import { CompiledQuery } from "kysely";
 /**
  * SQLite's half of declarative schema.
@@ -14,14 +14,36 @@ import { CompiledQuery } from "kysely";
  *  conventions over these five, and inventing names for them here would be the
  *  lowest-common-denominator type vocabulary this design rejects. */
 export const SQLITE_TYPES = ["integer", "real", "text", "blob", "numeric"];
+/**
+ * A declared value as SQLite literal text.
+ *
+ * Structured values are SERIALIZED, never stringified. `String({})` is
+ * `[object Object]` and `String([1,2])` is `1,2`, so a structured seed value —
+ * which the row projection admits wherever a column's mapped node is open —
+ * reached the database as that text. SQLite has no JSON type, only the
+ * convention of JSON in a `text` column, and the serialized form is exactly what
+ * that convention (and `json_extract`) reads.
+ *
+ * Bytes get SQLite's own blob literal: `!include-bytes` resolves to a
+ * `Uint8Array` before a controller sees it, and `String(...)` on one yields its
+ * elements comma-joined.
+ */
 function literal(value) {
-    if (value === null)
+    if (value === null || value === undefined)
         return "NULL";
     if (typeof value === "number" || typeof value === "bigint")
         return String(value);
     if (typeof value === "boolean")
         return value ? "1" : "0";
-    return `'${String(value).replace(/'/g, "''")}'`;
+    if (value instanceof Uint8Array)
+        return `X'${Buffer.from(value).toString("hex")}'`;
+    if (typeof value === "object")
+        return quoted(JSON.stringify(value));
+    return quoted(String(value));
+}
+/** Single quotes doubled — SQLite's only string escape. */
+function quoted(text) {
+    return `'${text.replace(/'/g, "''")}'`;
 }
 function columnDefault(column) {
     if (column.defaultExpression !== undefined)
@@ -100,6 +122,15 @@ export class SqliteSchemaDriver {
             }
         });
     }
+    /** SQLite has no DDL this design must keep out of a transaction, so this is
+     *  `runAtomically` under the name the contract asks for. */
+    async runSequentially(statements) {
+        await this.runAtomically(statements);
+    }
+    /** All of them: SQLite has no DDL this design must keep out of a transaction. */
+    transactionalPhase() {
+        return true;
+    }
     async introspect(_schema, tables) {
         const live = [];
         for (const table of tables) {
@@ -161,7 +192,11 @@ export class SqliteSchemaDriver {
                     onUpdate: first.on_update == null ? undefined : String(first.on_update),
                 });
             }
-            live.push({ name: table, columns, indexes, foreignKeys });
+            // Checks are deliberately NOT read back: SQLite keeps them only inside the
+            // table's stored DDL text, and parsing that would be a SQL parser in a
+            // schema driver. The shared half compares this engine's checks against the
+            // RECORDED declaration instead — see `checksInCreateTable`.
+            live.push({ name: table, columns, indexes, foreignKeys, checks: [] });
         }
         return live;
     }
@@ -243,6 +278,14 @@ export class SqliteSchemaDriver {
             parts.push("NOT NULL");
         if (column.unique)
             parts.push("UNIQUE");
+        // SQLite has no named types, so a domain reaches the database only as a
+        // constraint on the column that uses it. The values sort as text rather than
+        // in declaration order — the one thing the rendering cannot reproduce, and
+        // why the enum's `values:` order is documented as PostgreSQL's alone.
+        if (column.enum) {
+            const values = column.enum.values.map((value) => literal(value)).join(", ");
+            parts.push(`CHECK (${this.quote(column.name)} IN (${values}))`);
+        }
         const def = columnDefault(column);
         return parts.join(" ") + def;
     }
@@ -255,10 +298,14 @@ export class SqliteSchemaDriver {
     createTable(schema, table) {
         const parts = table.columns.map((column) => this.#columnDefinition(column));
         // Foreign keys are part of the table in SQLite — there is no ADD CONSTRAINT
-        // — so they are emitted here and nowhere else.
+        // — so they are emitted here and nowhere else. Named checks land in exactly
+        // the same place, for exactly the same reason.
         for (const fk of table.foreignKeys) {
             parts.push(this.#foreignKeyClause(fk));
         }
+        for (const check of table.checks) {
+            parts.push(`CONSTRAINT ${this.quote(check.name)} CHECK (${check.expression})`);
+        }
         return [
             `CREATE TABLE IF NOT EXISTS ${this.qualify(schema, table.name)} (\n  ${parts.join(",\n  ")}\n)`,
         ];
@@ -316,13 +363,116 @@ export class SqliteSchemaDriver {
         throw new Error(`SQLite.Table: foreign key '${name}' cannot be dropped from '${table}' — SQLite has no ` +
             `DROP CONSTRAINT. Rebuild the table in a 'migrations:' entry.`);
     }
+    /** SQLite has no `ADD CONSTRAINT`, so a check exists only as part of the table
+     *  it was created with — the same place its foreign keys are. */
+    checksInCreateTable = true;
+    /** Compared against the RECORDED declaration rather than live state, so this
+     *  is declaration against declaration and the text is the whole comparison. */
+    checkDiffers(live, declared) {
+        return live.expression !== declared.expression;
+    }
+    classifyCheckChange(_live, declared) {
+        return {
+            safe: false,
+            reason: `SQLite has no ALTER for a constraint — a check exists only as part of the table it was ` +
+                `created with — so '${declared.name}' cannot be changed in place. Rebuild the table in a ` +
+                `'migrations:' entry.`,
+        };
+    }
+    addCheck(_schema, table, check) {
+        throw new Error(`SQLite.Table: check '${check.name}' cannot be added to the existing table '${table}' — ` +
+            `SQLite has no ADD CONSTRAINT and a check exists only as part of the table it was ` +
+            `created with. Rebuild the table in a 'migrations:' entry.`);
+    }
+    dropCheck(_schema, table, name) {
+        throw new Error(`SQLite.Table: check '${name}' cannot be dropped from '${table}' — SQLite has no DROP ` +
+            `CONSTRAINT. Rebuild the table in a 'migrations:' entry.`);
+    }
+    /** Unreachable: nothing on SQLite is ever added `NOT VALID`, so nothing is
+     *  waiting to be proven. */
+    validateCheck(_schema, table, name) {
+        throw new Error(`SQLite.Table: check '${table}.${name}' has no deferred validation to run.`);
+    }
+    /**
+     * SQLite has no named types, so a domain has no database object behind it: the
+     * values are rendered as a `CHECK` on every column that references the enum.
+     *
+     * The DECLARATION is still a ledger object like any other, which is what lets a
+     * change to it be detected at all — see `classifyEnumChange`.
+     */
+    namedEnumTypes = false;
+    /** Nothing to read back: there is no type to introspect. */
+    async introspectEnums() {
+        return [];
+    }
+    /** Unreachable: the shared half asks only when `namedEnumTypes` holds. */
+    createEnum(_schema, declared) {
+        throw new Error(`SQLite.Enum '${declared.typeName}': SQLite has no named types, so nothing creates one.`);
+    }
+    addEnumValues(_schema, declared) {
+        throw new Error(`SQLite.Enum '${declared.typeName}': SQLite has no named types, so nothing alters one.`);
+    }
+    /** No statement at all — the `CHECK`s on referencing tables never named the
+     *  type, so the ledger key rewrite IS the rename. */
+    renameEnum() {
+        return [];
+    }
+    /** The one part of renaming where the two engines need no separate story:
+     *  SQLite renames a table with the same statement PostgreSQL does. */
+    renameTable(schema, from, to) {
+        return [`ALTER TABLE ${this.qualify(schema, from)} RENAME TO ${this.quote(to)}`];
+    }
+    /**
+     * A domain reaches the database inside the tables that use it, so changing one
+     * would mean rebuilding every referencing table — which is where SQLite's
+     * foreign keys and column alterations already are.
+     *
+     * The comparison is against the RECORDED declaration rather than live state,
+     * because there is no live state: nothing in the database corresponds to the
+     * type. That is exactly what makes snapshotting the whole enum declaration
+     * load-bearing rather than decorative.
+     */
+    classifyEnumChange(_live, declared, owned) {
+        if (!owned)
+            return { safe: true };
+        const same = owned.baseType === declared.baseType &&
+            owned.values.length === declared.values.length &&
+            owned.values.every((value, i) => value === declared.values[i]);
+        if (same)
+            return { safe: true };
+        return {
+            safe: false,
+            reason: `SQLite has no named types, so '${declared.typeName}' is rendered as a CHECK on every ` +
+                `column that references it — and SQLite has no ALTER for a constraint. Changing the ` +
+                `declaration would leave every existing table enforcing the old values. Rebuild the ` +
+                `referencing tables in a 'migrations:' entry, which is where a changed constraint on ` +
+                `this engine belongs.`,
+        };
+    }
+    dropEnum() {
+        return [];
+    }
+    /** SQLite has no installable extensions in the sense this declares — a
+     *  loadable extension is a build-time or connection-time concern, not a schema
+     *  object a pass can create. */
+    namedExtensions = false;
+    async introspectExtensions() {
+        return [];
+    }
+    createExtension(_schema, name) {
+        throw new Error(`SQLite.Schema: extension '${name}' cannot be created — SQLite has no installable ` +
+            `extensions a schema pass can provision.`);
+    }
+    dropExtension(_schema, name) {
+        throw new Error(`SQLite.Schema: extension '${name}' cannot be dropped.`);
+    }
     canReclaim(id) {
-        if (id.kind === "foreignKey") {
+        if (id.kind === "foreignKey" || id.kind === "check") {
             return {
                 safe: false,
-                reason: "SQLite has no DROP CONSTRAINT, so this foreign key cannot be dropped in place. " +
-                    "Rebuild the table in a 'migrations:' entry; the tombstone is cleared when the " +
-                    "constraint is gone.",
+                reason: `SQLite has no DROP CONSTRAINT, so this ${id.kind === "check" ? "check" : "foreign key"} ` +
+                    "cannot be dropped in place. Rebuild the table in a 'migrations:' entry; the tombstone " +
+                    "is cleared when the constraint is gone.",
             };
         }
         return { safe: true };
@@ -333,4 +483,21 @@ export class SqliteSchemaDriver {
     dropTable(schema, table) {
         return [`DROP TABLE IF EXISTS ${this.qualify(schema, table)}`];
     }
+    /** SQLite has had upsert since 3.24, so both engines render the same statement
+     *  SHAPE — which is why it lives in `row-statements.ts` and only the dialect
+     *  is answered here. */
+    get #rowDialect() {
+        return {
+            quote: (name) => this.quote(name),
+            literal,
+            qualify: (schema, table) => this.qualify(schema, table),
+            excludedAlias: "excluded",
+        };
+    }
+    upsertRow(schema, table, key, row) {
+        return upsertRowStatements(this.#rowDialect, schema, table, key, row);
+    }
+    deleteRow(schema, table, key, row) {
+        return deleteRowStatements(this.#rowDialect, schema, table, key, row);
+    }
 }

package/dist/schema/table-controller.js

@@ -1,4 +1,4 @@
-import { normalizeTable, tableReferenceResolver, } from "@telorun/sql";
+import { enumReferenceResolver, normalizeTable, tableReferenceResolver, } from "@telorun/sql";
 /**
  * `SQLite.Table` — one physical table, declared rather than migrated to.
  *
@@ -9,7 +9,7 @@ import { normalizeTable, tableReferenceResolver, } from "@telorun/sql";
 export class SqliteTableResource {
     declaration;
     constructor(raw, ctx) {
-        this.declaration = normalizeTable(raw, tableReferenceResolver(ctx, "SQLite.Table", raw.table));
+        this.declaration = normalizeTable(raw, tableReferenceResolver(ctx, "SQLite.Table", raw.table), sqliteColumnType(ctx, raw.table));
     }
     /** The physical table name, read by consumers that build statements against
      *  it (`self.table.table` in a repository's template). */
@@ -20,6 +20,25 @@ export class SqliteTableResource {
         return { table: this.declaration.name };
     }
 }
+/** SQLite has no named types, so an enum column's engine-native type is the
+ *  enum's declared base storage class; the values ride along as a CHECK. */
+function sqliteColumnType(ctx, table) {
+    const resolveEnum = enumReferenceResolver(ctx, "SQLite.Enum", table);
+    return (value, column) => {
+        const declared = resolveEnum(value, column);
+        if (!declared)
+            return { type: String(value) };
+        if (!declared.baseType) {
+            throw new Error(`SQLite.Table '${table}': column '${column}' references enum '${declared.typeName}', ` +
+                `which declares no 'baseType'. SQLite has no named types, so something has to say ` +
+                `which storage class the values sit in.`);
+        }
+        return {
+            type: declared.baseType,
+            enum: { typeName: declared.typeName, values: declared.values },
+        };
+    };
+}
 export function register() { }
 export async function create(resource, ctx) {
     return new SqliteTableResource(resource, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/sqlite",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Telo SQLite.Connection — SQLite backend for the Sql.Connection abstract (better-sqlite3 / bun:sqlite, transactional DDL).",
   "keywords": [
     "telo",
@@ -35,6 +35,10 @@
     "./table": {
       "bun": "./src/schema/table-controller.ts",
       "import": "./dist/schema/table-controller.js"
+    },
+    "./enum": {
+      "bun": "./src/schema/enum-controller.ts",
+      "import": "./dist/schema/enum-controller.js"
     }
   },
   "files": [
@@ -44,14 +48,14 @@
   "dependencies": {
     "better-sqlite3": "^12.8.0",
     "kysely": "^0.28.15",
-    "@telorun/sql": "0.22.1"
+    "@telorun/sql": "0.24.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.0.0",
     "@types/bun": "^1.3.10",
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
-    "@telorun/sdk": "0.80.0"
+    "@telorun/sdk": "0.82.1"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/schema/enum-controller.ts

@@ -0,0 +1,35 @@
+import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
+import { normalizeEnum, type DeclaredEnum, type RawEnum } from "@telorun/sql";
+
+/**
+ * `SQLite.Enum` — one declared set of permitted values.
+ *
+ * SQLite has no named types, so nothing in the database corresponds to this
+ * resource: the values are rendered as a `CHECK` on every column that references
+ * it. The DECLARATION is still a ledger object like any other, which is what
+ * lets a change to it be detected at all.
+ */
+export class SqliteEnumResource implements ResourceInstance {
+  readonly declaration: DeclaredEnum;
+
+  constructor(raw: RawEnum) {
+    this.declaration = normalizeEnum(raw);
+  }
+
+  get typeName(): string {
+    return this.declaration.typeName;
+  }
+
+  snapshot(): Record<string, unknown> {
+    return { typeName: this.declaration.typeName, values: [...this.declaration.values] };
+  }
+}
+
+export function register(): void {}
+
+export async function create(
+  resource: RawEnum,
+  _ctx: ResourceContext,
+): Promise<SqliteEnumResource> {
+  return new SqliteEnumResource(resource);
+}

package/src/schema/schema-controller.ts

@@ -7,6 +7,7 @@ import {
   type SqlConnection,
 } from "@telorun/sql";
 import { SqliteSchemaDriver } from "./sqlite-schema-driver.js";
+import type { SqliteEnumResource } from "./enum-controller.js";
 import type { SqliteTableResource } from "./table-controller.js";
 
 interface SqliteSchemaManifest {
@@ -15,7 +16,8 @@ interface SqliteSchemaManifest {
   version?: string;
   ledger?: string;
   tables?: SqliteTableResource[];
-  beforeMigrations?: MigrationMap;
+  enums?: SqliteEnumResource[];
+  prepare?: MigrationMap;
   migrations?: MigrationMap;
   reclaim?: ReclaimPolicy;
 }
@@ -56,7 +58,8 @@ class SqliteSchemaResource implements ResourceInstance {
       ledger: this.manifest.ledger,
       version: this.manifest.version,
       tables: (this.manifest.tables ?? []).map((table) => table.declaration),
-      beforeMigrations: this.manifest.beforeMigrations ?? {},
+      enums: (this.manifest.enums ?? []).map((declared) => declared.declaration),
+      prepare: this.manifest.prepare ?? {},
       migrations: this.manifest.migrations ?? {},
       reclaim: this.manifest.reclaim,
     });

package/src/schema/sqlite-schema-driver.ts

@@ -1,11 +1,15 @@
 import {
   quoteAnsiIdentifier,
   type ChangeSafety,
+  type DeclaredCheck,
   type DeclaredColumn,
+  type DeclaredEnum,
   type DeclaredForeignKey,
   type DeclaredIndex,
   type DeclaredTable,
+  type LiveCheck,
   type LiveColumn,
+  type LiveEnum,
   type SchemaObjectId,
   type LiveTable,
   type LedgerTables,
@@ -13,6 +17,9 @@ import {
   type LiveIndex,
   type SchemaDriver,
   type SqlConnection,
+  deleteRowStatements,
+  upsertRowStatements,
+  type RowDialect,
 } from "@telorun/sql";
 import { CompiledQuery, type Kysely } from "kysely";
 
@@ -33,11 +40,32 @@ import { CompiledQuery, type Kysely } from "kysely";
 export const SQLITE_TYPES = ["integer", "real", "text", "blob", "numeric"] as const;
 export type SqliteType = (typeof SQLITE_TYPES)[number];
 
+/**
+ * A declared value as SQLite literal text.
+ *
+ * Structured values are SERIALIZED, never stringified. `String({})` is
+ * `[object Object]` and `String([1,2])` is `1,2`, so a structured seed value —
+ * which the row projection admits wherever a column's mapped node is open —
+ * reached the database as that text. SQLite has no JSON type, only the
+ * convention of JSON in a `text` column, and the serialized form is exactly what
+ * that convention (and `json_extract`) reads.
+ *
+ * Bytes get SQLite's own blob literal: `!include-bytes` resolves to a
+ * `Uint8Array` before a controller sees it, and `String(...)` on one yields its
+ * elements comma-joined.
+ */
 function literal(value: unknown): string {
-  if (value === null) return "NULL";
+  if (value === null || value === undefined) return "NULL";
   if (typeof value === "number" || typeof value === "bigint") return String(value);
   if (typeof value === "boolean") return value ? "1" : "0";
-  return `'${String(value).replace(/'/g, "''")}'`;
+  if (value instanceof Uint8Array) return `X'${Buffer.from(value).toString("hex")}'`;
+  if (typeof value === "object") return quoted(JSON.stringify(value));
+  return quoted(String(value));
+}
+
+/** Single quotes doubled — SQLite's only string escape. */
+function quoted(text: string): string {
+  return `'${text.replace(/'/g, "''")}'`;
 }
 
 function columnDefault(column: DeclaredColumn): string {
@@ -125,6 +153,17 @@ export class SqliteSchemaDriver implements SchemaDriver {
     });
   }
 
+  /** SQLite has no DDL this design must keep out of a transaction, so this is
+   *  `runAtomically` under the name the contract asks for. */
+  async runSequentially(statements: readonly string[]): Promise<void> {
+    await this.runAtomically(statements);
+  }
+
+  /** All of them: SQLite has no DDL this design must keep out of a transaction. */
+  transactionalPhase(): boolean {
+    return true;
+  }
+
   async introspect(_schema: string, tables: readonly string[]): Promise<LiveTable[]> {
     const live: LiveTable[] = [];
     for (const table of tables) {
@@ -195,7 +234,11 @@ export class SqliteSchemaDriver implements SchemaDriver {
         });
       }
 
-      live.push({ name: table, columns, indexes, foreignKeys });
+      // Checks are deliberately NOT read back: SQLite keeps them only inside the
+      // table's stored DDL text, and parsing that would be a SQL parser in a
+      // schema driver. The shared half compares this engine's checks against the
+      // RECORDED declaration instead — see `checksInCreateTable`.
+      live.push({ name: table, columns, indexes, foreignKeys, checks: [] });
     }
     return live;
   }
@@ -288,6 +331,14 @@ export class SqliteSchemaDriver implements SchemaDriver {
     if (column.identity) parts.push("AUTOINCREMENT");
     if (!column.nullable) parts.push("NOT NULL");
     if (column.unique) parts.push("UNIQUE");
+    // SQLite has no named types, so a domain reaches the database only as a
+    // constraint on the column that uses it. The values sort as text rather than
+    // in declaration order — the one thing the rendering cannot reproduce, and
+    // why the enum's `values:` order is documented as PostgreSQL's alone.
+    if (column.enum) {
+      const values = column.enum.values.map((value) => literal(value)).join(", ");
+      parts.push(`CHECK (${this.quote(column.name)} IN (${values}))`);
+    }
     const def = columnDefault(column);
     return parts.join(" ") + def;
   }
@@ -303,10 +354,14 @@ export class SqliteSchemaDriver implements SchemaDriver {
   createTable(schema: string, table: DeclaredTable): string[] {
     const parts = table.columns.map((column) => this.#columnDefinition(column));
     // Foreign keys are part of the table in SQLite — there is no ADD CONSTRAINT
-    // — so they are emitted here and nowhere else.
+    // — so they are emitted here and nowhere else. Named checks land in exactly
+    // the same place, for exactly the same reason.
     for (const fk of table.foreignKeys) {
       parts.push(this.#foreignKeyClause(fk));
     }
+    for (const check of table.checks) {
+      parts.push(`CONSTRAINT ${this.quote(check.name)} CHECK (${check.expression})`);
+    }
     return [
       `CREATE TABLE IF NOT EXISTS ${this.qualify(schema, table.name)} (\n  ${parts.join(",\n  ")}\n)`,
     ];
@@ -377,14 +432,150 @@ export class SqliteSchemaDriver implements SchemaDriver {
     );
   }
 
+  /** SQLite has no `ADD CONSTRAINT`, so a check exists only as part of the table
+   *  it was created with — the same place its foreign keys are. */
+  readonly checksInCreateTable = true;
+
+  /** Compared against the RECORDED declaration rather than live state, so this
+   *  is declaration against declaration and the text is the whole comparison. */
+  checkDiffers(live: LiveCheck, declared: DeclaredCheck): boolean {
+    return live.expression !== declared.expression;
+  }
+
+  classifyCheckChange(_live: LiveCheck, declared: DeclaredCheck): ChangeSafety {
+    return {
+      safe: false,
+      reason:
+        `SQLite has no ALTER for a constraint — a check exists only as part of the table it was ` +
+        `created with — so '${declared.name}' cannot be changed in place. Rebuild the table in a ` +
+        `'migrations:' entry.`,
+    };
+  }
+
+  addCheck(_schema: string, table: string, check: DeclaredCheck): string[] {
+    throw new Error(
+      `SQLite.Table: check '${check.name}' cannot be added to the existing table '${table}' — ` +
+        `SQLite has no ADD CONSTRAINT and a check exists only as part of the table it was ` +
+        `created with. Rebuild the table in a 'migrations:' entry.`,
+    );
+  }
+
+  dropCheck(_schema: string, table: string, name: string): string[] {
+    throw new Error(
+      `SQLite.Table: check '${name}' cannot be dropped from '${table}' — SQLite has no DROP ` +
+        `CONSTRAINT. Rebuild the table in a 'migrations:' entry.`,
+    );
+  }
+
+  /** Unreachable: nothing on SQLite is ever added `NOT VALID`, so nothing is
+   *  waiting to be proven. */
+  validateCheck(_schema: string, table: string, name: string): string[] {
+    throw new Error(`SQLite.Table: check '${table}.${name}' has no deferred validation to run.`);
+  }
+
+  /**
+   * SQLite has no named types, so a domain has no database object behind it: the
+   * values are rendered as a `CHECK` on every column that references the enum.
+   *
+   * The DECLARATION is still a ledger object like any other, which is what lets a
+   * change to it be detected at all — see `classifyEnumChange`.
+   */
+  readonly namedEnumTypes = false;
+
+  /** Nothing to read back: there is no type to introspect. */
+  async introspectEnums(): Promise<LiveEnum[]> {
+    return [];
+  }
+
+  /** Unreachable: the shared half asks only when `namedEnumTypes` holds. */
+  createEnum(_schema: string, declared: DeclaredEnum): string[] {
+    throw new Error(
+      `SQLite.Enum '${declared.typeName}': SQLite has no named types, so nothing creates one.`,
+    );
+  }
+
+  addEnumValues(_schema: string, declared: DeclaredEnum): string[] {
+    throw new Error(
+      `SQLite.Enum '${declared.typeName}': SQLite has no named types, so nothing alters one.`,
+    );
+  }
+
+  /** No statement at all — the `CHECK`s on referencing tables never named the
+   *  type, so the ledger key rewrite IS the rename. */
+  renameEnum(): string[] {
+    return [];
+  }
+
+  /** The one part of renaming where the two engines need no separate story:
+   *  SQLite renames a table with the same statement PostgreSQL does. */
+  renameTable(schema: string, from: string, to: string): string[] {
+    return [`ALTER TABLE ${this.qualify(schema, from)} RENAME TO ${this.quote(to)}`];
+  }
+
+  /**
+   * A domain reaches the database inside the tables that use it, so changing one
+   * would mean rebuilding every referencing table — which is where SQLite's
+   * foreign keys and column alterations already are.
+   *
+   * The comparison is against the RECORDED declaration rather than live state,
+   * because there is no live state: nothing in the database corresponds to the
+   * type. That is exactly what makes snapshotting the whole enum declaration
+   * load-bearing rather than decorative.
+   */
+  classifyEnumChange(
+    _live: LiveEnum | undefined,
+    declared: DeclaredEnum,
+    owned: DeclaredEnum | undefined,
+  ): ChangeSafety {
+    if (!owned) return { safe: true };
+    const same =
+      owned.baseType === declared.baseType &&
+      owned.values.length === declared.values.length &&
+      owned.values.every((value, i) => value === declared.values[i]);
+    if (same) return { safe: true };
+    return {
+      safe: false,
+      reason:
+        `SQLite has no named types, so '${declared.typeName}' is rendered as a CHECK on every ` +
+        `column that references it — and SQLite has no ALTER for a constraint. Changing the ` +
+        `declaration would leave every existing table enforcing the old values. Rebuild the ` +
+        `referencing tables in a 'migrations:' entry, which is where a changed constraint on ` +
+        `this engine belongs.`,
+    };
+  }
+
+  dropEnum(): string[] {
+    return [];
+  }
+
+  /** SQLite has no installable extensions in the sense this declares — a
+   *  loadable extension is a build-time or connection-time concern, not a schema
+   *  object a pass can create. */
+  readonly namedExtensions = false;
+
+  async introspectExtensions(): Promise<string[]> {
+    return [];
+  }
+
+  createExtension(_schema: string, name: string): string[] {
+    throw new Error(
+      `SQLite.Schema: extension '${name}' cannot be created — SQLite has no installable ` +
+        `extensions a schema pass can provision.`,
+    );
+  }
+
+  dropExtension(_schema: string, name: string): string[] {
+    throw new Error(`SQLite.Schema: extension '${name}' cannot be dropped.`);
+  }
+
   canReclaim(id: SchemaObjectId): ChangeSafety {
-    if (id.kind === "foreignKey") {
+    if (id.kind === "foreignKey" || id.kind === "check") {
       return {
         safe: false,
         reason:
-          "SQLite has no DROP CONSTRAINT, so this foreign key cannot be dropped in place. " +
-          "Rebuild the table in a 'migrations:' entry; the tombstone is cleared when the " +
-          "constraint is gone.",
+          `SQLite has no DROP CONSTRAINT, so this ${id.kind === "check" ? "check" : "foreign key"} ` +
+          "cannot be dropped in place. Rebuild the table in a 'migrations:' entry; the tombstone " +
+          "is cleared when the constraint is gone.",
       };
     }
     return { safe: true };
@@ -397,4 +588,34 @@ export class SqliteSchemaDriver implements SchemaDriver {
   dropTable(schema: string, table: string): string[] {
     return [`DROP TABLE IF EXISTS ${this.qualify(schema, table)}`];
   }
+
+  /** SQLite has had upsert since 3.24, so both engines render the same statement
+   *  SHAPE — which is why it lives in `row-statements.ts` and only the dialect
+   *  is answered here. */
+  get #rowDialect(): RowDialect {
+    return {
+      quote: (name) => this.quote(name),
+      literal,
+      qualify: (schema, table) => this.qualify(schema, table),
+      excludedAlias: "excluded",
+    };
+  }
+
+  upsertRow(
+    schema: string,
+    table: string,
+    key: readonly string[],
+    row: Record<string, unknown>,
+  ): string[] {
+    return upsertRowStatements(this.#rowDialect, schema, table, key, row);
+  }
+
+  deleteRow(
+    schema: string,
+    table: string,
+    key: readonly string[],
+    row: Record<string, unknown>,
+  ): string[] {
+    return deleteRowStatements(this.#rowDialect, schema, table, key, row);
+  }
 }

package/src/schema/table-controller.ts

@@ -1,7 +1,9 @@
 import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
 import {
+  enumReferenceResolver,
   normalizeTable,
   tableReferenceResolver,
+  type ColumnTypeResolver,
   type DeclaredTable,
   type RawTable,
 } from "@telorun/sql";
@@ -17,7 +19,11 @@ export class SqliteTableResource implements ResourceInstance {
   readonly declaration: DeclaredTable;
 
   constructor(raw: RawTable, ctx: ResourceContext) {
-    this.declaration = normalizeTable(raw, tableReferenceResolver(ctx, "SQLite.Table", raw.table));
+    this.declaration = normalizeTable(
+      raw,
+      tableReferenceResolver(ctx, "SQLite.Table", raw.table),
+      sqliteColumnType(ctx, raw.table),
+    );
   }
 
   /** The physical table name, read by consumers that build statements against
@@ -31,6 +37,27 @@ export class SqliteTableResource implements ResourceInstance {
   }
 }
 
+/** SQLite has no named types, so an enum column's engine-native type is the
+ *  enum's declared base storage class; the values ride along as a CHECK. */
+function sqliteColumnType(ctx: ResourceContext, table: string): ColumnTypeResolver {
+  const resolveEnum = enumReferenceResolver(ctx, "SQLite.Enum", table);
+  return (value, column) => {
+    const declared = resolveEnum(value, column);
+    if (!declared) return { type: String(value) };
+    if (!declared.baseType) {
+      throw new Error(
+        `SQLite.Table '${table}': column '${column}' references enum '${declared.typeName}', ` +
+          `which declares no 'baseType'. SQLite has no named types, so something has to say ` +
+          `which storage class the values sit in.`,
+      );
+    }
+    return {
+      type: declared.baseType,
+      enum: { typeName: declared.typeName, values: declared.values },
+    };
+  };
+}
+
 export function register(): void {}
 
 export async function create(