@openagt/dashboard 0.0.0-stage → 0.8.0

package/dist/module-types/dashboard/components/SettingsRows.d.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from 'react';
+/** One section of the Settings page: a titled card of rows. */
+export declare function SettingsSection({ title, description, children }: {
+    title: string;
+    description?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** One setting: what it is and what it does on the left, its control on the right. */
+export declare function SettingsRow({ label, description, control, dimmed, }: {
+    label: string;
+    description: string;
+    control: ReactNode;
+    /** A row the rules turned off: greyed, but still shown with its reason. */
+    dimmed?: boolean;
+}): import("react").JSX.Element;
+export interface SettingsOption {
+    value: string;
+    label: string;
+    /** A line in the list that says something rather than being a choice. */
+    disabled?: boolean;
+}
+/**
+ * One setting picked from a list.
+ *
+ * A row with nothing to pick renders nothing at all (#1172). An empty `<select>` is a control that
+ * cannot be operated — it reads as broken rather than as "no choices here", which is exactly the
+ * paper cut this guard exists for. Every list on this page has a fixed first entry today ("Auto-detect",
+ * the agent's own default), so nothing hits it; it is here because the next list will be added
+ * without thinking about the empty case.
+ */
+export declare function SettingsSelectRow({ label, description, value, options, onChange, }: {
+    label: string;
+    description: string;
+    value: string;
+    options: SettingsOption[];
+    onChange: (next: string) => void;
+}): import("react").JSX.Element | null;

package/dist/module-types/dashboard/components/StartAgentButton.d.ts

@@ -0,0 +1,39 @@
+import type { ReactNode } from 'react';
+export declare function StartAgentButton({ icon, label, busyLabel, ariaLabel, menuAriaLabel, tooltip, tooltipClassName, prompt, configureDescription, onStart, onConfigure, busy, starting, disabled, variant, size, className, }: {
+    /** The primary half's icon; swapped for a spinner while this button's own start is in flight. */
+    icon: ReactNode;
+    /** The primary half's text. Omitted on the dense rows, which are icon-only — pass `ariaLabel` there. */
+    label?: string | undefined;
+    /** What the primary half reads while this button's own start is in flight. */
+    busyLabel?: string | undefined;
+    /** The primary half's accessible name. Required where there is no `label` to serve as one. */
+    ariaLabel?: string | undefined;
+    /** The chevron's accessible name — it has no text of its own, and "menu" would not say whose. */
+    menuAriaLabel: string;
+    /** What the primary half promises on hover: what it does, and what it is about to spend. */
+    tooltip: ReactNode;
+    tooltipClassName?: string | undefined;
+    /**
+     * The prompt "Configure first, then run" hands the launcher. For a click that starts several
+     * agents, the one the launcher can actually send — `configureDescription` then says so.
+     */
+    prompt: string;
+    /** The menu entry's second line: what this particular launcher trip is for. */
+    configureDescription: string;
+    onStart: () => void;
+    /**
+     * Open the launcher the prompt was stashed for — the project's own, since a draft is only
+     * rehydrated by the launcher of the project the reader lands on.
+     */
+    onConfigure: () => void;
+    /** A start is in flight somewhere on this surface: the primary half is out until it settles. */
+    busy?: boolean | undefined;
+    /** *This* button's start is the one in flight, so only it reads as busy. */
+    starting?: boolean | undefined;
+    /** There is nothing to act on at all (no project picked): both halves are out. */
+    disabled?: boolean | undefined;
+    variant?: 'default' | 'outline' | 'ghost' | undefined;
+    size?: 'xs' | 'sm' | 'icon-sm' | undefined;
+    /** Styling the two halves share, so the pair reads as one control rather than two buttons. */
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/badge.d.ts

@@ -0,0 +1,2 @@
+import type { HTMLAttributes } from 'react';
+export declare function Badge({ className, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/button.d.ts

@@ -0,0 +1,10 @@
+import { type VariantProps } from 'class-variance-authority';
+import type { ButtonHTMLAttributes } from 'react';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "ghost" | "outline" | null | undefined;
+    size?: "default" | "icon" | "icon-sm" | "sm" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+}
+export declare function Button({ className, variant, size, ...props }: ButtonProps): import("react").JSX.Element;
+export { buttonVariants };

package/dist/module-types/dashboard/components/ui/card.d.ts

@@ -0,0 +1,5 @@
+import type { HTMLAttributes } from 'react';
+export declare function Card({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function CardTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): import("react").JSX.Element;
+export declare function CardContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/checkbox.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps } from 'react';
+import { Checkbox as CheckboxPrimitive } from '@base-ui-components/react/checkbox';
+type CheckboxProps = Omit<ComponentProps<typeof CheckboxPrimitive.Root>, 'disabled'> & {
+    disabled?: boolean | undefined;
+};
+export declare function Checkbox({ className, disabled, ...props }: CheckboxProps): import("react").JSX.Element;
+export {};

package/dist/module-types/dashboard/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,16 @@
+import { Menu } from '@base-ui-components/react/menu';
+import type { ComponentProps } from 'react';
+export declare const DropdownMenu: typeof Menu.Root;
+export declare const DropdownMenuGroup: import("react").ForwardRefExoticComponent<import("@base-ui-components/react/menu").MenuGroupProps & import("react").RefAttributes<Element>>;
+export declare const DropdownMenuSub: typeof Menu.SubmenuRoot;
+export declare function DropdownMenuTrigger({ className, ...props }: ComponentProps<typeof Menu.Trigger>): import("react").JSX.Element;
+export declare function DropdownMenuContent({ className, sideOffset, align, children, ...props }: ComponentProps<typeof Menu.Popup> & {
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+}): import("react").JSX.Element;
+export declare function DropdownMenuItem({ className, ...props }: ComponentProps<typeof Menu.Item>): import("react").JSX.Element;
+export declare function DropdownMenuCheckboxItem({ className, children, closeOnClick, ...props }: ComponentProps<typeof Menu.CheckboxItem>): import("react").JSX.Element;
+export declare function DropdownMenuSubTrigger({ className, children, ...props }: ComponentProps<typeof Menu.SubmenuTrigger>): import("react").JSX.Element;
+export declare function DropdownMenuSubContent({ className, children, ...props }: ComponentProps<typeof Menu.Popup>): import("react").JSX.Element;
+export declare function DropdownMenuSeparator({ className, ...props }: ComponentProps<typeof Menu.Separator>): import("react").JSX.Element;
+export declare function DropdownMenuLabel({ className, ...props }: ComponentProps<typeof Menu.GroupLabel>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/input.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentProps } from 'react';
+export declare function Input({ className, type, ...props }: ComponentProps<'input'>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/option-label.d.ts

@@ -0,0 +1,4 @@
+export declare function OptionLabel({ label, description }: {
+    label: string;
+    description?: string | undefined;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/popover.d.ts

@@ -0,0 +1,8 @@
+import { Popover as BasePopover } from '@base-ui-components/react/popover';
+import type { ComponentProps } from 'react';
+export declare const Popover: typeof BasePopover.Root;
+export declare function PopoverTrigger({ className, ...props }: ComponentProps<typeof BasePopover.Trigger>): import("react").JSX.Element;
+export declare function PopoverContent({ className, sideOffset, align, children, ...props }: ComponentProps<typeof BasePopover.Popup> & {
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/scroll-area.d.ts

@@ -0,0 +1,10 @@
+import type { Ref } from 'react';
+import { ScrollArea as ScrollAreaPrimitive } from '@base-ui-components/react/scroll-area';
+export declare function ScrollArea({ className, children, viewportRef, viewportClassName, ...props }: ScrollAreaPrimitive.Root.Props & {
+    /** The scrolled element, for a rail that scrolls itself (ViewsRail). */
+    viewportRef?: Ref<HTMLDivElement>;
+    /** Extra classes on the viewport — where the height cap belongs when the Root has no definite
+     *  height. A `max-h-*` on the Root only caps the box; the viewport's `h-full` cannot resolve
+     *  against a parent's max-height, so the content grows instead of scrolling. Put the cap here. */
+    viewportClassName?: string;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/separator.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentProps } from 'react';
+import { Separator as SeparatorPrimitive } from '@base-ui-components/react/separator';
+export declare function Separator({ className, orientation, ...props }: ComponentProps<typeof SeparatorPrimitive>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/skeleton.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentProps } from 'react';
+export declare function Skeleton({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/slider.d.ts

@@ -0,0 +1,9 @@
+export declare function RangeSlider({ value, onValueChange, min, max, className, 'aria-label': ariaLabel, }: {
+    /** The selected [min, max] pair, both inclusive. */
+    value: [number, number];
+    onValueChange: (next: [number, number]) => void;
+    min?: number;
+    max?: number;
+    className?: string;
+    'aria-label'?: string;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/tooltip.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentProps } from 'react';
+import { Tooltip as TooltipPrimitive } from '@base-ui-components/react/tooltip';
+declare const TooltipProvider: import("react").FC<import("@base-ui-components/react/tooltip").TooltipProviderProps>;
+declare const Tooltip: typeof TooltipPrimitive.Root;
+declare function TooltipTrigger(props: ComponentProps<typeof TooltipPrimitive.Trigger>): import("react").JSX.Element;
+declare function TooltipContent({ className, sideOffset, side, align, children, ...props }: ComponentProps<typeof TooltipPrimitive.Popup> & {
+    sideOffset?: number;
+    side?: ComponentProps<typeof TooltipPrimitive.Positioner>['side'];
+    align?: ComponentProps<typeof TooltipPrimitive.Positioner>['align'];
+}): import("react").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/module-types/dashboard/lib/agent-settings.d.ts

@@ -0,0 +1,2 @@
+/** What a surface says when no model is pinned and the CLI picks for itself (#1143). */
+export declare const NO_MODEL_PINNED = "the CLI's own default";

package/dist/module-types/dashboard/lib/draft-handoff.d.ts

@@ -0,0 +1,15 @@
+/** At SPA boot: move `?draft=` out of the URL into sessionStorage and strip it from the address bar
+ * (and so from history and any Referer). Idempotent and a no-op when there is no draft param. */
+export declare function stashDraftFromUrl(): void;
+/**
+ * Carry a draft across an in-app navigation (#1139): the same stash the device hop uses, written
+ * directly rather than through the URL. For a click that knows what the next session should be
+ * about but lands on the launcher, where that knowledge would otherwise be dropped — a hot ticket
+ * with no run of its own.
+ *
+ * Deliberately not a `?draft=` param like the device hop: this navigation never leaves the tab, so
+ * there is nothing to hand another device and no reason to put the prompt in the address bar.
+ */
+export declare function stashPendingDraft(draft: string): void;
+/** The carried draft, if any, cleared as it is read so a reload does not re-seed it. */
+export declare function takePendingDraft(): string | null;

package/dist/module-types/dashboard/lib/format-date.d.ts

@@ -0,0 +1,51 @@
+/** A timestamp as local date + time, e.g. a project's last activity. */
+export declare function formatDateTime(value: string | undefined, fallback?: string): string;
+/**
+ * A short local date + time, e.g. "Jul 18, 10:35 PM". For places where the timestamp is standing
+ * in as a name (an unnamed session in the rail), where seconds are noise on the line that has to
+ * identify the row.
+ */
+export declare function formatDateTimeShort(value: string | undefined, fallback?: string): string;
+/** A timestamp as a local date alone, for the denser table columns. */
+export declare function formatDate(value: string | undefined, fallback?: string): string;
+/**
+ * A compact age (#1139): "22s ago" / "30m ago" / "5d ago" / "2w ago", the units the Agents list
+ * dates its rows in. Finer than {@link formatRelative} at both ends — it names seconds (a session
+ * that ended moments ago) and never falls back to a bare date (weeks, then years, stay relative) —
+ * so a row reads the same whether it finished this minute or last month. Pair it with
+ * {@link formatDateTime} in a `title` for the exact moment.
+ *
+ * Floored, not rounded: "1m ago" should mean at least a minute has passed, not "closer to a minute
+ * than to two".
+ */
+export declare function formatAge(value: string | undefined, fallback?: string): string;
+/**
+ * A timestamp as freshness (#948): "just now" / "12m ago" / "3h ago" / "2d ago", falling back
+ * to the local date past a week. An at-a-glance board wants "2m ago", not today's date.
+ */
+export declare function formatRelative(value: string | undefined, fallback?: string): string;
+/**
+ * A plain duration, floored to its largest whole unit: "2s" / "10m" / "2h" / "1d" (#960 Edit) — no
+ * "ago", and no weeks: this backs the pace-deviation figure, which can never exceed the week
+ * itself. Floored for the reason {@link formatAge} is: "1d" should mean a full day has passed, not
+ * "close enough to one".
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * The same duration spelled out — "1 day" / "2 hours" / "10 minutes" / "2 seconds" (#960 Edit) —
+ * for a sentence (a tooltip explaining the figure {@link formatDuration} renders as "1d"), where an
+ * abbreviation reads as a label rather than as prose.
+ */
+export declare function formatDurationLong(ms: number): string;
+/**
+ * A quota reset, as the week it sits under already places it: "Tuesday 8:59pm" (#960 Edit), not a
+ * date — the bar above says which day of the week it is; naming the date again would be the
+ * calendar repeating itself. Pair with {@link formatResetTooltip} for the exact moment.
+ */
+export declare function formatResetDay(at: number): string;
+/**
+ * The same moment in full, for a tooltip: "Quota resets on Jul 28, 8:59pm (Europe/Berlin)". Names
+ * the zone rather than leaving it implicit, since the reset is the account's own clock, and a
+ * viewer working from a different one should not have to guess whether the two agree.
+ */
+export declare function formatResetTooltip(at: number): string;

package/dist/module-types/dashboard/lib/host-services.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleHostBase } from '../module/index.js';
+/** The services, minus the package they are bound to: what the shell has, before a module is known. */
+export type HostServices = Omit<ModuleHostBase, 'package'>;
+/**
+ * Services for a shell that provides none (a unit test renders a page or a slot alone): nothing
+ * navigates, a start answers that there is no dashboard, no project has runs.
+ */
+export declare const INERT_HOST_SERVICES: HostServices;
+/** Set by the shell around the whole dashboard: the services every module's host is built from. */
+export declare const HostServicesContext: import("react").Context<HostServices | null>;
+/** The shell's services bound to one module package: the base of that module's host. */
+export declare function useHostServices(pkg: string): ModuleHostBase;

package/dist/module-types/dashboard/lib/models.d.ts

@@ -0,0 +1,24 @@
+import type { DriverOption } from '../components/DriverModelMenu.js';
+import { type DriverModels, type ModelsView } from '../rpc/models.js';
+/** The models each coding agent offers, `undefined` until the daemon has answered. */
+export declare function useModels(): ModelsView | undefined;
+/**
+ * Every coding agent with the models it listed, by the names it gives them, or a line saying why
+ * there are none: the one list every surface that picks a model offers (the start menu, Settings),
+ * so the two can never disagree on what a pick may be. No icons: those are the menu's own.
+ */
+export declare function driverOptions(models: ModelsView | undefined): DriverOption[];
+/**
+ * A model's name as its agent shows it ("Opus 5.5" for `opus`, and for `claude-opus-5-5`, the full
+ * id `opus` runs today). A model the agent does not list, or a list not answered yet, is named by
+ * the id itself: that is what the run was given or ran.
+ */
+export declare function modelName(models: DriverModels | undefined, id: string): string;
+export type { DriverModels, ModelsView };
+/** A coding agent as a module offers it: its name for the run (`claude-code`), its label, its models, and why it lists none. */
+export type CodingAgent = DriverOption;
+/**
+ * Every coding agent with the models it lists (#1902): the start menu's own list, for a module that
+ * lets a person pick one, so its picks are the ones a run can be given.
+ */
+export declare function useCodingAgents(): CodingAgent[];

package/dist/module-types/dashboard/lib/route.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Whether a first segment names a page a module adds (#1774) rather than a project: a lowercase
+ * letter, then lowercase letters and digits. Never a project's id, which always carries a
+ * `-<hash>` suffix, so the router reserves no module's word: whichever module claims the segment
+ * gets it, and the shell says "no such page" when none does.
+ */
+export declare function isPageSegment(segment: string): boolean;
+/** What the dashboard is looking at, as carried by the URL. */
+export interface Route {
+    /** A top-level view belonging to no project (#958). */
+    view?: 'settings';
+    /** The selected project, or null for the Overview. */
+    projectId: string | null;
+    /** The selected session (agent id), or null for the project's home/launcher. */
+    agentId: string | null;
+    /** A module's page (#1774), by its segment; no project and no agent is selected there. */
+    page?: string;
+    /** The segments after a module page's own, decoded: `/logs/a` carries `['a']`. */
+    pagePath?: string[];
+    /**
+     * The one project every page shows (#1513), by id; absent when every project shows. Carried as
+     * `?project=<id>`. On a project's own pages it is that project or absent, never another one.
+     */
+    scope?: string;
+}
+/**
+ * Read the route out of a URL's path and query. Anything unparseable is the Overview, and extra
+ * segments are ignored. A project's own page scoped to another project is scoped to its own.
+ */
+export declare function parseRoute(url: string): Route;
+/** The URL for a route, its path and its query — the inverse of {@link parseRoute}. */
+export declare function formatRoute(route: Route): string;
+/**
+ * `url` with the query parameters of `search` that are not the route's own added to it: what a
+ * module's page mirrored there (a list's filters) stays when only the picked project changes.
+ */
+export declare function keepPageQuery(url: string, search: string): string;

package/dist/module-types/dashboard/lib/rpc.d.ts

@@ -0,0 +1,31 @@
+import type { LiveFeedEvent } from '../../src/dashboard-rpc/index.js';
+/**
+ * A typed stub for one RPC. `F` is the implementation's own signature, so the call is checked
+ * against the real thing and a rename that misses a caller is a type error rather than a 404.
+ *
+ * Arguments and return value go through JSON, which is what they always did — the wire has no
+ * opinion about `Date` or `Map` here because none of these RPCs pass one.
+ */
+export declare function rpc<F extends (...args: never[]) => unknown>(name: string): (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>;
+/**
+ * A live feed of one agent's events.
+ *
+ * The contract the dashboard relies on, unchanged from the Channel it replaced: `listen` per
+ * event, and `onClose` telling a clean end (the server is done — an unknown project, a finished
+ * relay stream) apart from a dropped one (retry with backoff). That distinction is the whole
+ * reason the feed can say "the daemon is not answering" instead of looking like a quiet agent.
+ */
+export interface EventChannel {
+    listen(onEvent: (event: LiveFeedEvent) => void): void;
+    onClose(onClosed: (err?: Error) => void): void;
+    close(): void;
+}
+/**
+ * Subscribe to an agent's events over SSE. Rejects when the subscription itself fails, which the
+ * caller retries; a stream that opens and later dies closes with an error instead.
+ *
+ * Read with `fetch` rather than `EventSource` because `EventSource` reconnects on its own
+ * schedule, which would fight the caller's backoff and erase the clean-vs-dropped distinction —
+ * it reports every end as an error and retries even the ones that meant "done".
+ */
+export declare function openEvents(projectId: string, agentId?: string): Promise<EventChannel>;

package/dist/module-types/dashboard/lib/use-action.d.ts

@@ -0,0 +1,25 @@
+/**
+ * What an action did: `ok` says whether it succeeded, and only then is there a `value`.
+ *
+ * Said as a pair rather than as "the value, or `undefined` when it did not succeed", because an
+ * action that succeeds with nothing to report is not a failure: with the value alone, a `sendStop`
+ * that resolves void was indistinguishable from one that threw, and every such caller had to map
+ * its success to a stand-in value to tell the two apart.
+ */
+export type ActionOutcome<T> = {
+    ok: true;
+    value: Succeeded<T>;
+} | {
+    ok: false;
+};
+/** What is left of an action's result once its own refusal branch is ruled out. */
+type Succeeded<T> = Exclude<T, {
+    ok: false;
+}>;
+export declare function useAction(): {
+    busy: boolean;
+    error: string | null;
+    reset: () => void;
+    run: <T>(fn: () => Promise<T>, fallback?: string) => Promise<ActionOutcome<T>>;
+};
+export {};

package/dist/module-types/dashboard/lib/use-async.d.ts

@@ -0,0 +1,45 @@
+import { type DependencyList } from 'react';
+/**
+ * What a read shows when its deps change, until the new answer lands. By default, nothing: the
+ * `initial` value, so one target's data is never shown as another's.
+ *
+ * - `'previous'`: the last answer, whatever it was for. For a read whose target barely matters
+ *   to the eye (the git host page of a project), where blanking would only flicker.
+ * - `{ remember: key }`: the last answer read under this key, marked loaded, or nothing when no
+ *   answer was. For a page a person goes back and forth between (a run's facts): going back shows
+ *   what was read last time at once, and the read is made again all the same, so it is replaced
+ *   the moment the fresh answer lands. The key names the target, so no other target's answer is
+ *   ever shown.
+ */
+export type Keep = 'previous' | {
+    remember: string;
+};
+/** Forget the answer remembered under a key, for a target known to have changed since; with no key, every answer (for tests). */
+export declare function forgetRemembered(key?: string): void;
+/**
+ * Read an answer before the page that shows it is opened, and keep it under its key: the page
+ * then shows it in its first frame, and reads it again all the same. Nothing is read for a key
+ * that already holds an answer.
+ */
+export declare function readAhead<T>(key: string, load: () => Promise<T>): void;
+/**
+ * Read once, and again whenever `deps` change.
+ *
+ * Pass `null` for `load` when there is nothing to read yet (no project selected): the
+ * value stays `initial` and no read is made. `load` must close over exactly `deps`.
+ */
+export declare function useLoaded<T>(load: (() => Promise<T>) | null, initial: T, deps: DependencyList, keep?: Keep): T;
+/**
+ * Read now, again every `everyMs`, and again whenever `deps` change. Polling stops on
+ * unmount. `reload` reads immediately, for when a local action means the next tick is
+ * too late to wait for, and settles once that read has answered.
+ *
+ * Pass `null` for `load` when there is nothing to read yet. `load` must close over
+ * exactly `deps`. `loaded` is false until the first successful read, and again after
+ * a dep change — for callers that must tell "not there" from "not read yet".
+ */
+export declare function usePolled<T>(load: (() => Promise<T>) | null, initial: T, everyMs: number, deps: DependencyList, keep?: Keep): {
+    value: T;
+    reload: () => Promise<void>;
+    loaded: boolean;
+};

package/dist/module-types/dashboard/lib/use-modules.d.ts

@@ -0,0 +1,78 @@
+import type { LinkAction, ModuleCard, ModulePage, ModulePanel, ModuleRunSlots, ModuleSettings, ModuleUsageLimit } from '../module/index.js';
+/** A module page as the shell mounts it: the page, plus the package it came from and the projects that have it. */
+export interface MountedPage extends ModulePage {
+    package: string;
+    projects: string[];
+}
+/** A link action as the shell mounts it (#1774): the action, plus the package it came from and the projects that have it. */
+export interface MountedLinkAction extends LinkAction {
+    package: string;
+    projects: string[];
+}
+/** A card as the shell mounts it (#1818): the card, plus the package it came from and the projects that have it. */
+export interface MountedCard extends ModuleCard {
+    package: string;
+    projects: string[];
+}
+/** A side-rail tab as the shell mounts it: the tab, plus the package it came from and the projects that have it. */
+export interface MountedPanel extends ModulePanel {
+    package: string;
+    projects: string[];
+}
+/** A module's run slots as the shell mounts them: the slots, plus the package they came from and the projects that have it. */
+export interface MountedRunSlots extends ModuleRunSlots {
+    package: string;
+    projects: string[];
+}
+/** A Settings section as the shell mounts it: the section, plus the package it came from and the projects that have it. */
+export interface MountedSettings extends ModuleSettings {
+    package: string;
+    projects: string[];
+}
+/** A usage bar stop line as the shell mounts it: the line's read and save, plus the package it came from and the projects that have it. */
+export interface MountedUsageLimit extends ModuleUsageLimit {
+    package: string;
+    projects: string[];
+}
+/** What the installed modules bring, once loaded: their pages, their cards and their link actions. */
+export interface MountedModules {
+    pages: MountedPage[];
+    /** The Overview's cards, in the order they are drawn: by `order`, then by package name. */
+    cards: MountedCard[];
+    linkActions: MountedLinkAction[];
+    /** The side-rail tabs, in package order. */
+    panels: MountedPanel[];
+    /** The run slots, one entry per module that has any, in package order. */
+    runSlots: MountedRunSlots[];
+    /** The Settings page's sections, in the order they are drawn: by `order`, then by package name. */
+    settings: MountedSettings[];
+    /** The usage bar's stop line: the first module's that declares one, in package order; absent when none does. */
+    usageLimit?: MountedUsageLimit;
+    /** True once the module list was read and every module in it imported or skipped. */
+    loaded: boolean;
+}
+/** The order cards and Settings sections are drawn in: by `order` (50 when unsaid), then by package name. */
+export declare function byMountOrder(a: {
+    order?: number;
+    package: string;
+}, b: {
+    order?: number;
+    package: string;
+}): number;
+/**
+ * What the registered projects' modules add (#1774), in package order: the pages, a segment two
+ * modules claim going to the first, the cards (#1818), sorted by their order then their package, the link actions, the side-rail tabs, the run slots, the Settings sections (sorted as the cards are) and the usage bar's stop line (the first module's that declares one),
+ * every one of them, each carrying the package it came from and the projects that have it. `loaded` is false until the module list has
+ * been read and every module in it imported, so the shell can tell "no such page" from "not
+ * loaded yet".
+ */
+export declare function useModules(): MountedModules;
+/**
+ * The mounted modules, for any component in the shell (#1774): the shell reads them once with
+ * {@link useModules} and provides them here, so a page deep in the tree finds the link actions
+ * without the shell threading them through every prop. Outside the provider: nothing mounted,
+ * not loaded.
+ */
+export declare const ModulesContext: import("react").Context<MountedModules>;
+/** The installed modules' pages and link actions, as the shell mounted them. */
+export declare function useMountedModules(): MountedModules;

package/dist/module-types/dashboard/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from 'clsx';
+/** shadcn's class combiner: merge conditional classes, de-duping Tailwind conflicts. */
+export declare function cn(...inputs: ClassValue[]): string;