@spark-apps/quickpeek 1.2.3 → 1.2.5

package/dist/voices-ufga0oOn.d.mts

@@ -0,0 +1,647 @@
+import { Page } from 'playwright';
+
+/**
+ * Configuration types and defaults for QuickPeek
+ */
+declare const VERSION = "1.2.5";
+declare const CONFIG_FILE = "quickpeek.config.json";
+type UserTier = 'free' | 'pro' | 'elite';
+/** The one dimension knob users see: wide (16:9) or short (9:16). */
+type VideoSize = 'wide' | 'short';
+/** Narration pace, mapped to an Edge TTS rate. */
+type VoiceRate = 'slow' | 'normal' | 'fast';
+type VoiceGender = 'female' | 'male';
+/**
+ * What each size means in pixels. `zoom` shrinks the CSS viewport so a
+ * portrait page hits its mobile breakpoints and text stays legible; wide
+ * records at desktop layout untouched.
+ */
+declare const SIZE_PRESETS: Record<VideoSize, {
+    width: number;
+    height: number;
+    zoom: number;
+}>;
+/**
+ * The three named paces as multipliers of the voice's natural rate.
+ *
+ * A multiplier rather than the edge-tts "-20%" string it used to be, so the
+ * named pace can COMPOSE with the profile's numeric `audio.speed` instead of
+ * excluding it - see the note in tts/generate.ts, where excluding it made
+ * `audio.speed` dead code and took the profiles' narration pace with it.
+ */
+declare const RATE_FACTOR: Record<VoiceRate, number>;
+/**
+ * Set as video.outro when the closing card is already a plan step.
+ *
+ * Lives here rather than with the phase that sets it because compose reads it
+ * too: a run that ends on a credits card must not also stamp the free-tier
+ * end text over that card.
+ */
+declare const NO_CLIP_OUTRO = "@card-step";
+interface Config {
+    lang?: string;
+    plan?: {
+        maxSteps: number;
+    };
+    browser?: {
+        extension?: string;
+    };
+    profile?: 'wide' | 'short';
+    video: {
+        size: VideoSize;
+        width: number;
+        height: number;
+        format: string;
+        preset: 'ultrafast' | 'superfast' | 'veryfast' | 'faster' | 'fast' | 'medium' | 'slow' | 'slower' | 'veryslow';
+        quality: number;
+        fps: number;
+        cursor: boolean;
+        highlight: false | 'outline' | 'full';
+        fadeIn: number;
+        fadeOut: number;
+        transitions: 'none' | 'fade' | 'blend';
+        contrast: number;
+        tempo: number;
+        stepDelay: number;
+        watermark?: {
+            name: string;
+            iconPath?: string;
+            position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+            opacity?: number;
+        };
+        outro?: string;
+        outroCard?: {
+            /** The app the video is about - the card's headline. */
+            subject: {
+                name: string;
+                tagline?: string;
+                domain?: string;
+                iconPath?: string;
+                /** Play the mark rather than show a still of it. See OutroSubject. */
+                animatedMark?: 'vidlet';
+            };
+            /** Tools that made the video, shown small in the corner. */
+            credits?: Array<{
+                name: string;
+                role: string;
+                iconPath?: string;
+            }>;
+            promo?: {
+                code: string;
+                percent: number;
+                site?: string;
+            };
+            /**
+             * Say "free to start" on the closing card. Default true.
+             *
+             * Almost every product this records is freemium, and the free tier is
+             * the one closing line that never expires the way a discount code does,
+             * so it is opt-out rather than opt-in. Set false for a paid-only product.
+             */
+            freeTier?: boolean;
+            seconds?: number;
+        };
+        zoom?: number;
+        maxSpeedup?: number;
+        autoPan?: boolean;
+        introCard?: boolean;
+        outroCardEnabled?: boolean;
+        introCardSeconds?: number;
+        maxSilenceSecs?: number;
+        fitLimitSecs?: number;
+        captions?: Partial<CaptionStyle>;
+        hwaccel?: 'auto' | 'off';
+        captionsBurn?: boolean;
+    };
+    audio?: {
+        voice?: string;
+        gender?: VoiceGender;
+        rate?: VoiceRate;
+        format: string;
+        bitrate: string;
+        speed?: number;
+        voiceover?: boolean;
+        voiceClipsDir?: string;
+        ambience?: boolean;
+        transcribe?: boolean;
+    };
+    music?: {
+        path: string;
+        volume: number;
+        /**
+         * Which bundled CC0 bed to score with when no `path` is given.
+         *
+         * 'corporate' | 'calm' | 'lofi' - see assets/music/manifest.json. An unknown
+         * mood falls back to the default rather than dropping the music.
+         */
+        mood?: string;
+        /**
+         * Hold the music back until the closing card.
+         *
+         * A track written FOR the product is not a bed: ducked under a narrator
+         * for a minute it is inaudible, and it is the thing people are meant to
+         * hear. With this on, the demo plays dry and the song fades in exactly as
+         * the closing card arrives, with the rest of the video silent underneath
+         * the voice.
+         *
+         * ON by default. Music under narration was the single most disliked thing
+         * about the output: ducked it is mud, unducked it fights the voice, and
+         * either way it makes a 17 second demo sound like a stock video. Set
+         * false in quickpeek.config.json to score the whole video.
+         */
+        outroOnly?: boolean;
+    };
+    timing: {
+        minStepDuration: number;
+        /**
+         * Ceiling on a step's hold, in ms. Undefined means none.
+         *
+         * A demo is filmed in real time, so its holds ARE the recording time: a
+         * 75s video costs 75s to shoot no matter what the encoder does. Capping
+         * them is the only thing that makes a draft quick, and it is the one
+         * trade a draft can afford, since the question a draft answers is whether
+         * the demo clicks the right things in the right order.
+         */
+        maxStepDuration?: number;
+        /**
+         * How long an action waits for the page to paint, in ms.
+         *
+         * The recording floor is not the holds, it is the page loads: eleven
+         * navigations each waiting on content is most of a draft's runtime. A
+         * draft is allowed to film a half-drawn page; a deliverable is not.
+         */
+        paintBudget?: number;
+    };
+    output: {
+        dir: string;
+    };
+}
+interface CaptionWordStyle {
+    color: string;
+    size: number;
+    bold: boolean;
+}
+type CaptionPreset = 'karaoke' | 'hormozi' | 'shorts' | 'minimal';
+type CaptionPosition = 'bottom' | 'center' | 'top';
+interface CaptionStyle {
+    font: string;
+    outline: string;
+    outlineWidth: number;
+    shadow: number;
+    marginBottom: number;
+    preset: CaptionPreset;
+    position: CaptionPosition;
+    regular: CaptionWordStyle;
+    highlight: CaptionWordStyle;
+    /**
+     * Characters a caption line may reach before it wraps.
+     *
+     * A ceiling, not a target: the renderer narrows it further to whatever the
+     * frame actually fits at this font size. It exists because "fits the frame"
+     * and "reads at a glance on a phone" are different questions - a 9:16 short
+     * wants two short lines where a 16:9 tutorial is happy with one long one.
+     */
+    maxChars: number;
+}
+declare const DEFAULT_CONFIG: Config;
+/** The two standard deliverables. Every generated demo is one or the other. */
+type VideoProfileName = 'wide' | 'short';
+/**
+ * Standard settings per deliverable, applied over the loaded config.
+ *
+ * wide: a 16:9 educational tutorial. Comprehensive, natural pace - no
+ * over-limit squeeze (fitLimitSecs 0), desktop layout (zoom 1.5), narration
+ * slightly brisker than the voice's default.
+ *
+ * short: a 9:16 quick-paced short. Covers every interesting detail even past
+ * a minute, then is squeezed toward 60s - but never beyond 1.7x, because past
+ * that the fix is a tighter plan, not a faster player.
+ */
+declare const VIDEO_PROFILES: Record<VideoProfileName, {
+    video: Partial<Config['video']>;
+    audioSpeed: number;
+    voice?: string;
+}>;
+/** Overlay a standard profile on a loaded config. Explicit knobs win where set. */
+declare function applyProfile(config: Config, profile: VideoProfileName): Config;
+declare const DEFAULT_CAPTIONS: CaptionStyle;
+/**
+ * Caption geometry that suits the canvas, expressed as fractions of it.
+ *
+ * The fixed defaults above were authored once and applied to every shape, and
+ * on the 1080x1920 canvas QuickPeek defaults to they are wrong in three ways
+ * at once: 56px is 5% of the frame width, which is a desktop subtitle rather
+ * than a social caption; 80px of bottom margin puts the words 4% up the frame,
+ * underneath the title, channel row and action rail every phone player draws
+ * over the bottom of a vertical video; and 28 characters at that size is a
+ * single long line the eye has to track rather than a short stack it can take
+ * in at a glance.
+ *
+ * Fractions rather than pixels so the same reasoning holds at 720x1280 or
+ * 1440x2560. The portrait numbers: text at 21% of frame height clears the
+ * player chrome on YouTube Shorts, TikTok and Reels while staying in the lower
+ * third, and ~9% of frame width is the size those platforms' own captions use.
+ */
+declare function defaultCaptionsFor(width: number, height: number): CaptionStyle;
+
+/**
+ * AI API client — Spark AI communication
+ * Handles token management, rate limiting, and retries
+ *
+ * Two transports:
+ * - Relay (default for the published CLI): quickpeek-web mints a short-lived
+ *   per-user token from a registered email and proxies the chat server-side.
+ *   No credential ships in the npm bundle.
+ * - Direct (dev/server only): when SPARK_AI_KEY is present in the runtime
+ *   environment (never baked at build time), call Spark AI directly. This is
+ *   the path quickpeek-web itself uses server-side.
+ */
+
+interface RateLimitInfo {
+    used: number;
+    limit: number;
+    tier: UserTier;
+    resetAt?: string;
+}
+interface AIResponse {
+    success: true;
+    content: string;
+    limits: RateLimitInfo;
+}
+interface AIError {
+    success: false;
+    error: string;
+    isRateLimit?: boolean;
+    isAuthError?: boolean;
+    retryAfterSeconds?: number;
+    /** Upstream HTTP status, when the failure was an HTTP response. */
+    status?: number;
+    /** Host that produced the failure, so relay vs backend is distinguishable. */
+    host?: string;
+    /** Raw response body (truncated), for the error log. */
+    detail?: string;
+}
+type AIResult = AIResponse | AIError;
+/** Called before each backoff so the CLI can explain a long pause. */
+type RetryNotice = (info: {
+    attempt: number;
+    status: number;
+    delayMs: number;
+    host: string;
+}) => void;
+interface ChatOptions {
+    onRetry?: RetryNotice;
+    /**
+     * Backoff before each 5xx retry. Defaults to SERVER_BACKOFF_MS, which is
+     * sized to fit inside a serverless function budget — callAI runs inside the
+     * quickpeek-web routes as well as the CLI. Interactive callers should pass
+     * CLI_BACKOFF_MS, which can afford to outwait the backend's closed window.
+     */
+    backoffMs?: number[];
+    /**
+     * Completion-token budget to ask the backend for. Omitted, the backend falls
+     * back to the app's own default, which is 300 — far too small for the JSON
+     * this CLI asks for. See PLAN_MAX_TOKENS.
+     */
+    maxTokens?: number;
+}
+/**
+ * Every AI call this CLI makes is structured generation: a JSON plan with one
+ * entry per script line, or one caption per step. The backend defaults to a
+ * 300-token completion budget sized for a two-sentence chat reply, and a
+ * 14-line plan measured ~300 tokens of JSON on its own, so the default
+ * truncated every real run mid-array (salvaged silently by the JSON repair
+ * path) and returned nothing at all once the model's own reasoning ate the
+ * budget first. Ask for a budget the output actually fits in.
+ */
+declare const PLAN_MAX_TOKENS = 1500;
+/** Short enough to stay well inside a serverless maxDuration. */
+declare const SERVER_BACKOFF_MS: number[];
+/**
+ * Long enough to outlast the AI backend's ~45-60s closed window (measured
+ * 16 Aug 2026). Only safe where a human is waiting on a spinner.
+ */
+declare const CLI_BACKOFF_MS: number[];
+declare const RELAY_BASE: string;
+/**
+ * Relay mode: exchange the signed-in email for a short-lived relay token (cached)
+ */
+declare function getOrRefreshRelayToken(email: string): Promise<string>;
+/**
+ * Direct Spark AI call using the runtime SPARK_AI_KEY (dev + server-side use).
+ */
+declare function callAI(systemPrompt: string, userPrompt: string, tier?: UserTier, opts?: ChatOptions): Promise<AIResult>;
+/**
+ * Relayed Spark AI call for the published CLI: authenticates with the user's
+ * registered email via quickpeek-web, which holds the real key server-side
+ * and enforces per-user daily limits.
+ */
+declare function callAIViaRelay(systemPrompt: string, userPrompt: string, email: string, tier?: UserTier, opts?: ChatOptions): Promise<AIResult>;
+/**
+ * Parse AI-generated plan JSON from response text
+ */
+declare function parseAIPlanResponse(content: string): {
+    success: true;
+    plan: {
+        title?: string;
+        description?: string;
+        steps: Array<{
+            id?: number;
+            action?: string;
+            caption?: string;
+            target?: string;
+            value?: string;
+        }>;
+    };
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Normalize a URL by adding https:// and stripping www prefix
+ */
+declare function normalizeUrl(input: string): string;
+
+/**
+ * Shared types for QuickPeek core
+ */
+/** Action type suggested for an element based on its type */
+type SuggestedAction = 'click' | 'type' | 'upload' | 'drag' | 'select' | 'check';
+/** Element type discovered on a page */
+type ElementType = 'button' | 'input' | 'link' | 'text' | 'file' | 'select' | 'range' | 'checkbox';
+/** Discovered element from page crawl */
+interface ElementInfo {
+    /** Element type */
+    type: ElementType | string;
+    /** Display text/label for the element */
+    text: string;
+    /** CSS selector to target the element */
+    selector: string;
+    /** Suggested action for this element */
+    action?: SuggestedAction;
+    /** Simplified target name (just the text, for AI use) */
+    target?: string;
+    /** Same-origin destination, for links the planner may navigate to. */
+    href?: string | undefined;
+}
+/** Highlight mode for UI elements */
+type HighlightMode = false | 'outline' | 'full';
+/** Step in a demo plan */
+interface Step {
+    id: number | string;
+    action: string;
+    target?: string;
+    value?: string;
+    caption?: string;
+    description?: string;
+    duration?: number;
+    zoom?: number | string;
+    partial?: string;
+    transition?: 'fade' | 'blend';
+    highlight?: HighlightMode;
+    mediaFile?: string;
+    mediaType?: 'image' | 'video';
+    /**
+     * A small JPEG data URL of the file `value` names, attached only when a plan
+     * is handed to the browser editor, which cannot read a path on disk. Never
+     * written to a plan file; see plan-thumbs.ts.
+     */
+    thumb?: string;
+    /**
+     * Speak this step's caption but do not burn it.
+     *
+     * For a step whose frame is already type - a title or closing card - where
+     * a burned caption lands on top of the words it is repeating.
+     */
+    spokenOnly?: boolean;
+}
+/** Demo plan structure */
+interface Plan {
+    url: string;
+    title: string;
+    description: string;
+    lang?: string;
+    steps: Step[];
+}
+
+/**
+ * Page crawling and interactive element extraction
+ */
+
+/**
+ * Wait until the loading placeholders are gone, or give up and film anyway.
+ *
+ * waitForDomStable counts elements, and a skeleton shell is exactly the state
+ * where that count has already stopped moving: the panels are on screen, they
+ * are just grey. So the recorder started step 1 over spinners and the opening
+ * seconds of the demo are the app pretending to be itself.
+ *
+ * Three ways out, and none of them can hang a run: no placeholders (the
+ * common case, one evaluate and no wait at all), a count that never budges -
+ * which is furniture, a permanent element whose class happens to say spinner,
+ * not loading state - or the cap.
+ */
+declare function waitForPlaceholdersGone(page: Page, cap?: number): Promise<void>;
+/**
+ * Navigate and give the page a bounded chance to finish rendering.
+ *
+ * `networkidle` as the goto condition strands on pages that poll or stream —
+ * a signed-in dashboard rarely goes idle, so goto times out with the page
+ * already painted. Land on domcontentloaded, which such pages do reach, then
+ * wait for idle only as a best effort, then for the DOM to hold still, and
+ * finally for the skeletons to clear - a shell whose element count has
+ * settled is still not a page anyone wants filmed.
+ */
+declare function gotoSettled(page: Page, url: string, timeout?: number): Promise<void>;
+
+/**
+ * A selector matching one id.
+ *
+ * HTML ids are far more permissive than CSS identifiers: `description-(optional)`
+ * is a perfectly legal id, but `#description-(optional)` is invalid CSS and
+ * Playwright rejects it, so the step silently finds nothing. Anything that is
+ * not identifier-safe gets the attribute form instead.
+ */
+declare function idSelector(id: string): string;
+/**
+ * A selector matching one aria-label.
+ *
+ * An icon-only button carries its label in `aria-label`, and Playwright's
+ * `text=` engine and `:has-text()` both match rendered text — never attributes.
+ * A label borrowed from the attribute therefore has to be emitted as one too,
+ * or the selector matches nothing at all.
+ */
+declare function ariaLabelSelector(label: string): string;
+/**
+ * Crawl a page and extract interactive elements with smart selectors
+ * Results are cached in-memory for a few minutes to avoid duplicate browser launches
+ * @param url - URL to crawl
+ * @param task - Optional progress reporter (CLI uses ora spinners, web can omit)
+ */
+declare function crawlPage(url: string, task?: (text: string) => {
+    succeed: (text?: string) => void;
+}, storageStatePath?: string, viewport?: {
+    width: number;
+    height: number;
+}): Promise<{
+    title: string;
+    elements: ElementInfo[];
+    scrollable: number;
+}>;
+
+/**
+ * Utility functions for QuickPeek
+ */
+/**
+ * Get full language name from ISO code
+ */
+declare function getLanguageName(lang?: string): string | null;
+
+/**
+ * Convert rgba() or rgb() color string to hex
+ */
+declare function rgbaToHex(color: string): string;
+
+/**
+ * Parse partial field "start-end" into trim values
+ * e.g., "0-3.5" -> { trimStart: 0, trimEnd: 3.5 }
+ * e.g., "2-" -> { trimStart: 2, trimEnd: undefined }
+ */
+declare function parsePartial(partial: string | undefined): {
+    trimStart?: number;
+    trimEnd?: number;
+};
+/**
+ * Extract a message string from an unknown error value
+ */
+declare function getErrorMessage(err: unknown): string;
+declare function deStock(text: string): string;
+/**
+ * Strip dashes a caption should never carry.
+ *
+ * House rule: no em or en dashes in anything QuickPeek burns or speaks. On
+ * screen a long dash at portrait sizes is hard to tell from a hyphen and
+ * eats width a short has none of; spoken, edge-tts reads it as a hard stop
+ * mid-sentence. A comma does the same job in both places.
+ *
+ * A dash BETWEEN digits is a range ("2-3x", "10-20%"), so it becomes a
+ * hyphen rather than a comma.
+ */
+declare function stripLongDashes(text: string): string;
+/**
+ * Convert text to Title Case, keeping prepositions/articles lowercase
+ * First word is always capitalized
+ */
+declare function toTitleCase(text: string): string;
+/**
+ * Run `task` for every index in [0, count) with at most `size` in flight.
+ *
+ * Workers pull from a shared cursor rather than being handed a fixed slice, so
+ * one slow item does not leave its worker's remaining share unstarted while
+ * others sit idle. Tasks are expected to record their own results by index;
+ * nothing is collected here, because the callers that need ordering want to
+ * assemble it themselves.
+ */
+declare function runPooled(count: number, size: number, task: (index: number) => Promise<void>): Promise<void>;
+
+/**
+ * AI prompts for demo plan generation
+ */
+
+declare function buildSystemPrompt(maxSteps: number, profile?: 'wide' | 'short'): string;
+declare function buildUserPrompt(url: string, title: string, elements: ElementInfo[], langName: string | null, description: string | undefined, maxSteps: number, scrollable?: number): string;
+
+type Tier = 'free' | 'pro' | 'elite';
+interface SparkSubscription {
+    payment_type: 'subscription' | 'one_time';
+    status: 'active' | 'trialing' | 'past_due' | 'canceled' | 'lifetime';
+    is_lifetime: boolean;
+    current_period_end: string;
+    cancel_at_period_end: boolean;
+    billing_interval: 'monthly' | 'yearly' | 'one_time';
+    price_id: string;
+    created_at: string;
+}
+interface SparkTrial {
+    is_expired: boolean;
+    days_remaining: number;
+    uses_remaining: number;
+    max_days: number;
+    max_uses: number;
+}
+interface SparkStatus {
+    subscription: SparkSubscription | null;
+    verified: boolean;
+    registered: boolean;
+    usage_count: number;
+    trial: SparkTrial | null;
+    message?: string;
+}
+declare const getStatus: (email: string) => Promise<SparkStatus>;
+declare function getStatusCached(email: string): Promise<SparkStatus>;
+declare function getTier(d: SparkStatus): Tier;
+declare const isPaid: (d: SparkStatus) => boolean;
+declare const hasTrialRemaining: (d: SparkStatus) => boolean;
+declare const showPaywall: (d: SparkStatus) => boolean;
+declare const isCanceling: (d: SparkStatus) => boolean;
+/** Resolve tier directly from an email — the most common consumer call. Falls back to 'free' on error. */
+declare function getTierByEmail(email: string): Promise<Tier>;
+/** Check whether an email is verified. Falls back to false on error. */
+declare function isVerified(email: string): Promise<boolean>;
+declare function pricingUrl(opts?: {
+    email?: string;
+    returnUrl?: string;
+}): string;
+
+/**
+ * Shared constants for page scraping and element filtering
+ * Used by both CLI and web versions
+ */
+declare const EXCLUDED_LINK_PATTERNS: string[];
+/** CSS selectors for interactive page elements */
+declare const INTERACTIVE_SELECTORS: string[];
+/** Check if link text or href matches an excluded pattern */
+declare function isExcludedLink(text: string, href?: string): boolean;
+/** Check if a link should be skipped during crawling */
+declare function shouldSkipLink(text: string, href: string, currentPath: string): boolean;
+
+/**
+ * Edge TTS voice selection.
+ *
+ * QuickPeek uses the kit's WIDE table: 68 languages with standard neural
+ * voices and en-GB for English. Breadth matters more than polish here,
+ * because a demo gets captioned for whatever audience asked for it. Male
+ * voices exist for the 14 major languages of the kit's MALE table; the rest
+ * fall back to the standard voice for that language rather than switching
+ * language just to keep the gender.
+ */
+
+/**
+ * Asking for the multilingual voices by name rather than by Edge id.
+ *
+ * `audio.voice` takes an exact voice, which is precise and useless for
+ * choosing a SET: the multilingual voice differs per language, so an exact id
+ * pins the config to one language. This word resolves per language instead,
+ * so the same config narrates a demo in any of them.
+ */
+declare const INTERNATIONAL_VOICE = "international";
+/**
+ * The multilingual neural voice for a language, e.g. en-US-AvaMultilingualNeural.
+ *
+ * These read noticeably better than the standard neural voices and carry an
+ * accent across languages instead of switching person. The WIDE table is
+ * still the fallback: multilingual voices do not exist for every language,
+ * and dropping to the standard voice for one is better than no narration.
+ */
+declare function internationalVoiceFor(lang: string, gender?: VoiceGender): string | null;
+/** Whether narration exists for this language at all. */
+declare function hasVoice(lang: string): boolean;
+/**
+ * The Edge voice for a language + gender, falling back through WIDE_VOICES —
+ * or null for a language with no voice at all. Null keeps the deliberate
+ * captions-only fallback: English narration over foreign captions would be
+ * worse than silence.
+ */
+declare function voiceFor(lang: string, gender?: VoiceGender): string | null;
+
+export { getStatus as $, type AIError as A, type VideoSize as B, type CaptionStyle as C, DEFAULT_CAPTIONS as D, EXCLUDED_LINK_PATTERNS as E, type VoiceGender as F, applyProfile as G, type HighlightMode as H, INTERACTIVE_SELECTORS as I, ariaLabelSelector as J, buildSystemPrompt as K, buildUserPrompt as L, callAI as M, NO_CLIP_OUTRO as N, callAIViaRelay as O, PLAN_MAX_TOKENS as P, crawlPage as Q, RATE_FACTOR as R, SERVER_BACKOFF_MS as S, type Tier as T, type UserTier as U, type VoiceRate as V, deStock as W, defaultCaptionsFor as X, getErrorMessage as Y, getLanguageName as Z, getOrRefreshRelayToken as _, type CaptionPosition as a, getStatusCached as a0, getTierByEmail as a1, gotoSettled as a2, hasTrialRemaining as a3, hasVoice as a4, idSelector as a5, internationalVoiceFor as a6, isCanceling as a7, isExcludedLink as a8, isPaid as a9, isVerified as aa, normalizeUrl as ab, parseAIPlanResponse as ac, parsePartial as ad, pricingUrl as ae, rgbaToHex as af, runPooled as ag, shouldSkipLink as ah, showPaywall as ai, stripLongDashes as aj, toTitleCase as ak, voiceFor as al, waitForPlaceholdersGone as am, getTier as an, type Config as b, type AIResponse as c, type AIResult as d, CLI_BACKOFF_MS as e, CONFIG_FILE as f, type CaptionPreset as g, type CaptionWordStyle as h, type ChatOptions as i, DEFAULT_CONFIG as j, type ElementInfo as k, type ElementType as l, INTERNATIONAL_VOICE as m, type Plan as n, RELAY_BASE as o, type RateLimitInfo as p, type RetryNotice as q, SIZE_PRESETS as r, type SparkStatus as s, type SparkSubscription as t, type SparkTrial as u, type Step as v, type SuggestedAction as w, VERSION as x, VIDEO_PROFILES as y, type VideoProfileName as z };

package/dist/web.d.mts

@@ -1,6 +1,7 @@
-import { P as Plan } from './scraping-C334VxX5.mjs';
-export { A as AIError, a as AIResponse, b as AIResult, E as EXCLUDED_LINK_PATTERNS, i as ElementInfo, j as ElementType, F as FEATURES, H as HighlightMode, I as INTERACTIVE_SELECTORS, R as RateLimitInfo, l as SparkStatus, m as SparkSubscription, n as SparkTrial, o as Step, p as SuggestedAction, T as Tier, q as buildSystemPrompt, r as buildUserPrompt, s as callAI, u as crawlPage, v as getErrorMessage, w as getLanguageName, x as getStatus, y as getStatusCached, a0 as getTier, z as getTierByEmail, B as hasAccess, G as hasTrialRemaining, K as isCanceling, L as isExcludedLink, M as isPaid, N as isVerified, O as normalizeUrl, Q as parseAIPlanResponse, W as parsePartial, X as pricingUrl, Y as rgbaToHex, Z as shouldSkipLink, _ as showPaywall, $ as toTitleCase } from './scraping-C334VxX5.mjs';
-export { WIDE_VOICES as LANGUAGE_VOICES, hexToAss as hexToASS, windowsDrivePathToWsl as windowsPathToWSL } from '@spark-apps/video-kit';
+import { n as Plan } from './voices-ufga0oOn.mjs';
+export { A as AIError, c as AIResponse, d as AIResult, i as ChatOptions, E as EXCLUDED_LINK_PATTERNS, k as ElementInfo, l as ElementType, H as HighlightMode, I as INTERACTIVE_SELECTORS, m as INTERNATIONAL_VOICE, P as PLAN_MAX_TOKENS, p as RateLimitInfo, s as SparkStatus, t as SparkSubscription, u as SparkTrial, v as Step, w as SuggestedAction, T as Tier, K as buildSystemPrompt, L as buildUserPrompt, M as callAI, Q as crawlPage, W as deStock, Y as getErrorMessage, Z as getLanguageName, $ as getStatus, a0 as getStatusCached, an as getTier, a1 as getTierByEmail, a3 as hasTrialRemaining, a4 as hasVoice, a6 as internationalVoiceFor, a7 as isCanceling, a8 as isExcludedLink, a9 as isPaid, aa as isVerified, ab as normalizeUrl, ac as parseAIPlanResponse, ad as parsePartial, ae as pricingUrl, af as rgbaToHex, ag as runPooled, ah as shouldSkipLink, ai as showPaywall, aj as stripLongDashes, ak as toTitleCase, al as voiceFor } from './voices-ufga0oOn.mjs';
+export { MALE_VOICES, MULTILINGUAL_VOICES, WIDE_VOICES, hexToAss as hexToASS, windowsDrivePathToWsl as windowsPathToWSL } from '@spark-apps/video-kit';
+import 'playwright';
 
 /**
  * The plan file, and handing it to the browser editor.
@@ -112,6 +113,7 @@ interface PreservedValues {
         mediaType: string | undefined;
     }>;
     mediaSteps: Array<{
+        value: string | undefined;
         mediaFile: string | undefined;
         mediaType: string | undefined;
         target: string | undefined;