hd-garden 0.10.2 → 0.10.4

package/scripts/excalidraw.mjs

@@ -0,0 +1,372 @@
+/**
+ * Build-time export of `.excalidraw` scenes to a sibling flat SVG.
+ *
+ * Authors reference the source (`![说明](./assets/foo.excalidraw)`). Content
+ * sync calls `ensureExcalidrawSvg`, which deletes a missing or stale sibling
+ * `foo.svg` and writes a new one. The SVG is what gets published.
+ *
+ * Rendering goes through the pinned `excalidraw-image` binary (the official
+ * `@excalidraw/excalidraw` export path, fonts inlined as data URIs). One light
+ * SVG is written: `--no-background` drops the canvas plate, and scene strokes
+ * and fills stay as drawn. There is no dark twin and no Chromium step. The
+ * article bundle never loads Excalidraw. The first export downloads that
+ * binary from GitHub Releases into the user cache.
+ * `GARDEN_EXCALIDRAW_IMAGE` points at a local binary instead.
+ * `GARDEN_OFFLINE=1` refuses to download.
+ */
+import { spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const EXCALIDRAW_IMAGE_VERSION = "0.2.0";
+
+const RELEASE_BASE = `https://github.com/rickardp/excalidraw-image/releases/download/v${EXCALIDRAW_IMAGE_VERSION}`;
+
+/** @type {Record<string, { file: string, sha256: string }>} */
+const ASSETS = {
+  "darwin-arm64": {
+    file: "excalidraw-image-aarch64-apple-darwin.tar.gz",
+    sha256: "387f7ef44a75528e4c6cca9f0af4bba34e017986f34581d983bb2a96afb5d9ba",
+  },
+  "darwin-x64": {
+    file: "excalidraw-image-x86_64-apple-darwin.tar.gz",
+    sha256: "bef1198f6237123ecc7f63c1fc6a456413e5f6cc91ae4c548dc26d661066fc21",
+  },
+  "linux-arm64": {
+    file: "excalidraw-image-aarch64-unknown-linux-gnu.tar.gz",
+    sha256: "c6b222e128965568e281af96edfa437393b2ddb4e3ba360ec2b9b583f273143e",
+  },
+  "linux-x64": {
+    file: "excalidraw-image-x86_64-unknown-linux-gnu.tar.gz",
+    sha256: "6a86f5188b55aef092d9cedda786565bfdb399bb58e57a1bea26335ed8f19ac6",
+  },
+  "win32-x64": {
+    file: "excalidraw-image-x86_64-pc-windows-msvc.zip",
+    sha256: "19b387b2322d3b52f8003d2e8bea9ab5693086c5886986f86b5ac6c36009aeef",
+  },
+};
+
+const REASONS = {
+  "missing-source": "找不到 Excalidraw 源文件",
+  "export-failed": "导出 Excalidraw 失败",
+  offline: "离线构建找不到 excalidraw-image",
+  "download-failed": "下载 excalidraw-image 失败",
+  checksum: "excalidraw-image 校验和不匹配",
+  "embedded-scene": "导出的 SVG 仍包含可编辑场景",
+  "remote-asset": "导出的 SVG 引用了外部地址",
+  "not-svg": "导出结果不是 SVG",
+  "canvas-background": "导出的 SVG 仍带画布底色",
+  "unsupported-platform": "当前系统没有 excalidraw-image 预编译包",
+  "binary-missing": "GARDEN_EXCALIDRAW_IMAGE 指向的文件不存在",
+  "no-output": "导出程序没有写出 SVG",
+};
+
+const EXPORT_POLICY = "light-transparent";
+const STAMP = /<!--\s*garden-excalidraw-source:([0-9a-f]{64})(?:\s+([a-z0-9-]+))?\s*-->/u;
+const LOCK_WAIT_MS = 5 * 60 * 1000;
+
+export class ExcalidrawExportError extends Error {
+  /**
+   * @param {keyof typeof REASONS} code
+   * @param {string} message
+   * @param {string} file
+   */
+  constructor(code, message, file) {
+    super(message);
+    this.name = "ExcalidrawExportError";
+    this.code = code;
+    this.file = file;
+  }
+}
+
+/**
+ * @param {keyof typeof REASONS} code
+ * @param {string} file
+ * @param {string} [detail]
+ */
+function failExport(code, file, detail) {
+  const lead = REASONS[code];
+  if (!lead) {
+    const unknown = /** @type {never} */ (code);
+    throw new Error(`未知的 Excalidraw 错误码 ${unknown}`);
+  }
+  const tail = detail ? `（${detail}）` : "";
+  return new ExcalidrawExportError(code, `[excalidraw:${code}] ${lead} ${file}${tail}`, file);
+}
+
+/** sha256 of the `.excalidraw` bytes. Any edit changes the stamp. */
+export function sourceHash(contents) {
+  return crypto.createHash("sha256").update(contents).digest("hex");
+}
+
+/** `flow.excalidraw` → `flow.svg` beside it. The extension match is case-insensitive. */
+export function siblingSvgPath(excalidrawPath) {
+  return String(excalidrawPath).replace(/\.excalidraw$/iu, ".svg");
+}
+
+/** True for a Markdown path whose file is an `.excalidraw` source, not an `.excalidraw.svg`. */
+export function isExcalidrawPath(value) {
+  const clean = String(value ?? "").split(/[?#]/u, 1)[0];
+  return /\.excalidraw$/iu.test(clean);
+}
+
+function stampSvg(svg, hash) {
+  const stripped = svg.replace(/<!--\s*garden-excalidraw-source:[0-9a-f]{64}(?:\s+[a-z0-9-]+)?\s*-->/gu, "");
+  const at = stripped.search(/<svg[\s>]/iu);
+  if (at < 0) throw failExport("not-svg", "");
+  return `${stripped.slice(0, at)}<!-- garden-excalidraw-source:${hash} ${EXPORT_POLICY} -->${stripped.slice(at)}`;
+}
+
+/** A full-viewport `<rect>` is the exporter's canvas plate, not a scene shape. */
+function hasCanvasBackground(svg) {
+  const svgTag = /<svg\b[^>]*>/iu.exec(svg)?.[0] ?? "";
+  const attr = (tag, name) => new RegExp(`\\b${name}="([^"]*)"`, "iu").exec(tag)?.[1];
+  const width = Number(attr(svgTag, "width"));
+  const height = Number(attr(svgTag, "height"));
+  if (!(width > 0) || !(height > 0)) return false;
+  const same = (left, right) => Math.abs(left - right) < 0.01;
+  for (const match of svg.matchAll(/<rect\b[^>]*>/giu)) {
+    const tag = match[0];
+    const x = Number(attr(tag, "x") ?? 0);
+    const y = Number(attr(tag, "y") ?? 0);
+    const rectWidth = Number(attr(tag, "width"));
+    const rectHeight = Number(attr(tag, "height"));
+    if (same(x, 0) && same(y, 0) && same(rectWidth, width) && same(rectHeight, height)) return true;
+  }
+  return false;
+}
+
+/**
+ * A published figure must be a flat SVG: no embedded scene, no host the
+ * reader's browser would have to call.
+ * @param {string} svg
+ * @param {string} svgPath
+ */
+function assertFlatSvg(svg, svgPath) {
+  if (!/<svg[\s>]/iu.test(svg)) throw failExport("not-svg", svgPath);
+  if (/payload-start|application\/vnd\.excalidraw\+json/iu.test(svg)) {
+    throw failExport("embedded-scene", svgPath);
+  }
+  if (hasCanvasBackground(svg)) throw failExport("canvas-background", svgPath);
+  const urls = [...svg.matchAll(/https?:\/\/[^"')\s]+/giu)]
+    .map((match) => match[0])
+    .filter((url) => !/^https?:\/\/www\.w3\.org\//iu.test(url));
+  if (urls.length) throw failExport("remote-asset", svgPath, urls.slice(0, 3).join(" "));
+}
+
+function svgIsCurrent(svg, hash) {
+  const stamp = STAMP.exec(svg);
+  if (!stamp || stamp[1] !== hash || stamp[2] !== EXPORT_POLICY) return false;
+  try {
+    assertFlatSvg(svg, "");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function platformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function platformAsset() {
+  const asset = ASSETS[platformKey()];
+  if (!asset) {
+    throw failExport(
+      "unsupported-platform",
+      `${process.platform} ${process.arch}`,
+      "设置 GARDEN_EXCALIDRAW_IMAGE 指向本机的 excalidraw-image",
+    );
+  }
+  return asset;
+}
+
+/**
+ * @param {{ homedir?: string }} [options]
+ */
+function cachePath(options = {}) {
+  const home = options.homedir ?? os.homedir();
+  const exe = process.platform === "win32" ? "excalidraw-image.exe" : "excalidraw-image";
+  return path.join(home, ".cache", "garden", "excalidraw-image", EXCALIDRAW_IMAGE_VERSION, platformKey(), exe);
+}
+
+function sleep(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function withLock(lockDir, fn) {
+  fs.mkdirSync(path.dirname(lockDir), { recursive: true });
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  for (;;) {
+    try {
+      fs.mkdirSync(lockDir);
+      break;
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      let stale = false;
+      try {
+        stale = Date.now() - fs.statSync(lockDir).mtimeMs > LOCK_WAIT_MS;
+      } catch {
+        stale = true;
+      }
+      if (stale) {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+        continue;
+      }
+      if (Date.now() > deadline) throw failExport("download-failed", lockDir, "等待下载锁超时");
+      sleep(100);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    fs.rmSync(lockDir, { recursive: true, force: true });
+  }
+}
+
+function run(command, args, { timeout = 120_000 } = {}) {
+  return spawnSync(command, args, {
+    encoding: "utf8",
+    timeout,
+    maxBuffer: 32 * 1024 * 1024,
+    windowsHide: true,
+  });
+}
+
+function commandFailure(result, fallback) {
+  if (result.error) return result.error.message;
+  return (result.stderr || result.stdout || fallback).trim();
+}
+
+function findExportedBinary(dir) {
+  const names = new Set(["excalidraw-image", "excalidraw-image.exe"]);
+  const found = [];
+  const stack = [dir];
+  while (stack.length) {
+    const current = stack.pop();
+    if (!current) break;
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (names.has(entry.name)) found.push(full);
+    }
+  }
+  if (found.length !== 1) {
+    throw failExport("download-failed", dir, `压缩包里应有一个 excalidraw-image，实际 ${found.length} 个`);
+  }
+  return found[0];
+}
+
+/**
+ * @param {{ homedir?: string, env?: NodeJS.ProcessEnv }} options
+ */
+function installBinary(options) {
+  const asset = platformAsset();
+  const cached = cachePath(options);
+  return withLock(`${cached}.lock`, () => {
+    if (fs.existsSync(cached)) return cached;
+    const work = fs.mkdtempSync(path.join(os.tmpdir(), "garden-excalidraw-"));
+    try {
+      const archive = path.join(work, asset.file);
+      const url = `${RELEASE_BASE}/${asset.file}`;
+      console.error(`正在下载 excalidraw-image ${EXCALIDRAW_IMAGE_VERSION}（${asset.file}）…`);
+      const curl = run("curl", ["-fsSL", "--retry", "3", "--retry-delay", "2", "-o", archive, url]);
+      if (curl.status !== 0) throw failExport("download-failed", url, commandFailure(curl, "curl 失败"));
+      const got = crypto.createHash("sha256").update(fs.readFileSync(archive)).digest("hex");
+      if (got !== asset.sha256) throw failExport("checksum", asset.file, `期望 ${asset.sha256}，实际 ${got}`);
+      const unpacked = path.join(work, "unpacked");
+      fs.mkdirSync(unpacked, { recursive: true });
+      const extracted = run("tar", ["-xf", archive, "-C", unpacked]);
+      if (extracted.status !== 0) {
+        throw failExport("download-failed", archive, commandFailure(extracted, "tar 无法解压"));
+      }
+      const bin = findExportedBinary(unpacked);
+      fs.mkdirSync(path.dirname(cached), { recursive: true });
+      const partial = `${cached}.partial`;
+      fs.copyFileSync(bin, partial);
+      fs.chmodSync(partial, 0o755);
+      const version = run(partial, ["--version"]);
+      if (version.status !== 0 || !/excalidraw-image/u.test(version.stdout || "")) {
+        fs.rmSync(partial, { force: true });
+        throw failExport("download-failed", partial, commandFailure(version, "excalidraw-image --version 失败"));
+      }
+      fs.renameSync(partial, cached);
+      return cached;
+    } finally {
+      fs.rmSync(work, { recursive: true, force: true });
+    }
+  });
+}
+
+/**
+ * @param {{ homedir?: string, env?: NodeJS.ProcessEnv }} [options]
+ */
+function resolveBinary(options = {}) {
+  const env = options.env ?? process.env;
+  const override = env.GARDEN_EXCALIDRAW_IMAGE?.trim();
+  if (override) {
+    if (!fs.existsSync(override)) throw failExport("binary-missing", override);
+    return override;
+  }
+  platformAsset();
+  const cached = cachePath(options);
+  if (fs.existsSync(cached)) return cached;
+  if (env.GARDEN_OFFLINE === "1") throw failExport("offline", cached);
+  return installBinary(options);
+}
+
+let defaultBinary = "";
+
+/**
+ * @param {string} input
+ * @param {string} output
+ * @param {{ homedir?: string, env?: NodeJS.ProcessEnv }} [options]
+ */
+function renderWithBinary(input, output, options = {}) {
+  const custom = options.env !== undefined || options.homedir !== undefined;
+  const bin = !custom && defaultBinary && fs.existsSync(defaultBinary) ? defaultBinary : resolveBinary(options);
+  if (!custom) defaultBinary = bin;
+  const result = run(bin, [input, "--non-editable", "--no-background", "--format", "svg", "-o", output]);
+  if (result.status !== 0) {
+    throw failExport("export-failed", input, commandFailure(result, `退出码 ${result.status}`).slice(0, 800));
+  }
+}
+
+/**
+ * Write a current flat SVG next to `sourcePath`.
+ * A sibling SVG is reused only when it carries this source's hash and is flat.
+ * Otherwise it is deleted, then exported again. Export failure leaves no SVG.
+ *
+ * @param {string} sourcePath
+ * @param {{ render?: (input: string, output: string) => void, homedir?: string, env?: NodeJS.ProcessEnv }} [options]
+ * @returns {string} absolute path of the sibling SVG
+ */
+export function ensureExcalidrawSvg(sourcePath, options = {}) {
+  if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
+    throw failExport("missing-source", sourcePath);
+  }
+  const svgPath = siblingSvgPath(sourcePath);
+  if (svgPath === sourcePath) throw failExport("not-svg", sourcePath, "无法把源文件路径换成 .svg");
+  const hash = sourceHash(fs.readFileSync(sourcePath));
+  if (fs.existsSync(svgPath)) {
+    const current = fs.readFileSync(svgPath, "utf8");
+    if (svgIsCurrent(current, hash)) return svgPath;
+    fs.rmSync(svgPath, { force: true });
+  }
+  const render = options.render ?? ((input, output) => renderWithBinary(input, output, options));
+  try {
+    render(sourcePath, svgPath);
+    if (!fs.existsSync(svgPath) || !fs.statSync(svgPath).isFile()) throw failExport("no-output", svgPath);
+    const raw = fs.readFileSync(svgPath, "utf8");
+    assertFlatSvg(raw, svgPath);
+    fs.writeFileSync(svgPath, stampSvg(raw, hash));
+  } catch (error) {
+    fs.rmSync(svgPath, { force: true });
+    if (error instanceof ExcalidrawExportError) throw error;
+    const reason = error instanceof Error ? error.message : String(error);
+    throw failExport("export-failed", sourcePath, reason);
+  }
+  return svgPath;
+}

package/scripts/pack-editors.mjs

@@ -0,0 +1,241 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import zlib from "node:zlib";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const distDir = path.join(root, "editors", "dist");
+const lockDir = path.join(root, "editors", ".pack-lock");
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function distReady() {
+  const vsixDir = path.join(distDir, "vscode");
+  const manifest = path.join(distDir, "typora", "manifest.json");
+  if (!fs.existsSync(manifest) || !fs.existsSync(vsixDir)) return false;
+  return fs.readdirSync(vsixDir).some((name) => name.endsWith(".vsix"));
+}
+
+function withPackLock(fn) {
+  const started = Date.now();
+  for (;;) {
+    try {
+      fs.mkdirSync(lockDir);
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (Date.now() - started > 180_000) {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+        continue;
+      }
+      sleepSync(200);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    fs.rmSync(lockDir, { recursive: true, force: true });
+  }
+}
+
+function runBuild(script) {
+  const result = spawnSync(process.execPath, [script], { cwd: root, stdio: "inherit" });
+  if (result.status !== 0) process.exit(result.status || 1);
+}
+
+function xmlEscape(value) {
+  return String(value)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+
+function dosDate(date) {
+  const time = (date.getHours() << 11) | (date.getMinutes() << 5) | (date.getSeconds() >> 1);
+  const day = ((date.getFullYear() - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate();
+  return { time, day };
+}
+
+/** Store-method ZIP. VSIX is a ZIP with a manifest at the archive root. */
+function zipStore(entries) {
+  const { time, day } = dosDate(new Date());
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const name = Buffer.from(entry.name, "utf8");
+    const data = entry.data;
+    const crc = zlib.crc32(data);
+    const local = Buffer.alloc(30 + name.length);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0x0800, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(time, 10);
+    local.writeUInt16LE(day, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(data.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+    name.copy(local, 30);
+    locals.push(local, data);
+
+    const central = Buffer.alloc(46 + name.length);
+    central.writeUInt32LE(0x02014b50, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0x0800, 8);
+    central.writeUInt16LE(0, 10);
+    central.writeUInt16LE(time, 12);
+    central.writeUInt16LE(day, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(data.length, 20);
+    central.writeUInt32LE(data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    name.copy(central, 46);
+    centrals.push(central);
+    offset += local.length + data.length;
+  }
+  const centralDirectory = Buffer.concat(centrals);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(entries.length, 8);
+  end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(centralDirectory.length, 12);
+  end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...locals, centralDirectory, end]);
+}
+
+function addTree(entries, directory, prefix) {
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    const absolute = path.join(directory, entry.name);
+    const name = `${prefix}/${entry.name}`;
+    if (entry.isDirectory()) addTree(entries, absolute, name);
+    else if (entry.isFile()) entries.push({ name, data: fs.readFileSync(absolute) });
+  }
+}
+
+function contentTypes(entries) {
+  const defaults = new Map([
+    [".json", "application/json"],
+    [".js", "application/javascript"],
+    [".css", "text/css"],
+    [".md", "text/markdown"],
+    [".txt", "text/plain"],
+    [".vsixmanifest", "text/xml"],
+    [".xml", "text/xml"],
+    [".svg", "image/svg+xml"],
+    [".png", "image/png"],
+  ]);
+  const lines = [
+    `<?xml version="1.0" encoding="utf-8"?>`,
+    `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">`,
+  ];
+  const used = new Set(entries.map((entry) => path.posix.extname(entry.name).toLowerCase()));
+  used.add(".vsixmanifest");
+  used.add(".xml");
+  for (const [extension, type] of defaults) {
+    if (used.has(extension)) {
+      lines.push(`  <Default Extension="${extension.slice(1)}" ContentType="${type}"/>`);
+    }
+  }
+  if (entries.some((entry) => entry.name === "extension/LICENSE")) {
+    lines.push(`  <Override PartName="/extension/LICENSE" ContentType="text/plain"/>`);
+  }
+  lines.push(`</Types>`, ``);
+  return lines.join("\n");
+}
+
+function vsixManifest(manifest) {
+  const tags = (manifest.keywords ?? []).join(",");
+  const categories = (manifest.categories ?? []).join(",");
+  return `<?xml version="1.0" encoding="utf-8"?>
+<PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
+  <Metadata>
+    <Identity Language="en-US" Id="${xmlEscape(manifest.name)}" Version="${xmlEscape(manifest.version)}" Publisher="${xmlEscape(manifest.publisher)}"/>
+    <DisplayName>${xmlEscape(manifest.displayName)}</DisplayName>
+    <Description xml:space="preserve">${xmlEscape(manifest.description)}</Description>
+    <Tags>${xmlEscape(tags)}</Tags>
+    <Categories>${xmlEscape(categories)}</Categories>
+    <GalleryFlags>Public</GalleryFlags>
+    <Properties>
+      <Property Id="Microsoft.VisualStudio.Code.Engine" Value="${xmlEscape(manifest.engines.vscode)}"/>
+      <Property Id="Microsoft.VisualStudio.Code.ExtensionKind" Value="workspace"/>
+    </Properties>
+  </Metadata>
+  <Installation>
+    <InstallationTarget Id="Microsoft.VisualStudio.Code"/>
+  </Installation>
+  <Dependencies/>
+  <Assets>
+    <Asset Type="Microsoft.VisualStudio.Code.Manifest" Path="extension/package.json" Addressable="true"/>
+  </Assets>
+</PackageManifest>
+`;
+}
+
+function packageVsix() {
+  const source = path.join(root, "editors", "vscode");
+  const manifest = JSON.parse(fs.readFileSync(path.join(source, "package.json"), "utf8"));
+  const entries = [];
+  const license = path.join(root, "LICENSE");
+  if (fs.existsSync(license)) entries.push({ name: "extension/LICENSE", data: fs.readFileSync(license) });
+  entries.push({ name: "extension/package.json", data: fs.readFileSync(path.join(source, "package.json")) });
+  entries.push({ name: "extension/README.md", data: fs.readFileSync(path.join(source, "README.md")) });
+  addTree(entries, path.join(source, "dist"), "extension/dist");
+  addTree(entries, path.join(source, "snippets"), "extension/snippets");
+  addTree(entries, path.join(source, "syntaxes"), "extension/syntaxes");
+  entries.unshift(
+    { name: "[Content_Types].xml", data: Buffer.from(contentTypes(entries)) },
+    { name: "extension.vsixmanifest", data: Buffer.from(vsixManifest(manifest)) },
+  );
+  const destination = path.join(distDir, "vscode");
+  fs.mkdirSync(destination, { recursive: true });
+  const filename = `${manifest.name}-${manifest.version}.vsix`;
+  fs.writeFileSync(path.join(destination, filename), zipStore(entries));
+  return filename;
+}
+
+function packageTypora() {
+  const from = path.join(root, "editors", "typora", "dist");
+  const to = path.join(distDir, "typora");
+  fs.rmSync(to, { recursive: true, force: true });
+  fs.cpSync(from, to, { recursive: true });
+}
+
+function buildArtifacts() {
+  runBuild(path.join(root, "editors", "vscode", "build.mjs"));
+  runBuild(path.join(root, "editors", "typora", "build.mjs"));
+  fs.rmSync(distDir, { recursive: true, force: true });
+  fs.mkdirSync(distDir, { recursive: true });
+  const vsix = packageVsix();
+  packageTypora();
+  process.stdout.write(`编辑器插件已打包：editors/dist/vscode/${vsix}、editors/dist/typora/\n`);
+}
+
+/**
+ * Builds the VS Code VSIX and Typora plugin into `editors/dist/` when they are missing.
+ * `npm pack` calls this with `force` so the published tarball is freshly built.
+ */
+export function packEditors({ force = false } = {}) {
+  if (!force && distReady()) return distDir;
+  return withPackLock(() => {
+    if (!force && distReady()) return distDir;
+    buildArtifacts();
+    return distDir;
+  });
+}
+
+const invokedDirectly = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (invokedDirectly) packEditors({ force: true });

package/templates/site/README.en.md

@@ -10,6 +10,8 @@ make dev
 
 Running `npx garden dev` for the first time fills in any missing `Makefile` or skills and creates `.env.local`. Cursor and Codex read `.agents/skills/` automatically when opening this repository. Run `npx garden skill` anytime to update the bundled skills.
 
+`npx hd-garden init` copies the VS Code / Cursor and Typora Intelligent UI plugins into `.garden/editors/` and asks whether to install them when the terminal is interactive. Run `npx garden editors install` later (`--yes` installs both, `--vscode` or `--typora` installs one). Typora needs typora-community-plugin first; then enable the plugin under Settings, Installed plugins. Use the plugins to insert a plain `garden` brief for the `garden-ui` skill to compile, preview a component, and open the catalog. In Typora, type `/` and choose `/garden` to list each component with a small preview image. Hand `Compile this post:` to the skill when you want it compiled.
+
 Comments are disabled by default. Before publishing, open [Giscus](https://giscus.app), write the repository, repository ID, category, and category ID into `.env.local`, and set the matching `GISCUS_REPO`, `GISCUS_REPO_ID`, `GISCUS_CATEGORY`, and `GISCUS_CATEGORY_ID` under GitHub Actions Variables. Leaving them empty fails the publish workflow. To publish without comments, set `GISCUS_DISABLED` to `1`.
 
 To upgrade the engine, update `hd-garden` in `package.json` to the new version and run `npm install`.

package/templates/site/README.md

@@ -10,6 +10,8 @@ make dev
 
 第一次 `npx garden dev` 会补齐 Makefile 和 skill，并创建 `.env.local`。Cursor / Codex 打开这个仓库后会读到 `.agents/skills/`。要更新 skill，再运行 `npx garden skill`。
 
+`npx hd-garden init` 会把 VS Code / Cursor 与 Typora 的 Intelligent UI 插件放到 `.garden/editors/`，并在交互终端里询问要不要安装。之后可以运行 `npx garden editors install`（加 `--yes` 则直接安装，`--vscode` / `--typora` 只装一个）。Typora 需要先装 typora-community-plugin，再在「设置 → 已安装插件」里勾选。插件用来插入想法（一段给 `garden-ui` skill 编译的 `garden` 围栏，不是写好的 YAML）、预览组件、打开清单，并把「编译这篇」交给 skill。Typora 里输入 `/` 选 `/garden`，再从带小预览图的列表里选。
+
 评论默认关闭。发布前打开 [Giscus](https://giscus.app/zh-CN)，把仓库、仓库 ID、分类、分类 ID 写入 `.env.local`，并在 GitHub Actions Variables 设置同名的 `GISCUS_REPO`、`GISCUS_REPO_ID`、`GISCUS_CATEGORY`、`GISCUS_CATEGORY_ID`。留空会让发布失败。确定不开放评论时，把 `GISCUS_DISABLED` 设为 `1`。
 
 升级引擎：把 `package.json` 里的 `hd-garden` 改到新版本，例如 `^0.4.0`，再运行 `npm install`。

package/ui/core/transform.mjs

@@ -86,9 +86,17 @@ const absolute = (src, siteUrl) => (src && siteUrl && src.startsWith("/") ? `${s
 const escapeHtml = (value) =>
   String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 
+/** Text a reader can select inside an inlined Excalidraw SVG; path data and fonts stay out of search. */
+function excalidrawVisibleText(svg) {
+  const parts = [];
+  for (const match of svg.matchAll(/<(?:text|title)\b[^>]*>([^<]*)<\/(?:text|title)>/giu)) parts.push(match[1]);
+  return parts.join(" ");
+}
+
 /** Readable text for search and word count: captions and snapshot text, never intent. */
 export function contentToSearchText(content) {
-  return replaceFences(stripCardMarkers(content), (fence) => {
+  const withoutDiagramMarkup = String(content ?? "").replace(/<svg\b[^>]*class="[^"]*\bexcalidraw\b[^"]*"[\s\S]*?<\/svg>/giu, (svg) => ` ${excalidrawVisibleText(svg)} `);
+  return replaceFences(stripCardMarkers(withoutDiagramMarkup), (fence) => {
     if (fence.lang === "ui") {
       const payload = readPayload(fence.body);
       if (!payload) return " ";