@spooky-sync/core 0.0.0-canary.1

package/dist/index.js

@@ -0,0 +1,3082 @@
+import { DateTime, Duration, RecordId, Surreal, Uuid, applyDiagnostics, createRemoteEngines } from "surrealdb";
+import { QueryBuilder, RecordId as RecordId$1 } from "@spooky-sync/query-builder";
+import { createWasmWorkerEngines } from "@surrealdb/wasm";
+import pino from "pino";
+import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { createContextKey } from "@opentelemetry/api";
+import init, { SpookyProcessor } from "@spooky-sync/ssp-wasm";
+
+//#region src/utils/surql.ts
+const surql = {
+	seal(query, options) {
+		if (typeof query === "string") return `${query};`;
+		const txQuery = query;
+		const idx = options?.resultIndex ?? txQuery.statementCount - 1;
+		return {
+			sql: `${txQuery.sql};`,
+			extract(results) {
+				return results[idx + 1];
+			}
+		};
+	},
+	tx(queries) {
+		return {
+			__brand: "TxQuery",
+			sql: `BEGIN TRANSACTION;\n${queries.join(";")};\nCOMMIT TRANSACTION`,
+			statementCount: queries.length
+		};
+	},
+	selectById(idVar, returnValues) {
+		return `SELECT ${returnValues.join(",")} FROM ONLY $${idVar}`;
+	},
+	selectByFieldsAnd(table, whereVar, returnValues) {
+		return `SELECT ${returnValues.map((returnValues) => typeof returnValues === "string" ? returnValues : `${returnValues.field} as ${returnValues.alias}`).join(",")} FROM ${table} WHERE ${whereVar.map((whereVar) => typeof whereVar === "string" ? `${whereVar} = $${whereVar}` : `${whereVar.field} = $${whereVar.variable}`).join(" AND ")}`;
+	},
+	create(idVar, dataVar) {
+		return `CREATE ONLY $${idVar} CONTENT $${dataVar}`;
+	},
+	createSet(idVar, keyDataVars) {
+		return `CREATE ONLY $${idVar} SET ${keyDataVars.map((keyDataVar) => typeof keyDataVar === "string" ? `${keyDataVar} = $${keyDataVar}` : "statement" in keyDataVar ? keyDataVar.statement : `${keyDataVar.key} = $${keyDataVar.variable}`).join(", ")}`;
+	},
+	upsert(idVar, dataVar) {
+		return `UPSERT ONLY $${idVar} REPLACE $${dataVar}`;
+	},
+	updateMerge(idVar, dataVar) {
+		return `UPDATE ONLY $${idVar} MERGE $${dataVar}`;
+	},
+	updateSet(idVar, keyDataVar) {
+		return `UPDATE $${idVar} SET ${keyDataVar.map((keyDataVar) => typeof keyDataVar === "string" ? `${keyDataVar} = $${keyDataVar}` : "statement" in keyDataVar ? keyDataVar.statement : `${keyDataVar.key} = $${keyDataVar.variable}`).join(", ")}`;
+	},
+	delete(idVar) {
+		return `DELETE $${idVar}`;
+	},
+	let(name, query) {
+		return `LET $${name} = (${query})`;
+	},
+	createMutation(t, mutationIdVar, recordIdVar, dataVar, beforeRecordVar) {
+		switch (t) {
+			case "create": return `CREATE ONLY $${mutationIdVar} SET mutationType = 'create', recordId = $${recordIdVar}`;
+			case "update": {
+				let stmt = `CREATE ONLY $${mutationIdVar} SET mutationType = 'update', recordId = $${recordIdVar}, data = $${dataVar}`;
+				if (beforeRecordVar) stmt += `, beforeRecord = $${beforeRecordVar}`;
+				return stmt;
+			}
+			case "delete": return `CREATE ONLY $${mutationIdVar} SET mutationType = 'delete', recordId = $${recordIdVar}`;
+		}
+	},
+	returnObject(entries) {
+		return `RETURN {${entries.map(({ key, variable }) => `${key}: $${variable}`).join(",")}}`;
+	}
+};
+
+//#endregion
+//#region src/utils/parser.ts
+function cleanRecord(tableSchema, record) {
+	const cleaned = {};
+	for (const [key, value] of Object.entries(record)) if (key === "id" || key in tableSchema) cleaned[key] = value;
+	return cleaned;
+}
+function parseParams(tableSchema, params) {
+	const parsedParams = {};
+	for (const [key, value] of Object.entries(params)) {
+		const column = tableSchema[key];
+		if (column && value !== void 0) parsedParams[key] = parseValue(key, column, value);
+	}
+	return parsedParams;
+}
+function parseValue(name, column, value) {
+	if (column.recordId) {
+		if (value instanceof RecordId$1) return value;
+		if (typeof value === "string") return parseRecordIdString(value);
+		throw new Error(`Invalid value for ${name}: ${value}`);
+	}
+	if (column.dateTime) {
+		if (value instanceof Date) return value;
+		if (value instanceof DateTime) return value.toDate();
+		if (typeof value === "number" || typeof value === "string") return new Date(value);
+		throw new Error(`Invalid value for ${name}: ${value}`);
+	}
+	return value;
+}
+
+//#endregion
+//#region src/utils/error-classification.ts
+const NETWORK_ERROR_PATTERNS = [
+	"connection",
+	"timeout",
+	"timed out",
+	"websocket",
+	"fetch failed",
+	"disconnected",
+	"socket",
+	"network",
+	"econnrefused",
+	"econnreset",
+	"enotfound",
+	"epipe",
+	"abort"
+];
+function classifySyncError(error) {
+	const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+	for (const pattern of NETWORK_ERROR_PATTERNS) if (message.includes(pattern)) return "network";
+	return "application";
+}
+
+//#endregion
+//#region src/utils/index.ts
+const encodeRecordId = (recordId) => {
+	return `${recordId.table.toString()}:${recordId.id}`;
+};
+const extractIdPart = (id) => {
+	if (typeof id === "string") return id.split(":").slice(1).join(":");
+	const idValue = id.id;
+	if (typeof idValue === "string") return idValue;
+	return String(idValue);
+};
+const extractTablePart = (id) => {
+	if (typeof id === "string") return id.split(":")[0];
+	return id.table.toString();
+};
+const parseRecordIdString = (id) => {
+	const [table, ...idParts] = id.split(":");
+	return new RecordId(table, idParts.join(":"));
+};
+function generateId() {
+	return Uuid.v4().toString().replace(/-/g, "");
+}
+/**
+* Parse duration string or Duration object to milliseconds
+*/
+function parseDuration(duration) {
+	if (duration instanceof Duration) {
+		const ms = duration.milliseconds || duration._milliseconds;
+		if (ms) return Number(ms);
+		const str = duration.toString();
+		if (str !== "[object Object]") return parseDuration(str);
+		return 6e5;
+	}
+	if (typeof duration === "bigint") return Number(duration);
+	if (typeof duration !== "string") return 6e5;
+	const match = duration.match(/^(\d+)([smh])$/);
+	if (!match) return 6e5;
+	const val = parseInt(match[1], 10);
+	switch (match[2]) {
+		case "s": return val * 1e3;
+		case "h": return val * 36e5;
+		default: return val * 6e4;
+	}
+}
+/**
+* Helper for retrying DB operations with exponential backoff
+*/
+async function withRetry(logger, operation, retries = 3, delayMs = 100) {
+	let lastError;
+	for (let i = 0; i < retries; i++) try {
+		return await operation();
+	} catch (err) {
+		lastError = err;
+		if (err?.message?.includes("Can not open transaction") || err?.message?.includes("transaction") || err?.message?.includes("Database is busy")) {
+			const msg = err instanceof Error ? err.message : String(err);
+			logger.warn({
+				attempt: i + 1,
+				retries,
+				error: msg,
+				Category: "spooky-client::utils::withRetry"
+			}, "Retrying DB operation");
+			await new Promise((res) => setTimeout(res, delayMs * (i + 1)));
+			continue;
+		}
+		throw err;
+	}
+	throw lastError;
+}
+
+//#endregion
+//#region src/modules/data/index.ts
+/**
+* DataModule - Unified query and mutation management
+*
+* Merges the functionality of QueryManager and MutationManager.
+* Uses CacheModule for all storage operations.
+*/
+var DataModule = class {
+	activeQueries = /* @__PURE__ */ new Map();
+	subscriptions = /* @__PURE__ */ new Map();
+	mutationCallbacks = /* @__PURE__ */ new Set();
+	debounceTimers = /* @__PURE__ */ new Map();
+	logger;
+	constructor(cache, local, schema, logger, streamDebounceTime = 100) {
+		this.cache = cache;
+		this.local = local;
+		this.schema = schema;
+		this.streamDebounceTime = streamDebounceTime;
+		this.logger = logger.child({ service: "DataModule" });
+	}
+	async init() {
+		this.logger.info({ Category: "spooky-client::DataModule::init" }, "DataModule initialized");
+	}
+	/**
+	* Register a query and return its hash for subscriptions
+	*/
+	async query(tableName, surqlString, params, ttl) {
+		const hash = await this.calculateHash({
+			surql: surqlString,
+			params
+		});
+		this.logger.debug({
+			hash,
+			Category: "spooky-client::DataModule::query"
+		}, "Query Initialization: started");
+		const recordId = new RecordId("_spooky_query", hash);
+		if (this.activeQueries.has(hash)) {
+			this.logger.debug({
+				hash,
+				Category: "spooky-client::DataModule::query"
+			}, "Query Initialization: exists, returning");
+			return hash;
+		}
+		this.logger.debug({
+			hash,
+			Category: "spooky-client::DataModule::query"
+		}, "Query Initialization: not found, creating new query");
+		const queryState = await this.createNewQuery({
+			recordId,
+			surql: surqlString,
+			params,
+			ttl,
+			tableName
+		});
+		const { localArray } = this.cache.registerQuery({
+			queryHash: hash,
+			surql: surqlString,
+			params,
+			ttl: new Duration(ttl),
+			lastActiveAt: /* @__PURE__ */ new Date()
+		});
+		await withRetry(this.logger, () => this.local.query(surql.seal(surql.updateSet("id", ["localArray"])), {
+			id: recordId,
+			localArray
+		}));
+		this.activeQueries.set(hash, queryState);
+		this.startTTLHeartbeat(queryState);
+		this.logger.debug({
+			hash,
+			tableName,
+			recordCount: queryState.records.length,
+			Category: "spooky-client::DataModule::query"
+		}, "Query registered");
+		return hash;
+	}
+	/**
+	* Subscribe to query updates
+	*/
+	subscribe(queryHash, callback, options = {}) {
+		if (!this.subscriptions.has(queryHash)) this.subscriptions.set(queryHash, /* @__PURE__ */ new Set());
+		this.subscriptions.get(queryHash)?.add(callback);
+		if (options.immediate) {
+			const query = this.activeQueries.get(queryHash);
+			if (query) callback(query.records);
+		}
+		return () => {
+			const subs = this.subscriptions.get(queryHash);
+			if (subs) {
+				subs.delete(callback);
+				if (subs.size === 0) this.subscriptions.delete(queryHash);
+			}
+		};
+	}
+	/**
+	* Subscribe to mutations (for sync)
+	*/
+	onMutation(callback) {
+		this.mutationCallbacks.add(callback);
+		return () => {
+			this.mutationCallbacks.delete(callback);
+		};
+	}
+	/**
+	* Handle stream updates from DBSP (via CacheModule)
+	*/
+	async onStreamUpdate(update) {
+		const { queryHash, op } = update;
+		if (op === "UPDATE") {
+			if (this.debounceTimers.has(queryHash)) clearTimeout(this.debounceTimers.get(queryHash));
+			const timer = setTimeout(async () => {
+				this.debounceTimers.delete(queryHash);
+				await this.processStreamUpdate(update);
+			}, this.streamDebounceTime);
+			this.debounceTimers.set(queryHash, timer);
+		} else await this.processStreamUpdate(update);
+	}
+	async processStreamUpdate(update) {
+		const { queryHash, localArray } = update;
+		const queryState = this.activeQueries.get(queryHash);
+		if (!queryState) {
+			this.logger.warn({
+				queryHash,
+				Category: "spooky-client::DataModule::onStreamUpdate"
+			}, "Received update for unknown query. Skipping...");
+			return;
+		}
+		try {
+			const [records] = await this.local.query(queryState.config.surql, queryState.config.params);
+			queryState.records = records || [];
+			queryState.config.localArray = localArray;
+			queryState.updateCount++;
+			await this.local.query(surql.seal(surql.updateSet("id", ["localArray"])), {
+				id: queryState.config.id,
+				localArray
+			});
+			const subscribers = this.subscriptions.get(queryHash);
+			if (subscribers) for (const callback of subscribers) callback(queryState.records);
+			this.logger.debug({
+				queryHash,
+				recordCount: records?.length,
+				Category: "spooky-client::DataModule::onStreamUpdate"
+			}, "Query updated from stream");
+		} catch (err) {
+			this.logger.error({
+				err,
+				queryHash,
+				Category: "spooky-client::DataModule::onStreamUpdate"
+			}, "Failed to fetch records for stream update");
+		}
+	}
+	/**
+	* Get query state (for sync and devtools)
+	*/
+	getQueryByHash(hash) {
+		return this.activeQueries.get(hash);
+	}
+	/**
+	* Get query state by id (for sync and devtools)
+	*/
+	getQueryById(id) {
+		return this.activeQueries.get(extractIdPart(id));
+	}
+	/**
+	* Get all active queries (for devtools)
+	*/
+	getActiveQueries() {
+		return Array.from(this.activeQueries.values());
+	}
+	async updateQueryLocalArray(id, localArray) {
+		const queryState = this.activeQueries.get(id);
+		if (!queryState) {
+			this.logger.warn({
+				id,
+				Category: "spooky-client::DataModule::updateQueryLocalArray"
+			}, "Query to update local array not found");
+			return;
+		}
+		queryState.config.localArray = localArray;
+		await this.local.query(surql.seal(surql.updateSet("id", ["localArray"])), {
+			id: queryState.config.id,
+			localArray
+		});
+	}
+	async updateQueryRemoteArray(hash, remoteArray) {
+		const queryState = this.getQueryByHash(hash);
+		if (!queryState) {
+			this.logger.warn({
+				hash,
+				Category: "spooky-client::DataModule::updateQueryRemoteArray"
+			}, "Query to update remote array not found");
+			return;
+		}
+		queryState.config.remoteArray = remoteArray;
+		await this.local.query(surql.seal(surql.updateSet("id", ["remoteArray"])), {
+			id: queryState.config.id,
+			remoteArray
+		});
+	}
+	async run(backend, path, data, options) {
+		const route = this.schema.backends?.[backend]?.routes?.[path];
+		if (!route) throw new Error(`Route ${backend}.${path} not found`);
+		const tableName = this.schema.backends?.[backend]?.outboxTable;
+		if (!tableName) throw new Error(`Outbox table for backend ${backend} not found`);
+		const payload = {};
+		for (const argName of Object.keys(route.args)) {
+			const arg = route.args[argName];
+			if (data[argName] === void 0 && arg.optional === false) throw new Error(`Missing required argument ${argName}`);
+			payload[argName] = data[argName];
+		}
+		const record = {
+			path,
+			payload: JSON.stringify(payload),
+			max_retries: options?.max_retries ?? 3,
+			retry_strategy: options?.retry_strategy ?? "linear"
+		};
+		if (options?.assignedTo) record.assigned_to = options.assignedTo;
+		const recordId = `${tableName}:${generateId()}`;
+		await this.create(recordId, record);
+	}
+	/**
+	* Create a new record
+	*/
+	async create(id, data) {
+		const tableName = extractTablePart(id);
+		const tableSchema = this.schema.tables.find((t) => t.name === tableName);
+		if (!tableSchema) throw new Error(`Table ${tableName} not found`);
+		const rid = parseRecordIdString(id);
+		const params = parseParams(tableSchema.columns, data);
+		const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+		const dataKeys = Object.keys(params).map((key) => ({
+			key,
+			variable: `data_${key}`
+		}));
+		const prefixedParams = Object.fromEntries(dataKeys.map(({ key, variable }) => [variable, params[key]]));
+		const query = surql.seal(surql.tx([surql.createSet("id", dataKeys), surql.createMutation("create", "mid", "id", "data")]), { resultIndex: 0 });
+		const target = await withRetry(this.logger, () => this.local.execute(query, {
+			id: rid,
+			mid: mutationId,
+			...prefixedParams
+		}));
+		const parsedRecord = parseParams(tableSchema.columns, target);
+		await this.cache.save({
+			table: tableName,
+			op: "CREATE",
+			record: parsedRecord,
+			version: 1
+		}, true);
+		const mutationEvent = {
+			type: "create",
+			mutation_id: mutationId,
+			record_id: rid,
+			data: params,
+			record: target,
+			tableName
+		};
+		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
+		this.logger.debug({
+			id,
+			Category: "spooky-client::DataModule::create"
+		}, "Record created");
+		return target;
+	}
+	/**
+	* Update an existing record
+	*/
+	async update(table, id, data, options) {
+		const tableName = extractTablePart(id);
+		const tableSchema = this.schema.tables.find((t) => t.name === tableName);
+		if (!tableSchema) throw new Error(`Table ${tableName} not found`);
+		const rid = parseRecordIdString(id);
+		const params = parseParams(tableSchema.columns, data);
+		const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+		const [beforeRecord] = await withRetry(this.logger, () => this.local.query("SELECT * FROM ONLY $id", { id: rid }));
+		const query = surql.seal(surql.tx([
+			surql.updateSet("id", [{ statement: "spooky_rv += 1" }]),
+			surql.let("updated", surql.updateMerge("id", "data")),
+			surql.createMutation("update", "mid", "id", "data"),
+			surql.returnObject([{
+				key: "target",
+				variable: "updated"
+			}])
+		]));
+		const { target } = await withRetry(this.logger, () => this.local.execute(query, {
+			id: rid,
+			mid: mutationId,
+			data: params
+		}));
+		this.replaceRecordInQueries(target);
+		const parsedRecord = parseParams(tableSchema.columns, target);
+		await this.cache.save({
+			table,
+			op: "UPDATE",
+			record: parsedRecord,
+			version: target.spooky_rv
+		}, true);
+		const pushEventOptions = parseUpdateOptions(id, data, options);
+		const mutationEvent = {
+			type: "update",
+			mutation_id: mutationId,
+			record_id: rid,
+			data: params,
+			record: target,
+			beforeRecord: beforeRecord || void 0,
+			options: pushEventOptions
+		};
+		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
+		this.logger.debug({
+			id,
+			Category: "spooky-client::DataModule::update"
+		}, "Record updated");
+		return target;
+	}
+	/**
+	* Delete a record
+	*/
+	async delete(table, id) {
+		const tableName = extractTablePart(id);
+		if (!this.schema.tables.find((t) => t.name === tableName)) throw new Error(`Table ${tableName} not found`);
+		const rid = parseRecordIdString(id);
+		const mutationId = parseRecordIdString(`_spooky_pending_mutations:${Date.now()}`);
+		const query = surql.seal(surql.tx([surql.delete("id"), surql.createMutation("delete", "mid", "id")]));
+		await withRetry(this.logger, () => this.local.execute(query, {
+			id: rid,
+			mid: mutationId
+		}));
+		await this.cache.delete(table, id, true);
+		const mutationEvent = {
+			type: "delete",
+			mutation_id: mutationId,
+			record_id: rid
+		};
+		for (const callback of this.mutationCallbacks) callback([mutationEvent]);
+		this.logger.debug({
+			id,
+			Category: "spooky-client::DataModule::delete"
+		}, "Record deleted");
+	}
+	/**
+	* Rollback a failed optimistic create by deleting the record locally
+	*/
+	async rollbackCreate(recordId, tableName) {
+		const id = encodeRecordId(recordId);
+		try {
+			await withRetry(this.logger, () => this.local.query("DELETE $id", { id: recordId }));
+			await this.cache.delete(tableName, id, true);
+			this.removeRecordFromQueries(recordId);
+			this.logger.info({
+				id,
+				tableName,
+				Category: "spooky-client::DataModule::rollbackCreate"
+			}, "Rolled back optimistic create");
+		} catch (err) {
+			this.logger.error({
+				err,
+				id,
+				tableName,
+				Category: "spooky-client::DataModule::rollbackCreate"
+			}, "Failed to rollback create");
+		}
+	}
+	/**
+	* Rollback a failed optimistic update by restoring the previous record state
+	*/
+	async rollbackUpdate(recordId, tableName, beforeRecord) {
+		const id = encodeRecordId(recordId);
+		try {
+			const { id: _recordId, ...content } = beforeRecord;
+			await withRetry(this.logger, () => this.local.query(surql.seal(surql.upsert("id", "content")), {
+				id: recordId,
+				content
+			}));
+			const tableSchema = this.schema.tables.find((t) => t.name === tableName);
+			const parsedRecord = tableSchema ? parseParams(tableSchema.columns, beforeRecord) : beforeRecord;
+			await this.cache.save({
+				table: tableName,
+				op: "UPDATE",
+				record: parsedRecord,
+				version: beforeRecord.spooky_rv || 1
+			}, true);
+			await this.replaceRecordInQueries(beforeRecord);
+			this.logger.info({
+				id,
+				tableName,
+				Category: "spooky-client::DataModule::rollbackUpdate"
+			}, "Rolled back optimistic update");
+		} catch (err) {
+			this.logger.error({
+				err,
+				id,
+				tableName,
+				Category: "spooky-client::DataModule::rollbackUpdate"
+			}, "Failed to rollback update");
+		}
+	}
+	/**
+	* Remove a record from all active query states and notify subscribers
+	*/
+	removeRecordFromQueries(recordId) {
+		const encodedId = encodeRecordId(recordId);
+		for (const [queryHash, queryState] of this.activeQueries.entries()) {
+			const index = queryState.records.findIndex((r) => {
+				return (r.id instanceof RecordId ? encodeRecordId(r.id) : String(r.id)) === encodedId;
+			});
+			if (index !== -1) {
+				queryState.records.splice(index, 1);
+				const subscribers = this.subscriptions.get(queryHash);
+				if (subscribers) for (const callback of subscribers) callback(queryState.records);
+			}
+		}
+	}
+	async createNewQuery({ recordId, surql: surqlString, params, ttl, tableName }) {
+		const tableSchema = this.schema.tables.find((t) => t.name === tableName);
+		if (!tableSchema) throw new Error(`Table ${tableName} not found`);
+		let [configRecord] = await withRetry(this.logger, () => this.local.query("SELECT * FROM ONLY $id", { id: recordId }));
+		if (!configRecord) {
+			const [createdRecord] = await withRetry(this.logger, () => this.local.query(surql.seal(surql.create("id", "data")), {
+				id: recordId,
+				data: {
+					surql: surqlString,
+					params,
+					localArray: [],
+					remoteArray: [],
+					lastActiveAt: /* @__PURE__ */ new Date(),
+					ttl,
+					tableName
+				}
+			}));
+			configRecord = createdRecord;
+		}
+		const config = {
+			...configRecord,
+			id: recordId,
+			params: parseParams(tableSchema.columns, configRecord.params)
+		};
+		let records = [];
+		try {
+			const [result] = await this.local.query(surqlString, params);
+			records = result || [];
+		} catch (err) {
+			this.logger.warn({
+				err,
+				Category: "spooky-client::DataModule::createNewQuery"
+			}, "Failed to load initial cached records");
+		}
+		return {
+			config,
+			records,
+			ttlTimer: null,
+			ttlDurationMs: parseDuration(ttl),
+			updateCount: 0
+		};
+	}
+	async calculateHash(data) {
+		const content = JSON.stringify(data);
+		const msgBuffer = new TextEncoder().encode(content);
+		const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
+		return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+	}
+	startTTLHeartbeat(queryState) {
+		if (queryState.ttlTimer) return;
+		const heartbeatTime = Math.floor(queryState.ttlDurationMs * .9);
+		queryState.ttlTimer = setTimeout(() => {
+			this.logger.debug({
+				id: encodeRecordId(queryState.config.id),
+				Category: "spooky-client::DataModule::startTTLHeartbeat"
+			}, "TTL heartbeat");
+			this.startTTLHeartbeat(queryState);
+		}, heartbeatTime);
+	}
+	stopTTLHeartbeat(queryState) {
+		if (queryState.ttlTimer) {
+			clearTimeout(queryState.ttlTimer);
+			queryState.ttlTimer = null;
+		}
+	}
+	async replaceRecordInQueries(record) {
+		for (const queryState of this.activeQueries.values()) this.replaceRecordInQuery(queryState, record);
+	}
+	replaceRecordInQuery(queryState, record) {
+		const index = queryState.records.findIndex((r) => r.id === record.id);
+		if (index !== -1) queryState.records[index] = record;
+	}
+};
+/**
+* Parse update options to generate push event options
+*/
+function parseUpdateOptions(id, data, options) {
+	let pushEventOptions = {};
+	if (options?.debounced) pushEventOptions = { debounced: {
+		delay: options.debounced !== true ? options.debounced?.delay ?? 200 : 200,
+		key: (options.debounced !== true ? options.debounced?.key ?? id : id) === "recordId_x_fields" ? `${id}::${Object.keys(data).sort().join("#")}` : id
+	} };
+	return pushEventOptions;
+}
+
+//#endregion
+//#region src/services/database/database.ts
+var AbstractDatabaseService = class {
+	client;
+	logger;
+	events;
+	constructor(client, logger, events) {
+		this.client = client;
+		this.logger = logger.child({ service: "Database" });
+		this.events = events;
+	}
+	getClient() {
+		return this.client;
+	}
+	getEvents() {
+		return this.events;
+	}
+	tx() {
+		return this.client.beginTransaction();
+	}
+	queryQueue = Promise.resolve();
+	/**
+	* Execute a query with serialized execution to prevent WASM transaction issues.
+	*/
+	async query(query, vars) {
+		return new Promise((resolve, reject) => {
+			this.queryQueue = this.queryQueue.then(async () => {
+				const startTime = performance.now();
+				try {
+					this.logger.debug({
+						query,
+						vars,
+						Category: "spooky-client::Database::query"
+					}, "Executing query");
+					const result = await this.client.query(query, vars);
+					const duration = performance.now() - startTime;
+					this.events.emit(this.eventType, {
+						query,
+						vars,
+						duration,
+						success: true,
+						timestamp: Date.now()
+					});
+					resolve(result);
+					this.logger.trace({
+						query,
+						result,
+						Category: "spooky-client::Database::query"
+					}, "Query executed successfully");
+				} catch (err) {
+					const duration = performance.now() - startTime;
+					this.events.emit(this.eventType, {
+						query,
+						vars,
+						duration,
+						success: false,
+						error: err instanceof Error ? err.message : String(err),
+						timestamp: Date.now()
+					});
+					this.logger.error({
+						query,
+						vars,
+						err,
+						Category: "spooky-client::Database::query"
+					}, "Query execution failed");
+					reject(err);
+				}
+			}).catch(() => {});
+		});
+	}
+	async execute(query, vars) {
+		const raw = await this.query(query.sql, vars);
+		return query.extract(raw);
+	}
+	async close() {
+		this.logger.info({ Category: "spooky-client::Database::close" }, "Closing database connection");
+		await this.client.close();
+	}
+};
+
+//#endregion
+//#region src/events/index.ts
+/**
+* A type-safe event system that handles subscription, emission (including debouncing), and buffering of events.
+* @template E The EventTypeMap defining all supported events.
+*/
+var EventSystem = class {
+	subscriberId = 0;
+	isProcessing = false;
+	buffer;
+	subscribers;
+	subscribersTypeMap;
+	lastEvents;
+	debouncedEvents;
+	constructor(_eventTypes) {
+		this._eventTypes = _eventTypes;
+		this.buffer = [];
+		this.subscribers = this._eventTypes.reduce((acc, key) => {
+			return Object.assign(acc, { [key]: /* @__PURE__ */ new Map() });
+		}, {});
+		this.lastEvents = {};
+		this.subscribersTypeMap = /* @__PURE__ */ new Map();
+		this.debouncedEvents = /* @__PURE__ */ new Map();
+	}
+	get eventTypes() {
+		return this._eventTypes;
+	}
+	/**
+	* Subscribes a handler to a specific event type.
+	* @param type The event type to subscribe to.
+	* @param handler The function to call when the event occurs.
+	* @param options Subscription options (once, immediately).
+	* @returns A subscription ID that can be used to unsubscribe.
+	*/
+	subscribe(type, handler, options) {
+		const id = this.subscriberId++;
+		this.subscribers[type].set(id, {
+			id,
+			handler,
+			once: options?.once ?? false
+		});
+		this.subscribersTypeMap.set(id, type);
+		if (options?.immediately) {
+			const lastEvent = this.lastEvents[type];
+			if (lastEvent) handler(lastEvent);
+		}
+		return id;
+	}
+	/**
+	* Subscribes a handler to multiple event types.
+	* @param types An array of event types to subscribe to.
+	* @param handler The function to call when any of the events occur.
+	* @param options Subscription options.
+	* @returns An array of subscription IDs.
+	*/
+	subscribeMany(types, handler, options) {
+		return types.map((type) => this.subscribe(type, handler, options));
+	}
+	/**
+	* Unsubscribes a specific subscription by ID.
+	* @param id The subscription ID returned by subscribe().
+	* @returns True if the subscription was found and removed, false otherwise.
+	*/
+	unsubscribe(id) {
+		const type = this.subscribersTypeMap.get(id);
+		if (type) {
+			this.subscribers[type].delete(id);
+			this.subscribersTypeMap.delete(id);
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Emits an event with the given type and payload.
+	* @param type The type of event to emit.
+	* @param payload The data associated with the event.
+	*/
+	emit(type, payload) {
+		const event = {
+			type,
+			payload
+		};
+		this.addEvent(event);
+	}
+	/**
+	* Adds a fully constructed event object to the system.
+	* Similar to emit, but takes the full event object directly.
+	* Supports debouncing if options are provided.
+	* @param event The event object.
+	* @param options Options for the event push (e.g., debouncing).
+	*/
+	addEvent(event, options) {
+		if (options?.debounced) {
+			this.handleDebouncedEvent(event, options.debounced.key, options.debounced.delay);
+			return;
+		}
+		this.buffer.push(event);
+		this.scheduleProcessing();
+	}
+	handleDebouncedEvent(event, key, delay) {
+		if (this.debouncedEvents.has(key)) clearTimeout(this.debouncedEvents.get(key)?.timer);
+		const timer = setTimeout(() => {
+			this.debouncedEvents.delete(key);
+			this.buffer.push(event);
+			this.scheduleProcessing();
+		}, delay);
+		this.debouncedEvents.set(key, {
+			timer,
+			resolve: () => {}
+		});
+	}
+	scheduleProcessing() {
+		if (!this.isProcessing) queueMicrotask(() => this.processEvents());
+	}
+	async processEvents() {
+		if (this.isProcessing) return;
+		this.isProcessing = true;
+		try {
+			while (this.dequeue());
+		} finally {
+			this.isProcessing = false;
+		}
+	}
+	dequeue() {
+		const event = this.buffer.shift();
+		if (!event) return false;
+		this.setLastEvent(event.type, event);
+		this.broadcastEvent(event.type, event);
+		return true;
+	}
+	setLastEvent(type, event) {
+		this.lastEvents[type] = event;
+	}
+	broadcastEvent(type, event) {
+		const subscribers = this.subscribers[type].values();
+		for (const subscriber of subscribers) {
+			subscriber.handler(event);
+			if (subscriber.once) this.unsubscribe(subscriber.id);
+		}
+	}
+};
+function createEventSystem(eventTypes) {
+	return new EventSystem(eventTypes);
+}
+
+//#endregion
+//#region src/services/database/events/index.ts
+const DatabaseEventTypes = {
+	LocalQuery: "DATABASE_LOCAL_QUERY",
+	RemoteQuery: "DATABASE_REMOTE_QUERY"
+};
+function createDatabaseEventSystem() {
+	return createEventSystem([DatabaseEventTypes.LocalQuery, DatabaseEventTypes.RemoteQuery]);
+}
+
+//#endregion
+//#region src/services/database/local.ts
+var LocalDatabaseService = class extends AbstractDatabaseService {
+	config;
+	eventType = DatabaseEventTypes.LocalQuery;
+	constructor(config, logger) {
+		const events = createDatabaseEventSystem();
+		super(new Surreal({
+			codecOptions: { valueDecodeVisitor(value) {
+				if (value instanceof RecordId) return encodeRecordId(value);
+				if (value instanceof DateTime) return value.toDate();
+				return value;
+			} },
+			engines: applyDiagnostics(createWasmWorkerEngines(), ({ key, type, phase, ...other }) => {
+				if (phase === "progress" || phase === "after") logger.trace({
+					...other,
+					key,
+					type,
+					phase,
+					service: "surrealdb:local",
+					Category: "spooky-client::LocalDatabaseService::diagnostics"
+				}, `Local SurrealDB diagnostics captured ${type}:${phase}`);
+			})
+		}), logger, events);
+		this.config = config;
+	}
+	getConfig() {
+		return this.config;
+	}
+	async connect() {
+		const { namespace, database } = this.getConfig();
+		this.logger.info({
+			namespace,
+			database,
+			Category: "spooky-client::LocalDatabaseService::connect"
+		}, "Connecting to local database");
+		try {
+			const storeUrl = (this.getConfig().store ?? "memory") === "memory" ? "mem://" : "indxdb://spooky";
+			this.logger.debug({
+				storeUrl,
+				Category: "spooky-client::LocalDatabaseService::connect"
+			}, "[LocalDatabaseService] Calling client.connect");
+			await this.client.connect(storeUrl, {});
+			this.logger.debug({
+				namespace,
+				database,
+				Category: "spooky-client::LocalDatabaseService::connect"
+			}, "[LocalDatabaseService] client.connect returned. Calling client.use");
+			await this.client.use({
+				namespace,
+				database
+			});
+			this.logger.debug({ Category: "spooky-client::LocalDatabaseService::connect" }, "[LocalDatabaseService] client.use returned");
+			this.logger.info({ Category: "spooky-client::LocalDatabaseService::connect" }, "Connected to local database");
+		} catch (err) {
+			this.logger.error({
+				err,
+				Category: "spooky-client::LocalDatabaseService::connect"
+			}, "Failed to connect to local database");
+			throw err;
+		}
+	}
+};
+
+//#endregion
+//#region src/services/database/remote.ts
+var RemoteDatabaseService = class extends AbstractDatabaseService {
+	config;
+	eventType = DatabaseEventTypes.RemoteQuery;
+	constructor(config, logger) {
+		const events = createDatabaseEventSystem();
+		super(new Surreal({ engines: applyDiagnostics(createRemoteEngines(), ({ key, type, phase, ...other }) => {
+			if (phase === "progress" || phase === "after") logger.trace({
+				...other,
+				key,
+				type,
+				phase,
+				service: "surrealdb:remote",
+				Category: "spooky-client::RemoteDatabaseService::diagnostics"
+			}, `Remote SurrealDB diagnostics captured ${type}:${phase}`);
+		}) }), logger, events);
+		this.config = config;
+	}
+	getConfig() {
+		return this.config;
+	}
+	async connect() {
+		const { endpoint, token, namespace, database } = this.getConfig();
+		if (endpoint) {
+			this.logger.info({
+				endpoint,
+				namespace,
+				database,
+				Category: "spooky-client::RemoteDatabaseService::connect"
+			}, "Connecting to remote database");
+			try {
+				await this.client.connect(endpoint);
+				await this.client.use({
+					namespace,
+					database
+				});
+				if (token) {
+					this.logger.debug({ Category: "spooky-client::RemoteDatabaseService::connect" }, "Authenticating with token");
+					await this.client.authenticate(token);
+				}
+				this.logger.info({ Category: "spooky-client::RemoteDatabaseService::connect" }, "Connected to remote database");
+			} catch (err) {
+				this.logger.error({
+					err,
+					Category: "spooky-client::RemoteDatabaseService::connect"
+				}, "Failed to connect to remote database");
+				throw err;
+			}
+		} else this.logger.warn({ Category: "spooky-client::RemoteDatabaseService::connect" }, "No endpoint configured for remote database");
+	}
+	async signin(params) {
+		return this.client.signin(params);
+	}
+	async signup(params) {
+		return this.client.signup(params);
+	}
+	async authenticate(token) {
+		return this.client.authenticate(token);
+	}
+	async invalidate() {
+		return this.client.invalidate();
+	}
+};
+
+//#endregion
+//#region src/services/logger/index.ts
+createContextKey("Category");
+function mapLevelToSeverityNumber(level) {
+	switch (level) {
+		case "trace": return 1;
+		case "debug": return 5;
+		case "info": return 9;
+		case "warn": return 13;
+		case "error": return 17;
+		case "fatal": return 21;
+		default: return 9;
+	}
+}
+function createLogger(level = "info", otelEndpoint) {
+	const browserConfig = {
+		asObject: true,
+		write: (o) => {
+			console.log(JSON.stringify(o));
+		}
+	};
+	if (otelEndpoint) {
+		const loggerProvider = new LoggerProvider({
+			resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: "spooky-client" }),
+			processors: [new BatchLogRecordProcessor(new OTLPLogExporter({ url: otelEndpoint }))]
+		});
+		const otelLogger = {};
+		const getOtelLogger = (category) => {
+			if (!otelLogger[category]) otelLogger[category] = loggerProvider.getLogger(category);
+			return otelLogger[category];
+		};
+		browserConfig.transmit = {
+			level,
+			send: (levelLabel, logEvent) => {
+				try {
+					const messages = [...logEvent.messages];
+					const severityNumber = mapLevelToSeverityNumber(levelLabel);
+					let body = "";
+					const msg = messages.pop();
+					if (typeof msg === "string") body = msg;
+					else if (msg) body = JSON.stringify(msg);
+					let category = "spooky-client::unknown";
+					const attributes = {};
+					for (const msg of messages) if (typeof msg === "object") {
+						if (msg.Category) {
+							category = msg.Category;
+							delete msg.Category;
+						}
+						Object.assign(attributes, msg);
+					}
+					getOtelLogger(category).emit({
+						severityNumber,
+						severityText: levelLabel.toUpperCase(),
+						body,
+						attributes: {
+							...logEvent.bindings[0],
+							...attributes
+						},
+						timestamp: new Date(logEvent.ts)
+					});
+				} catch (e) {
+					console.warn("Failed to transmit log to OTEL endpoint", e);
+				}
+			}
+		};
+	}
+	return pino({
+		level,
+		browser: browserConfig
+	});
+}
+
+//#endregion
+//#region src/services/database/local-migrator.ts
+const sha1 = async (str) => {
+	const enc = new TextEncoder();
+	const hash = await crypto.subtle.digest("SHA-1", enc.encode(str));
+	return Array.from(new Uint8Array(hash)).map((v) => v.toString(16).padStart(2, "0")).join("");
+};
+var LocalMigrator = class {
+	logger;
+	constructor(localDb, logger) {
+		this.localDb = localDb;
+		this.logger = logger.child({ service: "LocalMigrator" });
+		logger?.child({ service: "LocalMigrator" }) ?? createLogger("info").child({ service: "LocalMigrator" });
+	}
+	async provision(schemaSurql) {
+		const hash = await sha1(schemaSurql);
+		const { database } = this.localDb.getConfig();
+		if (await this.isSchemaUpToDate(hash)) {
+			this.logger.info({ Category: "spooky-client::LocalMigrator::provision" }, "[Provisioning] Schema is up to date, skipping migration");
+			return;
+		}
+		await this.recreateDatabase(database);
+		const fullSchema = schemaSurql + "\n\n      DEFINE TABLE IF NOT EXISTS _spooky_stream_processor_state SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _spooky_query SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _spooky_schema SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n      DEFINE TABLE IF NOT EXISTS _spooky_pending_mutations SCHEMALESS PERMISSIONS FOR select, create, update, delete WHERE true;\n    ";
+		const statements = this.splitStatements(fullSchema);
+		for (let i = 0; i < statements.length; i++) {
+			const statement = statements[i];
+			const cleanStatement = statement.replace(/--.*/g, "").trim();
+			if (cleanStatement.toUpperCase().startsWith("DEFINE INDEX")) {
+				this.logger.warn({ Category: "spooky-client::LocalMigrator::provision" }, `[Provisioning] Skipping index definition (WASM hang avoidance): ${cleanStatement.substring(0, 50)}...`);
+				continue;
+			}
+			try {
+				this.logger.info({ Category: "spooky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Executing: ${statement.substring(0, 50)}...`);
+				await this.localDb.query(statement);
+				this.logger.info({ Category: "spooky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Done`);
+			} catch (e) {
+				this.logger.error({ Category: "spooky-client::LocalMigrator::provision" }, `[Provisioning] (${i + 1}/${statements.length}) Error executing statement: ${statement}`);
+				throw e;
+			}
+		}
+		await this.createHashRecord(hash);
+	}
+	async isSchemaUpToDate(hash) {
+		try {
+			const [lastSchemaRecord] = await this.localDb.query(`SELECT hash, created_at FROM ONLY _spooky_schema ORDER BY created_at DESC LIMIT 1;`);
+			return lastSchemaRecord?.hash === hash;
+		} catch (error) {
+			return false;
+		}
+	}
+	async recreateDatabase(database) {
+		try {
+			await this.localDb.query(`DEFINE DATABASE _spooky_temp;`);
+		} catch (e) {}
+		try {
+			await this.localDb.query(`
+        USE DB _spooky_temp;
+        REMOVE DATABASE ${database};
+      `);
+		} catch (e) {}
+		await this.localDb.query(`
+      DEFINE DATABASE ${database};
+      USE DB ${database};
+    `);
+	}
+	splitStatements(schema) {
+		const statements = [];
+		let current = "";
+		let depth = 0;
+		let inQuote = false;
+		let quoteChar = "";
+		let inComment = false;
+		for (let i = 0; i < schema.length; i++) {
+			const char = schema[i];
+			const nextChar = schema[i + 1];
+			if (inComment) {
+				current += char;
+				if (char === "\n") inComment = false;
+				continue;
+			}
+			if (!inQuote && char === "-" && nextChar === "-") {
+				inComment = true;
+				current += char;
+				continue;
+			}
+			if (inQuote) {
+				current += char;
+				if (char === quoteChar && schema[i - 1] !== "\\") inQuote = false;
+				continue;
+			}
+			if (char === "\"" || char === "'") {
+				inQuote = true;
+				quoteChar = char;
+				current += char;
+				continue;
+			}
+			if (char === "{") {
+				depth++;
+				current += char;
+				continue;
+			}
+			if (char === "}") {
+				depth--;
+				current += char;
+				continue;
+			}
+			if (char === ";" && depth === 0) {
+				if (current.trim().length > 0) statements.push(current.trim());
+				current = "";
+				continue;
+			}
+			current += char;
+		}
+		if (current.trim().length > 0) statements.push(current.trim());
+		return statements;
+	}
+	async createHashRecord(hash) {
+		await this.localDb.query(`UPSERT _spooky_schema SET hash = $hash, created_at = time::now() WHERE hash = $hash;`, { hash });
+	}
+};
+
+//#endregion
+//#region src/modules/sync/events/index.ts
+const SyncQueueEventTypes = {
+	MutationEnqueued: "MUTATION_ENQUEUED",
+	MutationDequeued: "MUTATION_DEQUEUED",
+	QueryItemEnqueued: "QUERY_ITEM_ENQUEUED"
+};
+function createSyncQueueEventSystem() {
+	return createEventSystem([
+		SyncQueueEventTypes.QueryItemEnqueued,
+		SyncQueueEventTypes.MutationEnqueued,
+		SyncQueueEventTypes.MutationDequeued
+	]);
+}
+const SyncEventTypes = {
+	QueryUpdated: "SYNC_QUERY_UPDATED",
+	RemoteDataIngested: "SYNC_REMOTE_DATA_INGESTED",
+	MutationRolledBack: "SYNC_MUTATION_ROLLED_BACK"
+};
+function createSyncEventSystem() {
+	return createEventSystem([
+		SyncEventTypes.QueryUpdated,
+		SyncEventTypes.RemoteDataIngested,
+		SyncEventTypes.MutationRolledBack
+	]);
+}
+
+//#endregion
+//#region src/modules/sync/queue/queue-up.ts
+var UpQueue = class {
+	queue = [];
+	_events;
+	logger;
+	debouncedMutations;
+	get events() {
+		return this._events;
+	}
+	constructor(local, logger) {
+		this.local = local;
+		this._events = createSyncQueueEventSystem();
+		this.logger = logger.child({ service: "UpQueue" });
+		this.debouncedMutations = /* @__PURE__ */ new Map();
+	}
+	get size() {
+		return this.queue.length;
+	}
+	push(event) {
+		if (event.options?.debounced) {
+			const { key, delay } = event.options.debounced;
+			this.handleDebouncedMutation(event, key, delay);
+			return;
+		}
+		this.addToQueue(event);
+	}
+	addToQueue(event) {
+		this.queue.push(event);
+		this._events.addEvent({
+			type: SyncQueueEventTypes.MutationEnqueued,
+			payload: { queueSize: this.queue.length }
+		});
+	}
+	handleDebouncedMutation(event, key, delay) {
+		const existing = this.debouncedMutations.get(key);
+		let firstBeforeRecord;
+		if (existing) {
+			clearTimeout(existing.timer);
+			firstBeforeRecord = existing.firstBeforeRecord;
+		} else if (event.type === "update") firstBeforeRecord = event.beforeRecord;
+		const timer = setTimeout(() => {
+			this.debouncedMutations.delete(key);
+			if (firstBeforeRecord && event.type === "update") event.beforeRecord = firstBeforeRecord;
+			this.addToQueue(event);
+		}, delay);
+		this.debouncedMutations.set(key, {
+			timer,
+			firstBeforeRecord
+		});
+	}
+	async next(fn, onRollback) {
+		const event = this.queue.shift();
+		if (event) {
+			try {
+				await fn(event);
+			} catch (error) {
+				if (classifySyncError(error) === "network") {
+					this.logger.error({
+						error,
+						event,
+						Category: "spooky-client::UpQueue::next"
+					}, "Network error processing mutation, re-queuing");
+					this.queue.unshift(event);
+					throw error;
+				}
+				this.logger.error({
+					error,
+					event,
+					Category: "spooky-client::UpQueue::next"
+				}, "Application error processing mutation, rolling back");
+				try {
+					await this.removeEventFromDatabase(event.mutation_id);
+				} catch (removeError) {
+					this.logger.error({
+						error: removeError,
+						event,
+						Category: "spooky-client::UpQueue::next"
+					}, "Failed to remove rolled-back mutation from database");
+				}
+				if (onRollback) try {
+					await onRollback(event, error instanceof Error ? error : new Error(String(error)));
+				} catch (rollbackError) {
+					this.logger.error({
+						error: rollbackError,
+						event,
+						Category: "spooky-client::UpQueue::next"
+					}, "Rollback handler failed");
+				}
+				this._events.addEvent({
+					type: SyncQueueEventTypes.MutationDequeued,
+					payload: { queueSize: this.queue.length }
+				});
+				return;
+			}
+			try {
+				await this.removeEventFromDatabase(event.mutation_id);
+			} catch (error) {
+				this.logger.error({
+					error,
+					event,
+					Category: "spooky-client::UpQueue::next"
+				}, "Failed to remove mutation from database after successful processing");
+			}
+			this._events.addEvent({
+				type: SyncQueueEventTypes.MutationDequeued,
+				payload: { queueSize: this.queue.length }
+			});
+		}
+	}
+	async removeEventFromDatabase(mutation_id) {
+		return this.local.query(`DELETE $mutation_id`, { mutation_id });
+	}
+	async loadFromDatabase() {
+		try {
+			const [records] = await this.local.query(`SELECT * FROM _spooky_pending_mutations ORDER BY created_at ASC`);
+			this.queue = records.map((r) => {
+				switch (r.mutationType) {
+					case "create": return {
+						type: "create",
+						mutation_id: parseRecordIdString(r.id),
+						record_id: parseRecordIdString(r.recordId),
+						data: r.data,
+						tableName: extractTablePart(r.recordId)
+					};
+					case "update": return {
+						type: "update",
+						mutation_id: parseRecordIdString(r.id),
+						record_id: parseRecordIdString(r.recordId),
+						data: r.data,
+						beforeRecord: r.beforeRecord
+					};
+					case "delete": return {
+						type: "delete",
+						mutation_id: parseRecordIdString(r.id),
+						record_id: parseRecordIdString(r.recordId)
+					};
+					default:
+						this.logger.warn({
+							mutationType: r.mutationType,
+							record: r,
+							Category: "spooky-client::UpQueue::loadFromDatabase"
+						}, "Unknown mutation type");
+						return null;
+				}
+			}).filter((e) => e !== null);
+		} catch (error) {
+			this.logger.error({
+				error,
+				Category: "spooky-client::UpQueue::loadFromDatabase"
+			}, "Failed to load pending mutations from database");
+		}
+	}
+};
+
+//#endregion
+//#region src/modules/sync/queue/queue-down.ts
+var DownQueue = class {
+	queue = [];
+	_events;
+	logger;
+	get events() {
+		return this._events;
+	}
+	constructor(local, logger) {
+		this.local = local;
+		this._events = createSyncQueueEventSystem();
+		this.logger = logger.child({ service: "DownQueue" });
+	}
+	get size() {
+		return this.queue.length;
+	}
+	push(event) {
+		this.queue.push(event);
+		this.emitPushEvent();
+	}
+	emitPushEvent() {
+		this._events.addEvent({
+			type: SyncQueueEventTypes.QueryItemEnqueued,
+			payload: { queueSize: this.queue.length }
+		});
+	}
+	async next(fn) {
+		const event = this.queue.shift();
+		if (event) try {
+			await fn(event);
+		} catch (error) {
+			this.logger.error({
+				error,
+				event,
+				Category: "spooky-client::DownQueue::next"
+			}, "Failed to process query");
+			this.queue.unshift(event);
+			throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/modules/sync/utils.ts
+var ArraySyncer = class {
+	localArray;
+	remoteArray;
+	needsSort = false;
+	constructor(localArray, remoteArray) {
+		this.remoteArray = remoteArray.sort((a, b) => a[0].localeCompare(b[0]));
+		this.localArray = localArray.sort((a, b) => a[0].localeCompare(b[0]));
+	}
+	/**
+	* Inserts an item into the local array
+	*/
+	insert(recordId, version) {
+		this.localArray.push([recordId, version]);
+		this.needsSort = true;
+	}
+	/**
+	* Updates the current local RecordVersionArray state.
+	*/
+	update(recordId, version) {
+		this.localArray = this.localArray.map((record) => {
+			if (record[0] === recordId) {
+				this.needsSort = true;
+				return [recordId, version];
+			}
+			return record;
+		});
+	}
+	/**
+	* Deletes an item from the local array
+	*/
+	delete(recordId) {
+		this.localArray = this.localArray.filter((record) => record[0] !== recordId);
+	}
+	/**
+	* Returns the difference between the local and remote arrays.
+	* Includes sets of added, updated, and removed records.
+	*/
+	nextSet() {
+		if (this.needsSort) {
+			this.localArray.sort((a, b) => a[0].localeCompare(b[0]));
+			this.needsSort = false;
+		}
+		console.log("xxxx555", this.localArray, this.remoteArray);
+		return diffRecordVersionArray(this.localArray, this.remoteArray);
+	}
+};
+function diffRecordVersionArray(local, remote) {
+	const localArray = local || [];
+	const remoteArray = remote || [];
+	const localMap = new Map(localArray);
+	const remoteMap = new Map(remoteArray);
+	const added = [];
+	const updated = [];
+	const removed = [];
+	for (const [recordId, remoteVersion] of remoteMap) {
+		const localVersion = localMap.get(recordId);
+		if (localVersion === void 0) added.push(recordId);
+		else if (localVersion < remoteVersion) updated.push(recordId);
+	}
+	for (const [recordId] of localMap) if (!remoteMap.has(recordId)) removed.push(recordId);
+	return {
+		added: added.map((id) => ({
+			id: parseRecordIdString(id),
+			version: remoteMap.get(id)
+		})),
+		updated: updated.map((id) => ({
+			id: parseRecordIdString(id),
+			version: remoteMap.get(id)
+		})),
+		removed: removed.map(parseRecordIdString)
+	};
+}
+function createDiffFromDbOp(op, recordId, version, versions) {
+	if (op !== "DELETE") {
+		const old = versions?.find((record) => record[0] === encodeRecordId(recordId));
+		if (old && old[1] >= version) return {
+			added: [],
+			updated: [],
+			removed: []
+		};
+	}
+	if (op === "CREATE") return {
+		added: [{
+			id: recordId,
+			version
+		}],
+		updated: [],
+		removed: []
+	};
+	else if (op === "UPDATE") return {
+		added: [],
+		updated: [{
+			id: recordId,
+			version
+		}],
+		removed: []
+	};
+	else return {
+		added: [],
+		updated: [],
+		removed: [recordId]
+	};
+}
+
+//#endregion
+//#region src/modules/sync/engine.ts
+/**
+* SyncEngine handles the core sync operations: fetching remote records,
+* caching them locally, and ingesting into DBSP.
+*
+* This is extracted from SpookySync to separate "how to sync" from "when to sync".
+*/
+var SyncEngine = class {
+	logger;
+	events = createSyncEventSystem();
+	constructor(remote, cache, schema, logger) {
+		this.remote = remote;
+		this.cache = cache;
+		this.schema = schema;
+		this.logger = logger.child({ service: "SpookySync:SyncEngine" });
+	}
+	/**
+	* Sync missing/updated/removed records between local and remote.
+	* Main entry point for sync operations.
+	* Uses batch processing to minimize events emitted.
+	*/
+	async syncRecords(diff) {
+		const { added, updated, removed } = diff;
+		this.logger.debug({
+			added,
+			updated,
+			removed,
+			Category: "spooky-client::SyncEngine::syncRecords"
+		}, "SyncEngine.syncRecords diff");
+		if (removed.length > 0) await this.handleRemovedRecords(removed);
+		const idsToFetch = [...added, ...updated].map((x) => x.id);
+		if (idsToFetch.length === 0) return;
+		const [remoteResults] = await this.remote.query("SELECT (SELECT * FROM ONLY <record>$parent.id) AS record, (SELECT version FROM ONLY _spooky_version WHERE record_id = <record>$parent.id)['version'] as spooky_rv FROM $idsToFetch", { idsToFetch });
+		console.log("remoteResults>", remoteResults);
+		const cacheBatch = [];
+		for (const { spooky_rv, record } of remoteResults) {
+			if (!record?.id) {
+				this.logger.warn({
+					record,
+					idsToFetch,
+					Category: "spooky-client::SyncEngine::syncRecords"
+				}, "Remote record has no id. Skipping record");
+				continue;
+			}
+			const fullId = encodeRecordId(record.id);
+			const table = record.id.table.toString();
+			const isAdded = added.some((item) => encodeRecordId(item.id) === fullId);
+			const localVersion = this.cache.lookup(fullId);
+			if (localVersion && spooky_rv <= localVersion) {
+				this.logger.info({
+					recordId: fullId,
+					version: spooky_rv,
+					localVersion,
+					Category: "spooky-client::SyncEngine::syncRecords"
+				}, "Local version is higher than remote version. Skipping record");
+				continue;
+			}
+			const tableSchema = this.schema.tables.find((t) => t.name === table);
+			const cleanedRecord = tableSchema ? cleanRecord(tableSchema.columns, record) : record;
+			cacheBatch.push({
+				table,
+				op: isAdded ? "CREATE" : "UPDATE",
+				record: cleanedRecord,
+				version: spooky_rv
+			});
+		}
+		if (cacheBatch.length > 0) await this.cache.saveBatch(cacheBatch);
+		this.events.emit(SyncEventTypes.RemoteDataIngested, { records: remoteResults });
+	}
+	/**
+	* Handle records that exist locally but not in remote array.
+	*/
+	async handleRemovedRecords(removed) {
+		this.logger.debug({
+			removed: removed.map((r) => r.toString()),
+			Category: "spooky-client::SyncEngine::handleRemovedRecords"
+		}, "Checking removed records");
+		let existingRemoteIds = /* @__PURE__ */ new Set();
+		try {
+			const [existingRemote] = await this.remote.query("SELECT id FROM $ids", { ids: removed });
+			existingRemoteIds = new Set(existingRemote.map((r) => encodeRecordId(r.id)));
+		} catch {
+			this.logger.debug({ Category: "spooky-client::SyncEngine::handleRemovedRecords" }, "Remote existence check failed, proceeding with deletion");
+		}
+		for (const recordId of removed) {
+			const recordIdStr = encodeRecordId(recordId);
+			if (!existingRemoteIds.has(recordIdStr)) {
+				this.logger.debug({
+					recordId: recordIdStr,
+					Category: "spooky-client::SyncEngine::handleRemovedRecords"
+				}, "Deleting confirmed removed record");
+				await this.cache.delete(recordId.table.name, recordIdStr);
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/modules/sync/scheduler.ts
+/**
+* SyncScheduler manages when to sync: queue management and orchestration.
+* Decides the order and timing of sync operations.
+*/
+var SyncScheduler = class {
+	isSyncingUp = false;
+	isSyncingDown = false;
+	constructor(upQueue, downQueue, onProcessUp, onProcessDown, logger, onRollback) {
+		this.upQueue = upQueue;
+		this.downQueue = downQueue;
+		this.onProcessUp = onProcessUp;
+		this.onProcessDown = onProcessDown;
+		this.logger = logger;
+		this.onRollback = onRollback;
+	}
+	async init() {
+		await this.upQueue.loadFromDatabase();
+		this.upQueue.events.subscribe(SyncQueueEventTypes.MutationEnqueued, this.syncUp.bind(this));
+		this.downQueue.events.subscribe(SyncQueueEventTypes.QueryItemEnqueued, this.syncDown.bind(this));
+	}
+	/**
+	* Add mutations to the upload queue
+	*/
+	enqueueMutation(mutations) {
+		for (const mutation of mutations) this.upQueue.push(mutation);
+	}
+	/**
+	* Add query events to the download queue
+	*/
+	enqueueDownEvent(event) {
+		this.downQueue.push(event);
+	}
+	/**
+	* Process upload queue
+	*/
+	async syncUp() {
+		if (this.isSyncingUp) return;
+		this.isSyncingUp = true;
+		try {
+			while (this.upQueue.size > 0) await this.upQueue.next(this.onProcessUp, this.onRollback);
+		} finally {
+			this.isSyncingUp = false;
+			this.syncDown();
+		}
+	}
+	/**
+	* Process download queue
+	*/
+	async syncDown() {
+		if (this.isSyncingDown) return;
+		if (this.upQueue.size > 0) return;
+		this.isSyncingDown = true;
+		try {
+			while (this.downQueue.size > 0) {
+				if (this.upQueue.size > 0) break;
+				await this.downQueue.next(this.onProcessDown);
+			}
+		} finally {
+			this.isSyncingDown = false;
+		}
+	}
+	get isSyncing() {
+		return this.isSyncingUp || this.isSyncingDown;
+	}
+};
+
+//#endregion
+//#region src/modules/sync/sync.ts
+/**
+* The main synchronization engine for Spooky.
+* Handles the bidirectional synchronization between the local database and the remote backend.
+* Uses a queue-based architecture with 'up' (local to remote) and 'down' (remote to local) queues.
+* @template S The schema structure type.
+*/
+var SpookySync = class {
+	clientId = "";
+	upQueue;
+	downQueue;
+	isInit = false;
+	logger;
+	syncEngine;
+	scheduler;
+	events = createSyncEventSystem();
+	get isSyncing() {
+		return this.scheduler.isSyncing;
+	}
+	get pendingMutationCount() {
+		return this.upQueue.size;
+	}
+	subscribeToPendingMutations(cb) {
+		const id1 = this.upQueue.events.subscribe(SyncQueueEventTypes.MutationEnqueued, (event) => cb(event.payload.queueSize));
+		const id2 = this.upQueue.events.subscribe(SyncQueueEventTypes.MutationDequeued, (event) => cb(event.payload.queueSize));
+		return () => {
+			this.upQueue.events.unsubscribe(id1);
+			this.upQueue.events.unsubscribe(id2);
+		};
+	}
+	constructor(local, remote, cache, dataModule, schema, logger) {
+		this.local = local;
+		this.remote = remote;
+		this.cache = cache;
+		this.dataModule = dataModule;
+		this.schema = schema;
+		this.logger = logger.child({ service: "SpookySync" });
+		this.upQueue = new UpQueue(this.local, this.logger);
+		this.downQueue = new DownQueue(this.local, this.logger);
+		this.syncEngine = new SyncEngine(this.remote, this.cache, this.schema, this.logger);
+		this.scheduler = new SyncScheduler(this.upQueue, this.downQueue, this.processUpEvent.bind(this), this.processDownEvent.bind(this), this.logger, this.handleRollback.bind(this));
+	}
+	/**
+	* Initializes the synchronization system.
+	* Starts the scheduler and initiates the initial sync cycles.
+	* @param clientId The unique identifier for this client instance.
+	* @throws Error if already initialized.
+	*/
+	async init(clientId) {
+		if (this.isInit) throw new Error("SpookySync is already initialized");
+		this.clientId = clientId;
+		this.isInit = true;
+		await this.scheduler.init();
+		this.scheduler.syncUp();
+		this.scheduler.syncUp();
+		this.scheduler.syncDown();
+		this.startRefLiveQueries();
+	}
+	async startRefLiveQueries() {
+		this.logger.debug({
+			clientId: this.clientId,
+			Category: "spooky-client::SpookySync::startRefLiveQueries"
+		}, "Starting ref live queries");
+		const [queryUuid] = await this.remote.query("LIVE SELECT * FROM _spooky_list_ref");
+		(await this.remote.getClient().liveOf(queryUuid)).subscribe((message) => {
+			this.logger.debug({
+				message,
+				Category: "spooky-client::SpookySync::startRefLiveQueries"
+			}, "Live update received");
+			if (message.action === "KILLED") return;
+			this.handleRemoteListRefChange(message.action, message.value.in, message.value.out, message.value.version).catch((err) => {
+				this.logger.error({
+					err,
+					Category: "spooky-client::SpookySync::startRefLiveQueries"
+				}, "Error handling remote list ref change");
+			});
+		});
+	}
+	async handleRemoteListRefChange(action, queryId, recordId, version) {
+		const existing = this.dataModule.getQueryById(queryId);
+		if (!existing) {
+			this.logger.warn({
+				queryId: queryId.toString(),
+				Category: "spooky-client::SpookySync::handleRemoteListRefChange"
+			}, "Received remote update for unknown local query");
+			return;
+		}
+		const { localArray } = existing.config;
+		this.logger.debug({
+			action,
+			queryId,
+			recordId,
+			version,
+			localArray,
+			Category: "spooky-client::SpookySync::handleRemoteListRefChange"
+		}, "Live update is being processed");
+		const diff = createDiffFromDbOp(action, recordId, version, localArray);
+		await this.syncEngine.syncRecords(diff);
+	}
+	/**
+	* Enqueues a 'down' event (from remote to local) for processing.
+	* @param event The DownEvent to enqueue.
+	*/
+	enqueueDownEvent(event) {
+		this.scheduler.enqueueDownEvent(event);
+	}
+	async processUpEvent(event) {
+		this.logger.debug({
+			event,
+			Category: "spooky-client::SpookySync::processUpEvent"
+		}, "Processing up event");
+		console.log("xx1", event);
+		switch (event.type) {
+			case "create":
+				const dataKeys = Object.keys(event.data).map((key) => ({
+					key,
+					variable: `data_${key}`
+				}));
+				const prefixedParams = Object.fromEntries(dataKeys.map(({ key, variable }) => [variable, event.data[key]]));
+				const query = surql.seal(surql.createSet("id", dataKeys));
+				await this.remote.query(query, {
+					id: event.record_id,
+					...prefixedParams
+				});
+				break;
+			case "update":
+				await this.remote.query(`UPDATE $id MERGE $data`, {
+					id: event.record_id,
+					data: event.data
+				});
+				break;
+			case "delete":
+				await this.remote.query(`DELETE $id`, { id: event.record_id });
+				break;
+			default:
+				this.logger.error({
+					event,
+					Category: "spooky-client::SpookySync::processUpEvent"
+				}, "processUpEvent unknown event type");
+				return;
+		}
+	}
+	async handleRollback(event, error) {
+		const recordId = encodeRecordId(event.record_id);
+		const tableName = event.type === "create" && event.tableName ? event.tableName : extractTablePart(recordId);
+		this.logger.warn({
+			type: event.type,
+			recordId,
+			tableName,
+			error: error.message,
+			Category: "spooky-client::SpookySync::handleRollback"
+		}, "Rolling back failed mutation");
+		switch (event.type) {
+			case "create":
+				await this.dataModule.rollbackCreate(event.record_id, tableName);
+				break;
+			case "update":
+				if (event.beforeRecord) await this.dataModule.rollbackUpdate(event.record_id, tableName, event.beforeRecord);
+				else this.logger.warn({
+					recordId,
+					Category: "spooky-client::SpookySync::handleRollback"
+				}, "Cannot rollback update: no beforeRecord available. Down-sync will reconcile.");
+				break;
+			case "delete":
+				this.logger.warn({
+					recordId,
+					Category: "spooky-client::SpookySync::handleRollback"
+				}, "Delete rollback not implemented. Down-sync will reconcile.");
+				break;
+		}
+		this.events.emit(SyncEventTypes.MutationRolledBack, {
+			eventType: event.type,
+			recordId,
+			error: error.message
+		});
+	}
+	async processDownEvent(event) {
+		this.logger.debug({
+			event,
+			Category: "spooky-client::SpookySync::processDownEvent"
+		}, "Processing down event");
+		switch (event.type) {
+			case "register": return this.registerQuery(event.payload.hash);
+			case "sync": return this.syncQuery(event.payload.hash);
+			case "heartbeat": return this.heartbeatQuery(event.payload.hash);
+			case "cleanup": return this.cleanupQuery(event.payload.hash);
+		}
+	}
+	/**
+	* Synchronizes a specific query by hash.
+	* Compares local and remote version arrays and fetches differences.
+	* @param hash The hash of the query to sync.
+	*/
+	async syncQuery(hash) {
+		const queryState = this.dataModule.getQueryByHash(hash);
+		if (!queryState) {
+			this.logger.warn({
+				hash,
+				Category: "spooky-client::SpookySync::syncQuery"
+			}, "Query not found");
+			return;
+		}
+		const diff = new ArraySyncer(queryState.config.localArray, queryState.config.remoteArray).nextSet();
+		if (!diff) return;
+		return this.syncEngine.syncRecords(diff);
+	}
+	/**
+	* Enqueues a list of mutations (up events) to be sent to the remote.
+	* @param mutations Array of UpEvents (create/update/delete) to enqueue.
+	*/
+	async enqueueMutation(mutations) {
+		this.scheduler.enqueueMutation(mutations);
+	}
+	async registerQuery(queryHash) {
+		try {
+			this.logger.debug({
+				queryHash,
+				Category: "spooky-client::SpookySync::registerQuery"
+			}, "Register Query state");
+			await this.createRemoteQuery(queryHash);
+			await this.syncQuery(queryHash);
+		} catch (e) {
+			this.logger.error({
+				err: e,
+				Category: "spooky-client::SpookySync::registerQuery"
+			}, "registerQuery error");
+			throw e;
+		}
+	}
+	async createRemoteQuery(queryHash) {
+		const queryState = this.dataModule.getQueryByHash(queryHash);
+		if (!queryState) {
+			this.logger.warn({
+				queryHash,
+				Category: "spooky-client::SpookySync::createRemoteQuery"
+			}, "Query to register not found");
+			throw new Error("Query to register not found");
+		}
+		await this.remote.query("fn::query::register($config)", { config: {
+			clientId: this.clientId,
+			id: queryState.config.id,
+			surql: queryState.config.surql,
+			params: queryState.config.params,
+			ttl: queryState.config.ttl
+		} });
+		const [items] = await this.remote.query(surql.selectByFieldsAnd("_spooky_list_ref", ["in"], ["out", "version"]), { in: queryState.config.id });
+		this.logger.trace({
+			queryId: encodeRecordId(queryState.config.id),
+			items,
+			Category: "spooky-client::SpookySync::createRemoteQuery"
+		}, "Got query record version array from remote");
+		const array = items.map((item) => [encodeRecordId(item.out), item.version]);
+		this.logger.debug({
+			queryId: encodeRecordId(queryState.config.id),
+			array,
+			Category: "spooky-client::SpookySync::createRemoteQuery"
+		}, "createdRemoteQuery");
+		if (array) await this.dataModule.updateQueryRemoteArray(queryHash, array);
+	}
+	async heartbeatQuery(queryHash) {
+		const queryState = this.dataModule.getQueryByHash(queryHash);
+		if (!queryState) {
+			this.logger.warn({
+				queryHash,
+				Category: "spooky-client::SpookySync::heartbeatQuery"
+			}, "Query to register not found");
+			throw new Error("Query to register not found");
+		}
+		await this.remote.query("fn::query::heartbeat($id)", { id: queryState.config.id });
+	}
+	async cleanupQuery(queryHash) {
+		const queryState = this.dataModule.getQueryByHash(queryHash);
+		if (!queryState) {
+			this.logger.warn({
+				queryHash,
+				Category: "spooky-client::SpookySync::cleanupQuery"
+			}, "Query to register not found");
+			throw new Error("Query to register not found");
+		}
+		await this.remote.query(`DELETE $id`, { id: queryState.config.id });
+	}
+};
+
+//#endregion
+//#region src/modules/auth/events/index.ts
+const AuthEventTypes = { AuthStateChanged: "AUTH_STATE_CHANGED" };
+function createAuthEventSystem() {
+	return createEventSystem([AuthEventTypes.AuthStateChanged]);
+}
+
+//#endregion
+//#region src/modules/devtools/index.ts
+var DevToolsService = class {
+	eventsHistory = [];
+	eventIdCounter = 0;
+	version = "1.0.0";
+	constructor(databaseService, remoteDatabaseService, logger, schema, authService, dataManager) {
+		this.databaseService = databaseService;
+		this.remoteDatabaseService = remoteDatabaseService;
+		this.logger = logger;
+		this.schema = schema;
+		this.authService = authService;
+		this.dataManager = dataManager;
+		this.exposeToWindow();
+		this.authService.eventSystem.subscribe(AuthEventTypes.AuthStateChanged, () => {
+			this.notifyDevTools();
+		});
+		this.logger.debug({ Category: "spooky-client::DevToolsService::init" }, "Service initialized");
+	}
+	getActiveQueries() {
+		const result = /* @__PURE__ */ new Map();
+		if (!this.dataManager) return result;
+		this.dataManager.getActiveQueries().forEach((q) => {
+			const queryHash = this.hashString(encodeRecordId(q.config.id));
+			result.set(queryHash, {
+				queryHash,
+				status: "active",
+				createdAt: q.config.lastActiveAt instanceof Date ? q.config.lastActiveAt.getTime() : new Date(q.config.lastActiveAt || Date.now()).getTime(),
+				lastUpdate: Date.now(),
+				updateCount: q.updateCount,
+				query: q.config.surql,
+				variables: q.config.params || {},
+				dataSize: q.records?.length || 0,
+				data: q.records,
+				localArray: q.config.localArray,
+				remoteArray: q.config.remoteArray
+			});
+		});
+		return result;
+	}
+	onQueryInitialized(payload) {
+		this.logger.debug({
+			payload,
+			Category: "spooky-client::DevToolsService::onQueryInitialized"
+		}, "QueryInitialized");
+		const queryHash = this.hashString(payload.queryId.toString());
+		this.addEvent("QUERY_REQUEST_INIT", {
+			queryHash,
+			query: payload.sql,
+			variables: {}
+		});
+		this.notifyDevTools();
+	}
+	onQueryUpdated(payload) {
+		this.logger.debug({
+			id: payload.queryId?.toString(),
+			Category: "spooky-client::DevToolsService::onQueryUpdated"
+		}, "QueryUpdated");
+		const queryHash = this.hashString(payload.queryId.toString());
+		this.addEvent("QUERY_UPDATED", {
+			queryHash,
+			data: payload.records
+		});
+		this.notifyDevTools();
+	}
+	onStreamUpdate(update) {
+		this.logger.debug({
+			update,
+			Category: "spooky-client::DevToolsService::onStreamUpdate"
+		}, "StreamUpdate");
+		this.addEvent("STREAM_UPDATE", { updates: [update] });
+		this.notifyDevTools();
+	}
+	onMutation(payload) {
+		payload.forEach((p) => {
+			this.addEvent("MUTATION_REQUEST_EXECUTION", { mutation: {
+				type: "create",
+				data: "data" in p ? p.data : void 0,
+				selector: encodeRecordId(p.record_id)
+			} });
+		});
+		this.notifyDevTools();
+	}
+	hashString(str) {
+		let hash = 0;
+		if (str.length === 0) return hash;
+		for (let i = 0; i < str.length; i++) {
+			const char = str.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return hash;
+	}
+	logEvent(eventType, payload) {
+		this.addEvent(eventType, payload);
+		this.notifyDevTools();
+	}
+	addEvent(eventType, payload) {
+		this.eventsHistory.push({
+			id: this.eventIdCounter++,
+			timestamp: Date.now(),
+			eventType,
+			payload: this.serializeForDevTools(payload)
+		});
+		if (this.eventsHistory.length > 100) this.eventsHistory.shift();
+	}
+	getState() {
+		return this.serializeForDevTools({
+			eventsHistory: [...this.eventsHistory],
+			activeQueries: Object.fromEntries(this.getActiveQueries()),
+			auth: {
+				authenticated: this.authService.isAuthenticated,
+				userId: this.authService.currentUser?.id
+			},
+			version: this.version,
+			database: {
+				tables: this.schema.tables.map((t) => t.name),
+				tableData: {}
+			}
+		});
+	}
+	notifyDevTools() {
+		if (typeof window !== "undefined") window.postMessage({
+			type: "SPOOKY_STATE_CHANGED",
+			source: "spooky-devtools-page",
+			state: this.getState()
+		}, "*");
+	}
+	serializeForDevTools(data, seen = /* @__PURE__ */ new WeakSet()) {
+		if (data === void 0) return "undefined";
+		if (data === null) return null;
+		if (data instanceof RecordId) return data.toString();
+		if (Array.isArray(data)) {
+			if (seen.has(data)) return "[Circular Array]";
+			seen.add(data);
+			return data.map((item) => this.serializeForDevTools(item, seen));
+		}
+		if (typeof data === "bigint") return data.toString();
+		if (data instanceof Date) return data.toISOString();
+		if (typeof data === "object") {
+			if (seen.has(data)) return "[Circular Object]";
+			seen.add(data);
+			const result = {};
+			for (const key in data) if (Object.prototype.hasOwnProperty.call(data, key)) result[key] = this.serializeForDevTools(data[key], seen);
+			return result;
+		}
+		return data;
+	}
+	exposeToWindow() {
+		if (typeof window !== "undefined") {
+			window.__SPOOKY__ = {
+				version: this.version,
+				getState: () => this.getState(),
+				clearHistory: () => {
+					this.eventsHistory = [];
+					this.notifyDevTools();
+				},
+				getTableData: async (tableName) => {
+					try {
+						const result = await this.databaseService.query(`SELECT * FROM ${tableName}`);
+						let records = [];
+						if (Array.isArray(result) && result.length > 0) {
+							const first = result[0];
+							if (Array.isArray(first)) records = first;
+							else if (first && typeof first === "object" && "result" in first && "status" in first) records = Array.isArray(first.result) ? first.result : [];
+							else records = result;
+						} else if (Array.isArray(result)) records = [];
+						return this.serializeForDevTools(records) || [];
+					} catch (e) {
+						this.logger.error({
+							err: e,
+							Category: "spooky-client::DevToolsService::exposeToWindow"
+						}, "Failed to get table data");
+						return [];
+					}
+				},
+				updateTableRow: async (tableName, recordId, updates) => {
+					try {
+						await this.databaseService.query(`UPDATE ${recordId} MERGE $updates`, { updates });
+						return { success: true };
+					} catch (e) {
+						return {
+							success: false,
+							error: e.message
+						};
+					}
+				},
+				deleteTableRow: async (tableName, recordId) => {
+					try {
+						await this.databaseService.query(`DELETE ${recordId}`);
+						return { success: true };
+					} catch (e) {
+						return {
+							success: false,
+							error: e.message
+						};
+					}
+				},
+				runQuery: async (query, target = "local") => {
+					try {
+						this.logger.debug({
+							query,
+							target,
+							Category: "spooky-client::DevToolsService::runQuery"
+						}, "Running query (START)");
+						const service = target === "remote" ? this.remoteDatabaseService : this.databaseService;
+						const startTime = Date.now();
+						const result = await service.query(query);
+						const queryTime = Date.now() - startTime;
+						this.logger.debug({
+							query,
+							time: queryTime,
+							resultType: typeof result,
+							isArray: Array.isArray(result),
+							Category: "spooky-client::DevToolsService::runQuery"
+						}, "Database returned result");
+						const serializeStart = Date.now();
+						const serialized = this.serializeForDevTools(result);
+						const serializeTime = Date.now() - serializeStart;
+						this.logger.debug({
+							serializeTime,
+							serializedLength: JSON.stringify(serialized).length,
+							Category: "spooky-client::DevToolsService::runQuery"
+						}, "Serialization complete");
+						return {
+							success: true,
+							data: serialized,
+							target
+						};
+					} catch (e) {
+						this.logger.error({
+							err: e,
+							query,
+							target,
+							Category: "spooky-client::DevToolsService::runQuery"
+						}, "Query execution failed");
+						return {
+							success: false,
+							error: (e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e)) || "Unknown occurred"
+						};
+					}
+				}
+			};
+			window.postMessage({
+				type: "SPOOKY_DETECTED",
+				source: "spooky-devtools-page",
+				data: {
+					version: this.version,
+					detected: true
+				}
+			}, "*");
+		}
+	}
+};
+
+//#endregion
+//#region src/modules/auth/index.ts
+var AuthService = class {
+	token = null;
+	currentUser = null;
+	isAuthenticated = false;
+	isLoading = true;
+	events = createAuthEventSystem();
+	get eventSystem() {
+		return this.events;
+	}
+	constructor(schema, remote, persistenceClient, logger) {
+		this.schema = schema;
+		this.remote = remote;
+		this.persistenceClient = persistenceClient;
+		this.logger = logger;
+	}
+	async init() {
+		await this.check();
+	}
+	getAccessDefinition(name) {
+		return this.schema.access?.[name];
+	}
+	/**
+	* Subscribe to auth state changes.
+	* callback is called immediately with current value and whenever validation status changes.
+	*/
+	subscribe(cb) {
+		cb(this.currentUser?.id || null);
+		const id = this.events.subscribe(AuthEventTypes.AuthStateChanged, (event) => {
+			cb(event.payload);
+		});
+		return () => {
+			this.events.unsubscribe(id);
+		};
+	}
+	notifyListeners() {
+		const userId = this.currentUser?.id || null;
+		this.events.emit(AuthEventTypes.AuthStateChanged, userId);
+	}
+	/**
+	* Check for existing session and validate
+	*/
+	async check(accessToken) {
+		this.isLoading = true;
+		try {
+			const token = accessToken || await this.persistenceClient.get("spooky_auth_token");
+			if (!token) {
+				this.logger.debug({ Category: "spooky-client::AuthService::check" }, "No token found in storage or arguments");
+				this.isLoading = false;
+				this.isAuthenticated = false;
+				this.notifyListeners();
+				return;
+			}
+			await this.remote.getClient().authenticate(token);
+			const result = await this.remote.query("SELECT * FROM ONLY $auth.id");
+			const items = Array.isArray(result) && Array.isArray(result[0]) ? result[0] : result;
+			const user = Array.isArray(items) ? items[0] : items;
+			if (user && user.id) {
+				this.logger.info({
+					user,
+					Category: "spooky-client::AuthService::check"
+				}, "Auth check complete (via $auth.id)");
+				await this.setSession(token, user);
+			} else {
+				this.logger.warn({ Category: "spooky-client::AuthService::check" }, "$auth.id empty, attempting manual user fetch");
+				const manualResult = await this.remote.query("SELECT * FROM user WHERE id = $auth.id LIMIT 1");
+				const manualItems = Array.isArray(manualResult) && Array.isArray(manualResult[0]) ? manualResult[0] : manualResult;
+				const manualUser = Array.isArray(manualItems) ? manualItems[0] : manualItems;
+				if (manualUser && manualUser.id) {
+					this.logger.info({
+						user: manualUser,
+						Category: "spooky-client::AuthService::check"
+					}, "Auth check complete (via manual fetch)");
+					await this.setSession(token, manualUser);
+				} else {
+					this.logger.warn({ Category: "spooky-client::AuthService::check" }, "Token valid but user not found via fallback");
+					await this.signOut();
+				}
+			}
+		} catch (error) {
+			this.logger.error({
+				error,
+				stack: error.stack,
+				Category: "spooky-client::AuthService::check"
+			}, "Auth check failed");
+			await this.signOut();
+		} finally {
+			this.isLoading = false;
+		}
+	}
+	/**
+	* Sign out and clear session
+	*/
+	async signOut() {
+		this.token = null;
+		this.currentUser = null;
+		this.isAuthenticated = false;
+		await this.persistenceClient.remove("spooky_auth_token");
+		try {
+			await this.remote.getClient().invalidate();
+		} catch (e) {}
+		this.notifyListeners();
+	}
+	async setSession(token, user) {
+		this.token = token;
+		this.currentUser = user;
+		this.isAuthenticated = true;
+		await this.persistenceClient.set("spooky_auth_token", token);
+		this.notifyListeners();
+	}
+	async signUp(accessName, params) {
+		const def = this.getAccessDefinition(accessName);
+		if (!def) throw new Error(`Access definition '${accessName}' not found`);
+		const runtimeParams = params;
+		const missingParams = Object.entries(def.signup.params).filter(([name, schema]) => !schema.optional && !(name in runtimeParams)).map(([name]) => name);
+		if (missingParams.length > 0) throw new Error(`Missing required signup params for '${accessName}': ${missingParams.join(", ")}`);
+		this.logger.info({
+			accessName,
+			runtimeParams,
+			Category: "spooky-client::AuthService::signUp"
+		}, "Attempting signup");
+		const { access } = await this.remote.getClient().signup({
+			access: accessName,
+			variables: runtimeParams
+		});
+		this.logger.info({ Category: "spooky-client::AuthService::signUp" }, "Signup successful, token received");
+		await this.check(access);
+	}
+	async signIn(accessName, params) {
+		const def = this.getAccessDefinition(accessName);
+		if (!def) throw new Error(`Access definition '${accessName}' not found`);
+		const runtimeParams = params;
+		const missingParams = Object.entries(def.signIn.params).filter(([name, schema]) => !schema.optional && !(name in runtimeParams)).map(([name]) => name);
+		if (missingParams.length > 0) throw new Error(`Missing required signin params for '${accessName}': ${missingParams.join(", ")}`);
+		this.logger.info({
+			accessName,
+			Category: "spooky-client::AuthService::signIn"
+		}, "Attempting signin");
+		const { access } = await this.remote.getClient().signin({
+			access: accessName,
+			variables: runtimeParams
+		});
+		await this.check(access);
+	}
+};
+
+//#endregion
+//#region src/services/stream-processor/index.ts
+var StreamProcessorService = class {
+	logger;
+	processor;
+	isInitialized = false;
+	receivers = [];
+	constructor(events, db, persistenceClient, logger) {
+		this.events = events;
+		this.db = db;
+		this.persistenceClient = persistenceClient;
+		this.logger = logger.child({ name: "StreamProcessorService" });
+	}
+	/**
+	* Add a receiver for stream updates.
+	* Multiple receivers can be registered (DataManager, DevTools, etc.)
+	*/
+	addReceiver(receiver) {
+		this.receivers.push(receiver);
+	}
+	notifyUpdates(updates) {
+		for (const update of updates) for (const receiver of this.receivers) receiver.onStreamUpdate(update);
+	}
+	/**
+	* Initialize the WASM module and processor.
+	* This must be called before using other methods.
+	*/
+	async init() {
+		if (this.isInitialized) return;
+		this.logger.info({ Category: "spooky-client::StreamProcessorService::init" }, "Initializing WASM...");
+		try {
+			await init();
+			this.processor = new SpookyProcessor();
+			await this.loadState();
+			this.isInitialized = true;
+			this.logger.info({ Category: "spooky-client::StreamProcessorService::init" }, "Initialized successfully");
+		} catch (e) {
+			this.logger.error({
+				error: e,
+				Category: "spooky-client::StreamProcessorService::init"
+			}, "Failed to initialize");
+			throw e;
+		}
+	}
+	async loadState() {
+		if (!this.processor) return;
+		try {
+			const result = await this.persistenceClient.get("_spooky_stream_processor_state");
+			if (Array.isArray(result) && result.length > 0 && Array.isArray(result[0]) && result[0].length > 0 && result[0][0]?.state) {
+				const state = result[0][0].state;
+				this.logger.info({
+					stateLength: state.length,
+					Category: "spooky-client::StreamProcessorService::loadState"
+				}, "Loading state from DB");
+				if (typeof this.processor.load_state === "function") this.processor.load_state(state);
+				else this.logger.warn({ Category: "spooky-client::StreamProcessorService::loadState" }, "load_state method not found on processor");
+			} else this.logger.info({ Category: "spooky-client::StreamProcessorService::loadState" }, "No saved state found");
+		} catch (e) {
+			this.logger.error({
+				error: e,
+				Category: "spooky-client::StreamProcessorService::loadState"
+			}, "Failed to load state");
+		}
+	}
+	async saveState() {
+		if (!this.processor) return;
+		try {
+			if (typeof this.processor.save_state === "function") {
+				const state = this.processor.save_state();
+				if (state) {
+					await this.persistenceClient.set("_spooky_stream_processor_state", state);
+					this.logger.trace({ Category: "spooky-client::StreamProcessorService::saveState" }, "State saved");
+				}
+			}
+		} catch (e) {
+			this.logger.error({
+				error: e,
+				Category: "spooky-client::StreamProcessorService::saveState"
+			}, "Failed to save state");
+		}
+	}
+	/**
+	* Ingest a record change into the processor.
+	* Emits 'stream_update' event if materialized views are affected.
+	* @param isOptimistic true = local mutation (increment versions), false = remote sync (keep versions)
+	*/
+	ingest(table, op, id, record) {
+		this.logger.debug({
+			table,
+			op,
+			id,
+			Category: "spooky-client::StreamProcessorService::ingest"
+		}, "Ingesting into ssp");
+		if (!this.processor) {
+			this.logger.warn({ Category: "spooky-client::StreamProcessorService::ingest" }, "Not initialized, skipping ingest");
+			return [];
+		}
+		try {
+			const normalizedRecord = this.normalizeValue(record);
+			const rawUpdates = this.processor.ingest(table, op, id, normalizedRecord);
+			this.logger.debug({
+				table,
+				op,
+				id,
+				rawUpdates: rawUpdates.length,
+				Category: "spooky-client::StreamProcessorService::ingest"
+			}, "Ingesting into ssp done");
+			if (rawUpdates && Array.isArray(rawUpdates) && rawUpdates.length > 0) {
+				const updates = rawUpdates.map((u) => ({
+					queryHash: u.query_id,
+					localArray: u.result_data,
+					op
+				}));
+				this.notifyUpdates(updates);
+			}
+			this.saveState();
+			return rawUpdates;
+		} catch (e) {
+			this.logger.error({
+				error: e,
+				Category: "spooky-client::StreamProcessorService::ingest"
+			}, "Ingesting into ssp failed");
+		}
+		return [];
+	}
+	/**
+	* Register a new query plan.
+	* Emits 'stream_update' with the initial result.
+	*/
+	registerQueryPlan(queryPlan) {
+		if (!this.processor) {
+			this.logger.warn({ Category: "spooky-client::StreamProcessorService::registerQueryPlan" }, "Not initialized, skipping registration");
+			return;
+		}
+		this.logger.debug({
+			queryHash: queryPlan.queryHash,
+			surql: queryPlan.surql,
+			params: queryPlan.params,
+			Category: "spooky-client::StreamProcessorService::registerQueryPlan"
+		}, "Registering query plan");
+		try {
+			const normalizedParams = this.normalizeValue(queryPlan.params);
+			const initialUpdate = this.processor.register_view({
+				id: queryPlan.queryHash,
+				surql: queryPlan.surql,
+				params: normalizedParams,
+				clientId: "local",
+				ttl: queryPlan.ttl.toString(),
+				lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			this.logger.debug({
+				initialUpdate,
+				Category: "spooky-client::StreamProcessorService::registerQueryPlan"
+			}, "register_view result");
+			if (!initialUpdate) throw new Error("Failed to register query plan");
+			const update = {
+				queryHash: initialUpdate.query_id,
+				localArray: initialUpdate.result_data
+			};
+			this.saveState();
+			this.logger.debug({
+				queryHash: queryPlan.queryHash,
+				surql: queryPlan.surql,
+				params: queryPlan.params,
+				Category: "spooky-client::StreamProcessorService::registerQueryPlan"
+			}, "Registered query plan");
+			return update;
+		} catch (e) {
+			this.logger.error({
+				error: e,
+				Category: "spooky-client::StreamProcessorService::registerQueryPlan"
+			}, "Error registering query plan");
+			throw e;
+		}
+	}
+	/**
+	* Unregister a query plan by ID.
+	*/
+	unregisterQueryPlan(queryHash) {
+		if (!this.processor) return;
+		try {
+			this.processor.unregister_view(queryHash);
+			this.saveState();
+		} catch (e) {
+			this.logger.error({
+				error: e,
+				Category: "spooky-client::StreamProcessorService::unregisterQueryPlan"
+			}, "Error unregistering query plan");
+		}
+	}
+	normalizeValue(value) {
+		if (value === null || value === void 0) return value;
+		if (typeof value === "object") {
+			const hasTable = "table" in value && typeof value.table?.toString === "function";
+			const hasId = "id" in value;
+			const hasToString = typeof value.toString === "function";
+			const isNotPlainObject = value.constructor !== Object;
+			if (hasTable && hasId && hasToString && isNotPlainObject) {
+				const result = value.toString();
+				this.logger.trace({
+					result,
+					Category: "spooky-client::StreamProcessorService::normalizeValue"
+				}, "RecordId detected");
+				return result;
+			}
+			if ("tb" in value && "id" in value && !("table" in value)) return `${value.tb}:${value.id}`;
+			if (Array.isArray(value)) return value.map((v) => this.normalizeValue(v));
+			if (value.constructor === Object) {
+				const out = {};
+				for (const k in value) out[k] = this.normalizeValue(value[k]);
+				return out;
+			}
+		}
+		return value;
+	}
+};
+
+//#endregion
+//#region src/modules/cache/index.ts
+/**
+* CacheModule - Centralized storage and DBSP ingestion
+*
+* Single responsibility: Handle all local storage operations and DBSP ingestion.
+* This module acts as the bridge between data operations and persistence.
+*/
+var CacheModule = class {
+	logger;
+	streamUpdateCallback;
+	versionLookups = {};
+	constructor(local, streamProcessor, streamUpdateCallback, logger) {
+		this.local = local;
+		this.streamProcessor = streamProcessor;
+		this.logger = logger.child({ service: "CacheModule" });
+		this.streamUpdateCallback = streamUpdateCallback;
+		this.streamProcessor.addReceiver(this);
+	}
+	/**
+	* Implements StreamUpdateReceiver interface
+	* Called directly by StreamProcessor when views change
+	*/
+	onStreamUpdate(update) {
+		this.logger.debug({
+			queryHash: update.queryHash,
+			arrayLength: update.localArray?.length,
+			Category: "spooky-client::CacheModule::onStreamUpdate"
+		}, "Stream update received");
+		this.streamUpdateCallback(update);
+	}
+	lookup(recordId) {
+		return this.versionLookups[recordId] ?? 0;
+	}
+	/**
+	* Save a single record to local DB and ingest into DBSP
+	* Used by mutations (create/update)
+	*/
+	async save(cacheRecord, skipDbInsert = false) {
+		return this.saveBatch([cacheRecord], skipDbInsert);
+	}
+	/**
+	* Save multiple records in a batch
+	* More efficient than calling save() multiple times
+	* Used by sync operations
+	*/
+	async saveBatch(records, skipDbInsert = false) {
+		if (records.length === 0) return;
+		this.logger.debug({
+			count: records.length,
+			Category: "spooky-client::CacheModule::saveBatch"
+		}, "Saving record batch");
+		try {
+			const populatedRecords = records.map((record) => {
+				if (!record.version) throw new Error("Record version is required");
+				return {
+					...record,
+					record: {
+						...record.record,
+						spooky_rv: record.version
+					}
+				};
+			});
+			if (!skipDbInsert) {
+				const query = surql.seal(surql.tx(populatedRecords.map((_, i) => {
+					return surql.upsert(`id${i}`, `content${i}`);
+				})));
+				const params = populatedRecords.reduce((acc, record, i) => {
+					const { id, ...content } = record.record;
+					return {
+						...acc,
+						[`id${i}`]: id,
+						[`content${i}`]: content
+					};
+				}, {});
+				await this.local.execute(query, params);
+			}
+			for (const record of populatedRecords) {
+				const recordId = encodeRecordId(record.record.id);
+				this.versionLookups[recordId] = record.version;
+				this.streamProcessor.ingest(record.table, record.op, recordId, record.record);
+			}
+			this.logger.debug({
+				count: records.length,
+				Category: "spooky-client::CacheModule::saveBatch"
+			}, "Batch saved successfully");
+		} catch (err) {
+			this.logger.error({
+				err,
+				count: records.length,
+				Category: "spooky-client::CacheModule::saveBatch"
+			}, "Failed to save batch");
+			throw err;
+		}
+	}
+	/**
+	* Delete a record from local DB and ingest deletion into DBSP
+	*/
+	async delete(table, id, skipDbDelete = false) {
+		this.logger.debug({
+			table,
+			id,
+			Category: "spooky-client::CacheModule::delete"
+		}, "Deleting record");
+		try {
+			if (!skipDbDelete) await this.local.query("DELETE $id", { id: parseRecordIdString(id) });
+			delete this.versionLookups[id];
+			await this.streamProcessor.ingest(table, "DELETE", id, {});
+			this.logger.debug({
+				table,
+				id,
+				Category: "spooky-client::CacheModule::delete"
+			}, "Record deleted successfully");
+		} catch (err) {
+			this.logger.error({
+				err,
+				table,
+				id,
+				Category: "spooky-client::CacheModule::delete"
+			}, "Failed to delete record");
+			throw err;
+		}
+	}
+	/**
+	* Register a query with DBSP to create a materialized view
+	* Returns the initial result array
+	*/
+	registerQuery(config) {
+		this.logger.debug({
+			queryHash: config.queryHash,
+			surql: config.surql,
+			Category: "spooky-client::CacheModule::registerQuery"
+		}, "Registering query");
+		try {
+			const update = this.streamProcessor.registerQueryPlan({
+				queryHash: config.queryHash,
+				surql: config.surql,
+				params: config.params,
+				ttl: config.ttl,
+				lastActiveAt: config.lastActiveAt,
+				localArray: [],
+				remoteArray: [],
+				meta: { tableName: "" }
+			});
+			if (!update) throw new Error("Failed to register query with DBSP");
+			this.logger.debug({
+				queryHash: config.queryHash,
+				arrayLength: update.localArray?.length,
+				Category: "spooky-client::CacheModule::registerQuery"
+			}, "Query registered successfully");
+			return { localArray: update.localArray };
+		} catch (err) {
+			this.logger.error({
+				err,
+				queryHash: config.queryHash,
+				Category: "spooky-client::CacheModule::registerQuery"
+			}, "Failed to register query");
+			throw err;
+		}
+	}
+	/**
+	* Unregister a query from DBSP
+	*/
+	unregisterQuery(queryHash) {
+		this.logger.debug({
+			queryHash,
+			Category: "spooky-client::CacheModule::unregisterQuery"
+		}, "Unregistering query");
+		try {
+			this.streamProcessor.unregisterQueryPlan(queryHash);
+			this.logger.debug({
+				queryHash,
+				Category: "spooky-client::CacheModule::unregisterQuery"
+			}, "Query unregistered successfully");
+		} catch (err) {
+			this.logger.error({
+				err,
+				queryHash,
+				Category: "spooky-client::CacheModule::unregisterQuery"
+			}, "Failed to unregister query");
+		}
+	}
+};
+
+//#endregion
+//#region src/services/persistence/localstorage.ts
+var LocalStoragePersistenceClient = class {
+	logger;
+	constructor(logger) {
+		this.logger = logger.child({ service: "PersistenceClient:LocalStorage" });
+	}
+	set(key, value) {
+		localStorage.setItem(key, JSON.stringify(value));
+		return Promise.resolve();
+	}
+	get(key) {
+		const value = localStorage.getItem(key);
+		if (!value) return Promise.resolve(null);
+		return Promise.resolve(JSON.parse(value));
+	}
+	remove(key) {
+		localStorage.removeItem(key);
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/services/persistence/surrealdb.ts
+var SurrealDBPersistenceClient = class {
+	logger;
+	constructor(db, logger) {
+		this.db = db;
+		this.logger = logger.child({ service: "PersistenceClient:SurrealDb" });
+	}
+	async set(key, val) {
+		try {
+			const id = parseRecordIdString(`_spooky_kv:${key}`);
+			await this.db.query(surql.seal(surql.upsert("id", "data")), {
+				id,
+				data: { val }
+			});
+		} catch (error) {
+			this.logger.error({
+				error,
+				Category: "spooky-client::SurrealDBPersistenceClient::set"
+			}, "Failed to set KV");
+			throw error;
+		}
+	}
+	async get(key) {
+		try {
+			const id = parseRecordIdString(`_spooky_kv:${key}`);
+			const [result] = await this.db.query(surql.seal(surql.selectById("id", ["val"])), { id });
+			if (!result?.val) return null;
+			return result.val;
+		} catch (error) {
+			this.logger.warn({
+				error,
+				Category: "spooky-client::SurrealDBPersistenceClient::get"
+			}, "Failed to get KV");
+			return null;
+		}
+	}
+	async remove(key) {
+		try {
+			const id = parseRecordIdString(`_spooky_kv:${key}`);
+			await this.db.query(surql.seal(surql.delete("id")), { id });
+		} catch (err) {
+			this.logger.info({
+				err,
+				Category: "spooky-client::SurrealDBPersistenceClient::remove"
+			}, "Failed to delete KV");
+		}
+	}
+};
+
+//#endregion
+//#region src/spooky.ts
+var SpookyClient = class {
+	local;
+	remote;
+	persistenceClient;
+	migrator;
+	cache;
+	dataModule;
+	sync;
+	devTools;
+	logger;
+	auth;
+	streamProcessor;
+	get remoteClient() {
+		return this.remote.getClient();
+	}
+	get localClient() {
+		return this.local.getClient();
+	}
+	get pendingMutationCount() {
+		return this.sync.pendingMutationCount;
+	}
+	subscribeToPendingMutations(cb) {
+		return this.sync.subscribeToPendingMutations(cb);
+	}
+	constructor(config) {
+		this.config = config;
+		const logger = createLogger(config.logLevel ?? "info", config.otelEndpoint);
+		this.logger = logger.child({ service: "SpookyClient" });
+		this.logger.info({
+			config: {
+				...config,
+				schema: "[SchemaStructure]"
+			},
+			Category: "spooky-client::SpookyClient::constructor"
+		}, "SpookyClient initialized");
+		this.local = new LocalDatabaseService(this.config.database, logger);
+		this.remote = new RemoteDatabaseService(this.config.database, logger);
+		if (config.persistenceClient === "surrealdb") this.persistenceClient = new SurrealDBPersistenceClient(this.local, logger);
+		else if (config.persistenceClient === "localstorage" || !config.persistenceClient) this.persistenceClient = new LocalStoragePersistenceClient(logger);
+		else this.persistenceClient = config.persistenceClient;
+		this.streamProcessor = new StreamProcessorService(new EventSystem(["stream_update"]), this.local, this.persistenceClient, logger);
+		this.migrator = new LocalMigrator(this.local, logger);
+		this.cache = new CacheModule(this.local, this.streamProcessor, (update) => {
+			this.dataModule.onStreamUpdate(update);
+		}, logger);
+		this.dataModule = new DataModule(this.cache, this.local, this.config.schema, logger, this.config.streamDebounceTime);
+		this.auth = new AuthService(this.config.schema, this.remote, this.persistenceClient, logger);
+		this.sync = new SpookySync(this.local, this.remote, this.cache, this.dataModule, this.config.schema, this.logger);
+		this.devTools = new DevToolsService(this.local, this.remote, logger, this.config.schema, this.auth, this.dataModule);
+		this.streamProcessor.addReceiver(this.devTools);
+		this.setupCallbacks();
+	}
+	/**
+	* Setup direct callbacks instead of event subscriptions
+	*/
+	setupCallbacks() {
+		this.dataModule.onMutation((mutations) => {
+			this.devTools.onMutation(mutations);
+			if (mutations.length > 0) this.sync.enqueueMutation(mutations);
+		});
+		this.sync.events.subscribe("SYNC_QUERY_UPDATED", (event) => {
+			this.devTools.logEvent("SYNC_QUERY_UPDATED", event.payload);
+		});
+		this.local.getEvents().subscribe("DATABASE_LOCAL_QUERY", (event) => {
+			this.devTools.logEvent("LOCAL_QUERY", event.payload);
+		});
+		this.remote.getEvents().subscribe("DATABASE_REMOTE_QUERY", (event) => {
+			this.devTools.logEvent("REMOTE_QUERY", event.payload);
+		});
+	}
+	async init() {
+		this.logger.info({ Category: "spooky-client::SpookyClient::init" }, "SpookyClient initialization started");
+		try {
+			const clientId = this.config.clientId ?? await this.loadOrGenerateClientId();
+			this.persistClientId(clientId);
+			this.logger.debug({
+				clientId,
+				Category: "spooky-client::SpookyClient::init"
+			}, "Client ID loaded");
+			await this.local.connect();
+			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Local database connected");
+			await this.migrator.provision(this.config.schemaSurql);
+			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Schema provisioned");
+			await this.remote.connect();
+			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Remote database connected");
+			await this.streamProcessor.init();
+			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "StreamProcessor initialized");
+			await this.auth.init();
+			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Auth initialized");
+			await this.dataModule.init();
+			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "DataModule initialized");
+			await this.sync.init(clientId);
+			this.logger.debug({ Category: "spooky-client::SpookyClient::init" }, "Sync initialized");
+			this.logger.info({ Category: "spooky-client::SpookyClient::init" }, "SpookyClient initialization completed successfully");
+		} catch (e) {
+			this.logger.error({
+				error: e,
+				Category: "spooky-client::SpookyClient::init"
+			}, "SpookyClient initialization failed");
+			throw e;
+		}
+	}
+	async close() {
+		await this.local.close();
+		await this.remote.close();
+	}
+	authenticate(token) {
+		return this.remote.getClient().authenticate(token);
+	}
+	deauthenticate() {
+		return this.remote.getClient().invalidate();
+	}
+	query(table, options, ttl = "10m") {
+		return new QueryBuilder(this.config.schema, table, async (q) => ({ hash: await this.initQuery(table, q, ttl) }), options);
+	}
+	async initQuery(table, q, ttl) {
+		const tableSchema = this.config.schema.tables.find((t) => t.name === table);
+		if (!tableSchema) throw new Error(`Table ${table} not found`);
+		const hash = await this.dataModule.query(table, q.selectQuery.query, parseParams(tableSchema.columns, q.selectQuery.vars ?? {}), ttl);
+		await this.sync.enqueueDownEvent({
+			type: "register",
+			payload: { hash }
+		});
+		return hash;
+	}
+	async queryRaw(sql, params, ttl) {
+		const tableName = sql.split("FROM ")[1].split(" ")[0];
+		return this.dataModule.query(tableName, sql, params, ttl);
+	}
+	async subscribe(queryHash, callback, options) {
+		return this.dataModule.subscribe(queryHash, callback, options);
+	}
+	run(backend, path, payload, options) {
+		return this.dataModule.run(backend, path, payload, options);
+	}
+	create(id, data) {
+		return this.dataModule.create(id, data);
+	}
+	update(table, id, data, options) {
+		return this.dataModule.update(table, id, data, options);
+	}
+	delete(table, id) {
+		return this.dataModule.delete(table, id);
+	}
+	async useRemote(fn) {
+		return fn(this.remote.getClient());
+	}
+	persistClientId(id) {
+		try {
+			this.persistenceClient.set("spooky_client_id", id);
+		} catch (e) {
+			this.logger.warn({
+				error: e,
+				Category: "spooky-client::SpookyClient::persistClientId"
+			}, "Failed to persist client ID");
+		}
+	}
+	async loadOrGenerateClientId() {
+		const clientId = await this.persistenceClient.get("spooky_client_id");
+		if (clientId) return clientId;
+		const newId = generateId();
+		await this.persistClientId(newId);
+		return newId;
+	}
+};
+
+//#endregion
+export { AuthEventTypes, AuthService, SpookyClient, createAuthEventSystem };