@nanmicoder/dsh-skills-hub 0.0.1

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

@@ -0,0 +1,106 @@
+/**
+ * Skills Hub HTTP client (browser half).
+ *
+ * Every request goes to the Host surface documented in docs/CONTRACT.md §5.2:
+ * one prefix route under `/api/skills-hub`, JSON in and JSON out, errors always
+ * shaped `{ error: { code, message } }`.
+ *
+ * Client purity: this module imports *types only* from the shared wire layer —
+ * never a value from the Host's `src/market/*`, which would drag Node code into
+ * the browser bundle (contract §2).
+ */
+import type { MarketFileContent, MarketListResult, MarketSource, NormalizedSkill, NormalizedSkillDetail, SecurityStatus, SourceStatusInfo } from '../market/types.ts';
+/**
+ * Structural mirror of the Host's `InstalledSkillRecord`
+ * (`src/skills/installed.ts`, contract §5.2).
+ *
+ * Declared here instead of `import type`-ing the Host module on purpose: that
+ * module reads the filesystem through `node:fs`, so pulling it into the browser
+ * program would drag Node-only code (and its missing `node:*` declarations)
+ * across the client purity boundary. The client only ever *reads* this shape out
+ * of JSON, so a structural mirror is sufficient — the wire contract stays the
+ * single source of truth.
+ */
+export interface InstalledSkillRecord {
+    key: string;
+    linked: boolean;
+    removable: boolean;
+    /** `source:slug` when the provenance sidecar exists, else `local:<dir>`. */
+    id: string;
+    source: MarketSource | 'local';
+    slug: string;
+    name: string;
+    dirName: string;
+    dirPath: string;
+    version?: string;
+    summary?: string;
+    installedAt?: string;
+    /** Installed by this plugin (the `.skills-hub.json` sidecar is present). */
+    managed: boolean;
+    bytes: number;
+    fileCount: number;
+}
+/** List query accepted by `GET /api/skills-hub/skills`. */
+export interface MarketQuery {
+    q?: string;
+    source: 'all' | MarketSource;
+    security: 'all' | SecurityStatus;
+    installed: 'all' | 'installed' | 'installable';
+    cursor?: string;
+    limit?: number;
+}
+/** One failure from the Skills Hub surface (transport, HTTP, or malformed body). */
+export declare class SkillsHubApiError extends Error {
+    /** Host error code (`MARKET_ERROR_CODES` value, `BAD_REQUEST`, …) or a client-side code. */
+    readonly code: string;
+    /** HTTP status; `0` when the request never reached the Host. */
+    readonly status: number;
+    constructor(code: string, status: number, message: string);
+}
+/**
+ * Whether a rejection is an aborted request.
+ *
+ * `AbortError` is control flow, not a failure: the controller aborts superseded
+ * requests on purpose, and surfacing one as a user-facing error would put a
+ * spurious banner in front of a perfectly healthy panel. Checked by `name`
+ * (not `instanceof`) because an abort may cross realms (iframes, workers).
+ * Exported so the state layer applies the exact same rule.
+ */
+export declare function isAbortError(error: unknown): boolean;
+/** Search the catalogue (market sources) — the remote list page. */
+export declare function fetchMarketList(query: MarketQuery, signal?: AbortSignal): Promise<MarketListResult>;
+/** One skill's full detail plus the health of the source that served it. */
+export declare function fetchSkillDetail(id: string, signal?: AbortSignal): Promise<{
+    skill: NormalizedSkillDetail;
+    sourceStatus: SourceStatusInfo;
+}>;
+/** One file of a skill, for the Files tab. */
+export declare function fetchSkillFile(id: string, path: string, signal?: AbortSignal): Promise<MarketFileContent>;
+/** Health of every market source, refreshed independently of the list. */
+export declare function fetchSourceStatus(signal?: AbortSignal): Promise<Record<MarketSource, SourceStatusInfo>>;
+/**
+ * Every skill DSH can currently see, including directories this plugin did not
+ * install (`managed: false`). This is the local index behind the "installed"
+ * filter — no upstream request is involved.
+ */
+export declare function fetchInstalled(signal?: AbortSignal): Promise<InstalledSkillRecord[]>;
+/** Install a market skill into the local skills directory. */
+export declare function installSkill(id: string): Promise<{
+    installedPath: string;
+    skill: NormalizedSkill;
+}>;
+/** Remove a skill this plugin installed (the Host refuses unmanaged directories). */
+export declare function uninstallSkill(id: string): Promise<{
+    removedPath: string;
+    skill: NormalizedSkill;
+}>;
+/** Preview the exact local copy without consulting a market provider. */
+export declare function fetchInstalledDetail(key: string, signal?: AbortSignal): Promise<{
+    item: InstalledSkillRecord;
+    markdown: string;
+}>;
+/** Remove a specifically selected local entry after the management UI confirmation. */
+export declare function removeInstalled(key: string): Promise<{
+    item: InstalledSkillRecord;
+    removedPath: string;
+}>;

package/lib/types/client/components/FilterBar.d.ts

@@ -0,0 +1,20 @@
+import type { MarketFilters } from '../state.ts';
+/**
+ * Search field plus the three catalogue filters.
+ *
+ * Native `<select>`s rather than a menu primitive: the DSH `Menu` is an
+ * anchored popover that needs its own open state and focus return, and three
+ * of them side by side would be three focus traps in a row. A `<select>` gets
+ * platform keyboard behaviour, a real label association, and renders inside a
+ * 720px panel without a portal.
+ *
+ * The result count is announced through a visually hidden live region instead
+ * of being printed twice: the visible count lives in the home header, and a
+ * screen reader still hears it change when a filter narrows the list.
+ */
+export declare function FilterBar(props: {
+    filters: MarketFilters;
+    total: number;
+    disabled: boolean;
+    onChange: (patch: Partial<MarketFilters>) => void;
+}): JSX.Element;

package/lib/types/client/components/FrontmatterPanel.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Structured view of a SKILL.md frontmatter block.
+ *
+ * SKILL.md metadata is data, not prose: pushing it through the markdown
+ * renderer turns a dozen short fields into a wall of setext headings. It is
+ * also reference material rather than the document itself, so it renders as a
+ * label/value list under its own heading, with the list itself scrolling once a
+ * skill declares more than a screenful of keys.
+ *
+ * `data` is typed `unknown`-valued on purpose — it is upstream YAML, and every
+ * cell is derived defensively rather than trusted.
+ */
+export declare function FrontmatterPanel(props: {
+    data: Record<string, unknown>;
+}): JSX.Element;

package/lib/types/client/components/InstallConfirmDialog.d.ts

@@ -0,0 +1,31 @@
+import type { MarketSource, SecurityStatus } from '../../market/types.ts';
+/** The subset of a skill the confirmation needs; the caller owns the source object. */
+export interface InstallConfirmSkill {
+    id: string;
+    name: string;
+    source: MarketSource;
+    version?: string;
+    securityStatus: SecurityStatus;
+    authorName: string;
+}
+/**
+ * Install confirmation.
+ *
+ * Mounted only while a confirmation is pending — the frozen props carry no
+ * `skill | null` and no `open`, so the caller's conditional render *is* the
+ * open state (the optional `open` prop exists only for a caller that prefers
+ * to keep the element mounted).
+ *
+ * Escape and mask-click closing come from `Modal` itself; while `busy` both
+ * are neutralised and the buttons are disabled, because an install already in
+ * flight cannot be recalled and a dialog that vanishes mid-request reads as a
+ * cancel that never happened.
+ */
+export declare function InstallConfirmDialog(props: {
+    skill: InstallConfirmSkill;
+    busy: boolean;
+    onCancel: () => void;
+    onConfirm: () => void;
+    /** Optional: defaults to open, since conditional mounting is the usual call site. */
+    open?: boolean;
+}): JSX.Element;

package/lib/types/client/components/InstallStateBadge.d.ts

@@ -0,0 +1,11 @@
+import type { InstallState } from '../../market/types.ts';
+/**
+ * Local install state chip.
+ *
+ * The three labels come from dictionary keys the contract already fixes —
+ * `installed`, `installed.installable` and `notInstallable` — so this badge
+ * adds no vocabulary of its own.
+ */
+export declare function InstallStateBadge(props: {
+    state: InstallState;
+}): JSX.Element;

package/lib/types/client/components/InstalledSkills.d.ts

@@ -0,0 +1,3 @@
+export declare function InstalledSkills({ onChanged }: {
+    onChanged: () => void;
+}): JSX.Element;

package/lib/types/client/components/MarkdownView.d.ts

@@ -0,0 +1,4 @@
+/** Self-contained GFM rendering for untrusted marketplace and local skill docs. */
+export declare function MarkdownView({ content }: {
+    content: string;
+}): JSX.Element;

package/lib/types/client/components/MarketDisclaimer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Third-party risk notice shown above the catalogue until it is acknowledged.
+ *
+ * Purely presentational: persistence (`localStorage`, `disclaimerDismissed`)
+ * belongs to the controller, so this component stays reusable in a bare test
+ * render and cannot drift from the stored flag.
+ */
+export declare function MarketDisclaimer(props: {
+    onDismiss: () => void;
+}): JSX.Element;

package/lib/types/client/components/MarketHome.d.ts

@@ -0,0 +1,12 @@
+import type { MarketState, MarketController } from '../state.ts';
+/**
+ * Market catalogue page.
+ *
+ * Presentational by contract: every interaction below is a call on the
+ * controller, and every rendered value comes from `state`. That keeps the
+ * whole page renderable in a bare test render with no services and no fetch.
+ */
+export declare function MarketHome(props: {
+    state: MarketState;
+    controller: MarketController;
+}): JSX.Element;

package/lib/types/client/components/SecurityBadge.d.ts

@@ -0,0 +1,16 @@
+import type { SecurityReport, SecurityStatus } from '../../market/types.ts';
+/**
+ * Audit verdict chip.
+ *
+ * Shows a shield for every verdict except `flagged`, which uses the warning
+ * triangle: a scan that found something must not look like a scan that merely
+ * ran, and shape reads faster than color alone.
+ *
+ * `reports` supplies the upstream status line for the hover title, so the chip
+ * can stay a two-word summary without hiding what the vendor actually said.
+ */
+export declare function SecurityBadge(props: {
+    status: SecurityStatus;
+    reports?: SecurityReport[];
+    compact?: boolean;
+}): JSX.Element;

package/lib/types/client/components/SkillAvatar.d.ts

@@ -0,0 +1,14 @@
+import type { MarketSource } from '../../market/types.ts';
+/**
+ * Skill icon tile.
+ *
+ * An `<img>` is rendered only for an `https:` URL: the string arrives from a
+ * third-party catalogue, and allowing `javascript:` or `data:` here would turn
+ * an upstream payload into script execution inside the DSH page.
+ */
+export declare function SkillAvatar(props: {
+    name: string;
+    source: MarketSource;
+    iconUrl?: string;
+    size: number;
+}): JSX.Element;

package/lib/types/client/components/SkillCard.d.ts

@@ -0,0 +1,17 @@
+import type { NormalizedSkill } from '../../market/types.ts';
+/**
+ * One catalogue card.
+ *
+ * The open affordance is a single stretched `<button>` behind the content
+ * instead of a click handler on the `<article>`: it is focusable, Enter/Space
+ * work for free, and the card never pretends a div is a link. That button sits
+ * under the content, so the content is `pointer-events: none` and the install
+ * control opts back in — without that pair, either the card stops opening or
+ * the install button becomes unclickable.
+ */
+export declare function SkillCard(props: {
+    skill: NormalizedSkill;
+    installing: boolean;
+    onOpen: (id: string) => void;
+    onInstall?: (id: string) => void;
+}): JSX.Element;

package/lib/types/client/components/SkillDetailView.d.ts

@@ -0,0 +1,21 @@
+import type { NormalizedSkillDetail } from '../../market/types.ts';
+import type { MarketController, MarketState } from '../state.ts';
+/**
+ * Skill detail page.
+ *
+ * Like the home page this component owns no data: the tab, the selected file
+ * and the file contents all live in `MarketState`, so switching tabs or
+ * re-opening a skill does not lose its place.
+ *
+ * The bundled GFM renderer handles catalogue Markdown without relying on a
+ * host renderer delegate. Raw HTML is disabled and URLs use its safe default.
+ */
+export declare function SkillDetailView(props: {
+    detail: NormalizedSkillDetail;
+    state: MarketState;
+    controller: MarketController;
+}): JSX.Element;
+/** Keeps the detail layout stable while its network request is in flight. */
+export declare function SkillDetailSkeleton({ onBack }: {
+    onBack: () => void;
+}): JSX.Element;

package/lib/types/client/components/SourceStatusBar.d.ts

@@ -0,0 +1,13 @@
+import type { MarketSource, SourceStatusInfo } from '../../market/types.ts';
+/**
+ * Per-source health strip.
+ *
+ * The upstream error string rides the pill's `title` instead of being printed:
+ * a 720px panel has no room for a stack trace next to two source names, and an
+ * operator who needs it can hover.
+ */
+export declare function SourceStatusBar(props: {
+    sources: Record<MarketSource, SourceStatusInfo>;
+    onRefresh: () => void;
+    refreshing: boolean;
+}): JSX.Element;

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

@@ -0,0 +1,71 @@
+/**
+ * Inline SVG icon set for the Skills Hub panel.
+ *
+ * The reference implementation used `lucide-react`; this plugin may not add a
+ * dependency for fifteen glyphs, so every icon is drawn here as a stroked
+ * `currentColor` SVG. Drawing rules kept uniform on purpose — a mixed set of
+ * stroke widths and caps is the fastest way for a ported UI to look alien:
+ *  - 16x16 viewBox (20x20 for the sidebar glyph, which the shell renders at 16-20px),
+ *  - `fill: none` + `stroke: currentColor` so an icon inherits its parent's
+ *    token-driven color and stays correct in both themes,
+ *  - 1.5 default stroke width (`1.75` where a heavier weight is needed),
+ *  - `aria-hidden` always: every icon here is decorative and either sits next
+ *    to a text label or inside a control that carries its own accessible name.
+ */
+/** Props shared by every icon: pixel box and an optional extra class. */
+export interface SkillsHubIconProps {
+    /** Rendered width and height in px. Defaults to 16. */
+    size?: number;
+    /** Extra class for placement; the icon owns only its own geometry. */
+    className?: string;
+}
+/** Props of the sidebar entry glyph, which the shell marks as selected. */
+export interface SkillsHubPanelIconProps extends SkillsHubIconProps {
+    /**
+     * Selected-panel state, injected by `sidebar.panellist` for the active row.
+     * Only the glyph's weight and awning fill change — color stays `currentColor`
+     * so the sidebar keeps ownership of the row's token colors.
+     */
+    active?: boolean;
+}
+/**
+ * Sidebar entry glyph: a shop awning over a storefront.
+ *
+ * Drawn on a 20px grid rather than 16 so the awning scallops stay legible at
+ * the 20px the shell may use for a wide sidebar; at 16px it scales down
+ * cleanly because every edge is axis-aligned or a single arc.
+ *
+ * Renders a bare `<svg>` and never a button: `sidebar.panellist` entries are
+ * rendered inside the sidebar's own `<button>` (see `PanelRow` in
+ * `dsh-client-ui-sidebar/lib/client.js`), so an interactive wrapper here would
+ * nest a control inside a control.
+ */
+export declare function SkillsHubIcon({ size, active, className }: SkillsHubPanelIconProps): JSX.Element;
+/** Magnifier: search input affordance. */
+export declare function SearchIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Arrow into a tray: install action and the download count. */
+export declare function DownloadIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Five-point star: star count. */
+export declare function StarIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Waste bin: uninstall action. */
+export declare function TrashIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Shield outline: audit / security status. */
+export declare function ShieldIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Left arrow: back to the catalogue. */
+export declare function ArrowLeftIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Circular arrow pair: re-fetch list or source health. */
+export declare function RefreshIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Two stacked sheets: copy file content. */
+export declare function CopyIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Tick: copied confirmation and the installed state. */
+export declare function CheckIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Document with a folded corner: a skill file. */
+export declare function FileIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Warning triangle: errors and flagged skills. */
+export declare function AlertIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Chevron: disclosure affordance on a selectable row. */
+export declare function ChevronRightIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Diagonal cross: dismiss a banner, clear the search field. */
+export declare function CloseIcon({ size, className }: SkillsHubIconProps): JSX.Element;
+/** Price tag: leading glyph of a card's tag row. */
+export declare function TagIcon({ size, className }: SkillsHubIconProps): JSX.Element;

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

@@ -0,0 +1,56 @@
+/**
+ * Skills Hub, browser half.
+ *
+ * Two registrations, exactly the shape `@deepseek-ai/dsh-client-ui-plugin-manager`
+ * uses for its own panel (read from
+ * `.../dsh-client-ui-plugin-manager/lib/client.js`, same DSH version):
+ *
+ *   ctx.slots.inject('main', function* () { yield ctx.slots.register({ name: 'main', key: PANEL_ID, … }, MarketPage) })
+ *   ctx.slots.inject('sidebar.panellist', () => ctx.slots.register({ name: 'sidebar.panellist', id: PANEL_ID, order, label, … }, SkillsHubIcon))
+ *
+ * `slots.inject` waits for the declaring entry (the frame declares `main`, the
+ * sidebar declares `sidebar.panellist`) and keeps the registration on this
+ * plugin's fiber, so unloading the plugin removes both contributions.
+ *
+ * Selecting the panel is **not** done here: the sidebar renders each
+ * `sidebar.panellist` entry inside its own `<button>` whose click calls
+ * `selectPanel(id)` → `ctx.layout.selectPanel(id)`
+ * (`.../dsh-client-ui-sidebar/lib/client.js`, `PanelRow` ≈ line 173 and the
+ * injected `selectPanel` ≈ line 483). Because our entry `id` equals the `main`
+ * registration key, that call opens this panel; adding our own button or a
+ * second `selectPanel` call would nest interactive elements and fight the shell.
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface SlotMap {
+        /**
+         * Global panel icon rows of the sidebar.
+         *
+         * Declared here because `@deepseek-ai/dsh-client-ui-sidebar` (the package that
+         * owns this slot) is not a dependency of this plugin: the registration below
+         * needs the slot key to exist in the contract table, and `slots.inject` waits
+         * for the sidebar to declare it at runtime. The owner share is the sidebar's
+         * own (`SidebarPanelIconOwnerProps`: requested edge and selection state).
+         */
+        'sidebar.panellist': {
+            kind: 'list';
+            scope: 'root';
+            owner: {
+                size: number;
+                active: boolean;
+            };
+        };
+    }
+}
+/** Stable plugin name of the browser half. */
+export declare const name = "skills-hub-client";
+/**
+ * Services required before the registrations can be made. `slots` is the
+ * registry itself; `locale` owns the dictionary this panel translates through.
+ * `layout` is deliberately absent — the sidebar selects the panel for us.
+ */
+export declare const inject: string[];
+/** Sidebar entry id and `main` slot key — the same value is what links the two. */
+export declare const PANEL_ID = "skills-hub";
+/** Register the sidebar entry and the panel it opens. */
+export declare function apply(ctx: ClientContext): void;

package/lib/types/client/locale-context.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Panel-local locale context.
+ *
+ * The framework hands the translate seat (`t: TranslateNS<NS>`) to the *slot
+ * component* only — `PropsLocale<N>` in
+ * `@deepseek-ai/dsh-client-ui-slots/lib/types/index.d.ts` adds it exactly when a
+ * registration declares `locale: NS`, and nothing propagates it further down the
+ * tree. The presentational components are deliberately prop-shaped (contract
+ * §5.4 gives them no `t`), so `MarketPage` — the one component the slot
+ * machinery calls — publishes its seat here and every descendant reads it.
+ *
+ * A context (rather than prop drilling or a module singleton) is what keeps the
+ * components pure and testable: a test can render any of them under its own
+ * provider without touching the DSH runtime.
+ */
+import { type ReactNode } from 'react';
+/** Translate one dictionary key with optional `{name}` template params. */
+export type Translate = (key: string, params?: Record<string, unknown>) => string;
+/** Publish the slot-injected translate seat to the panel's descendants. */
+export declare function LocaleProvider(props: {
+    t: Translate;
+    children: ReactNode;
+}): JSX.Element;
+/**
+ * Read the panel's translate seat.
+ *
+ * Throws instead of falling back to the raw key: a component rendered outside
+ * the panel would otherwise silently print dictionary keys, which is far harder
+ * to notice than a loud assembly error.
+ */
+export declare function useT(): Translate;

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

@@ -0,0 +1,117 @@
+/**
+ * `skillsHub` dictionaries for the Skills Hub panel.
+ *
+ * Registration mechanics are copied from `dsh-agent-teams/src/client/locales.ts`
+ * (same DSH version): the plugin calls `ctx.locale.register(NS, { zh, en })` and
+ * every registration site that declares `locale: NS` receives the framework's
+ * typed `t` seat. The namespace name is frozen by docs/CONTRACT.md §5.3.
+ */
+/** Dictionary namespace owned by the Skills Hub client plugin. */
+export declare const NS = "skillsHub";
+/**
+ * Simplified Chinese dictionary — the key-set source of truth.
+ *
+ * Kept as an unexported literal so `en` below can be *checked* against its exact
+ * key union while `zh` itself is exported as the plain `Record<string, string>`
+ * the contract §5.3 declares (the literal type would otherwise leak into every
+ * consumer, including the components workstream).
+ */
+declare const zhDictionary: {
+    installedTitle: string;
+    marketTab: string;
+    installedScope: string;
+    installedSearch: string;
+    refreshInstalled: string;
+    installedEmpty: string;
+    localSkill: string;
+    linkedSkill: string;
+    viewInstalled: string;
+    localUninstallDescription: string;
+    unlinkDescription: string;
+    uninstalling: string;
+    panel: string;
+    title: string;
+    subtitle: string;
+    searchPlaceholder: string;
+    clearSearch: string;
+    'source.all': string;
+    'source.clawhub': string;
+    'source.skillhub': string;
+    'security.all': string;
+    'security.verified': string;
+    'security.benign': string;
+    'security.unknown': string;
+    'security.flagged': string;
+    'installed.all': string;
+    'installed.installed': string;
+    'installed.installable': string;
+    'filter.source': string;
+    'filter.security': string;
+    'filter.installed': string;
+    count: string;
+    loading: string;
+    loadingMore: string;
+    loadMore: string;
+    loadMoreError: string;
+    empty: string;
+    emptyHint: string;
+    emptySearch: string;
+    emptySearchHint: string;
+    error: string;
+    retry: string;
+    install: string;
+    installing: string;
+    installed: string;
+    notInstallable: string;
+    uninstall: string;
+    uninstallConfirm: string;
+    uninstallTitle: string;
+    uninstallDescription: string;
+    installConfirmMessage: string;
+    installLocation: string;
+    cancel: string;
+    confirm: string;
+    close: string;
+    back: string;
+    overview: string;
+    files: string;
+    security: string;
+    viewReport: string;
+    frontmatter: string;
+    footnotes: string;
+    author: string;
+    downloads: string;
+    installs: string;
+    stars: string;
+    updated: string;
+    license: string;
+    version: string;
+    disclaimer: string;
+    dismiss: string;
+    'sourceStatus.ok': string;
+    'sourceStatus.degraded': string;
+    'sourceStatus.failed': string;
+    'sourceStatus.cached': string;
+    installDone: string;
+    uninstallDone: string;
+    noFiles: string;
+    fileTooLarge: string;
+    copy: string;
+    copied: string;
+    unoaudited: string;
+};
+/** Simplified Chinese dictionary. */
+export declare const zh: Record<string, string>;
+/**
+ * English dictionary. Typed against the Chinese key union so a missing or extra
+ * key is a compile error — the locale runtime requires bilingual balance and
+ * would otherwise throw at registration time.
+ */
+export declare const en: Record<keyof typeof zhDictionary, string>;
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Skills Hub panel copy. */
+        skillsHub: string;
+    }
+}
+export {};

package/lib/types/client/page/MarketPage.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Skills Hub panel root.
+ *
+ * Responsibilities, and nothing else:
+ *  - own exactly one controller per mounted panel instance (`props.useMarketController`);
+ *  - route `state.view` to `MarketHome` or `SkillDetailView`;
+ *  - render the install confirmation the controller asked for;
+ *  - render one notice toast for `state.notice`.
+ *
+ * This is also the only component the slot machinery calls, so it is the only
+ * place that receives the framework's `t` seat (`PropsLocale<NS>`); it publishes
+ * that seat through `LocaleProvider` for every descendant, which keeps the
+ * presentational components free of slot props (contract §5.4).
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import { NS } from '../locales.ts';
+import { type MarketPageInjected } from '../state.ts';
+/** Composed props of the `main` registration: the injected business face plus the locale seat. */
+export type MarketPageProps = MarketPageInjected & PropsLocale<typeof NS>;
+/** Panel entry: bind the controller and publish the locale seat. */
+export declare function MarketPage(props: MarketPageProps): JSX.Element;

package/lib/types/client/skill-markdown.d.ts

@@ -0,0 +1,2 @@
+/** Frontmatter is metadata, not part of the skill's rendered instructions. */
+export declare function stripSkillFrontmatter(markdown: string): string;