@prettier-ai/dsh-client-ui-settings-plugins 0.1.2-alpha.1

package/lib/index.js

@@ -0,0 +1,13 @@
+//#region lib/types/index.js
+/**
+* Plugins settings surface, node half. The empty apply exists so the plugin
+* appears in the host cordis.yml / Loader; the browser half owns the section
+* and its configurable tab through exports["./client"], discovered from the
+* package.json dsh.client declaration. Every section this page edits is owned
+* by the Host plugin that registered it, so this package registers no
+* namespace of its own.
+*/
+/** Host plugin body — no host-side behavior for this surface plugin. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/invariant.js

@@ -0,0 +1,24 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@prettier-ai/dsh-client-ui-settings-plugins`.
+* @module @prettier-ai/dsh-client-ui-settings-plugins/invariant
+*/
+const PACKAGE_NAME = "@prettier-ai/dsh-client-ui-settings-plugins";
+/** Cordis companion plugin name. */
+const name = "client-ui-settings-plugins-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: this is a browser-side settings surface whose node half owns no event
+* stream or mutable runtime data; the layering and write refusals are Host contracts covered by
+* the owning plugins and the api-proxy.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

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

@@ -0,0 +1,12 @@
+/** The agent loop's card: how many tool calls one step may run at once. */
+import type { InjectFace, PropsLocale, PropsRuntime } from '@prettier-ai/dsh-client-ui-slots';
+import type { AgentLoopCardFace } from './agent-loop-card-controller.ts';
+/** Props the renderer binds for the agent-loop card. */
+export type AgentLoopCardProps = PropsRuntime<'settings.plugin.item'> & PropsLocale<'settings.plugins'> & InjectFace<AgentLoopCardFace>;
+/**
+ * Render the agent-loop card.
+ * @param props - locale copy, the card snapshot, and its form actions.
+ * @returns the card.
+ */
+export declare function AgentLoopCard(props: AgentLoopCardProps): import("react").JSX.Element;
+//# sourceMappingURL=AgentLoopCard.d.ts.map

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

@@ -0,0 +1,12 @@
+/** The shell plugin's card: the limits every command the agent runs is bound by. */
+import type { InjectFace, PropsLocale, PropsRuntime } from '@prettier-ai/dsh-client-ui-slots';
+import type { BashCardFace } from './bash-card-controller.ts';
+/** Props the renderer binds for the shell card. */
+export type BashCardProps = PropsRuntime<'settings.plugin.item'> & PropsLocale<'settings.plugins'> & InjectFace<BashCardFace>;
+/**
+ * Render the shell card.
+ * @param props - locale copy, the card snapshot, and its form actions.
+ * @returns the card.
+ */
+export declare function BashCard(props: BashCardProps): import("react").JSX.Element;
+//# sourceMappingURL=BashCard.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * Configurable Host plugins contributed to the shared Plugins section.
+ *
+ * The tab enumerates settings namespaces but never interprets one — a card
+ * arrives through `settings.plugin.item` keyed by the namespace it edits, so a
+ * plugin that ships a browser half owns its own card and this tab only decides
+ * which keys to dispatch.
+ */
+import type { InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime } from '@prettier-ai/dsh-client-ui-slots';
+import type { ConfigurablePluginsTabFace } from './tab-store.ts';
+/** Props the renderer binds for the configurable tab. */
+export type ConfigurablePluginsTabProps = PropsRuntime<'settings.plugins.tab'> & PropsLocale<'settings.plugins'> & PropsRenderSlots<'settings.plugin.item'> & InjectFace<ConfigurablePluginsTabFace>;
+/**
+ * Render cards registered by plugins that expose editable settings.
+ * @param props - locale copy, slot rendering, and the namespaces to dispatch.
+ * @returns the card list, or the empty line once the Host has answered.
+ */
+export declare function ConfigurablePluginsTab(props: ConfigurablePluginsTabProps): import("react").JSX.Element | null;
+//# sourceMappingURL=ConfigurablePluginsTab.d.ts.map

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

@@ -0,0 +1,42 @@
+/**
+ * One plugin's card: a header naming the plugin and what its settings govern,
+ * disclosing that plugin's controls in place, with the save that writes them.
+ *
+ * The header is its own button rather than a shared disclosure row because a
+ * card stacks its name over its description, while that row lays the two side
+ * by side — the layout, not the behavior, is what differs. Disclosure is
+ * card-local state: which card a user has open is a reading gesture, not
+ * something the Host or the section has any stake in. Staged edits outlive
+ * collapsing, so the header marks a card holding unsaved edits.
+ *
+ * A card renders nothing while its namespace is unavailable: a deployment that
+ * does not compose the owning plugin should show no trace of it, rather than a
+ * disabled card the user cannot act on.
+ */
+import { type ReactNode } from 'react';
+import type { CardShell } from './card-form.ts';
+import type { PluginsSettingsLocaleKey } from './locales.ts';
+/** Card chrome shared by every plugin section. */
+export interface PluginCardProps {
+    /** Locale reader for this section's copy. */
+    t: (key: PluginsSettingsLocaleKey) => string;
+    /** Locale key of the plugin's name. */
+    titleKey: PluginsSettingsLocaleKey;
+    /** Locale key of the line describing what this plugin's settings govern. */
+    descriptionKey: PluginsSettingsLocaleKey;
+    /** The card's form state: availability, writability, and what a save would do. */
+    state: CardShell;
+    /** Write every staged edit. */
+    onSave: () => void;
+    /** Drop every staged edit. */
+    onDiscard: () => void;
+    /** The plugin's controls. */
+    children: ReactNode;
+}
+/**
+ * Render one plugin card.
+ * @param props - the plugin's copy keys, its form state, and its controls.
+ * @returns the card, or nothing when the namespace is unavailable.
+ */
+export declare function PluginCard(props: PluginCardProps): import("react").JSX.Element | null;
+//# sourceMappingURL=PluginCard.d.ts.map

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

@@ -0,0 +1,27 @@
+/** Plugins settings section: localized tabs around feature-owned pages. */
+import type { HostObservable, InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime } from '@prettier-ai/dsh-client-ui-slots';
+import type { PluginsSettingsLocaleKey } from './locales.ts';
+/** One tab projected from a `settings.plugins.tab` contribution. */
+export interface PluginsSettingsTabEntry {
+    id: string;
+    order: number;
+    label: string;
+}
+/** Registration-side business face for the section. */
+export interface PluginsSettingsSectionInjected {
+    hooks: {
+        /** Ordered, locale-aware projection of the Plugins tab ledger. */
+        tabs: HostObservable<readonly PluginsSettingsTabEntry[]>;
+    };
+}
+/** Props the renderer binds for the section. */
+export type PluginsSettingsSectionProps = PropsRuntime<'settings.section'> & PropsLocale<'settings.plugins'> & PropsRenderSlots<'settings.plugins.tab'> & InjectFace<PluginsSettingsSectionInjected>;
+/** Render one Plugins page whose contents arrive from feature-owned tabs. */
+export declare function PluginsSettingsSection({ t, renderSlot, useTabs }: PluginsSettingsSectionProps): import("react").JSX.Element;
+declare module '@prettier-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Plugins section, configurable-tab, and card copy. */
+        'settings.plugins': PluginsSettingsLocaleKey;
+    }
+}
+//# sourceMappingURL=PluginsSettingsSection.d.ts.map

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

@@ -0,0 +1,12 @@
+/** User control for model-selectable subagent delegation in new sessions. */
+import type { InjectFace, PropsLocale, PropsRuntime } from '@prettier-ai/dsh-client-ui-slots';
+import type { SubagentModelSelectionCardFace } from './subagent-model-selection-card-controller.ts';
+/** Props the renderer binds for the subagent model-selection card. */
+export type SubagentModelSelectionCardProps = PropsRuntime<'settings.plugin.item'> & PropsLocale<'settings.plugins'> & InjectFace<SubagentModelSelectionCardFace>;
+/**
+ * Render the default-off preference and its exact adapter-route choices.
+ * @param props - locale copy, the card snapshot, and its toggle action.
+ * @returns the preference card, or nothing when the namespace is unavailable.
+ */
+export declare function SubagentModelSelectionCard(props: SubagentModelSelectionCardProps): import("react").JSX.Element;
+//# sourceMappingURL=SubagentModelSelectionCard.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * The web-search provider's card: its endpoint, its per-request search budget,
+ * and the key — which is written through the credentials domain, never into
+ * the settings section, so the literal never rides a response.
+ */
+import type { InjectFace, PropsLocale, PropsRuntime } from '@prettier-ai/dsh-client-ui-slots';
+import type { WebSearchCardFace } from './web-search-card-controller.ts';
+/** Props the renderer binds for the web-search card. */
+export type WebSearchCardProps = PropsRuntime<'settings.plugin.item'> & PropsLocale<'settings.plugins'> & InjectFace<WebSearchCardFace>;
+/**
+ * Render the web-search card.
+ * @param props - locale copy, the card snapshot, and its form actions.
+ * @returns the card.
+ */
+export declare function WebSearchCard(props: WebSearchCardProps): import("react").JSX.Element;
+//# sourceMappingURL=WebSearchCard.d.ts.map

package/lib/types/client/agent-loop-card-controller.d.ts

@@ -0,0 +1,43 @@
+/** The agent-loop card's staged form over the `agent-loop` settings namespace. */
+import type { SnapshotStore } from '@prettier-ai/dsh-client-store';
+import type { SettingsScope } from '@prettier-ai/dsh-client-ui-settings/client';
+import { type CardActions, type CardFieldState, type CardShell } from './card-form.ts';
+/**
+ * Namespace of the agent loop's user-owned settings. Spelled here rather than
+ * imported: a client package must not depend on a Host package.
+ */
+export declare const AGENT_LOOP_NS = "agent-loop";
+/**
+ * The agent-loop fields this card edits. The Host section carries only this
+ * field — the composed `agents` array is deliberately not part of it.
+ */
+export interface AgentLoopSettings {
+    /** Upper bound on parallel-safe tool calls in flight per step. */
+    maxParallelToolCalls?: number;
+}
+/** What the agent-loop card renders. */
+export interface AgentLoopCardState extends CardShell {
+    /** Parallel tool-call cap. */
+    maxParallelToolCalls: CardFieldState;
+}
+/** The registration-side face the agent-loop card's slot entry injects. */
+export interface AgentLoopCardFace extends CardActions {
+    hooks: {
+        /** Card snapshot bound by the renderer as useAgentLoopCard. */
+        agentLoopCard: SnapshotStore<AgentLoopCardState>;
+    };
+}
+/** Bridges the `agent-loop` scope onto the card's staged form. */
+export declare class AgentLoopCardController {
+    private readonly form;
+    private readonly store;
+    /** @param scope - the bound settings scope for the `agent-loop` namespace. */
+    constructor(scope: SettingsScope<AgentLoopSettings>);
+    private projection;
+    /**
+     * Build the face the card's slot registration injects.
+     * @returns the card's snapshot and its form actions.
+     */
+    inject(): AgentLoopCardFace;
+}
+//# sourceMappingURL=agent-loop-card-controller.d.ts.map

package/lib/types/client/bash-card-controller.d.ts

@@ -0,0 +1,45 @@
+/** The shell card's staged form over the `bash` settings namespace. */
+import type { SnapshotStore } from '@prettier-ai/dsh-client-store';
+import type { SettingsScope } from '@prettier-ai/dsh-client-ui-settings/client';
+import { type CardActions, type CardFieldState, type CardShell } from './card-form.ts';
+/**
+ * Namespace of the shell capability. Spelled here rather than imported: a
+ * client package must not depend on a Host package, and the executor families
+ * that own it spell the same value.
+ */
+export declare const SHELL_NS = "shell";
+/** The shell fields this card edits — a subset of the served schema by design. */
+export interface BashSettings {
+    /** Foreground command timeout in milliseconds. */
+    timeoutMs?: number;
+    /** Per-stream in-memory output cap in bytes. */
+    maxOutputBytes?: number;
+}
+/** What the shell card renders. */
+export interface BashCardState extends CardShell {
+    /** Command timeout in milliseconds. */
+    timeoutMs: CardFieldState;
+    /** Per-stream output cap in bytes. */
+    maxOutputBytes: CardFieldState;
+}
+/** The registration-side face the shell card's slot entry injects. */
+export interface BashCardFace extends CardActions {
+    hooks: {
+        /** Card snapshot bound by the renderer as useBashCard. */
+        bashCard: SnapshotStore<BashCardState>;
+    };
+}
+/** Bridges the `bash` scope onto the shell card's staged form. */
+export declare class BashCardController {
+    private readonly form;
+    private readonly store;
+    /** @param scope - the bound settings scope for the `bash` namespace. */
+    constructor(scope: SettingsScope<BashSettings>);
+    private projection;
+    /**
+     * Build the face the card's slot registration injects.
+     * @returns the card's snapshot and its form actions.
+     */
+    inject(): BashCardFace;
+}
+//# sourceMappingURL=bash-card-controller.d.ts.map

package/lib/types/client/card-form.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Shared form model behind every plugin card.
+ *
+ * A card stages what the user types and writes it only when they save. Each
+ * settings write is a durable, revision-fenced document mutation, so a control
+ * that committed as it settled turned one edit into a write the user never
+ * asked for and could not preview; staged text makes what is on screen exactly
+ * what a save would store.
+ *
+ * A field shows its effective value — the user layer over the composition
+ * layer over the schema default — and whether the user layer carries it. That
+ * presence, not a value comparison, is what marks a field overridden: an
+ * override equal to the composition default is still an override.
+ */
+import { type SnapshotStore } from '@prettier-ai/dsh-client-store';
+import type { SettingsScope } from '@prettier-ai/dsh-client-ui-settings/client';
+/** The write one field's staged text performs when the card is saved. */
+export type FieldWrite = {
+    kind: 'set';
+    value: unknown;
+} | {
+    kind: 'clear';
+};
+/** How one section field converts between its stored value and its draft text. */
+export interface CardFieldSpec {
+    /** Field name inside the namespace section. */
+    field: string;
+    /** Render a stored value as draft text; the empty string when the section carries none. */
+    format: (value: unknown) => string;
+    /**
+     * The write this draft text stages, or undefined when the text is not a
+     * value this field accepts — which blocks the save rather than discarding it.
+     */
+    parse: (text: string) => FieldWrite | undefined;
+}
+/**
+ * A control whose value is written outside the settings section. A credential
+ * literal never rides a response, so its draft has nothing to seed from: it is
+ * blank until typed, and a blank draft writes nothing.
+ */
+export interface CardSecretSpec {
+    /** Field name addressing this control inside the card's form. */
+    field: string;
+    /** Write the staged text; resolves to whether the Host accepted it. */
+    write: (text: string) => Promise<boolean>;
+}
+/** One field as a card's control renders it. */
+export interface CardFieldState {
+    /** Draft text the control renders. */
+    text: string;
+    /**
+     * Whether saving would leave a user-layer entry for this field. A staged
+     * edit answers for itself, so the badge previews the save rather than
+     * reporting a state the pending edit already contradicts.
+     */
+    overridden: boolean;
+    /** Whether the draft is not a value this field accepts, which blocks saving. */
+    invalid: boolean;
+}
+/** Form state every plugin card shares. */
+export interface CardShell {
+    /** False while the namespace is not served to this client; the card renders nothing. */
+    available: boolean;
+    /** Whether the Host document accepts writes. */
+    writable: boolean;
+    /** Whether the form holds edits that a save would write. */
+    dirty: boolean;
+    /** Whether any staged draft is invalid, which blocks the save. */
+    invalid: boolean;
+    /** Whether a save is crossing the wire. */
+    saving: boolean;
+    /** Whether the last save did not land as staged; cleared by the next edit or save. */
+    failed: boolean;
+}
+/** The write actions every plugin card's slot entry injects. */
+export interface CardActions {
+    /** Stage draft text for one field. */
+    edit: (field: string, text: string) => void;
+    /** Stage a clear, so saving lets the field re-inherit the composition layer. */
+    resetField: (field: string) => void;
+    /** Write every staged edit, then re-seed from what the Host accepted. */
+    save: () => void;
+    /** Drop every staged edit. */
+    discard: () => void;
+}
+/**
+ * A whole-number field. An empty draft clears the field; any other draft that
+ * is not a finite number blocks the save.
+ * @param field - field name inside the namespace section.
+ * @returns the field's conversion spec.
+ */
+export declare function numberField(field: string): CardFieldSpec;
+/**
+ * A free-text field. An empty draft clears the field, so emptying the control
+ * and saving is the same gesture as resetting it.
+ * @param field - field name inside the namespace section.
+ * @returns the field's conversion spec.
+ */
+export declare function textField(field: string): CardFieldSpec;
+/**
+ * Stages one card's edits over one settings namespace and writes them on save.
+ *
+ * The form publishes through a snapshot store because slot components read
+ * through a snapshot selector, while both the scope and the local drafts
+ * change underneath; every projection is rebuilt from the two together.
+ */
+export declare class CardForm<T> {
+    private readonly scope;
+    private readonly specs;
+    private readonly secretSpecs;
+    private readonly staged;
+    private readonly listeners;
+    private saving;
+    private failed;
+    /**
+     * @param scope - the bound settings scope for this card's namespace.
+     * @param specs - the section fields this card edits.
+     * @param secrets - the card's write-only controls, written outside the section.
+     */
+    constructor(scope: SettingsScope<T>, specs: CardFieldSpec[], secrets?: CardSecretSpec[]);
+    /**
+     * Publish a projection of this form, rebuilt whenever the scope or a draft changes.
+     * @param project - build the card's state from the form's current reads.
+     * @returns the store the card's component reads through its bound selector.
+     */
+    bind<S>(project: () => S): SnapshotStore<S>;
+    /**
+     * Read the card-level state: what the Host serves, and what a save would do.
+     * @returns the form state every card shares.
+     */
+    shell(): CardShell;
+    /**
+     * Read one control's state.
+     * @param field - field name of a section field or of a write-only control.
+     * @returns the draft text, whether a save would leave an override, and whether it is invalid.
+     */
+    field(field: string): CardFieldState;
+    /**
+     * Build the edit, reset, save, and discard actions bound to this form.
+     * @returns the actions a card's slot entry injects.
+     */
+    actions(): CardActions;
+    /**
+     * Write every staged edit, then re-seed from what the Host accepted.
+     *
+     * The Host is the only authority on whether a value was accepted — its
+     * validators own the constraints no schema can express — so the outcome is
+     * read back from the section rather than predicted here. A save that did not
+     * land keeps its drafts, so the user can correct them instead of retyping.
+     * @returns settlement after every write and the read-back.
+     */
+    save(): Promise<void>;
+    /**
+     * Every staged edit a save would write. An entry whose draft is not a value
+     * its field accepts carries no write: the form is still dirty, and the save
+     * refuses rather than dropping the edit.
+     * @returns the planned writes, in the order the fields were staged.
+     */
+    private plan;
+    private clear;
+    private store;
+    private stage;
+    private spec;
+    private snapshotOf;
+    private sectionValue;
+    private baseValue;
+    private userLayer;
+    private stored;
+    private publish;
+}
+//# sourceMappingURL=card-form.d.ts.map

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

@@ -0,0 +1,61 @@
+/**
+ * Hand-written controls for the plugin configuration forms. Each renders one
+ * field's label, its staged text, whether saving would leave an override, and
+ * — when one stands — the reset that stages a clear back to the composition
+ * layer. Nothing here writes: a control reports what the user typed, and the
+ * card's save is the single point where a draft becomes a document mutation.
+ */
+/** What every field control needs regardless of its value type. */
+export interface FieldProps {
+    /** Stable id associating the label with its control. */
+    id: string;
+    /** Visible label. */
+    label: string;
+    /** One-line explanation rendered under the control. */
+    hint: string;
+    /** Draft text this control renders. */
+    text: string;
+    /** True when saving would leave a user-layer entry for this field. */
+    overridden: boolean;
+    /** True when the draft is not a value this field accepts. */
+    invalid: boolean;
+    /** Copy for the overridden badge. */
+    overriddenLabel: string;
+    /** Copy for the reset control. */
+    resetLabel: string;
+    /** Copy shown in place of the hint while the draft is invalid. */
+    invalidLabel: string;
+    /** Disables every control (read-only document, or an unavailable namespace). */
+    disabled: boolean;
+    /** Stage draft text. */
+    onEdit: (text: string) => void;
+    /** Stage a clear so the field re-inherits the composition layer. */
+    onReset: () => void;
+}
+/**
+ * A staged value field. `numeric` only hints the keypad: which drafts a field
+ * accepts is decided by its spec, so the control never silently rewrites what
+ * the user typed.
+ * @param props - the field's copy, its staged text, and the edit actions.
+ * @returns the labelled control.
+ */
+export declare function ValueField(props: FieldProps & {
+    /** Hints a numeric keypad without narrowing what the control accepts. */
+    numeric?: boolean;
+    /** Placeholder shown while the draft is empty. */
+    placeholder?: string;
+}): import("react").JSX.Element;
+/**
+ * A write-only credential control. The value never rides a response, so the
+ * control reports only whether one is configured and starts blank; a blank
+ * draft writes nothing, which keeps the stored key rather than clearing it.
+ * @param props - the field's copy, its staged text, and the configured state.
+ * @returns the labelled control.
+ */
+export declare function SecretField(props: Pick<FieldProps, 'id' | 'label' | 'hint' | 'text' | 'disabled' | 'onEdit'> & {
+    /** Whether the Host reports a configured credential for this reference. */
+    configured: boolean;
+    /** Copy describing the configured state. */
+    stateLabel: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=fields.d.ts.map

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

@@ -0,0 +1,29 @@
+/**
+ * Plugins settings surface, browser half — one section whose feature-owned
+ * tabs include configurable Host plugin cards and read-only inventory.
+ *
+ * The section declares `settings.plugins.tab`; its own `configurable` tab then
+ * declares `settings.plugin.item` and renders whatever cards were registered
+ * into it. The cards this package ships are the host-plane sections the
+ * deployment already exposes; each binds its namespace through the client
+ * settings scope, which keeps them unaware of one another and of other tabs.
+ */
+import type { Context as ClientContext } from '@prettier-ai/cordis';
+export type { PluginsSettingsSectionInjected, PluginsSettingsSectionProps } from './PluginsSettingsSection.tsx';
+export type { ConfigurablePluginsTabProps } from './ConfigurablePluginsTab.tsx';
+export type { ConfigurablePluginsTabFace, ConfigurablePluginsTabState } from './tab-store.ts';
+export type { PluginCardProps } from './PluginCard.tsx';
+export type { SettingsPluginItemOwnerProps } from './slot-contract.ts';
+export type { FieldProps } from './fields.tsx';
+export type { CardActions, CardFieldSpec, CardFieldState, CardSecretSpec, CardShell, } from './card-form.ts';
+export type { AgentLoopCardFace, AgentLoopCardState } from './agent-loop-card-controller.ts';
+export type { BashCardFace, BashCardState } from './bash-card-controller.ts';
+export type { WebSearchCardFace, WebSearchCardState } from './web-search-card-controller.ts';
+/** Required services (cordis fiber inject). */
+export declare const inject: string[];
+/**
+ * Mount the plugin configuration section and the cards this package ships.
+ * @param ctx - the browser plugin context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,8 @@
+/** Locale bundles for the plugin configuration section and its plugin cards. */
+/** Locale keys these surfaces render. */
+export type PluginsSettingsLocaleKey = 'nav' | 'title' | 'intro' | 'tabs' | 'configurableTab' | 'empty' | 'overridden' | 'reset' | 'readOnly' | 'expand' | 'collapse' | 'save' | 'saving' | 'discard' | 'unsaved' | 'saveFailed' | 'invalidNumber' | 'bashTitle' | 'bashDescription' | 'bashTimeoutMs' | 'bashTimeoutMsHint' | 'bashMaxOutputBytes' | 'bashMaxOutputBytesHint' | 'agentLoopTitle' | 'agentLoopDescription' | 'agentLoopMaxParallel' | 'agentLoopMaxParallelHint' | 'webSearchTitle' | 'webSearchDescription' | 'webSearchApiKey' | 'webSearchApiKeyHint' | 'webSearchApiKeySet' | 'webSearchApiKeyUnset' | 'webSearchBaseUrl' | 'webSearchBaseUrlHint' | 'webSearchMaxUses' | 'webSearchMaxUsesHint' | 'subagentModelSelectionTitle' | 'subagentModelSelectionDescription' | 'subagentModelSelectionToggle' | 'subagentModelSelectionChoose' | 'subagentModelSelectionAllowed' | 'subagentModelSelectionLoading' | 'subagentModelSelectionLoadFailed' | 'subagentModelSelectionRetry' | 'subagentModelSelectionPartial' | 'subagentModelSelectionUnavailable' | 'subagentModelSelectionUnavailableGroup' | 'subagentModelSelectionEmpty' | 'subagentModelSelectionRequired' | 'subagentModelSelectionConflict' | 'subagentModelSelectionOff';
+/** English copy. */
+export declare const en: Record<PluginsSettingsLocaleKey, string>;
+/** Simplified Chinese copy. */
+export declare const zh: Record<PluginsSettingsLocaleKey, string>;
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/slot-contract.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The `settings.plugin.item` slot type — one plugin's card inside the
+ * configurable-plugins tab, keyed by the settings namespace the card edits.
+ * Options: `key` (the namespace). A card draws its own internals; the tab only
+ * decides which namespaces to dispatch and stacks what comes back.
+ *
+ * Keying on the namespace is what lets a plugin distributed outside this
+ * repository contribute a card: it registers its own settings namespace on the
+ * Host and its own card under that key in the browser, and the tab pairs the
+ * two without ever learning what the namespace means.
+ *
+ * TYPE HOME RATIONALE: the tab declares this slot at runtime, and a plugin
+ * registering its own card already depends on this package for the slot's
+ * declaration. The type therefore lives with its declarer.
+ */
+declare module '@prettier-ai/dsh-client-ui-slots' {
+    interface SlotMap {
+        /** One plugin's card inside the plugin configuration section (see module JSDoc). */
+        'settings.plugin.item': {
+            kind: 'keyed';
+            scope: 'root';
+            owner: SettingsPluginItemOwnerProps;
+        };
+    }
+}
+/** Owner share of a plugin card (the section supplies nothing). */
+export interface SettingsPluginItemOwnerProps {
+    /** Marker field: card owner props are intentionally empty. */
+    children?: never;
+}
+//# sourceMappingURL=slot-contract.d.ts.map