@huanlin/dsh-plugin-preface-context 0.1.0

package/lib/types/client/client/preface-card-controller.js

@@ -0,0 +1,181 @@
+/**
+ * The preface-context card's staged form over the `preface-context` settings
+ * namespace.
+ *
+ * The upstream `ui-settings-plugins` package owns a `CardForm` helper, but it
+ * is an internal module (not re-exported from the package's `/client` public
+ * face), so an external plugin cannot reuse it. This controller is a slim
+ * equivalent: it stages the two fields (`enabled` boolean, `contextText`
+ * multiline string) and writes them through the bound {@link SettingsScope}
+ * on save, re-deriving its projection whenever the scope or a draft changes.
+ *
+ * Unlike the upstream `CardForm`, the `contextText` field is a multiline
+ * textarea: its draft preserves internal whitespace and newlines (the
+ * upstream `textField` helper trims, which would collapse a multi-paragraph
+ * preface into one line).
+ */
+/** A minimal snapshot store: a value + a listener set. Self-contained so the
+ * controller does not pull `createSnapshotStore` (a browser-bundle symbol)
+ * into its unit-test graph. */
+class MiniSnapshotStore {
+    snapshot;
+    listeners = new Set();
+    constructor(initial) {
+        this.snapshot = initial;
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    set(value) {
+        this.snapshot = value;
+        for (const listener of [...this.listeners])
+            listener();
+    }
+    update(mutator) {
+        // Shallow-clone then mutate (the projections here are plain objects with
+        // no nested mutation, so a deep immer draft is unnecessary).
+        const draft = Array.isArray(this.snapshot) ? [...this.snapshot] : { ...this.snapshot };
+        mutator(draft);
+        this.set(draft);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+}
+/** The default value for a field when the user-layer carries none. */
+function baseValue(snapshot, field) {
+    return snapshot.base?.[field];
+}
+/** The current resolved value of a field. */
+function sectionValue(snapshot, field) {
+    return snapshot.value?.[field];
+}
+/** Whether the user layer carries an entry for a field. */
+function stored(snapshot, field) {
+    const user = snapshot.user;
+    return user !== undefined && Object.hasOwn(user, field);
+}
+/** Format a stored value as draft text for a field. */
+function format(field, value) {
+    if (field === 'enabled')
+        return value === true ? 'true' : 'false';
+    if (field === 'contextText')
+        return typeof value === 'string' ? value : '';
+    return '';
+}
+/** Parse draft text into a write value, or undefined when invalid. */
+function parse(field, text) {
+    if (field === 'enabled') {
+        // The toggle is a boolean; the textarea is not used for this field.
+        return { value: text === 'true' };
+    }
+    // contextText: empty draft clears the field; otherwise the raw text is the
+    // value. Internal whitespace and newlines are preserved.
+    const trimmed = text.trim();
+    return trimmed === '' ? { clear: true } : { value: text };
+}
+/**
+ * Bridges the `preface-context` scope onto the card's staged 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 class PrefaceCardController {
+    scope;
+    store;
+    staged = new Map();
+    saving = false;
+    failed = false;
+    /** @param scope - the bound settings scope for the `preface-context` namespace. */
+    constructor(scope) {
+        this.scope = scope;
+        this.store = new MiniSnapshotStore(this.project());
+        scope.subscribe(() => { this.publish(); });
+    }
+    /** @returns the store the card's component reads through its bound selector. */
+    get snapshot() {
+        return this.store;
+    }
+    project() {
+        const snapshot = this.scope.getSnapshot();
+        const dirty = this.staged.size > 0;
+        return {
+            available: snapshot.status === 'ready',
+            writable: snapshot.writable,
+            dirty,
+            saving: this.saving,
+            failed: this.failed,
+            enabled: this.fieldState(snapshot, 'enabled'),
+            contextText: this.fieldState(snapshot, 'contextText'),
+        };
+    }
+    fieldState(snapshot, field) {
+        const staged = this.staged.get(field);
+        if (staged === undefined) {
+            return { text: format(field, sectionValue(snapshot, field)), overridden: stored(snapshot, field) };
+        }
+        const write = staged.clear ? { clear: true } : parse(field, staged.text);
+        return {
+            text: staged.text,
+            overridden: write !== undefined && 'value' in write,
+        };
+    }
+    /** Build the face the card's slot registration injects. */
+    inject() {
+        return {
+            hooks: { prefaceCard: this.store },
+            edit: (field, text) => { this.stage(field, { text, clear: false }); },
+            resetField: (field) => {
+                this.stage(field, { text: format(field, baseValue(this.scope.getSnapshot(), field)), clear: true });
+            },
+            save: () => { void this.save(); },
+            discard: () => {
+                if (this.staged.size === 0 && !this.failed)
+                    return;
+                this.staged.clear();
+                this.failed = false;
+                this.publish();
+            },
+        };
+    }
+    stage(field, edit) {
+        this.staged.set(field, edit);
+        this.failed = false;
+        this.publish();
+    }
+    publish() {
+        this.store.set(this.project());
+    }
+    /** Write every staged edit, then re-seed from what the Host accepted. */
+    async save() {
+        if (this.staged.size === 0 || this.saving)
+            return;
+        this.saving = true;
+        this.failed = false;
+        this.publish();
+        let landed = true;
+        for (const [field, staged] of this.staged) {
+            const write = staged.clear ? { clear: true } : parse(field, staged.text);
+            if (write === undefined)
+                continue;
+            try {
+                if ('clear' in write) {
+                    await this.scope.unset(field);
+                }
+                else {
+                    await this.scope.set(field, write.value);
+                }
+            }
+            catch {
+                landed = false;
+            }
+        }
+        if (landed)
+            this.staged.clear();
+        this.saving = false;
+        this.failed = !landed;
+        this.publish();
+    }
+}

package/lib/types/client/client/preface-card.css.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Card styles + runtime style injection for the preface-context settings
+ * card.
+ *
+ * The DSH client loader never serves `.css` artifacts — every style must be
+ * injected inside the bundle's factory closure (the same contract the
+ * upstream tsdown.client preset implements with lightningcss). A plain
+ * template-string stylesheet installed once at plugin activation is the slim
+ * equivalent for a hand-rolled bundle: static, prefixed class names
+ * (`dsh-pfc-*`, unique in the document) replace the hashed CSS-modules map,
+ * and the `<style data-plugin-css>` tag is removed when the plugin unloads.
+ *
+ * Colors resolve through `--dsw-alias-*` tokens so the card adapts to the
+ * light/dark theme.
+ *
+ * @module @huanlin/dsh-plugin-preface-context/client/preface-card.css
+ */
+/** Class-name map consumed by the card component (CSS-modules replacement). */
+export declare const css: {
+    readonly card: "dsh-pfc-card";
+    readonly cardOpen: "dsh-pfc-card--open";
+    readonly header: "dsh-pfc-header";
+    readonly headText: "dsh-pfc-head-text";
+    readonly name: "dsh-pfc-name";
+    readonly description: "dsh-pfc-description";
+    readonly pending: "dsh-pfc-pending";
+    readonly chevron: "dsh-pfc-chevron";
+    readonly chevronOpen: "dsh-pfc-chevron--open";
+    readonly body: "dsh-pfc-body";
+    readonly readOnly: "dsh-pfc-readonly";
+    readonly field: "dsh-pfc-field";
+    readonly head: "dsh-pfc-field-head";
+    readonly label: "dsh-pfc-label";
+    readonly badges: "dsh-pfc-badges";
+    readonly badge: "dsh-pfc-badge";
+    readonly reset: "dsh-pfc-reset";
+    readonly textarea: "dsh-pfc-textarea";
+    readonly toggleRow: "dsh-pfc-toggle-row";
+    readonly toggle: "dsh-pfc-toggle";
+    readonly toggleOn: "dsh-pfc-toggle--on";
+    readonly knob: "dsh-pfc-knob";
+    readonly knobOn: "dsh-pfc-knob--on";
+    readonly hint: "dsh-pfc-hint";
+    readonly footer: "dsh-pfc-footer";
+    readonly failed: "dsh-pfc-failed";
+    readonly discard: "dsh-pfc-discard";
+    readonly save: "dsh-pfc-save";
+};
+/**
+ * Install the card stylesheet as one tagged `<style>` element.
+ * @returns the disposer removing the tag (idempotent outside a document).
+ */
+export declare function installPrefaceCardStyles(): () => void;

package/lib/types/client/client/preface-card.css.js

@@ -0,0 +1,327 @@
+/**
+ * Card styles + runtime style injection for the preface-context settings
+ * card.
+ *
+ * The DSH client loader never serves `.css` artifacts — every style must be
+ * injected inside the bundle's factory closure (the same contract the
+ * upstream tsdown.client preset implements with lightningcss). A plain
+ * template-string stylesheet installed once at plugin activation is the slim
+ * equivalent for a hand-rolled bundle: static, prefixed class names
+ * (`dsh-pfc-*`, unique in the document) replace the hashed CSS-modules map,
+ * and the `<style data-plugin-css>` tag is removed when the plugin unloads.
+ *
+ * Colors resolve through `--dsw-alias-*` tokens so the card adapts to the
+ * light/dark theme.
+ *
+ * @module @huanlin/dsh-plugin-preface-context/client/preface-card.css
+ */
+/** Class-name map consumed by the card component (CSS-modules replacement). */
+export const css = {
+    card: 'dsh-pfc-card',
+    cardOpen: 'dsh-pfc-card--open',
+    header: 'dsh-pfc-header',
+    headText: 'dsh-pfc-head-text',
+    name: 'dsh-pfc-name',
+    description: 'dsh-pfc-description',
+    pending: 'dsh-pfc-pending',
+    chevron: 'dsh-pfc-chevron',
+    chevronOpen: 'dsh-pfc-chevron--open',
+    body: 'dsh-pfc-body',
+    readOnly: 'dsh-pfc-readonly',
+    field: 'dsh-pfc-field',
+    head: 'dsh-pfc-field-head',
+    label: 'dsh-pfc-label',
+    badges: 'dsh-pfc-badges',
+    badge: 'dsh-pfc-badge',
+    reset: 'dsh-pfc-reset',
+    textarea: 'dsh-pfc-textarea',
+    toggleRow: 'dsh-pfc-toggle-row',
+    toggle: 'dsh-pfc-toggle',
+    toggleOn: 'dsh-pfc-toggle--on',
+    knob: 'dsh-pfc-knob',
+    knobOn: 'dsh-pfc-knob--on',
+    hint: 'dsh-pfc-hint',
+    footer: 'dsh-pfc-footer',
+    failed: 'dsh-pfc-failed',
+    discard: 'dsh-pfc-discard',
+    save: 'dsh-pfc-save',
+};
+/** `data-plugin-css` tag id of the injected stylesheet. */
+const STYLE_TAG_ID = '@huanlin/dsh-plugin-preface-context/preface-card.css';
+/** The card stylesheet (injected as one tagged `<style>` at activation). */
+const CSS = `
+.dsh-pfc-card {
+  list-style: none;
+  border: 1px solid var(--dsw-alias-border-l2, rgba(128, 128, 128, 0.22));
+  background: var(--dsw-alias-bg-layer-3, transparent);
+  border-radius: 12px;
+  transition: border-color 0.16s, background 0.16s;
+  overflow: hidden;
+}
+
+.dsh-pfc-card--open {
+  border-color: var(--dsw-alias-border-l3, rgba(128, 128, 128, 0.35));
+}
+
+.dsh-pfc-header {
+  display: flex;
+  width: 100%;
+  align-items: center;
+  gap: 12px;
+  padding: 14px 16px;
+  font: inherit;
+  color: inherit;
+  text-align: left;
+  background: transparent;
+  border: 0;
+  cursor: pointer;
+}
+
+.dsh-pfc-head-text {
+  display: flex;
+  flex: 1 1 auto;
+  flex-direction: column;
+  gap: 4px;
+  min-width: 0;
+}
+
+.dsh-pfc-name {
+  font-size: 15px;
+  font-weight: 600;
+  line-height: 1.4;
+  color: var(--dsw-alias-label-primary, inherit);
+}
+
+.dsh-pfc-description {
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--dsw-alias-label-tertiary, rgba(128, 128, 128, 0.7));
+}
+
+.dsh-pfc-pending {
+  flex: none;
+  white-space: nowrap;
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 17px;
+  padding: 1px 8px;
+  border-radius: 999px;
+  color: var(--dsw-alias-label-secondary, inherit);
+  background: var(--dsw-alias-bg-module-platform, rgba(128, 128, 128, 0.12));
+}
+
+.dsh-pfc-chevron {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  color: var(--dsw-alias-label-tertiary, inherit);
+  transition: transform 0.16s;
+}
+
+.dsh-pfc-chevron--open {
+  transform: rotate(180deg);
+}
+
+.dsh-pfc-body {
+  margin: 0 16px;
+  padding: 12px 0 4px;
+  border-top: 1px solid var(--dsw-alias-border-l2, rgba(128, 128, 128, 0.22));
+}
+
+.dsh-pfc-readonly {
+  margin: 0 0 8px;
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--dsw-alias-label-tertiary, rgba(128, 128, 128, 0.7));
+}
+
+.dsh-pfc-field {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  margin: 0 0 12px;
+}
+
+.dsh-pfc-field-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.dsh-pfc-label {
+  font-size: 13px;
+  font-weight: 500;
+  color: var(--dsw-alias-label-primary, inherit);
+}
+
+.dsh-pfc-badges {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-left: auto;
+}
+
+.dsh-pfc-badge {
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 17px;
+  padding: 1px 8px;
+  border-radius: 999px;
+  color: var(--dsw-alias-label-secondary, inherit);
+  background: var(--dsw-alias-bg-module-platform, rgba(128, 128, 128, 0.12));
+}
+
+.dsh-pfc-reset {
+  appearance: none;
+  font: inherit;
+  font-size: 12px;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  cursor: pointer;
+  color: var(--dsw-alias-brand-primary, #0a84ff);
+}
+
+.dsh-pfc-reset:disabled {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+
+.dsh-pfc-textarea {
+  width: 100%;
+  box-sizing: border-box;
+  min-height: 96px;
+  resize: vertical;
+  padding: 6px 10px;
+  font-family: var(--dsw-font-mono, ui-monospace, monospace);
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--dsw-alias-label-primary, inherit);
+  background: var(--dsw-alias-bg-layer-3, transparent);
+  border: 1px solid var(--dsw-alias-border-l2, rgba(128, 128, 128, 0.3));
+  border-radius: 8px;
+}
+
+.dsh-pfc-textarea:focus {
+  outline: none;
+  border-color: var(--dsw-alias-brand-primary, #0a84ff);
+}
+
+.dsh-pfc-textarea:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.dsh-pfc-toggle-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.dsh-pfc-toggle {
+  position: relative;
+  width: 40px;
+  height: 22px;
+  flex: none;
+  padding: 0;
+  background: var(--dsw-alias-bg-module-platform, rgba(128, 128, 128, 0.12));
+  border: 1px solid var(--dsw-alias-border-l2, rgba(128, 128, 128, 0.3));
+  border-radius: 999px;
+  cursor: pointer;
+  transition: background 0.16s, border-color 0.16s;
+}
+
+.dsh-pfc-toggle--on {
+  background: var(--dsw-alias-brand-primary, #0a84ff);
+  border-color: var(--dsw-alias-brand-primary, #0a84ff);
+}
+
+.dsh-pfc-knob {
+  position: absolute;
+  top: 2px;
+  left: 2px;
+  width: 16px;
+  height: 16px;
+  background: var(--dsw-alias-bg-layer-1, #fff);
+  border-radius: 50%;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.2);
+  transition: transform 0.16s;
+}
+
+.dsh-pfc-knob--on {
+  transform: translateX(18px);
+}
+
+.dsh-pfc-toggle:disabled {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+
+.dsh-pfc-hint {
+  margin: 0;
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--dsw-alias-label-tertiary, rgba(128, 128, 128, 0.6));
+}
+
+.dsh-pfc-footer {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 12px 0 4px;
+  border-top: 1px solid var(--dsw-alias-border-l2, rgba(128, 128, 128, 0.22));
+}
+
+.dsh-pfc-failed {
+  flex: 1 1 auto;
+  min-width: 0;
+  margin: 0;
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--dsw-alias-label-error, #ff453a);
+}
+
+.dsh-pfc-discard,
+.dsh-pfc-save {
+  appearance: none;
+  font: inherit;
+  font-size: 13px;
+  font-weight: 500;
+  line-height: 20px;
+  padding: 5px 14px;
+  border: 1px solid transparent;
+  border-radius: 8px;
+  cursor: pointer;
+  color: var(--dsw-alias-label-primary, inherit);
+  background: var(--dsw-alias-bg-module-platform, rgba(128, 128, 128, 0.12));
+  transition: background 0.16s, opacity 0.16s;
+}
+
+.dsh-pfc-save {
+  background: var(--dsw-alias-brand-primary, #0a84ff);
+  color: var(--dsw-alias-bg-layer-1, #fff);
+}
+
+.dsh-pfc-discard:disabled,
+.dsh-pfc-save:disabled {
+  cursor: not-allowed;
+  opacity: 0.5;
+}
+`;
+/**
+ * Install the card stylesheet as one tagged `<style>` element.
+ * @returns the disposer removing the tag (idempotent outside a document).
+ */
+export function installPrefaceCardStyles() {
+    if (typeof document === 'undefined')
+        return () => { };
+    if (document.querySelector(`style[data-plugin-css='${STYLE_TAG_ID}']`) !== null)
+        return () => { };
+    const style = document.createElement('style');
+    style.dataset.plugin = '@huanlin/dsh-plugin-preface-context';
+    style.dataset.pluginCss = STYLE_TAG_ID;
+    style.textContent = CSS;
+    document.head.appendChild(style);
+    return () => { style.remove(); };
+}

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

@@ -0,0 +1,27 @@
+/**
+ * The preface-context settings card: a collapsible card on the "插件配置"
+ * settings page. Renders an enable toggle and a multiline textarea for the
+ * context text. Stages edits locally and writes them on save through the
+ * bound {@link PrefaceCardController}.
+ *
+ * The chrome mirrors the upstream `PluginCard` shape (a header button
+ * stacking name over description, a dirty pill, a rotating chevron; a body
+ * with the form controls and a footer with Discard/Save) because the
+ * upstream client value face exports no reusable card. Styles come from the
+ * statically injected `preface-card.css` stylesheet (the loader never serves
+ * `.css` artifacts); every color resolves through a `--dsw-alias-*` token so
+ * the card adapts to the light/dark theme.
+ */
+import { type ReactNode } from 'react';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { PrefaceCardFace, PrefaceCardActions } from './preface-card-controller.ts';
+/** Injected dependencies of the card (slot `inject`). */
+export type PrefaceCardInjected = PrefaceCardFace & PrefaceCardActions;
+/** Props the renderer binds for the card. */
+export type PrefaceCardProps = PropsRuntime<'settings.plugin.item'> & PropsLocale<'settings.preface-context'> & InjectFace<PrefaceCardInjected>;
+/**
+ * Render the preface-context card.
+ * @param props - locale copy, the card snapshot, and its form actions.
+ * @returns the card, or nothing when the namespace is unavailable.
+ */
+export declare function PrefaceCard(props: PrefaceCardProps): ReactNode;

package/lib/types/client/client/preface-card.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The preface-context settings card: a collapsible card on the "插件配置"
+ * settings page. Renders an enable toggle and a multiline textarea for the
+ * context text. Stages edits locally and writes them on save through the
+ * bound {@link PrefaceCardController}.
+ *
+ * The chrome mirrors the upstream `PluginCard` shape (a header button
+ * stacking name over description, a dirty pill, a rotating chevron; a body
+ * with the form controls and a footer with Discard/Save) because the
+ * upstream client value face exports no reusable card. Styles come from the
+ * statically injected `preface-card.css` stylesheet (the loader never serves
+ * `.css` artifacts); every color resolves through a `--dsw-alias-*` token so
+ * the card adapts to the light/dark theme.
+ */
+import { useState } from 'react';
+import clsx from 'clsx';
+import { IconChevronDownOutline14 } from '@deepseek-ai/dsh-client-ui-primitives';
+import { css } from "./preface-card.css.js";
+/**
+ * Render the preface-context card.
+ * @param props - locale copy, the card snapshot, and its form actions.
+ * @returns the card, or nothing when the namespace is unavailable.
+ */
+export function PrefaceCard(props) {
+    const [open, setOpen] = useState(false);
+    const { t } = props;
+    const state = props.usePrefaceCard(snapshot => snapshot);
+    if (!state.available)
+        return null;
+    const title = t('title');
+    const blocked = !state.dirty || state.saving;
+    const enabledOn = state.enabled.text === 'true';
+    return (_jsxs("li", { className: clsx(css.card, open && css.cardOpen), children: [_jsxs("button", { type: "button", className: css.header, "aria-expanded": open, "aria-label": `${t(open ? 'collapse' : 'expand')}: ${title}`, onClick: () => { setOpen(!open); }, children: [_jsxs("span", { className: css.headText, children: [_jsx("span", { className: css.name, children: title }), _jsx("span", { className: css.description, children: t('description') })] }), state.dirty ? _jsx("span", { className: css.pending, children: t('unsaved') }) : null, _jsx(IconChevronDownOutline14, { className: clsx(css.chevron, open && css.chevronOpen) })] }), open
+                ? (_jsxs("div", { className: css.body, children: [!state.writable ? _jsx("p", { className: css.readOnly, role: "status", children: t('readOnly') }) : null, _jsxs("div", { className: css.field, children: [_jsxs("div", { className: css.head, children: [_jsx("label", { className: css.label, children: t('enabled') }), state.enabled.overridden
+                                            ? (_jsxs("span", { className: css.badges, children: [_jsx("span", { className: css.badge, children: t('overridden') }), _jsx("button", { type: "button", className: css.reset, disabled: !state.writable, onClick: () => { props.resetField('enabled'); }, children: t('reset') })] }))
+                                            : null] }), _jsx("div", { className: css.toggleRow, children: _jsx("button", { type: "button", role: "switch", "aria-checked": enabledOn, className: clsx(css.toggle, enabledOn && css.toggleOn), disabled: !state.writable, onClick: () => { props.edit('enabled', enabledOn ? 'false' : 'true'); }, children: _jsx("span", { className: clsx(css.knob, enabledOn && css.knobOn) }) }) }), _jsx("p", { className: css.hint, children: t('enabledHint') })] }), _jsxs("div", { className: css.field, children: [_jsxs("div", { className: css.head, children: [_jsx("label", { className: css.label, children: t('contextText') }), state.contextText.overridden
+                                            ? (_jsxs("span", { className: css.badges, children: [_jsx("span", { className: css.badge, children: t('overridden') }), _jsx("button", { type: "button", className: css.reset, disabled: !state.writable, onClick: () => { props.resetField('contextText'); }, children: t('reset') })] }))
+                                            : null] }), _jsx("textarea", { id: "plugin-config-preface-context-text", className: css.textarea, value: state.contextText.text, placeholder: t('contextTextPlaceholder'), disabled: !state.writable, onChange: (event) => { props.edit('contextText', event.target.value); } }), _jsx("p", { className: css.hint, children: t('contextTextHint') })] }), _jsxs("div", { className: css.footer, children: [state.failed ? _jsx("p", { className: css.failed, role: "status", children: t('saveFailed') }) : null, _jsx("button", { type: "button", className: css.discard, disabled: !state.dirty || state.saving, onClick: props.discard, children: t('discard') }), _jsx("button", { type: "button", className: css.save, disabled: blocked, onClick: props.save, children: t(state.saving ? 'saving' : 'save') })] })] }))
+                : null] }));
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Config schema for the preface-context plugin (Schemastery, strict).
+ *
+ * The plugin-row config (the `entry` passed to `apply`) is the composition
+ * BASE of the `preface-context` settings namespace. The settings user layer
+ * is layered on top (schema defaults → base → user layer) when a settings
+ * service is mounted; without one, the entry is the sole source.
+ *
+ * @module @huanlin/dsh-plugin-preface-context/config
+ */
+import z from 'schemastery';
+/** User-editable configuration for the preface-context plugin. */
+export interface PrefaceConfig {
+    /** Master switch: when false, no context is injected at session start. */
+    enabled: boolean;
+    /** The text block injected as model-visible instructions context. */
+    contextText: string;
+}
+/**
+ * Schemastery schema for the `preface-context` settings namespace.
+ *
+ * Strict by construction: unknown keys fail validation here, even though the
+ * settings service itself is non-strict and would otherwise accept them.
+ */
+export declare const Config: z<Schemastery.ObjectS<{
+    enabled: z<boolean, boolean>;
+    contextText: z<string, string>;
+}>, Schemastery.ObjectT<{
+    enabled: z<boolean, boolean>;
+    contextText: z<string, string>;
+}>>;
+/**
+ * Resolve a raw config patch through the schema, returning a full
+ * {@link PrefaceConfig} with defaults applied. Unknown keys are rejected
+ * here (the settings service itself is non-strict and would otherwise accept
+ * them), matching the Loader's strict validation.
+ * @param input - a partial or complete config object.
+ * @returns the schema-resolved config.
+ * @throws when the input carries an unknown key or a value the schema rejects.
+ */
+export declare function resolvePrefaceConfig(input: Partial<PrefaceConfig>): PrefaceConfig;