dsh-codinput 0.3.5 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-codinput",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "DSH WebUI 插件：把聊天输入框变成代码编辑器一样的输入风格（CodeMirror 6 接管 conversation.composer.bar）。",
   "license": "MIT",
   "author": "Witherwithwinter",

package/src/client/components/InputSlotSeat.tsx

@@ -25,9 +25,8 @@
  * 私有），现网无此类条目；如出现则降级为无 store props 渲染。
  */
 
-import { createElement, useMemo } from 'react';
-import { diagError } from '../diag';
-import { EntryBoundary, entryId, entryInjectProps, listRows, translatorFor, useSlotEntries } from './slotEntry';
+import { useMemo } from 'react';
+import { entryId, listRows, renderSlotEntry, useSlotEntries } from './slotEntry';
 
 export interface InputSlotSeatProps {
   /** 官方子槽位全名（如 conversation.input.left）。 */
@@ -46,35 +45,5 @@ export function InputSlotSeat(props: InputSlotSeatProps): JSX.Element | null {
   // 官方同款门槛：无会话不渲染（input.left / input.right 都是 strict session 槽位）。
   if (sessionId === undefined || rows.length === 0) return null;
 
-  return (
-    <>
-      {rows.map((entry, index) => {
-        const Comp = entry.component as React.ComponentType<Record<string, unknown>>;
-        // 条目词典的 t（官方 localeSeat 同款）；无 locale 或绑定失败 → 不下发，
-        // 组件按各自回退（enhancer 回退内置中文词典）。
-        let t: unknown;
-        try {
-          t = translatorFor(entry) ?? undefined;
-        } catch {
-          t = undefined;
-        }
-        let injected: Record<string, unknown> | null = null;
-        try {
-          injected = entryInjectProps(entry, sessionId);
-        } catch (error) {
-          diagError('slot.seat.inject', error);
-        }
-        return createElement(
-          EntryBoundary,
-          { key: entryId(entry, index) },
-          createElement(Comp, {
-            ...(standard ?? {}),
-            sessionId,
-            ...(injected ?? {}),
-            ...(t !== undefined ? { t } : {}),
-          }),
-        );
-      })}
-    </>
-  );
+  return <>{rows.map((entry, index) => renderSlotEntry(entry, entryId(entry, index), { sessionId, standard }))}</>;
 }

package/src/client/components/ModelSlot.tsx

@@ -0,0 +1,83 @@
+/**
+ * 模型座单值镜像（issue #4）：`conversation.input.model`。
+ *
+ * 座位事实（宿主 0.2.1-rc.2 取证）：
+ * - `conversation.input.model` 是 `{kind:"single", scope:"session"}` 单值槽，
+ *   由官方 InputBar 条目（`conversation.composer.bar` 缺省条目）声明，唯一
+ *   渲染点在 InputBar 体内：`input.model → renderSlot(..., { locked })`；
+ *   官方占用者是 client-ui-model-selection 的 ModelSelect（替换风险标记
+ *   `shadows-shipped-ui`，生态替换类插件按契约以 priority 遮蔽它）。
+ * - Codinput 以 priority 遮蔽整个 bar 后，该 renderSlot 调用点随官方条目一起
+ *   消失；但「遮蔽」不是 dispose——宿主条目仍在 ledger 上，座位声明仍在，
+ *   第三方对它的 `slots.inject` 照常触发、`register` 照常成功（单值槽低
+ *   priority 无人竞争时静默赢）、`entries` 里它确实是赢家，只是没有任何
+ *   renderSlot 会读它。表现为「插件装了、不报错、永不上屏」。
+ *
+ * 本组件的收敛口径（0.3.6 起）：
+ * - **只镜像第三方遮蔽者**（宿主动态包：register 被强制分配负数遮蔽秩、
+ *   fiber 名带 `dyn/` 前缀），见 `isShadowingOccupant`；
+ * - **出厂占用的 ModelSelect 不镜像**——那个座位一直由 Codinput 自绘的模型
+ *   芯片代表（模型名显示仍走官方 `conversation.input.model.label` 子座），
+ *   镜像出厂条目会与自绘芯片重复成两个模型选择器；
+ * - 有第三方遮蔽者时**让位**：镜像其组件、隐藏自绘芯片（同座只留一个控件，
+ *   与官方「一个单值座只画一个占用者」一致）。
+ *
+ * 官方门槛同款复刻：`sessionId === undefined` 时该座位不渲染（此时自绘芯片
+ * 保持现状）。owner prop `locked`（官方 `InputControlOwnerProps`：会话是否
+ * 拒绝交互）原样下发——生态替换类插件按契约消费它（如 reasoning-slider 的
+ * `props.locked === true` 置灰）。
+ */
+
+import { useMemo } from 'react';
+import type { ReactNode } from 'react';
+import type { SlotEntryLike } from '../host-types';
+import {
+  entryId,
+  entryInjectFailed,
+  firstComponentEntry,
+  isShadowingOccupant,
+  renderSlotEntry,
+  useSlotEntries,
+} from './slotEntry';
+
+const MODEL_SLOT = 'conversation.input.model';
+
+export interface ModelSlotProps {
+  sessionId: string | undefined;
+  /** 宿主下发给本插件条目的 standard props 原样面（见 InputSlotSeat）。 */
+  standard: Record<string, unknown> | undefined;
+  /** 官方 owner prop locked（会话拒绝交互时第三方座条目应置灰）。 */
+  locked: boolean;
+  /** 无第三方遮蔽者时的自绘模型芯片（保持既有 UX）。 */
+  fallback: ReactNode;
+}
+
+/** 模型座的第三方遮蔽者（无则 null）：单值槽赢家且命中动态包判据。 */
+export function useModelSeatOccupant(): SlotEntryLike | null {
+  const entries = useSlotEntries(MODEL_SLOT);
+  return useMemo(() => {
+    const winner = firstComponentEntry(entries);
+    return winner !== null && isShadowingOccupant(winner) ? winner : null;
+  }, [entries]);
+}
+
+export function ModelSlot(props: ModelSlotProps): JSX.Element | null {
+  const { sessionId, standard, locked, fallback } = props;
+  const occupant = useModelSeatOccupant();
+
+  // 官方门槛：无会话不画该座位；自绘芯片（fallback）保持既有行为。
+  if (sessionId === undefined || occupant === null) return <>{fallback}</>;
+
+  // 让位可行性：inject 面必须在宿主 fiber 上下文里才算数（见 slotEntry）。
+  // 若该条目的 inject 依赖宿主服务面（插件侧调用会抛 without inject），
+  // 让位降级——回退自绘芯片（它本就是官方模型选择的等价物），而不是留空。
+  if (entryInjectFailed(occupant, sessionId)) return <>{fallback}</>;
+
+  return renderSlotEntry(occupant, `model:${entryId(occupant, 0)}`, {
+    sessionId,
+    standard,
+    ownerProps: { locked },
+    // 组件本体崩溃同样回退自绘芯片（逐条目边界已在 renderSlotEntry 内）。
+    fallback,
+  });
+}

package/src/client/components/Toolbar.tsx

@@ -18,6 +18,7 @@ import { openCommandMenu } from '../triggers';
 import { t, useT } from '../i18n';
 import { IconPlusOfficial, IconSendOfficial, IconStopOfficial } from '../icons';
 import { ModelMenu } from './ModelMenu';
+import { ModelSlot } from './ModelSlot';
 import { PermissionMenu } from './PermissionMenu';
 import { VoiceActivity } from './VoiceActivity';
 import { InputLeftSlot } from './InputLeftSlot';
@@ -105,9 +106,14 @@ export function Toolbar(props: ToolbarProps): JSX.Element {
           {state !== undefined && sessionId !== undefined ? (
             <InputRightSlot sessionId={sessionId} standard={inputStandard} />
           ) : null}
-          <ModelMenu
+          {/* 官方右区顺序：input.right → input.model。模型座单值槽的第三方
+              遮蔽者（如 reasoning-slider / dsh-model-accordion / effort-dial）
+              由 ModelSlot 镜像并让位；无遮蔽者时回退自绘模型芯片（issue #4）。 */}
+          <ModelSlot
             sessionId={sessionId}
-            onNotify={onNotify}
+            standard={inputStandard}
+            locked={disabled === true}
+            fallback={<ModelMenu sessionId={sessionId} onNotify={onNotify} />}
           />
         </div>
         <div className="dci-voice-seat">

package/src/client/components/slotEntry.tsx

@@ -5,7 +5,7 @@
  * 共用同一套合成公式，抽到这里避免多份漂移）。
  */
 
-import { useCallback, useSyncExternalStore, Component } from 'react';
+import { createElement, useCallback, useSyncExternalStore, Component } from 'react';
 import type { HostObservable, SlotEntryLike } from '../host-types';
 import { bindForeign } from '../i18n';
 import { diagError } from '../diag';
@@ -42,11 +42,33 @@ export function useSlotEntries(key: string): readonly unknown[] {
   return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
 
+/**
+ * React 可作为元素类型使用的「组件包装」符号（memo / forwardRef / lazy）。
+ * 只认这三类，不做「任意 symbol `$$typeof`」放行——element / context / 伪造
+ * 对象都不是可渲染组件类型：放行后 React 会在为子元素创建 Fiber 时抛 #130，
+ * 而该错误发生在 EntryBoundary 自身的工作单元内（边界只捕获后代错误），会
+ * 冒泡到宿主的 SlotErrorBoundary 并废黜 conversation.composer.bar（接管整体
+ * 退回官方输入框）。收紧后这类坏条目回到静默跳过，与 v0.3.5 行为一致。
+ */
+const RENDERABLE_OBJECT_TYPES: readonly symbol[] = [
+  Symbol.for('react.memo'),
+  Symbol.for('react.forward_ref'),
+  Symbol.for('react.lazy'),
+];
+
+/** 组件位是否为 React 可渲染类型（函数组件 / memo / forwardRef / lazy 包装）。 */
+export function isRenderableComponent(value: unknown): boolean {
+  if (typeof value === 'function') return true;
+  if (value === null || typeof value !== 'object') return false;
+  const type = (value as { $$typeof?: unknown }).$$typeof;
+  return typeof type === 'symbol' && RENDERABLE_OBJECT_TYPES.includes(type);
+}
+
 /** single 槽位赢家 = entries 首个带组件的条目（register 即按优先级排序）。 */
 export function firstComponentEntry(entries: readonly unknown[]): SlotEntryLike | null {
   for (const candidate of entries) {
     const record = candidate as SlotEntryLike | null | undefined;
-    if (record && typeof record === 'object' && typeof record.component === 'function') return record;
+    if (record && typeof record === 'object' && isRenderableComponent(record.component)) return record;
   }
   return null;
 }
@@ -61,7 +83,7 @@ export function listRows(entries: readonly unknown[]): SlotEntryLike[] {
   const byId = new Map<unknown, SlotEntryLike>();
   for (const candidate of entries) {
     const record = candidate as (SlotEntryLike & { options?: { id?: unknown } }) | null | undefined;
-    if (!record || typeof record !== 'object' || typeof record.component !== 'function') continue;
+    if (!record || typeof record !== 'object' || !isRenderableComponent(record.component)) continue;
     const id = (record as { options?: { id?: unknown } }).options?.id;
     if (byId.has(id)) continue;
     byId.set(id, record);
@@ -82,6 +104,76 @@ export function entryId(entry: SlotEntryLike, index: number): string {
   return options?.id ?? `#${index}`;
 }
 
+/**
+ * 座位「第三方遮蔽者」判据（单值座让位用）。
+ *
+ * 宿主的动态包守卫（dsh-cordis-client-runner 的 `guardedSlots`）对非 chain
+ * 槽位的 register 做两件事：① **强制**用页内遮蔽秩覆盖插件自报的 priority
+ * （`--nextPriority`，负数且唯一——插件写 priority:-1 也会被覆盖成分配值）；
+ * ② fiber 名取 `dyn/<pluginId>`，而条目 `registrant` = `options.registrant ??
+ * fiber.name`。出厂自带占用者（如 client-ui-model-selection 的 ModelSelect）
+ * 不经过该守卫：不带 priority（≡0），registrant 也没有 `dyn/` 前缀。
+ *
+ * 据此把「第三方遮蔽者」与「出厂占用者」分开：前者应当让位（镜像它），
+ * 后者继续由 Codinput 自绘控件代表（镜像出厂条目会与自绘控件重复）。
+ * 负 priority 是主判据（分配秩即遮蔽意图）；`dyn/` 前缀是兜底（防旧宿主/
+ * 未来守卫变化下 priority 未落进条目 options 的形态）。
+ */
+export function isShadowingOccupant(entry: SlotEntryLike): boolean {
+  const options = (entry as { options?: { priority?: number; registrant?: string } }).options;
+  const priority = options?.priority;
+  if (typeof priority === 'number' && priority < 0) return true;
+  const registrant = entry.registrant ?? options?.registrant;
+  return typeof registrant === 'string' && registrant.startsWith('dyn/');
+}
+
+/**
+ * 单条目渲染（座位镜像与单值座共用）：官方 SessionEntry → renderEntry 的
+ * props 展开式 `{...standard(kit), sessionId, ...entryInjectProps, ...t,
+ * ...ownerProps}`——owner props 最后展开（如模型座的 `locked` 不被 kit 覆盖）。
+ * 逐条目 EntryBoundary 隔离：单个条目崩溃只丢本座位。
+ */
+export function renderSlotEntry(
+  entry: SlotEntryLike,
+  key: string,
+  options: {
+    sessionId: string;
+    standard: Record<string, unknown> | undefined;
+    /** 官方 renderSlot 第二参数的 owner props（如模型座 { locked }）。 */
+    ownerProps?: Record<string, unknown> | undefined;
+    /** 条目崩溃时的兜底渲染（单值座让位用：回退自绘控件；缺省 null）。 */
+    fallback?: React.ReactNode;
+  },
+): JSX.Element {
+  const { sessionId, standard, ownerProps, fallback } = options;
+  const Comp = entry.component as React.ComponentType<Record<string, unknown>>;
+  // 条目词典的 t（官方 localeSeat 同款）；无 locale 或绑定失败 → 不下发，
+  // 组件按各自回退（如 enhancer 回退内置中文词典）。
+  let t: unknown;
+  try {
+    t = translatorFor(entry) ?? undefined;
+  } catch {
+    t = undefined;
+  }
+  let injected: Record<string, unknown> | null = null;
+  try {
+    injected = entryInjectProps(entry, sessionId);
+  } catch (error) {
+    diagError('slot.seat.inject', error);
+  }
+  return createElement(
+    EntryBoundary,
+    { key, fallback },
+    createElement(Comp, {
+      ...(standard ?? {}),
+      sessionId,
+      ...(injected ?? {}),
+      ...(t !== undefined ? { t } : {}),
+      ...(ownerProps ?? {}),
+    }),
+  );
+}
+
 export type SnapshotSelectorHook = <S>(sel: (s: any) => S, eq?: (a: S, b: S) => boolean) => S;
 
 /** 快照 store → use<Name> 选择器钩子（官方 observableHook 同款，按源缓存）。 */
@@ -113,38 +205,60 @@ export function standardHookPropName(name: string): string {
  * 复刻）：以 sessionId 调 inject，把 hooks 子表折成 use<Name> 钩子、其余
  * 原样下传；keyedHooks 需要官方 keyed resolver 面，插件侧不可复现 → 跳过
  * （现网条目无键控钩子）。结果按（条目 × 会话）缓存——官方同款缓存轴。
+ *
+ * 为什么额外记「失败」：官方 renderer 是在**宿主自己的 fiber 上下文里**调
+ * 这个 inject 闭包；插件侧从自己的 fiber 调会丢掉条目所属插件的 ctx 绑定，
+ * 于是依赖宿主服务面的 inject 会抛 `cannot get property "remote.session"
+ * without inject`（实测 dsh-model-accordion 0.2.1 的 `directoryFor`）。这是
+ * 插件侧不可复现的边界——单值座镜像据此让位降级（回退自绘控件），而不是把
+ * 空 props 下发给一个必然崩溃的组件。
  */
-const entryInjectCache = new WeakMap<object, Map<string, Record<string, unknown> | null>>();
-export function entryInjectProps(entry: SlotEntryLike, sessionId: string): Record<string, unknown> | null {
-  if (typeof entry.inject !== 'function') return null;
+interface InjectBound {
+  props: Record<string, unknown> | null;
+  failed: boolean;
+}
+const entryInjectCache = new WeakMap<object, Map<string, InjectBound>>();
+
+function boundInject(entry: SlotEntryLike, sessionId: string): InjectBound {
   let perSession = entryInjectCache.get(entry);
   if (!perSession) {
     perSession = new Map();
     entryInjectCache.set(entry, perSession);
   }
-  if (!perSession.has(sessionId)) {
-    let bound: Record<string, unknown> | null = null;
-    try {
-      const face = entry.inject(sessionId);
-      if (face && typeof face === 'object') {
-        const { hooks: _hooks, keyedHooks: _keyed, ...rest } = face as Record<string, unknown> & {
-          hooks?: Record<string, unknown>;
-          keyedHooks?: Record<string, unknown>;
-        };
-        void _keyed;
-        for (const [name, source] of Object.entries(_hooks ?? {})) {
-          const hook = snapshotHookFor(source);
-          if (hook) rest[standardHookPropName(name)] = hook;
-        }
-        bound = rest;
+  const cached = perSession.get(sessionId);
+  if (cached) return cached;
+  let bound: InjectBound = { props: null, failed: false };
+  try {
+    const face = entry.inject?.(sessionId);
+    if (face && typeof face === 'object') {
+      const { hooks: _hooks, keyedHooks: _keyed, ...rest } = face as Record<string, unknown> & {
+        hooks?: Record<string, unknown>;
+        keyedHooks?: Record<string, unknown>;
+      };
+      void _keyed;
+      for (const [name, source] of Object.entries(_hooks ?? {})) {
+        const hook = snapshotHookFor(source);
+        if (hook) rest[standardHookPropName(name)] = hook;
       }
-    } catch (error) {
-      diagError('slot.inject', error);
-      bound = null;
+      bound = { props: rest, failed: false };
     }
-    perSession.set(sessionId, bound);
+  } catch (error) {
+    diagError('slot.inject', error);
+    bound = { props: null, failed: true };
   }
-  return perSession.get(sessionId) ?? null;
+  perSession.set(sessionId, bound);
+  return bound;
+}
+
+export function entryInjectProps(entry: SlotEntryLike, sessionId: string): Record<string, unknown> | null {
+  if (typeof entry.inject !== 'function') return null;
+  return boundInject(entry, sessionId).props;
+}
+
+/** 该条目 inject 是否抛错（宿主 ctx 绑定面缺失的判据，见上）。 */
+export function entryInjectFailed(entry: SlotEntryLike, sessionId: string): boolean {
+  if (typeof entry.inject !== 'function') return false;
+  return boundInject(entry, sessionId).failed;
 }
 
 /** 官方 renderer 的 locale 座位：locale.bind(entry.locale)，按 ns 缓存。 */

package/src/client/host-types.ts

@@ -61,7 +61,15 @@ export interface SlotEntryLike {
   readonly inject?: (...args: unknown[]) => Record<string, unknown>;
   /** 条目词典命名空间（locale.bind(ns) 即官方传给组件的 t）。 */
   readonly locale?: string;
+  /** 归属（options.registrant ?? fiber.name；动态包为 dyn/<pluginId>）。 */
   readonly registrant?: string;
+  /** 注册选项切面：priority 负数 = 动态包被守卫分配的页内遮蔽秩（见 slotEntry）。 */
+  readonly options?: {
+    readonly id?: string;
+    readonly order?: number;
+    readonly priority?: number;
+    readonly registrant?: string;
+  };
 }
 
 // ---------- input machine ----------