@birdapi/velinstyle 1.2.1 → 1.3.0

package/cli/motion.js

@@ -0,0 +1,738 @@
+/**
+ * CLI: velinstyle motion list|presets|doctor|…|create|atelier|transition|sequence|usage|…
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, copyFileSync } from 'fs';
+import { join, resolve, basename, relative } from 'path';
+import { fileURLToPath } from 'url';
+import {
+  catalogSummary,
+  listPresets,
+  listPolicies,
+  listTriggers,
+  listBlueprints,
+  listTimelines,
+  listMotion,
+  getPolicy,
+  validatePolicy,
+  doctorMotionHtml,
+  scanMotionHtml,
+  analyzeMotionHtml,
+  reviewMotionHtml,
+  optimizeMotionHtml,
+  emitMotionBlueprint,
+  NAMESPACES,
+} from '../core/motion/index.js';
+import {
+  createMotionClip,
+  createMotionTransition,
+  createMotionSequence,
+  createAtelierBatch,
+  createEffectClip,
+  listClipPresets,
+  getUsageSummary,
+  runCreateWizard,
+  runAtelierWizard,
+  listImageFiles,
+  ensureMotionDirs,
+  loadMotionConfig,
+  runPixVerseSetup,
+  listMotionProviders,
+  formatMotionProvidersText,
+  redactSecrets,
+} from '../packages/velinstyle-motion/src/index.js';
+
+const PKG_ROOT = join(fileURLToPath(new URL('.', import.meta.url)), '..');
+
+const CLIP_SUBS = new Set([
+  'create', 'atelier', 'transition', 'sequence', 'export', 'usage',
+  'zoom', 'pan', 'rotate', 'particles', 'intro', 'outro',
+  'setup', 'providers',
+]);
+
+function collectHtmlFiles(target) {
+  const abs = resolve(target || '.');
+  if (!existsSync(abs)) throw new Error(`Path not found: ${abs}`);
+  const st = statSync(abs);
+  if (st.isFile()) return [abs];
+  const out = [];
+  const walk = (dir) => {
+    for (const name of readdirSync(dir)) {
+      if (name === 'node_modules' || name === '.git' || name === 'dist' || name === 'vendor') continue;
+      const p = join(dir, name);
+      const s = statSync(p);
+      if (s.isDirectory()) walk(p);
+      else if (/\.html?$/i.test(name) || /\.blade\.php$/i.test(name)) out.push(p);
+    }
+  };
+  walk(abs);
+  return out;
+}
+
+function readAllHtml(target) {
+  const files = collectHtmlFiles(target);
+  return {
+    files,
+    html: files.map((f) => readFileSync(f, 'utf-8')).join('\n'),
+  };
+}
+
+/**
+ * @param {string[]} args
+ * @param {{ C: object, getArg: Function, hasFlag: Function, emitExperience: Function }} util
+ */
+export async function motionCmd(args, util) {
+  const { getArg, hasFlag, emitExperience } = util;
+  const sub = args[0] || 'list';
+  const rest = args.slice(1);
+  const target = rest.find((a) => !a.startsWith('-')) || '.';
+  const asJson = hasFlag('--json');
+  const present = (payload) => emitExperience('motion', payload);
+
+  try {
+    if (CLIP_SUBS.has(sub)) {
+      await runClipCommand(sub, rest, { getArg, hasFlag, asJson, present });
+      return;
+    }
+
+    if (sub === 'list' || sub === '--help' || sub === '-h') {
+      if (sub !== 'list' && (sub === '--help' || sub === '-h' || !args[0])) {
+        await present({
+          message: 'Usage: velinstyle motion <list|presets|create|atelier|doctor|scan|…>',
+          suggestions: [
+            { text: 'velinstyle motion create image.webp' },
+            { text: 'velinstyle motion presets --clips' },
+            { text: 'velinstyle motion doctor .' },
+            { text: 'velinstyle motion analyze .' },
+          ],
+        });
+        return;
+      }
+      const summary = catalogSummary();
+      if (asJson) {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+      }
+      await present({
+        subtitle: 'list',
+        message: `Motion Registry v${summary.version}`,
+        items: Object.entries(summary.counts).map(([k, v]) => ({ label: k, value: String(v) })),
+        table: {
+          columns: ['Namespace', 'Count'],
+          rows: Object.entries(summary.counts).map(([k, v]) => [k, String(v)]),
+        },
+        notifications: [
+          { tone: 'info', message: 'Page Motion: presets · timelines · triggers · policies · blueprints' },
+          { tone: 'info', message: 'Clip Motion (1.3): motion create · atelier · providers · setup pixverse · usage' },
+        ],
+      });
+      return;
+    }
+
+    if (sub === 'presets') {
+      if (hasFlag('--clips')) {
+        const clips = listClipPresets();
+        if (asJson) {
+          console.log(JSON.stringify(clips, null, 2));
+          return;
+        }
+        await present({
+          subtitle: 'clip-presets',
+          message: `${clips.length} clip presets`,
+          table: {
+            columns: ['Id', 'Engine', 'Status', 'Title'],
+            rows: clips.map((p) => [p.id, p.engine || '', p.status || '', p.title || '']),
+          },
+        });
+        return;
+      }
+      const items = listPresets();
+      if (asJson) {
+        console.log(JSON.stringify(items, null, 2));
+        return;
+      }
+      await present({
+        subtitle: 'presets',
+        message: `${items.length} presets`,
+        table: {
+          columns: ['Id', 'Category', 'Status', 'Title'],
+          rows: items.map((p) => [p.id, p.category || '', p.status || '', p.title || '']),
+        },
+      });
+      return;
+    }
+
+    if (sub === 'policy') {
+      const action = rest[0] && !rest[0].startsWith('-') ? rest[0] : 'list';
+      if (action === 'list' || action === 'list'.toString()) {
+        const policies = listPolicies();
+        if (asJson) {
+          console.log(JSON.stringify(policies, null, 2));
+          return;
+        }
+        await present({
+          subtitle: 'policy',
+          message: `${policies.length} policies`,
+          table: {
+            columns: ['Id', 'Title', 'Max ms'],
+            rows: policies.map((p) => [p.id, p.title || '', String(p.maxDurationMs ?? '—')]),
+          },
+        });
+        return;
+      }
+      if (action === 'show' || action === 'validate') {
+        const id = rest[1] || rest[0];
+        const policyId = action === 'show' || action === 'validate' ? (rest[1] || getArg('--id')) : action;
+        const resolved = validatePolicy(policyId === 'show' || policyId === 'validate' ? rest[1] : policyId);
+        // simplify: velinstyle motion policy safe
+        const pid = ['list', 'show', 'validate'].includes(action) ? rest[1] : action;
+        const result = validatePolicy(pid);
+        if (!result.ok) {
+          await present({ status: 'ERROR', message: result.error, exitCode: 1 });
+          return;
+        }
+        if (asJson) {
+          console.log(JSON.stringify(result.policy, null, 2));
+          return;
+        }
+        await present({
+          subtitle: 'policy',
+          message: result.policy.title || result.policy.id,
+          items: [
+            { label: 'Id', value: result.policy.id },
+            { label: 'Max duration', value: String(result.policy.maxDurationMs ?? '—') },
+            { label: 'Status', value: result.policy.status || '—' },
+          ],
+          notifications: [{ tone: 'info', message: result.policy.description || '' }],
+        });
+        return;
+      }
+      const result = validatePolicy(action);
+      if (!result.ok) {
+        await present({ status: 'ERROR', message: result.error, exitCode: 1 });
+        return;
+      }
+      await present({
+        subtitle: 'policy',
+        message: result.policy.title,
+        notifications: [{ tone: 'ok', message: result.policy.description }],
+      });
+      return;
+    }
+
+    if (sub === 'demo') {
+      const gallery = join(PKG_ROOT, 'samples', 'motion-gallery.html');
+      await present({
+        subtitle: 'demo',
+        message: 'Motion Playground / Gallery',
+        items: [
+          { label: 'Gallery', value: existsSync(gallery) ? gallery : 'samples/motion-gallery.html' },
+          { label: 'Showcase', value: 'Gallery → Code → Preview → A11y → Performance → CLI → Studio' },
+        ],
+        suggestions: [
+          { text: `velinstyle serve ${existsSync(gallery) ? 'samples' : '.'}` },
+          { text: 'Open samples/motion-gallery.html' },
+        ],
+      });
+      return;
+    }
+
+    if (sub === 'doctor') {
+      const { files, html } = readAllHtml(target);
+      if (!files.length) {
+        await present({ status: 'WARNING', message: 'No HTML files found', exitCode: 1 });
+        return;
+      }
+      const report = doctorMotionHtml(html);
+      if (asJson) {
+        console.log(JSON.stringify(report, null, 2));
+        process.exitCode = report.ok ? 0 : 1;
+        return;
+      }
+      await present({
+        subtitle: 'doctor',
+        status: report.ok ? (report.summary.warnings ? 'WARNING' : 'PASS') : 'ERROR',
+        message: report.ok
+          ? `motion doctor: ok (${report.summary.elements} elements)`
+          : `motion doctor: ${report.summary.errors} error(s)`,
+        items: [
+          { label: 'Files', value: String(files.length) },
+          { label: 'Elements', value: String(report.summary.elements) },
+          { label: 'Errors', value: String(report.summary.errors) },
+          { label: 'Warnings', value: String(report.summary.warnings) },
+        ],
+        table: {
+          columns: ['Sev', 'Code', 'Message'],
+          rows: report.findings.slice(0, 25).map((f) => [f.severity, f.code, String(f.message).slice(0, 48)]),
+        },
+        exitCode: report.ok ? undefined : 1,
+      });
+      return;
+    }
+
+    if (sub === 'scan') {
+      const { files, html } = readAllHtml(target);
+      const report = scanMotionHtml(html);
+      if (asJson) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+      await present({
+        subtitle: 'scan',
+        message: `${report.summary.elements} motion elements · ${report.summary.presets} presets · ${report.summary.triggers} triggers`,
+        items: [
+          { label: 'Files', value: String(files.length) },
+          { label: 'Elements', value: String(report.summary.elements) },
+          { label: 'Presets', value: String(report.summary.presets) },
+          { label: 'Infinite', value: String(report.summary.infinite) },
+        ],
+        table: {
+          columns: ['Preset', 'Count'],
+          rows: Object.entries(report.presets || {}).map(([k, v]) => [k, String(v)]),
+        },
+      });
+      return;
+    }
+
+    if (sub === 'analyze') {
+      const { files, html } = readAllHtml(target);
+      const report = analyzeMotionHtml(html);
+      if (asJson) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+      const m = report.metrics;
+      await present({
+        subtitle: 'analyze',
+        status: report.ok ? 'PASS' : 'WARNING',
+        message: `Animations ${m.animations} · Duration ${m.durationLabel}`,
+        items: [
+          { label: 'Animations', value: String(m.animations) },
+          { label: 'Duration', value: m.durationLabel },
+          { label: 'Average', value: `${m.averageMs} ms` },
+          { label: 'Longest', value: `${m.longestMs} ms` },
+          { label: 'Reduced Motion', value: m.reducedMotion },
+          { label: 'Infinite', value: String(m.infinite) },
+          { label: 'Layout Shift Risk', value: m.layoutShiftRisk },
+        ],
+        project: { files: files.length },
+      });
+      return;
+    }
+
+    if (sub === 'review') {
+      const { html } = readAllHtml(target);
+      const report = reviewMotionHtml(html);
+      if (asJson) {
+        console.log(JSON.stringify(report, null, 2));
+        process.exitCode = report.gate === 'fail' ? 1 : 0;
+        return;
+      }
+      await present({
+        layout: 'review',
+        subtitle: 'review',
+        status: report.gate === 'fail' ? 'ERROR' : report.gate === 'warn' ? 'WARNING' : 'PASS',
+        message: `gate ${report.gate} · motion score ${report.scores.motion}`,
+        stats: report.scores,
+        items: Object.entries(report.metrics).map(([k, v]) => ({ label: k, value: String(v) })),
+        table: {
+          columns: ['Sev', 'Code', 'Message'],
+          rows: report.findings.slice(0, 20).map((f) => [f.severity, f.code, String(f.message).slice(0, 48)]),
+        },
+        exitCode: report.gate === 'fail' ? 1 : undefined,
+      });
+      return;
+    }
+
+    if (sub === 'report') {
+      const { files, html } = readAllHtml(target);
+      const analysis = analyzeMotionHtml(html);
+      const outDir = resolve(getArg('--out') || 'motion-report');
+      mkdirSync(outDir, { recursive: true });
+      const payload = {
+        schema: 'velinstyle.motion.report',
+        version: 1,
+        files: files.map((f) => relative(process.cwd(), f)),
+        ...analysis,
+        catalog: catalogSummary(),
+      };
+      writeFileSync(join(outDir, 'index.json'), JSON.stringify(payload, null, 2));
+      await present({
+        subtitle: 'report',
+        message: `Wrote motion report → ${outDir}`,
+        items: [
+          { label: 'Files', value: String(files.length) },
+          { label: 'Animations', value: String(analysis.metrics.animations) },
+        ],
+      });
+      return;
+    }
+
+    if (sub === 'optimize') {
+      const write = hasFlag('--write');
+      const files = collectHtmlFiles(target);
+      let changedFiles = 0;
+      const rows = [];
+      for (const file of files) {
+        const html = readFileSync(file, 'utf-8');
+        const result = optimizeMotionHtml(html);
+        if (result.changed) {
+          changedFiles += 1;
+          rows.push([basename(file), result.changes.slice(0, 2).join('; ')]);
+          if (write) writeFileSync(file, result.html, 'utf-8');
+        }
+      }
+      if (asJson) {
+        console.log(JSON.stringify({ changedFiles, dryRun: !write, rows }, null, 2));
+        return;
+      }
+      await present({
+        subtitle: 'optimize',
+        message: changedFiles
+          ? `${write ? 'Updated' : 'Would update'} ${changedFiles} file(s)`
+          : 'No safe optimizations',
+        table: rows.length ? { columns: ['File', 'Changes'], rows: rows.slice(0, 30) } : null,
+        suggestions: write ? [] : [{ text: 'Re-run with --write to apply' }],
+      });
+      return;
+    }
+
+    if (sub === 'blueprint') {
+      const kind = rest[0];
+      if (!kind || kind === 'list') {
+        const bps = listBlueprints();
+        await present({
+          subtitle: 'blueprint',
+          message: `${bps.length} blueprints`,
+          table: {
+            columns: ['Id', 'Status', 'Title'],
+            rows: bps.map((b) => [b.id, b.status || '', b.title || '']),
+          },
+        });
+        return;
+      }
+      const result = emitMotionBlueprint(kind);
+      if (!result.ok) {
+        await present({ status: 'ERROR', message: result.error, exitCode: 1 });
+        return;
+      }
+      const out = getArg('--output', '-o');
+      if (out) {
+        writeFileSync(resolve(out), result.html, 'utf-8');
+        await present({
+          subtitle: 'blueprint',
+          message: `Wrote ${resolve(out)}`,
+          items: [
+            { label: 'Kind', value: kind },
+            { label: 'Policy', value: result.blueprint.policy || 'safe' },
+          ],
+        });
+        return;
+      }
+      console.log(result.html);
+      return;
+    }
+
+    // namespace dump for studio: velinstyle motion timelines
+    if (NAMESPACES.includes(sub) || NAMESPACES.includes(`${sub}s`)) {
+      const ns = NAMESPACES.includes(sub) ? sub : `${sub}s`;
+      const items = listMotion(ns);
+      if (asJson) {
+        console.log(JSON.stringify(items, null, 2));
+        return;
+      }
+      await present({
+        subtitle: ns,
+        message: `${items.length} ${ns}`,
+        table: {
+          columns: ['Id', 'Status', 'Title'],
+          rows: items.map((i) => [i.id, i.status || '', i.title || '']),
+        },
+      });
+      return;
+    }
+
+    await present({
+      status: 'ERROR',
+      message: `Unknown motion subcommand: ${sub}`,
+      suggestions: [{ text: 'velinstyle motion list' }],
+      exitCode: 1,
+    });
+  } catch (e) {
+    await present({
+      status: 'ERROR',
+      message: /** @type {Error} */ (e).message || String(e),
+      exitCode: 1,
+    });
+  }
+}
+
+/**
+ * Clip pipeline commands (1.3.0 — @birdapi/velinstyle-motion).
+ */
+async function runClipCommand(sub, rest, { getArg, hasFlag, asJson, present }) {
+  const yes = hasFlag('--yes') || hasFlag('-y');
+  const ai = hasFlag('--ai');
+  const dryRun = hasFlag('--dry-run') || process.env.VELIN_MOTION_DRY_RUN === '1';
+  const out = getArg('--out') || getArg('--output') || getArg('-o');
+  const preset = getArg('--preset');
+  const provider = getArg('--provider');
+  const model = getArg('--model');
+  const quality = getArg('--quality');
+  const duration = getArg('--duration');
+  const style = getArg('--style');
+  const prompt = getArg('--prompt');
+  const positional = rest.filter((a) => !a.startsWith('-'));
+
+  if (sub === 'providers') {
+    const list = listMotionProviders();
+    if (asJson) {
+      console.log(JSON.stringify(redactSecrets(list), null, 2));
+      return;
+    }
+    process.stdout.write(formatMotionProvidersText());
+    return;
+  }
+
+  if (sub === 'setup') {
+    const target = (positional[0] || 'pixverse').toLowerCase();
+    if (target !== 'pixverse') {
+      throw new Error(`Unknown provider setup: ${target}. Supported: pixverse`);
+    }
+    const result = await runPixVerseSetup({
+      yes,
+      skipNetwork: dryRun || yes,
+    });
+    if (asJson) {
+      console.log(JSON.stringify(redactSecrets(result), null, 2));
+      return;
+    }
+    await present({
+      subtitle: 'setup pixverse',
+      status: 'PASS',
+      message: 'PixVerse Setup abgeschlossen',
+      items: [
+        { label: 'Provider', value: 'pixverse' },
+        { label: 'setup_completed', value: 'true' },
+        { label: 'API key', value: result.apiKeyPresent ? 'present' : 'missing' },
+      ],
+    });
+    return;
+  }
+
+  if (sub === 'usage') {
+    const summary = getUsageSummary(process.cwd());
+    if (asJson) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    await present({
+      subtitle: 'usage',
+      message: 'Motion Usage',
+      items: [
+        { label: 'Heute Clips', value: String(summary.today.clips) },
+        { label: 'Heute AI', value: String(summary.today.ai) },
+        { label: 'Woche Clips', value: String(summary.week.clips) },
+        { label: 'Woche AI', value: String(summary.week.ai) },
+        { label: 'PixVerse Credits (Hint)', value: String(summary.pixverse.creditsUsedHint) },
+      ],
+    });
+    return;
+  }
+
+  if (sub === 'export') {
+    const cfg = loadMotionConfig();
+    const src = positional[0] || cfg.output_dir;
+    await present({
+      subtitle: 'export',
+      message: `Export source: ${resolve(src)} — local clips are already HTML/CSS under motion-output; AI jobs write MP4 when provider returns a URL.`,
+      suggestions: [{ text: 'velinstyle motion create image.webp --preset soft-zoom --yes' }],
+    });
+    return;
+  }
+
+  if (['zoom', 'pan', 'rotate', 'particles', 'intro', 'outro'].includes(sub)) {
+    const image = positional[0];
+    if (!image) throw new Error(`Usage: velinstyle motion ${sub} <image>`);
+    const result = await createEffectClip(sub, image, {
+      duration: duration ? Number(duration) : undefined,
+      outDir: out,
+      yes: true,
+    });
+    if (asJson) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    await present({
+      subtitle: sub,
+      message: `Local clip → ${result.htmlPath}`,
+      items: [
+        { label: 'Engine', value: 'local' },
+        { label: 'Duration', value: `${(result.durationMs || 0) / 1000}s` },
+      ],
+    });
+    return;
+  }
+
+  if (sub === 'create') {
+    const image = positional[0];
+    if (!image) throw new Error('Usage: velinstyle motion create <image> [--preset …] [--ai] [--yes]');
+    ensureMotionDirs();
+    const plan = await runCreateWizard({
+      image,
+      ai: ai || style === 'ai',
+      yes: yes || asJson || Boolean(preset),
+      flags: {
+        preset,
+        provider,
+        model,
+        quality,
+        duration,
+        style: style || (ai ? 'ai' : undefined),
+        prompt,
+        out,
+      },
+    });
+    const result = await createMotionClip({
+      ...plan,
+      yes: yes || asJson,
+      quiet: asJson,
+      json: asJson,
+      dryRun,
+      outDir: plan.outDir || out,
+    });
+    if (asJson) {
+      console.log(JSON.stringify(redactSecrets(result), null, 2));
+      return;
+    }
+    await present({
+      subtitle: 'create',
+      status: 'PASS',
+      message: result.htmlPath
+        ? `Clip fertig → ${result.htmlPath}`
+        : result.videoPath
+          ? `Video fertig → ${result.videoPath}`
+          : result.manifestPath
+            ? `AI dry-run → ${result.manifestPath}`
+            : `Job ${result.job?.id || ''} fertig`,
+      items: [
+        { label: 'Engine', value: result.engine || plan.engine },
+        { label: 'Preset', value: plan.preset || '—' },
+        { label: 'Job', value: result.job?.id || '—' },
+      ],
+    });
+    return;
+  }
+
+  if (sub === 'atelier') {
+    const dir = positional[0] || '.';
+    const images = listImageFiles(resolve(dir));
+    const plan = await runAtelierWizard({
+      assetCount: images.length,
+      yes: yes || asJson,
+      ai: ai || style === 'ai',
+      count: getArg('--count') ? Number(getArg('--count')) : undefined,
+      preset: preset || 'atelier',
+      duration: duration ? Number(duration) : undefined,
+      outDir: out,
+    });
+    const batch = await createAtelierBatch({
+      dir,
+      count: plan.count,
+      preset: plan.preset,
+      engine: plan.engine,
+      provider: plan.provider,
+      duration: plan.duration,
+      quality: plan.quality,
+      outDir: plan.outDir || out,
+      yes: yes || asJson,
+      json: asJson,
+      dryRun,
+    });
+    if (asJson) {
+      console.log(JSON.stringify(redactSecrets(batch), null, 2));
+      return;
+    }
+    await present({
+      subtitle: 'atelier',
+      message: `Motion Batch fertig — ${batch.count} Clips · ${batch.totalSec}s Gesamtmaterial`,
+      items: [
+        { label: 'Bilder', value: String(batch.images) },
+        { label: 'Clips', value: String(batch.count) },
+        { label: 'Output', value: batch.outDir },
+      ],
+    });
+    return;
+  }
+
+  if (sub === 'transition') {
+    const [a, b] = positional;
+    if (!a || !b) throw new Error('Usage: velinstyle motion transition <imageA> <imageB>');
+    const result = await createMotionTransition({
+      imageA: a,
+      imageB: b,
+      engine: ai || style === 'ai' ? 'ai' : 'local',
+      provider,
+      model,
+      quality,
+      duration: duration ? Number(duration) : undefined,
+      prompt,
+      outDir: out,
+      yes: yes || asJson,
+      json: asJson,
+      dryRun,
+    });
+    if (asJson) {
+      console.log(JSON.stringify(redactSecrets(result), null, 2));
+      return;
+    }
+    await present({
+      subtitle: 'transition',
+      message: result.htmlPath || result.videoPath || result.manifestPath || 'Transition done',
+    });
+    return;
+  }
+
+  if (sub === 'sequence') {
+    if (positional.length < 2) throw new Error('Usage: velinstyle motion sequence <f1> <f2> […fn]');
+    const result = await createMotionSequence({
+      frames: positional,
+      provider: provider || 'pixverse',
+      model,
+      quality,
+      duration: duration ? Number(duration) : undefined,
+      prompt,
+      outDir: out,
+      yes: yes || asJson,
+      json: asJson,
+      dryRun,
+    });
+    if (asJson) {
+      console.log(JSON.stringify(redactSecrets(result), null, 2));
+      return;
+    }
+    await present({
+      subtitle: 'sequence',
+      message: result.videoPath || result.manifestPath || 'Sequence done',
+    });
+    return;
+  }
+
+  throw new Error(`Unknown clip subcommand: ${sub}`);
+}
+
+/**
+ * Lightweight step for velinstyle check.
+ */
+export async function motionCheckStep(path, { quiet, C } = {}) {
+  try {
+    const { html, files } = readAllHtml(path);
+    if (!files.length) return { ok: true, skipped: true };
+    const report = doctorMotionHtml(html);
+    if (!quiet && C) {
+      console.log(`  motion: ${report.summary.elements} elements · ${report.ok ? C.green('ok') : C.red('issues')}`);
+    }
+    return { ok: report.ok, ...report.summary };
+  } catch {
+    return { ok: true, skipped: true };
+  }
+}