@vibeframe/cli 0.104.3 → 0.105.2

package/dist/commands/ai-motion.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @module ai-motion
+ * @description Motion graphics render and composite command.
+ *
+ * ## Commands: vibe generate motion
+ * ## Dependencies: Claude, Gemini, Remotion
+ *
+ * Extracted from ai.ts as part of modularisation.
+ * ai.ts re-exports all public types and functions from this module.
+ * @see MODELS.md for AI model configuration
+ */
+import { type Command } from "commander";
+export interface MotionCommandOptions {
+    description: string;
+    duration?: number;
+    width?: number;
+    height?: number;
+    fps?: number;
+    style?: string;
+    /** If set, render the generated code with Remotion */
+    render?: boolean;
+    /** Base video to composite the motion graphic onto */
+    video?: string;
+    /** Image to analyze with Gemini — color/mood/composition fed into Claude prompt */
+    image?: string;
+    /** Analyze base video before generating motion: auto | off | required */
+    understand?: "auto" | "off" | "required";
+    /** Override the default video understanding prompt */
+    understandingPrompt?: string;
+    /** Path to existing TSX file to refine instead of generating from scratch */
+    fromTsx?: string;
+    /**
+     * LLM model alias for code generation.
+     * sonnet (default) | opus | gemini | gemini-3.1-pro
+     */
+    model?: string;
+    /** Output path (TSX if code-only, WebM/MP4 if rendered) */
+    output?: string;
+}
+export interface MotionCommandResult {
+    success: boolean;
+    codePath?: string;
+    renderedPath?: string;
+    compositedPath?: string;
+    componentName?: string;
+    error?: string;
+}
+export declare function executeMotion(options: MotionCommandOptions): Promise<MotionCommandResult>;
+/**
+ * Register the 'motion' sub-command on the given parent command.
+ * Called from ai.ts: registerMotionCommand(aiCommand)
+ */
+export declare function registerMotionCommand(aiCommand: Command): void;

package/dist/commands/ai-review.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module ai-review
+ *
+ * AI-powered video quality review and auto-fix using Gemini.
+ *
+ * CLI command: review
+ *
+ * Execute function:
+ *   executeReview - Analyze video quality across 5 categories and optionally auto-fix
+ *
+ * @dependencies Gemini (Google), FFmpeg (auto-fix filters)
+ */
+import { Command } from "commander";
+import type { VideoReviewFeedback } from "./ai-edit.js";
+/** Options for {@link executeReview}. */
+export interface ReviewOptions {
+    /** Path to the video file to review */
+    videoPath: string;
+    /** Optional storyboard JSON for context-aware review */
+    storyboardPath?: string;
+    /** Optional project context for beat-aware review */
+    projectContext?: string;
+    /** Automatically apply fixable corrections via FFmpeg */
+    autoApply?: boolean;
+    /** Run a verification pass after applying fixes */
+    verify?: boolean;
+    /** Gemini model shorthand (default: "flash") */
+    model?: "flash" | "flash-2.5" | "pro";
+    /** Output path for the fixed video (auto-apply mode) */
+    outputPath?: string;
+}
+/** Result from {@link executeReview}. */
+export interface ReviewResult {
+    /** Whether the review completed successfully */
+    success: boolean;
+    /** Structured review feedback with per-category scores */
+    feedback?: VideoReviewFeedback;
+    /** Descriptions of fixes that were auto-applied */
+    appliedFixes?: string[];
+    /** Post-fix verification quality score 1-10 */
+    verificationScore?: number;
+    /** Path to the reviewed/fixed output video */
+    outputPath?: string;
+    /** Error message on failure */
+    error?: string;
+}
+/**
+ * Review video quality using Gemini AI and optionally auto-fix issues.
+ *
+ * Analyzes 5 quality categories (pacing, color, text readability, audio-visual
+ * sync, composition) and returns scored feedback. When auto-apply is enabled,
+ * applies fixable corrections via FFmpeg filters.
+ *
+ * @param options - Review configuration
+ * @returns Result with structured feedback and optional fix details
+ */
+export declare function executeReview(options: ReviewOptions): Promise<ReviewResult>;
+export declare function registerReviewCommand(aiCommand: Command): void;

package/dist/commands/ai-script-pipeline-cli.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module ai-script-pipeline-cli
+ * @description Commander wiring for `vibe pipeline regenerate-scene`. The
+ *   sibling `script-to-video` subcommand and its execute function were
+ *   removed in favour of the skill-driven `vibe scene build` flow; only
+ *   regenerate-scene survives because it operates on existing on-disk
+ *   storyboards. Execute function lives in `ai-script-pipeline.ts`.
+ */
+import { Command } from "commander";
+export declare function registerScriptPipelineCommands(aiCommand: Command): void;

package/dist/commands/ai-script-pipeline.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @module ai-script-pipeline
+ *
+ * Library function for scene regeneration in script-to-video output
+ * directories, plus pass-through re-exports of `_shared/video-utils.js` and
+ * `_shared/video-providers.js` helpers (consumed by `ai-video.ts` and
+ * `generate/video.ts`).
+ *
+ * Powers the manifest tool `remix_regenerate_scene` and the user-facing
+ * `vibe pipeline regenerate-scene` CLI subcommand.
+ *
+ * Note: `executeScriptToVideo` and the `pipeline script-to-video` CLI / MCP
+ * surface were removed in favour of the Hyperframes-style skill-driven
+ * `vibe scene build` flow, which is idempotent, cheaper, and per-beat
+ * editable. The `regenerate-scene` half is preserved because it operates on
+ * the on-disk storyboard.{yaml,json} produced by older runs (and by other
+ * pipelines that still emit that layout).
+ *
+ * @dependencies ElevenLabs (TTS), OpenAI/Gemini/Grok (images),
+ *               Kling/Runway/Veo/Grok (video), FFmpeg (extension)
+ */
+import { type StoryboardSegment, DEFAULT_VIDEO_RETRIES, RETRY_DELAY_MS, sleep, uploadToImgbb, extendVideoToTarget, logSceneFailure, waitForVideoWithRetry } from "./_shared/video-utils.js";
+import { generateVideoWithRetryGrok, generateVideoWithRetryKling, generateVideoWithRetryRunway, generateVideoWithRetryVeo } from "./_shared/video-providers.js";
+export { DEFAULT_VIDEO_RETRIES, RETRY_DELAY_MS, sleep, uploadToImgbb, extendVideoToTarget, logSceneFailure, waitForVideoWithRetry, generateVideoWithRetryGrok, generateVideoWithRetryKling, generateVideoWithRetryRunway, generateVideoWithRetryVeo, };
+export type { StoryboardSegment };
+/** Options for {@link executeRegenerateScene}. */
+export interface RegenerateSceneOptions {
+    /** Path to the project output directory containing storyboard.json */
+    projectDir: string;
+    /** 1-indexed scene numbers to regenerate */
+    scenes: number[];
+    /** Only regenerate video (keep existing image) */
+    videoOnly?: boolean;
+    /** Only regenerate narration audio */
+    narrationOnly?: boolean;
+    /** Only regenerate scene image */
+    imageOnly?: boolean;
+    /** Video generation provider */
+    generator?: "grok" | "kling" | "runway" | "veo";
+    /** Image generation provider */
+    imageProvider?: "gemini" | "openai" | "grok";
+    /** ElevenLabs voice name or ID */
+    voice?: string;
+    /** Video aspect ratio */
+    aspectRatio?: "16:9" | "9:16" | "1:1";
+    /** Max retries per video generation call */
+    retries?: number;
+    /** Reference scene number for character consistency (auto-detects if not specified) */
+    referenceScene?: number;
+    /** Called at per-scene progress points (`Scene N: regenerating narration...`). */
+    onProgress?: (message: string) => void;
+}
+/** Result from {@link executeRegenerateScene}. */
+export interface RegenerateSceneResult {
+    /** Whether all requested scenes were regenerated */
+    success: boolean;
+    /** 1-indexed scene numbers successfully regenerated */
+    regeneratedScenes: number[];
+    /** 1-indexed scene numbers that failed to regenerate */
+    failedScenes: number[];
+    /** Error message on failure */
+    error?: string;
+}
+/**
+ * Regenerate specific scene(s) in an existing script-to-video project.
+ *
+ * Reads the storyboard.{yaml,json} from the project directory, then
+ * regenerates the requested scenes using the specified video/image provider.
+ * Supports image-to-video via ImgBB URL upload for Kling.
+ *
+ * @param options - Scene regeneration configuration
+ * @returns Result with lists of regenerated and failed scene numbers
+ */
+export declare function executeRegenerateScene(options: RegenerateSceneOptions): Promise<RegenerateSceneResult>;

package/dist/commands/ai-suggest-edit.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module ai-suggest-edit
+ * @description Library function for AI suggest. Powers `analyze suggest` via the
+ * manifest tool `analyze_suggest_edit`. The legacy `vibe ai suggest/edit/storyboard`
+ * Commander registrations were removed alongside the dead `commands/ai.ts`
+ * orchestrator (the `vibe ai *` namespace was never `addCommand`'d to `program`).
+ *
+ * @see MODELS.md for AI model configuration
+ */
+import { type EditSuggestion } from "@vibeframe/ai-providers";
+export interface ExecuteSuggestEditOptions {
+    projectPath: string;
+    instruction: string;
+    apply?: boolean;
+    apiKey?: string;
+}
+export interface SuggestEditEntry {
+    type: EditSuggestion["type"];
+    description: string;
+    confidence: number;
+    clipIds: string[];
+    params: Record<string, unknown>;
+}
+export interface ExecuteSuggestEditResult {
+    success: boolean;
+    suggestions?: SuggestEditEntry[];
+    applied?: boolean;
+    appliedSuggestion?: SuggestEditEntry;
+    outputPath?: string;
+    error?: string;
+}
+export declare function executeSuggestEdit(options: ExecuteSuggestEditOptions): Promise<ExecuteSuggestEditResult>;

package/dist/commands/ai-video.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @module ai-video
+ * @description Library functions for video generation, status, cancel, and
+ * extension. Powers the manifest tools `generate_video`,
+ * `generate_video_status`, `generate_video_cancel`, `generate_video_extend`
+ * (the user reaches these via `vibe generate video[-...]`).
+ *
+ * The legacy `vibe ai video / video-status / video-cancel / kling / kling-status /
+ * video-extend` Commander registrations were removed alongside the dead
+ * `commands/ai.ts` orchestrator (the `vibe ai *` namespace was never
+ * `addCommand`'d to `program`).
+ *
+ * @see MODELS.md for AI model configuration
+ */
+export interface VideoGenerateOptions {
+    prompt: string;
+    provider?: "grok" | "runway" | "kling" | "veo" | "seedance" | "fal";
+    image?: string;
+    refImages?: string[];
+    refVideos?: string[];
+    refAudio?: string[];
+    duration?: number;
+    ratio?: string;
+    seed?: number;
+    mode?: string;
+    negative?: string;
+    resolution?: string;
+    veoModel?: string;
+    runwayModel?: string;
+    seedanceModel?: string;
+    generateAudio?: boolean;
+    output?: string;
+    wait?: boolean;
+    apiKey?: string;
+}
+export interface VideoGenerateResult {
+    success: boolean;
+    taskId?: string;
+    status?: string;
+    videoUrl?: string;
+    duration?: number;
+    outputPath?: string;
+    provider?: string;
+    error?: string;
+}
+export declare function executeVideoGenerate(options: VideoGenerateOptions): Promise<VideoGenerateResult>;
+export interface VideoStatusOptions {
+    taskId: string;
+    provider?: "runway" | "kling";
+    taskType?: "text2video" | "image2video";
+    wait?: boolean;
+    output?: string;
+    apiKey?: string;
+}
+export interface VideoStatusResult {
+    success: boolean;
+    taskId?: string;
+    status?: string;
+    progress?: number;
+    videoUrl?: string;
+    duration?: number;
+    outputPath?: string;
+    error?: string;
+}
+export declare function executeVideoStatus(options: VideoStatusOptions): Promise<VideoStatusResult>;
+export interface VideoCancelOptions {
+    taskId: string;
+    apiKey?: string;
+}
+export interface VideoCancelResult {
+    success: boolean;
+    error?: string;
+}
+export declare function executeVideoCancel(options: VideoCancelOptions): Promise<VideoCancelResult>;
+export interface VideoExtendOptions {
+    videoId: string;
+    provider?: "kling" | "veo";
+    prompt?: string;
+    duration?: number;
+    negative?: string;
+    veoModel?: string;
+    output?: string;
+    wait?: boolean;
+    apiKey?: string;
+}
+export interface VideoExtendResult {
+    success: boolean;
+    taskId?: string;
+    status?: string;
+    videoUrl?: string;
+    duration?: number;
+    outputPath?: string;
+    error?: string;
+}
+export declare function executeVideoExtend(options: VideoExtendOptions): Promise<VideoExtendResult>;

package/dist/commands/ai.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/audio.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @module audio
+ *
+ * Top-level `vibe audio` command group for audio operations.
+ *
+ * Commands:
+ *   audio transcribe   - Transcribe audio using Whisper
+ *   audio list-voices  - List available ElevenLabs voices
+ *   audio isolate      - Isolate vocals from audio (ElevenLabs)
+ *   audio clone-voice  - Clone a voice from audio samples (ElevenLabs)
+ *   audio dub          - Dub audio/video to another language (Whisper + Claude + ElevenLabs)
+ *   audio duck         - Auto-duck background music when voice is present (FFmpeg)
+ *
+ * @dependencies Whisper (OpenAI), ElevenLabs, Claude (Anthropic), FFmpeg
+ */
+import { Command } from "commander";
+export declare const audioCommand: Command;

package/dist/commands/batch.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const batchCommand: Command;

package/dist/commands/batch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/build.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const buildCommand: Command;

package/dist/commands/completion.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module commands/completion
+ *
+ * `vibe completion <shell>` — emit a shell completion script for the
+ * given shell (zsh / bash / fish). The script is generated by walking
+ * the live Commander program tree, so completion stays in sync with
+ * the actual command set without a parallel manifest.
+ *
+ * Install:
+ *   zsh:  vibe completion zsh  >> ~/.zsh/completions/_vibe   (then add the dir to fpath)
+ *         or:  echo 'eval "$(vibe completion zsh)"' >> ~/.zshrc
+ *   bash: echo 'eval "$(vibe completion bash)"' >> ~/.bashrc
+ *   fish: vibe completion fish > ~/.config/fish/completions/vibe.fish
+ *
+ * Cost tiers ride along in zsh descriptions (e.g.
+ * "[VERY-HIGH] Generate video …") so the user sees the price tag at
+ * tab-completion time, not just in --help.
+ */
+import { Command } from "commander";
+export declare const completionCommand: Command;

package/dist/commands/completion.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/context.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Context command - Output CONTEXT.md for agent runtime discovery.
+ * Allows AI agents to read CLI guidelines without needing CLAUDE.md or CONTEXT.md on disk.
+ */
+import { Command } from "commander";
+export declare function resolveContextPath(baseDir?: string): string | null;
+export declare const contextCommand: Command;

package/dist/commands/context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/demo.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Demo command - Run sample edits on a generated test video.
+ * No API keys needed, FFmpeg only.
+ */
+import { Command } from "commander";
+export declare const demoCommand: Command;

package/dist/commands/detect.d.ts

@@ -0,0 +1,55 @@
+import { Command } from "commander";
+export interface DetectScenesOptions {
+    videoPath: string;
+    threshold?: number;
+    outputPath?: string;
+}
+export interface DetectScenesResult {
+    success: boolean;
+    scenes?: {
+        index: number;
+        startTime: number;
+        endTime: number;
+        duration: number;
+    }[];
+    totalDuration?: number;
+    error?: string;
+}
+export interface DetectSilenceOptions {
+    mediaPath: string;
+    noise?: string;
+    duration?: string;
+    outputPath?: string;
+}
+export interface DetectSilenceResult {
+    success: boolean;
+    silences?: {
+        start: number;
+        end: number;
+        duration: number;
+    }[];
+    error?: string;
+}
+export interface DetectBeatsOptions {
+    audioPath: string;
+    outputPath?: string;
+}
+export interface DetectBeatsResult {
+    success: boolean;
+    beats?: number[];
+    beatCount?: number;
+    error?: string;
+}
+/**
+ * Detect scene changes in video using FFmpeg.
+ */
+export declare function executeDetectScenes(options: DetectScenesOptions): Promise<DetectScenesResult>;
+/**
+ * Detect silence periods in audio/video using FFmpeg.
+ */
+export declare function executeDetectSilence(options: DetectSilenceOptions): Promise<DetectSilenceResult>;
+/**
+ * Detect beats in audio using FFmpeg ebur128 loudness analysis.
+ */
+export declare function executeDetectBeats(options: DetectBeatsOptions): Promise<DetectBeatsResult>;
+export declare const detectCommand: Command;

package/dist/commands/doctor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Doctor command - System health check and capability report
+ */
+import { Command } from "commander";
+export declare const doctorCommand: Command;

package/dist/commands/doctor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/edit/motion-overlay.d.ts

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { type MotionCommandOptions } from "../ai-motion.js";
+export type MotionOverlayUnderstand = "auto" | "off" | "required";
+export type MotionOverlayPosition = "full" | "center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export interface MotionOverlayOptions {
+    videoPath: string;
+    description?: string;
+    asset?: string;
+    output?: string;
+    duration?: number;
+    start?: number;
+    style?: string;
+    model?: MotionCommandOptions["model"];
+    understand?: MotionOverlayUnderstand;
+    understandingPrompt?: string;
+    position?: MotionOverlayPosition;
+    scale?: number;
+    opacity?: number;
+    loop?: boolean;
+}
+export interface MotionOverlayResult {
+    success: boolean;
+    outputPath?: string;
+    codePath?: string;
+    renderedPath?: string;
+    provider?: "remotion" | "lottie";
+    error?: string;
+}
+export declare function executeMotionOverlay(options: MotionOverlayOptions): Promise<MotionOverlayResult>;
+export declare function registerMotionOverlayCommand(parent: Command): void;

package/dist/commands/edit-cmd.d.ts

@@ -0,0 +1,112 @@
+/**
+ * @module edit-cmd
+ *
+ * Top-level `vibe edit` command group for post-production editing.
+ *
+ * Commands:
+ *   edit silence-cut    - Remove silent segments (FFmpeg / Gemini)
+ *   edit jump-cut       - Remove filler words (Whisper + FFmpeg)
+ *   edit caption        - Add styled captions (Whisper + FFmpeg)
+ *   edit noise-reduce   - Audio/video noise removal (FFmpeg)
+ *   edit fade           - Fade in/out effects (FFmpeg)
+ *   edit translate-srt  - Translate SRT subtitles (Claude or OpenAI)
+ *   edit grade          - Color grading (Claude + FFmpeg)
+ *   edit text-overlay   - Simple static text overlays (FFmpeg drawtext)
+ *   edit motion-overlay - Designed motion graphics overlays (Remotion/Lottie)
+ *   edit speed-ramp     - Speed ramping (Whisper + Claude + FFmpeg)
+ *   edit reframe        - Reframe aspect ratio (Claude Vision + FFmpeg)
+ *   edit image          - Image editing (Gemini, OpenAI, or Grok)
+ *   edit interpolate    - Frame interpolation / slow motion (FFmpeg)
+ *   edit upscale       - Video upscaling (FFmpeg or Replicate)
+ *   edit fill-gaps      - Fill timeline gaps with AI video (Kling)
+ *
+ * @dependencies Whisper, Claude, Gemini, Kling, Replicate, FFmpeg
+ */
+import { Command } from "commander";
+export declare const editCommand: Command;
+export interface GradeOptions {
+    videoPath: string;
+    style?: string;
+    preset?: string;
+    output?: string;
+    analyzeOnly?: boolean;
+    apiKey?: string;
+}
+export interface GradeResult {
+    success: boolean;
+    outputPath?: string;
+    style?: string;
+    description?: string;
+    ffmpegFilter?: string;
+    error?: string;
+}
+export declare function executeGrade(options: GradeOptions): Promise<GradeResult>;
+export interface SpeedRampOptions {
+    videoPath: string;
+    output?: string;
+    style?: "dramatic" | "smooth" | "action";
+    minSpeed?: number;
+    maxSpeed?: number;
+    analyzeOnly?: boolean;
+    language?: string;
+    apiKey?: string;
+}
+export interface SpeedRampResult {
+    success: boolean;
+    outputPath?: string;
+    keyframes?: Array<{
+        time: number;
+        speed: number;
+        reason: string;
+    }>;
+    avgSpeed?: number;
+    error?: string;
+}
+export declare function executeSpeedRamp(options: SpeedRampOptions): Promise<SpeedRampResult>;
+export interface ReframeOptions {
+    videoPath: string;
+    aspect?: string;
+    focus?: "auto" | "face" | "center" | "action";
+    output?: string;
+    analyzeOnly?: boolean;
+    apiKey?: string;
+}
+export interface ReframeResult {
+    success: boolean;
+    outputPath?: string;
+    sourceAspect?: string;
+    targetAspect?: string;
+    keyframeCount?: number;
+    error?: string;
+}
+export declare function executeReframe(options: ReframeOptions): Promise<ReframeResult>;
+export interface InterpolateOptions {
+    videoPath: string;
+    output?: string;
+    factor?: number;
+    fps?: number;
+    quality?: "fast" | "quality";
+}
+export interface InterpolateResult {
+    success: boolean;
+    outputPath?: string;
+    originalFps?: number;
+    targetFps?: number;
+    factor?: number;
+    error?: string;
+}
+export declare function executeInterpolate(options: InterpolateOptions): Promise<InterpolateResult>;
+export interface UpscaleOptions {
+    videoPath: string;
+    output?: string;
+    scale?: number;
+    quality?: "fast" | "quality";
+}
+export interface UpscaleResult {
+    success: boolean;
+    outputPath?: string;
+    originalRes?: string;
+    targetRes?: string;
+    error?: string;
+}
+export declare function executeUpscale(options: UpscaleOptions): Promise<UpscaleResult>;

package/dist/commands/envelope-snapshots.test.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file envelope-snapshots.test.ts
+ *
+ * Drift detection for Issue #33's CLI UX standardization. Snapshots:
+ *   1. The JSON Schema returned by `vibe <cmd> --describe` for every
+ *      leaf command (catches schema/option/argument drift).
+ *   2. The `--dry-run --json` envelope shape for representative
+ *      commands across the major groups (catches success-envelope
+ *      drift — keys moved, renamed, removed).
+ *
+ * Why:
+ * - The new `outputSuccess()` envelope (#194-#199, v0.72.0) is now load-bearing.
+ *   Every agent / MCP host parses `data.X` not `X`. A regression that
+ *   re-flattens or renames keys would silently break agent integrations.
+ *   Snapshots make the regression visible in PR review.
+ * - `--describe` is the agent's discovery channel for parameters. Drift
+ *   in option descriptions / enum hints / argument shapes invalidates
+ *   prompts that were written against the old schema.
+ *
+ * Normalization:
+ * - `elapsedMs` is replaced with `<elapsedMs>` before snapshotting (it
+ *   varies per run). Other fields are kept verbatim.
+ * - Cost-estimate-driven `costUsd` is stable per command and not normalized.
+ *
+ * Maintenance:
+ * - When a snapshot diff is INTENTIONAL (e.g. you renamed a key on
+ *   purpose), run with `-u` (`pnpm -F @vibeframe/cli exec vitest run -u`)
+ *   to update the snapshot file, then review the diff.
+ * - When a snapshot diff is UNINTENTIONAL, the test names will tell
+ *   you which command and which channel (--describe vs --dry-run).
+ */
+export {};