@spark-apps/quickpeek 1.2.1 → 1.2.3

package/dist/qp.js

@@ -128,6 +128,20 @@ var init_utils = __esm({
 function apiKey() {
   return process.env.SPARK_AI_KEY || "";
 }
+function hostOf2(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return "AI service";
+  }
+}
+function firstLine(text) {
+  return truncate((text ?? "").trim().split("\n")[0] ?? "", 200);
+}
+function truncate(text, max) {
+  const trimmed = (text ?? "").trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max)}\u2026` : trimmed;
+}
 async function getOrRefreshDirectToken() {
   const now = Date.now();
   if (cachedDirectToken && cachedDirectToken.expiresAt > now + 3e5) {
@@ -179,8 +193,10 @@ async function getOrRefreshRelayToken(email) {
     throw new Error(`Failed to get QuickPeek token: ${getErrorMessage(err)}`);
   }
 }
-async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier) {
-  let lastRateLimitError = null;
+async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier, opts = {}) {
+  const { onRetry, backoffMs = SERVER_BACKOFF_MS } = opts;
+  let lastRetriableError = null;
+  const host = hostOf2(chatUrl);
   for (let attempt = 1; attempt <= 3; attempt++) {
     try {
       const response = await fetch(chatUrl, {
@@ -196,36 +212,53 @@ async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier)
           ]
         })
       });
+      const bodyText = await response.text().catch(() => "");
       let data = {};
-      const contentType = response.headers.get("content-type") ?? "";
-      if (contentType.includes("application/json")) {
-        data = await response.json();
+      try {
+        data = bodyText ? JSON.parse(bodyText) : {};
+      } catch {
       }
       if (!response.ok) {
-        const error = data.error || `Spark AI error: ${response.status} ${response.statusText}`;
-        if (response.status === 429 && attempt < 3) {
-          const retryAfter = response.headers.get("Retry-After");
-          const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 1e3 * 2 ** (attempt - 1);
-          lastRateLimitError = {
+        const upstream = data.error || firstLine(bodyText) || response.statusText || "no error body";
+        const error = `${host} ${response.status}: ${upstream}`;
+        const detail = truncate(bodyText, 800);
+        const isRetriable = response.status === 429 || response.status >= 500;
+        if (isRetriable && attempt < 3) {
+          const retryAfter2 = response.headers.get("Retry-After");
+          const delayMs = retryAfter2 ? parseInt(retryAfter2, 10) * 1e3 : response.status >= 500 ? backoffMs[attempt - 1] ?? backoffMs[backoffMs.length - 1] ?? 2e3 : 1e3 * 2 ** (attempt - 1);
+          onRetry?.({ attempt, status: response.status, delayMs, host });
+          lastRetriableError = {
             success: false,
             error,
-            isRateLimit: true,
-            ...retryAfter ? { retryAfterSeconds: parseInt(retryAfter, 10) } : {}
+            isRateLimit: response.status === 429,
+            status: response.status,
+            host,
+            ...detail ? { detail } : {},
+            ...retryAfter2 ? { retryAfterSeconds: parseInt(retryAfter2, 10) } : {}
           };
           await new Promise((resolve9) => setTimeout(resolve9, Math.min(delayMs, 3e4)));
           continue;
         }
+        const retryAfter = response.headers.get("Retry-After");
+        const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : Number.NaN;
         return {
           success: false,
           error,
           isRateLimit: response.status === 429,
-          isAuthError: response.status === 401 || response.status === 403
+          isAuthError: response.status === 401 || response.status === 403,
+          status: response.status,
+          host,
+          ...detail ? { detail } : {},
+          ...Number.isFinite(retryAfterSeconds) ? { retryAfterSeconds } : {}
         };
       }
       if (!data.success || !data.response) {
         return {
           success: false,
-          error: data.error || "No response from Spark AI"
+          error: `${host} 200 but no content: ${data.error || firstLine(bodyText) || "empty response"}`,
+          status: response.status,
+          host,
+          ...bodyText ? { detail: truncate(bodyText, 800) } : {}
         };
       }
       return {
@@ -239,14 +272,16 @@ async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier)
         }
       };
     } catch (err) {
-      if (attempt === 3) throw err;
+      if (attempt === 3) {
+        return { success: false, error: `${host} unreachable: ${getErrorMessage(err)}`, host };
+      }
       const delayMs = 1e3 * 2 ** (attempt - 1);
       await new Promise((resolve9) => setTimeout(resolve9, delayMs));
     }
   }
-  return lastRateLimitError || { success: false, error: "Request failed after retries" };
+  return lastRetriableError || { success: false, error: `${host}: request failed after retries`, host };
 }
-async function callAI(systemPrompt, userPrompt, tier = "free") {
+async function callAI(systemPrompt, userPrompt, tier = "free", opts = {}) {
   if (!apiKey()) {
     return {
       success: false,
@@ -256,12 +291,12 @@ async function callAI(systemPrompt, userPrompt, tier = "free") {
   }
   try {
     const token = await getOrRefreshDirectToken();
-    return await executeChat(SPARK_AI_CHAT, token, systemPrompt, userPrompt, tier);
+    return await executeChat(SPARK_AI_CHAT, token, systemPrompt, userPrompt, tier, opts);
   } catch (err) {
     return { success: false, error: `Spark AI error: ${getErrorMessage(err)}` };
   }
 }
-async function callAIViaRelay(systemPrompt, userPrompt, email, tier = "free") {
+async function callAIViaRelay(systemPrompt, userPrompt, email, tier = "free", opts = {}) {
   if (!email) {
     return {
       success: false,
@@ -271,11 +306,11 @@ async function callAIViaRelay(systemPrompt, userPrompt, email, tier = "free") {
   }
   try {
     let token = await getOrRefreshRelayToken(email);
-    let result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier);
+    let result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier, opts);
     if (!result.success && result.isAuthError) {
       cachedRelayToken = null;
       token = await getOrRefreshRelayToken(email);
-      result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier);
+      result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier, opts);
     }
     return result;
   } catch (err) {
@@ -307,11 +342,13 @@ function normalizeUrl(input) {
   url = url.replace(/^(https?:\/\/)?(www\.)?/i, "");
   return `https://${url}`;
 }
-var SPARK_AI_BASE, SPARK_AI_CHAT, SPARK_AI_TOKEN, RELAY_BASE, RELAY_TOKEN_URL, RELAY_CHAT_URL, cachedDirectToken, cachedRelayToken;
+var SERVER_BACKOFF_MS, CLI_BACKOFF_MS, SPARK_AI_BASE, SPARK_AI_CHAT, SPARK_AI_TOKEN, RELAY_BASE, RELAY_TOKEN_URL, RELAY_CHAT_URL, cachedDirectToken, cachedRelayToken;
 var init_api_client = __esm({
   "src/lib/api-client.ts"() {
     "use strict";
     init_utils();
+    SERVER_BACKOFF_MS = [2e3, 4e3];
+    CLI_BACKOFF_MS = [1e4, 3e4];
     SPARK_AI_BASE = "https://sparkbrain.app";
     SPARK_AI_CHAT = `${SPARK_AI_BASE}/api/chat`;
     SPARK_AI_TOKEN = `${SPARK_AI_BASE}/api/models/token`;
@@ -342,7 +379,7 @@ async function getStatusCached(email) {
 function getTier(d) {
   if (!d.subscription || !d.registered) return "free";
   if (d.subscription.status === "canceled" || d.subscription.status === "past_due") return "free";
-  return TIERS[d.subscription.price_id] ?? "free";
+  return TIERS[d.subscription.price_id] ?? "pro";
 }
 async function getTierByEmail(email) {
   try {
@@ -359,17 +396,18 @@ async function isVerified(email) {
   }
 }
 function pricingUrl(opts) {
-  const u = new URL(`${BASE}/pricing/${APP_ID}`);
+  const u = new URL(`${BASE}/${OWNER_SLUG}/${APP_ID}`);
   if (opts?.email) u.searchParams.set("email", opts.email);
   if (opts?.returnUrl) u.searchParams.set("return_url", opts.returnUrl);
   return u.toString();
 }
-var APP_ID, BASE, TIERS, RANK, FEATURES, getStatus, _cache, isPaid, hasAccess, hasTrialRemaining, showPaywall, isCanceling;
+var APP_ID, OWNER_SLUG, BASE, TIERS, RANK, FEATURES, getStatus, _cache, isPaid, hasAccess, hasTrialRemaining, showPaywall, isCanceling;
 var init_SparkStripe_feature_gating = __esm({
   "src/lib/SparkStripe-feature-gating.ts"() {
     "use strict";
     APP_ID = process.env.SPARK_APP_ID ?? "quickpeek";
-    BASE = "https://sparkstripe.com";
+    OWNER_SLUG = process.env.SPARK_OWNER_SLUG ?? "spark";
+    BASE = "https://sparkpay.dev";
     TIERS = {
       price_1TADnPEf9opkuWid9NtqOYON: "pro",
       price_1TADnPEf9opkuWidgbvvX9ma: "pro",
@@ -421,7 +459,7 @@ var VERSION, CONFIG_FILE, DEFAULT_CONFIG, DEFAULT_CAPTIONS;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
-    VERSION = "1.2.1";
+    VERSION = "1.2.3";
     CONFIG_FILE = "quickpeek.config.json";
     DEFAULT_CONFIG = {
       plan: { maxSteps: 8 },
@@ -571,6 +609,9 @@ var init_scraping = __esm({
 });
 
 // src/lib/crawl.ts
+function idSelector(id) {
+  return /^[A-Za-z_-][\w-]*$/.test(id) ? `#${id}` : `[id="${id.replace(/(["\\])/g, "\\$1")}"]`;
+}
 function getActionForType(type) {
   switch (type) {
     case "button":
@@ -596,7 +637,7 @@ async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
     return { title: cached.title, elements: [...cached.elements], scrollable: cached.scrollable };
   }
   const browserTask = task2("Launching browser");
-  const browser = await import_playwright.chromium.launch({ headless: true });
+  const browser = await import_playwright3.chromium.launch({ headless: true });
   const context = await browser.newContext({
     ...storageStatePath ? { storageState: storageStatePath } : {},
     // Crawl at the size we will record at, or the measurements below describe
@@ -700,9 +741,9 @@ async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
     } else if (el.isFile || el.type === "file") {
       selector = 'input[type="file"]';
     } else if (el.type === "range") {
-      selector = el.id ? `#${el.id}` : 'input[type="range"]';
+      selector = el.id ? idSelector(el.id) : 'input[type="range"]';
     } else if (el.type === "checkbox") {
-      selector = el.id ? `#${el.id}` : 'input[type="checkbox"]';
+      selector = el.id ? idSelector(el.id) : 'input[type="checkbox"]';
     } else if (el.type === "button") {
       if (btnTexts[el.text] === 1) {
         selector = `text="${el.text}"`;
@@ -712,7 +753,7 @@ async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
     } else if (el.type === "link") {
       selector = `text="${el.text}"`;
     } else if (el.id) {
-      selector = `#${el.id}`;
+      selector = idSelector(el.id);
     } else if (el.name) {
       selector = `[name="${el.name}"]`;
     } else if (el.placeholder) {
@@ -747,11 +788,11 @@ async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
   }
   return { title, elements, scrollable };
 }
-var import_playwright, noopTask, CRAWL_CACHE_TTL_MS, CRAWL_CACHE_MAX_ENTRIES, crawlCache;
+var import_playwright3, noopTask, CRAWL_CACHE_TTL_MS, CRAWL_CACHE_MAX_ENTRIES, crawlCache;
 var init_crawl = __esm({
   "src/lib/crawl.ts"() {
     "use strict";
-    import_playwright = require("playwright");
+    import_playwright3 = require("playwright");
     init_scraping();
     noopTask = () => ({ succeed: () => {
     } });
@@ -813,9 +854,9 @@ function convertArgToWSL(arg2) {
 function spawnFFmpeg(cmd2, args) {
   if (isWindowsRuntime) {
     const wslArgs = args.map(convertArgToWSL);
-    return (0, import_node_child_process.spawn)("wsl", ["-e", cmd2, ...wslArgs]);
+    return (0, import_node_child_process2.spawn)("wsl", ["-e", cmd2, ...wslArgs]);
   }
-  return (0, import_node_child_process.spawn)(cmd2, args);
+  return (0, import_node_child_process2.spawn)(cmd2, args);
 }
 function runFFmpeg(args, errorLabel) {
   return new Promise((resolve9, reject) => {
@@ -831,11 +872,11 @@ function runFFmpeg(args, errorLabel) {
     proc.on("error", reject);
   });
 }
-var import_node_child_process, isWindowsRuntime;
+var import_node_child_process2, isWindowsRuntime;
 var init_spawn = __esm({
   "src/lib/ffmpeg/spawn.ts"() {
     "use strict";
-    import_node_child_process = require("child_process");
+    import_node_child_process2 = require("child_process");
     init_utils();
     isWindowsRuntime = process.platform === "win32";
   }
@@ -1016,8 +1057,39 @@ function getMediaDuration(filePath) {
     proc.on("error", reject);
   });
 }
+function getAudioCodec(filePath) {
+  return new Promise((resolve9) => {
+    const args = [
+      "-v",
+      "error",
+      "-select_streams",
+      "a:0",
+      "-show_entries",
+      "stream=codec_name",
+      "-of",
+      "default=noprint_wrappers=1:nokey=1",
+      filePath
+    ];
+    const proc = spawnFFmpeg("ffprobe", args);
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data;
+    });
+    proc.on("close", (code) => resolve9(code === 0 ? stdout.trim() : ""));
+    proc.on("error", () => resolve9(""));
+  });
+}
+async function isHonestWav(filePath) {
+  const codec = await getAudioCodec(filePath);
+  return codec.startsWith("pcm_");
+}
+function buildConcatArgs(listPath, output) {
+  const isWav = output.toLowerCase().endsWith(".wav");
+  const codec = isWav ? ["-c:a", "pcm_s16le"] : ["-c", "copy"];
+  return ["-y", "-f", "concat", "-safe", "0", "-i", listPath, ...codec, output];
+}
 function concatMedia(listPath, output) {
-  return runFFmpeg(["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", output], "ffmpeg concat failed");
+  return runFFmpeg(buildConcatArgs(listPath, output), "ffmpeg concat failed");
 }
 function generateSilence(outputPath, durationMs) {
   return runFFmpeg(
@@ -1266,6 +1338,114 @@ var init_ffmpeg2 = __esm({
   }
 });
 
+// src/lib/json-repair.ts
+function repairUnicodeEscapes(content) {
+  return content.replace(/\\u\{([0-9a-fA-F]{1,6})\}/g, (match, hex) => {
+    const code = Number.parseInt(hex, 16);
+    return code <= 1114111 ? String.fromCodePoint(code) : match;
+  }).replace(/\\u(?![0-9a-fA-F]{4})/g, "\\\\u");
+}
+function salvageTruncatedJson(content) {
+  const stack = [];
+  const cuts = [];
+  let inString = false;
+  let escaped = false;
+  const record = (index, closesContainer) => cuts.push({ index, open: stack.join(""), closesContainer });
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') {
+        inString = false;
+        record(i + 1, false);
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      record(i + 1, true);
+    } else if (ch === ",") {
+      record(i, content[i - 1] === "}" || content[i - 1] === "]");
+    }
+  }
+  const tryCut = (cut) => {
+    const head = content.slice(0, cut.index).replace(/[\s,]+$/, "");
+    if (head.endsWith(":")) return null;
+    let closed = head;
+    for (let d = cut.open.length - 1; d >= 0; d--) {
+      closed += CLOSERS[cut.open[d]];
+    }
+    try {
+      JSON.parse(closed);
+      return closed;
+    } catch {
+      return null;
+    }
+  };
+  const attempts = Math.min(cuts.length, MAX_SALVAGE_ATTEMPTS);
+  for (const containerOnly of [true, false]) {
+    for (let n = 0; n < attempts; n++) {
+      const cut = cuts[cuts.length - 1 - n];
+      if (containerOnly && !cut.closesContainer) continue;
+      const salvaged = tryCut(cut);
+      if (salvaged !== null) return salvaged;
+    }
+  }
+  return null;
+}
+function extractJsonCandidates(content) {
+  let text = content.trim();
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)(?:```|$)/);
+  if (fence?.[1]?.trim()) text = fence[1].trim();
+  const start = text.search(/[{[]/);
+  if (start === -1) return [];
+  const closer = text[start] === "{" ? "}" : "]";
+  const end = text.lastIndexOf(closer);
+  const candidates = [text.slice(start)];
+  if (end > start && end < text.length - 1) candidates.unshift(text.slice(start, end + 1));
+  return candidates;
+}
+function parseAIJson(content) {
+  const candidates = extractJsonCandidates(content);
+  if (candidates.length === 0) return null;
+  for (const text of candidates) {
+    try {
+      return { value: JSON.parse(text), repaired: false };
+    } catch {
+    }
+  }
+  for (const text of candidates) {
+    try {
+      return { value: JSON.parse(repairUnicodeEscapes(text)), repaired: true };
+    } catch {
+    }
+  }
+  for (const text of candidates) {
+    for (const variant of [repairUnicodeEscapes(text), text]) {
+      const salvaged = salvageTruncatedJson(variant);
+      if (salvaged === null) continue;
+      try {
+        return { value: JSON.parse(salvaged), repaired: true };
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+var MAX_SALVAGE_ATTEMPTS, CLOSERS;
+var init_json_repair = __esm({
+  "src/lib/json-repair.ts"() {
+    "use strict";
+    MAX_SALVAGE_ATTEMPTS = 500;
+    CLOSERS = { "{": "}", "[": "]" };
+  }
+});
+
 // src/lib/prompts.ts
 function buildSystemPrompt(maxSteps) {
   let scope;
@@ -1467,7 +1647,7 @@ var init_styles = __esm({
 async function registerFreeUser(email) {
   const APP_ID2 = process.env.SPARK_APP_ID ?? "quickpeek";
   try {
-    const response = await fetch(`https://sparkstripe.com/api/register-free`, {
+    const response = await fetch(`https://sparkpay.dev/api/register-free`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ email, app_id: APP_ID2, app_name: "QuickPeek" })
@@ -1534,7 +1714,7 @@ async function getMediaStepDuration(step, baseDir) {
     return 0;
   }
   const mediaPath = (0, import_node_path2.isAbsolute)(step.value) ? step.value : (0, import_node_path2.resolve)(baseDir, step.value);
-  if (!(0, import_node_fs2.existsSync)(mediaPath)) {
+  if (!(0, import_node_fs3.existsSync)(mediaPath)) {
     return 0;
   }
   try {
@@ -1556,8 +1736,8 @@ async function getMediaStepDuration(step, baseDir) {
 async function loadVoiceoverMeta(outputDir) {
   const metaPath = (0, import_node_path2.join)(outputDir, "voiceover.json");
   try {
-    if (!(0, import_node_fs2.existsSync)(metaPath)) return null;
-    const content = await (0, import_promises2.readFile)(metaPath, "utf-8");
+    if (!(0, import_node_fs3.existsSync)(metaPath)) return null;
+    const content = await (0, import_promises3.readFile)(metaPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -1565,7 +1745,7 @@ async function loadVoiceoverMeta(outputDir) {
 }
 async function saveVoiceoverMeta(outputDir, meta) {
   const metaPath = (0, import_node_path2.join)(outputDir, "voiceover.json");
-  await (0, import_promises2.writeFile)(metaPath, JSON.stringify(meta, null, 2));
+  await (0, import_promises3.writeFile)(metaPath, JSON.stringify(meta, null, 2));
 }
 async function concatenateAudio(inputs, output, workDir) {
   const formatPath = (f) => {
@@ -1574,17 +1754,17 @@ async function concatenateAudio(inputs, output, workDir) {
   };
   const listContent = inputs.map((f) => `file '${formatPath(f)}'`).join("\n");
   const listPath = (0, import_node_path2.join)(workDir, "concat.txt");
-  await (0, import_promises2.writeFile)(listPath, listContent);
+  await (0, import_promises3.writeFile)(listPath, listContent);
   await concatMedia(listPath, output);
-  await (0, import_promises2.unlink)(listPath).catch(() => {
+  await (0, import_promises3.unlink)(listPath).catch(() => {
   });
 }
-var import_node_fs2, import_promises2, import_node_path2, isWindows;
+var import_node_fs3, import_promises3, import_node_path2, isWindows;
 var init_helpers = __esm({
   "src/lib/tts/helpers.ts"() {
     "use strict";
-    import_node_fs2 = require("fs");
-    import_promises2 = require("fs/promises");
+    import_node_fs3 = require("fs");
+    import_promises3 = require("fs/promises");
     import_node_path2 = require("path");
     init_ffmpeg2();
     init_utils();
@@ -1633,9 +1813,9 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
     const audioPath = (0, import_node_path3.join)(audioDir, `step-${stepNum}.mp3`);
     const originalPaddingPath = (0, import_node_path3.join)(audioDir, `step-${stepNum}-padding.mp3`);
     const silencePath = (0, import_node_path3.join)(audioDir, `step-${stepNum}-silence.mp3`);
-    if ((0, import_node_fs3.existsSync)(audioPath)) {
+    if ((0, import_node_fs4.existsSync)(audioPath)) {
       segments.push(audioPath);
-      if ((0, import_node_fs3.existsSync)(originalPaddingPath)) {
+      if ((0, import_node_fs4.existsSync)(originalPaddingPath)) {
         segments.push(originalPaddingPath);
       }
       if (recordingDuration > voiceDuration) {
@@ -1643,7 +1823,7 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
         await generateSilence(alignPaddingPath, recordingDuration - voiceDuration);
         segments.push(alignPaddingPath);
       }
-    } else if ((0, import_node_fs3.existsSync)(silencePath)) {
+    } else if ((0, import_node_fs4.existsSync)(silencePath)) {
       if (targetDuration !== voiceDuration) {
         await generateSilence(silencePath, targetDuration);
       }
@@ -1667,11 +1847,11 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
   }
   return alignedStepAudio;
 }
-var import_node_fs3, import_node_path3;
+var import_node_fs4, import_node_path3;
 var init_timing = __esm({
   "src/lib/tts/timing.ts"() {
     "use strict";
-    import_node_fs3 = require("fs");
+    import_node_fs4 = require("fs");
     import_node_path3 = require("path");
     init_ffmpeg2();
     init_helpers();
@@ -1736,6 +1916,19 @@ var init_voices = __esm({
 
 // src/lib/tts/synthesize.ts
 async function synthesizeSpeech(text, outputPath, voice) {
+  let pythonMsg = "";
+  for (let attempt = 0; attempt < PYTHON_ATTEMPTS; attempt++) {
+    try {
+      await synthesizeWithPython(text, outputPath, voice);
+      return;
+    } catch (err) {
+      pythonMsg = err instanceof Error ? err.message : String(err);
+      if (attempt < PYTHON_ATTEMPTS - 1) await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  await synthesizeWithNode(text, outputPath, voice, pythonMsg);
+}
+async function synthesizeWithPython(text, outputPath, voice) {
   const tempScriptPath = (0, import_node_path5.join)((0, import_node_path5.resolve)(outputPath, ".."), `tts-${Date.now()}.py`);
   const wslScriptPath = isWindows ? toWSLPathForTTS((0, import_node_path5.resolve)(tempScriptPath)) : tempScriptPath;
   const wslOutputPath = isWindows ? toWSLPathForTTS((0, import_node_path5.resolve)(outputPath)) : outputPath;
@@ -1753,44 +1946,49 @@ async def main():
 asyncio.run(main())
 `;
   try {
-    await (0, import_promises3.writeFile)(tempScriptPath, pythonScript);
+    await (0, import_promises4.writeFile)(tempScriptPath, pythonScript);
     const pythonCmd = isWindows ? `wsl python3 "${wslScriptPath}"` : `python3 "${wslScriptPath}"`;
     await execAsync(pythonCmd, { timeout: 3e4 });
-    await import("fs/promises").then((fs) => fs.unlink(tempScriptPath).catch(() => {
-    }));
-    return;
-  } catch (pythonErr) {
-    await import("fs/promises").then((fs) => fs.unlink(tempScriptPath).catch(() => {
-    }));
-    const pythonMsg = pythonErr instanceof Error ? pythonErr.message : String(pythonErr);
-    const maxRetries = 2;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const { MsEdgeTTS, OUTPUT_FORMAT } = await import("msedge-tts");
-        const tts = new MsEdgeTTS();
-        await tts.setMetadata(voice, OUTPUT_FORMAT.AUDIO_24KHZ_96KBITRATE_MONO_MP3);
-        await tts.toFile(outputPath, text);
-        return;
-      } catch (nodeErr) {
-        if (attempt === maxRetries) {
-          const nodeMsg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
-          throw new Error(`TTS failed (Python: ${pythonMsg.slice(0, 100)}, Node: ${nodeMsg.slice(0, 100)})`);
-        }
-        await new Promise((r) => setTimeout(r, 500));
+  } finally {
+    await (0, import_promises4.unlink)(tempScriptPath).catch(() => {
+    });
+  }
+}
+async function synthesizeWithNode(text, outputPath, voice, pythonMsg, maxRetries = 2) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const { MsEdgeTTS, OUTPUT_FORMAT } = await import("msedge-tts");
+      const tts = new MsEdgeTTS();
+      await tts.setMetadata(voice, OUTPUT_FORMAT.AUDIO_24KHZ_96KBITRATE_MONO_MP3);
+      const { audioStream } = tts.toStream(text);
+      await (0, import_promises5.pipeline)(audioStream, (0, import_node_fs5.createWriteStream)(outputPath));
+      const { size } = await (0, import_promises4.stat)(outputPath);
+      if (size === 0) throw new Error("No audio data received");
+      return;
+    } catch (nodeErr) {
+      await (0, import_promises4.unlink)(outputPath).catch(() => {
+      });
+      if (attempt === maxRetries) {
+        const nodeMsg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
+        throw new Error(`TTS failed (Python: ${pythonMsg.slice(0, 100)}, Node: ${nodeMsg.slice(0, 100)})`);
       }
+      await new Promise((r) => setTimeout(r, 500));
     }
   }
 }
-var import_node_child_process2, import_promises3, import_node_path5, import_node_util, execAsync;
+var import_node_child_process3, import_node_fs5, import_promises4, import_node_path5, import_promises5, import_node_util, execAsync, PYTHON_ATTEMPTS;
 var init_synthesize = __esm({
   "src/lib/tts/synthesize.ts"() {
     "use strict";
-    import_node_child_process2 = require("child_process");
-    import_promises3 = require("fs/promises");
+    import_node_child_process3 = require("child_process");
+    import_node_fs5 = require("fs");
+    import_promises4 = require("fs/promises");
     import_node_path5 = require("path");
+    import_promises5 = require("stream/promises");
     import_node_util = require("util");
     init_helpers();
-    execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
+    execAsync = (0, import_node_util.promisify)(import_node_child_process3.exec);
+    PYTHON_ATTEMPTS = 2;
   }
 });
 
@@ -1827,7 +2025,7 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
     return { voiceoverPath: "", stepAudio: stepAudio2 };
   }
   const audioDir = (0, import_node_path6.join)(workDir, "audio");
-  await (0, import_promises4.mkdir)(audioDir, { recursive: true });
+  await (0, import_promises6.mkdir)(audioDir, { recursive: true });
   const segments = [];
   const stepAudio = /* @__PURE__ */ new Map();
   const ttsTask = task2("Generating voiceover");
@@ -1878,7 +2076,7 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
     return { voiceoverPath: "", stepAudio };
   }
   const concatTask = task2("Combining audio");
-  await (0, import_promises4.mkdir)(outputDir, { recursive: true });
+  await (0, import_promises6.mkdir)(outputDir, { recursive: true });
   const voiceoverPath = (0, import_node_path6.join)(outputDir, "voiceover.wav");
   await concatenateAudio(segments, voiceoverPath, workDir);
   concatTask.succeed("Done");
@@ -1892,11 +2090,11 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
   await saveVoiceoverMeta(outputDir, meta);
   return { voiceoverPath, stepAudio };
 }
-var import_promises4, import_node_path6;
+var import_promises6, import_node_path6;
 var init_generate = __esm({
   "src/lib/tts/generate.ts"() {
     "use strict";
-    import_promises4 = require("fs/promises");
+    import_promises6 = require("fs/promises");
     import_node_path6 = require("path");
     init_ffmpeg2();
     init_voices();
@@ -1943,6 +2141,7 @@ var init_types3 = __esm({
 // src/lib/index.ts
 var lib_exports = {};
 __export(lib_exports, {
+  CLI_BACKOFF_MS: () => CLI_BACKOFF_MS,
   CONFIG_FILE: () => CONFIG_FILE,
   CURSOR_CSS: () => CURSOR_CSS,
   CURSOR_PNG: () => CURSOR_PNG,
@@ -1953,9 +2152,11 @@ __export(lib_exports, {
   FEATURES: () => FEATURES,
   INTERACTIVE_SELECTORS: () => INTERACTIVE_SELECTORS,
   LANGUAGE_VOICES: () => import_video_kit5.WIDE_VOICES,
+  SERVER_BACKOFF_MS: () => SERVER_BACKOFF_MS,
   VERSION: () => VERSION,
   alignVoiceoverToRecording: () => alignVoiceoverToRecording,
   applyTransitions: () => applyTransitions,
+  buildConcatArgs: () => buildConcatArgs,
   buildKeepSegments: () => buildKeepSegments,
   buildStepTransitions: () => buildStepTransitions,
   buildSystemPrompt: () => buildSystemPrompt,
@@ -1969,9 +2170,11 @@ __export(lib_exports, {
   concatVideoWithOutro: () => concatVideoWithOutro,
   crawlPage: () => crawlPage,
   estimateWordTimings: () => estimateWordTimings,
+  extractJsonCandidates: () => extractJsonCandidates,
   generateASSHeader: () => generateASSHeader,
   generateSilence: () => generateSilence,
   generateVoiceover: () => generateVoiceover,
+  getAudioCodec: () => getAudioCodec,
   getErrorMessage: () => getErrorMessage,
   getLanguageName: () => getLanguageName,
   getMediaDuration: () => getMediaDuration,
@@ -1982,20 +2185,25 @@ __export(lib_exports, {
   hasAccess: () => hasAccess,
   hasTrialRemaining: () => hasTrialRemaining,
   hexToASS: () => import_video_kit.hexToAss,
+  idSelector: () => idSelector,
   isCanceling: () => isCanceling,
   isExcludedLink: () => isExcludedLink,
+  isHonestWav: () => isHonestWav,
   isPaid: () => isPaid,
   isVerified: () => isVerified,
   loadExistingVoiceover: () => loadExistingVoiceover,
   loadVoiceoverMeta: () => loadVoiceoverMeta,
   mapTimestampsAfterCompression: () => mapTimestampsAfterCompression,
   normalizeUrl: () => normalizeUrl,
+  parseAIJson: () => parseAIJson,
   parseAIPlanResponse: () => parseAIPlanResponse,
   parsePartial: () => parsePartial,
   pricingUrl: () => pricingUrl,
   registerFreeUser: () => registerFreeUser,
+  repairUnicodeEscapes: () => repairUnicodeEscapes,
   resolveVoice: () => resolveVoice,
   rgbaToHex: () => rgbaToHex,
+  salvageTruncatedJson: () => salvageTruncatedJson,
   shouldSkipLink: () => shouldSkipLink,
   shouldWatermark: () => shouldWatermark,
   showPaywall: () => showPaywall,
@@ -2014,6 +2222,7 @@ var init_lib = __esm({
     init_crawl();
     init_cursor();
     init_ffmpeg2();
+    init_json_repair();
     init_prompts();
     init_SparkStripe_feature_gating();
     init_scraping();
@@ -2032,16 +2241,14 @@ var import_dotenv = __toESM(require("dotenv"));
 var import_chalk21 = __toESM(require("chalk"));
 
 // src/commands/auth-cmd.ts
-var import_node_readline2 = require("readline");
 var import_chalk3 = __toESM(require("chalk"));
-var import_playwright2 = require("playwright");
 
 // src/browser/auth-state.ts
 var import_node_fs = require("fs");
 var import_promises = require("fs/promises");
 var import_node_os = require("os");
 var import_node_path = require("path");
-var AUTH_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".quickpeek", "auth");
+var AUTH_DIR = process.env.QUICKPEEK_AUTH_DIR || (0, import_node_path.join)((0, import_node_os.homedir)(), ".quickpeek", "auth");
 function hostOf(url) {
   try {
     return new URL(url).host;
@@ -2053,156 +2260,468 @@ function authStatePath(url) {
   const host = hostOf(url);
   return host ? (0, import_node_path.join)(AUTH_DIR, `${host}.json`) : null;
 }
+function authMetaPath(url) {
+  const host = hostOf(url);
+  return host ? (0, import_node_path.join)(AUTH_DIR, `${host}.meta.json`) : null;
+}
 function findAuthState(url) {
   const path = authStatePath(url);
   return path && (0, import_node_fs.existsSync)(path) ? path : void 0;
 }
-async function saveAuthState(url, state) {
+async function saveAuthState(url, state, startUrl) {
   const path = authStatePath(url);
   if (!path) throw new Error(`Not a valid URL: ${url}`);
   await (0, import_promises.mkdir)(AUTH_DIR, { recursive: true });
   await (0, import_promises.writeFile)(path, JSON.stringify(state, null, 2));
   await (0, import_promises.chmod)(path, 384);
+  if (startUrl) {
+    await (0, import_promises.writeFile)(authMetaPath(url), JSON.stringify({ startUrl, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  }
   return path;
 }
+function findStartUrl(url) {
+  const path = authMetaPath(url);
+  if (!path || !(0, import_node_fs.existsSync)(path)) return void 0;
+  try {
+    const startUrl = JSON.parse((0, import_node_fs.readFileSync)(path, "utf8")).startUrl;
+    return typeof startUrl === "string" && startUrl.startsWith("http") ? startUrl : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveStartUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const bareOrigin = (parsed.pathname === "/" || parsed.pathname === "") && !parsed.search && !parsed.hash;
+    if (!bareOrigin || !findAuthState(url)) return url;
+    return findStartUrl(url) ?? url;
+  } catch {
+    return url;
+  }
+}
 async function clearAuthState(url) {
   if (url) {
     const path = authStatePath(url);
     if (!path || !(0, import_node_fs.existsSync)(path)) return [];
     await (0, import_promises.unlink)(path);
+    const meta = authMetaPath(url);
+    if (meta && (0, import_node_fs.existsSync)(meta)) await (0, import_promises.unlink)(meta);
     return [hostOf(url)];
   }
   if (!(0, import_node_fs.existsSync)(AUTH_DIR)) return [];
   const files = (await (0, import_promises.readdir)(AUTH_DIR)).filter((f) => f.endsWith(".json"));
   await Promise.all(files.map((f) => (0, import_promises.unlink)((0, import_node_path.join)(AUTH_DIR, f))));
-  return files.map((f) => f.slice(0, -".json".length));
+  return files.filter((f) => !f.endsWith(".meta.json")).map((f) => f.slice(0, -".json".length));
 }
 async function listAuthStates() {
   if (!(0, import_node_fs.existsSync)(AUTH_DIR)) return [];
-  return (await (0, import_promises.readdir)(AUTH_DIR)).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
+  return (await (0, import_promises.readdir)(AUTH_DIR)).filter((f) => f.endsWith(".json") && !f.endsWith(".meta.json")).map((f) => f.slice(0, -".json".length));
 }
 
-// src/help.ts
-var import_chalk = __toESM(require("chalk"));
-init_lib();
-
-// src/logo.ts
-var import_figlet = __toESM(require("figlet"));
-var import_gradient_string = __toESM(require("gradient-string"));
-var DEFAULT_LOGO_CONFIG = {
-  text: "QuickPeek",
-  font: "Slant",
-  horizontalLayout: "default",
-  gradientColors: ["#00ffff", "#00d4ff", "#a855f7", "#ec4899"],
-  suffix: " \u{1F440}"
-};
-function renderLogo(config = {}) {
-  const resolved = { ...DEFAULT_LOGO_CONFIG, ...config };
-  const ascii = import_figlet.default.textSync(resolved.text, {
-    font: resolved.font,
-    horizontalLayout: resolved.horizontalLayout
-  });
-  const colored = (0, import_gradient_string.default)(resolved.gradientColors)(ascii);
-  return resolved.suffix ? `${colored}${resolved.suffix}` : colored;
-}
+// src/browser/launch.ts
+var import_promises2 = require("fs/promises");
+var import_playwright2 = require("playwright");
 
-// src/utils/config-loader.ts
-var import_node_fs4 = require("fs");
-var import_promises5 = require("fs/promises");
-var import_node_os2 = require("os");
-var import_node_path7 = require("path");
-init_lib();
-async function loadConfig(_url, langOverride) {
-  const configPath = (0, import_node_path7.join)(process.cwd(), CONFIG_FILE);
-  if ((0, import_node_fs4.existsSync)(configPath)) {
-    try {
-      const content = await (0, import_promises5.readFile)(configPath, "utf-8");
-      const userConfig = JSON.parse(content);
-      const config = {
-        lang: langOverride || userConfig.lang || "en",
-        plan: { ...DEFAULT_CONFIG.plan, ...userConfig.plan },
-        video: { ...DEFAULT_CONFIG.video, ...userConfig.video },
-        audio: { ...DEFAULT_CONFIG.audio, ...userConfig.audio },
-        music: userConfig.music,
-        timing: { ...DEFAULT_CONFIG.timing, ...userConfig.timing },
-        output: { ...DEFAULT_CONFIG.output, ...userConfig.output }
-      };
-      return { config, created: false };
-    } catch {
-    }
+// src/browser/wsl.ts
+var import_node_child_process = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_http = require("http");
+var import_playwright = require("playwright");
+function isWSL() {
+  if (process.platform !== "linux") return false;
+  try {
+    const r = (0, import_node_child_process.execSync)("uname -r", { encoding: "utf-8" }).toLowerCase();
+    return r.includes("microsoft") || r.includes("wsl");
+  } catch {
+    return false;
   }
-  const fullDefaultConfig = {
-    lang: "en",
-    plan: { maxSteps: 8 },
-    video: {
-      width: 1080,
-      height: 1920,
-      fps: 30,
-      quality: 0.5,
-      preset: "fast",
-      cursor: true,
-      highlight: false,
-      fadeIn: 500,
-      // ms
-      fadeOut: 500,
-      // ms
-      contrast: 0.25
-    },
-    audio: {
-      // Voice is derived from lang setting via LANGUAGE_VOICES mapping
-      // To override, use Edge TTS voice name like 'en-GB-SoniaNeural'
-      speed: 1
-    },
-    music: {
-      path: "",
-      volume: 0.3
-    },
-    output: { dir: "./demo" }
-  };
-  await (0, import_promises5.writeFile)(configPath, JSON.stringify(fullDefaultConfig, null, 2));
-  return { config: { ...DEFAULT_CONFIG, lang: langOverride || "en" }, created: true };
 }
-var WORK_DIR = ".quickpeek";
-async function prepareWorkDir() {
-  const workDir = (0, import_node_path7.join)(process.cwd(), WORK_DIR);
-  if ((0, import_node_fs4.existsSync)(workDir)) {
-    await (0, import_promises5.rm)(workDir, { recursive: true });
-  }
-  await (0, import_promises5.mkdir)(workDir, { recursive: true });
-  return workDir;
+function tryEnableWSLInterop() {
+  return (0, import_node_fs2.existsSync)("/proc/sys/fs/binfmt_misc/WSLInterop");
 }
-var USER_DATA_DIR = (0, import_node_path7.join)((0, import_node_os2.homedir)(), ".quickpeek");
-var USER_DATA_FILE = (0, import_node_path7.join)(USER_DATA_DIR, "user.json");
-async function loadUserData() {
+function wslToWindowsPath(wslPath) {
+  if (!wslPath) return wslPath;
+  const m = wslPath.match(/^\/mnt\/([a-z])\/(.*)/);
+  if (!m) return wslPath;
+  return `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, "\\")}`;
+}
+function findExe(whereExeQuery, ...hardcoded) {
+  for (const p of hardcoded) if ((0, import_node_fs2.existsSync)(p)) return p;
   try {
-    if ((0, import_node_fs4.existsSync)(USER_DATA_FILE)) {
-      return JSON.parse(await (0, import_promises5.readFile)(USER_DATA_FILE, "utf-8"));
-    }
+    const line = (0, import_node_child_process.execSync)(`where.exe ${whereExeQuery}`, { encoding: "utf-8", timeout: 3e3 }).split("\n")[0]?.trim();
+    if (line) return line.replace(/^([A-Za-z]):\\/, (_, d) => `/mnt/${d.toLowerCase()}/`).replace(/\\/g, "/");
   } catch {
   }
-  return {};
+  return null;
 }
-async function saveUserData(userData) {
-  if (!(0, import_node_fs4.existsSync)(USER_DATA_DIR)) {
-    await (0, import_promises5.mkdir)(USER_DATA_DIR, { recursive: true });
+var findWindowsChrome = () => findExe(
+  "chrome.exe",
+  "/mnt/c/Program Files/Google/Chrome/Application/chrome.exe",
+  "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"
+);
+var findWindowsNode = () => findExe("node.exe");
+function getWindowsHostIP() {
+  try {
+    const m = (0, import_node_child_process.execSync)("ip route show default", { encoding: "utf-8", timeout: 2e3 }).match(
+      /default via (\d+\.\d+\.\d+\.\d+)/
+    );
+    if (m?.[1]) return m[1];
+  } catch {
   }
-  const existing = await loadUserData();
-  const merged = { ...existing, ...userData };
-  await (0, import_promises5.writeFile)(USER_DATA_FILE, JSON.stringify(merged, null, 2));
-}
-var DEFAULT_CAPTIONS_CSS = `.caption {
-  font-family: Arial, sans-serif;
-  -webkit-text-stroke: 3px #000000;
-}
-.caption .regular {
-  font-size: 56px;
-  color: #FFFFFF;
+  try {
+    const m = (0, import_node_fs2.readFileSync)("/etc/resolv.conf", "utf-8").match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
+    if (m?.[1]) return m[1];
+  } catch {
+  }
+  return "127.0.0.1";
 }
-.caption .highlight {
-  font-size: 64px;
-  color: #FFFF00;
+function startRelay(nodePath, windowsHost, targetPort) {
+  const script = `var n=require('net'),s=n.createServer(function(c){var r=n.createConnection(${targetPort},'127.0.0.1');c.pipe(r);r.pipe(c);r.on('error',function(){c.destroy()});c.on('error',function(){r.destroy()});});s.listen(0,'${windowsHost}',function(){process.stdout.write('PORT:'+s.address().port+'\\n')});`;
+  return new Promise((resolve9, reject) => {
+    const proc = (0, import_node_child_process.spawn)(nodePath, ["-e", script], { stdio: ["ignore", "pipe", "ignore"], detached: true });
+    const timer = setTimeout(() => reject(new Error("relay startup timed out")), 6e3);
+    let buf = "";
+    proc.stdout.on("data", (d) => {
+      buf += d.toString();
+      const m = buf.match(/PORT:(\d+)/);
+      if (m) {
+        clearTimeout(timer);
+        resolve9({ proc, port: +m[1] });
+      }
+    });
+    proc.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+  });
 }
-`;
+function waitForChrome(host, port) {
+  return new Promise((resolve9, reject) => {
+    const deadline = Date.now() + 2e4;
+    const poll = () => {
+      if (Date.now() > deadline) {
+        reject(new Error("Chrome debug port did not open within 20 s"));
+        return;
+      }
+      const req = (0, import_node_http.request)({ host, port, path: "/json/version", method: "GET" }, (res) => {
+        res.resume();
+        resolve9();
+      });
+      req.on("error", () => setTimeout(poll, 600));
+      req.setTimeout(1e3, () => {
+        req.destroy();
+        setTimeout(poll, 600);
+      });
+      req.end();
+    };
+    poll();
+  });
+}
+async function launchWindowsChrome(extensionPath, userDataDir, options = {}) {
+  const debugPort = options.debugPort ?? 9222;
+  const chromePath = findWindowsChrome();
+  if (!chromePath) throw new Error("Windows Chrome not found. Install Google Chrome for Windows.");
+  const nodePath = findWindowsNode();
+  if (!nodePath) throw new Error("Windows Node.js not found. Install Node.js for Windows.");
+  const winUserData = wslToWindowsPath(userDataDir);
+  const winExtPath = extensionPath ? wslToWindowsPath(extensionPath) : "";
+  const chromeProc = (0, import_node_child_process.spawn)(
+    chromePath,
+    [
+      `--remote-debugging-port=${debugPort}`,
+      `--user-data-dir=${winUserData}`,
+      ...winExtPath ? [`--disable-extensions-except=${winExtPath}`, `--load-extension=${winExtPath}`] : [],
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-background-networking",
+      "--disable-sync",
+      "--disable-features=TranslateUI",
+      options.startMaximized ? "--start-maximized" : "--start-minimized"
+    ],
+    { stdio: "ignore", detached: true }
+  );
+  chromeProc.unref();
+  const windowsHost = getWindowsHostIP();
+  const { proc: relay, port: proxyPort } = await startRelay(nodePath, windowsHost, debugPort);
+  try {
+    await waitForChrome(windowsHost, proxyPort);
+    const browser = await import_playwright.chromium.connectOverCDP(`http://${windowsHost}:${proxyPort}`, { timeout: 5e3 });
+    return {
+      browser,
+      cleanup: async () => {
+        try {
+          await browser.close();
+        } catch {
+        }
+        relay.kill();
+      }
+    };
+  } catch (err) {
+    relay.kill();
+    throw err;
+  }
+}
+
+// src/browser/launch.ts
+function recordingViewport(config) {
+  const zoom = config.video.zoom && config.video.zoom > 0 ? config.video.zoom : 1;
+  return {
+    width: Math.round(config.video.width / zoom),
+    height: Math.round(config.video.height / zoom)
+  };
+}
+async function launchBrowserContext(config, userDataDir, recordVideo, storageStatePath) {
+  const extensionPath = config.browser?.extension;
+  const zoom = config.video.zoom && config.video.zoom > 0 ? config.video.zoom : 1;
+  const viewport = recordingViewport(config);
+  const scaleOpts = zoom === 1 ? {} : { deviceScaleFactor: zoom };
+  const videoOpts = recordVideo ? { recordVideo } : {};
+  const cspOpts = { bypassCSP: true };
+  const authOpts = storageStatePath ? { storageState: storageStatePath } : {};
+  let context;
+  let browser = null;
+  let chromeSession = null;
+  if (extensionPath) {
+    await (0, import_promises2.mkdir)(userDataDir, { recursive: true });
+    const persistentArgs = [
+      `--disable-extensions-except=${extensionPath}`,
+      `--load-extension=${extensionPath}`,
+      "--window-position=-32000,-32000",
+      "--window-size=1,1"
+    ];
+    const useWindowsChrome = isWSL() && tryEnableWSLInterop();
+    if (useWindowsChrome) {
+      try {
+        chromeSession = await launchWindowsChrome(extensionPath, userDataDir, { viewport, ...scaleOpts, ...videoOpts });
+        const contexts = chromeSession.browser.contexts();
+        context = contexts[0] || await chromeSession.browser.newContext({
+          viewport,
+          ...scaleOpts,
+          ...videoOpts,
+          ...cspOpts,
+          acceptDownloads: true
+        });
+      } catch {
+        context = await import_playwright2.chromium.launchPersistentContext(userDataDir, {
+          headless: false,
+          args: persistentArgs,
+          viewport,
+          ...scaleOpts,
+          ...videoOpts,
+          ...cspOpts,
+          acceptDownloads: true
+        });
+      }
+    } else {
+      context = await import_playwright2.chromium.launchPersistentContext(userDataDir, {
+        headless: false,
+        args: persistentArgs,
+        viewport,
+        ...scaleOpts,
+        ...videoOpts,
+        ...cspOpts,
+        acceptDownloads: true
+      });
+    }
+  } else {
+    if (process.env.QP_HEADED === "1") {
+      const headedOpts = {
+        headless: false,
+        args: ["--disable-blink-features=AutomationControlled"],
+        ignoreDefaultArgs: ["--enable-automation"]
+      };
+      try {
+        browser = await import_playwright2.chromium.launch({ ...headedOpts, channel: "chrome" });
+      } catch {
+        browser = await import_playwright2.chromium.launch(headedOpts);
+      }
+    } else {
+      browser = await import_playwright2.chromium.launch({ headless: true });
+    }
+    context = await browser.newContext({
+      viewport,
+      ...scaleOpts,
+      ...videoOpts,
+      ...authOpts,
+      ...cspOpts,
+      acceptDownloads: true
+    });
+  }
+  await hideDevOverlays(context);
+  return { context, browser, chromeSession };
+}
+async function hideDevOverlays(context) {
+  await context.addInitScript(() => {
+    const css = "nextjs-portal,vite-error-overlay,vite-plugin-checker-error-overlay{display:none!important;pointer-events:none!important}";
+    const add = () => {
+      const style = document.createElement("style");
+      style.textContent = css;
+      document.head?.appendChild(style);
+    };
+    if (document.head) add();
+    else document.addEventListener("DOMContentLoaded", add, { once: true });
+  }).catch(() => {
+  });
+}
+async function launchSignInBrowser() {
+  const opts = {
+    headless: false,
+    args: ["--disable-blink-features=AutomationControlled"],
+    ignoreDefaultArgs: ["--enable-automation"]
+  };
+  try {
+    return await import_playwright2.chromium.launch({ ...opts, channel: "chrome" });
+  } catch {
+    return await import_playwright2.chromium.launch(opts);
+  }
+}
+async function cleanupBrowserSession(session) {
+  if (session.chromeSession) {
+    await session.chromeSession.cleanup();
+  } else {
+    await session.context.close();
+    if (session.browser) await session.browser.close();
+  }
+}
+
+// src/browser/auth-session.ts
+function sameSite(a, b) {
+  if (a === b) return true;
+  const tail = (h) => h.split(".").slice(-2).join(".");
+  return a.includes(".") && b.includes(".") && tail(a) === tail(b);
+}
+function captureStartUrl(context, targetUrl) {
+  const targetHost = new URL(targetUrl).host;
+  const pages = context.pages();
+  for (let i = pages.length - 1; i >= 0; i--) {
+    const pageUrl = pages[i].url();
+    if (!pageUrl.startsWith("http")) continue;
+    if (sameSite(new URL(pageUrl).host, targetHost)) return pageUrl;
+  }
+  return void 0;
+}
+
+// src/help.ts
+var import_chalk = __toESM(require("chalk"));
+init_lib();
+
+// src/logo.ts
+var import_figlet = __toESM(require("figlet"));
+var import_gradient_string = __toESM(require("gradient-string"));
+var DEFAULT_LOGO_CONFIG = {
+  text: "QuickPeek",
+  font: "Slant",
+  horizontalLayout: "default",
+  gradientColors: ["#00ffff", "#00d4ff", "#a855f7", "#ec4899"],
+  suffix: " \u{1F440}"
+};
+function renderLogo(config = {}) {
+  const resolved = { ...DEFAULT_LOGO_CONFIG, ...config };
+  const ascii = import_figlet.default.textSync(resolved.text, {
+    font: resolved.font,
+    horizontalLayout: resolved.horizontalLayout
+  });
+  const colored = (0, import_gradient_string.default)(resolved.gradientColors)(ascii);
+  return resolved.suffix ? `${colored}${resolved.suffix}` : colored;
+}
+
+// src/utils/config-loader.ts
+var import_node_fs6 = require("fs");
+var import_promises7 = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path7 = require("path");
+init_lib();
+async function loadConfig(_url, langOverride) {
+  const configPath = (0, import_node_path7.join)(process.cwd(), CONFIG_FILE);
+  if ((0, import_node_fs6.existsSync)(configPath)) {
+    try {
+      const content = await (0, import_promises7.readFile)(configPath, "utf-8");
+      const userConfig = JSON.parse(content);
+      const config = {
+        lang: langOverride || userConfig.lang || "en",
+        plan: { ...DEFAULT_CONFIG.plan, ...userConfig.plan },
+        video: { ...DEFAULT_CONFIG.video, ...userConfig.video },
+        audio: { ...DEFAULT_CONFIG.audio, ...userConfig.audio },
+        music: userConfig.music,
+        timing: { ...DEFAULT_CONFIG.timing, ...userConfig.timing },
+        output: { ...DEFAULT_CONFIG.output, ...userConfig.output }
+      };
+      return { config, created: false };
+    } catch {
+    }
+  }
+  const fullDefaultConfig = {
+    lang: "en",
+    plan: { maxSteps: 8 },
+    video: {
+      width: 1080,
+      height: 1920,
+      fps: 30,
+      quality: 0.5,
+      preset: "fast",
+      cursor: true,
+      highlight: false,
+      fadeIn: 500,
+      // ms
+      fadeOut: 500,
+      // ms
+      contrast: 0.25
+    },
+    audio: {
+      // Voice is derived from lang setting via LANGUAGE_VOICES mapping
+      // To override, use Edge TTS voice name like 'en-GB-SoniaNeural'
+      speed: 1
+    },
+    music: {
+      path: "",
+      volume: 0.3
+    },
+    output: { dir: "./demo" }
+  };
+  await (0, import_promises7.writeFile)(configPath, JSON.stringify(fullDefaultConfig, null, 2));
+  return { config: { ...DEFAULT_CONFIG, lang: langOverride || "en" }, created: true };
+}
+var WORK_DIR = ".quickpeek";
+async function prepareWorkDir() {
+  const workDir = (0, import_node_path7.join)(process.cwd(), WORK_DIR);
+  if ((0, import_node_fs6.existsSync)(workDir)) {
+    await (0, import_promises7.rm)(workDir, { recursive: true });
+  }
+  await (0, import_promises7.mkdir)(workDir, { recursive: true });
+  return workDir;
+}
+var USER_DATA_DIR = (0, import_node_path7.join)((0, import_node_os2.homedir)(), ".quickpeek");
+var USER_DATA_FILE = (0, import_node_path7.join)(USER_DATA_DIR, "user.json");
+async function loadUserData() {
+  try {
+    if ((0, import_node_fs6.existsSync)(USER_DATA_FILE)) {
+      return JSON.parse(await (0, import_promises7.readFile)(USER_DATA_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+async function saveUserData(userData) {
+  if (!(0, import_node_fs6.existsSync)(USER_DATA_DIR)) {
+    await (0, import_promises7.mkdir)(USER_DATA_DIR, { recursive: true });
+  }
+  const existing = await loadUserData();
+  const merged = { ...existing, ...userData };
+  await (0, import_promises7.writeFile)(USER_DATA_FILE, JSON.stringify(merged, null, 2));
+}
+var DEFAULT_CAPTIONS_CSS = `.caption {
+  font-family: Arial, sans-serif;
+  -webkit-text-stroke: 3px #000000;
+}
+.caption .regular {
+  font-size: 56px;
+  color: #FFFFFF;
+}
+.caption .highlight {
+  font-size: 64px;
+  color: #FFFF00;
+}
+`;
 function parseCaptionCSS(css) {
   const style = JSON.parse(JSON.stringify(DEFAULT_CAPTIONS));
   const captionBlock = css.match(/\.caption\s*\{([^}]+)\}/)?.[1] || "";
@@ -2250,12 +2769,12 @@ function parseCaptionCSS(css) {
 }
 async function loadCaptions() {
   const captionsPath = (0, import_node_path7.join)(process.cwd(), "captions.css");
-  if (!(0, import_node_fs4.existsSync)(captionsPath)) {
-    await (0, import_promises5.writeFile)(captionsPath, DEFAULT_CAPTIONS_CSS);
+  if (!(0, import_node_fs6.existsSync)(captionsPath)) {
+    await (0, import_promises7.writeFile)(captionsPath, DEFAULT_CAPTIONS_CSS);
     return DEFAULT_CAPTIONS;
   }
   try {
-    const css = await (0, import_promises5.readFile)(captionsPath, "utf-8");
+    const css = await (0, import_promises7.readFile)(captionsPath, "utf-8");
     return parseCaptionCSS(css);
   } catch {
     return DEFAULT_CAPTIONS;
@@ -2266,8 +2785,8 @@ async function savePlan(plan, planPath) {
     ...plan,
     steps: plan.steps.map(({ duration, ...step }) => step)
   };
-  await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(planPath), { recursive: true });
-  await (0, import_promises5.writeFile)(planPath, JSON.stringify(cleanPlan, null, 2));
+  await (0, import_promises7.mkdir)((0, import_node_path7.dirname)(planPath), { recursive: true });
+  await (0, import_promises7.writeFile)(planPath, JSON.stringify(cleanPlan, null, 2));
 }
 
 // src/help.ts
@@ -2346,6 +2865,7 @@ async function showHelp() {
     [`${cmd("qp login")}`, `qp login`, "Sign in with your Google account"],
     [`${cmd("qp logout")}`, `qp logout`, "Sign out"],
     [`${cmd("qp auth")} ${arg("<url>")}`, `qp auth <url>`, "Save a signed-in session for a site you demo"],
+    [`${cmd("qp auth list")}`, `qp auth list`, "Show which sites have a saved session"],
     [`${cmd("qp auth clear")} ${arg("[url]")}`, `qp auth clear [url]`, "Forget saved sessions"],
     [`${cmd("qp init")}`, `qp init`, "Create config file"],
     [`${cmd("qp config")} ${arg("<key>")} ${arg("<value>")}`, `qp config <key> <value>`, "Update a config option"]
@@ -2400,6 +2920,9 @@ var autoYes = false;
 function setAutoYes(value) {
   autoYes = value;
 }
+function isAutoYes() {
+  return autoYes;
+}
 function task(text) {
   return (0, import_ora.default)({ text, prefixText: INDENT, spinner: "dots" }).start();
 }
@@ -2430,11 +2953,20 @@ function promptInput(prompt2) {
     });
   });
 }
-var _isWSL = process.platform === "linux" && process.env.WSL_DISTRO_NAME;
-function formatClickablePath(filePath) {
-  const absolutePath = (0, import_node_path8.resolve)(filePath);
-  if (_isWSL || process.platform !== "win32") {
-    return absolutePath;
+function waitForEnter(prompt2 = `${INDENT}Press Enter when done...`) {
+  return new Promise((resolve9) => {
+    const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+    rl.question(prompt2, () => {
+      rl.close();
+      resolve9();
+    });
+  });
+}
+var _isWSL = process.platform === "linux" && process.env.WSL_DISTRO_NAME;
+function formatClickablePath(filePath) {
+  const absolutePath = (0, import_node_path8.resolve)(filePath);
+  if (_isWSL || process.platform !== "win32") {
+    return absolutePath;
   }
   let formatted = absolutePath;
   formatted = formatted.replace(/\//g, "\\");
@@ -2450,15 +2982,6 @@ function formatDuration(ms) {
 }
 
 // src/commands/auth-cmd.ts
-function waitForEnter(prompt2) {
-  return new Promise((resolve9) => {
-    const rl = (0, import_node_readline2.createInterface)({ input: process.stdin, output: process.stdout });
-    rl.question(prompt2, () => {
-      rl.close();
-      resolve9();
-    });
-  });
-}
 async function authCommand(url) {
   console.log();
   showLogo();
@@ -2466,9 +2989,10 @@ async function authCommand(url) {
     console.log(import_chalk3.default.red(`  Not a valid URL: ${url}`));
     return;
   }
-  console.log(import_chalk3.default.white("  A browser will open. Sign in to the site, then come back here."));
+  console.log(import_chalk3.default.white("  A browser will open. Sign in, then leave it on the page demos"));
+  console.log(import_chalk3.default.white("  should start from (usually your dashboard) and come back here."));
   console.log();
-  const browser = await import_playwright2.chromium.launch({ headless: false });
+  const browser = await launchSignInBrowser();
   const context = await browser.newContext();
   const page = await context.newPage();
   try {
@@ -2478,11 +3002,15 @@ async function authCommand(url) {
   await waitForEnter(import_chalk3.default.cyan("  Press Enter when you are signed in... "));
   try {
     const state = await context.storageState();
-    const path = await saveAuthState(url, state);
+    const startUrl = captureStartUrl(context, url);
+    const path = await saveAuthState(url, state, startUrl);
     console.log();
     console.log(import_chalk3.default.green(`  \u2713 Session saved for ${new URL(url).host}`));
     console.log(import_chalk3.default.dim(`  ${formatClickablePath(path)}`));
     console.log(import_chalk3.default.dim("  Crawls and recordings of this site now start signed in."));
+    if (startUrl && startUrl !== url) {
+      console.log(import_chalk3.default.dim("  Demos of the bare URL will start at ") + import_chalk3.default.cyan(startUrl));
+    }
     console.log(import_chalk3.default.dim("  Run ") + import_chalk3.default.cyan(`qp auth clear ${new URL(url).host}`) + import_chalk3.default.dim(" to forget it."));
   } finally {
     await browser.close().catch(() => {
@@ -2524,17 +3052,17 @@ var import_chalk11 = __toESM(require("chalk"));
 init_lib();
 
 // src/ai/client.ts
-var import_node_readline3 = require("readline");
+var import_node_readline2 = require("readline");
 var import_chalk5 = __toESM(require("chalk"));
 init_lib();
 
 // src/utils/browser-auth.ts
-var import_node_http = require("http");
+var import_node_http2 = require("http");
 var import_node_url = require("url");
 var import_chalk4 = __toESM(require("chalk"));
 
 // src/lib/browser-open.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 function editorBaseUrl() {
   return (process.env.QUICKPEEK_API_BASE || "https://quickpeek.co").replace(/\/$/, "");
 }
@@ -2542,7 +3070,7 @@ function openInBrowser(url) {
   const isWSL2 = process.platform === "linux" && Boolean(process.env.WSL_DISTRO_NAME);
   const command = isWSL2 ? `cmd.exe /c start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
   return new Promise((resolve9) => {
-    (0, import_node_child_process3.exec)(command, () => resolve9());
+    (0, import_node_child_process4.exec)(command, () => resolve9());
   });
 }
 
@@ -2558,7 +3086,7 @@ async function browserLogin() {
       server?.close();
       resolve9(email);
     };
-    server = (0, import_node_http.createServer)((req, res) => {
+    server = (0, import_node_http2.createServer)((req, res) => {
       const url = new import_node_url.URL(req.url || "/", `http://localhost`);
       const path = url.pathname;
       if (path === "/callback" || path === "/") {
@@ -2612,13 +3140,132 @@ async function browserLogin() {
   });
 }
 
+// src/utils/logging.ts
+var import_promises8 = require("fs/promises");
+var import_node_path9 = require("path");
+var LOG_FILE_NAME = "quickpeek.log";
+var logFileInitialized = false;
+var logFilePath = LOG_FILE_NAME;
+async function writeLogEntry(entry) {
+  try {
+    if (!logFileInitialized) {
+      await (0, import_promises8.writeFile)(logFilePath, entry);
+      logFileInitialized = true;
+    } else {
+      await (0, import_promises8.appendFile)(logFilePath, entry);
+    }
+  } catch {
+  }
+}
+async function setLogFilePath(outputDir) {
+  logFilePath = (0, import_node_path9.join)(outputDir, LOG_FILE_NAME);
+  const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
+${"=".repeat(60)}
+
+`;
+  try {
+    await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(logFilePath), { recursive: true });
+    await (0, import_promises8.writeFile)(logFilePath, header2);
+    logFileInitialized = true;
+  } catch {
+  }
+}
+async function logInfo(context, message) {
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [${context}] ${message}
+`);
+}
+async function logDebug(context, message) {
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [${context}] ${message}
+`);
+}
+async function logError(context, error) {
+  let errorMsg;
+  if (error instanceof Error) {
+    errorMsg = `${error.message}
+${error.stack}`;
+  } else if (typeof error === "object" && error !== null) {
+    errorMsg = JSON.stringify(error, null, 2);
+  } else {
+    errorMsg = String(error);
+  }
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ERROR] [${context}]
+${errorMsg}
+
+`);
+}
+async function logStep(stepNum, action, details) {
+  const detailsStr = Object.entries(details).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [STEP ${stepNum}] ${action} | ${detailsStr}
+`);
+}
+
+// src/ai/mcp-context.ts
+var import_node_async_hooks = require("async_hooks");
+var DelegatedGenerationError = class extends Error {
+  tool;
+  step;
+  /** The system instructions the call was about to send. */
+  system;
+  /** The user-side prompt. */
+  prompt;
+  constructor(tool, step, system, prompt2) {
+    super(
+      `Generation for "${tool}" (${step}) belongs to the calling model, not Groq. The tool should hand back this prompt and accept the result as a parameter.`
+    );
+    this.name = "DelegatedGenerationError";
+    this.tool = tool;
+    this.step = step;
+    this.system = system;
+    this.prompt = prompt2;
+  }
+};
+var mcpCall = new import_node_async_hooks.AsyncLocalStorage();
+function currentMcpTool() {
+  return mcpCall.getStore()?.tool ?? null;
+}
+function suppliedAnswer(step) {
+  return mcpCall.getStore()?.answers?.[step];
+}
+function recordDelegation(e) {
+  const store = mcpCall.getStore();
+  if (store && !store.pending.some((p) => p.step === e.step)) store.pending.push(e);
+}
+
 // src/ai/client.ts
 var lastRateLimitInfo = null;
+function wrap(text, width) {
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    let current = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      if (current && current.length + word.length + 1 > width) {
+        lines.push(current);
+        current = word;
+      } else {
+        current = current ? `${current} ${word}` : word;
+      }
+    }
+    lines.push(current);
+  }
+  return lines.filter((l) => l.length > 0);
+}
+function diagnose(status, host) {
+  const where = host ?? "the AI service";
+  if (status === void 0) return `Could not reach ${where}. Check your network, then retry.`;
+  if (status === 401 || status === 403) return `${where} rejected the credentials. Run qp login and retry.`;
+  if (status === 413) return `The prompt was too large for ${where}. Shorten the script or the page.`;
+  if (status === 429) return `${where} is rate limiting. Wait for the quota to reset, then retry.`;
+  if (status === 502 || status === 503 || status === 504) {
+    return `${where} could not reach the AI backend (upstream outage). Retry in a few minutes.`;
+  }
+  if (status >= 500) return `${where} failed internally. Retry in a few minutes; if it persists, report this.`;
+  return `${where} rejected the request. See the body above.`;
+}
 function getLastRateLimitInfo() {
   return lastRateLimitInfo;
 }
 function prompt(question) {
-  const rl = (0, import_node_readline3.createInterface)({ input: process.stdin, output: process.stdout });
+  const rl = (0, import_node_readline2.createInterface)({ input: process.stdin, output: process.stdout });
   return new Promise((resolve9) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -2661,15 +3308,33 @@ async function setupUserEmail() {
   console.log();
   return email;
 }
-async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "free") {
-  const result = process.env.SPARK_AI_KEY ? await callAI(systemPrompt, userPrompt, tier) : await callAIViaRelay(systemPrompt, userPrompt, userEmail ?? "", tier);
+async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "free", step = "plan") {
+  const mcpTool = currentMcpTool();
+  if (mcpTool) {
+    const answered = suppliedAnswer(step);
+    if (typeof answered === "string") return answered;
+    const refusal = new DelegatedGenerationError(mcpTool, step, systemPrompt, userPrompt);
+    recordDelegation(refusal);
+    throw refusal;
+  }
+  const onRetry = ({ attempt, status, delayMs, host }) => {
+    console.log(
+      import_chalk5.default.dim(
+        `
+  ${host} returned ${status}; retrying in ${Math.round(delayMs / 1e3)}s (attempt ${attempt + 1} of 3)`
+      )
+    );
+  };
+  const chatOpts = { onRetry, backoffMs: CLI_BACKOFF_MS };
+  const result = process.env.SPARK_AI_KEY ? await callAI(systemPrompt, userPrompt, tier, chatOpts) : await callAIViaRelay(systemPrompt, userPrompt, userEmail ?? "", tier, chatOpts);
   if (!result.success) {
-    await logError2("AI API", new Error(result.error));
+    await logError2("AI API", new Error(result.detail ? `${result.error}
+Body: ${result.detail}` : result.error));
     if (result.isRateLimit) {
       console.log();
       console.log(import_chalk5.default.red("  \u26A0 Rate Limit Reached (after 3 retries)"));
       console.log();
-      console.log(import_chalk5.default.dim("  Spark AI daily limit exceeded. You may have hit your quota."));
+      console.log(import_chalk5.default.dim(`  ${result.error}`));
       console.log(import_chalk5.default.dim("  Options:"));
       if (result.retryAfterSeconds) {
         const minutes = Math.ceil(result.retryAfterSeconds / 60);
@@ -2684,17 +3349,31 @@ async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "
     }
     if (result.isAuthError) {
       console.log();
-      console.log(import_chalk5.default.red("  \u26A0 Authentication Error"));
+      console.log(import_chalk5.default.red(`  \u26A0 Authentication Error${result.status ? ` (HTTP ${result.status})` : ""}`));
       console.log();
-      console.log(import_chalk5.default.dim(`  ${result.error}`));
+      for (const line of wrap(result.error, 76)) {
+        console.log(import_chalk5.default.dim(`  ${line}`));
+      }
+      console.log();
+      console.log(import_chalk5.default.dim(`  ${diagnose(result.status, result.host)}`));
       console.log();
       process.exit(1);
     }
     console.log();
-    console.log(import_chalk5.default.red("  \u26A0 AI Error"));
+    console.log(import_chalk5.default.red(`  \u26A0 AI Error${result.status ? ` (HTTP ${result.status})` : ""}`));
+    console.log();
+    for (const line of wrap(result.error, 76)) {
+      console.log(import_chalk5.default.dim(`  ${line}`));
+    }
+    if (result.detail && !result.error.includes(result.detail)) {
+      console.log();
+      for (const line of wrap(result.detail, 76).slice(0, 6)) {
+        console.log(import_chalk5.default.dim(`  ${line}`));
+      }
+    }
     console.log();
-    const firstLine = result.error.split("\n")[0] ?? result.error;
-    console.log(import_chalk5.default.dim(`  ${firstLine.slice(0, 80)}`));
+    console.log(import_chalk5.default.dim(`  ${diagnose(result.status, result.host)}`));
+    console.log(import_chalk5.default.dim(`  Full response body: ${logFilePath}`));
     console.log();
     process.exit(1);
   }
@@ -2702,7 +3381,48 @@ async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "
   return result.content;
 }
 
+// src/ai/json-plan.ts
+init_lib();
+init_utils();
+var JSON_FIX_SYSTEM_PROMPT = "You fix malformed JSON. Return ONLY valid JSON, no explanation.";
+var PLAN_SHAPE = `The JSON should have: url, title, description, steps array.
+Each step has: id (number), action, caption, and optionally target, value.`;
+var jsonFixUserPrompt = (content, shape) => `Fix this malformed JSON. Return ONLY valid JSON, no explanation.
+${shape}
+
+Malformed content:
+${content}`;
+var noopTask2 = () => ({ succeed: () => {
+}, fail: () => {
+} });
+async function parseAIJsonWithRepair(content, opts) {
+  const { logError: logError2, userEmail, tier = "free", shape = PLAN_SHAPE, context = "JSON Fix" } = opts;
+  const direct = parseAIJson(content);
+  if (direct) return direct.value;
+  const makeTask = opts.task ?? noopTask2;
+  const fixTask = makeTask("Fixing malformed JSON");
+  try {
+    const fixed = await callGroq(JSON_FIX_SYSTEM_PROMPT, jsonFixUserPrompt(content, shape), logError2, userEmail, tier);
+    const repaired = parseAIJson(fixed);
+    if (!repaired) throw new Error("No usable JSON in fix");
+    fixTask.succeed("JSON fixed by AI");
+    return repaired.value;
+  } catch (err) {
+    await logError2(context, err);
+    fixTask.fail("Could not fix JSON");
+    throw new Error(`Malformed JSON: ${getErrorMessage(err)}`);
+  }
+}
+
 // src/ai/narrate.ts
+var SCRIPT_ACTIONS = /* @__PURE__ */ new Set(["click", "type", "scroll", "wait", "select", "check", "navigate"]);
+var NEEDS_TARGET = /* @__PURE__ */ new Set(["click", "type", "select", "check", "navigate"]);
+function isUsableStep(step) {
+  if (!step?.action || !SCRIPT_ACTIONS.has(step.action)) return false;
+  if (NEEDS_TARGET.has(step.action) && !step.target) return false;
+  if (step.action === "navigate" && !/^https?:\/\//.test(step.target ?? "")) return false;
+  return true;
+}
 async function generateCaptionsForSteps(steps, url, title, lang, logError2, userEmail, pageContext, tier = "free") {
   const langName = getLanguageName(lang);
   const stepList = steps.map((s, i) => {
@@ -2728,33 +3448,34 @@ Steps to caption:
 ${stepList}
 
 Return exactly ${steps.length} captions as a JSON array.`;
-  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier);
-  const arrayMatch = content.match(/\[[\s\S]*\]/);
-  if (!arrayMatch) throw new Error("No JSON array in AI caption response");
-  const captions = JSON.parse(arrayMatch[0]);
+  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier, "narration");
+  const parsed = parseAIJson(content);
+  if (!parsed || !Array.isArray(parsed.value)) throw new Error("No JSON array in AI caption response");
+  const captions = parsed.value;
   return steps.map((s, i) => ({
     ...s,
     id: i + 1,
     caption: toTitleCase(captions[i] ?? `Step ${i + 1}.`)
   }));
 }
-async function generatePlanFromScript(captions, url, title, pageElementsText, lang, logError2, userEmail, tier = "free") {
+async function generatePlanFromScript(captions, url, title, pageElementsText, lang, logError2, userEmail, tier = "free", task2) {
   const systemPrompt = `You map narration sentences to web UI actions.
-Given page elements and a script, return a JSON demo plan.
+Given page elements and a numbered script, return one action per script line.
 
 RULES:
-- Return ONLY valid JSON
-- Preserve captions EXACTLY as given \u2014 never alter the text
+- Return ONLY valid JSON, no explanation, no captions
+- Return exactly one entry per script line, in order, with "line" set to that line's number
 - Use page elements to pick realistic actions/targets
-- If a caption doesn't match a specific UI action, use { "action": "wait" }
+- If a line doesn't match a specific UI action, use { "action": "wait" }
+- Keep every target and value short
 
 ACTION FORMATS:
-\u2022 click: { "action": "click", "target": "button text" }
-\u2022 type: { "action": "type", "target": "input selector", "value": "text from caption" }
-\u2022 scroll: { "action": "scroll", "value": "up|down" }
-\u2022 wait: { "action": "wait" }
+\u2022 click: { "line": 1, "action": "click", "target": "button text" }
+\u2022 type: { "line": 2, "action": "type", "target": "input selector", "value": "text to type" }
+\u2022 scroll: { "line": 3, "action": "scroll", "value": "up|down" }
+\u2022 wait: { "line": 4, "action": "wait" }
 
-OUTPUT: full plan JSON with url, title, description, steps[]`;
+OUTPUT: {"description":"one short sentence","steps":[ ... ]}`;
   const scriptLines = captions.map((c, i) => `${i + 1}. "${c}"`).join("\n");
   const userMessage = `URL: ${url}
 App: ${title}
@@ -2762,22 +3483,46 @@ App: ${title}
 Available page elements:
 ${pageElementsText}
 
-Narration script (map each line to a UI action, preserve caption text exactly):
+Narration script (map each line to a UI action):
 ${scriptLines}
 
-Return the full plan JSON.`;
-  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier);
-  const jsonMatch = content.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error("No JSON in AI script response");
-  const plan = JSON.parse(jsonMatch[0]);
-  plan.url = url;
-  if (lang !== void 0) plan.lang = lang;
-  plan.steps = plan.steps.map(({ duration: _d, ...s }, i) => ({
-    ...s,
-    id: i + 1,
-    caption: captions[i] ?? s.caption ?? ""
-  }));
-  return plan;
+Return JSON with a "description" and a "steps" array of exactly ${captions.length} actions.`;
+  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier, "narration");
+  const parsed = await parseAIJsonWithRepair(content, {
+    logError: logError2,
+    task: task2,
+    userEmail,
+    tier,
+    shape: "The JSON should have: description (string), steps (array of {line, action, target, value}).",
+    context: "Script Plan"
+  });
+  const raw = Array.isArray(parsed?.steps) ? parsed.steps : [];
+  const byLine = /* @__PURE__ */ new Map();
+  raw.forEach((step, i) => {
+    if (!step || typeof step !== "object") return;
+    const line = typeof step.line === "number" && step.line >= 1 ? step.line : i + 1;
+    if (!byLine.has(line)) byLine.set(line, step);
+  });
+  const steps = captions.map((caption, i) => {
+    const mapped = byLine.get(i + 1);
+    if (!isUsableStep(mapped)) {
+      return { id: i + 1, action: "wait", caption };
+    }
+    return {
+      id: i + 1,
+      action: mapped.action,
+      caption,
+      ...mapped.target ? { target: mapped.target } : {},
+      ...mapped.value ? { value: mapped.value } : {}
+    };
+  });
+  return {
+    url,
+    title,
+    description: typeof parsed?.description === "string" ? parsed.description : title,
+    ...lang !== void 0 ? { lang } : {},
+    steps
+  };
 }
 
 // src/browser/events-to-plan.ts
@@ -2845,191 +3590,48 @@ function eventsToSteps(events, url) {
       continue;
     }
     if (event.type === "click") {
-      const selectorRaw = !isGenericTag(event.selector) ? event.selector : event.target;
-      if (isGenericTag(selectorRaw)) continue;
-      const selector = selectorRaw;
-      const timeDiff = event.timestamp - prevClickTime;
-      if (selector === prevClickSelector && timeDiff < DOUBLE_CLICK_THRESHOLD_MS && steps.length > 0) {
-        const last = steps[steps.length - 1];
-        if (last.action === "click") {
-          last.action = "click-2";
-          prevClickSelector = void 0;
-          continue;
-        }
-      }
-      steps.push({ id: idCounter++, action: "click", target: selector });
-      prevClickSelector = selector;
-      prevClickTime = event.timestamp;
-      continue;
-    }
-    if (event.type === "scroll") {
-      const dir = event.scrollDir ?? "down";
-      if (steps.length > 0) {
-        const last = steps[steps.length - 1];
-        if (last.action === "scroll" && last.value === dir) continue;
-      }
-      steps.push({ id: idCounter++, action: "scroll", value: dir });
-      prevClickSelector = void 0;
-    }
-  }
-  return steps;
-}
-function normalizeUrl2(url) {
-  try {
-    const u = new URL(url);
-    return u.origin + u.pathname.replace(/\/$/, "");
-  } catch {
-    return url;
-  }
-}
-
-// src/capture.ts
-var import_node_child_process5 = require("child_process");
-var import_node_http3 = require("http");
-var import_node_readline4 = require("readline");
-var import_playwright4 = require("playwright");
-
-// src/browser/wsl.ts
-var import_node_child_process4 = require("child_process");
-var import_node_fs5 = require("fs");
-var import_node_http2 = require("http");
-var import_playwright3 = require("playwright");
-function isWSL() {
-  if (process.platform !== "linux") return false;
-  try {
-    const r = (0, import_node_child_process4.execSync)("uname -r", { encoding: "utf-8" }).toLowerCase();
-    return r.includes("microsoft") || r.includes("wsl");
-  } catch {
-    return false;
-  }
-}
-function tryEnableWSLInterop() {
-  return (0, import_node_fs5.existsSync)("/proc/sys/fs/binfmt_misc/WSLInterop");
-}
-function wslToWindowsPath(wslPath) {
-  if (!wslPath) return wslPath;
-  const m = wslPath.match(/^\/mnt\/([a-z])\/(.*)/);
-  if (!m) return wslPath;
-  return `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, "\\")}`;
-}
-function findExe(whereExeQuery, ...hardcoded) {
-  for (const p of hardcoded) if ((0, import_node_fs5.existsSync)(p)) return p;
-  try {
-    const line = (0, import_node_child_process4.execSync)(`where.exe ${whereExeQuery}`, { encoding: "utf-8", timeout: 3e3 }).split("\n")[0]?.trim();
-    if (line) return line.replace(/^([A-Za-z]):\\/, (_, d) => `/mnt/${d.toLowerCase()}/`).replace(/\\/g, "/");
-  } catch {
-  }
-  return null;
-}
-var findWindowsChrome = () => findExe(
-  "chrome.exe",
-  "/mnt/c/Program Files/Google/Chrome/Application/chrome.exe",
-  "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"
-);
-var findWindowsNode = () => findExe("node.exe");
-function getWindowsHostIP() {
-  try {
-    const m = (0, import_node_child_process4.execSync)("ip route show default", { encoding: "utf-8", timeout: 2e3 }).match(
-      /default via (\d+\.\d+\.\d+\.\d+)/
-    );
-    if (m?.[1]) return m[1];
-  } catch {
-  }
-  try {
-    const m = (0, import_node_fs5.readFileSync)("/etc/resolv.conf", "utf-8").match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
-    if (m?.[1]) return m[1];
-  } catch {
-  }
-  return "127.0.0.1";
-}
-function startRelay(nodePath, windowsHost, targetPort) {
-  const script = `var n=require('net'),s=n.createServer(function(c){var r=n.createConnection(${targetPort},'127.0.0.1');c.pipe(r);r.pipe(c);r.on('error',function(){c.destroy()});c.on('error',function(){r.destroy()});});s.listen(0,'${windowsHost}',function(){process.stdout.write('PORT:'+s.address().port+'\\n')});`;
-  return new Promise((resolve9, reject) => {
-    const proc = (0, import_node_child_process4.spawn)(nodePath, ["-e", script], { stdio: ["ignore", "pipe", "ignore"], detached: true });
-    const timer = setTimeout(() => reject(new Error("relay startup timed out")), 6e3);
-    let buf = "";
-    proc.stdout.on("data", (d) => {
-      buf += d.toString();
-      const m = buf.match(/PORT:(\d+)/);
-      if (m) {
-        clearTimeout(timer);
-        resolve9({ proc, port: +m[1] });
-      }
-    });
-    proc.on("error", (e) => {
-      clearTimeout(timer);
-      reject(e);
-    });
-  });
-}
-function waitForChrome(host, port) {
-  return new Promise((resolve9, reject) => {
-    const deadline = Date.now() + 2e4;
-    const poll = () => {
-      if (Date.now() > deadline) {
-        reject(new Error("Chrome debug port did not open within 20 s"));
-        return;
-      }
-      const req = (0, import_node_http2.request)({ host, port, path: "/json/version", method: "GET" }, (res) => {
-        res.resume();
-        resolve9();
-      });
-      req.on("error", () => setTimeout(poll, 600));
-      req.setTimeout(1e3, () => {
-        req.destroy();
-        setTimeout(poll, 600);
-      });
-      req.end();
-    };
-    poll();
-  });
-}
-async function launchWindowsChrome(extensionPath, userDataDir, options = {}) {
-  const debugPort = options.debugPort ?? 9222;
-  const chromePath = findWindowsChrome();
-  if (!chromePath) throw new Error("Windows Chrome not found. Install Google Chrome for Windows.");
-  const nodePath = findWindowsNode();
-  if (!nodePath) throw new Error("Windows Node.js not found. Install Node.js for Windows.");
-  const winUserData = wslToWindowsPath(userDataDir);
-  const winExtPath = extensionPath ? wslToWindowsPath(extensionPath) : "";
-  const chromeProc = (0, import_node_child_process4.spawn)(
-    chromePath,
-    [
-      `--remote-debugging-port=${debugPort}`,
-      `--user-data-dir=${winUserData}`,
-      ...winExtPath ? [`--disable-extensions-except=${winExtPath}`, `--load-extension=${winExtPath}`] : [],
-      "--no-first-run",
-      "--no-default-browser-check",
-      "--disable-background-networking",
-      "--disable-sync",
-      "--disable-features=TranslateUI",
-      options.startMaximized ? "--start-maximized" : "--start-minimized"
-    ],
-    { stdio: "ignore", detached: true }
-  );
-  chromeProc.unref();
-  const windowsHost = getWindowsHostIP();
-  const { proc: relay, port: proxyPort } = await startRelay(nodePath, windowsHost, debugPort);
-  try {
-    await waitForChrome(windowsHost, proxyPort);
-    const browser = await import_playwright3.chromium.connectOverCDP(`http://${windowsHost}:${proxyPort}`, { timeout: 5e3 });
-    return {
-      browser,
-      cleanup: async () => {
-        try {
-          await browser.close();
-        } catch {
+      const selectorRaw = !isGenericTag(event.selector) ? event.selector : event.target;
+      if (isGenericTag(selectorRaw)) continue;
+      const selector = selectorRaw;
+      const timeDiff = event.timestamp - prevClickTime;
+      if (selector === prevClickSelector && timeDiff < DOUBLE_CLICK_THRESHOLD_MS && steps.length > 0) {
+        const last = steps[steps.length - 1];
+        if (last.action === "click") {
+          last.action = "click-2";
+          prevClickSelector = void 0;
+          continue;
         }
-        relay.kill();
       }
-    };
-  } catch (err) {
-    relay.kill();
-    throw err;
+      steps.push({ id: idCounter++, action: "click", target: selector });
+      prevClickSelector = selector;
+      prevClickTime = event.timestamp;
+      continue;
+    }
+    if (event.type === "scroll") {
+      const dir = event.scrollDir ?? "down";
+      if (steps.length > 0) {
+        const last = steps[steps.length - 1];
+        if (last.action === "scroll" && last.value === dir) continue;
+      }
+      steps.push({ id: idCounter++, action: "scroll", value: dir });
+      prevClickSelector = void 0;
+    }
+  }
+  return steps;
+}
+function normalizeUrl2(url) {
+  try {
+    const u = new URL(url);
+    return u.origin + u.pathname.replace(/\/$/, "");
+  } catch {
+    return url;
   }
 }
 
 // src/capture.ts
+var import_node_child_process5 = require("child_process");
+var import_node_http3 = require("http");
+var import_playwright4 = require("playwright");
 var EVENT_TRACKER_SCRIPT = `
 (function () {
   if (window.__qpTracking) return;
@@ -3141,16 +3743,6 @@ var EVENT_TRACKER_SCRIPT = `
   }, { passive: true, capture: true });
 }());
 `;
-function waitForEnter2() {
-  return new Promise((resolve9) => {
-    const rl = (0, import_node_readline4.createInterface)({ input: process.stdin, output: process.stdout });
-    process.stdout.write("  Press Enter when done...\n");
-    rl.once("line", () => {
-      rl.close();
-      resolve9();
-    });
-  });
-}
 async function launchCaptureChrome() {
   const debugPort = 9222;
   const chromePath = findWindowsChrome();
@@ -3249,7 +3841,7 @@ async function captureUserSession(url, _workDir) {
     return [title, parts.join(" | ")];
   }).catch(() => ["", ""]);
   startTime = Date.now();
-  await waitForEnter2();
+  await waitForEnter();
   const durationMs = Date.now() - startTime;
   if (relay) {
     try {
@@ -3264,83 +3856,25 @@ async function captureUserSession(url, _workDir) {
   return { events, durationMs, pageTitle, pageContext };
 }
 
-// src/utils/logging.ts
-var import_promises6 = require("fs/promises");
-var import_node_path9 = require("path");
-var LOG_FILE_NAME = "quickpeek.log";
-var logFileInitialized = false;
-var logFilePath = LOG_FILE_NAME;
-async function writeLogEntry(entry) {
-  try {
-    if (!logFileInitialized) {
-      await (0, import_promises6.writeFile)(logFilePath, entry);
-      logFileInitialized = true;
-    } else {
-      await (0, import_promises6.appendFile)(logFilePath, entry);
-    }
-  } catch {
-  }
-}
-async function setLogFilePath(outputDir) {
-  logFilePath = (0, import_node_path9.join)(outputDir, LOG_FILE_NAME);
-  const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
-${"=".repeat(60)}
-
-`;
-  try {
-    await (0, import_promises6.writeFile)(logFilePath, header2);
-    logFileInitialized = true;
-  } catch {
-  }
-}
-async function logInfo(context, message) {
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [${context}] ${message}
-`);
-}
-async function logDebug(context, message) {
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [${context}] ${message}
-`);
-}
-async function logError(context, error) {
-  let errorMsg;
-  if (error instanceof Error) {
-    errorMsg = `${error.message}
-${error.stack}`;
-  } else if (typeof error === "object" && error !== null) {
-    errorMsg = JSON.stringify(error, null, 2);
-  } else {
-    errorMsg = String(error);
-  }
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ERROR] [${context}]
-${errorMsg}
-
-`);
-}
-async function logStep(stepNum, action, details) {
-  const detailsStr = Object.entries(details).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [STEP ${stepNum}] ${action} | ${detailsStr}
-`);
-}
-
 // src/commands/phases/video-phase.ts
-var import_node_fs12 = require("fs");
-var import_promises13 = require("fs/promises");
+var import_node_fs13 = require("fs");
+var import_promises14 = require("fs/promises");
 var import_node_path18 = require("path");
 init_lib();
 
 // src/record.ts
-var import_node_fs10 = require("fs");
-var import_promises10 = require("fs/promises");
+var import_node_fs11 = require("fs");
+var import_promises11 = require("fs/promises");
 var import_node_path15 = require("path");
 var import_chalk6 = __toESM(require("chalk"));
 
 // src/browser/actions.ts
-var import_node_fs7 = require("fs");
-var import_promises7 = require("fs/promises");
+var import_node_fs8 = require("fs");
+var import_promises9 = require("fs/promises");
 var import_node_path11 = require("path");
 
 // src/browser/effects.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path10 = require("path");
 init_lib();
 function loadHighlightCSS() {
@@ -3351,7 +3885,7 @@ function loadHighlightCSS() {
     // src/browser/ → src/
   ];
   for (const p of candidates) {
-    if ((0, import_node_fs6.existsSync)(p)) return (0, import_node_fs6.readFileSync)(p, "utf-8");
+    if ((0, import_node_fs7.existsSync)(p)) return (0, import_node_fs7.readFileSync)(p, "utf-8");
   }
   return "";
 }
@@ -3551,6 +4085,10 @@ async function resolveElement(page, target) {
       await locator.waitFor({ state: "visible", timeout });
       return await locator.elementHandle({ timeout: 1e3 });
     }
+    if (target.startsWith("#") && !/^#[A-Za-z_-][\w-]*$/.test(target)) {
+      const attr = `[id="${target.slice(1).replace(/(["\\])/g, "\\$1")}"]`;
+      return await page.waitForSelector(attr, { state: "visible", timeout });
+    }
     return await page.waitForSelector(target, { state: "visible", timeout });
   } catch {
     return null;
@@ -3700,7 +4238,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
           if (!isPlaceholder) {
             const normalizedPath = rawPath.startsWith("mnt/") ? `/${rawPath}` : rawPath;
             const filePath = (0, import_node_path11.isAbsolute)(normalizedPath) ? normalizedPath : (0, import_node_path11.resolve)(baseDir, normalizedPath);
-            if ((0, import_node_fs7.existsSync)(filePath)) {
+            if ((0, import_node_fs8.existsSync)(filePath)) {
               await fileInput.setInputFiles(filePath);
               await page.waitForTimeout(2e3);
               break;
@@ -3817,7 +4355,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
       break;
     case "image": {
       const imagePath = step.value ? (0, import_node_path11.isAbsolute)(step.value) ? step.value : (0, import_node_path11.resolve)(baseDir, step.value) : null;
-      if (imagePath && (0, import_node_fs7.existsSync)(imagePath)) {
+      if (imagePath && (0, import_node_fs8.existsSync)(imagePath)) {
         const imgStyle = step.target === "stretch" ? `width: ${config.video.width}px; height: ${config.video.height}px; object-fit: cover;` : "max-width: 90%; max-height: 90%;";
         if (await showImagePage(page, imagePath, imgStyle, config, cursorInjected)) injected = true;
       }
@@ -3847,7 +4385,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
         await pendingDownload;
         pendingDownload = null;
       }
-      if (lastDownloadPath && (0, import_node_fs7.existsSync)(lastDownloadPath)) {
+      if (lastDownloadPath && (0, import_node_fs8.existsSync)(lastDownloadPath)) {
         const imgStyle = step.target === "stretch" ? "width: 100%; height: 100%; object-fit: contain;" : "max-width: 90%; max-height: 90%; object-fit: contain;";
         if (await showImagePage(page, lastDownloadPath, imgStyle, config, cursorInjected)) injected = true;
       }
@@ -3858,7 +4396,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
 async function showImagePage(page, filePath, imgStyle, config, cursorInjected) {
   const { width, height } = config.video;
   const ext = filePath.split(".").pop()?.toLowerCase() || "";
-  const fileBuffer = await (0, import_promises7.readFile)(filePath);
+  const fileBuffer = await (0, import_promises9.readFile)(filePath);
   const base64 = fileBuffer.toString("base64");
   const mimeTypes = {
     png: "image/png",
@@ -3887,64 +4425,6 @@ async function showImagePage(page, filePath, imgStyle, config, cursorInjected) {
   return false;
 }
 
-// src/browser/launch.ts
-var import_promises8 = require("fs/promises");
-var import_playwright5 = require("playwright");
-async function launchBrowserContext(config, userDataDir, recordVideo, storageStatePath) {
-  const extensionPath = config.browser?.extension;
-  const viewport = { width: config.video.width, height: config.video.height };
-  const videoOpts = recordVideo ? { recordVideo } : {};
-  const authOpts = storageStatePath ? { storageState: storageStatePath } : {};
-  let context;
-  let browser = null;
-  let chromeSession = null;
-  if (extensionPath) {
-    await (0, import_promises8.mkdir)(userDataDir, { recursive: true });
-    const persistentArgs = [
-      `--disable-extensions-except=${extensionPath}`,
-      `--load-extension=${extensionPath}`,
-      "--window-position=-32000,-32000",
-      "--window-size=1,1"
-    ];
-    const useWindowsChrome = isWSL() && tryEnableWSLInterop();
-    if (useWindowsChrome) {
-      try {
-        chromeSession = await launchWindowsChrome(extensionPath, userDataDir, { viewport, ...videoOpts });
-        const contexts = chromeSession.browser.contexts();
-        context = contexts[0] || await chromeSession.browser.newContext({ viewport, ...videoOpts, acceptDownloads: true });
-      } catch {
-        context = await import_playwright5.chromium.launchPersistentContext(userDataDir, {
-          headless: false,
-          args: persistentArgs,
-          viewport,
-          ...videoOpts,
-          acceptDownloads: true
-        });
-      }
-    } else {
-      context = await import_playwright5.chromium.launchPersistentContext(userDataDir, {
-        headless: false,
-        args: persistentArgs,
-        viewport,
-        ...videoOpts,
-        acceptDownloads: true
-      });
-    }
-  } else {
-    browser = await import_playwright5.chromium.launch({ headless: true });
-    context = await browser.newContext({ viewport, ...videoOpts, ...authOpts, acceptDownloads: true });
-  }
-  return { context, browser, chromeSession };
-}
-async function cleanupBrowserSession(session) {
-  if (session.chromeSession) {
-    await session.chromeSession.cleanup();
-  } else {
-    await session.context.close();
-    if (session.browser) await session.browser.close();
-  }
-}
-
 // src/record.ts
 init_lib();
 
@@ -3953,16 +4433,16 @@ var import_node_path13 = require("path");
 init_utils();
 
 // src/browser/step-validator.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path12 = require("path");
 init_utils();
 function findMediaFile(filename, baseDir) {
   const name = (0, import_node_path12.basename)(filename);
   const searchDirs = [baseDir, (0, import_node_path12.join)(baseDir, "res"), (0, import_node_path12.join)(baseDir, "assets"), (0, import_node_path12.join)(baseDir, "media")];
   for (const dir of searchDirs) {
-    if (!(0, import_node_fs8.existsSync)(dir)) continue;
+    if (!(0, import_node_fs9.existsSync)(dir)) continue;
     try {
-      const files = (0, import_node_fs8.readdirSync)(dir);
+      const files = (0, import_node_fs9.readdirSync)(dir);
       if (files.includes(name)) return (0, import_node_path12.join)(dir, name);
       const match = files.find((f) => f.toLowerCase() === name.toLowerCase());
       if (match) return (0, import_node_path12.join)(dir, match);
@@ -4038,7 +4518,7 @@ function resolveMediaStep(step, baseDir, label, startTime) {
     return { success: false, error: `Missing ${label} path`, executionTimeMs: Date.now() - startTime };
   }
   const specifiedPath = (0, import_node_path12.isAbsolute)(step.value) ? step.value : (0, import_node_path12.resolve)(baseDir, step.value);
-  if ((0, import_node_fs8.existsSync)(specifiedPath)) return { success: true, executionTimeMs: Date.now() - startTime };
+  if ((0, import_node_fs9.existsSync)(specifiedPath)) return { success: true, executionTimeMs: Date.now() - startTime };
   const foundPath = findMediaFile(step.value, baseDir);
   if (foundPath) {
     step.value = `./${foundPath.replace(`${baseDir}/`, "").replace(`${baseDir}\\`, "")}`;
@@ -4160,7 +4640,7 @@ async function validateAndExecuteStep(page, step, plan, baseDir) {
         if (!isPlaceholder) {
           const normalizedPath = rawPath.startsWith("mnt/") ? `/${rawPath}` : rawPath;
           let filePath = (0, import_node_path12.isAbsolute)(normalizedPath) ? normalizedPath : (0, import_node_path12.resolve)(baseDir, normalizedPath);
-          if (!(0, import_node_fs8.existsSync)(filePath)) {
+          if (!(0, import_node_fs9.existsSync)(filePath)) {
             const foundPath = findMediaFile(rawPath, baseDir);
             if (foundPath) {
               const relativePath = `./${foundPath.replace(`${baseDir}/`, "").replace(`${baseDir}\\`, "")}`;
@@ -4324,8 +4804,8 @@ async function validateStepsOnPage(plan, config, logError2, baseDir, onStepStart
 }
 
 // src/browser/meta.ts
-var import_node_fs9 = require("fs");
-var import_promises9 = require("fs/promises");
+var import_node_fs10 = require("fs");
+var import_promises10 = require("fs/promises");
 var import_node_path14 = require("path");
 var RECORDING_FILE = "recording.mp4";
 var RECORDING_META_FILE = "recording.meta.json";
@@ -4334,9 +4814,9 @@ function getRecordingPath(outputDir) {
 }
 async function loadRecordingMeta(outputDir) {
   const metaPath = (0, import_node_path14.join)(outputDir, RECORDING_META_FILE);
-  if (!(0, import_node_fs9.existsSync)(metaPath)) return null;
+  if (!(0, import_node_fs10.existsSync)(metaPath)) return null;
   try {
-    const content = await (0, import_promises9.readFile)(metaPath, "utf-8");
+    const content = await (0, import_promises10.readFile)(metaPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -4344,7 +4824,7 @@ async function loadRecordingMeta(outputDir) {
 }
 async function saveRecordingMeta(outputDir, meta) {
   const metaPath = (0, import_node_path14.join)(outputDir, RECORDING_META_FILE);
-  await (0, import_promises9.writeFile)(metaPath, JSON.stringify(meta, null, 2));
+  await (0, import_promises10.writeFile)(metaPath, JSON.stringify(meta, null, 2));
 }
 function canReuseRecording(plan, config, stepDurations, existingMeta) {
   if (!existingMeta) {
@@ -4414,14 +4894,14 @@ function formatStepLabel(step) {
 }
 async function recordSession(plan, config, stepDurations, workDir, baseDir, task2, logError2) {
   const videoDir = (0, import_node_path15.join)(workDir, "video");
-  await (0, import_promises10.mkdir)(videoDir, { recursive: true });
+  await (0, import_promises11.mkdir)(videoDir, { recursive: true });
   const getStepDuration = (stepNum) => {
     return stepDurations[stepNum - 1] ?? config.timing.minStepDuration;
   };
   const browserTask = task2("Starting browser recording");
   const recordingStartTime = Date.now();
   const userDataDir = (0, import_node_path15.join)(workDir, "browser-data");
-  const recordVideo = { dir: videoDir, size: { width: config.video.width, height: config.video.height } };
+  const recordVideo = { dir: videoDir, size: recordingViewport(config) };
   const authState = findAuthState(plan.url);
   const { context, browser, chromeSession } = await launchBrowserContext(config, userDataDir, recordVideo, authState);
   const page = context.pages()[0] || await context.newPage();
@@ -4442,6 +4922,7 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
   let onMediaPage = firstStepIsMedia;
   const failures = [];
   const actualStepDurations = [];
+  let pageClosedEarly = false;
   for (let i = 0; i < plan.steps.length; i++) {
     const step = plan.steps[i];
     const stepNum = i + 1;
@@ -4468,6 +4949,12 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
       let targetEl = null;
       if (step.target) {
         targetEl = await resolveElement(page, step.target);
+        if (!targetEl) {
+          console.log(
+            `
+    \u26A0 target "${step.target}" not found on page \u2014 step ${stepNum} recorded without the action`
+          );
+        }
       }
       if (step.zoom && step.zoom !== 1 && targetEl && !isExtensionPage) {
         const preZoomBox = await targetEl.boundingBox() ?? void 0;
@@ -4504,11 +4991,19 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
     }
     const stepElapsed = Date.now() - stepStartTime;
     const waitTime = Math.max(0, stepDuration - stepElapsed);
-    if (waitTime > 0) await page.waitForTimeout(waitTime);
     const stepDelay = config.video.stepDelay ?? 500;
     const isLastStep = i === plan.steps.length - 1;
-    if (!isLastStep && stepDelay > 0) {
-      await page.waitForTimeout(stepDelay);
+    try {
+      if (waitTime > 0) await page.waitForTimeout(waitTime);
+      if (!isLastStep && stepDelay > 0) await page.waitForTimeout(stepDelay);
+    } catch (err) {
+      if (page.isClosed()) {
+        console.log(import_chalk6.default.yellow("\n  \u26A0 Browser page closed early \u2014 saving the recording captured so far"));
+        pageClosedEarly = true;
+        actualStepDurations.push(Math.max(stepElapsed, stepDuration));
+        break;
+      }
+      throw err;
     }
     if (!isExtensionPage) {
       const shouldHighlight = step.highlight !== void 0 ? step.highlight : config.video.highlight;
@@ -4526,13 +5021,14 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
       console.log(import_chalk6.default.yellow(`    - ${f}`));
     }
   }
+  while (actualStepDurations.length < plan.steps.length) actualStepDurations.push(0);
   const saveTask = task2("Saving video");
   const video = page.video();
   if (!video) throw new Error("No video recorder available");
-  await page.close();
+  if (!pageClosedEarly) await page.close();
   const videoPath = await video.path();
   await cleanupBrowserSession({ context, browser, chromeSession });
-  if (!videoPath || !(0, import_node_fs10.existsSync)(videoPath)) {
+  if (!videoPath || !(0, import_node_fs11.existsSync)(videoPath)) {
     throw new Error("Video file was not created");
   }
   saveTask.succeed("Video saved");
@@ -4541,8 +5037,8 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
 
 // src/utils/video-pipeline.ts
 var import_video_kit6 = require("@spark-apps/video-kit");
-var import_node_fs11 = require("fs");
-var import_promises11 = require("fs/promises");
+var import_node_fs12 = require("fs");
+var import_promises12 = require("fs/promises");
 var import_node_path16 = require("path");
 var import_chalk7 = __toESM(require("chalk"));
 init_lib();
@@ -4593,7 +5089,7 @@ async function generateASS(plan, stepAudio, workDir, config, captions) {
     currentTime += audio.duration;
   }
   const assPath = (0, import_node_path16.join)(workDir, "subtitles.ass");
-  await (0, import_promises11.writeFile)(assPath, ass);
+  await (0, import_promises12.writeFile)(assPath, ass);
   return assPath;
 }
 function buildVideoOverlays(steps, stepDurations, baseDir) {
@@ -4607,7 +5103,7 @@ function buildVideoOverlays(steps, stepDurations, baseDir) {
       const ext = step.value.split(".").pop()?.toLowerCase() || "";
       if (["mp4", "webm", "mov"].includes(ext)) {
         const mediaPath = (0, import_node_path16.isAbsolute)(step.value) ? step.value : (0, import_node_path16.resolve)(baseDir, step.value);
-        if ((0, import_node_fs11.existsSync)(mediaPath)) {
+        if ((0, import_node_fs12.existsSync)(mediaPath)) {
           const partial = parsePartial(step.partial);
           overlays.push({
             path: mediaPath,
@@ -4636,13 +5132,13 @@ async function composeAndFinish(videoPath, audioPath, assPath, config, userTier
     process.exit(0);
   }
   const composeTask = task("Building final video");
-  await (0, import_promises11.mkdir)(config.output.dir, { recursive: true });
+  await (0, import_promises12.mkdir)(config.output.dir, { recursive: true });
   const suffix = config.lang ? `-${config.lang}` : "";
   const finalPath = (0, import_node_path16.join)(config.output.dir, `demo${suffix}.${config.video.format}`);
   const videoDuration = await getMediaDuration(videoPath) / 1e3;
-  const hasVoiceover = audioPath && (0, import_node_fs11.existsSync)(audioPath);
+  const hasVoiceover = audioPath && (0, import_node_fs12.existsSync)(audioPath);
   const musicPath = config.music?.path ? (0, import_node_path16.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path16.resolve)(config.output.dir, config.music.path) : "";
-  const hasMusic = musicPath && (0, import_node_fs11.existsSync)(musicPath);
+  const hasMusic = musicPath && (0, import_node_fs12.existsSync)(musicPath);
   try {
     await composeVideo({
       videoPath,
@@ -4707,19 +5203,20 @@ var import_chalk9 = __toESM(require("chalk"));
 init_lib();
 
 // src/plan.ts
-var import_promises12 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 var import_node_path17 = require("path");
 var import_chalk8 = __toESM(require("chalk"));
-var import_playwright6 = require("playwright");
+var import_playwright5 = require("playwright");
 init_lib();
+init_json_repair();
 async function crawlExtension(url, extensionPath, workDir, task2) {
   const browserTask = task2("Launching browser with extension");
   const userDataDir = (0, import_node_path17.join)(workDir, ".browser-data");
-  await (0, import_promises12.mkdir)(userDataDir, { recursive: true });
+  await (0, import_promises13.mkdir)(userDataDir, { recursive: true });
   let context;
   let chromeSession = null;
   const useWindowsChrome = isWSL() && tryEnableWSLInterop();
-  const launchPersistent = () => import_playwright6.chromium.launchPersistentContext(userDataDir, {
+  const launchPersistent = () => import_playwright5.chromium.launchPersistentContext(userDataDir, {
     headless: false,
     args: [
       `--disable-extensions-except=${extensionPath}`,
@@ -4800,7 +5297,7 @@ async function crawlExtension(url, extensionPath, workDir, task2) {
     else if (el.type === "select" || el.type === "select-one") action = "select";
     else if (el.type === "checkbox") action = "check";
     else if (["text", "email", "password", "number", "search", "url", "tel"].includes(el.type)) action = "type";
-    const selector = el.id ? `#${el.id}` : el.name ? `[name="${el.name}"]` : `text="${el.text}"`;
+    const selector = el.id ? idSelector(el.id) : el.name ? `[name="${el.name}"]` : `text="${el.text}"`;
     return {
       type: el.type === "button" || el.type === "link" ? el.type : "input",
       text: el.text,
@@ -4812,31 +5309,8 @@ async function crawlExtension(url, extensionPath, workDir, task2) {
   crawlTask.succeed(`Found ${elements.length} interactive elements`);
   return { title, elements };
 }
-var JSON_FIX_SYSTEM_PROMPT = "You fix malformed JSON. Return ONLY valid JSON, no explanation.";
-var jsonFixUserPrompt = (content) => `Fix this malformed JSON plan. Return ONLY valid JSON, no explanation.
-The JSON should have: url, title, description, steps array.
-Each step has: id (number), action, caption, and optionally target, value.
-
-Malformed content:
-${content}`;
 async function parsePlanJson(content, task2, logError2, userEmail, tier = "free") {
-  try {
-    return JSON.parse(content);
-  } catch {
-    const fixTask = task2("Fixing malformed JSON");
-    try {
-      const fixed = await callGroq(JSON_FIX_SYSTEM_PROMPT, jsonFixUserPrompt(content), logError2, userEmail, tier);
-      const jsonMatch = fixed.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) throw new Error("No JSON in fix");
-      const plan = JSON.parse(jsonMatch[0]);
-      fixTask.succeed("JSON fixed by AI");
-      return plan;
-    } catch (err) {
-      await logError2("JSON Fix", err);
-      fixTask.fail("Could not fix JSON");
-      throw new Error(`Malformed JSON: ${getErrorMessage(err)}`);
-    }
-  }
+  return parseAIJsonWithRepair(content, { logError: logError2, task: task2, userEmail, tier });
 }
 async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError2, userEmail, extensionPath, workDir, tier = "free", viewport) {
   const { title, elements, scrollable } = extensionPath && workDir ? { ...await crawlExtension(url, extensionPath, workDir, task2), scrollable: void 0 } : await crawlPage(url, task2, findAuthState(url), viewport);
@@ -4845,10 +5319,9 @@ async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError
   const systemPrompt = buildSystemPrompt(maxSteps);
   const userPrompt = buildUserPrompt(url, title, elements, langName, description, maxSteps, scrollable);
   try {
-    const content = await callGroq(systemPrompt, userPrompt, logError2, userEmail, tier);
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) throw new Error("No JSON found in response");
-    const plan = await parsePlanJson(jsonMatch[0], task2, logError2, userEmail, tier);
+    const content = await callGroq(systemPrompt, userPrompt, logError2, userEmail, tier, "plan");
+    const plan = await parsePlanJson(content, task2, logError2, userEmail, tier);
+    if (!Array.isArray(plan.steps)) throw new Error("AI response has no steps array");
     if (lang !== void 0) plan.lang = lang;
     plan.steps = plan.steps.map(({ duration, ...s }, i) => ({
       ...s,
@@ -4865,7 +5338,7 @@ async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError
   }
 }
 async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier = "free") {
-  const content = await (0, import_promises12.readFile)(planPath, "utf-8");
+  const content = await (0, import_promises13.readFile)(planPath, "utf-8");
   const plan = await parsePlanJson(content, task2, logError2, userEmail, tier);
   if (!plan.url || !plan.steps || !Array.isArray(plan.steps)) {
     throw new Error("Invalid plan: missing url or steps");
@@ -4898,7 +5371,7 @@ async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier =
     renumberTask.fail("No valid steps");
     throw new Error("Plan has no valid steps");
   }
-  await (0, import_promises12.writeFile)(planPath, JSON.stringify(plan, null, 2));
+  await (0, import_promises13.writeFile)(planPath, JSON.stringify(plan, null, 2));
   const removed = originalCount - plan.steps.length;
   renumberTask.succeed(
     removed > 0 ? `${plan.steps.length} steps (${removed} removed)` : `${plan.steps.length} steps validated`
@@ -5013,6 +5486,21 @@ function getOutputDirFromUrl(url) {
 
 // src/commands/phases/video-phase.ts
 var INDENT4 = "   ";
+function resolveOutro(config, userTier) {
+  if (userTier !== "free") {
+    const custom = config.video.outro?.trim();
+    if (!custom) return void 0;
+    const path = (0, import_node_path18.resolve)(custom);
+    if ((0, import_node_fs13.existsSync)(path)) return path;
+    info(`${INDENT4}\u26A0 outro not found: ${path}`);
+    return void 0;
+  }
+  const scriptDir = getScriptDir();
+  const bundled = (0, import_node_path18.join)(scriptDir, "assets", "qp.wm");
+  if ((0, import_node_fs13.existsSync)(bundled)) return bundled;
+  const fallback = (0, import_node_path18.join)(scriptDir, "..", "dist", "assets", "qp.wm");
+  return (0, import_node_fs13.existsSync)(fallback) ? fallback : void 0;
+}
 async function runVideoPhase(params) {
   let { stepAudio } = params;
   const { plan, config, voiceoverPath, workDir, captions, userTier } = params;
@@ -5031,7 +5519,7 @@ async function runVideoPhase(params) {
               mediaDuration = (trimEnd - trimStart2) * 1e3;
             } else {
               const mediaPath = (0, import_node_path18.resolve)(s.value);
-              if ((0, import_node_fs12.existsSync)(mediaPath)) {
+              if ((0, import_node_fs13.existsSync)(mediaPath)) {
                 try {
                   const fullDuration = await getMediaDuration(mediaPath);
                   const start = (trimStart2 ?? 0) * 1e3;
@@ -5043,7 +5531,7 @@ async function runVideoPhase(params) {
             }
           } else {
             const mediaPath = (0, import_node_path18.resolve)(s.value);
-            if ((0, import_node_fs12.existsSync)(mediaPath)) {
+            if ((0, import_node_fs13.existsSync)(mediaPath)) {
               try {
                 mediaDuration = await getMediaDuration(mediaPath);
               } catch {
@@ -5056,7 +5544,7 @@ async function runVideoPhase(params) {
     })
   );
   const recordingPath = getRecordingPath(config.output.dir);
-  const hasExistingRecording = existingRecordingMeta && (0, import_node_fs12.existsSync)(recordingPath);
+  const hasExistingRecording = existingRecordingMeta && (0, import_node_fs13.existsSync)(recordingPath);
   let videoPath = recordingPath;
   const firstStep = plan.steps[0];
   const firstStepIsVideo = firstStep && (firstStep.action === "video" || firstStep.action === "media");
@@ -5065,7 +5553,7 @@ async function runVideoPhase(params) {
     header("Record");
     const result = await recordSession(plan, config, stepDurations, workDir, config.output.dir, task, logError);
     stepAudio = await alignVoiceoverToRecording(stepAudio, result.actualStepDurations, workDir, config.output.dir);
-    await (0, import_promises13.copyFile)(result.videoPath, recordingPath);
+    await (0, import_promises14.copyFile)(result.videoPath, recordingPath);
     const meta = buildRecordingMeta(plan, config, result.actualStepDurations);
     meta.pageLoadTime = result.pageLoadTime;
     await saveRecordingMeta(config.output.dir, meta);
@@ -5117,7 +5605,7 @@ async function runVideoPhase(params) {
     const transitionTask = task("Applying transitions");
     try {
       const transitionedPath = (0, import_node_path18.join)(workDir, "transitioned.mp4");
-      const videoDuration = alignedStepDurations.reduce((a, b) => a + b, 0) / 1e3;
+      const videoDuration = await getMediaDuration(videoPath) / 1e3;
       await applyTransitions({
         inputVideo: videoPath,
         outputVideo: transitionedPath,
@@ -5135,30 +5623,24 @@ async function runVideoPhase(params) {
   const assPath = await generateASS(plan, stepAudio, workDir, config, captions);
   let videoToCompose = videoPath;
   let mainContentDuration;
-  if (userTier === "free") {
-    const scriptDir = getScriptDir();
-    let outroPath = (0, import_node_path18.join)(scriptDir, "assets", "qp.wm");
-    if (!(0, import_node_fs12.existsSync)(outroPath)) {
-      outroPath = (0, import_node_path18.join)(scriptDir, "..", "dist", "assets", "qp.wm");
-    }
-    if ((0, import_node_fs12.existsSync)(outroPath)) {
-      try {
-        const mainDuration = await getMediaDuration(videoPath);
-        mainContentDuration = mainDuration / 1e3 - trimStart;
-        const combinedPath = (0, import_node_path18.join)(workDir, "combined-with-outro.mp4");
-        await concatVideoWithOutro({
-          inputPath: videoPath,
-          outroPath,
-          outputPath: combinedPath,
-          width: config.video.width,
-          height: config.video.height,
-          preset: config.video.preset
-        });
-        videoToCompose = combinedPath;
-      } catch (err) {
-        await logError("Concat Outro", err);
-        mainContentDuration = void 0;
-      }
+  const outroPath = resolveOutro(config, userTier);
+  if (outroPath) {
+    try {
+      const mainDuration = await getMediaDuration(videoPath);
+      mainContentDuration = mainDuration / 1e3 - trimStart;
+      const combinedPath = (0, import_node_path18.join)(workDir, "combined-with-outro.mp4");
+      await concatVideoWithOutro({
+        inputPath: videoPath,
+        outroPath,
+        outputPath: combinedPath,
+        width: config.video.width,
+        height: config.video.height,
+        preset: config.video.preset
+      });
+      videoToCompose = combinedPath;
+    } catch (err) {
+      await logError("Concat Outro", err);
+      mainContentDuration = void 0;
     }
   }
   let finalPath = await composeAndFinish(
@@ -5192,7 +5674,7 @@ async function runVideoPhase(params) {
 }
 
 // src/commands/phases/voiceover-phase.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_node_path19 = require("path");
 var import_chalk10 = __toESM(require("chalk"));
 init_lib();
@@ -5202,9 +5684,9 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
     const filesToDelete = ["voiceover.json", "voiceover.wav", "recording.meta.json"];
     for (const file of filesToDelete) {
       const filePath = (0, import_node_path19.join)(config.output.dir, file);
-      if ((0, import_node_fs13.existsSync)(filePath)) {
-        const { unlink: unlink3 } = await import("fs/promises");
-        await unlink3(filePath).catch(() => {
+      if ((0, import_node_fs14.existsSync)(filePath)) {
+        const { unlink: unlink4 } = await import("fs/promises");
+        await unlink4(filePath).catch(() => {
         });
       }
     }
@@ -5213,7 +5695,12 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
   const voice = resolveVoice(config);
   const existingMeta = await loadVoiceoverMeta(config.output.dir);
   const voiceoverFile = (0, import_node_path19.join)(config.output.dir, "voiceover.wav");
-  const hasExistingVoiceover = existingMeta && (0, import_node_fs13.existsSync)(voiceoverFile);
+  const voiceoverOnDisk = existingMeta && (0, import_node_fs14.existsSync)(voiceoverFile);
+  const staleContainer = voiceoverOnDisk ? !await isHonestWav(voiceoverFile) : false;
+  if (staleContainer) {
+    info("Existing voiceover has a stale container, regenerating");
+  }
+  const hasExistingVoiceover = voiceoverOnDisk && !staleContainer;
   const voiceMatches = !existingMeta || !voice || existingMeta.voice === voice;
   let voiceoverPath;
   let stepAudio;
@@ -5303,7 +5790,8 @@ async function captureCommand(url, lang) {
       lang,
       logError,
       userData.email,
-      captureResult.pageContext
+      captureResult.pageContext,
+      userData.tier ?? "free"
     );
     narrateTask.succeed(`${steps.length} captions generated`);
   } catch (err) {
@@ -5348,7 +5836,7 @@ async function captureCommand(url, lang) {
 }
 
 // src/commands/edit-cmd.ts
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 var import_node_path21 = require("path");
 var import_chalk12 = __toESM(require("chalk"));
 
@@ -5463,10 +5951,10 @@ var PLAN_FILE = /^plan-([a-z]{2}(?:-[A-Z]{2})?)\.json$/;
 function findPlanFile(dir, lang) {
   if (lang) {
     const exact = (0, import_node_path21.join)(dir, `plan-${lang}.json`);
-    return (0, import_node_fs14.existsSync)(exact) ? exact : null;
+    return (0, import_node_fs15.existsSync)(exact) ? exact : null;
   }
-  if (!(0, import_node_fs14.existsSync)(dir)) return null;
-  const plans = (0, import_node_fs14.readdirSync)(dir).filter((f) => PLAN_FILE.test(f));
+  if (!(0, import_node_fs15.existsSync)(dir)) return null;
+  const plans = (0, import_node_fs15.readdirSync)(dir).filter((f) => PLAN_FILE.test(f));
   const preferred = plans.find((f) => f === "plan-en.json") ?? plans[0];
   return preferred ? (0, import_node_path21.join)(dir, preferred) : null;
 }
@@ -5481,7 +5969,7 @@ async function editCommand(url, lang) {
     console.log();
     return;
   }
-  const parsed = parsePlanText((0, import_node_fs14.readFileSync)(planPath, "utf8"));
+  const parsed = parsePlanText((0, import_node_fs15.readFileSync)(planPath, "utf8"));
   if (!parsed.ok) {
     console.log(import_chalk12.default.red(`  ${planPath} cannot be opened: ${parsed.error}`));
     console.log();
@@ -5504,14 +5992,14 @@ async function editCommand(url, lang) {
 }
 
 // src/commands/init-cmd.ts
-var import_node_fs15 = require("fs");
-var import_promises14 = require("fs/promises");
+var import_node_fs16 = require("fs");
+var import_promises15 = require("fs/promises");
 var import_node_path22 = require("path");
 var import_chalk13 = __toESM(require("chalk"));
 init_lib();
 async function initCommand() {
   const configPath = (0, import_node_path22.join)(process.cwd(), CONFIG_FILE);
-  if ((0, import_node_fs15.existsSync)(configPath)) {
+  if ((0, import_node_fs16.existsSync)(configPath)) {
     console.log(import_chalk13.default.yellow(`  \u26A0 ${CONFIG_FILE} already exists`));
     return;
   }
@@ -5535,7 +6023,7 @@ async function initCommand() {
       volume: 0.3
     }
   };
-  await (0, import_promises14.writeFile)(configPath, `${JSON.stringify(defaultConfig, null, 2)}
+  await (0, import_promises15.writeFile)(configPath, `${JSON.stringify(defaultConfig, null, 2)}
 `);
   console.log(import_chalk13.default.green(`  \u2714 Created ${CONFIG_FILE}`));
   console.log(import_chalk13.default.dim(`  Edit it or use: qp config <key> <value>`));
@@ -5543,11 +6031,11 @@ async function initCommand() {
 async function configCommand(key, value) {
   const configPath = (0, import_node_path22.join)(process.cwd(), CONFIG_FILE);
   if (!key) {
-    if (!(0, import_node_fs15.existsSync)(configPath)) {
+    if (!(0, import_node_fs16.existsSync)(configPath)) {
       console.log(import_chalk13.default.yellow(`  No ${CONFIG_FILE} found. Run: qp init`));
       return;
     }
-    const content = await (0, import_promises14.readFile)(configPath, "utf-8");
+    const content = await (0, import_promises15.readFile)(configPath, "utf-8");
     console.log(import_chalk13.default.cyan(`  ${CONFIG_FILE}:`));
     console.log(content);
     return;
@@ -5558,9 +6046,9 @@ async function configCommand(key, value) {
     return;
   }
   let config = {};
-  if ((0, import_node_fs15.existsSync)(configPath)) {
+  if ((0, import_node_fs16.existsSync)(configPath)) {
     try {
-      config = JSON.parse(await (0, import_promises14.readFile)(configPath, "utf-8"));
+      config = JSON.parse(await (0, import_promises15.readFile)(configPath, "utf-8"));
     } catch {
     }
   }
@@ -5582,7 +6070,7 @@ async function configCommand(key, value) {
     }
     obj[keys[keys.length - 1]] = parsedValue;
   }
-  await (0, import_promises14.writeFile)(configPath, `${JSON.stringify(config, null, 2)}
+  await (0, import_promises15.writeFile)(configPath, `${JSON.stringify(config, null, 2)}
 `);
   console.log(import_chalk13.default.green(`  \u2714 Set ${key} = ${value}`));
 }
@@ -5648,8 +6136,8 @@ async function logoutCommand() {
 }
 
 // src/commands/record-cmd.ts
-var import_node_fs18 = require("fs");
-var import_promises17 = require("fs/promises");
+var import_node_fs19 = require("fs");
+var import_promises18 = require("fs/promises");
 var import_node_path25 = require("path");
 var import_chalk19 = __toESM(require("chalk"));
 init_lib();
@@ -5824,18 +6312,18 @@ async function runAuthPhase(input) {
 }
 
 // src/commands/phases/plan-phase.ts
-var import_node_fs16 = require("fs");
-var import_promises15 = require("fs/promises");
+var import_node_fs17 = require("fs");
+var import_promises16 = require("fs/promises");
 var import_node_path23 = require("path");
 var import_chalk17 = __toESM(require("chalk"));
 
 // src/ai/fix.ts
 init_lib();
 async function callGroqAndFinalize(systemPrompt, userMessage, plan, logError2, userEmail, tier = "free") {
-  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier);
-  const jsonMatch = content.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error("No JSON in AI response");
-  return finalizePlan(JSON.parse(jsonMatch[0]), plan);
+  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier, "fix");
+  const result = await parseAIJsonWithRepair(content, { logError: logError2, userEmail, tier, context: "Plan Fix" });
+  if (!Array.isArray(result.steps)) throw new Error("AI response has no steps array");
+  return finalizePlan(result, plan);
 }
 function finalizePlan(result, original) {
   result.url = original.url;
@@ -5959,10 +6447,15 @@ async function translatePlan(plan, targetLang, logError2, userEmail, tier = "fre
 ${JSON.stringify(toTranslate)}
 
 Return ONLY JSON: {"description": "...", "captions": ["...", ...]}`;
-  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier);
-  const jsonMatch = content.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error("No JSON in translation response");
-  const translated = JSON.parse(jsonMatch[0]);
+  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier, "fix");
+  const translated = await parseAIJsonWithRepair(content, {
+    logError: logError2,
+    userEmail,
+    tier,
+    shape: "The JSON should have: description (string), captions (array of strings).",
+    context: "Translate Plan"
+  });
+  if (!Array.isArray(translated.captions)) throw new Error("Translation response has no captions array");
   const translatedPlan = JSON.parse(JSON.stringify(plan));
   translatedPlan.title = plan.title;
   translatedPlan.description = translated.description || plan.description;
@@ -5994,9 +6487,9 @@ async function runPlanPhase(params) {
   const extensionPath = config.browser?.extension;
   let existingPlan = null;
   let existingPlanPath = null;
-  if ((0, import_node_fs16.existsSync)(planPath)) {
+  if ((0, import_node_fs17.existsSync)(planPath)) {
     try {
-      const parsed = JSON.parse(await (0, import_promises15.readFile)(planPath, "utf-8"));
+      const parsed = JSON.parse(await (0, import_promises16.readFile)(planPath, "utf-8"));
       if (parsed.url && parsed.steps?.length > 0) {
         existingPlan = parsed;
         existingPlanPath = planPath;
@@ -6006,12 +6499,12 @@ async function runPlanPhase(params) {
   }
   if (!existingPlan) {
     try {
-      const files = (0, import_node_fs16.readdirSync)(config.output.dir);
+      const files = (0, import_node_fs17.readdirSync)(config.output.dir);
       const planFiles = files.filter((f) => /^plan-[a-z]{2}(-[A-Z]{2})?\.json$/.test(f) && f !== (0, import_node_path23.basename)(planPath));
       for (const file of planFiles) {
         const filePath = (0, import_node_path23.join)(config.output.dir, file);
         try {
-          const parsed = JSON.parse(await (0, import_promises15.readFile)(filePath, "utf-8"));
+          const parsed = JSON.parse(await (0, import_promises16.readFile)(filePath, "utf-8"));
           if (parsed.url && parsed.steps?.length > 0) {
             existingPlan = parsed;
             existingPlanPath = filePath;
@@ -6023,9 +6516,9 @@ async function runPlanPhase(params) {
     } catch {
     }
   }
-  if (!existingPlan && (0, import_node_fs16.existsSync)(legacyPlanPath)) {
+  if (!existingPlan && (0, import_node_fs17.existsSync)(legacyPlanPath)) {
     try {
-      const parsed = JSON.parse(await (0, import_promises15.readFile)(legacyPlanPath, "utf-8"));
+      const parsed = JSON.parse(await (0, import_promises16.readFile)(legacyPlanPath, "utf-8"));
       if (parsed.url && parsed.steps?.length > 0) {
         existingPlan = parsed;
         existingPlanPath = legacyPlanPath;
@@ -6035,6 +6528,11 @@ async function runPlanPhase(params) {
   }
   const normalizeUrl4 = (u) => u.replace(/\/+$/, "").toLowerCase();
   const urlMatches = existingPlan && normalizeUrl4(existingPlan.url) === normalizeUrl4(url);
+  if (existingPlan && !urlMatches && isAutoYes()) {
+    console.log();
+    console.log(import_chalk17.default.dim(`  Existing plan is for ${existingPlan.url}, not ${url} \u2014 regenerating.`));
+    existingPlan = null;
+  }
   let plan;
   const doTranslate = async (failMsg) => {
     const translateTask = task(`Translating to ${targetLang}`);
@@ -6168,9 +6666,9 @@ async function runPlanPhase(params) {
   const planLang = plan.lang || "en";
   if (planLang !== targetLang) {
     let useExistingTranslation = false;
-    if ((0, import_node_fs16.existsSync)(planPath) && existingPlanPath !== planPath) {
+    if ((0, import_node_fs17.existsSync)(planPath) && existingPlanPath !== planPath) {
       try {
-        const translatedPlan = JSON.parse(await (0, import_promises15.readFile)(planPath, "utf-8"));
+        const translatedPlan = JSON.parse(await (0, import_promises16.readFile)(planPath, "utf-8"));
         if (translatedPlan.steps?.length === plan.steps.length && translatedPlan.lang === targetLang) {
           console.log();
           console.log(import_chalk17.default.dim(`  Found translated plan: ${formatClickablePath(planPath)}`));
@@ -6194,7 +6692,7 @@ async function runPlanPhase(params) {
 }
 
 // src/commands/phases/validation-phase.ts
-var import_promises16 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 var import_chalk18 = __toESM(require("chalk"));
 async function runValidationPhase(params) {
   let { plan } = params;
@@ -6321,7 +6819,7 @@ async function runValidationPhase(params) {
       console.log(import_chalk18.default.yellow(`  Skipping step ${stepNum} - may fail during recording`));
       continue;
     }
-    plan = JSON.parse(await (0, import_promises16.readFile)(planPath, "utf-8"));
+    plan = JSON.parse(await (0, import_promises17.readFile)(planPath, "utf-8"));
     const finalRevalidateTask = task(`Final validation of step ${stepNum}`);
     const finalRevalidation = await validateStepsOnPage(plan, config, logError, config.output.dir);
     const finalResult = finalRevalidation.results[result.stepIndex];
@@ -6345,7 +6843,7 @@ async function runValidationPhase(params) {
 }
 
 // src/commands/utils/chrome-extension.ts
-var import_node_fs17 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_os3 = require("os");
 var import_node_path24 = require("path");
 function resolveChromeExtension(extensionId) {
@@ -6354,7 +6852,7 @@ function resolveChromeExtension(extensionId) {
   const getChromeExtDirs = (userDataPath) => {
     const dirs = [];
     try {
-      const profiles = (0, import_node_fs17.readdirSync)(userDataPath).filter((p) => p === "Default" || p.startsWith("Profile "));
+      const profiles = (0, import_node_fs18.readdirSync)(userDataPath).filter((p) => p === "Default" || p.startsWith("Profile "));
       for (const profile of profiles) {
         dirs.push((0, import_node_path24.join)(userDataPath, profile, "Extensions"));
       }
@@ -6369,7 +6867,7 @@ function resolveChromeExtension(extensionId) {
     possibleDirs.push(...getChromeExtDirs((0, import_node_path24.join)((0, import_node_os3.homedir)(), "Library", "Application Support", "Google", "Chrome")));
   } else {
     try {
-      const windowsUsers = (0, import_node_fs17.readdirSync)("/mnt/c/Users").filter(
+      const windowsUsers = (0, import_node_fs18.readdirSync)("/mnt/c/Users").filter(
         (u) => !["All Users", "Default", "Default User", "Public", "desktop.ini"].includes(u)
       );
       for (const user of windowsUsers) {
@@ -6381,18 +6879,18 @@ function resolveChromeExtension(extensionId) {
   }
   for (const chromeExtDir of possibleDirs) {
     const extDir = (0, import_node_path24.join)(chromeExtDir, extensionId);
-    if (!(0, import_node_fs17.existsSync)(extDir)) continue;
+    if (!(0, import_node_fs18.existsSync)(extDir)) continue;
     try {
-      const versions = (0, import_node_fs17.readdirSync)(extDir).filter((f) => !f.startsWith("."));
+      const versions = (0, import_node_fs18.readdirSync)(extDir).filter((f) => !f.startsWith("."));
       if (versions.length === 0) continue;
       const latestVersion = versions.sort().pop();
       const extPath = (0, import_node_path24.join)(extDir, latestVersion);
       let name = extensionId;
       let popupPath = "popup.html";
       const manifestPath = (0, import_node_path24.join)(extPath, "manifest.json");
-      if ((0, import_node_fs17.existsSync)(manifestPath)) {
+      if ((0, import_node_fs18.existsSync)(manifestPath)) {
         try {
-          const manifest = JSON.parse((0, import_node_fs17.readFileSync)(manifestPath, "utf-8"));
+          const manifest = JSON.parse((0, import_node_fs18.readFileSync)(manifestPath, "utf-8"));
           if (manifest.name && !manifest.name.startsWith("__MSG_")) {
             name = manifest.name;
           }
@@ -6434,6 +6932,13 @@ async function recordCommand(url, options = {}) {
     console.log(import_chalk19.default.dim(`  Extension: ${chromeExtension.name}`));
     console.log(import_chalk19.default.dim(`  Path: ${chromeExtension.path}`));
   }
+  if (!chromeExtension) {
+    const startUrl = resolveStartUrl(url);
+    if (startUrl !== url) {
+      console.log(import_chalk19.default.dim(`  Signed-in start page: ${startUrl}`));
+      url = startUrl;
+    }
+  }
   config.output.dir = chromeExtension ? `./${chromeExtension.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}-demo` : getOutputDirFromUrl(url);
   const userData = await loadUserData();
   const authResult = await runAuthPhase({
@@ -6467,7 +6972,7 @@ async function recordCommand(url, options = {}) {
   if (langOverride) config.lang = langOverride;
   if (config.music?.path) {
     const musicPath = (0, import_node_path25.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path25.resolve)(config.output.dir, config.music.path);
-    if (!(0, import_node_fs18.existsSync)(musicPath)) {
+    if (!(0, import_node_fs19.existsSync)(musicPath)) {
       console.log();
       console.log(import_chalk19.default.yellow(`  \u26A0 Music file not found: ${config.music.path}`));
       console.log(import_chalk19.default.dim(`    Config: ${(0, import_node_path25.join)(process.cwd(), CONFIG_FILE)}`));
@@ -6489,7 +6994,7 @@ async function recordCommand(url, options = {}) {
   const planPath = (0, import_node_path25.join)(config.output.dir, `plan-${targetLang}.json`);
   const legacyPlanPath = (0, import_node_path25.join)(config.output.dir, "plan.json");
   const isExtensionUrl = url.startsWith("chrome-extension://");
-  await (0, import_promises17.mkdir)(config.output.dir, { recursive: true });
+  await (0, import_promises18.mkdir)(config.output.dir, { recursive: true });
   await setLogFilePath(config.output.dir);
   try {
     const plan = await runPlanPhase({
@@ -6546,31 +7051,67 @@ async function recordCommand(url, options = {}) {
 }
 
 // src/commands/script-cmd.ts
-var import_promises18 = require("fs/promises");
+var import_promises19 = require("fs/promises");
 var import_node_path26 = require("path");
 var import_chalk20 = __toESM(require("chalk"));
 init_lib();
+async function reusablePlan(planPath, lines) {
+  try {
+    const plan = JSON.parse(await (0, import_promises19.readFile)(planPath, "utf-8"));
+    if (!Array.isArray(plan.steps)) return null;
+    if (plan.steps.length < lines.length) return null;
+    const matches = lines.every((line, i) => plan.steps[i]?.caption === line);
+    return matches ? plan : null;
+  } catch {
+    return null;
+  }
+}
 async function scriptCommand(url, scriptPath, lang) {
+  url = resolveStartUrl(url);
   const { config, workDir, captions } = await initCommandEnv(url, lang);
+  const userData = await loadUserData();
+  const userTier = userData.email ? await getTierByEmail(userData.email) : "free";
   header("Script");
-  const raw = await (0, import_promises18.readFile)(scriptPath, "utf-8");
+  const raw = await (0, import_promises19.readFile)(scriptPath, "utf-8");
   const lines = raw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
   if (lines.length === 0) {
     console.log(import_chalk20.default.red("  Script file is empty or has no non-comment lines"));
     process.exit(1);
   }
   info(`${lines.length} captions from script`);
+  const maxSteps = config.plan?.maxSteps ?? 8;
+  if (lines.length > maxSteps) {
+    console.log(
+      import_chalk20.default.yellow(`  \u26A0 ${lines.length} script lines exceeds plan.maxSteps (${maxSteps}) \u2014 recording all of them.`)
+    );
+    console.log(import_chalk20.default.dim(`    Raise plan.maxSteps in quickpeek.config.json to silence this, or split the script.`));
+  }
   header("Analyze");
   const crawlTask = task("Crawling page for UI elements");
-  const { elements } = await crawlPage(url, () => crawlTask);
+  const { elements } = await crawlPage(url, () => crawlTask, findAuthState(url));
   const elementsText = elements.slice(0, 30).map((e) => `  ${e.action}: ${e.text} (${e.selector})`).join("\n");
   header("Plan");
   const planTask = task("Mapping script to UI actions");
   const appTitle = new URL(url).hostname.replace(/^www\./, "");
-  const plan = await generatePlanFromScript(lines, url, appTitle, elementsText, lang, logError);
   const planPath = (0, import_node_path26.join)(config.output.dir, `plan-${lang ?? "en"}.json`);
-  await savePlan(plan, planPath);
-  planTask.succeed(`${plan.steps.length} steps planned`);
+  let plan = await reusablePlan(planPath, lines);
+  if (plan) {
+    planTask.succeed(`${plan.steps.length} steps reused from existing plan`);
+  } else {
+    plan = await generatePlanFromScript(
+      lines,
+      url,
+      appTitle,
+      elementsText,
+      lang,
+      logError,
+      userData.email,
+      userTier,
+      () => planTask
+    );
+    await savePlan(plan, planPath);
+    planTask.succeed(`${plan.steps.length} steps planned`);
+  }
   header("Voiceover");
   const { voiceoverPath, stepAudio } = await generateVoiceover(
     plan.steps,
@@ -6586,7 +7127,7 @@ async function scriptCommand(url, scriptPath, lang) {
   const { videoPath } = await recordSession(plan, config, stepDurations, workDir, config.output.dir, task, logError);
   header("Compose");
   const assPath = await generateASS(plan, stepAudio, workDir, config, captions);
-  const finalPath = await composeAndFinish(videoPath, voiceoverPath, assPath, config, "free");
+  const finalPath = await composeAndFinish(videoPath, voiceoverPath, assPath, config, userTier);
   console.log();
   console.log(import_chalk20.default.bold.green("  Done!"));
   console.log(import_chalk20.default.cyan(`  ${finalPath}`));
@@ -6696,7 +7237,9 @@ function parseArgs(args) {
   let fresh = false;
   for (let i = 0; i < args.length; i++) {
     const arg2 = args[i];
-    if (arg2.startsWith("lang=")) {
+    if (!url && (arg2.startsWith("http://") || arg2.startsWith("https://"))) {
+      url = normalizeUrl3(arg2);
+    } else if (arg2.startsWith("lang=")) {
       lang = arg2.slice(5);
     } else if (arg2 === "--script" || arg2 === "-s") {
       scriptPath = args[i + 1];