syncorejs 0.1.0

package/dist/core/src/runtime/runtime.js

@@ -0,0 +1,1143 @@
+import { createSchemaSnapshot, diffSchemaSnapshots, parseSchemaSnapshot, renderCreateSearchIndexStatement, renderMigrationSql, searchIndexTableName } from "../../../schema/src/planner.js";
+import { generateId } from "./id.js";
+import { fromZonedTime, toZonedTime } from "date-fns-tz";
+//#region ../core/src/runtime/runtime.ts
+const DEFAULT_MISFIRE_POLICY = { type: "catch_up" };
+var RuntimeFilterBuilder = class {
+	eq(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: "=",
+				value
+			}
+		};
+	}
+	gt(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: ">",
+				value
+			}
+		};
+	}
+	gte(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: ">=",
+				value
+			}
+		};
+	}
+	lt(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: "<",
+				value
+			}
+		};
+	}
+	lte(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: "<=",
+				value
+			}
+		};
+	}
+	and(...expressions) {
+		return {
+			type: "and",
+			expressions
+		};
+	}
+	or(...expressions) {
+		return {
+			type: "or",
+			expressions
+		};
+	}
+};
+var RuntimeIndexRangeBuilder = class {
+	conditions = [];
+	eq(field, value) {
+		this.conditions.push({
+			field,
+			operator: "=",
+			value
+		});
+		return this;
+	}
+	gt(field, value) {
+		this.conditions.push({
+			field,
+			operator: ">",
+			value
+		});
+		return this;
+	}
+	gte(field, value) {
+		this.conditions.push({
+			field,
+			operator: ">=",
+			value
+		});
+		return this;
+	}
+	lt(field, value) {
+		this.conditions.push({
+			field,
+			operator: "<",
+			value
+		});
+		return this;
+	}
+	lte(field, value) {
+		this.conditions.push({
+			field,
+			operator: "<=",
+			value
+		});
+		return this;
+	}
+	build() {
+		return [...this.conditions];
+	}
+};
+var RuntimeSearchIndexBuilder = class {
+	searchField;
+	searchText;
+	filters = [];
+	search(field, value) {
+		this.searchField = field;
+		this.searchText = value;
+		return this;
+	}
+	eq(field, value) {
+		this.filters.push({
+			field,
+			operator: "=",
+			value
+		});
+		return this;
+	}
+	build() {
+		if (!this.searchField || !this.searchText) throw new Error("Search queries require a search field and search text.");
+		return {
+			searchField: this.searchField,
+			searchText: this.searchText,
+			filters: [...this.filters]
+		};
+	}
+};
+var RuntimeQueryBuilder = class {
+	orderDirection = "asc";
+	source = { type: "table" };
+	filterExpression;
+	constructor(executeQuery, tableName, dependencyCollector) {
+		this.executeQuery = executeQuery;
+		this.tableName = tableName;
+		this.dependencyCollector = dependencyCollector;
+	}
+	withIndex(indexName, builder) {
+		this.source = {
+			type: "index",
+			name: indexName,
+			range: builder?.(new RuntimeIndexRangeBuilder()).build() ?? []
+		};
+		return this;
+	}
+	withSearchIndex(indexName, builder) {
+		this.source = {
+			type: "search",
+			name: indexName,
+			query: builder(new RuntimeSearchIndexBuilder()).build()
+		};
+		return this;
+	}
+	order(order) {
+		this.orderDirection = order;
+		return this;
+	}
+	filter(builder) {
+		this.filterExpression = builder(new RuntimeFilterBuilder());
+		return this;
+	}
+	async collect() {
+		return this.execute();
+	}
+	async take(count) {
+		return this.execute({ limit: count });
+	}
+	async first() {
+		return (await this.execute({ limit: 1 }))[0] ?? null;
+	}
+	async unique() {
+		const results = await this.execute({ limit: 2 });
+		if (results.length > 1) throw new Error("Expected a unique result but found multiple rows.");
+		return results[0] ?? null;
+	}
+	async paginate(options) {
+		const offset = options.cursor ? Number.parseInt(options.cursor, 10) : 0;
+		const page = await this.execute({
+			limit: options.numItems,
+			offset
+		});
+		const nextCursor = page.length < options.numItems ? null : String(offset + page.length);
+		return {
+			page,
+			cursor: nextCursor,
+			isDone: nextCursor === null
+		};
+	}
+	async execute(options) {
+		this.dependencyCollector?.add(`table:${this.tableName}`);
+		const queryOptions = {
+			tableName: this.tableName,
+			source: this.source,
+			filterExpression: this.filterExpression,
+			orderDirection: this.orderDirection
+		};
+		if (this.dependencyCollector) queryOptions.dependencyCollector = this.dependencyCollector;
+		if (options?.limit !== void 0) queryOptions.limit = options.limit;
+		if (options?.offset !== void 0) queryOptions.offset = options.offset;
+		return this.executeQuery(queryOptions);
+	}
+};
+/**
+* The local Syncore runtime that owns the database, storage, scheduler, and function execution.
+*/
+var SyncoreRuntime = class {
+	runtimeId = generateId();
+	platform;
+	capabilities;
+	experimentalPlugins;
+	activeQueries = /* @__PURE__ */ new Map();
+	disabledSearchIndexes = /* @__PURE__ */ new Set();
+	recentEvents = [];
+	schedulerTimer;
+	recurringJobs;
+	schedulerPollIntervalMs;
+	started = false;
+	constructor(options) {
+		this.options = options;
+		this.platform = options.platform ?? "node";
+		this.experimentalPlugins = options.experimentalPlugins ?? [];
+		this.recurringJobs = options.scheduler?.recurringJobs ?? [];
+		this.schedulerPollIntervalMs = options.scheduler?.pollIntervalMs ?? 1e3;
+		this.capabilities = Object.freeze(this.buildCapabilities());
+	}
+	/**
+	* Start the local Syncore runtime.
+	*/
+	async start() {
+		if (this.started) return;
+		await this.ensureSystemTables();
+		await this.reconcileStorageState();
+		await this.applySchema();
+		await this.syncRecurringJobs();
+		await this.runPluginHook("onStart");
+		this.schedulerTimer = setInterval(() => {
+			this.processDueJobs();
+		}, this.schedulerPollIntervalMs);
+		this.started = true;
+		this.emitDevtools({
+			type: "runtime.connected",
+			runtimeId: this.runtimeId,
+			platform: this.platform,
+			timestamp: Date.now()
+		});
+	}
+	/**
+	* Stop the local Syncore runtime and release any open resources.
+	*/
+	async stop() {
+		if (this.schedulerTimer) {
+			clearInterval(this.schedulerTimer);
+			this.schedulerTimer = void 0;
+		}
+		if (this.started) await this.runPluginHook("onStop");
+		await this.options.driver.close?.();
+		if (this.started) this.emitDevtools({
+			type: "runtime.disconnected",
+			runtimeId: this.runtimeId,
+			timestamp: Date.now()
+		});
+		this.started = false;
+	}
+	/**
+	* Create a typed client for calling this runtime from the same process.
+	*/
+	createClient() {
+		return {
+			query: (reference, ...args) => this.runQuery(reference, normalizeOptionalArgs(args)),
+			mutation: (reference, ...args) => this.runMutation(reference, normalizeOptionalArgs(args)),
+			action: (reference, ...args) => this.runAction(reference, normalizeOptionalArgs(args)),
+			watchQuery: (reference, ...args) => this.watchQuery(reference, normalizeOptionalArgs(args))
+		};
+	}
+	getDevtoolsSnapshot() {
+		return {
+			runtimeId: this.runtimeId,
+			platform: this.platform,
+			connectedAt: Date.now(),
+			activeQueries: [...this.activeQueries.values()].map((query) => ({
+				id: query.id,
+				functionName: query.functionName,
+				dependencyKeys: [...query.dependencyKeys],
+				lastRunAt: query.lastRunAt
+			})),
+			pendingJobs: [],
+			recentEvents: [...this.recentEvents]
+		};
+	}
+	getRuntimeId() {
+		return this.runtimeId;
+	}
+	async runQuery(reference, args = {}) {
+		const definition = this.resolveFunction(reference, "query");
+		const dependencyCollector = /* @__PURE__ */ new Set();
+		const startedAt = Date.now();
+		const result = await this.invokeFunction(definition, args, {
+			mutationDepth: 0,
+			changedTables: /* @__PURE__ */ new Set(),
+			dependencyCollector
+		});
+		this.emitDevtools({
+			type: "query.executed",
+			runtimeId: this.runtimeId,
+			queryId: reference.name,
+			functionName: reference.name,
+			dependencies: [...dependencyCollector],
+			durationMs: Date.now() - startedAt,
+			timestamp: Date.now()
+		});
+		return result;
+	}
+	async runMutation(reference, args = {}) {
+		const definition = this.resolveFunction(reference, "mutation");
+		const mutationId = generateId();
+		const startedAt = Date.now();
+		const changedTables = /* @__PURE__ */ new Set();
+		const result = await this.options.driver.withTransaction(async () => this.invokeFunction(definition, args, {
+			mutationDepth: 1,
+			changedTables
+		}));
+		await this.refreshInvalidatedQueries(changedTables, mutationId);
+		this.emitDevtools({
+			type: "mutation.committed",
+			runtimeId: this.runtimeId,
+			mutationId,
+			functionName: reference.name,
+			changedTables: [...changedTables],
+			durationMs: Date.now() - startedAt,
+			timestamp: Date.now()
+		});
+		return result;
+	}
+	async runAction(reference, args = {}) {
+		const definition = this.resolveFunction(reference, "action");
+		const actionId = generateId();
+		const startedAt = Date.now();
+		try {
+			const result = await this.invokeFunction(definition, args, {
+				mutationDepth: 0,
+				changedTables: /* @__PURE__ */ new Set()
+			});
+			this.emitDevtools({
+				type: "action.completed",
+				runtimeId: this.runtimeId,
+				actionId,
+				functionName: reference.name,
+				durationMs: Date.now() - startedAt,
+				timestamp: Date.now()
+			});
+			return result;
+		} catch (error) {
+			this.emitDevtools({
+				type: "action.completed",
+				runtimeId: this.runtimeId,
+				actionId,
+				functionName: reference.name,
+				durationMs: Date.now() - startedAt,
+				timestamp: Date.now(),
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+	}
+	watchQuery(reference, args = {}) {
+		const key = this.createActiveQueryKey(reference.name, args);
+		let record = this.activeQueries.get(key);
+		if (!record) {
+			record = {
+				id: key,
+				functionName: reference.name,
+				args,
+				listeners: /* @__PURE__ */ new Set(),
+				consumers: 0,
+				dependencyKeys: /* @__PURE__ */ new Set(),
+				lastResult: void 0,
+				lastError: void 0,
+				lastRunAt: 0
+			};
+			this.activeQueries.set(key, record);
+			this.rerunActiveQuery(record);
+		}
+		const activeRecord = record;
+		activeRecord.consumers += 1;
+		let disposed = false;
+		const ownedListeners = /* @__PURE__ */ new Set();
+		return {
+			onUpdate: (callback) => {
+				activeRecord.listeners.add(callback);
+				ownedListeners.add(callback);
+				queueMicrotask(callback);
+				return () => {
+					activeRecord.listeners.delete(callback);
+					ownedListeners.delete(callback);
+				};
+			},
+			localQueryResult: () => activeRecord.lastResult,
+			localQueryError: () => activeRecord.lastError,
+			dispose: () => {
+				if (disposed) return;
+				disposed = true;
+				for (const callback of ownedListeners) activeRecord.listeners.delete(callback);
+				ownedListeners.clear();
+				activeRecord.consumers = Math.max(0, activeRecord.consumers - 1);
+				if (activeRecord.consumers === 0) this.activeQueries.delete(key);
+			}
+		};
+	}
+	async executeQueryBuilder(options) {
+		const table = this.options.schema.getTable(options.tableName);
+		const params = [];
+		const whereClauses = [];
+		const orderClauses = [];
+		let joinClause = "";
+		const source = options.source;
+		if (source.type === "index") {
+			const index = table.indexes.find((candidate) => candidate.name === source.name);
+			if (!index) throw new Error(`Unknown index "${source.name}" on table "${options.tableName}".`);
+			for (const condition of source.range) whereClauses.push(this.renderCondition("t", condition, params));
+			const primaryField = index.fields[0];
+			if (primaryField) orderClauses.push(`${fieldExpression("t", primaryField)} ${options.orderDirection.toUpperCase()}`);
+		}
+		if (source.type === "search") {
+			const searchIndex = table.searchIndexes.find((candidate) => candidate.name === source.name);
+			if (!searchIndex) throw new Error(`Unknown search index "${source.name}" on table "${options.tableName}".`);
+			if (searchIndex.searchField !== source.query.searchField) throw new Error(`Search index "${searchIndex.name}" expects field "${searchIndex.searchField}".`);
+			const searchIndexKey = `${options.tableName}:${searchIndex.name}`;
+			if (this.disabledSearchIndexes.has(searchIndexKey)) {
+				whereClauses.push(`${fieldExpression("t", searchIndex.searchField)} LIKE ?`);
+				params.push(`%${source.query.searchText}%`);
+			} else {
+				joinClause = `JOIN ${quoteIdentifier(searchIndexTableName(options.tableName, searchIndex.name))} s ON s._id = t._id`;
+				whereClauses.push(`s.search_value MATCH ?`);
+				params.push(source.query.searchText);
+			}
+			for (const condition of source.query.filters) whereClauses.push(this.renderCondition("t", condition, params));
+		}
+		if (options.filterExpression) whereClauses.push(this.renderExpression("t", options.filterExpression, params));
+		if (orderClauses.length === 0) orderClauses.push(`t._creationTime ${options.orderDirection.toUpperCase()}`);
+		orderClauses.push(`t._id ${options.orderDirection.toUpperCase()}`);
+		const sql = [
+			`SELECT t._id, t._creationTime, t._json FROM ${quoteIdentifier(options.tableName)} t`,
+			joinClause,
+			whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "",
+			`ORDER BY ${orderClauses.join(", ")}`,
+			options.limit !== void 0 ? `LIMIT ${options.limit}` : "",
+			options.offset !== void 0 ? `OFFSET ${options.offset}` : ""
+		].filter(Boolean).join(" ");
+		return (await this.options.driver.all(sql, params)).map((row) => this.deserializeDocument(options.tableName, row));
+	}
+	async invokeFunction(definition, rawArgs, state) {
+		const args = definition.argsValidator.parse(rawArgs);
+		const ctx = this.createContext(definition.kind, state);
+		const result = await definition.handler(ctx, args);
+		if (definition.returnsValidator) return definition.returnsValidator.parse(result);
+		return result;
+	}
+	createContext(kind, state) {
+		const db = kind === "mutation" ? this.createDatabaseWriter(state) : this.createDatabaseReader(state);
+		const storage = this.createStorageApi();
+		const scheduler = this.createSchedulerApi();
+		return {
+			db,
+			storage,
+			capabilities: this.capabilities,
+			scheduler,
+			runQuery: (reference, ...args) => this.runQuery(reference, normalizeOptionalArgs(args)),
+			runMutation: (reference, ...args) => {
+				const normalizedArgs = normalizeOptionalArgs(args);
+				if (kind === "mutation") return this.options.driver.withSavepoint(`sp_${generateId().replace(/-/g, "_")}`, () => this.invokeFunction(this.resolveFunction(reference, "mutation"), normalizedArgs, {
+					mutationDepth: state.mutationDepth + 1,
+					changedTables: state.changedTables
+				}));
+				return this.runMutation(reference, normalizedArgs);
+			},
+			runAction: (reference, ...args) => this.runAction(reference, normalizeOptionalArgs(args))
+		};
+	}
+	createDatabaseReader(state) {
+		return {
+			get: async (tableName, id) => {
+				state.dependencyCollector?.add(`table:${tableName}`);
+				state.dependencyCollector?.add(`row:${tableName}:${id}`);
+				const row = await this.options.driver.get(`SELECT _id, _creationTime, _json FROM ${quoteIdentifier(tableName)} WHERE _id = ?`, [id]);
+				return row ? this.deserializeDocument(tableName, row) : null;
+			},
+			query: (tableName) => new RuntimeQueryBuilder((options) => this.executeQueryBuilder(options), tableName, state.dependencyCollector),
+			raw: (sql, params) => this.options.driver.all(sql, params)
+		};
+	}
+	createDatabaseWriter(state) {
+		const reader = this.createDatabaseReader(state);
+		return {
+			...reader,
+			insert: async (tableName, value) => {
+				const validated = this.validateDocument(tableName, value);
+				const id = generateId();
+				const creationTime = Date.now();
+				const json = stableStringify(validated);
+				await this.options.driver.run(`INSERT INTO ${quoteIdentifier(tableName)} (_id, _creationTime, _json) VALUES (?, ?, ?)`, [
+					id,
+					creationTime,
+					json
+				]);
+				await this.syncSearchIndexes(tableName, {
+					_id: id,
+					_creationTime: creationTime,
+					_json: json
+				});
+				state.changedTables.add(tableName);
+				return id;
+			},
+			patch: async (tableName, id, value) => {
+				const current = await reader.get(tableName, id);
+				if (!current) throw new Error(`Document "${id}" does not exist in "${tableName}".`);
+				const merged = {
+					...omitSystemFields(current),
+					...value
+				};
+				for (const key of Object.keys(merged)) if (merged[key] === void 0) delete merged[key];
+				const validated = this.validateDocument(tableName, merged);
+				await this.options.driver.run(`UPDATE ${quoteIdentifier(tableName)} SET _json = ? WHERE _id = ?`, [stableStringify(validated), id]);
+				const row = await this.options.driver.get(`SELECT _id, _creationTime, _json FROM ${quoteIdentifier(tableName)} WHERE _id = ?`, [id]);
+				if (row) await this.syncSearchIndexes(tableName, row);
+				state.changedTables.add(tableName);
+			},
+			replace: async (tableName, id, value) => {
+				const validated = this.validateDocument(tableName, value);
+				await this.options.driver.run(`UPDATE ${quoteIdentifier(tableName)} SET _json = ? WHERE _id = ?`, [stableStringify(validated), id]);
+				const row = await this.options.driver.get(`SELECT _id, _creationTime, _json FROM ${quoteIdentifier(tableName)} WHERE _id = ?`, [id]);
+				if (!row) throw new Error(`Document "${id}" does not exist in "${tableName}".`);
+				await this.syncSearchIndexes(tableName, row);
+				state.changedTables.add(tableName);
+			},
+			delete: async (tableName, id) => {
+				await this.options.driver.run(`DELETE FROM ${quoteIdentifier(tableName)} WHERE _id = ?`, [id]);
+				await this.removeSearchIndexes(tableName, id);
+				state.changedTables.add(tableName);
+			}
+		};
+	}
+	createStorageApi() {
+		return {
+			put: async (input) => {
+				const id = generateId();
+				const createdAt = Date.now();
+				await this.options.driver.run(`INSERT OR REPLACE INTO "_storage_pending" (_id, _creationTime, file_name, content_type) VALUES (?, ?, ?, ?)`, [
+					id,
+					createdAt,
+					input.fileName ?? null,
+					input.contentType ?? null
+				]);
+				const object = await this.options.storage.put(id, input);
+				await this.options.driver.withTransaction(async () => {
+					await this.options.driver.run(`INSERT OR REPLACE INTO "_storage" (_id, _creationTime, file_name, content_type, size, path) VALUES (?, ?, ?, ?, ?, ?)`, [
+						id,
+						createdAt,
+						input.fileName ?? null,
+						object.contentType,
+						object.size,
+						object.path
+					]);
+					await this.options.driver.run(`DELETE FROM "_storage_pending" WHERE _id = ?`, [id]);
+				});
+				this.emitDevtools({
+					type: "storage.updated",
+					runtimeId: this.runtimeId,
+					storageId: id,
+					operation: "put",
+					timestamp: Date.now()
+				});
+				return id;
+			},
+			get: async (id) => {
+				const row = await this.options.driver.get(`SELECT _id, _creationTime, file_name, content_type, size, path FROM "_storage" WHERE _id = ?`, [id]);
+				if (!row) return null;
+				return {
+					id: row._id,
+					path: row.path,
+					size: row.size,
+					contentType: row.content_type
+				};
+			},
+			read: async (id) => {
+				if (!await this.options.driver.get(`SELECT _id FROM "_storage" WHERE _id = ?`, [id])) return null;
+				return this.options.storage.read(id);
+			},
+			delete: async (id) => {
+				await this.options.storage.delete(id);
+				await this.options.driver.withTransaction(async () => {
+					await this.options.driver.run(`DELETE FROM "_storage" WHERE _id = ?`, [id]);
+					await this.options.driver.run(`DELETE FROM "_storage_pending" WHERE _id = ?`, [id]);
+				});
+				this.emitDevtools({
+					type: "storage.updated",
+					runtimeId: this.runtimeId,
+					storageId: id,
+					operation: "delete",
+					timestamp: Date.now()
+				});
+			}
+		};
+	}
+	createSchedulerApi() {
+		return {
+			runAfter: async (delayMs, reference, ...args) => {
+				const schedulerArgs = splitSchedulerArgs(args);
+				const functionArgs = schedulerArgs[0];
+				const misfirePolicy = schedulerArgs[1] ?? DEFAULT_MISFIRE_POLICY;
+				return this.scheduleJob(Date.now() + delayMs, reference, functionArgs, misfirePolicy);
+			},
+			runAt: async (timestamp, reference, ...args) => {
+				const schedulerArgs = splitSchedulerArgs(args);
+				const functionArgs = schedulerArgs[0];
+				const misfirePolicy = schedulerArgs[1] ?? DEFAULT_MISFIRE_POLICY;
+				const value = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+				return this.scheduleJob(value, reference, functionArgs, misfirePolicy);
+			},
+			cancel: async (id) => {
+				await this.options.driver.run(`UPDATE "_scheduled_functions" SET status = 'cancelled', updated_at = ? WHERE id = ?`, [Date.now(), id]);
+			}
+		};
+	}
+	async ensureSystemTables() {
+		await this.options.driver.exec(`
+      CREATE TABLE IF NOT EXISTS "_syncore_migrations" (
+        id TEXT PRIMARY KEY,
+        applied_at INTEGER NOT NULL,
+        sql TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS "_syncore_schema_state" (
+        id TEXT PRIMARY KEY,
+        schema_hash TEXT NOT NULL,
+        schema_json TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS "_storage" (
+        _id TEXT PRIMARY KEY,
+        _creationTime INTEGER NOT NULL,
+        file_name TEXT,
+        content_type TEXT,
+        size INTEGER NOT NULL,
+        path TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS "_storage_pending" (
+        _id TEXT PRIMARY KEY,
+        _creationTime INTEGER NOT NULL,
+        file_name TEXT,
+        content_type TEXT
+      );
+      CREATE TABLE IF NOT EXISTS "_scheduled_functions" (
+        id TEXT PRIMARY KEY,
+        function_name TEXT NOT NULL,
+        function_kind TEXT NOT NULL,
+        args_json TEXT NOT NULL,
+        status TEXT NOT NULL,
+        run_at INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        recurring_name TEXT,
+        schedule_json TEXT,
+        timezone TEXT,
+        misfire_policy TEXT NOT NULL,
+        last_run_at INTEGER,
+        window_ms INTEGER
+      );
+    `);
+		try {
+			await this.options.driver.exec(`ALTER TABLE "_syncore_schema_state" ADD COLUMN schema_json TEXT NOT NULL DEFAULT '{}'`);
+		} catch {}
+	}
+	async reconcileStorageState() {
+		const pendingRows = await this.options.driver.all(`SELECT _id, _creationTime, file_name, content_type FROM "_storage_pending"`);
+		for (const pendingRow of pendingRows) {
+			if (!await this.options.driver.get(`SELECT _id FROM "_storage" WHERE _id = ?`, [pendingRow._id])) {
+				await this.options.storage.delete(pendingRow._id);
+				this.emitDevtools({
+					type: "log",
+					runtimeId: this.runtimeId,
+					level: "warn",
+					message: `Recovered interrupted storage write ${pendingRow._id}.`,
+					timestamp: Date.now()
+				});
+			}
+			await this.options.driver.run(`DELETE FROM "_storage_pending" WHERE _id = ?`, [pendingRow._id]);
+		}
+		if (!this.options.storage.list) return;
+		const storedRows = await this.options.driver.all(`SELECT _id FROM "_storage"`);
+		const knownIds = new Set(storedRows.map((row) => row._id));
+		const physicalObjects = await this.options.storage.list();
+		for (const object of physicalObjects) {
+			if (knownIds.has(object.id)) continue;
+			await this.options.storage.delete(object.id);
+			this.emitDevtools({
+				type: "log",
+				runtimeId: this.runtimeId,
+				level: "warn",
+				message: `Removed orphaned storage object ${object.id}.`,
+				timestamp: Date.now()
+			});
+		}
+	}
+	async applySchema() {
+		const nextSnapshot = createSchemaSnapshot(this.options.schema);
+		const stateRow = await this.options.driver.get(`SELECT schema_hash, schema_json FROM "_syncore_schema_state" WHERE id = 'current'`);
+		let previousSnapshot = null;
+		if (stateRow?.schema_json && stateRow.schema_json !== "{}") try {
+			previousSnapshot = parseSchemaSnapshot(stateRow.schema_json);
+		} catch {
+			previousSnapshot = null;
+		}
+		const plan = diffSchemaSnapshots(previousSnapshot, nextSnapshot);
+		if (plan.destructiveChanges.length > 0) throw new Error(`Syncore detected destructive schema changes that require a manual migration:\n${plan.destructiveChanges.join("\n")}`);
+		for (const warning of plan.warnings) this.emitDevtools({
+			type: "log",
+			runtimeId: this.runtimeId,
+			level: "warn",
+			message: warning,
+			timestamp: Date.now()
+		});
+		for (const statement of plan.statements) {
+			const searchKey = this.findSearchIndexKeyForStatement(statement);
+			try {
+				await this.options.driver.exec(statement);
+			} catch (error) {
+				if (searchKey) {
+					this.disabledSearchIndexes.add(searchKey);
+					this.emitDevtools({
+						type: "log",
+						runtimeId: this.runtimeId,
+						level: "warn",
+						message: `FTS5 unavailable for ${searchKey}; falling back to LIKE search.`,
+						timestamp: Date.now()
+					});
+					continue;
+				}
+				throw error;
+			}
+		}
+		if (plan.statements.length > 0 || plan.warnings.length > 0) {
+			const migrationSql = renderMigrationSql(plan, { title: "Syncore automatic schema reconciliation" });
+			await this.options.driver.run(`INSERT OR REPLACE INTO "_syncore_migrations" (id, applied_at, sql) VALUES (?, ?, ?)`, [
+				nextSnapshot.hash,
+				Date.now(),
+				migrationSql
+			]);
+		}
+		await this.options.driver.run(`INSERT INTO "_syncore_schema_state" (id, schema_hash, schema_json, updated_at)
+       VALUES ('current', ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET schema_hash = excluded.schema_hash, schema_json = excluded.schema_json, updated_at = excluded.updated_at`, [
+			nextSnapshot.hash,
+			stableStringify(nextSnapshot),
+			Date.now()
+		]);
+		for (const tableName of this.options.schema.tableNames()) {
+			const table = this.getTableDefinition(tableName);
+			for (const searchIndex of table.searchIndexes) {
+				const searchKey = `${tableName}:${searchIndex.name}`;
+				try {
+					await this.options.driver.exec(renderCreateSearchIndexStatement(tableName, searchIndex));
+					this.disabledSearchIndexes.delete(searchKey);
+				} catch {
+					const alreadyDisabled = this.disabledSearchIndexes.has(searchKey);
+					this.disabledSearchIndexes.add(searchKey);
+					if (!alreadyDisabled) this.emitDevtools({
+						type: "log",
+						runtimeId: this.runtimeId,
+						level: "warn",
+						message: `FTS5 unavailable for ${searchKey}; falling back to LIKE search.`,
+						timestamp: Date.now()
+					});
+				}
+			}
+		}
+	}
+	async scheduleJob(runAt, reference, args, misfirePolicy) {
+		const id = generateId();
+		const now = Date.now();
+		await this.options.driver.run(`INSERT INTO "_scheduled_functions"
+        (id, function_name, function_kind, args_json, status, run_at, created_at, updated_at, recurring_name, schedule_json, timezone, misfire_policy, last_run_at, window_ms)
+       VALUES (?, ?, ?, ?, 'scheduled', ?, ?, ?, NULL, NULL, NULL, ?, NULL, ?)`, [
+			id,
+			reference.name,
+			reference.kind,
+			stableStringify(args),
+			runAt,
+			now,
+			now,
+			misfirePolicy.type,
+			misfirePolicy.type === "windowed" ? misfirePolicy.windowMs : null
+		]);
+		return id;
+	}
+	async syncRecurringJobs() {
+		for (const job of this.recurringJobs) {
+			const id = `recurring:${job.name}`;
+			if (await this.options.driver.get(`SELECT * FROM "_scheduled_functions" WHERE id = ?`, [id])) continue;
+			const nextRunAt = computeNextRun(job.schedule, Date.now());
+			await this.options.driver.run(`INSERT INTO "_scheduled_functions"
+         (id, function_name, function_kind, args_json, status, run_at, created_at, updated_at, recurring_name, schedule_json, timezone, misfire_policy, last_run_at, window_ms)
+         VALUES (?, ?, ?, ?, 'scheduled', ?, ?, ?, ?, ?, ?, ?, NULL, ?)`, [
+				id,
+				job.function.name,
+				job.function.kind,
+				stableStringify(job.args),
+				nextRunAt,
+				Date.now(),
+				Date.now(),
+				job.name,
+				stableStringify(job.schedule),
+				"timezone" in job.schedule ? job.schedule.timezone ?? null : null,
+				job.misfirePolicy.type,
+				job.misfirePolicy.type === "windowed" ? job.misfirePolicy.windowMs : null
+			]);
+		}
+	}
+	async processDueJobs() {
+		const now = Date.now();
+		const dueJobs = await this.options.driver.all(`SELECT * FROM "_scheduled_functions" WHERE status = 'scheduled' AND run_at <= ? ORDER BY run_at ASC`, [now]);
+		const executedJobIds = [];
+		for (const job of dueJobs) {
+			const misfirePolicy = parseMisfirePolicy(job.misfire_policy, job.window_ms);
+			if (!shouldRunMissedJob(job.run_at, now, misfirePolicy)) {
+				await this.advanceOrFinalizeJob(job, "skipped", now);
+				continue;
+			}
+			try {
+				if (job.function_kind === "mutation") await this.runMutation({
+					kind: "mutation",
+					name: job.function_name
+				}, JSON.parse(job.args_json));
+				else await this.runAction({
+					kind: "action",
+					name: job.function_name
+				}, JSON.parse(job.args_json));
+				executedJobIds.push(job.id);
+				await this.advanceOrFinalizeJob(job, "completed", now);
+			} catch (error) {
+				await this.options.driver.run(`UPDATE "_scheduled_functions" SET status = 'failed', updated_at = ? WHERE id = ?`, [Date.now(), job.id]);
+				this.emitDevtools({
+					type: "log",
+					runtimeId: this.runtimeId,
+					level: "error",
+					message: `Scheduled job ${job.id} failed: ${error instanceof Error ? error.message : String(error)}`,
+					timestamp: Date.now()
+				});
+			}
+		}
+		if (executedJobIds.length > 0) this.emitDevtools({
+			type: "scheduler.tick",
+			runtimeId: this.runtimeId,
+			executedJobIds,
+			timestamp: Date.now()
+		});
+	}
+	async advanceOrFinalizeJob(job, terminalStatus, executedAt) {
+		if (!job.recurring_name || !job.schedule_json) {
+			await this.options.driver.run(`UPDATE "_scheduled_functions" SET status = ?, updated_at = ?, last_run_at = ? WHERE id = ?`, [
+				terminalStatus,
+				executedAt,
+				executedAt,
+				job.id
+			]);
+			return;
+		}
+		const nextRunAt = computeNextRun(JSON.parse(job.schedule_json), executedAt + 1);
+		await this.options.driver.run(`UPDATE "_scheduled_functions"
+       SET status = 'scheduled', run_at = ?, updated_at = ?, last_run_at = ?
+       WHERE id = ?`, [
+			nextRunAt,
+			executedAt,
+			executedAt,
+			job.id
+		]);
+	}
+	async refreshInvalidatedQueries(changedTables, mutationId) {
+		for (const query of this.activeQueries.values()) {
+			if (![...changedTables].some((tableName) => query.dependencyKeys.has(`table:${tableName}`))) continue;
+			this.emitDevtools({
+				type: "query.invalidated",
+				runtimeId: this.runtimeId,
+				queryId: query.id,
+				reason: `Mutation ${mutationId} changed ${[...changedTables].join(", ")}`,
+				timestamp: Date.now()
+			});
+			await this.rerunActiveQuery(query);
+		}
+	}
+	async rerunActiveQuery(record) {
+		record.dependencyKeys.clear();
+		try {
+			record.lastResult = await this.runQuery({
+				kind: "query",
+				name: record.functionName
+			}, record.args);
+			record.lastError = void 0;
+			record.lastRunAt = Date.now();
+			record.dependencyKeys = await this.collectQueryDependencies(record.functionName, record.args);
+		} catch (error) {
+			record.lastError = error;
+		}
+		for (const listener of record.listeners) listener();
+	}
+	async collectQueryDependencies(functionName, args) {
+		const definition = this.resolveFunction({
+			kind: "query",
+			name: functionName
+		}, "query");
+		const dependencyCollector = /* @__PURE__ */ new Set();
+		await this.invokeFunction(definition, args, {
+			mutationDepth: 0,
+			changedTables: /* @__PURE__ */ new Set(),
+			dependencyCollector
+		});
+		return dependencyCollector;
+	}
+	resolveFunction(reference, expectedKind) {
+		const definition = this.options.functions[reference.name];
+		if (!definition) throw new Error(`Unknown function "${reference.name}".`);
+		if (definition.kind !== expectedKind) throw new Error(`Function "${reference.name}" is a ${definition.kind}, expected ${expectedKind}.`);
+		return definition;
+	}
+	validateDocument(tableName, value) {
+		return this.getTableDefinition(tableName).validator.parse(value);
+	}
+	deserializeDocument(tableName, row) {
+		const payload = JSON.parse(row._json);
+		const document = {
+			...payload,
+			_id: row._id,
+			_creationTime: row._creationTime
+		};
+		this.getTableDefinition(tableName).validator.parse(payload);
+		return document;
+	}
+	async syncSearchIndexes(tableName, row) {
+		const table = this.getTableDefinition(tableName);
+		if (table.searchIndexes.length === 0) return;
+		const payload = JSON.parse(row._json);
+		for (const searchIndex of table.searchIndexes) {
+			if (this.disabledSearchIndexes.has(`${tableName}:${searchIndex.name}`)) continue;
+			await this.options.driver.run(`DELETE FROM ${quoteIdentifier(searchIndexTableName(tableName, searchIndex.name))} WHERE _id = ?`, [row._id]);
+			await this.options.driver.run(`INSERT INTO ${quoteIdentifier(searchIndexTableName(tableName, searchIndex.name))} (_id, search_value) VALUES (?, ?)`, [row._id, toSearchValue(payload[searchIndex.searchField])]);
+		}
+	}
+	async removeSearchIndexes(tableName, id) {
+		const table = this.getTableDefinition(tableName);
+		for (const searchIndex of table.searchIndexes) {
+			if (this.disabledSearchIndexes.has(`${tableName}:${searchIndex.name}`)) continue;
+			await this.options.driver.run(`DELETE FROM ${quoteIdentifier(searchIndexTableName(tableName, searchIndex.name))} WHERE _id = ?`, [id]);
+		}
+	}
+	renderExpression(tableAlias, expression, params) {
+		if (expression.type === "condition") return this.renderCondition(tableAlias, expression.condition, params);
+		const separator = expression.type === "and" ? " AND " : " OR ";
+		return `(${expression.expressions.map((child) => this.renderExpression(tableAlias, child, params)).join(separator)})`;
+	}
+	renderCondition(tableAlias, condition, params) {
+		params.push(condition.value);
+		return `${fieldExpression(tableAlias, condition.field)} ${condition.operator} ?`;
+	}
+	createActiveQueryKey(name, args) {
+		return `${name}:${stableStringify(args)}`;
+	}
+	emitDevtools(event) {
+		this.recentEvents.unshift(event);
+		this.recentEvents.splice(24);
+		this.options.devtools?.emit(event);
+	}
+	createPluginContext() {
+		return {
+			runtimeId: this.runtimeId,
+			platform: this.platform,
+			schema: this.options.schema,
+			driver: this.options.driver,
+			storage: this.options.storage,
+			...this.options.scheduler ? { scheduler: this.options.scheduler } : {},
+			...this.options.devtools ? { devtools: this.options.devtools } : {},
+			emitDevtools: (event) => {
+				this.emitDevtools(event);
+			}
+		};
+	}
+	buildCapabilities() {
+		const capabilities = { ...this.options.capabilities ?? {} };
+		for (const plugin of this.experimentalPlugins) {
+			if (!plugin.capabilities) continue;
+			const contributed = typeof plugin.capabilities === "function" ? plugin.capabilities(this.createPluginContext()) : plugin.capabilities;
+			if (!contributed) continue;
+			Object.assign(capabilities, contributed);
+		}
+		return capabilities;
+	}
+	async runPluginHook(hook) {
+		const context = this.createPluginContext();
+		for (const plugin of this.experimentalPlugins) {
+			const handler = plugin[hook];
+			if (!handler) continue;
+			await handler(context);
+		}
+	}
+	findSearchIndexKeyForStatement(statement) {
+		for (const tableName of this.options.schema.tableNames()) {
+			const table = this.getTableDefinition(tableName);
+			for (const searchIndex of table.searchIndexes) if (statement === renderCreateSearchIndexStatement(tableName, searchIndex)) return `${tableName}:${searchIndex.name}`;
+		}
+		return null;
+	}
+	getTableDefinition(tableName) {
+		return this.options.schema.getTable(tableName);
+	}
+};
+function fieldExpression(tableAlias, field) {
+	return `json_extract(${tableAlias ? `${tableAlias}.` : ""}_json, '$.${field}')`;
+}
+function quoteIdentifier(identifier) {
+	return `"${identifier.replaceAll("\"", "\"\"")}"`;
+}
+function stableStringify(value) {
+	return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+	if (Array.isArray(value)) return value.map(sortValue);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, sortValue(nested)]));
+	return value;
+}
+function omitSystemFields(document) {
+	const clone = { ...document };
+	delete clone._id;
+	delete clone._creationTime;
+	return clone;
+}
+function toSearchValue(value) {
+	if (typeof value === "string") return value;
+	if (value === null || value === void 0) return "";
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	return stableStringify(value);
+}
+function parseMisfirePolicy(type, windowMs) {
+	if (type === "windowed") return {
+		type,
+		windowMs: windowMs ?? 0
+	};
+	if (type === "skip" || type === "run_once_if_missed") return { type };
+	return { type: "catch_up" };
+}
+function shouldRunMissedJob(scheduledAt, now, policy) {
+	if (scheduledAt >= now) return true;
+	switch (policy.type) {
+		case "catch_up": return true;
+		case "run_once_if_missed": return true;
+		case "skip": return false;
+		case "windowed": return now - scheduledAt <= policy.windowMs;
+	}
+}
+function computeNextRun(schedule, fromTimestamp) {
+	switch (schedule.type) {
+		case "interval": return fromTimestamp + intervalToMs(schedule);
+		case "daily": return nextDailyOccurrence(fromTimestamp, schedule);
+		case "weekly": return nextWeeklyOccurrence(fromTimestamp, schedule);
+	}
+}
+function intervalToMs(schedule) {
+	if (schedule.seconds) return schedule.seconds * 1e3;
+	if (schedule.minutes) return schedule.minutes * 60 * 1e3;
+	return (schedule.hours ?? 1) * 60 * 60 * 1e3;
+}
+function nextDailyOccurrence(fromTimestamp, schedule) {
+	const timezone = schedule.timezone ?? "UTC";
+	const zonedNow = toZonedTime(new Date(fromTimestamp), timezone);
+	const zoned = new Date(zonedNow.getTime());
+	zoned.setHours(schedule.hour, schedule.minute, 0, 0);
+	if (zoned.getTime() <= zonedNow.getTime()) zoned.setDate(zoned.getDate() + 1);
+	return fromZonedTime(zoned, timezone).getTime();
+}
+function nextWeeklyOccurrence(fromTimestamp, schedule) {
+	const timezone = schedule.timezone ?? "UTC";
+	const zonedNow = toZonedTime(new Date(fromTimestamp), timezone);
+	const targetDay = [
+		"sunday",
+		"monday",
+		"tuesday",
+		"wednesday",
+		"thursday",
+		"friday",
+		"saturday"
+	].indexOf(schedule.dayOfWeek);
+	const zoned = new Date(zonedNow.getTime());
+	const delta = (targetDay - zonedNow.getDay() + 7) % 7;
+	zoned.setDate(zoned.getDate() + delta);
+	zoned.setHours(schedule.hour, schedule.minute, 0, 0);
+	if (zoned.getTime() <= zonedNow.getTime()) zoned.setDate(zoned.getDate() + 7);
+	return fromZonedTime(zoned, timezone).getTime();
+}
+function createFunctionReference(kind, name) {
+	return {
+		kind,
+		name
+	};
+}
+/**
+* Create a typed function reference from a concrete Syncore function definition.
+*
+* Generated code uses this helper to preserve function arg and result inference.
+*/
+function createFunctionReferenceFor(kind, name) {
+	return {
+		kind,
+		name
+	};
+}
+function normalizeOptionalArgs(args) {
+	return args[0] ?? {};
+}
+function splitSchedulerArgs(args) {
+	if (args.length === 0) return [{}, void 0];
+	if (args.length === 1) {
+		const [first] = args;
+		if (isMisfirePolicy(first)) return [{}, first];
+		return [first ?? {}, void 0];
+	}
+	return [args[0] ?? {}, args[1]];
+}
+function isMisfirePolicy(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+//#endregion
+export { SyncoreRuntime, createFunctionReference, createFunctionReferenceFor };
+
+//# sourceMappingURL=runtime.js.map