@lingfan-engine/ui 0.0.0-stage → 0.1.1

package/src/host/index.ts

@@ -0,0 +1,47 @@
+/**
+ * 宿主公共面出口（唯一出口）：两个参考宿主（Vue 参考宿主、原生 DOM 模板宿主）共用的
+ * 「表现层骨架」——帧循环、状态分发、层级下发、帧驱动表现、节律默认值。
+ *
+ * 这里只放**与平台无关的纯逻辑**：DOM 写入、框架状态、样式表统统留在各宿主自己的目录里。
+ * 判据很简单——本目录不得出现 `document` / `window` / 框架 import / 模块级可变状态；
+ * 需要碰 DOM 的地方一律以接口形式把动作注入进来。
+ */
+export {
+  DEFAULT_ACTION_TOAST_MS,
+  DEFAULT_LOAD_TOAST_MS,
+  DEFAULT_NOTIFY_MS,
+  DEFAULT_ROLLBACK_NOTICE_MS,
+  DEFAULT_TEXT_CPS,
+  DEFAULT_TOAST_MS,
+} from "./duration";
+export {
+  createVisualEffects,
+  resolveAnimatedStyle,
+  type AnimatedStyle,
+  type AnimationHost,
+  type EffectSource,
+  type EffectSurfaceHost,
+  type VisualEffectsOptions,
+} from "./effects";
+export {
+  createFrameLoop,
+  type FrameLoop,
+  type FrameLoopOptions,
+  type FrameSource,
+} from "./frame-loop";
+export {
+  createLayerView,
+  type LayerView,
+  type LayerViewOptions,
+} from "./layer-view";
+export {
+  createStateView,
+  isDialogueSuppressed,
+  isNvlActive,
+  isTypingEnabled,
+  resolveTypingCps,
+  type StateIntent,
+  type StateKeyTable,
+  type StateViewOptions,
+  type TypingSetting,
+} from "./state-view";

package/src/host/layer-view.ts

@@ -0,0 +1,74 @@
+/**
+ * 层级 z：把「实例级 z 覆盖」这张表按层落到渲染面上。
+ *
+ * 一个层最终用哪个 z 由三级链决定（实例 > 工程层默认 > 内建），判定本身在引擎里
+ * （`resolveInstanceZ`）；本模块只负责两件事：
+ * 1. 记住某层被命令参数覆盖成了什么（`setOverride`），值不是数字时视为「回层默认」；
+ * 2. 用注入的 `applyLayerZ` 把六个 DOM 层交给宿主去写。
+ *
+ * 视频层单独一个方法：它的 z 不在 DOM 上而在视频端口内部，且**只在视频层自己变化时**
+ * 才需要下发。合并进 `apply()` 会让「改标题栏层级」也写入一次视频样式——多出来的
+ * 那一次写没有任何语义，却足以让「谁在改 DOM」变得难查。
+ */
+
+import {
+  resolveInstanceZ,
+  type LayerId,
+  type LayerZTable,
+} from "@lingfan-engine/core";
+
+/** 由 DOM 承载的层（顺序即写入顺序；视频/小游戏/历史/偏好不在此表） */
+const DOM_LAYERS: readonly LayerId[] = [
+  "stage",
+  "dialogue",
+  "choices",
+  "notifications",
+  "toolbar",
+];
+
+/** 层级视图的输入：工程层默认表 + 两个下发出口（视频层可省） */
+export interface LayerViewOptions {
+  /** 工程层默认（`project.json` 的 `shell.layers`） */
+  layerZ: LayerZTable;
+  /** 写某个 DOM 层的 z 序 */
+  applyLayerZ(layer: LayerId, z: number): void;
+  /** 视频层 z 下发（端口内部；不提供时 `applyVideo()` 为空操作） */
+  onVideoZ?(z: number): void;
+}
+
+/** 层级视图句柄：实例级覆盖的收纳与下发 */
+export interface LayerView {
+  /** 命令参数写入的实例级覆盖：`undefined` = 回层默认 */
+  setOverride(layer: string, value: number | undefined): void;
+  /** 某个层的最终 z */
+  zOf(layer: LayerId): number;
+  /** 把所有 DOM 层的最终 z 下发一次（装配期与每次覆盖变化后调用） */
+  apply(): void;
+  /** 单独下发视频层 z（仅在该层变化后调用） */
+  applyVideo(): void;
+}
+
+/**
+ * 创建层级视图：覆盖表在闭包里，每实例一份。
+ * `apply()` 只遍历由 DOM 承载的层；视频层走 `applyVideo()` 单独下发。
+ */
+export function createLayerView(options: LayerViewOptions): LayerView {
+  const overrides: Partial<Record<string, number>> = {};
+
+  const zOf = (layer: LayerId): number =>
+    resolveInstanceZ(layer, overrides[layer], options.layerZ);
+
+  return {
+    setOverride(layer: string, value: number | undefined): void {
+      if (value === undefined) delete overrides[layer];
+      else overrides[layer] = value;
+    },
+    zOf,
+    apply(): void {
+      for (const layer of DOM_LAYERS) options.applyLayerZ(layer, zOf(layer));
+    },
+    applyVideo(): void {
+      options.onVideoZ?.(zOf("video"));
+    },
+  };
+}

package/src/host/state-view.ts

@@ -0,0 +1,190 @@
+/**
+ * 状态分发：把引擎状态变更（`{ key, value }`）翻译成宿主认得的一条**视图意图**。
+ *
+ * 引擎的状态键是弱类型的（`value: unknown`），每个键怎么解读、缺省怎么回退，是一套容易
+ * 在多个宿主里各写一遍、然后慢慢走样的规则：数值键要不要落回层默认、数组键要不要兜空、
+ * `"hide"` 算不算隐藏、打字机开关缺省是开还是关……这里把这套规则收成一处。
+ *
+ * 分工是「意图带数据、导出函数带规则」：意图只把状态里的事实搬出来（文本、设置、数组），
+ * 需要宿主提供外部事实才能算出的值（默认字速、角色配色）走具名注入或导出的纯函数，
+ * 于是宿主的 switch 里只剩「落到自己的 DOM / 框架状态上」这一件事。
+ *
+ * **键名与键分类都由宿主注入**：订阅哪几个状态键是宿主与引擎之间的接线契约，本模块不内置
+ * 任何键名；「键名 → 层名」的判定也用宿主给的函数（通常就是引擎的 `instanceZLayer`）。
+ *
+ * 本模块是纯函数式的：不持有视图状态、不写 DOM。
+ */
+
+import type { ElementInstance, LayerId } from "@lingfan-engine/core";
+
+/** 故事级打字机设置（`text_typewriter` 命令写入的状态形态） */
+export interface TypingSetting {
+  enabled?: boolean;
+  speed?: number;
+}
+
+/** 一条视图意图：`kind` 决定宿主去看哪个字段 */
+export type StateIntent =
+  /** 某层的实例级 z 被改写（`z` 为 undefined = 回层默认） */
+  | { kind: "layer"; layer: LayerId; z: number | undefined }
+  /** 说话人一行：空串 = 无人说话 */
+  | { kind: "speaker"; text: string; color: string | null }
+  /** 新的一句正文；`setting` 为 undefined = 用宿主默认（打字机开、默认字速） */
+  | { kind: "dialog-text"; text: string; setting: TypingSetting | undefined }
+  /** 等待态机的当前态（决定对话层让位与选项区形态） */
+  | { kind: "waiting"; waiting: string }
+  /** NVL 模式（`"none"` = 关闭） */
+  | { kind: "nvl-mode"; mode: string }
+  /** NVL 缓冲行（整体替换） */
+  | { kind: "nvl-buffer"; lines: readonly string[] }
+  /** 菜单选项或输入提示变了：选项区整体重建 */
+  | { kind: "choices" }
+  /** 对话框显隐（`window show|hide`） */
+  | { kind: "dialog-visible"; hidden: boolean }
+  /** 舞台元素整体替换 */
+  | { kind: "elements"; elements: readonly ElementInstance[] }
+  /** 与本宿主无关的键 */
+  | { kind: "none" };
+
+/** 宿主订阅的状态键表：每项是引擎状态键的名字，只是换个可读的别名 */
+export interface StateKeyTable {
+  /** 当前说话人 */
+  speaker: string;
+  /** 当前正文 */
+  dialogText: string;
+  /** 等待态 */
+  waiting: string;
+  /** NVL 模式 */
+  nvlMode: string;
+  /** NVL 缓冲 */
+  nvlBuffer: string;
+  /** 菜单选项文本 */
+  menuOptions: string;
+  /** 菜单选项目标 */
+  menuTargets: string;
+  /** 对话框显隐 */
+  dialogVisible: string;
+  /** 舞台元素表 */
+  elements: string;
+}
+
+/** 状态分发器的输入：键表 + 三个查询出口（层级反查、打字机设置、角色配色） */
+export interface StateViewOptions {
+  /** 宿主订阅的键表 */
+  keys: StateKeyTable;
+  /** 键名 → 该键是否承载某一层的实例级 z；不是层级键时返回 undefined */
+  resolveLayer(key: string): LayerId | undefined;
+  /** 读当前故事级打字机设置 */
+  readTypingSetting(): TypingSetting | undefined;
+  /** 角色配色查询；无名或未定义配色时返回 null */
+  readCharacterColor(name: string): string | null;
+}
+
+/** 读说话人一行：状态键里存的是字符串，非字符串一律当空 */
+function readSpeakerIntent(
+  value: unknown,
+  readCharacterColor: (name: string) => string | null,
+): StateIntent {
+  const text = typeof value === "string" ? value : "";
+  // 空串也要查一次：名字为空时配色查询的返回值同样是配色口径的一部分，跳过会引入分叉
+  return { kind: "speaker", text, color: readCharacterColor(text) };
+}
+
+/**
+ * 创建状态分发器：返回的函数对每个状态键给出一条意图。
+ * 各键互不重叠，故分支顺序只影响可读性。
+ */
+export function createStateView(
+  options: StateViewOptions,
+): (key: string, value: unknown) => StateIntent {
+  const { keys } = options;
+  return (key: string, value: unknown): StateIntent => {
+    // 实例级 z：先问宿主这个键是不是层级键，值非数字时视为「回层默认」
+    const layer = options.resolveLayer(key);
+    if (layer !== undefined) {
+      return {
+        kind: "layer",
+        layer,
+        z: typeof value === "number" ? value : undefined,
+      };
+    }
+    if (key === keys.speaker) {
+      return readSpeakerIntent(value, options.readCharacterColor);
+    }
+    if (key === keys.dialogText) {
+      const text = typeof value === "string" ? value : "";
+      return {
+        kind: "dialog-text",
+        text,
+        setting: options.readTypingSetting(),
+      };
+    }
+    if (key === keys.waiting) {
+      return {
+        kind: "waiting",
+        waiting: typeof value === "string" ? value : "none",
+      };
+    }
+    if (key === keys.nvlMode) {
+      return {
+        kind: "nvl-mode",
+        mode: typeof value === "string" ? value : "none",
+      };
+    }
+    if (key === keys.nvlBuffer) {
+      return {
+        kind: "nvl-buffer",
+        lines: Array.isArray(value) ? (value as string[]) : [],
+      };
+    }
+    // 选项与目标两键分别写入：任一到达都做一次整体重建
+    if (key === keys.menuOptions || key === keys.menuTargets)
+      return { kind: "choices" };
+    if (key === keys.dialogVisible)
+      return { kind: "dialog-visible", hidden: value === "hide" };
+    if (key === keys.elements) {
+      return {
+        kind: "elements",
+        elements: (value as ElementInstance[] | undefined) ?? [],
+      };
+    }
+    return { kind: "none" };
+  };
+}
+
+/**
+ * 本句字速：故事给了正数就用它，否则用宿主默认。
+ * `0` / 负数 / 非数字都当没给——`0` 会让打字机永远不前进（表现为卡死在空台词）。
+ */
+export function resolveTypingCps(
+  setting: TypingSetting | undefined,
+  fallback: number,
+): number {
+  const speed = setting?.speed;
+  return typeof speed === "number" && speed > 0 ? speed : fallback;
+}
+
+/** 本句是否走打字机：只有显式 `enabled === false` 才整句直出，缺省是打字机开 */
+export function isTypingEnabled(setting: TypingSetting | undefined): boolean {
+  return setting?.enabled !== false;
+}
+
+/**
+ * NVL 层是否生效：模式开着**且**有内容。
+ * 只有模式而无内容时仍走普通对话框——否则会闪出一个空白整屏层。
+ */
+export function isNvlActive(mode: string, lines: readonly string[]): boolean {
+  return mode !== "none" && lines.length > 0;
+}
+
+/**
+ * 对话层是否让位。三个让位条件互相独立：
+ * NVL 接管、故事显式隐藏、以及视频等待期——视频要占满舞台，压不住底部对话框会很难看。
+ */
+export function isDialogueSuppressed(state: {
+  nvlActive: boolean;
+  hidden: boolean;
+  waiting: string;
+}): boolean {
+  return state.nvlActive || state.hidden || state.waiting === "video";
+}

package/src/index.ts

@@ -0,0 +1,161 @@
+/**
+ * 参考展示层出口：按渲染域归类（dialogue 对话渲染 / audio 音频差量 / video 视频命令流），
+ * 框架无关的可测纯逻辑。具体宿主（Vue/React/原生 DOM）只消费这些入口，换框架不影响核心。
+ */
+export {
+  configureStoryFonts,
+  renderInlineMarkup,
+  sanitizeFont,
+  type StoryFontGate,
+  Typewriter,
+  renderDialogueLine,
+  type DialogueLineInput,
+  type DialogueLineView,
+} from "./dialogue";
+export {
+  builtinBubbleTemplate,
+  createDialogueTemplateRegistry,
+  type DialogueTemplateFn,
+  type DialogueTemplateInput,
+  type DialogueTemplateRegistry,
+  type DialogueTemplateView,
+} from "./dialogue";
+export {
+  TemplateRegistry,
+  createTemplateRegistry,
+  type TemplateFn,
+  type TemplateViewBase,
+} from "./templates";
+export {
+  builtinChoiceTemplate,
+  createChoiceTemplateRegistry,
+  type ChoiceTemplateFn,
+  type ChoiceTemplateInput,
+  type ChoiceTemplateOption,
+  type ChoiceTemplateRegistry,
+  type ChoiceTemplateView,
+} from "./choices";
+export {
+  builtinNotifyTemplate,
+  createNotifyTemplateRegistry,
+  toNotifyTone,
+  type NotifyTemplateFn,
+  type NotifyTemplateInput,
+  type NotifyTemplateRegistry,
+  type NotifyTemplateView,
+  type NotifyTone,
+} from "./notify";
+export {
+  EMPTY_AUDIO_VIEW,
+  createAudioRenderer,
+  planAudioActions,
+  readAudioView,
+  type AudioAction,
+  type AudioRenderer,
+  type AudioRendererOptions,
+  type AudioView,
+} from "./audio";
+export {
+  createVideoRenderer,
+  type VideoRenderer,
+  type VideoRendererOptions,
+} from "./video";
+export { createMinigameRegistry, type MinigameRegistry } from "./minigame";
+export {
+  createElementRegistry,
+  createElementResourceResolver,
+  easingFn,
+  easingNames,
+  elementClassName,
+  elementSource,
+  elementStyle,
+  hasElementInteraction,
+  interpolateAnimation,
+  isElementDisabled,
+  registerBuiltinElementRenderers,
+  renderElementTree,
+  resolveElementAction,
+  shakeOffset,
+  transitionOpacity,
+  type ElementAction,
+  type ElementActionOptions,
+  type ElementRegistry,
+  type ElementRenderer,
+  type ElementRenderContext,
+  type ElementResourceResolver,
+  type ElementTreeRenderOptions,
+  type RenderEvent,
+  type RenderEventPatch,
+  type RenderKind,
+  type RenderPort,
+  type RenderPropValue,
+  type RenderSpec,
+} from "./element";
+export {
+  createDomOverlaySurface,
+  createDomRenderPort,
+  materialize,
+  type DomOverlaySurface,
+  type NarrativeMounts,
+} from "./dom";
+export {
+  createCommandRegistry,
+  type CommandRegistry,
+  type NamedCommandHandler,
+} from "./commands";
+export {
+  GAME_INPUT_BLOCKED_SELECTOR,
+  INPUT_SCOPES,
+  createInputScopeState,
+  isGameInputTarget,
+  isInputScope,
+  routesToNarrative,
+  type ClosestLike,
+  type InputScope,
+  type InputScopeState,
+} from "./input";
+export {
+  createNarrativeOverlay,
+  type ChoicesLayerInput,
+  type ChoicesLayerOption,
+  type ChoicesLayerView,
+  type ChoicesTexts,
+  type DialogueLayerView,
+  type NarrativeOverlay,
+  type NarrativeOverlayOptions,
+  type NarrativeOverlayView,
+  type NotifyLayerItem,
+  type OverlayLayerId,
+  type OverlaySurface,
+} from "./overlay";
+export {
+  DEFAULT_ACTION_TOAST_MS,
+  DEFAULT_LOAD_TOAST_MS,
+  DEFAULT_NOTIFY_MS,
+  DEFAULT_ROLLBACK_NOTICE_MS,
+  DEFAULT_TEXT_CPS,
+  DEFAULT_TOAST_MS,
+  createFrameLoop,
+  createLayerView,
+  createStateView,
+  createVisualEffects,
+  isDialogueSuppressed,
+  isNvlActive,
+  isTypingEnabled,
+  resolveAnimatedStyle,
+  resolveTypingCps,
+  type AnimatedStyle,
+  type AnimationHost,
+  type EffectSource,
+  type EffectSurfaceHost,
+  type FrameLoop,
+  type FrameLoopOptions,
+  type FrameSource,
+  type LayerView,
+  type LayerViewOptions,
+  type StateIntent,
+  type StateKeyTable,
+  type StateViewOptions,
+  type TypingSetting,
+  type VisualEffectsOptions,
+} from "./host";

package/src/input/index.ts

@@ -0,0 +1,11 @@
+export {
+  GAME_INPUT_BLOCKED_SELECTOR,
+  INPUT_SCOPES,
+  createInputScopeState,
+  isGameInputTarget,
+  isInputScope,
+  routesToNarrative,
+  type ClosestLike,
+  type InputScope,
+  type InputScopeState,
+} from "./scope";

package/src/input/scope.ts

@@ -0,0 +1,100 @@
+/**
+ * 输入域声明与游戏输入判据（框架无关纯逻辑，宿主与嵌入方共用）。
+ *
+ * 回答两个不同层面的「谁消费输入」：
+ *
+ * 1. **事件目标层面**（[`isGameInputTarget`]）：舞台铺满视口且内部挂着工具条与面板，
+ *    事件会从这些控件冒泡上来。命中原生输入控件、或位于标记为 UI 容器的元素内
+ *    （`[data-ui-zone]`）即非游戏输入——否则在历史面板里滚动会连带把故事回退，
+ *    输入框里的空格会被推进逻辑消费。
+ * 2. **模式层面**（[`InputScope`]）：外部玩法系统接管期间（方向键行走、战斗、QTE），
+ *    推进类按键应整体让位，而不是逐事件判断。
+ *
+ * 两者正交，[`routesToNarrative`] 同时要求「域为对话」与「目标不是控件」。
+ * 域是**宿主状态**而非引擎状态：输入路由属展示层职责，引擎只暴露等待态
+ * （`__waiting`），由宿主决定把按键交给谁。
+ *
+ * 有意不看「容器当前是否真能滚动」：同一面板的滚轮行为不应随内容多少变脸
+ * （内容不满一屏时也一律不回溯，避免滚轮在面板里时而回溯时而滚动）。
+ */
+
+/** 输入域：本帧的按键 / 滚轮 / 点击归谁消费 */
+export type InputScope =
+  /** 对话域（默认）：推进、回溯、前进由叙事层消费 */
+  | "dialogue"
+  /** 外部玩法域：叙事层整体让位，输入归外部系统（行走、战斗…） */
+  | "world"
+  /** 面板域：输入归界面控件，叙事层不消费 */
+  | "ui";
+
+/** 域全集（诊断 / 遍历用；顺序 = 默认在前） */
+export const INPUT_SCOPES: readonly InputScope[] = ["dialogue", "world", "ui"];
+
+/** 域值收窄：非声明值一律不成立（外部传入的字符串不做猜测） */
+export function isInputScope(value: unknown): value is InputScope {
+  return value === "dialogue" || value === "world" || value === "ui";
+}
+
+/** 原生输入控件 + UI 容器标记；命中即非游戏输入 */
+export const GAME_INPUT_BLOCKED_SELECTOR =
+  'input, textarea, select, [contenteditable]:not([contenteditable="false"]), [data-ui-zone]';
+
+/** 判定所需的最小事件目标接口（显式入参便于单测；真实值 = DOM Element） */
+export interface ClosestLike {
+  closest(selector: string): unknown | null;
+}
+
+/**
+ * 事件目标是否属于游戏域（`true` = 应触发游戏输入）。
+ * 不具备 `closest` 能力的目标（视口/文档/非元素）保守视为游戏域——它们不可能是控件内部。
+ */
+export function isGameInputTarget(target: unknown): boolean {
+  if (target === null || typeof target !== "object") return true;
+  const el = target as Partial<ClosestLike>;
+  if (typeof el.closest !== "function") return true;
+  return el.closest(GAME_INPUT_BLOCKED_SELECTOR) === null;
+}
+
+/**
+ * 本次输入是否归叙事层消费：**域为对话** 且 **目标不在控件/UI 面板内**。
+ *
+ * 任一不成立即不消费，宿主据此短路——玩法接管期间连 `advance` 都不发，
+ * 避免「让位后仍在后台推进故事」这类竞态。
+ */
+export function routesToNarrative(scope: InputScope, target: unknown): boolean {
+  return scope === "dialogue" && isGameInputTarget(target);
+}
+
+/** 可变输入域（宿主持有；订阅用于界面提示与路由刷新） */
+export interface InputScopeState {
+  current(): InputScope;
+  /** 切换域；非法值忽略（保持原域）——域来自宿主，畸形输入不猜 */
+  set(scope: InputScope): void;
+  /** 订阅域变化；返回退订函数 */
+  subscribe(listener: (scope: InputScope) => void): () => void;
+}
+
+/**
+ * 建输入域状态。默认 `dialogue`（叙事激活），玩法系统接管时由宿主切 `world`。
+ * 同值重复设置不通知订阅者（宿主可能在每帧断言域）。
+ */
+export function createInputScopeState(
+  initial: InputScope = "dialogue",
+): InputScopeState {
+  let scope: InputScope = initial;
+  const listeners = new Set<(scope: InputScope) => void>();
+  return {
+    current: () => scope,
+    set(next: InputScope): void {
+      if (!isInputScope(next) || next === scope) return;
+      scope = next;
+      for (const listener of listeners) listener(scope);
+    },
+    subscribe(listener: (scope: InputScope) => void): () => void {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+  };
+}

package/src/minigame/index.ts

@@ -0,0 +1,2 @@
+/** 小游戏渲染域出口：小游戏注册表（宿主按名字取用实现，渲染层不内建任何小游戏）。 */
+export { createMinigameRegistry, type MinigameRegistry } from "./registry";

package/src/minigame/registry.ts

@@ -0,0 +1,35 @@
+/**
+ * 小游戏注册表（UI 层职责）：minigame 命令只声明 gameId，
+ * 宿主经注册表解析工厂后挂载。与对话框模板注册表的关键差异：**未知 gameId 无默认回退**
+ * ——get 返回 undefined = fail-closed（宿主必须显式上报，不得伪造完成）。
+ */
+
+import type { MinigameFactory } from "@lingfan-engine/core";
+
+/**
+ * 小游戏 id → 工厂的查表。`get` 未命中即 `undefined`，调用方必须显式上报
+ * ——玩法系统未注册时不得上报完成结果，否则叙事会带着假的完成结果往下走。
+ */
+export interface MinigameRegistry {
+  /** 注册/覆盖更新（同 gameId 再注册 = 替换，开发热替换语义） */
+  register(gameId: string, factory: MinigameFactory): void;
+  /** 解析工厂；未注册 = undefined（fail-closed：不伪造默认实现） */
+  get(gameId: string): MinigameFactory | undefined;
+  has(gameId: string): boolean;
+}
+
+/** 造一张空的小游戏表；玩法系统由宿主在装配期逐个注册 */
+export function createMinigameRegistry(): MinigameRegistry {
+  const factories = new Map<string, MinigameFactory>();
+  return {
+    register(gameId: string, factory: MinigameFactory): void {
+      factories.set(gameId, factory);
+    },
+    get(gameId: string): MinigameFactory | undefined {
+      return factories.get(gameId);
+    },
+    has(gameId: string): boolean {
+      return factories.has(gameId);
+    },
+  };
+}

package/src/notify/index.ts

@@ -0,0 +1,11 @@
+/** 通知层挂载点出口（模板注册制）。 */
+export {
+  builtinNotifyTemplate,
+  createNotifyTemplateRegistry,
+  toNotifyTone,
+  type NotifyTemplateFn,
+  type NotifyTemplateInput,
+  type NotifyTemplateRegistry,
+  type NotifyTemplateView,
+  type NotifyTone,
+} from "./templates";