syncorejs 0.2.1 → 0.2.3

package/dist/_vendor/core/runtime/runtime.mjs

@@ -1,1381 +1,105 @@
-import { generateId } from "./id.mjs";
-import { createSchemaSnapshot, describeValidator, diffSchemaSnapshots, parseSchemaSnapshot, renderCreateSearchIndexStatement, renderMigrationSql, searchIndexTableName } from "../../schema/index.js";
-import { fromZonedTime, toZonedTime } from "date-fns-tz";
+import { RuntimeKernel } from "./internal/runtimeKernel.mjs";
 //#region 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.
+* Local-first Syncore runtime that hosts your schema, functions, and storage.
+*
+* `SyncoreRuntime` is the central engine of every Syncore app. It owns the
+* SQLite driver, the storage adapter, the reactivity engine, and the
+* background scheduler. Platform-specific factory functions
+* (`createNodeSyncoreRuntime`, `createWebSyncoreRuntime`, etc.) wrap it with
+* environment-appropriate defaults so you rarely need to instantiate it
+* directly.
+*
+* **Lifecycle**
+* 1. Construct the runtime (schema migration is deferred until first use).
+* 2. Call `await runtime.start()` to apply the schema, start the scheduler,
+*    and connect to devtools. The runtime emits `"runtime.connected"` when ready.
+* 3. Call `runtime.createClient()` to get a {@link SyncoreClient} for
+*    invoking functions and subscribing to reactive queries.
+* 4. Call `await runtime.stop()` on shutdown to flush pending jobs and close
+*    the database.
+*
+* ```ts
+* const runtime = new SyncoreRuntime({
+*   schema,
+*   functions,
+*   driver: new NodeSqliteDriver("./db.sqlite"),
+*   storage: new NodeFileStorageAdapter("./storage"),
+* });
+* await runtime.start();
+* const client = runtime.createClient();
+* ```
 */
 var SyncoreRuntime = class {
-	runtimeId = generateId();
-	platform;
-	capabilities;
-	experimentalPlugins;
-	activeQueries = /* @__PURE__ */ new Map();
-	disabledSearchIndexes = /* @__PURE__ */ new Set();
-	recentEvents = [];
-	devtoolsListeners = /* @__PURE__ */ new Set();
-	devtoolsInvalidationListeners = /* @__PURE__ */ new Set();
-	externalChangeSourceId = generateId();
-	detachExternalChangeListener;
-	pendingExternalChangePromise;
-	queuedExternalChange;
-	schedulerTimer;
-	recurringJobs;
-	schedulerPollIntervalMs;
-	driverDatabasePath;
-	prepared = false;
-	started = false;
+	options;
+	kernel;
 	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());
-		this.driverDatabasePath = inferDriverDatabasePath(options.driver);
-		this.options.devtools?.attachRuntime?.(this);
+		this.kernel = new RuntimeKernel(options, this);
 	}
 	/**
-	* Start the local Syncore runtime.
+	* Start the runtime: apply the schema migration, initialise the scheduler,
+	* and connect to devtools (if configured).
+	*
+	* Must be called and awaited before using the client. Calling `start()`
+	* a second time is a no-op.
 	*/
 	async start() {
-		if (this.started) return;
-		await this.prepareForDirectAccess();
-		await this.runPluginHook("onStart");
-		this.detachExternalChangeListener = this.options.externalChangeSignal?.subscribe((event) => {
-			this.handleExternalChangeEvent(event);
-		});
-		this.schedulerTimer = setInterval(() => {
-			this.processDueJobs();
-		}, this.schedulerPollIntervalMs);
-		this.started = true;
-		this.emitDevtools({
-			type: "runtime.connected",
-			runtimeId: this.runtimeId,
-			platform: this.platform,
-			timestamp: Date.now()
-		});
+		await this.kernel.start();
 	}
+	/**
+	* Prepare the runtime for direct (synchronous) access patterns used by
+	* devtools and migration tooling.
+	*
+	* You do not need to call this in normal application code.
+	*/
 	async prepareForDirectAccess() {
-		if (this.prepared) return;
-		await this.ensureSystemTables();
-		await this.reconcileStorageState();
-		await this.applySchema();
-		await this.syncRecurringJobs();
-		this.prepared = true;
+		await this.kernel.prepareForDirectAccess();
 	}
 	/**
-	* Stop the local Syncore runtime and release any open resources.
+	* Stop the runtime gracefully.
+	*
+	* Flushes any pending scheduler jobs, closes the SQLite driver, and
+	* disconnects from devtools. Call this when your application is shutting
+	* down to avoid database file corruption.
 	*/
 	async stop() {
-		if (this.schedulerTimer) {
-			clearInterval(this.schedulerTimer);
-			this.schedulerTimer = void 0;
-		}
-		if (this.started) await this.runPluginHook("onStop");
-		this.detachExternalChangeListener?.();
-		this.detachExternalChangeListener = void 0;
-		await this.options.driver.close?.();
-		if (this.started) this.emitDevtools({
-			type: "runtime.disconnected",
-			runtimeId: this.runtimeId,
-			timestamp: Date.now()
-		});
-		this.started = false;
+		await this.kernel.stop();
 	}
 	/**
-	* Create a typed client for calling this runtime from the same process.
+	* Create a new {@link SyncoreClient} bound to this runtime.
+	*
+	* Multiple clients can be created from the same runtime — they all share
+	* the same underlying database and reactivity engine. Usually you only need
+	* one client per runtime instance.
 	*/
 	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))
-		};
-	}
-	async getDevtoolsLiveQuerySnapshot() {
-		return {
-			summary: this.getRuntimeSummary(),
-			activeQueries: this.getActiveQueryInfos(),
-			schemaTables: await this.getSchemaTablesForDevtools()
-		};
-	}
-	getRuntimeSummary() {
-		return {
-			runtimeId: this.runtimeId,
-			platform: this.platform,
-			connectedAt: Date.now(),
-			activeQueryCount: this.activeQueries.size,
-			recentEventCount: this.recentEvents.length
-		};
-	}
-	getActiveQueryInfos() {
-		return [...this.activeQueries.values()].map((query) => ({
-			id: query.id,
-			functionName: query.functionName,
-			dependencyKeys: [...query.dependencyKeys],
-			lastRunAt: query.lastRunAt
-		}));
-	}
-	getDriverDatabasePath() {
-		return this.driverDatabasePath;
-	}
-	async cancelScheduledJob(id) {
-		await this.prepareForDirectAccess();
-		if (((await this.options.driver.run(`UPDATE "_scheduled_functions"
-       SET status = 'cancelled', updated_at = ?
-       WHERE id = ? AND status = 'scheduled'`, [Date.now(), id])).changes ?? 0) > 0) {
-			this.notifySchedulerJobsChanged();
-			return true;
-		}
-		return false;
-	}
-	async updateScheduledJob(options) {
-		await this.prepareForDirectAccess();
-		const existing = await this.options.driver.get(`SELECT status, recurring_name FROM "_scheduled_functions" WHERE id = ?`, [options.id]);
-		if (!existing || existing.status !== "scheduled" || !existing.recurring_name) return false;
-		const now = Date.now();
-		const runAt = options.runAt ?? computeNextRun(options.schedule, now);
-		if (((await this.options.driver.run(`UPDATE "_scheduled_functions"
-       SET args_json = ?, run_at = ?, updated_at = ?, schedule_json = ?, timezone = ?, misfire_policy = ?, window_ms = ?
-       WHERE id = ? AND status = 'scheduled' AND recurring_name IS NOT NULL`, [
-			stableStringify(options.args),
-			runAt,
-			now,
-			stableStringify(options.schedule),
-			"timezone" in options.schedule ? options.schedule.timezone ?? null : null,
-			options.misfirePolicy.type,
-			options.misfirePolicy.type === "windowed" ? options.misfirePolicy.windowMs : null,
-			options.id
-		])).changes ?? 0) > 0) {
-			this.notifySchedulerJobsChanged();
-			return true;
-		}
-		return false;
+		return this.kernel.createClient();
 	}
-	subscribeToDevtoolsEvents(listener) {
-		this.devtoolsListeners.add(listener);
-		return () => {
-			this.devtoolsListeners.delete(listener);
-		};
-	}
-	subscribeToDevtoolsInvalidations(listener) {
-		this.devtoolsInvalidationListeners.add(listener);
-		return () => {
-			this.devtoolsInvalidationListeners.delete(listener);
-		};
-	}
-	notifyDevtoolsScopes(scopes) {
-		const scopeSet = new Set(scopes);
-		if (scopeSet.size === 0) return;
-		for (const listener of this.devtoolsInvalidationListeners) listener(scopeSet);
-	}
-	async runDevtoolsMutation(callback, meta = {}) {
-		const mutationId = generateId();
-		const startedAt = Date.now();
-		const changedTables = /* @__PURE__ */ new Set();
-		const storageChanges = [];
-		const result = await this.options.driver.withTransaction(async () => callback({ db: this.createDatabaseWriter({
-			mutationDepth: 1,
-			changedTables,
-			storageChanges
-		}) }));
-		await this.refreshInvalidatedQueries(changedTables, mutationId);
-		if (storageChanges.length > 0) await this.refreshAllActiveQueries();
-		if (changedTables.size > 0) await this.publishExternalChange({
-			scope: "database",
-			reason: "commit",
-			changedTables: [...changedTables]
-		});
-		await this.publishStorageChanges(storageChanges);
-		this.emitDevtools({
-			type: "mutation.committed",
-			runtimeId: this.runtimeId,
-			mutationId,
-			functionName: "__devtools__/mutation",
-			changedTables: [...changedTables],
-			durationMs: Date.now() - startedAt,
-			timestamp: Date.now(),
-			...meta.origin ? { origin: meta.origin } : {}
-		});
-		return result;
-	}
-	async forceRefreshDevtools(reason, meta = {}) {
-		await this.refreshAllActiveQueries();
-		await this.publishExternalChange({
-			scope: "database",
-			reason: "reconcile"
-		});
-		this.notifyDevtoolsScopes(["all"]);
-		this.emitDevtools({
-			type: "log",
-			runtimeId: this.runtimeId,
-			level: "info",
-			message: reason,
-			timestamp: Date.now(),
-			...meta.origin ? { origin: meta.origin } : {}
-		});
-	}
-	getRuntimeId() {
-		return this.runtimeId;
+	/**
+	* Return the low-level admin API.
+	*
+	* The admin API exposes devtools introspection, direct query/mutation
+	* execution, and scheduler management. It is used by the devtools
+	* dashboard and integration tooling — most application code should use
+	* the regular `SyncoreClient` instead.
+	*/
+	getAdmin() {
+		return this.kernel.admin;
 	}
 	async runQuery(reference, args = {}, meta = {}) {
-		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(),
-			storageChanges: [],
-			dependencyCollector
-		});
-		this.emitDevtools({
-			type: "query.executed",
-			runtimeId: this.runtimeId,
-			queryId: reference.name,
-			functionName: reference.name,
-			dependencies: [...dependencyCollector],
-			durationMs: Date.now() - startedAt,
-			timestamp: Date.now(),
-			...meta.origin ? { origin: meta.origin } : {}
-		});
-		return result;
+		return this.kernel.executionEngine.runQuery(reference, args, meta);
 	}
 	async runMutation(reference, args = {}, meta = {}) {
-		const definition = this.resolveFunction(reference, "mutation");
-		const mutationId = generateId();
-		const startedAt = Date.now();
-		const changedTables = /* @__PURE__ */ new Set();
-		const storageChanges = [];
-		const result = await this.options.driver.withTransaction(async () => this.invokeFunction(definition, args, {
-			mutationDepth: 1,
-			changedTables,
-			storageChanges
-		}));
-		await this.refreshInvalidatedQueries(changedTables, mutationId);
-		if (storageChanges.length > 0) await this.refreshAllActiveQueries();
-		if (changedTables.size > 0) await this.publishExternalChange({
-			scope: "database",
-			reason: "commit",
-			changedTables: [...changedTables]
-		});
-		await this.publishStorageChanges(storageChanges);
-		this.emitDevtools({
-			type: "mutation.committed",
-			runtimeId: this.runtimeId,
-			mutationId,
-			functionName: reference.name,
-			changedTables: [...changedTables],
-			durationMs: Date.now() - startedAt,
-			timestamp: Date.now(),
-			...meta.origin ? { origin: meta.origin } : {}
-		});
-		return result;
+		return this.kernel.executionEngine.runMutation(reference, args, meta);
 	}
 	async runAction(reference, args = {}, meta = {}) {
-		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(),
-				storageChanges: []
-			});
-			this.emitDevtools({
-				type: "action.completed",
-				runtimeId: this.runtimeId,
-				actionId,
-				functionName: reference.name,
-				durationMs: Date.now() - startedAt,
-				timestamp: Date.now(),
-				...meta.origin ? { origin: meta.origin } : {}
-			});
-			return result;
-		} catch (error) {
-			this.emitDevtools({
-				type: "action.completed",
-				runtimeId: this.runtimeId,
-				actionId,
-				functionName: reference.name,
-				durationMs: Date.now() - startedAt,
-				timestamp: Date.now(),
-				...meta.origin ? { origin: meta.origin } : {},
-				error: error instanceof Error ? error.message : String(error)
-			});
-			throw error;
-		}
+		return this.kernel.executionEngine.runAction(reference, args, meta);
 	}
 	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(state);
-		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,
-					storageChanges: state.storageChanges
-				}));
-				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(state) {
-		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()
-				});
-				state.storageChanges.push({
-					storageId: id,
-					reason: "storage-put"
-				});
-				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()
-				});
-				state.storageChanges.push({
-					storageId: id,
-					reason: "storage-delete"
-				});
-			}
-		};
-	}
-	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.cancelScheduledJob(id);
-			}
-		};
-	}
-	notifySchedulerJobsChanged() {
-		this.notifyDevtoolsScopes(["scheduler.jobs"]);
-	}
-	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
-		]);
-		this.notifySchedulerJobsChanged();
-		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
-			]);
-			this.notifySchedulerJobsChanged();
-		}
-	}
-	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.notifySchedulerJobsChanged();
-				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()
-			});
-			this.notifySchedulerJobsChanged();
-		}
-	}
-	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
-			]);
-			this.notifySchedulerJobsChanged();
-			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
-		]);
-		this.notifySchedulerJobsChanged();
-	}
-	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 handleExternalChangeEvent(event) {
-		if (event.sourceId === this.externalChangeSourceId) return;
-		const result = this.options.externalChangeApplier ? await this.options.externalChangeApplier.applyExternalChange(event) : {
-			databaseChanged: event.scope === "database" || event.scope === "all",
-			storageChanged: event.scope === "storage" || event.scope === "all"
-		};
-		await this.processExternalChangeResult(result);
-	}
-	async processExternalChangeResult(result) {
-		if (!result.databaseChanged && !result.storageChanged) return;
-		if (this.pendingExternalChangePromise) {
-			this.queuedExternalChange = {
-				databaseChanged: (this.queuedExternalChange?.databaseChanged ?? false) || result.databaseChanged,
-				storageChanged: (this.queuedExternalChange?.storageChanged ?? false) || result.storageChanged
-			};
-			return this.pendingExternalChangePromise;
-		}
-		this.pendingExternalChangePromise = (async () => {
-			if (result.databaseChanged || result.storageChanged) await this.refreshAllActiveQueries();
-		})();
-		try {
-			await this.pendingExternalChangePromise;
-		} finally {
-			this.pendingExternalChangePromise = void 0;
-			const queued = this.queuedExternalChange;
-			this.queuedExternalChange = void 0;
-			if (queued) await this.processExternalChangeResult(queued);
-		}
-	}
-	async publishExternalChange(event) {
-		await this.options.externalChangeSignal?.publish({
-			...event,
-			sourceId: this.externalChangeSourceId,
-			timestamp: Date.now()
-		});
-	}
-	async publishStorageChanges(storageChanges) {
-		for (const change of storageChanges) await this.publishExternalChange({
-			scope: "storage",
-			reason: change.reason,
-			storageIds: [change.storageId]
-		});
-	}
-	async refreshAllActiveQueries() {
-		for (const query of this.activeQueries.values()) await this.rerunActiveQuery(query);
-	}
-	async getSchemaTablesForDevtools() {
-		const tables = [];
-		for (const name of this.options.schema.tableNames()) {
-			const table = this.getTableDefinition(name);
-			const validatorDesc = describeValidator(table.validator);
-			const fields = validatorDesc.kind === "object" ? Object.entries(validatorDesc.shape).map(([fieldName, fieldDesc]) => {
-				const desc = fieldDesc;
-				const optional = desc.kind === "optional";
-				return {
-					name: fieldName,
-					type: optional ? desc.inner?.kind ?? "any" : desc.kind,
-					optional
-				};
-			}) : [];
-			fields.unshift({
-				name: "_id",
-				type: "string",
-				optional: false
-			}, {
-				name: "_creationTime",
-				type: "number",
-				optional: false
-			});
-			let documentCount = 0;
-			try {
-				documentCount = (await this.options.driver.get(`SELECT COUNT(*) as count FROM ${quoteIdentifier(name)}`))?.count ?? 0;
-			} catch {
-				documentCount = 0;
-			}
-			tables.push({
-				name,
-				fields,
-				indexes: table.indexes.map((index) => ({
-					name: index.name,
-					fields: index.fields,
-					unique: false
-				})),
-				documentCount
-			});
-		}
-		return tables;
-	}
-	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(),
-			storageChanges: [],
-			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);
-		this.notifyDevtoolsScopes(devtoolsScopesForEvent(event));
-		for (const listener of this.devtoolsListeners) listener(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);
+		return this.kernel.watchQuery(reference, args);
 	}
 };
-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 devtoolsScopesForEvent(event) {
-	switch (event.type) {
-		case "runtime.connected":
-		case "runtime.disconnected": return new Set(["runtime.summary", "runtime.activeQueries"]);
-		case "query.executed":
-		case "query.invalidated": return new Set(["runtime.summary", "runtime.activeQueries"]);
-		case "mutation.committed": return new Set(["runtime.summary", ...event.changedTables.map((table) => `table:${table}`)]);
-		case "scheduler.tick": return new Set(["scheduler.jobs", "runtime.summary"]);
-		case "storage.updated": return new Set(["runtime.summary"]);
-		case "action.completed":
-		case "log": return new Set(["runtime.summary"]);
-	}
-}
-function inferDriverDatabasePath(driver) {
-	const candidate = driver;
-	return candidate.databasePath ?? candidate.filename;
-}
-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,
@@ -1383,9 +107,8 @@ function createFunctionReference(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.
+* Create a function reference from an existing Syncore function definition
+* while preserving its inferred args and result types.
 */
 function createFunctionReferenceFor(kind, name) {
 	return {
@@ -1393,21 +116,6 @@ function createFunctionReferenceFor(kind, name) {
 		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 };