hexo-text-pipeline 0.2.0

package/lib/core/checker/static.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const fs = require('node:fs');
+const { STAGES } = require('../stages');
+
+const KNOWN_TOP_KEYS = ['enable', 'debug', 'strict', 'inject_css', 'inject_js', 'presets', 'hooks', 'plugins', 'plugins_dir', 'tap'];
+const KNOWN_TAP_KEYS = ['enable', 'match', 'dir'];
+const KNOWN_HOOK_KEYS = ['command', 'script', 'stage', 'slot', 'priority', 'name', 'timeout', 'enable', 'match'];
+
+function editDistance(a, b) {
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  let prev = Array.from({ length: cols }, (_, j) => j);
+
+  for (let i = 1; i < rows; i += 1) {
+    const current = [i];
+    for (let j = 1; j < cols; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      current.push(Math.min(prev[j] + 1, current[j - 1] + 1, prev[j - 1] + cost));
+    }
+    prev = current;
+  }
+  return prev[cols - 1];
+}
+
+function suggest(key, candidates) {
+  const lower = key.toLowerCase();
+  let best = null;
+  let bestDistance = 3; // 编辑距离 <= 2 才算像
+
+  for (const candidate of candidates) {
+    const distance = editDistance(lower, candidate);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = candidate;
+    }
+  }
+  return best ? ' (did you mean "' + best + '"?)' : '';
+}
+
+/**
+ * 注册期静态检查（兜底第一道防线）：在任何文章被处理之前发现配置问题。
+ * 返回 issue 列表 { level: 'error' | 'warn', message }；
+ * strict 模式下 error 级会让构建失败，否则全部降为日志告警。
+ */
+function checkPluginConfig(rawConfig) {
+  const issues = [];
+  if (!rawConfig || typeof rawConfig !== 'object') return issues;
+
+  for (const key of Object.keys(rawConfig)) {
+    if (!KNOWN_TOP_KEYS.includes(key)) {
+      issues.push({
+        level: 'warn',
+        message: 'unknown config key "text_pipeline.' + key + '"' + suggest(key, KNOWN_TOP_KEYS)
+      });
+    }
+  }
+  if ('presets' in rawConfig && !Array.isArray(rawConfig.presets)) {
+    issues.push({ level: 'error', message: 'text_pipeline.presets must be a list' });
+  }
+  if ('hooks' in rawConfig && !Array.isArray(rawConfig.hooks)) {
+    issues.push({ level: 'error', message: 'text_pipeline.hooks must be a list' });
+  }
+  if ('plugins_dir' in rawConfig && rawConfig.plugins_dir !== false && typeof rawConfig.plugins_dir !== 'string') {
+    issues.push({ level: 'error', message: 'text_pipeline.plugins_dir must be a directory name string or false' });
+  }
+  if (
+    'plugins' in rawConfig &&
+    (!rawConfig.plugins || typeof rawConfig.plugins !== 'object' || Array.isArray(rawConfig.plugins))
+  ) {
+    issues.push({ level: 'error', message: 'text_pipeline.plugins must be a map of <plugin name> -> overrides' });
+  } else if (rawConfig.plugins && typeof rawConfig.plugins === 'object') {
+    for (const [name, sub] of Object.entries(rawConfig.plugins)) {
+      if (!sub || typeof sub !== 'object' || Array.isArray(sub)) {
+        // `arrow: false` 之类的写法意图明显但会被静默忽略——指条明路
+        issues.push({
+          level: 'warn',
+          message: 'text_pipeline.plugins.' + name + ' must be an object (to disable a plugin use { enable: false })'
+        });
+      }
+    }
+  }
+  for (const [index, entry] of (Array.isArray(rawConfig.hooks) ? rawConfig.hooks : []).entries()) {
+    if (!entry || typeof entry !== 'object') continue;
+    for (const key of Object.keys(entry)) {
+      if (!KNOWN_HOOK_KEYS.includes(key)) {
+        issues.push({
+          level: 'warn',
+          message: 'unknown key "' + key + '" in hooks[' + index + ']' + suggest(key, KNOWN_HOOK_KEYS)
+        });
+      }
+    }
+  }
+  if (rawConfig.tap && typeof rawConfig.tap === 'object') {
+    for (const key of Object.keys(rawConfig.tap)) {
+      if (!KNOWN_TAP_KEYS.includes(key)) {
+        issues.push({
+          level: 'warn',
+          message: 'unknown key "' + key + '" in text_pipeline.tap' + suggest(key, KNOWN_TAP_KEYS)
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+/**
+ * node 级检查：stage 合法性、重名、priority 类型、script 文件可达性（advisory：
+ * 文件可以等会儿再创建——即改即用，所以只 warn 不拦截）、同 stage 同 priority 的顺序歧义提示。
+ */
+function checkNodes(nodes) {
+  const issues = [];
+  const seen = new Map();
+
+  for (const node of nodes) {
+    if (!STAGES[node.stage]) {
+      issues.push({
+        level: 'error',
+        message: '"' + node.name + '" targets unknown stage "' + node.stage + '" (valid: ' + Object.keys(STAGES).join(', ') + ')'
+      });
+    }
+    if (seen.has(node.name)) {
+      issues.push({
+        level: 'warn',
+        message: 'duplicate node name "' + node.name + '" — both will run; rename one to tell them apart in logs'
+      });
+    }
+    seen.set(node.name, node);
+
+    if (node.priority !== undefined && !Number.isFinite(node.priority)) {
+      issues.push({ level: 'error', message: '"' + node.name + '" has a non-numeric priority' });
+    }
+    if (node.slot !== undefined && node.slot !== 'early' && node.slot !== 'late') {
+      issues.push({ level: 'error', message: '"' + node.name + '" has invalid slot "' + node.slot + '" (use early or late)' });
+    }
+    if (node.scriptPath && !fs.existsSync(node.scriptPath)) {
+      issues.push({
+        level: 'warn',
+        message: '"' + node.name + '" script not found yet: ' + node.scriptPath + ' (will be retried on each render)'
+      });
+    }
+  }
+
+  // 顺序歧义提示：不同来源（不同 preset / hook）的 node 落在同 stage 同 priority 时，
+  // 相对顺序只由注册顺序决定——提示用户用 priority 显式表达意图。
+  // 同一来源内部共享 priority 是常态（preset 自己声明的顺序），不提示。
+  const byStagePriority = new Map();
+  for (const node of nodes) {
+    const key = node.stage + '.' + (node.slot || 'early') + '@' + (Number.isFinite(node.priority) ? node.priority : 10);
+    if (!byStagePriority.has(key)) byStagePriority.set(key, []);
+    byStagePriority.get(key).push(node);
+  }
+  for (const [key, group] of byStagePriority) {
+    const origins = new Set(group.map((node) => node.origin || 'unknown'));
+    if (origins.size > 1) {
+      // info 级：这是常见且行为良定义的情况（preset 先于 hook），只在 doctor 报告里展示，
+      // 不在构建日志刷 warn——否则最普通的配置都会告警，用户会学会无视警告
+      issues.push({
+        level: 'info',
+        message: 'nodes from different sources share priority at ' + key + ' (' + group.map((n) => n.name).join(' → ') + '); order follows registration — set explicit priorities to pin it'
+      });
+    }
+  }
+
+  return issues;
+}
+
+module.exports = { checkPluginConfig, checkNodes, suggest };

package/lib/core/config.js

@@ -0,0 +1,74 @@
+'use strict';
+
+function normalizeBase(base) {
+  const raw = String(base || '').trim();
+  if (!raw) return '';
+  return raw.replace(/\/+$/, '');
+}
+
+/**
+ * 归一化 hexo.config.text_pipeline。
+ * 顶层开关 + 全局选项 + presets（插件的插件）+ hooks（用户脚本/命令）。
+ * 字段合法性由 checker/static 负责，这里只做形状归一，未知字段不丢（raw 保留给 checker）。
+ */
+const DEFAULT_PLUGINS_DIR = 'text-pipeline';
+
+function normalizeConfig(hexoConfig) {
+  const raw = (hexoConfig && hexoConfig.text_pipeline) || {};
+  return {
+    enable: raw.enable !== false,
+    debug: Boolean(raw.debug),
+    strict: Boolean(raw.strict),
+    injectCss: raw.inject_css !== false,
+    injectJs: raw.inject_js !== false,
+    presets: Array.isArray(raw.presets) ? raw.presets : [],
+    hooks: Array.isArray(raw.hooks) ? raw.hooks : [],
+    // 单文件插件目录：false 关闭自动发现，字符串改目录名，缺省用约定值
+    pluginsDir:
+      raw.plugins_dir === false
+        ? false
+        : typeof raw.plugins_dir === 'string' && raw.plugins_dir.trim()
+          ? raw.plugins_dir.trim()
+          : DEFAULT_PLUGINS_DIR,
+    plugins: raw.plugins && typeof raw.plugins === 'object' && !Array.isArray(raw.plugins) ? raw.plugins : {},
+    tap: raw.tap && typeof raw.tap === 'object' ? raw.tap : { enable: false },
+    raw
+  };
+}
+
+/**
+ * presets 条目两种写法：'obsidian' 或 { name: 'obsidian', config: {...} }。
+ */
+function normalizePresetEntry(entry) {
+  if (typeof entry === 'string') {
+    return { name: entry.trim(), config: {} };
+  }
+  if (entry && typeof entry === 'object' && typeof entry.name === 'string') {
+    return {
+      name: entry.name.trim(),
+      config: entry.config && typeof entry.config === 'object' ? entry.config : {}
+    };
+  }
+  return null;
+}
+
+/** preset config 里某个 node 的子配置（presets[].config.<shortName>）。 */
+function nodeConfig(presetConfig, shortName) {
+  const sub = presetConfig && presetConfig[shortName];
+  return sub && typeof sub === 'object' ? sub : {};
+}
+
+/** node 的 enable 解析顺序：用户子配置 > node.enabledByDefault > 默认开。preset 与单文件插件共用。 */
+function isNodeEnabled(node, sub) {
+  if (typeof sub.enable === 'boolean') return sub.enable;
+  return node.enabledByDefault !== false;
+}
+
+module.exports = {
+  normalizeBase,
+  normalizeConfig,
+  normalizePresetEntry,
+  nodeConfig,
+  isNodeEnabled,
+  DEFAULT_PLUGINS_DIR
+};

package/lib/core/console/pipeline.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { STAGES } = require('../stages');
+
+const DIFF_MAX_LINES = 40;
+const DIFF_DP_LIMIT = 2000;
+
+/**
+ * `hexo pipeline` 诊断命令（兜底第三道防线）：上线前把整条管线摊开看。
+ *
+ * 默认：打印每个 stage 的 node 执行顺序（priority + 来源）和全部静态检查结果。
+ * --dry-run <file>：读样例 markdown 文件，剥 frontmatter 后逐 node 跑
+ * before_post_render 链，打印每个 node 改了什么（行级 diff）——
+ * 两个 node 语义上互相打架时，在这里直接看见。
+ */
+function formatReport(state) {
+  const lines = [];
+  lines.push('text-pipeline');
+  lines.push('');
+
+  for (const stageName of Object.keys(STAGES)) {
+    const slots = [
+      ['early', state.registry.forStage(stageName, 'early')],
+      ['late', state.registry.forStage(stageName, 'late')]
+    ];
+    if (!slots[0][1].length && !slots[1][1].length) continue;
+
+    lines.push(stageName + '  (' + STAGES[stageName].description + ')');
+    for (const [slot, nodes] of slots) {
+      if (!nodes.length) continue;
+      lines.push('  ' + slot + (slot === 'late' ? '  (after hexo internals & other plugins)' : '  (before hexo internals & other plugins)'));
+      nodes.forEach((node, index) => {
+        const priority = Number.isFinite(node.priority) ? node.priority : 10;
+        lines.push('    ' + (index + 1) + '. [' + priority + '] ' + node.name + '  <' + (node.origin || 'unknown') + '>');
+      });
+    }
+    lines.push('');
+  }
+  if (lines.length === 2) {
+    lines.push('(no nodes registered on any stage)');
+    lines.push('');
+  }
+
+  if (state.issues.length) {
+    lines.push('checks:');
+    for (const issue of state.issues) {
+      lines.push('  ' + issue.level.toUpperCase() + ': ' + issue.message);
+    }
+  } else {
+    lines.push('checks: all clear');
+  }
+
+  return lines.join('\n');
+}
+
+function stripFrontMatter(text) {
+  const match = text.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n/);
+  return match ? text.slice(match[0].length) : text;
+}
+
+/** 行级 LCS diff，超大文件退化为只报行数变化。返回展示行数组。 */
+function lineDiff(before, after) {
+  const a = before.split('\n');
+  const b = after.split('\n');
+
+  if (a.length > DIFF_DP_LIMIT || b.length > DIFF_DP_LIMIT) {
+    return ['  (file too large for a diff: ' + a.length + ' -> ' + b.length + ' lines)'];
+  }
+
+  // 标准 LCS DP
+  const dp = Array.from({ length: a.length + 1 }, () => new Uint16Array(b.length + 1));
+  for (let i = a.length - 1; i >= 0; i -= 1) {
+    for (let j = b.length - 1; j >= 0; j -= 1) {
+      dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+    }
+  }
+
+  const out = [];
+  let i = 0;
+  let j = 0;
+  let truncated = false;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      i += 1;
+      j += 1;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      out.push('  - ' + a[i]);
+      i += 1;
+    } else {
+      out.push('  + ' + b[j]);
+      j += 1;
+    }
+    if (out.length >= DIFF_MAX_LINES) {
+      truncated = true;
+      break;
+    }
+  }
+  if (!truncated) {
+    while (i < a.length && out.length < DIFF_MAX_LINES) out.push('  - ' + a[i++]);
+    while (j < b.length && out.length < DIFF_MAX_LINES) out.push('  + ' + b[j++]);
+    if (i < a.length || j < b.length) truncated = true;
+  }
+  if (truncated) out.push('  … (diff truncated at ' + DIFF_MAX_LINES + ' lines)');
+  return out;
+}
+
+function formatDryRun(hexo, state, filePath) {
+  const resolved = path.resolve(hexo.base_dir || process.cwd(), filePath);
+  const raw = fs.readFileSync(resolved, 'utf8');
+  let current = stripFrontMatter(raw);
+
+  const lines = ['dry-run: ' + filePath + '  (stage: before_post_render)', ''];
+  const post = { source: filePath, path: '', title: path.basename(filePath, path.extname(filePath)) };
+
+  // early → late 串行；真实渲染中两者之间还有 hexo 内置 filter 和其他插件，这里不模拟
+  const chain = [
+    ...state.registry.forStage('before_post_render', 'early'),
+    ...state.registry.forStage('before_post_render', 'late')
+  ];
+
+  for (const node of chain) {
+    const warnings = [];
+    // 与 engine 的 ctx 构建保持一致：config / presetConfig 仅 node 自带时出现
+    const ctx = {
+      hexo,
+      post,
+      stage: 'before_post_render',
+      pluginConfig: state.pluginConfig,
+      utils: hexo.textPipeline && hexo.textPipeline.utils,
+      log: { warn: (m) => warnings.push(m), debug() {} }
+    };
+    if (node.config !== undefined) ctx.config = node.config;
+    if (node.presetConfig !== undefined) ctx.presetConfig = node.presetConfig;
+
+    if (typeof node.test === 'function' && !node.test(current)) {
+      lines.push('· ' + node.name + ': skipped (test)');
+      continue;
+    }
+
+    let output;
+    try {
+      output = node.convert(current, ctx);
+      if (typeof output !== 'string') {
+        throw new Error('returned ' + typeof output + ' instead of a string');
+      }
+    } catch (err) {
+      lines.push('✗ ' + node.name + ': FAILED — ' + (err && err.message) + ' (text passed through unchanged)');
+      continue;
+    }
+
+    for (const warning of warnings) {
+      lines.push('! ' + node.name + ': ' + warning);
+    }
+
+    if (output === current) {
+      lines.push('· ' + node.name + ': no change');
+    } else {
+      lines.push('✓ ' + node.name + ': changed (' + current.length + ' -> ' + output.length + ' chars)');
+      lines.push(...lineDiff(current, output));
+      current = output;
+    }
+  }
+
+  lines.push('');
+  lines.push('note: only before_post_render runs in a dry-run; later stages need rendered HTML.');
+  lines.push('note: hexo internal filters and other plugins (which run between the early and late slots) are not simulated.');
+  return lines.join('\n');
+}
+
+function registerDoctorCommand(hexo) {
+  if (!hexo.extend.console || typeof hexo.extend.console.register !== 'function') {
+    return;
+  }
+  hexo.extend.console.register(
+    'pipeline',
+    'Inspect the text pipeline: node order, check results; --dry-run <file> traces a sample file node by node',
+    {
+      options: [{ name: '--dry-run <file>', desc: 'run the before_post_render chain on a markdown file and show each node\'s diff' }]
+    },
+    function pipelineCommand(args) {
+      const state = this._textPipeline;
+      if (!state) {
+        console.log('text-pipeline is disabled (text_pipeline.enable: false) or not registered');
+        return;
+      }
+
+      const dryRunTarget = args && (args['dry-run'] || args.d);
+      if (typeof dryRunTarget === 'string' && dryRunTarget) {
+        // 文章索引等 preset 服务依赖数据库，先 load 再跑
+        const ready = typeof this.load === 'function' ? this.load() : Promise.resolve();
+        return ready.then(() => {
+          console.log(formatDryRun(this, state, dryRunTarget));
+        });
+      }
+
+      console.log(formatReport(state));
+    }
+  );
+}
+
+module.exports = { registerDoctorCommand, formatReport, formatDryRun, _internal: { lineDiff, stripFrontMatter } };

package/lib/core/engine.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const { normalizeConfig } = require('./config');
+const { STAGES, LATE_FILTER_PRIORITY } = require('./stages');
+const { createRegistry, createPublicApi } = require('./api');
+const { loadPresets } = require('./loaders/preset');
+const { loadHooks } = require('./loaders/hooks');
+const { loadPluginDir } = require('./loaders/plugin-dir');
+const { checkPluginConfig, checkNodes } = require('./checker/static');
+const { createRuntimeGuard } = require('./checker/runtime');
+const { createTap } = require('./tap');
+const { registerDoctorCommand } = require('./console/pipeline');
+
+const registeredHexoInstances = new WeakSet();
+
+function makeLogger(hexo, debug, name) {
+  const prefix = '[text-pipeline' + (name ? ':' + name : '') + '] ';
+  const hexoLog = hexo.log || {};
+  return {
+    debug(message) {
+      if (!debug || typeof hexoLog.info !== 'function') return;
+      hexoLog.info(prefix + message);
+    },
+    warn(message) {
+      if (typeof hexoLog.warn === 'function') {
+        hexoLog.warn(prefix + message);
+      }
+    }
+  };
+}
+
+/**
+ * 唯一调度者。注册流程（兜底链路）：
+ *   1. 静态检查配置（checker/static）—— strict 下 error 直接让构建失败
+ *   2. 加载 presets（插件的插件）、hooks（用户脚本/命令）与单文件插件目录
+ *      （plugin-dir，零配置自动发现）为统一 node
+ *   3. node 级静态检查（stage、重名、priority、脚本可达性、顺序歧义）
+ *   4. 为 stage 表里每个 stage 注册一个 hexo filter，执行时懒查注册表
+ *      （所以 hexo.textPipeline.register 在任何时刻注册都生效）
+ *   5. 执行期每个 node 过 runtime guard：异常隔离、熔断、输出异常告警
+ *
+ * 同 stage 内顺序：priority 小者先跑，同级按注册顺序
+ * （加载顺序 preset → hook → plugin）。
+ */
+function register(hexo) {
+  if (!hexo || !hexo.extend || !hexo.extend.filter || typeof hexo.extend.filter.register !== 'function') {
+    return;
+  }
+  if (registeredHexoInstances.has(hexo)) {
+    return;
+  }
+  registeredHexoInstances.add(hexo);
+
+  registerDoctorCommand(hexo); // 禁用时也注册，`hexo pipeline` 会提示插件未启用
+
+  const pluginConfig = normalizeConfig(hexo.config);
+  if (!pluginConfig.enable) {
+    return;
+  }
+
+  const engineLog = makeLogger(hexo, pluginConfig.debug);
+  const baseDir = hexo.base_dir;
+
+  const issues = checkPluginConfig(pluginConfig.raw);
+  const presetResult = loadPresets(pluginConfig.presets, baseDir);
+  const hookResult = loadHooks(pluginConfig.hooks, baseDir);
+  const pluginResult =
+    pluginConfig.pluginsDir === false
+      ? { nodes: [], issues: [] }
+      : loadPluginDir(pluginConfig.pluginsDir, pluginConfig.plugins, baseDir);
+  issues.push(...presetResult.issues, ...hookResult.issues, ...pluginResult.issues);
+
+  const candidates = presetResult.nodes.concat(hookResult.nodes, pluginResult.nodes);
+  issues.push(...checkNodes(candidates));
+
+  if (pluginConfig.strict) {
+    const errors = issues.filter((issue) => issue.level === 'error');
+    if (errors.length) {
+      throw new Error(
+        '[text-pipeline] strict mode: config check failed\n  - ' + errors.map((e) => e.message).join('\n  - ')
+      );
+    }
+  }
+  for (const issue of issues) {
+    if (issue.level === 'info') {
+      engineLog.debug(issue.message); // 仅 debug / `hexo pipeline` 可见
+    } else {
+      engineLog.warn(issue.level + ': ' + issue.message);
+    }
+  }
+
+  const registry = createRegistry();
+  for (const node of candidates) {
+    if (STAGES[node.stage]) registry.add(node);
+  }
+
+  const guard = createRuntimeGuard({ strict: pluginConfig.strict });
+  hexo.extend.filter.register('before_generate', () => {
+    guard.reset();
+  });
+
+  const tap = createTap(pluginConfig.tap, baseDir, engineLog);
+  if (tap) {
+    engineLog.warn('tap is ON — stage snapshots are written to ' + tap.root + ' (debug mode, disable for normal builds)');
+  }
+
+  const canInject = hexo.extend.injector && typeof hexo.extend.injector.register === 'function';
+  const injectAssets = (node) => {
+    if (!canInject) return;
+    if (pluginConfig.injectCss && node.css) {
+      hexo.extend.injector.register('head_end', '<style>' + node.css + '</style>');
+    }
+    if (pluginConfig.injectJs && node.js) {
+      const js = typeof node.js === 'function' ? node.js(node.config || {}) : node.js;
+      if (js) {
+        hexo.extend.injector.register('body_end', '<script>' + js + '</script>');
+      }
+    }
+  };
+
+  const api = createPublicApi(registry, { onRegister: injectAssets, log: engineLog });
+  hexo.textPipeline = api;
+  // doctor 命令与测试读取的内部状态
+  hexo._textPipeline = { registry, issues, pluginConfig, guard };
+
+  // target：post 类 stage 是 post 数据对象，string 类是 { path } 等输出元信息。
+  // ctx 上按 stage 类型分流成 post / file 两个名字，不再用 ctx.post 装非 post 的东西；
+  // config / presetConfig 只在 node 自带时出现（hook 没有，ctx 上也不会有）。
+  const runChain = (stageName, slot, text, target) => {
+    let current = text;
+
+    if (tap) tap.capture(stageName + '.' + slot, target, 'input', current);
+
+    for (const node of registry.forStage(stageName, slot)) {
+      if (typeof node.test === 'function' && !node.test(current)) continue;
+
+      const log = makeLogger(hexo, pluginConfig.debug, node.name);
+      const ctx = {
+        hexo,
+        stage: stageName,
+        pluginConfig,
+        utils: api.utils,
+        log
+      };
+      if (STAGES[stageName].kind === 'post') {
+        ctx.post = target;
+      } else {
+        ctx.file = target;
+      }
+      if (node.config !== undefined) ctx.config = node.config;
+      if (node.presetConfig !== undefined) ctx.presetConfig = node.presetConfig;
+
+      const next = guard.run(node, current, ctx);
+      if (next !== current) {
+        log.debug(stageName + ' applied source=' + ((target && (target.source || target.path)) || 'unknown'));
+        if (tap) tap.capture(stageName + '.' + slot, target, node.name, next);
+      }
+      current = next;
+    }
+
+    return current;
+  };
+
+  // 每个 stage 两个挂点：early 抢在 hexo 内置/其他插件之前，late 在其全部跑完之后
+  for (const stageName of Object.keys(STAGES)) {
+    const slots = [
+      ['early', STAGES[stageName].filterPriority],
+      ['late', LATE_FILTER_PRIORITY]
+    ];
+    for (const [slot, filterPriority] of slots) {
+      if (STAGES[stageName].kind === 'post') {
+        hexo.extend.filter.register(stageName, (data) => {
+          if (!data || typeof data.content !== 'string') {
+            return data;
+          }
+          data.content = runChain(stageName, slot, data.content, data);
+          return data;
+        }, filterPriority);
+      } else {
+        hexo.extend.filter.register(stageName, (text, data) => {
+          if (typeof text !== 'string') {
+            return text;
+          }
+          return runChain(stageName, slot, text, data || {});
+        }, filterPriority);
+      }
+    }
+  }
+
+  for (const node of registry.all()) {
+    injectAssets(node);
+  }
+
+  for (const { name, init } of presetResult.inits) {
+    try {
+      init(hexo);
+    } catch (err) {
+      engineLog.warn('preset "' + name + '" init failed: ' + (err && err.message));
+    }
+  }
+}
+
+module.exports = {
+  register,
+  registeredHexoInstances,
+  STAGES
+};