@shenora/react 0.10.0 → 0.11.0

package/dist/store.d.ts

@@ -13,12 +13,16 @@ export interface ShenoraStoreIo<TState = unknown> {
     /** Current state — for an action that needs to compute an OPTIMISTIC update from it. */
     getState: () => TState;
     /**
-     * Apply a local state change with NO host round trip and NO wire event — the seam for an
-     * optimistic update an action can fully decide by itself (e.g. dropping the rows a
-     * `CLEAR_FINISHED`-style action just told the host to drop). The host stays authoritative for
-     * everything a `snapshot`/`on` reducer already covers; this exists for the narrow case where the
-     * action already knows the answer and a host round trip would only be a delivery delay, not new
-     * information.
+     * Apply a local state change with NO host round trip and NO wire event — an optimistic update an
+     * action can fully decide by itself. The host stays authoritative for everything a `snapshot`/`on`
+     * reducer covers; this is for state the ACTION already knows and the host would only echo back.
+     *
+     * 🔴 **Reach for it only when the host has no event to tell you.** This used to be documented with
+     * the kit's own `clearFinished` doing an optimistic prune, and that example was WITHDRAWN: the
+     * moment `REQUEST_REMOVED` existed, the local prune became a second thing deciding which rows are
+     * gone, able to disagree with the host about it. If the host emits an event for the change, let the
+     * reducer own it — an optimistic path beside a wire event is a divergence waiting to happen, not a
+     * latency win.
      */
     setState: (reduce: (state: TState) => TState) => void;
 }
@@ -30,7 +34,6 @@ export interface ShenoraStoreSnapshot<TState> {
     /** Fold the response into state. */
     apply: (state: TState, data: unknown) => TState;
 }
-/** Inputs for {@link createShenoraStore}. */
 export interface ShenoraStoreOptions<TState, TActions> {
     /** State before anything has arrived. */
     initial: TState;

package/dist/store.js

@@ -1,6 +1,32 @@
 import { useCallback, useDebugValue, useRef, useSyncExternalStore } from 'react';
 import { getBridge } from './bridge.js';
 import { eventBus as defaultEventBus } from './eventBus.js';
+/** Inputs for {@link createShenoraStore}. */
+/**
+ * Is the fresh selector result the same VALUE as the previous one, for re-render purposes?
+ *
+ * `Object.is` plus ONE level of own-key comparison. The shallow step is what lets an inline selector
+ * that derives a new object work — `s => ({ count: s.lines.length })` builds a different object every
+ * call, and without this every call would look like a change and loop.
+ *
+ * ⚠ Deliberately one level. Deep equality would make an unchanged NESTED value hide a changed outer
+ * one only by cost, and a store whose selectors need deep comparison is selecting too much.
+ */
+function equivalent(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    // Arrays and plain objects only — anything exotic (Map, Date, a class) falls back to identity above.
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    return aKeys.every((k) => Object.prototype.hasOwnProperty.call(b, k)
+        && Object.is(a[k], b[k]));
+}
 /**
  * A store fed by one module's host event stream, shared by every component that reads it.
  *
@@ -46,6 +72,10 @@ export function createShenoraStore(module, options) {
         ?? ((error, context) => console.error(`[shenora] store ${context.module}.${context.type} failed:`, error));
     let state = initial;
     let snapshotLoaded = false;
+    // Bumped on detach. A snapshot response from an earlier subscriber epoch resolving late must be
+    // DROPPED: the current epoch has (or will have) its own, fresher request, and applying the old
+    // body after the new one is a lost update wearing a success path.
+    let snapshotEpoch = 0;
     const listeners = new Set();
     let unsubscribes = [];
     const bridge = () => options.bridge ?? getBridge();
@@ -66,7 +96,7 @@ export function createShenoraStore(module, options) {
         }
         catch (error) {
             // A throwing reducer must not corrupt shared state or break the other subscribers — the same
-            // guarded-callback rule the host applies to app code (Shenora.Core.AppCallback).
+            // guarded-callback rule the host applies to app code (Shenora.AppCallback).
             report(error, { module, type });
         }
     };
@@ -75,9 +105,12 @@ export function createShenoraStore(module, options) {
             return;
         snapshotLoaded = true; // set BEFORE awaiting: two components mounting in the same tick must not
         // both fire the request (React StrictMode double-invokes effects, which is precisely this case).
+        const epoch = snapshotEpoch;
         bridge()
             .invoke(module, snapshot.type, { payload: snapshot.payload, scope })
             .then((data) => {
+            if (epoch !== snapshotEpoch)
+                return; // a previous epoch's answer — the live one owns state
             try {
                 setState(snapshot.apply(state, data));
             }
@@ -85,6 +118,8 @@ export function createShenoraStore(module, options) {
                 report(error, { module, type: snapshot.type });
             }
         }, (error) => {
+            if (epoch !== snapshotEpoch)
+                return;
             // Allow a later retry: a snapshot that failed because the host was not ready yet should not
             // leave the store permanently empty for the rest of the session.
             snapshotLoaded = false;
@@ -99,6 +134,13 @@ export function createShenoraStore(module, options) {
         for (const off of unsubscribes)
             off();
         unsubscribes = [];
+        // The next mount must RE-LOAD: with no bus subscription live, everything the host emits from
+        // here on is missed, so the snapshot the flag was guarding is stale the moment this returns.
+        // The flag exists to dedupe same-tick double-mounts (StrictMode), not to span subscriber epochs —
+        // and the epoch bump orphans any request still in flight, so its late answer cannot clobber the
+        // next epoch's fresher one.
+        snapshotLoaded = false;
+        snapshotEpoch++;
     };
     const subscribe = (listener) => {
         // ONE subscription per event type for the whole store — the property that makes this worth
@@ -119,23 +161,42 @@ export function createShenoraStore(module, options) {
         getState,
         setState: (reduce) => setState(reduce(getState())),
     };
+    /**
+     * Subscribe to the store, optionally through a selector.
+     *
+     * 🔴 **The selector is RE-RUN every time and the previous RESULT is reused when equivalent.** It used
+     * to be memoized against STATE identity alone, which looked like the careful thing and was wrong: a
+     * selector whose closure changed while the state did not returned the PREVIOUS selector's value. A
+     * list row doing `useShenoraRequests(s => s.byId[id])` whose `id` prop changes — virtualised reuse, a
+     * route change — rendered the previous row's data until some unrelated event replaced the state.
+     *
+     * ⚠ <b>Two requirements pull against each other and both are met by comparing RESULTS rather than
+     * inputs.</b> `useSyncExternalStore` re-renders whenever `getSnapshot` returns something new by
+     * `Object.is`, so:
+     * <list type="bullet">
+     * <item>keying the cache on STATE alone gives stale values when the selector changes — the bug above;</item>
+     * <item>keying it on the SELECTOR too loops forever for an inline selector that derives a new object
+     * (`s => ({ count: s.lines.length })`) — a fresh identity each render, a fresh object each call.
+     * zustand v5 has exactly that behaviour and answers it with an opt-in `useShallow`.</item>
+     * </list>
+     * Comparing the RESULT shallowly gives both: a derived object that is field-for-field the same reuses
+     * the previous reference and does not re-render, while a genuinely different row does.
+     */
     function useStore(selector) {
-        // getSnapshot must return a STABLE value for an unchanged store, or React throws
-        // "The result of getSnapshot should be cached" and can loop. So the selector result is memoized
-        // against the state identity: recomputed only when state actually changed.
-        const cache = useRef(null);
-        const selectorRef = useRef(selector);
-        selectorRef.current = selector;
+        // The last result handed to React. Reused whenever the fresh one is equivalent, which is what keeps
+        // getSnapshot stable without pinning it to an input that can go stale.
+        const previous = useRef(null);
         const getSelected = useCallback(() => {
             const current = getState();
-            const select = selectorRef.current;
-            if (!select)
+            if (!selector)
                 return current;
-            if (cache.current === null || !Object.is(cache.current.state, current)) {
-                cache.current = { state: current, selected: select(current) };
+            const next = selector(current);
+            if (previous.current !== null && equivalent(previous.current.value, next)) {
+                return previous.current.value;
             }
-            return cache.current.selected;
-        }, []);
+            previous.current = { value: next };
+            return next;
+        }, [selector]);
         const value = useSyncExternalStore(subscribe, getSelected, getSelected);
         useDebugValue(value);
         return value;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 /**
- * The Shenora IPC wire contract — the TS mirror of the `Shenora.Ipc` C# envelopes (names are
+ * The Shenora IPC wire contract — the TS mirror of the `Shenora.Core.Ipc` C# envelopes (names are
  * pinned on both sides; the host serializes camelCase). Transport-neutral: the same envelopes
  * travel over WebView2 postMessage, a WebSocket, or a mobile shell's channel.
  */
@@ -21,7 +21,23 @@ export declare const HANDSHAKE_TYPE = "READY";
  */
 export declare const IpcErrorCodes: {
     readonly unknownError: "UNKNOWN_ERROR";
+    /**
+     * **No MODULE claimed the request** — nothing on the host answers that name. Parameters:
+     * `module`, `type`.
+     *
+     * ⚠ Distinct from {@link noRoute}, and the split is what makes it actionable: this means the module
+     * was never registered host-side, while `noRoute` means it WAS and does not know that type. Opposite
+     * fixes — wire the module up, versus correct a route name — so collapsing both into `NO_HANDLER` with
+     * identical parameters leaves a dead page undiagnosable from the wire.
+     */
     readonly noHandler: "NO_HANDLER";
+    /**
+     * **The module answered but has no route of that type.** Parameters: `module`, `type`.
+     *
+     * Seeing this is proof the module IS registered and mapped, which is exactly what {@link noHandler}
+     * cannot tell you — so this is a route-name problem, not a composition problem.
+     */
+    readonly noRoute: "NO_ROUTE";
     /**
      * A scope-routed module was called without a `scope`. Parameters: `module`.
      *
@@ -118,6 +134,15 @@ export declare const ShellCapabilities: {
     readonly savePicker: "savePicker";
     readonly secondaryWindows: "secondaryWindows";
     readonly tray: "tray";
+    /**
+     * The host can put a FILE LIST on the clipboard, so the user can paste into Explorer, Finder or a
+     * file manager. No web API expresses this, and a phone's pasteboard has none — so it is the one part
+     * of the clipboard worth branching on.
+     *
+     * ⚠ It says nothing about the rest: text and bytes work everywhere, and the gesture-driven half is
+     * `navigator.clipboard`'s job, not the host's.
+     */
+    readonly clipboardFiles: "clipboardFiles";
     /**
      * The host can serve LOCAL FILES to this page — media, images, documents, exports — through its resource
      * interceptor. Pair it with {@link mediaUrl}.

package/dist/types.js

@@ -1,5 +1,5 @@
 /**
- * The Shenora IPC wire contract — the TS mirror of the `Shenora.Ipc` C# envelopes (names are
+ * The Shenora IPC wire contract — the TS mirror of the `Shenora.Core.Ipc` C# envelopes (names are
  * pinned on both sides; the host serializes camelCase). Transport-neutral: the same envelopes
  * travel over WebView2 postMessage, a WebSocket, or a mobile shell's channel.
  */
@@ -21,7 +21,23 @@ export const HANDSHAKE_TYPE = 'READY';
  */
 export const IpcErrorCodes = {
     unknownError: 'UNKNOWN_ERROR',
+    /**
+     * **No MODULE claimed the request** — nothing on the host answers that name. Parameters:
+     * `module`, `type`.
+     *
+     * ⚠ Distinct from {@link noRoute}, and the split is what makes it actionable: this means the module
+     * was never registered host-side, while `noRoute` means it WAS and does not know that type. Opposite
+     * fixes — wire the module up, versus correct a route name — so collapsing both into `NO_HANDLER` with
+     * identical parameters leaves a dead page undiagnosable from the wire.
+     */
     noHandler: 'NO_HANDLER',
+    /**
+     * **The module answered but has no route of that type.** Parameters: `module`, `type`.
+     *
+     * Seeing this is proof the module IS registered and mapped, which is exactly what {@link noHandler}
+     * cannot tell you — so this is a route-name problem, not a composition problem.
+     */
+    noRoute: 'NO_ROUTE',
     /**
      * A scope-routed module was called without a `scope`. Parameters: `module`.
      *
@@ -76,6 +92,15 @@ export const ShellCapabilities = {
     savePicker: 'savePicker',
     secondaryWindows: 'secondaryWindows',
     tray: 'tray',
+    /**
+     * The host can put a FILE LIST on the clipboard, so the user can paste into Explorer, Finder or a
+     * file manager. No web API expresses this, and a phone's pasteboard has none — so it is the one part
+     * of the clipboard worth branching on.
+     *
+     * ⚠ It says nothing about the rest: text and bytes work everywhere, and the gesture-driven half is
+     * `navigator.clipboard`'s job, not the host's.
+     */
+    clipboardFiles: 'clipboardFiles',
     /**
      * The host can serve LOCAL FILES to this page — media, images, documents, exports — through its resource
      * interceptor. Pair it with {@link mediaUrl}.

package/dist/useDropZone.d.ts

@@ -1,8 +1,8 @@
 import { type RefObject } from 'react';
 import { type ShenoraBridge } from './bridge.js';
 import { type ShenoraEventBus } from './eventBus.js';
-/** The reserved module the drop-zone stack speaks (host: `DropZoneManager`/`DropZoneFacade`). */
-export declare const DROP_ZONE_MODULE = "DROP_ZONE";
+/** The reserved module the drop-zone stack speaks (host: `DropZoneManager`/`DropZoneModule`). */
+export declare const DROP_ZONE_MODULE = "SHENORA.DROPZONE";
 /** A native file drop delivered to a zone. */
 export interface DropZoneFileDrop {
     zoneId: string;
@@ -29,17 +29,30 @@ export interface UseDropZoneOptions {
     onDrop: (files: string[], drop: DropZoneFileDrop) => void;
     /** False = zone torn down (same as unmount). Default true. */
     enabled?: boolean;
-    /** Stable zone id; default: generated per mount. */
+    /** Stable zone id; default: generated per mount. ⚠ Read on the FIRST render only — changing it later
+     * does not re-register the zone, which is what "stable" means here. */
     zoneId?: string;
     /**
      * Class toggled on the element while a file drag hovers the zone. UNSTYLED — headless (D13):
      * the library ships no CSS; style it in the app. Default `"shenora-drop-hover"`.
+     * ⚠ Read on the FIRST render only, like {@link UseDropZoneOptions.zoneId}: the hover effect
+     * captures it for its cleanup while the drop path reads it live, so a mid-hover change would add one
+     * class and remove another, leaving the first stuck on the element. Switch it by remounting.
      */
     dropClassName?: string;
     /** The bridge to speak over. Default: the shared default bridge. */
     bridge?: ShenoraBridge;
     /** The event bus host notifications arrive on. Default: the shared bus. */
     bus?: ShenoraEventBus;
+    /**
+     * Where a failed REGISTER / UPDATE / SHOW / UNREGISTER is reported. Default: `console.error`.
+     *
+     * ⚠ Worth routing somewhere real, because a failure here is INVISIBLE in the UI: the page renders
+     * exactly as it should and files simply do not drop. This hook was the last error path in the package
+     * that could only ever reach the console — `bridge.ts`'s `onPostError`, `store.ts`'s `onError` and
+     * `segmentBinder.ts`'s `onDiagnostic` all take an app sink.
+     */
+    onError?: (error: unknown, route: string) => void;
 }
 /**
  * **The file-drop API for a Shenora page. Do not use the DOM's own drop event for files —

package/dist/useDropZone.js

@@ -2,8 +2,8 @@ import { useEffect, useRef, useState } from 'react';
 import { getBridge } from './bridge.js';
 import { eventBus as defaultEventBus } from './eventBus.js';
 import { debounce, randomId } from './internal.js';
-/** The reserved module the drop-zone stack speaks (host: `DropZoneManager`/`DropZoneFacade`). */
-export const DROP_ZONE_MODULE = 'DROP_ZONE';
+/** The reserved module the drop-zone stack speaks (host: `DropZoneManager`/`DropZoneModule`). */
+export const DROP_ZONE_MODULE = 'SHENORA.DROPZONE';
 const newZoneId = () => randomId('drop-zone-');
 /**
  * **The file-drop API for a Shenora page. Do not use the DOM's own drop event for files —
@@ -30,13 +30,34 @@ const newZoneId = () => randomId('drop-zone-');
  */
 export function useDropZone(options) {
     const { targetRef, enabled = true } = options;
-    const zoneIdRef = useRef(options.zoneId ?? newZoneId());
+    // ⚠ LAZY, because `useRef(newZoneId())` evaluates its argument on EVERY render and keeps only the
+    // first — so the generator ran a `crypto.randomUUID()` per render of every drop zone, for a value
+    // used once. The empty string is a safe sentinel: a generated id is never empty, and a caller who
+    // passes `zoneId: ''` short-circuits the `??` and so still never reaches the generator.
+    const zoneIdRef = useRef('');
+    if (zoneIdRef.current === '')
+        zoneIdRef.current = options.zoneId ?? newZoneId();
+    // ⚠ Read ONCE, like the id, and unlike `onDrop`/`bridge` below which track the latest value. That is
+    // deliberate rather than an oversight: the hover effect captures this class for its cleanup, while
+    // the FILE_DROP effect reads it live, so a value that could change mid-hover would let one path add
+    // class A and another remove class B — leaving A stuck on the element with no drag in progress. The
+    // default is a constant, so unlike the id there is nothing here worth making lazy.
     const dropClassRef = useRef(options.dropClassName ?? 'shenora-drop-hover');
     const onDropRef = useRef(options.onDrop);
     onDropRef.current = options.onDrop;
     const bridgeRef = useRef(options.bridge);
     bridgeRef.current = options.bridge;
     const bus = options.bus ?? defaultEventBus;
+    // Tracks the latest handler (like `onDrop`), so a cleanup that runs long after mount still reports
+    // through the sink the app has NOW. Only when the app supplied none does this log — a caller that
+    // took `onError` owns its reporting and must not be double-logged, the rule the package's other
+    // three sinks follow.
+    const onErrorRef = useRef(options.onError);
+    onErrorRef.current = options.onError;
+    const reportRef = useRef(() => { });
+    reportRef.current = (error, route) => onErrorRef.current
+        ? onErrorRef.current(error, route)
+        : console.error(`[shenora] drop-zone ${route} failed:`, error);
     // Make the ref's CONTENT reactive (P5.5 H2). `targetRef` is a stable object, so effects keyed on it
     // run exactly once — and if `targetRef.current` was null on that run (a conditionally-rendered
     // target, or any order where the ref is attached after the first commit) the effect bailed out and
@@ -91,7 +112,7 @@ export function useDropZone(options) {
                 .then(() => {
                 if (epochRef.current === epoch)
                     isRegisteredRef.current = true;
-            }, (error) => console.error('[shenora] drop-zone REGISTER failed:', error))
+            }, (error) => reportRef.current(error, 'REGISTER'))
                 .finally(() => {
                 if (epochRef.current === epoch)
                     registeringRef.current = false;
@@ -101,7 +122,7 @@ export function useDropZone(options) {
             lastBoundsRef.current = bounds;
             bridge
                 .invoke(DROP_ZONE_MODULE, 'UPDATE', { payload: { zoneId: zoneIdRef.current, ...bounds } })
-                .catch((error) => console.error('[shenora] drop-zone UPDATE failed:', error));
+                .catch((error) => reportRef.current(error, 'UPDATE'));
         }
     };
     // Track the element and keep the native overlay in sync.
@@ -115,7 +136,7 @@ export function useDropZone(options) {
         const sendShow = debounce(() => {
             (bridgeRef.current ?? getBridge())
                 .invoke(DROP_ZONE_MODULE, 'SHOW', { payload: { zoneId: zoneIdRef.current } })
-                .catch((error) => console.error('[shenora] drop-zone SHOW failed:', error));
+                .catch((error) => reportRef.current(error, 'SHOW'));
         }, 100);
         // The element's mouseleave (and the window losing focus) re-arm the overlay — native
         // MouseLeave alone is unreliable through the WebView.
@@ -152,7 +173,7 @@ export function useDropZone(options) {
             if (attemptedRef.current) {
                 (bridgeRef.current ?? getBridge())
                     .invoke(DROP_ZONE_MODULE, 'UNREGISTER', { payload: { zoneId: zoneIdRef.current } })
-                    .catch((error) => console.error('[shenora] drop-zone UNREGISTER failed:', error));
+                    .catch((error) => reportRef.current(error, 'UNREGISTER'));
                 epochRef.current++; // invalidate any in-flight REGISTER's ack (see epochRef)
                 isRegisteredRef.current = false;
                 registeringRef.current = false; // a remount must re-send immediately

package/dist/windowCommands.d.ts

@@ -33,7 +33,7 @@ interface WindowRequests {
     };
 }
 /**
- * Typed client for the host's `WINDOW` module (`WindowCommandFacade` in Shenora.Windows) —
+ * Typed client for the host's `SHENORA.WINDOW` module (`WindowCommandModule` in Shenora.Windows) —
  * drive the frameless window's chrome from the page: chrome buttons call
  * `minimize`/`toggleMaximize`/`close`, the header's `onMouseDown` calls `startDrag` (the window
  * then drags natively — snap and multi-monitor included), and a thin strip at the very top

package/dist/windowCommands.js

@@ -2,7 +2,7 @@ import { useEffect, useRef, useState } from 'react';
 import { debounce } from './internal.js';
 import { BaseModuleService } from './moduleService.js';
 /**
- * Typed client for the host's `WINDOW` module (`WindowCommandFacade` in Shenora.Windows) —
+ * Typed client for the host's `SHENORA.WINDOW` module (`WindowCommandModule` in Shenora.Windows) —
  * drive the frameless window's chrome from the page: chrome buttons call
  * `minimize`/`toggleMaximize`/`close`, the header's `onMouseDown` calls `startDrag` (the window
  * then drags natively — snap and multi-monitor included), and a thin strip at the very top
@@ -11,7 +11,7 @@ import { BaseModuleService } from './moduleService.js';
  */
 export class WindowCommands extends BaseModuleService {
     constructor(bridge) {
-        super('WINDOW', bridge);
+        super('SHENORA.WINDOW', bridge);
     }
     minimize() {
         return this.send('MINIMIZE');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shenora/react",
-  "version": "0.10.0",
-  "description": "React client for Shenora desktop hosts: correlated invoke/send/subscribe over the WebView2 bridge, typed module services, hooks, and a browser fallback for pure-UI development.",
+  "version": "0.11.0",
+  "description": "React client for Shenora hosts on Windows, Android and iOS: correlated invoke/send/subscribe over the desktop postMessage bridge or the MAUI HybridWebView transport, typed module services, host-backed stores, and hooks for request tracking and media playback. Drop zones and window commands are desktop-only, because the capabilities are. Ships a browser fallback for pure-UI development.",
   "license": "MIT",
   "author": "Jiarong Gu",
   "repository": {
@@ -14,6 +14,10 @@
     "shenora",
     "webview2",
     "desktop",
+    "android",
+    "ios",
+    "maui",
+    "hybrid",
     "ipc",
     "react",
     "winforms",
@@ -44,7 +48,9 @@
     "//typecheck": "The ONLY thing that type-checks the tests — `build` excludes them and vitest transpiles without checking, so `@ts-expect-error` assertions (which pin the typed-service generic) are inert without this. Run by dev.mjs verify.",
     "typecheck": "tsc -p tsconfig.json",
     "test": "vitest run",
-    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "//typecheck:floor": "The peerDependency FLOOR is a tested claim, not an assumption: type-checks the SHIPPED sources against React 18 types while everything else builds on 19, so an API that does not exist in 18 (useActionState, use, …) fails HERE instead of in a React 18 consumer's build. Run by dev.mjs verify.",
+    "typecheck:floor": "tsc -p tsconfig.react18.json"
   },
   "peerDependencies": {
     "react": ">=18"
@@ -52,6 +58,7 @@
   "devDependencies": {
     "@testing-library/react": "^16.3.2",
     "@types/react": "^19.2.17",
+    "@types/react18": "npm:@types/react@^18",
     "jsdom": "^29.1.1",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",