openart-realtime-sdk 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Upstash, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# Realtime
+
+The easiest way to add realtime features to any Next.js project.
+
+![Project Image](public/thumbnail.png)
+
+## Features
+
+- ⏰ Setup takes 60 seconds
+- 🧨 Clean APIs & first-class TypeScript support
+- ⚡ Extremely fast, zero dependencies, 1.9kB gzipped
+- 💻 Deploy anywhere: Vercel, Netlify, etc.
+- 💎 100% type-safe with zod 4 or zod mini
+- ⏱️ Built-in message histories
+- 🔌 Automatic connection management w/ delivery guarantee
+- 🔋 Built-in middleware and authentication helpers
+- 📶 100% HTTP-based: Redis streams & SSE
+
+---
+
+## Quickstart
+
+Check out the examples in the repository to get started.

package/dist/client/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var useRealtime_js = require('./use-realtime.js');
+var provider_js = require('./provider.js');
+
+
+
+Object.keys(useRealtime_js).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return useRealtime_js[k]; }
+	});
+});
+Object.keys(provider_js).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return provider_js[k]; }
+	});
+});

package/dist/client/index.d.cts

@@ -0,0 +1,50 @@
+import { EventPayloadUnion, EventPaths, ConnectionStatus, RealtimeMessage } from '../shared/index.cjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import 'zod/v4';
+import 'zod/v4/core';
+
+interface UseRealtimeOpts<T extends Record<string, unknown>, E extends string> {
+    events?: readonly E[];
+    onData?: (arg: EventPayloadUnion<T, E>) => void;
+    channels?: readonly (string | undefined)[];
+    enabled?: boolean;
+}
+declare function useRealtime<T extends Record<string, unknown>, const E extends EventPaths<T>>(opts: UseRealtimeOpts<T, E>): {
+    status: ConnectionStatus;
+};
+
+type RealtimeContextValue = {
+    status: ConnectionStatus;
+    register: (id: string, channels: string[], cb: (msg: RealtimeMessage) => void) => void;
+    unregister: (id: string) => void;
+};
+declare const RealtimeContext: React.Context<RealtimeContextValue | null>;
+interface RealtimeProviderProps {
+    children: React.ReactNode;
+    api?: {
+        url?: string;
+        withCredentials?: boolean;
+    };
+    maxReconnectAttempts?: number;
+    /**
+     * Whether to disconnect when the window is hidden (e.g. switched tab).
+     * Defaults to true.
+     */
+    disconnectOnWindowHidden?: boolean;
+    /**
+     * Delay in ms before disconnecting when window is hidden.
+     * Useful to prevent flapping when user quickly switches tabs.
+     * Defaults to 5000ms.
+     */
+    disconnectDelay?: number;
+}
+declare function RealtimeProvider({ children, api, maxReconnectAttempts, disconnectOnWindowHidden, disconnectDelay }: RealtimeProviderProps): react_jsx_runtime.JSX.Element;
+declare function useRealtimeContext(): RealtimeContextValue;
+declare const createRealtime: <T extends Record<string, unknown>>() => {
+    useRealtime: <const E extends EventPaths<T>>(opts: UseRealtimeOpts<T, E>) => {
+        status: ConnectionStatus;
+    };
+};
+
+export { RealtimeContext, RealtimeProvider, type RealtimeProviderProps, type UseRealtimeOpts, createRealtime, useRealtime, useRealtimeContext };

package/dist/client/index.d.ts

@@ -0,0 +1,50 @@
+import { EventPayloadUnion, EventPaths, ConnectionStatus, RealtimeMessage } from '../shared/index.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import 'zod/v4';
+import 'zod/v4/core';
+
+interface UseRealtimeOpts<T extends Record<string, unknown>, E extends string> {
+    events?: readonly E[];
+    onData?: (arg: EventPayloadUnion<T, E>) => void;
+    channels?: readonly (string | undefined)[];
+    enabled?: boolean;
+}
+declare function useRealtime<T extends Record<string, unknown>, const E extends EventPaths<T>>(opts: UseRealtimeOpts<T, E>): {
+    status: ConnectionStatus;
+};
+
+type RealtimeContextValue = {
+    status: ConnectionStatus;
+    register: (id: string, channels: string[], cb: (msg: RealtimeMessage) => void) => void;
+    unregister: (id: string) => void;
+};
+declare const RealtimeContext: React.Context<RealtimeContextValue | null>;
+interface RealtimeProviderProps {
+    children: React.ReactNode;
+    api?: {
+        url?: string;
+        withCredentials?: boolean;
+    };
+    maxReconnectAttempts?: number;
+    /**
+     * Whether to disconnect when the window is hidden (e.g. switched tab).
+     * Defaults to true.
+     */
+    disconnectOnWindowHidden?: boolean;
+    /**
+     * Delay in ms before disconnecting when window is hidden.
+     * Useful to prevent flapping when user quickly switches tabs.
+     * Defaults to 5000ms.
+     */
+    disconnectDelay?: number;
+}
+declare function RealtimeProvider({ children, api, maxReconnectAttempts, disconnectOnWindowHidden, disconnectDelay }: RealtimeProviderProps): react_jsx_runtime.JSX.Element;
+declare function useRealtimeContext(): RealtimeContextValue;
+declare const createRealtime: <T extends Record<string, unknown>>() => {
+    useRealtime: <const E extends EventPaths<T>>(opts: UseRealtimeOpts<T, E>) => {
+        status: ConnectionStatus;
+    };
+};
+
+export { RealtimeContext, RealtimeProvider, type RealtimeProviderProps, type UseRealtimeOpts, createRealtime, useRealtime, useRealtimeContext };

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export * from './use-realtime.js';
+export * from './provider.js';

package/dist/server/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var handler_js = require('./handler.js');
+var realtime_js = require('./realtime.js');
+
+
+
+Object.keys(handler_js).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return handler_js[k]; }
+	});
+});
+Object.keys(realtime_js).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return realtime_js[k]; }
+	});
+});

package/dist/server/index.d.cts

@@ -0,0 +1,86 @@
+import Redis from 'ioredis';
+import * as z from 'zod/v4/core';
+import { Logger, EventPaths, EventPayloadUnion, HistoryArgs, SystemEvent, UserEvent } from '../shared/index.cjs';
+import 'zod/v4';
+
+type Schema = Record<string, z.$ZodType | Record<string, unknown>>;
+type HistoryConfig = {
+    maxLength?: number;
+    expireAfterSecs?: number;
+};
+type Opts = {
+    schema?: Schema;
+    redis?: Redis | undefined;
+    maxDurationSecs?: number;
+    verbose?: boolean;
+    logger?: Logger;
+    history?: HistoryConfig | boolean;
+};
+declare class RealtimeBase<T extends Opts> {
+    private channels;
+    private _schema;
+    private _verbose;
+    private _history;
+    constructor(data: T);
+    private createEventHandlers;
+    channel<N extends string>(channel: N, history?: HistoryConfig | boolean): RealtimeChannel<T>;
+}
+type SchemaPaths<T, Prefix extends string = ""> = {
+    [K in keyof T]: K extends string ? T[K] extends z.$ZodType ? Prefix extends "" ? K : `${Prefix}${K}` : T[K] extends object ? SchemaPaths<T[K], `${Prefix}${K}.`> : never : never;
+}[keyof T];
+type EventPath<T extends Opts> = T["schema"] extends Schema ? SchemaPaths<T["schema"]> : never;
+type SchemaValue<T, Path extends string> = Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? SchemaValue<T[First], Rest> : never : Path extends keyof T ? T[Path] : never;
+type EventData<T extends Opts, K extends string> = T["schema"] extends Schema ? SchemaValue<T["schema"], K> extends z.$ZodType ? z.infer<SchemaValue<T["schema"], K>> : never : never;
+type HistoryMessage = {
+    id: string;
+    event: string;
+    channel: string;
+    data: unknown;
+};
+type SubscribeArgs<T extends Opts, E extends EventPaths<T["schema"]>> = {
+    events: readonly E[];
+    onData: (arg: EventPayloadUnion<T["schema"], E>) => void;
+    history?: boolean | HistoryArgs;
+};
+type RealtimeChannel<T extends Opts> = {
+    subscribe: <E extends EventPaths<T["schema"]>>(args: SubscribeArgs<T, E>) => Promise<() => void>;
+    unsubscribe: () => void;
+    emit: <K extends EventPath<T>>(event: K, data: EventData<T, K>, opts?: {
+        history?: HistoryConfig | boolean;
+    }) => Promise<void>;
+    history: (params?: HistoryArgs) => Promise<HistoryMessage[]>;
+};
+type InferSchemaRecursive<T> = {
+    [K in keyof T]: T[K] extends z.$ZodType ? z.infer<T[K]> : T[K] extends object ? InferSchemaRecursive<T[K]> : never;
+};
+type InferSchema<T extends Schema> = InferSchemaRecursive<T>;
+type InferRealtimeEvents<T> = T extends Realtime<infer R> ? NonNullable<R["schema"]> : never;
+type Realtime<T extends Opts> = RealtimeBase<T> & {
+    channel: (name: string, history?: HistoryConfig | boolean) => RealtimeChannel<T>;
+} & RealtimeChannel<T>;
+declare const Realtime: new <T extends Opts>(data?: T) => Realtime<T>;
+
+declare function handle<T extends Opts>(config: {
+    realtime: Realtime<T>;
+    /**
+     * Maximum number of missed messages to retrieve from history upon reconnection.
+     * Defaults to 2000. Increase this if your application expects high message volume
+     * and needs to ensure clients catch up on all history after long disconnections.
+     * Warning: Setting this too high may cause memory issues on the server.
+     */
+    maxRecoveryLimit?: number;
+    /**
+     * Middleware to authorize the request (e.g. check session cookie, check channel permissions).
+     * Return a Response to block the request, or nothing to allow.
+     */
+    middleware?: ({ request, channels, }: {
+        request: Request;
+        channels: string[];
+    }) => Response | void | Promise<Response | void>;
+}): (request: Request) => Promise<Response | void>;
+declare function json(data: SystemEvent | UserEvent): Uint8Array<ArrayBuffer>;
+declare class StreamingResponse extends Response {
+    constructor(res: ReadableStream<Uint8Array>, init?: ResponseInit);
+}
+
+export { type EventData, type EventPath, type HistoryConfig, type HistoryMessage, type InferRealtimeEvents, type InferSchema, type Opts, Realtime, StreamingResponse, handle, json };

package/dist/server/index.d.ts

@@ -0,0 +1,86 @@
+import Redis from 'ioredis';
+import * as z from 'zod/v4/core';
+import { Logger, EventPaths, EventPayloadUnion, HistoryArgs, SystemEvent, UserEvent } from '../shared/index.js';
+import 'zod/v4';
+
+type Schema = Record<string, z.$ZodType | Record<string, unknown>>;
+type HistoryConfig = {
+    maxLength?: number;
+    expireAfterSecs?: number;
+};
+type Opts = {
+    schema?: Schema;
+    redis?: Redis | undefined;
+    maxDurationSecs?: number;
+    verbose?: boolean;
+    logger?: Logger;
+    history?: HistoryConfig | boolean;
+};
+declare class RealtimeBase<T extends Opts> {
+    private channels;
+    private _schema;
+    private _verbose;
+    private _history;
+    constructor(data: T);
+    private createEventHandlers;
+    channel<N extends string>(channel: N, history?: HistoryConfig | boolean): RealtimeChannel<T>;
+}
+type SchemaPaths<T, Prefix extends string = ""> = {
+    [K in keyof T]: K extends string ? T[K] extends z.$ZodType ? Prefix extends "" ? K : `${Prefix}${K}` : T[K] extends object ? SchemaPaths<T[K], `${Prefix}${K}.`> : never : never;
+}[keyof T];
+type EventPath<T extends Opts> = T["schema"] extends Schema ? SchemaPaths<T["schema"]> : never;
+type SchemaValue<T, Path extends string> = Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? SchemaValue<T[First], Rest> : never : Path extends keyof T ? T[Path] : never;
+type EventData<T extends Opts, K extends string> = T["schema"] extends Schema ? SchemaValue<T["schema"], K> extends z.$ZodType ? z.infer<SchemaValue<T["schema"], K>> : never : never;
+type HistoryMessage = {
+    id: string;
+    event: string;
+    channel: string;
+    data: unknown;
+};
+type SubscribeArgs<T extends Opts, E extends EventPaths<T["schema"]>> = {
+    events: readonly E[];
+    onData: (arg: EventPayloadUnion<T["schema"], E>) => void;
+    history?: boolean | HistoryArgs;
+};
+type RealtimeChannel<T extends Opts> = {
+    subscribe: <E extends EventPaths<T["schema"]>>(args: SubscribeArgs<T, E>) => Promise<() => void>;
+    unsubscribe: () => void;
+    emit: <K extends EventPath<T>>(event: K, data: EventData<T, K>, opts?: {
+        history?: HistoryConfig | boolean;
+    }) => Promise<void>;
+    history: (params?: HistoryArgs) => Promise<HistoryMessage[]>;
+};
+type InferSchemaRecursive<T> = {
+    [K in keyof T]: T[K] extends z.$ZodType ? z.infer<T[K]> : T[K] extends object ? InferSchemaRecursive<T[K]> : never;
+};
+type InferSchema<T extends Schema> = InferSchemaRecursive<T>;
+type InferRealtimeEvents<T> = T extends Realtime<infer R> ? NonNullable<R["schema"]> : never;
+type Realtime<T extends Opts> = RealtimeBase<T> & {
+    channel: (name: string, history?: HistoryConfig | boolean) => RealtimeChannel<T>;
+} & RealtimeChannel<T>;
+declare const Realtime: new <T extends Opts>(data?: T) => Realtime<T>;
+
+declare function handle<T extends Opts>(config: {
+    realtime: Realtime<T>;
+    /**
+     * Maximum number of missed messages to retrieve from history upon reconnection.
+     * Defaults to 2000. Increase this if your application expects high message volume
+     * and needs to ensure clients catch up on all history after long disconnections.
+     * Warning: Setting this too high may cause memory issues on the server.
+     */
+    maxRecoveryLimit?: number;
+    /**
+     * Middleware to authorize the request (e.g. check session cookie, check channel permissions).
+     * Return a Response to block the request, or nothing to allow.
+     */
+    middleware?: ({ request, channels, }: {
+        request: Request;
+        channels: string[];
+    }) => Response | void | Promise<Response | void>;
+}): (request: Request) => Promise<Response | void>;
+declare function json(data: SystemEvent | UserEvent): Uint8Array<ArrayBuffer>;
+declare class StreamingResponse extends Response {
+    constructor(res: ReadableStream<Uint8Array>, init?: ResponseInit);
+}
+
+export { type EventData, type EventPath, type HistoryConfig, type HistoryMessage, type InferRealtimeEvents, type InferSchema, type Opts, Realtime, StreamingResponse, handle, json };

package/dist/server/index.js

@@ -0,0 +1,2 @@
+export * from './handler.js';
+export * from './realtime.js';

package/dist/shared/index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var types = require('./types');
+
+
+
+Object.keys(types).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return types[k]; }
+	});
+});

package/dist/shared/index.d.cts

@@ -0,0 +1,64 @@
+import z from 'zod/v4';
+import z__default from 'zod/v4/core';
+
+declare const systemEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"connected">;
+    channel: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reconnect">;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"disconnected">;
+    channels: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>], "type">;
+type SystemEvent = z.infer<typeof systemEvent>;
+declare const userEvent: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodUnknown;
+    event: z.ZodString;
+    channel: z.ZodString;
+}, z.core.$strip>;
+type UserEvent = z.infer<typeof userEvent>;
+type RealtimeMessage = SystemEvent | UserEvent;
+type ConnectionStatus = "connected" | "disconnected" | "error" | "connecting";
+type EventPaths<T, Prefix extends string = "", Depth extends readonly number[] = []> = Depth["length"] extends 10 ? never : {
+    [K in keyof T & string]: T[K] extends z__default.$ZodType ? `${Prefix}${K}` : T[K] extends Record<string, unknown> ? EventPaths<T[K], `${Prefix}${K}.`, [...Depth, 0]> : `${Prefix}${K}`;
+}[keyof T & string];
+type EventData<T, K extends string, Depth extends readonly number[] = []> = Depth["length"] extends 10 ? never : K extends `${infer A}.${infer Rest}` ? A extends keyof T ? T[A] extends z__default.$ZodType ? never : EventData<T[A], Rest, [...Depth, 0]> : never : K extends keyof T ? T[K] extends z__default.$ZodType ? T[K] : never : never;
+type EventPayloadUnion<T, E extends string> = E extends unknown ? {
+    event: E;
+    data: z__default.infer<EventData<T, E>>;
+    channel: string;
+} : never;
+type HistoryArgs = {
+    limit?: number;
+    start?: number;
+    end?: number;
+};
+interface Logger {
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    debug?(message: string, ...args: unknown[]): void;
+}
+interface RealtimeConfig {
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Custom logger implementation
+     * @default console
+     */
+    logger?: Logger;
+}
+
+export { type ConnectionStatus, type EventPaths, type EventPayloadUnion, type HistoryArgs, type Logger, type RealtimeConfig, type RealtimeMessage, type SystemEvent, type UserEvent, systemEvent, userEvent };

package/dist/shared/index.d.ts

@@ -0,0 +1,64 @@
+import z from 'zod/v4';
+import z__default from 'zod/v4/core';
+
+declare const systemEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"connected">;
+    channel: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reconnect">;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"disconnected">;
+    channels: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>], "type">;
+type SystemEvent = z.infer<typeof systemEvent>;
+declare const userEvent: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodUnknown;
+    event: z.ZodString;
+    channel: z.ZodString;
+}, z.core.$strip>;
+type UserEvent = z.infer<typeof userEvent>;
+type RealtimeMessage = SystemEvent | UserEvent;
+type ConnectionStatus = "connected" | "disconnected" | "error" | "connecting";
+type EventPaths<T, Prefix extends string = "", Depth extends readonly number[] = []> = Depth["length"] extends 10 ? never : {
+    [K in keyof T & string]: T[K] extends z__default.$ZodType ? `${Prefix}${K}` : T[K] extends Record<string, unknown> ? EventPaths<T[K], `${Prefix}${K}.`, [...Depth, 0]> : `${Prefix}${K}`;
+}[keyof T & string];
+type EventData<T, K extends string, Depth extends readonly number[] = []> = Depth["length"] extends 10 ? never : K extends `${infer A}.${infer Rest}` ? A extends keyof T ? T[A] extends z__default.$ZodType ? never : EventData<T[A], Rest, [...Depth, 0]> : never : K extends keyof T ? T[K] extends z__default.$ZodType ? T[K] : never : never;
+type EventPayloadUnion<T, E extends string> = E extends unknown ? {
+    event: E;
+    data: z__default.infer<EventData<T, E>>;
+    channel: string;
+} : never;
+type HistoryArgs = {
+    limit?: number;
+    start?: number;
+    end?: number;
+};
+interface Logger {
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    debug?(message: string, ...args: unknown[]): void;
+}
+interface RealtimeConfig {
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Custom logger implementation
+     * @default console
+     */
+    logger?: Logger;
+}
+
+export { type ConnectionStatus, type EventPaths, type EventPayloadUnion, type HistoryArgs, type Logger, type RealtimeConfig, type RealtimeMessage, type SystemEvent, type UserEvent, systemEvent, userEvent };

package/dist/shared/index.js

@@ -0,0 +1 @@
+export * from './types';

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "openart-realtime-sdk",
+  "version": "1.0.1",
+  "author": "OpenArt",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hui200102/realtime.git"
+  },
+  "main": "dist/server/index.js",
+  "module": "dist/server/index.js",
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "@types/react": "^19.1.16",
+    "@types/react-dom": "^19.1.9",
+    "@types/ioredis-mock": "^8.2.5",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2",
+    "vitest": "^2.1.8",
+    "tsx": "^4.7.0",
+    "@testing-library/react": "^16.1.0",
+    "@testing-library/dom": "^10.4.0",
+    "jsdom": "^25.0.1",
+    "ioredis-mock": "^8.9.0",
+    "zod": "^4.1.11"
+  },
+  "peerDependencies": {
+    "ioredis": "^5.4.0",
+    "zod": "^3.25.0 || ^4.0.0",
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/server/index.d.ts",
+        "default": "./dist/server/index.js"
+      },
+      "require": {
+        "types": "./dist/server/index.d.ts",
+        "default": "./dist/server/index.js"
+      }
+    },
+    "./client": {
+      "import": {
+        "types": "./dist/client/index.d.ts",
+        "default": "./dist/client/index.js"
+      },
+      "require": {
+        "types": "./dist/client/index.d.ts",
+        "default": "./dist/client/index.js"
+      }
+    }
+  },
+  "access": "public",
+  "description": "An HTTP-based realtime client powered by Redis Streams.",
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/realtime-framework/realtime",
+  "keywords": [
+    "realtime",
+    "serverless"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
+    "lint": "tsc",
+    "test": "vitest",
+    "benchmark": "tsx benchmark/stress.ts",
+    "release": "npm publish --access public && git push --follow-tags"
+  },
+  "type": "module",
+  "types": "dist/server/index.d.ts"
+}