@t3lnet/sceneforge 1.0.0

package/dist/index.js

@@ -0,0 +1,2064 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../shared/src/yaml-parser.ts
+import { parse, stringify } from "yaml";
+
+// ../shared/src/schema.ts
+import { z } from "zod";
+var DEMO_SCHEMA_VERSION = 1;
+var stepTargetSchema = z.object({
+  type: z.enum(["button", "link", "input", "text", "selector"]),
+  text: z.string().optional(),
+  selector: z.string().optional(),
+  name: z.string().optional()
+}).strict().superRefine((target, ctx) => {
+  switch (target.type) {
+    case "selector":
+      if (!target.selector) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "selector target requires selector"
+        });
+      }
+      break;
+    case "text":
+      if (!target.text) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "text target requires text"
+        });
+      }
+      break;
+    case "button":
+    case "link":
+    case "input":
+      if (!target.text && !target.name && !target.selector) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "target requires text, name, or selector"
+        });
+      }
+      break;
+  }
+});
+var waitConditionSchema = z.object({
+  type: z.enum(["text", "selector", "navigation", "idle", "selectorHidden", "textHidden"]),
+  value: z.string().optional(),
+  timeout: z.coerce.number().int().positive().optional()
+}).strict().superRefine((condition, ctx) => {
+  if (["text", "selector", "selectorHidden", "textHidden"].includes(condition.type)) {
+    if (!condition.value) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `wait condition '${condition.type}' requires value`
+      });
+    }
+  }
+});
+var dragConfigSchema = z.object({
+  deltaX: z.coerce.number(),
+  deltaY: z.coerce.number(),
+  steps: z.coerce.number().int().positive().optional()
+}).strict();
+var waitActionSchema = z.object({
+  action: z.literal("wait"),
+  duration: z.coerce.number().nonnegative().optional(),
+  waitFor: waitConditionSchema.optional()
+}).strict().superRefine((action, ctx) => {
+  if (action.duration === void 0 && action.waitFor === void 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "wait action requires duration or waitFor"
+    });
+  }
+});
+var navigateActionSchema = z.object({
+  action: z.literal("navigate"),
+  path: z.string().min(1),
+  waitFor: waitConditionSchema.optional()
+}).strict();
+var clickActionSchema = z.object({
+  action: z.literal("click"),
+  target: stepTargetSchema,
+  highlight: z.boolean().optional(),
+  waitFor: waitConditionSchema.optional()
+}).strict();
+var typeActionSchema = z.object({
+  action: z.literal("type"),
+  target: stepTargetSchema,
+  text: z.string(),
+  waitFor: waitConditionSchema.optional()
+}).strict();
+var uploadActionSchema = z.object({
+  action: z.literal("upload"),
+  file: z.string().min(1),
+  target: stepTargetSchema.optional(),
+  waitFor: waitConditionSchema.optional()
+}).strict();
+var hoverActionSchema = z.object({
+  action: z.literal("hover"),
+  target: stepTargetSchema,
+  waitFor: waitConditionSchema.optional()
+}).strict();
+var scrollActionSchema = z.object({
+  action: z.literal("scroll"),
+  duration: z.coerce.number().optional(),
+  waitFor: waitConditionSchema.optional()
+}).strict();
+var scrollToActionSchema = z.object({
+  action: z.literal("scrollTo"),
+  target: stepTargetSchema,
+  waitFor: waitConditionSchema.optional()
+}).strict();
+var dragActionSchema = z.object({
+  action: z.literal("drag"),
+  target: stepTargetSchema,
+  drag: dragConfigSchema,
+  waitFor: waitConditionSchema.optional()
+}).strict();
+var actionSchema = z.union([
+  navigateActionSchema,
+  clickActionSchema,
+  typeActionSchema,
+  uploadActionSchema,
+  waitActionSchema,
+  hoverActionSchema,
+  scrollActionSchema,
+  scrollToActionSchema,
+  dragActionSchema
+]);
+var demoStepSchema = z.object({
+  id: z.string().min(1),
+  script: z.string(),
+  actions: z.array(actionSchema)
+}).strict();
+var videoSegmentSchema = z.object({
+  file: z.string().min(1),
+  duration: z.coerce.number().positive().optional(),
+  fade: z.boolean().optional(),
+  fadeDuration: z.coerce.number().positive().optional()
+}).strict();
+var musicStartPointSchema = z.union([
+  z.object({ type: z.literal("beginning") }).strict(),
+  z.object({ type: z.literal("afterIntro") }).strict(),
+  z.object({ type: z.literal("step"), stepId: z.string().min(1) }).strict(),
+  z.object({ type: z.literal("time"), seconds: z.coerce.number().nonnegative() }).strict()
+]);
+var musicEndPointSchema = z.union([
+  z.object({ type: z.literal("end") }).strict(),
+  z.object({ type: z.literal("beforeOutro") }).strict(),
+  z.object({ type: z.literal("step"), stepId: z.string().min(1) }).strict(),
+  z.object({ type: z.literal("time"), seconds: z.coerce.number().nonnegative() }).strict()
+]);
+var backgroundMusicSchema = z.object({
+  file: z.string().min(1),
+  volume: z.coerce.number().min(0).max(1).optional(),
+  startAt: musicStartPointSchema.optional(),
+  endAt: musicEndPointSchema.optional(),
+  loop: z.boolean().optional(),
+  fadeIn: z.coerce.number().nonnegative().optional(),
+  fadeOut: z.coerce.number().nonnegative().optional()
+}).strict();
+var mediaConfigSchema = z.object({
+  intro: videoSegmentSchema.optional(),
+  outro: videoSegmentSchema.optional(),
+  backgroundMusic: backgroundMusicSchema.optional()
+}).strict();
+var demoDefinitionSchema = z.object({
+  version: z.coerce.number().int().positive().default(DEMO_SCHEMA_VERSION),
+  name: z.string().min(1),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  steps: z.array(demoStepSchema),
+  media: mediaConfigSchema.optional()
+}).strict();
+function formatValidationError(error) {
+  if (!error || typeof error !== "object" || !("issues" in error)) {
+    return "Invalid demo definition";
+  }
+  const issues = error.issues;
+  return issues.map((issue) => {
+    const path4 = issue.path.length ? issue.path.join(".") : "root";
+    return `${path4}: ${issue.message}`;
+  }).join("; ");
+}
+function parseDemoDefinition(input) {
+  return demoDefinitionSchema.parse(input);
+}
+function safeParseDemoDefinition(input) {
+  return demoDefinitionSchema.safeParse(input);
+}
+
+// ../shared/src/yaml-parser.ts
+function parseFromYAML(yamlString, options) {
+  const parsed = parse(yamlString);
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Invalid YAML: expected an object");
+  }
+  const resolved = options?.resolveSecrets ? resolveSecrets(parsed, options.resolveSecrets) : parsed;
+  try {
+    return parseDemoDefinition(resolved);
+  } catch (error) {
+    throw new Error(formatValidationError(error));
+  }
+}
+function serializeToYAML(demo) {
+  const cleanDemo = {
+    version: demo.version ?? DEMO_SCHEMA_VERSION,
+    name: demo.name,
+    title: demo.title,
+    ...demo.description && { description: demo.description },
+    steps: demo.steps.map(serializeStep)
+  };
+  return stringify(cleanDemo, {
+    indent: 2,
+    lineWidth: 100,
+    defaultStringType: "QUOTE_DOUBLE",
+    defaultKeyType: "PLAIN"
+  });
+}
+function serializeStep(step) {
+  return {
+    id: step.id,
+    script: step.script,
+    actions: step.actions.map(serializeAction)
+  };
+}
+function serializeAction(action) {
+  const result = {
+    action: action.action
+  };
+  if (action.path !== void 0) {
+    result.path = action.path;
+  }
+  if (action.target !== void 0) {
+    result.target = serializeTarget(action.target);
+  }
+  if (action.text !== void 0) {
+    result.text = action.text;
+  }
+  if (action.file !== void 0) {
+    result.file = action.file;
+  }
+  if (action.duration !== void 0) {
+    result.duration = action.duration;
+  }
+  if (action.highlight === true) {
+    result.highlight = true;
+  }
+  if (action.waitFor !== void 0) {
+    result.waitFor = serializeWaitCondition(action.waitFor);
+  }
+  if (action.drag !== void 0) {
+    result.drag = {
+      deltaX: action.drag.deltaX,
+      deltaY: action.drag.deltaY,
+      ...action.drag.steps !== void 0 && { steps: action.drag.steps }
+    };
+  }
+  return result;
+}
+function serializeTarget(target) {
+  const result = {
+    type: target.type
+  };
+  if (target.text !== void 0) {
+    result.text = target.text;
+  }
+  if (target.selector !== void 0) {
+    result.selector = target.selector;
+  }
+  if (target.name !== void 0) {
+    result.name = target.name;
+  }
+  return result;
+}
+function serializeWaitCondition(waitFor) {
+  const result = {
+    type: waitFor.type
+  };
+  if (waitFor.value !== void 0) {
+    result.value = waitFor.value;
+  }
+  if (waitFor.timeout !== void 0) {
+    result.timeout = waitFor.timeout;
+  }
+  return result;
+}
+function validateDemoDefinition(definition) {
+  const result = safeParseDemoDefinition(definition);
+  if (!result.success) {
+    throw new Error(formatValidationError(result.error));
+  }
+}
+function createEmptyDemo() {
+  return {
+    version: DEMO_SCHEMA_VERSION,
+    name: "new-demo",
+    title: "New Demo",
+    description: "",
+    steps: []
+  };
+}
+function createEmptyStep(id) {
+  const stepId = id || `step-${Date.now()}`;
+  return {
+    id: stepId,
+    script: "",
+    actions: []
+  };
+}
+var SECRET_PATTERN = /\$\{(ENV|SECRET):([A-Za-z0-9_]+)\}/g;
+function resolveSecrets(value, resolver, path4 = "root") {
+  if (typeof value === "string") {
+    if (!SECRET_PATTERN.test(value)) {
+      return value;
+    }
+    SECRET_PATTERN.lastIndex = 0;
+    return value.replace(SECRET_PATTERN, (_match, _type, key) => {
+      const resolved = resolver(key);
+      if (resolved === void 0) {
+        throw new Error(`Missing secret for ${key} at ${path4}`);
+      }
+      return resolved;
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry, index) => resolveSecrets(entry, resolver, `${path4}[${index}]`)
+    );
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+      result[key] = resolveSecrets(entry, resolver, `${path4}.${key}`);
+    }
+    return result;
+  }
+  return value;
+}
+
+// ../shared/src/target-resolver.ts
+function resolveTarget(target) {
+  if (target.selector) {
+    return target.selector;
+  }
+  switch (target.type) {
+    case "button":
+      if (target.text) {
+        return `button:has-text("${target.text}"), [role="button"]:has-text("${target.text}")`;
+      }
+      if (target.name) {
+        return `button[name="${target.name}"], [role="button"][name="${target.name}"]`;
+      }
+      break;
+    case "link":
+      if (target.text) {
+        return `a:has-text("${target.text}")`;
+      }
+      if (target.name) {
+        return `a[name="${target.name}"]`;
+      }
+      break;
+    case "input":
+      if (target.name) {
+        return `input[name="${target.name}"], textarea[name="${target.name}"]`;
+      }
+      if (target.text) {
+        return `label:has-text("${target.text}") + input, label:has-text("${target.text}") input`;
+      }
+      break;
+    case "text":
+      if (target.text) {
+        return `text="${target.text}"`;
+      }
+      break;
+    case "selector":
+      break;
+  }
+  throw new Error(`Unable to resolve target: ${JSON.stringify(target)}`);
+}
+function resolvePath(pathTemplate, variables) {
+  let result = pathTemplate;
+  for (const [key, value] of Object.entries(variables)) {
+    if (value === void 0) {
+      continue;
+    }
+    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), value);
+  }
+  return result;
+}
+
+// ../shared/src/action-helpers.ts
+function createClickAction(selector, highlight = false) {
+  return {
+    action: "click",
+    target: {
+      type: "selector",
+      selector
+    },
+    highlight
+  };
+}
+function createTypeAction(selector, text) {
+  return {
+    action: "type",
+    target: {
+      type: "selector",
+      selector
+    },
+    text
+  };
+}
+function createNavigateAction(path4) {
+  return {
+    action: "navigate",
+    path: path4
+  };
+}
+function createWaitAction(duration) {
+  return {
+    action: "wait",
+    duration
+  };
+}
+function createWaitForAction(type, value, timeout = 15e3) {
+  return {
+    action: "wait",
+    waitFor: {
+      type,
+      value,
+      timeout
+    }
+  };
+}
+function createUploadAction(file, selector) {
+  const action = {
+    action: "upload",
+    file
+  };
+  if (selector) {
+    action.target = {
+      type: "selector",
+      selector
+    };
+  }
+  return action;
+}
+function createHoverAction(selector) {
+  return {
+    action: "hover",
+    target: {
+      type: "selector",
+      selector
+    }
+  };
+}
+function createScrollAction(duration = 500) {
+  return {
+    action: "scroll",
+    duration
+  };
+}
+function createScrollToAction(selector) {
+  return {
+    action: "scrollTo",
+    target: {
+      type: "selector",
+      selector
+    }
+  };
+}
+function createDragAction(selector, deltaX, deltaY, steps = 20) {
+  return {
+    action: "drag",
+    target: {
+      type: "selector",
+      selector
+    },
+    drag: {
+      deltaX,
+      deltaY,
+      steps
+    }
+  };
+}
+
+// ../playwright/src/demo-runner.ts
+import { expect } from "@playwright/test";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+
+// ../generation/src/voice-synthesis.ts
+import { spawn } from "child_process";
+import { ElevenLabsClient } from "elevenlabs";
+import * as fs from "fs/promises";
+import * as path from "path";
+var DEFAULT_MAX_OUTPUT_BYTES = 512 * 1024;
+var DEFAULT_MAX_CONCURRENCY = 2;
+var DEFAULT_RETRY_OPTIONS = {
+  retries: 3,
+  minDelayMs: 500,
+  maxDelayMs: 8e3
+};
+function sanitizeFileSegment(value, fallback = "segment", maxLength = 80) {
+  const raw = String(value ?? "").trim();
+  if (!raw) {
+    return fallback;
+  }
+  const cleaned = raw.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const collapsed = cleaned.replace(/_{2,}/g, "_").replace(/^_+|_+$/g, "");
+  const safe = collapsed || fallback;
+  const trimmed = safe.length > maxLength ? safe.slice(0, maxLength) : safe;
+  if (trimmed === "." || trimmed === "..") {
+    return fallback;
+  }
+  return trimmed;
+}
+function appendWithLimit(buffer, chunk, limit) {
+  const next = buffer + chunk;
+  if (next.length <= limit) {
+    return next;
+  }
+  return next.slice(next.length - limit);
+}
+function runCommand(command, args, options = {}) {
+  const {
+    stdio = ["ignore", "pipe", "pipe"],
+    cwd,
+    maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES
+  } = options;
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, { stdio, cwd });
+    let stdout = "";
+    let stderr = "";
+    if (child.stdout) {
+      child.stdout.on("data", (chunk) => {
+        stdout = appendWithLimit(stdout, chunk.toString(), maxOutputBytes);
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        stderr = appendWithLimit(stderr, chunk.toString(), maxOutputBytes);
+      });
+    }
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2({ stdout, stderr });
+        return;
+      }
+      const error = new Error(`${command} exited with code ${code}`);
+      error.code = code ?? void 0;
+      error.stderr = stderr;
+      reject(error);
+    });
+  });
+}
+async function probeMediaDurationMs(filePath) {
+  try {
+    const { stdout } = await runCommand("ffprobe", [
+      "-v",
+      "error",
+      "-show_entries",
+      "format=duration",
+      "-of",
+      "default=noprint_wrappers=1:nokey=1",
+      filePath
+    ]);
+    const durationSec = parseFloat(stdout.trim());
+    if (Number.isFinite(durationSec)) {
+      return Math.round(durationSec * 1e3);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function getStatusCode(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const maybeError = error;
+  return maybeError.status ?? maybeError.statusCode ?? maybeError.response?.status;
+}
+function getHeaderValue(headers, name) {
+  if (!headers || typeof headers !== "object") {
+    return null;
+  }
+  const getter = headers.get;
+  if (typeof getter === "function") {
+    return getter.call(headers, name);
+  }
+  const record = headers;
+  const direct = record[name];
+  if (typeof direct === "string") {
+    return direct;
+  }
+  const lower = record[name.toLowerCase()];
+  if (typeof lower === "string") {
+    return lower;
+  }
+  const upper = record[name.toUpperCase()];
+  if (typeof upper === "string") {
+    return upper;
+  }
+  return null;
+}
+function getRetryAfterMs(error) {
+  if (!error || typeof error !== "object") return null;
+  const maybeError = error;
+  const headerValue = getHeaderValue(maybeError.response?.headers, "retry-after");
+  const retryAfter = headerValue ?? maybeError.retryAfter;
+  if (retryAfter === void 0 || retryAfter === null) {
+    return null;
+  }
+  const seconds = Number(retryAfter);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, Math.round(seconds * 1e3));
+  }
+  return null;
+}
+function isRetryableError(error) {
+  const status = getStatusCode(error);
+  if (status && [408, 429, 500, 502, 503, 504].includes(status)) {
+    return true;
+  }
+  const message = String(error?.message ?? "");
+  return /(rate limit|timeout|ECONNRESET|ETIMEDOUT|EAI_AGAIN|socket hang up)/i.test(message);
+}
+function getRetryDelayMs(attempt, options, error) {
+  const minDelayMs = options.minDelayMs ?? DEFAULT_RETRY_OPTIONS.minDelayMs;
+  const maxDelayMs = options.maxDelayMs ?? DEFAULT_RETRY_OPTIONS.maxDelayMs;
+  const baseDelay = Math.min(maxDelayMs, minDelayMs * 2 ** attempt);
+  const jitter = 0.5 + Math.random();
+  const retryAfterMs = getRetryAfterMs(error) ?? 0;
+  return Math.max(retryAfterMs, Math.round(baseDelay * jitter));
+}
+async function withRetry(fn, options = {}) {
+  const retries = options.retries ?? DEFAULT_RETRY_OPTIONS.retries;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (!isRetryableError(error) || attempt >= retries) {
+        throw error;
+      }
+      const delayMs = getRetryDelayMs(attempt, options, error);
+      await sleep(delayMs);
+      attempt += 1;
+    }
+  }
+}
+var VoiceSynthesizer = class {
+  constructor(config) {
+    __publicField(this, "client");
+    __publicField(this, "config");
+    this.config = config;
+    this.client = new ElevenLabsClient({
+      apiKey: config.apiKey
+    });
+  }
+  /**
+   * List available voices (useful for finding voice IDs)
+   */
+  async listVoices() {
+    const response = await this.client.voices.getAll();
+    return response.voices.map((voice) => ({
+      voiceId: voice.voice_id,
+      name: voice.name || "Unnamed",
+      category: voice.category || "unknown"
+    }));
+  }
+  /**
+   * Synthesize a single text segment to audio
+   */
+  async synthesizeSegment(text, outputPath, options) {
+    const audio = await this.client.textToSpeech.convert(this.config.voiceId, {
+      text,
+      model_id: this.config.modelId || "eleven_multilingual_v2",
+      voice_settings: {
+        stability: options?.stability ?? 0.5,
+        similarity_boost: options?.similarityBoost ?? 0.75,
+        style: options?.style ?? 0,
+        use_speaker_boost: options?.useSpeakerBoost ?? true
+      }
+    });
+    const chunks = [];
+    for await (const chunk of audio) {
+      chunks.push(Buffer.from(chunk));
+    }
+    const audioBuffer = Buffer.concat(chunks);
+    await fs.writeFile(outputPath, audioBuffer);
+    const probedDurationMs = await probeMediaDurationMs(outputPath);
+    if (probedDurationMs !== null) {
+      return { durationMs: probedDurationMs };
+    }
+    const fileSizeBytes = audioBuffer.length;
+    const estimatedDurationMs = Math.round(fileSizeBytes * 8 / 128);
+    console.warn(`[voice] ffprobe unavailable, using estimated duration for ${outputPath}`);
+    return { durationMs: estimatedDurationMs };
+  }
+  /**
+   * Generate a sound effect from text description
+   */
+  async generateSoundEffect(description, outputPath, options) {
+    const audio = await withRetry(
+      () => this.client.textToSoundEffects.convert({
+        text: description,
+        duration_seconds: options?.durationSeconds ?? 1,
+        prompt_influence: options?.promptInfluence ?? 0.3
+      }),
+      options?.retry
+    );
+    const chunks = [];
+    for await (const chunk of audio) {
+      chunks.push(Buffer.from(chunk));
+    }
+    await fs.writeFile(outputPath, Buffer.concat(chunks));
+  }
+  /**
+   * Synthesize all segments from a script JSON file
+   */
+  async synthesizeScript(scriptPath, outputDir, options) {
+    const scriptContent = await fs.readFile(scriptPath, "utf-8");
+    const script = JSON.parse(scriptContent);
+    const audioDir = path.join(outputDir, "audio", script.demoName);
+    await fs.mkdir(audioDir, { recursive: true });
+    const synthesizedSegments = new Array(script.segments.length);
+    const maxConcurrency = Math.max(
+      1,
+      options?.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY
+    );
+    let progressCount = 0;
+    let nextIndex = 0;
+    const workers = Array.from({ length: Math.min(maxConcurrency, script.segments.length) }, async () => {
+      while (true) {
+        const index = nextIndex;
+        nextIndex += 1;
+        if (index >= script.segments.length) {
+          break;
+        }
+        const segment = script.segments[index];
+        const safeStepId = sanitizeFileSegment(segment.stepId, `step-${index + 1}`);
+        const audioFileName = `${String(index + 1).padStart(2, "0")}_${safeStepId}.mp3`;
+        const audioPath = path.join(audioDir, audioFileName);
+        progressCount += 1;
+        options?.onProgress?.(progressCount, script.segments.length, segment.stepId);
+        try {
+          const result = await withRetry(
+            () => this.synthesizeSegment(segment.text, audioPath, options?.voiceSettings),
+            options?.retry
+          );
+          synthesizedSegments[index] = {
+            stepId: segment.stepId,
+            audioPath,
+            durationMs: result.durationMs,
+            text: segment.text
+          };
+          console.log(`[voice] Synthesized: ${segment.stepId} (${result.durationMs.toFixed(0)}ms)`);
+        } catch (error) {
+          console.error(`[voice] Failed to synthesize ${segment.stepId}:`, error);
+          throw error;
+        }
+      }
+    });
+    await Promise.all(workers);
+    let soundEffectsPath;
+    if (options?.generateClickSounds) {
+      soundEffectsPath = path.join(audioDir, "click.mp3");
+      await this.generateClickSound(soundEffectsPath);
+    }
+    return {
+      demoName: script.demoName,
+      segments: synthesizedSegments,
+      soundEffectsPath
+    };
+  }
+  /**
+   * Generate a UI click sound effect
+   */
+  async generateClickSound(outputPath) {
+    await this.generateSoundEffect(
+      "soft UI button click, subtle, digital, clean interface sound",
+      outputPath,
+      { durationSeconds: 0.5, promptInfluence: 0.5 }
+    );
+    console.log("[voice] Generated click sound effect");
+  }
+  /**
+   * Generate ambient background music
+   */
+  async generateBackgroundMusic(outputPath, options) {
+    const styleDescriptions = {
+      corporate: "soft corporate background music, professional, minimal, ambient technology sounds",
+      tech: "modern technology background music, subtle electronic, innovative, clean",
+      calm: "calm ambient background music, peaceful, soft piano, gentle",
+      upbeat: "light upbeat background music, positive, motivational, subtle energy"
+    };
+    const description = styleDescriptions[options?.style || "tech"];
+    const duration = options?.durationSeconds ?? 30;
+    await this.generateSoundEffect(description, outputPath, {
+      durationSeconds: Math.min(duration, 30),
+      promptInfluence: 0.4
+    });
+    console.log(`[voice] Generated background music (${options?.style || "tech"} style)`);
+  }
+};
+async function generateTimingManifest(scriptPath, synthesisResult, outputPath) {
+  const scriptContent = await fs.readFile(scriptPath, "utf-8");
+  const script = JSON.parse(scriptContent);
+  const manifest = {
+    demoName: script.demoName,
+    segments: synthesisResult.segments.map((synth) => {
+      const originalSegment = script.segments.find((s) => s.stepId === synth.stepId);
+      return {
+        stepId: synth.stepId,
+        audioFile: synth.audioPath,
+        videoStartTimeMs: originalSegment?.startTimeMs ?? 0,
+        audioDurationMs: synth.durationMs,
+        text: synth.text
+      };
+    }),
+    soundEffects: synthesisResult.soundEffectsPath ? { clickSound: synthesisResult.soundEffectsPath } : void 0,
+    backgroundMusic: synthesisResult.backgroundMusicPath
+  };
+  await fs.writeFile(outputPath, JSON.stringify(manifest, null, 2));
+  return manifest;
+}
+function createVoiceSynthesizer(config) {
+  return new VoiceSynthesizer(config);
+}
+
+// ../generation/src/script-generator.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var ScriptGenerator = class {
+  constructor(demoName, title, startTimeMs) {
+    __publicField(this, "segments", []);
+    __publicField(this, "stepBoundaries", []);
+    __publicField(this, "currentStepId", null);
+    __publicField(this, "currentStepStartMs", null);
+    __publicField(this, "demoName");
+    __publicField(this, "title");
+    __publicField(this, "startTime");
+    this.demoName = demoName;
+    this.title = title;
+    this.startTime = startTimeMs ?? Date.now();
+  }
+  /**
+   * Marks the start of a step (for video splitting).
+   */
+  startStep(stepId) {
+    if (this.currentStepId && this.currentStepStartMs !== null) {
+      this.stepBoundaries.push({
+        stepId: this.currentStepId,
+        stepIndex: this.stepBoundaries.length,
+        videoStartMs: this.currentStepStartMs,
+        videoEndMs: Date.now() - this.startTime
+      });
+    }
+    this.currentStepId = stepId;
+    this.currentStepStartMs = Date.now() - this.startTime;
+  }
+  /**
+   * Marks the end of all steps (call at demo completion).
+   */
+  finishAllSteps() {
+    if (this.currentStepId && this.currentStepStartMs !== null) {
+      this.stepBoundaries.push({
+        stepId: this.currentStepId,
+        stepIndex: this.stepBoundaries.length,
+        videoStartMs: this.currentStepStartMs,
+        videoEndMs: Date.now() - this.startTime
+      });
+      this.currentStepId = null;
+      this.currentStepStartMs = null;
+    }
+  }
+  /**
+   * Estimates reading duration for text.
+   * Based on ~150 words per minute average speaking rate.
+   */
+  estimateReadingDuration(text) {
+    const words = text.split(/\s+/).length;
+    const wpm = 150;
+    return Math.round(words / wpm * 60 * 1e3);
+  }
+  /**
+   * Adds a narration segment with automatic timing.
+   */
+  addSegment(stepId, text, options) {
+    const now = Date.now();
+    const startTimeMs = now - this.startTime;
+    const estimatedDurationMs = this.estimateReadingDuration(text);
+    this.segments.push({
+      stepId,
+      text,
+      startTimeMs,
+      endTimeMs: startTimeMs + estimatedDurationMs,
+      estimatedDurationMs,
+      pauseBeforeMs: options?.pauseBeforeMs,
+      pauseAfterMs: options?.pauseAfterMs
+    });
+  }
+  /**
+   * Updates the end time of the last segment.
+   * Call this when a step completes to capture actual duration.
+   */
+  completeLastSegment() {
+    if (this.segments.length > 0) {
+      const lastSegment = this.segments[this.segments.length - 1];
+      lastSegment.endTimeMs = Date.now() - this.startTime;
+    }
+  }
+  /**
+   * Generates the complete script output.
+   */
+  getOutput() {
+    const now = Date.now();
+    return {
+      demoName: this.demoName,
+      title: this.title,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalDurationMs: now - this.startTime,
+      segments: this.segments,
+      stepBoundaries: this.stepBoundaries
+    };
+  }
+  /**
+   * Exports script as JSON.
+   */
+  async exportJSON(outputPath) {
+    const output = this.getOutput();
+    await fs2.mkdir(path2.dirname(outputPath), { recursive: true });
+    await fs2.writeFile(outputPath, JSON.stringify(output, null, 2));
+  }
+  /**
+   * Exports script as SRT subtitle format.
+   */
+  async exportSRT(outputPath) {
+    const output = this.getOutput();
+    let srt = "";
+    output.segments.forEach((segment, index) => {
+      const startTime = formatSRTTime(segment.startTimeMs);
+      const endTime = formatSRTTime(segment.endTimeMs);
+      srt += `${index + 1}
+`;
+      srt += `${startTime} --> ${endTime}
+`;
+      srt += `${segment.text}
+
+`;
+    });
+    await fs2.mkdir(path2.dirname(outputPath), { recursive: true });
+    await fs2.writeFile(outputPath, srt.trim());
+  }
+  /**
+   * Exports script in a format suitable for AI voice generation services.
+   * Includes SSML-like pause markers.
+   */
+  async exportAIVoiceScript(outputPath) {
+    const output = this.getOutput();
+    const voiceScript = {
+      demoName: output.demoName,
+      title: output.title,
+      totalDuration: formatReadableTime(output.totalDurationMs),
+      segments: output.segments.map((segment, index) => ({
+        index: index + 1,
+        stepId: segment.stepId,
+        text: segment.text,
+        ssmlHints: generateSSMLHints(segment),
+        pauseBeforeMs: segment.pauseBeforeMs || 0,
+        pauseAfterMs: segment.pauseAfterMs || 500,
+        syncPointMs: segment.startTimeMs
+      }))
+    };
+    await fs2.mkdir(path2.dirname(outputPath), { recursive: true });
+    await fs2.writeFile(outputPath, JSON.stringify(voiceScript, null, 2));
+  }
+  /**
+   * Exports script as human-readable markdown for voice actors.
+   */
+  async exportMarkdown(outputPath) {
+    const output = this.getOutput();
+    let markdown = `# ${output.title}
+
+`;
+    markdown += `**Demo:** ${output.demoName}
+`;
+    markdown += `**Total Duration:** ${formatReadableTime(output.totalDurationMs)}
+`;
+    markdown += `**Generated:** ${output.generatedAt}
+
+`;
+    markdown += `---
+
+`;
+    markdown += `## Script
+
+`;
+    output.segments.forEach((segment, index) => {
+      markdown += `### ${index + 1}. ${segment.stepId}
+
+`;
+      markdown += `**Timing:** ${formatReadableTime(segment.startTimeMs)} - ${formatReadableTime(segment.endTimeMs)}
+
+`;
+      if (segment.pauseBeforeMs) {
+        markdown += `*[Pause ${segment.pauseBeforeMs}ms before]*
+
+`;
+      }
+      markdown += `> ${segment.text}
+
+`;
+      if (segment.pauseAfterMs) {
+        markdown += `*[Pause ${segment.pauseAfterMs}ms after]*
+
+`;
+      }
+      markdown += `---
+
+`;
+    });
+    await fs2.mkdir(path2.dirname(outputPath), { recursive: true });
+    await fs2.writeFile(outputPath, markdown);
+  }
+};
+function formatSRTTime(ms) {
+  const hours = Math.floor(ms / 36e5);
+  const minutes = Math.floor(ms % 36e5 / 6e4);
+  const seconds = Math.floor(ms % 6e4 / 1e3);
+  const milliseconds = ms % 1e3;
+  return `${pad(hours, 2)}:${pad(minutes, 2)}:${pad(seconds, 2)},${pad(milliseconds, 3)}`;
+}
+function formatReadableTime(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}:${pad(minutes, 2)}:${pad(seconds, 2)}`;
+  }
+  return `${minutes}:${pad(seconds, 2)}`;
+}
+function pad(num, size) {
+  let s = num.toString();
+  while (s.length < size) s = "0" + s;
+  return s;
+}
+function generateSSMLHints(segment) {
+  let ssml = segment.text;
+  if (segment.pauseBeforeMs) {
+    ssml = `<break time="${segment.pauseBeforeMs}ms"/> ${ssml}`;
+  }
+  if (segment.pauseAfterMs) {
+    ssml = `${ssml} <break time="${segment.pauseAfterMs}ms"/>`;
+  }
+  return ssml;
+}
+function createScriptGenerator(demoName, title, startTimeMs) {
+  return new ScriptGenerator(demoName, title, startTimeMs);
+}
+
+// ../playwright/src/cursor-overlay.ts
+var CURSOR_STYLES = `
+  /* Hide the real cursor when demo cursor is active */
+  html.demo-cursor-active, html.demo-cursor-active * {
+    cursor: none !important;
+  }
+
+  /* Demo cursor container */
+  #demo-cursor {
+    position: fixed;
+    pointer-events: none;
+    z-index: 999999;
+    will-change: left, top;
+  }
+
+  /* Cursor arrow SVG - larger for visibility */
+  #demo-cursor-arrow {
+    width: 32px;
+    height: 32px;
+    filter: drop-shadow(0 2px 6px rgba(0, 0, 0, 0.6)) drop-shadow(0 0 2px rgba(0, 0, 0, 0.4));
+  }
+
+  /* Click ripple effect - larger and more visible */
+  .demo-click-ripple {
+    position: absolute;
+    top: 4px;
+    left: 4px;
+    width: 60px;
+    height: 60px;
+    border-radius: 50%;
+    background: radial-gradient(circle, rgba(239, 68, 68, 0.7) 0%, rgba(239, 68, 68, 0.3) 40%, rgba(239, 68, 68, 0) 70%);
+    transform: translate(-50%, -50%) scale(0);
+    animation: demo-ripple 0.5s ease-out forwards;
+    pointer-events: none;
+  }
+
+  @keyframes demo-ripple {
+    0% {
+      transform: translate(-50%, -50%) scale(0);
+      opacity: 1;
+    }
+    100% {
+      transform: translate(-50%, -50%) scale(2.5);
+      opacity: 0;
+    }
+  }
+
+  /* Highlight ring for elements being clicked - thicker and more visible */
+  .demo-highlight-ring {
+    position: fixed;
+    border: 3px solid rgba(239, 68, 68, 0.9);
+    border-radius: 6px;
+    pointer-events: none;
+    z-index: 999998;
+    box-shadow: 0 0 0 3px rgba(239, 68, 68, 0.3), inset 0 0 0 1px rgba(239, 68, 68, 0.2);
+    animation: demo-highlight-pulse 0.8s ease-out forwards;
+  }
+
+  @keyframes demo-highlight-pulse {
+    0% {
+      opacity: 1;
+      transform: scale(1);
+    }
+    50% {
+      opacity: 0.9;
+      transform: scale(1.03);
+    }
+    100% {
+      opacity: 0;
+      transform: scale(1.08);
+    }
+  }
+
+  /* Trail effect for cursor movement */
+  .demo-cursor-trail {
+    position: fixed;
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: rgba(239, 68, 68, 0.4);
+    pointer-events: none;
+    z-index: 999998;
+    animation: demo-trail-fade 0.3s ease-out forwards;
+  }
+
+  @keyframes demo-trail-fade {
+    0% {
+      opacity: 0.6;
+      transform: scale(1);
+    }
+    100% {
+      opacity: 0;
+      transform: scale(0.5);
+    }
+  }
+`;
+var CURSOR_SVG = `
+  <svg id="demo-cursor-arrow" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M3 3L10.5 21L13 13L21 10.5L3 3Z" fill="#ef4444" stroke="white" stroke-width="2" stroke-linejoin="round"/>
+  </svg>
+`;
+var NAME_HELPER_SCRIPT = `
+(() => {
+  if (typeof window.__name !== "function") {
+    window.__name = (target, value) => {
+      try {
+        Object.defineProperty(target, "name", { value, configurable: true });
+      } catch {
+        // Ignore failures setting function names.
+      }
+      return target;
+    };
+  }
+})();
+`;
+var nameHelperInstalled = /* @__PURE__ */ new WeakSet();
+async function ensureNameHelper(page) {
+  if (!nameHelperInstalled.has(page)) {
+    await page.addInitScript({ content: NAME_HELPER_SCRIPT });
+    nameHelperInstalled.add(page);
+  }
+  await page.addScriptTag({ content: NAME_HELPER_SCRIPT });
+}
+async function injectCursorOverlay(page) {
+  await ensureNameHelper(page);
+  await page.addStyleTag({ content: CURSOR_STYLES });
+  await page.evaluate((cursorSvg) => {
+    const cursor = document.createElement("div");
+    cursor.id = "demo-cursor";
+    cursor.innerHTML = cursorSvg;
+    cursor.style.left = "-100px";
+    cursor.style.top = "-100px";
+    document.body.appendChild(cursor);
+    document.documentElement.classList.add("demo-cursor-active");
+    window.__demoCursor = {
+      setPosition: (x, y) => {
+        cursor.style.left = `${x}px`;
+        cursor.style.top = `${y}px`;
+      },
+      click: () => {
+        const ripple = document.createElement("div");
+        ripple.className = "demo-click-ripple";
+        cursor.appendChild(ripple);
+        setTimeout(() => ripple.remove(), 500);
+      },
+      highlight: (rect) => {
+        const ring = document.createElement("div");
+        ring.className = "demo-highlight-ring";
+        ring.style.left = `${rect.x}px`;
+        ring.style.top = `${rect.y}px`;
+        ring.style.width = `${rect.width}px`;
+        ring.style.height = `${rect.height}px`;
+        document.body.appendChild(ring);
+        setTimeout(() => ring.remove(), 800);
+      },
+      addTrail: (x, y) => {
+        const trail = document.createElement("div");
+        trail.className = "demo-cursor-trail";
+        trail.style.left = `${x}px`;
+        trail.style.top = `${y}px`;
+        document.body.appendChild(trail);
+        setTimeout(() => trail.remove(), 300);
+      },
+      destroy: () => {
+        cursor.remove();
+        document.documentElement.classList.remove("demo-cursor-active");
+        document.querySelectorAll(".demo-cursor-trail, .demo-highlight-ring, .demo-click-ripple").forEach((el) => el.remove());
+      }
+    };
+  }, CURSOR_SVG);
+}
+async function moveCursorTo(page, x, y, options) {
+  const steps = options?.steps ?? 15;
+  const trailEnabled = options?.trailEnabled ?? true;
+  const currentPos = await page.evaluate(() => {
+    const cursor = document.getElementById("demo-cursor");
+    if (!cursor) return { x: 0, y: 0 };
+    return {
+      x: parseFloat(cursor.style.left) || 0,
+      y: parseFloat(cursor.style.top) || 0
+    };
+  });
+  if (currentPos.x < 0 || currentPos.y < 0) {
+    currentPos.x = x > 100 ? x - 100 : 50;
+    currentPos.y = y > 100 ? y - 100 : 50;
+    await page.evaluate(
+      ([startX, startY]) => {
+        const api = window.__demoCursor;
+        if (api) api.setPosition(startX, startY);
+      },
+      [currentPos.x, currentPos.y]
+    );
+    await page.waitForTimeout(50);
+  }
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps;
+    const easeT = 1 - Math.pow(1 - t, 3);
+    const newX = currentPos.x + (x - currentPos.x) * easeT;
+    const newY = currentPos.y + (y - currentPos.y) * easeT;
+    await page.evaluate(
+      ({ posX, posY, addTrail }) => {
+        const api = window.__demoCursor;
+        if (api) {
+          api.setPosition(posX, posY);
+          if (addTrail) {
+            api.addTrail(posX + 4, posY + 4);
+          }
+        }
+      },
+      { posX: newX, posY: newY, addTrail: trailEnabled && i % 3 === 0 }
+    );
+    await page.waitForTimeout(20);
+  }
+  await page.evaluate(
+    ([finalX, finalY]) => {
+      const api = window.__demoCursor;
+      if (api) api.setPosition(finalX, finalY);
+    },
+    [x, y]
+  );
+  await page.mouse.move(x, y);
+  await page.waitForTimeout(100);
+}
+async function triggerClickRipple(page) {
+  await page.evaluate(() => {
+    const api = window.__demoCursor;
+    if (api) {
+      api.click();
+    }
+  });
+  await page.waitForTimeout(150);
+}
+async function highlightElement(page, selector) {
+  const boundingBox = await page.locator(selector).first().boundingBox();
+  if (boundingBox) {
+    await page.evaluate(
+      (rect) => {
+        const api = window.__demoCursor;
+        if (api) {
+          api.highlight(rect);
+        }
+      },
+      {
+        x: boundingBox.x - 6,
+        y: boundingBox.y - 6,
+        width: boundingBox.width + 12,
+        height: boundingBox.height + 12
+      }
+    );
+  }
+}
+async function removeCursorOverlay(page) {
+  await page.evaluate(() => {
+    const api = window.__demoCursor;
+    if (api) {
+      api.destroy();
+    }
+  });
+}
+async function demoClick(page, selector, options) {
+  const element = page.locator(selector).first();
+  const timeout = options?.timeoutMs ?? 1e4;
+  await element.scrollIntoViewIfNeeded();
+  await element.waitFor({ state: "visible", timeout });
+  const boundingBox = await element.boundingBox();
+  if (!boundingBox) {
+    throw new Error(`Element not found or not visible: ${selector}`);
+  }
+  const centerX = boundingBox.x + boundingBox.width / 2;
+  const centerY = boundingBox.y + boundingBox.height / 2;
+  if (options?.delayBefore) {
+    await page.waitForTimeout(options.delayBefore);
+  }
+  await moveCursorTo(page, centerX, centerY, { steps: 20 });
+  if (options?.highlight) {
+    await highlightElement(page, selector);
+    await page.waitForTimeout(200);
+  }
+  await triggerClickRipple(page);
+  await element.click({ timeout });
+  await page.waitForTimeout(200);
+  if (options?.delayAfter) {
+    await page.waitForTimeout(options.delayAfter);
+  }
+}
+async function demoHover(page, selector, options) {
+  const element = page.locator(selector).first();
+  const timeout = options?.timeoutMs ?? 1e4;
+  await element.scrollIntoViewIfNeeded();
+  await element.waitFor({ state: "visible", timeout });
+  const boundingBox = await element.boundingBox();
+  if (!boundingBox) {
+    throw new Error(`Element not found or not visible: ${selector}`);
+  }
+  const centerX = boundingBox.x + boundingBox.width / 2;
+  const centerY = boundingBox.y + boundingBox.height / 2;
+  await moveCursorTo(page, centerX, centerY, { steps: 15 });
+  if (options?.highlight) {
+    await highlightElement(page, selector);
+  }
+  await element.hover({ timeout });
+  await page.waitForTimeout(300);
+}
+async function demoType(page, selector, text, options) {
+  const element = page.locator(selector).first();
+  await element.scrollIntoViewIfNeeded();
+  await element.waitFor({ state: "visible", timeout: 1e4 });
+  const boundingBox = await element.boundingBox();
+  if (!boundingBox) {
+    throw new Error(`Element not found or not visible: ${selector}`);
+  }
+  const centerX = boundingBox.x + boundingBox.width / 2;
+  const centerY = boundingBox.y + boundingBox.height / 2;
+  await moveCursorTo(page, centerX, centerY);
+  if (options?.highlight) {
+    await highlightElement(page, selector);
+    await page.waitForTimeout(150);
+  }
+  await triggerClickRipple(page);
+  await element.click();
+  await page.waitForTimeout(100);
+  await element.fill(text);
+  await page.waitForTimeout(200);
+}
+
+// ../playwright/src/demo-runner.ts
+var DEFAULT_ACTION_TIMEOUT_MS = 15e3;
+var NAVIGATION_TIMEOUT_MS = 45e3;
+var UPLOAD_TIMEOUT_MS = 3e4;
+var ACTION_TIMEOUT_BUFFER_MS = 2e3;
+var DEFAULT_WAIT_TIMEOUT_MS = Number(process.env.DEMO_WAIT_TIMEOUT_MS ?? 15e3);
+var WAIT_RETRY_ATTEMPTS = Math.max(
+  1,
+  Number(process.env.DEMO_WAIT_RETRY_ATTEMPTS ?? 2)
+);
+var WAIT_RETRY_BASE_DELAY_MS = Number(process.env.DEMO_WAIT_RETRY_DELAY_MS ?? 500);
+function sanitizeDiagnosticsSegment(value, fallback) {
+  const raw = String(value ?? "").trim();
+  if (!raw) {
+    return fallback;
+  }
+  const cleaned = raw.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const collapsed = cleaned.replace(/_{2,}/g, "_").replace(/^_+|_+$/g, "");
+  const safe = collapsed || fallback;
+  const trimmed = safe.length > 80 ? safe.slice(0, 80) : safe;
+  return trimmed === "." || trimmed === ".." ? fallback : trimmed;
+}
+function logEvent(level, event, data) {
+  const payload = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    event,
+    ...data
+  };
+  const line = JSON.stringify(payload);
+  if (level === "error") {
+    console.error(line);
+  } else if (level === "warn") {
+    console.warn(line);
+  } else {
+    console.log(line);
+  }
+}
+function getActionTimeoutMs(action) {
+  if (action.action === "navigate") {
+    return NAVIGATION_TIMEOUT_MS;
+  }
+  if (action.action === "upload") {
+    return UPLOAD_TIMEOUT_MS;
+  }
+  if (action.action === "wait") {
+    if (action.duration !== void 0) {
+      return Math.max(DEFAULT_ACTION_TIMEOUT_MS, action.duration + ACTION_TIMEOUT_BUFFER_MS);
+    }
+    if (action.waitFor?.timeout) {
+      return action.waitFor.timeout + ACTION_TIMEOUT_BUFFER_MS;
+    }
+  }
+  if (action.waitFor?.timeout) {
+    return action.waitFor.timeout + ACTION_TIMEOUT_BUFFER_MS;
+  }
+  return DEFAULT_ACTION_TIMEOUT_MS;
+}
+async function withActionTimeout(timeoutMs, label, fn) {
+  let timeoutId = null;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([fn(), timeoutPromise]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+async function captureDiagnostics(params) {
+  const { context, stepId, stepIndex, actionIndex, action, error, runId } = params;
+  const diagnosticsDir = path3.join(context.outputDir, "diagnostics");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const stepLabel = sanitizeDiagnosticsSegment(stepId ?? "unknown-step", "unknown-step");
+  const actionLabel = actionIndex !== void 0 ? `action-${actionIndex + 1}` : "action";
+  const baseName = `${timestamp}-${runId}-${stepLabel}-${actionLabel}`;
+  try {
+    await fs3.mkdir(diagnosticsDir, { recursive: true });
+  } catch {
+  }
+  const metadata = {
+    runId,
+    stepId,
+    stepIndex,
+    actionIndex,
+    action,
+    error: error instanceof Error ? error.message : String(error),
+    url: context.page.url(),
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    const screenshotPath = path3.join(diagnosticsDir, `${baseName}.png`);
+    await context.page.screenshot({ path: screenshotPath, fullPage: true });
+  } catch {
+  }
+  try {
+    const domContent = await context.page.content();
+    const maxChars = 2e4;
+    const snippet = domContent.length > maxChars ? `${domContent.slice(0, maxChars)}
+<!-- truncated -->` : domContent;
+    const domPath = path3.join(diagnosticsDir, `${baseName}.dom.html`);
+    await fs3.writeFile(domPath, snippet, "utf-8");
+  } catch {
+  }
+  try {
+    const metaPath = path3.join(diagnosticsDir, `${baseName}.json`);
+    await fs3.writeFile(metaPath, JSON.stringify(metadata, null, 2), "utf-8");
+  } catch {
+  }
+}
+async function loadDemoDefinition(filePath, options) {
+  const content = await fs3.readFile(filePath, "utf-8");
+  const definition = parseFromYAML(content, options);
+  validateDemoDefinition(definition);
+  return definition;
+}
+function resolveFilePath(filePath, baseDir) {
+  if (path3.isAbsolute(filePath)) {
+    return filePath;
+  }
+  const root = baseDir ?? process.cwd();
+  return path3.resolve(root, filePath);
+}
+function resolveNavigatePath(actionPath, context) {
+  const resolvedPath = resolvePath(actionPath, { baseURL: context.baseURL });
+  if (/\{[^}]+\}/.test(resolvedPath)) {
+    throw new Error(
+      `Navigate action contains unresolved template variables: ${resolvedPath}`
+    );
+  }
+  return resolvedPath;
+}
+async function executeWaitCondition(page, condition, actionContext) {
+  const timeout = condition.timeout || DEFAULT_WAIT_TIMEOUT_MS;
+  let navigated = false;
+  const getSelectorContext = async () => {
+    if (!condition.value) return {};
+    try {
+      if (condition.type === "selector" || condition.type === "selectorHidden") {
+        const count = await page.locator(condition.value).count();
+        return { selectorCount: count };
+      }
+      if (condition.type === "text" || condition.type === "textHidden") {
+        const count = await page.getByText(condition.value, { exact: false }).count();
+        return { textMatchCount: count };
+      }
+    } catch (error) {
+      return { selectorContextError: error instanceof Error ? error.message : String(error) };
+    }
+    return {};
+  };
+  for (let attempt = 0; attempt < WAIT_RETRY_ATTEMPTS; attempt += 1) {
+    try {
+      switch (condition.type) {
+        case "text":
+          if (!condition.value) {
+            throw new Error("Wait for text requires 'value'");
+          }
+          await expect(page.getByText(condition.value, { exact: false }).first()).toBeVisible({
+            timeout
+          });
+          break;
+        case "selector":
+          if (!condition.value) {
+            throw new Error("Wait for selector requires 'value'");
+          }
+          await page.locator(condition.value).first().waitFor({ state: "visible", timeout });
+          break;
+        case "navigation":
+          await page.waitForURL(/.*/, { waitUntil: "networkidle", timeout });
+          navigated = true;
+          break;
+        case "idle":
+          await page.waitForLoadState("networkidle", { timeout });
+          break;
+        case "selectorHidden":
+          if (!condition.value) {
+            throw new Error("Wait for selectorHidden requires 'value'");
+          }
+          await page.locator(condition.value).first().waitFor({ state: "hidden", timeout });
+          break;
+        case "textHidden":
+          if (!condition.value) {
+            throw new Error("Wait for textHidden requires 'value'");
+          }
+          await expect(page.getByText(condition.value, { exact: false }).first()).toBeHidden({
+            timeout
+          });
+          break;
+      }
+      if (attempt > 0 && actionContext) {
+        logEvent("info", "wait_retry_success", {
+          runId: actionContext.runId,
+          demoName: actionContext.demoName,
+          stepId: actionContext.stepId,
+          actionIndex: actionContext.actionIndex,
+          waitType: condition.type,
+          attempt: attempt + 1
+        });
+      }
+      return navigated;
+    } catch (error) {
+      const selectorContext = await getSelectorContext();
+      logEvent("warn", "wait_retry", {
+        runId: actionContext?.runId,
+        demoName: actionContext?.demoName,
+        stepId: actionContext?.stepId,
+        actionIndex: actionContext?.actionIndex,
+        waitType: condition.type,
+        waitValue: condition.value,
+        timeout,
+        attempt: attempt + 1,
+        error: error instanceof Error ? error.message : String(error),
+        ...selectorContext
+      });
+      if (attempt >= WAIT_RETRY_ATTEMPTS - 1) {
+        throw error;
+      }
+      const delayMs = WAIT_RETRY_BASE_DELAY_MS * (attempt + 1);
+      await page.waitForTimeout(delayMs);
+    }
+  }
+  return navigated;
+}
+async function executeAction(action, context, actionContext) {
+  const { page } = context;
+  let navigated = false;
+  const timeoutMs = getActionTimeoutMs(action);
+  const startedAt = Date.now();
+  logEvent("info", "action_start", {
+    runId: actionContext.runId,
+    demoName: actionContext.demoName,
+    stepId: actionContext.stepId,
+    stepIndex: actionContext.stepIndex,
+    actionIndex: actionContext.actionIndex,
+    actionType: action.action,
+    timeoutMs
+  });
+  try {
+    await withActionTimeout(timeoutMs, `${action.action} action`, async () => {
+      switch (action.action) {
+        case "navigate": {
+          if (!action.path) {
+            throw new Error("Navigate action missing 'path'");
+          }
+          const resolvedPath = resolveNavigatePath(action.path, context);
+          const fullURL = resolvedPath.startsWith("http") ? resolvedPath : `${context.baseURL}${resolvedPath}`;
+          await page.goto(fullURL, { waitUntil: "networkidle", timeout: timeoutMs });
+          navigated = true;
+          await injectCursorOverlay(page);
+          break;
+        }
+        case "click": {
+          if (!action.target) {
+            throw new Error("Click action missing 'target'");
+          }
+          const selector = resolveTarget(action.target);
+          await demoClick(page, selector, {
+            highlight: action.highlight,
+            delayAfter: 500,
+            timeoutMs
+          });
+          break;
+        }
+        case "type": {
+          if (!action.target) {
+            throw new Error("Type action missing 'target'");
+          }
+          if (!action.text) {
+            throw new Error("Type action missing 'text'");
+          }
+          const selector = resolveTarget(action.target);
+          const element = page.locator(selector).first();
+          await element.waitFor({ state: "visible", timeout: timeoutMs });
+          await element.scrollIntoViewIfNeeded();
+          const box = await element.boundingBox();
+          if (box) {
+            await moveCursorTo(page, box.x + box.width / 2, box.y + box.height / 2);
+          }
+          await element.click({ timeout: timeoutMs });
+          await element.fill(action.text, { timeout: timeoutMs });
+          break;
+        }
+        case "upload": {
+          if (!action.file) {
+            throw new Error("Upload action missing 'file'");
+          }
+          const filePath = resolveFilePath(action.file, context.assetBaseDir);
+          const fileSelector = action.target?.selector || 'input[type="file"]';
+          const fileInput = page.locator(fileSelector).first();
+          await fileInput.setInputFiles(filePath, { timeout: timeoutMs });
+          break;
+        }
+        case "wait": {
+          if (action.duration) {
+            await page.waitForTimeout(action.duration);
+          } else if (action.waitFor) {
+            navigated = await executeWaitCondition(page, action.waitFor, actionContext);
+            if (navigated) {
+              await injectCursorOverlay(page);
+            }
+          }
+          break;
+        }
+        case "hover": {
+          if (!action.target) {
+            throw new Error("Hover action missing 'target'");
+          }
+          const selector = resolveTarget(action.target);
+          const element = page.locator(selector).first();
+          await element.waitFor({ state: "visible", timeout: timeoutMs });
+          await element.scrollIntoViewIfNeeded();
+          const box = await element.boundingBox();
+          if (box) {
+            await moveCursorTo(page, box.x + box.width / 2, box.y + box.height / 2);
+          }
+          await element.hover({ timeout: timeoutMs });
+          break;
+        }
+        case "scroll": {
+          const scrollAmount = action.duration || 500;
+          await page.mouse.wheel(0, scrollAmount);
+          await page.waitForTimeout(300);
+          break;
+        }
+        case "scrollTo": {
+          if (!action.target) {
+            throw new Error("ScrollTo action missing 'target'");
+          }
+          const selector = resolveTarget(action.target);
+          await page.locator(selector).first().scrollIntoViewIfNeeded({ timeout: timeoutMs });
+          await page.waitForTimeout(300);
+          break;
+        }
+        case "drag": {
+          if (!action.target) {
+            throw new Error("Drag action missing 'target'");
+          }
+          if (!action.drag) {
+            throw new Error("Drag action missing 'drag' configuration");
+          }
+          const selector = resolveTarget(action.target);
+          const element = page.locator(selector).first();
+          await element.waitFor({ state: "visible", timeout: timeoutMs });
+          await element.scrollIntoViewIfNeeded();
+          const box = await element.boundingBox();
+          if (!box) {
+            throw new Error(`Drag target not found or not visible: ${selector}`);
+          }
+          const startX = box.x + box.width / 2;
+          const startY = box.y + box.height / 2;
+          const endX = startX + action.drag.deltaX;
+          const endY = startY + action.drag.deltaY;
+          const dragSteps = action.drag.steps || 20;
+          await moveCursorTo(page, startX, startY, { steps: 15 });
+          await page.waitForTimeout(100);
+          await page.mouse.move(startX, startY);
+          await page.mouse.down();
+          await page.waitForTimeout(50);
+          for (let i = 1; i <= dragSteps; i++) {
+            const t = i / dragSteps;
+            const easeT = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+            const currentX = startX + (endX - startX) * easeT;
+            const currentY = startY + (endY - startY) * easeT;
+            await page.mouse.move(currentX, currentY);
+            await page.evaluate(
+              ([x, y, shouldAddTrail]) => {
+                const api = window.__demoCursor;
+                if (api) {
+                  api.setPosition(x, y);
+                  if (shouldAddTrail) {
+                    api.addTrail(x + 4, y + 4);
+                  }
+                }
+              },
+              [currentX, currentY, i % 3 === 0]
+            );
+            await page.waitForTimeout(25);
+          }
+          await page.mouse.up();
+          await page.waitForTimeout(200);
+          break;
+        }
+        default:
+          throw new Error(`Unknown action type: ${action.action}`);
+      }
+      if (action.waitFor && action.action !== "wait") {
+        const waitNavigated = await executeWaitCondition(page, action.waitFor, actionContext);
+        if (waitNavigated) {
+          await injectCursorOverlay(page);
+          navigated = true;
+        }
+      }
+      await page.waitForTimeout(200);
+    });
+    logEvent("info", "action_complete", {
+      runId: actionContext.runId,
+      demoName: actionContext.demoName,
+      stepId: actionContext.stepId,
+      stepIndex: actionContext.stepIndex,
+      actionIndex: actionContext.actionIndex,
+      actionType: action.action,
+      durationMs: Date.now() - startedAt,
+      navigated
+    });
+  } catch (error) {
+    logEvent("error", "action_failed", {
+      runId: actionContext.runId,
+      demoName: actionContext.demoName,
+      stepId: actionContext.stepId,
+      stepIndex: actionContext.stepIndex,
+      actionIndex: actionContext.actionIndex,
+      actionType: action.action,
+      durationMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    await captureDiagnostics({
+      context,
+      stepId: actionContext.stepId,
+      stepIndex: actionContext.stepIndex,
+      actionIndex: actionContext.actionIndex,
+      action,
+      error,
+      runId: actionContext.runId
+    });
+    throw error;
+  }
+  return navigated;
+}
+async function executeStep(step, context, scriptGenerator, runId, demoName, stepIndex) {
+  console.log(`[demo] Executing step: ${step.id} (${step.actions.length} actions)`);
+  logEvent("info", "step_start", {
+    runId,
+    demoName,
+    stepId: step.id,
+    stepIndex,
+    actionCount: step.actions.length
+  });
+  if (scriptGenerator) {
+    scriptGenerator.addSegment(step.id, step.script);
+  }
+  for (let i = 0; i < step.actions.length; i++) {
+    const action = step.actions[i];
+    console.log(`[demo]   Action ${i + 1}/${step.actions.length}: ${action.action}`);
+    await executeAction(action, context, {
+      stepId: step.id,
+      stepIndex,
+      actionIndex: i,
+      runId,
+      demoName
+    });
+  }
+  logEvent("info", "step_complete", {
+    runId,
+    demoName,
+    stepId: step.id,
+    stepIndex,
+    actionCount: step.actions.length
+  });
+}
+function getStepStartTarget(step) {
+  for (const action of step.actions) {
+    if (action.action === "wait" || action.action === "navigate") {
+      continue;
+    }
+    if (!action.target) {
+      continue;
+    }
+    try {
+      return {
+        selector: resolveTarget(action.target),
+        waitForState: action.action === "upload" ? "attached" : "visible"
+      };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function waitForStepReady(page, step) {
+  const target = getStepStartTarget(step);
+  if (!target) {
+    return;
+  }
+  try {
+    await page.locator(target.selector).first().waitFor({ state: target.waitForState, timeout: DEFAULT_WAIT_TIMEOUT_MS });
+  } catch {
+  }
+}
+function getStepEndSelector(step) {
+  for (let index = step.actions.length - 1; index >= 0; index -= 1) {
+    const action = step.actions[index];
+    if (action.action === "wait" || action.action === "navigate") {
+      continue;
+    }
+    if (!action.target) {
+      continue;
+    }
+    try {
+      return resolveTarget(action.target);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function waitForStepExit(page, step) {
+  const selector = getStepEndSelector(step);
+  if (!selector) {
+    return;
+  }
+  try {
+    await page.locator(selector).first().waitFor({ state: "hidden", timeout: 1500 });
+  } catch {
+  }
+}
+async function runDemo(definition, context, options = {}) {
+  const startTime = Date.now();
+  const transitionDelayMs = 500;
+  const runId = `${definition.name}-${startTime}`;
+  let scriptGenerator = null;
+  logEvent("info", "demo_start", {
+    runId,
+    demoName: definition.name,
+    stepCount: definition.steps.length,
+    baseURL: context.baseURL
+  });
+  try {
+    await injectCursorOverlay(context.page);
+    const hadVideoStartTime = context.videoRecordingStartTime !== void 0;
+    const syncedVideoStartTimeMs = context.videoRecordingStartTime ?? Date.now();
+    if (!hadVideoStartTime) {
+      context.videoRecordingStartTime = syncedVideoStartTimeMs;
+    }
+    logEvent("info", "video_sync", {
+      runId,
+      demoName: definition.name,
+      videoStartTimeMs: syncedVideoStartTimeMs,
+      providedByCaller: hadVideoStartTime
+    });
+    if (options.generateScripts) {
+      scriptGenerator = createScriptGenerator(
+        definition.name,
+        definition.title,
+        syncedVideoStartTimeMs
+      );
+    }
+    for (let stepIndex = 0; stepIndex < definition.steps.length; stepIndex += 1) {
+      const step = definition.steps[stepIndex];
+      if (scriptGenerator && stepIndex > 0) {
+        await waitForStepReady(context.page, step);
+      }
+      if (scriptGenerator) {
+        scriptGenerator.startStep(step.id);
+      }
+      await executeStep(step, context, scriptGenerator, runId, definition.name, stepIndex);
+      if (scriptGenerator && stepIndex < definition.steps.length - 1) {
+        await waitForStepExit(context.page, step);
+        await context.page.waitForTimeout(transitionDelayMs);
+      }
+    }
+    if (scriptGenerator) {
+      scriptGenerator.finishAllSteps();
+      const scriptOutputDir = options.scriptOutputDir ?? path3.join(context.outputDir, "scripts");
+      const scriptBasePath = path3.join(scriptOutputDir, definition.name);
+      await scriptGenerator.exportJSON(`${scriptBasePath}.json`);
+      await scriptGenerator.exportSRT(`${scriptBasePath}.srt`);
+      await scriptGenerator.exportMarkdown(`${scriptBasePath}.md`);
+      await scriptGenerator.exportAIVoiceScript(`${scriptBasePath}.voice.json`);
+      await removeCursorOverlay(context.page);
+      logEvent("info", "demo_complete", {
+        runId,
+        demoName: definition.name,
+        durationMs: Date.now() - startTime
+      });
+      return {
+        success: true,
+        demoName: definition.name,
+        videoPath: context.videoPath,
+        scriptPath: `${scriptBasePath}.json`,
+        duration: Date.now() - startTime
+      };
+    }
+    await removeCursorOverlay(context.page);
+    logEvent("info", "demo_complete", {
+      runId,
+      demoName: definition.name,
+      durationMs: Date.now() - startTime
+    });
+    return {
+      success: true,
+      demoName: definition.name,
+      videoPath: context.videoPath,
+      duration: Date.now() - startTime
+    };
+  } catch (error) {
+    logEvent("error", "demo_failed", {
+      runId,
+      demoName: definition.name,
+      durationMs: Date.now() - startTime,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    await captureDiagnostics({
+      context,
+      error,
+      runId
+    });
+    return {
+      success: false,
+      demoName: definition.name,
+      error: error instanceof Error ? error : new Error(String(error)),
+      duration: Date.now() - startTime
+    };
+  }
+}
+async function runDemoFromFile(definitionPath, context, options) {
+  const definition = await loadDemoDefinition(definitionPath);
+  return runDemo(definition, context, options);
+}
+async function discoverDemos(demoDir) {
+  const files = await fs3.readdir(demoDir);
+  return files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => path3.join(demoDir, f));
+}
+export {
+  DEMO_SCHEMA_VERSION,
+  ScriptGenerator,
+  VoiceSynthesizer,
+  createClickAction,
+  createDragAction,
+  createEmptyDemo,
+  createEmptyStep,
+  createHoverAction,
+  createNavigateAction,
+  createScriptGenerator,
+  createScrollAction,
+  createScrollToAction,
+  createTypeAction,
+  createUploadAction,
+  createVoiceSynthesizer,
+  createWaitAction,
+  createWaitForAction,
+  demoClick,
+  demoDefinitionSchema,
+  demoHover,
+  demoType,
+  discoverDemos,
+  formatValidationError,
+  generateTimingManifest,
+  highlightElement,
+  injectCursorOverlay,
+  loadDemoDefinition,
+  moveCursorTo,
+  parseDemoDefinition,
+  parseFromYAML,
+  removeCursorOverlay,
+  resolvePath,
+  resolveTarget,
+  runDemo,
+  runDemoFromFile,
+  safeParseDemoDefinition,
+  serializeToYAML,
+  triggerClickRipple,
+  validateDemoDefinition
+};
+//# sourceMappingURL=index.js.map