@akairos/pipeline 0.18.1 → 0.19.0

package/ARTICLE-THEMES.md

@@ -24,6 +24,8 @@ zzp publish --state ./workflow-state.json --article-theme ./my-template
 
 账号默认使用 `wx.accounts.<account>.articleTheme`，相对路径以配置文件所在目录为基准。显式 `--article-theme` 优先，路径相对当前目录；handoff 支持同义的可选 `article_theme` 字段。没有选择正文模板时保持既有配置。封面仍使用 `--cover-theme`。
 
+WeChat Visual Studio 的「导出配置」下载独立 `wechat-style.json`，同样通过 `--article-theme` 选择。文件含内嵌 `css`、`editorVars`、`exportTheme`、`syntaxPresets` 和 `structure`；页首图片以内嵌 Data URL 保存。不含账号凭据，不需要附带目录包文件。独立 JSON 使用自身样式，不叠加账号 `theme/customCss`，显式 `wechat-export --custom-css` 仍可覆盖。可用 `article-theme --path` 校验或安装；默认配置引用后由现有 `typeset-assets-sync` 收集部署，详见 [Studio 配置指南](docs/visual-studio-and-config-sync.md)。
+
 模板样式叠加在现有基础样式上，既有账号 `theme` 覆盖和 `customCss` 最后生效。新版正文模板默认不附带内置账号署名，用户自己配置的 footerText 仍保留。旧 Markdown 插件接收可选 `articleThemePath`，可以继续忽略该字段；要支持付费模板预览，应使用内置渲染器或实现该可选参数。桌面端预览同样调用当前已配置的渲染插件。
 
 发布前冻结模板版本、CSS 和资源到工作区 `.zzhub-media/article-themes`；渲染结果记录 `article_theme_hash`。同一篇文章更改模板、版本或声明素材后会重新导出。旧状态不含该字段时仍可使用。

package/README.md

@@ -56,7 +56,7 @@ Pipeline 需要 [Bun](https://bun.sh/) 运行。npm 可以安装包，但命令
 npm install -g @akairos/pipeline
 
 # 或从源码运行
-git clone https://github.com/aatrooox/zzhub-pipeline.git
+git clone https://github.com/k7airos/zzhub-pipeline.git
 cd zzhub-pipeline
 bun install
 bun run src/cli.ts --help
@@ -160,7 +160,7 @@ Pipeline 在创建和更新草稿时，会自动读取封面图真实尺寸，
 | **`@akairos/milkdown-article-plugins`** | Remark / Milkdown 全语法自定义解析与渲染插件 |
 | **`@akairos/typeset-studio`** | 微信大图头图、多比例排版与卡片视觉合成引擎 |
 
-配置在 `plugins.imageRenderer` / `plugins.markdownRenderer` 的外部插件在独立 Bun 子进程中加载和执行。加载与 doctor 默认上限为 10 秒，渲染为 120 秒；Markdown 渲染显式传入 `timeoutMs` 时，子进程上限额外预留 10 秒。可通过 `ZZHUB_PIPELINE_PLUGIN_TIMEOUT_MS` 覆盖调用上限。同步死循环、超时和异常退出会终止插件进程，非法返回值会给出 `PLUGIN_*` 错误，命令不会自动重试或静默切换模板。
+配置在 `plugins.imageRenderer` / `plugins.markdownRenderer` 的外部插件在独立 Bun 子进程中加载，插件的 `render`、`doctor`、`browser` 和 `studio` 方法也在子进程调用。加载、资源入口查询与 doctor 默认上限为 10 秒，`render` 为 120 秒；Markdown 渲染显式传入 `timeoutMs` 时，子进程上限额外预留 10 秒。可通过 `ZZHUB_PIPELINE_PLUGIN_TIMEOUT_MS` 覆盖子进程调用上限。同步死循环、超时和异常退出会终止插件进程，非法返回值会给出 `PLUGIN_*` 错误，命令不会自动重试或静默切换模板。浏览器型插件返回入口后，由 pipeline 现有 Chrome 运行时加载页面，并按渲染 `timeoutMs` 管理浏览器生命周期。
 
 图片渲染失败后任务进入失败状态，保留正文与审核结果。修复插件后执行 `zzp reset --state <state_path> --mode render`，再继续任务；也可以将对应的 `plugins.*Renderer` 配置设为 `null` 使用内置渲染器。外部插件通过 `onProgress` 回传进度，不应依赖修改输入对象或跨调用保存内存状态。子进程继承当前环境和文件权限，这一机制负责故障隔离，不是权限沙箱。
 
@@ -170,6 +170,27 @@ Pipeline 在创建和更新草稿时，会自动读取封面图真实尺寸，
 
 旧的字符串入口继续有效，等同于没有配置专属参数；`null` 使用内置渲染器。`zzp config --import` 中的渲染器条目整体替换原条目，只改一个参数时使用 `--key plugins.imageRenderer.options.<参数名>`。
 
+### myno 排版插件
+
+myno 通过可选的 Markdown 渲染插件接入。从 pipeline 0.19.0 起可选依赖固定为 `@akairos/myno@0.3.0`，仍需在配置中显式启用；使用 `--omit optional` 安装时需自行提供插件。npm 配置示例：
+
+```json
+{
+  "plugins": {
+    "markdownRenderer": {
+      "module": "@akairos/myno/adapter",
+      "options": {}
+    }
+  }
+}
+```
+
+本地开发时可先在 myno 仓库执行 `bun run build`，将 `module` 指向构建后的 `dist/adapter.js` 绝对路径。运行时部署包只接受 npm 入口和空 `options`，不会复制本机插件路径。
+
+插件可以实现原有的 `render(input, options)`，也可以像 myno 一样只实现 `browser(options)`，返回浏览器排版入口的绝对路径 `{ scriptPath }`。`wechat-export` 和公众号文章发布通过同一个插件加载器调度；浏览器型插件复用 pipeline 现有的 Chrome、超时清理、离线模板校验和文件输出，仅页面排版实现来自插件。myno 不增加浏览器自动化依赖，调样式和导出 config 也不需要启动无头浏览器。独立样式仍与发布账号分离。
+
+Markdown 插件可选提供 `studio(options)`，返回绝对资源目录 `root` 和该目录内的 HTML 相对路径 `entry`。`zzp wechat-preview studio` 将插件页面挂到 `/studio`，脚本和样式挂到 `/studio-assets/`；`/api/studio/config`、`/api/studio/save-config` 和历史记录继续由 pipeline 提供。插件不支持 Studio 时返回明确提示；配置为 `null` 保留内置工作台。切换插件后需重启已运行的预览服务。
+
 ### Typeset Studio 插件配置
 
 Pipeline 已通过 npm 依赖 `@akairos/typeset-studio`。在本地配置文件启用适配器，并指定与 Studio 编辑器共用的数据目录：
@@ -212,6 +233,8 @@ zzp typeset-assets-sync --output ./pipeline-runtime --account-map '{"default":"W
 
 配置包只包含插件入口、Studio 容器路径和账号主题/CSS/文章模板路径，不包含微信凭据、COS PAT 或 Worker token。账号的 `customCss`、`articleTheme` 为 null 时会清除服务器旧引用。服务器用 `nezus-infra` 的 `sync pipeline-runtime` 命令校验文件清单、合并排版白名单并备份切换；镜像与 npm 依赖继续固定版本部署。
 
+WeChat Visual Studio 可通过「导出配置」下载不绑定账号的独立排版 JSON。CLI 用 `--article-theme ./wechat-style.json` 选择；在默认配置的账号 `articleTheme` 中引用后，也会由上述运行时包收集部署。文件内嵌 CSS 与页首图片，无需附带模板目录。详见 [Studio 独立配置与部署](docs/visual-studio-and-config-sync.md)。
+
 ### 推进一个发布任务
 
 Pipeline 每次只推进一个动作。创建任务后，反复执行 `status`，按照返回的 `next_action` 继续；不要直接修改 `workflow-state.json`。
@@ -245,7 +268,7 @@ zzp publish --state <state_path>
 
 实际顺序以 `status --view agent` 为准。需要发布贴图时，把 `--content-form` 改为 `newspic`；多页图片可以在渲染前附加 `newspic` 规格。
 
-如果正文由 Agent 生成或审核，可以直接使用仓库里的 [`zzhub-publish` Skill](skills/zzhub-publish/SKILL.md)。Skill 只负责编排 Agent，文章正文仍由调用方提供。
+如果正文由 Agent 生成或审核，可以使用配套的 [kairos-skills](https://github.com/k7airos/kairos-skills) 仓库中的 [`zzhub-publish` Skill](https://github.com/k7airos/kairos-skills/tree/main/skills/zzhub-publish/SKILL.md)。Skill 负责编排 Agent 状态机，文章正文仍由调用方提供。
 
 ## 云端 Worker
 
@@ -375,7 +398,7 @@ zzp monitor stop
 - [云端 Worker API、部署与更新](services/cloud-worker/README.md)
 - [封面主题和图片排版](docs/render-themes.md)
 - [离线正文模板](ARTICLE-THEMES.md)
-- [Agent 发布 Skill](skills/zzhub-publish/SKILL.md)
+- [Kairos Agent Skills 仓库](https://github.com/k7airos/kairos-skills)：配套的 Agent 技能集合（包含 `zzhub-publish` 状态机编排、`milkdown-writing` 写作排版规范、`auto-ai-daily` 自动化发文）
 - [第三方声明](THIRD-PARTY-NOTICES.md)
 
 ## 开发与验证

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akairos/pipeline",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "type": "module",
   "license": "MIT",
   "bin": {
@@ -27,20 +27,22 @@
     "release:major": "changelogen --release --major --push"
   },
   "dependencies": {
-    "@akairos/milkdown-article-plugins": "^0.1.3",
-    "@akairos/milkdown-article-style": "^0.1.1",
-    "@akairos/typeset-studio": "0.2.5",
+    "@akairos/milkdown-article-plugins": "^0.1.6",
+    "@akairos/milkdown-article-style": "^0.1.2",
+    "@akairos/typeset-studio": "0.2.6",
     "@chenglou/pretext": "0.0.8",
     "image-size": "^2.0.2",
     "pngjs": "^7.0.0",
     "zod": "^4.4.2"
   },
   "optionalDependencies": {
+    "@akairos/myno": "0.3.0",
     "@napi-rs/canvas": "^0.1.97",
     "cos-nodejs-sdk-v5": "^2.15.4"
   },
   "devDependencies": {
-    "@milkdown/kit": "^7.18.0",
+    "@milkdown/crepe": "^7.21.2",
+    "@milkdown/kit": "^7.21.2",
     "@types/bun": "latest",
     "@types/pngjs": "^6.0.5",
     "changelogen": "^0.6.2",

package/src/adapter-loader.ts

@@ -15,7 +15,10 @@ import type {
 } from "./adapter-types";
 import { builtinImageRenderer } from "./adapters/builtin-image-renderer";
 import { builtinMarkdownRenderer } from "./adapters/builtin-markdown-renderer";
-import { PluginDoctorSchema, PluginImageOutputSchema, PluginMarkdownOutputSchema, PluginMetadataSchema, runExternalPlugin } from "./plugin-runtime";
+import { PluginBrowserSchema, PluginDoctorSchema, PluginImageOutputSchema, PluginMarkdownOutputSchema, PluginMetadataSchema, PluginStudioSchema, runExternalPlugin } from "./plugin-runtime";
+import { exportMarkdownToWechatHtml } from "./wechat-preview";
+import { notifyProgress } from "./monitor/recorder";
+import { findChrome } from "./imgx/runtime";
 
 // ── Public API ───────────────────────────────────────────────────
 
@@ -75,9 +78,26 @@ export async function resolveMarkdownRenderer(
     return {
       name: metadata.name,
       version: metadata.version,
-      ...(metadata.hasDoctor ? { doctor: () => runExternalPlugin(pluginPath, "doctor", PluginDoctorSchema, undefined, { options }) } : {}),
-      render: ({ onProgress, ...input }) => runExternalPlugin(pluginPath, "render", PluginMarkdownOutputSchema, input, { options }, onProgress,
-        input.timeoutMs && Number.isFinite(input.timeoutMs) && input.timeoutMs > 0 ? input.timeoutMs + 10_000 : 120_000),
+      ...(metadata.hasDoctor || metadata.hasBrowser ? { doctor: async () => {
+        const checks = metadata.hasDoctor ? await runExternalPlugin(pluginPath, "doctor", PluginDoctorSchema, undefined, { options }) : [];
+        if (metadata.hasBrowser) {
+          const chrome = findChrome();
+          checks.push({ name: "chrome", ok: Boolean(chrome), message: chrome ?? "Chrome/Chromium not found" });
+        }
+        return checks;
+      } } : {}),
+      ...(metadata.hasStudio ? { studio: () => runExternalPlugin(pluginPath, "studio", PluginStudioSchema, undefined, { options }) } : {}),
+      render: async ({ onProgress, ...input }) => {
+        if (metadata.hasBrowser) {
+          const browser = await runExternalPlugin(pluginPath, "browser", PluginBrowserSchema, undefined, { options });
+          notifyProgress(onProgress, { stage: "render.html", message: "正在导出微信 HTML" });
+          const result = await exportMarkdownToWechatHtml({ ...input, browserScriptPath: browser.scriptPath });
+          notifyProgress(onProgress, { stage: "render.html", message: "微信 HTML 导出完成", current: 1, total: 1, unit: "files" });
+          return result;
+        }
+        return runExternalPlugin(pluginPath, "render", PluginMarkdownOutputSchema, input, { options }, onProgress,
+          input.timeoutMs && Number.isFinite(input.timeoutMs) && input.timeoutMs > 0 ? input.timeoutMs + 10_000 : 120_000);
+      },
     };
   }
 

package/src/adapter-types.ts

@@ -207,7 +207,21 @@ export interface MarkdownRenderPlugin {
   /** Environment checks */
   doctor?: (options?: Record<string, unknown>) => Promise<PipelinePluginDoctorCheck[]>;
 
+  /** 工作台静态资源由插件分发，配置读写仍由宿主提供。 */
+  studio?: (options?: Record<string, unknown>) => Promise<MarkdownStudioAssets>;
+
   /** Render markdown to WeChat-compatible HTML */
   /** 专属配置作为第二个参数传入，旧插件可忽略。 */
   render: (input: MarkdownRenderInput, options?: Record<string, unknown>) => Promise<MarkdownRenderOutput>;
 }
+
+/** root 是插件资源目录，entry 是该目录内的 HTML 相对路径。 */
+export interface MarkdownStudioAssets {
+  root: string;
+  entry: string;
+}
+
+/** 仅提供浏览器排版资源的插件，Chrome 生命周期由 pipeline 管理。 */
+export interface BrowserMarkdownRenderPlugin extends Omit<MarkdownRenderPlugin, "render"> {
+  browser: (options?: Record<string, unknown>) => Promise<{ scriptPath: string }>;
+}

package/src/article-theme.test.ts

@@ -4,6 +4,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { readArticleTheme, snapshotArticleTheme } from "./article-theme";
 import { filterIdempotent } from "./providers/publish-core";
+import { resolveWechatArticleTheme } from "./wechat-preview";
+import { prepareMarkdownRuntime, RUNTIME_ROOT } from "./runtime-package";
+import { PipelineConfigSchema } from "./schema/config";
 
 const roots: string[] = [];
 afterEach(async () => { for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true }); });
@@ -53,6 +56,58 @@ test("越界、符号链接、网络样式与不兼容版本不能导入", async
   }
 });
 
+test("Studio 单文件配置可跨账号复用、冻结及沿用运行时配置包部署", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zzp-studio-config-"));
+  roots.push(root);
+  const path = join(root, "my-style.json");
+  const profile = {
+    schemaVersion: 1, engineVersion: 1, id: "wechat-style", name: "独立排版", version: "1.0.0",
+    editorVars: { "--brand": "#123456" },
+    exportTheme: { bodyFontSize: "18px", footerText: "", primaryColor: "#123456" },
+    syntaxPresets: { h2: "contrast-green" },
+    structure: { numberedHeadings: true, headingLabel: "章节", calloutPresets: { tip: { title: "建议" } }, headerImageUrl: "data:image/png;base64,aW1hZ2U=" },
+    css: "p { color: #123456; }",
+  };
+  await writeFile(path, JSON.stringify(profile));
+  const theme = await readArticleTheme(path);
+  expect(theme.files.size).toBe(1);
+  expect(theme.css).toBe(profile.css);
+  const accountOverrides = { editorVars: { "--brand": "#ff0000" }, exportTheme: { bodyFontSize: "14px" }, syntaxPresets: { h2: "pillar" } };
+  const first = resolveWechatArticleTheme("default", accountOverrides, theme);
+  const other = resolveWechatArticleTheme("ancientone", accountOverrides, theme);
+  expect(first).toEqual(other);
+  expect(first.theme.exportTheme.bodyFontSize).toBe("18px");
+  expect(first.syntaxPresets).toEqual(profile.syntaxPresets);
+  expect(first.structure?.headerImageUrl).toBe(profile.structure.headerImageUrl);
+  expect(first.structure?.calloutPresets).toEqual(profile.structure.calloutPresets);
+  const frozen = await snapshotArticleTheme(theme, join(root, "frozen"));
+  expect((await readArticleTheme(frozen.path)).hash).toBe(theme.hash);
+
+  const config = PipelineConfigSchema.parse({ wx: { accounts: { default: { articleTheme: path, customCss: join(root, "missing.css"), pat: "secret" } } } });
+  const deployed = await prepareMarkdownRuntime(config);
+  const manifest = "markdown/article-themes/default/manifest.json";
+  expect(deployed.accounts.default).toMatchObject({ articleTheme: `${RUNTIME_ROOT}/${manifest}`, customCss: null });
+  expect(JSON.stringify(deployed.accounts)).not.toContain("secret");
+  expect(JSON.parse(new TextDecoder().decode(deployed.files.get(manifest))).css).toBe(profile.css);
+  await writeFile(path, JSON.stringify({ ...profile, css: "p { color: blue; }" }));
+  expect((await readArticleTheme(path)).hash).not.toBe(theme.hash);
+});
+
+test("独立配置拒绝凭据、外部素材与不安全 CSS", async () => {
+  const root = await mkdtemp(join(tmpdir(), "zzp-studio-invalid-"));
+  roots.push(root);
+  const path = join(root, "style.json");
+  const profile = { schemaVersion: 1, engineVersion: 1, id: "style", name: "Style", version: "1.0.0", css: "" };
+  for (const patch of [
+    { account: "default" }, { pat: "secret" }, { assets: ["asset.png"] },
+    { css: "p { background: url(file:///secret); }" },
+    { structure: { headerImageUrl: "file:///secret" } },
+  ]) {
+    await writeFile(path, JSON.stringify({ ...profile, ...patch }));
+    await expect(readArticleTheme(path)).rejects.toThrow();
+  }
+});
+
 test("结果未知阻止普通重发，明确重置才建立新发布尝试", async () => {
   const { root } = await fixture();
   const { defaultState, readState, writeState } = await import("./state");

package/src/article-theme.ts

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { lstat, mkdir, mkdtemp, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
+import { WechatStructureOverridesSchema } from "./schema/config";
 
 /** 模板只包含声明、CSS 与素材，不执行客户包中的脚本。 */
 export const ArticleThemeSchema = z.object({
@@ -18,11 +19,16 @@ export const ArticleThemeSchema = z.object({
   assets: z.array(z.string()).max(100).default([]),
   editorVars: z.record(z.string(), z.string()).default({}),
   exportTheme: z.record(z.string(), z.string()).default({}),
+  /** Studio 独立配置内嵌 CSS，无需附带模板目录。 */
+  css: z.string().max(256_000).optional(),
+  syntaxPresets: z.record(z.string(), z.string()).optional(),
   structure: z.object({
     numberedHeadings: z.boolean().default(false),
     headingLabel: z.string().max(30).default(""),
     quoteLabel: z.string().max(30).default(""),
     headerImage: z.string().nullable().default(null),
+    headerImageUrl: z.string().regex(/^data:image\/(?:png|jpeg|gif|webp);base64,[A-Za-z0-9+/]+={0,2}$/).nullable().optional(),
+    calloutPresets: WechatStructureOverridesSchema.shape.calloutPresets,
   }).default({ numberedHeadings: false, headingLabel: "", quoteLabel: "", headerImage: null }),
 }).strict();
 
@@ -64,10 +70,12 @@ export async function readArticleTheme(inputPath: string): Promise<ArticleThemeP
   }
   const manifestName = basename(manifestPath);
   const manifest = ArticleThemeSchema.parse(JSON.parse(new TextDecoder().decode(await read(manifestName))));
-  const paths = [manifest.stylesheet, manifest.sample, manifest.preview, manifest.license, ...manifest.assets];
+  const standalone = manifest.css !== undefined;
+  if (standalone && (manifest.assets.length || manifest.structure.headerImage)) throw new Error("独立排版配置必须内嵌素材，不能引用模板目录文件");
+  const paths = standalone ? [] : [manifest.stylesheet, manifest.sample, manifest.preview, manifest.license, ...manifest.assets];
   if (manifest.structure.headerImage) paths.push(manifest.structure.headerImage);
   for (const name of new Set(paths)) await read(name);
-  const css = new TextDecoder().decode(files.get(manifest.stylesheet));
+  const css = manifest.css ?? new TextDecoder().decode(files.get(manifest.stylesheet));
   // 模板无需 CSS 转义；拒绝用转义或注释隐藏的网络/文件资源。
   const unsafeCss = (value: string) => /\\|@import\b|url\s*\(|expression\s*\(/i.test(value.replace(/\/\*[\s\S]*?\*\//g, ""));
   if (Object.keys(manifest.editorVars).some(key => !/^--[a-zA-Z0-9_-]+$/.test(key))) throw new Error("模板变量名无效");

package/src/commands/article-theme.ts

@@ -6,7 +6,7 @@ import { printResult } from "../output";
 export async function articleTheme(args: string[]): Promise<void> {
   const parsed = parseArgs(args);
   if (parsed.help) {
-    console.log("Usage: zzp article-theme --path <模板目录或 manifest.json> [--install <本地模板库>]\n只校验或复制模板，不联网、不发布。");
+    console.log("Usage: zzp article-theme --path <Studio 独立 JSON、模板目录或 manifest.json> [--install <本地模板库>]\n只校验或复制模板，不联网、不发布。");
     return;
   }
   let theme = await readArticleTheme(requireArg(parsed, "path", "template path"));

package/src/commands/init.ts

@@ -64,6 +64,7 @@ Options:
   --newspic-render-spec-file  JSON file for newspic pagination / page-image intent (optional)
   --style-hint       e.g. fact_report (optional)
   --cover-theme      Cover theme ID (optional)
+  --article-theme    Standalone Studio JSON or local article theme package (optional)
   --requires-research  Flag
   --requires-style     Flag
   --requires-render    Flag
@@ -140,6 +141,7 @@ Options:
     explicit_constraints: [],
     style_hint: styleHint,
     cover_theme: coverTheme,
+    article_theme: optionalArg(parsed, "article-theme") ? resolve(optionalArg(parsed, "article-theme")!) : null,
     newspic_render: newspicRender,
     ...(newspicFile ? { newspic_file: resolve(newspicFile) } : {}),
     requires: {

package/src/commands/publish.ts

@@ -47,7 +47,7 @@ Usage: zzhub-pipeline publish [options]
 Options:
   --state      Path to state JSON (required)
   --route      Only publish this route (optional; default: all targets)
-  --article-theme    Local article theme package (optional)
+  --article-theme    Standalone Studio JSON or local article theme package (optional)
   --dry-run    Print commands without executing (optional)
 `.trim());
     return;

package/src/commands/typeset-assets-sync.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { PNG } from "pngjs";
 import { createTypesetAssetsSyncCommand } from "./typeset-assets-sync";
 import type { uploadFileToCos } from "../providers/cos";
+import { readArticleTheme } from "../article-theme";
 
 let root: string;
 let previousConfig: string | undefined;
@@ -60,6 +61,13 @@ test("dry-run reads only referenced images and never uploads, verifies URLs, or
 
 test("deduplicates shared images, rewrites only sources, and exports styles without credentials", async () => {
   await writeFile(join(root, "templates/shared.json"), JSON.stringify({ ...template, id: "shared" }));
+  const style = { schemaVersion: 1, engineVersion: 1, id: "style", name: "Style", version: "1.0.0", css: "p { color: #123456; }", exportTheme: { bodyFontSize: "18px" } };
+  await writeFile(join(root, "style.json"), JSON.stringify(style));
+  const configPath = join(root, "config.json");
+  const config = await result(configPath);
+  config.wx.accounts.default.articleTheme = "style.json";
+  config.plugins.markdownRenderer = { module: "@akairos/myno/adapter", options: {} };
+  await writeFile(configPath, JSON.stringify(config));
   let uploads = 0;
   const command = createTypesetAssetsSyncCommand({ upload: uploader(async () => { uploads++; }), verifyUrl });
   const destination = join(root, "runtime");
@@ -67,9 +75,12 @@ test("deduplicates shared images, rewrites only sources, and exports styles with
   expect(uploads).toBe(1);
   expect((await result(join(root, "templates/jinx.json"))).images[0]).toEqual({ ...template.images[0], src: "https://cdn.example/jinx.png" });
   const patch = await result(join(destination, "pipeline.patch.json"));
-  expect(patch.wx.accounts.default).toMatchObject({ customCss: "/data/pipeline-runtime/markdown/custom-css-default.css", articleTheme: null });
+  expect(patch.plugins.markdownRenderer).toEqual({ module: "@akairos/myno/adapter", options: {} });
+  expect(patch.wx.accounts.default).toMatchObject({ customCss: null, articleTheme: "/data/pipeline-runtime/markdown/article-themes/default/manifest.json" });
+  expect((await readArticleTheme(join(destination, "markdown/article-themes/default/manifest.json"))).css).toBe(style.css);
   for (const secret of ["secret-cos-token", "private-secret", "private-app-id", "private-pat"]) expect(JSON.stringify(patch)).not.toContain(secret);
   expect((await result(join(destination, "manifest.json"))).typesetTemplates).toBe(2);
+  expect(await readFile(join(destination, "typeset-studio/templates/.canvas-presets-v1"), "utf8")).toBe("1");
   expect((await readFile(join(root, "uploads/jinx.png"))).equals(image)).toBe(true);
   await command(["--output", destination]);
   expect(uploads).toBe(1);

package/src/commands/wechat-export.ts

@@ -8,6 +8,7 @@ import { loadConfig, resolveConfigRelativePath } from "../config";
 import { resolveMarkdownRenderer } from "../adapter-loader";
 import { WechatExportError } from "../wechat-preview";
 import { registerPreviewEntry } from "../wechat-preview/server";
+import { readArticleTheme } from "../article-theme";
 
 const CSS_DEMO = `
 Custom CSS is cascaded after the built-in theme and converted to conservative
@@ -69,7 +70,7 @@ Options:
   --account            Account/theme key (optional; default: default)
   --title              Page title for the render shell (optional)
   --preview-shell-out  Path to exact final-HTML preview (optional)
-  --article-theme      Local article theme package (optional)
+  --article-theme      Standalone Studio JSON or local article theme package (optional)
   --summary-only       Omit HTML from stdout; still write the complete output file
   --custom-css         CSS override path; replaces account customCss (optional)
   --timeout-ms         Real browser wait limit in ms (default: 15000)
@@ -108,9 +109,13 @@ ${CSS_DEMO}
 
   const config = loadConfig();
   const wxAccount = config.wx.accounts[account] ?? config.wx.accounts[config.wx.defaultAccount];
+  const articleThemeArg = optionalArg(parsed, "article-theme");
+  const articleThemePath = articleThemeArg ? resolve(articleThemeArg) : resolveConfigRelativePath(wxAccount?.articleTheme);
+  // 独立配置替代账号样式；显式 CSS 参数仍可覆盖本次导出。
+  const standalone = articleThemePath ? (await readArticleTheme(articleThemePath)).manifest.css !== undefined : false;
   const customCss = resolveWechatExportCustomCss(
     cliCustomCss,
-    wxAccount?.customCss,
+    standalone ? null : wxAccount?.customCss,
   );
   const markdownRenderer = await resolveMarkdownRenderer(config);
 
@@ -125,8 +130,8 @@ ${CSS_DEMO}
       title,
       previewShellOutPath,
       customCss,
-      articleThemePath: optionalArg(parsed, "article-theme") ? resolve(optionalArg(parsed, "article-theme")!) : resolveConfigRelativePath(wxAccount?.articleTheme),
-      themeOverrides: wxAccount?.theme,
+      articleThemePath,
+      themeOverrides: standalone ? undefined : wxAccount?.theme,
       timeoutMs: timeoutMs !== undefined && Number.isFinite(timeoutMs) ? timeoutMs : undefined,
       debugDir: debugDir ? resolve(process.cwd(), debugDir) : undefined,
     });

package/src/plugin-runner.ts

@@ -1,13 +1,15 @@
 import type { MonitorProgress } from "./monitor/types";
 
 /** 子进程只执行一次插件调用，进度与结果通过 IPC 返回。 */
-process.on("message", async (request: { specifier: string; action: "describe" | "doctor" | "render"; input?: Record<string, unknown>; options?: Record<string, unknown> }) => {
+process.on("message", async (request: { specifier: string; action: "describe" | "doctor" | "render" | "studio" | "browser"; input?: Record<string, unknown>; options?: Record<string, unknown> }) => {
   try {
     const module = await import(request.specifier);
     const plugin = module.default ?? module.plugin ?? module;
     if (!plugin || typeof plugin !== "object" || typeof plugin.name !== "string" || !plugin.name.trim() ||
-        typeof plugin.render !== "function" || (plugin.doctor !== undefined && typeof plugin.doctor !== "function")) {
-      throw new Error("插件必须导出 name、render，以及可选的 doctor 函数");
+        (typeof plugin.render !== "function" && typeof plugin.browser !== "function") ||
+        (plugin.browser !== undefined && typeof plugin.browser !== "function") || (plugin.doctor !== undefined && typeof plugin.doctor !== "function") ||
+        (plugin.studio !== undefined && typeof plugin.studio !== "function")) {
+      throw new Error("插件必须导出 name、render 或 browser，以及可选的 doctor 函数和 studio 函数");
     }
     // 故障插件频繁报告进度时，限制 IPC 消息数量。
     let lastProgressAt = 0;
@@ -18,9 +20,13 @@ process.on("message", async (request: { specifier: string; action: "describe" |
       process.send?.({ type: "progress", value: progress });
     };
     const value = request.action === "describe"
-      ? { name: plugin.name, version: plugin.version, hasDoctor: typeof plugin.doctor === "function" }
+      ? { name: plugin.name, version: plugin.version, hasDoctor: typeof plugin.doctor === "function", hasStudio: typeof plugin.studio === "function", hasBrowser: typeof plugin.browser === "function" }
       : request.action === "doctor"
         ? await plugin.doctor(request.options)
+        : request.action === "studio"
+          ? await plugin.studio(request.options)
+        : request.action === "browser"
+          ? await plugin.browser(request.options)
         : await plugin.render({ ...request.input, onProgress }, request.options);
     process.send?.({ type: "result", value });
   } catch (error) {

package/src/plugin-runtime.test.ts

@@ -115,6 +115,25 @@ test("markdown plugins receive their own options in doctor and render", async ()
   expect((await plugin.render({ markdownPath: join(directory, "post.md"), outPath: join(directory, "post.html"), account: "default" })).html).toBe(options.html);
 });
 
+test("browser-only markdown plugins validate their entry and receive their own options", async () => {
+  const pluginPath = join(directory, "browser-plugin.mjs");
+  await writeFile(pluginPath, `export default {name:'browser-test',browser(options){return {scriptPath:options.scriptPath}}}`);
+  const plugin = await resolveMarkdownRenderer(PipelineConfigSchema.parse({ plugins: { markdownRenderer: { module: pluginPath, options: { scriptPath: "relative.js" } } } }));
+  await expect(plugin.render({ markdownPath: "unused.md", outPath: "out.html", account: "default" })).rejects.toMatchObject({ code: "PLUGIN_INVALID_RESULT" });
+  expect((await plugin.doctor!()).some(check => check.name === "chrome")).toBe(true);
+});
+
+test("Studio capability is optional, isolated and validates asset directory paths", async () => {
+  const pluginPath = await fixture("return null", `async studio(options){return {root:${JSON.stringify(directory)},entry:options.entry}},`);
+  const config = (entry: string) => PipelineConfigSchema.parse({ plugins: { markdownRenderer: { module: pluginPath, options: { entry } } } });
+  const plugin = await resolveMarkdownRenderer(config("studio.html"));
+  expect(await plugin.studio!()).toEqual({ root: directory, entry: "studio.html" });
+  const invalid = await resolveMarkdownRenderer(config("../outside.html"));
+  await expect(invalid.studio!()).rejects.toMatchObject({ code: "PLUGIN_INVALID_RESULT" });
+  const plain = await resolveMarkdownRenderer(PipelineConfigSchema.parse({ plugins: { markdownRenderer: await fixture("return null") } }));
+  expect(plain.studio).toBeUndefined();
+});
+
 test("reports thrown errors, process exits, and invalid image results without escaping the parent", async () => {
   for (const [body, code] of [
     ['throw new Error("bad template")', "PLUGIN_EXECUTION_FAILED"],

package/src/plugin-runtime.ts

@@ -10,7 +10,7 @@ import { resolveBunBinary } from "./spawn";
 /** 插件错误保留阶段和错误码，终端与调用方使用同一提示。 */
 export class PluginExecutionError extends Error {
   constructor(readonly code: string, specifier: string, action: string, detail: string) {
-    const stage = action === "describe" ? "加载" : action === "doctor" ? "检查" : "渲染";
+    const stage = action === "describe" || action === "browser" ? "加载" : action === "doctor" ? "检查" : action === "studio" ? "工作台加载" : "渲染";
     super(`[${code}] 插件「${specifier}」${stage}失败：${detail}。请检查插件配置、运行 zzp doctor 或切换内置渲染器，修复后再重试；本次未自动重试。`);
     this.name = "PluginExecutionError";
   }
@@ -20,6 +20,15 @@ export const PluginMetadataSchema = z.object({
   name: z.string().trim().min(1),
   version: z.string().optional(),
   hasDoctor: z.boolean(),
+  hasStudio: z.boolean().default(false),
+  hasBrowser: z.boolean().default(false),
+});
+export const PluginBrowserSchema = z.object({
+  scriptPath: z.string().refine(isAbsolute, "浏览器入口必须是绝对路径"),
+});
+export const PluginStudioSchema = z.object({
+  root: z.string().refine(isAbsolute, "Studio root 必须是绝对路径"),
+  entry: z.string().min(1).refine(value => !isAbsolute(value) && !value.split(/[\\/]/).includes(".."), "Studio entry 必须位于资源目录内"),
 });
 export const PluginDoctorSchema = z.array(z.object({
   name: z.string().min(1), ok: z.boolean(), message: z.string().optional(), detail: z.unknown().optional(),
@@ -48,7 +57,7 @@ const ProgressSchema = z.object({
 /** 外部插件独立执行；父进程可终止同步死循环、异常退出和永不结束的 Promise。 */
 export async function runExternalPlugin<T>(
   specifier: string,
-  action: "describe" | "doctor" | "render",
+  action: "describe" | "doctor" | "render" | "studio" | "browser",
   schema: z.ZodType<T>,
   input?: Record<string, unknown>,
   configuration: { options?: Record<string, unknown>; environment?: Record<string, string> } = {},

package/src/providers/index.ts

@@ -84,15 +84,17 @@ async function publishWechatArticleRoute({
   try {
     const markdownRenderer = await resolveMarkdownRenderer(config);
     const wxAccount = config.wx.accounts[account] ?? config.wx.accounts[config.wx.defaultAccount];
+    // 独立正文配置与发布账号的凭据、默认 CSS 分离。
+    const standalone = articleTheme?.manifest.css !== undefined;
     const rendered = await markdownRenderer.render({
       onProgress: reportProgress,
       markdownPath: exportPostPath,
       outPath: workspacePaths.zotepadExportHtml,
       account,
       title: state.metadata.title,
-      customCss: resolveConfigRelativePath(wxAccount?.customCss),
+      customCss: standalone ? null : resolveConfigRelativePath(wxAccount?.customCss),
       articleThemePath: articleTheme?.path,
-      themeOverrides: wxAccount?.theme,
+      themeOverrides: standalone ? undefined : wxAccount?.theme,
     });
     const { html } = rendered;
 

package/src/runtime-package.ts

@@ -61,7 +61,7 @@ export function validateStudioDefaults(text: string, templateIds: Set<string>):
 }
 
 /** 准备账号主题文件，只导出样式白名单，不复制凭据或本机插件入口。 */
-export async function prepareMarkdownRuntime(config: PipelineConfig, accountMap: Record<string, string> = {}): Promise<{ files: Map<string, Uint8Array>; accounts: Record<string, unknown> }> {
+export async function prepareMarkdownRuntime(config: PipelineConfig, accountMap: Record<string, string> = {}): Promise<{ files: Map<string, Uint8Array>; accounts: Record<string, unknown>; markdownRenderer: PipelineConfig["plugins"]["markdownRenderer"] }> {
   const files = new Map<string, Uint8Array>();
   const accounts: Record<string, unknown> = {};
   for (const [localAccount, value] of Object.entries(config.wx.accounts)) {
@@ -69,13 +69,14 @@ export async function prepareMarkdownRuntime(config: PipelineConfig, accountMap:
     if (!/^[a-zA-Z0-9_.-]{1,80}$/.test(account) || [".", "..", "__proto__", "constructor", "prototype"].includes(account)) throw new Error(`无效的样式账号标识：${account}`);
     if (Object.hasOwn(accounts, account)) throw new Error(`账号映射重复：${account}`);
     const next: Record<string, unknown> = { theme: value.theme, customCss: null, articleTheme: null };
-    if (value.customCss) {
+    const theme = value.articleTheme ? await readArticleTheme(resolveConfigRelativePath(value.articleTheme)!) : null;
+    // 独立配置已内嵌 CSS，部署时不依赖被替代的账号样式文件。
+    if (value.customCss && theme?.manifest.css === undefined) {
       const name = `markdown/custom-css-${account}.css`;
       files.set(name, await readRuntimeSource(resolveConfigRelativePath(value.customCss)!));
       next.customCss = `${RUNTIME_ROOT}/${name}`;
     }
-    if (value.articleTheme) {
-      const theme = await readArticleTheme(resolveConfigRelativePath(value.articleTheme)!);
+    if (theme) {
       const prefix = `markdown/article-themes/${account}`;
       for (const [name, bytes] of theme.files) files.set(`${prefix}/${name}`, bytes);
       files.set(`${prefix}/manifest.json`, Buffer.from(JSON.stringify(theme.manifest, null, 2)));
@@ -83,7 +84,12 @@ export async function prepareMarkdownRuntime(config: PipelineConfig, accountMap:
     }
     accounts[account] = next;
   }
-  return { files, accounts };
+  const entry = config.plugins.markdownRenderer;
+  const module = typeof entry === "string" ? entry : entry?.module;
+  // 部署只接受可复现的 npm 入口，禁止把本机绝对路径带到服务器。
+  if (module && module !== "@akairos/myno/adapter") throw new Error("运行时同步仅支持 @akairos/myno/adapter 或内置 Markdown 渲染器");
+  if (typeof entry === "object" && entry && Object.keys(entry.options).length) throw new Error("myno 运行时同步暂不接受专属参数");
+  return { files, accounts, markdownRenderer: module ? { module, options: {} } : null };
 }
 
 /** 写入带文件哈希的独立配置包，调用者在全部成功后切换目录。 */
@@ -100,8 +106,9 @@ export async function writeRuntimePackage(destination: string, templates: Map<st
   files.set("typeset-studio/default-template.json", Buffer.from(defaults));
   // 防止渲染时重新播种内置模板，使部署目录与文件清单保持一致。
   files.set("typeset-studio/templates/.initialized", Buffer.from("1"));
+  files.set("typeset-studio/templates/.canvas-presets-v1", Buffer.from("1"));
   const patch = {
-    plugins: { imageRenderer: { module: "@akairos/typeset-studio/adapter", options: { dataDir: `${RUNTIME_ROOT}/typeset-studio` } }, markdownRenderer: null },
+    plugins: { imageRenderer: { module: "@akairos/typeset-studio/adapter", options: { dataDir: `${RUNTIME_ROOT}/typeset-studio` } }, markdownRenderer: markdown.markdownRenderer },
     wx: { accounts: markdown.accounts },
   };
   files.set("pipeline.patch.json", Buffer.from(JSON.stringify(patch, null, 2) + "\n"));