@voltro/local-first 0.29.0

package/dist/index.js

@@ -0,0 +1,243 @@
+import { a as e, c as t, i as n, n as r, o as i, r as a, s as o, t as s } from "./room-CzWRYppA.js";
+import * as c from "yjs";
+//#region src/crdt/yjsBackend.ts
+var l = "t", u = (e) => c.encodeStateAsUpdate(e), d = (e) => {
+	let t = new c.Doc();
+	return e.length > 0 && c.applyUpdate(t, e), t;
+}, f = (e) => {
+	let t = e.getText(l);
+	return {
+		toString: () => t.toString(),
+		insert: (e, n) => t.insert(e, n),
+		delete: (e, n) => t.delete(e, n),
+		encodeState: () => u(e),
+		applyState: (t) => {
+			t.length > 0 && c.applyUpdate(e, t);
+		}
+	};
+}, p = {
+	name: "yjs",
+	createText: (e) => {
+		let t = new c.Doc();
+		return e !== void 0 && e.length > 0 && t.getText(l).insert(0, e), f(t);
+	},
+	merge: (e, t) => c.mergeUpdates([e, t]),
+	decodeText: (e) => {
+		let t = d(e), n = t.getText(l).toString();
+		return t.destroy(), n;
+	},
+	emptyState: () => u(new c.Doc())
+}, m = p, h = (e, t = m) => {
+	let n = t.createText(e), r = {
+		backend: t.name,
+		toString: () => n.toString(),
+		insert: (e, t) => (n.insert(e, t), r),
+		delete: (e, t) => (n.delete(e, t), r),
+		merge: (e) => (n.applyState(e), r),
+		encode: () => n.encodeState()
+	};
+	return r;
+}, g = (e, t, n = m) => n.merge(e, t), _ = (e, t = m) => t.decodeText(e), v = (e = m) => e.emptyState(), y = (e) => {
+	if (e.writer !== void 0) return `w:${e.writer}`;
+	try {
+		return `v:${JSON.stringify(e.value)}`;
+	} catch {
+		return `v:${String(e.value)}`;
+	}
+}, b = (e, t) => t.updatedAt > e.updatedAt ? t.value : t.updatedAt < e.updatedAt ? e.value : y(t) > y(e) ? t.value : e.value, x = (e) => e === "lastWriteWins" ? b : e, S = (e) => {
+	let t = (t, n, r) => {
+		let i = e[t];
+		return (i === void 0 ? b : x(i))(n, r);
+	};
+	return {
+		resolveField: t,
+		resolveRecord: (e, n) => {
+			let r = {}, i = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(n)]);
+			for (let a of i) {
+				let i = e[a], o = n[a];
+				if (i === void 0) {
+					o !== void 0 && (r[a] = o.value);
+					continue;
+				}
+				if (o === void 0) {
+					r[a] = i.value;
+					continue;
+				}
+				r[a] = t(a, i, o);
+			}
+			return r;
+		}
+	};
+}, C = (e, t) => `${e}
${t}`, w = () => {
+	let e = /* @__PURE__ */ new Map(), t = [], n = /* @__PURE__ */ new Set(), r = (e) => e.slice();
+	return {
+		kind: "in-memory",
+		loadCrdtState: (t, n) => {
+			let i = e.get(C(t, n));
+			return Promise.resolve(i === void 0 ? void 0 : r(i));
+		},
+		saveCrdtState: (t, n, i) => (e.set(C(t, n), r(i)), Promise.resolve()),
+		loadQueue: () => Promise.resolve(t.map((e) => ({ ...e }))),
+		saveQueue: (e) => (t = e.map((e) => ({ ...e })), Promise.resolve()),
+		pin: (e, t) => (n.add(C(e, t)), Promise.resolve()),
+		isPinned: (e, t) => Promise.resolve(n.has(C(e, t)))
+	};
+}, T = "voltro_local_first", E = "\0queue", D = "\0pin\0", O = (e, t) => `cell\u0000${e}\u0000${t}`, k = (e, t) => `${D}${e}\u0000${t}`, A = (e) => new Promise((t, n) => {
+	e.onsuccess = () => t(e.result), e.onerror = () => n(e.error ?? /* @__PURE__ */ Error("IndexedDB request failed"));
+}), j = async (e) => {
+	let t = e?.factory ?? globalThis.indexedDB;
+	if (t === void 0) throw Error("createIndexedDbPersistence: no IndexedDB available. Pass options.factory (e.g. in a non-browser host) or use createInMemoryPersistence().");
+	let n = e?.databaseName ?? "voltro-local-first", r = t.open(n, 1), i = await new Promise((e, t) => {
+		r.onupgradeneeded = () => {
+			let e = r.result;
+			e.objectStoreNames.contains(T) || e.createObjectStore(T);
+		}, r.onsuccess = () => e(r.result), r.onerror = () => t(r.error ?? /* @__PURE__ */ Error("IndexedDB open failed"));
+	}), a = async (e) => A(i.transaction(T, "readonly").objectStore(T).get(e)), o = async (e, t) => {
+		await A(i.transaction(T, "readwrite").objectStore(T).put(t, e));
+	}, s = (e) => {
+		if (e instanceof Uint8Array) return e.slice();
+		if (e instanceof ArrayBuffer) return new Uint8Array(e.slice(0));
+		if (Array.isArray(e)) return Uint8Array.from(e);
+	};
+	return {
+		kind: "indexeddb",
+		loadCrdtState: async (e, t) => s(await a(O(e, t))),
+		saveCrdtState: async (e, t, n) => {
+			await o(O(e, t), n.slice());
+		},
+		loadQueue: async () => {
+			let e = await a(E);
+			return e === void 0 || !Array.isArray(e.writes) ? [] : e.writes.map((e) => ({ ...e }));
+		},
+		saveQueue: async (e) => {
+			let t = { writes: e.map((e) => ({ ...e })) };
+			await o(E, t);
+		},
+		pin: async (e, t) => {
+			await o(k(e, t), !0);
+		},
+		isPinned: async (e, t) => await a(k(e, t)) === !0
+	};
+}, M = (e) => e.inFlight === void 0 ? e.pending : [e.inFlight, ...e.pending], N = async (e, n = !0) => {
+	let r = await e.loadQueue(), a = {
+		...i(n),
+		pending: r
+	};
+	return {
+		getState: () => a,
+		dispatch: async (n) => (a = t(a, n), await e.saveQueue(M(a)), a)
+	};
+}, P = (e) => `${e.table}\u0000${e.id}\u0000${e.column}`, F = 0, I = () => {
+	let e = typeof crypto < "u" ? crypto : void 0;
+	return e && typeof e.randomUUID == "function" ? e.randomUUID() : `w_${Date.now().toString(36)}_${F += 1}`;
+}, L = (n) => {
+	let { transport: r, adapter: a } = n, s = n.backend ?? m, c = n.now ?? Date.now, l = n.maxAttempts ?? 5, u = i(n.online ?? !0), d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set(), p = () => {
+		for (let e of f) try {
+			e();
+		} catch {}
+	}, h = (e, t) => {
+		let n = P(e), r = d.get(n), i = r === void 0 ? t : g(r, t, s);
+		d.set(n, i), a?.saveCrdtState(e.table, e.id, i).catch(() => void 0);
+	}, _ = () => {
+		if (a === void 0) return;
+		let e = u.inFlight === void 0 ? u.pending : [u.inFlight, ...u.pending];
+		a.saveQueue(e).catch(() => void 0);
+	}, v = !1, y = async () => {
+		if (!v) {
+			v = !0;
+			try {
+				for (; e(u);) {
+					u = t(u, { type: "drain-start" });
+					let e = u.inFlight;
+					if (e === void 0) break;
+					try {
+						await r.push(e), u = t(u, {
+							type: "ack",
+							id: e.id
+						}), _(), p();
+					} catch (n) {
+						if (u = t(u, {
+							type: "fail",
+							id: e.id,
+							error: n instanceof Error ? n.message : String(n)
+						}), _(), p(), e.attempts + 1 >= l) break;
+					}
+				}
+			} finally {
+				v = !1;
+			}
+		}
+	}, b = r.onRemoteState((e) => {
+		h(e, e.state), p();
+	});
+	return {
+		enqueue: (e) => {
+			h(e, e.update);
+			let n = {
+				id: I(),
+				payload: e,
+				enqueuedAt: c(),
+				attempts: 0
+			};
+			u = t(u, {
+				type: "enqueue",
+				write: n
+			}), _(), p(), y();
+		},
+		setOnline: (e) => {
+			u = t(u, e ? { type: "online" } : { type: "offline" }), _(), p(), e && y();
+		},
+		queueState: () => u,
+		outstanding: () => o(u),
+		getState: (e) => {
+			let t = d.get(P(e));
+			return t === void 0 ? void 0 : t.slice();
+		},
+		getText: (e) => {
+			let t = d.get(P(e));
+			return t === void 0 ? "" : s.decodeText(t);
+		},
+		subscribe: (e) => (f.add(e), () => {
+			f.delete(e);
+		}),
+		flush: async () => {
+			await y();
+		},
+		close: () => {
+			b(), f.clear();
+		}
+	};
+}, R = () => ({ rooms: /* @__PURE__ */ new Map() }), z = (e = R()) => {
+	let t = /* @__PURE__ */ new Set(), n = (t) => {
+		let n = e.rooms.get(t);
+		return n === void 0 && (n = /* @__PURE__ */ new Set(), e.rooms.set(t, n)), n;
+	};
+	return {
+		kind: "presence-channel",
+		publish: (n, r) => {
+			let i = e.rooms.get(n);
+			if (i !== void 0) {
+				for (let e of i) if (!t.has(e)) try {
+					e(r);
+				} catch {}
+			}
+		},
+		subscribe: (e, r) => {
+			let i = n(e);
+			return i.add(r), t.add(r), () => {
+				i.delete(r), t.delete(r);
+			};
+		}
+	};
+}, B = [
+	"durable-persistence-indexeddb",
+	"sync-transport-syncclient",
+	"presence-room",
+	"localFirst-mixin-discovery"
+], V = [
+	"sync-transport-app-binding",
+	"presence-broker-binding",
+	"wasm-sqlite-durable-adapter"
+];
+//#endregion
+export { B as IMPLEMENTED_SINCE_SEAMS, V as RUNTIME_SEAMS, e as canDrain, S as conflictPolicy, r as connectionReducer, h as crdtText, w as createInMemoryPersistence, R as createInMemoryPresenceBus, z as createInMemoryPresenceChannel, j as createIndexedDbPersistence, s as createPresenceRoom, L as createSyncClient, _ as decodeCrdtText, m as defaultCrdtBackend, a as deriveSyncStatus, v as emptyCrdtState, n as initialConnection, i as initialSyncQueue, b as lastWriteWins, N as loadPersistedSyncQueue, g as mergeCrdtStates, o as outstandingCount, t as syncQueueReducer, p as yjsBackend };

package/dist/react.d.ts

@@ -0,0 +1,138 @@
+declare type ConnectionPhase = 'online' | 'offline' | 'reconnecting';
+
+declare interface ConnectionState {
+    readonly phase: ConnectionPhase;
+    /** Confirmation attempts made since the network last came back. 0 when online/offline. */
+    readonly attempt: number;
+}
+
+/**
+ * A dumb ephemeral pub/sub channel. Publish a string payload to a room;
+ * subscribe to a room and get every payload (from other peers) back.
+ *
+ * Mirrors `BroadcastProvider` so a runtime adapter can forward straight onto the
+ * app's broker. `publish` is fire-and-forget (presence loss is tolerable — the
+ * next heartbeat corrects it); `subscribe` returns its unsubscribe.
+ */
+declare interface PresenceChannel {
+    readonly kind: 'presence-channel';
+    readonly publish: (room: string, payload: string) => void;
+    readonly subscribe: (room: string, handler: (payload: string) => void) => () => void;
+}
+
+/** One other peer's last-known presence. */
+declare interface PresencePeer<TPresence> {
+    readonly peerId: string;
+    readonly presence: TPresence;
+    /** Clock value of the last message seen from this peer (for TTL expiry). */
+    readonly lastSeen: number;
+}
+
+/** A single queued write. `payload` is opaque to the queue — the wire seam owns its shape. */
+declare interface QueuedWrite<T = unknown> {
+    readonly id: string;
+    readonly payload: T;
+    /** When the write was first enqueued (ms epoch). Set by the caller for determinism. */
+    readonly enqueuedAt: number;
+    /** How many times delivery has been attempted and failed. 0 until the first `fail`. */
+    readonly attempts: number;
+}
+
+declare interface SyncQueueState<T = unknown> {
+    /** Whether the queue believes it can reach the server. Drives draining. */
+    readonly online: boolean;
+    /** Writes waiting to be sent, oldest first. */
+    readonly pending: readonly QueuedWrite<T>[];
+    /** The write currently being delivered, if any. Only one at a time (in-order delivery). */
+    readonly inFlight: QueuedWrite<T> | undefined;
+    /** Last delivery error message, if the most recent attempt failed. */
+    readonly lastError: string | undefined;
+}
+
+/** What an offline indicator shows: a join of network phase and queue depth. */
+declare type SyncStatus = 'offline' | 'syncing' | 'synced';
+
+export declare interface UseConnectionStatus {
+    readonly state: ConnectionState;
+    readonly phase: ConnectionPhase;
+    /** Display status joining phase with `outstanding` writes: offline | syncing | synced. */
+    readonly status: SyncStatus;
+    /** Report a confirmed round-trip to the server (moves reconnecting → online). */
+    readonly confirm: () => void;
+    /** Report a failed confirmation (counts a reconnect attempt). */
+    readonly confirmFailed: () => void;
+}
+
+/**
+ * Observe network connection lifecycle for the local-first layer.
+ *
+ * @param outstanding number of unsynced writes (e.g. `useSyncQueue().outstanding`)
+ *   — folded into the display status so `synced` means online AND drained.
+ *
+ * ```tsx
+ * const q = useSyncQueue()
+ * const { status } = useConnectionStatus(q.outstanding)
+ * {status !== 'synced' && <OfflineBanner status={status} />}
+ * ```
+ */
+export declare const useConnectionStatus: (outstanding?: number) => UseConnectionStatus;
+
+export declare interface UsePresence<TPresence> {
+    /** This peer's current presence. */
+    readonly presence: TPresence;
+    /** Every other live peer. */
+    readonly others: readonly PresencePeer<TPresence>[];
+    /** Replace this peer's presence and publish it. */
+    readonly setPresence: (presence: TPresence) => void;
+}
+
+/**
+ * Ephemeral multiplayer awareness for a document/room.
+ *
+ * ```tsx
+ * const { presence, others, setPresence } = usePresence(
+ *   documentId,
+ *   { cursor: editor.selection, name: currentUser.name },
+ *   { channel },
+ * )
+ * // render `others` as remote cursors; call setPresence on selection change
+ * ```
+ */
+export declare const usePresence: <TPresence>(roomId: string, initial: TPresence, options: UsePresenceOptions) => UsePresence<TPresence>;
+
+export declare interface UsePresenceOptions {
+    /** The transport. In an app, injected from a broker-bound provider. */
+    readonly channel: PresenceChannel;
+    /** This peer's stable id. Defaults to a fresh per-mount id (one tab = one peer). */
+    readonly peerId?: string;
+    /** A peer silent this long (ms) is dropped. Default 30_000. */
+    readonly ttlMs?: number;
+    /** Heartbeat + sweep cadence (ms). Default 5_000. Kept well under `ttlMs`. */
+    readonly heartbeatMs?: number;
+}
+
+export declare interface UseSyncQueue<T = unknown> {
+    readonly state: SyncQueueState<T>;
+    /** Outstanding writes (pending + in-flight). 0 means synced. */
+    readonly outstanding: number;
+    /** Queue a write at the tail. */
+    readonly enqueue: (write: QueuedWrite<T>) => void;
+    readonly setOnline: (online: boolean) => void;
+    /** Move the head into flight (no-op unless online, idle, and non-empty). */
+    readonly drainNext: () => void;
+    readonly ack: (id: string) => void;
+    readonly fail: (id: string, error: string) => void;
+}
+
+/**
+ * Reactive view of an offline write queue.
+ *
+ * ```tsx
+ * const q = useSyncQueue()
+ * q.enqueue({ id, payload, enqueuedAt: Date.now(), attempts: 0 })
+ * // ... transport wiring calls q.drainNext() / q.ack(id) / q.fail(id, msg)
+ * ```
+ */
+export declare const useSyncQueue: <T = unknown>(online?: boolean) => UseSyncQueue<T>;
+
+export { }

package/dist/react.js

@@ -0,0 +1,102 @@
+import { c as e, i as t, n, o as r, r as i, s as a, t as o } from "./room-CzWRYppA.js";
+import { useCallback as s, useEffect as c, useMemo as l, useReducer as u, useRef as d, useState as f } from "react";
+//#region src/react/useSyncQueue.ts
+var p = (t = !0) => {
+	let [n, i] = u(e, t, r), o = s((e) => {
+		i({
+			type: "enqueue",
+			write: e
+		});
+	}, []), c = s((e) => {
+		i(e ? { type: "online" } : { type: "offline" });
+	}, []), d = s(() => i({ type: "drain-start" }), []), f = s((e) => i({
+		type: "ack",
+		id: e
+	}), []), p = s((e, t) => {
+		i({
+			type: "fail",
+			id: e,
+			error: t
+		});
+	}, []), m = a(n);
+	return l(() => ({
+		state: n,
+		outstanding: m,
+		enqueue: o,
+		setOnline: c,
+		drainNext: d,
+		ack: f,
+		fail: p
+	}), [
+		n,
+		m,
+		o,
+		c,
+		d,
+		f,
+		p
+	]);
+}, m = () => typeof navigator > "u" || navigator.onLine ? "online" : "offline", h = (e = 0) => {
+	let [r, a] = u(n, void 0, () => t(m()));
+	c(() => {
+		if (typeof window > "u") return;
+		let e = () => a({ type: "network-up" }), t = () => a({ type: "network-down" });
+		return window.addEventListener("online", e), window.addEventListener("offline", t), () => {
+			window.removeEventListener("online", e), window.removeEventListener("offline", t);
+		};
+	}, []);
+	let o = s(() => a({ type: "confirmed" }), []), d = s(() => a({ type: "confirm-failed" }), []), f = i(r.phase, e);
+	return l(() => ({
+		state: r,
+		phase: r.phase,
+		status: f,
+		confirm: o,
+		confirmFailed: d
+	}), [
+		r,
+		f,
+		o,
+		d
+	]);
+}, g = 0, _ = () => {
+	let e = typeof crypto < "u" ? crypto : void 0;
+	return e && typeof e.randomUUID == "function" ? e.randomUUID() : `peer_${Date.now().toString(36)}_${g += 1}`;
+}, v = (e, t, n) => {
+	let { channel: r } = n, i = n.ttlMs ?? 3e4, a = n.heartbeatMs ?? 5e3, u = l(() => n.peerId ?? _(), [n.peerId]), p = d(null), [m, h] = f(0), g = d(t);
+	g.current = t, c(() => {
+		let t = o({
+			channel: r,
+			roomId: e,
+			peerId: u,
+			initial: g.current,
+			ttlMs: i
+		});
+		p.current = t;
+		let n = t.onChange(() => h((e) => e + 1)), s = setInterval(() => {
+			t.heartbeat(), t.sweep();
+		}, a);
+		return h((e) => e + 1), () => {
+			clearInterval(s), n(), t.leave(), p.current = null;
+		};
+	}, [
+		r,
+		e,
+		u,
+		i,
+		a
+	]);
+	let v = s((e) => {
+		p.current?.update(e);
+	}, []), y = p.current;
+	return l(() => ({
+		presence: y?.self() ?? g.current,
+		others: y?.others() ?? [],
+		setPresence: v
+	}), [
+		y,
+		v,
+		m
+	]);
+};
+//#endregion
+export { h as useConnectionStatus, v as usePresence, p as useSyncQueue };

package/dist/room-CzWRYppA.js

@@ -0,0 +1,134 @@
+//#region src/sync/queue.ts
+var e = (e = !0) => ({
+	online: e,
+	pending: [],
+	inFlight: void 0,
+	lastError: void 0
+}), t = (e) => e.online && e.inFlight === void 0 && e.pending.length > 0, n = (e) => e.pending.length + (e.inFlight === void 0 ? 0 : 1), r = (e) => ({
+	...e,
+	attempts: e.attempts + 1
+}), i = (e, n) => {
+	switch (n.type) {
+		case "enqueue": return {
+			...e,
+			pending: [...e.pending, n.write]
+		};
+		case "online": return e.online ? e : {
+			...e,
+			online: !0
+		};
+		case "offline": return e.inFlight === void 0 ? e.online ? {
+			...e,
+			online: !1
+		} : e : {
+			...e,
+			online: !1,
+			pending: [e.inFlight, ...e.pending],
+			inFlight: void 0
+		};
+		case "drain-start": {
+			if (!t(e)) return e;
+			let [n, ...r] = e.pending;
+			return n === void 0 ? e : {
+				...e,
+				pending: r,
+				inFlight: n,
+				lastError: void 0
+			};
+		}
+		case "ack": return e.inFlight === void 0 || e.inFlight.id !== n.id ? e : {
+			...e,
+			inFlight: void 0,
+			lastError: void 0
+		};
+		case "fail": return e.inFlight === void 0 || e.inFlight.id !== n.id ? e : {
+			...e,
+			pending: [r(e.inFlight), ...e.pending],
+			inFlight: void 0,
+			lastError: n.error
+		};
+	}
+}, a = (e = "online") => ({
+	phase: e,
+	attempt: 0
+}), o = (e, t) => {
+	switch (t.type) {
+		case "network-down": return e.phase === "offline" ? e : {
+			phase: "offline",
+			attempt: 0
+		};
+		case "network-up": return e.phase === "online" ? e : {
+			phase: "reconnecting",
+			attempt: 0
+		};
+		case "confirmed": return e.phase === "online" ? e : {
+			phase: "online",
+			attempt: 0
+		};
+		case "confirm-failed": return e.phase === "reconnecting" ? {
+			phase: "reconnecting",
+			attempt: e.attempt + 1
+		} : e;
+	}
+}, s = (e, t) => e === "offline" ? "offline" : e === "reconnecting" || t > 0 ? "syncing" : "synced", c = (e) => {
+	let { channel: t, roomId: n, peerId: r, initial: i } = e, a = e.ttlMs ?? 3e4, o = e.now ?? Date.now, s = i, c = 0, l = !1, u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Set(), p = () => {
+		for (let e of f) try {
+			e();
+		} catch {}
+	}, m = (e) => {
+		c += 1;
+		let i = e === "leave" ? {
+			t: e,
+			peerId: r,
+			seq: c
+		} : {
+			t: e,
+			peerId: r,
+			seq: c,
+			presence: s
+		};
+		t.publish(n, JSON.stringify(i));
+	}, h = t.subscribe(n, (e) => {
+		if (l) return;
+		let t;
+		try {
+			t = JSON.parse(e);
+		} catch {
+			return;
+		}
+		if (t.peerId === r) return;
+		if (t.t === "leave") {
+			d.delete(t.peerId), u.delete(t.peerId) && p();
+			return;
+		}
+		let n = u.has(t.peerId);
+		t.seq <= (d.get(t.peerId) ?? 0) || (d.set(t.peerId, t.seq), u.set(t.peerId, {
+			peerId: t.peerId,
+			presence: t.presence,
+			lastSeen: o()
+		}), n || m("update"), p());
+	});
+	return m("update"), {
+		self: () => s,
+		others: () => Array.from(u.values()),
+		update: (e) => {
+			s = e, m("update"), p();
+		},
+		heartbeat: () => {
+			l || m("update");
+		},
+		sweep: () => {
+			let e = o() - a, t = !1;
+			for (let [n, r] of u) r.lastSeen < e && (u.delete(n), t = !0);
+			t && p();
+		},
+		onChange: (e) => (f.add(e), () => {
+			f.delete(e);
+		}),
+		leave: () => {
+			l || (l = !0, m("leave"), h(), u.clear(), d.clear(), p(), f.clear());
+		}
+	};
+};
+//#endregion
+export { t as a, i as c, a as i, o as n, e as o, s as r, n as s, c as t };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@voltro/local-first",
+  "version": "0.29.0",
+  "description": "Local-first / CRDT primitives (opt-in): a Yjs-backed crdtText() field and its deterministic merge, an offline sync-queue reducer, connection-status state machine, and last-write-wins conflict policy. Library-level primitives only — client SQLite persistence, the sync wire, and the presence channel are documented seams.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js",
+      "default": "./dist/react.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "yjs": "^13.6.27"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}