@hoardodile/cli 0.0.0

package/dist/main.js

@@ -0,0 +1,1684 @@
+import { mkdtempSync, rmSync, existsSync, statSync, readdirSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, watch } from 'fs';
+import os, { tmpdir } from 'os';
+import { join, dirname, resolve, sep, extname } from 'path';
+import { pathToFileURL } from 'url';
+import { createProbeCache, HOOK_NAMES, createPluginSandbox, DEFAULT_SANDBOX_CONFIG, buildRegistry, createPluginHooks, createPluginResourceAPI, createDirectoryContainer } from '@hoardodile/host';
+import { ok, err } from '@hoardodile/sdk-types';
+import { defineCommand } from 'citty';
+import { mediaProbes } from '@hoardodile/host/probe';
+import { pluginManifest } from '@hoardodile/sdk-types/schema';
+import babel from '@rolldown/plugin-babel';
+import tailwindcss from '@tailwindcss/vite';
+import react, { reactCompilerPreset } from '@vitejs/plugin-react';
+import { build } from 'vite';
+import { parseTemplateFragments, tokeniseExpression, parseTemplateExpression } from '@hoardodile/sdk-types/template';
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+import { createHash } from 'crypto';
+import { mkdir, writeFile } from 'fs/promises';
+import { parseImageVariantQuery, normalizeImageVariantSpec, imageVariantCanonical } from '@hoardodile/sdk-types/image-variant';
+import { RESOURCE_PREVIEW_MAX_AREA, RESOURCE_COVER_MAX_AREA } from '@hoardodile/sdk-types/resource';
+import { createStoragePaths } from '@hoardodile/host/hoard';
+
+// src/main.ts
+var EXIT_PASS = 0;
+var EXIT_REGRESSION = 1;
+var EXIT_ERROR = 2;
+var CliError = class extends Error {
+};
+var FALLBACK_ID = "00000000-0000-4000-8000-000000000000";
+function resolvePluginTarget(opts) {
+  const dirPath = opts.pluginDir !== void 0 ? resolve(opts.pluginDir) : opts.main !== void 0 ? dirname(resolve(opts.main)) : void 0;
+  if (dirPath === void 0) {
+    throw new CliError("provide --plugin-dir <dir> or --main <main.js>");
+  }
+  const mainPath = opts.main !== void 0 ? resolve(opts.main) : join(dirPath, "main.js");
+  if (!existsSync(mainPath)) {
+    throw new CliError(`plugin main.js not found: ${mainPath}`);
+  }
+  const manifestPath = join(dirPath, "manifest.json");
+  let manifest;
+  if (existsSync(manifestPath)) {
+    const parsed = pluginManifest.safeParse(
+      JSON.parse(readFileSync(manifestPath, "utf-8"))
+    );
+    if (!parsed.success) {
+      throw new CliError(
+        `invalid manifest.json at ${manifestPath}: ${parsed.error.message}`
+      );
+    }
+    manifest = parsed.data;
+  } else {
+    manifest = {
+      id: FALLBACK_ID,
+      name: "cli-plugin",
+      description: "CLI-invoked plugin without a manifest.json",
+      version: "0.0.0",
+      permissions: {
+        sourceMeta: false,
+        searchMeta: false,
+        danmaku: false,
+        message: false,
+        imageHashes: false,
+        container: false,
+        download: false
+      }
+    };
+  }
+  return { id: manifest.id, manifest, mainPath, dirPath };
+}
+var cliProbeCache = createProbeCache();
+function buildCliResourceAPI(dir, opts = {}) {
+  return createPluginResourceAPI({
+    view: createDirectoryContainer(dir),
+    ...mediaProbes,
+    extractCacheDir: opts.extractCacheDir,
+    probeCache: cliProbeCache,
+    cacheScope: `cli:${dir}`
+  });
+}
+function buildArchiveResourceAPI(resourceDir, extractCacheDir) {
+  return createPluginResourceAPI({
+    view: createDirectoryContainer(resourceDir),
+    ...mediaProbes,
+    extractCacheDir,
+    probeCache: cliProbeCache,
+    cacheScope: `cli:${resourceDir}`
+  });
+}
+async function createCliHooks(target, sandbox) {
+  const plugin = await sandbox.loadPlugin({
+    id: target.id,
+    mainPath: target.mainPath,
+    eager: true
+  });
+  if (plugin === void 0) {
+    throw new CliError(`plugin failed to load: ${target.mainPath}`);
+  }
+  const registry = buildRegistry([
+    {
+      id: target.id,
+      manifest: target.manifest,
+      enabled: true,
+      priority: 0,
+      pinned: false,
+      color: "",
+      missing: false,
+      builtin: false,
+      dev: false,
+      plugin,
+      diskPath: target.dirPath
+    }
+  ]);
+  return createPluginHooks({ getRegistry: () => registry });
+}
+async function runCliHook(opts) {
+  const api = buildCliResourceAPI(opts.dir, {
+    extractCacheDir: opts.extractCacheDir
+  });
+  const started = performance.now();
+  let result;
+  try {
+    switch (opts.hook) {
+      case "detect":
+        result = await opts.hooks.detectForPlugin(api, opts.id);
+        break;
+      case "sourceMeta":
+        result = (await opts.hooks.runMetaHooks(api, opts.id)).sourceMeta?.value;
+        break;
+      case "searchMeta":
+        result = (await opts.hooks.runMetaHooks(api, opts.id)).searchMeta?.value;
+        break;
+      case "coverLocal":
+        result = await opts.hooks.resolveLocalCoverSource(api, opts.id);
+        break;
+      case "listFiles":
+        result = await opts.hooks.buildFileList(api, opts.id);
+        break;
+    }
+  } catch (caught) {
+    return err({
+      result: caught instanceof Error ? caught.message : String(caught),
+      durationMs: performance.now() - started
+    });
+  }
+  return ok({ result, durationMs: performance.now() - started });
+}
+
+// src/bench.ts
+function machineInfo() {
+  return {
+    platform: os.platform(),
+    arch: os.arch(),
+    cpus: os.cpus().length,
+    cpuModel: os.cpus()[0]?.model ?? "unknown",
+    node: process.version
+  };
+}
+function fingerprint(machine) {
+  return [
+    machine.platform,
+    machine.arch,
+    machine.cpus,
+    machine.cpuModel,
+    machine.node
+  ].join("|");
+}
+function computeBenchReport(opts) {
+  return (async () => {
+    for (let i = 0; i < opts.warmupRuns; i++) {
+      await opts.run();
+    }
+    const samples = [];
+    let peakRss = 0;
+    for (let i = 0; i < opts.repeat; i++) {
+      const outcome = await opts.run();
+      samples.push(outcome.durationMs);
+      peakRss = Math.max(peakRss, process.memoryUsage().rss);
+    }
+    return {
+      schema: 1,
+      kind: "plugin-hook",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      config: {
+        pluginId: opts.pluginId,
+        hook: opts.hook,
+        dir: opts.dir,
+        repeat: opts.repeat,
+        warmupRuns: opts.warmupRuns
+      },
+      machine: machineInfo(),
+      caveats: [
+        "Baselines are only valid on the same machine and environment \u2014 absolute sandbox timings (worker + protocol + probes) are not comparable across machines."
+      ],
+      memoryPeakMb: Math.round(peakRss / 1024 / 1024 * 10) / 10,
+      samplesMs: samples,
+      stats: computeStats(samples)
+    };
+  })();
+}
+function computeStats(samples) {
+  const sorted = [...samples].sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)] ?? 0;
+  const mean = samples.reduce((a, b) => a + b, 0) / Math.max(1, samples.length);
+  const p95 = sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))] ?? 0;
+  return {
+    medianMs: round1(median),
+    meanMs: round1(mean),
+    p95Ms: round1(p95),
+    minMs: round1(sorted[0] ?? 0),
+    maxMs: round1(sorted[sorted.length - 1] ?? 0)
+  };
+}
+function loadBaseline(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err2) {
+    throw new Error(
+      `cannot read baseline file ${path}: ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+  }
+  if (!isBenchReport(parsed)) {
+    throw new Error(
+      `baseline file ${path} is not a bench report (kind plugin-hook)`
+    );
+  }
+  return parsed;
+}
+function isBenchReport(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (v.schema !== 1) return false;
+  if (v.kind !== "plugin-hook") return false;
+  if (typeof v.timestamp !== "string") return false;
+  const config = v.config;
+  if (typeof config !== "object" || config === null || typeof config.pluginId !== "string" || typeof config.hook !== "string") {
+    return false;
+  }
+  const machine = v.machine;
+  if (typeof machine !== "object" || machine === null || typeof machine.node !== "string") {
+    return false;
+  }
+  const stats = v.stats;
+  return typeof stats === "object" && stats !== null && typeof stats.medianMs === "number";
+}
+function compareBaseline(report, baseline, thresholdPercent) {
+  if (fingerprint(report.machine) !== fingerprint(baseline.machine)) {
+    console.warn(
+      `WARNING: baseline machine differs (fresh: ${fingerprint(report.machine)} vs baseline: ${fingerprint(baseline.machine)}) \u2014 sandbox timings are not comparable across machines.`
+    );
+  }
+  const ratio = report.stats.medianMs / Math.max(1e-4, baseline.stats.medianMs);
+  const regressed = report.stats.medianMs > baseline.stats.medianMs * (1 + thresholdPercent / 100);
+  const delta = ((ratio - 1) * 100).toFixed(1);
+  const message = regressed ? `REGRESSION: median ${report.stats.medianMs}ms vs baseline ${baseline.stats.medianMs}ms (${delta}%) exceeds the ${thresholdPercent}% threshold. Baselines are only valid on the same machine and environment \u2014 absolute sandbox timings (worker + protocol + probes) are not comparable across machines.` : `median ${report.stats.medianMs}ms vs baseline ${baseline.stats.medianMs}ms (${delta}%) \u2014 within the ${thresholdPercent}% threshold.`;
+  return { baseline, ratio, regressed, message };
+}
+function writeReport(path, report) {
+  writeFileSync(path, `${JSON.stringify(report, null, 2)}
+`);
+}
+function formatBenchSummary(report) {
+  const lines = [
+    `hook ${report.config.hook} \xD7 ${report.config.repeat} (${report.config.warmupRuns} warmup)`,
+    `plugin ${report.config.pluginId}`,
+    `machine ${report.machine.platform}/${report.machine.arch} \xB7 ${report.machine.cpus} cpus (${report.machine.cpuModel}) \xB7 node ${report.machine.node} \xB7 peak rss ${report.memoryPeakMb}MB`,
+    `samples: ${report.samplesMs.map((ms) => `${ms.toFixed(1)}ms`).join(" ")}`,
+    `median ${report.stats.medianMs}ms \xB7 mean ${report.stats.meanMs}ms \xB7 p95 ${report.stats.p95Ms}ms \xB7 min ${report.stats.minMs}ms \xB7 max ${report.stats.maxMs}ms`
+  ];
+  return lines.join("\n");
+}
+function benchExitCode(compare) {
+  if (compare === void 0) return EXIT_PASS;
+  return compare.regressed ? EXIT_REGRESSION : EXIT_PASS;
+}
+function round1(value) {
+  return Math.round(value * 10) / 10;
+}
+var KNOWN_FUNCTIONS = /* @__PURE__ */ new Set([
+  "asset",
+  "bytes",
+  "duration",
+  "eq",
+  "gt",
+  "gte",
+  "icon",
+  "if",
+  "inc",
+  "join",
+  "kind",
+  "lt",
+  "lte",
+  "ne",
+  "number",
+  "searchKindIcons",
+  "t"
+]);
+function lintTemplate(template, i18nKeys) {
+  const issues = [];
+  const open = (template.match(/\{\{/g) ?? []).length;
+  const close = (template.match(/\}\}/g) ?? []).length;
+  if (open !== close) {
+    return [
+      {
+        template,
+        message: `unbalanced {{ }} braces (${open} open, ${close} close)`
+      }
+    ];
+  }
+  for (const fragment of parseTemplateFragments(template)) {
+    if (fragment.kind !== "expr") continue;
+    lintExpression(fragment.source, template, i18nKeys, issues);
+  }
+  return issues;
+}
+function lintExpression(source, template, i18nKeys, issues) {
+  const tokens = tokeniseExpression(source);
+  const opens = tokens.filter((t) => t.kind === "lparen").length;
+  const closes = tokens.filter((t) => t.kind === "rparen").length;
+  if (opens !== closes) {
+    issues.push({
+      template,
+      message: `unbalanced parentheses in {{${source}}} (${opens} open, ${closes} close)`
+    });
+    return;
+  }
+  const expr = parseTemplateExpression(source);
+  if (expr === void 0) {
+    issues.push({
+      template,
+      message: `cannot parse expression "{{${source}}}" (expected a call or path)`
+    });
+    return;
+  }
+  walkExpr(expr, (call) => {
+    if (!KNOWN_FUNCTIONS.has(call.name)) {
+      issues.push({
+        template,
+        message: `unknown function "${call.name}" (known: ${[...KNOWN_FUNCTIONS].join(", ")})`
+      });
+      return;
+    }
+    if (call.name === "t") {
+      const key = firstStringArg(call.args);
+      if (key !== void 0 && !i18nKeys.has(key)) {
+        issues.push({
+          template,
+          message: `t('${key}') references an i18n key the manifest does not declare`
+        });
+      }
+    }
+  });
+}
+function walkExpr(expr, visit) {
+  if (expr.kind !== "call") return;
+  visit(expr);
+  for (const arg of expr.args) {
+    if (arg.kind === "expr") walkExpr(arg.expr, visit);
+  }
+}
+function firstStringArg(args) {
+  const first = args[0];
+  if (first?.kind === "string") return first.value;
+  return void 0;
+}
+function manifestTemplates(manifest) {
+  const templates = [];
+  for (const block of Object.values(manifest.ui?.card ?? {})) {
+    if (block === void 0) continue;
+    for (const corner of [block.tl, block.tr, block.bl, block.br]) {
+      if (corner !== void 0) templates.push(...corner);
+    }
+  }
+  for (const kind of manifest.ui?.search?.kinds ?? []) {
+    templates.push(kind.label);
+    if (kind.icon !== void 0) templates.push(kind.icon);
+  }
+  if (manifest.ui?.message?.anchor !== void 0) {
+    templates.push(manifest.ui.message.anchor);
+  }
+  return templates;
+}
+function lintManifestTemplates(manifest) {
+  const templates = manifestTemplates(manifest);
+  const i18nKeys = new Set(Object.keys(manifest.i18n ?? {}));
+  const issues = [];
+  for (const template of templates) {
+    issues.push(...lintTemplate(template, i18nKeys));
+  }
+  return { templates, issues };
+}
+
+// src/build.ts
+function isWatcher(result) {
+  return "on" in result;
+}
+async function buildPlugin(dir, opts) {
+  const watchMode = opts.watch;
+  const manifestPath = join(dir, "manifest.json");
+  if (!existsSync(manifestPath)) {
+    throw new Error(`No manifest.json found in ${dir}`);
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  if (typeof manifest.id !== "string" || manifest.id.length === 0) {
+    throw new Error("manifest.json missing id field");
+  }
+  lintTemplates(manifest);
+  const outDir = join(dir, "dist");
+  if (!watchMode) {
+    rmSync(outDir, { recursive: true, force: true });
+  }
+  mkdirSync(outDir, { recursive: true });
+  const htmlEntry = join(dir, "index.html");
+  const mainEntry = join(dir, "src", "main.ts");
+  if (existsSync(htmlEntry)) {
+    const result = await build({
+      root: dir,
+      base: "./",
+      // React Compiler only on the iframe client build; the server
+      // (SSR) bundle runs in a worker sandbox with no rendering.
+      plugins: [
+        react(),
+        babel({ presets: [reactCompilerPreset()] }),
+        tailwindcss()
+      ],
+      build: {
+        outDir,
+        emptyOutDir: false,
+        chunkSizeWarningLimit: Infinity,
+        rollupOptions: {
+          input: htmlEntry
+        },
+        watch: watchMode ? {} : null
+      }
+    });
+    if (watchMode && isWatcher(result)) {
+      result.on("event", (event) => {
+        if (event.code === "END") {
+          console.log(`[watch] ${manifest.id} client rebuilt`);
+        } else if (event.code === "ERROR") {
+          console.error(`[watch] ${manifest.id} client error:`, event.error);
+        }
+      });
+    }
+  }
+  if (existsSync(mainEntry)) {
+    const result = await build({
+      root: dir,
+      plugins: [react()],
+      // The server bundle runs inside the permission-model sandbox,
+      // which grants fs-read to the plugin dir only and lets the module
+      // policy gate load nothing outside it — the bundle must be one
+      // self-contained ESM file. Vite's default externalizes
+      // node_modules dependencies, which is exactly what an installed
+      // (tarball/npm) plugin hits: its `main.js` would keep bare
+      // `@hoardodile/*` imports whose resolution the sandbox denies.
+      // Inline everything instead (workspace plugins already ended up
+      // inlined via source resolution — this makes both cases uniform).
+      ssr: { noExternal: true },
+      build: {
+        ssr: mainEntry,
+        outDir,
+        emptyOutDir: false,
+        target: "node24",
+        rollupOptions: {
+          output: {
+            entryFileNames: "main.js",
+            chunkFileNames: "[name].js"
+          },
+          external: []
+        },
+        watch: watchMode ? {} : null
+      }
+    });
+    assertSelfContainedServerBundle(join(outDir));
+    if (watchMode && isWatcher(result)) {
+      result.on("event", (event) => {
+        if (event.code === "END") {
+          assertSelfContainedServerBundle(join(outDir));
+          console.log(`[watch] ${manifest.id} server rebuilt`);
+        } else if (event.code === "ERROR") {
+          console.error(`[watch] ${manifest.id} server error:`, event.error);
+        }
+      });
+    }
+  }
+  copyFileSync(manifestPath, join(outDir, "manifest.json"));
+  if (watchMode) {
+    watch(manifestPath, () => {
+      copyFileSync(manifestPath, join(outDir, "manifest.json"));
+      console.log(`[watch] ${manifest.id} manifest updated`);
+    });
+    console.log(`[watch] ${manifest.id} watching for changes...`);
+    await new Promise(() => {
+    });
+  }
+  console.log(`${manifest.id} \u2192 ${outDir}`);
+}
+function lintTemplates(manifest) {
+  const { templates, issues } = lintManifestTemplates(manifest);
+  if (templates.length === 0) return;
+  const errors = issues.filter((issue) => !issue.message.includes("i18n key"));
+  if (errors.length > 0) {
+    const detail = errors.map((issue) => `  - ${issue.message}
+    ${issue.template}`).join("\n");
+    throw new Error(`manifest template validation failed:
+${detail}`);
+  }
+  for (const issue of issues.filter(
+    (issue2) => issue2.message.includes("i18n key")
+  )) {
+    console.warn(`[build] warning: ${issue.message}
+    ${issue.template}`);
+  }
+}
+function assertSelfContainedServerBundle(outDir) {
+  for (const file of readdirSync(outDir, { withFileTypes: true })) {
+    if (!file.isFile() || !file.name.endsWith(".js")) continue;
+    const source = readFileSync(join(outDir, file.name), "utf-8");
+    if (/(?:from\s*["']node:|import\s*\(\s*["']node:)/.test(source)) {
+      throw new Error(
+        `plugin main bundle (${file.name}) imports a Node builtin \u2014 the plugin main process cannot use node:fs/net/child_process/\u2026; read files and probe metadata through the ResourceAPI instead`
+      );
+    }
+    if (/\brequire\s*\(/.test(source)) {
+      throw new Error(
+        `plugin main bundle (${file.name}) calls require() \u2014 the plugin main process is self-contained; use the ResourceAPI instead`
+      );
+    }
+    if (/(?:from\s*["']|import\s*\(\s*["'])(?![./])/.test(source)) {
+      throw new Error(
+        `plugin main bundle (${file.name}) leaves a bare import unresolved \u2014 the SDK closure must be inlined; the plugin sandbox cannot load node_modules`
+      );
+    }
+  }
+}
+function resolveCreateArgs(opts) {
+  const args = ["dlx", "--yes", "create-hoardodile-plugin"];
+  if (opts.name !== void 0) args.push(opts.name);
+  if (opts.tarballs !== void 0) args.push("--tarballs", opts.tarballs);
+  return args;
+}
+async function executeCreate(opts) {
+  return new Promise((resolveExit) => {
+    const child = spawn("pnpm", resolveCreateArgs(opts), {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", (err2) => {
+      console.error(
+        `[hoardodile] failed to start create-hoardodile-plugin: ${err2.message}`
+      );
+      resolveExit(EXIT_ERROR);
+    });
+    child.on("exit", (code) => {
+      resolveExit(code ?? EXIT_ERROR);
+    });
+  });
+}
+function snapshotDetect(detection) {
+  return detection.ok ? { ok: true } : { ok: false, reasons: detection.reasons };
+}
+function resolveBuiltPluginTarget(pluginDir) {
+  const manifestPath = join(pluginDir, "manifest.json");
+  if (!existsSync(manifestPath)) {
+    throw new CliError(`no manifest.json found in ${pluginDir}`);
+  }
+  const mainPath = join(pluginDir, "dist", "main.js");
+  if (!existsSync(mainPath)) {
+    throw new CliError(`plugin bundle not built: ${mainPath}`);
+  }
+  const manifest = pluginManifest.parse(
+    JSON.parse(readFileSync(manifestPath, "utf8"))
+  );
+  return { id: manifest.id, manifest, mainPath, dirPath: pluginDir };
+}
+async function captureHookSnapshot(opts) {
+  const { target, api } = opts;
+  const sandbox = createPluginSandbox(DEFAULT_SANDBOX_CONFIG);
+  try {
+    const hooks = await createCliHooks(target, sandbox);
+    return await collectHookResults({ target, api, hooks });
+  } finally {
+    await sandbox.disposeAll();
+  }
+}
+async function collectHookResults(opts) {
+  const { target, api, hooks } = opts;
+  const errors = {};
+  async function attempt(hook, run) {
+    try {
+      return await run();
+    } catch (err2) {
+      errors[hook] = err2 instanceof Error ? err2.message : String(err2);
+      return void 0;
+    }
+  }
+  const detect = snapshotDetect(
+    await attempt("detect", () => hooks.detectForPlugin(api, target.id)) ?? {
+      ok: false,
+      reasons: ["detect threw an exception"]
+    }
+  );
+  const meta = await attempt("meta", () => hooks.runMetaHooks(api, target.id));
+  const files = await attempt(
+    "listFiles",
+    () => hooks.buildFileList(api, target.id)
+  );
+  const coverLocal = await attempt(
+    "coverLocal",
+    () => hooks.resolveLocalCoverSource(api, target.id)
+  );
+  const hashes = hooks.supportsImageHashes(target.id) ? await attempt("imageHashes", () => hooks.runImageHashes(api, target.id)) : void 0;
+  const fileStats = await attempt("fileStats", () => measureFileStats(api)) ?? {};
+  return {
+    pluginId: target.id,
+    detect,
+    sourceMeta: meta?.sourceMeta?.value,
+    searchMeta: meta?.searchMeta?.value,
+    coverLocal,
+    files,
+    fileStats,
+    imageHashes: hashes?.hashes,
+    errors,
+    capturedAt: Date.now()
+  };
+}
+async function measureFileStats(api) {
+  const names = await api.listFileNames();
+  const stats = await api.statFiles(names);
+  let sizeBytes = 0;
+  for (const stat of stats) sizeBytes += stat?.sizeBytes ?? 0;
+  return { count: names.length, sizeBytes };
+}
+function formatHookSnapshot(snapshot) {
+  const parts = [
+    snapshot.detect.ok ? "detect ok" : `detect miss (${(snapshot.detect.reasons ?? []).join(", ")})`,
+    `${snapshot.fileStats.count ?? 0} files`
+  ];
+  if (snapshot.files !== void 0) {
+    parts.push(`listFiles ${snapshot.files.length}`);
+  }
+  if (snapshot.sourceMeta !== void 0) parts.push("sourceMeta");
+  if (snapshot.searchMeta !== void 0) parts.push("searchMeta");
+  if (snapshot.coverLocal !== void 0) {
+    parts.push(`cover ${snapshot.coverLocal}`);
+  }
+  for (const [hook, message] of Object.entries(snapshot.errors)) {
+    parts.push(`${hook} failed: ${message}`);
+  }
+  return parts.join(" \xB7 ");
+}
+function cacheKey(resId, path, suffix = "") {
+  return createHash("sha256").update(`${resId}\0${path}${suffix}`).digest("hex").slice(0, 32);
+}
+function contentTypeOf(format) {
+  return format === "webp" ? "image/webp" : "image/avif";
+}
+function createRenderProviders(opts) {
+  let renderPromise;
+  function loadRender() {
+    renderPromise ??= import('@hoardodile/host/render').catch(
+      (err2) => {
+        console.warn(
+          `[hoardodile] preview and frame rendering are unavailable \u2014 install "sharp" (and an ffmpeg binary for video) to enable them: ${err2 instanceof Error ? err2.message : String(err2)}`
+        );
+        return void 0;
+      }
+    );
+    return renderPromise;
+  }
+  async function readEntry(api, path) {
+    try {
+      return await api.readFile(path);
+    } catch {
+      return void 0;
+    }
+  }
+  function cached(base) {
+    for (const format of ["avif", "webp"]) {
+      const path = `${base}.${format}`;
+      if (existsSync(path)) return { path, contentType: contentTypeOf(format) };
+    }
+    return void 0;
+  }
+  async function cover(resId) {
+    if (opts.resolveCoverSource === void 0) return void 0;
+    const source = await opts.resolveCoverSource(resId);
+    if (source === void 0) return void 0;
+    const api = await opts.resolveApi(resId);
+    if (api === void 0) return void 0;
+    const type = await api.sniff(source);
+    const kind = type?.kind;
+    if (kind !== "image" && kind !== "video" && kind !== "audio") {
+      return void 0;
+    }
+    const ext = type?.ext ?? extname(source).toLowerCase();
+    const base = join(opts.cacheDir, `cover-${cacheKey(resId, source)}`);
+    const hit = cached(base);
+    if (hit !== void 0) return hit;
+    const render = await loadRender();
+    if (render === void 0) return void 0;
+    await mkdir(opts.cacheDir, { recursive: true });
+    try {
+      if (kind === "image") {
+        const bytes = await readEntry(api, source);
+        if (bytes === void 0) return void 0;
+        const rendered = await render.renderImageThumbOnce({
+          input: Buffer.from(bytes),
+          ext,
+          resolveDest: (format) => `${base}.${format}`,
+          variant: {
+            format: "avif",
+            fit: "inside",
+            maxArea: RESOURCE_COVER_MAX_AREA,
+            webpQuality: render.WEBP_QUALITY,
+            avifQuality: render.AVIF_QUALITY
+          }
+        });
+        return {
+          path: rendered.path,
+          contentType: contentTypeOf(rendered.format)
+        };
+      }
+      const sourcePath = join(
+        opts.cacheDir,
+        `source-${cacheKey(resId, source, "cover")}${ext}`
+      );
+      if (!existsSync(sourcePath)) {
+        const bytes = await readEntry(api, source);
+        if (bytes === void 0) return void 0;
+        await writeFile(sourcePath, bytes);
+      }
+      const destPath = `${base}.avif`;
+      if (kind === "video") {
+        await render.renderVideoFrame({
+          source: sourcePath,
+          destPath,
+          ffmpeg: render.resolveFfmpegPaths(),
+          maxArea: RESOURCE_COVER_MAX_AREA,
+          quality: render.AVIF_QUALITY,
+          format: "avif",
+          timeSeconds: 0,
+          ext
+        });
+      } else {
+        await render.renderAudioCoverArt({
+          source: sourcePath,
+          destPath,
+          ffmpeg: render.resolveFfmpegPaths(),
+          maxArea: RESOURCE_COVER_MAX_AREA,
+          quality: render.AVIF_QUALITY,
+          format: "avif",
+          ext
+        });
+      }
+      return { path: destPath, contentType: "image/avif" };
+    } catch (err2) {
+      console.warn(
+        `[hoardodile] cover render failed for ${source}: ${err2 instanceof Error ? err2.message : String(err2)}`
+      );
+      return void 0;
+    }
+  }
+  async function preview(resId, path, variant) {
+    const api = await opts.resolveApi(resId);
+    if (api === void 0) return void 0;
+    if ((await api.sniff(path))?.kind !== "image") return void 0;
+    const parsed = parseImageVariantQuery(variant ?? {});
+    if (parsed.kind !== "variant") return void 0;
+    const render = await loadRender();
+    if (render === void 0) return void 0;
+    const resolved = normalizeImageVariantSpec(parsed.spec, {
+      avifQuality: render.PREVIEW_AVIF_QUALITY,
+      webpQuality: render.PREVIEW_WEBP_QUALITY
+    });
+    const base = join(
+      opts.cacheDir,
+      `preview-${cacheKey(resId, path, imageVariantCanonical(resolved))}`
+    );
+    const hit = cached(base);
+    if (hit !== void 0) return hit;
+    const bytes = await readEntry(api, path);
+    if (bytes === void 0) return void 0;
+    await mkdir(opts.cacheDir, { recursive: true });
+    try {
+      const rendered = await render.renderImageThumbOnce({
+        input: Buffer.from(bytes),
+        resolveDest: (format) => `${base}.${format}`,
+        variant: resolved
+      });
+      return {
+        path: rendered.path,
+        contentType: contentTypeOf(rendered.format)
+      };
+    } catch (err2) {
+      console.warn(
+        `[hoardodile] preview render failed for ${path}: ${err2 instanceof Error ? err2.message : String(err2)}`
+      );
+      return void 0;
+    }
+  }
+  async function frame(resId, path, timeMs) {
+    const api = await opts.resolveApi(resId);
+    if (api === void 0) return void 0;
+    const type = await api.sniff(path);
+    if (type?.kind !== "video") return void 0;
+    const destPath = join(
+      opts.cacheDir,
+      `frame-${cacheKey(resId, path, `@${timeMs}`)}.avif`
+    );
+    if (existsSync(destPath)) {
+      return { path: destPath, contentType: "image/avif" };
+    }
+    const render = await loadRender();
+    if (render === void 0) return void 0;
+    const sourcePath = join(
+      opts.cacheDir,
+      `source-${cacheKey(resId, path)}${type.ext}`
+    );
+    if (!existsSync(sourcePath)) {
+      const bytes = await readEntry(api, path);
+      if (bytes === void 0) return void 0;
+      await mkdir(opts.cacheDir, { recursive: true });
+      await writeFile(sourcePath, bytes);
+    }
+    try {
+      await render.renderVideoFrame({
+        source: sourcePath,
+        destPath,
+        ffmpeg: render.resolveFfmpegPaths(),
+        maxArea: RESOURCE_PREVIEW_MAX_AREA,
+        quality: render.PREVIEW_AVIF_QUALITY,
+        format: "avif",
+        timeSeconds: timeMs / 1e3,
+        ext: type.ext
+      });
+      return { path: destPath, contentType: "image/avif" };
+    } catch (err2) {
+      console.warn(
+        `[hoardodile] frame render failed for ${path}@${timeMs}ms: ${err2 instanceof Error ? err2.message : String(err2)}`
+      );
+      return void 0;
+    }
+  }
+  return { cover, preview, frame };
+}
+var requireBuiltin = createRequire(import.meta.url);
+function parseJson(value) {
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function openReadOnly(dbPath) {
+  const { DatabaseSync: Database } = requireBuiltin("node:sqlite");
+  try {
+    return new Database(dbPath, { readOnly: true });
+  } catch (err2) {
+    const snapshotDir = mkdtempSync(join(tmpdir(), "hoardodile-wb-"));
+    const dir = resolve(dbPath, "..");
+    const base = dbPath.slice(dir.length + 1);
+    let copied = false;
+    for (const entry of readdirSync(dir)) {
+      if (!entry.startsWith(base)) continue;
+      copyFileSync(join(dir, entry), join(snapshotDir, entry));
+      copied = entry === base || copied;
+    }
+    if (!copied) throw err2;
+    console.log(
+      `[hoardodile] database is busy \u2014 reading a temporary copy (${snapshotDir})`
+    );
+    return new Database(join(snapshotDir, base), { readOnly: true });
+  }
+}
+function openStorage(rootDir) {
+  const root = resolve(rootDir);
+  const dbPath = join(root, "app.sqlite");
+  if (!existsSync(dbPath)) {
+    throw new Error(
+      `no app.sqlite in ${root} \u2014 point --storage at a hoardodile data root`
+    );
+  }
+  const db = openReadOnly(dbPath);
+  const paths = createStoragePaths({ root });
+  function rowToResource(row) {
+    const stats = parseJson(row.file_stats);
+    return {
+      id: String(row.id),
+      name: String(row.name ?? row.id),
+      contentPluginId: asString(row.content_plugin_id),
+      fileVersion: Number(row.file_version ?? 1),
+      sourceMeta: parseJson(row.source_meta),
+      searchMeta: parseJson(row.search_meta),
+      fileStats: typeof stats === "object" && stats !== null ? stats : void 0
+    };
+  }
+  const listStmt = db.prepare(
+    `SELECT r.id, r.name, r.content_plugin_id, r.file_version,
+		        m.source_meta, m.search_meta, m.file_stats
+		   FROM resources r
+		   LEFT JOIN resource_meta m ON m.resource_id = r.id
+		  WHERE r.deleted_at IS NULL
+		  ORDER BY r.created_at DESC`
+  );
+  const findStmt = db.prepare(
+    `SELECT r.id, r.name, r.content_plugin_id, r.file_version,
+		        m.source_meta, m.search_meta, m.file_stats
+		   FROM resources r
+		   LEFT JOIN resource_meta m ON m.resource_id = r.id
+		  WHERE r.id = ?`
+  );
+  const commentsStmt = db.prepare(
+    `SELECT c.id, c.body, c.created_at, c.floor, c.anchor_data
+		   FROM comments c
+		   JOIN comment_resources cr ON cr.comment_id = c.id
+		  WHERE cr.resource_id = ? AND c.deleted_at IS NULL
+		  ORDER BY c.created_at ASC`
+  );
+  const danmakuStmt = db.prepare(
+    `SELECT id, anchor_data, text, color, mode, created_at
+		   FROM danmakus
+		  WHERE anchor_resource_id = ?
+		  ORDER BY created_at ASC`
+  );
+  const prefsStmt = db.prepare(
+    `SELECT key, value FROM plugin_preferences WHERE plugin_id = ?`
+  );
+  const cacheStmt = db.prepare(
+    `SELECT key, value FROM plugin_cache WHERE plugin_id = ? AND res_id = ?`
+  );
+  function keyValues(rows) {
+    const out = {};
+    for (const row of rows) out[String(row.key)] = String(row.value);
+    return out;
+  }
+  return {
+    listResources() {
+      return listStmt.all().map(rowToResource);
+    },
+    findResource(resId) {
+      const row = findStmt.get(resId);
+      return row === void 0 ? void 0 : rowToResource(row);
+    },
+    readState(resId, pluginId) {
+      const resource = this.findResource(resId);
+      return {
+        name: resource?.name ?? resId,
+        messages: commentsStmt.all(resId).map((row) => ({
+          id: String(row.id),
+          body: String(row.body ?? ""),
+          createdAt: Number(row.created_at ?? 0),
+          charIds: [],
+          resIds: [resId],
+          likeCount: 0,
+          dislikeCount: 0,
+          replyCount: 0,
+          floor: row.floor === null ? void 0 : Number(row.floor),
+          anchor: {
+            resId,
+            data: parseJson(row.anchor_data)?.data
+          }
+        })),
+        danmaku: danmakuStmt.all(resId).map((row) => ({
+          id: String(row.id),
+          anchor: {
+            resId,
+            data: parseJson(row.anchor_data)?.data
+          },
+          text: String(row.text ?? ""),
+          color: String(row.color ?? ""),
+          mode: String(row.mode ?? "scroll"),
+          createdAt: Number(row.created_at ?? 0)
+        })),
+        prefs: keyValues(prefsStmt.all(pluginId)),
+        cache: keyValues(cacheStmt.all(pluginId, resId))
+      };
+    },
+    archivePath(resource) {
+      return paths.atVersion(resource.fileVersion).resource(resource.id);
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+
+// src/dev.ts
+var RECAPTURE_DEBOUNCE_MS = 300;
+var FIRST_BUILD_TIMEOUT_MS = 6e4;
+var RESOURCE_LIST_LIMIT = 200;
+var DIRECTORY_RES_ID = "workbench";
+function resolvePluginDir(value) {
+  const dir = resolve(value ?? ".");
+  if (!existsSync(join(dir, "manifest.json"))) {
+    throw new Error(
+      `no manifest.json found in ${dir} \u2014 run this from a plugin directory or pass --plugin-dir`
+    );
+  }
+  return dir;
+}
+function hasWatchScript(pluginDir) {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(pluginDir, "package.json"), "utf8")
+    );
+    return typeof pkg?.scripts?.watch === "string";
+  } catch {
+    return false;
+  }
+}
+async function loadWorkbenchServe(pluginDir) {
+  const requireFromPlugin = createRequire(join(pluginDir, "package.json"));
+  let workbenchEntry;
+  try {
+    workbenchEntry = requireFromPlugin.resolve("@hoardodile/workbench");
+  } catch {
+    throw new Error(
+      "@hoardodile/workbench not found in this plugin's dependencies \u2014 add it to devDependencies (the template and `create-hoardodile-plugin` include it) and run `pnpm install`."
+    );
+  }
+  return import(pathToFileURL(workbenchEntry).href);
+}
+function spawnWatcher(opts) {
+  console.log(`[hoardodile] starting ${opts.label}`);
+  return spawn(opts.command, [...opts.args], {
+    cwd: opts.cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+}
+function startBuildWatcher(pluginDir) {
+  const watcher = hasWatchScript(pluginDir) ? spawnWatcher({
+    command: "pnpm",
+    args: ["watch"],
+    cwd: pluginDir,
+    label: `\`pnpm watch\` in ${pluginDir}`
+  }) : spawnWatcher({
+    command: process.execPath,
+    args: [process.argv[1] ?? "", "plugin", "build", "--watch"],
+    cwd: pluginDir,
+    label: "`plugin build --watch` (no watch script found)"
+  });
+  watcher.on("error", (err2) => {
+    console.error(`[hoardodile] build watcher failed: ${err2.message}`);
+    process.exitCode = EXIT_ERROR;
+  });
+  watcher.on("exit", (code) => {
+    if (code !== null && code !== 0) {
+      console.error(`[hoardodile] build watcher exited with code ${code}`);
+      process.exitCode = EXIT_ERROR;
+    }
+  });
+  return watcher;
+}
+async function waitForBuild(distDir, timeoutMs) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    if (existsSync(join(distDir, "main.js"))) return true;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+function directorySource(dataDir, extractCacheDir) {
+  const api = buildCliResourceAPI(dataDir, { extractCacheDir });
+  return {
+    list: () => [{ id: DIRECTORY_RES_ID, name: "Workbench" }],
+    apiFor: (resId) => resId === DIRECTORY_RES_ID ? api : void 0,
+    stateFor: () => void 0,
+    extractCacheDir
+  };
+}
+function storageSource(storage, extractCacheDir) {
+  const apis = /* @__PURE__ */ new Map();
+  return {
+    list: () => storage.listResources().slice(0, RESOURCE_LIST_LIMIT).map((resource) => ({
+      id: resource.id,
+      name: resource.name,
+      contentPluginId: resource.contentPluginId
+    })),
+    apiFor(resId) {
+      if (apis.has(resId)) return apis.get(resId);
+      const resource = storage.findResource(resId);
+      const archive = resource === void 0 ? void 0 : storage.archivePath(resource);
+      const api = archive !== void 0 && existsSync(archive) ? buildArchiveResourceAPI(archive, extractCacheDir) : void 0;
+      if (api === void 0 && resource !== void 0) {
+        console.warn(`[hoardodile] no source archive for resource ${resId}`);
+      }
+      apis.set(resId, api);
+      return api;
+    },
+    stateFor: (resId, pluginId) => storage.readState(resId, pluginId),
+    extractCacheDir,
+    close: () => storage.close()
+  };
+}
+function createSnapshotStore(opts) {
+  const snapshots = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Map();
+  async function capture(resId) {
+    const api = opts.source.apiFor(resId);
+    if (api === void 0) return;
+    try {
+      const target = resolveBuiltPluginTarget(opts.pluginDir);
+      const snapshot = await captureHookSnapshot({ target, api });
+      snapshots.set(resId, snapshot);
+      console.log(`[hoardodile] ${resId}: ${formatHookSnapshot(snapshot)}`);
+      if (!snapshot.detect.ok) {
+        console.error(
+          "[hoardodile] detect failed \u2014 the plugin may not match this resource."
+        );
+      }
+    } catch (err2) {
+      console.error(
+        `[hoardodile] hook snapshot failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+      );
+    }
+  }
+  function refresh(resId) {
+    const inFlight = running.get(resId);
+    if (inFlight !== void 0) return inFlight;
+    const run = capture(resId).finally(() => running.delete(resId));
+    running.set(resId, run);
+    return run;
+  }
+  return {
+    /** Capture on demand, then serve the cached result. */
+    async read(resId) {
+      if (!snapshots.has(resId)) await refresh(resId);
+      return snapshots.get(resId);
+    },
+    /** Drop every capture so the next read re-runs against the new build. */
+    invalidate() {
+      snapshots.clear();
+    },
+    captured: () => [...snapshots.keys()],
+    refresh
+  };
+}
+function watchDistForRebuilds(distDir, onRebuild) {
+  let timer;
+  const watcher = watch(distDir, () => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = setTimeout(onRebuild, RECAPTURE_DEBOUNCE_MS);
+  });
+  return () => {
+    if (timer !== void 0) clearTimeout(timer);
+    watcher.close();
+  };
+}
+function resolveSource(opts) {
+  const extractCacheDir = join(opts.pluginDir, ".hoardodile", "extract");
+  if (opts.storageDir !== void 0) {
+    const root = resolve(opts.storageDir);
+    const storage = openStorage(root);
+    const count = storage.listResources().length;
+    console.log(`[hoardodile] storage: ${root} (${count} resources, read-only)`);
+    return storageSource(storage, extractCacheDir);
+  }
+  const dataDir = opts.dataDir !== void 0 ? resolve(opts.dataDir) : join(resolve(opts.pluginDir ?? "."), "testdata");
+  if (!existsSync(dataDir)) {
+    console.warn(
+      `[hoardodile] no data dir found at ${dataDir} \u2014 mount one with --data (or --storage <hoardodile-root>).`
+    );
+    return void 0;
+  }
+  console.log(`[hoardodile] data: ${dataDir}`);
+  return directorySource(dataDir, extractCacheDir);
+}
+async function executeDev(opts) {
+  const pluginDir = resolvePluginDir(opts.pluginDir);
+  const distDir = join(pluginDir, "dist");
+  const source = resolveSource({ ...opts, pluginDir });
+  const target = existsSync(join(distDir, "main.js")) ? resolveBuiltPluginTarget(pluginDir) : void 0;
+  const watcher = startBuildWatcher(pluginDir);
+  const snapshots = source === void 0 ? void 0 : createSnapshotStore({ pluginDir, source });
+  const render = source === void 0 ? void 0 : createRenderProviders({
+    resolveApi: async (resId) => source.apiFor(resId),
+    // The plugin's coverLocal pick is captured in the hook
+    // snapshot; the cover render feeds the workbench picker.
+    resolveCoverSource: async (resId) => (await snapshots?.read(resId))?.coverLocal,
+    // Rendered artifacts live with the plugin, never inside
+    // the user's storage root.
+    cacheDir: join(pluginDir, ".hoardodile", "cache")
+  });
+  const { serveWorkbench } = await loadWorkbenchServe(pluginDir);
+  const server = await serveWorkbench({
+    pluginDir: distDir,
+    port: opts.port,
+    // User-consented dev downloads land in the plugin's own scratch
+    // vault, next to the extraction cache — never in the read-only
+    // storage root or the data dir.
+    vaultRoot: join(pluginDir, ".hoardodile", "vault"),
+    providers: {
+      resources: () => source?.list() ?? [],
+      files: source === void 0 ? void 0 : createFileProvider(source),
+      snapshot: (resId) => snapshots?.read(resId),
+      state: (resId) => source?.stateFor(resId, target?.id ?? ""),
+      preview: render?.preview,
+      frame: render?.frame,
+      cover: render?.cover
+    }
+  });
+  let stopDistWatch;
+  if (await waitForBuild(distDir, FIRST_BUILD_TIMEOUT_MS)) {
+    const first = opts.resId ?? source?.list()[0]?.id;
+    if (first !== void 0) await snapshots?.refresh(first);
+    stopDistWatch = watchDistForRebuilds(distDir, () => {
+      const captured = snapshots?.captured() ?? [];
+      snapshots?.invalidate();
+      for (const resId of captured) void snapshots?.refresh(resId);
+    });
+  } else {
+    console.error(
+      "[hoardodile] no dist/main.js appeared within 60s \u2014 is the build working?"
+    );
+  }
+  await new Promise((resolveStop) => {
+    const stop = () => {
+      stopDistWatch?.();
+      watcher.kill();
+      source?.close?.();
+      server.close(() => resolveStop());
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  return EXIT_PASS;
+}
+function createFileProvider(source) {
+  return {
+    async list(resId) {
+      return await source.apiFor(resId)?.listFileNames() ?? [];
+    },
+    async stat(resId, path) {
+      return source.apiFor(resId)?.statFile(path);
+    },
+    async read(resId, path) {
+      try {
+        return await source.apiFor(resId)?.readFile(path);
+      } catch {
+        return void 0;
+      }
+    },
+    async extracted(_path, path) {
+      const root = source.extractCacheDir;
+      if (root === void 0) return void 0;
+      const abs = resolve(root, path);
+      if (abs !== resolve(root) && !abs.startsWith(resolve(root) + sep)) {
+        return void 0;
+      }
+      try {
+        return readFileSync(abs);
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+
+// src/main.ts
+function parseRepeat(value) {
+  if (value === void 0) return 5;
+  const n = Number.parseInt(value, 10);
+  if (!Number.isFinite(n) || n < 1) {
+    throw new CliError(`--repeat must be a positive integer, got "${value}"`);
+  }
+  return n;
+}
+function parseWarmup(value) {
+  if (value === void 0) return 1;
+  const n = Number.parseInt(value, 10);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new CliError(
+      `--warmup must be a non-negative integer, got "${value}"`
+    );
+  }
+  return n;
+}
+function parseThreshold(value) {
+  if (value === void 0) return 20;
+  const n = Number.parseFloat(value);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new CliError(
+      `--threshold must be a non-negative number, got "${value}"`
+    );
+  }
+  return n;
+}
+function parseHook(value) {
+  if (!HOOK_NAMES.includes(value)) {
+    throw new CliError(
+      `unknown hook "${value}" \u2014 expected one of: ${HOOK_NAMES.join(", ")}`
+    );
+  }
+  return value;
+}
+function parsePort(value) {
+  const n = Number.parseInt(value, 10);
+  if (!Number.isFinite(n) || n < 1 || n > 65535) {
+    throw new CliError(`--port must be a valid port number, got "${value}"`);
+  }
+  return n;
+}
+var main = defineCommand({
+  meta: {
+    name: "hoardodile",
+    description: "hoardodile developer CLI \u2014 content-plugin create, build, run, bench and dev commands."
+  },
+  subCommands: {
+    plugin: defineCommand({
+      meta: {
+        name: "plugin",
+        description: "Content-plugin developer commands."
+      },
+      subCommands: {
+        create: defineCommand({
+          meta: {
+            name: "create",
+            description: "Scaffold a new content plugin (runs create-hoardodile-plugin via pnpm dlx)."
+          },
+          args: {
+            name: {
+              type: "positional",
+              description: "Plugin directory name (npm-style, lowercase letters, digits and dashes). Defaults to an interactive prompt."
+            },
+            tarballs: {
+              type: "string",
+              description: "Directory of packed SDK tarballs; rewires the scaffolded plugin's SDK deps to them."
+            }
+          },
+          async run({ args }) {
+            return executeCreate({
+              name: args.name,
+              tarballs: args.tarballs
+            });
+          }
+        }),
+        run: defineCommand({
+          meta: {
+            name: "run",
+            description: "Run one plugin hook against a directory and print the JSON result."
+          },
+          args: {
+            hook: {
+              type: "positional",
+              required: true,
+              description: `Hook to run: ${HOOK_NAMES.join(", ")}`
+            },
+            dir: {
+              type: "positional",
+              required: true,
+              description: "Data directory the hook reads from."
+            },
+            pluginDir: {
+              type: "string",
+              description: "Plugin directory (manifest.json + main.js). Defaults to the --main parent."
+            },
+            main: {
+              type: "string",
+              description: "Path to the built plugin main.js. Defaults to <plugin-dir>/main.js."
+            },
+            inProcess: {
+              type: "boolean",
+              description: "Run the hook in-process instead of through the worker sandbox. Debugging only \u2014 bypasses the production execution path."
+            },
+            pretty: {
+              type: "boolean",
+              description: "Pretty-print the JSON result (indented)."
+            }
+          },
+          async run({ args }) {
+            return executeRun({
+              hook: parseHook(args.hook ?? ""),
+              dir: args.dir ?? "",
+              pluginDir: args.pluginDir,
+              main: args.main,
+              inProcess: args.inProcess === true,
+              pretty: args.pretty === true
+            });
+          }
+        }),
+        bench: defineCommand({
+          meta: {
+            name: "bench",
+            description: "Measure hook duration (sandboxed, real probes) and compare against a baseline."
+          },
+          args: {
+            hook: {
+              type: "positional",
+              required: true,
+              description: `Hook to benchmark: ${HOOK_NAMES.join(", ")}`
+            },
+            dir: {
+              type: "positional",
+              required: true,
+              description: "Data directory the hook reads from."
+            },
+            pluginDir: {
+              type: "string",
+              description: "Plugin directory (manifest.json + main.js). Defaults to the --main parent."
+            },
+            main: {
+              type: "string",
+              description: "Path to the built plugin main.js. Defaults to <plugin-dir>/main.js."
+            },
+            inProcess: {
+              type: "boolean",
+              description: "Run in-process instead of through the worker sandbox. Debugging only."
+            },
+            repeat: {
+              type: "string",
+              description: "Measured iterations after the warmup runs. Default 5."
+            },
+            warmup: {
+              type: "string",
+              description: "Discarded warmup runs before the measured samples. Default 1."
+            },
+            json: {
+              type: "string",
+              description: "Write the JSON report to this file."
+            },
+            save: {
+              type: "string",
+              description: "Save a fresh baseline report to this file."
+            },
+            compare: {
+              type: "string",
+              description: "Compare against a previous report file; exit 1 when the median regresses past --threshold."
+            },
+            threshold: {
+              type: "string",
+              description: "Regression threshold in percent of the baseline median. Default 20."
+            }
+          },
+          async run({ args }) {
+            return executeBench({
+              hook: parseHook(args.hook ?? ""),
+              dir: args.dir ?? "",
+              pluginDir: args.pluginDir,
+              main: args.main,
+              inProcess: args.inProcess === true,
+              repeat: parseRepeat(args.repeat),
+              warmupRuns: parseWarmup(args.warmup),
+              thresholdPercent: parseThreshold(args.threshold),
+              jsonPath: args.json,
+              savePath: args.save,
+              comparePath: args.compare
+            });
+          }
+        }),
+        dev: defineCommand({
+          meta: {
+            name: "dev",
+            description: "Build a plugin in watch mode and serve it in the workbench (default http://127.0.0.1:5199), with sandboxed hooks, preview variants and video frames."
+          },
+          args: {
+            pluginDir: {
+              type: "string",
+              description: "Plugin directory (manifest.json + package.json). Defaults to the current directory."
+            },
+            data: {
+              type: "string",
+              description: "Data directory served as a single resource. Defaults to <plugin-dir>/testdata when it exists."
+            },
+            storage: {
+              type: "string",
+              description: "hoardodile storage root to develop against. Opened READ-ONLY: resources come from app.sqlite and their bare-file folders, and plugin writes stay in the workbench's in-memory mock."
+            },
+            res: {
+              type: "string",
+              description: "Resource id to capture first when serving a storage root."
+            },
+            port: {
+              type: "string",
+              description: "Workbench port. Default 5199."
+            }
+          },
+          async run({ args }) {
+            return executeDev({
+              pluginDir: args.pluginDir ?? "",
+              dataDir: args.data,
+              storageDir: args.storage,
+              resId: args.res,
+              port: args.port === void 0 ? 5199 : parsePort(args.port)
+            });
+          }
+        }),
+        build: defineCommand({
+          meta: {
+            name: "build",
+            description: "Build a plugin in the current directory (manifest.json + src/ + index.html) into dist/. Pass --watch to rebuild on change."
+          },
+          args: {
+            watch: {
+              type: "boolean",
+              description: "Rebuild on file changes instead of exiting."
+            }
+          },
+          async run({ args }) {
+            return executeBuild({
+              dir: process.cwd(),
+              watch: args.watch === true
+            });
+          }
+        })
+      }
+    })
+  }
+});
+async function executeRun(opts) {
+  const exitCode = await executeRunInner(opts);
+  process.exitCode = exitCode;
+  return exitCode;
+}
+async function executeRunInner(opts) {
+  try {
+    const target = resolvePluginTarget({
+      pluginDir: opts.pluginDir,
+      main: opts.main
+    });
+    await ensureFreshBuild(target);
+    const extractCacheDir = mkdtempSync(join(tmpdir(), "hoard-cli-extract-"));
+    try {
+      const outcome = opts.inProcess ? await runInProcess(
+        target.mainPath,
+        opts.hook,
+        opts.dir,
+        extractCacheDir
+      ) : await withSandboxHooks(
+        target,
+        (hooks) => runCliHook({
+          id: target.id,
+          hooks,
+          hook: opts.hook,
+          dir: opts.dir,
+          extractCacheDir
+        })
+      );
+      console.log(JSON.stringify(outcome, null, opts.pretty ? 2 : 0));
+    } finally {
+      rmSync(extractCacheDir, { recursive: true, force: true });
+    }
+    return EXIT_PASS;
+  } catch (err2) {
+    console.error(
+      `[hoardodile] ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    return EXIT_ERROR;
+  }
+}
+async function executeBench(opts) {
+  const exitCode = await executeBenchInner(opts);
+  process.exitCode = exitCode;
+  return exitCode;
+}
+async function executeBenchInner(opts) {
+  try {
+    const target = resolvePluginTarget({
+      pluginDir: opts.pluginDir,
+      main: opts.main
+    });
+    await ensureFreshBuild(target);
+    if (opts.inProcess) {
+      const report = await computeBenchReport({
+        pluginId: target.id,
+        hook: opts.hook,
+        dir: opts.dir,
+        repeat: opts.repeat,
+        warmupRuns: opts.warmupRuns,
+        run: () => runInProcess(target.mainPath, opts.hook, opts.dir)
+      });
+      return finishBench(report, opts);
+    }
+    const sandbox = createPluginSandbox(DEFAULT_SANDBOX_CONFIG);
+    try {
+      const hooks = await createCliHooks(target, sandbox);
+      const report = await computeBenchReport({
+        pluginId: target.id,
+        hook: opts.hook,
+        dir: opts.dir,
+        repeat: opts.repeat,
+        warmupRuns: opts.warmupRuns,
+        run: () => runCliHook({ id: target.id, hooks, hook: opts.hook, dir: opts.dir })
+      });
+      return finishBench(report, opts);
+    } finally {
+      await sandbox.disposeAll();
+    }
+  } catch (err2) {
+    console.error(
+      `[hoardodile] ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    return EXIT_ERROR;
+  }
+}
+function finishBench(report, opts) {
+  console.log(formatBenchSummary(report));
+  let compare;
+  if (opts.comparePath !== void 0) {
+    const baseline = loadBaseline(opts.comparePath);
+    compare = compareBaseline(report, baseline, opts.thresholdPercent);
+    console.log(compare.message);
+  }
+  if (opts.savePath !== void 0) writeReport(opts.savePath, report);
+  if (opts.jsonPath !== void 0) writeReport(opts.jsonPath, report);
+  return benchExitCode(compare);
+}
+async function executeBuild(opts) {
+  try {
+    await buildPlugin(opts.dir, { watch: opts.watch });
+    return EXIT_PASS;
+  } catch (err2) {
+    console.error(
+      `[hoardodile] ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    return EXIT_ERROR;
+  }
+}
+async function withSandboxHooks(target, fn) {
+  const sandbox = createPluginSandbox(DEFAULT_SANDBOX_CONFIG);
+  try {
+    const hooks = await createCliHooks(target, sandbox);
+    return await fn(hooks);
+  } finally {
+    await sandbox.disposeAll();
+  }
+}
+async function ensureFreshBuild(target) {
+  const distDir = target.dirPath;
+  const pluginDir = dirname(distDir);
+  const srcDir = join(pluginDir, "src");
+  const manifestPath = join(pluginDir, "manifest.json");
+  if (!existsSync(srcDir) || !existsSync(manifestPath)) return;
+  if (!existsSync(join(distDir, "main.js"))) return;
+  const distMtime = newestFileMtime(distDir);
+  const newestSource = Math.max(
+    newestFileMtime(srcDir),
+    statSync(manifestPath).mtimeMs
+  );
+  const REBUILD_TOLERANCE_MS = 2e3;
+  if (distMtime + REBUILD_TOLERANCE_MS <= newestSource) {
+    console.log(`[hoardodile] dist/ is stale \u2014 rebuilding ${pluginDir}`);
+    await buildPlugin(pluginDir, { watch: false });
+  }
+}
+function newestFileMtime(dir) {
+  let newest = 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      newest = Math.max(newest, newestFileMtime(full));
+    } else if (entry.isFile()) {
+      newest = Math.max(newest, statSync(full).mtimeMs);
+    }
+  }
+  return newest;
+}
+async function runInProcess(mainPath, hook, dir, extractCacheDir) {
+  const mod = await import(pathToFileURL(mainPath).href);
+  if (typeof mod !== "object" || mod === null || !("default" in mod)) {
+    throw new CliError(
+      `plugin at ${mainPath} must default-export a plugin definition`
+    );
+  }
+  const def = mod.default;
+  const fn = def[hook];
+  if (typeof fn !== "function") {
+    throw new CliError(`plugin has no ${hook} hook`);
+  }
+  const api = buildCliResourceAPI(dir, { extractCacheDir });
+  const started = performance.now();
+  const result = await fn(api);
+  return ok({ result, durationMs: performance.now() - started });
+}
+
+export { main };
+//# sourceMappingURL=main.js.map
+//# sourceMappingURL=main.js.map