demo-dev 0.0.1-alpha.0

package/dist/index.js

@@ -0,0 +1,2116 @@
+// src/capture/continuous-capture.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { join } from "path";
+import { chromium } from "playwright";
+import { createCursor } from "ghost-cursor-playwright";
+
+// src/browser/session.ts
+import { access, mkdir } from "fs/promises";
+import { dirname } from "path";
+var fileExists = async (path) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var resolveSessionConfig = (outputDir) => {
+  const storageStatePath = process.env.DEMO_STORAGE_STATE;
+  const saveStorageStatePath = process.env.DEMO_SAVE_STORAGE_STATE ?? `${outputDir}/storage-state.json`;
+  return { storageStatePath, saveStorageStatePath };
+};
+var getContextOptionsWithSession = async (contextOptions, session) => {
+  if (session.storageStatePath && await fileExists(session.storageStatePath)) {
+    return {
+      ...contextOptions,
+      storageState: session.storageStatePath
+    };
+  }
+  return contextOptions;
+};
+var persistSessionState = async (page, session) => {
+  if (!session.saveStorageStatePath) return;
+  await mkdir(dirname(session.saveStorageStatePath), { recursive: true }).catch(() => void 0);
+  await page.context().storageState({ path: session.saveStorageStatePath }).catch(() => void 0);
+};
+
+// src/capture/continuous-capture.ts
+var stripBadge = (text) => text.replace(/\d+\s*$/, "").trim();
+var resolveLocatorExact = (page, target) => {
+  switch (target.strategy) {
+    case "label":
+      return page.getByLabel(target.value, { exact: target.exact });
+    case "text":
+      return page.getByText(target.value, { exact: target.exact });
+    case "placeholder":
+      return page.getByPlaceholder(target.value, { exact: target.exact });
+    case "testId":
+      return page.getByTestId(target.value);
+    case "css":
+      return page.locator(target.value);
+    case "role":
+      return page.getByRole(target.role, {
+        name: target.name,
+        exact: target.exact
+      });
+  }
+};
+var resolveLocator = (page, target) => {
+  const exact = resolveLocatorExact(page, target);
+  let result = exact;
+  if (target.strategy === "text" || target.strategy === "label") {
+    const stripped = stripBadge(target.value);
+    if (stripped !== target.value && stripped.length > 0) {
+      result = result.or(
+        target.strategy === "text" ? page.getByText(stripped, { exact: false }) : page.getByLabel(stripped, { exact: false })
+      );
+    }
+    if (target.exact) {
+      result = result.or(
+        target.strategy === "text" ? page.getByText(target.value, { exact: false }) : page.getByLabel(target.value, { exact: false })
+      );
+    }
+  }
+  if (target.strategy === "role" && target.name) {
+    const stripped = stripBadge(target.name);
+    if (stripped !== target.name && stripped.length > 0) {
+      result = result.or(
+        page.getByRole(target.role, { name: stripped, exact: false })
+      );
+    }
+    result = result.or(page.getByText(target.name, { exact: false }));
+    if (stripped !== target.name) {
+      result = result.or(page.getByText(stripped, { exact: false }));
+    }
+  }
+  return result;
+};
+var humanDelay = (baseMs, jitter = 0.4) => {
+  const factor = 1 + (Math.random() * 2 - 1) * jitter;
+  return Math.max(50, Math.round(baseMs * factor));
+};
+var boxForAction = async (page, action) => {
+  const getBox = async (locator) => {
+    const box = await locator.first().boundingBox().catch(() => null);
+    if (!box) return void 0;
+    return {
+      x: box.x + box.width / 2,
+      y: box.y + box.height / 2,
+      width: box.width,
+      height: box.height
+    };
+  };
+  switch (action.type) {
+    case "click":
+    case "hover":
+    case "fill":
+    case "select":
+    case "dragSelect":
+      return getBox(resolveLocator(page, action.target));
+    case "scrollIntoView":
+      return getBox(resolveLocator(page, action.target));
+    case "waitForText":
+      return getBox(page.getByText(action.value, { exact: action.exact }));
+    default:
+      return void 0;
+  }
+};
+var CURSOR_TRACKER_SCRIPT = `
+(() => {
+  if (window.__cursorTrackerInstalled) return;
+  window.__cursorTrackerInstalled = true;
+  window.__cursorSamples = [];
+  window.__cursorTrackingStart = Date.now();
+  let lastX = 0, lastY = 0;
+
+  document.addEventListener('mousemove', (e) => {
+    lastX = e.clientX;
+    lastY = e.clientY;
+  }, { passive: true });
+
+  const tick = () => {
+    window.__cursorSamples.push({
+      atMs: Date.now() - window.__cursorTrackingStart,
+      x: lastX,
+      y: lastY,
+    });
+    requestAnimationFrame(tick);
+  };
+  requestAnimationFrame(tick);
+})();
+`;
+var ZOOM_INJECT_SCRIPT = `
+(() => {
+  if (window.__zoomInstalled) return;
+  window.__zoomInstalled = true;
+  const html = document.documentElement;
+  html.style.transition = 'transform 0.8s cubic-bezier(0.22, 0.61, 0.36, 1)';
+  html.style.transformOrigin = '0 0';
+  window.__zoomTo = (x, y, scale) => {
+    const vw = window.innerWidth;
+    const vh = window.innerHeight;
+    const tx = -(x - vw / scale / 2) * (scale - 1);
+    const ty = -(y - vh / scale / 2) * (scale - 1);
+    const clampedTx = Math.min(0, Math.max(tx, -(vw * (scale - 1))));
+    const clampedTy = Math.min(0, Math.max(ty, -(vh * (scale - 1))));
+    html.style.transform = 'scale(' + scale + ') translate(' + clampedTx / scale + 'px, ' + clampedTy / scale + 'px)';
+  };
+  window.__zoomReset = () => {
+    html.style.transform = 'scale(1) translate(0px, 0px)';
+  };
+})();
+`;
+var zoomToPoint = async (page, x, y, scale = 1.5) => {
+  await page.evaluate(ZOOM_INJECT_SCRIPT).catch(() => void 0);
+  await page.evaluate(
+    ({ x: x2, y: y2, scale: scale2 }) => window.__zoomTo?.(x2, y2, scale2),
+    { x, y, scale }
+  ).catch(() => void 0);
+  await page.waitForTimeout(850);
+};
+var zoomReset = async (page) => {
+  await page.evaluate(() => window.__zoomReset?.()).catch(() => void 0);
+  await page.waitForTimeout(850);
+};
+var drainCursorSamples = async (page, log, offsetMs) => {
+  try {
+    const samples = await page.evaluate(() => {
+      const s = window.__cursorSamples ?? [];
+      window.__cursorSamples = [];
+      return s;
+    });
+    for (const s of samples) {
+      log.push({ atMs: s.atMs + offsetMs, x: s.x, y: s.y });
+    }
+  } catch {
+  }
+};
+var CURSOR_OVERLAY_SCRIPT = `
+(() => {
+  if (document.getElementById('__ghost-cursor')) return;
+
+  /* \u2500\u2500 macOS-style pointer cursor \u2500\u2500 */
+  const cursor = document.createElement('div');
+  cursor.id = '__ghost-cursor';
+  Object.assign(cursor.style, {
+    position: 'fixed', zIndex: '999999', pointerEvents: 'none',
+    left: '0px', top: '0px', width: '22px', height: '32px',
+    transition: 'left 0.04s cubic-bezier(.2,.8,.3,1), top 0.04s cubic-bezier(.2,.8,.3,1)',
+    filter: 'drop-shadow(0 2px 3px rgba(0,0,0,0.4))',
+  });
+  /* Standard macOS cursor: white fill, black outline, clean geometry */
+  cursor.innerHTML = '<svg width="22" height="32" viewBox="0 0 22 32" xmlns="http://www.w3.org/2000/svg">' +
+    '<path d="M1.5 0.5L1.5 24.5L7 18.5L11.5 28.5L14.5 27L10 17.5L18 17.5Z" fill="white" stroke="black" stroke-width="1.2" stroke-linejoin="round"/>' +
+    '</svg>';
+  document.body.appendChild(cursor);
+
+  /* \u2500\u2500 Click ripple \u2500\u2500 */
+  const ripple = document.createElement('div');
+  ripple.id = '__ghost-ripple';
+  Object.assign(ripple.style, {
+    position: 'fixed', zIndex: '999998', pointerEvents: 'none',
+    width: '40px', height: '40px', borderRadius: '50%',
+    border: '2px solid rgba(59,130,246,0.6)',
+    background: 'rgba(59,130,246,0.12)',
+    transform: 'translate(-50%,-50%) scale(0)',
+    opacity: '0', left: '0px', top: '0px',
+    transition: 'transform 0.35s cubic-bezier(.2,.8,.3,1), opacity 0.35s ease-out',
+  });
+  document.body.appendChild(ripple);
+
+  document.addEventListener('mousemove', (e) => {
+    cursor.style.left = e.clientX + 'px';
+    cursor.style.top = e.clientY + 'px';
+  }, { passive: true });
+
+  document.addEventListener('mousedown', (e) => {
+    /* Pointer press animation */
+    cursor.style.transform = 'scale(0.82)';
+    setTimeout(() => { cursor.style.transform = 'scale(1)'; }, 150);
+
+    /* Ripple at click position */
+    ripple.style.left = e.clientX + 'px';
+    ripple.style.top = e.clientY + 'px';
+    ripple.style.transform = 'translate(-50%,-50%) scale(0)';
+    ripple.style.opacity = '1';
+    /* Force reflow so transition restarts */
+    void ripple.offsetWidth;
+    ripple.style.transform = 'translate(-50%,-50%) scale(1)';
+    ripple.style.opacity = '0';
+  });
+})();
+`;
+var humanTypeInto = async (page, locator, value) => {
+  await locator.first().click();
+  await locator.first().fill("");
+  for (const char of value) {
+    await page.keyboard.type(char, { delay: humanDelay(65, 0.5) });
+  }
+};
+var runActionWithCursor = async (page, action, baseUrl, cursor) => {
+  switch (action.type) {
+    case "navigate": {
+      const url = new URL(action.url, baseUrl).toString();
+      try {
+        await page.goto(url, { waitUntil: "networkidle", timeout: 3e4 });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("page.goto: Timeout")) throw error;
+        await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+        await page.waitForTimeout(1500);
+      }
+      await page.evaluate(CURSOR_OVERLAY_SCRIPT).catch(() => void 0);
+      await page.evaluate(CURSOR_TRACKER_SCRIPT).catch(() => void 0);
+      await page.evaluate(ZOOM_INJECT_SCRIPT).catch(() => void 0);
+      await page.waitForTimeout(humanDelay(400));
+      break;
+    }
+    case "wait": {
+      await page.waitForTimeout(action.ms);
+      break;
+    }
+    case "scroll": {
+      await page.evaluate(
+        (y) => window.scrollBy({ top: y, behavior: "smooth" }),
+        action.y
+      );
+      await page.waitForTimeout(humanDelay(500));
+      break;
+    }
+    case "scrollIntoView": {
+      const locator = resolveLocator(page, action.target);
+      await locator.first().scrollIntoViewIfNeeded();
+      await page.waitForTimeout(humanDelay(300));
+      break;
+    }
+    case "click": {
+      const selector = buildCssSelector(action.target);
+      if (selector) {
+        await cursor.actions.click({
+          target: selector,
+          waitBeforeClick: [100, 300]
+        });
+      } else {
+        const box = await resolveLocator(page, action.target).first().boundingBox().catch(() => null);
+        if (box) {
+          await cursor.actions.move({
+            x: box.x + box.width / 2,
+            y: box.y + box.height / 2
+          });
+          await page.waitForTimeout(humanDelay(120));
+          await page.mouse.click(
+            box.x + box.width / 2,
+            box.y + box.height / 2
+          );
+        } else {
+          await resolveLocator(page, action.target).first().click();
+        }
+      }
+      const clickBox = await resolveLocator(page, action.target).first().boundingBox().catch(() => null);
+      if (clickBox) {
+        await zoomToPoint(page, clickBox.x + clickBox.width / 2, clickBox.y + clickBox.height / 2, 1.4);
+        await page.waitForTimeout(humanDelay(1200));
+        await zoomReset(page);
+      } else {
+        await page.waitForTimeout(humanDelay(200));
+      }
+      break;
+    }
+    case "hover": {
+      const selector = buildCssSelector(action.target);
+      if (selector) {
+        await cursor.actions.move(selector);
+      } else {
+        const box = await resolveLocator(page, action.target).first().boundingBox().catch(() => null);
+        if (box) {
+          await cursor.actions.move({
+            x: box.x + box.width / 2,
+            y: box.y + box.height / 2
+          });
+        } else {
+          await resolveLocator(page, action.target).first().hover();
+        }
+      }
+      const hoverBox = await resolveLocator(page, action.target).first().boundingBox().catch(() => null);
+      if (hoverBox) {
+        await zoomToPoint(page, hoverBox.x + hoverBox.width / 2, hoverBox.y + hoverBox.height / 2, 1.3);
+        await page.waitForTimeout(humanDelay(1e3));
+        await zoomReset(page);
+      } else {
+        await page.waitForTimeout(humanDelay(300));
+      }
+      break;
+    }
+    case "fill": {
+      const locator = resolveLocator(page, action.target);
+      const selector = buildCssSelector(action.target);
+      if (selector) {
+        await cursor.actions.click({
+          target: selector,
+          waitBeforeClick: [80, 200]
+        });
+      } else {
+        const box = await locator.first().boundingBox().catch(() => null);
+        if (box) {
+          await cursor.actions.move({
+            x: box.x + box.width / 2,
+            y: box.y + box.height / 2
+          });
+          await page.waitForTimeout(humanDelay(100));
+          await page.mouse.click(
+            box.x + box.width / 2,
+            box.y + box.height / 2
+          );
+        }
+      }
+      await page.waitForTimeout(humanDelay(150));
+      await humanTypeInto(page, locator, action.value);
+      await page.waitForTimeout(humanDelay(200));
+      break;
+    }
+    case "press": {
+      await page.keyboard.press(action.key);
+      await page.waitForTimeout(humanDelay(150));
+      break;
+    }
+    case "select": {
+      const locator = resolveLocator(page, action.target);
+      await locator.first().selectOption(action.value);
+      await page.waitForTimeout(humanDelay(200));
+      break;
+    }
+    case "dragSelect": {
+      const box = await resolveLocator(page, action.target).first().boundingBox();
+      if (!box) throw new Error("dragSelect: no bounding box");
+      const startX = box.x + box.width * (action.startX ?? 0.08);
+      const startY = box.y + box.height * (action.startY ?? 0.12);
+      const endX = box.x + box.width * (action.endX ?? 0.7);
+      const endY = box.y + box.height * (action.endY ?? action.startY ?? 0.12);
+      await cursor.actions.move({ x: startX, y: startY });
+      await page.waitForTimeout(humanDelay(100));
+      await page.mouse.down();
+      await page.mouse.move(endX, endY, { steps: 24 });
+      await page.mouse.up();
+      await page.waitForTimeout(humanDelay(200));
+      break;
+    }
+    case "waitForText": {
+      await page.getByText(action.value, { exact: action.exact }).first().waitFor({ timeout: action.timeoutMs ?? 1e4 }).catch(() => console.warn(`[capture] waitForText timed out: "${action.value}"`));
+      break;
+    }
+    case "waitForUrl": {
+      const urlMatcher = action.value.startsWith("http://") || action.value.startsWith("https://") || action.value.includes("*") ? action.value : new URL(action.value, baseUrl).toString();
+      await page.waitForURL(urlMatcher, { timeout: action.timeoutMs ?? 1e4 }).catch(() => console.warn(`[capture] waitForUrl timed out: "${action.value}"`));
+      break;
+    }
+  }
+};
+var buildCssSelector = (target) => {
+  switch (target.strategy) {
+    case "css": {
+      if (/:has-text|:text|:visible|>>/.test(target.value)) return void 0;
+      return target.value;
+    }
+    case "testId":
+      return `[data-testid="${target.value}"]`;
+    default:
+      return void 0;
+  }
+};
+var DEFAULT_VIEWPORT = { width: 1600, height: 900 };
+var capturePlanContinuous = async (plan, options) => {
+  const viewport = options.viewport ?? plan.scenes[0]?.viewport ?? DEFAULT_VIEWPORT;
+  const captureDir = join(options.outputDir, "continuous");
+  await mkdir2(captureDir, { recursive: true });
+  const videoPath = join(captureDir, "recording.webm");
+  const session = resolveSessionConfig(options.outputDir);
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext(
+    await getContextOptionsWithSession({ viewport }, session)
+  );
+  const page = await context.newPage();
+  page.setDefaultTimeout(8e3);
+  const cursorLog = [];
+  const interactions = [];
+  const sceneMarkers = [];
+  const captureStartedAt = Date.now();
+  const elapsed = () => Date.now() - captureStartedAt;
+  await page.screencast.start({ path: videoPath });
+  const cursor = await createCursor(page, {
+    overshootSpread: 2,
+    overshootRadius: 8
+  });
+  let cursorTrackingOffset = 0;
+  const drainInterval = setInterval(async () => {
+    await drainCursorSamples(page, cursorLog, cursorTrackingOffset);
+  }, 200);
+  try {
+    for (const scene of plan.scenes) {
+      const sceneStart = elapsed();
+      interactions.push({
+        type: "scene-start",
+        sceneId: scene.id,
+        atMs: sceneStart
+      });
+      await page.screencast.showChapter(scene.title).catch(() => void 0);
+      await page.waitForTimeout(humanDelay(600));
+      for (const action of scene.actions) {
+        const boxBefore = await boxForAction(page, action).catch(() => void 0);
+        try {
+          await runActionWithCursor(page, action, options.baseUrl, cursor);
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          console.warn(`[capture] action ${action.type} failed (skipping): ${msg.split("\n")[0]}`);
+        }
+        if (action.type === "navigate") {
+          cursorTrackingOffset = elapsed();
+          await page.evaluate(CURSOR_TRACKER_SCRIPT).catch(() => void 0);
+          await page.evaluate(CURSOR_OVERLAY_SCRIPT).catch(() => void 0);
+        }
+        const boxAfter = await boxForAction(page, action);
+        const box = boxAfter ?? boxBefore;
+        interactions.push({
+          type: action.type,
+          sceneId: scene.id,
+          atMs: elapsed(),
+          x: box?.x,
+          y: box?.y,
+          width: box?.width,
+          height: box?.height,
+          fillValue: action.type === "fill" ? action.value : void 0
+        });
+      }
+      await page.waitForLoadState("networkidle").catch(() => void 0);
+      await page.waitForTimeout(humanDelay(500));
+      await persistSessionState(page, session);
+      const sceneEnd = elapsed();
+      interactions.push({
+        type: "scene-end",
+        sceneId: scene.id,
+        atMs: sceneEnd
+      });
+      sceneMarkers.push({
+        sceneId: scene.id,
+        sceneTitle: scene.title,
+        startMs: sceneStart,
+        endMs: sceneEnd,
+        url: page.url()
+      });
+      await page.waitForTimeout(humanDelay(400));
+    }
+    await drainCursorSamples(page, cursorLog, cursorTrackingOffset);
+    const totalDurationMs = elapsed();
+    await page.screencast.stop();
+    await context.close();
+    await browser.close();
+    return {
+      videoPath,
+      cursorLog,
+      interactions,
+      sceneMarkers,
+      totalDurationMs,
+      viewport
+    };
+  } finally {
+    clearInterval(drainInterval);
+    await browser.close().catch(() => void 0);
+  }
+};
+
+// src/planner/prompt.ts
+import { mkdir as mkdir3 } from "fs/promises";
+import { join as join3 } from "path";
+import { chromium as chromium2 } from "playwright";
+
+// src/config/project.ts
+import { access as access2, readFile } from "fs/promises";
+import { resolve } from "path";
+var DEFAULT_CONFIG_PATHS = ["demo.dev.config.json", ".demo-dev.json"];
+var fileExists2 = async (path) => {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isRecord = (value) => {
+  return typeof value === "object" && value !== null;
+};
+var readStringArray = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.filter((item) => typeof item === "string");
+  return items.length > 0 ? items : void 0;
+};
+var readTarget = (value) => {
+  if (!isRecord(value) || typeof value.strategy !== "string") return void 0;
+  switch (value.strategy) {
+    case "label":
+    case "text":
+    case "placeholder":
+      if (typeof value.value === "string") {
+        return {
+          strategy: value.strategy,
+          value: value.value,
+          exact: typeof value.exact === "boolean" ? value.exact : void 0
+        };
+      }
+      return void 0;
+    case "testId":
+    case "css":
+      if (typeof value.value === "string") {
+        return { strategy: value.strategy, value: value.value };
+      }
+      return void 0;
+    case "role":
+      if (typeof value.role === "string") {
+        return {
+          strategy: "role",
+          role: value.role,
+          name: typeof value.name === "string" ? value.name : void 0,
+          exact: typeof value.exact === "boolean" ? value.exact : void 0
+        };
+      }
+      return void 0;
+    default:
+      return void 0;
+  }
+};
+var normalizeAuthConfig = (value) => {
+  if (!isRecord(value)) return void 0;
+  return {
+    loginPath: typeof value.loginPath === "string" ? value.loginPath : void 0,
+    emailTarget: readTarget(value.emailTarget),
+    passwordTarget: readTarget(value.passwordTarget),
+    submitTarget: readTarget(value.submitTarget),
+    successUrlPattern: typeof value.successUrlPattern === "string" ? value.successUrlPattern : void 0,
+    postSubmitWaitMs: typeof value.postSubmitWaitMs === "number" ? value.postSubmitWaitMs : void 0
+  };
+};
+var normalizeProjectConfig = (value) => {
+  if (!isRecord(value)) return {};
+  return {
+    projectName: typeof value.projectName === "string" ? value.projectName : void 0,
+    baseUrl: typeof value.baseUrl === "string" ? value.baseUrl : void 0,
+    readyUrl: typeof value.readyUrl === "string" ? value.readyUrl : void 0,
+    devCommand: typeof value.devCommand === "string" ? value.devCommand : void 0,
+    baseRef: typeof value.baseRef === "string" ? value.baseRef : void 0,
+    outputDir: typeof value.outputDir === "string" ? value.outputDir : void 0,
+    storageStatePath: typeof value.storageStatePath === "string" ? value.storageStatePath : void 0,
+    saveStorageStatePath: typeof value.saveStorageStatePath === "string" ? value.saveStorageStatePath : void 0,
+    preferredRoutes: readStringArray(value.preferredRoutes),
+    featureHints: readStringArray(value.featureHints),
+    authRequiredRoutes: readStringArray(value.authRequiredRoutes),
+    auth: normalizeAuthConfig(value.auth)
+  };
+};
+var loadProjectConfig = async (configPath) => {
+  const explicitPath = configPath ?? process.env.DEMO_CONFIG;
+  const candidatePaths = explicitPath ? [explicitPath] : DEFAULT_CONFIG_PATHS;
+  for (const candidate of candidatePaths) {
+    const absolutePath = resolve(candidate);
+    if (!await fileExists2(absolutePath)) continue;
+    const parsed = JSON.parse(await readFile(absolutePath, "utf8"));
+    return {
+      path: absolutePath,
+      config: normalizeProjectConfig(parsed)
+    };
+  }
+  return { config: {} };
+};
+var applyProjectEnvironment = (config) => {
+  if (!process.env.DEMO_STORAGE_STATE && config.storageStatePath) {
+    process.env.DEMO_STORAGE_STATE = config.storageStatePath;
+  }
+  if (!process.env.DEMO_SAVE_STORAGE_STATE && config.saveStorageStatePath) {
+    process.env.DEMO_SAVE_STORAGE_STATE = config.saveStorageStatePath;
+  }
+};
+var summarizeProjectHints = (config) => {
+  return {
+    preferredRoutes: config.preferredRoutes ?? [],
+    featureHints: config.featureHints ?? [],
+    authRequiredRoutes: config.authRequiredRoutes ?? []
+  };
+};
+
+// src/ai/provider.ts
+import { execFile } from "child_process";
+import { mkdtemp, readFile as readFile2, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { promisify } from "util";
+import { z } from "zod";
+var execFileAsync = promisify(execFile);
+var extractJson = (text) => {
+  const fenced = text.match(/```json\s*([\s\S]*?)```/i)?.[1];
+  if (fenced) return fenced.trim();
+  const firstBrace = text.indexOf("{");
+  const lastBrace = text.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+    return text.slice(firstBrace, lastBrace + 1);
+  }
+  return text.trim();
+};
+var runCommand = async (command, args, stdin) => {
+  if (stdin) {
+    const { spawn } = await import("child_process");
+    return new Promise((resolve3, reject) => {
+      const child = spawn(command, args, { cwd: process.cwd(), stdio: ["pipe", "pipe", "pipe"] });
+      let stdout2 = "";
+      let stderr2 = "";
+      child.stdout.on("data", (d) => {
+        stdout2 += d.toString();
+      });
+      child.stderr.on("data", (d) => {
+        stderr2 += d.toString();
+      });
+      child.on("error", reject);
+      child.on("close", (code) => {
+        if (code !== 0) reject(new Error(`${command} exited with ${code}: ${stderr2}`));
+        else resolve3({ stdout: stdout2, stderr: stderr2 });
+      });
+      child.stdin.write(stdin);
+      child.stdin.end();
+    });
+  }
+  const { stdout, stderr } = await execFileAsync(command, args, {
+    cwd: process.cwd(),
+    maxBuffer: 1024 * 1024 * 20
+  });
+  return { stdout, stderr };
+};
+var commandExists = async (command) => {
+  try {
+    await execFileAsync("which", [command]);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var getConfig = () => ({
+  provider: process.env.DEMO_AI_PROVIDER ?? "auto",
+  model: process.env.DEMO_AI_MODEL,
+  mandatory: process.env.DEMO_AI_MANDATORY !== "false"
+});
+var getOpenAiConfig = () => {
+  const apiKey = process.env.DEMO_OPENAI_API_KEY;
+  const baseUrl = process.env.DEMO_OPENAI_BASE_URL ?? "https://api.openai.com/v1";
+  const model = process.env.DEMO_OPENAI_MODEL ?? process.env.DEMO_AI_MODEL ?? "gpt-4.1-mini";
+  return { apiKey, baseUrl, model };
+};
+var requestFromOpenAi = async (options) => {
+  const config = getOpenAiConfig();
+  if (!config.apiKey) throw new Error("OpenAI API key not configured. Set DEMO_OPENAI_API_KEY.");
+  const response = await fetch(`${config.baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model: config.model,
+      temperature: 0.2,
+      response_format: { type: "json_object" },
+      messages: [
+        { role: "system", content: options.system },
+        { role: "user", content: options.prompt }
+      ]
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OpenAI request failed: ${response.status} ${await response.text()}`);
+  }
+  const payload = z.object({
+    choices: z.array(z.object({ message: z.object({ content: z.string().nullable().optional() }) }))
+  }).parse(await response.json());
+  const content = payload.choices[0]?.message.content;
+  if (!content) throw new Error("OpenAI returned empty content");
+  return options.schema.parse(JSON.parse(extractJson(content)));
+};
+var requestFromCursor = async (options) => {
+  if (!await commandExists("cursor-agent")) throw new Error("cursor-agent not found");
+  const stdinContent = `${options.system}
+
+${options.prompt}`;
+  const args = ["--print", "--output-format", "json", "--trust", "--mode", "plan"];
+  if (options.model) args.push("--model", options.model);
+  args.push("-");
+  const { stdout } = await runCommand("cursor-agent", args, stdinContent);
+  const payload = JSON.parse(stdout);
+  if (payload.is_error) throw new Error(payload.result ?? "Cursor provider returned error");
+  if (!payload.result) throw new Error("Cursor provider returned empty result");
+  return options.schema.parse(JSON.parse(extractJson(payload.result)));
+};
+var requestFromClaude = async (options) => {
+  if (!await commandExists("claude")) throw new Error("claude not found");
+  const stdinContent = `${options.prompt}
+
+Return strict JSON only.`;
+  const args = [
+    "-p",
+    "--output-format",
+    "json",
+    "--system-prompt",
+    options.system,
+    "--allowedTools",
+    ""
+  ];
+  if (options.model) args.push("--model", options.model);
+  args.push("-");
+  const { stdout } = await runCommand("claude", args, stdinContent);
+  const payload = JSON.parse(stdout);
+  if (payload.is_error) throw new Error(payload.result ?? "Claude provider returned error");
+  if (!payload.result) throw new Error("Claude provider returned empty result");
+  return options.schema.parse(JSON.parse(extractJson(payload.result)));
+};
+var requestFromCodex = async (options) => {
+  if (!await commandExists("codex")) throw new Error("codex not found");
+  const tempDir = await mkdtemp(join2(tmpdir(), "demo-dev-codex-"));
+  const outputPath = join2(tempDir, "last-message.json");
+  try {
+    const fullPrompt = `${options.system}
+
+${options.prompt}
+
+Return strict JSON only.`;
+    const args = [
+      "exec",
+      "--skip-git-repo-check",
+      "--sandbox",
+      "read-only",
+      "--output-last-message",
+      outputPath
+    ];
+    if (options.model) args.push("--model", options.model);
+    args.push(fullPrompt);
+    await runCommand("codex", args);
+    const content = await readFile2(outputPath, "utf8");
+    return options.schema.parse(JSON.parse(extractJson(content)));
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+};
+var PROVIDERS = ["cursor", "claude", "codex", "openai"];
+var requestAiJson = async (options) => {
+  const config = getConfig();
+  const providers = config.provider === "auto" ? PROVIDERS : [config.provider];
+  const errors = [];
+  for (const provider of providers) {
+    let prompt = options.prompt;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        switch (provider) {
+          case "cursor":
+            return await requestFromCursor({ ...options, prompt, model: config.model });
+          case "claude":
+            return await requestFromClaude({ ...options, prompt, model: config.model });
+          case "codex":
+            return await requestFromCodex({ ...options, prompt, model: config.model });
+          case "openai":
+            return await requestFromOpenAi({ ...options, prompt });
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (attempt === 0) {
+          prompt = `${options.prompt}
+
+Your previous response failed validation with this error:
+${message}
+
+Return corrected strict JSON only.`;
+          continue;
+        }
+        errors.push(`${provider}: ${message}`);
+        break;
+      }
+    }
+    if (config.provider !== "auto") break;
+  }
+  if (!config.mandatory) return null;
+  throw new Error(`No AI provider succeeded. ${errors.join(" | ")}`);
+};
+
+// src/planner/schema.ts
+import { z as z2 } from "zod";
+var actionTargetSchema = z2.discriminatedUnion("strategy", [
+  z2.object({ strategy: z2.literal("label"), value: z2.string(), exact: z2.boolean().optional() }),
+  z2.object({ strategy: z2.literal("text"), value: z2.string(), exact: z2.boolean().optional() }),
+  z2.object({ strategy: z2.literal("placeholder"), value: z2.string(), exact: z2.boolean().optional() }),
+  z2.object({ strategy: z2.literal("testId"), value: z2.string() }),
+  z2.object({ strategy: z2.literal("css"), value: z2.string() }),
+  z2.object({ strategy: z2.literal("role"), role: z2.string(), name: z2.string().optional(), exact: z2.boolean().optional() })
+]);
+var focusRegionSchema = z2.object({
+  x: z2.number(),
+  y: z2.number(),
+  width: z2.number(),
+  height: z2.number(),
+  label: z2.string().optional()
+});
+var sceneDirectionSchema = z2.object({
+  shot: z2.enum(["hero", "detail", "workflow"]),
+  focusRegion: focusRegionSchema.optional(),
+  accentColor: z2.string().optional(),
+  cameraMove: z2.enum(["push-in", "pan-left", "pan-right"]).optional()
+});
+var sceneActionSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("navigate"), url: z2.string() }),
+  z2.object({ type: z2.literal("wait"), ms: z2.number().int().min(0).max(2e4) }),
+  z2.object({ type: z2.literal("scroll"), y: z2.number().int().min(-5e3).max(5e3) }),
+  z2.object({ type: z2.literal("click"), target: actionTargetSchema }),
+  z2.object({ type: z2.literal("hover"), target: actionTargetSchema }),
+  z2.object({ type: z2.literal("fill"), target: actionTargetSchema, value: z2.string() }),
+  z2.object({ type: z2.literal("press"), key: z2.string() }),
+  z2.object({ type: z2.literal("select"), target: actionTargetSchema, value: z2.string() }),
+  z2.object({ type: z2.literal("waitForText"), value: z2.string(), exact: z2.boolean().optional(), timeoutMs: z2.number().int().min(0).max(2e4).optional() }),
+  z2.object({ type: z2.literal("waitForUrl"), value: z2.string(), timeoutMs: z2.number().int().min(0).max(2e4).optional() })
+]);
+var demoSceneSchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  goal: z2.string(),
+  url: z2.string(),
+  viewport: z2.object({ width: z2.number().int().min(320).max(2400), height: z2.number().int().min(320).max(2400) }),
+  actions: z2.array(sceneActionSchema).min(1),
+  narration: z2.string(),
+  caption: z2.string(),
+  durationMs: z2.number().int().min(1e3).max(3e4),
+  evidenceHints: z2.array(z2.string()).default([]),
+  direction: sceneDirectionSchema.optional()
+});
+var demoPlanSchema = z2.object({
+  title: z2.string(),
+  summary: z2.string(),
+  branch: z2.string(),
+  generatedAt: z2.string(),
+  scenes: z2.array(demoSceneSchema).min(1).max(6)
+});
+
+// src/planner/prompt.ts
+var EXPLORE_SCRIPT = `(() => {
+  function norm(v) { return (v||"").replace(/\\s+/g," ").trim().slice(0,140); }
+  function vis(el) {
+    const r = el.getBoundingClientRect(), s = getComputedStyle(el);
+    return r.width>0 && r.height>0 && s.visibility!=="hidden" && s.display!=="none" && s.opacity!=="0";
+  }
+  function role(el) {
+    const r = el.getAttribute("role"); if(r) return r;
+    const t = el.tagName.toLowerCase();
+    if(t==="a") return "link"; if(t==="button") return "button";
+    if(t==="select") return "combobox"; if(t==="textarea") return "textbox";
+    if(t==="input") { const tp=(el.type||"text").toLowerCase(); return ["submit","button"].includes(tp)?"button":"textbox"; }
+    return t;
+  }
+  function name(el) {
+    return norm(el.getAttribute("aria-label")) || norm(el.placeholder) || norm(el.textContent) || role(el);
+  }
+  const sels = "button,a[href],input,select,textarea,[role=button],[role=link],[role=tab],[role=menuitem],[data-testid]";
+  const elems = Array.from(document.querySelectorAll(sels)).filter(vis).slice(0,50).map(el => ({
+    tag: el.tagName.toLowerCase(), role: role(el), name: name(el),
+    text: norm(el.textContent)||undefined, label: undefined,
+    placeholder: norm(el.placeholder)||undefined,
+    href: el.href||undefined, testId: el.getAttribute("data-testid")||undefined,
+  }));
+  const headings = Array.from(document.querySelectorAll("h1,h2,h3")).map(h=>norm(h.textContent)).filter(Boolean).slice(0,10);
+  const text = norm(document.body?.innerText).slice(0,800);
+  const navLinks = Array.from(document.querySelectorAll("nav a[href], aside a[href], [role=navigation] a[href]"))
+    .filter(vis).slice(0,20).map(a => ({ text: norm(a.textContent), href: a.href }));
+  return { headings, textPreview: text, interactiveElements: elems, navLinks };
+})()`;
+var collectPageSnapshot = async (page) => {
+  const data = await page.evaluate(EXPLORE_SCRIPT);
+  return {
+    url: page.url(),
+    title: await page.title().catch(() => ""),
+    ...data
+  };
+};
+var exploreSite = async (baseUrl, outputDir, projectConfig) => {
+  const screenshotDir = join3(outputDir, "exploration");
+  await mkdir3(screenshotDir, { recursive: true });
+  const session = resolveSessionConfig(outputDir);
+  const browser = await chromium2.launch({ headless: true });
+  const context = await browser.newContext(
+    await getContextOptionsWithSession(
+      { viewport: { width: 1440, height: 900 } },
+      session
+    )
+  );
+  const page = await context.newPage();
+  const pages = [];
+  const screenshotPaths = [];
+  const visited = /* @__PURE__ */ new Set();
+  const startUrls = ["/"];
+  if (projectConfig?.preferredRoutes) {
+    startUrls.push(...projectConfig.preferredRoutes);
+  }
+  try {
+    for (const route of startUrls) {
+      const fullUrl = new URL(route, baseUrl).toString();
+      const normalized = new URL(fullUrl).pathname;
+      if (visited.has(normalized)) continue;
+      visited.add(normalized);
+      try {
+        await page.goto(fullUrl, { waitUntil: "networkidle", timeout: 2e4 });
+      } catch {
+        try {
+          await page.goto(fullUrl, { waitUntil: "domcontentloaded", timeout: 2e4 });
+          await page.waitForTimeout(1500);
+        } catch {
+          continue;
+        }
+      }
+      const snapshot = await collectPageSnapshot(page);
+      pages.push(snapshot);
+      const ssPath = join3(screenshotDir, `page-${pages.length}.png`);
+      await page.screenshot({ path: ssPath });
+      screenshotPaths.push(ssPath);
+      if (pages.length >= 4) break;
+      for (const link of snapshot.navLinks) {
+        if (pages.length >= 4) break;
+        try {
+          const linkPath = new URL(link.href).pathname;
+          if (visited.has(linkPath)) continue;
+          if (!link.href.startsWith(baseUrl)) continue;
+          visited.add(linkPath);
+          await page.goto(link.href, { waitUntil: "networkidle", timeout: 15e3 });
+          const navSnapshot = await collectPageSnapshot(page);
+          pages.push(navSnapshot);
+          const navSsPath = join3(screenshotDir, `page-${pages.length}.png`);
+          await page.screenshot({ path: navSsPath });
+          screenshotPaths.push(navSsPath);
+        } catch {
+          continue;
+        }
+      }
+    }
+  } finally {
+    await context.close();
+    await browser.close();
+  }
+  return { pages, screenshotPaths };
+};
+var buildPromptPlannerPrompt = (userPrompt, exploration, projectConfig) => {
+  const pageDescriptions = exploration.pages.map((p, i) => {
+    const elements = p.interactiveElements.map((el) => {
+      const parts = [`${el.role}: "${el.name}"`];
+      if (el.href) parts.push(`\u2192 ${el.href}`);
+      if (el.placeholder) parts.push(`(placeholder: "${el.placeholder}")`);
+      if (el.testId) parts.push(`[data-testid="${el.testId}"]`);
+      return `    ${parts.join(" ")}`;
+    }).join("\n");
+    return [
+      `Page ${i + 1}: ${p.title}`,
+      `  URL: ${p.url}`,
+      `  Headings: ${p.headings.join(" | ")}`,
+      `  Content preview: ${p.textPreview.slice(0, 300)}`,
+      `  Interactive elements (${p.interactiveElements.length}):`,
+      elements
+    ].join("\n");
+  });
+  return [
+    "You are a product demo director.",
+    "A user wants to create a demo video of their web app with a single prompt.",
+    "",
+    "USER PROMPT:",
+    `"${userPrompt}"`,
+    "",
+    "SITE EXPLORATION:",
+    "I visited the app and found these pages with their interactive elements:",
+    "",
+    ...pageDescriptions,
+    "",
+    "INSTRUCTIONS:",
+    "1. Create 3-6 scenes that tell the story the user described.",
+    "2. Each scene should have specific, executable actions (navigate, click, hover, fill, scroll, wait, press).",
+    "3. Use REAL element selectors from the exploration above. Prefer strategy: 'text' or 'role' with the exact name/text shown.",
+    "4. Write narration that sounds like a human giving a product tour \u2014 conversational, not robotic.",
+    "5. All URLs must be relative paths (e.g., /inbox not https://app.example.com/inbox).",
+    "6. Keep durationMs between 4000 and 9000 per scene.",
+    "7. Start with a navigate action in the first scene.",
+    "8. Add wait actions (300-800ms) between interactions for pacing.",
+    "9. Use scroll actions to reveal below-the-fold content when relevant.",
+    "",
+    "ACTION TARGET STRATEGIES (use these exact formats):",
+    '  { "strategy": "text", "value": "Button Text", "exact": false }  \u2014 match by visible text',
+    '  { "strategy": "role", "role": "button", "name": "Submit" }      \u2014 match by ARIA role + name',
+    '  { "strategy": "css", "value": ".my-class" }                     \u2014 CSS selector',
+    '  { "strategy": "placeholder", "value": "Search..." }             \u2014 match by placeholder',
+    '  { "strategy": "testId", "value": "my-test-id" }                 \u2014 match by data-testid',
+    "",
+    "Project hints:",
+    JSON.stringify(summarizeProjectHints(projectConfig ?? {}), null, 2),
+    "",
+    "EXACT JSON SCHEMA (follow this structure precisely):",
+    JSON.stringify({
+      title: "Demo Title",
+      summary: "One sentence summary",
+      branch: "prompt",
+      generatedAt: "2026-01-01T00:00:00.000Z",
+      scenes: [{
+        id: "scene-1",
+        title: "Scene Title",
+        goal: "What this scene demonstrates",
+        url: "/relative-path",
+        viewport: { width: 1440, height: 900 },
+        actions: [
+          { type: "navigate", url: "/relative-path" },
+          { type: "wait", ms: 500 },
+          { type: "click", target: { strategy: "text", value: "Button Text", exact: false } },
+          { type: "hover", target: { strategy: "role", role: "button", name: "Name" } },
+          { type: "scroll", y: 200 },
+          { type: "fill", target: { strategy: "placeholder", value: "Search..." }, value: "typed text" }
+        ],
+        narration: "Conversational narration for this scene.",
+        caption: "Short caption",
+        durationMs: 6e3,
+        evidenceHints: []
+      }]
+    }, null, 2),
+    "",
+    "Output a strict JSON DemoPlan following the schema above. No markdown, no explanation."
+  ].join("\n");
+};
+var buildPromptPlan = async (options) => {
+  const exploration = await exploreSite(
+    options.baseUrl,
+    options.outputDir,
+    options.projectConfig
+  );
+  if (exploration.pages.length === 0) {
+    throw new Error("Could not load any pages from " + options.baseUrl);
+  }
+  const prompt = buildPromptPlannerPrompt(
+    options.prompt,
+    exploration,
+    options.projectConfig
+  );
+  const plan = await requestAiJson({
+    system: "You are a product demo director. You create demo plans from natural language prompts. You have been given a site exploration with real page content and interactive elements. Use ONLY elements that actually exist on the pages. Output strict JSON only.",
+    prompt,
+    schema: demoPlanSchema,
+    temperature: 0.3
+  });
+  if (!plan) {
+    throw new Error(
+      "AI provider could not generate a plan. Set DEMO_OPENAI_API_KEY or use a local AI provider."
+    );
+  }
+  return {
+    ...plan,
+    branch: "prompt",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    scenes: plan.scenes.map((scene) => ({
+      ...scene,
+      evidenceHints: scene.evidenceHints ?? []
+    }))
+  };
+};
+
+// src/render/visual-plan.ts
+var CLICK_ZOOM_SCALE = 1.6;
+var HOVER_ZOOM_SCALE = 1.3;
+var FILL_ZOOM_SCALE = 1.5;
+var DEFAULT_ZOOM_SCALE = 1;
+var MIN_ZOOM_GAP_MS = 800;
+var IDLE_THRESHOLD_MS = 1500;
+var IDLE_SPEED = 6;
+var LOADING_SPEED = 2.5;
+var SMOOTH_WINDOW = 5;
+var zoomScaleForEvent = (type) => {
+  switch (type) {
+    case "click":
+      return CLICK_ZOOM_SCALE;
+    case "fill":
+      return FILL_ZOOM_SCALE;
+    case "hover":
+      return HOVER_ZOOM_SCALE;
+    case "select":
+      return CLICK_ZOOM_SCALE;
+    case "dragSelect":
+      return FILL_ZOOM_SCALE;
+    default:
+      return DEFAULT_ZOOM_SCALE;
+  }
+};
+var isInteractive = (type) => type === "click" || type === "hover" || type === "fill" || type === "select" || type === "dragSelect" || type === "press";
+var buildZoomKeyframes = (interactions, viewport) => {
+  const keyframes = [];
+  keyframes.push({
+    atMs: 0,
+    centerX: 0.5,
+    centerY: 0.5,
+    scale: 1,
+    holdMs: 500,
+    easing: "ease-in-out",
+    transitionMs: 0
+  });
+  let lastKeyframeMs = 0;
+  for (const interaction of interactions) {
+    if (!isInteractive(interaction.type)) continue;
+    if (interaction.x == null || interaction.y == null) continue;
+    if (interaction.atMs - lastKeyframeMs < MIN_ZOOM_GAP_MS) continue;
+    const centerX = interaction.x / viewport.width;
+    const centerY = interaction.y / viewport.height;
+    const scale = zoomScaleForEvent(interaction.type);
+    keyframes.push({
+      atMs: interaction.atMs - 300,
+      // Start zooming 300ms before
+      centerX,
+      centerY,
+      scale,
+      holdMs: 600,
+      easing: "spring",
+      transitionMs: 500
+    });
+    keyframes.push({
+      atMs: interaction.atMs + 800,
+      centerX: 0.5,
+      centerY: 0.5,
+      scale: 1,
+      holdMs: 200,
+      easing: "ease-in-out",
+      transitionMs: 600
+    });
+    lastKeyframeMs = interaction.atMs + 800;
+  }
+  return mergeNearbyKeyframes(keyframes);
+};
+var mergeNearbyKeyframes = (keyframes) => {
+  if (keyframes.length <= 2) return keyframes;
+  const merged = [keyframes[0]];
+  for (let i = 1; i < keyframes.length; i++) {
+    const prev = merged[merged.length - 1];
+    const curr = keyframes[i];
+    if (curr.atMs - prev.atMs < 400 && Math.abs(curr.scale - prev.scale) < 0.2) {
+      if (curr.scale > prev.scale) {
+        merged[merged.length - 1] = curr;
+      }
+      continue;
+    }
+    merged.push(curr);
+  }
+  return merged;
+};
+var buildSpeedSegments = (interactions, sceneMarkers, totalDurationMs) => {
+  const segments = [];
+  const navigations = interactions.filter((i) => i.type === "navigate");
+  const interactiveEvents = interactions.filter((i) => isInteractive(i.type));
+  const moments = [
+    ...interactiveEvents.map((i) => ({ atMs: i.atMs, type: "interactive" })),
+    ...navigations.map((i) => ({ atMs: i.atMs, type: "navigate" }))
+  ].sort((a, b) => a.atMs - b.atMs);
+  if (moments.length === 0) {
+    segments.push({
+      startMs: 0,
+      endMs: totalDurationMs,
+      speed: 1,
+      reason: "normal"
+    });
+    return segments;
+  }
+  let cursor = 0;
+  for (let i = 0; i < moments.length; i++) {
+    const moment = moments[i];
+    const gapMs = moment.atMs - cursor;
+    if (gapMs > IDLE_THRESHOLD_MS) {
+      const idleEnd = moment.atMs - 500;
+      if (idleEnd > cursor) {
+        segments.push({
+          startMs: cursor,
+          endMs: idleEnd,
+          speed: IDLE_SPEED,
+          reason: "idle"
+        });
+        cursor = idleEnd;
+      }
+    }
+    if (moment.type === "navigate") {
+      const nextInteractive = moments.find(
+        (m) => m.atMs > moment.atMs && m.type === "interactive"
+      );
+      const loadEnd = nextInteractive ? Math.min(nextInteractive.atMs - 300, moment.atMs + 3e3) : moment.atMs + 2e3;
+      if (loadEnd > moment.atMs + 500) {
+        segments.push({
+          startMs: cursor,
+          endMs: moment.atMs,
+          speed: 1,
+          reason: "normal"
+        });
+        segments.push({
+          startMs: moment.atMs,
+          endMs: loadEnd,
+          speed: LOADING_SPEED,
+          reason: "loading"
+        });
+        cursor = loadEnd;
+        continue;
+      }
+    }
+    const nextMoment = moments[i + 1];
+    const endMs = nextMoment ? nextMoment.atMs : totalDurationMs;
+    if (cursor < endMs) {
+      segments.push({
+        startMs: cursor,
+        endMs,
+        speed: 1,
+        reason: "normal"
+      });
+      cursor = endMs;
+    }
+  }
+  if (cursor < totalDurationMs) {
+    segments.push({
+      startMs: cursor,
+      endMs: totalDurationMs,
+      speed: 1,
+      reason: "normal"
+    });
+  }
+  return mergeAdjacentSegments(segments);
+};
+var mergeAdjacentSegments = (segments) => {
+  if (segments.length <= 1) return segments;
+  const merged = [segments[0]];
+  for (let i = 1; i < segments.length; i++) {
+    const prev = merged[merged.length - 1];
+    const curr = segments[i];
+    if (prev.speed === curr.speed && prev.endMs >= curr.startMs - 10) {
+      prev.endMs = curr.endMs;
+    } else {
+      merged.push(curr);
+    }
+  }
+  return merged;
+};
+var smoothCursorLog = (raw, windowSize = SMOOTH_WINDOW) => {
+  if (raw.length === 0) return [];
+  const smoothed = [];
+  for (let i = 0; i < raw.length; i++) {
+    const start = Math.max(0, i - Math.floor(windowSize / 2));
+    const end = Math.min(raw.length, i + Math.ceil(windowSize / 2));
+    let sumX = 0;
+    let sumY = 0;
+    let count = 0;
+    for (let j = start; j < end; j++) {
+      const weight = 1 - Math.abs(j - i) / windowSize;
+      sumX += raw[j].x * weight;
+      sumY += raw[j].y * weight;
+      count += weight;
+    }
+    smoothed.push({
+      atMs: raw[i].atMs,
+      x: Math.round(sumX / count),
+      y: Math.round(sumY / count)
+    });
+  }
+  const downsampled = [];
+  let lastMs = -Infinity;
+  for (const pt of smoothed) {
+    if (pt.atMs - lastMs >= 33) {
+      downsampled.push(pt);
+      lastMs = pt.atMs;
+    }
+  }
+  return downsampled;
+};
+var calculateAdjustedDuration = (segments) => {
+  let total = 0;
+  for (const seg of segments) {
+    total += (seg.endMs - seg.startMs) / seg.speed;
+  }
+  return Math.round(total);
+};
+var buildVisualPlan = (capture) => {
+  const zoomKeyframes = buildZoomKeyframes(
+    capture.interactions,
+    capture.viewport
+  );
+  const speedSegments = buildSpeedSegments(
+    capture.interactions,
+    capture.sceneMarkers,
+    capture.totalDurationMs
+  );
+  const smoothedCursor = smoothCursorLog(capture.cursorLog);
+  const adjustedDurationMs = calculateAdjustedDuration(speedSegments);
+  return {
+    zoomKeyframes,
+    speedSegments,
+    smoothedCursor,
+    adjustedDurationMs
+  };
+};
+
+// src/render/ffmpeg-compose.ts
+import { execFile as execFile3 } from "child_process";
+import { writeFile as writeFile2 } from "fs/promises";
+import { join as join5, dirname as dirname3, resolve as resolve2 } from "path";
+import { mkdir as mkdir5 } from "fs/promises";
+import { promisify as promisify3 } from "util";
+
+// src/render/browser-frame.ts
+import { execFile as execFile2 } from "child_process";
+import { mkdir as mkdir4 } from "fs/promises";
+import { join as join4, dirname as dirname2 } from "path";
+import { promisify as promisify2 } from "util";
+import { chromium as chromium3 } from "playwright";
+var execFileAsync2 = promisify2(execFile2);
+var DEFAULT_GRADIENT_FROM = "#f97316";
+var DEFAULT_GRADIENT_TO = "#a855f7";
+var DEFAULT_PADDING = 48;
+var CHROME_HEIGHT = 52;
+var renderFrameTemplate = async (outputPath, contentWidth, contentHeight, options) => {
+  const padding = options.padding ?? DEFAULT_PADDING;
+  const gradFrom = options.gradientFrom ?? DEFAULT_GRADIENT_FROM;
+  const gradTo = options.gradientTo ?? DEFAULT_GRADIENT_TO;
+  const displayUrl = options.displayUrl ?? "app.example.com";
+  const windowWidth = contentWidth;
+  const windowHeight = contentHeight + CHROME_HEIGHT;
+  const canvasWidth = windowWidth + padding * 2;
+  const canvasHeight = windowHeight + padding * 2;
+  const contentOffsetX = padding;
+  const contentOffsetY = padding + CHROME_HEIGHT;
+  const html = `<!DOCTYPE html>
+<html><head><style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    width: ${canvasWidth}px; height: ${canvasHeight}px;
+    background: linear-gradient(135deg, ${gradFrom} 0%, ${gradTo} 100%);
+    display: flex; align-items: center; justify-content: center;
+    font-family: -apple-system, BlinkMacSystemFont, "SF Pro Text", "Helvetica Neue", sans-serif;
+  }
+  .window {
+    width: ${windowWidth}px; height: ${windowHeight}px;
+    border-radius: 12px;
+    overflow: hidden;
+    box-shadow: 0 25px 60px rgba(0,0,0,0.35), 0 8px 20px rgba(0,0,0,0.2);
+  }
+  .chrome {
+    height: ${CHROME_HEIGHT}px;
+    background: linear-gradient(180deg, #e8e6e3 0%, #d5d3d0 100%);
+    display: flex; align-items: center; padding: 0 16px;
+    border-bottom: 1px solid #c4c2bf;
+  }
+  .traffic-lights { display: flex; gap: 8px; margin-right: 16px; }
+  .dot { width: 12px; height: 12px; border-radius: 50%; }
+  .dot-red { background: #ff5f57; border: 1px solid #e0443e; }
+  .dot-yellow { background: #febc2e; border: 1px solid #d4a020; }
+  .dot-green { background: #28c840; border: 1px solid #1ea633; }
+  .nav-buttons { display: flex; gap: 6px; margin-right: 12px; }
+  .nav-btn { width: 20px; height: 20px; display: flex; align-items: center; justify-content: center; color: #888; font-size: 16px; }
+  .url-bar {
+    flex: 1; height: 30px; border-radius: 6px;
+    background: rgba(255,255,255,0.75); border: 1px solid rgba(0,0,0,0.1);
+    display: flex; align-items: center; justify-content: center;
+    padding: 0 12px; font-size: 13px; color: #555;
+  }
+  .lock { margin-right: 5px; font-size: 11px; color: #888; }
+  .content { width: ${contentWidth}px; height: ${contentHeight}px; background: #fff; }
+</style></head><body>
+  <div class="window">
+    <div class="chrome">
+      <div class="traffic-lights">
+        <div class="dot dot-red"></div>
+        <div class="dot dot-yellow"></div>
+        <div class="dot dot-green"></div>
+      </div>
+      <div class="nav-buttons">
+        <div class="nav-btn">&larr;</div>
+        <div class="nav-btn">&rarr;</div>
+      </div>
+      <div class="url-bar">
+        <span class="lock">&#x1f512;</span>
+        ${escapeHtml(displayUrl)}
+      </div>
+    </div>
+    <div class="content"></div>
+  </div>
+</body></html>`;
+  await mkdir4(dirname2(outputPath), { recursive: true });
+  const browser = await chromium3.launch({ headless: true });
+  const page = await browser.newPage({ viewport: { width: canvasWidth, height: canvasHeight } });
+  await page.setContent(html, { waitUntil: "networkidle" });
+  await page.screenshot({ path: outputPath, omitBackground: false });
+  await browser.close();
+  return { canvasWidth, canvasHeight, contentOffsetX, contentOffsetY };
+};
+var escapeHtml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var applyBrowserFrame = async (inputPath, outputPath, contentWidth, contentHeight, options, crf, preset) => {
+  const tempDir = join4(dirname2(outputPath), ".frame-temp");
+  await mkdir4(tempDir, { recursive: true });
+  const framePngPath = join4(tempDir, "browser-frame.png");
+  const { canvasWidth, canvasHeight, contentOffsetX, contentOffsetY } = await renderFrameTemplate(
+    framePngPath,
+    contentWidth,
+    contentHeight,
+    options
+  );
+  await execFileAsync2("ffmpeg", [
+    "-i",
+    inputPath,
+    "-i",
+    framePngPath,
+    "-filter_complex",
+    `[0:v]scale=${contentWidth}:${contentHeight}:flags=lanczos[vid];[1:v]loop=loop=-1:size=1:start=0,setpts=N/FRAME_RATE/TB[frame];[frame][vid]overlay=${contentOffsetX}:${contentOffsetY}:shortest=1[out]`,
+    "-map",
+    "[out]",
+    "-c:v",
+    "libx264",
+    "-preset",
+    preset,
+    "-crf",
+    String(crf),
+    "-pix_fmt",
+    "yuv420p",
+    "-an",
+    "-y",
+    outputPath
+  ]);
+  return { outputWidth: canvasWidth, outputHeight: canvasHeight };
+};
+
+// src/render/ffmpeg-compose.ts
+var execFileAsync3 = promisify3(execFile3);
+var QUALITY_PRESETS = {
+  draft: { crf: 28, preset: "ultrafast", fps: 24 },
+  standard: { crf: 18, preset: "fast", fps: 30 },
+  high: { crf: 12, preset: "slow", fps: 60 }
+};
+var hasDrawtext = async () => {
+  try {
+    const { stdout } = await execFileAsync3("ffmpeg", ["-filters"], { maxBuffer: 1024 * 1024 });
+    return stdout.includes("drawtext");
+  } catch {
+    return false;
+  }
+};
+var generateTitleCard = async (title, outputPath, width, height, durationSec, fps) => {
+  await mkdir5(dirname3(outputPath), { recursive: true });
+  const canDrawText = await hasDrawtext();
+  if (canDrawText) {
+    await execFileAsync3("ffmpeg", [
+      "-f",
+      "lavfi",
+      "-i",
+      `color=c=0x171410:s=${width}x${height}:d=${durationSec}:r=${fps}`,
+      "-vf",
+      `drawtext=text='${escapeFFmpegText(title)}':fontsize=48:fontcolor=white:x=(w-text_w)/2:y=(h-text_h)/2`,
+      "-c:v",
+      "libx264",
+      "-pix_fmt",
+      "yuv420p",
+      "-y",
+      outputPath
+    ]);
+  } else {
+    await execFileAsync3("ffmpeg", [
+      "-f",
+      "lavfi",
+      "-i",
+      `color=c=0x171410:s=${width}x${height}:d=${durationSec}:r=${fps}`,
+      "-c:v",
+      "libx264",
+      "-pix_fmt",
+      "yuv420p",
+      "-y",
+      outputPath
+    ]);
+  }
+};
+var escapeFFmpegText = (text) => text.replace(/'/g, "'\\''").replace(/:/g, "\\:").replace(/\\/g, "\\\\");
+var buildNarrationTracks = (voiceLines, sceneMarkers, speedSegments, interactions) => {
+  const tracks = [];
+  const markerBySceneId = new Map(sceneMarkers.map((m) => [m.sceneId, m]));
+  for (const line of voiceLines) {
+    if (!line.audioPath) continue;
+    const marker = markerBySceneId.get(line.sceneId);
+    if (!marker) continue;
+    const outputTimeSec = rawTimeToOutputTime(marker.startMs, speedSegments) / 1e3;
+    const sceneInteractions = interactions.filter(
+      (i) => i.sceneId === marker.sceneId && i.type !== "scene-start" && i.type !== "scene-end"
+    );
+    const firstInteraction = sceneInteractions[0];
+    let anchorSec = outputTimeSec;
+    if (firstInteraction) {
+      const interactionOutputSec = rawTimeToOutputTime(firstInteraction.atMs, speedSegments) / 1e3;
+      anchorSec = Math.min(interactionOutputSec + 0.3, outputTimeSec + 3);
+      anchorSec = Math.max(anchorSec, outputTimeSec);
+    }
+    const prev = tracks[tracks.length - 1];
+    if (prev) {
+      const prevVoice = voiceLines.find((v) => v.audioPath === prev.path);
+      const prevEndSec = prev.startSec + (prevVoice?.audioDurationMs ?? 0) / 1e3;
+      if (anchorSec < prevEndSec) {
+        anchorSec = prevEndSec + 0.3;
+      }
+    }
+    tracks.push({
+      path: line.audioPath,
+      startSec: anchorSec
+    });
+  }
+  return tracks;
+};
+var rawTimeToOutputTime = (rawMs, segments) => {
+  let outputMs = 0;
+  for (const seg of segments) {
+    if (rawMs <= seg.startMs) break;
+    const segStart = seg.startMs;
+    const segEnd = Math.min(seg.endMs, rawMs);
+    const segDuration = segEnd - segStart;
+    outputMs += segDuration / seg.speed;
+    if (rawMs <= seg.endMs) break;
+  }
+  return outputMs;
+};
+var composeVideo = async (options) => {
+  const q = QUALITY_PRESETS[options.quality ?? "standard"];
+  const width = options.width ?? options.capture.viewport.width;
+  const height = options.height ?? options.capture.viewport.height;
+  const fps = options.fps ?? q.fps;
+  await mkdir5(dirname3(options.outputPath), { recursive: true });
+  const tempDir = join5(dirname3(options.outputPath), ".ffmpeg-temp");
+  await mkdir5(tempDir, { recursive: true });
+  const speedAdjustedPath = join5(tempDir, "speed-adjusted.mp4");
+  await applySpeedRamps(
+    options.videoPath,
+    speedAdjustedPath,
+    options.visualPlan.speedSegments,
+    fps,
+    width,
+    height,
+    q.crf,
+    q.preset
+  );
+  let mainVideoPath = speedAdjustedPath;
+  let finalWidth = width;
+  let finalHeight = height;
+  if (options.frame) {
+    const frameOpts = options.frame === true ? {} : options.frame;
+    if (!frameOpts.displayUrl && options.capture.sceneMarkers[0]) {
+      try {
+        frameOpts.displayUrl = new URL(options.capture.sceneMarkers[0].url).host;
+      } catch {
+      }
+    }
+    const framedPath = join5(tempDir, "framed.mp4");
+    const { outputWidth, outputHeight } = await applyBrowserFrame(
+      speedAdjustedPath,
+      framedPath,
+      width,
+      height,
+      frameOpts,
+      q.crf,
+      q.preset
+    );
+    mainVideoPath = framedPath;
+    finalWidth = outputWidth;
+    finalHeight = outputHeight;
+  }
+  let introPath;
+  if (options.title) {
+    introPath = join5(tempDir, "intro.mp4");
+    await generateTitleCard(options.title, introPath, finalWidth, finalHeight, 2, fps);
+  }
+  const concatPath = introPath ? join5(tempDir, "concatenated.mp4") : mainVideoPath;
+  if (introPath) {
+    await concatVideos([introPath, mainVideoPath], concatPath);
+  }
+  if (options.voiceLines?.length || options.bgm) {
+    await mixAudio(
+      concatPath,
+      options.outputPath,
+      options.voiceLines ?? [],
+      options.capture.sceneMarkers,
+      options.visualPlan.speedSegments,
+      options.capture.interactions,
+      options.bgm,
+      introPath ? 2 : 0
+    );
+  } else {
+    await execFileAsync3("ffmpeg", [
+      "-i",
+      concatPath,
+      "-c",
+      "copy",
+      "-y",
+      options.outputPath
+    ]);
+  }
+  return options.outputPath;
+};
+var applySpeedRamps = async (inputPath, outputPath, segments, fps, width, height, crf, preset) => {
+  const allNormal = segments.every((s) => s.speed === 1);
+  if (allNormal || segments.length <= 1) {
+    await execFileAsync3("ffmpeg", [
+      "-i",
+      inputPath,
+      "-vf",
+      `scale=${width}:${height}:flags=lanczos,fps=${fps}`,
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset,
+      "-crf",
+      String(crf),
+      "-pix_fmt",
+      "yuv420p",
+      "-an",
+      "-y",
+      outputPath
+    ]);
+    return;
+  }
+  const tempDir = dirname3(outputPath);
+  const segmentPaths = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const segPath = join5(tempDir, `seg-${i}.mp4`);
+    const startSec = (seg.startMs / 1e3).toFixed(3);
+    const durationSec = ((seg.endMs - seg.startMs) / 1e3).toFixed(3);
+    const ptsExpr = seg.speed === 1 ? "PTS-STARTPTS" : `(PTS-STARTPTS)/${seg.speed.toFixed(2)}`;
+    await execFileAsync3("ffmpeg", [
+      "-ss",
+      startSec,
+      "-t",
+      durationSec,
+      "-i",
+      inputPath,
+      "-vf",
+      `scale=${width}:${height}:flags=lanczos,fps=${fps},setpts=${ptsExpr}`,
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset,
+      "-crf",
+      String(crf),
+      "-pix_fmt",
+      "yuv420p",
+      "-an",
+      "-y",
+      segPath
+    ]);
+    segmentPaths.push(segPath);
+  }
+  const listPath = join5(tempDir, "speed-concat.txt");
+  const listContent = segmentPaths.map((p) => `file '${resolve2(p)}'`).join("\n");
+  await writeFile2(listPath, listContent, "utf-8");
+  await execFileAsync3("ffmpeg", [
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    listPath,
+    "-c",
+    "copy",
+    "-y",
+    outputPath
+  ]);
+};
+var concatVideos = async (inputs, outputPath) => {
+  if (inputs.length === 1) {
+    await execFileAsync3("ffmpeg", ["-i", inputs[0], "-c", "copy", "-y", outputPath]);
+    return;
+  }
+  const inputArgs = inputs.flatMap((p) => ["-i", resolve2(p)]);
+  const filterParts = inputs.map((_, i) => `[${i}:v]`).join("");
+  const filter = `${filterParts}concat=n=${inputs.length}:v=1:a=0[outv]`;
+  await execFileAsync3("ffmpeg", [
+    ...inputArgs,
+    "-filter_complex",
+    filter,
+    "-map",
+    "[outv]",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "fast",
+    "-crf",
+    "18",
+    "-pix_fmt",
+    "yuv420p",
+    "-y",
+    outputPath
+  ]);
+};
+var mixAudio = async (videoPath, outputPath, voiceLines, sceneMarkers, speedSegments, interactions, bgm, introOffsetSec) => {
+  const narrationTracks = buildNarrationTracks(voiceLines, sceneMarkers, speedSegments, interactions);
+  const adjustedTracks = narrationTracks.map((t) => ({
+    ...t,
+    startSec: t.startSec + introOffsetSec
+  }));
+  if (adjustedTracks.length === 0 && !bgm) {
+    await execFileAsync3("ffmpeg", ["-i", videoPath, "-c", "copy", "-y", outputPath]);
+    return;
+  }
+  const inputs = ["-i", videoPath];
+  const filterParts = [];
+  let streamIdx = 1;
+  filterParts.push(`anullsrc=r=44100:cl=stereo[silence]`);
+  const overlayLabels = ["[silence]"];
+  for (const track of adjustedTracks) {
+    inputs.push("-i", track.path);
+    const delayMs = Math.round(track.startSec * 1e3);
+    filterParts.push(
+      `[${streamIdx}]aresample=44100,adelay=${delayMs}|${delayMs}:all=1,apad[narr${streamIdx}]`
+    );
+    overlayLabels.push(`[narr${streamIdx}]`);
+    streamIdx++;
+  }
+  if (bgm) {
+    inputs.push("-i", bgm.path);
+    const vol = bgm.volume ?? 0.16;
+    filterParts.push(
+      `[${streamIdx}]aresample=44100,volume=${vol.toFixed(2)},aloop=loop=-1:size=2e+09,apad[bgm]`
+    );
+    overlayLabels.push("[bgm]");
+    streamIdx++;
+  }
+  filterParts.push(
+    `${overlayLabels.join("")}amix=inputs=${overlayLabels.length}:duration=first:normalize=0[aout]`
+  );
+  const filterComplex = filterParts.join(";");
+  await execFileAsync3("ffmpeg", [
+    ...inputs,
+    "-filter_complex",
+    filterComplex,
+    "-map",
+    "0:v",
+    "-map",
+    "[aout]",
+    "-c:v",
+    "copy",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "192k",
+    "-shortest",
+    "-y",
+    outputPath
+  ]);
+};
+
+// src/lib/fs.ts
+import { mkdir as mkdir6, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+var writeJson = async (path, value) => {
+  await mkdir6(dirname4(path), { recursive: true });
+  await writeFile3(path, JSON.stringify(value, null, 2) + "\n", "utf8");
+};
+
+// src/voice/script.ts
+var estimateMs = (text) => {
+  const words = text.trim().split(/\s+/).filter(Boolean).length;
+  const chineseChars = text.replace(/\s+/g, "").length;
+  return Math.max(2500, Math.round((words > 1 ? words : chineseChars) * 280));
+};
+var tokenizeNarration = (text, estimatedMs) => {
+  const tokens = text.match(/\S+\s*/g) ?? [text];
+  const weighted = tokens.map((token) => ({
+    text: token,
+    weight: Math.max(token.replace(/\s+/g, "").length, 1)
+  }));
+  const totalWeight = weighted.reduce((sum, token) => sum + token.weight, 0) || 1;
+  let cursor = 0;
+  return weighted.map((token, index) => {
+    const remaining = estimatedMs - cursor;
+    const sliceMs = index === weighted.length - 1 ? remaining : Math.max(120, Math.round(token.weight / totalWeight * estimatedMs));
+    const startMs = cursor;
+    const endMs = Math.min(estimatedMs, startMs + sliceMs);
+    cursor = endMs;
+    return {
+      text: token.text,
+      startMs,
+      endMs
+    };
+  });
+};
+var buildVoiceScript = (plan) => {
+  return plan.scenes.map((scene) => {
+    const estimatedMs = estimateMs(scene.narration);
+    return {
+      sceneId: scene.id,
+      text: scene.narration,
+      estimatedMs,
+      tokens: tokenizeNarration(scene.narration, estimatedMs)
+    };
+  });
+};
+
+// src/voice/tts.ts
+import { execFile as execFile5 } from "child_process";
+import { access as access4, mkdir as mkdir7, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join6 } from "path";
+import { promisify as promisify5 } from "util";
+
+// src/lib/data-uri.ts
+import { readFile as readFile3 } from "fs/promises";
+import { extname } from "path";
+var MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".m4a": "audio/mp4",
+  ".webm": "video/webm",
+  ".mp4": "video/mp4"
+};
+var fileToDataUri = async (path) => {
+  const buffer = await readFile3(path);
+  const ext = extname(path).toLowerCase();
+  const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+  return `data:${mimeType};base64,${buffer.toString("base64")}`;
+};
+
+// src/lib/media.ts
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync4 = promisify4(execFile4);
+var getMediaDurationMs = async (path) => {
+  try {
+    const { stdout } = await execFileAsync4("ffprobe", [
+      "-v",
+      "error",
+      "-show_entries",
+      "format=duration",
+      "-of",
+      "default=noprint_wrappers=1:nokey=1",
+      path
+    ]);
+    const seconds = Number(stdout.trim());
+    if (!Number.isFinite(seconds) || seconds <= 0) return void 0;
+    return Math.round(seconds * 1e3);
+  } catch {
+    return void 0;
+  }
+};
+
+// src/voice/tts.ts
+var execFileAsync5 = promisify5(execFile5);
+var parseOptionalNumber = (value) => {
+  if (!value?.trim()) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+};
+var parseOptionalBoolean = (value) => {
+  if (!value?.trim()) return void 0;
+  if (["1", "true", "yes", "on"].includes(value.toLowerCase())) return true;
+  if (["0", "false", "no", "off"].includes(value.toLowerCase())) return false;
+  return void 0;
+};
+var normalizeBaseUrl = (baseUrl) => baseUrl.replace(/\/+$/, "");
+var getTtsConfig = () => {
+  return {
+    provider: process.env.DEMO_TTS_PROVIDER ?? "auto",
+    openAiApiKey: process.env.DEMO_OPENAI_API_KEY,
+    openAiBaseUrl: process.env.DEMO_OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+    openAiModel: process.env.DEMO_TTS_MODEL ?? "gpt-4o-mini-tts",
+    openAiVoice: process.env.DEMO_TTS_VOICE ?? "alloy",
+    elevenlabsApiKey: process.env.DEMO_ELEVENLABS_API_KEY,
+    elevenlabsBaseUrl: process.env.DEMO_ELEVENLABS_BASE_URL ?? "https://api.elevenlabs.io/v1",
+    elevenlabsVoiceId: process.env.DEMO_ELEVENLABS_VOICE_ID,
+    elevenlabsModel: process.env.DEMO_ELEVENLABS_MODEL ?? "eleven_multilingual_v2",
+    elevenlabsOutputFormat: process.env.DEMO_ELEVENLABS_OUTPUT_FORMAT ?? "mp3_44100_128",
+    elevenlabsStability: parseOptionalNumber(process.env.DEMO_ELEVENLABS_STABILITY),
+    elevenlabsSimilarityBoost: parseOptionalNumber(process.env.DEMO_ELEVENLABS_SIMILARITY_BOOST),
+    elevenlabsStyle: parseOptionalNumber(process.env.DEMO_ELEVENLABS_STYLE),
+    elevenlabsSpeakerBoost: parseOptionalBoolean(process.env.DEMO_ELEVENLABS_SPEAKER_BOOST),
+    localVoice: process.env.DEMO_LOCAL_TTS_VOICE ?? "Samantha",
+    localRate: process.env.DEMO_LOCAL_TTS_RATE ?? "185"
+  };
+};
+var commandExists2 = async (command) => {
+  try {
+    await access4(command);
+    return true;
+  } catch {
+    try {
+      await execFileAsync5("which", [command]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var retimeLineToAudioDuration = (line, audioDurationMs) => {
+  if (!audioDurationMs || !line.tokens.length || line.estimatedMs <= 0) {
+    return {
+      ...line,
+      audioDurationMs
+    };
+  }
+  const scale = audioDurationMs / line.estimatedMs;
+  return {
+    ...line,
+    audioDurationMs,
+    tokens: line.tokens.map((token, index) => ({
+      ...token,
+      startMs: Math.max(0, Math.round(token.startMs * scale)),
+      endMs: index === line.tokens.length - 1 ? audioDurationMs : Math.max(1, Math.round(token.endMs * scale))
+    }))
+  };
+};
+var writeAudioLine = async (line, audioPath, arrayBuffer) => {
+  await writeFile4(audioPath, Buffer.from(arrayBuffer));
+  const audioDurationMs = await getMediaDurationMs(audioPath);
+  const timedLine = retimeLineToAudioDuration(line, audioDurationMs);
+  return {
+    ...timedLine,
+    audioPath,
+    audioSrc: await fileToDataUri(audioPath)
+  };
+};
+var synthesizeOpenAiLine = async (line, outputDir, config) => {
+  if (!config.openAiApiKey) throw new Error("OpenAI TTS not configured. Set DEMO_OPENAI_API_KEY.");
+  const response = await fetch(`${normalizeBaseUrl(config.openAiBaseUrl)}/audio/speech`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${config.openAiApiKey}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model: config.openAiModel,
+      voice: config.openAiVoice,
+      input: line.text,
+      format: "mp3"
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OpenAI TTS request failed: ${response.status} ${errorText}`);
+  }
+  return writeAudioLine(line, join6(outputDir, `${line.sceneId}.mp3`), await response.arrayBuffer());
+};
+var synthesizeElevenLabsLine = async (line, outputDir, config) => {
+  if (!config.elevenlabsApiKey) throw new Error("ElevenLabs TTS not configured. Set DEMO_ELEVENLABS_API_KEY.");
+  if (!config.elevenlabsVoiceId) throw new Error("ElevenLabs voice id not configured");
+  const voiceSettings = {
+    ...config.elevenlabsStability === void 0 ? {} : { stability: config.elevenlabsStability },
+    ...config.elevenlabsSimilarityBoost === void 0 ? {} : { similarity_boost: config.elevenlabsSimilarityBoost },
+    ...config.elevenlabsStyle === void 0 ? {} : { style: config.elevenlabsStyle },
+    ...config.elevenlabsSpeakerBoost === void 0 ? {} : { use_speaker_boost: config.elevenlabsSpeakerBoost }
+  };
+  const response = await fetch(
+    `${normalizeBaseUrl(config.elevenlabsBaseUrl)}/text-to-speech/${encodeURIComponent(config.elevenlabsVoiceId)}`,
+    {
+      method: "POST",
+      headers: {
+        accept: "audio/mpeg",
+        "content-type": "application/json",
+        "xi-api-key": config.elevenlabsApiKey
+      },
+      body: JSON.stringify({
+        text: line.text,
+        model_id: config.elevenlabsModel,
+        output_format: config.elevenlabsOutputFormat,
+        ...Object.keys(voiceSettings).length > 0 ? { voice_settings: voiceSettings } : {}
+      })
+    }
+  );
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`ElevenLabs TTS request failed: ${response.status} ${errorText}`);
+  }
+  return writeAudioLine(line, join6(outputDir, `${line.sceneId}.mp3`), await response.arrayBuffer());
+};
+var synthesizeLocalLine = async (line, outputDir, config) => {
+  const hasSay = await commandExists2("say");
+  const hasFfmpeg = await commandExists2("ffmpeg");
+  if (!hasSay || !hasFfmpeg) {
+    throw new Error("Local TTS tools not available");
+  }
+  const tempDir = await mkdtemp2(join6(tmpdir2(), "demo-dev-tts-"));
+  const aiffPath = join6(tempDir, `${line.sceneId}.aiff`);
+  const audioPath = join6(outputDir, `${line.sceneId}.mp3`);
+  try {
+    await execFileAsync5("say", ["-v", config.localVoice, "-r", config.localRate, "-o", aiffPath, line.text], {
+      maxBuffer: 1024 * 1024 * 10
+    });
+    await execFileAsync5(
+      "ffmpeg",
+      ["-y", "-i", aiffPath, "-codec:a", "libmp3lame", "-q:a", "3", audioPath],
+      { maxBuffer: 1024 * 1024 * 10 }
+    );
+    const audioDurationMs = await getMediaDurationMs(audioPath);
+    const timedLine = retimeLineToAudioDuration(line, audioDurationMs);
+    return {
+      ...timedLine,
+      audioPath,
+      audioSrc: await fileToDataUri(audioPath)
+    };
+  } finally {
+    await rm2(tempDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+};
+var getProviderOrder = (config) => {
+  switch (config.provider) {
+    case "elevenlabs":
+      return ["elevenlabs"];
+    case "openai":
+      return ["openai"];
+    case "local":
+      return ["local"];
+    case "auto":
+    default: {
+      const providers = [];
+      if (config.elevenlabsApiKey && config.elevenlabsVoiceId) providers.push("elevenlabs");
+      if (config.openAiApiKey) providers.push("openai");
+      providers.push("local");
+      return providers;
+    }
+  }
+};
+var synthesizeWithProvider = async (provider, line, outputDir, config) => {
+  switch (provider) {
+    case "elevenlabs":
+      return synthesizeElevenLabsLine(line, outputDir, config);
+    case "openai":
+      return synthesizeOpenAiLine(line, outputDir, config);
+    case "local":
+      return synthesizeLocalLine(line, outputDir, config);
+  }
+};
+var synthesizeVoice = async (lines, options = {}) => {
+  const outputDir = options.outputDir ?? "artifacts/audio";
+  const config = getTtsConfig();
+  const providers = getProviderOrder(config);
+  await mkdir7(outputDir, { recursive: true });
+  const results = [];
+  for (const line of lines) {
+    let synthesized;
+    const errors = [];
+    for (const provider of providers) {
+      try {
+        synthesized = await synthesizeWithProvider(provider, line, outputDir, config);
+        break;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`${provider}: ${message}`);
+      }
+    }
+    if (synthesized) {
+      results.push(synthesized);
+      continue;
+    }
+    console.warn(`TTS failed for ${line.sceneId}, fallback to text-only`, errors.join(" | "));
+    results.push(line);
+  }
+  return results;
+};
+export {
+  applyProjectEnvironment,
+  buildPromptPlan,
+  buildVisualPlan,
+  buildVoiceScript,
+  capturePlanContinuous,
+  composeVideo,
+  loadProjectConfig,
+  synthesizeVoice,
+  writeJson
+};