dineway 0.1.3

package/dist/registry-DSd1GWB8.mjs

@@ -0,0 +1,851 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { a as isSqlite, c as tableExists, n as currentTimestamp, s as listTablesLike } from "./dialect-helpers-B9uSp2GJ.mjs";
+import { t as validateIdentifier } from "./validate-CqRJb_xU.mjs";
+import { i as RESERVED_FIELD_SLUGS, n as FIELD_TYPE_TO_COLUMN, r as RESERVED_COLLECTION_SLUGS } from "./types-DuNbGKjF.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/database/transaction.ts
+/**
+* Run a callback inside a transaction if supported, or directly if not.
+*
+* Probes the database once on first call to determine if transactions work.
+* The result is cached for the lifetime of the process/worker.
+*/
+let transactionsSupported = null;
+const TRANSACTIONS_NOT_SUPPORTED_RE = /transactions are not supported/i;
+async function withTransaction(db, fn) {
+	if (transactionsSupported === true) return db.transaction().execute(fn);
+	if (transactionsSupported === false) return fn(db);
+	try {
+		const result = await db.transaction().execute(fn);
+		transactionsSupported = true;
+		return result;
+	} catch (error) {
+		if (error instanceof Error && TRANSACTIONS_NOT_SUPPORTED_RE.test(error.message)) {
+			transactionsSupported = false;
+			return fn(db);
+		}
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/search/fts-manager.ts
+/**
+* FTS5 Manager
+*
+* Handles creation, deletion, and management of FTS5 virtual tables
+* for full-text search on content collections.
+*/
+var FTSManager = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Validate a collection slug and its searchable field names.
+	* Must be called before any raw SQL interpolation.
+	*/
+	validateInputs(collectionSlug, searchableFields) {
+		validateIdentifier(collectionSlug, "collection slug");
+		if (searchableFields) for (const field of searchableFields) validateIdentifier(field, "searchable field name");
+	}
+	/**
+	* Get the FTS table name for a collection
+	* Uses _dineway_ prefix to clearly mark as internal/system table
+	*/
+	getFtsTableName(collectionSlug) {
+		return `_dineway_fts_${collectionSlug}`;
+	}
+	/**
+	* Get the content table name for a collection
+	*/
+	getContentTableName(collectionSlug) {
+		return `ec_${collectionSlug}`;
+	}
+	/**
+	* Check if an FTS table exists for a collection
+	*/
+	async ftsTableExists(collectionSlug) {
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		return tableExists(this.db, ftsTable);
+	}
+	/**
+	* Create an FTS5 virtual table for a collection.
+	* FTS5 is SQLite-only; on other dialects this is a no-op.
+	*
+	* @param collectionSlug - The collection slug
+	* @param searchableFields - Array of field names to index
+	* @param weights - Optional field weights for ranking
+	*/
+	async createFtsTable(collectionSlug, searchableFields, _weights) {
+		if (!isSqlite(this.db)) return;
+		this.validateInputs(collectionSlug, searchableFields);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		const contentTable = this.getContentTableName(collectionSlug);
+		const columns = [
+			"id UNINDEXED",
+			"locale UNINDEXED",
+			...searchableFields
+		].join(", ");
+		await sql.raw(`
+			CREATE VIRTUAL TABLE IF NOT EXISTS "${ftsTable}" USING fts5(
+				${columns},
+				content='${contentTable}',
+				content_rowid='rowid',
+				tokenize='porter unicode61'
+			)
+		`).execute(this.db);
+		await this.createTriggers(collectionSlug, searchableFields);
+	}
+	/**
+	* Create triggers to keep FTS table in sync with content table
+	*/
+	async createTriggers(collectionSlug, searchableFields) {
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		const contentTable = this.getContentTableName(collectionSlug);
+		const fieldList = searchableFields.join(", ");
+		const newFieldList = searchableFields.map((f) => `NEW.${f}`).join(", ");
+		await sql.raw(`
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_insert" 
+			AFTER INSERT ON "${contentTable}" 
+			BEGIN
+				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+				VALUES (NEW.rowid, NEW.id, NEW.locale, ${newFieldList});
+			END
+		`).execute(this.db);
+		await sql.raw(`
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_update" 
+			AFTER UPDATE ON "${contentTable}" 
+			BEGIN
+				DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
+				INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+				VALUES (NEW.rowid, NEW.id, NEW.locale, ${newFieldList});
+			END
+		`).execute(this.db);
+		await sql.raw(`
+			CREATE TRIGGER IF NOT EXISTS "${ftsTable}_delete" 
+			AFTER DELETE ON "${contentTable}" 
+			BEGIN
+				DELETE FROM "${ftsTable}" WHERE rowid = OLD.rowid;
+			END
+		`).execute(this.db);
+	}
+	/**
+	* Drop triggers for a collection
+	*/
+	async dropTriggers(collectionSlug) {
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_insert"`).execute(this.db);
+		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_update"`).execute(this.db);
+		await sql.raw(`DROP TRIGGER IF EXISTS "${ftsTable}_delete"`).execute(this.db);
+	}
+	/**
+	* Drop the FTS table and triggers for a collection
+	*/
+	async dropFtsTable(collectionSlug) {
+		if (!isSqlite(this.db)) return;
+		this.validateInputs(collectionSlug);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		await this.dropTriggers(collectionSlug);
+		await sql.raw(`DROP TABLE IF EXISTS "${ftsTable}"`).execute(this.db);
+	}
+	/**
+	* Rebuild the FTS index for a collection
+	*
+	* This is useful after bulk imports or if the index gets out of sync.
+	*/
+	async rebuildIndex(collectionSlug, searchableFields, weights) {
+		if (!isSqlite(this.db)) return;
+		await this.dropFtsTable(collectionSlug);
+		await this.createFtsTable(collectionSlug, searchableFields, weights);
+		await this.populateFromContent(collectionSlug, searchableFields);
+	}
+	/**
+	* Populate the FTS table from existing content
+	*/
+	async populateFromContent(collectionSlug, searchableFields) {
+		if (!isSqlite(this.db)) return;
+		this.validateInputs(collectionSlug, searchableFields);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		const contentTable = this.getContentTableName(collectionSlug);
+		const fieldList = searchableFields.join(", ");
+		await sql.raw(`
+			INSERT INTO "${ftsTable}"(rowid, id, locale, ${fieldList})
+			SELECT rowid, id, locale, ${fieldList} FROM "${contentTable}"
+			WHERE deleted_at IS NULL
+		`).execute(this.db);
+	}
+	/**
+	* Get the search configuration for a collection
+	*/
+	async getSearchConfig(collectionSlug) {
+		const result = await this.db.selectFrom("_dineway_collections").select("search_config").where("slug", "=", collectionSlug).executeTakeFirst();
+		if (!result?.search_config) return null;
+		try {
+			const parsed = JSON.parse(result.search_config);
+			if (typeof parsed !== "object" || parsed === null || !("enabled" in parsed) || typeof parsed.enabled !== "boolean") return null;
+			const config = { enabled: parsed.enabled };
+			if ("weights" in parsed && typeof parsed.weights === "object" && parsed.weights !== null) {
+				const weights = {};
+				for (const [k, v] of Object.entries(parsed.weights)) if (typeof v === "number") weights[k] = v;
+				config.weights = weights;
+			}
+			return config;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Update the search configuration for a collection
+	*/
+	async setSearchConfig(collectionSlug, config) {
+		await this.db.updateTable("_dineway_collections").set({ search_config: JSON.stringify(config) }).where("slug", "=", collectionSlug).execute();
+	}
+	/**
+	* Get searchable fields for a collection
+	*/
+	async getSearchableFields(collectionSlug) {
+		const collection = await this.db.selectFrom("_dineway_collections").select("id").where("slug", "=", collectionSlug).executeTakeFirst();
+		if (!collection) return [];
+		return (await this.db.selectFrom("_dineway_fields").select("slug").where("collection_id", "=", collection.id).where("searchable", "=", 1).execute()).map((f) => f.slug);
+	}
+	/**
+	* Enable search for a collection
+	*
+	* Creates the FTS table and triggers, and populates from existing content.
+	*/
+	async enableSearch(collectionSlug, options) {
+		if (!isSqlite(this.db)) throw new Error("Full-text search is only available with SQLite databases");
+		const searchableFields = await this.getSearchableFields(collectionSlug);
+		if (searchableFields.length === 0) throw new Error(`No searchable fields defined for collection "${collectionSlug}". Mark at least one field as searchable before enabling search.`);
+		await this.createFtsTable(collectionSlug, searchableFields, options?.weights);
+		await this.populateFromContent(collectionSlug, searchableFields);
+		await this.setSearchConfig(collectionSlug, {
+			enabled: true,
+			weights: options?.weights
+		});
+	}
+	/**
+	* Disable search for a collection
+	*
+	* Drops the FTS table and triggers.
+	*/
+	async disableSearch(collectionSlug) {
+		if (!isSqlite(this.db)) return;
+		await this.dropFtsTable(collectionSlug);
+		await this.setSearchConfig(collectionSlug, { enabled: false });
+	}
+	/**
+	* Get index statistics for a collection
+	*/
+	async getIndexStats(collectionSlug) {
+		if (!isSqlite(this.db)) return null;
+		this.validateInputs(collectionSlug);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		if (!await this.ftsTableExists(collectionSlug)) return null;
+		return { indexed: (await sql`
+			SELECT COUNT(*) as count FROM "${sql.raw(ftsTable)}"
+		`.execute(this.db)).rows[0]?.count ?? 0 };
+	}
+	/**
+	* Verify FTS index integrity and rebuild if corrupted.
+	*
+	* Checks for row count mismatch between content table and FTS table.
+	*
+	* Returns true if the index was rebuilt, false if it was healthy.
+	*/
+	async verifyAndRepairIndex(collectionSlug) {
+		if (!isSqlite(this.db)) return false;
+		this.validateInputs(collectionSlug);
+		const ftsTable = this.getFtsTableName(collectionSlug);
+		const contentTable = this.getContentTableName(collectionSlug);
+		if (!await this.ftsTableExists(collectionSlug)) return false;
+		const contentCount = await sql`
+			SELECT COUNT(*) as count FROM ${sql.ref(contentTable)}
+			WHERE deleted_at IS NULL
+		`.execute(this.db);
+		const ftsCount = await sql`
+			SELECT COUNT(*) as count FROM "${sql.raw(ftsTable)}"
+		`.execute(this.db);
+		const contentRows = contentCount.rows[0]?.count ?? 0;
+		const ftsRows = ftsCount.rows[0]?.count ?? 0;
+		if (contentRows !== ftsRows) {
+			console.warn(`FTS index for "${collectionSlug}" has ${ftsRows} rows but content table has ${contentRows}. Rebuilding.`);
+			const fields = await this.getSearchableFields(collectionSlug);
+			const config = await this.getSearchConfig(collectionSlug);
+			if (fields.length > 0) await this.rebuildIndex(collectionSlug, fields, config?.weights);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Verify and repair FTS indexes for all search-enabled collections.
+	*
+	* Intended to run at startup to auto-heal any corruption from
+	* previous process crashes.
+	*/
+	async verifyAndRepairAll() {
+		if (!isSqlite(this.db)) return 0;
+		const collections = await this.db.selectFrom("_dineway_collections").select("slug").where("search_config", "is not", null).execute();
+		let repaired = 0;
+		for (const { slug } of collections) {
+			if (!(await this.getSearchConfig(slug))?.enabled) continue;
+			try {
+				if (await this.verifyAndRepairIndex(slug)) repaired++;
+			} catch (error) {
+				console.error(`Failed to verify/repair FTS index for "${slug}":`, error);
+			}
+		}
+		return repaired;
+	}
+};
+
+//#endregion
+//#region src/schema/registry.ts
+var registry_exports = /* @__PURE__ */ __exportAll({
+	SchemaError: () => SchemaError,
+	SchemaRegistry: () => SchemaRegistry
+});
+const SLUG_VALIDATION_PATTERN = /^[a-z][a-z0-9_]*$/;
+const EC_PREFIX_PATTERN = /^ec_/;
+const SINGLE_QUOTE_PATTERN = /'/g;
+const UNDERSCORE_PATTERN = /_/g;
+const WORD_BOUNDARY_PATTERN = /\b\w/g;
+/** Valid column types for runtime validation */
+const COLUMN_TYPES = new Set([
+	"TEXT",
+	"REAL",
+	"INTEGER",
+	"JSON"
+]);
+/** Valid collection source prefixes/values */
+const VALID_SOURCES = new Set([
+	"manual",
+	"discovered",
+	"seed"
+]);
+function isCollectionSource(value) {
+	return VALID_SOURCES.has(value) || value.startsWith("template:") || value.startsWith("import:");
+}
+function isFieldType(value) {
+	return value in FIELD_TYPE_TO_COLUMN;
+}
+function isColumnType(value) {
+	return COLUMN_TYPES.has(value);
+}
+/**
+* Error thrown when a schema operation fails
+*/
+var SchemaError = class extends Error {
+	constructor(message, code, details) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "SchemaError";
+	}
+};
+/**
+* Schema Registry
+*
+* Manages collection and field definitions stored in the database.
+* Handles runtime DDL operations (CREATE TABLE, ALTER TABLE).
+*/
+var SchemaRegistry = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* List all collections
+	*/
+	async listCollections() {
+		return (await this.db.selectFrom("_dineway_collections").selectAll().orderBy("slug", "asc").execute()).map(this.mapCollectionRow);
+	}
+	/**
+	* Get a collection by slug
+	*/
+	async getCollection(slug) {
+		const row = await this.db.selectFrom("_dineway_collections").where("slug", "=", slug).selectAll().executeTakeFirst();
+		return row ? this.mapCollectionRow(row) : null;
+	}
+	/**
+	* Get a collection with all its fields
+	*/
+	async getCollectionWithFields(slug) {
+		const collection = await this.getCollection(slug);
+		if (!collection) return null;
+		const fields = await this.listFields(collection.id);
+		return {
+			...collection,
+			fields
+		};
+	}
+	/**
+	* Create a new collection
+	*/
+	async createCollection(input) {
+		this.validateSlug(input.slug, "collection");
+		if (RESERVED_COLLECTION_SLUGS.includes(input.slug)) throw new SchemaError(`Collection slug "${input.slug}" is reserved`, "RESERVED_SLUG");
+		if (await this.getCollection(input.slug)) throw new SchemaError(`Collection "${input.slug}" already exists`, "COLLECTION_EXISTS");
+		const id = ulid();
+		const hasSeo = input.hasSeo ?? input.supports?.includes("seo") ?? false;
+		await withTransaction(this.db, async (trx) => {
+			await trx.insertInto("_dineway_collections").values({
+				id,
+				slug: input.slug,
+				label: input.label,
+				label_singular: input.labelSingular ?? null,
+				description: input.description ?? null,
+				icon: input.icon ?? null,
+				supports: input.supports ? JSON.stringify(input.supports) : null,
+				source: input.source ?? "manual",
+				has_seo: hasSeo ? 1 : 0,
+				comments_enabled: input.commentsEnabled ? 1 : 0,
+				url_pattern: input.urlPattern ?? null
+			}).execute();
+			await this.createContentTable(input.slug, trx);
+		});
+		const collection = await this.getCollection(input.slug);
+		if (!collection) throw new SchemaError("Failed to create collection", "CREATE_FAILED");
+		return collection;
+	}
+	/**
+	* Update a collection
+	*/
+	async updateCollection(slug, input) {
+		const existing = await this.getCollection(slug);
+		if (!existing) throw new SchemaError(`Collection "${slug}" not found`, "COLLECTION_NOT_FOUND");
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const supportsArray = input.supports ?? existing.supports;
+		const hasSeo = input.hasSeo !== void 0 ? input.hasSeo : input.supports !== void 0 ? supportsArray.includes("seo") : existing.hasSeo;
+		await this.db.updateTable("_dineway_collections").set({
+			label: input.label ?? existing.label,
+			label_singular: input.labelSingular ?? existing.labelSingular ?? null,
+			description: input.description ?? existing.description ?? null,
+			icon: input.icon ?? existing.icon ?? null,
+			supports: input.supports ? JSON.stringify(input.supports) : JSON.stringify(existing.supports),
+			url_pattern: input.urlPattern !== void 0 ? input.urlPattern ?? null : existing.urlPattern ?? null,
+			has_seo: hasSeo ? 1 : 0,
+			comments_enabled: input.commentsEnabled !== void 0 ? input.commentsEnabled ? 1 : 0 : existing.commentsEnabled ? 1 : 0,
+			comments_moderation: input.commentsModeration ?? existing.commentsModeration,
+			comments_closed_after_days: input.commentsClosedAfterDays !== void 0 ? input.commentsClosedAfterDays : existing.commentsClosedAfterDays,
+			comments_auto_approve_users: input.commentsAutoApproveUsers !== void 0 ? input.commentsAutoApproveUsers ? 1 : 0 : existing.commentsAutoApproveUsers ? 1 : 0,
+			updated_at: now
+		}).where("slug", "=", slug).execute();
+		const updated = await this.getCollection(slug);
+		if (!updated) throw new SchemaError("Failed to update collection", "UPDATE_FAILED");
+		return updated;
+	}
+	/**
+	* Delete a collection
+	*/
+	async deleteCollection(slug, options) {
+		const existing = await this.getCollection(slug);
+		if (!existing) throw new SchemaError(`Collection "${slug}" not found`, "COLLECTION_NOT_FOUND");
+		if (!options?.force) {
+			if (await this.collectionHasContent(slug)) throw new SchemaError(`Collection "${slug}" has content. Use force: true to delete.`, "COLLECTION_HAS_CONTENT");
+		}
+		await this.dropContentTable(slug);
+		await this.db.deleteFrom("_dineway_collections").where("id", "=", existing.id).execute();
+	}
+	/**
+	* List fields for a collection
+	*/
+	async listFields(collectionId) {
+		return (await this.db.selectFrom("_dineway_fields").where("collection_id", "=", collectionId).selectAll().orderBy("sort_order", "asc").orderBy("created_at", "asc").execute()).map(this.mapFieldRow);
+	}
+	/**
+	* Get a field by slug within a collection
+	*/
+	async getField(collectionSlug, fieldSlug) {
+		const collection = await this.getCollection(collectionSlug);
+		if (!collection) return null;
+		const row = await this.db.selectFrom("_dineway_fields").where("collection_id", "=", collection.id).where("slug", "=", fieldSlug).selectAll().executeTakeFirst();
+		return row ? this.mapFieldRow(row) : null;
+	}
+	/**
+	* Create a new field
+	*/
+	async createField(collectionSlug, input) {
+		const collection = await this.getCollection(collectionSlug);
+		if (!collection) throw new SchemaError(`Collection "${collectionSlug}" not found`, "COLLECTION_NOT_FOUND");
+		this.validateSlug(input.slug, "field");
+		if (RESERVED_FIELD_SLUGS.includes(input.slug)) throw new SchemaError(`Field slug "${input.slug}" is reserved`, "RESERVED_SLUG");
+		if (await this.getField(collectionSlug, input.slug)) throw new SchemaError(`Field "${input.slug}" already exists in collection "${collectionSlug}"`, "FIELD_EXISTS");
+		const id = ulid();
+		const columnType = FIELD_TYPE_TO_COLUMN[input.type];
+		const maxSort = await this.db.selectFrom("_dineway_fields").where("collection_id", "=", collection.id).select((eb) => eb.fn.max("sort_order").as("max")).executeTakeFirst();
+		const sortOrder = input.sortOrder ?? (maxSort?.max ?? -1) + 1;
+		await this.db.insertInto("_dineway_fields").values({
+			id,
+			collection_id: collection.id,
+			slug: input.slug,
+			label: input.label,
+			type: input.type,
+			column_type: columnType,
+			required: input.required ? 1 : 0,
+			unique: input.unique ? 1 : 0,
+			default_value: input.defaultValue !== void 0 ? JSON.stringify(input.defaultValue) : null,
+			validation: input.validation ? JSON.stringify(input.validation) : null,
+			widget: input.widget ?? null,
+			options: input.options ? JSON.stringify(input.options) : null,
+			sort_order: sortOrder,
+			searchable: input.searchable ? 1 : 0,
+			translatable: input.translatable === false ? 0 : 1
+		}).execute();
+		await this.addColumn(collectionSlug, input.slug, input.type, {
+			required: input.required,
+			defaultValue: input.defaultValue
+		});
+		const field = await this.getField(collectionSlug, input.slug);
+		if (!field) throw new SchemaError("Failed to create field", "CREATE_FAILED");
+		return field;
+	}
+	/**
+	* Update a field
+	*/
+	async updateField(collectionSlug, fieldSlug, input) {
+		const field = await this.getField(collectionSlug, fieldSlug);
+		if (!field) throw new SchemaError(`Field "${fieldSlug}" not found in collection "${collectionSlug}"`, "FIELD_NOT_FOUND");
+		await this.db.updateTable("_dineway_fields").set({
+			label: input.label ?? field.label,
+			required: input.required !== void 0 ? input.required ? 1 : 0 : field.required ? 1 : 0,
+			unique: input.unique !== void 0 ? input.unique ? 1 : 0 : field.unique ? 1 : 0,
+			searchable: input.searchable !== void 0 ? input.searchable ? 1 : 0 : field.searchable ? 1 : 0,
+			translatable: input.translatable !== void 0 ? input.translatable ? 1 : 0 : field.translatable ? 1 : 0,
+			default_value: input.defaultValue !== void 0 ? JSON.stringify(input.defaultValue) : field.defaultValue !== void 0 ? JSON.stringify(field.defaultValue) : null,
+			validation: input.validation ? JSON.stringify(input.validation) : field.validation ? JSON.stringify(field.validation) : null,
+			widget: input.widget ?? field.widget ?? null,
+			options: input.options ? JSON.stringify(input.options) : field.options ? JSON.stringify(field.options) : null,
+			sort_order: input.sortOrder ?? field.sortOrder
+		}).where("id", "=", field.id).execute();
+		const updated = await this.getField(collectionSlug, fieldSlug);
+		if (!updated) throw new SchemaError("Failed to update field", "UPDATE_FAILED");
+		if (input.searchable !== void 0 && input.searchable !== field.searchable) await this.rebuildSearchIndex(collectionSlug);
+		return updated;
+	}
+	/**
+	* Rebuild the search index for a collection
+	*
+	* Called when searchable fields change. If search is enabled for the collection,
+	* this will rebuild the FTS table with the updated field list.
+	*/
+	async rebuildSearchIndex(collectionSlug) {
+		const ftsManager = new FTSManager(this.db);
+		const config = await ftsManager.getSearchConfig(collectionSlug);
+		if (!config?.enabled) return;
+		const searchableFields = await ftsManager.getSearchableFields(collectionSlug);
+		if (searchableFields.length === 0) await ftsManager.disableSearch(collectionSlug);
+		else await ftsManager.rebuildIndex(collectionSlug, searchableFields, config.weights);
+	}
+	/**
+	* Delete a field
+	*/
+	async deleteField(collectionSlug, fieldSlug) {
+		const field = await this.getField(collectionSlug, fieldSlug);
+		if (!field) throw new SchemaError(`Field "${fieldSlug}" not found in collection "${collectionSlug}"`, "FIELD_NOT_FOUND");
+		await this.dropColumn(collectionSlug, fieldSlug);
+		await this.db.deleteFrom("_dineway_fields").where("id", "=", field.id).execute();
+	}
+	/**
+	* Reorder fields
+	*/
+	async reorderFields(collectionSlug, fieldSlugs) {
+		const collection = await this.getCollection(collectionSlug);
+		if (!collection) throw new SchemaError(`Collection "${collectionSlug}" not found`, "COLLECTION_NOT_FOUND");
+		for (let i = 0; i < fieldSlugs.length; i++) await this.db.updateTable("_dineway_fields").set({ sort_order: i }).where("collection_id", "=", collection.id).where("slug", "=", fieldSlugs[i]).execute();
+	}
+	/**
+	* Create a content table for a collection
+	*/
+	async createContentTable(slug, db) {
+		const conn = db ?? this.db;
+		const tableName = this.getTableName(slug);
+		await conn.schema.createTable(tableName).addColumn("id", "text", (col) => col.primaryKey()).addColumn("slug", "text").addColumn("status", "text", (col) => col.defaultTo("draft")).addColumn("author_id", "text").addColumn("primary_byline_id", "text").addColumn("created_at", "text", (col) => col.defaultTo(currentTimestamp(conn))).addColumn("updated_at", "text", (col) => col.defaultTo(currentTimestamp(conn))).addColumn("published_at", "text").addColumn("scheduled_at", "text").addColumn("deleted_at", "text").addColumn("version", "integer", (col) => col.defaultTo(1)).addColumn("live_revision_id", "text", (col) => col.references("revisions.id")).addColumn("draft_revision_id", "text", (col) => col.references("revisions.id")).addColumn("locale", "text", (col) => col.notNull().defaultTo("en")).addColumn("translation_group", "text").addUniqueConstraint(`${tableName}_slug_locale_unique`, ["slug", "locale"]).execute();
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_slug`)}
+			ON ${sql.ref(tableName)} (slug)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_scheduled`)}
+			ON ${sql.ref(tableName)} (scheduled_at)
+			WHERE scheduled_at IS NOT NULL
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_live_revision`)}
+			ON ${sql.ref(tableName)} (live_revision_id)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_draft_revision`)}
+			ON ${sql.ref(tableName)} (draft_revision_id)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_author`)}
+			ON ${sql.ref(tableName)} (author_id)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_primary_byline`)}
+			ON ${sql.ref(tableName)} (primary_byline_id)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_locale`)}
+			ON ${sql.ref(tableName)} (locale)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_translation_group`)}
+			ON ${sql.ref(tableName)} (translation_group)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_updated_id`)}
+			ON ${sql.ref(tableName)} (deleted_at, updated_at DESC, id DESC)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_status`)}
+			ON ${sql.ref(tableName)} (deleted_at, status)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_created_id`)}
+			ON ${sql.ref(tableName)} (deleted_at, created_at DESC, id DESC)
+		`.execute(conn);
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${tableName}_deleted_published_id`)}
+			ON ${sql.ref(tableName)} (deleted_at, published_at DESC, id DESC)
+		`.execute(conn);
+	}
+	/**
+	* Drop a content table
+	*/
+	async dropContentTable(slug) {
+		const tableName = this.getTableName(slug);
+		await sql`DROP TABLE IF EXISTS ${sql.ref(tableName)}`.execute(this.db);
+	}
+	/**
+	* Add a column to a content table
+	*/
+	async addColumn(collectionSlug, fieldSlug, fieldType, options) {
+		const tableName = this.getTableName(collectionSlug);
+		const columnType = FIELD_TYPE_TO_COLUMN[fieldType];
+		const columnName = this.getColumnName(fieldSlug);
+		if (options?.required && options?.defaultValue !== void 0) {
+			const defaultVal = this.formatDefaultValue(options.defaultValue, fieldType);
+			await sql`
+				ALTER TABLE ${sql.ref(tableName)} 
+				ADD COLUMN ${sql.ref(columnName)} ${sql.raw(columnType)} NOT NULL DEFAULT ${sql.raw(defaultVal)}
+			`.execute(this.db);
+		} else if (options?.required) {
+			const defaultVal = this.getEmptyDefault(fieldType);
+			await sql`
+				ALTER TABLE ${sql.ref(tableName)} 
+				ADD COLUMN ${sql.ref(columnName)} ${sql.raw(columnType)} NOT NULL DEFAULT ${sql.raw(defaultVal)}
+			`.execute(this.db);
+		} else await sql`
+				ALTER TABLE ${sql.ref(tableName)} 
+				ADD COLUMN ${sql.ref(columnName)} ${sql.raw(columnType)}
+			`.execute(this.db);
+	}
+	/**
+	* Drop a column from a content table
+	*/
+	async dropColumn(collectionSlug, fieldSlug) {
+		const tableName = this.getTableName(collectionSlug);
+		const columnName = this.getColumnName(fieldSlug);
+		await sql`
+			ALTER TABLE ${sql.ref(tableName)} 
+			DROP COLUMN ${sql.ref(columnName)}
+		`.execute(this.db);
+	}
+	/**
+	* Check if a collection has any content
+	*/
+	async collectionHasContent(slug) {
+		const tableName = this.getTableName(slug);
+		try {
+			return ((await sql`
+				SELECT COUNT(*) as count FROM ${sql.ref(tableName)} 
+				WHERE deleted_at IS NULL
+			`.execute(this.db)).rows[0]?.count ?? 0) > 0;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Get table name for a collection
+	*/
+	getTableName(slug) {
+		return `ec_${slug}`;
+	}
+	/**
+	* Get column name for a field
+	*/
+	getColumnName(slug) {
+		return slug;
+	}
+	/**
+	* Validate a slug
+	*/
+	validateSlug(slug, type) {
+		if (!slug || typeof slug !== "string") throw new SchemaError(`${type} slug is required`, "INVALID_SLUG");
+		if (!SLUG_VALIDATION_PATTERN.test(slug)) throw new SchemaError(`${type} slug must start with a letter and contain only lowercase letters, numbers, and underscores`, "INVALID_SLUG");
+		if (slug.length > 63) throw new SchemaError(`${type} slug must be 63 characters or less`, "INVALID_SLUG");
+	}
+	/**
+	* Format a default value for SQL.
+	*
+	* SQLite `ALTER TABLE ADD COLUMN ... DEFAULT` requires a literal constant
+	* expression — parameterized values cannot be used here. We manually escape
+	* single quotes and coerce types to ensure the output is safe.
+	*
+	* INTEGER/REAL values are coerced through `Number()` which can only produce
+	* digits, `.`, `-`, `e`, `Infinity`, or `NaN` — all safe in SQL.
+	* TEXT/JSON values have single quotes escaped via SQL standard doubling (`''`).
+	*/
+	formatDefaultValue(value, fieldType) {
+		if (value === null || value === void 0) return "NULL";
+		const columnType = FIELD_TYPE_TO_COLUMN[fieldType];
+		if (columnType === "JSON") return `'${JSON.stringify(value).replace(SINGLE_QUOTE_PATTERN, "''")}'`;
+		if (columnType === "INTEGER") {
+			if (typeof value === "boolean") return value ? "1" : "0";
+			const num = Number(value);
+			if (!Number.isFinite(num)) return "0";
+			return String(Math.trunc(num));
+		}
+		if (columnType === "REAL") {
+			const num = Number(value);
+			if (!Number.isFinite(num)) return "0";
+			return String(num);
+		}
+		let text;
+		if (typeof value === "string") text = value;
+		else if (typeof value === "number" || typeof value === "boolean") text = String(value);
+		else if (typeof value === "object" && value !== null) text = JSON.stringify(value);
+		else text = "";
+		return `'${text.replace(SINGLE_QUOTE_PATTERN, "''")}'`;
+	}
+	/**
+	* Get empty default for a field type
+	*/
+	getEmptyDefault(fieldType) {
+		switch (FIELD_TYPE_TO_COLUMN[fieldType]) {
+			case "INTEGER": return "0";
+			case "REAL": return "0.0";
+			case "JSON": return "'null'";
+			default: return "''";
+		}
+	}
+	/**
+	* Map a collection row to a Collection object
+	*/
+	mapCollectionRow = (row) => {
+		const moderation = row.comments_moderation;
+		return {
+			id: row.id,
+			slug: row.slug,
+			label: row.label,
+			labelSingular: row.label_singular ?? void 0,
+			description: row.description ?? void 0,
+			icon: row.icon ?? void 0,
+			supports: row.supports ? JSON.parse(row.supports) : [],
+			source: row.source && isCollectionSource(row.source) ? row.source : void 0,
+			hasSeo: row.has_seo === 1,
+			urlPattern: row.url_pattern ?? void 0,
+			commentsEnabled: row.comments_enabled === 1,
+			commentsModeration: moderation === "all" || moderation === "first_time" || moderation === "none" ? moderation : "first_time",
+			commentsClosedAfterDays: row.comments_closed_after_days ?? 90,
+			commentsAutoApproveUsers: row.comments_auto_approve_users === 1,
+			createdAt: row.created_at,
+			updatedAt: row.updated_at
+		};
+	};
+	/**
+	* Map a field row to a Field object
+	*/
+	mapFieldRow = (row) => {
+		return {
+			id: row.id,
+			collectionId: row.collection_id,
+			slug: row.slug,
+			label: row.label,
+			type: isFieldType(row.type) ? row.type : "string",
+			columnType: isColumnType(row.column_type) ? row.column_type : "TEXT",
+			required: row.required === 1,
+			unique: row.unique === 1,
+			defaultValue: row.default_value ? JSON.parse(row.default_value) : void 0,
+			validation: row.validation ? JSON.parse(row.validation) : void 0,
+			widget: row.widget ?? void 0,
+			options: row.options ? JSON.parse(row.options) : void 0,
+			sortOrder: row.sort_order,
+			searchable: row.searchable === 1,
+			translatable: row.translatable !== 0,
+			createdAt: row.created_at
+		};
+	};
+	/**
+	* Discover orphaned content tables
+	*
+	* Finds ec_* tables that exist in the database but don't have a
+	* corresponding entry in _dineway_collections.
+	*/
+	async discoverOrphanedTables() {
+		const allTables = await listTablesLike(this.db, "ec_%");
+		const registered = await this.listCollections();
+		const registeredSlugs = new Set(registered.map((c) => c.slug));
+		const orphans = [];
+		for (const tableName of allTables) {
+			const slug = tableName.replace(EC_PREFIX_PATTERN, "");
+			if (!registeredSlugs.has(slug)) try {
+				const countResult = await sql`
+						SELECT COUNT(*) as count FROM ${sql.ref(tableName)}
+						WHERE deleted_at IS NULL
+					`.execute(this.db);
+				orphans.push({
+					slug,
+					tableName,
+					rowCount: countResult.rows[0]?.count ?? 0
+				});
+			} catch {
+				orphans.push({
+					slug,
+					tableName,
+					rowCount: 0
+				});
+			}
+		}
+		return orphans;
+	}
+	/**
+	* Register an orphaned table as a collection
+	*
+	* Creates a _dineway_collections entry for an existing ec_* table.
+	*/
+	async registerOrphanedTable(slug, options) {
+		const tableName = this.getTableName(slug);
+		if (!await tableExists(this.db, tableName)) throw new SchemaError(`Table "${tableName}" does not exist`, "TABLE_NOT_FOUND");
+		if (await this.getCollection(slug)) throw new SchemaError(`Collection "${slug}" is already registered`, "COLLECTION_EXISTS");
+		const id = ulid();
+		const label = options?.label || this.slugToLabel(slug);
+		await this.db.insertInto("_dineway_collections").values({
+			id,
+			slug,
+			label,
+			label_singular: options?.labelSingular ?? null,
+			description: options?.description ?? null,
+			icon: null,
+			supports: JSON.stringify([]),
+			source: "discovered",
+			has_seo: 0,
+			url_pattern: null
+		}).execute();
+		const collection = await this.getCollection(slug);
+		if (!collection) throw new SchemaError("Failed to register orphaned table", "REGISTER_FAILED");
+		return collection;
+	}
+	/**
+	* Convert slug to human-readable label
+	*/
+	slugToLabel(slug) {
+		return slug.replace(UNDERSCORE_PATTERN, " ").replace(WORD_BOUNDARY_PATTERN, (c) => c.toUpperCase());
+	}
+};
+
+//#endregion
+export { withTransaction as a, FTSManager as i, SchemaRegistry as n, registry_exports as r, SchemaError as t };