@zenbujs/core 0.0.1

package/dist/transport-BMSzG2-F.mjs

@@ -0,0 +1,1045 @@
+import { t as traceKyju } from "./trace-DCB7qFzT.mjs";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as Context from "effect/Context";
+import * as Stream from "effect/Stream";
+import { nanoid } from "nanoid";
+import * as Fiber from "effect/Fiber";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+//#region ../kyju/src/v2/shared.ts
+const SendContext = Context.GenericTag("SendContext");
+const ClientStateRef = Context.GenericTag("ClientStateRef");
+const MaxPageSizeContext = Context.GenericTag("MaxPageSizeContext");
+//#endregion
+//#region ../kyju/src/v2/replica/helpers.ts
+const makeRequestAwaiter = () => {
+	const pending = /* @__PURE__ */ new Map();
+	return {
+		resolve: (ack) => {
+			const entry = pending.get(ack.requestId);
+			if (entry) {
+				pending.delete(ack.requestId);
+				entry.resolve(ack);
+			}
+		},
+		await: (requestId) => new Promise((resolve) => {
+			pending.set(requestId, {
+				requestId,
+				resolve
+			});
+		})
+	};
+};
+const setAtPath = ({ root, path, value }) => {
+	if (path.length === 0) return value;
+	const [head, ...rest] = path;
+	const isIndex = /^\d+$/.test(head);
+	if (Array.isArray(root)) {
+		/**
+		* so react observes a new reference
+		*/
+		const arr = [...root];
+		const index = Number(head);
+		if (rest.length === 0) {
+			arr[index] = value;
+			return arr;
+		}
+		arr[index] = setAtPath({
+			root: arr[index] ?? (/^\d+$/.test(rest[0] ?? "") ? [] : {}),
+			path: rest,
+			value
+		});
+		return arr;
+	}
+	if (typeof root !== "object" || root === null) root = isIndex ? [] : {};
+	if (Array.isArray(root)) {
+		const arr = [...root];
+		const index = Number(head);
+		if (rest.length === 0) {
+			arr[index] = value;
+			return arr;
+		}
+		arr[index] = setAtPath({
+			root: arr[index] ?? (/^\d+$/.test(rest[0] ?? "") ? [] : {}),
+			path: rest,
+			value
+		});
+		return arr;
+	}
+	const obj = { ...root };
+	if (rest.length === 0) {
+		obj[head] = value;
+		return obj;
+	}
+	obj[head] = setAtPath({
+		root: obj[head] ?? (/^\d+$/.test(rest[0] ?? "") ? [] : {}),
+		path: rest,
+		value
+	});
+	return obj;
+};
+const requireConnected = ({ ref }) => Effect.gen(function* () {
+	const state = yield* Ref.get(ref);
+	if (state.kind === "disconnected") return yield* Effect.die("Cannot process event: not connected");
+	return state;
+});
+const applyState = ({ ref, fn }) => Ref.update(ref, (current) => {
+	if (current.kind === "disconnected") return current;
+	return fn(current);
+});
+//#endregion
+//#region ../kyju/src/v2/replica/replica.ts
+const concatToCollection = (col, items) => {
+	if (items.length === 0) return col;
+	return {
+		...col,
+		items: [...col.items, ...items],
+		totalCount: col.totalCount + items.length
+	};
+};
+const applyRootSet = (ref, op) => applyState({
+	ref,
+	fn: (state) => ({
+		...state,
+		root: setAtPath({
+			root: state.root,
+			path: op.path,
+			value: op.value
+		})
+	})
+});
+const applyCollectionCreate = (ref, op) => {
+	const collection = {
+		id: op.collectionId,
+		totalCount: op.data?.length ?? 0,
+		items: op.data ?? []
+	};
+	return applyState({
+		ref,
+		fn: (state) => ({
+			...state,
+			collections: [...state.collections, collection]
+		})
+	});
+};
+const applyCollectionDelete = (ref, op) => applyState({
+	ref,
+	fn: (state) => ({
+		...state,
+		collections: state.collections.filter((col) => col.id !== op.collectionId)
+	})
+});
+const applyBlobCreate = (ref, op) => {
+	const blob = {
+		id: op.blobId,
+		data: op.hot ? {
+			kind: "hot",
+			value: op.data
+		} : { kind: "cold" },
+		fileSize: 0
+	};
+	return applyState({
+		ref,
+		fn: (state) => ({
+			...state,
+			blobs: [...state.blobs, blob]
+		})
+	});
+};
+const applyBlobSet = (ref, op) => applyState({
+	ref,
+	fn: (state) => ({
+		...state,
+		blobs: state.blobs.map((blob) => {
+			if (blob.id !== op.blobId) return blob;
+			if (blob.data.kind === "hot") return {
+				...blob,
+				data: {
+					kind: "hot",
+					value: op.data
+				}
+			};
+			return blob;
+		})
+	})
+});
+const applyBlobDelete = (ref, op) => applyState({
+	ref,
+	fn: (state) => ({
+		...state,
+		blobs: state.blobs.filter((blob) => blob.id !== op.blobId)
+	})
+});
+const applyWrite = ({ stateRef, op }) => {
+	switch (op.type) {
+		case "root.set": return applyRootSet(stateRef, op);
+		case "collection.create": return applyCollectionCreate(stateRef, op);
+		case "collection.concat": return applyState({
+			ref: stateRef,
+			fn: (state) => ({
+				...state,
+				collections: state.collections.map((col) => col.id === op.collectionId ? concatToCollection(col, op.data) : col)
+			})
+		});
+		case "collection.delete": return applyCollectionDelete(stateRef, op);
+		case "blob.create": return applyBlobCreate(stateRef, op);
+		case "blob.set": return applyBlobSet(stateRef, op);
+		case "blob.delete": return applyBlobDelete(stateRef, op);
+	}
+};
+const applyReplicatedWrite = ({ stateRef, op }) => {
+	switch (op.type) {
+		case "root.set": return applyRootSet(stateRef, op);
+		case "collection.create": return applyCollectionCreate(stateRef, op);
+		case "collection.concat": return applyState({
+			ref: stateRef,
+			fn: (state) => ({
+				...state,
+				collections: state.collections.map((col) => {
+					if (col.id !== op.collectionId) return col;
+					return concatToCollection(col, op.data);
+				})
+			})
+		});
+		case "collection.delete": return applyCollectionDelete(stateRef, op);
+		case "blob.create": return applyBlobCreate(stateRef, op);
+		case "blob.set": return applyBlobSet(stateRef, op);
+		case "blob.delete": return applyBlobDelete(stateRef, op);
+	}
+};
+const createReplicaEffect = (replicaId, collectionCallbacks) => Effect.gen(function* () {
+	const awaiter = makeRequestAwaiter();
+	const stateRef = yield* ClientStateRef;
+	const sendToServer = (event, requestId) => Effect.gen(function* () {
+		const { send } = yield* SendContext;
+		const promise = awaiter.await(requestId);
+		send(event);
+		return yield* Effect.promise(() => promise);
+	});
+	const mergeSubscribeAck = (ack, collectionId) => applyState({
+		ref: stateRef,
+		fn: (state) => {
+			const entry = {
+				id: collectionId,
+				totalCount: ack.totalCount,
+				items: ack.items
+			};
+			const exists = state.collections.some((col) => col.id === collectionId);
+			return {
+				...state,
+				collections: exists ? state.collections.map((col) => col.id === collectionId ? entry : col) : [...state.collections, entry]
+			};
+		}
+	});
+	const notifyConcatCallbacks = (op) => Effect.gen(function* () {
+		if (op.type !== "collection.concat") return;
+		const cbs = collectionCallbacks.get(op.collectionId);
+		if (!cbs || cbs.size === 0) return;
+		const currentState = yield* Ref.get(stateRef);
+		if (currentState.kind !== "connected") return;
+		const col = currentState.collections.find((c) => c.id === op.collectionId);
+		if (!col) return;
+		for (const cb of cbs) cb({
+			collectionId: op.collectionId,
+			newItems: op.data,
+			collection: col
+		});
+	});
+	const postMessage = (event) => Effect.gen(function* () {
+		switch (event.kind) {
+			case "connect": {
+				const requestId = nanoid();
+				const ack = yield* sendToServer({
+					kind: "connect",
+					message: {
+						type: "connect",
+						version: event.version,
+						requestId,
+						replicaId
+					}
+				}, requestId);
+				if (ack.error) return yield* Effect.fail(ack.error);
+				yield* Ref.set(stateRef, {
+					kind: "connected",
+					sessionId: ack.sessionId,
+					root: ack.root,
+					collections: [],
+					blobs: []
+				});
+				return;
+			}
+			case "disconnect": {
+				const state = yield* requireConnected({ ref: stateRef });
+				const requestId = nanoid();
+				const ack = yield* sendToServer({
+					kind: "disconnect",
+					replicaId,
+					message: {
+						type: "disconnect",
+						sessionId: state.sessionId,
+						requestId
+					}
+				}, requestId);
+				if (ack.error) return yield* Effect.fail(ack.error);
+				yield* Ref.set(stateRef, { kind: "disconnected" });
+				return;
+			}
+			case "subscribe-collection": {
+				const state = yield* requireConnected({ ref: stateRef });
+				const requestId = nanoid();
+				const ack = yield* sendToServer({
+					kind: "subscribe-collection",
+					collectionId: event.collectionId,
+					sessionId: state.sessionId,
+					requestId,
+					replicaId
+				}, requestId);
+				if (ack.error) return yield* Effect.fail(ack.error);
+				yield* mergeSubscribeAck(ack, event.collectionId);
+				return;
+			}
+			case "unsubscribe-collection": {
+				const state = yield* requireConnected({ ref: stateRef });
+				const requestId = nanoid();
+				yield* sendToServer({
+					kind: "unsubscribe-collection",
+					collectionId: event.collectionId,
+					sessionId: state.sessionId,
+					requestId,
+					replicaId
+				}, requestId);
+				yield* applyState({
+					ref: stateRef,
+					fn: (s) => ({
+						...s,
+						collections: s.collections.filter((col) => col.id !== event.collectionId)
+					})
+				});
+				return;
+			}
+			case "write": {
+				const state = yield* requireConnected({ ref: stateRef });
+				yield* traceKyju("kyju:replica.applyWrite", applyWrite({
+					stateRef,
+					op: event.op
+				}), { op: event.op.type });
+				yield* notifyConcatCallbacks(event.op);
+				const writeRequestId = nanoid();
+				const writeAck = yield* traceKyju("kyju:replica.sendToServer", sendToServer({
+					kind: "write",
+					op: event.op,
+					sessionId: state.sessionId,
+					requestId: writeRequestId,
+					replicaId
+				}, writeRequestId), { op: event.op.type });
+				if (writeAck.error) return yield* Effect.fail(writeAck.error);
+				return;
+			}
+			case "replicated-write":
+				yield* requireConnected({ ref: stateRef });
+				yield* applyReplicatedWrite({
+					stateRef,
+					op: event.op
+				});
+				yield* notifyConcatCallbacks(event.op);
+				return;
+			case "read": {
+				const readState = yield* requireConnected({ ref: stateRef });
+				const readRequestId = nanoid();
+				const readOp = event.op;
+				switch (readOp.type) {
+					case "collection.fetch-range":
+						yield* sendToServer({
+							kind: "read",
+							op: readOp,
+							sessionId: readState.sessionId,
+							requestId: readRequestId,
+							replicaId
+						}, readRequestId);
+						return;
+					case "blob.read": {
+						const ack = yield* sendToServer({
+							kind: "read",
+							op: readOp,
+							sessionId: readState.sessionId,
+							requestId: readRequestId,
+							replicaId
+						}, readRequestId);
+						if (ack.error) return yield* Effect.fail(ack.error);
+						yield* applyState({
+							ref: stateRef,
+							fn: (state) => {
+								const entry = {
+									id: readOp.blobId,
+									data: {
+										kind: "hot",
+										value: ack.data
+									},
+									fileSize: 0
+								};
+								const exists = state.blobs.some((b) => b.id === readOp.blobId);
+								return {
+									...state,
+									blobs: exists ? state.blobs.map((b) => b.id === readOp.blobId ? entry : b) : [...state.blobs, entry]
+								};
+							}
+						});
+						return;
+					}
+				}
+			}
+			case "db-update": {
+				const msg = event.message;
+				if (msg.type === "ack") {
+					awaiter.resolve(msg);
+					return;
+				}
+				yield* requireConnected({ ref: stateRef });
+				switch (msg.type) {
+					case "blob.metadataUpdate":
+						yield* applyState({
+							ref: stateRef,
+							fn: (state) => ({
+								...state,
+								blobs: state.blobs.map((blob) => blob.id === msg.blobId ? {
+									...blob,
+									fileSize: msg.fileSize
+								} : blob)
+							})
+						});
+						return;
+					case "reconnect": {
+						const reconState = yield* requireConnected({ ref: stateRef });
+						const disconnectId = nanoid();
+						const disconnectAck = yield* sendToServer({
+							kind: "disconnect",
+							replicaId,
+							message: {
+								type: "disconnect",
+								sessionId: reconState.sessionId,
+								requestId: disconnectId
+							}
+						}, disconnectId);
+						if (disconnectAck.error) return yield* Effect.fail(disconnectAck.error);
+						yield* Ref.set(stateRef, { kind: "disconnected" });
+						const connectId = nanoid();
+						const connectAck = yield* sendToServer({
+							kind: "connect",
+							message: {
+								type: "connect",
+								version: 0,
+								requestId: connectId,
+								replicaId
+							}
+						}, connectId);
+						if (connectAck.error) return yield* Effect.fail(connectAck.error);
+						yield* Ref.set(stateRef, {
+							kind: "connected",
+							sessionId: connectAck.sessionId,
+							root: connectAck.root,
+							collections: [],
+							blobs: []
+						});
+						return;
+					}
+				}
+			}
+		}
+	});
+	return { postMessage };
+});
+const createReplica = (args) => {
+	const replicaId = args.replicaId ?? nanoid();
+	const stateRef = Effect.runSync(SubscriptionRef.make({ kind: "disconnected" }));
+	const collectionCallbacks = /* @__PURE__ */ new Map();
+	const provide = (effect) => effect.pipe(Effect.provideService(SendContext, { send: args.send }), Effect.provideService(ClientStateRef, stateRef), Effect.provideService(MaxPageSizeContext, { maxPageSizeBytes: args.maxPageSizeBytes }));
+	const { postMessage: rawPostMessageEffect } = Effect.runSync(provide(createReplicaEffect(replicaId, collectionCallbacks)));
+	const postMessageEffect = (event) => provide(rawPostMessageEffect(event));
+	const postMessage = (event) => Effect.runPromise(postMessageEffect(event).pipe(Effect.catchAll(() => Effect.void)));
+	const onCollectionConcat = (collectionId, cb) => {
+		let cbs = collectionCallbacks.get(collectionId);
+		if (!cbs) {
+			cbs = /* @__PURE__ */ new Set();
+			collectionCallbacks.set(collectionId, cbs);
+		}
+		cbs.add(cb);
+	};
+	const offCollectionConcat = (collectionId, cb) => {
+		const cbs = collectionCallbacks.get(collectionId);
+		if (cbs) {
+			cbs.delete(cb);
+			if (cbs.size === 0) collectionCallbacks.delete(collectionId);
+		}
+	};
+	const getState = () => Effect.runSync(Ref.get(stateRef));
+	const _forceState = (state) => {
+		Effect.runSync(Ref.set(stateRef, state));
+	};
+	const subscribe = (cb) => {
+		const fiber = Effect.runFork(Stream.runForEach(stateRef.changes, (state) => Effect.sync(() => cb(state))));
+		return () => {
+			Effect.runFork(Fiber.interrupt(fiber));
+		};
+	};
+	return {
+		postMessage,
+		postMessageEffect,
+		getState,
+		_forceState,
+		subscribe,
+		replicaId,
+		onCollectionConcat,
+		offCollectionConcat
+	};
+};
+//#endregion
+//#region ../kyju/src/v2/client/proxy.ts
+/**
+* 
+* we are recording the set of operations performed on a proxy object,
+* so that we can later play them over and convert them into events
+* to the kyju db
+* 
+*/
+const createRecordingProxy = (target) => {
+	const operations = [];
+	const dirtyArrayPaths = /* @__PURE__ */ new Map();
+	const markArrayDirty = (arrayPath, arr) => {
+		const key = arrayPath.join("\0");
+		if (!dirtyArrayPaths.has(key)) dirtyArrayPaths.set(key, {
+			path: arrayPath,
+			arr
+		});
+	};
+	const makeProxy = (obj, currentPath) => {
+		return new Proxy(obj, {
+			get(t, prop, receiver) {
+				if (typeof prop === "symbol") return Reflect.get(t, prop, receiver);
+				const value = t[prop];
+				if (value !== null && typeof value === "object") return makeProxy(value, [...currentPath, prop]);
+				return value;
+			},
+			set(t, prop, value) {
+				if (typeof prop === "symbol") {
+					t[prop] = value;
+					return true;
+				}
+				t[prop] = value;
+				if (Array.isArray(t)) markArrayDirty(currentPath, t);
+				else operations.push({
+					path: [...currentPath, prop],
+					value
+				});
+				return true;
+			}
+		});
+	};
+	const snapshot = JSON.parse(JSON.stringify(target));
+	return {
+		proxy: makeProxy(snapshot, []),
+		getOperations: () => {
+			const result = [...operations];
+			for (const { path, arr } of dirtyArrayPaths.values()) result.push({
+				path,
+				value: arr
+			});
+			return result;
+		},
+		snapshot
+	};
+};
+//#endregion
+//#region ../kyju/src/v2/client/client.ts
+function createClientCore(send, replica) {
+	const subscriberCounts = /* @__PURE__ */ new Map();
+	const subscribePromises = /* @__PURE__ */ new Map();
+	const getConnectedState = () => {
+		const state = replica.getState();
+		if (state.kind === "disconnected") throw new Error("Cannot read state: not connected");
+		return state;
+	};
+	const getRoot = () => getConnectedState().root;
+	const getAtPath = (obj, path) => {
+		let current = obj;
+		for (const key of path) {
+			if (current == null) return void 0;
+			current = current[key];
+		}
+		return current;
+	};
+	const isCollectionValue = (val) => val != null && typeof val === "object" && "collectionId" in val;
+	const isBlobValue = (val) => val != null && typeof val === "object" && "blobId" in val;
+	const subscribeToPath = (path, cb) => {
+		let prev;
+		let initialized = false;
+		return replica.subscribe((state) => {
+			if (state.kind === "disconnected") return;
+			const value = getAtPath(state.root, path);
+			if (!initialized || !Object.is(prev, value)) {
+				prev = value;
+				initialized = true;
+				cb(value);
+			}
+		});
+	};
+	const makeCollectionNode = (fieldKey) => {
+		const getCollectionId = () => {
+			return getAtPath(getRoot(), [fieldKey])?.collectionId;
+		};
+		return {
+			concat: (items) => {
+				return send({
+					kind: "write",
+					op: {
+						type: "collection.concat",
+						collectionId: getCollectionId(),
+						data: items
+					}
+				});
+			},
+			read: (range) => send({
+				kind: "read",
+				op: {
+					type: "collection.fetch-range",
+					collectionId: getCollectionId(),
+					range: range ?? {
+						start: 0,
+						end: Number.MAX_SAFE_INTEGER
+					}
+				}
+			}),
+			create: (data) => Effect.gen(function* () {
+				const collectionId = nanoid();
+				yield* send({
+					kind: "write",
+					op: {
+						type: "collection.create",
+						collectionId,
+						data
+					}
+				});
+				yield* send({
+					kind: "write",
+					op: {
+						type: "root.set",
+						path: [fieldKey],
+						value: {
+							collectionId,
+							debugName: fieldKey
+						}
+					}
+				});
+			}),
+			delete: () => send({
+				kind: "write",
+				op: {
+					type: "collection.delete",
+					collectionId: getCollectionId()
+				}
+			}),
+			subscribe: (cb) => subscribeToPath([fieldKey], cb),
+			subscribeData: (cb) => makeCollectionNodeAtPath([fieldKey]).subscribeData(cb)
+		};
+	};
+	const makeCollectionNodeAtPath = (path) => {
+		const getCollectionId = () => {
+			return getAtPath(getRoot(), path)?.collectionId;
+		};
+		return {
+			concat: (items) => send({
+				kind: "write",
+				op: {
+					type: "collection.concat",
+					collectionId: getCollectionId(),
+					data: items
+				}
+			}),
+			read: (range) => send({
+				kind: "read",
+				op: {
+					type: "collection.fetch-range",
+					collectionId: getCollectionId(),
+					range: range ?? {
+						start: 0,
+						end: Number.MAX_SAFE_INTEGER
+					}
+				}
+			}),
+			create: (data) => Effect.gen(function* () {
+				const collectionId = nanoid();
+				yield* send({
+					kind: "write",
+					op: {
+						type: "collection.create",
+						collectionId,
+						data
+					}
+				});
+				yield* send({
+					kind: "write",
+					op: {
+						type: "root.set",
+						path,
+						value: {
+							collectionId,
+							debugName: path[path.length - 1] ?? ""
+						}
+					}
+				});
+			}),
+			delete: () => send({
+				kind: "write",
+				op: {
+					type: "collection.delete",
+					collectionId: getCollectionId()
+				}
+			}),
+			subscribe: (cb) => subscribeToPath(path, cb),
+			subscribeData: (cb) => {
+				const collectionId = getCollectionId();
+				const count = subscriberCounts.get(collectionId) ?? 0;
+				subscriberCounts.set(collectionId, count + 1);
+				const wrappedCb = (data) => {
+					cb({
+						collection: data.collection,
+						newItems: data.newItems
+					});
+				};
+				replica.onCollectionConcat(collectionId, wrappedCb);
+				const deliverInitial = () => {
+					const state = replica.getState();
+					if (state.kind === "connected") {
+						const col = state.collections.find((c) => c.id === collectionId);
+						if (col) cb({
+							collection: col,
+							newItems: col.items
+						});
+					}
+				};
+				if (count === 0) {
+					const p = Effect.runPromise(send({
+						kind: "subscribe-collection",
+						collectionId
+					}).pipe(Effect.catchAll(() => Effect.void))).then(deliverInitial);
+					subscribePromises.set(collectionId, p);
+				} else {
+					const existing = subscribePromises.get(collectionId);
+					if (existing) existing.then(deliverInitial);
+					else deliverInitial();
+				}
+				let unsubscribed = false;
+				return () => {
+					if (unsubscribed) return;
+					unsubscribed = true;
+					replica.offCollectionConcat(collectionId, wrappedCb);
+					const current = subscriberCounts.get(collectionId) ?? 1;
+					if (current <= 1) {
+						subscriberCounts.delete(collectionId);
+						subscribePromises.delete(collectionId);
+						Effect.runPromise(send({
+							kind: "unsubscribe-collection",
+							collectionId
+						}).pipe(Effect.catchAll(() => Effect.void)));
+					} else subscriberCounts.set(collectionId, current - 1);
+				};
+			}
+		};
+	};
+	const makeBlobNode = (fieldKey) => {
+		const getBlobId = () => {
+			return getAtPath(getRoot(), [fieldKey])?.blobId;
+		};
+		return {
+			read: () => send({
+				kind: "read",
+				op: {
+					type: "blob.read",
+					blobId: getBlobId()
+				}
+			}),
+			set: (data) => send({
+				kind: "write",
+				op: {
+					type: "blob.set",
+					blobId: getBlobId(),
+					data
+				}
+			}),
+			create: (data, hot) => Effect.gen(function* () {
+				const blobId = nanoid();
+				yield* send({
+					kind: "write",
+					op: {
+						type: "blob.create",
+						blobId,
+						data,
+						hot
+					}
+				});
+				yield* send({
+					kind: "write",
+					op: {
+						type: "root.set",
+						path: [fieldKey],
+						value: {
+							blobId,
+							debugName: fieldKey
+						}
+					}
+				});
+			}),
+			delete: () => send({
+				kind: "write",
+				op: {
+					type: "blob.delete",
+					blobId: getBlobId()
+				}
+			})
+		};
+	};
+	const ARRAY_READ_METHODS = new Set([
+		"map",
+		"filter",
+		"slice",
+		"flatMap",
+		"reduce",
+		"reduceRight",
+		"forEach",
+		"some",
+		"every",
+		"indexOf",
+		"includes",
+		"join",
+		"findIndex",
+		"keys",
+		"values",
+		"entries",
+		"flat",
+		"toString"
+	]);
+	const makeFieldNode = (path) => new Proxy({}, { get(_, prop) {
+		if (typeof prop === "symbol") {
+			const val = getAtPath(getRoot(), path);
+			if (Array.isArray(val) && prop === Symbol.iterator) return val[Symbol.iterator].bind(val);
+			return;
+		}
+		const val = getAtPath(getRoot(), path);
+		if (isCollectionValue(val)) {
+			const node = makeCollectionNodeAtPath(path);
+			if (prop in node || prop === "concat" || prop === "subscribeData" || prop === "read" || prop === "create" || prop === "delete" || prop === "subscribe") return node[prop];
+		}
+		if (Array.isArray(val)) switch (prop) {
+			case "read": return () => val;
+			case "set": return (value) => send({
+				kind: "write",
+				op: {
+					type: "root.set",
+					path,
+					value
+				}
+			});
+			case "subscribe": return (cb) => subscribeToPath(path, cb);
+			case "length": return val.length;
+			case "find": return (predicate) => {
+				const index = val.findIndex(predicate);
+				if (index < 0) return void 0;
+				return makeFieldNode([...path, String(index)]);
+			};
+			case "at": return (i) => {
+				const resolved = i < 0 ? val.length + i : i;
+				if (resolved < 0 || resolved >= val.length) return void 0;
+				return makeFieldNode([...path, String(resolved)]);
+			};
+			default:
+				if (ARRAY_READ_METHODS.has(prop)) return Array.prototype[prop].bind(val);
+				if (/^\d+$/.test(prop)) return makeFieldNode([...path, prop]);
+				return makeFieldNode([...path, prop]);
+		}
+		switch (prop) {
+			case "read": return () => val;
+			case "set": return (value) => send({
+				kind: "write",
+				op: {
+					type: "root.set",
+					path,
+					value
+				}
+			});
+			case "subscribe": return (cb) => subscribeToPath(path, cb);
+			default: return makeFieldNode([...path, prop]);
+		}
+	} });
+	const readRootFn = () => getRoot();
+	const updateFn = (fn) => traceKyju("kyju:client.update", Effect.gen(function* () {
+		const { proxy, getOperations } = createRecordingProxy(getRoot());
+		const result = fn(proxy);
+		if (result !== void 0) yield* send({
+			kind: "write",
+			op: {
+				type: "root.set",
+				path: [],
+				value: result
+			}
+		});
+		else {
+			const ops = getOperations();
+			for (const op of ops) yield* send({
+				kind: "write",
+				op: {
+					type: "root.set",
+					path: op.path,
+					value: op.value
+				}
+			});
+		}
+	}));
+	const createBlobFn = (data, hot) => Effect.gen(function* () {
+		const blobId = nanoid();
+		yield* send({
+			kind: "write",
+			op: {
+				type: "blob.create",
+				blobId,
+				data,
+				hot
+			}
+		});
+		return blobId;
+	});
+	const deleteBlobFn = (blobId) => send({
+		kind: "write",
+		op: {
+			type: "blob.delete",
+			blobId
+		}
+	});
+	const getBlobDataFn = (blobId) => Effect.gen(function* () {
+		const state = replica.getState();
+		if (state.kind !== "connected") return null;
+		const blob = state.blobs.find((b) => b.id === blobId);
+		if (blob && blob.data.kind === "hot") return blob.data.value;
+		yield* send({
+			kind: "read",
+			op: {
+				type: "blob.read",
+				blobId
+			}
+		}).pipe(Effect.catchAll(() => Effect.succeed(void 0)));
+		const newState = replica.getState();
+		if (newState.kind !== "connected") return null;
+		const warmed = newState.blobs.find((b) => b.id === blobId);
+		if (!warmed || warmed.data.kind !== "hot") return null;
+		return warmed.data.value;
+	});
+	return new Proxy({}, { get(_, prop) {
+		if (typeof prop === "symbol") return void 0;
+		if (prop === "readRoot") return readRootFn;
+		if (prop === "update") return updateFn;
+		if (prop === "createBlob") return createBlobFn;
+		if (prop === "deleteBlob") return deleteBlobFn;
+		if (prop === "getBlobData") return getBlobDataFn;
+		const rootVal = getAtPath(getRoot(), [prop]);
+		if (isCollectionValue(rootVal)) return makeCollectionNode(prop);
+		if (isBlobValue(rootVal)) return makeBlobNode(prop);
+		return makeFieldNode([prop]);
+	} });
+}
+const createEffectClient = (replica) => createClientCore(replica.postMessageEffect, replica);
+function wrapEffectProxy(target) {
+	return new Proxy(target, { get(t, prop) {
+		if (typeof prop === "symbol") return Reflect.get(t, prop);
+		const val = t[prop];
+		if (typeof val === "function") return (...args) => {
+			const result = val(...args);
+			if (Effect.isEffect(result)) return Effect.runPromise(result.pipe(Effect.catchAll(() => Effect.void)));
+			if (result != null && typeof result === "object" && !Array.isArray(result)) return wrapEffectProxy(result);
+			return result;
+		};
+		if (val != null && typeof val === "object" && !Array.isArray(val)) return wrapEffectProxy(val);
+		return val;
+	} });
+}
+const createClient = (replica) => {
+	return wrapEffectProxy(createEffectClient("postMessageEffect" in replica ? replica : {
+		...replica,
+		postMessageEffect: (event) => Effect.promise(() => replica.postMessage(event))
+	}));
+};
+//#endregion
+//#region ../kyju/src/v2/transport.ts
+const UINT8_TAG = "__$u8";
+function dbStringify(value) {
+	return JSON.stringify(value, (_key, val) => {
+		if (val instanceof Uint8Array) {
+			let binary = "";
+			for (let i = 0; i < val.length; i++) binary += String.fromCharCode(val[i]);
+			return { [UINT8_TAG]: btoa(binary) };
+		}
+		return val;
+	});
+}
+function dbParse(text) {
+	return JSON.parse(text, (_key, val) => {
+		if (val !== null && typeof val === "object") {
+			if (UINT8_TAG in val) {
+				const binary = atob(val[UINT8_TAG]);
+				const bytes = new Uint8Array(binary.length);
+				for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+				return bytes;
+			}
+			if (val.type === "Buffer" && Array.isArray(val.data)) return new Uint8Array(val.data);
+		}
+		return val;
+	});
+}
+function extractReplicaId(event) {
+	if (event.kind === "connect") return event.message.replicaId;
+	if ("replicaId" in event) return event.replicaId;
+}
+function createRouter() {
+	const routes = /* @__PURE__ */ new Map();
+	return {
+		send(event) {
+			routes.get(event.replicaId)?.(event);
+		},
+		connection(opts) {
+			let replicaId;
+			return {
+				receive(event) {
+					const rid = extractReplicaId(event);
+					if (rid && !replicaId) {
+						replicaId = rid;
+						routes.set(rid, opts.send);
+					}
+					return opts.postMessage(event);
+				},
+				close() {
+					if (replicaId) routes.delete(replicaId);
+				}
+			};
+		}
+	};
+}
+async function connectReplica(opts) {
+	const replica = createReplica({
+		send: opts.send,
+		maxPageSizeBytes: opts.maxPageSizeBytes ?? 1024 * 1024
+	});
+	const unsub = opts.subscribe((event) => {
+		if (event.replicaId === replica.replicaId) replica.postMessage(event);
+	});
+	await replica.postMessage({
+		kind: "connect",
+		version: 0
+	});
+	return {
+		client: createClient(replica),
+		replica,
+		disconnect: async () => {
+			await replica.postMessage({ kind: "disconnect" }).catch(() => {});
+			unsub();
+		}
+	};
+}
+//#endregion
+export { createClient as a, dbStringify as i, createRouter as n, createEffectClient as o, dbParse as r, createReplica as s, connectReplica as t };