@iadev93/zuno 0.0.3 → 0.0.5

package/README.md

@@ -190,6 +190,10 @@ If you export server helpers from core, consider **server-only subpath exports**
 
 ---
 
+If you’re using Zuno in a real project, please open an issue and tell us your use case.
+
+---
+
 ## License
 
 MIT

package/dist/core/createZuno.d.ts

@@ -0,0 +1,77 @@
+import type { ZunoStateEvent } from "../sync/sync-types";
+import type { Universe, ZunoSnapshot } from "./types";
+/** Store */
+type ZunoStore<T> = {
+    get(): T;
+    set(next: T): void;
+    subscribe(cb: (state: T) => void): () => void;
+};
+export type CreateZunoOptions = {
+    /** Universe */
+    universe?: Universe;
+    /** Optional transports */
+    channelName?: string;
+    /** SSE */
+    sseUrl?: string;
+    /** Sync */
+    syncUrl?: string;
+    /** Behavior */
+    optimistic?: boolean;
+    /** Client ID */
+    clientId?: string;
+};
+/**
+ * Creates a Zuno instance, which provides a state management system with optional synchronization
+ * capabilities via Server-Sent Events (SSE) and BroadcastChannel.
+ *
+ * @param opts - Configuration options for the Zuno instance.
+ * @param opts.universe - An optional pre-existing ZunoUniverse instance. If not provided, a new one will be created.
+ * @param opts.channelName - An optional name for the BroadcastChannel to enable local tab synchronization.
+ * @param opts.sseUrl - The URL for the Server-Sent Events endpoint to receive state updates from a server.
+ * @param opts.syncUrl - The URL for the synchronization endpoint to send state updates to a server. Required if `sseUrl` is provided.
+ * @param opts.optimistic - A boolean indicating whether state updates should be applied optimistically before server confirmation. Defaults to `true`.
+ * @param opts.clientId - A unique identifier for the client. If not provided, a random UUID will be generated.
+ * @returns An object containing methods to interact with the Zuno instance, including `getStore`, `destroy`, and `broadcast`.
+ */
+export declare const createZuno: (opts?: CreateZunoOptions) => {
+    /** Universe */
+    universe: Universe;
+    /** Client ID */
+    clientId: string;
+    /** Get store */
+    getStore: <T>(storeKey: string, init: () => T) => import("./types").Store<T>;
+    /** Create store */
+    store: <T>(storeKey: string, init: () => T) => {
+        key: string;
+        get: () => T;
+        set: (next: T | ((prev: T) => T)) => Promise<any>;
+        subscribe: (cb: (state: T) => void) => () => void;
+        raw: () => ZunoStore<T>;
+    };
+    /** Get state */
+    get: <T>(storeKey: string, init?: () => T) => T;
+    /** Set state */
+    set: <T>(storeKey: string, next: T | ((prev: T) => T), init?: () => T) => Promise<{
+        ok: boolean;
+        status: number;
+        json: any;
+    }>;
+    /** Subscribe to store */
+    subscribe: <T>(storeKey: string, init: () => T, cb: (state: T) => void) => () => boolean;
+    /** Dispatch event */
+    dispatch: (event: ZunoStateEvent) => Promise<{
+        ok: boolean;
+        status: number;
+        json: any;
+    }>;
+    /** Stop */
+    stop: () => void;
+    /** Hydrate snapshot */
+    hydrateSnapshot: (snapshot: ZunoSnapshot) => void;
+    /** Get last event ID */
+    getLastEventId: () => number;
+    /** Set last event ID */
+    setLastEventId: (id: number) => void;
+};
+export {};
+//# sourceMappingURL=createZuno.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createZuno.d.ts","sourceRoot":"","sources":["../../src/core/createZuno.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEtD,YAAY;AACZ,KAAK,SAAS,CAAC,CAAC,IAAI;IAClB,GAAG,IAAI,CAAC,CAAC;IACT,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,SAAS,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe;IACf,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB,0BAA0B;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,UAAU;IACV,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,WAAW;IACX,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,eAAe;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,gBAAgB;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GAAI,OAAM,iBAAsB;IAmRnD,eAAe;;IAEf,gBAAgB;;IAIhB,gBAAgB;eAlIA,CAAC,YAAa,MAAM,QAAQ,MAAM,CAAC;IAoInD,mBAAmB;YArBN,CAAC,YAAa,MAAM,QAAQ,MAAM,CAAC;aAb3C,MAAM;;6CAE0B,OAAO,CAAC,GAAG,CAAC;sCACnB,IAAI,KAAK,MAAM,IAAI;;;IAiCjD,gBAAgB;UA7HL,CAAC,YAAa,MAAM,SAAS,MAAM,CAAC,KAAG,CAAC;IA+HnD,gBAAgB;UAhFC,CAAC,YACR,MAAM,QACV,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,SACnB,MAAM,CAAC;;;;;IA+Ed,yBAAyB;gBA1DR,CAAC,YACR,MAAM,QACV,MAAM,CAAC,MACT,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI;IA2DtB,qBAAqB;sBA7HQ,cAAc;;;;;IA+H3C,WAAW;;IAGX,uBAAuB;gCAhRU,YAAY;IAkR7C,wBAAwB;;IAExB,wBAAwB;yBA3PE,MAAM;CA8PnC,CAAC"}

package/dist/core/createZuno.js

@@ -0,0 +1,250 @@
+import { createUniverse } from "./universe";
+import { startSSE } from "../sync/sse-client";
+import { startBroadcastChannel } from "../sync/broadcast-channel";
+import { applyIncomingEvent } from "../sync/apply-incoming-event";
+/**
+ * Creates a Zuno instance, which provides a state management system with optional synchronization
+ * capabilities via Server-Sent Events (SSE) and BroadcastChannel.
+ *
+ * @param opts - Configuration options for the Zuno instance.
+ * @param opts.universe - An optional pre-existing ZunoUniverse instance. If not provided, a new one will be created.
+ * @param opts.channelName - An optional name for the BroadcastChannel to enable local tab synchronization.
+ * @param opts.sseUrl - The URL for the Server-Sent Events endpoint to receive state updates from a server.
+ * @param opts.syncUrl - The URL for the synchronization endpoint to send state updates to a server. Required if `sseUrl` is provided.
+ * @param opts.optimistic - A boolean indicating whether state updates should be applied optimistically before server confirmation. Defaults to `true`.
+ * @param opts.clientId - A unique identifier for the client. If not provided, a random UUID will be generated.
+ * @returns An object containing methods to interact with the Zuno instance, including `getStore`, `destroy`, and `broadcast`.
+ */
+export const createZuno = (opts = {}) => {
+    /** Local state */
+    const localState = new Map();
+    /** Local per-store versions (for BC / local ordering) */
+    const versions = new Map();
+    /** Universe */
+    const universe = (opts.universe ?? (createUniverse()));
+    /** Unique client ID */
+    const clientId = opts.clientId ?? (globalThis.crypto?.randomUUID?.() ?? String(Math.random()));
+    /** SSE ready */
+    let sseReady = false;
+    /** Last event ID */
+    let lastEventId = 0;
+    /**
+     * Hydrate snapshot
+     * @param snapshot - The snapshot to hydrate.
+     */
+    function hydrateSnapshot(snapshot) {
+        const plain = {};
+        for (const [k, rec] of Object.entries(snapshot.state)) {
+            plain[k] = rec.state;
+            versions.set(k, rec.version);
+        }
+        universe.restore(plain);
+        lastEventId = snapshot.lastEventId;
+    }
+    /**
+     * Get store base version
+     * @param storeKey - The key of the store to get the base version for.
+     */
+    function getStoreBaseVersion(storeKey) { return versions.get(storeKey) ?? 0; }
+    /**
+     * Get last event ID
+     */
+    function getLastEventId() { return lastEventId; }
+    /**
+     * Set last event ID
+     * @param id - The new last event ID.
+     */
+    function setLastEventId(id) { lastEventId = id; }
+    /** SSE Prefer server sync if provided */
+    const sse = opts.sseUrl && opts.syncUrl
+        ? startSSE({
+            universe,
+            url: opts.sseUrl,
+            syncUrl: opts.syncUrl,
+            optimistic: opts.optimistic ?? true,
+            clientId,
+            versions,
+            getLastEventId: () => lastEventId,
+            onOpen: () => {
+                sseReady = true;
+            },
+            onClose: () => {
+                sseReady = false;
+            },
+        })
+        : null;
+    /** Apply event to target */
+    const apply = (event) => {
+        /** Update last event ID */
+        if (typeof event.eventId === "number")
+            lastEventId = Math.max(lastEventId, event.eventId);
+        applyIncomingEvent(universe, event, { clientId, localState, versions });
+    };
+    /** Broadcast Channel for local tab sync */
+    const bc = opts.channelName
+        ? startBroadcastChannel({
+            /** Channel name for BroadcastChannel */
+            channelName: opts.channelName,
+            /** Unique client ID */
+            clientId,
+            /** Apply event to target */
+            onEvent: (ev) => {
+                apply(ev);
+            },
+            /** Get snapshot of local state */
+            getSnapshot: () => {
+                /** Snapshot */
+                const snap = universe.snapshot();
+                /** Snapshot */
+                const out = {};
+                /** Iterate local state */
+                for (const [storeKey, state] of Object.entries(snap)) {
+                    /** Add to snapshot */
+                    out[storeKey] = {
+                        state,
+                        version: versions.get(storeKey) ?? 0,
+                    };
+                }
+                return out;
+            },
+            /** Apply snapshot to target */
+            onSnapshot: (snap) => {
+                /** Iterate snapshot with store key and record */
+                for (const [storeKey, rec] of Object.entries(snap)) {
+                    /** Record */
+                    const record = rec;
+                    /** Get the universe store state or the store state */
+                    const state = record?.state ?? record;
+                    /** Get the universe store version or the store version */
+                    const version = typeof record?.version === "number" ? record.version : 0;
+                    /** Set the latest version */
+                    // versions.set(storeKey, Math.max(versions.get(storeKey) ?? 0, version));
+                    /** Apply the event */
+                    apply({ storeKey, state, version });
+                }
+            },
+        })
+        : null;
+    /** Immediately ask other tabs for snapshot (BC-first) */
+    setTimeout(() => bc?.hello(), 0);
+    /** Store factory
+     * @param storeKey - The key of the store to get.
+     * @param init - The initialization function for the store.
+     * @returns The store.
+    */
+    const getStore = (storeKey, init) => {
+        return universe.getStore(storeKey, init);
+    };
+    /** Get store by store key
+     * @param storeKey - The key of the store to get.
+     * @param init - The initialization function for the store.
+     * @returns The state of the store.
+    */
+    const get = (storeKey, init) => {
+        return universe.getStore(storeKey, init ?? (() => undefined)).get();
+    };
+    /** Dispatch event to universe
+     * @param event - The event to dispatch.
+     * @returns A promise that resolves to the result of the dispatch.
+    */
+    const dispatch = async (event) => {
+        /** Check if SSE is enabled */
+        if (sse && sseReady) {
+            /** Payload with origin */
+            const payload = { ...event, origin: clientId, baseVersion: getStoreBaseVersion(event.storeKey) };
+            /** Dispatch to SSE */
+            return await sse.dispatch(payload);
+        }
+        /** Current version */
+        const current = versions.get(event.storeKey) ?? 0;
+        /** Next version */
+        const nextVersion = current + 1;
+        /** Apply event with next version */
+        apply({ ...event, version: nextVersion });
+        /** Set version */
+        versions.set(event.storeKey, nextVersion);
+        /** Check if BroadcastChannel is enabled */
+        if (bc) {
+            /** Publish event */
+            bc.publish({ ...event, version: nextVersion, origin: clientId });
+        }
+        /** Return success */
+        return { ok: true, status: 200, json: null };
+    };
+    /** Set store state
+     * @param storeKey - The key of the store to set.
+     * @param next - The new state to set.
+     * @param init - The initialization function for the store.
+     * @returns A promise that resolves to the result of the dispatch.
+    */
+    const set = async (storeKey, next, init) => {
+        /** Get store */
+        const store = universe.getStore(storeKey, init ?? (() => undefined));
+        /** Get previous state */
+        const prev = store.get();
+        /** Get next state */
+        const state = typeof next === "function" ? next(prev) : next;
+        /** Dispatch event */
+        return dispatch({ storeKey, state });
+    };
+    /** Subscribe to store
+     * @param storeKey - The key of the store to subscribe to.
+     * @param init - The initialization function for the store.
+     * @param cb - The callback function to be called when the store state changes.
+     * @returns A function to unsubscribe from the store.
+    */
+    const subscribe = (storeKey, init, cb) => {
+        /** Get store */
+        const store = universe.getStore(storeKey, init);
+        return store.subscribe(cb);
+    };
+    /** Stop cleanup */
+    const stop = () => {
+        sse?.unsubscribe?.();
+        bc?.stop?.();
+    };
+    /**
+     * Creates a bound store for a specific key.
+     * @param storeKey The key of the store to create.
+     * @param init The initialization function for the store.
+     * @returns A BoundStore object representing the store.
+     */
+    const store = (storeKey, init) => {
+        const rawStore = getStore(storeKey, init);
+        return {
+            key: storeKey,
+            raw: () => rawStore,
+            get: () => rawStore.get(),
+            subscribe: (cb) => rawStore.subscribe(cb),
+            set: (next) => set(storeKey, next, init),
+        };
+    };
+    return {
+        /** Universe */
+        universe,
+        /** Client ID */
+        clientId,
+        // ------------ DX ------------ \\
+        /** Get store */
+        getStore,
+        /** Create store */
+        store,
+        /** Get state */
+        get,
+        /** Set state */
+        set,
+        /** Subscribe to store */
+        subscribe,
+        // ------------ Advanced ------------ \\
+        /** Dispatch event */
+        dispatch,
+        /** Stop */
+        stop,
+        /** Hydrate snapshot */
+        hydrateSnapshot,
+        /** Get last event ID */
+        getLastEventId,
+        /** Set last event ID */
+        setLastEventId,
+    };
+};

package/dist/core/store.d.ts

@@ -0,0 +1,10 @@
+import type { Store } from "./types";
+/**
+ * Creates a ZUNO state management store.
+ *
+ * @template T The type of the state managed by the store.
+ * @param {T} initial The initial state value.
+ * @returns {Store<T>} An object containing methods to interact with the store.
+ */
+export declare const createStore: <T>(initial: T) => Store<T>;
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/core/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,SAAS,CAAC,KAAG,KAAK,CAAC,CAAC,CAsBlD,CAAC"}

package/dist/core/store.js

@@ -0,0 +1,27 @@
+/**
+ * Creates a ZUNO state management store.
+ *
+ * @template T The type of the state managed by the store.
+ * @param {T} initial The initial state value.
+ * @returns {Store<T>} An object containing methods to interact with the store.
+ */
+export const createStore = (initial) => {
+    let state = initial;
+    const listeners = new Set();
+    return {
+        get: () => state,
+        set: (next) => {
+            const value = typeof next === "function"
+                ? next(state)
+                : next;
+            if (Object.is(value, state))
+                return;
+            state = value;
+            listeners.forEach((l) => l(state));
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        }
+    };
+};

package/dist/core/types.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Represents a generic store that can hold and manage a state of type T.
+ * It provides methods to get, set, and subscribe to changes in the state.
+ */
+export interface Store<T> {
+    /**
+     * Retrieves the current value of the store's state.
+     * @returns The current state.
+     */
+    get(): T;
+    /**
+     * Sets the new state of the store.
+     * It can accept either a direct value or a function that receives the previous state
+     * and returns the new state.
+     * @param next The new state value or a function to derive the new state.
+     */
+    set(next: T | ((prev: T) => T)): void;
+    /**
+     * Subscribes a listener function to state changes.
+     * The listener will be called whenever the state updates.
+     * @param listener The function to call when the state changes.
+     * @returns {boolean} A function to unsubscribe the listener. Calling this function will remove the subscription.
+     */
+    subscribe(listener: (state: T) => void): () => boolean;
+}
+/**
+ * Represents a global container or manager for multiple stores,
+ * often referred to as a "universe" in state management patterns.
+ * It allows creating, retrieving, snapshotting, and restoring stores.
+ */
+export interface Universe {
+    /**
+     * Retrieves a store by its unique key. If the store does not exist,
+     * it initializes it using the provided `init` function and then returns it.
+     * @param key The unique identifier for the store.
+     * @param init A function to initialize the store's state if it doesn't already exist.
+     * @returns The requested store.
+     */
+    getStore<T>(key: string, init: () => T): Store<T>;
+    /**
+     * Creates a snapshot of the current state of all stores managed by the Universe.
+     * The snapshot is a record where keys are store identifiers and values are their states.
+     * @returns A record representing the current state of all stores.
+     */
+    snapshot(): Record<string, unknown>;
+    /**
+     * Restores the state of all stores in the Universe from a provided data snapshot.
+     * This can be used to rehydrate the application's state.
+     * @param data A record containing the state to restore for each store.
+     */
+    restore(data: Record<string, unknown>): void;
+    /**
+     * Deletes a store by its unique key.
+     * @param key The unique identifier for the store to delete.
+     */
+    delete(key: string): void;
+    /**
+     * Clears all stores from the Universe.
+     */
+    clear(): void;
+    /**
+     * Restores the state of all stores in the Universe from a provided data snapshot.
+     * This can be used to rehydrate the application's state.
+     * @param snapshot A record containing the state to restore for each store.
+     */
+    hydrateSnapshot(snapshot: ZunoSnapshot): void;
+}
+/**
+ * Context for incoming events.
+ * It is used to prevent loops (don’t re-apply your own broadcast) and to track per-store version tracking (SSE uses it, BC can ignore it).
+ */
+export type IncomingEventContext = {
+    /** Used to prevent loops (don’t re-apply your own broadcast) */
+    clientId: string;
+    /** Per-store version tracking (SSE uses it, BC can ignore it) */
+    versions?: Map<string, number>;
+    /** Optional in-memory snapshot state for BC “hello/snapshot” */
+    localState?: Map<string, unknown>;
+};
+/**
+ * A snapshot of the universe state.
+ * It is used to rehydrate the application's state.
+ */
+export type ZunoSnapshot = {
+    state: Record<string, {
+        state: unknown;
+        version: number;
+    }>;
+    lastEventId: number;
+};
+/**
+ * A contract for adapters to interact with the store in a read-only manner.
+ * This provides a "native feel" for consumers preventing them from touching the core directly.
+ */
+export type ZunoReadable<T> = {
+    /** Read current value (must be sync) */
+    getSnapshot(): T;
+    /**
+     * Subscribe to changes.
+     * Must call `onChange` whenever snapshot may have changed.
+     * Returns unsubscribe.
+     */
+    subscribe(onChange: () => void): () => void;
+    /** Optional: for SSR hydration safety in React */
+    getServerSnapshot?: () => T;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB;;;OAGG;IACH,GAAG,IAAI,CAAC,CAAC;IACT;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC;IACtC;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,OAAO,CAAC;CACxD;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAClD;;;;OAIG;IACH,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAE7C;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;OAIG;IACH,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;CAE/C;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;IAEjB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE/B,gEAAgE;IAChE,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC1D,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;IAC5B,wCAAwC;IACxC,WAAW,IAAI,CAAC,CAAC;IAEjB;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAE5C,kDAAkD;IAClD,iBAAiB,CAAC,EAAE,MAAM,CAAC,CAAC;CAC7B,CAAC"}

package/dist/core/types.js

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

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"}