@xiongtao.xt/tau-plugins 0.18.0 → 0.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiongtao.xt/tau-plugins",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -11,7 +11,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "type": "module",
-  "description": "Tau 插件作者类型契约；运行时由宿主提供",
+  "description": "Tau 插件作者类型契约；插件实现由宿主提供，发布数据客户端可独立使用",
   "exports": {
     ".": {
       "types": "./types/packages/plugins/src/index.d.ts",
@@ -22,6 +22,18 @@
       "types": "./types/packages/plugins/src/sync.d.ts",
       "default": "./runtime.js"
     },
+    "./publish-data": {
+      "types": "./types/packages/plugins/src/publish-data.d.ts",
+      "default": "./publish-data.js"
+    },
+    "./publish-client": {
+      "types": "./types/packages/plugins/src/publish-client.d.ts",
+      "default": "./publish-client.js"
+    },
+    "./publish-artifacts": {
+      "types": "./types/packages/plugins/src/publish-artifacts.d.ts",
+      "default": "./publish-artifacts.js"
+    },
     "./whiteboard": {
       "types": "./types/packages/plugins/src/whiteboard.d.ts",
       "default": "./runtime.js"
@@ -30,7 +42,7 @@
   "dependencies": {
     "@types/react": "19.2.0",
     "@types/react-dom": "19.2.0",
-    "lucide-react": "0.399.0",
+    "lucide-react": "0.468.0",
     "clsx": "2.1.1",
     "slate": "0.126.2",
     "slate-react": "0.126.4",

package/publish-artifacts.js

@@ -0,0 +1,252 @@
+// packages/plugins/src/ids.ts
+function assertLocalId(value) {
+  if (typeof value !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value)) {
+    throw new Error("\u63D2\u4EF6\u6807\u8BC6\u5FC5\u987B\u4E3A 1 \u81F3 128 \u4F4D\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u6A2A\u7EBF\u6216\u4E0B\u5212\u7EBF");
+  }
+}
+
+// packages/plugins/src/version.ts
+function parseVersion(value) {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(
+    value
+  );
+  if (!match) throw new Error(`\u7248\u672C\u53F7\u65E0\u6548\uFF1A${value}`);
+  const pre = match[4]?.split(".") ?? [];
+  if (pre.some((part) => /^\d+$/.test(part) && part.length > 1 && part.startsWith("0")))
+    throw new Error(`\u7248\u672C\u53F7\u65E0\u6548\uFF1A${value}`);
+  return { core: match.slice(1, 4), pre };
+}
+function comparePluginVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  const numeric = (x, y) => BigInt(x) === BigInt(y) ? 0 : BigInt(x) > BigInt(y) ? 1 : -1;
+  for (let index = 0; index < 3; index++) {
+    const result = numeric(a.core[index], b.core[index]);
+    if (result) return result;
+  }
+  if (!a.pre.length || !b.pre.length)
+    return a.pre.length === b.pre.length ? 0 : a.pre.length ? -1 : 1;
+  for (let index = 0; index < Math.max(a.pre.length, b.pre.length); index++) {
+    const x = a.pre[index], y = b.pre[index];
+    if (x === void 0 || y === void 0) return x === void 0 ? -1 : 1;
+    if (x === y) continue;
+    const nx = /^\d+$/.test(x), ny = /^\d+$/.test(y);
+    return nx && ny ? numeric(x, y) : nx !== ny ? nx ? -1 : 1 : x > y ? 1 : -1;
+  }
+  return 0;
+}
+
+// packages/plugins/src/categories.ts
+var PLUGIN_CATEGORIES = [
+  { id: "sync", label: "\u540C\u6B65" },
+  { id: "upload", label: "\u8D44\u6E90\u4E0A\u4F20" },
+  { id: "editor", label: "\u7F16\u8F91\u5668" },
+  { id: "whiteboard", label: "\u767D\u677F" },
+  { id: "blog-template", label: "\u535A\u5BA2\u6A21\u677F" },
+  { id: "ai", label: "AI" },
+  { id: "voice", label: "\u8BED\u97F3" },
+  { id: "page", label: "\u9875\u9762" }
+];
+var PLUGIN_KEYWORD_LIMIT = 5;
+var PLUGIN_KEYWORD_MAX_LENGTH = 20;
+var categoryIds = new Set(PLUGIN_CATEGORIES.map((item) => item.id));
+var isPluginCategory = (value) => typeof value === "string" && categoryIds.has(value);
+function readCatalogFields(item, strict) {
+  const fail = (message) => {
+    if (strict) throw new Error(message);
+  };
+  const list = (value, name) => {
+    if (value === void 0) return [];
+    if (Array.isArray(value)) return value;
+    fail(`${name} \u5FC5\u987B\u662F\u6570\u7EC4`);
+    return [];
+  };
+  const categories = [];
+  for (const value of list(item.categories, "categories")) {
+    if (!isPluginCategory(value)) fail(`\u672A\u77E5\u63D2\u4EF6\u5206\u7C7B\uFF1A${String(value)}`);
+    else if (!categories.includes(value)) categories.push(value);
+  }
+  const keywords = [];
+  for (const value of list(item.keywords, "keywords")) {
+    const keyword = typeof value === "string" ? value.trim() : "";
+    if (!keyword || keyword.length > PLUGIN_KEYWORD_MAX_LENGTH)
+      fail(`\u5173\u952E\u8BCD\u5FC5\u987B\u4E3A 1 \u81F3 ${PLUGIN_KEYWORD_MAX_LENGTH} \u5B57`);
+    else if (!keywords.includes(keyword)) keywords.push(keyword);
+  }
+  if (keywords.length > PLUGIN_KEYWORD_LIMIT) {
+    fail(`\u5173\u952E\u8BCD\u6700\u591A ${PLUGIN_KEYWORD_LIMIT} \u4E2A`);
+    keywords.length = PLUGIN_KEYWORD_LIMIT;
+  }
+  return {
+    ...categories.length ? { categories: Object.freeze(categories) } : {},
+    ...keywords.length ? { keywords: Object.freeze(keywords) } : {}
+  };
+}
+
+// packages/plugins/src/package.ts
+var PLUGIN_SHARED_MODULES = [
+  "@tau/plugins",
+  "@tau/plugins/whiteboard",
+  "@tau/plugins/sync",
+  "@tau/ui",
+  "react",
+  "react-dom",
+  "react-dom/client",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime"
+];
+function validatePluginManifest(value, options = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("\u63D2\u4EF6\u6E05\u5355\u5FC5\u987B\u662F\u5BF9\u8C61");
+  const item = value;
+  if (item.formatVersion !== 1 || item.apiVersion !== 1 || item.platform !== "desktop" || item.format !== "cjs")
+    throw new Error("\u63D2\u4EF6\u5305\u683C\u5F0F\u3001API \u7248\u672C\u6216\u5E73\u53F0\u4E0D\u517C\u5BB9");
+  if (typeof item.id !== "string") throw new Error("\u63D2\u4EF6 ID \u65E0\u6548");
+  assertLocalId(item.id);
+  if (typeof item.name !== "string" || !item.name.trim() || typeof item.version !== "string" || !/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(item.version))
+    throw new Error("\u63D2\u4EF6\u540D\u79F0\u6216\u7248\u672C\u65E0\u6548");
+  const file = (input, extension) => {
+    if (typeof input !== "string" || !/^[\w./-]+$/.test(input) || input.split("/").some((part) => !part || part === "." || part === "..") || !input.endsWith(extension))
+      throw new Error("\u63D2\u4EF6\u5165\u53E3\u6216\u6837\u5F0F\u8DEF\u5F84\u65E0\u6548");
+    return input;
+  };
+  const main = file(item.main, ".js");
+  if (item.sync !== void 0) throw new Error("Node\u540C\u6B65\u5165\u53E3\u5DF2\u505C\u7528\uFF0C\u8BF7\u66F4\u65B0\u63D2\u4EF6");
+  if (item.minAppVersion !== void 0) {
+    if (typeof item.minAppVersion !== "string") throw new Error("\u6700\u4F4E\u5BA2\u6237\u7AEF\u7248\u672C\u65E0\u6548");
+    comparePluginVersions(item.minAppVersion, item.minAppVersion);
+  }
+  const styles = item.styles === void 0 ? void 0 : file(item.styles, ".css");
+  if (item.editor !== void 0 && item.editor !== true) throw new Error("editor \u53EA\u80FD\u58F0\u660E\u4E3A true");
+  if (item.whiteboard !== void 0 && item.whiteboard !== true)
+    throw new Error("whiteboard \u53EA\u80FD\u58F0\u660E\u4E3A true");
+  const catalog = readCatalogFields(item, options.strict === true);
+  const integrity = {};
+  for (const name of [main, ...styles ? [styles] : []]) {
+    const hash = item.integrity && typeof item.integrity === "object" ? item.integrity[name] : void 0;
+    if (typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash))
+      throw new Error("\u63D2\u4EF6\u4EA7\u7269\u7F3A\u5C11\u6709\u6548\u7684\u5B8C\u6574\u6027\u6458\u8981");
+    integrity[name] = hash;
+  }
+  return Object.freeze({
+    formatVersion: 1,
+    id: item.id,
+    name: item.name,
+    version: item.version,
+    ...typeof item.minAppVersion === "string" ? { minAppVersion: item.minAppVersion } : {},
+    apiVersion: 1,
+    platform: "desktop",
+    format: "cjs",
+    main,
+    ...item.editor === true ? { editor: true } : {},
+    ...item.whiteboard === true ? { whiteboard: true } : {},
+    ...catalog,
+    integrity: Object.freeze(integrity),
+    ...styles === void 0 ? {} : { styles }
+  });
+}
+
+// packages/plugins/src/rendering.ts
+var PLUGIN_RENDER_VERSION = 1;
+function evaluatePluginPackage(artifact, modules) {
+  const manifest = validatePluginManifest(artifact.manifest);
+  const module = { exports: {} };
+  new Function(
+    "require",
+    "module",
+    "exports",
+    '"use strict";\n' + artifact.code + `
+//# sourceURL=tau-plugin://${manifest.id}/${manifest.version}/main.js`
+  )(
+    (id) => {
+      if (!PLUGIN_SHARED_MODULES.some((name) => name === id) || !Object.hasOwn(modules, id))
+        throw new Error(`\u63D2\u4EF6\u4F7F\u7528\u4E86\u672A\u63D0\u4F9B\u7684\u5BBF\u4E3B\u6A21\u5757\uFF1A${id}`);
+      return modules[id];
+    },
+    module,
+    module.exports
+  );
+  return validatePluginDefinition(manifest, module.exports.default);
+}
+function validatePluginDefinition(manifest, definition) {
+  if (!definition || typeof definition.create !== "function" || definition.id !== manifest.id || definition.name !== manifest.name || definition.version !== manifest.version || definition.apiVersion !== manifest.apiVersion)
+    throw new Error("\u63D2\u4EF6\u5165\u53E3\u5B9A\u4E49\u4E0E\u6E05\u5355\u4E0D\u4E00\u81F4");
+  if (Boolean(definition.editorExtensions?.length) !== Boolean(manifest.editor))
+    throw new Error("\u7F16\u8F91\u5668\u8D21\u732E\u5FC5\u987B\u4E0E manifest.editor \u58F0\u660E\u4E00\u81F4");
+  if (Boolean(definition.whiteboardExtensions?.length) !== Boolean(manifest.whiteboard))
+    throw new Error("\u767D\u677F\u8D21\u732E\u5FC5\u987B\u4E0E manifest.whiteboard \u58F0\u660E\u4E00\u81F4");
+  getPluginWhiteboardTypes(definition);
+  if (definition.editorCodecs?.length && !manifest.editor)
+    throw new Error("Markdown codec \u5FC5\u987B\u968F\u7F16\u8F91\u5668\u8D21\u732E\u58F0\u660E");
+  if (manifest.editor) {
+    const types = getPluginNodeTypes(definition);
+    if (definition.editorCodecs?.some((codec) => !types.includes(codec.type)))
+      throw new Error("\u63D2\u4EF6 codec \u53EA\u80FD\u58F0\u660E\u672C\u63D2\u4EF6\u63D0\u4F9B\u7684\u8282\u70B9\u7C7B\u578B");
+  }
+  return definition;
+}
+function getPluginNodeTypes(definition) {
+  const types = [];
+  for (const extension of definition.editorExtensions ?? []) {
+    if ("plugins" in extension) throw new Error("\u7F16\u8F91\u5668\u63D2\u4EF6\u4E0D\u652F\u6301\u539F\u59CB Slate \u5305\u88C5\u5668");
+    for (const element of extension.elements ?? []) {
+      if (!element.type || types.includes(element.type))
+        throw new Error(`\u63D2\u4EF6\u8282\u70B9\u7C7B\u578B\u4E3A\u7A7A\u6216\u91CD\u590D\uFF1A${element.type}`);
+      types.push(element.type);
+    }
+  }
+  if (definition.editorExtensions?.length && !types.length)
+    throw new Error("\u7F16\u8F91\u5668\u63D2\u4EF6\u5FC5\u987B\u58F0\u660E\u8282\u70B9\u7C7B\u578B");
+  const htmlTypes = /* @__PURE__ */ new Set();
+  for (const extension of definition.editorExtensions ?? []) {
+    for (const source of extension.styleSources ?? [])
+      if (!types.includes(source.type) || !source.field || !["html", "tsx"].includes(source.language))
+        throw new Error("\u63D2\u4EF6\u6837\u5F0F\u6E90\u7801\u5FC5\u987B\u58F0\u660E\u672C\u63D2\u4EF6\u7684\u8282\u70B9\u5B57\u6BB5\u548C\u8BED\u8A00");
+    for (const serializer of extension.htmlSerializers ?? []) {
+      if (!types.includes(serializer.type) || htmlTypes.has(serializer.type) || typeof serializer.toHtml !== "function")
+        throw new Error("\u63D2\u4EF6 HTML \u5BFC\u51FA\u7C7B\u578B\u91CD\u590D\u6216\u4E0D\u5C5E\u4E8E\u672C\u63D2\u4EF6");
+      htmlTypes.add(serializer.type);
+    }
+  }
+  return types;
+}
+function getPluginWhiteboardTypes(definition) {
+  if (definition.whiteboardExtensions !== void 0 && !Array.isArray(definition.whiteboardExtensions))
+    throw new Error("\u767D\u677F\u6269\u5C55\u58F0\u660E\u5FC5\u987B\u4E3A\u6570\u7EC4");
+  const types = /* @__PURE__ */ new Set();
+  const extensions = /* @__PURE__ */ new Set();
+  for (const extension of definition.whiteboardExtensions ?? []) {
+    if (!extension || typeof extension.id !== "string" || extension.apiVersion !== 1 || typeof extension.create !== "function" || extension.id !== definition.id && !extension.id.startsWith(`${definition.id}.`) || extensions.has(extension.id))
+      throw new Error("\u767D\u677F\u6269\u5C55\u8EAB\u4EFD\u91CD\u590D\u6216\u4E0D\u5C5E\u4E8E\u5F53\u524D\u63D2\u4EF6");
+    extensions.add(extension.id);
+    if (!Array.isArray(extension.elements) || !extension.elements.length)
+      throw new Error("\u767D\u677F\u63D2\u4EF6\u5FC5\u987B\u58F0\u660E\u9759\u6001\u5143\u7D20");
+    for (const element of extension.elements) {
+      if (!element || typeof element.type !== "string" || !element.type.startsWith(`${definition.id}.`) || types.has(element.type) || typeof element.render !== "function")
+        throw new Error("\u767D\u677F\u5143\u7D20\u91CD\u590D\u3001\u7F3A\u5C11\u6E32\u67D3\u6216\u4E0D\u5C5E\u4E8E\u5F53\u524D\u63D2\u4EF6");
+      types.add(element.type);
+    }
+  }
+  return [...types];
+}
+function assertRenderTypes(definition, expected) {
+  const actual = getPluginNodeTypes(definition);
+  if (actual.length !== expected.length || actual.some((type) => !expected.includes(type)))
+    throw new Error("\u53D1\u5E03\u7684\u8282\u70B9\u5F52\u5C5E\u4E0E\u63D2\u4EF6\u5B9A\u4E49\u4E0D\u4E00\u81F4");
+}
+
+// packages/plugins/src/publish-artifacts.ts
+var PLUGIN_RENDER_VERSION2 = PLUGIN_RENDER_VERSION;
+function evaluatePluginPackage2(artifact, modules) {
+  return evaluatePluginPackage(artifact, modules);
+}
+function assertRenderTypes2(definition, types) {
+  assertRenderTypes(definition, types);
+}
+export {
+  PLUGIN_RENDER_VERSION2 as PLUGIN_RENDER_VERSION,
+  PLUGIN_SHARED_MODULES,
+  assertRenderTypes2 as assertRenderTypes,
+  evaluatePluginPackage2 as evaluatePluginPackage,
+  validatePluginManifest
+};

package/publish-client.js

@@ -0,0 +1,258 @@
+// packages/plugins/src/publish-client.ts
+var DataError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "DataError";
+  }
+};
+function assert(condition, code, message) {
+  if (!condition) throw new DataError(code, message);
+}
+function record(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function resourceUrl(relative, base) {
+  assert(
+    typeof relative === "string" && !!relative && !/[\\:%?#]/.test(relative) && relative.split("/").every((part) => part && part !== "." && part !== ".."),
+    "INVALID_DATA",
+    "\u6570\u636E\u8D44\u6E90\u8DEF\u5F84\u65E0\u6548"
+  );
+  return new URL(relative, base).href;
+}
+function cancelled(signal) {
+  if (signal?.aborted) throw new DOMException("\u8BFB\u53D6\u5DF2\u53D6\u6D88", "AbortError");
+}
+async function waitFor(pending, signal) {
+  cancelled(signal);
+  if (!signal) return pending;
+  let abort = () => {
+  };
+  try {
+    return await Promise.race([
+      pending,
+      new Promise((_resolve, reject) => {
+        abort = () => reject(new DOMException("\u8BFB\u53D6\u5DF2\u53D6\u6D88", "AbortError"));
+        signal.addEventListener("abort", abort, { once: true });
+      })
+    ]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+function createClient({ manifestUrl }) {
+  const origin = new URL(manifestUrl).href;
+  const cache = /* @__PURE__ */ new Map();
+  let manifestPromise;
+  let searchPromise;
+  let engine;
+  function json(url, expected) {
+    assert(/^[a-f0-9]{64}$/.test(expected), "INVALID_DATA", "\u6458\u8981\u683C\u5F0F\u9519\u8BEF");
+    const filenameHash = new URL(url).pathname.match(/\.([a-f0-9]{64})\.json$/)?.[1];
+    assert(filenameHash === expected, "INTEGRITY_MISMATCH", "\u6587\u4EF6\u540D\u4E0E\u58F0\u660E\u6458\u8981\u4E0D\u4E00\u81F4");
+    let pending = cache.get(url);
+    if (!pending) {
+      pending = (async () => {
+        const response = await fetch(url);
+        if (!response.ok)
+          throw new DataError("RESOURCE_LOAD_FAILED", `HTTP ${response.status}\uFF1A${url}`);
+        const bytes = await response.arrayBuffer();
+        const digest = [...new Uint8Array(await crypto.subtle.digest("SHA-256", bytes))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+        assert(digest === expected, "INTEGRITY_MISMATCH", `\u8D44\u6E90\u6458\u8981\u9519\u8BEF\uFF1A${url}`);
+        try {
+          return JSON.parse(new TextDecoder().decode(bytes));
+        } catch {
+          throw new DataError("INVALID_DATA", `JSON \u65E0\u6548\uFF1A${url}`);
+        }
+      })().catch((error) => {
+        cache.delete(url);
+        if (error instanceof DataError) throw error;
+        throw new DataError("RESOURCE_LOAD_FAILED", String(error));
+      });
+      cache.set(url, pending);
+    }
+    return pending;
+  }
+  function manifest() {
+    if (!manifestPromise) {
+      manifestPromise = (async () => {
+        const hash = new URL(origin).pathname.match(/site\.([a-f0-9]{64})\.json$/)?.[1];
+        assert(hash, "INVALID_DATA", "\u6E05\u5355 URL \u7F3A\u5C11\u6458\u8981");
+        const value = await json(origin, hash);
+        assert(record(value), "INVALID_DATA", "\u6E05\u5355\u5FC5\u987B\u662F\u5BF9\u8C61");
+        assert(value.version === 1, "PROTOCOL_MISMATCH", "\u6570\u636E\u534F\u8BAE\u7248\u672C\u4E0D\u5339\u914D");
+        assert(
+          record(value.site) && Array.isArray(value.items) && record(value.search),
+          "INVALID_DATA",
+          "\u6E05\u5355\u5B57\u6BB5\u7F3A\u5931"
+        );
+        const keys = /* @__PURE__ */ new Set();
+        assert(
+          typeof value.site.title === "string" && typeof value.site.description === "string" && typeof value.site.basePath === "string",
+          "INVALID_DATA",
+          "\u7AD9\u70B9\u6570\u636E\u7F3A\u5931"
+        );
+        for (const item of value.items) {
+          assert(
+            record(item) && typeof item.key === "string" && typeof item.type === "string",
+            "INVALID_DATA",
+            "\u6570\u636E\u8EAB\u4EFD\u7F3A\u5931"
+          );
+          assert(!keys.has(item.key), "INVALID_DATA", "\u6E05\u5355 key \u91CD\u590D");
+          assert(
+            typeof item.data === "string" && typeof item.integrity === "string",
+            "INVALID_DATA",
+            "\u6570\u636E\u6587\u4EF6\u5F15\u7528\u7F3A\u5931"
+          );
+          keys.add(item.key);
+          assert(
+            ["home", "card", "article", "doc", "quest", "list"].includes(String(item.type)) && typeof item.title === "string",
+            "INVALID_DATA",
+            "\u6570\u636E\u7C7B\u578B\u6216\u6807\u9898\u65E0\u6548"
+          );
+          resourceUrl(item.data, origin);
+          assert(/^[a-f0-9]{64}$/.test(item.integrity), "INVALID_DATA", "\u6570\u636E\u6458\u8981\u65E0\u6548");
+        }
+        assert(
+          typeof value.search.data === "string" && typeof value.search.integrity === "string",
+          "INVALID_DATA",
+          "\u7D22\u5F15\u5F15\u7528\u7F3A\u5931"
+        );
+        resourceUrl(value.search.data, origin);
+        assert(
+          /^[a-f0-9]{64}$/.test(value.search.integrity),
+          "INVALID_DATA",
+          "\u7D22\u5F15\u6458\u8981\u65E0\u6548"
+        );
+        return value;
+      })().catch((error) => {
+        manifestPromise = void 0;
+        cache.delete(origin);
+        throw error;
+      });
+    }
+    return manifestPromise;
+  }
+  function index() {
+    if (!searchPromise) {
+      searchPromise = (async () => {
+        const source = await manifest();
+        const url = resourceUrl(source.search.data, origin);
+        const value = await json(url, source.search.integrity);
+        assert(record(value), "INVALID_DATA", "\u7D22\u5F15\u5FC5\u987B\u662F\u5BF9\u8C61");
+        assert(value.version === 1, "PROTOCOL_MISMATCH", "\u7D22\u5F15\u7248\u672C\u4E0D\u5339\u914D");
+        assert(Array.isArray(value.documents), "INVALID_DATA", "\u7D22\u5F15\u7F3A\u5C11 documents");
+        const seen = /* @__PURE__ */ new Set();
+        for (const document of value.documents) {
+          assert(
+            record(document) && typeof document.key === "string",
+            "INVALID_DATA",
+            "\u641C\u7D22\u8EAB\u4EFD\u65E0\u6548"
+          );
+          const item = source.items.find((item2) => item2.key === document.key);
+          assert(
+            item && item.type === document.type && !seen.has(document.key),
+            "INVALID_DATA",
+            "\u641C\u7D22 key \u672A\u95ED\u5408\u6216\u91CD\u590D"
+          );
+          assert(
+            ["card", "article", "doc", "quest"].includes(String(document.type)),
+            "INVALID_DATA",
+            "\u641C\u7D22\u7C7B\u578B\u9519\u8BEF"
+          );
+          assert(
+            ["title", "summary", "content"].every((field) => typeof document[field] === "string"),
+            "INVALID_DATA",
+            "\u641C\u7D22\u6587\u672C\u7F3A\u5931"
+          );
+          assert(
+            Array.isArray(document.tags) && document.tags.every((tag) => typeof tag === "string"),
+            "INVALID_DATA",
+            "\u641C\u7D22\u6807\u7B7E\u65E0\u6548"
+          );
+          seen.add(document.key);
+        }
+        return value;
+      })().catch((error) => {
+        searchPromise = void 0;
+        if (manifestPromise)
+          void manifestPromise.then(
+            (source) => cache.delete(resourceUrl(source.search.data, origin)),
+            () => void 0
+          );
+        throw error;
+      });
+    }
+    return searchPromise;
+  }
+  return {
+    async readManifest({ signal } = {}) {
+      cancelled(signal);
+      return waitFor(manifest(), signal);
+    },
+    async readData({ key, signal }) {
+      cancelled(signal);
+      const source = await waitFor(manifest(), signal);
+      const item = source.items.find((item2) => item2.key === key);
+      assert(item, "DATA_NOT_FOUND", `\u672A\u53D1\u5E03\u5185\u5BB9\uFF1A${key}`);
+      const dataUrl = resourceUrl(item.data, origin);
+      const value = await waitFor(json(dataUrl, item.integrity), signal);
+      assert(
+        record(value) && record(value.meta) && record(value.content),
+        "INVALID_DATA",
+        "\u5185\u5BB9\u7ED3\u6784\u9519\u8BEF"
+      );
+      assert(value.version === 1, "PROTOCOL_MISMATCH", "\u5185\u5BB9\u534F\u8BAE\u7248\u672C\u4E0D\u5339\u914D");
+      assert(
+        value.key === key && value.meta.type === item.type && (item.id === void 0 || value.content.id === void 0 || value.content.id === item.id),
+        "IDENTITY_MISMATCH",
+        "\u5185\u5BB9\u8EAB\u4EFD\u4E0D\u5339\u914D"
+      );
+      return {
+        data: value,
+        dataUrl,
+        ...source.settings ? { settings: source.settings } : {}
+      };
+    },
+    async search(query, { limit = 12, signal } = {}) {
+      cancelled(signal);
+      const normalized = query.replace(/\s+/g, " ").trim();
+      if (!normalized) return [];
+      assert(Number.isInteger(limit) && limit > 0, "INVALID_DATA", "limit \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+      const [{ documents }, { default: Fuse }] = await waitFor(
+        Promise.all([index(), import("./client/fuse-M2Z6NNAT.js")]),
+        signal
+      );
+      cancelled(signal);
+      if (engine?.documents !== documents)
+        engine = {
+          documents,
+          fuse: new Fuse(documents, {
+            keys: ["title", "summary", "content", "tags"],
+            includeMatches: true,
+            threshold: 0.3,
+            ignoreLocation: true
+          })
+        };
+      return engine.fuse.search(normalized, { limit }).map(({ item, matches }) => {
+        const { content: _content, ...hit } = item;
+        const ranges = (matches ?? []).flatMap((match) => {
+          if (!match.value || !["title", "summary", "content", "tags"].includes(match.key ?? ""))
+            return [];
+          return [
+            {
+              field: match.key,
+              text: match.value,
+              ranges: match.indices.map(([start, end]) => [start, end + 1])
+            }
+          ];
+        });
+        return { ...hit, matches: ranges };
+      });
+    }
+  };
+}
+export {
+  DataError,
+  createClient
+};

package/publish-data.js

@@ -0,0 +1 @@
+export {};

package/types/packages/editor/api.d.ts

@@ -1,4 +1,4 @@
-export * from "./src/api/index";
+export * from "./src/core/api/index";
 /** 扩展包通过模块增强登记元素；不要求内核知道包名或实现文件。 */
 declare const extensionElementMapBrand: unique symbol;
 declare const extensionInlineElementMapBrand: unique symbol;

package/types/packages/editor/contracts.d.ts

@@ -1,3 +1,3 @@
 /** 无 React/DOM 运行时代码的声明入口，供应用 SDK 适配现有扩展协议。 */
-export { defineExtension, defineElement } from "./src/api/extension";
-export type { EditorExtension, ElementSpec, ElementRenderProps } from "./src/api/extension";
+export { defineExtension, defineElement } from "./src/core/api/extension";
+export type { EditorExtension, ElementSpec, ElementRenderProps } from "./src/core/api/extension";

package/types/packages/editor/source-contracts.d.ts

@@ -0,0 +1,48 @@
+import type { ReactNode, ReactElement } from "react";
+import type { LucideIcon } from "lucide-react";
+import type { Editor, Element, Path } from "slate";
+import type { ElementBehaviors, ParagraphElement, BlockElement } from "./api";
+export interface SourceBlockEditorProps {
+    mode: string;
+    title: string;
+    icon: LucideIcon;
+    initValue: string;
+    onChange(value: string): void;
+    element: Element;
+    center?: boolean;
+    extend?: boolean;
+    fluid?: boolean;
+    children?: ReactNode;
+}
+export interface RuntimeStyleCompiler {
+    compile(request: {
+        source: string;
+        language: "html" | "tsx";
+    }): Promise<string>;
+}
+export interface SourceEditorRuntime {
+    SourceBlockEditor(props: SourceBlockEditorProps): ReactElement;
+    useSourceBlock(element: Element): {
+        theme: {
+            isDark: boolean;
+            token(word: string): string;
+        };
+        compiler: RuntimeStyleCompiler | undefined;
+        update(properties: Record<string, unknown>): void;
+    };
+    useReportPreviewError(error: string | null, options?: {
+        stale?: boolean;
+    }): boolean;
+    insertSourceBlock(editor: Editor, element: BlockElement, line?: number): Path | undefined;
+    sourceBlockParagraphBehavior(type: string): ElementBehaviors<ParagraphElement>;
+}
+export interface InlineSourceRuntime {
+    useInlineSource(element: Element): {
+        readOnly: boolean;
+        compiler: RuntimeStyleCompiler | undefined;
+        update(properties: Record<string, unknown>): void;
+        remove(): void;
+    };
+    insertInlineSource(editor: Editor, element: Element): void;
+    InlineSourceBoundary(): ReactElement;
+}

package/types/packages/editor/src/{services → core/services}/overlayBackDismiss.d.ts

@@ -7,4 +7,4 @@ export interface OverlayBackDismissAdapter {
     /** 在当前编辑器所在的页面上下文登记退场；不渲染 UI，不监听全局按键。 */
     Layer: ComponentType<OverlayBackDismissProps>;
 }
-export declare const IOverlayBackDismiss: import("../../../shared/service-contract").ServiceIdentifier<OverlayBackDismissAdapter>;
+export declare const IOverlayBackDismiss: import("../../../../shared/service-contract").ServiceIdentifier<OverlayBackDismissAdapter>;

package/types/packages/editor/src/{services → core/services}/registry.d.ts

@@ -2,5 +2,5 @@
  * 服务注册表实现已下沉到 @tau/shared/service-registry（编辑器与白板等宿主共用），
  * 此处保留原导入路径与公共 API 不变。
  */
-export { createServiceRegistry, createChildRegistry } from "../../../shared/service-registry";
-export type { ServiceRegistry, ServiceRegister, ServiceRegistration, } from "../../../shared/service-registry";
+export { createServiceRegistry, createChildRegistry } from "../../../../shared/service-registry";
+export type { ServiceRegistry, ServiceRegister, ServiceRegistration, } from "../../../../shared/service-registry";

package/types/packages/editor/src/{services → core/services}/tokens.d.ts

@@ -1,10 +1,10 @@
 import type { ThemeService } from "../theme/ThemeService";
 import type { ExtensionErrorReporter } from "./errorReporter";
 import type { EditorNotifier } from "./notifier";
-export { createServiceId, type ServiceIdentifier } from "../../../shared/service-contract";
+export { createServiceId, type ServiceIdentifier } from "../../../../shared/service-contract";
 /** 主题服务：未注册时编辑器用 DOM 默认实现（读 <html> 的 data-mode / data-theme） */
-export declare const IThemeService: import("../../../shared/service-contract").ServiceIdentifier<ThemeService>;
+export declare const IThemeService: import("../../../../shared/service-contract").ServiceIdentifier<ThemeService>;
 /** 轻提示与确认：未注册时用 @tau/ui 的 toast（宿主需挂 ToastHost）与原生 confirm */
-export declare const IEditorNotifier: import("../../../shared/service-contract").ServiceIdentifier<EditorNotifier>;
+export declare const IEditorNotifier: import("../../../../shared/service-contract").ServiceIdentifier<EditorNotifier>;
 /** 扩展运行期错误上报：未注册时写控制台 */
-export declare const IExtensionErrorReporter: import("../../../shared/service-contract").ServiceIdentifier<ExtensionErrorReporter>;
+export declare const IExtensionErrorReporter: import("../../../../shared/service-contract").ServiceIdentifier<ExtensionErrorReporter>;

package/types/packages/editor/src/{types → core/types}/custom-element.d.ts

@@ -1,6 +1,6 @@
 import type { ParagraphElement } from "./element/paragraph";
 import type { FormattedText } from "./text";
-import type { ExtensionElementMap, ExtensionInlineElementMap } from "../../api";
+import type { ExtensionElementMap, ExtensionInlineElementMap } from "../../../api";
 export interface BuiltinElementMap {
     paragraph: ParagraphElement;
 }

package/types/packages/editor/src/core/types/text.d.ts

@@ -0,0 +1 @@
+export type { FormattedText } from "../../../../markdown/src/model";