@nice-code/state 0.7.0 → 0.9.0

package/build/react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/react/useStoreState.ts","../../src/react/InjectStoreState.ts","../../src/react/useLocalStore.ts"],"sourcesContent":["import { useCallback, useRef, useSyncExternalStore } from \"react\";\r\nimport type { Store } from \"../core/Store\";\r\n\r\n/**\r\n * Compares the previously selected value against the next one. Returning `true`\r\n * tells the hook the value is unchanged, so React is handed the *same*\r\n * reference and no re-render is scheduled.\r\n */\r\nexport type TEqualityFn<SS> = (a: SS, b: SS) => boolean;\r\n\r\n// Default equality is a strict reference check — the fastest possible path, and\r\n// exactly right when selectors return state branches (Immer's structural\r\n// sharing keeps unchanged branches referentially stable). Pass `deepEqual` from\r\n// `fast-equals` when a selector builds a fresh object/array each call.\r\nfunction strictEqual(a: unknown, b: unknown): boolean {\r\n  return a === b;\r\n}\r\n\r\ninterface ISelectionCache<R> {\r\n  value: R;\r\n}\r\n\r\n/**\r\n * Subscribe a React component to a store, optionally narrowing to a derived\r\n * slice.\r\n *\r\n * Built on `useSyncExternalStore`, so it is tear-free under React 18+\r\n * concurrent rendering with no manual `useState`/`useEffect` subscription loop.\r\n *\r\n * A `useRef` cache holds the last selected value. On every store emission the\r\n * selector is re-evaluated and the result is run through a strict-reference\r\n * fast-path first; only if the reference differs is `equalityFn` consulted. A\r\n * new reference is handed back to React exclusively when a genuine change is\r\n * detected, so equal-but-new selector results never trigger a render.\r\n */\r\nfunction useStoreState<S extends object>(store: Store<S>): S;\r\nfunction useStoreState<S extends object, SS>(\r\n  store: Store<S>,\r\n  getSubState: (state: S) => SS,\r\n  equalityFn?: TEqualityFn<SS>,\r\n): SS;\r\nfunction useStoreState<S extends object, SS>(\r\n  store: Store<S>,\r\n  getSubState?: (state: S) => SS,\r\n  equalityFn: (a: S | SS, b: S | SS) => boolean = strictEqual,\r\n): S | SS {\r\n  // Keep the latest selector/equality without forcing a resubscribe when a\r\n  // caller passes inline functions. The store-emission cache below guarantees\r\n  // referential stability regardless of identity churn here.\r\n  const selectorRef = useRef(getSubState);\r\n  const equalityRef = useRef(equalityFn);\r\n  selectorRef.current = getSubState;\r\n  equalityRef.current = equalityFn;\r\n\r\n  const cacheRef = useRef<ISelectionCache<S | SS> | null>(null);\r\n\r\n  const getSnapshot = useCallback((): S | SS => {\r\n    const rawState = store.getRawState();\r\n    const selector = selectorRef.current;\r\n    const nextValue: S | SS = selector ? selector(rawState) : rawState;\r\n\r\n    const cache = cacheRef.current;\r\n\r\n    if (cache === null) {\r\n      cacheRef.current = { value: nextValue };\r\n      return nextValue;\r\n    }\r\n\r\n    const lastValue = cache.value;\r\n\r\n    // Fast-path: reference is identical → return the cached value untouched.\r\n    if (nextValue === lastValue) {\r\n      return lastValue;\r\n    }\r\n\r\n    // Reference changed → consult the configurable equality function. When it\r\n    // reports equality, keep the old reference so React skips the render.\r\n    if (equalityRef.current(lastValue, nextValue)) {\r\n      return lastValue;\r\n    }\r\n\r\n    cache.value = nextValue;\r\n    return nextValue;\r\n  }, [store]);\r\n\r\n  const subscribe = useCallback(\r\n    (onStoreChange: () => void): (() => void) => store.subscribe(onStoreChange),\r\n    [store],\r\n  );\r\n\r\n  // Same snapshot getter serves the server: it reads the store's current value,\r\n  // which on the server is the SSR-seeded state.\r\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\r\n}\r\n\r\nexport { useStoreState };\r\n","import type { ReactElement } from \"react\";\r\nimport type { Store } from \"../core/Store\";\r\nimport { type TEqualityFn, useStoreState } from \"./useStoreState\";\r\n\r\nexport interface IPropsInjectStoreState<S extends object, SS> {\r\n  store: Store<S>;\r\n  on?: (state: S) => SS;\r\n  /**\r\n   * Optional equality function for the selected slice. Defaults to a strict\r\n   * reference check; pass `deepEqual` from `fast-equals` for inline objects.\r\n   */\r\n  equalityFn?: TEqualityFn<SS>;\r\n  children: (output: SS) => ReactElement;\r\n}\r\n\r\n/**\r\n * Render-prop binding: subscribes to `store` (optionally narrowed by `on`) and\r\n * renders `children` with the selected slice.\r\n */\r\nexport function InjectStoreState<S extends object, SS = S>({\r\n  store,\r\n  on,\r\n  equalityFn,\r\n  children,\r\n}: IPropsInjectStoreState<S, SS>): ReactElement {\r\n  const state = useStoreState(store, on ?? ((s: S) => s as unknown as SS), equalityFn);\r\n  return children(state);\r\n}\r\n","import { useRef } from \"react\";\r\nimport { Store } from \"../core/Store\";\r\n\r\n/**\r\n * Standard shallow comparison of dependency arrays — the same semantics React\r\n * uses for its own hook dependency lists. No deep traversal.\r\n */\r\nfunction shallowEqualDeps(\r\n  a: ReadonlyArray<unknown> | undefined,\r\n  b: ReadonlyArray<unknown> | undefined,\r\n): boolean {\r\n  if (a === b) {\r\n    return true;\r\n  }\r\n  if (a == null || b == null || a.length !== b.length) {\r\n    return false;\r\n  }\r\n  for (let i = 0; i < a.length; i++) {\r\n    if (a[i] !== b[i]) {\r\n      return false;\r\n    }\r\n  }\r\n  return true;\r\n}\r\n\r\n/**\r\n * Create a component-local {@link Store} that persists across renders. Passing a\r\n * `deps` array re-creates the store (with a fresh initial state) whenever the\r\n * dependencies change by shallow comparison.\r\n */\r\nfunction useLocalStore<S extends object>(\r\n  initialState: (() => S) | S,\r\n  deps?: ReadonlyArray<unknown>,\r\n): Store<S> {\r\n  const storeRef = useRef<Store<S> | null>(null);\r\n  const depsRef = useRef<ReadonlyArray<unknown> | undefined>(deps);\r\n\r\n  if (storeRef.current === null) {\r\n    storeRef.current = new Store(initialState);\r\n  } else if (deps !== undefined && !shallowEqualDeps(depsRef.current, deps)) {\r\n    storeRef.current = new Store(initialState);\r\n    depsRef.current = deps;\r\n  }\r\n\r\n  return storeRef.current;\r\n}\r\n\r\nexport { useLocalStore };\r\n"],"mappings":";;;AAcA,SAAS,YAAY,GAAY,GAAqB;CACpD,OAAO,MAAM;AACf;AAyBA,SAAS,cACP,OACA,aACA,aAAgD,aACxC;CAIR,MAAM,cAAc,OAAO,WAAW;CACtC,MAAM,cAAc,OAAO,UAAU;CACrC,YAAY,UAAU;CACtB,YAAY,UAAU;CAEtB,MAAM,WAAW,OAAuC,IAAI;CAE5D,MAAM,cAAc,kBAA0B;EAC5C,MAAM,WAAW,MAAM,YAAY;EACnC,MAAM,WAAW,YAAY;EAC7B,MAAM,YAAoB,WAAW,SAAS,QAAQ,IAAI;EAE1D,MAAM,QAAQ,SAAS;EAEvB,IAAI,UAAU,MAAM;GAClB,SAAS,UAAU,EAAE,OAAO,UAAU;GACtC,OAAO;EACT;EAEA,MAAM,YAAY,MAAM;EAGxB,IAAI,cAAc,WAChB,OAAO;EAKT,IAAI,YAAY,QAAQ,WAAW,SAAS,GAC1C,OAAO;EAGT,MAAM,QAAQ;EACd,OAAO;CACT,GAAG,CAAC,KAAK,CAAC;CASV,OAAO,qBAPW,aACf,kBAA4C,MAAM,UAAU,aAAa,GAC1E,CAAC,KAAK,CAK4B,GAAG,aAAa,WAAW;AACjE;;;;;;;AC1EA,SAAgB,iBAA2C,EACzD,OACA,IACA,YACA,YAC8C;CAE9C,OAAO,SADO,cAAc,OAAO,QAAQ,MAAS,IAAqB,UACrD,CAAC;AACvB;;;;;;;ACpBA,SAAS,iBACP,GACA,GACS;CACT,IAAI,MAAM,GACR,OAAO;CAET,IAAI,KAAK,QAAQ,KAAK,QAAQ,EAAE,WAAW,EAAE,QAC3C,OAAO;CAET,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAC5B,IAAI,EAAE,OAAO,EAAE,IACb,OAAO;CAGX,OAAO;AACT;;;;;;AAOA,SAAS,cACP,cACA,MACU;CACV,MAAM,WAAW,OAAwB,IAAI;CAC7C,MAAM,UAAU,OAA2C,IAAI;CAE/D,IAAI,SAAS,YAAY,MACvB,SAAS,UAAU,IAAI,MAAM,YAAY;MACpC,IAAI,SAAS,KAAA,KAAa,CAAC,iBAAiB,QAAQ,SAAS,IAAI,GAAG;EACzE,SAAS,UAAU,IAAI,MAAM,YAAY;EACzC,QAAQ,UAAU;CACpB;CAEA,OAAO,SAAS;AAClB"}

package/package.json

@@ -1,23 +1,21 @@
 {
   "name": "@nice-code/state",
-  "version": "0.7.0",
-  "private": false,
-  "type": "module",
+  "version": "0.9.0",
   "exports": {
     ".": {
       "source": "./src/index.ts",
-      "types": "./build/types/index.d.ts",
-      "import": "./build/index.js"
-    },
-    "./react": {
-      "source": "./src/react/index.ts",
-      "types": "./build/types/react/index.d.ts",
-      "import": "./build/react/index.js"
+      "import": "./build/index.js",
+      "types": "./build/index.d.ts"
     },
     "./devtools/browser": {
       "source": "./src/devtools/browser/index.ts",
-      "types": "./build/types/devtools/browser/index.d.ts",
-      "import": "./build/devtools/browser/index.js"
+      "import": "./build/devtools/browser/index.js",
+      "types": "./build/devtools/browser/index.d.ts"
+    },
+    "./react": {
+      "source": "./src/react/index.ts",
+      "import": "./build/react/index.js",
+      "types": "./build/react/index.d.ts"
     }
   },
   "files": [
@@ -25,32 +23,37 @@
     "package.json",
     "README.md"
   ],
+  "peerDependencies": {
+    "react": ">=19"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "private": false,
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
+    "build-bun": "bun run clean-build && bun run build.ts && bun run build-types",
+    "build": "bun run clean-build && tsdown",
+    "build-types": "tsc --project tsconfig.build.json",
+    "build-watch": "bun run clean-build && bun run build.ts --watch && bun run build-types --watch",
+    "clean-build": "bunx rimraf build",
     "type-check": "bunx tsc --noEmit",
     "type-check-watch": "bunx tsc --noEmit --watch",
-    "clean-build": "bunx rimraf build",
     "vitest": "vitest --typecheck",
-    "vitest-agent": "vitest --typecheck --reporter=agent",
-    "build": "bun run clean-build && bun run build.ts && bun run build-types",
-    "build-watch": "bun run clean-build && bun run build.ts --watch && bun run build-types --watch",
-    "build-types": "tsc --project tsconfig.build.json"
+    "vitest-agent": "vitest --typecheck --reporter=agent"
   },
+  "type": "module",
   "dependencies": {
+    "@tanstack/react-virtual": "^3.13.26",
+    "fast-equals": "6.0.0",
     "immer": "11.1.8",
-    "fast-equals": "6.0.0"
+    "nice-devtools-shared": "0.9.0"
   },
   "devDependencies": {
     "react": "19.2.7"
-  },
-  "peerDependencies": {
-    "react": ">=19"
-  },
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    }
   }
 }

package/build/types/core/Store.d.ts

@@ -1,136 +0,0 @@
-import { type Draft, type Patch, type PatchListener } from "immer";
-/**
- * A plain pub/sub listener. Fired (in the order added) every time the store's
- * root state reference changes. This is the vanilla integration point that any
- * ecosystem — including the React adapter's `useSyncExternalStore` — builds on.
- */
-export type TUpdateListener = () => void;
-/**
- * @typeParam S  The store's state
- * @param draft     The mutable draft to change during this update (Immer proxy).
- * @param original  A readonly snapshot of the state as it was before this update.
- */
-export type TUpdateFunction<S> = (draft: Draft<S>, original: S) => void;
-/**
- * A selector that derives a watched slice `T` from the full store state `S`.
- */
-export type TStoreWatch<S extends object, T> = (state: S) => T;
-/**
- * Fired by {@link Store.watch} whenever the watched slice changes structurally.
- */
-export type TStoreSubscriptionListener<S extends object, T> = (watched: T, allState: S, previousWatched: T) => void;
-/**
- * Runs inside an Immer `produce` whenever a watched slice changes, letting the
- * store derive further state from its own mutations.
- */
-export type TReactionFunction<S extends object, T> = (watched: T, draft: Draft<S>, original: S, previousWatched: T) => void;
-export type TStoreActionUpdate<S extends object> = (updater: TUpdateFunction<S> | TUpdateFunction<S>[], patchesCallback?: TPatchesCallback) => void;
-export type TStoreAction<S extends object> = (update: TStoreActionUpdate<S>) => void;
-export type TPatchesCallback = (patches: Patch[], inversePatches: Patch[]) => void;
-export interface IStoreInternalOptions<S extends object> {
-    ssr: boolean;
-    reactionCreators?: TReactionCreator<S>[];
-}
-export interface ICreateReactionOptions {
-    runNow?: boolean;
-    runNowWithSideEffects?: boolean;
-}
-/**
- * A framework-agnostic, Immer-backed state container.
- *
- * The store owns a single immutable state value and a `Set` of plain
- * listeners. Every mutation runs through Immer's `produce`, and listeners are
- * only notified when the resulting root reference actually changes — making
- * "no-op" updates genuinely free for subscribers.
- *
- * @typeParam S  Your store's state interface.
- */
-export declare class Store<S extends object = object> {
-    private currentState;
-    private readonly createInitialState;
-    private ssr;
-    /** Plain pub/sub listeners — a Set both dedupes and dispatches fast. */
-    private readonly listeners;
-    private reactionCreators;
-    private reactions;
-    private clientSubscriptions;
-    constructor(initialState: S | (() => S));
-    get state(): S;
-    /**
-     * Returns the raw state object contained within this store at this moment.
-     *
-     * ---
-     * ** WARNING **
-     *
-     * Most of the time, if you're using this in your app, there's probably a
-     * better way to do it (a selector subscription or the React adapter).
-     * ---
-     */
-    getRawState(): S;
-    /**
-     * Subscribe a plain listener to store mutations. The listener fires once per
-     * committed update (root reference change) and receives no arguments — read
-     * the latest value with {@link getRawState}.
-     *
-     * This is the low-level primitive that vanilla code and framework adapters
-     * (e.g. React's `useSyncExternalStore`) build upon.
-     *
-     * @returns An unsubscribe function.
-     */
-    subscribe(listener: TUpdateListener): () => void;
-    /**
-     * Subscribe to a derived slice of state. The `listener` only fires when the
-     * watched value changes structurally (per the Fast-Path rule).
-     *
-     * @returns An unsubscribe function.
-     */
-    watch<T>(watch: TStoreWatch<S, T>, listener: TStoreSubscriptionListener<S, T>): () => void;
-    /**
-     * Register a reaction: when the watched slice changes, the `reaction` recipe
-     * runs inside Immer to derive further state on the same store.
-     *
-     * @returns A function that removes the reaction.
-     */
-    createReaction<T>(watch: TStoreWatch<S, T>, reaction: TReactionFunction<S, T>, { runNow, runNowWithSideEffects }?: ICreateReactionOptions): () => void;
-    /**
-     * Subscribe to the Immer patches produced by each update.
-     *
-     * @returns An unsubscribe function.
-     */
-    listenToPatches(patchListener: PatchListener): () => void;
-    /**
-     * Mutate the store via one or more Immer update functions.
-     *
-     * @param updater          A single update function, or an array applied in order.
-     * @param patchesCallback  Optional callback receiving the patches for this update.
-     */
-    update(updater: TUpdateFunction<S> | TUpdateFunction<S>[], patchesCallback?: TPatchesCallback): void;
-    /**
-     * Replace the store's state entirely with a new state value.
-     */
-    replace(newState: S): void;
-    /**
-     * Replace the store's state by mapping from the current state.
-     */
-    replaceFromCurrent(replacer: (state: S) => S): void;
-    /**
-     * Apply a set of Immer patches to the store.
-     */
-    applyPatches(patches: Patch[]): void;
-}
-/**
- * Apply Immer patches to a store, committing only if the root reference changes.
- */
-export declare function applyPatchesToStore<S extends object = object>(store: Store<S>, patches: Patch[]): void;
-/**
- * Mutate a store via one or more Immer update functions.
- *
- * Patches are only computed when there's a consumer for them (a registered
- * patch listener or a `patchesCallback`), keeping the common path allocation-free.
- * Listeners are notified only when the root reference actually changes.
- *
- * @param store            The store to update.
- * @param updater          A single update function, or an array applied in order.
- * @param patchesCallback  Optional callback receiving the patches for this update.
- */
-export declare function update<S extends object = object>(store: Store<S>, updater: TUpdateFunction<S> | TUpdateFunction<S>[], patchesCallback?: TPatchesCallback): void;

package/build/types/core/index.d.ts

@@ -1 +0,0 @@
-export { applyPatchesToStore, type ICreateReactionOptions, type IStoreInternalOptions, Store, type TPatchesCallback, type TReactionFunction, type TStoreAction, type TStoreActionUpdate, type TStoreSubscriptionListener, type TStoreWatch, type TUpdateFunction, type TUpdateListener, update, } from "./Store";

package/build/types/devtools/browser/NiceStateDevtools.d.ts

@@ -1,10 +0,0 @@
-import type { TDevtoolsPosition } from "../core/StateDevtools.types";
-import type { StateDevtoolsCore } from "../core/StateDevtoolsCore";
-export interface INiceStateDevtoolsProps {
-    core: StateDevtoolsCore;
-    position?: TDevtoolsPosition;
-    initialOpen?: boolean;
-    /** Show the panel even when NODE_ENV is not "development". */
-    forceEnable?: boolean;
-}
-export declare function NiceStateDevtools({ forceEnable, ...props }: INiceStateDevtoolsProps): import("react/jsx-runtime").JSX.Element | null;

package/build/types/devtools/browser/components/ChangeDetailPanel.d.ts

@@ -1,12 +0,0 @@
-import type { IDevtoolsStateChange } from "../../core/StateDevtools.types";
-export type TChangeView = "diff" | "props" | "before" | "after";
-export declare function ChangeDetailPanel({ change, onRevert, view, onViewChange, compress, onCompressChange, latestFirst, onLatestFirstChange, }: {
-    change: IDevtoolsStateChange;
-    onRevert: (change: IDevtoolsStateChange) => void;
-    view: TChangeView;
-    onViewChange: (view: TChangeView) => void;
-    compress: boolean;
-    onCompressChange: (compress: boolean) => void;
-    latestFirst: boolean;
-    onLatestFirstChange: (latestFirst: boolean) => void;
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/ChangeList.d.ts

@@ -1,9 +0,0 @@
-import type { CSSProperties } from "react";
-import { type IChangeGroup } from "./utils";
-export declare function ChangeList({ groups, selectedCuid, onSelect, showStore, style, }: {
-    groups: IChangeGroup[];
-    selectedCuid: string | null;
-    onSelect: (cuid: string) => void;
-    showStore: boolean;
-    style?: CSSProperties;
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/DiffView.d.ts

@@ -1,13 +0,0 @@
-/**
- * Test-framework-style diff: only the paths that changed. Changed paths are
- * grouped into a hierarchy by their shared parents — `countHistory.0` and
- * `countHistory.1` nest under a single `countHistory` node, each shown by its
- * direct key only. Single-child chains collapse to a dotted path (`a.b.c`) so
- * lone deep changes stay on one line. Short values render inline with the key
- * (`count: 0 → 1`); long ones keep the removed/added line block.
- */
-export declare function DiffView({ before, after, latestFirst, }: {
-    before: unknown;
-    after: unknown;
-    latestFirst?: boolean;
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/JsonDiffView.d.ts

@@ -1,24 +0,0 @@
-/**
- * Unified, git-style diff of the entire state snapshot. Both sides are rendered
- * as pretty JSON and line-diffed, so unchanged structure stays visible for
- * context while removed lines (red, `−`) and added lines (green, `+`) call out
- * exactly which sections of the whole state moved.
- */
-export declare function JsonDiffView({ before, after, compress, latestFirst, }: {
-    before: unknown;
-    after: unknown;
-    compress?: boolean;
-    latestFirst?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
-/**
- * The full JSON of one snapshot with the lines that differ from the other side
- * highlighted in place — red behind removed lines on the "before" side, green
- * behind added lines on the "after" side. Lines common to both render plainly so
- * the highlight reads as "here is what changed within the whole state".
- */
-export declare function HighlightedJsonView({ before, after, side, compress, }: {
-    before: unknown;
-    after: unknown;
-    side: "before" | "after";
-    compress?: boolean;
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/JsonView.d.ts

@@ -1,7 +0,0 @@
-import type { CSSProperties } from "react";
-export declare function renderColoredJson(text: string): React.ReactNode[];
-export declare function JsonView({ value, indent, style, }: {
-    value: unknown;
-    indent?: number;
-    style?: CSSProperties;
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/PanelChrome.d.ts

@@ -1,54 +0,0 @@
-import { type ReactNode } from "react";
-import type { TDevtoolsPosition } from "../../core/StateDevtools.types";
-export type TDockSide = "top" | "bottom" | "left" | "right";
-export declare function getDockSide(pos: TDevtoolsPosition): TDockSide;
-export interface IDevtoolsLauncherItem {
-    id: string;
-    label: string;
-    icon: string;
-    badge?: string;
-    onOpen: () => void;
-}
-export declare function PanelHeader({ position, onPositionChange, onClose, onClear, paused, onTogglePause, openOthers, children, }: {
-    position: TDevtoolsPosition;
-    onPositionChange: (p: TDevtoolsPosition) => void;
-    onClose: () => void;
-    onClear?: () => void;
-    paused: boolean;
-    onTogglePause: () => void;
-    openOthers?: IDevtoolsLauncherItem[];
-    children?: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
-export declare function ResizeHandle({ dockSide, dockedSize, onChange, }: {
-    dockSide: TDockSide;
-    dockedSize: number;
-    onChange: (size: number) => void;
-}): import("react/jsx-runtime").JSX.Element;
-/**
- * Draggable divider between the list and the detail pane. `horizontal` refers to
- * the split axis: a row layout (dock top/bottom) splits horizontally and drags
- * left/right; a column layout (dock left/right) splits vertically. The reported
- * ratio is the fraction of the container the *detail* pane should occupy.
- */
-export declare function SplitHandle({ horizontal, onRatioChange, }: {
-    horizontal: boolean;
-    onRatioChange: (ratio: number) => void;
-}): import("react/jsx-runtime").JSX.Element;
-/** A compact segmented toggle used for the Timeline / State mode switch. */
-export declare function SegmentedControl<T extends string>({ options, value, onChange, }: {
-    options: {
-        value: T;
-        label: string;
-    }[];
-    value: T;
-    onChange: (value: T) => void;
-}): import("react/jsx-runtime").JSX.Element;
-/**
- * The combined, page-wide launcher shown while every devtool is collapsed — one
- * grouped pill with a segment per registered devtool, so the buttons never
- * overlap or hide behind each other. Rendered by the coordinator's "primary"
- * devtool only.
- */
-export declare function DevtoolsLauncher({ items }: {
-    items: IDevtoolsLauncherItem[];
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/SectionLabel.d.ts

@@ -1,4 +0,0 @@
-export declare function SectionLabel({ label, color, }: {
-    label: string;
-    color?: string;
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/StateInspector.d.ts

@@ -1,16 +0,0 @@
-import type { IDevtoolsStoreInfo } from "../../core/StateDevtools.types";
-/**
- * Live current-state view (top half) plus a direct JSON editor (bottom half) for
- * one store — a fixed 50/50 split so the editor is usable without manual
- * resizing. Editing is the "trigger edits directly for testing" capability: the
- * draft is parsed and handed to {@link StateDevtoolsCore.applyEdit}, which
- * replaces the store state.
- *
- * The draft is seeded from the live state only while it is clean — once the user
- * types, incoming external updates no longer clobber their edit (a "reload"
- * button re-syncs on demand).
- */
-export declare function StateInspector({ store, onApply, }: {
-    store: IDevtoolsStoreInfo;
-    onApply: (storeId: string, newState: unknown) => void;
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/StoreTabs.d.ts

@@ -1,12 +0,0 @@
-import type { IDevtoolsStoreInfo } from "../../core/StateDevtools.types";
-/**
- * Horizontal store filter. `null` selection means "all stores". When
- * `includeAll` is false (the State inspector needs a concrete store) the All
- * pill is omitted.
- */
-export declare function StoreTabs({ stores, selectedStoreId, onSelect, includeAll, }: {
-    stores: IDevtoolsStoreInfo[];
-    selectedStoreId: string | null;
-    onSelect: (id: string | null) => void;
-    includeAll?: boolean;
-}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/utils.d.ts

@@ -1,98 +0,0 @@
-import type { Patch } from "immer";
-import type { IDevtoolsStateChange, TStateChangeSource } from "../../core/StateDevtools.types";
-export declare function safeStringify(value: unknown, indent?: number): string;
-export declare function formatTimestamp(ms: number): string;
-export declare function formatRelativeAge(ms: number): string;
-export declare const SOURCE_LABEL: Record<TStateChangeSource, string>;
-export declare const SOURCE_COLOR: Record<TStateChangeSource, string>;
-/** Render an Immer patch path (`["todos", 0, "done"]`) as `todos.0.done`. */
-export declare function patchPathToString(path: Patch["path"]): string;
-/**
- * A terse, single-line summary of what a change touched, for the timeline row.
- * Prefers a `path: prev → next` form for single scalar replaces, otherwise lists
- * the distinct top-level paths affected.
- */
-export declare function summarizeChange(change: IDevtoolsStateChange): string;
-/** A run of consecutive, structurally-equal changes collapsed into one row. */
-export interface IChangeGroup {
-    /** Newest change in the run — the one the row renders and selects. */
-    representative: IDevtoolsStateChange;
-    /**
-     * Oldest change in the run — the one that actually moved the state (every later
-     * member re-applied the same mutation as a no-op). Its `prevSnapshot` is the
-     * real "before" of the whole run, so the detail panel uses it to show what the
-     * initial update changed instead of the representative's empty self-diff.
-     */
-    oldest: IDevtoolsStateChange;
-    /** How many changes the run collapses (1 = ungrouped). */
-    count: number;
-}
-/**
- * Structural identity of a change by its *resulting* state: same store, same
- * snapshot. The feature collapses updates that "didn't change the state from the
- * previous update", so we compare the committed state itself rather than the
- * mutation that produced it. Keying on patches would miss the no-op cases this is
- * meant to catch — a fresh object reference with identical content, or a
- * same-value write from a different source (e.g. a devtools edit followed by an
- * app update). Those carry patches yet leave the state untouched, so they belong
- * in the run that already reached this state regardless of source.
- */
-export declare function changeGroupKey(change: IDevtoolsStateChange): string;
-/** Collapse consecutive structurally-equal changes (list is newest-first). */
-export declare function groupChanges(changes: IDevtoolsStateChange[]): IChangeGroup[];
-export type TDiffKind = "added" | "removed" | "changed";
-export interface IDiffEntry {
-    path: string;
-    segments: (string | number)[];
-    kind: TDiffKind;
-    before?: unknown;
-    after?: unknown;
-}
-/**
- * Structural diff between two snapshots, flattened to the individual leaf/branch
- * paths that actually changed — the data behind the test-framework-style "Diff"
- * view. Unchanged branches are skipped entirely (Immer's structural sharing
- * means equal branches keep their reference, so this stays cheap).
- */
-export declare function computeDiff(before: unknown, after: unknown): IDiffEntry[];
-export type TLineDiffKind = "common" | "removed" | "added";
-export interface ILineDiffOp {
-    kind: TLineDiffKind;
-    text: string;
-}
-/**
- * Classic LCS line diff between two blocks of text — the data behind the unified
- * git-style "Diff View" and the per-line highlighting in the Before / After
- * panels. Snapshots rendered as pretty JSON stay small, so the O(n·m) table is
- * comfortably cheap.
- */
-export declare function computeLineDiff(beforeText: string, afterText: string): ILineDiffOp[];
-/**
- * Reorder each contiguous changed hunk so additions sit above removals when
- * `latestFirst` is set (the new state on top). Common lines anchor the hunks in
- * place; only the −/+ lines within a run are regrouped, so the surrounding
- * context never moves. With `latestFirst` off the ops are returned untouched.
- */
-export declare function orderLineDiffOps(ops: ILineDiffOp[], latestFirst: boolean): ILineDiffOp[];
-export type TCompressedTone = "common" | "added" | "removed" | "placeholder";
-/** Which document a compressed diff is being rendered for. */
-export type TDiffSide = "unified" | "before" | "after";
-export interface ICompressedLine {
-    /** Nesting depth — the renderer turns this into leading indentation. */
-    depth: number;
-    /** Gutter glyph: `+` added, `−` removed, or a space for structure/placeholder. */
-    sign: string;
-    tone: TCompressedTone;
-    /** The line's JSON (or placeholder) text, without indentation. */
-    text: string;
-}
-/**
- * A structure-aware "address" diff: the JSON tree pruned down to just the
- * branches that actually changed. Parents of a change keep their brackets so the
- * path stays legible, and each run of untouched siblings collapses into a single
- * `… N unchanged …` placeholder (which, for arrays, naturally reports the counts
- * before and after a change). `side` picks which document we're rebuilding —
- * `"unified"` shows removed (−) and added (+) together, while `"before"` /
- * `"after"` show only the lines that belong to that one snapshot.
- */
-export declare function computeCompressedDiff(before: unknown, after: unknown, side: TDiffSide, latestFirst?: boolean): ICompressedLine[];

package/build/types/devtools/browser/devtools_dock.d.ts

@@ -1,54 +0,0 @@
-export type TDockSide = "top" | "bottom" | "left" | "right";
-/** A handle to one registered devtool, used to render launch controls. */
-export interface IDockDevtoolRef {
-    id: string;
-    label: string;
-    icon: string;
-    badge?: string;
-    onOpen: () => void;
-}
-/** The live, syncable part of a devtool's registration. */
-export interface IDockDevtoolSync {
-    side: TDockSide;
-    size: number;
-    open: boolean;
-    badge?: string;
-}
-export interface IDockDevtoolInput extends IDockDevtoolSync {
-    id: string;
-    label: string;
-    icon: string;
-    onOpen: () => void;
-}
-export interface IDockView {
-    /** Offset (px) from the docked edge — stacks open panels on the same side. */
-    dockOffset: number;
-    /**
-     * True when this panel shares its dock side with another open panel (stacked
-     * either nearer or further from the edge). Stacked panels square off all their
-     * corners so they sit flush as one continuous block — only a panel alone on
-     * its side keeps its rounded, page-facing corners.
-     */
-    stacked: boolean;
-    /** Is any devtool on the page currently open? */
-    anyOpen: boolean;
-    /** First-registered devtool — the one that renders the combined launcher. */
-    isPrimary: boolean;
-    /** Every registered devtool, for the combined launcher. */
-    devtools: IDockDevtoolRef[];
-    /** Closed devtools other than this one, for an open panel's header. */
-    otherClosed: IDockDevtoolRef[];
-}
-export interface IDevtoolsDockCoordinator {
-    version: number;
-    register(panel: IDockDevtoolInput): () => void;
-    update(id: string, next: IDockDevtoolSync): void;
-    getView(id: string): IDockView;
-    subscribe(listener: () => void): () => void;
-}
-/**
- * Returns the page-wide dock coordinator, installing it on `window` the first
- * time it is requested. On the server (no `window`) a throwaway instance is
- * returned so callers can use it unconditionally.
- */
-export declare function getDevtoolsDockCoordinator(): IDevtoolsDockCoordinator;

package/build/types/devtools/browser/index.d.ts

@@ -1,3 +0,0 @@
-export type { IDevtoolsStateChange, IDevtoolsStoreInfo, IStateDevtoolsSnapshot, TDevtoolsPosition, TStateChangeSource, TStateDevtoolsListener, } from "../core/StateDevtools.types";
-export { type IStateDevtoolsCoreOptions, StateDevtoolsCore, } from "../core/StateDevtoolsCore";
-export { type INiceStateDevtoolsProps, NiceStateDevtools } from "./NiceStateDevtools";

package/build/types/devtools/core/StateDevtools.types.d.ts

@@ -1,43 +0,0 @@
-import type { Patch } from "immer";
-export type TDevtoolsPosition = "dock-bottom" | "dock-top" | "dock-left" | "dock-right";
-/**
- * How a recorded change came to be. `update` is the normal Immer-patch path,
- * `replace` is a whole-state swap with no patches, and the two `devtools-*`
- * sources are writes the devtools itself made (manual edits / reverts) so they
- * can be visually distinguished from real app traffic.
- */
-export type TStateChangeSource = "update" | "replace" | "devtools-edit" | "devtools-revert";
-/**
- * A single committed mutation of a registered store. Captures both the Immer
- * patches (when available) and full before/after snapshots so the panel can
- * render a precise diff and offer a one-click revert.
- */
-export interface IDevtoolsStateChange {
-    cuid: string;
-    storeId: string;
-    storeLabel: string;
-    timestamp: number;
-    patches: Patch[];
-    inversePatches: Patch[];
-    prevSnapshot: unknown;
-    snapshot: unknown;
-    source: TStateChangeSource;
-}
-/**
- * Live summary of a registered store, refreshed on every commit so the panel's
- * tabs and state inspector always reflect the current value.
- */
-export interface IDevtoolsStoreInfo {
-    id: string;
-    label: string;
-    currentState: unknown;
-    changeCount: number;
-    lastChangeTime?: number;
-}
-export interface IStateDevtoolsSnapshot {
-    stores: IDevtoolsStoreInfo[];
-    /** Most-recent-first across all registered stores. */
-    changes: IDevtoolsStateChange[];
-    paused: boolean;
-}
-export type TStateDevtoolsListener = (snapshot: IStateDevtoolsSnapshot) => void;