emdash 0.0.0-b → 0.0.2

package/src/database/dialect-helpers.ts

@@ -0,0 +1,138 @@
+/**
+ * Dialect-specific SQL helpers
+ *
+ * Every function takes a Kysely `db` instance and detects the dialect from
+ * the adapter class. No module-level state, no globals, no heuristics —
+ * the adapter is the source of truth.
+ *
+ * This is NOT an ORM abstraction — just targeted helpers for the ~15 places
+ * that use raw dialect-specific SQL. Most Kysely schema builder code already
+ * works cross-dialect.
+ */
+
+import type { ColumnDataType, Kysely, RawBuilder } from "kysely";
+import { sql } from "kysely";
+
+import type { DatabaseDialectType } from "../db/adapters.js";
+
+export type { DatabaseDialectType };
+
+/**
+ * Detect dialect type from a Kysely instance via the adapter class name.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function detectDialect(db: Kysely<any>): DatabaseDialectType {
+	const name = db.getExecutor().adapter.constructor.name;
+	if (name === "PostgresAdapter") return "postgres";
+	return "sqlite";
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function isSqlite(db: Kysely<any>): boolean {
+	return detectDialect(db) === "sqlite";
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function isPostgres(db: Kysely<any>): boolean {
+	return detectDialect(db) === "postgres";
+}
+
+/**
+ * Default timestamp expression for column defaults.
+ * Wrapped in parens for use in CREATE TABLE ... DEFAULT (...).
+ *
+ * sqlite:   (datetime('now'))
+ * postgres: CURRENT_TIMESTAMP
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function currentTimestamp(db: Kysely<any>): RawBuilder<string> {
+	if (isPostgres(db)) {
+		return sql`CURRENT_TIMESTAMP`;
+	}
+	return sql`(datetime('now'))`;
+}
+
+/**
+ * Timestamp expression for use in WHERE clauses and SET expressions.
+ * No wrapping parens.
+ *
+ * sqlite:   datetime('now')
+ * postgres: CURRENT_TIMESTAMP
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function currentTimestampValue(db: Kysely<any>): RawBuilder<string> {
+	if (isPostgres(db)) {
+		return sql`CURRENT_TIMESTAMP`;
+	}
+	return sql`datetime('now')`;
+}
+
+/**
+ * Check if a table exists in the database.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export async function tableExists(db: Kysely<any>, tableName: string): Promise<boolean> {
+	if (isPostgres(db)) {
+		const result = await sql<{ exists: boolean }>`
+			SELECT EXISTS(
+				SELECT 1 FROM information_schema.tables
+				WHERE table_schema = 'public' AND table_name = ${tableName}
+			) as exists
+		`.execute(db);
+		return result.rows[0]?.exists === true;
+	}
+
+	const result = await sql<{ name: string }>`
+		SELECT name FROM sqlite_master
+		WHERE type = 'table' AND name = ${tableName}
+	`.execute(db);
+	return result.rows.length > 0;
+}
+
+/**
+ * List tables matching a LIKE pattern.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export async function listTablesLike(db: Kysely<any>, pattern: string): Promise<string[]> {
+	if (isPostgres(db)) {
+		const result = await sql<{ table_name: string }>`
+			SELECT table_name FROM information_schema.tables
+			WHERE table_schema = 'public' AND table_name LIKE ${pattern}
+		`.execute(db);
+		return result.rows.map((r) => r.table_name);
+	}
+
+	const result = await sql<{ name: string }>`
+		SELECT name FROM sqlite_master
+		WHERE type = 'table' AND name LIKE ${pattern}
+	`.execute(db);
+	return result.rows.map((r) => r.name);
+}
+
+/**
+ * Column type for binary data.
+ *
+ * sqlite:   blob
+ * postgres: bytea
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function binaryType(db: Kysely<any>): ColumnDataType {
+	if (isPostgres(db)) {
+		return "bytea";
+	}
+	return "blob";
+}
+
+/**
+ * SQL expression for extracting a field from a JSON/JSONB column.
+ *
+ * sqlite:   json_extract(column, '$.path')
+ * postgres: column->>'path'
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function jsonExtractExpr(db: Kysely<any>, column: string, path: string): string {
+	if (isPostgres(db)) {
+		return `${column}->>'${path}'`;
+	}
+	return `json_extract(${column}, '$.${path}')`;
+}

package/src/database/index.ts

@@ -0,0 +1,5 @@
+export { createDatabase, EmDashDatabaseError } from "./connection.js";
+export type { DatabaseConfig } from "./connection.js";
+export { runMigrations, getMigrationStatus, rollbackMigration } from "./migrations/runner.js";
+export type { MigrationStatus } from "./migrations/runner.js";
+export type * from "./types.js";

package/src/database/migrations/001_initial.ts

@@ -0,0 +1,170 @@
+import type { Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+/**
+ * Initial schema migration
+ *
+ * Note: Content tables (ec_posts, ec_pages, etc.) are created dynamically
+ * by the SchemaRegistry when collections are added via the admin UI.
+ * This migration only creates system tables.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// Revisions - stores snapshots of content entries
+	// References entries in ec_* tables by collection + entry_id
+	await db.schema
+		.createTable("revisions")
+		.ifNotExists()
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("collection", "text", (col) => col.notNull()) // e.g., 'posts'
+		.addColumn("entry_id", "text", (col) => col.notNull()) // ID in the ec_* table
+		.addColumn("data", "text", (col) => col.notNull()) // JSON snapshot of all fields
+		.addColumn("author_id", "text")
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.execute();
+
+	await db.schema
+		.createIndex("idx_revisions_entry")
+		.ifNotExists()
+		.on("revisions")
+		.columns(["collection", "entry_id"])
+		.execute();
+
+	// Taxonomies
+	await db.schema
+		.createTable("taxonomies")
+		.ifNotExists()
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("name", "text", (col) => col.notNull())
+		.addColumn("slug", "text", (col) => col.notNull())
+		.addColumn("label", "text", (col) => col.notNull())
+		.addColumn("parent_id", "text")
+		.addColumn("data", "text")
+		.addUniqueConstraint("taxonomies_name_slug_unique", ["name", "slug"])
+		.addForeignKeyConstraint("taxonomies_parent_fk", ["parent_id"], "taxonomies", ["id"], (cb) =>
+			cb.onDelete("set null"),
+		)
+		.execute();
+
+	await db.schema
+		.createIndex("idx_taxonomies_name")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("name")
+		.execute();
+
+	// Content-Taxonomy junction - references entries in ec_* tables
+	await db.schema
+		.createTable("content_taxonomies")
+		.ifNotExists()
+		.addColumn("collection", "text", (col) => col.notNull()) // e.g., 'posts'
+		.addColumn("entry_id", "text", (col) => col.notNull()) // ID in the ec_* table
+		.addColumn("taxonomy_id", "text", (col) => col.notNull())
+		.addPrimaryKeyConstraint("content_taxonomies_pk", ["collection", "entry_id", "taxonomy_id"])
+		.addForeignKeyConstraint(
+			"content_taxonomies_taxonomy_fk",
+			["taxonomy_id"],
+			"taxonomies",
+			["id"],
+			(cb) => cb.onDelete("cascade"),
+		)
+		.execute();
+
+	// Media
+	await db.schema
+		.createTable("media")
+		.ifNotExists()
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("filename", "text", (col) => col.notNull())
+		.addColumn("mime_type", "text", (col) => col.notNull())
+		.addColumn("size", "integer")
+		.addColumn("width", "integer")
+		.addColumn("height", "integer")
+		.addColumn("alt", "text")
+		.addColumn("caption", "text")
+		.addColumn("storage_key", "text", (col) => col.notNull())
+		.addColumn("content_hash", "text") // xxHash64 for deduplication
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("author_id", "text")
+		.execute();
+
+	await db.schema
+		.createIndex("idx_media_content_hash")
+		.ifNotExists()
+		.on("media")
+		.column("content_hash")
+		.execute();
+
+	// Users
+	await db.schema
+		.createTable("users")
+		.ifNotExists()
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("email", "text", (col) => col.notNull().unique())
+		.addColumn("password_hash", "text", (col) => col.notNull())
+		.addColumn("name", "text")
+		.addColumn("role", "text", (col) => col.defaultTo("subscriber"))
+		.addColumn("avatar_id", "text")
+		.addColumn("data", "text")
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.execute();
+
+	await db.schema
+		.createIndex("idx_users_email")
+		.ifNotExists()
+		.on("users")
+		.column("email")
+		.execute();
+
+	// Options (key-value store)
+	await db.schema
+		.createTable("options")
+		.ifNotExists()
+		.addColumn("name", "text", (col) => col.primaryKey())
+		.addColumn("value", "text", (col) => col.notNull())
+		.execute();
+
+	// Audit logs (security events)
+	await db.schema
+		.createTable("audit_logs")
+		.ifNotExists()
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("timestamp", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("actor_id", "text")
+		.addColumn("actor_ip", "text")
+		.addColumn("action", "text", (col) => col.notNull())
+		.addColumn("resource_type", "text")
+		.addColumn("resource_id", "text")
+		.addColumn("details", "text")
+		.addColumn("status", "text")
+		.execute();
+
+	await db.schema
+		.createIndex("idx_audit_actor")
+		.ifNotExists()
+		.on("audit_logs")
+		.column("actor_id")
+		.execute();
+	await db.schema
+		.createIndex("idx_audit_action")
+		.ifNotExists()
+		.on("audit_logs")
+		.column("action")
+		.execute();
+	await db.schema
+		.createIndex("idx_audit_timestamp")
+		.ifNotExists()
+		.on("audit_logs")
+		.column("timestamp")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("audit_logs").execute();
+	await db.schema.dropTable("options").execute();
+	await db.schema.dropTable("users").execute();
+	await db.schema.dropTable("media").execute();
+	await db.schema.dropTable("content_taxonomies").execute();
+	await db.schema.dropTable("taxonomies").execute();
+	await db.schema.dropTable("revisions").execute();
+}

package/src/database/migrations/002_media_status.ts

@@ -0,0 +1,26 @@
+import type { Kysely } from "kysely";
+
+/**
+ * Add status column to media table for tracking upload state.
+ * Status values: 'pending' | 'ready' | 'failed'
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.alterTable("media")
+		.addColumn("status", "text", (col) => col.notNull().defaultTo("ready"))
+		.execute();
+
+	await db.schema.createIndex("idx_media_status").on("media").column("status").execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropIndex("idx_media_status").execute();
+
+	// Note: SQLite doesn't support DROP COLUMN directly
+	// For a proper down migration in SQLite, you'd need to:
+	// 1. Create a new table without the column
+	// 2. Copy data over
+	// 3. Drop old table
+	// 4. Rename new table
+	// For simplicity, we'll leave this as a no-op since down migrations are rarely used
+}

package/src/database/migrations/003_schema_registry.ts

@@ -0,0 +1,79 @@
+import type { Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+/**
+ * Migration: Schema Registry Tables
+ *
+ * Creates the schema registry tables that store collection and field definitions.
+ * This enables dynamic schema management where D1 is the source of truth.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// Collection definitions (like WordPress post types, but stored in DB)
+	await db.schema
+		.createTable("_emdash_collections")
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("slug", "text", (col) => col.notNull().unique())
+		.addColumn("label", "text", (col) => col.notNull())
+		.addColumn("label_singular", "text")
+		.addColumn("description", "text")
+		.addColumn("icon", "text")
+		.addColumn("supports", "text") // JSON array: ["revisions", "drafts", "preview"]
+		.addColumn("source", "text") // 'template:blog', 'import:wordpress', 'manual'
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.execute();
+
+	// Field definitions for each collection
+	await db.schema
+		.createTable("_emdash_fields")
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("collection_id", "text", (col) => col.notNull())
+		.addColumn("slug", "text", (col) => col.notNull())
+		.addColumn("label", "text", (col) => col.notNull())
+		.addColumn("type", "text", (col) => col.notNull()) // 'string', 'number', 'boolean', 'portableText', etc.
+		.addColumn("column_type", "text", (col) => col.notNull()) // 'TEXT', 'REAL', 'INTEGER', 'JSON'
+		.addColumn("required", "integer", (col) => col.defaultTo(0)) // boolean as 0/1
+		.addColumn("unique", "integer", (col) => col.defaultTo(0)) // boolean as 0/1
+		.addColumn("default_value", "text") // JSON-encoded default
+		.addColumn("validation", "text") // JSON: { min: 0, max: 100, pattern: "^[a-z]+$" }
+		.addColumn("widget", "text") // UI widget hint: 'textarea', 'richtext', 'select'
+		.addColumn("options", "text") // JSON: widget-specific config
+		.addColumn("sort_order", "integer", (col) => col.defaultTo(0))
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addForeignKeyConstraint(
+			"fields_collection_fk",
+			["collection_id"],
+			"_emdash_collections",
+			["id"],
+			(cb) => cb.onDelete("cascade"),
+		)
+		.execute();
+
+	// Unique constraint on collection + field slug
+	await db.schema
+		.createIndex("idx_fields_collection_slug")
+		.on("_emdash_fields")
+		.columns(["collection_id", "slug"])
+		.unique()
+		.execute();
+
+	// Index for faster field lookups
+	await db.schema
+		.createIndex("idx_fields_collection")
+		.on("_emdash_fields")
+		.column("collection_id")
+		.execute();
+
+	// Index for sorting
+	await db.schema
+		.createIndex("idx_fields_sort")
+		.on("_emdash_fields")
+		.columns(["collection_id", "sort_order"])
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_emdash_fields").execute();
+	await db.schema.dropTable("_emdash_collections").execute();
+}

package/src/database/migrations/004_plugins.ts

@@ -0,0 +1,62 @@
+import type { Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+/**
+ * Migration: Plugin System Tables
+ *
+ * Creates the plugin storage table and plugin state tracking.
+ * Plugin storage uses a document store with declared indexes.
+ *
+ * @see PLUGIN-SYSTEM.md § Plugin Storage
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// Core storage table for plugin documents
+	await db.schema
+		.createTable("_plugin_storage")
+		.addColumn("plugin_id", "text", (col) => col.notNull())
+		.addColumn("collection", "text", (col) => col.notNull())
+		.addColumn("id", "text", (col) => col.notNull())
+		.addColumn("data", "text", (col) => col.notNull()) // JSON
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addPrimaryKeyConstraint("pk_plugin_storage", ["plugin_id", "collection", "id"])
+		.execute();
+
+	// Base index for listing
+	await db.schema
+		.createIndex("idx_plugin_storage_list")
+		.on("_plugin_storage")
+		.columns(["plugin_id", "collection", "created_at"])
+		.execute();
+
+	// Plugin state tracking for lifecycle hooks
+	await db.schema
+		.createTable("_plugin_state")
+		.addColumn("plugin_id", "text", (col) => col.primaryKey())
+		.addColumn("version", "text", (col) => col.notNull())
+		.addColumn("status", "text", (col) => col.notNull().defaultTo("installed")) // installed, active, inactive
+		.addColumn("installed_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("activated_at", "text")
+		.addColumn("deactivated_at", "text")
+		.addColumn("data", "text") // JSON for plugin-specific state
+		.execute();
+
+	// Index tracking for dynamic expression indexes on plugin storage
+	// This tracks which indexes have been created so we can manage them
+	await db.schema
+		.createTable("_plugin_indexes")
+		.addColumn("plugin_id", "text", (col) => col.notNull())
+		.addColumn("collection", "text", (col) => col.notNull())
+		.addColumn("index_name", "text", (col) => col.notNull())
+		.addColumn("fields", "text", (col) => col.notNull()) // JSON array of field paths
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addPrimaryKeyConstraint("pk_plugin_indexes", ["plugin_id", "collection", "index_name"])
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_plugin_indexes").execute();
+	await db.schema.dropTable("_plugin_state").execute();
+	await db.schema.dropTable("_plugin_storage").execute();
+}

package/src/database/migrations/005_menus.ts

@@ -0,0 +1,67 @@
+import type { Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+/**
+ * Navigation Menus migration
+ *
+ * Creates tables for admin-editable navigation menus.
+ * Menu items can reference content entries, taxonomy terms, or custom URLs.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// Menu definitions
+	await db.schema
+		.createTable("_emdash_menus")
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("name", "text", (col) => col.notNull().unique())
+		.addColumn("label", "text", (col) => col.notNull())
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.execute();
+
+	// Menu items (ordered, hierarchical)
+	await db.schema
+		.createTable("_emdash_menu_items")
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("menu_id", "text", (col) => col.notNull())
+		.addColumn("parent_id", "text")
+		.addColumn("sort_order", "integer", (col) => col.notNull().defaultTo(0))
+		.addColumn("type", "text", (col) => col.notNull()) // 'page', 'post', 'custom', 'taxonomy', 'collection'
+		.addColumn("reference_collection", "text")
+		.addColumn("reference_id", "text")
+		.addColumn("custom_url", "text")
+		.addColumn("label", "text", (col) => col.notNull())
+		.addColumn("title_attr", "text")
+		.addColumn("target", "text")
+		.addColumn("css_classes", "text")
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.addForeignKeyConstraint("menu_items_menu_fk", ["menu_id"], "_emdash_menus", ["id"], (cb) =>
+			cb.onDelete("cascade"),
+		)
+		.addForeignKeyConstraint(
+			"menu_items_parent_fk",
+			["parent_id"],
+			"_emdash_menu_items",
+			["id"],
+			(cb) => cb.onDelete("cascade"),
+		)
+		.execute();
+
+	// Index for efficient menu item queries
+	await db.schema
+		.createIndex("idx_menu_items_menu")
+		.on("_emdash_menu_items")
+		.columns(["menu_id", "sort_order"])
+		.execute();
+
+	await db.schema
+		.createIndex("idx_menu_items_parent")
+		.on("_emdash_menu_items")
+		.column("parent_id")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_emdash_menu_items").execute();
+	await db.schema.dropTable("_emdash_menus").execute();
+}

package/src/database/migrations/006_taxonomy_defs.ts

@@ -0,0 +1,51 @@
+import type { Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+/**
+ * Taxonomy definitions migration
+ *
+ * Adds _emdash_taxonomy_defs table to store taxonomy definitions (category, tag, custom)
+ * and seeds default category and tag taxonomies.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// Taxonomy definitions (what taxonomies exist)
+	await db.schema
+		.createTable("_emdash_taxonomy_defs")
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("name", "text", (col) => col.notNull().unique()) // 'category', 'tag'
+		.addColumn("label", "text", (col) => col.notNull()) // 'Categories'
+		.addColumn("label_singular", "text") // 'Category'
+		.addColumn("hierarchical", "integer", (col) => col.defaultTo(0)) // 0 or 1
+		.addColumn("collections", "text") // JSON array: ["posts"]
+		.addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(db)))
+		.execute();
+
+	// Seed default taxonomies
+	await db
+		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Kysely migration runs against unknown schema
+		.insertInto("_emdash_taxonomy_defs" as never)
+		.values([
+			{
+				id: "taxdef_category",
+				name: "category",
+				label: "Categories",
+				label_singular: "Category",
+				hierarchical: 1,
+				collections: JSON.stringify(["posts"]),
+			},
+			{
+				id: "taxdef_tag",
+				name: "tag",
+				label: "Tags",
+				label_singular: "Tag",
+				hierarchical: 0,
+				collections: JSON.stringify(["posts"]),
+			},
+		])
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_emdash_taxonomy_defs").execute();
+}

package/src/database/migrations/007_widgets.ts

@@ -0,0 +1,42 @@
+import { type Kysely, sql } from "kysely";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// Widget areas table
+	await db.schema
+		.createTable("_emdash_widget_areas")
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("name", "text", (col) => col.notNull().unique())
+		.addColumn("label", "text", (col) => col.notNull())
+		.addColumn("description", "text")
+		.addColumn("created_at", "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`))
+		.execute();
+
+	// Widgets table
+	await db.schema
+		.createTable("_emdash_widgets")
+		.addColumn("id", "text", (col) => col.primaryKey())
+		.addColumn("area_id", "text", (col) =>
+			col.notNull().references("_emdash_widget_areas.id").onDelete("cascade"),
+		)
+		.addColumn("sort_order", "integer", (col) => col.notNull().defaultTo(0))
+		.addColumn("type", "text", (col) => col.notNull()) // 'content', 'menu', 'component'
+		.addColumn("title", "text")
+		.addColumn("content", "text") // JSON: Portable Text for content type
+		.addColumn("menu_name", "text") // For menu type
+		.addColumn("component_id", "text") // For component type: 'core:recent-posts'
+		.addColumn("component_props", "text") // JSON: props for component
+		.addColumn("created_at", "text", (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`))
+		.execute();
+
+	// Index for efficient lookups by area and order
+	await db.schema
+		.createIndex("idx_widgets_area")
+		.on("_emdash_widgets")
+		.columns(["area_id", "sort_order"])
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropTable("_emdash_widgets").execute();
+	await db.schema.dropTable("_emdash_widget_areas").execute();
+}