@reticlehq/browser 2.13.0 → 2.14.0

package/dist/registry/adapters.js

@@ -1,14 +1,9 @@
-/** Framework adapter registry — enriches elements with component identity + source. */
-// Persist on a global so the registry survives HMR module re-evaluation (otherwise the
-// adapter silently drops after a hot reload and source mapping degrades). See feedback #7.
 const globalStore = globalThis;
 const adapters = (globalStore.__reticleAdapters ??= []);
-/** Called by @reticlehq/react (and future adapters) to register themselves. */
 export function registerAdapter(adapter) {
     if (!adapters.some((a) => a.name === adapter.name))
         adapters.push(adapter);
 }
-/** First adapter that can identify the element wins. */
 export function identifyComponent(el) {
     for (const adapter of adapters) {
         const info = adapter.identify(el);
@@ -17,7 +12,6 @@ export function identifyComponent(el) {
     }
     return null;
 }
-/** First adapter that returns non-undefined component state for the element wins. */
 export function readComponentState(el) {
     for (const adapter of adapters) {
         if (adapter.readState === undefined)
@@ -28,10 +22,6 @@ export function readComponentState(el) {
     }
     return undefined;
 }
-/**
- * True if any installed adapter reports framework enter/leave hover handlers on the element.
- * No-op-safe: returns false when no adapter is installed or none implements the probe.
- */
 export function elementHasHoverHandlers(el) {
     for (const adapter of adapters) {
         if (adapter.hasHoverHandlers === undefined)

package/dist/registry/auto-testids.d.ts

@@ -1,21 +1,2 @@
-/**
- * The testids the page is actually showing, read from the live DOM.
- *
- * `registerCapabilities({ testids: [...] })` used to be the only source, and `init` filled it by
- * grepping the source at install time. That list is a snapshot of the codebase on the day `init` ran:
- * it goes stale on the next commit that renames an element, it is empty for every app whose testids
- * arrive with a lazy route, and finishing it was homework handed to whoever ran the install.
- *
- * The attribute in the DOM is the same declaration, read fresh, so nothing has to be copied into a
- * config file to be true. Reticle's own presenter markup is excluded — advertising our own controls
- * as the app's testable surface would be the tool describing itself.
- */
-/**
- * Ceiling on the reported list.
- *
- * A virtualized 500-row grid stamps a testid per cell, and the capabilities payload rides in every
- * announce — an uncapped read turns one long table into a permanently expensive message. The cap is
- * on the REPORT, not on what can be driven: a testid past it is still findable by query.
- */
 export declare const MAX_AUTO_TESTIDS = 200;
 export declare function domTestids(doc: Document): string[];

package/dist/registry/auto-testids.js

@@ -1,26 +1,6 @@
-/**
- * The testids the page is actually showing, read from the live DOM.
- *
- * `registerCapabilities({ testids: [...] })` used to be the only source, and `init` filled it by
- * grepping the source at install time. That list is a snapshot of the codebase on the day `init` ran:
- * it goes stale on the next commit that renames an element, it is empty for every app whose testids
- * arrive with a lazy route, and finishing it was homework handed to whoever ran the install.
- *
- * The attribute in the DOM is the same declaration, read fresh, so nothing has to be copied into a
- * config file to be true. Reticle's own presenter markup is excluded — advertising our own controls
- * as the app's testable surface would be the tool describing itself.
- */
 const TESTID_ATTR = 'data-testid';
 const TESTID_SELECTOR = `[${TESTID_ATTR}]`;
-/**
- * Ceiling on the reported list.
- *
- * A virtualized 500-row grid stamps a testid per cell, and the capabilities payload rides in every
- * announce — an uncapped read turns one long table into a permanently expensive message. The cap is
- * on the REPORT, not on what can be driven: a testid past it is still findable by query.
- */
 export const MAX_AUTO_TESTIDS = 200;
-/** Reticle's own UI carries testids; they are not the host app's surface. */
 const RETICLE_OWN_PREFIX = 'reticle-';
 export function domTestids(doc) {
     const out = [];
@@ -30,7 +10,7 @@ export function domTestids(doc) {
         nodes = doc.querySelectorAll(TESTID_SELECTOR);
     }
     catch {
-        return out; // a document that cannot be queried (detached, hostile) simply advertises nothing
+        return out;
     }
     for (let i = 0; i < nodes.length && out.length < MAX_AUTO_TESTIDS; i += 1) {
         const value = nodes[i]?.getAttribute(TESTID_ATTR);

package/dist/registry/capabilities.d.ts

@@ -1,4 +1,3 @@
-/** Self-describing capability registry — the testable surface the app advertises. */
 export interface CapabilityFlow {
     name: string;
     steps: string[];
@@ -8,46 +7,16 @@ export interface Capabilities {
     signals: string[];
     stores: string[];
     flows: CapabilityFlow[];
-    /**
-     * True when Reticle's OWN presenter is visible to snapshots and queries.
-     *
-     * Present only when the hatch is open, and reported here rather than left implicit, because a
-     * verdict drawn against Reticle's own interface is not an ordinary verdict: an agent that can see
-     * the impact panel can also assert against it. Anybody reading a result should be able to tell
-     * which kind they are holding without going to look at a build config.
-     */
     presenterExposed?: boolean;
 }
-/** What the host app passes to reticle.describe; all fields optional. */
 export interface CapabilitiesInput {
     testids?: string[];
     signals?: string[];
     stores?: string[];
     flows?: CapabilityFlow[];
 }
-/** Set by the SDK at connect. Idempotent; the last connect wins. */
 export declare function setCapabilitiesListener(cb: (() => void) | undefined): void;
-/** Called by the host app via reticle.describe. Merges (idempotent), never replaces wholesale. */
 export declare function registerCapabilities(input: CapabilitiesInput): void;
-/** Snapshot copy of the registered capabilities (defensive — never hand out the live arrays). */
 export declare function getCapabilities(): Capabilities;
-/**
- * Testids the app DECLARED, without the ones merely observed in the DOM.
- *
- * The difference carries meaning the merged list cannot. `knownEmptyState` asks "did the app NAME
- * this element as part of its testable surface?", which is how a zero-match query against
- * `cart-empty-region` is told apart from a broken selector. Every testid on the page is observed, so
- * answering that over the merged list makes it true whenever the page has any testid at all — the
- * same as not asking.
- */
 export declare function declaredTestids(): string[];
-/**
- * Whether the app has a testable surface at all (used in the HELLO flag).
- *
- * Answered over the OBSERVED surface as well as the declared one. It used to be answerable only by
- * declaration, so an app with two hundred testids in its DOM and a live Redux store reported
- * `hasCapabilities: false` until somebody typed those facts into a config file — and the agent
- * reading that flag concluded, correctly by the flag and wrongly in fact, that there was nothing to
- * drive.
- */
 export declare function hasCapabilities(): boolean;

package/dist/registry/capabilities.js

@@ -1,23 +1,12 @@
-/** Self-describing capability registry — the testable surface the app advertises. */
 import { RETICLE_RENDERS_STORE } from '@reticlehq/core';
 import { isPresenterVisible } from '../dom/dom-ignore.js';
 import { domTestids } from './auto-testids.js';
 import { storeNames } from './stores.js';
-/**
- * The two halves of the capability report the app no longer has to write down.
- *
- * `testids` and `stores` used to be *declarations* — strings copied into a generated file by `init`
- * and then expected to stay true. Both are now read from the thing they describe: the testids from
- * the DOM, the store names from the registry (which the React adapter fills by discovery). What the
- * app declares is still merged in and still wins nothing away: `signals` and `flows` cannot be
- * observed and remain the app's to state.
- */
 function liveTestids() {
     if ('undefined' === typeof document)
         return [];
     return domTestids(document);
 }
-/** Registered stores, minus the ones Reticle registered on the app's behalf. */
 function liveStores() {
     return storeNames().filter((name) => RETICLE_RENDERS_STORE !== name);
 }
@@ -28,7 +17,6 @@ function union(declared, observed) {
             out.push(value);
     return out;
 }
-// Persist on a global so the registry survives HMR module re-evaluation (matches __reticleAdapters).
 const globalStore = globalThis;
 function empty() {
     return { testids: [], signals: [], stores: [], flows: [] };
@@ -41,22 +29,10 @@ function mergeUnique(into, add) {
         if (!into.includes(v))
             into.push(v);
 }
-/**
- * Notified whenever capabilities change, so the SDK can re-announce them to the bridge.
- *
- * `hasCapabilities` rides in the HELLO, which goes out at connect() — and registering deliberately
- * happens AFTER connect, because `registerStore` needs a live SDK to subscribe through. Without a
- * notification, an app that declared its whole testable surface still appeared to the agent as
- * having none, permanently. The hook lives HERE rather than on `reticle.describe` because the
- * documented entry point is this bare function; only wiring `describe` would have fixed the path
- * almost nobody uses.
- */
 let onChanged;
-/** Set by the SDK at connect. Idempotent; the last connect wins. */
 export function setCapabilitiesListener(cb) {
     onChanged = cb;
 }
-/** Called by the host app via reticle.describe. Merges (idempotent), never replaces wholesale. */
 export function registerCapabilities(input) {
     mergeUnique(capabilities.testids, input.testids);
     mergeUnique(capabilities.signals, input.signals);
@@ -68,45 +44,24 @@ export function registerCapabilities(input) {
                 capabilities.flows.push({ name: flow.name, steps: [...flow.steps] });
             }
             else {
-                existing.steps = [...flow.steps]; // last writer wins for a named flow
+                existing.steps = [...flow.steps];
             }
         }
     }
     onChanged?.();
 }
-/** Snapshot copy of the registered capabilities (defensive — never hand out the live arrays). */
 export function getCapabilities() {
     return {
         testids: union(capabilities.testids, liveTestids()),
         signals: [...capabilities.signals],
         stores: union(capabilities.stores, liveStores()),
         flows: capabilities.flows.map((f) => ({ name: f.name, steps: [...f.steps] })),
-        // Only when open — an absent field is the ordinary case and should not cost a line in every
-        // capabilities payload ever sent.
         ...(isPresenterVisible() ? { presenterExposed: true } : {}),
     };
 }
-/**
- * Testids the app DECLARED, without the ones merely observed in the DOM.
- *
- * The difference carries meaning the merged list cannot. `knownEmptyState` asks "did the app NAME
- * this element as part of its testable surface?", which is how a zero-match query against
- * `cart-empty-region` is told apart from a broken selector. Every testid on the page is observed, so
- * answering that over the merged list makes it true whenever the page has any testid at all — the
- * same as not asking.
- */
 export function declaredTestids() {
     return [...capabilities.testids];
 }
-/**
- * Whether the app has a testable surface at all (used in the HELLO flag).
- *
- * Answered over the OBSERVED surface as well as the declared one. It used to be answerable only by
- * declaration, so an app with two hundred testids in its DOM and a live Redux store reported
- * `hasCapabilities: false` until somebody typed those facts into a config file — and the agent
- * reading that flag concluded, correctly by the flag and wrongly in fact, that there was nothing to
- * drive.
- */
 export function hasCapabilities() {
     return (capabilities.signals.length > 0 ||
         capabilities.flows.length > 0 ||

package/dist/registry/commit-and-signal.d.ts

@@ -1,8 +1,2 @@
-/**
- * P5b — pair a mutation with its signal so the two can't drift. The lighter alternative to a
- * Zustand middleware: one call runs the mutation, then emits the signal exactly once, and returns
- * the mutation's value. If `mutate` throws, the mutation never happened — so the signal is NOT
- * emitted and the error propagates unchanged (no try/finally, which would wrongly emit on throw).
- */
 import type { ReticleEmitter } from './emitter.js';
 export declare function commitAndSignal<T>(emitter: ReticleEmitter, mutate: () => T, name: string, data?: Record<string, unknown>): T;

package/dist/registry/commit-and-signal.js

@@ -1,11 +1,5 @@
-/**
- * P5b — pair a mutation with its signal so the two can't drift. The lighter alternative to a
- * Zustand middleware: one call runs the mutation, then emits the signal exactly once, and returns
- * the mutation's value. If `mutate` throws, the mutation never happened — so the signal is NOT
- * emitted and the error propagates unchanged (no try/finally, which would wrongly emit on throw).
- */
 export function commitAndSignal(emitter, mutate, name, data) {
-    const result = mutate(); // throws here? then signal below is never reached — by design.
+    const result = mutate();
     emitter.signal(name, data);
     return result;
 }

package/dist/registry/domains.d.ts

@@ -1,11 +1,3 @@
-/**
- * P5c — self-registering domains. Instead of one hand-maintained flat-map of the whole testable
- * surface, each app domain co-locates its `{ testids, signals, stores }` and calls
- * `registerReticleDomain...)`; the capability registry assembles itself from every domain. Thin
- * adapter over `registerCapabilities`, so merge/dedupe (and HMR persistence) are reused, not
- * reinvented — later calls accumulate as a union, empty domains are a no-op.
- */
-/** A co-located domain bundle (one `reticle.ts` per app domain). */
 export interface ReticleDomain {
     testids?: readonly string[];
     signals?: readonly string[];

package/dist/registry/domains.js

@@ -1,10 +1,3 @@
-/**
- * P5c — self-registering domains. Instead of one hand-maintained flat-map of the whole testable
- * surface, each app domain co-locates its `{ testids, signals, stores }` and calls
- * `registerReticleDomain...)`; the capability registry assembles itself from every domain. Thin
- * adapter over `registerCapabilities`, so merge/dedupe (and HMR persistence) are reused, not
- * reinvented — later calls accumulate as a union, empty domains are a no-op.
- */
 import { registerCapabilities } from './capabilities.js';
 export function registerReticleDomain(domain) {
     const input = {};

package/dist/registry/emitter.d.ts

@@ -1,27 +1,13 @@
-/**
- * The injected-emitter pattern (P5a): host-app components depend on a tiny structural interface
- * instead of importing the SDK directly. The real emitter proxies to the connected `reticle`
- * singleton; when Reticle isn't connected (or isn't loaded) every call is a SAFE NO-OP — so nothing
- * breaks in production or before `reticle.connect`, and `@reticlehq/browser` stays out of the prod bundle.
- */
-/** Structural emitter the host app's components depend on. */
 export interface ReticleEmitter {
     signal: (name: string, data?: Record<string, unknown>) => void;
     state: (name: string, value: unknown) => void;
 }
-/** The subset of the reticle singleton an emitter proxies to (lets tests inject a fake). */
 export interface EmitterTarget {
     signal(name: string, data?: Record<string, unknown>): void;
     state(name: string, value: unknown): void;
-    /** Discriminator the emitter reads per call to decide forward-vs-no-op. */
     readonly connected: boolean;
 }
 export interface CreateReticleEmitterOptions {
-    /** Override the proxy target (tests / advanced embedding). Defaults to the reticle singleton. */
     target?: EmitterTarget;
 }
-/**
- * Create an emitter. Reads `target.connected` on EVERY call (not at creation) so an emitter
- * made at module load — before `reticle.connect` — starts working the moment Reticle connects.
- */
 export declare function createReticleEmitter(options?: CreateReticleEmitterOptions): ReticleEmitter;

package/dist/registry/emitter.js

@@ -1,14 +1,4 @@
-/**
- * The injected-emitter pattern (P5a): host-app components depend on a tiny structural interface
- * instead of importing the SDK directly. The real emitter proxies to the connected `reticle`
- * singleton; when Reticle isn't connected (or isn't loaded) every call is a SAFE NO-OP — so nothing
- * breaks in production or before `reticle.connect`, and `@reticlehq/browser` stays out of the prod bundle.
- */
 import { reticle } from '../index.js';
-/**
- * Create an emitter. Reads `target.connected` on EVERY call (not at creation) so an emitter
- * made at module load — before `reticle.connect` — starts working the moment Reticle connects.
- */
 export function createReticleEmitter(options = {}) {
     const target = options.target ?? reticle;
     return {

package/dist/registry/store-adapters.d.ts

@@ -1,23 +1,4 @@
 import { type StoreLike, type StoreSubscribe } from './stores.js';
-/**
- * Adapters that give non-`{getState, subscribe}` state libraries the shape `registerStore` wants.
- *
- * `registerStore` duck-types on `{getState, subscribe}`, which zustand and Redux satisfy natively — so
- * those two needed nothing and got support for free. Everything else was unserved, and the gap was not
- * evenly distributed: by weekly npm downloads TanStack Query (~64M) is larger than zustand (~46M) and
- * redux (~39M), and it holds the state most likely to be WRONG in a way nothing else can see.
- *
- * That last point is the reason this file exists rather than a docs page. A stale-cache bug — the UI
- * rendering data the server has since changed, a mutation that never invalidated its query, an
- * optimistic update that was never rolled back — fires NO network request. An outside-in tool watching
- * the network sees silence and calls it healthy; the DOM shows a plausible number. The only witness is
- * the cache itself, and until now Reticle could not read it either.
- *
- * Every adapter here is a pure function returning `{getState, subscribe}`. None of them import their
- * library — they take an already-constructed client/store/proxy and use structural types, so this file
- * adds no dependency and no bundle weight for an app that uses none of them.
- */
-/** The minimum of TanStack Query's `QueryClient` that this adapter touches. */
 interface QueryLike {
     queryKey: readonly unknown[];
     state: {
@@ -38,7 +19,6 @@ interface QueryCacheLike {
 interface QueryClientLike {
     getQueryCache: () => QueryCacheLike;
 }
-/** How a single cached query is projected into readable state. */
 export interface QuerySnapshot {
     status: string;
     fetchStatus: string | undefined;
@@ -47,174 +27,40 @@ export interface QuerySnapshot {
     error: string | null;
     data: unknown;
 }
-/**
- * Expose a TanStack Query cache as a Reticle store, keyed by query key.
- *
- * `isStale` / `fetchStatus` / `dataUpdatedAt` are carried deliberately: they are what let an agent
- * assert the stronger property — not merely "the value rendered is X" but "the cache the UI rendered
- * from was actually fresh". A screenshot cannot distinguish a correct number from a correct-looking
- * stale one, and neither can a network log when the request never fired.
- *
- * ```ts
- * registerStore('queries', tanstackQueryStore(queryClient));
- * ```
- */
 export declare function tanstackQueryStore(client: QueryClientLike): StoreLike;
-/**
- * The minimum of a Jotai vanilla store this adapter touches, generic in the ATOM type.
- *
- * `atom: object` was rejected by TypeScript for a real store and the reason is contravariance, not
- * pedantry: Jotai's `get` is `<Value>(atom: Atom<Value>) => Value`, and a function that requires an
- * `Atom` cannot stand in for one that accepts any `object`. So `jotaiStore(createStore(), …)` did
- * not compile — the adapter was advertised, shipped, and unusable from TypeScript without a cast,
- * which the shape-matched fake in the sibling test could never reveal because the fake was written
- * to the same belief the adapter was.
- */
 interface JotaiStoreLike<A> {
     get: (atom: A) => unknown;
     sub: (atom: A, listener: () => void) => () => void;
 }
-/**
- * Expose a chosen set of Jotai atoms as one Reticle store.
- *
- * The atom map is not an ergonomic shortcut, it is forced by the design: Jotai has no registry of live
- * atoms to enumerate, so "the whole store" is not a thing that exists. Naming the atoms you care about
- * is the only way to snapshot them, and it doubles as a declaration of what matters.
- *
- * ```ts
- * registerStore('app', jotaiStore(getDefaultStore(), { cart: cartAtom, user: userAtom }));
- * ```
- */
 export declare function jotaiStore<A>(store: JotaiStoreLike<A>, atoms: Record<string, A>): StoreLike;
-/** The minimum of an XState actor this adapter touches. */
 interface ActorLike {
     getSnapshot: () => unknown;
     subscribe: (listener: () => void) => {
         unsubscribe: () => void;
     };
 }
-/**
- * Expose an XState actor as a Reticle store. Its `subscribe` returns a subscription OBJECT rather than
- * an unsubscribe function, which is the single reason it does not satisfy `StoreLike` already.
- */
 export declare function xstateStore(actor: ActorLike): StoreLike;
-/**
- * Expose a Valtio proxy as a Reticle store. Valtio ships `snapshot`/`subscribe` as free functions
- * rather than methods, so the caller passes them in — importing them here would make every consumer
- * of this file depend on valtio.
- *
- * ```ts
- * import { snapshot, subscribe } from 'valtio/vanilla';
- * registerStore('app', valtioStore(state, snapshot, subscribe));
- * ```
- */
 export declare function valtioStore<T extends object>(proxy: T, snapshot: (p: T) => unknown, subscribe: (p: T, listener: () => void) => () => void): StoreLike;
-/**
- * Expose a MobX observable as a Reticle store. `toJS` and `reaction` are passed in for the same
- * dependency reason as valtio above.
- *
- * ```ts
- * import { reaction, toJS } from 'mobx';
- * registerStore('app', mobxStore(store, toJS, reaction));
- * ```
- */
 export declare function mobxStore<T>(observable: T, toJS: (value: T) => unknown, reaction: (track: () => unknown, effect: () => void) => () => void): StoreLike;
-/** The minimum of a Recoil `Loadable` this adapter touches. */
 interface RecoilLoadableLike {
-    /** 'hasValue' | 'loading' | 'hasError'. Widened to string: it arrives from outside this package. */
     state: string;
-    /** The value, the pending promise, or the thrown error — which one depends on `state`. */
     contents: unknown;
 }
-/** The minimum of a Recoil `Snapshot` this adapter touches, generic in the ATOM type. */
 interface RecoilSnapshotLike<A> {
     getLoadable: (atom: A) => RecoilLoadableLike;
 }
-/** How one Recoil atom is projected: the value never travels without the load state beside it. */
 export interface RecoilAtomSnapshot {
     status: string;
     value: unknown;
     error: string | null;
 }
-/**
- * Expose a chosen set of Recoil atoms as one Reticle store.
- *
- * Three things about Recoil's API shape this adapter is built around, none of them optional:
- *
- *  - **The atom map is forced, not an ergonomic choice.** Recoil has no enumerable registry of live
- *    atoms, so "the whole store" is not a thing that exists. Naming the atoms is the only way to
- *    snapshot them, and it doubles as a declaration of what matters — the same reason `jotaiStore`
- *    takes one.
- *  - **`.state`/`.contents`, never `.getValue()`.** On a pending async selector `getValue()` THROWS
- *    the pending promise, and on a failed one it throws the error. Either would take down the whole
- *    state read over one slow atom — so a loading atom reports `status: 'loading'` with a null value
- *    rather than silently becoming an empty object or an exception.
- *  - **One subscription, not one per atom.** Recoil exposes no per-atom subscription outside React
- *    (`jotaiStore` gets `store.sub(atom, …)`; there is no equivalent here). The transaction stream is
- *    the only public change signal, so the caller passes it in — the same "the library ships free
- *    functions, so hand them over" shape as `valtioStore` and `mobxStore`.
- *
- * Wire it from a bridge component, which is where `useRecoilTransactionObserver_UNSTABLE` lives:
- *
- * ```tsx
- * const latest = useRef(snapshot_UNSTABLE());
- * const listeners = useRef(new Set<() => void>()).current;
- * useRecoilTransactionObserver_UNSTABLE(({ snapshot }) => {
- *   latest.current = snapshot;
- *   for (const l of listeners) l();
- * });
- * registerStore('recoil', recoilStore({ cart: cartAtom }, () => latest.current, (l) => {
- *   listeners.add(l);
- *   return () => listeners.delete(l);
- * }));
- * ```
- */
 export declare function recoilStore<A>(atoms: Record<string, A>, snapshot: () => RecoilSnapshotLike<A>, subscribe: StoreSubscribe): StoreLike;
-/**
- * The minimum of a Svelte store this adapter touches.
- *
- * `subscribe` may return either the unsubscribe function or an object carrying one — the store
- * contract permits both, and an RxJS-shaped source returns the object form.
- */
 interface SvelteReadable {
     subscribe: (run: (value: unknown) => void) => (() => void) | {
         unsubscribe: () => void;
     };
 }
-/**
- * Expose a Svelte store as a Reticle store.
- *
- * Structurally unlike every other adapter in this file: they all wrap something that can be PULLED
- * (`getState`, `getSnapshot`, `snapshot(proxy)`, `toJS`). A Svelte store has no pull side at all —
- * `{ subscribe }` is the entire contract. What makes a pull possible anyway is the part of that
- * contract which says `subscribe` must call back **immediately and synchronously** with the current
- * value: subscribe, catch the value, unsubscribe, return it. That is precisely how `svelte/store`'s
- * own `get()` is implemented, so it is a blessed read rather than a trick.
- *
- * Doing it that way is what keeps this adapter free of the `dispose` the obvious implementation
- * needs. Caching the latest value would mean holding a permanent subscription, which means a
- * teardown the other five adapters don't have, which means a leak the moment a caller forgets it.
- * A transient subscription per read owns nothing and leaks nothing.
- *
- * ```ts
- * registerStore('cart', svelteStore(cartStore));
- * ```
- */
 export declare function svelteStore(readable: SvelteReadable, warn?: (message: string) => void): StoreLike;
-/**
- * The minimum of a Pinia store this adapter touches.
- *
- * Two things here look over-specified and are not, both found by compiling against the real library
- * rather than against a fake written to the same belief as the adapter:
- *
- *  - **`$state: object`, not `Record<string, unknown>`.** A Pinia store's `$state` is a concrete
- *    object type with named keys and no index signature, and TypeScript rejects those for a
- *    `Record<string, unknown>` parameter. `piniaStore(useCartStore())` did not compile — the same
- *    shape of failure as the Jotai contravariance note above, and equally invisible to a fake.
- *  - **`flush` as the literal union**, not `string`. The option object is checked contravariantly, so
- *    a widened `string` here makes the real `$subscribe` unassignable to this shape and the whole
- *    store stops matching.
- */
 interface PiniaStoreLike {
     $state: object;
     $subscribe: (callback: (mutation: unknown, state: unknown) => void, options?: {
@@ -222,39 +68,7 @@ interface PiniaStoreLike {
         flush?: 'pre' | 'post' | 'sync';
     }) => () => void;
 }
-/**
- * Expose a Pinia store as a Reticle store. `$state` / `$subscribe` are close to `{getState,
- * subscribe}` but not close enough for `registerStore`'s duck-type, which is the whole reason a Vue
- * app currently connects and then reports no state at all.
- *
- * Both `$subscribe` options are load-bearing:
- *
- *  - **`detached`** keeps the subscription alive past the component that happened to register the
- *    store. Without it Pinia tears the listener down on unmount, so a store registered from inside a
- *    component goes permanently silent after the first route change — readable, but never again
- *    emitting a STATE_CHANGE, which reads exactly like an app that stopped changing.
- *  - **`flush: 'sync'`** puts the notification inside the action's attribution window. The default
- *    (`'post'`) defers it past the Vue update tick, and a state change that lands after the window
- *    closed is no longer linked to the click that caused it in the causal summary.
- *
- * `$state` carries state, not getters — a Pinia getter is derived, so asserting on the state it
- * derives from is the stronger assertion anyway.
- *
- * ```ts
- * registerStore('cart', piniaStore(useCartStore()));
- * ```
- */
 export declare function piniaStore(store: PiniaStoreLike): StoreLike;
-/**
- * Build a store whose value is PUSHED in rather than pulled — for state that has no object to read.
- *
- * React Context and `useState`/`useReducer` keep their value inside the fiber tree; there is no store
- * instance and no subscription point outside React, so no adapter over a public API is possible. The
- * only way in is to invert the direction: the component holding the value tells Reticle when it
- * changes. `@reticlehq/react`'s `useReticleStore` hook is the ergonomic wrapper over this.
- *
- * Returns the store plus the `push` that updates it, so the caller owns the write side.
- */
 export declare function pushStore(initial: unknown): {
     store: StoreLike;
     push: (value: unknown) => void;