@honua/app-platform 0.0.20-alpha.0

package/realtime/reducer.js

@@ -0,0 +1,351 @@
+/**
+ * Pure reducer helpers for realtime feature state.
+ *
+ * @module
+ */
+const DEFAULT_MAX_SEEN_EVENT_IDS = 256;
+const DEFAULT_MAX_TOMBSTONES = 1024;
+export function emptyRealtimeFeatureState() {
+    return {
+        status: "idle",
+        records: {},
+        tombstones: {},
+        ignoredEventCount: 0,
+        seenEventIds: [],
+    };
+}
+export function realtimeFeatureKey(sourceId, id) {
+    return `${sourceId ?? ""}:${String(id)}`;
+}
+export function realtimeSubscriptionKey(request) {
+    return [
+        request.requestId ?? "",
+        request.sourceId,
+        request.layerId === undefined ? "" : String(request.layerId),
+        request.where ?? "",
+        request.fields?.join(",") ?? "",
+        encodeIdentityPart(request.spatialFilter),
+    ].join("\u0000");
+}
+export function realtimeResumeCheckpoint(state) {
+    if (!state.checkpoint)
+        return undefined;
+    return { ...state.checkpoint };
+}
+export function reduceRealtimeFeatureState(state, event, options = {}) {
+    if (isDuplicateOrOutOfOrder(state, event)) {
+        return {
+            ...state,
+            ignoredEventCount: state.ignoredEventCount + 1,
+        };
+    }
+    const receivedAt = event.receivedAt ?? options.now?.() ?? Date.now();
+    const base = withEventMetadata(state, event, receivedAt, options.maxSeenEventIds ?? DEFAULT_MAX_SEEN_EVENT_IDS);
+    const metadata = mutationMetadata(event, receivedAt);
+    switch (event.type) {
+        case "snapshot":
+            return applySnapshot(base, event.features, {
+                replace: event.replace ?? true,
+                ...metadata,
+            });
+        case "upsert":
+            return applyUpsert(base, event.feature, metadata);
+        case "delete":
+            return boundTombstones(applyDelete(base, {
+                id: event.id,
+                sourceId: event.sourceId,
+                cursor: metadata.cursor,
+                sequence: metadata.sequence,
+                version: event.version,
+                updatedAt: event.updatedAt,
+                deletedAt: event.deletedAt ?? receivedAt,
+            }), options, receivedAt);
+        case "delta":
+            return boundTombstones(applyDelta(base, event.upserts ?? [], event.deletes ?? [], metadata), options, receivedAt);
+        case "heartbeat":
+            return {
+                ...base,
+                status: base.status === "closed" || base.status === "error" ? base.status : "live",
+                lastHeartbeatAt: receivedAt,
+                staleSince: undefined,
+                error: base.status === "error" ? base.error : undefined,
+                statusReason: base.status === "error" ? base.statusReason : undefined,
+                retryAfterMs: base.status === "error" ? base.retryAfterMs : undefined,
+                reconnectAttempt: base.status === "error" ? base.reconnectAttempt : undefined,
+            };
+        case "status":
+            return {
+                ...base,
+                status: event.status,
+                lastStatusAt: receivedAt,
+                staleSince: event.status === "stale" ? (event.staleSince ?? receivedAt) : undefined,
+                error: event.status === "error" ? base.error : undefined,
+                statusReason: event.reason,
+                retryAfterMs: event.retryAfterMs,
+                reconnectAttempt: event.reconnectAttempt,
+                terminalError: event.status === "error" ? base.terminalError : undefined,
+            };
+        case "error":
+            return {
+                ...base,
+                status: event.terminal ? "error" : "reconnecting",
+                lastStatusAt: receivedAt,
+                error: event.error,
+                statusReason: event.code,
+                retryAfterMs: event.retryAfterMs,
+                terminalError: event.terminal === true,
+                staleSince: event.terminal ? base.staleSince : receivedAt,
+            };
+    }
+}
+export function reconcileRealtimeStaleness(state, options) {
+    const now = options.now ?? Date.now();
+    const lastLiveAt = state.lastHeartbeatAt ?? state.lastEventAt;
+    if (!lastLiveAt || now - lastLiveAt <= options.staleAfterMs)
+        return state;
+    if (state.status === "closed" || state.status === "error" || state.status === "offline")
+        return state;
+    return {
+        ...state,
+        status: "stale",
+        staleSince: state.staleSince ?? lastLiveAt + options.staleAfterMs,
+    };
+}
+function isDuplicateOrOutOfOrder(state, event) {
+    if (event.eventId && state.seenEventIds.includes(event.eventId))
+        return true;
+    const sequence = eventSequence(event);
+    return typeof sequence === "number" && typeof state.lastSequence === "number" && sequence <= state.lastSequence;
+}
+function withEventMetadata(state, event, receivedAt, maxSeenEventIds) {
+    const seenEventIds = event.eventId
+        ? [...state.seenEventIds, event.eventId].slice(-Math.max(1, maxSeenEventIds))
+        : state.seenEventIds;
+    const sequence = eventSequence(event);
+    const checkpoint = mergeCheckpoint(state.checkpoint, event);
+    const cursor = eventCursor(event) ?? state.cursor;
+    const watermark = eventWatermark(event) ?? state.watermark;
+    const timestamp = eventTimestamp(event) ?? state.timestamp;
+    const deltaToken = eventDeltaToken(event) ?? state.deltaToken;
+    const status = isRecoverableStatus(state.status) ? "live" : state.status;
+    return {
+        ...state,
+        status,
+        cursor,
+        watermark,
+        timestamp,
+        deltaToken,
+        checkpoint,
+        lastSequence: typeof sequence === "number" ? sequence : state.lastSequence,
+        lastEventAt: receivedAt,
+        staleSince: undefined,
+        error: status === "live" ? undefined : state.error,
+        seenEventIds,
+    };
+}
+function applySnapshot(state, features, metadata) {
+    const records = metadata.replace ? {} : { ...state.records };
+    const tombstones = metadata.replace ? {} : { ...state.tombstones };
+    for (const feature of features) {
+        const key = realtimeFeatureKey(feature.sourceId, feature.id);
+        records[key] = {
+            ...feature,
+            key,
+            cursor: metadata.cursor,
+            sequence: metadata.sequence,
+            receivedAt: metadata.receivedAt,
+        };
+        delete tombstones[key];
+    }
+    return {
+        ...state,
+        records,
+        tombstones,
+    };
+}
+function applyDelta(state, upserts, deletes, metadata) {
+    if (upserts.length === 0 && deletes.length === 0) {
+        return state;
+    }
+    // Build the next records/tombstones maps once and mutate them across every
+    // item in the batch. The previous implementation delegated to
+    // applyUpsert/applyDelete per item, each of which spread the entire records
+    // (and tombstones) dictionary — O(deltaSize x stateSize): a 100-mutation
+    // delta over a 10k-feature state copied ~1M entries.
+    const records = { ...state.records };
+    const tombstones = { ...state.tombstones };
+    for (const feature of upserts) {
+        const key = realtimeFeatureKey(feature.sourceId, feature.id);
+        delete tombstones[key];
+        records[key] = {
+            ...feature,
+            key,
+            cursor: metadata.cursor,
+            sequence: metadata.sequence,
+            receivedAt: metadata.receivedAt,
+        };
+    }
+    for (const tombstone of deletes) {
+        const key = realtimeFeatureKey(tombstone.sourceId, tombstone.id);
+        delete records[key];
+        tombstones[key] = {
+            id: tombstone.id,
+            sourceId: tombstone.sourceId,
+            cursor: metadata.cursor,
+            sequence: metadata.sequence,
+            version: tombstone.version,
+            updatedAt: tombstone.updatedAt,
+            deletedAt: tombstone.deletedAt ?? metadata.receivedAt,
+            key,
+        };
+    }
+    return {
+        ...state,
+        records,
+        tombstones,
+    };
+}
+/**
+ * Evict tombstones that exceed the configured age (`tombstoneTtlMs`) or count
+ * (`maxTombstones`, default {@link DEFAULT_MAX_TOMBSTONES}) bound. Returns the
+ * input state unchanged when nothing is pruned so reducers stay referentially
+ * stable on the common path.
+ */
+function boundTombstones(state, options, now) {
+    const maxTombstones = options.maxTombstones ?? DEFAULT_MAX_TOMBSTONES;
+    const ttlMs = options.tombstoneTtlMs;
+    const hasTtl = typeof ttlMs === "number" && ttlMs >= 0;
+    const entries = Object.values(state.tombstones);
+    const overCount = maxTombstones > 0 && entries.length > maxTombstones;
+    if (!overCount && !hasTtl) {
+        return state;
+    }
+    let kept = entries;
+    if (hasTtl) {
+        kept = kept.filter((tombstone) => now - (tombstone.deletedAt ?? 0) <= ttlMs);
+    }
+    if (maxTombstones > 0 && kept.length > maxTombstones) {
+        // Retain the most-recently-deleted entries.
+        kept = [...kept].sort((a, b) => (a.deletedAt ?? 0) - (b.deletedAt ?? 0)).slice(kept.length - maxTombstones);
+    }
+    if (kept.length === entries.length) {
+        return state;
+    }
+    const tombstones = {};
+    for (const tombstone of kept) {
+        tombstones[tombstone.key] = tombstone;
+    }
+    return { ...state, tombstones };
+}
+function applyUpsert(state, feature, metadata) {
+    const key = realtimeFeatureKey(feature.sourceId, feature.id);
+    const tombstones = { ...state.tombstones };
+    delete tombstones[key];
+    return {
+        ...state,
+        records: {
+            ...state.records,
+            [key]: {
+                ...feature,
+                key,
+                cursor: metadata.cursor,
+                sequence: metadata.sequence,
+                receivedAt: metadata.receivedAt,
+            },
+        },
+        tombstones,
+    };
+}
+function applyDelete(state, tombstone) {
+    const key = realtimeFeatureKey(tombstone.sourceId, tombstone.id);
+    const records = { ...state.records };
+    delete records[key];
+    return {
+        ...state,
+        records,
+        tombstones: {
+            ...state.tombstones,
+            [key]: {
+                ...tombstone,
+                key,
+            },
+        },
+    };
+}
+function eventCursor(event) {
+    return event.checkpoint?.cursor ?? event.cursor;
+}
+function eventWatermark(event) {
+    return event.checkpoint?.watermark ?? event.watermark;
+}
+function eventTimestamp(event) {
+    return event.checkpoint?.timestamp ?? event.timestamp;
+}
+function eventDeltaToken(event) {
+    return event.checkpoint?.deltaToken ?? event.deltaToken;
+}
+function eventSequence(event) {
+    return event.sequence ?? event.checkpoint?.sequence;
+}
+function mutationMetadata(event, receivedAt) {
+    return {
+        cursor: eventCursor(event),
+        sequence: eventSequence(event),
+        receivedAt,
+    };
+}
+function mergeCheckpoint(previous, event) {
+    const cursor = eventCursor(event);
+    const watermark = eventWatermark(event);
+    const timestamp = eventTimestamp(event);
+    const sequence = eventSequence(event);
+    const deltaToken = eventDeltaToken(event);
+    if (previous === undefined &&
+        cursor === undefined &&
+        watermark === undefined &&
+        timestamp === undefined &&
+        sequence === undefined &&
+        deltaToken === undefined) {
+        return undefined;
+    }
+    return {
+        ...(previous ?? {}),
+        ...(cursor !== undefined ? { cursor } : {}),
+        ...(watermark !== undefined ? { watermark } : {}),
+        ...(timestamp !== undefined ? { timestamp } : {}),
+        ...(sequence !== undefined ? { sequence } : {}),
+        ...(deltaToken !== undefined ? { deltaToken } : {}),
+    };
+}
+function isRecoverableStatus(status) {
+    return (status === "idle" ||
+        status === "connecting" ||
+        status === "reconnecting" ||
+        status === "stale" ||
+        status === "offline");
+}
+function encodeIdentityPart(value) {
+    if (value === undefined)
+        return "";
+    if (typeof value !== "object" || value === null)
+        return String(value);
+    try {
+        return JSON.stringify(sortIdentityValue(value));
+    }
+    catch {
+        return String(value);
+    }
+}
+function sortIdentityValue(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    if (Array.isArray(value))
+        return value.map(sortIdentityValue);
+    if (typeof value !== "object" || value === null)
+        return value;
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+        sorted[key] = sortIdentityValue(value[key]);
+    }
+    return sorted;
+}

package/realtime/sse.d.ts

@@ -0,0 +1,23 @@
+import type { RealtimeFeatureEvent, RealtimeFeatureTransport, RealtimeSubscriptionRequest } from "./types.js";
+export interface RealtimeServerSentEventSource {
+    readonly readyState?: number;
+    onopen: ((event: Event) => void) | null;
+    onmessage: ((event: MessageEvent<string>) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    close(): void;
+    addEventListener?(type: string, listener: (event: MessageEvent<string>) => void): void;
+    removeEventListener?(type: string, listener: (event: MessageEvent<string>) => void): void;
+}
+export type RealtimeServerSentEventSourceFactory = (url: string, init?: EventSourceInit) => RealtimeServerSentEventSource;
+export interface RealtimeServerSentEventsTransportOptions<TFeature = unknown> {
+    readonly url: string;
+    readonly eventSourceFactory?: RealtimeServerSentEventSourceFactory;
+    readonly withCredentials?: boolean;
+    readonly eventTypes?: ReadonlyArray<string>;
+    readonly encodeRequest?: (url: URL, request: RealtimeSubscriptionRequest) => void;
+    readonly decodeEvent?: (payload: unknown) => RealtimeFeatureEvent<TFeature>;
+}
+export declare function createRealtimeServerSentEventsTransport<TFeature = unknown>(options: RealtimeServerSentEventsTransportOptions<TFeature>): RealtimeFeatureTransport<TFeature>;
+export declare function encodeDefaultRealtimeRequest(url: URL, request: RealtimeSubscriptionRequest): URL;
+export declare function decodeRealtimeServerSentEvent<TFeature = unknown>(payload: unknown): RealtimeFeatureEvent<TFeature>;
+//# sourceMappingURL=sse.d.ts.map

package/realtime/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/realtime/sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EAEpB,wBAAwB,EAExB,2BAA2B,EAC5B,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACxC,SAAS,EAAE,CAAC,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1D,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACzC,KAAK,IAAI,IAAI,CAAC;IACd,gBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC;IACvF,mBAAmB,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC;CAC3F;AAED,MAAM,MAAM,oCAAoC,GAAG,CACjD,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,eAAe,KACnB,6BAA6B,CAAC;AAEnC,MAAM,WAAW,wCAAwC,CAAC,QAAQ,GAAG,OAAO;IAC1E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,kBAAkB,CAAC,EAAE,oCAAoC,CAAC;IACnE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,2BAA2B,KAAK,IAAI,CAAC;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,oBAAoB,CAAC,QAAQ,CAAC,CAAC;CAC7E;AAID,wBAAgB,uCAAuC,CAAC,QAAQ,GAAG,OAAO,EACxE,OAAO,EAAE,wCAAwC,CAAC,QAAQ,CAAC,GAC1D,wBAAwB,CAAC,QAAQ,CAAC,CAyEpC;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,2BAA2B,GAAG,GAAG,CAsBhG;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,GAAG,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAUlH"}

package/realtime/sse.js

@@ -0,0 +1,143 @@
+const DEFAULT_EVENT_TYPES = ["snapshot", "upsert", "delete", "delta", "heartbeat", "status", "error"];
+export function createRealtimeServerSentEventsTransport(options) {
+    return {
+        capabilities: {
+            kind: "sse",
+            resumeModes: ["cursor", "watermark", "timestamp", "sequence", "delta-token"],
+            emitsHeartbeats: true,
+            emitsWatermarks: true,
+        },
+        subscribe(request, observer) {
+            // If the caller's signal is already aborted at subscribe time, the
+            // "abort" event has already fired and will never fire again, so the
+            // listener registered below would never run and the EventSource would
+            // leak (open connection + auto-reconnect + attached listeners). Bail
+            // out synchronously before constructing anything, mirroring the
+            // up-front `signal?.aborted` guard used elsewhere (e.g. core/batch.ts).
+            if (request.signal?.aborted) {
+                observer.complete();
+                return { close: () => { } };
+            }
+            const url = new URL(options.url, "http://honua.local");
+            encodeDefaultRealtimeRequest(url, request);
+            options.encodeRequest?.(url, request);
+            const source = createEventSource(resolveEventSourceUrl(options.url, url), options);
+            let closed = false;
+            const listeners = [];
+            const emitPayload = (payload) => {
+                if (closed || payload.trim() === "")
+                    return;
+                try {
+                    observer.next((options.decodeEvent ?? (decodeRealtimeServerSentEvent))(JSON.parse(payload)));
+                }
+                catch (error) {
+                    observer.error(error);
+                }
+            };
+            const messageListener = (event) => emitPayload(event.data);
+            source.onopen = () => {
+                if (!closed)
+                    observer.next({ type: "status", status: "live", receivedAt: Date.now() });
+            };
+            source.onmessage = messageListener;
+            source.onerror = (event) => {
+                if (!closed)
+                    observer.next({ type: "status", status: "reconnecting", reason: "sse-error", receivedAt: Date.now() });
+                if (isEventSourceClosed(source))
+                    observer.error(event);
+            };
+            for (const type of options.eventTypes ?? DEFAULT_EVENT_TYPES) {
+                if (!source.addEventListener)
+                    break;
+                const listener = (event) => emitPayload(event.data);
+                source.addEventListener(type, listener);
+                listeners.push([type, listener]);
+            }
+            const abortListener = () => closeSource();
+            request.signal?.addEventListener("abort", abortListener, { once: true });
+            function closeSource() {
+                if (closed)
+                    return;
+                closed = true;
+                request.signal?.removeEventListener("abort", abortListener);
+                for (const [type, listener] of listeners)
+                    source.removeEventListener?.(type, listener);
+                source.onopen = null;
+                source.onmessage = null;
+                source.onerror = null;
+                source.close();
+                observer.complete();
+            }
+            return {
+                close: closeSource,
+            };
+        },
+    };
+}
+export function encodeDefaultRealtimeRequest(url, request) {
+    url.searchParams.set("sourceId", String(request.sourceId));
+    if (request.layerId !== undefined)
+        url.searchParams.set("layerId", String(request.layerId));
+    if (request.requestId)
+        url.searchParams.set("requestId", request.requestId);
+    if (request.mode)
+        url.searchParams.set("mode", request.mode);
+    if (request.where)
+        url.searchParams.set("where", request.where);
+    if (request.fields?.length)
+        url.searchParams.set("fields", request.fields.join(","));
+    if (request.cursor ?? request.resumeFrom?.cursor)
+        url.searchParams.set("cursor", request.cursor ?? request.resumeFrom?.cursor ?? "");
+    if (request.watermark ?? request.resumeFrom?.watermark) {
+        url.searchParams.set("watermark", request.watermark ?? request.resumeFrom?.watermark ?? "");
+    }
+    if (request.timestamp ?? request.resumeFrom?.timestamp) {
+        url.searchParams.set("timestamp", request.timestamp ?? request.resumeFrom?.timestamp ?? "");
+    }
+    if (request.deltaToken ?? request.resumeFrom?.deltaToken) {
+        url.searchParams.set("deltaToken", request.deltaToken ?? request.resumeFrom?.deltaToken ?? "");
+    }
+    if (request.resumeFrom?.sequence !== undefined)
+        url.searchParams.set("sequence", String(request.resumeFrom.sequence));
+    if (request.spatialFilter !== undefined)
+        url.searchParams.set("spatialFilter", JSON.stringify(request.spatialFilter));
+    if (request.metadata !== undefined)
+        url.searchParams.set("metadata", JSON.stringify(request.metadata));
+    return url;
+}
+export function decodeRealtimeServerSentEvent(payload) {
+    if (!isRecord(payload))
+        throw new Error("Realtime SSE payload must be a JSON object.");
+    if (typeof payload.type === "string")
+        return payload;
+    if (isRecord(payload.event) && typeof payload.event.type === "string") {
+        return payload.event;
+    }
+    if (typeof payload.kind === "string") {
+        return { ...payload, type: payload.kind };
+    }
+    throw new Error("Realtime SSE payload is missing an event type.");
+}
+function createEventSource(url, options) {
+    if (options.eventSourceFactory) {
+        return options.eventSourceFactory(url, { withCredentials: options.withCredentials });
+    }
+    // The global `EventSource` is a constructor: calling it as a plain
+    // function (`EventSource(url, init)`) throws a TypeError in browsers,
+    // so the default path must construct with `new`.
+    const EventSourceCtor = globalThis.EventSource;
+    if (!EventSourceCtor)
+        throw new Error("EventSource is not available; provide eventSourceFactory for this runtime.");
+    return new EventSourceCtor(url, { withCredentials: options.withCredentials });
+}
+function resolveEventSourceUrl(input, url) {
+    if (input.startsWith("http://") || input.startsWith("https://"))
+        return url.toString();
+    return `${url.pathname}${url.search}`;
+}
+function isEventSourceClosed(source) {
+    return source.readyState === 2;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/realtime/store.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Store and transport bridge for realtime feature state.
+ *
+ * @module
+ */
+import type { RealtimeFeatureEvent, RealtimeFeatureState, RealtimeFeatureTransport, RealtimeReducerOptions, RealtimeStalenessOptions, RealtimeStateListener, RealtimeSubscriptionHandle, RealtimeSubscriptionRequest } from "./types.js";
+export interface RealtimeFeatureStore<TFeature = unknown> {
+    readonly state: RealtimeFeatureState<TFeature>;
+    apply(event: RealtimeFeatureEvent<TFeature>): RealtimeFeatureState<TFeature>;
+    checkStale(options: RealtimeStalenessOptions): RealtimeFeatureState<TFeature>;
+    subscribe(listener: RealtimeStateListener<TFeature>, options?: {
+        readonly fireImmediately?: boolean;
+    }): () => void;
+    connect(transport: RealtimeFeatureTransport<TFeature>, request: RealtimeSubscriptionRequest): RealtimeSubscriptionHandle;
+    close(): void;
+}
+export declare function createRealtimeFeatureStore<TFeature = unknown>(initialState?: RealtimeFeatureState<TFeature>, options?: RealtimeReducerOptions): RealtimeFeatureStore<TFeature>;
+//# sourceMappingURL=store.d.ts.map

package/realtime/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/realtime/store.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,qBAAqB,EACrB,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,oBAAoB,CAAC,QAAQ,GAAG,OAAO;IACtD,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAC/C,KAAK,CAAC,KAAK,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAC7E,UAAU,CAAC,OAAO,EAAE,wBAAwB,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAC9E,SAAS,CAAC,QAAQ,EAAE,qBAAqB,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,IAAI,CAAC;IACnH,OAAO,CACL,SAAS,EAAE,wBAAwB,CAAC,QAAQ,CAAC,EAC7C,OAAO,EAAE,2BAA2B,GACnC,0BAA0B,CAAC;IAC9B,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,GAAG,OAAO,EAC3D,YAAY,GAAE,oBAAoB,CAAC,QAAQ,CAAyC,EACpF,OAAO,GAAE,sBAA2B,GACnC,oBAAoB,CAAC,QAAQ,CAAC,CA2DhC"}

package/realtime/store.js

@@ -0,0 +1,63 @@
+/**
+ * Store and transport bridge for realtime feature state.
+ *
+ * @module
+ */
+import { emptyRealtimeFeatureState, reconcileRealtimeStaleness, reduceRealtimeFeatureState } from "./reducer.js";
+export function createRealtimeFeatureStore(initialState = emptyRealtimeFeatureState(), options = {}) {
+    let state = initialState;
+    let activeHandle;
+    const listeners = new Set();
+    function emit(event) {
+        for (const listener of [...listeners])
+            listener(state, event);
+    }
+    function setState(next, event) {
+        if (Object.is(state, next))
+            return state;
+        state = next;
+        emit(event);
+        return state;
+    }
+    return {
+        get state() {
+            return state;
+        },
+        apply(event) {
+            return setState(reduceRealtimeFeatureState(state, event, options), event);
+        },
+        checkStale(stalenessOptions) {
+            return setState(reconcileRealtimeStaleness(state, stalenessOptions), undefined);
+        },
+        subscribe(listener, subscribeOptions = {}) {
+            listeners.add(listener);
+            if (subscribeOptions.fireImmediately)
+                listener(state, undefined);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        connect(transport, request) {
+            activeHandle?.close();
+            this.apply({ type: "status", status: "connecting" });
+            activeHandle = transport.subscribe(request, {
+                next: (event) => this.apply(event),
+                error: (error) => this.apply({ type: "error", error }),
+                complete: () => this.apply({ type: "status", status: "closed" }),
+            });
+            return {
+                close: () => {
+                    activeHandle?.close();
+                    activeHandle = undefined;
+                    this.apply({ type: "status", status: "closed" });
+                },
+            };
+        },
+        close() {
+            activeHandle?.close();
+            activeHandle = undefined;
+            setState({ ...state, status: "closed" }, { type: "status", status: "closed" });
+            listeners.clear();
+        },
+    };
+}