@vibeframe/cli 0.115.6 → 0.115.8

package/dist/commands/_shared/edit/jump-cut.d.ts

@@ -52,8 +52,8 @@ export interface JumpCutResult {
 /** Default set of filler words detected by jump-cut. */
 export declare const DEFAULT_FILLER_WORDS: string[];
 /**
- * Transcribe audio with word-level timestamps using Whisper API directly.
- * Uses timestamp_granularities[]=word for filler detection.
+ * Transcribe audio with word-level timestamps (Whisper through the
+ * transcription contract) for filler detection. Throws on failure.
  */
 export declare function transcribeWithWords(audioPath: string, apiKey: string, language?: string): Promise<{
     words: {

package/dist/commands/_shared/image-jobs.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The CLI side of the image contract: open an image provider by name with
+ * the user's key, read input images, and save results. Image commands,
+ * tools, scenes, and builds go through here instead of branching on
+ * provider names.
+ */
+import { type ImageGenerator, type ImageInput } from "@vibeframe/ai-providers";
+/** Env var holding each image provider's key. */
+export declare const IMAGE_PROVIDER_ENV: Readonly<Record<string, string>>;
+/** Display names for spinners and messages. */
+export declare const IMAGE_PROVIDER_LABELS: Readonly<Record<string, string>>;
+/** An image generator for `provider`, with the given key or the configured one. */
+export declare function openImageGenerator(provider: string, apiKey?: string): Promise<ImageGenerator>;
+/** A local image file as contract input. */
+export declare function readImageInput(path: string): Promise<ImageInput>;
+/** Save image bytes to `output` (relative to cwd), converting to the extension's format. */
+export declare function saveImage(output: string, bytes: Uint8Array): Promise<string>;
+/** The catalog label for a model ID, for human output. */
+export declare function imageModelLabel(provider: string, modelId: string): string;
+/** CLI quality words to the contract's: `standard`/`hd` are the old OpenAI names. */
+export declare function contractQuality(quality?: string): "low" | "medium" | "high" | undefined;

package/dist/commands/_shared/openai-image.d.ts

@@ -1,36 +1,10 @@
 /**
  * @module _shared/openai-image
  *
- * Shared OpenAI `generateImage` helper for `vibe ai image` and
- * `vibe generate image`. Both commands had their own near-identical
- * provider initialisation + model-alias parsing + result construction.
- * v0.52.0 added gpt-image-2 wiring to `ai-image.ts` only and
- * `vibe generate image -m 2` silently fell back to gpt-image-1.5 — the
- * duplication guarantees a recurrence next time the OpenAI image flow
- * is touched.
- *
- * Each top-level command keeps its own CLI wiring and output formatting;
- * this helper owns just the API call + label derivation.
- *
- * See issue #58.
+ * OpenAI image model alias resolution, used by image cost estimates.
+ * Generation itself goes through the image contract (`executeImageGenerate`).
  */
-import type { GPTImageModel, ImageResult } from "@vibeframe/ai-providers";
-/** Subset of CLI options consumed by the helper. */
-export interface OpenAIImageHelperOptions {
-    model?: string;
-    size?: string;
-    quality?: string;
-    style?: string;
-    /** Stringified count from commander; parsed inside the helper. */
-    count?: string;
-}
-export interface OpenAIImageHelperResult {
-    result: ImageResult;
-    /** Resolved model id passed to the API. */
-    openaiModel: GPTImageModel;
-    /** Human-friendly label for spinner / success output. */
-    modelLabel: string;
-}
+import type { GPTImageModel } from "@vibeframe/ai-providers";
 /**
  * Resolve the user-supplied model alias to the API id + display label, from
  * the model catalog. Unknown or empty aliases resolve to the default model.
@@ -41,10 +15,3 @@ export declare function resolveOpenAIImageModel(modelAlias?: string): {
     openaiModel: GPTImageModel;
     modelLabel: string;
 };
-/**
- * Run an OpenAI image generation. Caller owns: api-key acquisition,
- * spinner lifecycle, output formatting (JSON vs human), and file save.
- */
-export declare function executeOpenAIImageGenerate(prompt: string, options: OpenAIImageHelperOptions, ctx: {
-    apiKey: string;
-}): Promise<OpenAIImageHelperResult>;

package/dist/commands/_shared/scene-inspect.d.ts

@@ -54,4 +54,3 @@ export interface ProjectInspectResult {
     reportPath?: string;
 }
 export declare function inspectProject(opts: ProjectInspectOptions): Promise<ProjectInspectResult>;
-export declare function displayIssue(issue: ReviewIssue): string;

package/dist/commands/_shared/scene-render.d.ts

@@ -2,11 +2,8 @@
  * @module _shared/scene-render
  *
  * Render a VibeFrame scene project to MP4/WebM/MOV using the Hyperframes
- * producer directly. Unlike the FFmpeg-bridge backend in
- * `pipeline/renderers/hyperframes.ts` which has to convert a `TimelineState`
- * into a temp Hyperframes project, scene projects already ARE Hyperframes
- * projects — so we hand the producer the user's project dir and entry file
- * verbatim.
+ * producer directly. Scene projects already ARE Hyperframes projects, so
+ * we hand the producer the user's project dir and entry file verbatim.
  *
  * `executeSceneRender()` is decoupled from CLI flags so that the C6 agent
  * tool and the C5 `--format scenes` pipeline can call it the same way. It
@@ -126,10 +123,7 @@ export declare function buildRenderConfig(opts: {
 };
 export declare function buildMediaOpenCommand(action: RenderOpenAction, filePath: string, platform?: NodeJS.Platform): MediaOpenCommand;
 /**
- * Render a scene project. Mirrors the contract of the existing Hyperframes
- * backend (preflight → execute → structured result), but skips the
- * `TimelineState` → temp project conversion because the user's project is
- * already a valid Hyperframes project.
+ * Render a scene project: preflight → execute → structured result.
  */
 export declare function executeSceneRender(opts?: SceneRenderOptions): Promise<SceneRenderResult>;
 export interface BeatRenderRootResult {

package/dist/commands/_shared/transcription.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The CLI side of the transcription contract: transcribe an audio file on
+ * disk and get the result shape the commands already use. Every command
+ * that needs a transcript (audio, captions, highlights, jump-cut, scene
+ * narration) goes through here.
+ */
+import { type ProviderErrorKind, type TranscriptGranularity, type TranscriptResult } from "@vibeframe/ai-providers";
+export interface TranscribeFileOptions {
+    apiKey: string;
+    language?: string;
+    granularity?: TranscriptGranularity;
+}
+/** Transcribe `path` with Whisper. Failures come back as `status: "failed"` with an error kind. */
+export declare function transcribeAudioFile(path: string, options: TranscribeFileOptions): Promise<TranscriptResult & {
+    errorKind?: ProviderErrorKind;
+}>;

package/dist/commands/_shared/translate-texts.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Translate a list of short texts (subtitle cues, dub segments) with Claude
+ * or OpenAI, in batches, keeping each text's position. Lines come back
+ * tagged `[N]` and are matched by that index, so a skipped or merged line
+ * cannot shift every later translation; anything missing keeps its source
+ * text.
+ */
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
+export interface TranslateTextsOptions {
+    /** Target language name or code ("Korean", "ko"). */
+    targetLanguage: string;
+    sourceLanguage?: string;
+    /** Default: Claude when ANTHROPIC_API_KEY is set, else OpenAI. */
+    provider?: "claude" | "openai";
+    apiKey?: string;
+    /** Texts per request. Default 30. */
+    batchSize?: number;
+}
+export type TranslateTextsResult = {
+    success: true;
+    texts: string[];
+    provider: "claude" | "openai";
+} | {
+    success: false;
+    error: string;
+    errorKind?: ProviderErrorKind;
+};
+/** "ko" → "Korean"; names pass through. */
+export declare function languageName(code: string): string;
+export declare function translateTexts(texts: string[], options: TranslateTextsOptions): Promise<TranslateTextsResult>;

package/dist/commands/_shared/tts-resolve.d.ts

@@ -18,7 +18,7 @@
  * to branch on provider id. All providers already return the same
  * `{ success, audioBuffer, error?, characterCount? }` result.
  */
-import type { KokoroLoadEvent } from "@vibeframe/ai-providers";
+import type { KokoroLoadEvent, ProviderErrorKind } from "@vibeframe/ai-providers";
 /** TTS providers VibeFrame can route to. `"auto"` picks based on key availability. */
 export type TtsProviderName = "auto" | "elevenlabs" | "openai" | "kokoro";
 /** Concrete provider id surfaced in result metadata. Never `"auto"`. */
@@ -33,6 +33,8 @@ export interface TtsCallOptions {
     voice?: string;
     /** Speaking speed multiplier (Kokoro: 0.5–2; ElevenLabs: 0.7–1.2). */
     speed?: number;
+    /** Catalog model ID or alias for the resolved provider. */
+    model?: string;
     /** Cold-start progress callback (Kokoro only — fires on first ~330MB load). */
     onProgress?: (event: KokoroLoadEvent) => void;
 }
@@ -41,7 +43,11 @@ export interface TtsCallResult {
     success: boolean;
     audioBuffer?: Buffer;
     error?: string;
+    /** Why the provider failed (`auth`, `quota`, `invalid-request`, ...). */
+    errorKind?: ProviderErrorKind;
     characterCount?: number;
+    /** The catalog model that spoke it. */
+    model?: string;
 }
 /** Synthesise speech from text. Provider-specific implementation lives behind this. */
 export type TtsCallable = (text: string, options?: TtsCallOptions) => Promise<TtsCallResult>;

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

@@ -3,7 +3,7 @@
  *
  * Media analysis execute functions using Gemini multimodal AI.
  *
- * CLI commands: gemini-video, analyze
+ * Powers `vibe inspect media` and the matching agent/MCP tools.
  *
  * Execute functions:
  *   executeGeminiVideo - Analyze video files or YouTube URLs with Gemini
@@ -11,7 +11,6 @@
  *
  * @dependencies Gemini (Google)
  */
-import { Command } from "commander";
 /** Options for {@link executeGeminiVideo}. */
 export interface GeminiVideoOptions {
     /** Video file path or YouTube URL */
@@ -102,4 +101,3 @@ export interface AnalyzeResult {
  * @returns Result with Gemini's response, detected source type, and token usage
  */
 export declare function executeAnalyze(options: AnalyzeOptions): Promise<AnalyzeResult>;
-export declare function registerAnalyzeCommands(aiCommand: Command): void;

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

@@ -12,6 +12,7 @@
  *
  * @see MODELS.md for AI model configuration
  */
+import type { ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface TranscribeOptions {
     audioPath: string;
     language?: string;
@@ -29,7 +30,10 @@ export interface TranscribeResult {
     }>;
     detectedLanguage?: string;
     outputPath?: string;
+    /** Subtitle format written to `outputPath` (json, srt, vtt). */
+    format?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeTranscribe(options: TranscribeOptions): Promise<TranscribeResult>;
 export interface IsolateOptions {
@@ -41,6 +45,7 @@ export interface IsolateResult {
     success: boolean;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeIsolate(options: IsolateOptions): Promise<IsolateResult>;
 export interface VoiceCloneOptions {
@@ -56,13 +61,18 @@ export interface VoiceCloneResult {
     voiceId?: string;
     name?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVoiceClone(options: VoiceCloneOptions): Promise<VoiceCloneResult>;
 export interface DubOptions {
     mediaPath: string;
+    /** Target language code or name ("ko", "Spanish"). */
     language: string;
     source?: string;
+    /** Voice for the chosen TTS provider. */
     voice?: string;
+    /** TTS provider: auto (default), elevenlabs, openai, kokoro. */
+    tts?: string;
     analyzeOnly?: boolean;
     output?: string;
 }
@@ -72,8 +82,22 @@ export interface DubResult {
     sourceLanguage?: string;
     targetLanguage?: string;
     segmentCount?: number;
+    /** Each segment's timing with its original and translated text. */
+    segments?: Array<{
+        startTime: number;
+        endTime: number;
+        original: string;
+        translated: string;
+    }>;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
+/**
+ * Dub speech to another language: transcribe (Whisper), translate (Claude,
+ * or OpenAI without an Anthropic key), speak each segment (any TTS
+ * provider), and place each line at its segment's start time, speeding up
+ * lines that would overrun their slot.
+ */
 export declare function executeDub(options: DubOptions): Promise<DubResult>;
 export interface DuckOptions {
     musicPath: string;

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

@@ -12,14 +12,6 @@ import { Project } from "../engine/index.js";
  * `SuggestEditEntry`, which omits the optional `id`/`previewUrl`.
  */
 export type ApplicableSuggestion = Pick<EditSuggestion, "type" | "clipIds" | "params">;
-/**
- * Download a video from URL, handling Veo/Google API authentication.
- * Uses x-goog-api-key header (not query param) for Google API URLs.
- *
- * @param url - Video URL to download
- * @param apiKey - Google API key (caller should resolve from env/config)
- */
-export declare function downloadVideo(url: string, apiKey?: string): Promise<Buffer>;
 /** Format a duration in seconds to m:ss.s display format */
 export declare function formatTime(seconds: number): string;
 /** Apply a single AI edit suggestion to a project */

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

@@ -12,48 +12,60 @@
  *
  * @see MODELS.md for AI model configuration
  */
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ImageGenerateOptions {
     prompt: string;
+    /** Default: the configured or first available image provider. */
     provider?: string;
     output?: string;
+    /** Explicit OpenAI size; otherwise the ratio picks one. */
     size?: string;
     ratio?: string;
     quality?: string;
-    style?: string;
+    /** Gemini "1K"/"2K"/"4K", Grok "1k"/"2k". */
+    resolution?: string;
     count?: number;
     model?: string;
     apiKey?: string;
 }
 export interface ImageGenerateResult {
     success: boolean;
+    /** Where the first image was saved. */
     outputPath?: string;
+    /** Every saved image: `out.png`, then `out-2.png`, `out-3.png`, ... */
+    outputPaths?: string[];
     images?: Array<{
-        url?: string;
-        base64?: string;
-        mimeType?: string;
+        base64: string;
+        mimeType: string;
         revisedPrompt?: string;
     }>;
     provider?: string;
     model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeImageGenerate(options: ImageGenerateOptions): Promise<ImageGenerateResult>;
-export interface GeminiEditOptions {
+export interface ImageEditOptions {
     imagePaths: string[];
     prompt: string;
+    /** Default: gemini. */
+    provider?: string;
     output?: string;
     model?: string;
     ratio?: string;
     resolution?: string;
+    quality?: string;
     apiKey?: string;
 }
-export interface GeminiEditResult {
+export interface ImageEditResult {
     success: boolean;
     outputPath?: string;
+    provider?: string;
     model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
-export declare function executeGeminiEdit(options: GeminiEditOptions): Promise<GeminiEditResult>;
+export declare function executeImageEdit(options: ImageEditOptions): Promise<ImageEditResult>;
 export interface ThumbnailBestFrameOptions {
     videoPath: string;
     outputPath: string;

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

@@ -0,0 +1,76 @@
+/**
+ * @module edit/lottie-overlay
+ *
+ * `vibe edit motion-overlay <video> --asset <file.lottie|file.json>`.
+ *
+ * Two passes, so the source video is never re-rendered through a browser:
+ *
+ *   1. Hyperframes renders only the Lottie layer, at the source's display
+ *      size, to ProRes 4444 with alpha. The page drives a dotLottie player
+ *      frame by frame from `window.__hf.seek`, so every frame is
+ *      deterministic and nothing depends on wall-clock playback.
+ *   2. FFmpeg overlays that layer onto the original video at `start`,
+ *      keeping the source resolution, frame rate, and audio.
+ */
+export type LottiePosition = "full" | "center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export interface LottieOverlayOptions {
+    videoPath: string;
+    assetPath: string;
+    outputPath: string;
+    /** Seconds into the video where the overlay appears. */
+    start: number;
+    /** Seconds the overlay stays on screen. */
+    duration: number;
+    position: LottiePosition;
+    /** Fraction of the frame the overlay box spans (ignored for `full`). */
+    scale: number;
+    opacity: number;
+    loop: boolean;
+}
+export interface LottieOverlayResult {
+    success: boolean;
+    outputPath?: string;
+    error?: string;
+    /** How to fix a failure that retrying will not fix. */
+    suggestion?: string;
+}
+export interface VideoStreamInfo {
+    /** Display size, after any rotation metadata is applied. */
+    width: number;
+    height: number;
+    fps: number;
+    duration: number;
+}
+/** Probe the first video stream. Width/height are swapped for 90/270 degree rotations, as FFmpeg autorotates on decode. */
+export declare function probeVideoStream(path: string): Promise<VideoStreamInfo>;
+/** Reject files dotLottie cannot open before spending a browser render on them. */
+export declare function checkLottieAsset(path: string): Promise<string | undefined>;
+/** CSS box for the overlay canvas, in pixels of the layer. */
+export declare function overlayBox(layer: {
+    width: number;
+    height: number;
+}, position: LottiePosition, scale: number): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+/**
+ * The layer page. `window.__hf` is published only after the animation has
+ * loaded, because the producer starts capturing once `__hf.duration > 0`.
+ */
+export declare function lottieLayerHtml(opts: {
+    width: number;
+    height: number;
+    duration: number;
+    assetUrl: string;
+    box: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    opacity: number;
+    loop: boolean;
+}): string;
+export declare function renderLottieOverlay(options: LottieOverlayOptions): Promise<LottieOverlayResult>;

package/dist/commands/edit/lottie-overlay.test.d.ts

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

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

@@ -1,7 +1,8 @@
 import { Command } from "commander";
 import { type MotionCommandOptions } from "../ai-motion.js";
+import { type LottiePosition } from "./lottie-overlay.js";
 export type MotionOverlayUnderstand = "auto" | "off" | "required";
-export type MotionOverlayPosition = "full" | "center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export type MotionOverlayPosition = LottiePosition;
 export interface MotionOverlayOptions {
     videoPath: string;
     description?: string;
@@ -25,6 +26,10 @@ export interface MotionOverlayResult {
     renderedPath?: string;
     provider?: "remotion" | "lottie";
     error?: string;
+    /** How to fix a failure that a retry will not fix. */
+    suggestion?: string;
+    /** False for deterministic local failures (bad asset, missing Chrome/FFmpeg). */
+    retryable?: boolean;
 }
 export declare function executeMotionOverlay(options: MotionOverlayOptions): Promise<MotionOverlayResult>;
 export declare function registerMotionOverlayCommand(parent: Command): void;

package/dist/commands/generate/image.d.ts

@@ -1,8 +1,9 @@
 /**
  * @module generate/image
- * @description `vibe generate image` (alias `img`) — multi-provider image
- * generation. OpenAI gpt-image-2.5, Gemini Nano Banana, Grok, Runway. Split
- * out of `generate.ts` in v0.69 (Plan G Phase 2).
+ * @description `vibe generate image` (alias `img`) — image generation on
+ * OpenAI GPT Image, Gemini Nano Banana, or Grok Imagine. Validation,
+ * provider choice, and the dry run live here; generation is
+ * `executeImageGenerate`, the same executor the MCP tool and pipelines use.
  */
 import type { Command } from "commander";
 export declare function registerImageCommand(parent: Command): void;

package/dist/commands/generate/music.d.ts

@@ -5,6 +5,7 @@
  * conditioning). Split out of `generate.ts` in v0.69 (Plan G Phase 2).
  */
 import type { Command } from "commander";
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteMusicOptions {
     prompt: string;
     output?: string;
@@ -12,6 +13,9 @@ export interface ExecuteMusicOptions {
     provider?: "elevenlabs" | "replicate";
     instrumental?: boolean;
     wait?: boolean;
+    /** Replicate MusicGen variant: large, stereo-large, melody-large, stereo-melody-large. */
+    model?: string;
+    apiKey?: string;
 }
 export interface ExecuteMusicResult {
     success: boolean;
@@ -22,6 +26,7 @@ export interface ExecuteMusicResult {
     status?: string;
     audioUrl?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeMusic(options: ExecuteMusicOptions): Promise<ExecuteMusicResult>;
 export declare function registerMusicCommand(parent: Command): void;

package/dist/commands/generate/sound-effect.d.ts

@@ -1,19 +1,25 @@
 /**
  * @module generate/sound-effect
  * @description `vibe generate sound-effect` — ElevenLabs SFX generation.
- * Split out of `generate.ts` in v0.69 (Plan G Phase 2).
+ * The command validates and formats; `executeSoundEffect` (also used by
+ * pipelines and the MCP tool) does the work.
  */
 import type { Command } from "commander";
+import { type ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteSoundEffectOptions {
     prompt: string;
     output?: string;
+    /** Seconds (0.5-30); the model picks when omitted. */
     duration?: number;
+    /** 0-1, default 0.3. */
     promptInfluence?: number;
+    apiKey?: string;
 }
 export interface ExecuteSoundEffectResult {
     success: boolean;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeSoundEffect(options: ExecuteSoundEffectOptions): Promise<ExecuteSoundEffectResult>;
 export declare function registerSoundEffectCommand(parent: Command): void;

package/dist/commands/generate/speech.d.ts

@@ -1,20 +1,29 @@
 /**
  * @module generate/speech
- * @description `vibe generate speech` (alias `tts`) — ElevenLabs text-to-
- * speech with optional duration-fit post-processing. Split out of
- * `generate.ts` in v0.69 (Plan G Phase 2).
+ * @description `vibe generate narration` (alias `voiceover`) — text to
+ * speech on ElevenLabs, OpenAI, or local Kokoro, through the same TTS
+ * resolver scenes and builds use.
  */
 import type { Command } from "commander";
+import type { ProviderErrorKind } from "@vibeframe/ai-providers";
 export interface ExecuteSpeechOptions {
     text: string;
     output?: string;
     voice?: string;
+    /** auto (default): ElevenLabs if its key is set, else OpenAI, else local Kokoro. */
+    provider?: string;
+    /** Catalog model ID or alias for the chosen provider. */
+    model?: string;
+    speed?: number;
 }
 export interface ExecuteSpeechResult {
     success: boolean;
     outputPath?: string;
     characterCount?: number;
+    provider?: string;
+    model?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeSpeech(options: ExecuteSpeechOptions): Promise<ExecuteSpeechResult>;
 export declare function registerNarrationCommand(parent: Command): void;

package/dist/commands/generate.d.ts

@@ -18,8 +18,6 @@
 import { Command } from "commander";
 export { executeSoundEffect } from "./generate/sound-effect.js";
 export type { ExecuteSoundEffectOptions, ExecuteSoundEffectResult, } from "./generate/sound-effect.js";
-export { executeMusicStatus } from "./generate/music-status.js";
-export type { ExecuteMusicStatusOptions, ExecuteMusicStatusResult, } from "./generate/music-status.js";
 export { executeStoryboard } from "./generate/storyboard.js";
 export type { ExecuteStoryboardOptions, ExecuteStoryboardResult } from "./generate/storyboard.js";
 export { executeSpeech } from "./generate/speech.js";

package/dist/commands/output.d.ts

@@ -40,7 +40,6 @@ export declare function apiError(msg: string, retryable?: boolean): StructuredEr
  */
 export declare function providerFailure(message: string, kind?: string): StructuredError;
 export declare function notFoundError(path: string): StructuredError;
-export declare function networkError(msg: string): StructuredError;
 export declare function generalError(msg: string, suggestion?: string): StructuredError;
 /**
  * The `--max-cost` refusal. A command that declines to spend is a failure, so
@@ -114,8 +113,6 @@ export declare function outputResult(result: Record<string, unknown>): void;
 export declare function log(...args: unknown[]): void;
 /** Create a spinner that is silent in JSON/quiet mode */
 export declare function spinner(text: string): ReturnType<typeof ora>;
-/** Suggest next steps - only in human interactive mode */
-export declare function suggestNext(tip: string): void;
 export declare function emitDeprecationWarning(oldName: string, newName: string, removeIn: string): void;
 /** Test-only: reset deduplication memory between cases. */
 export declare function _resetDeprecationMemoryForTesting(): void;

package/dist/commands/sanitize.d.ts

@@ -8,11 +8,6 @@
  * fake system prompts, and markdown-disguised commands.
  */
 export declare function sanitizeLLMResponse(text: string): string;
-/**
- * Sanitize a file path returned by an AI model.
- * Prevents path traversal and null byte injection.
- */
-export declare function sanitizeFilePath(path: string): string;
 /**
  * Sanitize structured data from AI responses (e.g., JSON parsed results).
  * Recursively sanitizes all string values.

package/dist/commands/validate.d.ts

@@ -20,14 +20,3 @@ export declare function validateResourceId(id: string): string;
  * Prevents terminal injection and other control-char exploits.
  */
 export declare function rejectControlChars(input: string): string;
-/**
- * Validate a media file path and check its extension against an allowlist.
- */
-export declare function validateMediaFile(path: string, allowedExts: string[]): string;
-/** Common media file extensions */
-export declare const MEDIA_EXTS: {
-    video: string[];
-    audio: string[];
-    image: string[];
-    subtitle: string[];
-};

package/dist/config/index.d.ts

@@ -21,10 +21,6 @@ export type Scope = "user" | "project";
 export declare const USER_CONFIG_DIR: string;
 /** User-scope config file (~/.vibeframe/config.yaml by default). */
 export declare const USER_CONFIG_PATH: string;
-/** User data directory (~/.local/share/vibeframe by default). */
-export declare const USER_DATA_DIR: string;
-/** User cache directory (~/.vibeframe/cache by default). */
-export declare const USER_CACHE_DIR: string;
 /** Legacy user-scope config directory used by pre-XDG installs. */
 export declare const LEGACY_USER_CONFIG_DIR: string;
 /** Legacy user-scope config file used by pre-XDG installs. */
@@ -101,10 +97,5 @@ export declare function isConfigured(options?: Pick<LoadConfigOptions, "cwd">):
  * the provider's environment variable if neither config has it.
  */
 export declare function getApiKeyFromConfig(providerKey: string, options?: Pick<LoadConfigOptions, "cwd">): Promise<string | undefined>;
-/**
- * Update a provider key in the active scope (project if present, else user).
- * Pass `{scope}` to force a specific destination.
- */
-export declare function updateProviderKey(providerKey: string, apiKey: string, options?: SaveConfigOptions): Promise<void>;
 export type { VibeConfig, LLMProvider } from "./schema.js";
 export { createDefaultConfig, PROVIDER_NAMES, PROVIDER_ENV_ALIASES, PROVIDER_ENV_VARS, } from "./schema.js";