@iadev93/zuno 0.0.2

package/dist/core/universe.d.ts

@@ -0,0 +1,12 @@
+import type { Universe } from "./types";
+/**
+ * Creates a ZUNO Universe.
+ *
+ * A Universe is a simple container that manages multiple named stores.
+ * It:
+ * - Lazily creates a store when `getStore` is called with a new key
+ * - Can snapshot the state of all known stores
+ * - Can restore state from a snapshot
+ */
+export declare const createUniverse: () => Universe;
+//# sourceMappingURL=universe.d.ts.map

package/dist/core/universe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universe.d.ts","sourceRoot":"","sources":["../../src/core/universe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAuB,MAAM,SAAS,CAAC;AAG7D;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,QAAO,QAoDjC,CAAC"}

package/dist/core/universe.js

@@ -0,0 +1,53 @@
+import { createStore } from "./store";
+/**
+ * Creates a ZUNO Universe.
+ *
+ * A Universe is a simple container that manages multiple named stores.
+ * It:
+ * - Lazily creates a store when `getStore` is called with a new key
+ * - Can snapshot the state of all known stores
+ * - Can restore state from a snapshot
+ */
+export const createUniverse = () => {
+    const stores = new Map();
+    return {
+        getStore(key, init) {
+            if (!stores.has(key)) {
+                const initialState = init();
+                stores.set(key, createStore(initialState));
+            }
+            // TypeScript doesn't know the concrete T stored under this key,
+            // but by convention you control init(), so this cast is safe.
+            return stores.get(key);
+        },
+        snapshot() {
+            const out = {};
+            for (const [key, store] of stores.entries()) {
+                out[key] = store.get();
+            }
+            return out;
+        },
+        restore(data) {
+            for (const [key, value] of Object.entries(data)) {
+                const existing = stores.get(key);
+                if (existing) {
+                    existing.set(value);
+                }
+                else {
+                    // create a new store with this initial value
+                    const newStore = createStore(value);
+                    stores.set(key, newStore);
+                }
+            }
+        },
+        delete(key) {
+            stores.delete(key);
+        },
+        clear() {
+            stores.clear();
+        },
+        hydrateSnapshot(snapshot) {
+            this.restore(snapshot.state);
+        }
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { createZuno } from "./core/createZuno";
+export type { CreateZunoOptions } from "./core/createZuno";
+export type * from "./core/types";
+export { startSSE } from "./sync/sse-client";
+export { startBroadcastChannel } from "./sync/broadcast-channel";
+export type * from "./sync/sync-types";
+export * from "./sync/transport";
+export type { ZunoReadable, ZunoSubscribableStore } from "./shared/readable";
+export { toReadable } from "./shared/readable";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,mBAAmB,cAAc,CAAC;AAGlC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,mBAAmB,mBAAmB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AAGjC,YAAY,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { createZuno } from "./core/createZuno";
+// Sync (client)
+export { startSSE } from "./sync/sse-client";
+export { startBroadcastChannel } from "./sync/broadcast-channel";
+export * from "./sync/transport";
+export { toReadable } from "./shared/readable";

package/dist/server/apply-state-event.d.ts

@@ -0,0 +1,26 @@
+import type { ZunoStateEvent } from "../sync/sync-types";
+/**
+ * Result of applying a state event.
+ * If the event was applied successfully, `ok` is true and `event` contains the applied event.
+ * If there was a version conflict, `ok` is false and `reason` is "VERSION_CONFLICT".
+ */
+export type ApplyResult = {
+    ok: true;
+    event: ZunoStateEvent;
+} | {
+    ok: false;
+    reason: "VERSION_CONFLICT";
+    current: {
+        state: any;
+        version: number;
+    };
+};
+/**
+ * Core sync handler that applies an event to the universe
+ * and broadcasts it to all SSE subscribers.
+ * This is independent of HTTP / WebSocket / whatever transport.
+ * @property {ZunoStateEvent} incoming - The incoming event to apply.
+ * @returns {ApplyResult} The result of the application.
+ */
+export declare const applyStateEvent: (incoming: ZunoStateEvent) => ApplyResult;
+//# sourceMappingURL=apply-state-event.d.ts.map

package/dist/server/apply-state-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-state-event.d.ts","sourceRoot":"","sources":["../../src/server/apply-state-event.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,cAAc,CAAA;CAAE,GACnC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE;QAAE,KAAK,EAAE,GAAG,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAExF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,cAAc,KAAG,WAwB1D,CAAC"}

package/dist/server/apply-state-event.js

@@ -0,0 +1,29 @@
+import { publishToStateEvent } from "./state.bus";
+import { appendEvent } from "./state.log";
+import { getUniverseRecord, updateUniverseState } from "./universe-store";
+/**
+ * Core sync handler that applies an event to the universe
+ * and broadcasts it to all SSE subscribers.
+ * This is independent of HTTP / WebSocket / whatever transport.
+ * @property {ZunoStateEvent} incoming - The incoming event to apply.
+ * @returns {ApplyResult} The result of the application.
+ */
+export const applyStateEvent = (incoming) => {
+    /** Get the current state of the store */
+    const current = getUniverseRecord(incoming.storeKey) ?? { state: undefined, version: 0 };
+    /** Only enforce if client provided baseVersion */
+    if (typeof incoming.baseVersion === "number" && incoming.baseVersion !== current.version) {
+        return { ok: false, reason: "VERSION_CONFLICT", current };
+    }
+    /** Create a new event with the next version and current timestamp */
+    const event = appendEvent({
+        ...incoming,
+        version: current.version + 1,
+        ts: Date.now(),
+    });
+    /** Update the universe state */
+    updateUniverseState(event);
+    /** Publish the event */
+    publishToStateEvent(event);
+    return { ok: true, event };
+};

package/dist/server/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./snapshot-handler";
+export { createSSEConnection, setUniverseState } from "./sse-handler";
+export * from "./apply-state-event";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,OAAO,EACL,mBAAmB,EAAE,gBAAgB,EACtC,MAAM,eAAe,CAAC;AACvB,cAAc,qBAAqB,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,3 @@
+export * from "./snapshot-handler";
+export { createSSEConnection, setUniverseState } from "./sse-handler";
+export * from "./apply-state-event";

package/dist/server/server-transport.d.ts

@@ -0,0 +1,8 @@
+import type { ZunoTransport } from "../sync/sync-types";
+/**
+ * Creates a server transport for Zuno.
+ *
+ * @returns A ZunoTransport instance.
+ */
+export declare const createServerTransport: () => ZunoTransport;
+//# sourceMappingURL=server-transport.d.ts.map

package/dist/server/server-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-transport.d.ts","sourceRoot":"","sources":["../../src/server/server-transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAOxE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAAO,aAoBxC,CAAC"}

package/dist/server/server-transport.js

@@ -0,0 +1,25 @@
+/**
+ * Creates a server transport for Zuno.
+ *
+ * @returns A ZunoTransport instance.
+ */
+export const createServerTransport = () => {
+    /**
+     * The set of subscribers to state events.
+     */
+    const subs = new Set();
+    /**
+     * Publishes a state event to all subscribers.
+     */
+    return {
+        async publish(event) {
+            for (const cb of subs)
+                cb(event);
+            return { ok: true, status: 200, json: null };
+        },
+        subscribe(cb) {
+            subs.add(cb);
+            return () => subs.delete(cb);
+        },
+    };
+};

package/dist/server/snapshot-handler.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from "http";
+/**
+ * Sends a snapshot of the universe state to the client.
+ *
+ * @param _req The incoming HTTP request object.
+ * @param res The server response object, used to send the JSON universe state.
+ */
+export declare function sendSnapshot(_req: IncomingMessage, res: ServerResponse): void;
+//# sourceMappingURL=snapshot-handler.d.ts.map

package/dist/server/snapshot-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-handler.d.ts","sourceRoot":"","sources":["../../src/server/snapshot-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAA;AAI3D;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,QAStE"}

package/dist/server/snapshot-handler.js

@@ -0,0 +1,18 @@
+import { getUniverseState } from "./universe-store";
+import { getLastEventId } from "./state.log";
+/**
+ * Sends a snapshot of the universe state to the client.
+ *
+ * @param _req The incoming HTTP request object.
+ * @param res The server response object, used to send the JSON universe state.
+ */
+export function sendSnapshot(_req, res) {
+    const body = {
+        state: getUniverseState(),
+        version: getUniverseState().version ?? 0,
+        lastEventId: getLastEventId(),
+    };
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(body));
+}

package/dist/server/sse-handler.d.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage, ServerResponse } from "http";
+type IncomingHeaders = IncomingMessage["headers"];
+/**
+ * Creates a Server-Sent Events (SSE) connection for Zuno state updates.
+ */
+export declare const createSSEConnection: (req: IncomingMessage, res: ServerResponse, headers: IncomingHeaders) => void;
+/**
+ * Synchronizes the Zuno universe state by applying an incoming event.
+ *
+ * This endpoint accepts a POST request with a JSON body representing a `ZunoStateEvent`.
+ * It updates the universe state and then publishes the event to all SSE subscribers.
+ *
+ * @param req The incoming HTTP request object, expected to contain a JSON `ZunoStateEvent` in its body.
+ * @param res The server response object, used to acknowledge the update or report errors.
+ * @param transport The transport object used to publish the event to all SSE subscribers.
+ */
+export declare const syncUniverseState: (req: IncomingMessage, res: ServerResponse) => void;
+/**
+ * Sets the universe state to a specific version.
+ * Backwards-compatible alias of syncUniverseState.
+ */
+export declare const setUniverseState: (req: IncomingMessage, res: ServerResponse) => void;
+export {};
+//# sourceMappingURL=sse-handler.d.ts.map

package/dist/server/sse-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-handler.d.ts","sourceRoot":"","sources":["../../src/server/sse-handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAK5D,KAAK,eAAe,GAAG,eAAe,CAAC,SAAS,CAAC,CAAA;AAEjD;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,SAAS,eAAe,SA0EtG,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI,KAAK,eAAe,EAAE,KAAK,cAAc,SAwC1E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,eAAe,EAAE,KAAK,cAAc,SAEzE,CAAC"}

package/dist/server/sse-handler.js

@@ -0,0 +1,127 @@
+import { subscribeToStateEvents } from "./state.bus";
+import { getUniverseState } from "./universe-store";
+import { applyStateEvent } from "./apply-state-event";
+import { getEventsAfter } from "./state.log";
+/**
+ * Creates a Server-Sent Events (SSE) connection for Zuno state updates.
+ */
+export const createSSEConnection = (req, res, headers) => {
+    res.writeHead(200, {
+        "Cache-Control": "no-cache, no-transform",
+        "Content-Type": "text/event-stream; charset=utf-8",
+        Connection: "keep-alive",
+        "X-Accel-Buffering": "no",
+        ...headers
+    });
+    /**
+     * Immediately flushes the response headers to the client.
+     * This is crucial for SSE to ensure the client receives headers and
+     * starts processing the event stream without buffering delays.
+     */
+    res.flushHeaders?.();
+    /** Get the last event id from header `last-event-id` or query param `lastEventId` */
+    const raw = req.headers["last-event-id"] || new URL(req.url || "", "http://localhost").searchParams.get("lastEventId");
+    const lastEventId = Number.parseInt(Array.isArray(raw) ? raw[0] : (raw ?? "0"), 10) || 0;
+    /**
+     * If the client has a `last-event-id`, it means it's reconnecting after a disconnect.
+     * In this case, we need to send it any missed events since the last event it received.
+     */
+    if (lastEventId > 0) {
+        /** Get the events that occurred after the last event the client received. */
+        const missed = getEventsAfter(lastEventId);
+        /** Send the missed events to the client. */
+        for (const event of missed) {
+            res.write(`id: ${event.eventId}\n`);
+            res.write(`event: state\n`);
+            res.write(`data: ${JSON.stringify(event)}\n\n`);
+        }
+    }
+    /**
+     * If the client doesn't have a `last-event-id`, it means it's a fresh connection.
+     * In this case, we need to send it the current state of the universe.
+     */
+    else {
+        /** Send the current state of the universe to the client. */
+        res.write(`event: snapshot\n`);
+        res.write(`data: ${JSON.stringify(getUniverseState())}\n\n`);
+    }
+    /** Subscribe to state events and send them to the client */
+    const unsubscribe = subscribeToStateEvents((event) => {
+        res.write(`id: ${event.eventId}\n`);
+        res.write(`event: state\n`);
+        res.write(`data: ${JSON.stringify(event)}\n\n`); // The actual event data
+    });
+    /**
+     * Set up a heartbeat mechanism to keep the SSE connection alive.
+     * A ping event is sent every 15 seconds.
+     */
+    const heartbeat = setInterval(() => {
+        res.write(`: ping ${Date.now()}\n\n`);
+    }, 15000);
+    /**
+     * Send an initial connection message to the client.
+     * This helps the client know when the connection is established.
+     */
+    res.write(": connected \n\n");
+    /**
+     * Clean up subscription when the client disconnects.
+     */
+    req.on("close", () => {
+        clearInterval(heartbeat);
+        unsubscribe();
+        res.end();
+    });
+};
+/**
+ * Synchronizes the Zuno universe state by applying an incoming event.
+ *
+ * This endpoint accepts a POST request with a JSON body representing a `ZunoStateEvent`.
+ * It updates the universe state and then publishes the event to all SSE subscribers.
+ *
+ * @param req The incoming HTTP request object, expected to contain a JSON `ZunoStateEvent` in its body.
+ * @param res The server response object, used to acknowledge the update or report errors.
+ * @param transport The transport object used to publish the event to all SSE subscribers.
+ */
+export const syncUniverseState = (req, res) => {
+    const MAX_BODY_BYTES = 512 * 1024; // 512KB safety
+    let body = "";
+    // Accumulate data chunks from the request body
+    req.on("data", (chunk) => {
+        body += chunk.toString("utf8");
+        if (body.length > MAX_BODY_BYTES) {
+            res.writeHead(413, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, reason: "PAYLOAD_TOO_LARGE" }));
+            req.destroy();
+        }
+    });
+    req.on("end", () => {
+        try {
+            const incoming = JSON.parse(body || "{}");
+            const result = applyStateEvent(incoming); // ✅ core sync
+            if (!result.ok) {
+                if (result.reason === "VERSION_CONFLICT") {
+                    res.writeHead(409, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({
+                        ok: false,
+                        reason: "VERSION_CONFLICT",
+                        current: result.current,
+                    }));
+                }
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true, event: result.event }));
+        }
+        catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, reason: "INVALID_JSON" }));
+        }
+    });
+};
+/**
+ * Sets the universe state to a specific version.
+ * Backwards-compatible alias of syncUniverseState.
+ */
+export const setUniverseState = (req, res) => {
+    return syncUniverseState(req, res);
+};

package/dist/server/state.bus.d.ts

@@ -0,0 +1,18 @@
+import type { ZunoStateEvent } from "../sync/sync-types";
+import type { ZunoStateListener } from "./types";
+/**
+ * Subscribes a listener function to state events.
+ * The listener will be called whenever a new state event is published.
+ *
+ * @param listener The function to be called when a state event occurs.
+ * @returns A cleanup function that, when called, unsubscribes the listener.
+ */
+export declare const subscribeToStateEvents: (listener: ZunoStateListener) => () => void;
+/**
+ * Publishes a state event to all registered listeners.
+ * Each subscribed listener will receive the event.
+ *
+ * @param event The state event to be published.
+ */
+export declare const publishToStateEvent: (event: ZunoStateEvent) => void;
+//# sourceMappingURL=state.bus.d.ts.map

package/dist/server/state.bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.bus.d.ts","sourceRoot":"","sources":["../../src/server/state.bus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAOjD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,GAAI,UAAU,iBAAiB,eAKjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,cAAc,SAExD,CAAA"}

package/dist/server/state.bus.js

@@ -0,0 +1,26 @@
+/**
+ * The set of listeners subscribed to state events.
+ */
+const listeners = new Set();
+/**
+ * Subscribes a listener function to state events.
+ * The listener will be called whenever a new state event is published.
+ *
+ * @param listener The function to be called when a state event occurs.
+ * @returns A cleanup function that, when called, unsubscribes the listener.
+ */
+export const subscribeToStateEvents = (listener) => {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+};
+/**
+ * Publishes a state event to all registered listeners.
+ * Each subscribed listener will receive the event.
+ *
+ * @param event The state event to be published.
+ */
+export const publishToStateEvent = (event) => {
+    listeners.forEach(listener => listener(event));
+};

package/dist/server/state.log.d.ts

@@ -0,0 +1,22 @@
+import type { ZunoStateEvent } from "../sync/sync-types";
+/**
+ * Appends an event to the log.
+ *
+ * @param event The event to append.
+ * @returns The appended event.
+ */
+export declare const appendEvent: (event: ZunoStateEvent) => ZunoStateEvent;
+/**
+ * Returns events after the given event id.
+ *
+ * @param lastEventId The last event id to return events after.
+ * @returns The events after the given event id.
+ */
+export declare const getEventsAfter: (lastEventId: number) => ZunoStateEvent[];
+/**
+ * Returns the last event id in the log.
+ *
+ * @returns The last event id in the log.
+ */
+export declare const getLastEventId: () => number;
+//# sourceMappingURL=state.log.d.ts.map

package/dist/server/state.log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.log.d.ts","sourceRoot":"","sources":["../../src/server/state.log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAWzD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,cAAc,mBAShD,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,aAAa,MAAM,qBAEjD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,cAE1B,CAAA"}

package/dist/server/state.log.js

@@ -0,0 +1,37 @@
+/** Maximum number of events to keep in the log. */
+const MAX_EVENTS = 1000;
+/** The next event id to assign. */
+let nextEventId = 1;
+/** The log of events. */
+const eventLog = [];
+/**
+ * Appends an event to the log.
+ *
+ * @param event The event to append.
+ * @returns The appended event.
+ */
+export const appendEvent = (event) => {
+    event.eventId = nextEventId++;
+    eventLog.push(event);
+    if (eventLog.length > MAX_EVENTS) {
+        eventLog.shift();
+    }
+    return event;
+};
+/**
+ * Returns events after the given event id.
+ *
+ * @param lastEventId The last event id to return events after.
+ * @returns The events after the given event id.
+ */
+export const getEventsAfter = (lastEventId) => {
+    return eventLog.filter(event => (event?.eventId ?? 0) > lastEventId);
+};
+/**
+ * Returns the last event id in the log.
+ *
+ * @returns The last event id in the log.
+ */
+export const getLastEventId = () => {
+    return eventLog[eventLog.length - 1]?.eventId ?? 0;
+};

package/dist/server/types.d.ts

@@ -0,0 +1,8 @@
+import type { ZunoStateEvent } from "../sync/sync-types";
+/**
+ * A callback function type for listening to Zuno state events.
+ *
+ * @param event The Zuno state event that occurred.
+ */
+export type ZunoStateListener = (event: ZunoStateEvent) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/server/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/server/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC"}

package/dist/server/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/universe-store.d.ts

@@ -0,0 +1,29 @@
+import type { ZunoStateEvent } from "../sync/sync-types";
+/**
+ * A global map to store the state of different parts of the universe.
+ * The keys are `storeKey` strings and the values are the corresponding state objects.
+ */
+type UniverseRecord = {
+    state: any;
+    version: number;
+};
+/**
+ * Retrieves the current state of a specific store in the universe.
+ * @param storeKey The key of the store to retrieve.
+ * @returns The current state of the store, or undefined if the store does not exist.
+ */
+export declare const getUniverseRecord: (storeKey: string) => UniverseRecord | undefined;
+/**
+ * Updates the state of a specific store in the universe.
+ * @param event The ZunoStateEvent containing the storeKey and the new state to set.
+ */
+export declare const updateUniverseState: (event: ZunoStateEvent) => void;
+/**
+ * Retrieves the current state of the entire universe.
+ * @returns An object containing the state of all stores in the universe.
+ */
+export declare const getUniverseState: () => {
+    [k: string]: UniverseRecord;
+};
+export {};
+//# sourceMappingURL=universe-store.d.ts.map

package/dist/server/universe-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universe-store.d.ts","sourceRoot":"","sources":["../../src/server/universe-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;GAGG;AACH,KAAK,cAAc,GAAG;IACpB,KAAK,EAAE,GAAG,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAIF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,cAAc,GAAG,SAErE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,cAAc,SAQxD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;CAE5B,CAAC"}

package/dist/server/universe-store.js

@@ -0,0 +1,26 @@
+const universeState = new Map();
+/**
+ * Retrieves the current state of a specific store in the universe.
+ * @param storeKey The key of the store to retrieve.
+ * @returns The current state of the store, or undefined if the store does not exist.
+ */
+export const getUniverseRecord = (storeKey) => {
+    return universeState.get(storeKey);
+};
+/**
+ * Updates the state of a specific store in the universe.
+ * @param event The ZunoStateEvent containing the storeKey and the new state to set.
+ */
+export const updateUniverseState = (event) => {
+    const current = universeState.get(event.storeKey) ?? { state: undefined, version: 0 };
+    // If applyStateEvent already computed event.version, prefer it.
+    const nextVersion = typeof event.version === "number" ? event.version : current.version + 1;
+    universeState.set(event.storeKey, { state: event.state, version: nextVersion });
+};
+/**
+ * Retrieves the current state of the entire universe.
+ * @returns An object containing the state of all stores in the universe.
+ */
+export const getUniverseState = () => {
+    return Object.fromEntries(universeState);
+};

package/dist/shared/readable.d.ts

@@ -0,0 +1,21 @@
+/** Universal UI adapter contract */
+export type ZunoReadable<T> = {
+    /** Read current value (sync) */
+    getSnapshot(): T;
+    /**
+     * Subscribe to changes.
+     * Call `onChange()` whenever snapshot may have changed.
+     * Return unsubscribe.
+     */
+    subscribe(onChange: () => void): () => void;
+    /** Optional: React SSR (server snapshot) */
+    getServerSnapshot?: () => T;
+};
+/** Minimal store shape that can be adapted into a readable */
+export type ZunoSubscribableStore<T> = {
+    get(): T;
+    subscribe(cb: (state: T) => void): () => void;
+};
+/** Adapter helper: convert store => readable */
+export declare function toReadable<T>(store: ZunoSubscribableStore<T>): ZunoReadable<T>;
+//# sourceMappingURL=readable.d.ts.map

package/dist/shared/readable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readable.d.ts","sourceRoot":"","sources":["../../src/shared/readable.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;IAC5B,gCAAgC;IAChC,WAAW,IAAI,CAAC,CAAC;IAEjB;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAE5C,4CAA4C;IAC5C,iBAAiB,CAAC,EAAE,MAAM,CAAC,CAAC;CAC7B,CAAC;AAEF,8DAA8D;AAC9D,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI;IACrC,GAAG,IAAI,CAAC,CAAC;IACT,SAAS,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC/C,CAAC;AAEF,gDAAgD;AAChD,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAK9E"}

package/dist/shared/readable.js

@@ -0,0 +1,7 @@
+/** Adapter helper: convert store => readable */
+export function toReadable(store) {
+    return {
+        getSnapshot: () => store.get(),
+        subscribe: (onChange) => store.subscribe(() => onChange()),
+    };
+}

package/dist/sync/apply-incoming-event.d.ts

@@ -0,0 +1,10 @@
+import type { IncomingEventContext, Universe } from "../core/types";
+import type { ZunoStateEvent } from "./sync-types";
+/**
+ * Applies an incoming event to the Universe in a safe, reusable way.
+ * @property universe - The universe to apply the event to.
+ * @property event - The event to apply.
+ * @property ctx - The context for the event.
+ **/
+export declare function applyIncomingEvent(universe: Universe, event: ZunoStateEvent, ctx: IncomingEventContext): void;
+//# sourceMappingURL=apply-incoming-event.d.ts.map

package/dist/sync/apply-incoming-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-incoming-event.d.ts","sourceRoot":"","sources":["../../src/sync/apply-incoming-event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD;;;;;IAKI;AACJ,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,oBAAoB,QA4B1B"}