relay-state 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leo Mendez
+
+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,359 @@
+# relay-state
+
+> Shared state for micro frontends, designed for React. Client-side only.
+
+[![CI](https://github.com/leomendez/relay-state/actions/workflows/ci.yml/badge.svg)](https://github.com/leomendez/relay-state/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/relay-state)](https://www.npmjs.com/package/relay-state)
+[![license](https://img.shields.io/github/license/leomendez/relay-state)](LICENSE)
+
+## The Problem
+
+In micro frontend architectures like [single-spa](https://single-spa.js.org/), independently deployed sub-applications share a single browser window but have no built-in way to share state. When App A updates a user's profile, App B has no idea it happened.
+
+Common workarounds -- module federation, custom event buses cobbled together per team, or dumping state into `localStorage` -- are either heavyweight, fragile, or require framework coupling.
+
+**relay-state** solves this with a minimal approach: an **in-memory cache** backed by **window `CustomEvent` dispatch**. Any micro frontend on the page can read, write, and subscribe to shared state. The library is designed for React -- the subscription API plugs directly into `useSyncExternalStore` and a first-class `useRelayState` hook is included. The core event mechanism is framework-agnostic in principle, but React is the primary target and the only officially supported integration.
+
+## Install
+
+```bash
+# pnpm
+pnpm add relay-state
+
+# npm
+npm install relay-state
+
+# Vite+
+vp add relay-state
+```
+
+## Quick Start
+
+```tsx
+import { useRelayState, useRelayStateValue, useSetRelayState } from "relay-state/react";
+
+// Tuple API — like useState, but shared across micro frontends
+function Counter() {
+  const [count, setCount] = useRelayState<number>("count", 0);
+  return <button onClick={() => setCount((n) => (n ?? 0) + 1)}>Count: {count}</button>;
+}
+
+// Read-only — re-renders on changes, no setter
+function UserBadge() {
+  const user = useRelayStateValue<{ name: string; role: string }>("user");
+  if (!user) return null;
+  return (
+    <span>
+      {user.name} ({user.role})
+    </span>
+  );
+}
+
+// Write-only — does NOT re-render when state changes
+function PromoteButton() {
+  const setUser = useSetRelayState<{ name: string; role: string }>("user");
+  return <button onClick={() => setUser((u) => ({ ...u, role: "admin" }))}>Promote</button>;
+}
+```
+
+## API
+
+### `get<T>(key: string): T | undefined`
+
+Returns the current value for a key, or `undefined` if the key has not been set.
+
+```ts
+const count = get<number>("count"); // number | undefined
+```
+
+### `has(key: string): boolean`
+
+Returns `true` if the key exists in the store, even if its value is `undefined`. Useful for distinguishing between "key was set to `undefined`" and "key was never set."
+
+```ts
+set("key", undefined);
+has("key"); // true
+has("other"); // false
+```
+
+### `set<T>(key: string, value: T | ((prev: T | undefined) => T)): void`
+
+Sets a value in the store and dispatches a `CustomEvent` on `window` to notify all subscribers. Accepts either a direct value or an updater function.
+
+```ts
+// Direct value
+set("count", 0);
+
+// Updater function (receives the previous value)
+set<number>("count", (prev) => (prev ?? 0) + 1);
+```
+
+> **Note:** Because updater functions are detected via `typeof value === "function"`, storing a function as a value requires wrapping it: `set("callback", () => myFunction)`. This is the same tradeoff React's `useState` makes.
+
+### `subscribe<T>(key: string, callback: (value: T | undefined) => void): () => void`
+
+Subscribes to changes for a specific key. The callback fires whenever `set` or `del` is called for that key, including updates originating from other micro frontend bundles. Returns an unsubscribe function.
+
+```ts
+const unsubscribe = subscribe<number>("count", (value) => {
+  console.log("Count is now:", value);
+});
+
+// Stop listening
+unsubscribe();
+```
+
+This signature is designed to work directly with React's [`useSyncExternalStore`](https://react.dev/reference/react/useSyncExternalStore).
+
+### `del(key: string): void`
+
+Deletes a key from the store and notifies subscribers with `undefined`.
+
+```ts
+del("count");
+```
+
+### `clear(): void`
+
+Removes all keys from the store and notifies all active subscribers with `undefined`. Use this for logout flows or full application resets.
+
+```ts
+clear();
+```
+
+### `createStore(namespace: string): RelayStore`
+
+Creates a namespaced store. All keys are internally prefixed with `namespace:`, preventing collisions between micro frontends while sharing the same underlying cache and event bus.
+
+```ts
+import { createStore } from "relay-state";
+
+// In App A
+const appA = createStore("appA");
+appA.set("user", { name: "Leo" });
+appA.get("user"); // { name: "Leo" }
+
+// In App B
+const appB = createStore("appB");
+appB.set("user", { name: "Maria" });
+appB.get("user"); // { name: "Maria" }
+
+// No collision -- these are stored as "appA:user" and "appB:user"
+```
+
+A namespaced store returns an object with `get`, `has`, `set`, `subscribe`, `del`, and `clear` -- the same API as the global functions, scoped to the namespace.
+
+### `RelayStore` (type)
+
+The interface returned by `createStore`:
+
+```ts
+interface RelayStore {
+  get: <T = unknown>(key: string) => T | undefined;
+  has: (key: string) => boolean;
+  set: <T = unknown>(key: string, value: T | ((prev: T | undefined) => T)) => void;
+  subscribe: <T = unknown>(key: string, callback: (value: T | undefined) => void) => () => void;
+  del: (key: string) => void;
+  clear: () => void;
+}
+```
+
+## React Integration
+
+A React hook is available via the `relay-state/react` entrypoint. It uses [`useSyncExternalStore`](https://react.dev/reference/react/useSyncExternalStore) under the hood, so your components re-render automatically when shared state changes.
+
+React 18+ is a peer dependency.
+
+> **Note:** relay-state is client-side only. It requires `window` at runtime and is not designed for server-side rendering.
+
+### `useRelayState<T>(key, initialValue?) → [value, setter]`
+
+The primary hook. Returns a tuple of the current value and a setter — the same pattern as React's `useState`.
+
+```tsx
+import { useRelayState } from "relay-state/react";
+
+function Counter() {
+  const [count, setCount] = useRelayState<number>("count", 0);
+  return <button onClick={() => setCount((prev) => (prev ?? 0) + 1)}>Count: {count}</button>;
+}
+```
+
+The setter accepts either a direct value or an updater function:
+
+```ts
+setCount(10);
+setCount((prev) => (prev ?? 0) + 1);
+```
+
+When `initialValue` is provided and the key is currently unset, the value is written to the store on first mount so all consumers see the same default — regardless of which micro frontend mounts first.
+
+### `useRelayStateValue<T>(key, initialValue?) → value`
+
+Subscribes to a key and returns only the current value. Use this when a component needs to read state but never write it.
+
+```tsx
+import { useRelayStateValue } from "relay-state/react";
+
+function UserBadge() {
+  const user = useRelayStateValue<{ name: string }>("user");
+  if (!user) return null;
+  return <span>{user.name}</span>;
+}
+```
+
+### `useSetRelayState<T>(key) → setter`
+
+Returns a stable setter function without subscribing to state changes. Components using only this hook will **not re-render** when the value changes — the key performance primitive for write-only components.
+
+```tsx
+import { useSetRelayState } from "relay-state/react";
+
+function PromoteButton() {
+  const setUser = useSetRelayState<{ name: string; role: string }>("user");
+  return (
+    <button onClick={() => setUser((prev) => ({ ...prev, role: "admin" }))}>
+      Promote to Admin
+    </button>
+  );
+}
+```
+
+The `relay-state/react` entrypoint also re-exports all core functions (`get`, `has`, `set`, `del`, `subscribe`, `createStore`, `clear`) and the `RelayStore` type for convenience.
+
+## Best Practices
+
+### Centralize keys as constants
+
+String keys are the contract between micro frontends. A typo in one app silently breaks the connection with another. Keep all shared keys in a single file, published as a shared package or committed to a common location all apps can import from.
+
+```ts
+// packages/shared-keys/index.ts
+export const KEYS = {
+  user: "user",
+  cart: "cart",
+  featureFlags: "feature-flags",
+} as const;
+```
+
+Then import them wherever you use relay-state:
+
+```tsx
+import { KEYS } from "@myorg/shared-keys";
+import { useRelayState, useRelayStateValue } from "relay-state/react";
+
+function Counter() {
+  const [user, setUser] = useRelayState(KEYS.user);
+  // ...
+}
+```
+
+This gives you a single source of truth for the key namespace, makes refactoring safe (rename in one place), and makes it easy to see at a glance what state is shared across your application.
+
+If you are using `createStore` for namespaced stores, the same principle applies -- centralize both the namespace string and the key names:
+
+```ts
+// packages/shared-keys/index.ts
+export const STORES = {
+  appA: "appA",
+  appB: "appB",
+} as const;
+
+export const APP_A_KEYS = {
+  user: "user",
+  settings: "settings",
+} as const;
+```
+
+## How It Works
+
+1. State is stored in an in-memory `Map` -- fast reads and writes with zero serialization overhead.
+2. Every `set` and `del` call dispatches a [`CustomEvent`](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent) on `window` with the event name `relay-state:{key}`.
+3. `subscribe` listens for these events using `window.addEventListener`. When an event arrives, it updates the local cache before calling the callback -- so `get()` always reflects the latest value, even if the event originated from a different bundle.
+4. `useRelayState` wires `subscribe` and `get` into React's `useSyncExternalStore`, so components re-render automatically.
+
+Because events go through `window`, the underlying mechanism is framework-agnostic -- any script on the same page can listen. However, relay-state is designed and tested for React. Use in other frameworks is theoretically possible but unsupported.
+
+## Deploying Across Micro Frontends
+
+relay-state works with independently bundled micro frontends — each app can include its own copy of the library. Updates propagate via `window` CustomEvents, and each bundle's local cache stays in sync when it receives an event.
+
+### single-spa
+
+Each micro frontend installs relay-state as a normal dependency. No special configuration is required:
+
+```bash
+# pnpm
+pnpm add relay-state
+
+# npm
+npm install relay-state
+
+# Vite+
+vp add relay-state
+```
+
+State written by one app is broadcast via `window` events and received by all other apps that have subscribed to the same key, regardless of which bundle they loaded relay-state from.
+
+**Optional: share a single instance via import maps**
+
+If you want all micro frontends to share one bundle of relay-state (slightly more efficient, one fewer module to download), you can register it as a shared dependency in your import map:
+
+```json
+{
+  "imports": {
+    "relay-state": "https://cdn.example.com/relay-state@0.1.0/index.mjs",
+    "relay-state/react": "https://cdn.example.com/relay-state@0.1.0/react.mjs"
+  }
+}
+```
+
+Then each micro frontend imports relay-state normally -- the browser resolves it to the shared CDN bundle instead of a local copy. With a shared instance, all apps also share the in-memory cache directly (not just via events), which eliminates any edge cases where a consumer reads `get()` before subscribing.
+
+## Future Ideas
+
+These features are planned but not yet implemented:
+
+**Atom-level defaults.** Today, `initialValue` is set per hook call. A future API would let you define the key, type, and default value together as an atom -- similar to Jotai -- so the default is co-located with the key definition and shared across all consumers automatically:
+
+```ts
+// future API (not yet implemented)
+const countAtom = atom<number>("count", 0);
+
+function Counter() {
+  const [count, setCount] = useRelayState(countAtom);
+  // count is always number, never undefined
+}
+```
+
+**Typed store.** A `createTypedStore` API that encodes the full key-to-type map at the store level, giving compile-time safety without a separate constants file:
+
+```ts
+// future API (not yet implemented)
+const store = createTypedStore<{
+  user: { name: string; role: string };
+  count: number;
+}>("appA");
+
+store.set("user", { name: "Leo", role: "admin" }); // fully typed
+store.set("typo", 1); // TypeScript error
+```
+
+## Not the Right Fit?
+
+relay-state is purpose-built for **cross-micro-frontend state sharing** in React-based architectures like single-spa where independently deployed apps share a browser window. It is intentionally minimal and not a general-purpose state manager.
+
+If you need a full-featured state management solution within a single React application, consider:
+
+- **[Zustand](https://github.com/pmndrs/zustand)** -- A small, fast, and scalable state management library for React. Great for app-level state with a simple hook-based API.
+- **[Jotai](https://github.com/pmndrs/jotai)** -- Primitive and flexible atomic state management for React. Ideal when you want fine-grained, bottom-up state composition.
+
+Both are excellent choices for React application state. relay-state fills a different niche: lightweight state that needs to cross micro frontend boundaries.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+[MIT](LICENSE) &copy; Leo Mendez

package/dist/index.d.mts

@@ -0,0 +1,54 @@
+//#region src/index.d.ts
+/**
+ * Sentinel value dispatched by `del` and `clear` to distinguish deletion from storing `undefined`.
+ * Uses `Symbol.for` so the sentinel is shared across independently bundled copies.
+ */
+declare const DELETED: unique symbol;
+/** Returns the current value for a key, or `undefined` if the key has not been set. */
+declare function get<T = unknown>(key: string): T | undefined;
+/** Returns `true` if the key exists in the store, even if its value is `undefined`. */
+declare function has(key: string): boolean;
+/**
+ * Sets a value in the store and dispatches a `CustomEvent` on `window` to notify all subscribers.
+ * Accepts either a direct value or an updater function that receives the previous value.
+ *
+ * **Note:** Because updater functions are detected via `typeof value === "function"`, storing a
+ * function as a value requires wrapping it: `set("cb", () => myFunction)`.
+ */
+declare function set<T = unknown>(key: string, value: T | ((prev: T | undefined) => T)): void;
+/**
+ * Subscribes to changes for a key. The callback fires whenever `set` or `del` is called for
+ * that key, including updates originating from other micro frontend bundles. Returns an
+ * unsubscribe function.
+ *
+ * The signature is compatible with React's `useSyncExternalStore`.
+ */
+declare function subscribe<T = unknown>(key: string, callback: (value: T | undefined) => void): () => void;
+/** Deletes a key from the store and notifies subscribers with `undefined`. */
+declare function del(key: string): void;
+/**
+ * Removes all keys from the store and notifies all active subscribers with `undefined`.
+ * Useful for logout flows or full application resets.
+ */
+declare function clear(): void;
+/** The interface returned by `createStore`. */
+interface RelayStore {
+  get: <T = unknown>(key: string) => T | undefined;
+  has: (key: string) => boolean;
+  set: <T = unknown>(key: string, value: T | ((prev: T | undefined) => T)) => void;
+  subscribe: <T = unknown>(key: string, callback: (value: T | undefined) => void) => () => void;
+  del: (key: string) => void;
+  /** Removes all keys in this namespace and notifies their subscribers with `undefined`. */
+  clear: () => void;
+}
+/**
+ * Creates a namespaced store. All keys are prefixed with `namespace:` internally, preventing
+ * collisions between micro frontends while sharing the same underlying cache and event bus.
+ *
+ * @example
+ * const appA = createStore("appA");
+ * appA.set("user", { name: "Leo" }); // stored as "appA:user"
+ */
+declare function createStore(namespace: string): RelayStore;
+//#endregion
+export { DELETED, RelayStore, clear, createStore, del, get, has, set, subscribe };

package/dist/index.mjs

@@ -0,0 +1,100 @@
+//#region src/index.ts
+const cache = /* @__PURE__ */ new Map();
+const EVENT_PREFIX = "relay-state:";
+/**
+* Sentinel value dispatched by `del` and `clear` to distinguish deletion from storing `undefined`.
+* Uses `Symbol.for` so the sentinel is shared across independently bundled copies.
+*/
+const DELETED = Symbol.for("relay-state:deleted");
+function dispatch(key, value) {
+	window.dispatchEvent(new CustomEvent(`${EVENT_PREFIX}${key}`, { detail: { value } }));
+}
+/** Returns the current value for a key, or `undefined` if the key has not been set. */
+function get(key) {
+	return cache.get(key);
+}
+/** Returns `true` if the key exists in the store, even if its value is `undefined`. */
+function has(key) {
+	return cache.has(key);
+}
+/**
+* Sets a value in the store and dispatches a `CustomEvent` on `window` to notify all subscribers.
+* Accepts either a direct value or an updater function that receives the previous value.
+*
+* **Note:** Because updater functions are detected via `typeof value === "function"`, storing a
+* function as a value requires wrapping it: `set("cb", () => myFunction)`.
+*/
+function set(key, value) {
+	const resolved = typeof value === "function" ? value(cache.get(key)) : value;
+	if (cache.has(key) && Object.is(cache.get(key), resolved)) return;
+	cache.set(key, resolved);
+	dispatch(key, resolved);
+}
+/**
+* Subscribes to changes for a key. The callback fires whenever `set` or `del` is called for
+* that key, including updates originating from other micro frontend bundles. Returns an
+* unsubscribe function.
+*
+* The signature is compatible with React's `useSyncExternalStore`.
+*/
+function subscribe(key, callback) {
+	const listener = (event) => {
+		const val = event.detail.value;
+		if (val === DELETED) {
+			cache.delete(key);
+			callback(void 0);
+		} else {
+			if (!cache.has(key) || !Object.is(cache.get(key), val)) cache.set(key, val);
+			callback(val);
+		}
+	};
+	window.addEventListener(`${EVENT_PREFIX}${key}`, listener);
+	if (cache.has(key)) callback(cache.get(key));
+	return () => {
+		window.removeEventListener(`${EVENT_PREFIX}${key}`, listener);
+	};
+}
+/** Deletes a key from the store and notifies subscribers with `undefined`. */
+function del(key) {
+	cache.delete(key);
+	dispatch(key, DELETED);
+}
+/**
+* Removes all keys from the store and notifies all active subscribers with `undefined`.
+* Useful for logout flows or full application resets.
+*/
+function clear() {
+	for (const key of Array.from(cache.keys())) del(key);
+}
+/**
+* Creates a namespaced store. All keys are prefixed with `namespace:` internally, preventing
+* collisions between micro frontends while sharing the same underlying cache and event bus.
+*
+* @example
+* const appA = createStore("appA");
+* appA.set("user", { name: "Leo" }); // stored as "appA:user"
+*/
+function createStore(namespace) {
+	const prefix = (key) => `${namespace}:${key}`;
+	const keys = /* @__PURE__ */ new Set();
+	return {
+		get: (key) => get(prefix(key)),
+		has: (key) => has(prefix(key)),
+		set: (key, value) => {
+			keys.add(key);
+			set(prefix(key), value);
+		},
+		subscribe: (key, callback) => subscribe(prefix(key), callback),
+		del: (key) => {
+			keys.delete(key);
+			del(prefix(key));
+		},
+		clear: () => {
+			for (const key of keys) del(prefix(key));
+			keys.clear();
+		}
+	};
+}
+if (typeof window !== "undefined" && import.meta.env?.DEV) window.__RELAY_STATE__ = { cache };
+//#endregion
+export { DELETED, clear, createStore, del, get, has, set, subscribe };

package/dist/react.d.mts

@@ -0,0 +1,29 @@
+import { DELETED, RelayStore, clear, createStore, del, get, has, set, subscribe } from "./index.mjs";
+
+//#region src/react.d.ts
+/** A setter that accepts either a direct value or an updater function. */
+type Setter<T> = (value: T | ((prev: T | undefined) => T)) => void;
+/**
+ * Subscribes to a key and returns the current value. Re-renders when the value changes.
+ *
+ * If `initialValue` is provided and the key is currently unset, the value is written to the
+ * store on first mount so all consumers see the same default.
+ *
+ * Use this when a component needs to read state but never write it.
+ */
+declare function useRelayStateValue<T = unknown>(key: string, initialValue?: T): T | undefined;
+/**
+ * Returns a stable setter for a key. The component does **not** re-render when the value
+ * changes — the key performance primitive for write-only components.
+ */
+declare function useSetRelayState<T = unknown>(key: string): Setter<T>;
+/**
+ * Returns a `[value, setter]` tuple — the same pattern as React's `useState`, but shared
+ * across micro frontends. Re-renders when the value changes.
+ *
+ * If `initialValue` is provided and the key is currently unset, the value is written to the
+ * store on first mount so all consumers see the same default.
+ */
+declare function useRelayState<T = unknown>(key: string, initialValue?: T): [T | undefined, Setter<T>];
+//#endregion
+export { DELETED, type RelayStore, Setter, clear, createStore, del, get, has, set, subscribe, useRelayState, useRelayStateValue, useSetRelayState };

package/dist/react.mjs

@@ -0,0 +1,39 @@
+import { DELETED, clear, createStore, del, get, has, set, subscribe } from "./index.mjs";
+import { useCallback, useRef, useSyncExternalStore } from "react";
+//#region src/react.ts
+/**
+* Subscribes to a key and returns the current value. Re-renders when the value changes.
+*
+* If `initialValue` is provided and the key is currently unset, the value is written to the
+* store on first mount so all consumers see the same default.
+*
+* Use this when a component needs to read state but never write it.
+*/
+function useRelayStateValue(key, initialValue) {
+	const initKeyRef = useRef(null);
+	if (initKeyRef.current !== key) {
+		initKeyRef.current = key;
+		if (initialValue !== void 0 && get(key) === void 0) set(key, initialValue);
+	}
+	const value = useSyncExternalStore((cb) => subscribe(key, cb), () => get(key), () => get(key));
+	return value === void 0 ? initialValue : value;
+}
+/**
+* Returns a stable setter for a key. The component does **not** re-render when the value
+* changes — the key performance primitive for write-only components.
+*/
+function useSetRelayState(key) {
+	return useCallback((value) => set(key, value), [key]);
+}
+/**
+* Returns a `[value, setter]` tuple — the same pattern as React's `useState`, but shared
+* across micro frontends. Re-renders when the value changes.
+*
+* If `initialValue` is provided and the key is currently unset, the value is written to the
+* store on first mount so all consumers see the same default.
+*/
+function useRelayState(key, initialValue) {
+	return [useRelayStateValue(key, initialValue), useSetRelayState(key)];
+}
+//#endregion
+export { DELETED, clear, createStore, del, get, has, set, subscribe, useRelayState, useRelayStateValue, useSetRelayState };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "relay-state",
+  "version": "0.2.0",
+  "description": "Framework-agnostic shared state store for micro frontends, powered by window events and an in-memory cache.",
+  "homepage": "https://github.com/leomendez/relay-state#readme",
+  "bugs": {
+    "url": "https://github.com/leomendez/relay-state/issues"
+  },
+  "license": "MIT",
+  "author": "Leo Mendez",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leomendez/relay-state.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./react": "./dist/react.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check",
+    "prepublishOnly": "vp run build",
+    "prepare": "vp config"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@typescript/native-preview": "7.0.0-dev.20260328.1",
+    "bumpp": "^11.0.1",
+    "jsdom": "^29.0.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "typescript": "^6.0.2",
+    "vite-plus": "^0.1.14"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "packageManager": "pnpm@10.33.0"
+}