@iadev93/zuno 0.0.2

package/README.md

@@ -0,0 +1,195 @@
+# @iadev93/zuno
+
+**Zuno** is a universal, event-driven state system designed to keep **client, server, and multiple runtimes** in sync with strong consistency guarantees.
+
+Zuno is built around a simple idea:
+
+> State is not local — it is **distributed, versioned, and observable**.
+
+This package is the **core** of the Zuno ecosystem:
+
+* State engine (Universe + Stores)
+* Versioned event model
+* Sync primitives (SSE + BroadcastChannel)
+* Adapter contract (`ZunoReadable`) for UI/framework bindings
+* Optional server helpers (snapshot + SSE handlers)
+
+---
+
+## Install
+
+```bash
+npm install @iadev93/zuno
+```
+
+---
+
+## Quick Start (Client)
+
+```ts
+import { createZuno } from "@iadev93/zuno";
+
+const zuno = createZuno();
+
+const counter = zuno.store("counter", () => 0);
+
+await counter.set((v) => v + 1);
+console.log(counter.get());
+```
+
+---
+
+## Core Concepts
+
+### Universe
+
+A Universe is a container for many stores. It is responsible for:
+
+* creating and caching stores by key
+* coordinating versioned state events
+* providing a stable API for sync/transports
+
+### Store
+
+A Store is keyed state.
+
+* `get()` returns current snapshot
+* `set(next)` updates state (supports functional updates)
+* `subscribe(cb)` notifies on changes
+
+### State Events (Versioned)
+
+Zuno sync is driven by **versioned state events**. Each event includes:
+
+* `storeKey`
+* `state`
+* `origin` (who produced it)
+* `baseVersion` (what it was based on)
+* `version` (monotonic)
+* `eventId` (optional)
+
+This enables deterministic ordering and protects against stale overwrites.
+
+---
+
+## Client Sync
+
+Zuno supports multi-tab / multi-client synchronization.
+
+### 1) Same-origin tabs (BroadcastChannel)
+
+```ts
+import { startBroadcastChannel } from "@iadev93/zuno";
+
+startBroadcastChannel({
+  channelName: "zuno-demo"
+});
+```
+
+> BroadcastChannel works **only across the same origin**.
+
+### 2) Multi-client sync (SSE)
+
+```ts
+import { startSSE } from "@iadev93/zuno";
+
+startSSE({
+  url: "/zuno/events",
+  // optional: pass shared Maps for version bookkeeping
+  // versions,
+});
+```
+
+SSE is ideal for:
+
+* low-latency state fanout
+* CDN/proxy friendly infra
+* avoiding WebSocket lock-in
+
+---
+
+## Adapter Contract (UI / Frameworks)
+
+Zuno exposes a minimal adapter contract that can be consumed by any UI/runtime:
+
+```ts
+type ZunoReadable<T> = {
+  getSnapshot(): T;
+  subscribe(onChange: () => void): () => void;
+  getServerSnapshot?: () => T;
+};
+```
+
+Helper:
+
+```ts
+import { toReadable } from "@iadev93/zuno";
+
+const readable = toReadable(store);
+```
+
+This contract is used by `@iadev93/zuno-react` and future adapters (Solid/Vue/Svelte/etc.).
+
+---
+
+## Server Usage (Optional Helpers)
+
+If you want to host Zuno sync endpoints yourself (without `@iadev93/zuno-express`), the core package provides server-side utilities via the `@iadev93/zuno/server` entry point.
+
+### Snapshot handler
+
+The snapshot handler returns the current universe/store snapshot for new clients.
+
+```ts
+import { /* snapshot handler export */ } from "@iadev93/zuno/server";
+```
+
+### SSE connection + state publishing
+
+Zuno’s SSE utilities typically do two jobs:
+
+* register a client connection
+* broadcast state events to connected clients
+
+```ts
+import { createSSEConnection, setUniverseState } from "@iadev93/zuno/server";
+```
+
+### Applying incoming events
+
+Incoming events should be validated and applied using the core apply routine.
+
+```ts
+import { /* apply-state-event export */ } from "@iadev93/zuno/server";
+```
+
+---
+
+## Recommended: Express Integration
+
+If you’re using Express, use the dedicated adapter:
+
+```bash
+npm install @iadev93/zuno-express
+```
+
+It wires SSE + snapshot routes cleanly and keeps your core imports tidy.
+
+---
+
+## Public Exports
+
+Core exports are intentionally minimal:
+
+* `createZuno`, `CreateZunoOptions`
+* `startSSE`, `startBroadcastChannel`
+* `ZunoReadable`, `ZunoSubscribableStore`, `toReadable`
+* (optional) server helpers if you choose to expose them
+
+If you export server helpers from core, consider **server-only subpath exports** to prevent accidental client bundling.
+
+---
+
+## 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 {};