@arkstack/realtime 0.16.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Toneflix Technologies Limited
+
+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,158 @@
+# @arkstack/realtime
+
+[![@arkstack/realtime](https://img.shields.io/npm/dt/@arkstack/realtime?style=flat-square&label=@arkstack/realtime&link=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2F@arkstack/realtime)](https://www.npmjs.com/package/@arkstack/realtime)
+
+The client for consuming [Arkstack](https://arkstack.toneflix.net) realtime notifications. A framework-agnostic core plus React and Vue bindings, backed by [Pusher](https://pusher.com/channels) or [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging).
+
+Pairs with the `realtime` notification driver in [`@arkstack/notifications`](https://www.npmjs.com/package/@arkstack/notifications), which broadcasts a per-user channel (`user.<id>`) that this client subscribes to.
+
+## Install
+
+```sh
+pnpm add @arkstack/realtime
+```
+
+Then install the client SDK for your transport (both are optional peer dependencies — install only the one you use):
+
+```sh
+pnpm add pusher-js   # Pusher transport
+pnpm add firebase    # Firebase transport
+```
+
+## Usage
+
+Create a client and subscribe to a user's channel. `subscribe`/`forUser` resolve to an unsubscribe function.
+
+```ts
+import { createRealtime } from '@arkstack/realtime';
+
+const realtime = createRealtime({
+  transport: 'pusher',
+  pusher: {
+    key: import.meta.env.VITE_PUSHER_KEY,
+    cluster: 'mt1',
+    authEndpoint: '/broadcasting/auth',
+  },
+});
+
+const unsubscribe = await realtime.forUser(user.id, (notification) => {
+  console.log(notification.title, notification.description);
+});
+
+// later
+unsubscribe();
+await realtime.disconnect();
+```
+
+Each `notification` matches the payload broadcast by the server:
+
+```ts
+interface RealtimeNotification {
+  id: string;
+  type: string | null;
+  title: string;
+  description: string;
+  actionText?: string | null;
+  actionLink?: string | null;
+  meta?: Record<string, unknown> | null;
+  read_at: string | null;
+  created_at: string;
+}
+```
+
+## React
+
+```tsx
+import { useNotifications } from '@arkstack/realtime/react';
+
+function Bell({ realtime, userId }) {
+  const { notifications, latest, clear } = useNotifications(
+    realtime,
+    realtime.channelFor(userId),
+    { limit: 20 },
+  );
+
+  return (
+    <span onClick={clear}>
+      {notifications.length} · {latest?.title}
+    </span>
+  );
+}
+```
+
+The hook accumulates notifications (newest first), caps them at `limit`, and unsubscribes automatically on unmount or when `client`/`channel` change.
+
+## Vue
+
+```vue
+<script setup>
+import { useNotifications } from '@arkstack/realtime/vue';
+
+const props = defineProps(['realtime', 'userId']);
+const { notifications, latest, clear } = useNotifications(
+  props.realtime,
+  props.realtime.channelFor(props.userId),
+  { limit: 20 },
+);
+</script>
+
+<template>
+  <span @click="clear">{{ notifications.length }} · {{ latest?.title }}</span>
+</template>
+```
+
+The composable unsubscribes automatically when the component's scope is disposed.
+
+## Firebase
+
+Firebase Cloud Messaging delivers to the device (via `onMessage`), so notifications are matched by event name rather than channel:
+
+```ts
+const realtime = createRealtime({
+  transport: 'firebase',
+  firebase: {
+    apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
+    projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
+    appId: import.meta.env.VITE_FIREBASE_APP_ID,
+    messagingSenderId: import.meta.env.VITE_FIREBASE_SENDER_ID,
+  },
+});
+```
+
+## Custom transport
+
+Provide `transportFactory` to bridge any backend (a raw WebSocket, SSE, a test double, …):
+
+```ts
+import { createRealtime, type RealtimeTransport } from '@arkstack/realtime';
+
+const transport: RealtimeTransport = {
+  subscribe(channel, event, handler) {
+    const socket = new WebSocket(`wss://example.test/${channel}`);
+    socket.addEventListener('message', (e) => {
+      const { event: name, payload } = JSON.parse(e.data);
+      if (name === event) handler(payload);
+    });
+
+    return { channel, unsubscribe: () => socket.close() };
+  },
+  disconnect() {},
+};
+
+const realtime = createRealtime({ transportFactory: () => transport });
+```
+
+## API
+
+- `createRealtime(config)` — create a `RealtimeClient`. Config: `transport` (`'pusher'` | `'firebase'`), `event` (default `notification`), `channelPrefix` (default `user.`), `pusher`/`firebase` credentials, or a custom `transportFactory`.
+- `client.subscribe(channel, handler)` / `client.forUser(userId, handler)` — subscribe; returns an unsubscribe function.
+- `client.channelFor(userId)` — the per-user channel name.
+- `client.disconnect()` — tear down the transport connection.
+- `@arkstack/realtime/react` — `useNotifications(client, channel, { limit? })` → `{ notifications, latest, clear }`.
+- `@arkstack/realtime/vue` — `useNotifications(client, channel, { limit? })` → `{ notifications, latest, clear, stop }`.
+
+See the [notifications guide](https://arkstack.toneflix.net/guide/notifications) for the server side.
+
+## License
+
+MIT

package/dist/RealtimeClient-D6-kesaz.d.ts

@@ -0,0 +1,101 @@
+//#region src/types.d.ts
+/**
+ * The notification payload delivered to realtime clients. Mirrors the server
+ * `RealtimeNotificationPayload` in `@arkstack/notifications` (kept local so the
+ * client has no server dependency).
+ */
+interface RealtimeNotification {
+  id: string;
+  type: string | null;
+  title: string;
+  description: string;
+  actionText?: string | null;
+  actionLink?: string | null;
+  meta?: Record<string, unknown> | null;
+  read_at: string | null;
+  created_at: string;
+}
+type RealtimeTransportName = 'pusher' | 'firebase';
+type NotificationHandler = (notification: RealtimeNotification) => void;
+/** A live subscription to one channel; call `unsubscribe()` to stop listening. */
+interface RealtimeSubscription {
+  channel: string;
+  unsubscribe(): void;
+}
+/**
+ * A transport binds a `(channel, event)` to a handler and tears the binding down
+ * on `unsubscribe`. Implemented by the built-in Pusher/Firebase transports, or
+ * supplied via {@link RealtimeConfig.transportFactory} for custom backends/tests.
+ */
+interface RealtimeTransport {
+  subscribe(channel: string, event: string, handler: NotificationHandler): RealtimeSubscription | Promise<RealtimeSubscription>;
+  disconnect(): void | Promise<void>;
+}
+interface PusherClientConfig {
+  key: string;
+  cluster?: string;
+  /** Endpoint that authorizes private/presence channels. */
+  authEndpoint?: string;
+  auth?: {
+    headers?: Record<string, string>;
+    params?: Record<string, string>;
+  };
+  forceTLS?: boolean;
+}
+interface FirebaseClientConfig {
+  apiKey: string;
+  projectId: string;
+  appId: string;
+  messagingSenderId: string;
+  /** Web push VAPID key used when requesting a messaging token. */
+  vapidKey?: string;
+}
+interface RealtimeConfig {
+  transport?: RealtimeTransportName;
+  /** Event name broadcasts are published under (default `notification`). */
+  event?: string;
+  /** Prefix for the per-user channel (default `user.`), used by `forUser()`. */
+  channelPrefix?: string;
+  pusher?: PusherClientConfig;
+  firebase?: FirebaseClientConfig;
+  /** Inject a transport directly — bypasses the built-ins (tests, custom backends). */
+  transportFactory?: () => RealtimeTransport | Promise<RealtimeTransport>;
+}
+//#endregion
+//#region src/RealtimeClient.d.ts
+/**
+ * Consumes Arkstack realtime notifications. Resolves a transport (Pusher,
+ * Firebase, or an injected one) lazily on first subscribe, and exposes a small
+ * channel-oriented API used directly or by the React/Vue bindings.
+ */
+declare class RealtimeClient {
+  private config;
+  private transportPromise?;
+  private readonly event;
+  private readonly channelPrefix;
+  constructor(config?: RealtimeConfig);
+  /** The channel name a given user's notifications are broadcast on. */
+  channelFor(userId: string | number): string;
+  private transport;
+  private resolveTransport;
+  /**
+   * Subscribe to a channel. Returns a function that unsubscribes.
+   *
+   * @param channel  The channel name (e.g. `user.7`).
+   * @param handler  Called with each incoming notification.
+   */
+  subscribe(channel: string, handler: NotificationHandler): Promise<() => void>;
+  /**
+   * Subscribe to a user's channel (`{channelPrefix}{userId}`).
+   *
+   * @param userId   The user id.
+   * @param handler  Called with each incoming notification.
+   */
+  forUser(userId: string | number, handler: NotificationHandler): Promise<() => void>;
+  /** Tear down the underlying transport connection. */
+  disconnect(): Promise<void>;
+}
+/** Create a {@link RealtimeClient}. */
+declare const createRealtime: (config?: RealtimeConfig) => RealtimeClient;
+//#endregion
+export { PusherClientConfig as a, RealtimeSubscription as c, NotificationHandler as i, RealtimeTransport as l, createRealtime as n, RealtimeConfig as o, FirebaseClientConfig as r, RealtimeNotification as s, RealtimeClient as t, RealtimeTransportName as u };

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { a as PusherClientConfig, c as RealtimeSubscription, i as NotificationHandler, l as RealtimeTransport, n as createRealtime, o as RealtimeConfig, r as FirebaseClientConfig, s as RealtimeNotification, t as RealtimeClient, u as RealtimeTransportName } from "./RealtimeClient-D6-kesaz.js";
+
+//#region src/transports/pusher.d.ts
+/**
+ * Realtime transport backed by [pusher-js](https://github.com/pusher/pusher-js).
+ * The SDK is an optional peer dependency imported lazily, so consumers only pull
+ * it in when they use the Pusher transport.
+ */
+declare const createPusherTransport: (config: PusherClientConfig) => Promise<RealtimeTransport>;
+//#endregion
+//#region src/transports/firebase.d.ts
+/**
+ * Realtime transport backed by [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging/js/receive)
+ * foreground messages. `firebase` is an optional peer dependency imported lazily.
+ *
+ * FCM delivers to the device (not per-channel), so the channel is informational;
+ * messages are matched by `event` and the JSON-encoded payload is parsed back.
+ */
+declare const createFirebaseTransport: (config: FirebaseClientConfig) => Promise<RealtimeTransport>;
+//#endregion
+export { type FirebaseClientConfig, type NotificationHandler, type PusherClientConfig, RealtimeClient, type RealtimeConfig, type RealtimeNotification, type RealtimeSubscription, type RealtimeTransport, type RealtimeTransportName, createFirebaseTransport, createPusherTransport, createRealtime };

package/dist/index.js

@@ -0,0 +1,150 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/RealtimeClient.ts
+/**
+* Consumes Arkstack realtime notifications. Resolves a transport (Pusher,
+* Firebase, or an injected one) lazily on first subscribe, and exposes a small
+* channel-oriented API used directly or by the React/Vue bindings.
+*/
+var RealtimeClient = class {
+	config;
+	transportPromise;
+	event;
+	channelPrefix;
+	constructor(config = {}) {
+		this.config = config;
+		this.event = config.event ?? "notification";
+		this.channelPrefix = config.channelPrefix ?? "user.";
+	}
+	/** The channel name a given user's notifications are broadcast on. */
+	channelFor(userId) {
+		return `${this.channelPrefix}${userId}`;
+	}
+	transport() {
+		this.transportPromise ??= this.resolveTransport();
+		return this.transportPromise;
+	}
+	async resolveTransport() {
+		if (this.config.transportFactory) return await this.config.transportFactory();
+		if (this.config.transport === "firebase") {
+			if (!this.config.firebase) throw new Error("Realtime: `firebase` config is required for the Firebase transport");
+			const { createFirebaseTransport } = await Promise.resolve().then(() => firebase_exports);
+			return await createFirebaseTransport(this.config.firebase);
+		}
+		if (!this.config.pusher) throw new Error("Realtime: `pusher` config is required for the Pusher transport");
+		const { createPusherTransport } = await Promise.resolve().then(() => pusher_exports);
+		return await createPusherTransport(this.config.pusher);
+	}
+	/**
+	* Subscribe to a channel. Returns a function that unsubscribes.
+	*
+	* @param channel  The channel name (e.g. `user.7`).
+	* @param handler  Called with each incoming notification.
+	*/
+	async subscribe(channel, handler) {
+		const subscription = await (await this.transport()).subscribe(channel, this.event, handler);
+		return () => subscription.unsubscribe();
+	}
+	/**
+	* Subscribe to a user's channel (`{channelPrefix}{userId}`).
+	*
+	* @param userId   The user id.
+	* @param handler  Called with each incoming notification.
+	*/
+	async forUser(userId, handler) {
+		return await this.subscribe(this.channelFor(userId), handler);
+	}
+	/** Tear down the underlying transport connection. */
+	async disconnect() {
+		if (!this.transportPromise) return;
+		await (await this.transportPromise).disconnect();
+		this.transportPromise = void 0;
+	}
+};
+/** Create a {@link RealtimeClient}. */
+const createRealtime = (config = {}) => new RealtimeClient(config);
+//#endregion
+//#region src/transports/pusher.ts
+var pusher_exports = /* @__PURE__ */ __exportAll({ createPusherTransport: () => createPusherTransport });
+/**
+* Realtime transport backed by [pusher-js](https://github.com/pusher/pusher-js).
+* The SDK is an optional peer dependency imported lazily, so consumers only pull
+* it in when they use the Pusher transport.
+*/
+const createPusherTransport = async (config) => {
+	const mod = await import("pusher-js").catch(() => {
+		throw new Error("The \"pusher-js\" package is required for the Pusher transport. Install it with `npm i pusher-js`.");
+	});
+	const client = new (mod.default ?? mod)(config.key, {
+		cluster: config.cluster ?? "mt1",
+		forceTLS: config.forceTLS ?? true,
+		authEndpoint: config.authEndpoint,
+		auth: config.auth
+	});
+	return {
+		subscribe(channel, event, handler) {
+			const subscription = client.subscribe(channel);
+			const listener = (data) => handler(data);
+			subscription.bind(event, listener);
+			return {
+				channel,
+				unsubscribe() {
+					subscription.unbind(event, listener);
+					client.unsubscribe(channel);
+				}
+			};
+		},
+		disconnect() {
+			client.disconnect();
+		}
+	};
+};
+//#endregion
+//#region src/transports/firebase.ts
+var firebase_exports = /* @__PURE__ */ __exportAll({ createFirebaseTransport: () => createFirebaseTransport });
+/**
+* Realtime transport backed by [Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging/js/receive)
+* foreground messages. `firebase` is an optional peer dependency imported lazily.
+*
+* FCM delivers to the device (not per-channel), so the channel is informational;
+* messages are matched by `event` and the JSON-encoded payload is parsed back.
+*/
+const createFirebaseTransport = async (config) => {
+	const [appMod, messagingMod] = await Promise.all([import("firebase/app"), import("firebase/messaging")]).catch(() => {
+		throw new Error("The \"firebase\" package is required for the Firebase transport. Install it with `npm i firebase`.");
+	});
+	const app = appMod.initializeApp({
+		apiKey: config.apiKey,
+		projectId: config.projectId,
+		appId: config.appId,
+		messagingSenderId: config.messagingSenderId
+	});
+	const messaging = messagingMod.getMessaging(app);
+	const onMessage = messagingMod.onMessage;
+	return {
+		subscribe(channel, event, handler) {
+			return {
+				channel,
+				unsubscribe: onMessage(messaging, (payload) => {
+					if (payload.data?.event !== event || !payload.data.payload) return;
+					try {
+						handler(JSON.parse(payload.data.payload));
+					} catch {}
+				})
+			};
+		},
+		disconnect() {}
+	};
+};
+//#endregion
+export { RealtimeClient, createFirebaseTransport, createPusherTransport, createRealtime };

package/dist/react/index.d.ts

@@ -0,0 +1,24 @@
+import { s as RealtimeNotification, t as RealtimeClient } from "../RealtimeClient-D6-kesaz.js";
+
+//#region src/react/index.d.ts
+interface UseNotificationsOptions {
+  /** Cap the number of retained notifications (newest kept). Default: unbounded. */
+  limit?: number;
+}
+interface UseNotificationsResult {
+  notifications: RealtimeNotification[];
+  latest: RealtimeNotification | null;
+  clear: () => void;
+}
+/**
+ * Subscribe a React component to a realtime channel, accumulating incoming
+ * notifications (newest first) into state. Automatically unsubscribes on unmount
+ * or when `client`/`channel` change.
+ *
+ * @param client   A {@link RealtimeClient} (from `createRealtime`).
+ * @param channel  The channel to subscribe to, e.g. `client.channelFor(user.id)`.
+ * @param options  `limit` caps how many notifications are retained.
+ */
+declare function useNotifications(client: RealtimeClient, channel: string, options?: UseNotificationsOptions): UseNotificationsResult;
+//#endregion
+export { UseNotificationsOptions, UseNotificationsResult, useNotifications };

package/dist/react/index.js

@@ -0,0 +1,43 @@
+import { useCallback, useEffect, useState } from "react";
+//#region src/react/index.ts
+/**
+* Subscribe a React component to a realtime channel, accumulating incoming
+* notifications (newest first) into state. Automatically unsubscribes on unmount
+* or when `client`/`channel` change.
+*
+* @param client   A {@link RealtimeClient} (from `createRealtime`).
+* @param channel  The channel to subscribe to, e.g. `client.channelFor(user.id)`.
+* @param options  `limit` caps how many notifications are retained.
+*/
+function useNotifications(client, channel, options = {}) {
+	const [notifications, setNotifications] = useState([]);
+	const { limit } = options;
+	useEffect(() => {
+		let unsubscribe;
+		let cancelled = false;
+		const push = (notification) => setNotifications((prev) => {
+			const next = [notification, ...prev];
+			return limit ? next.slice(0, limit) : next;
+		});
+		client.subscribe(channel, push).then((off) => {
+			if (cancelled) off();
+			else unsubscribe = off;
+		}).catch(() => {		/** surfaced by the caller's own error handling */});
+		return () => {
+			cancelled = true;
+			unsubscribe?.();
+		};
+	}, [
+		client,
+		channel,
+		limit
+	]);
+	const clear = useCallback(() => setNotifications([]), []);
+	return {
+		notifications,
+		latest: notifications[0] ?? null,
+		clear
+	};
+}
+//#endregion
+export { useNotifications };

package/dist/vue/index.d.ts

@@ -0,0 +1,26 @@
+import { s as RealtimeNotification, t as RealtimeClient } from "../RealtimeClient-D6-kesaz.js";
+import { ComputedRef, Ref } from "vue";
+
+//#region src/vue/index.d.ts
+interface UseNotificationsOptions {
+  /** Cap the number of retained notifications (newest kept). Default: unbounded. */
+  limit?: number;
+}
+interface UseNotificationsResult {
+  notifications: Ref<RealtimeNotification[]>;
+  latest: ComputedRef<RealtimeNotification | null>;
+  clear: () => void;
+  stop: () => void;
+}
+/**
+ * Subscribe the current Vue scope to a realtime channel, accumulating incoming
+ * notifications (newest first) into a ref. Automatically unsubscribes when the
+ * scope is disposed (component unmount).
+ *
+ * @param client   A {@link RealtimeClient} (from `createRealtime`).
+ * @param channel  The channel to subscribe to, e.g. `client.channelFor(user.id)`.
+ * @param options  `limit` caps how many notifications are retained.
+ */
+declare function useNotifications(client: RealtimeClient, channel: string, options?: UseNotificationsOptions): UseNotificationsResult;
+//#endregion
+export { UseNotificationsOptions, UseNotificationsResult, useNotifications };

package/dist/vue/index.js

@@ -0,0 +1,41 @@
+import { computed, onScopeDispose, ref } from "vue";
+//#region src/vue/index.ts
+/**
+* Subscribe the current Vue scope to a realtime channel, accumulating incoming
+* notifications (newest first) into a ref. Automatically unsubscribes when the
+* scope is disposed (component unmount).
+*
+* @param client   A {@link RealtimeClient} (from `createRealtime`).
+* @param channel  The channel to subscribe to, e.g. `client.channelFor(user.id)`.
+* @param options  `limit` caps how many notifications are retained.
+*/
+function useNotifications(client, channel, options = {}) {
+	const notifications = ref([]);
+	const { limit } = options;
+	let unsubscribe;
+	let cancelled = false;
+	const push = (notification) => {
+		const next = [notification, ...notifications.value];
+		notifications.value = limit ? next.slice(0, limit) : next;
+	};
+	client.subscribe(channel, push).then((off) => {
+		if (cancelled) off();
+		else unsubscribe = off;
+	}).catch(() => {	/** surfaced by the caller's own error handling */});
+	const stop = () => {
+		cancelled = true;
+		unsubscribe?.();
+		unsubscribe = void 0;
+	};
+	onScopeDispose(stop);
+	return {
+		notifications,
+		latest: computed(() => notifications.value[0] ?? null),
+		clear: () => {
+			notifications.value = [];
+		},
+		stop
+	};
+}
+//#endregion
+export { useNotifications };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@arkstack/realtime",
+  "version": "0.16.7",
+  "type": "module",
+  "description": "Client for consuming Arkstack realtime notifications (Pusher/Firebase), with framework-agnostic core plus React and Vue bindings.",
+  "homepage": "https://arkstack.toneflix.net/guide/notifications",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arkstack-hq/arkstack.git",
+    "directory": "packages/realtime"
+  },
+  "keywords": [
+    "realtime",
+    "notifications",
+    "pusher",
+    "firebase",
+    "websocket",
+    "react",
+    "vue",
+    "arkstack"
+  ],
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./react": "./dist/react/index.js",
+    "./vue": "./dist/vue/index.js",
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "pusher-js": "^8.4.0",
+    "firebase": "^11.0.0",
+    "react": ">=18",
+    "vue": "^3.4.0"
+  },
+  "peerDependenciesMeta": {
+    "pusher-js": {
+      "optional": true
+    },
+    "firebase": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.3",
+    "react": "^19.2.3",
+    "vue": "^3.5.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest",
+    "version:patch": "pnpm version patch"
+  }
+}