dsh-plugin-shop 0.8.7 → 0.9.0-beta.1

package/lib/types/client/ShopDetailAction.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The shop's two buttons on dsh's Plugins page (design
+ * 2026-10-16-shop-sidebar-page §7), in the head of a detail page, before the
+ * page's own switch and uninstall (`plugins.detail.actions`, dsh 0.1.7-rc.2
+ * and later): "Open Plugin shop" on the shop's own bundle page, and "View in
+ * Plugin shop" on the page of any bundle the shelf lists. Any other subject
+ * renders nothing, as the slot's contract asks of an entry.
+ *
+ * It renders inside dsh's page, so it carries its own error boundary: a
+ * throw here costs the reader a button, never dsh's page.
+ */
+import { type ReactNode } from 'react';
+import type { InjectFace, PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ShopCatalogResult } from '../host/index.ts';
+import type { ShopPageStore } from './page-store.ts';
+/** One bundle as a detail contribution sees it: the field this reads of the
+ * Plugins page's `PluginPackageRef` (`dsh-client-ui-plugin-manager`'s slot
+ * contract, identical in 0.1.7-rc.2 and 0.2.0-rc.2). */
+export interface PluginPackageRef {
+    readonly name: string;
+}
+/** What a detail page is about, as the Plugins page hands it over. */
+export type PluginsSubject = {
+    readonly kind: 'bundle';
+    readonly pkg: PluginPackageRef;
+} | {
+    readonly kind: 'row';
+    readonly pkg: PluginPackageRef;
+} | {
+    readonly kind: 'item';
+    readonly id: string;
+};
+/** The face index.ts hands the buttons. */
+export interface ShopDetailActionInjected {
+    /** The catalog a listing question is asked of (index.ts `listing`). */
+    listing: () => Promise<ShopCatalogResult>;
+    /** Whether the page can be opened at all: false without a layout service
+     * that can select a panel. */
+    canOpen: () => boolean;
+    openShop: () => void;
+    page: ShopPageStore;
+}
+export type ShopDetailActionProps = {
+    subject: PluginsSubject;
+} & PropsLocale<'settings.shop'> & InjectFace<ShopDetailActionInjected>;
+export declare function ShopDetailAction(props: ShopDetailActionProps): ReactNode;

package/lib/types/client/ShopGlyph.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The shop's glyph in dsh's sidebar (design 2026-10-16-shop-sidebar-page
+ * §4.3): a bag with a whale tail, drawn the way dsh draws its own panel
+ * glyphs — a 16×16 view box, one-pixel `currentColor` strokes, no fill — so
+ * the row's colour and its selection treatment reach it unchanged. `active`
+ * is ignored, as dsh's own glyphs ignore it: the row draws the selection.
+ */
+import type { ReactNode } from 'react';
+export declare function ShopGlyph({ size }: {
+    size: number;
+    active: boolean;
+}): ReactNode;

package/lib/types/client/ShopPage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The shop's own page in dsh's main column (design
+ * 2026-10-16-shop-sidebar-page §4.2), framed as dsh frames its Plugins page:
+ * the page is its own scroll container, its head carries the title and the
+ * one intro line and clears the desktop title bar, and the body below is
+ * `ShopTab`, unchanged.
+ *
+ * It keeps the reader's scroll position in the page store (design
+ * 2026-10-16-shop-sidebar-page §5.7). The position is written on every
+ * scroll event — a browser fires at most one a frame, and the store takes it
+ * without telling anyone — with the card at the page's top edge. The page
+ * goes back there once, when the shelf is on screen again and the installed
+ * list has answered, unless the reader moved first: the same card at the
+ * same height, held there for a moment while the cards around it render, or
+ * the position when that card is no longer on the shelf or the shelf was
+ * refiltered since.
+ */
+import { type ReactNode } from 'react';
+import { type ShopTabProps } from './ShopTab.tsx';
+/** How long the page holds the reader's card at its height once it is put
+ * back, in ms. The cards near it render a frame or two later and take their
+ * real heights, each correction brings a few more above it into range, and
+ * the shelf's entry animation moves it for 220ms (ShopTab.module.css).
+ * Measured on dsh 0.2.0-rc.2 with the live catalog, the card stood still
+ * within 200ms of being put back. */
+export declare const HOLD_MS = 500;
+export declare function ShopPage(props: ShopTabProps): ReactNode;

package/lib/types/client/ShopTab.d.ts

@@ -6,6 +6,7 @@
 import { type ReactNode } from 'react';
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import type { InstallArgs, ShopCatalogResult, ShopInstalledEntry, ShopInstallResult, ShopInstallStatusResult, ShopRestartResult, ShopSetEnabledResult, ShopUninstallResult, ShopUpdateResult, ShopVersionResult } from '../host/index.ts';
+import { type ShopPageStore } from './page-store.ts';
 /** The tab's Remote face: the Host result types, already unwrapped from the
  * wire envelope by `index.ts`; `catalog` throws on a wire error so the tab's
  * error state renders. */
@@ -50,8 +51,11 @@ export interface ShopTabInjected {
     /** Be told when the version answers start coming from another dsh process
      * — dsh restarted under the page, which nothing reloads — with the first
      * answer from it; returns the unsubscribe. The receipts a restart settles
-     * are the tab's to clear (design §8, 2026-10-06 amendment). Optional: a
-     * stub may not offer it. */
+     * are the page store's to clear (`noteRestarted`), which index.ts calls on
+     * every restart under the page, tab or no tab; the tab clears them itself
+     * only for the store it builds when none is handed over (design §8,
+     * 2026-10-06 amendment, and design 2026-10-16-shop-sidebar-page §5.5).
+     * Optional: a stub may not offer it. */
     onRestarted?: (listener: (fresh: ShopVersionResult) => void) => () => void;
     updateStart: (args: {
         version: string;
@@ -60,13 +64,26 @@ export interface ShopTabInjected {
      * reload. Injected so a test can observe it without touching jsdom's
      * non-writable `location.reload`. */
     reload?: () => void;
+    /** The page's store (page-store.ts): the reader's place on the shelf and
+     * every flow, kept across leaving and returning (design
+     * 2026-10-16-shop-sidebar-page §5). Optional: without it the tab builds a
+     * store of its own, which lives and dies with the tab — how the tab
+     * behaved before the store existed, and what a stub gets. */
+    page?: ShopPageStore;
 }
-/** Full component props assembled by the Settings slot renderer. */
-/** The shop body's props: since 2026-10-15 the shop is its own Settings
- * section (design §5.1), whose one owner prop, `close`, the body ignores. */
-export type ShopTabProps = PropsRuntime<'settings.section'> & PropsLocale<'settings.shop'> & InjectFace<ShopTabInjected>;
-/** The shop body inside its own error boundary, as `ShopSection` renders it
- * below the page's title and intro (the settings slot registers `ShopSection`,
- * `index.ts`). Exported under the name the body used to carry, so nothing can
- * render the body without the boundary. */
+/** What only the page frame hands the body (ShopPage.tsx). */
+export interface ShopTabOwnProps {
+    /** Called once per mount, on the first commit with the shelf on screen
+     * and an answer from the installed list, rows or none or a failure: the
+     * frame restores its scroll position then (design
+     * 2026-10-16-shop-sidebar-page §5.7). */
+    onShelfReady?: () => void;
+}
+/** The page's props as the main-column renderer assembles them (no owner
+ * props), plus what only the page frame hands the body. */
+export type ShopTabProps = PropsRuntime<'main'> & PropsLocale<'settings.shop'> & InjectFace<ShopTabInjected> & ShopTabOwnProps;
+/** The shop body inside its own error boundary, as `ShopPage` renders it
+ * below the page's head (index.ts registers `ShopPage` in the main column).
+ * Exported under the name the body used to carry, so nothing can render the
+ * body without the boundary. */
 export declare function ShopTab(props: ShopTabProps): ReactNode;

package/lib/types/client/flow-registry.d.ts

@@ -0,0 +1,89 @@
+/**
+ * One keyed registry of install-shaped flows: start, poll to terminal, reset.
+ *
+ * Framework-free, so a flow can belong to the page rather than to a component
+ * (design 2026-10-16-shop-sidebar-page §5). dsh mounts the shop only while it
+ * is on screen, and a flow held in a component's state — the poll loop an
+ * effect of that component — stopped the moment the reader looked elsewhere:
+ * the install ran on in the host, and nothing was left to fold its status or
+ * write its receipt. The page store (page-store.ts) owns three that outlive
+ * every component showing them, and `useRegistryFlows` (useFlows.ts) renders
+ * one for React.
+ *
+ * Install and uninstall are the same machine, and so is the shop's own
+ * update: they differ only in what the STARTING RPC's answer means, which is
+ * the three `begin*` mappings at the foot of this file.
+ */
+import type { InstallArgs, ShopInstallResult, ShopInstallStatusResult, ShopUninstallResult, ShopUpdateResult } from '../host/index.ts';
+import { type InstallView } from './present.ts';
+/** The one idle view, so a key the registry holds no flow for and a key it
+ * reset to idle hand a memoized consumer the same object. */
+export declare const IDLE_VIEW: InstallView;
+/** `map` without every entry `drop` selects, or null when it selects none.
+ * The copy is made at the first match, so a prune that matches nothing
+ * copies nothing, and its caller, handed null, publishes nothing. The
+ * registry's `resetWhere` and the page store's owed notices share this
+ * contract, so a fourth prune cannot return an empty map instead. */
+export declare function pruned<K, V>(map: ReadonlyMap<K, V>, drop: (value: V, key: K) => boolean): Map<K, V> | null;
+/** What a registry holds at one moment. Replaced whole on every change, so a
+ * consumer can tell "changed" from "same" by identity. */
+export interface FlowSnapshot {
+    readonly views: ReadonlyMap<string, InstallView>;
+    /** Identities whose start is in flight and unanswered. */
+    readonly starting: ReadonlySet<string>;
+}
+export interface FlowRegistryDeps<TArgs> {
+    /** The starting RPC with its answer mapped to the first view. Never
+     * rejects: the mapping folds a transport throw into a view. */
+    begin: (args: TArgs) => Promise<InstallView>;
+    installStatus: (args: {
+        installId: string;
+    }) => Promise<ShopInstallStatusResult>;
+    /** Once per identity that reaches a terminal state: which one, and the
+     * arguments its flow was started with. The outcome is load-bearing: a
+     * failed flow changed nothing on the server. */
+    onSettled?: (key: string, outcome: 'done' | 'failed', args: TArgs) => void;
+}
+export interface FlowRegistryOptions {
+    /** Keep polling while nothing subscribes. The page store's registries do,
+     * so an install the reader left finishes its receipt with no page showing
+     * it; a component's own registry does not, so its polling stops when the
+     * component unmounts and resumes if it mounts again. */
+    pollUnwatched: boolean;
+}
+export interface FlowRegistry<TArgs> {
+    getSnapshot: () => FlowSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    /** Start `key`'s flow. A second start while the first is unanswered is
+     * ignored: the host does not dedupe, so a second RPC would download and
+     * install the same thing twice. */
+    start: (key: string, args: TArgs) => Promise<void>;
+    reset: (key: string) => void;
+    /** Reset every identity whose view `predicate` selects. It is handed the
+     * identity too, so a caller can select one identity's view by its kind. */
+    resetWhere: (predicate: (view: InstallView, key: string) => boolean) => void;
+    /** Stop for good: no more polling, starts, changes or listeners, a start
+     * still unanswered included. The snapshot stays readable. */
+    dispose: () => void;
+}
+/**
+ * @param deps read on every call, so an owner can hand over its latest
+ *   functions without rebuilding the registry.
+ */
+export declare function createFlowRegistry<TArgs>(deps: () => FlowRegistryDeps<TArgs>, options: FlowRegistryOptions): FlowRegistry<TArgs>;
+/** An install's start: the host's business union mapped to the first view. */
+export declare function beginInstall(install: (args: InstallArgs) => Promise<ShopInstallResult>): (args: InstallArgs) => Promise<InstallView>;
+/** An uninstall's start. Its refusals: not in the catalog, not installed.
+ * The host reports no phase for an uninstall, which opens on `installing`. */
+export declare function beginUninstall(uninstall: (args: {
+    name: string;
+}) => Promise<ShopUninstallResult>): (args: {
+    name: string;
+}) => Promise<InstallView>;
+/** The shop's own update's start. Its refusal: a version that is not plain
+ * semver. */
+export declare function beginUpdate(updateStart: (args: {
+    version: string;
+}) => Promise<ShopUpdateResult>): (args: {
+    version: string;
+}) => Promise<InstallView>;

package/lib/types/client/index.d.ts

@@ -1,17 +1,57 @@
 /**
- * Shop settings surface, browser half — one Settings section (`settings.section`)
- * that browses the catalog, installs with acknowledgement, toggles
- * enablement, lists installed plugins, and restarts dsh after installs.
+ * Shop surface, browser half — the shop's own page in dsh's main column
+ * (`main`), which browses the catalog, installs on one click, toggles
+ * enablement, lists installed plugins, and restarts dsh after installs; its
+ * row in the left sidebar (`sidebar.panellist`); and the two buttons on dsh's
+ * Plugins page that lead into it (`plugins.detail.actions`) (design
+ * 2026-10-16-shop-sidebar-page).
  * Mounts the shop Remote itself (the assembly does not know this package)
- * and holds no privilege beyond the nine `shop/*` methods (§5.3).
+ * and holds no privilege beyond the nine `shop/*` methods (the shop design's
+ * §5.3).
  */
 import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
 import type { ShopLocaleKey } from './locales.ts';
+import { type PluginsSubject } from './ShopDetailAction.tsx';
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {
-        /** Shop Settings section copy. */
+        /** The shop page's copy. */
         'settings.shop': ShopLocaleKey;
     }
+    interface SlotMap {
+        /** dsh's left column of global panels (`dsh-client-ui-sidebar`, on
+         * 0.1.5-rc.3, 0.1.7-rc.2 and 0.2.0-rc.2): one row per entry, which owns
+         * the button, its label and its selection, and renders the entry's glyph
+         * at the size it asks. Declared here, in dsh's own terms, because the
+         * 0.1.1-rc.2 protocol this package builds against predates it — as
+         * `connection/reset` is below. */
+        'sidebar.panellist': {
+            kind: 'list';
+            scope: 'root';
+            owner: {
+                size: number;
+                active: boolean;
+            };
+        };
+        /** The main column, keyed by panel id (`dsh-client-ui-layout`, the same
+         * harnesses): only the selected key is mounted, and the sidebar row with
+         * the same id selects it. Declared here for the same reason. */
+        'main': {
+            kind: 'keyed';
+            scope: 'root';
+        };
+        /** Controls at the head of a detail page on dsh's Plugins page
+         * (`dsh-client-ui-plugin-manager`, 0.1.7-rc.2 and later), rendered with
+         * the page's subject; an entry renders null for a subject it has nothing
+         * for. On a harness without the Plugins page nothing declares it, and a
+         * registration into it waits without ever rendering. */
+        'plugins.detail.actions': {
+            kind: 'list';
+            scope: 'root';
+            owner: {
+                subject: PluginsSubject;
+            };
+        };
+    }
 }
 declare module '@deepseek-ai/cordis' {
     interface Events {
@@ -26,10 +66,14 @@ declare module '@deepseek-ai/cordis' {
 }
 /** Dictionary namespace owned by this plugin. */
 export declare const NS = "settings.shop";
+/** The id the shop's sidebar row and its main-column page share (design
+ * 2026-10-16-shop-sidebar-page §4.1). */
+export declare const SHOP_PANEL = "shop";
 /** How long a stashed catalog may satisfy a plain open. The host applies the
  * same five-minute freshness window, so the client stash must not outlive it. */
 export declare const WARM_TTL_MS: number;
-/** Services required by the tab registration and the Remote mount.
+/** Services required by the page, row and Plugins page button registrations
+ * and the Remote mount.
  *
  * `remote.shop` is deliberately ABSENT: this package both mounts its own
  * Remote (the assembly does not know it, §7.3) and consumes it, and cordis
@@ -40,5 +84,6 @@ export declare const WARM_TTL_MS: number;
  * namespace is therefore read through the reflect shop instead (`ctx.get`,
  * see apply), which has no inject requirement. */
 export declare const inject: string[];
-/** Mount the shop Remote and contribute the shop's Settings section. */
+/** Mount the shop Remote and contribute the shop's page, its sidebar row and
+ * its buttons on dsh's Plugins page. */
 export declare function apply(ctx: ClientContext): Promise<void>;

package/lib/types/client/listeners.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The listener plumbing the client's external stores share: the page store
+ * and its owed notices (page-store.ts), the flow registries
+ * (flow-registry.ts) and the restart monitor (restart-monitor.ts). Each keeps
+ * its listeners in a plain `Set`. React subscribes through `listen`, as
+ * `useSyncExternalStore` asks, and a change reaches every listener through
+ * `notify`.
+ *
+ * Functions over that `Set`, never an object a store keeps in its place. The
+ * restart monitor's store lives on `globalThis`, and a 0.8.x shop hands it
+ * over (design 2026-10-16-shop-sidebar-page §6). Its `listeners` is a plain
+ * `Set` that the predecessor's own code adds to, deletes from and iterates,
+ * so the field's shape is a contract across versions, and these functions
+ * take that `Set` as it is.
+ */
+/** Add `listener`, and hand back what removes it. A forgotten set takes
+ * none: its store tells nobody anything more, so a listener subscribing in
+ * a hot swap's window would only be held. */
+export declare function listen(listeners: Set<() => void>, listener: () => void): () => void;
+/** Call every listener as the set stands when the call begins. Over a copy,
+ * so a listener that subscribes or unsubscribes one while it runs (React
+ * re-subscribing in the render the change caused) changes the next notify,
+ * never this one. */
+export declare function notify(listeners: ReadonlySet<() => void>): void;
+/** Drop every listener, and take none again: a disposed store tells nobody
+ * anything more. */
+export declare function forget(listeners: Set<() => void>): void;

package/lib/types/client/locales.d.ts

@@ -1,14 +1,21 @@
-/** Copy dictionaries for the shop's Settings section. */
+/** Copy dictionaries for the shop's page in dsh's main column, its row in the
+ * sidebar, and its two buttons on dsh's Plugins page. */
 /** Simplified Chinese dictionary and key source of truth. */
 export declare const zh: {
-    /** The shop's name in Settings (design §5.1, amended 2026-10-15): its nav
-     * entry and its page title, one key so the two cannot drift apart. */
+    /** The shop's name: its sidebar row and its page title (design
+     * 2026-10-16-shop-sidebar-page §4.1), one key so the two cannot drift
+     * apart. */
     title: string;
-    /** The shop's Settings page intro line (design §5.1, amended 2026-10-15),
-     * as the built-in Models and 内置插件 pages carry one under their title. */
+    /** The page's intro line, under its title, as dsh's own pages carry one. */
     intro: string;
+    /** The Plugins page's button on the shop's own bundle page (design
+     * 2026-10-16-shop-sidebar-page §7). */
+    openShop: string;
+    /** Its button on a page of a bundle the shelf lists. */
+    viewInShop: string;
     loading: string;
     error: string;
+    installedLoading: string;
     installedError: string;
     retry: string;
     /** The shop's own error boundary caught a render error; the error's message
@@ -199,8 +206,11 @@ export type ShopLocaleKey = keyof typeof zh;
 export declare const en: {
     title: string;
     intro: string;
+    openShop: string;
+    viewInShop: string;
     loading: string;
     error: string;
+    installedLoading: string;
     installedError: string;
     retry: string;
     tabCrashed: string;

package/lib/types/client/page-store.d.ts

@@ -0,0 +1,255 @@
+/**
+ * The shop page's state, held by the page rather than by the components that
+ * show it (design 2026-10-16-shop-sidebar-page §5).
+ *
+ * dsh mounts the shop only while it is on screen — the main column renders
+ * only the selected panel, as the Settings shell, the shop's home through
+ * 0.8.7, rendered only the open section — so what a component held in its
+ * own state went the moment the reader looked elsewhere: the search text,
+ * the filters, an install's progress and its receipt, the restart offer
+ * included (the shop design's §5.1, "Leaving the section"). This store keeps
+ * them, and it owns the flows' polling (flow-registry.ts), so an install the
+ * reader left still has its status folded and its receipt written.
+ *
+ * It sits on `globalThis` under a registry symbol for the reason
+ * `restart-monitor.ts` does: the symbol is the one thing a hot-swapped module
+ * instance shares with the one it replaced. Each `apply` still builds a new
+ * store (index.ts), because a re-applied bundle is a new page.
+ */
+import type { InstallArgs, ShopInstallResult, ShopInstallStatusResult, ShopUninstallResult, ShopUpdateResult } from '../host/index.ts';
+import { type FlowRegistry, type FlowRegistryOptions } from './flow-registry.ts';
+import { type Category, type ShelfOrder } from './present.ts';
+/** The reader's controls over the shelf, kept across leaving and returning. */
+export interface ShelfView {
+    readonly query: string;
+    /** `installed` is a filter mode alongside the catalog categories: it selects
+     * by installed state, not by `catalog.category`. */
+    readonly category: Category | 'installed' | null;
+    /** Design 2026-10-12-shelf-orders §4. In memory like every control here: a
+     * page reload starts at the star order. */
+    readonly order: ShelfOrder;
+    /** Off by default: a filter nobody asked for must not hide listings on
+     * first open. Independent of `category`, because it subtracts from
+     * whatever the categories selected rather than competing with them. */
+    readonly hideIncompatible: boolean;
+    /** How far the shelf has grown, in §A1's batches. */
+    readonly visibleCount: number;
+}
+/** What a switch owes before the page shows the truth (ShopTab's
+ * `EnabledSwitch`). */
+export type OwedNotice = 'reload' | 'restart';
+/** Where a switch is drawn. An outdated plugin draws two, its card's and its
+ * Updatable row's, and each owes only what was done to it. */
+declare const SWITCH_SURFACES: readonly ["card", "row"];
+export type SwitchSurface = (typeof SWITCH_SURFACES)[number];
+/** The owed map's key for one switch: `<surface>:<identity>`. */
+export declare function switchKey(surface: SwitchSurface, identity: string): string;
+/** The card the reader is at: the first on the shelf whose bottom lies below
+ * the page's top edge (design 2026-10-16-shop-sidebar-page §5.7). */
+export interface ScrollAnchor {
+    /** Its identity (`identityKey`), since two listed entries can share a
+     * name. */
+    readonly key: string;
+    /** Its top relative to the page's top edge, in px: zero or negative while
+     * the card spans the edge, and at most the shelf's gap between cards while
+     * the edge falls in that gap. A reader above the shelf has no card. */
+    readonly offset: number;
+}
+export interface PageSnapshot {
+    readonly view: ShelfView;
+    /** A settle changed what the catalog's verdicts depend on, and no answer to
+     * a page's request for them since has landed (design
+     * 2026-09-01-harness-compatibility section 9.1;
+     * 2026-10-16-shop-sidebar-page §5.4). */
+    readonly reverdictPending: boolean;
+    /** How many reverdicts the page has been asked for: bumped with
+     * `reverdictPending` by every settle that raises one. A request carries the
+     * count it was asked at, so its answer clears only the latest. */
+    readonly reverdicts: number;
+    /** Bumped by every settle that may have changed the profile and by dsh
+     * restarting under the page: a mounted page re-reads the installed list. */
+    readonly settled: number;
+}
+/** The RPCs the store's flows run on: the shop's injected face. */
+export interface PageStoreDeps {
+    install: (args: InstallArgs) => Promise<ShopInstallResult>;
+    uninstall: (args: {
+        name: string;
+    }) => Promise<ShopUninstallResult>;
+    updateStart: (args: {
+        version: string;
+    }) => Promise<ShopUpdateResult>;
+    installStatus: (args: {
+        installId: string;
+    }) => Promise<ShopInstallStatusResult>;
+    /** Tells the client half a package left the profile: index.ts's
+     * page-removed set, which the module table must never override. */
+    noteUninstalled?: (name: string) => void;
+}
+export interface ShopPageStore {
+    /** The shape a successor may read
+     * (design 2026-10-16-shop-sidebar-page §6). */
+    readonly schema: 1;
+    readonly installs: FlowRegistry<InstallArgs>;
+    readonly uninstalls: FlowRegistry<{
+        name: string;
+    }>;
+    readonly self: FlowRegistry<{
+        version: string;
+    }>;
+    getSnapshot: () => PageSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    /** Publish the view with `patch` applied, unless that changes nothing: a
+     * pill pressed again, or a batch the shelf already shows. */
+    setView: (patch: Partial<ShelfView>) => void;
+    updateView: (update: (view: ShelfView) => Partial<ShelfView>) => void;
+    /** Whether the card of one identity is expanded. A channel of its own,
+     * apart from the page snapshot, as the owed notices below are: one card
+     * opens, and the shelf re-renders whole whenever the snapshot is
+     * replaced. */
+    isExpanded: (key: string) => boolean;
+    /** Be told when any card opens or closes. */
+    subscribeExpanded: (listener: () => void) => () => void;
+    /** Open the card if it is closed, close it if it is open. */
+    toggleExpanded: (key: string) => void;
+    /** Open the card, and leave it open if it is: a jump to one plugin opens
+     * its card from outside it. */
+    expand: (key: string) => void;
+    /** Put one plugin on the shelf, as the Plugins page's "View in Plugin
+     * shop" asks (design 2026-10-16-shop-sidebar-page §7): the search text
+     * set to its name, every category, nothing subtracted, the first batch,
+     * the top of the page, and the one card `card` names opened. Whatever
+     * search the reader left is replaced: they asked to see this plugin. */
+    focus: (name: string, card: string | null) => void;
+    /** What one switch owes (`switchKey`), or undefined when it owes nothing.
+     * A channel of its own, apart from the page snapshot: one switch renders a
+     * notice, and the shelf, which re-renders whole whenever the snapshot is
+     * replaced, has no use for it. */
+    getOwed: (switchKey: string) => OwedNotice | undefined;
+    /** Be told when any switch's notice changes. */
+    subscribeOwed: (listener: () => void) => () => void;
+    /** Read when a switch's toggle starts, and handed back with its answer
+     * (`setOwed`): it counts the times this page saw an installation leave the
+     * profile. */
+    owedEpoch: () => number;
+    /** Sticky, and a restart outranks a reload. `since` is the `owedEpoch` the
+     * toggle started at. An answer that lands after its identity left the
+     * profile, by an uninstall that landed or from the installed list a page
+     * read, re-creates nothing: it describes the installation before, and a
+     * reinstall draws fresh switches under the same keys. A restart under the
+     * page leaves every answer standing: the page notes one only from the new
+     * process's version answer, the old process sent its answers before it
+     * exited, and an answer that lands after the restart is noted is the new
+     * process's, whose restart is owed. */
+    setOwed: (switchKey: string, owed: OwedNotice, since: number) => void;
+    /** The identities the installed list a page read holds. Every switch of an
+     * identity it no longer holds owes nothing: the plugin left the profile,
+     * removed outside the shop (dsh's Plugins page, `dsh plugin remove`) when
+     * no uninstall of this page settled for it. */
+    noteInstalled: (identities: Iterable<string>) => void;
+    /** The answer to a page's reverdict request landed, a failed one
+     * included; `asked` is the `reverdicts` count it was asked at. An answer to
+     * an earlier one clears nothing: a settle since raised another, which the
+     * page has yet to ask for or to hear back about. */
+    clearReverdict: (asked: number) => void;
+    /** dsh restarted under the page (index.ts `onRestarted`). */
+    noteRestarted: () => void;
+    /** Where the page was scrolled to, and the card at its top edge (design
+     * 2026-10-16-shop-sidebar-page §5.7). Written on every scroll without
+     * telling anyone, since nothing renders from it; read once, when the page
+     * comes back. A position written without a card has none. */
+    recordScroll: (top: number, anchor?: ScrollAnchor | null) => void;
+    readScroll: () => number;
+    /** The card written with the position, or null. A view change that
+     * refilters or reorders the shelf forgets it, as `focus` does: the card is
+     * somewhere else on the new shelf, or gone, and no scroll event need follow
+     * to write the card the reader sees now. */
+    readAnchor: () => ScrollAnchor | null;
+    /** ShopPage reports its own mount here. The page is the only surface that
+     * knows it is on screen, and it knows it without asking dsh anything:
+     * `main` mounts a key's panel only while it is selected. Not published
+     * either: what reads it is the hot-swap hand-over record, which this
+     * instance's `main` entry takes as it leaves and the next instance's
+     * `apply` reads (index.ts; design 2026-10-16-shop-sidebar-page §6). */
+    notePageMounted: (mounted: boolean) => void;
+    /** As this instance's `main` entry leaves, record whether the page showed
+     * (index.ts; design 2026-10-16-shop-sidebar-page §6). Reads the mount flag
+     * above — NEVER dsh's layout service, whose selection observable is not
+     * the same object on every leg (measured 2026-10-16,
+     * design 2026-10-16-shop-sidebar-page §3.1; see index.ts's layout-face
+     * comment). */
+    recordTeardown: () => void;
+    /** What a successor reads of this instance. */
+    handover: () => Handover;
+    /** Stop the flows' polling and drop every listener. A disposed store
+     * publishes nothing and registers no listener again, so a hot swap's
+     * window cannot change it. What it held stays readable, and the store
+     * stays under its page key until the next `apply` replaces it: a successor
+     * reads what this instance left from there (design
+     * 2026-10-16-shop-sidebar-page §5.1, §6). */
+    dispose: () => void;
+}
+/** The shelf a page opens on: the star order, every category, one batch. */
+export declare const INITIAL_VIEW: ShelfView;
+/**
+ * @param deps read on every call, so the owner can hand over its latest
+ *   functions without rebuilding the store.
+ * @param options the page's own store polls unwatched; a store a tab builds
+ *   for itself does not, and stops with the tab (ShopTab).
+ */
+export declare function createPageStore(deps: () => PageStoreDeps, options: FlowRegistryOptions): ShopPageStore;
+/** What sits at the page key. A later shop's store, met after a downgrade,
+ * need not share this one's shape, so only an object that says it is of
+ * this `schema` is handed out as this store; anything else is reported as
+ * another schema's and goes no further (design 2026-10-16-shop-sidebar-page
+ * §5.1). */
+export type PageKeyOccupant = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'store';
+    readonly store: ShopPageStore;
+} | {
+    readonly kind: 'other';
+    readonly occupant: unknown;
+};
+/** What a shop applied earlier left on this page: nothing, a store of this
+ * schema, or another schema's object. */
+export declare function readPageStore(): PageKeyOccupant;
+/** Make `store` the page's. Returns what it replaces. */
+export declare function installPageStore(store: ShopPageStore): PageKeyOccupant;
+/** What a successor reads of the instance it replaces
+ * (design 2026-10-16-shop-sidebar-page §6). */
+export interface Handover {
+    /** Whether the shop page was showing when the instance's teardown began. */
+    readonly showing: boolean;
+}
+/** What applied on this page before the instance reading it
+ * (design 2026-10-16-shop-sidebar-page §6). */
+export type Predecessor = {
+    readonly kind: 'none';
+}
+/** A shop that still lived in Settings: a 0.8.4–0.8.7 shop, which left the
+ * restart monitor's store and no page store, or a build with the page store
+ * but not yet the page, whose schema-1 store cannot hand over. */
+ | {
+    readonly kind: 'section';
+}
+/** A 0.9.0-or-later shop, and whether its page showed as it was torn down.
+ * A later shop's store of another schema reads as not showing: its
+ * hand-over cannot be read. */
+ | {
+    readonly kind: 'page';
+    readonly showing: boolean;
+};
+/** Read at the very start of `apply`, before this instance puts its own
+ * stores on the page. */
+export declare function readPredecessor(): Predecessor;
+/** Stop what the page key held, through the `dispose` it has and no other:
+ * an object that claims this schema and lacks one is stopped no more than a
+ * schema-2 object is, and neither can throw the shop off the page. */
+export declare function disposeOccupant(occupant: PageKeyOccupant): void;
+/** Test-only: dispose the page's store and forget it, as a reload does, a
+ * store of another shape included (`disposeOccupant`): a case that left one
+ * must not have its cleanup throw over its own failure. */
+export declare function resetPageStore(): void;
+export {};