@shellraining/dsh-local-annotation 0.0.0-stage → 0.1.1

package/lib/client.js

@@ -0,0 +1,1824 @@
+// Generated from TypeScript by pnpm run build.
+window.__ModuleLoader__.load({
+  id: "@shellraining/dsh-local-annotation",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.tsx
+var client_exports = {};
+__export(client_exports, {
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(client_exports);
+var import_client = require("react-dom/client");
+
+// src/appearance.ts
+var STROKES = [
+  { id: "marker", label: "荧光笔" },
+  { id: "underline", label: "实线" },
+  { id: "dashed", label: "虚线" },
+  { id: "dotted", label: "点线" },
+  { id: "wavy", label: "波浪线" }
+];
+var ICONS = [
+  { id: "message", label: "气泡" },
+  { id: "bookmark", label: "书签" },
+  { id: "note", label: "便签" },
+  { id: "number", label: "纯编号" }
+];
+var COLORS = [
+  { value: "theme", label: "主题色" },
+  { value: "#fbf719", label: "柠檬黄" },
+  { value: "#77dba9", label: "薄荷绿" },
+  { value: "#f5a6c8", label: "樱花粉" },
+  { value: "#b9a3f5", label: "薰衣紫" },
+  { value: "#80c8f5", label: "晴空蓝" }
+];
+var DEFAULT_APPEARANCE = { stroke: "marker", color: "#fbf719", icon: "message" };
+var PREFIX = "dsh-local-annotation.appearance.v1.";
+var FIELDS = ["stroke", "color", "icon"];
+function valid(field, value) {
+  if (typeof value !== "string") return false;
+  if (field === "color") return value === "theme" || /^#[\da-f]{6}$/i.test(value);
+  return (field === "stroke" ? STROKES : ICONS).some((option) => option.id === value);
+}
+function ink(color) {
+  return color === "theme" ? "var(--dsw-alias-brand-primary)" : /^#[\da-f]{6}$/i.test(color) ? color : DEFAULT_APPEARANCE.color;
+}
+function highlightCSS(stroke, color) {
+  const tint = ink(color);
+  if (stroke === "marker") return `background-color:color-mix(in srgb, ${tint} 32%, transparent);text-decoration:none;`;
+  const line = stroke === "underline" ? "solid" : stroke;
+  return `background-color:transparent;text-decoration:underline ${line} ${tint};text-decoration-thickness:2px;text-underline-offset:.2em;`;
+}
+var AppearanceStore = class {
+  constructor(changed) {
+    this.changed = changed;
+    this.read();
+    this.style.dataset.localAnnotationAppearance = "";
+    this.render();
+    document.head.append(this.style);
+    window.addEventListener("storage", this.sync);
+  }
+  changed;
+  state = { ...DEFAULT_APPEARANCE };
+  style = document.createElement("style");
+  sync = (event) => {
+    if (event.key !== null && !FIELDS.some((field) => event.key === PREFIX + field)) return;
+    try {
+      if (event.storageArea !== window.localStorage) return;
+    } catch {
+      return;
+    }
+    this.read();
+    this.render();
+    this.changed(this.state);
+  };
+  getSnapshot() {
+    return this.state;
+  }
+  read() {
+    const next = { ...DEFAULT_APPEARANCE };
+    try {
+      for (const field of FIELDS) {
+        const value = window.localStorage.getItem(PREFIX + field);
+        if (valid(field, value)) Object.assign(next, { [field]: value });
+      }
+    } catch {
+    }
+    this.state = next;
+  }
+  set(field, value) {
+    if (!valid(field, value)) throw new Error("无效的批注外观设置。");
+    try {
+      window.localStorage.setItem(PREFIX + field, value);
+    } catch {
+      throw new Error("无法保存外观设置，请检查浏览器存储权限或可用空间。");
+    }
+    this.read();
+    this.render();
+    this.changed(this.state);
+  }
+  render() {
+    const { stroke, color, icon } = this.state;
+    this.style.textContent = `
+      ::highlight(dsh-local-annotation) { ${highlightCSS(stroke, color)} }
+      [data-local-annotation-marker], [data-local-annotation-status] .dla-number {
+        --dla-ink:${ink(color)}; --dla-marker-mask:var(--dla-mask-${icon});
+        --dla-marker-outline:var(--dla-outline-${icon});
+        --dla-marker-radius:${icon === "number" ? "var(--dsw-radius-sm)" : "0"};
+      }
+    `;
+  }
+  dispose() {
+    window.removeEventListener("storage", this.sync);
+    this.style.remove();
+  }
+};
+
+// src/model.ts
+var MAX_ITEMS = 200;
+var MAX_TEXT = 16e3;
+var MAX_NOTE = 8e3;
+var MAX_ID = 1024;
+var MAX_SOURCE = 8192;
+function boundedString(value, name2, max, nonempty = false) {
+  if (typeof value !== "string" || value.length > max || nonempty && !value.trim()) {
+    throw new TypeError(`${name2} 必须是${nonempty ? "非空" : ""}字符串，且不超过 ${max} 个字符`);
+  }
+  return value;
+}
+function annotationKey(value, name2) {
+  return boundedString(value, name2, MAX_ID, true);
+}
+function object(value, name2) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError(`${name2} 格式无效`);
+  return value;
+}
+function annotationSource(value, sessionId) {
+  const source = object(value, "批注来源");
+  if (source.kind === "message") return { kind: "message", key: boundedString(source.key, "消息来源", MAX_SOURCE, true) };
+  if (source.kind !== "file") throw new TypeError("批注必须具有明确的消息或文件来源");
+  const url = boundedString(source.url, "文件来源 URL", MAX_SOURCE, true);
+  const path = boundedString(source.path, "文件来源路径", MAX_SOURCE, true);
+  if (/[?#\u0000-\u001f\u007f]/.test(url) || /[\u0000-\u001f\u007f]/.test(path)) throw new TypeError("文件来源包含无效字符");
+  const match = /^dsh-resource:\/\/file\/session\/([^/]+)\/(.+)$/.exec(url);
+  let owner;
+  let decodedPath;
+  try {
+    owner = match?.[1] === void 0 ? void 0 : decodeURIComponent(match[1]);
+    decodedPath = match?.[2]?.split("/").map(decodeURIComponent).join("/");
+  } catch {
+    throw new TypeError("文件来源 URL 编码无效");
+  }
+  if (owner !== sessionId || decodedPath !== path) throw new TypeError("文件来源必须属于当前会话且与路径一致");
+  return { kind: "file", url, path };
+}
+function timestamp(value, name2) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new TypeError(`${name2} 必须是非负安全整数`);
+  return value;
+}
+function copyAnnotation(value) {
+  const item = object(value, "批注");
+  const sessionId = annotationKey(item.sessionId, "会话 ID");
+  const text = boundedString(item.text, "批注原文", MAX_TEXT, true);
+  const start = item.start;
+  const end = item.end;
+  const unknownPosition = start === -1 && end === -1;
+  if (!unknownPosition && (typeof start !== "number" || typeof end !== "number" || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end <= start)) {
+    throw new TypeError("批注位置必须是有效区间或 -1/-1");
+  }
+  const createdAt = timestamp(item.createdAt, "创建时间");
+  const updatedAt = timestamp(item.updatedAt, "更新时间");
+  if (updatedAt < createdAt) throw new TypeError("更新时间不能早于创建时间");
+  return {
+    id: annotationKey(item.id, "批注 ID"),
+    sessionId,
+    text,
+    note: boundedString(item.note, "批注内容", MAX_NOTE),
+    source: annotationSource(item.source, sessionId),
+    start,
+    end,
+    before: boundedString(item.before, "前文", MAX_TEXT),
+    after: boundedString(item.after, "后文", MAX_TEXT),
+    createdAt,
+    updatedAt
+  };
+}
+
+// src/anchors.ts
+var MESSAGE = '[data-chat-flow-kind="assistant-step"][data-chat-anchor-key]';
+var FILE_TEXT = "[data-document-markdown], [data-textpreview-plain], [data-code-preview] [data-code-block-content]";
+var EXCLUDED = 'button,input,textarea,select,[contenteditable="true"],[hidden],[aria-hidden="true"],[data-turn-process-hidden="true"],[data-local-annotation-panel],[data-local-annotation-card],[data-local-annotation-toolbar],[data-local-annotation-markers],[data-local-annotation-status]';
+var MAX_SOURCE_TEXT = 2e6;
+var MAX_NODES = 5e4;
+function sourceKey(source) {
+  return source.kind === "message" ? `message:${source.key}` : `file:${source.url}`;
+}
+function sourceOf(node, sessionId) {
+  const element = node instanceof Element ? node : node.parentElement;
+  if (!element || element.closest(EXCLUDED)) return null;
+  const file = element.closest(FILE_TEXT);
+  if (file) {
+    const preview = file.closest('[data-textpreview-state="text"][data-textpreview-url]');
+    const url = preview?.getAttribute("data-textpreview-url") ?? "";
+    const match = /^dsh-resource:\/\/file\/session\/([^/]+)\/(.+)$/.exec(url);
+    if (!match?.[1] || !match[2] || /[?#\u0000-\u001f]/.test(url)) return null;
+    try {
+      if (decodeURIComponent(match[1]) !== sessionId) return null;
+      const path = match[2].split("/").map(decodeURIComponent).join("/");
+      if (/[\u0000-\u001f\u007f]/.test(path)) return null;
+      return { root: file, source: { kind: "file", url, path } };
+    } catch {
+      return null;
+    }
+  }
+  const root = element.closest(MESSAGE);
+  if (!root || root.dataset.chatGroupPart === "reasoning" || root.closest(EXCLUDED)) return null;
+  if (root.closest("[data-conversation-session]")?.getAttribute("data-conversation-session") !== sessionId) return null;
+  return { root, source: { kind: "message", key: root.dataset.chatAnchorKey } };
+}
+function findRoot(source, sessionId) {
+  const selector = source.kind === "message" ? `${MESSAGE}[data-chat-anchor-key="${CSS.escape(source.key)}"]` : `[data-textpreview-url="${CSS.escape(source.url)}"] :is(${FILE_TEXT})`;
+  for (const element of document.querySelectorAll(selector)) {
+    const found = sourceOf(element, sessionId);
+    if (found && sourceKey(found.source) === sourceKey(source)) return found.root;
+  }
+  return null;
+}
+function indexText(root) {
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
+    acceptNode: (node) => node.parentElement?.closest(EXCLUDED) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT
+  });
+  const segments = [];
+  const parts = [];
+  let length = 0;
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    if (!(node instanceof Text)) continue;
+    if (segments.length >= MAX_NODES || length + node.length > MAX_SOURCE_TEXT) return null;
+    segments.push({ node, start: length, end: length + node.length });
+    parts.push(node.data);
+    length += node.length;
+  }
+  return { text: parts.join(""), segments };
+}
+function offsetAt(index, node, offset) {
+  const point = document.createRange();
+  point.setStart(node, offset);
+  point.collapse(true);
+  for (const segment of index.segments) {
+    if (segment.node === node) return segment.start + offset;
+    if (point.comparePoint(segment.node, 0) >= 0) return segment.start;
+  }
+  return index.text.length;
+}
+function rangeAt(index, start, end) {
+  const first = index.segments.find((s) => s.start <= start && s.end > start);
+  const last = index.segments.find((s) => s.start < end && s.end >= end);
+  if (!first || !last) return null;
+  const range = document.createRange();
+  range.setStart(first.node, start - first.start);
+  range.setEnd(last.node, end - last.start);
+  return range;
+}
+function capture(range, sessionId) {
+  const startRoot = sourceOf(range.startContainer, sessionId);
+  const endRoot = sourceOf(range.endContainer, sessionId);
+  if (!startRoot || !endRoot || startRoot.root !== endRoot.root) return null;
+  const index = indexText(startRoot.root);
+  if (!index) throw new Error("这段正文过大，请在较短的消息或文件预览中批注。");
+  const start = offsetAt(index, range.startContainer, range.startOffset);
+  const end = offsetAt(index, range.endContainer, range.endOffset);
+  if (end <= start || end - start > MAX_TEXT) throw new Error(`每条引文最多 ${MAX_TEXT} 个字符。`);
+  const text = index.text.slice(start, end);
+  if (!text.trim() || range.toString() !== text) return null;
+  const now = Date.now();
+  return {
+    id: crypto.randomUUID(),
+    sessionId,
+    text,
+    note: "",
+    source: startRoot.source,
+    start,
+    end,
+    before: index.text.slice(Math.max(0, start - 32), start),
+    after: index.text.slice(end, end + 32),
+    createdAt: now,
+    updatedAt: now
+  };
+}
+var Anchors = class {
+  indices = /* @__PURE__ */ new WeakMap();
+  invalidate(root) {
+    this.indices.delete(root);
+  }
+  clear() {
+    this.indices = /* @__PURE__ */ new WeakMap();
+  }
+  resolve(item, root) {
+    let index = this.indices.get(root);
+    if (index === void 0) {
+      index = indexText(root);
+      this.indices.set(root, index);
+    }
+    if (!index) return null;
+    let start = item.start;
+    if (start < 0 || index.text.slice(start, item.end) !== item.text) {
+      let found = -1;
+      let from = 0;
+      while (from <= index.text.length) {
+        const pos = index.text.indexOf(item.text, from);
+        if (pos < 0) break;
+        const before = index.text.slice(Math.max(0, pos - item.before.length), pos);
+        const after = index.text.slice(pos + item.text.length, pos + item.text.length + item.after.length);
+        if ((!item.before || before === item.before) && (!item.after || after === item.after)) {
+          if (found >= 0) return null;
+          found = pos;
+        }
+        from = pos + 1;
+      }
+      if (found < 0) return null;
+      start = found;
+    }
+    return rangeAt(index, start, start + item.text.length);
+  }
+};
+
+// src/markers.ts
+var WIDTH = 26;
+var HEIGHT = 24;
+var Markers = class {
+  constructor(open) {
+    this.open = open;
+    this.fonts?.addEventListener("loadingdone", this.schedule);
+  }
+  open;
+  groups = /* @__PURE__ */ new Map();
+  frame = 0;
+  disposed = false;
+  resize = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(() => this.schedule());
+  intersection = typeof IntersectionObserver === "undefined" ? null : new IntersectionObserver((entries) => {
+    for (const entry of entries) {
+      const group = this.groups.get(entry.target);
+      if (!group) continue;
+      group.visible = entry.isIntersecting;
+      if (group.visible) this.schedule();
+    }
+  });
+  fonts = document.fonts;
+  schedule = () => {
+    if (!this.disposed && this.groups.size && !this.frame) {
+      this.frame = requestAnimationFrame(() => {
+        this.frame = 0;
+        this.position();
+      });
+    }
+  };
+  update(entries) {
+    if (this.disposed) return;
+    const scrollable = /* @__PURE__ */ new Map();
+    const positionRoot = (node, source) => {
+      let element = node instanceof HTMLElement ? node : node.parentElement;
+      for (; element && element !== source && source.contains(element); element = element.parentElement) {
+        let scroll = scrollable.get(element);
+        if (scroll === void 0) {
+          const style = getComputedStyle(element);
+          scroll = /^(auto|scroll)$/.test(style.overflowX) || /^(auto|scroll)$/.test(style.overflowY);
+          scrollable.set(element, scroll);
+        }
+        if (scroll) return element;
+      }
+      return source;
+    };
+    const limited = [];
+    for (const entry of entries.slice(0, MAX_ITEMS)) {
+      const root = positionRoot(entry.range.startContainer, entry.root);
+      if (root.contains(entry.range.endContainer) && root === positionRoot(entry.range.endContainer, entry.root)) {
+        limited.push({ ...entry, root });
+      }
+    }
+    const roots = new Set(limited.map((entry) => entry.root));
+    this.resize?.disconnect();
+    for (const [root, group] of this.groups) {
+      if (!roots.has(root)) this.remove(root, group);
+      else {
+        group.node.replaceChildren();
+        group.markers = [];
+      }
+    }
+    const layout = /* @__PURE__ */ new Set([document.documentElement]);
+    for (const entry of limited) {
+      const { root, item, number } = entry;
+      let group = this.groups.get(root);
+      if (!group) {
+        const position = getComputedStyle(root).position === "static" ? { value: root.style.getPropertyValue("position"), priority: root.style.getPropertyPriority("position") } : null;
+        if (position) root.style.setProperty("position", "relative");
+        const node = document.createElement("div");
+        node.dataset.localAnnotationMarkers = "";
+        node.style.cssText = "all:initial;position:absolute;left:0;top:0;width:0;height:0;pointer-events:none;z-index:1;";
+        root.append(node);
+        group = { node, position, markers: [], visible: true };
+        this.groups.set(root, group);
+        this.intersection?.observe(root);
+      }
+      if (group.node.parentElement !== root) root.append(group.node);
+      const button = document.createElement("button");
+      button.type = "button";
+      button.dataset.localAnnotationMarker = "";
+      button.dataset.digits = String(number).length.toString();
+      const label = document.createElement("span");
+      label.textContent = String(number);
+      button.append(label);
+      button.setAttribute("aria-label", `编辑批注 ${number}`);
+      button.title = (item.note || item.text).slice(0, 240);
+      button.style.cssText = `position:absolute;box-sizing:border-box;width:${WIDTH}px;height:${HEIGHT}px;pointer-events:auto;visibility:hidden;user-select:none;text-align:center;`;
+      button.onpointerdown = (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+      };
+      button.onclick = (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        this.open(item);
+      };
+      group.node.append(button);
+      group.markers.push({ entry, button });
+      for (let element = root; element; element = element.parentElement) layout.add(element);
+      for (let element = entry.range.startContainer.parentElement; element && root.contains(element); element = element.parentElement) {
+        layout.add(element);
+        if (element === root) break;
+      }
+    }
+    if (this.groups.size) for (const element of layout) this.resize?.observe(element);
+    if (!this.groups.size && this.frame) {
+      cancelAnimationFrame(this.frame);
+      this.frame = 0;
+    }
+    this.schedule();
+  }
+  position() {
+    const writes = [];
+    for (const [root, group] of this.groups) {
+      if (!group.visible || !root.isConnected) continue;
+      const box = root.getBoundingClientRect();
+      const sx = root.offsetWidth ? box.width / root.offsetWidth : 0;
+      const sy = root.offsetHeight ? box.height / root.offsetHeight : 0;
+      const left = root.scrollLeft - root.clientLeft;
+      const top = root.scrollTop - root.clientTop;
+      const maxX = Math.max(0, root.scrollWidth - WIDTH);
+      const maxY = Math.max(0, root.scrollHeight - HEIGHT);
+      const overlaps = /* @__PURE__ */ new Map();
+      for (const { entry, button } of group.markers) {
+        const write = { button };
+        writes.push(write);
+        if (!sx || !sy || !root.contains(entry.range.startContainer) || !root.contains(entry.range.endContainer)) continue;
+        const caret = entry.range.cloneRange();
+        caret.collapse(true);
+        const rect = caret.getClientRects()[0] ?? caret.getBoundingClientRect();
+        if (!rect.height) continue;
+        const x = (rect.left - box.left) / sx + left;
+        const y = Math.max(0, Math.min(maxY, (rect.top - box.top) / sy + top - HEIGHT + 2));
+        const key = `${Math.round(x / WIDTH)}:${Math.round(y / HEIGHT)}`;
+        const count = overlaps.get(key) ?? 0;
+        overlaps.set(key, count + 1);
+        write.x = Math.max(0, Math.min(maxX, x + count * WIDTH));
+        write.y = y;
+      }
+    }
+    for (const { button, x, y } of writes) {
+      button.style.visibility = x === void 0 ? "hidden" : "visible";
+      if (x !== void 0 && y !== void 0) {
+        button.style.left = `${x}px`;
+        button.style.top = `${y}px`;
+      }
+    }
+  }
+  remove(root, group) {
+    this.intersection?.unobserve(root);
+    group.node.remove();
+    if (group.position && root.style.getPropertyValue("position") === "relative" && root.style.getPropertyPriority("position") === "") {
+      if (group.position.value) root.style.setProperty("position", group.position.value, group.position.priority);
+      else root.style.removeProperty("position");
+    }
+    this.groups.delete(root);
+  }
+  dispose() {
+    this.disposed = true;
+    this.resize?.disconnect();
+    this.intersection?.disconnect();
+    this.fonts?.removeEventListener("loadingdone", this.schedule);
+    if (this.frame) cancelAnimationFrame(this.frame);
+    this.frame = 0;
+    for (const [root, group] of this.groups) this.remove(root, group);
+  }
+};
+
+// src/highlights.ts
+var NAME = "dsh-local-annotation";
+var api = CSS;
+var HighlightClass = globalThis.Highlight;
+var Highlights = class {
+  supported = !!api.highlights && !!HighlightClass;
+  highlight = HighlightClass ? new HighlightClass() : null;
+  groups = /* @__PURE__ */ new Map();
+  anchors = new Anchors();
+  dirty = /* @__PURE__ */ new Set();
+  timer;
+  sessionId = "";
+  markers;
+  numbers = /* @__PURE__ */ new Map();
+  observer = new MutationObserver((records) => {
+    let addedSource = false;
+    for (const record of records) {
+      const target = record.target instanceof Element ? record.target : record.target.parentElement;
+      if (target?.closest("[data-local-annotation-markers],[data-local-annotation-status]")) continue;
+      const changed = [...record.addedNodes, ...record.removedNodes];
+      if (record.type === "childList" && changed.length && changed.every((node) => node instanceof Element && node.matches("[data-local-annotation-markers]"))) continue;
+      for (const group of this.groups.values()) {
+        if (group.root && (!group.root.isConnected || group.root.contains(record.target) || record.type === "attributes" && record.target instanceof Element && record.target.contains(group.root))) this.dirty.add(group);
+      }
+      if (record.type === "attributes") addedSource = true;
+      if (!addedSource) for (const node of record.addedNodes) {
+        if (node instanceof Element && (node.matches(`${MESSAGE},[data-textpreview-url],${FILE_TEXT}`) || node.querySelector(`${MESSAGE},[data-textpreview-url],${FILE_TEXT}`))) {
+          addedSource = true;
+          break;
+        }
+      }
+    }
+    if (addedSource) {
+      for (const group of this.groups.values()) if (!group.root?.isConnected) this.dirty.add(group);
+    }
+    if (this.dirty.size && this.timer === void 0) this.timer = setTimeout(() => this.flush(), 100);
+  });
+  constructor(open) {
+    this.markers = new Markers(open);
+    if (this.highlight) api.highlights?.set(NAME, this.highlight);
+  }
+  update(sessionId, items) {
+    this.reset();
+    this.sessionId = sessionId;
+    items.forEach((item, index) => this.numbers.set(item.id, index + 1));
+    for (const item of items) {
+      const key = sourceKey(item.source);
+      let group = this.groups.get(key);
+      if (!group) {
+        group = { source: item.source, items: [], root: null, ranges: /* @__PURE__ */ new Map() };
+        this.groups.set(key, group);
+      }
+      group.items.push(item);
+      this.dirty.add(group);
+    }
+    this.flush();
+    if (this.groups.size) this.observer.observe(document.getElementById("root") ?? document.body, {
+      subtree: true,
+      childList: true,
+      characterData: true,
+      attributes: true,
+      attributeFilter: ["hidden", "aria-hidden", "data-turn-process-hidden", "data-textpreview-state", "data-textpreview-url"]
+    });
+  }
+  flush() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    for (const group of this.dirty) {
+      for (const range of group.ranges.values()) this.highlight?.delete(range);
+      group.ranges.clear();
+      if (group.root) this.anchors.invalidate(group.root);
+      group.root = findRoot(group.source, this.sessionId);
+      if (!group.root) continue;
+      for (const item of group.items) {
+        const range = this.anchors.resolve(item, group.root);
+        if (range) {
+          group.ranges.set(item.id, range);
+          this.highlight?.add(range);
+        }
+      }
+    }
+    this.dirty.clear();
+    const entries = [];
+    for (const group of this.groups.values()) {
+      if (!group.root) continue;
+      for (const item of group.items) {
+        const range = group.ranges.get(item.id);
+        if (range) entries.push({ item, range, root: group.root, number: this.numbers.get(item.id) ?? 1 });
+      }
+    }
+    this.markers.update(entries);
+  }
+  range(item) {
+    const root = findRoot(item.source, item.sessionId);
+    if (!root) return null;
+    this.anchors.invalidate(root);
+    return this.anchors.resolve(item, root);
+  }
+  // Hit testing only on a click inside one source, never on pointermove/scroll.
+  hit(target, x, y) {
+    const source = sourceOf(target, this.sessionId);
+    if (!source) return null;
+    const group = this.groups.get(sourceKey(source.source));
+    if (!group) return null;
+    if (this.dirty.has(group)) this.flush();
+    for (const item of group.items) {
+      const range = group.ranges.get(item.id);
+      if (!range?.startContainer.isConnected) continue;
+      for (const rect of range.getClientRects()) {
+        if (x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom) return item;
+      }
+    }
+    return null;
+  }
+  locate(item) {
+    const root = findRoot(item.source, item.sessionId);
+    if (!root) return false;
+    this.anchors.invalidate(root);
+    const range = this.anchors.resolve(item, root);
+    if (!range) return false;
+    const element = range.startContainer.parentElement;
+    element?.scrollIntoView({ block: "center", behavior: "instant" });
+    if (!this.supported) {
+      const selection = window.getSelection();
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+    }
+    return true;
+  }
+  reset() {
+    this.observer.disconnect();
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    this.markers.update([]);
+    this.numbers.clear();
+    this.groups.clear();
+    this.dirty.clear();
+    this.anchors.clear();
+    this.highlight?.clear();
+  }
+  dispose() {
+    this.reset();
+    this.markers.dispose();
+    if (api.highlights?.get(NAME) === this.highlight) api.highlights.delete(NAME);
+  }
+};
+
+// src/selection.ts
+function installSelection(current, onSelect, onError) {
+  const events = new AbortController();
+  const button = document.createElement("button");
+  button.type = "button";
+  button.textContent = "批注";
+  button.title = "批注所选文字";
+  const toolbar = document.createElement("div");
+  toolbar.dataset.localAnnotationToolbar = "";
+  toolbar.hidden = true;
+  toolbar.append(button);
+  document.body.append(toolbar);
+  let pointerDown = false;
+  let composing = false;
+  let frame = 0;
+  let timer;
+  let range = null;
+  let sessionId;
+  let scrollEvents = null;
+  const hide = () => {
+    toolbar.hidden = true;
+    range = null;
+    sessionId = void 0;
+    scrollEvents?.abort();
+    scrollEvents = null;
+    clearTimeout(timer);
+    cancelAnimationFrame(frame);
+    frame = 0;
+  };
+  const show = () => {
+    frame = 0;
+    if (pointerDown || composing) return;
+    const selection = window.getSelection();
+    const id = current();
+    if (!id || !selection?.rangeCount || selection.isCollapsed) {
+      hide();
+      return;
+    }
+    const selected = selection.getRangeAt(0);
+    const start = sourceOf(selected.startContainer, id);
+    const end = sourceOf(selected.endContainer, id);
+    if (!start || !end || start.root !== end.root) {
+      hide();
+      return;
+    }
+    hide();
+    const caret = document.createRange();
+    if (!selection.focusNode) return;
+    caret.setStart(selection.focusNode, selection.focusOffset);
+    caret.collapse(true);
+    const rect = caret.getBoundingClientRect();
+    if (!rect.height || rect.bottom < 40 || rect.top > window.innerHeight) return;
+    range = selected.cloneRange();
+    sessionId = id;
+    toolbar.style.left = `${Math.max(8, Math.min(window.innerWidth - 80, rect.right + 8))}px`;
+    toolbar.style.top = `${Math.max(48, Math.min(window.innerHeight - 44, rect.bottom + 6))}px`;
+    toolbar.hidden = false;
+    scrollEvents = new AbortController();
+    document.addEventListener("scroll", hide, { capture: true, passive: true, signal: scrollEvents.signal });
+    window.addEventListener("resize", hide, { passive: true, signal: scrollEvents.signal });
+  };
+  const schedule = () => {
+    cancelAnimationFrame(frame);
+    frame = requestAnimationFrame(show);
+  };
+  const signal = events.signal;
+  document.addEventListener("pointerdown", (event) => {
+    if (toolbar.contains(event.target)) return;
+    pointerDown = true;
+    hide();
+  }, { capture: true, signal });
+  document.addEventListener("pointerup", () => {
+    pointerDown = false;
+    schedule();
+  }, { signal });
+  document.addEventListener("pointercancel", () => {
+    pointerDown = false;
+    hide();
+  }, { signal });
+  document.addEventListener("selectionchange", () => {
+    if (pointerDown || composing || toolbar.contains(document.activeElement)) return;
+    hide();
+    timer = setTimeout(schedule, 120);
+  }, { signal });
+  document.addEventListener("compositionstart", () => {
+    composing = true;
+    hide();
+  }, { signal });
+  document.addEventListener("compositionend", () => {
+    composing = false;
+  }, { signal });
+  document.addEventListener("keydown", (event) => {
+    if (event.key === "Escape") hide();
+  }, { signal });
+  window.addEventListener("blur", () => {
+    pointerDown = false;
+    hide();
+  }, { signal });
+  toolbar.addEventListener("pointerdown", (event) => event.preventDefault(), { signal });
+  button.addEventListener("click", () => {
+    if (!range || !sessionId || current() !== sessionId || !range.startContainer.isConnected) {
+      hide();
+      return;
+    }
+    try {
+      const selected = range.cloneRange();
+      const item = capture(selected, sessionId);
+      hide();
+      if (item) {
+        window.getSelection()?.removeAllRanges();
+        onSelect(item, selected);
+      }
+    } catch (error) {
+      hide();
+      onError(error);
+    }
+  }, { signal });
+  return { hide, dispose() {
+    hide();
+    events.abort();
+    toolbar.remove();
+  } };
+}
+
+// src/storage.ts
+var DATABASE = "dsh-local-annotation-v1";
+var ITEMS = "annotations";
+var IMPORTS = "legacy-imports";
+var LEGACY_PREFIX = "dsh.annotation.pending.v1.";
+var MAX_LEGACY_CHARS = 16 * 1024 * 1024;
+var OPEN_TIMEOUT = 1e4;
+function failure(error, fallback) {
+  if (error instanceof Error) return error;
+  return new Error(fallback, { cause: error });
+}
+function expectedVersion(value) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) throw new TypeError("预期版本必须是非负安全整数");
+}
+function conflict() {
+  return new Error("批注已在其他窗口修改或删除，请刷新后重试");
+}
+function nextVersion(previous) {
+  const next = Math.max(Date.now(), previous === void 0 ? 0 : previous + 1);
+  if (!Number.isSafeInteger(next)) throw new Error("批注版本已超出安全范围");
+  return next;
+}
+function legacyItems(raw, sessionId) {
+  if (raw.length > MAX_LEGACY_CHARS) throw new Error("旧批注数据过大，未导入任何内容");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed) || parsed.length > MAX_ITEMS) throw new Error(`旧批注必须是至多 ${MAX_ITEMS} 项的数组`);
+  const seen = /* @__PURE__ */ new Set();
+  const now = nextVersion();
+  return parsed.map((value, index) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`旧批注第 ${index + 1} 项格式无效`);
+    const item = value;
+    const originalId = annotationKey(item.id, "旧批注 ID");
+    const id = annotationKey(`legacy-${originalId}`, "导入批注 ID");
+    if (seen.has(id)) throw new Error(`旧批注存在重复 ID：${originalId}`);
+    seen.add(id);
+    const text = boundedString(item.text, "旧批注原文", MAX_TEXT, true);
+    let source;
+    if (typeof item.sourceUrl === "string" && typeof item.sourcePath === "string") {
+      try {
+        source = annotationSource({ kind: "file", url: item.sourceUrl, path: item.sourcePath }, sessionId);
+      } catch {
+      }
+    }
+    if (!source && typeof item.seqKey === "string" && item.seqKey.trim()) source = annotationSource({ kind: "message", key: item.seqKey }, sessionId);
+    if (!source) throw new Error(`旧批注第 ${index + 1} 项没有属于当前会话的明确来源，整批导入已取消`);
+    const start = item.textOffset === void 0 ? -1 : item.textOffset;
+    if (typeof start !== "number" || !Number.isSafeInteger(start) || start < -1) throw new TypeError(`旧批注第 ${index + 1} 项位置无效`);
+    return copyAnnotation({
+      id,
+      sessionId,
+      text,
+      note: item.note ?? "",
+      source,
+      start,
+      end: start === -1 ? -1 : start + text.length,
+      before: item.ctxBefore ?? "",
+      after: item.ctxAfter ?? "",
+      createdAt: now,
+      updatedAt: now
+    });
+  });
+}
+var AnnotationStore = class {
+  listeners = /* @__PURE__ */ new Set();
+  connections = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Set();
+  environment;
+  channel;
+  disposed = false;
+  constructor(environment = globalThis) {
+    this.environment = environment;
+    try {
+      if (environment.BroadcastChannel) {
+        this.channel = new environment.BroadcastChannel(DATABASE);
+        this.channel.onmessage = (event) => {
+          const data = event.data;
+          if (!data || typeof data !== "object" || !("sessionId" in data)) return;
+          try {
+            this.notify(annotationKey(data.sessionId, "会话 ID"));
+          } catch {
+          }
+        };
+      }
+    } catch {
+    }
+  }
+  ensureActive() {
+    if (this.disposed) throw new Error("批注存储已关闭");
+  }
+  open() {
+    this.ensureActive();
+    return new Promise((resolve, reject) => {
+      let factory;
+      try {
+        factory = this.environment.indexedDB;
+      } catch (error) {
+        reject(failure(error, "无法访问 IndexedDB"));
+        return;
+      }
+      if (!factory) {
+        reject(new Error("当前环境不支持 IndexedDB，批注未保存"));
+        return;
+      }
+      let request;
+      try {
+        request = factory.open(DATABASE, 1);
+      } catch (error) {
+        reject(failure(error, "无法打开批注存储"));
+        return;
+      }
+      let settled = false;
+      const stop = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this.pending.delete(cancel);
+        reject(error);
+      };
+      const cancel = () => stop(new Error("批注存储已关闭"));
+      const timer = setTimeout(() => stop(new Error("打开批注存储超时，请关闭占用数据库的旧窗口后重试")), OPEN_TIMEOUT);
+      this.pending.add(cancel);
+      request.onblocked = () => stop(new Error("批注数据库升级被其他窗口阻塞，请关闭旧窗口后重试"));
+      request.onerror = () => stop(failure(request.error, "打开批注数据库失败"));
+      request.onupgradeneeded = () => {
+        if (settled || this.disposed) {
+          request.transaction?.abort();
+          return;
+        }
+        try {
+          const db = request.result;
+          const items = db.createObjectStore(ITEMS, { keyPath: ["sessionId", "id"] });
+          items.createIndex("sessionId", "sessionId");
+          db.createObjectStore(IMPORTS, { keyPath: "sessionId" });
+        } catch (error) {
+          request.transaction?.abort();
+          stop(failure(error, "初始化批注数据库失败"));
+        }
+      };
+      request.onsuccess = () => {
+        const db = request.result;
+        if (settled || this.disposed) {
+          db.close();
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        this.pending.delete(cancel);
+        this.connections.add(db);
+        db.onversionchange = () => {
+          db.close();
+          this.connections.delete(db);
+        };
+        resolve(db);
+      };
+    });
+  }
+  async transaction(mode, action) {
+    const db = await this.open();
+    try {
+      this.ensureActive();
+      return await new Promise((resolve, reject) => {
+        const tx = db.transaction([ITEMS, IMPORTS], mode);
+        let result;
+        let ready = false;
+        let error;
+        const abort = (cause) => {
+          error ??= failure(cause, "批注事务失败");
+          try {
+            tx.abort();
+          } catch {
+            reject(error);
+          }
+        };
+        tx.oncomplete = () => {
+          if (ready) resolve(result);
+          else reject(new Error("批注事务未产生结果"));
+        };
+        tx.onabort = () => reject(error ?? failure(tx.error, "批注事务已中止，数据未保存"));
+        tx.onerror = () => {
+          error ??= failure(tx.error, "批注读写失败，可能是存储空间不足");
+        };
+        try {
+          action(tx.objectStore(ITEMS), tx.objectStore(IMPORTS), (value) => {
+            result = value;
+            ready = true;
+          }, abort);
+        } catch (cause) {
+          abort(cause);
+        }
+      });
+    } finally {
+      db.close();
+      this.connections.delete(db);
+    }
+  }
+  async list(sessionId) {
+    annotationKey(sessionId, "会话 ID");
+    return this.transaction("readonly", (items, _imports, finish, abort) => {
+      const request = items.index("sessionId").getAll(sessionId, MAX_ITEMS + 1);
+      request.onsuccess = () => {
+        try {
+          if (request.result.length > MAX_ITEMS) throw new Error("批注数量超限，未截断数据");
+          const rows = request.result.map(copyAnnotation);
+          finish(rows.sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id)));
+        } catch (error) {
+          abort(error);
+        }
+      };
+    });
+  }
+  async put(item, expectedUpdatedAt) {
+    const value = copyAnnotation(item);
+    expectedVersion(expectedUpdatedAt);
+    await this.transaction("readwrite", (items, _imports, finish, abort) => {
+      const request = items.get([value.sessionId, value.id]);
+      request.onsuccess = () => {
+        try {
+          const old = request.result === void 0 ? void 0 : copyAnnotation(request.result);
+          if (expectedUpdatedAt === void 0 ? old !== void 0 : old === void 0 || old.updatedAt !== expectedUpdatedAt) throw conflict();
+          const save = () => {
+            value.updatedAt = nextVersion(old?.updatedAt);
+            value.createdAt = old?.createdAt ?? value.updatedAt;
+            items.put(value);
+            finish(void 0);
+          };
+          if (old) {
+            save();
+            return;
+          }
+          const count = items.index("sessionId").count(value.sessionId);
+          count.onsuccess = () => {
+            try {
+              if (count.result >= MAX_ITEMS) throw new Error(`每个会话最多保存 ${MAX_ITEMS} 条批注`);
+              save();
+            } catch (error) {
+              abort(error);
+            }
+          };
+        } catch (error) {
+          abort(error);
+        }
+      };
+    });
+    this.changed(value.sessionId);
+    return value;
+  }
+  async remove(sessionId, id, expectedUpdatedAt) {
+    annotationKey(sessionId, "会话 ID");
+    annotationKey(id, "批注 ID");
+    expectedVersion(expectedUpdatedAt);
+    const changed = await this.transaction("readwrite", (items, _imports, finish, abort) => {
+      const request = items.get([sessionId, id]);
+      request.onsuccess = () => {
+        try {
+          const old = request.result === void 0 ? void 0 : copyAnnotation(request.result);
+          if (expectedUpdatedAt !== void 0 && (!old || old.updatedAt !== expectedUpdatedAt)) throw conflict();
+          if (old) items.delete([sessionId, id]);
+          finish(old !== void 0);
+        } catch (error) {
+          abort(error);
+        }
+      };
+    });
+    if (changed) this.changed(sessionId);
+  }
+  async importLegacy(sessionId) {
+    this.ensureActive();
+    annotationKey(sessionId, "会话 ID");
+    const storage = this.environment.localStorage;
+    if (!storage) throw new Error("当前环境无法读取旧批注存储");
+    const raw = storage.getItem(LEGACY_PREFIX + encodeURIComponent(sessionId));
+    if (raw === null || raw === "") return 0;
+    const candidates = legacyItems(raw, sessionId);
+    if (!candidates.length) return 0;
+    const imported = await this.transaction("readwrite", (items, imports, finish, abort) => {
+      const metadata = imports.get(sessionId);
+      metadata.onsuccess = () => {
+        try {
+          const record = metadata.result;
+          let remembered = [];
+          if (record !== void 0) {
+            if (!record || typeof record !== "object" || !("ids" in record) || !Array.isArray(record.ids) || record.ids.length > MAX_ITEMS) throw new Error("旧批注导入记录损坏");
+            remembered = record.ids.map((id) => annotationKey(id, "导入批注 ID"));
+          }
+          const done = new Set(remembered);
+          const fresh = candidates.filter((item) => !done.has(item.id));
+          if (!fresh.length) {
+            finish(0);
+            return;
+          }
+          if (done.size + fresh.length > MAX_ITEMS) throw new Error(`旧批注累计导入数量不能超过 ${MAX_ITEMS}`);
+          const count = items.index("sessionId").count(sessionId);
+          count.onsuccess = () => {
+            let total = count.result;
+            let added = 0;
+            let cursor = 0;
+            const next = () => {
+              try {
+                const item = fresh[cursor++];
+                if (!item) {
+                  imports.put({ sessionId, ids: [...done] });
+                  finish(added);
+                  return;
+                }
+                const request = items.get([sessionId, item.id]);
+                request.onsuccess = () => {
+                  try {
+                    if (request.result === void 0) {
+                      if (total >= MAX_ITEMS) throw new Error(`导入后批注超过 ${MAX_ITEMS} 条，整批导入已取消`);
+                      items.add(item);
+                      total++;
+                      added++;
+                    }
+                    done.add(item.id);
+                    next();
+                  } catch (error) {
+                    abort(error);
+                  }
+                };
+              } catch (error) {
+                abort(error);
+              }
+            };
+            next();
+          };
+        } catch (error) {
+          abort(error);
+        }
+      };
+    });
+    if (imported) this.changed(sessionId);
+    return imported;
+  }
+  subscribe(listener) {
+    this.ensureActive();
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify(sessionId) {
+    if (this.disposed) return;
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(sessionId);
+      } catch (error) {
+        console.error("批注存储订阅回调失败", error);
+      }
+    }
+  }
+  changed(sessionId) {
+    if (this.disposed) return;
+    this.notify(sessionId);
+    try {
+      this.channel?.postMessage({ sessionId });
+    } catch {
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const cancel of [...this.pending]) cancel();
+    for (const db of this.connections) db.close();
+    this.connections.clear();
+    this.listeners.clear();
+    this.channel?.close();
+    this.channel = void 0;
+  }
+};
+
+// src/floating.ts
+function floatingCard(host, close) {
+  let anchor = null;
+  let frame = 0;
+  let events = null;
+  const position = () => {
+    frame = 0;
+    if (!anchor || host.hidden) return;
+    let { x, y } = anchor;
+    if (anchor.range) {
+      if (!anchor.range.endContainer.isConnected) {
+        close();
+        return;
+      }
+      const caret = anchor.range.cloneRange();
+      caret.collapse(false);
+      let rect = caret.getBoundingClientRect();
+      if (!rect.height || rect.bottom < 48 || rect.top > window.innerHeight) {
+        caret.setStart(anchor.range.startContainer, anchor.range.startOffset);
+        caret.collapse(true);
+        rect = caret.getBoundingClientRect();
+      }
+      if (!rect.height || rect.bottom < 48 || rect.top > window.innerHeight) {
+        close();
+        return;
+      }
+      x = rect.right;
+      y = rect.bottom;
+    }
+    const width = host.offsetWidth;
+    const height = host.offsetHeight;
+    const left = Math.max(8, Math.min(window.innerWidth - width - 8, x + 8));
+    const below = y + 8;
+    const top = Math.max(48, Math.min(
+      window.innerHeight - height - 8,
+      below + height <= window.innerHeight - 8 ? below : y - height - 24
+    ));
+    host.style.transform = `translate(${Math.round(left)}px, ${Math.round(top)}px)`;
+  };
+  const schedule = () => {
+    if (!frame) frame = requestAnimationFrame(position);
+  };
+  const observer = new ResizeObserver(schedule);
+  const hide = () => {
+    host.hidden = true;
+    anchor = null;
+    events?.abort();
+    events = null;
+    observer.disconnect();
+    cancelAnimationFrame(frame);
+    frame = 0;
+  };
+  return {
+    show(next) {
+      anchor = next;
+      host.hidden = false;
+      if (!events) {
+        events = new AbortController();
+        const signal = events.signal;
+        document.addEventListener("scroll", (event) => {
+          if (event.target instanceof Node && host.contains(event.target)) return;
+          schedule();
+        }, { capture: true, passive: true, signal });
+        window.addEventListener("resize", schedule, { passive: true, signal });
+        document.addEventListener("pointerdown", (event) => {
+          const target = event.target;
+          if (target instanceof Element && !host.contains(target) && !target.closest("[data-local-annotation-toolbar]")) close();
+        }, { capture: true, signal });
+        document.addEventListener("keydown", (event) => {
+          if (event.key === "Escape" && !event.isComposing && event.keyCode !== 229) {
+            event.preventDefault();
+            close();
+          }
+        }, { signal });
+        observer.observe(host);
+      }
+      schedule();
+    },
+    hide,
+    dispose: hide
+  };
+}
+
+// src/controller.ts
+var Controller = class {
+  constructor(ctx, host) {
+    this.ctx = ctx;
+    this.floating = floatingCard(host, () => this.close());
+    this.selection = installSelection(() => this.state.sessionId, (item, range) => {
+      this.anchor = { range, x: 24, y: 64 };
+      if (this.state.loading) return;
+      if (this.state.pending) {
+        this.showItem(this.state.pending);
+        return;
+      }
+      if (this.state.items.length >= MAX_ITEMS) {
+        this.error(new Error(`每个会话最多 ${MAX_ITEMS} 条批注。`));
+        this.showError();
+        return;
+      }
+      if (this.pendingBySession.size >= 8 && !this.pendingBySession.has(item.sessionId)) {
+        this.error(new Error("已有 8 个会话保留未保存批注，请先保存或取消其中一条。"));
+        this.showError();
+        return;
+      }
+      this.pendingBySession.set(item.sessionId, item);
+      this.patch({ pending: item, error: "", card: { item, editing: true } });
+      this.paint();
+      this.floating.show(this.anchor);
+    }, (error) => {
+      this.error(error);
+      this.showError();
+    });
+    const click = (event) => {
+      if (event.button !== 0 || event.metaKey || event.ctrlKey || event.altKey || event.shiftKey || !(event.target instanceof Element) || event.target.closest('a,button,input,textarea,[contenteditable="true"],[data-local-annotation-card]')) return;
+      if (!window.getSelection()?.isCollapsed) return;
+      const item = this.highlights.hit(event.target, event.clientX, event.clientY);
+      if (!item) return;
+      this.anchor = { range: this.highlights.range(item), x: event.clientX, y: event.clientY };
+      this.showItem(item);
+    };
+    document.addEventListener("click", click);
+    this.disposers.push(() => document.removeEventListener("click", click));
+    const sync = () => {
+      const id = this.ctx.uiSession.adapter.current.getSnapshot().key;
+      if (id === this.state.sessionId) return;
+      ++this.generation;
+      this.selection.hide();
+      this.close();
+      this.patch({ sessionId: id, items: [], pending: id ? this.pendingBySession.get(id) ?? null : null, error: "", loading: !!id });
+      this.paint();
+      if (id) void this.refresh(id);
+    };
+    this.disposers.push(ctx.uiSession.adapter.current.subscribe(sync));
+    this.disposers.push(this.store.subscribe((id) => {
+      if (id === this.state.sessionId) void this.refresh(id);
+    }));
+    const onFocus = () => {
+      if (this.state.sessionId) void this.refresh(this.state.sessionId);
+    };
+    window.addEventListener("focus", onFocus);
+    this.disposers.push(() => window.removeEventListener("focus", onFocus));
+    sync();
+  }
+  ctx;
+  store = new AnnotationStore();
+  highlights = new Highlights((item) => this.showItem(item));
+  listeners = /* @__PURE__ */ new Set();
+  appearance = new AppearanceStore((appearance) => this.patch({ appearance }));
+  state = {
+    sessionId: void 0,
+    items: [],
+    pending: null,
+    error: "",
+    loading: false,
+    highlightSupported: this.highlights.supported,
+    appearance: this.appearance.getSnapshot(),
+    card: null
+  };
+  pendingBySession = /* @__PURE__ */ new Map();
+  generation = 0;
+  disposed = false;
+  disposers = [];
+  selection;
+  floating;
+  anchor = { range: null, x: 24, y: 64 };
+  drafts = /* @__PURE__ */ new Map();
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getSnapshot = () => this.state;
+  setAppearance(field, value) {
+    this.appearance.set(field, value);
+  }
+  patch(patch) {
+    if (this.disposed) return;
+    this.state = { ...this.state, ...patch };
+    for (const listener of this.listeners) listener();
+  }
+  error(error) {
+    this.patch({ error: error instanceof Error ? error.message : String(error) });
+  }
+  paint() {
+    this.highlights.update(this.state.sessionId ?? "", this.state.pending ? [...this.state.items, this.state.pending] : this.state.items);
+  }
+  async refresh(id) {
+    const generation = ++this.generation;
+    try {
+      const items = await this.store.list(id);
+      if (this.disposed || generation !== this.generation || id !== this.state.sessionId) return;
+      this.patch({ items, loading: false });
+      this.paint();
+    } catch (error) {
+      if (!this.disposed && generation === this.generation && id === this.state.sessionId) {
+        this.patch({ loading: false });
+        this.error(error);
+      }
+    }
+  }
+  close() {
+    const pending = this.state.pending;
+    if (pending && !this.draft(pending).trim()) {
+      this.pendingBySession.delete(pending.sessionId);
+      this.drafts.delete(this.draftKey(pending));
+      this.patch({ pending: null });
+      this.paint();
+    }
+    this.floating.hide();
+    this.patch({ card: null });
+  }
+  showError() {
+    if (!this.state.sessionId) return;
+    this.patch({ card: { item: null, editing: false } });
+    if (!this.anchor.range?.endContainer.isConnected) this.anchor = { range: null, x: Math.min(window.innerWidth / 2, 480), y: 80 };
+    this.floating.show(this.anchor);
+  }
+  showItem(item) {
+    if (item.sessionId !== this.state.sessionId) return;
+    const base = this.drafts.get(this.draftKey(item))?.item ?? item;
+    this.patch({ card: { item: base, editing: true }, error: "" });
+    this.anchor = { ...this.anchor, range: this.highlights.range(item) };
+    this.floating.show(this.anchor);
+  }
+  draftKey(item) {
+    return JSON.stringify([item.sessionId, item.id]);
+  }
+  draft(item) {
+    return this.drafts.get(this.draftKey(item))?.note ?? item.note;
+  }
+  setDraft(item, note) {
+    const key = this.draftKey(item);
+    if (!this.drafts.has(key) && this.drafts.size >= 32) this.drafts.delete(this.drafts.keys().next().value);
+    this.drafts.set(key, { item, note: note.slice(0, MAX_NOTE) });
+  }
+  async save(item, note) {
+    if (item.sessionId !== this.state.sessionId || this.disposed) return;
+    const id = item.sessionId;
+    try {
+      if (note.length > MAX_NOTE) throw new Error(`批注最多 ${MAX_NOTE} 个字符。`);
+      const pending = this.state.pending?.id === item.id;
+      const saved = await this.store.put({ ...item, note }, pending ? void 0 : item.updatedAt);
+      this.drafts.delete(this.draftKey(item));
+      if (this.pendingBySession.get(id)?.id === item.id) this.pendingBySession.delete(id);
+      if (this.disposed || id !== this.state.sessionId) return;
+      if (this.state.pending?.id === item.id) this.patch({ pending: null });
+      const items = this.state.items.filter((value) => value.id !== saved.id);
+      items.push(saved);
+      items.sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id));
+      this.patch({ items, error: "" });
+      if (this.state.card?.item?.id === item.id) this.close();
+      this.paint();
+      await this.refresh(id);
+    } catch (error) {
+      if (id === this.state.sessionId) this.error(error);
+      throw error;
+    }
+  }
+  cancelPending() {
+    if (this.state.sessionId) this.pendingBySession.delete(this.state.sessionId);
+    if (this.state.pending) this.drafts.delete(this.draftKey(this.state.pending));
+    this.close();
+    this.patch({ pending: null, error: "" });
+    this.paint();
+  }
+  async remove(item) {
+    if (item.sessionId !== this.state.sessionId || this.disposed) return;
+    try {
+      await this.store.remove(item.sessionId, item.id, item.updatedAt);
+      this.drafts.delete(this.draftKey(item));
+      if (this.state.card?.item?.id === item.id) this.close();
+      if (item.sessionId === this.state.sessionId) {
+        this.patch({ error: "" });
+        await this.refresh(item.sessionId);
+      }
+    } catch (error) {
+      if (item.sessionId === this.state.sessionId) this.error(error);
+      throw error;
+    }
+  }
+  insert(items) {
+    try {
+      const binding = this.ctx.uiSession.adapter.current.getSnapshot();
+      if (!items.length || !binding.key || binding.key !== this.state.sessionId || items.some((item) => item.sessionId !== binding.key)) return false;
+      const actions = binding.props.inputActions;
+      if (!actions) throw new Error("输入框尚未就绪，请稍后重试。");
+      const span = actions.captureInsertion();
+      const text = "\n\n" + items.map((item, index) => {
+        const source = item.source.kind === "file" ? `文件：${item.source.path}
+` : "";
+        return `批注 ${index + 1}
+${source}${item.text.split("\n").map((line) => `> ${line}`).join("\n")}` + (item.note.trim() ? `
+批注：${item.note}` : "");
+      }).join("\n\n") + "\n\n";
+      if (text.length > 256e3) throw new Error("引用总量过大，请分批插入。");
+      if (this.ctx.uiSession.adapter.current.getSnapshot().key !== binding.key || !actions.insertText(text, span)) {
+        throw new Error("输入框正在更新，未插入批注；请稍后重试。");
+      }
+      this.patch({ error: "" });
+      return true;
+    } catch (error) {
+      this.error(error);
+      return false;
+    }
+  }
+  dispose() {
+    this.disposed = true;
+    ++this.generation;
+    this.selection.dispose();
+    this.floating.dispose();
+    this.drafts.clear();
+    for (const dispose of this.disposers) dispose();
+    this.highlights.dispose();
+    this.appearance.dispose();
+    this.store.dispose();
+    this.pendingBySession.clear();
+    this.listeners.clear();
+  }
+};
+
+// src/view.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+function Trash() {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.7", "aria-hidden": "true", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M3 6h18M9 6V3h6v3M5 6l1 15h12l1-15M10 10v7M14 10v7" }) });
+}
+function Close() {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.7", "aria-hidden": "true", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "m6 6 12 12M18 6 6 18" }) });
+}
+function brief(text, length) {
+  return text.length > length ? text.slice(0, length) + "…" : text;
+}
+function Card({ controller }) {
+  const state = (0, import_react.useSyncExternalStore)(controller.subscribe, controller.getSnapshot);
+  if (!state.card) return null;
+  if (!state.card.item) return state.error ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { "data-local-annotation-panel": "", role: "alert", children: [
+    state.error,
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "dla-icon", "aria-label": "关闭", onClick: () => controller.close(), children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Close, {}) })
+  ] }) : null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Editor, { controller, item: state.card.item }, JSON.stringify([state.sessionId, state.card.item.id]));
+}
+function Editor({ controller, item }) {
+  const state = (0, import_react.useSyncExternalStore)(controller.subscribe, controller.getSnapshot);
+  const [base] = (0, import_react.useState)(item);
+  const [note, setNote] = (0, import_react.useState)(() => controller.draft(item));
+  const [busy, setBusy] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)("");
+  const textarea = (0, import_react.useRef)(null);
+  const composing = (0, import_react.useRef)(false);
+  const inFlight = (0, import_react.useRef)(false);
+  const newItem = state.pending?.id === item.id;
+  const quote = (item.source.kind === "file" ? `${item.source.path}
+` : "") + item.text;
+  (0, import_react.useEffect)(() => {
+    textarea.current?.focus({ preventScroll: true });
+    textarea.current?.setSelectionRange(note.length, note.length);
+  }, []);
+  async function run(action) {
+    if (inFlight.current) return;
+    inFlight.current = true;
+    setBusy(true);
+    setError("");
+    try {
+      await action();
+    } catch (cause) {
+      setError(cause instanceof Error ? cause.message : "操作失败，请重试。");
+    } finally {
+      inFlight.current = false;
+      setBusy(false);
+    }
+  }
+  function keyDown(event) {
+    if (composing.current || event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229) return;
+    if (event.key === "Enter" && !event.shiftKey) {
+      event.preventDefault();
+      event.stopPropagation();
+      void run(() => controller.save(base, note));
+    } else if (event.key === "Escape") {
+      event.preventDefault();
+      event.stopPropagation();
+      controller.close();
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", { "data-local-annotation-panel": "", role: "dialog", "aria-label": newItem ? "添加批注" : "编辑批注", "aria-modal": false, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("header", { className: "dla-head", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: newItem ? "添加批注" : "编辑批注" }),
+      !newItem ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "dla-icon dla-danger", title: "删除批注", "aria-label": "删除批注", disabled: busy, onClick: () => {
+        void run(() => controller.remove(base));
+      }, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Trash, {}) }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "dla-icon dla-close", title: "关闭", "aria-label": "关闭批注", onClick: () => controller.close(), children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Close, {}) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("blockquote", { className: "dla-quote", title: quote, children: brief(quote, 200) }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "textarea",
+      {
+        ref: textarea,
+        "aria-label": "批注内容",
+        placeholder: "写下批注（可留空，仅标记原文）",
+        value: note,
+        maxLength: MAX_NOTE,
+        rows: 3,
+        disabled: busy,
+        spellCheck: false,
+        onChange: (event) => {
+          setNote(event.target.value);
+          controller.setDraft(base, event.target.value);
+        },
+        onKeyDown: keyDown,
+        onCompositionStart: () => {
+          composing.current = true;
+        },
+        onCompositionEnd: () => {
+          composing.current = false;
+        }
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("footer", { className: "dla-footer", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AppearancePicker, { controller, disabled: busy }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "dla-save", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("button", { type: "button", disabled: busy || state.loading, onClick: () => {
+        void run(() => controller.save(base, note));
+      }, children: [
+        "✓ ",
+        busy ? "保存中…" : "保存"
+      ] }) })
+    ] }),
+    error || state.error ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "dla-error", role: "alert", children: error || state.error }) : null
+  ] });
+}
+function AppearancePicker({ controller, disabled }) {
+  const { appearance } = (0, import_react.useSyncExternalStore)(controller.subscribe, controller.getSnapshot);
+  const [error, setError] = (0, import_react.useState)("");
+  function change(field, value) {
+    try {
+      controller.setAppearance(field, value);
+      setError("");
+    } catch (cause) {
+      setError(cause instanceof Error ? cause.message : "外观设置未保存。");
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("details", { className: "dla-appearance", style: { "--dla-ink": ink(appearance.color) }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("summary", { children: "批注外观" }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("fieldset", { disabled, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("legend", { children: "划线" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "dla-options", children: STROKES.map((option) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", "aria-pressed": appearance.stroke === option.id, onClick: () => change("stroke", option.id), children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dla-stroke-sample", "data-stroke": option.id, children: option.label }) }, option.id)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("fieldset", { disabled, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("legend", { children: "颜色" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dla-options", children: [
+        COLORS.map((option) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "dla-swatch", title: option.label, "aria-label": option.label, "aria-pressed": appearance.color.toLowerCase() === option.value, style: { "--dla-swatch": ink(option.value) }, onClick: () => change("color", option.value) }, option.value)),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { className: "dla-custom-color", title: "自定义荧光色", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", { type: "color", "aria-label": "自定义荧光色", value: appearance.color === "theme" ? COLORS[1].value : appearance.color, onChange: (event) => change("color", event.target.value) }),
+          "自选"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("fieldset", { disabled, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("legend", { children: "旁注图标" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "dla-options", children: ICONS.map((option) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", title: option.label, "aria-label": option.label, "aria-pressed": appearance.icon === option.id, onClick: () => change("icon", option.id), children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "aria-hidden": "true", className: "dla-marker-sample", style: { "--dla-marker-mask": `var(--dla-mask-${option.id})`, "--dla-marker-outline": `var(--dla-outline-${option.id})`, "--dla-marker-radius": option.id === "number" ? "var(--dsw-radius-sm)" : "0" }, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "1" }) }) }, option.id)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "dla-appearance-hint", children: "立即生效，应用于所有批注" }),
+    error ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "dla-error", role: "alert", children: error }) : null
+  ] });
+}
+function ComposerStatus({ controller, sessionId }) {
+  const state = (0, import_react.useSyncExternalStore)(controller.subscribe, controller.getSnapshot);
+  const [open, setOpen] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)("");
+  (0, import_react.useEffect)(() => {
+    setOpen(false);
+    setError("");
+  }, [sessionId, state.sessionId]);
+  if (sessionId !== state.sessionId || !state.items.length) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "div",
+    {
+      "data-local-annotation-status": "",
+      onMouseEnter: () => setOpen(true),
+      onMouseLeave: () => setOpen(false),
+      onFocus: () => setOpen(true),
+      onBlur: (event) => {
+        if (!event.currentTarget.contains(event.relatedTarget)) setOpen(false);
+      },
+      onKeyDown: (event) => {
+        if (event.key === "Escape") {
+          event.stopPropagation();
+          setOpen(false);
+        }
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("button", { type: "button", className: "dla-chip", "aria-expanded": open, onClick: () => setOpen((value) => !value), children: [
+          "批注 ×",
+          state.items.length
+        ] }),
+        open ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dla-preview", role: "region", "aria-label": "已保存批注", children: [
+          state.items.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "dla-preview-item", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("button", { type: "button", className: "dla-summary", onClick: () => {
+              setOpen(false);
+              controller.showItem(item);
+            }, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dla-number", "data-digits": String(index + 1).length, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: index + 1 }) }),
+              brief(item.text, 100),
+              item.note ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "dla-preview-note", children: brief(item.note, 60) }) : null
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "dla-icon dla-danger", "aria-label": `删除批注 ${index + 1}`, onClick: () => {
+              void controller.remove(item).catch((cause) => setError(String(cause)));
+            }, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Trash, {}) })
+          ] }, item.id)),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", className: "dla-attach", onClick: () => {
+            if (controller.insert(state.items)) setOpen(false);
+          }, children: "附加到输入框" }),
+          error || state.error ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "dla-error", role: "alert", children: error || state.error }) : null
+        ] }) : null
+      ]
+    }
+  );
+}
+
+// src/icons.ts
+var paths = {
+  message: ["M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"],
+  bookmark: ["M17 3a2 2 0 0 1 2 2v15a1 1 0 0 1-1.496.868l-4.512-2.578a2 2 0 0 0-1.984 0l-4.512 2.578A1 1 0 0 1 5 20V5a2 2 0 0 1 2-2z"],
+  note: ["M21 9a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 15 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2z", "M15 3v5a1 1 0 0 0 1 1h5"]
+};
+function mask(parts, outline, viewBox) {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}" preserveAspectRatio="none" fill="${outline ? "none" : "white"}" stroke="white" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">${parts.map((d) => `<path d="${d}"/>`).join("")}</svg>`;
+  return `url("data:image/svg+xml,${encodeURIComponent(svg)}")`;
+}
+var ICON_MASKS = Object.entries(paths).map(([id, parts]) => {
+  const viewBox = id === "bookmark" ? "4 0 16 24" : "1 0 22 24";
+  return `--dla-mask-${id}:${mask(parts, false, viewBox)};--dla-outline-${id}:${mask(parts, true, viewBox)};`;
+}).join("\n") + "--dla-mask-number:none;--dla-outline-number:linear-gradient(transparent,transparent);";
+
+// src/styles.ts
+var STYLE = `
+:root { ${ICON_MASKS} }
+::highlight(dsh-local-annotation) { background-color: var(--dsw-alias-bg-document-selection); }
+[data-local-annotation-card] { position: fixed; z-index: 1000; top: 0; left: 0; width: fit-content; }
+[data-local-annotation-card][hidden], [data-local-annotation-toolbar][hidden] { display: none; }
+[data-local-annotation-toolbar], [data-local-annotation-panel], .dla-preview {
+  box-sizing: border-box; color: var(--dsw-alias-label-primary); background: var(--dsw-menu-surface-fill);
+  backdrop-filter: var(--dsw-menu-backdrop-filter); border: 1px solid var(--dsw-alias-border-l2);
+  border-radius: var(--dsw-radius-panel); corner-shape: var(--dsw-corner-shape); box-shadow: var(--dsw-elevation-panel);
+  font: var(--dsw-font-xs-13); font-family: var(--dsw-font-family); -webkit-app-region: no-drag;
+}
+[data-local-annotation-toolbar] { position: fixed; z-index: 1000; padding: 3px; max-width: calc(100vw - 16px); }
+[data-local-annotation-panel] { width: min(320px, calc(100vw - 16px)); max-height: calc(100dvh - 64px); overflow: auto; padding: 12px; }
+[data-local-annotation-panel] .dla-head { display: flex; align-items: center; gap: 6px; font: var(--dsw-font-xs-strong-13); }
+[data-local-annotation-panel] .dla-close { margin-left: auto; }
+[data-local-annotation-panel] .dla-quote { margin: 10px 0; padding: 4px 9px; border-left: 2px solid var(--dsw-alias-border-l2); color: var(--dsw-alias-label-tertiary); font: var(--dsw-font-xxs-12); max-height: 76px; overflow: auto; white-space: pre-wrap; overflow-wrap: anywhere; }
+[data-local-annotation-panel] textarea { box-sizing: border-box; width: 100%; min-height: 74px; resize: vertical; padding: 8px; font: inherit; color: var(--dsw-alias-label-primary); background: var(--dsw-specific-input-major); border: 1px solid var(--dsw-alias-border-l2); border-radius: var(--dsw-radius-md); corner-shape: var(--dsw-corner-shape); }
+[data-local-annotation-panel] button, [data-local-annotation-toolbar] button, [data-local-annotation-status] button { font: inherit; color: inherit; border: 0; background: transparent; border-radius: var(--dsw-radius-sm); corner-shape: var(--dsw-corner-shape); cursor: pointer; padding: 4px 8px; -webkit-app-region: no-drag; }
+:is([data-local-annotation-panel], [data-local-annotation-toolbar], [data-local-annotation-status]) button:hover { background: var(--dsw-alias-interactive-bg-hover); }
+:is([data-local-annotation-panel], [data-local-annotation-status]) .dla-icon { display: inline-flex; align-items: center; justify-content: center; flex: none; width: 24px; height: 24px; padding: 4px; }
+:is([data-local-annotation-panel], [data-local-annotation-status]) .dla-danger { color: var(--dsw-alias-label-tertiary); }
+:is([data-local-annotation-panel], [data-local-annotation-status]) .dla-danger:hover { color: var(--dsw-alias-state-error-primary); background: var(--dsw-alias-interactive-bg-hover-danger); }
+:is([data-local-annotation-panel], [data-local-annotation-toolbar], [data-local-annotation-status]) :is(button,textarea):focus-visible, [data-local-annotation-marker]:focus-visible { outline: var(--dsw-focus-ring-width) solid var(--dsw-focus-ring-color); outline-offset: 2px; }
+[data-local-annotation-panel] button:disabled { opacity: .5; cursor: default; }
+.dla-error { color: var(--dsw-alias-state-error-primary); font: var(--dsw-font-xxs-12); overflow-wrap: anywhere; }
+[data-local-annotation-status] { position: relative; display: inline-flex; font: var(--dsw-font-xxs-12); color: var(--dsw-alias-label-secondary); }
+[data-local-annotation-status] .dla-chip { border: 1px solid var(--dsw-alias-border-l2); border-radius: var(--dsw-radius-xl); padding: 2px 8px; white-space: nowrap; }
+[data-local-annotation-status] .dla-preview { position: absolute; bottom: 100%; left: 0; z-index: 1000; width: min(300px,calc(100vw - 32px)); max-height: min(360px,50dvh); overflow: auto; padding: 8px 10px; }
+[data-local-annotation-status] .dla-preview-item { display: flex; align-items: flex-start; gap: 4px; padding: 6px 0; border-bottom: 1px solid var(--dsw-alias-border-l2); }
+[data-local-annotation-status] .dla-summary { flex: 1; min-width: 0; padding: 0; text-align: left; font: var(--dsw-font-xxs-12); color: var(--dsw-alias-label-tertiary); overflow-wrap: anywhere; }
+[data-local-annotation-status] .dla-preview-note { display: block; color: var(--dsw-alias-label-secondary); margin: 3px 0 0 22px; }
+[data-local-annotation-status] .dla-number { display: inline-grid; vertical-align: middle; width: 26px; height: 24px; margin-right: 6px; }
+[data-local-annotation-status] .dla-attach { margin-top: 6px; color: var(--dsw-alias-brand-text); }
+[data-local-annotation-marker] { display: grid; width: 26px; height: 24px; padding: 0; border: 0; background: transparent; cursor: pointer; pointer-events: auto; -webkit-app-region: no-drag; }
+:is([data-local-annotation-marker], .dla-number, .dla-marker-sample) {
+  position: relative; isolation: isolate; place-items: center; box-sizing: border-box;
+  color: var(--dsw-alias-label-primary); font: var(--dsw-font-xxxs-strong-11); font-variant-numeric: tabular-nums;
+}
+:is([data-local-annotation-marker], .dla-number, .dla-marker-sample)::before,
+:is([data-local-annotation-marker], .dla-number, .dla-marker-sample)::after {
+  content: ''; position: absolute; inset: 0; pointer-events: none; z-index: -1;
+  border-radius: var(--dla-marker-radius, 0);
+  mask: var(--dla-marker-mask, var(--dla-mask-message)) center / 100% 100% no-repeat;
+}
+:is([data-local-annotation-marker], .dla-number, .dla-marker-sample)::before { background: color-mix(in srgb, var(--dla-ink) 26%, var(--dsw-specific-input-major)); }
+:is([data-local-annotation-marker], .dla-number, .dla-marker-sample)::after {
+  background: color-mix(in srgb, var(--dla-ink) 55%, var(--dsw-alias-label-primary));
+  mask-image: var(--dla-marker-outline, var(--dla-outline-message));
+}
+[data-local-annotation-marker]:hover::before { background: color-mix(in srgb, var(--dla-ink) 45%, var(--dsw-specific-input-major)); }
+[data-local-annotation-marker]:hover { filter: drop-shadow(0 1px 2px var(--dsw-alias-border-l2)); }
+:is([data-local-annotation-marker], .dla-number, .dla-marker-sample) > span { position: relative; padding-bottom: 2px; }
+:is([data-local-annotation-marker], .dla-number)[data-digits='3'] > span { font-size: 9px; }
+[data-local-annotation-panel] .dla-footer { display: flex; align-items: flex-start; justify-content: space-between; gap: 8px; margin-top: 8px; }
+[data-local-annotation-panel] .dla-save { margin: 0; margin-left: auto; flex: none; }
+.dla-appearance { min-width: 0; flex: 1; }
+.dla-appearance summary { width: fit-content; padding: 4px 0; cursor: pointer; color: var(--dsw-alias-label-secondary); font: var(--dsw-font-xxs-12); }
+.dla-appearance summary:focus-visible { outline: var(--dsw-focus-ring-width) solid var(--dsw-focus-ring-color); outline-offset: 2px; }
+.dla-appearance fieldset { border: 0; padding: 0; margin: 8px 0; min-width: 0; }
+.dla-appearance legend { padding: 0; margin-bottom: 5px; font: var(--dsw-font-xxs-12); color: var(--dsw-alias-label-tertiary); }
+.dla-appearance .dla-options { display: flex; flex-wrap: wrap; gap: 4px; align-items: center; }
+[data-local-annotation-panel] .dla-appearance button { border: 1px solid transparent; padding: 4px 6px; }
+[data-local-annotation-panel] .dla-appearance button[aria-pressed='true'] { border-color: var(--dsw-alias-brand-primary); background: var(--dsw-alias-interactive-bg-hover); }
+.dla-stroke-sample { display: inline-block; padding: 0 1px 3px; font: var(--dsw-font-xxs-12); }
+${STROKES.map((option) => `.dla-stroke-sample[data-stroke='${option.id}'] { ${highlightCSS(option.id, "theme").replaceAll("var(--dsw-alias-brand-primary)", "var(--dla-ink)")} }`).join("\n")}
+[data-local-annotation-panel] .dla-appearance .dla-swatch { padding: 4px; width: 26px; height: 26px; border-radius: var(--dsw-radius-xl); }
+.dla-swatch::before { content: ''; display: block; width: 16px; height: 16px; border-radius: 50%; background: var(--dla-swatch); box-shadow: inset 0 0 0 1px var(--dsw-alias-border-l2); }
+.dla-custom-color { display: inline-flex; align-items: center; gap: 4px; font: var(--dsw-font-xxs-12); color: var(--dsw-alias-label-secondary); cursor: pointer; }
+.dla-custom-color input { width: 24px; height: 24px; padding: 0; border: 1px solid var(--dsw-alias-border-l2); border-radius: var(--dsw-radius-sm); background: transparent; cursor: pointer; }
+.dla-custom-color input:focus-visible { outline: var(--dsw-focus-ring-width) solid var(--dsw-focus-ring-color); outline-offset: 2px; }
+.dla-marker-sample { display: inline-grid; width: 26px; height: 24px; }
+.dla-appearance-hint { font: var(--dsw-font-xxxs-strong-11); color: var(--dsw-alias-label-tertiary); margin: 4px 0; }
+`;
+
+// src/client.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var name = "dsh-local-annotation";
+var inject = ["uiSession", "slots"];
+function apply(ctx) {
+  ctx.effect(() => {
+    const style = document.createElement("style");
+    style.dataset.plugin = name;
+    style.textContent = STYLE;
+    document.head.append(style);
+    const host = document.createElement("div");
+    host.dataset.localAnnotationCard = "";
+    host.hidden = true;
+    document.body.append(host);
+    let controller;
+    let root;
+    let disposeStatus;
+    const dispose = () => {
+      disposeStatus?.();
+      root?.unmount();
+      controller?.dispose();
+      host.remove();
+      style.remove();
+    };
+    try {
+      controller = new Controller(ctx, host);
+      root = (0, import_client.createRoot)(host);
+      root.render(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Card, { controller }));
+      const active = controller;
+      disposeStatus = ctx.slots.inject("conversation.input.left", () => ctx.slots.register({
+        name: "conversation.input.left",
+        id: name,
+        inject: (sessionId) => ({ controller: active, sessionId })
+      }, ComposerStatus));
+      return dispose;
+    } catch (error) {
+      dispose();
+      throw error;
+    }
+  }, `${name}: inline annotation card`);
+}
+/*! Lucide icon paths: https://lucide.dev — ISC License
+ * Copyright (c) 2026 Lucide Icons and Contributors
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+    return module.exports;
+  }
+});