@powerhousedao/reactor-browser 6.2.0-dev.5 → 6.2.0-dev.50

package/dist/src/rpc/index.js

@@ -0,0 +1,1250 @@
+import { t as RegistryClient } from "../../client-u13cr-Vg.js";
+import { DriveCollectionId, ReactorEventTypes, SyncEventTypes } from "@powerhousedao/reactor";
+//#region src/rpc/listeners.ts
+var KeyedListeners = class {
+	map = /* @__PURE__ */ new Map();
+	add(key, fn) {
+		let set = this.map.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.map.set(key, set);
+		}
+		set.add(fn);
+		return () => {
+			const current = this.map.get(key);
+			if (!current) return;
+			current.delete(fn);
+			if (current.size === 0) this.map.delete(key);
+		};
+	}
+	emit(key, ...a) {
+		const set = this.map.get(key);
+		if (!set) return;
+		for (const fn of [...set]) fn(...a);
+	}
+	emitAll(...a) {
+		for (const set of [...this.map.values()]) for (const fn of [...set]) fn(...a);
+	}
+};
+var Listeners = class {
+	keyed = new KeyedListeners();
+	add(fn) {
+		return this.keyed.add(null, fn);
+	}
+	emit(...a) {
+		this.keyed.emit(null, ...a);
+	}
+};
+//#endregion
+//#region src/rpc/op-channel.ts
+const RPC_DEFAULT_TIMEOUT_MS = 3e4;
+function toVoid(promise) {
+	return promise.then(() => void 0);
+}
+function opChannel(router, kind, timeoutMs = RPC_DEFAULT_TIMEOUT_MS) {
+	const call = (method, args = []) => router.request((id) => ({
+		k: kind,
+		id,
+		method,
+		args
+	}), { timeoutMs });
+	return {
+		call,
+		callVoid: (method, args) => toVoid(call(method, args))
+	};
+}
+//#endregion
+//#region src/rpc/admin-client.ts
+/** Worker lifecycle channel (info/restart/clearStorage/migrate) over the shared router. */
+function createWorkerAdminClient(router) {
+	let migrationState = { status: "idle" };
+	const migrationListeners = new Listeners();
+	router.on("migration", (msg) => {
+		migrationState = msg.state;
+		migrationListeners.emit();
+	});
+	const send = (method) => router.request((id) => ({
+		k: "admin",
+		id,
+		method
+	}), { timeoutMs: RPC_DEFAULT_TIMEOUT_MS });
+	return {
+		info: () => send("info"),
+		restart: () => toVoid(send("restart")),
+		clearStorage: () => toVoid(send("clearStorage")),
+		migrate: () => toVoid(send("migrate")),
+		getMigrationState: () => migrationState,
+		subscribeMigration: (callback) => migrationListeners.add(callback)
+	};
+}
+//#endregion
+//#region src/rpc/error-info.ts
+const MAX_STACK_LENGTH = 8 * 1024;
+const MAX_CAUSE_DEPTH = 8;
+function toErrorInfo(err, depth = 0) {
+	if (depth > MAX_CAUSE_DEPTH) return {
+		name: "Error",
+		message: "cause chain truncated"
+	};
+	if (err instanceof Error) {
+		const info = {
+			name: err.name || "Error",
+			message: err.message
+		};
+		if (typeof err.stack === "string") info.stack = err.stack.length > MAX_STACK_LENGTH ? err.stack.slice(0, MAX_STACK_LENGTH) : err.stack;
+		if (err.cause !== void 0) info.cause = toErrorInfo(err.cause, depth + 1);
+		return info;
+	}
+	if (typeof err === "string") return {
+		name: "Error",
+		message: err
+	};
+	if (err && typeof err === "object") {
+		const record = err;
+		return {
+			name: typeof record.name === "string" ? record.name : "Error",
+			message: typeof record.message === "string" ? record.message : safeStringify(err)
+		};
+	}
+	return {
+		name: "Error",
+		message: safeStringify(err)
+	};
+}
+function safeStringify(value) {
+	if (value === null || value === void 0) return String(value);
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "[unserializable]";
+	}
+}
+function fromErrorInfo(info) {
+	const err = new Error(info.message);
+	Object.defineProperty(err, "name", {
+		value: info.name,
+		configurable: true,
+		writable: true
+	});
+	if (info.stack !== void 0) err.stack = info.stack;
+	if (info.cause !== void 0) Object.defineProperty(err, "cause", {
+		value: fromErrorInfo(info.cause),
+		configurable: true,
+		writable: true
+	});
+	return err;
+}
+//#endregion
+//#region src/rpc/paging.ts
+function isPageableResult(value) {
+	return value !== null && typeof value === "object" && typeof value.next === "function";
+}
+function hasNextToken(value) {
+	return value !== null && typeof value === "object" && typeof value.nextToken === "string";
+}
+function dehydratePage(value, registerCursor) {
+	if (!isPageableResult(value)) return value;
+	const { next, ...rest } = value;
+	return {
+		...rest,
+		nextToken: registerCursor(next)
+	};
+}
+function rehydratePage(value, fetchPage) {
+	if (!hasNextToken(value)) return value;
+	const { nextToken, ...rest } = value;
+	return {
+		...rest,
+		next: () => fetchPage(nextToken)
+	};
+}
+//#endregion
+//#region src/rpc/subscription.ts
+var SubscriptionStore = class {
+	map = /* @__PURE__ */ new Map();
+	set(id, unsubscribe) {
+		this.map.set(id, unsubscribe);
+	}
+	get(id) {
+		return this.map.get(id);
+	}
+	delete(id) {
+		this.map.delete(id);
+	}
+	end(id) {
+		const unsubscribe = this.map.get(id);
+		if (unsubscribe) {
+			this.map.delete(id);
+			unsubscribe();
+		}
+	}
+	drain() {
+		for (const unsubscribe of this.map.values()) unsubscribe();
+		this.map.clear();
+	}
+};
+function createCorrelatedSubscriptions(router, config) {
+	let counter = 0;
+	const subs = /* @__PURE__ */ new Map();
+	router.on(config.eventKind, (message) => {
+		const sub = subs.get(message.id);
+		if (sub) config.onEvent(sub, message);
+	});
+	router.on(config.errKind, (message) => {
+		const id = message.id;
+		const sub = subs.get(id);
+		if (sub) {
+			subs.delete(id);
+			router.post(config.close(id));
+			config.onError(sub, message);
+		}
+	});
+	return { subscribe(sub, open) {
+		const id = `${config.idPrefix}${++counter}`;
+		subs.set(id, sub);
+		router.post(open(id));
+		return () => {
+			subs.delete(id);
+			router.post(config.close(id));
+		};
+	} };
+}
+//#endregion
+//#region src/rpc/client-proxy.ts
+function isAbortSignal(value) {
+	return typeof value === "object" && value !== null && typeof value.aborted === "boolean" && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
+}
+function createReactorClientProxy(router, options = {}) {
+	const registry = options.registry;
+	function fetchPage(token) {
+		return router.request((id) => ({
+			k: "page",
+			id,
+			token
+		}), { transform: rehydrate });
+	}
+	function rehydrate(value) {
+		return rehydratePage(value, fetchPage);
+	}
+	const changeSubs = createCorrelatedSubscriptions(router, {
+		idPrefix: "sub",
+		eventKind: "event",
+		errKind: "sub-err",
+		onEvent: (callback, msg) => callback(msg.change),
+		onError: (_callback, msg) => console.error("Reactor subscription failed:", fromErrorInfo(msg.error)),
+		close: (id) => ({
+			k: "unsub",
+			id
+		})
+	});
+	router.on("reload", (msg) => {
+		options.onReload?.(msg.reason, msg.workerGen);
+	});
+	const call = (method, args) => {
+		let abortAt;
+		for (let i = 0; i < args.length; i++) if (isAbortSignal(args[i])) abortAt = i;
+		let wire = args;
+		if (abortAt !== void 0) {
+			wire = args.slice();
+			wire[abortAt] = void 0;
+		}
+		return router.request((id) => ({
+			k: "req",
+			id,
+			method,
+			args: wire,
+			abortAt
+		}), {
+			transform: rehydrate,
+			setup: (id) => {
+				if (abortAt === void 0) return;
+				const signal = args[abortAt];
+				const sendAbort = () => router.post({
+					k: "abort",
+					targetId: id
+				});
+				if (signal.aborted) {
+					sendAbort();
+					return;
+				}
+				signal.addEventListener("abort", sendAbort, { once: true });
+				return () => signal.removeEventListener("abort", sendAbort);
+			}
+		});
+	};
+	const subscribe = (search, callback, view) => changeSubs.subscribe(callback, (id) => ({
+		k: "sub",
+		id,
+		search,
+		view
+	}));
+	const forwarders = /* @__PURE__ */ new Map();
+	const forwarder = (method) => {
+		let fn = forwarders.get(method);
+		if (!fn) {
+			fn = (...args) => call(method, args);
+			forwarders.set(method, fn);
+		}
+		return fn;
+	};
+	const drives = new Proxy({}, { get: (_target, prop) => typeof prop === "string" ? forwarder(`drives.${prop}`) : void 0 });
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop !== "string" || prop === "then") return;
+		if (prop === "drives") return drives;
+		if (prop === "subscribe") return subscribe;
+		if (registry) {
+			if (prop === "getDocumentModelModule") return (documentType) => Promise.resolve().then(() => registry.getModule(documentType));
+			if (prop === "getDocumentModelModules") return (_namespace, paging) => Promise.resolve({
+				results: registry.getAllModules(),
+				options: paging ?? {
+					cursor: "",
+					limit: Number.MAX_SAFE_INTEGER
+				}
+			});
+		}
+		return forwarder(prop);
+	} });
+}
+//#endregion
+//#region src/rpc/inspector-proxy.ts
+function createInspectorProxy(router) {
+	const ops = opChannel(router, "inspector-op");
+	return {
+		getQueueState: () => ops.call("queue.getState"),
+		pauseQueue: () => ops.callVoid("queue.pause"),
+		resumeQueue: () => ops.callVoid("queue.resume"),
+		getProcessors: () => ops.call("processors.getAll"),
+		retryProcessor: (processorId) => ops.callVoid("processors.retry", [processorId]),
+		validateDocument: (documentId, branch) => ops.call("integrity.validate", [documentId, branch]),
+		rebuildKeyframes: (documentId, branch) => ops.call("integrity.rebuildKeyframes", [documentId, branch]),
+		rebuildSnapshots: (documentId, branch) => ops.call("integrity.rebuildSnapshots", [documentId, branch]),
+		queryReactorDb: (sql, params) => ops.call("db.query", [sql, params ?? []])
+	};
+}
+//#endregion
+//#region src/rpc/protocol.ts
+const RPC_PROTOCOL_VERSION = 2;
+/** Error reply kind for a client message kind, so it reaches the right registry. */
+function responseErrorKind(k) {
+	if (k === "sub") return "sub-err";
+	if (k === "sub-live") return "live-err";
+	return "err";
+}
+//#endregion
+//#region src/rpc/host-reply.ts
+const defaultOk = () => ({ ok: true });
+function hostResponder(transport) {
+	const ok = (id, value = { ok: true }) => {
+		transport.post({
+			k: "res",
+			id,
+			value
+		});
+	};
+	const err = (id, error) => {
+		transport.post({
+			k: "err",
+			id,
+			error: toErrorInfo(error)
+		});
+	};
+	return {
+		ok,
+		err,
+		errForKind(message, error) {
+			if (!("id" in message)) return;
+			transport.post({
+				k: responseErrorKind(message.k),
+				id: message.id,
+				error: toErrorInfo(error)
+			});
+		},
+		async run(id, body, mapOk = defaultOk) {
+			try {
+				ok(id, mapOk(await body()));
+			} catch (error) {
+				err(id, error);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/rpc/live-query-proxy.ts
+function createLiveQueryProxy(router) {
+	const subs = createCorrelatedSubscriptions(router, {
+		idPrefix: "live",
+		eventKind: "event-live",
+		errKind: "live-err",
+		onEvent: (sub, msg) => sub.onResults(msg.results),
+		onError: (sub, msg) => sub.onError?.(fromErrorInfo(msg.error)),
+		close: (id) => ({
+			k: "unsub-live",
+			id
+		})
+	});
+	return { query(sql, params, onResults, onError) {
+		return subs.subscribe({
+			onResults,
+			onError
+		}, (id) => ({
+			k: "sub-live",
+			id,
+			sql,
+			params
+		}));
+	} };
+}
+//#endregion
+//#region src/rpc/relational-db-proxy.ts
+function createRelationalPgliteProxy(router) {
+	const ops = opChannel(router, "db-op");
+	const liveProxy = createLiveQueryProxy(router);
+	return {
+		query: async (sql, params) => {
+			return { rows: await ops.call("query", [sql, params ?? []]) };
+		},
+		live: { query: (sql, params, callback) => new Promise((resolve, reject) => {
+			let settled = false;
+			const unsubscribe = liveProxy.query(sql, params ?? [], (results) => {
+				if (!settled) {
+					settled = true;
+					resolve({ unsubscribe });
+				}
+				callback?.(results);
+			}, (error) => {
+				if (!settled) {
+					settled = true;
+					reject(error instanceof Error ? error : new Error(String(error)));
+				}
+			});
+		}) }
+	};
+}
+//#endregion
+//#region src/rpc/sync-manager-proxy.ts
+const SYNC_STATUS_CHANGED_EVENT = 90001;
+const SEED_MAX_ATTEMPTS = 3;
+const SEED_RETRY_DELAY_MS = 500;
+const DEFAULT_SNAPSHOT = {
+	state: "connecting",
+	failureCount: 0,
+	lastSuccessUtcMs: 0,
+	lastFailureUtcMs: 0,
+	pushBlocked: false,
+	pushFailureCount: 0,
+	receivingPages: false,
+	requiresAuth: false
+};
+var NoopMailbox = class {
+	get items() {
+		return [];
+	}
+	get ackOrdinal() {
+		return 0;
+	}
+	get latestOrdinal() {
+		return 0;
+	}
+	init() {}
+	advanceOrdinal() {}
+	get() {}
+	add() {}
+	remove() {}
+	onAdded() {}
+	onRemoved() {}
+	pause() {}
+	resume() {}
+	flush() {}
+	isPaused() {
+		return false;
+	}
+};
+const NOOP_MAILBOX = new NoopMailbox();
+function rehydrateMeta(wire) {
+	return {
+		id: wire.id,
+		name: wire.name,
+		collectionId: DriveCollectionId.forDrive(wire.collectionId.driveId, wire.collectionId.branch),
+		channelConfig: wire.channelConfig,
+		filter: wire.filter,
+		options: wire.options
+	};
+}
+function channelUrl(meta) {
+	const url = meta.channelConfig.parameters.url;
+	return typeof url === "string" ? url : void 0;
+}
+var SyncManagerProxy = class {
+	ops;
+	connectionStates = /* @__PURE__ */ new Map();
+	connectionListeners = new KeyedListeners();
+	syncStatuses = /* @__PURE__ */ new Map();
+	syncStatusListeners = new Listeners();
+	remotes = [];
+	seedPromise = null;
+	constructor(router, busProxy) {
+		this.ops = opChannel(router, "sync-op");
+		busProxy.subscribe(SyncEventTypes.CONNECTION_STATE_CHANGED, (_type, event) => {
+			const e = event;
+			this.connectionStates.set(e.remoteName, e.snapshot);
+			this.notifyConnection(e.remoteName);
+		});
+		busProxy.subscribe(SYNC_STATUS_CHANGED_EVENT, (_type, event) => {
+			const e = event;
+			this.syncStatuses.set(e.documentId, e.status);
+			this.syncStatusListeners.emit(e.documentId, e.status);
+		});
+		this.ensureSeeded();
+	}
+	async startup() {
+		let lastError;
+		for (let attempt = 0; attempt < SEED_MAX_ATTEMPTS; attempt++) try {
+			await this.ensureSeeded();
+			return;
+		} catch (error) {
+			lastError = error;
+			if (attempt < SEED_MAX_ATTEMPTS - 1) await new Promise((resolve) => setTimeout(resolve, SEED_RETRY_DELAY_MS));
+		}
+		throw lastError;
+	}
+	shutdown() {
+		return {
+			isShutdown: true,
+			completed: Promise.resolve()
+		};
+	}
+	getByName(name) {
+		const remote = this.remotes.find((r) => r.meta.name === name);
+		if (!remote) throw new Error(`Unknown remote: ${name}`);
+		return remote;
+	}
+	getById(id) {
+		const remote = this.remotes.find((r) => r.meta.id === id);
+		if (!remote) throw new Error(`Unknown remote id: ${id}`);
+		return remote;
+	}
+	async add(name, collectionId, channelConfig, filter, options) {
+		await this.callSyncOp("add", [
+			name,
+			collectionId.key,
+			channelConfig,
+			filter,
+			options
+		]);
+		await this.refreshRemotes();
+		return this.getByName(name);
+	}
+	triggerPull(name) {
+		this.callSyncOp("triggerPull", [name]).catch((error) => {
+			console.error(`triggerPull failed for remote "${name}":`, error);
+		});
+	}
+	async remove(name) {
+		await this.callSyncOp("remove", [name]);
+		await this.refreshRemotes();
+	}
+	list() {
+		return [...this.remotes];
+	}
+	waitForSync() {
+		return Promise.reject(/* @__PURE__ */ new Error("waitForSync is not supported over the worker RPC boundary"));
+	}
+	getSyncStatus(documentId) {
+		return this.syncStatuses.get(documentId);
+	}
+	onSyncStatusChange(callback) {
+		return this.syncStatusListeners.add(callback);
+	}
+	callSyncOp(method, args) {
+		return this.ops.call(method, args);
+	}
+	notifyConnection(remoteName) {
+		if (remoteName !== void 0) {
+			this.connectionListeners.emit(remoteName);
+			return;
+		}
+		this.connectionListeners.emitAll();
+	}
+	makeChannel(remoteName, url) {
+		return {
+			inbox: NOOP_MAILBOX,
+			outbox: NOOP_MAILBOX,
+			deadLetter: NOOP_MAILBOX,
+			init: () => Promise.resolve(),
+			shutdown: () => Promise.resolve(),
+			getConnectionState: () => this.connectionStates.get(remoteName) ?? DEFAULT_SNAPSHOT,
+			onConnectionStateChange: (callback) => {
+				const listener = () => callback(this.connectionStates.get(remoteName) ?? DEFAULT_SNAPSHOT);
+				return this.connectionListeners.add(remoteName, listener);
+			},
+			triggerPull: () => {
+				this.callSyncOp("triggerPull", [remoteName]).catch((error) => {
+					console.error(`triggerPull failed for remote "${remoteName}":`, error);
+				});
+			},
+			config: { url }
+		};
+	}
+	async refreshRemotes() {
+		const wire = await this.callSyncOp("list", []);
+		const names = /* @__PURE__ */ new Set();
+		this.remotes = wire.map((w) => {
+			const meta = rehydrateMeta(w.meta);
+			names.add(meta.name);
+			if (!this.connectionStates.has(meta.name)) this.connectionStates.set(meta.name, w.connectionState);
+			return {
+				meta,
+				channel: this.makeChannel(meta.name, channelUrl(meta))
+			};
+		});
+		for (const name of [...this.connectionStates.keys()]) if (!names.has(name)) this.connectionStates.delete(name);
+		this.notifyConnection();
+	}
+	ensureSeeded() {
+		if (!this.seedPromise) {
+			const pending = this.refreshRemotes();
+			this.seedPromise = pending;
+			pending.catch(() => {
+				if (this.seedPromise === pending) this.seedPromise = null;
+			});
+		}
+		return this.seedPromise;
+	}
+};
+function createSyncManagerProxy(router, busProxy) {
+	return new SyncManagerProxy(router, busProxy);
+}
+//#endregion
+//#region src/rpc/forwarded-events.ts
+const FORWARDED_EVENT_TYPES = [
+	SyncEventTypes.SYNC_PENDING,
+	SyncEventTypes.SYNC_SUCCEEDED,
+	SyncEventTypes.SYNC_FAILED,
+	SyncEventTypes.DEAD_LETTER_ADDED,
+	SyncEventTypes.CONNECTION_STATE_CHANGED,
+	ReactorEventTypes.MODEL_LOADED
+];
+const FORWARDED_BUS_EVENT_TYPES = [...FORWARDED_EVENT_TYPES, SYNC_STATUS_CHANGED_EVENT];
+//#endregion
+//#region src/rpc/event-bus-proxy.ts
+/** Tab-side IEventBus over bus-event; emit() is unsupported (the worker emits). */
+var ReactorEventBusProxy = class {
+	forwardedTypes = new Set(FORWARDED_BUS_EVENT_TYPES);
+	subscribers = new KeyedListeners();
+	constructor(router) {
+		router.on("bus-event", (msg) => {
+			this.subscribers.emit(msg.eventType, msg.eventType, msg.event);
+		});
+	}
+	subscribe(type, subscriber) {
+		if (!this.forwardedTypes.has(type)) throw new Error(`ReactorEventBusProxy cannot subscribe to event type ${type}: the worker forwards only [${[...this.forwardedTypes].join(", ")}]`);
+		const entry = subscriber;
+		return this.subscribers.add(type, entry);
+	}
+	emit() {
+		return Promise.reject(/* @__PURE__ */ new Error("EventBus.emit is not supported tab-side; the reactor graph emits in the worker"));
+	}
+};
+function createReactorEventBusProxy(router) {
+	return new ReactorEventBusProxy(router);
+}
+//#endregion
+//#region src/rpc/connect-reactor.ts
+function connectReactorClient(router, hello, onReload, registry) {
+	const client = createReactorClientProxy(router, {
+		onReload,
+		registry
+	});
+	router.post({
+		k: "hello",
+		id: "hello",
+		version: hello.version,
+		construct: hello.construct,
+		packages: hello.packages
+	});
+	return client;
+}
+function postReactorIdentity(router, user) {
+	router.post({
+		k: "identity",
+		user
+	});
+}
+//#endregion
+//#region src/rpc/host-server.ts
+const MAX_PENDING_PAGES = 1e3;
+var ReactorHostServer = class {
+	client;
+	transport;
+	reply;
+	aborters = /* @__PURE__ */ new Map();
+	subscriptions = new SubscriptionStore();
+	pages = /* @__PURE__ */ new Map();
+	pageCounter = 0;
+	detach = () => {};
+	constructor(client, transport) {
+		this.client = client;
+		this.transport = transport;
+		this.reply = hostResponder(transport);
+	}
+	start() {
+		this.detach = this.transport.onMessage((message) => {
+			this.handleMessage(message);
+		});
+	}
+	stop() {
+		this.detach();
+		this.subscriptions.drain();
+		this.aborters.clear();
+		this.pages.clear();
+	}
+	async handleMessage(message) {
+		try {
+			switch (message.k) {
+				case "req":
+					await this.handleRequest(message);
+					return;
+				case "page":
+					await this.handlePage(message);
+					return;
+				case "abort":
+					this.aborters.get(message.targetId)?.abort();
+					return;
+				case "sub":
+					this.handleSubscribe(message);
+					return;
+				case "unsub":
+					this.subscriptions.end(message.id);
+					return;
+			}
+		} catch (error) {
+			this.reply.errForKind(message, error);
+		}
+	}
+	async handleRequest(message) {
+		let args = message.args;
+		let controller;
+		if (message.abortAt !== void 0) {
+			controller = new AbortController();
+			this.aborters.set(message.id, controller);
+			args = message.args.slice();
+			args[message.abortAt] = controller.signal;
+		}
+		try {
+			const value = await this.resolveMethod(message.method)(...args);
+			this.reply.ok(message.id, this.prepareResult(value));
+		} catch (error) {
+			this.reply.err(message.id, error);
+		} finally {
+			if (controller) this.aborters.delete(message.id);
+		}
+	}
+	async handlePage(message) {
+		const next = this.pages.get(message.token);
+		this.pages.delete(message.token);
+		if (!next) {
+			this.reply.err(message.id, /* @__PURE__ */ new Error("Paged cursor already consumed or expired"));
+			return;
+		}
+		try {
+			const value = await next();
+			this.reply.ok(message.id, this.prepareResult(value));
+		} catch (error) {
+			this.reply.err(message.id, error);
+		}
+	}
+	handleSubscribe(message) {
+		const unsubscribe = this.client.subscribe(message.search, (change) => this.transport.post({
+			k: "event",
+			id: message.id,
+			change
+		}), message.view);
+		this.subscriptions.set(message.id, unsubscribe);
+	}
+	prepareResult(value) {
+		return dehydratePage(value, (next) => {
+			const token = `p${++this.pageCounter}`;
+			this.pages.set(token, next);
+			if (this.pages.size > MAX_PENDING_PAGES) {
+				const oldest = this.pages.keys().next().value;
+				if (oldest !== void 0) this.pages.delete(oldest);
+			}
+			return token;
+		});
+	}
+	resolveMethod(path) {
+		if (path.startsWith("drives.")) {
+			const name = path.slice(7);
+			const fn = this.client.drives[name];
+			if (typeof fn !== "function") throw new Error(`Unknown drive method: ${name}`);
+			return fn.bind(this.client.drives);
+		}
+		const fn = this.client[path];
+		if (typeof fn !== "function") throw new Error(`Unknown reactor method: ${path}`);
+		return fn.bind(this.client);
+	}
+};
+//#endregion
+//#region src/rpc/transport.ts
+function createPortTransport(port) {
+	port.start();
+	port.addEventListener("messageerror", (event) => {
+		console.error("[rpc transport] failed to deserialize message", event);
+	});
+	return {
+		post(message) {
+			port.postMessage(message);
+		},
+		onMessage(listener) {
+			const handler = (event) => {
+				listener(event.data);
+			};
+			port.addEventListener("message", handler);
+			return () => port.removeEventListener("message", handler);
+		},
+		close() {
+			port.close();
+		}
+	};
+}
+//#endregion
+//#region src/rpc/reactor-host.ts
+function isDataMessage(msg) {
+	return msg.k === "req" || msg.k === "sub" || msg.k === "page" || msg.k === "sync-op" || msg.k === "db-op" || msg.k === "inspector-op" || msg.k === "sub-live";
+}
+function versionsCompatible(a, b) {
+	return a.appBuildId === b.appBuildId && a.rpcProtocolVersion === b.rpcProtocolVersion;
+}
+function workerGenForVersion(version) {
+	return `v${version.rpcProtocolVersion}-${version.appBuildId}`;
+}
+var ReactorHost = class {
+	options;
+	disposers = /* @__PURE__ */ new Set();
+	clients = /* @__PURE__ */ new Set();
+	clientPromise = null;
+	baseline = null;
+	ownerId;
+	bootedAtMs;
+	migrationState = null;
+	constructor(options) {
+		this.options = options;
+		this.ownerId = options.ownerId ?? crypto.randomUUID();
+		this.bootedAtMs = options.bootedAtMs ?? Date.now();
+		if (options.client) this.clientPromise = Promise.resolve(options.client);
+	}
+	connect(transport) {
+		let server = null;
+		let ready = false;
+		const buffer = [];
+		const liveSubs = new SubscriptionStore();
+		const reply = hostResponder(transport);
+		const ensureServer = async (construct) => {
+			if (server) return;
+			server = new ReactorHostServer(await this.resolveClient(construct), transport);
+		};
+		const drainBuffer = async () => {
+			while (buffer.length > 0) {
+				const message = buffer.shift();
+				await server.handleMessage(message);
+			}
+			ready = true;
+		};
+		const detach = transport.onMessage((message) => {
+			const msg = message;
+			if (msg.k === "ping") {
+				transport.post({
+					k: "pong",
+					id: msg.id,
+					ownerId: this.ownerId,
+					bootedAtMs: this.bootedAtMs
+				});
+				return;
+			}
+			if (this.migrationState?.status === "migrating" && isDataMessage(msg)) {
+				reply.errForKind(msg, /* @__PURE__ */ new Error("migration in progress"));
+				return;
+			}
+			if (msg.k === "hello") {
+				this.handleHello(msg, transport, reply, ensureServer, drainBuffer);
+				return;
+			}
+			if (msg.k === "register-packages") {
+				this.handleRegister(msg, reply);
+				return;
+			}
+			if (msg.k === "unregister-packages") {
+				this.handleUnregister(msg, reply);
+				return;
+			}
+			if (msg.k === "identity") {
+				this.options.onIdentity?.(msg.user);
+				return;
+			}
+			if (msg.k === "sync-op") {
+				this.handleOp(msg, this.options.onSyncOp, "sync", reply);
+				return;
+			}
+			if (msg.k === "db-op") {
+				this.handleOp(msg, this.options.onDbOp, "db", reply);
+				return;
+			}
+			if (msg.k === "inspector-op") {
+				this.handleOp(msg, this.options.onInspectorOp, "inspector", reply);
+				return;
+			}
+			if (msg.k === "sub-live") {
+				this.handleLiveSubscribe(msg, transport, reply, liveSubs);
+				return;
+			}
+			if (msg.k === "unsub-live") {
+				liveSubs.end(msg.id);
+				return;
+			}
+			if (msg.k === "admin") {
+				this.handleAdmin(msg, reply);
+				return;
+			}
+			if (ready && server) server.handleMessage(msg);
+			else buffer.push(msg);
+		});
+		this.clients.add(transport);
+		if (this.migrationState) transport.post({
+			k: "migration",
+			state: this.migrationState
+		});
+		if (this.options.client) ensureServer().then(drainBuffer).catch((error) => {
+			console.error("ReactorHost buffer drain failed", error);
+		});
+		const dispose = () => {
+			server?.stop();
+			detach();
+			liveSubs.drain();
+			this.clients.delete(transport);
+			this.disposers.delete(dispose);
+		};
+		this.disposers.add(dispose);
+		return dispose;
+	}
+	connectPort(port) {
+		return this.connect(createPortTransport(port));
+	}
+	broadcastBusEvent(eventType, event) {
+		for (const transport of this.clients) transport.post({
+			k: "bus-event",
+			eventType,
+			event
+		});
+	}
+	broadcastReload(reason, workerGen) {
+		for (const transport of this.clients) transport.post({
+			k: "reload",
+			reason,
+			workerGen
+		});
+	}
+	setMigrationState(state) {
+		this.migrationState = state;
+		for (const transport of this.clients) transport.post({
+			k: "migration",
+			state
+		});
+	}
+	get connectionCount() {
+		return this.disposers.size;
+	}
+	handleAdmin(message, reply) {
+		if (message.method === "restart") {
+			this.options.onAdminRestart?.();
+			reply.ok(message.id);
+			return;
+		}
+		if (message.method === "clearStorage") {
+			this.handleAdminAsync(this.options.onAdminClearStorage, message, reply);
+			return;
+		}
+		if (message.method === "migrate") {
+			this.handleAdminAsync(this.options.onAdminMigrate, message, reply);
+			return;
+		}
+		const info = {
+			namespace: this.options.namespace ?? "",
+			ownerId: this.ownerId,
+			bootedAtMs: this.bootedAtMs,
+			connectedClients: this.connectionCount,
+			appBuildId: this.baseline?.appBuildId ?? this.options.appBuildId ?? "unknown",
+			rpcProtocolVersion: this.baseline?.rpcProtocolVersion ?? 2
+		};
+		reply.ok(message.id, info);
+	}
+	async handleAdminAsync(handler, message, reply) {
+		await reply.run(message.id, async () => {
+			await handler?.();
+		});
+	}
+	resolveClient(construct) {
+		if (!this.clientPromise) {
+			const build = this.options.build;
+			if (!build) return Promise.reject(/* @__PURE__ */ new Error("ReactorHost has no client or builder"));
+			const pending = build(construct);
+			this.clientPromise = pending;
+			pending.catch(() => {
+				if (this.clientPromise === pending) this.clientPromise = null;
+			});
+		}
+		return this.clientPromise;
+	}
+	async awaitClientReady() {
+		if (this.clientPromise) await this.clientPromise;
+	}
+	requireHandler(handler, message, reply, label) {
+		if (handler) return true;
+		reply.errForKind(message, /* @__PURE__ */ new Error(`ReactorHost has no ${label} handler`));
+		return false;
+	}
+	async handleHello(message, transport, reply, ensureServer, drainBuffer) {
+		if (this.baseline) {
+			if (!versionsCompatible(this.baseline, message.version)) {
+				transport.post({
+					k: "reload",
+					reason: "reactor version mismatch",
+					workerGen: workerGenForVersion(message.version)
+				});
+				reply.ok(message.id, { ok: false });
+				return;
+			}
+		} else this.baseline = message.version;
+		await reply.run(message.id, async () => {
+			await ensureServer(message.construct);
+			if (message.packages && message.packages.length > 0) await this.options.registerPackages?.(message.packages);
+			await drainBuffer();
+		});
+	}
+	async handleRegister(message, reply) {
+		await reply.run(message.id, async () => {
+			await this.options.registerPackages?.(message.specs);
+		});
+	}
+	async handleUnregister(message, reply) {
+		await reply.run(message.id, async () => {
+			await this.options.unregisterPackages?.(message.names);
+		});
+	}
+	async handleOp(message, handler, label, reply) {
+		if (!this.requireHandler(handler, message, reply, label)) return;
+		await reply.run(message.id, async () => {
+			await this.awaitClientReady();
+			return handler(message.method, message.args);
+		}, (value) => value);
+	}
+	async handleLiveSubscribe(message, transport, reply, liveSubs) {
+		const handler = this.options.onLiveQuery;
+		if (!this.requireHandler(handler, message, reply, "live-query")) return;
+		const placeholder = () => void 0;
+		liveSubs.set(message.id, placeholder);
+		try {
+			await this.awaitClientReady();
+			const unsubscribe = await handler(message.sql, message.params, (results) => {
+				transport.post({
+					k: "event-live",
+					id: message.id,
+					results
+				});
+			});
+			if (liveSubs.get(message.id) !== placeholder) {
+				unsubscribe();
+				return;
+			}
+			liveSubs.set(message.id, unsubscribe);
+		} catch (error) {
+			if (liveSubs.get(message.id) === placeholder) liveSubs.delete(message.id);
+			reply.errForKind(message, error);
+		}
+	}
+};
+//#endregion
+//#region src/rpc/worker-package-loader.ts
+function packageName(spec) {
+	const at = spec.lastIndexOf("@");
+	return at > 0 ? spec.slice(0, at) : spec;
+}
+function isDocumentModelModule(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.reducer === "function" && typeof candidate.documentModel?.global?.id === "string";
+}
+var WorkerPackageLoader = class {
+	cdnUrl;
+	importPackage;
+	resolvePackages;
+	modulesByType = /* @__PURE__ */ new Map();
+	loadedSpecs = /* @__PURE__ */ new Set();
+	failures = [];
+	constructor(options) {
+		this.cdnUrl = options.cdnUrl.replace(/\/$/, "");
+		this.importPackage = options.importPackage;
+		const registryClient = new RegistryClient(options.cdnUrl);
+		this.resolvePackages = options.resolvePackages ?? ((documentType) => registryClient.getPackagesByDocumentType(documentType));
+	}
+	async loadPackages(specs) {
+		await Promise.all([...new Set(specs)].map((spec) => this.loadPackage(spec)));
+		return this.models;
+	}
+	async load(documentType) {
+		const existing = this.modulesByType.get(documentType);
+		if (existing) return existing;
+		const packageNames = await this.resolvePackages(documentType);
+		const failuresBefore = this.failures.length;
+		await Promise.all([...new Set(packageNames)].map((name) => this.loadPackage(name)));
+		const loaded = this.modulesByType.get(documentType);
+		if (loaded) return loaded;
+		throw this.notLoadedError(documentType, packageNames, this.failures.slice(failuresBefore));
+	}
+	get models() {
+		return [...new Set(this.modulesByType.values())];
+	}
+	get loadFailures() {
+		return [...this.failures];
+	}
+	notLoadedError(documentType, packageNames, failures) {
+		if (packageNames.length === 0) return /* @__PURE__ */ new Error(`No package found for document model: ${documentType}`);
+		if (failures.length === 0) return /* @__PURE__ */ new Error(`Imported [${packageNames.join(", ")}] but document model not found: ${documentType}`);
+		const cause = failures.length === 1 ? failures[0].error : new AggregateError(failures.map((failure) => failure.error));
+		return new Error(`Failed to import package(s) [${packageNames.join(", ")}] for document model: ${documentType}`, { cause });
+	}
+	async loadPackage(spec) {
+		if (this.loadedSpecs.has(spec)) return;
+		const name = packageName(spec);
+		const url = `${this.cdnUrl}/${name}/browser/document-models/index.js`;
+		try {
+			const namespace = await this.importPackage(url);
+			for (const value of Object.values(namespace)) if (isDocumentModelModule(value)) this.modulesByType.set(value.documentModel.global.id, value);
+			this.loadedSpecs.add(spec);
+		} catch (error) {
+			this.failures.push({
+				name,
+				url,
+				error
+			});
+		}
+	}
+};
+//#endregion
+//#region src/rpc/rpc-correlator.ts
+/**
+* Request/response correlation shared by every RPC proxy: one pending map,
+* res/err settlement, and per-request timeout/transform/cleanup.
+*/
+var RpcCorrelator = class {
+	counter = 0;
+	pending = /* @__PURE__ */ new Map();
+	constructor(poster, prefix = "r") {
+		this.poster = poster;
+		this.prefix = prefix;
+	}
+	nextId() {
+		return `${this.prefix}${++this.counter}`;
+	}
+	/** Settle the pending request a res/err refers to; a missing id is a no-op. */
+	handleMessage(message) {
+		if (message.k !== "res" && message.k !== "err") return;
+		const entry = this.pending.get(message.id);
+		if (!entry) return;
+		this.pending.delete(message.id);
+		if (entry.timer) clearTimeout(entry.timer);
+		entry.cleanup?.();
+		if (message.k === "res") entry.resolve(entry.transform ? entry.transform(message.value) : message.value);
+		else entry.reject(fromErrorInfo(message.error));
+	}
+	/** Send a request, resolving on its res/err. `build` stamps the generated id. */
+	request(build, options = {}) {
+		const id = this.nextId();
+		const message = build(id);
+		const method = message.method;
+		const label = typeof method === "string" ? `${message.k} "${method}"` : message.k;
+		const promise = new Promise((resolve, reject) => {
+			let timer;
+			if (options.timeoutMs !== void 0) {
+				const timeoutMs = options.timeoutMs;
+				timer = setTimeout(() => {
+					const entry = this.pending.get(id);
+					if (entry) {
+						this.pending.delete(id);
+						entry.cleanup?.();
+						reject(/* @__PURE__ */ new Error(`Reactor worker did not respond to ${label} within ${timeoutMs}ms; the worker may have failed to load`));
+					}
+				}, timeoutMs);
+			}
+			this.pending.set(id, {
+				resolve,
+				reject,
+				timer,
+				transform: options.transform
+			});
+		});
+		this.poster.post(message);
+		const cleanup = options.setup?.(id);
+		if (cleanup) {
+			const entry = this.pending.get(id);
+			if (entry) entry.cleanup = cleanup;
+			else cleanup();
+		}
+		return promise;
+	}
+};
+//#endregion
+//#region src/rpc/message-router.ts
+/**
+* Owns the single transport.onMessage and dispatches each message to the one
+* consumer that owns its kind. Composes the shared RpcCorrelator (res/err) and
+* exposes request/nextId; attach/detach swap the transport for reconnect.
+*/
+var MessageRouter = class {
+	handlers = /* @__PURE__ */ new Map();
+	correlator;
+	transport = null;
+	detachTransport = () => {};
+	constructor(prefix = "r") {
+		this.correlator = new RpcCorrelator(this, prefix);
+		const settle = (message) => this.correlator.handleMessage(message);
+		this.handlers.set("res", settle);
+		this.handlers.set("err", settle);
+	}
+	attach(transport) {
+		this.detachTransport();
+		this.transport = transport;
+		this.detachTransport = transport.onMessage((message) => {
+			const msg = message;
+			this.handlers.get(msg.k)?.(msg);
+		});
+	}
+	detach() {
+		this.detachTransport();
+		this.detachTransport = () => {};
+		this.transport = null;
+	}
+	post(message) {
+		if (!this.transport) throw new Error("MessageRouter.post called before attach");
+		this.transport.post(message);
+	}
+	/** Register the sole owner of a message kind; throws on a duplicate. */
+	on(kind, handler) {
+		if (this.handlers.has(kind)) throw new Error(`MessageRouter already has a handler for "${kind}"`);
+		const route = handler;
+		this.handlers.set(kind, route);
+		return () => {
+			if (this.handlers.get(kind) === route) this.handlers.delete(kind);
+		};
+	}
+	request(build, options) {
+		return this.correlator.request(build, options);
+	}
+	nextId() {
+		return this.correlator.nextId();
+	}
+};
+//#endregion
+export { FORWARDED_BUS_EVENT_TYPES, FORWARDED_EVENT_TYPES, KeyedListeners, Listeners, MessageRouter, RPC_DEFAULT_TIMEOUT_MS, RPC_PROTOCOL_VERSION, ReactorEventBusProxy, ReactorHost, ReactorHostServer, RpcCorrelator, SYNC_STATUS_CHANGED_EVENT, SubscriptionStore, SyncManagerProxy, WorkerPackageLoader, connectReactorClient, createCorrelatedSubscriptions, createInspectorProxy, createLiveQueryProxy, createPortTransport, createReactorClientProxy, createReactorEventBusProxy, createRelationalPgliteProxy, createSyncManagerProxy, createWorkerAdminClient, fromErrorInfo, hostResponder, opChannel, postReactorIdentity, toErrorInfo, toVoid };
+
+//# sourceMappingURL=index.js.map