@t3lnet/sceneforge 1.0.7 → 1.0.8

package/dist/index.js

@@ -180,8 +180,8 @@ function formatValidationError(error) {
   }
   const issues = error.issues;
   return issues.map((issue) => {
-    const path4 = issue.path.length ? issue.path.join(".") : "root";
-    return `${path4}: ${issue.message}`;
+    const path5 = issue.path.length ? issue.path.join(".") : "root";
+    return `${path5}: ${issue.message}`;
   }).join("; ");
 }
 function parseDemoDefinition(input) {
@@ -311,7 +311,7 @@ function createEmptyStep(id) {
   };
 }
 var SECRET_PATTERN = /\$\{(ENV|SECRET):([A-Za-z0-9_]+)\}/g;
-function resolveSecrets(value, resolver, path4 = "root") {
+function resolveSecrets(value, resolver, path5 = "root") {
   if (typeof value === "string") {
     if (!SECRET_PATTERN.test(value)) {
       return value;
@@ -320,20 +320,20 @@ function resolveSecrets(value, resolver, path4 = "root") {
     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}`);
+        throw new Error(`Missing secret for ${key} at ${path5}`);
       }
       return resolved;
     });
   }
   if (Array.isArray(value)) {
     return value.map(
-      (entry, index) => resolveSecrets(entry, resolver, `${path4}[${index}]`)
+      (entry, index) => resolveSecrets(entry, resolver, `${path5}[${index}]`)
     );
   }
   if (value && typeof value === "object") {
     const result = {};
     for (const [key, entry] of Object.entries(value)) {
-      result[key] = resolveSecrets(entry, resolver, `${path4}.${key}`);
+      result[key] = resolveSecrets(entry, resolver, `${path5}.${key}`);
     }
     return result;
   }
@@ -412,10 +412,10 @@ function createTypeAction(selector, text) {
     text
   };
 }
-function createNavigateAction(path4) {
+function createNavigateAction(path5) {
   return {
     action: "navigate",
-    path: path4
+    path: path5
   };
 }
 function createWaitAction(duration) {
@@ -488,14 +488,323 @@ function createDragAction(selector, deltaX, deltaY, steps = 20) {
 
 // ../playwright/src/demo-runner.ts
 import { expect } from "@playwright/test";
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
 
 // ../generation/src/voice-synthesis.ts
 import { spawn } from "child_process";
 import { ElevenLabsClient } from "elevenlabs";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+
+// ../generation/src/voice-cache.ts
+import * as crypto from "crypto";
 import * as fs from "fs/promises";
 import * as path from "path";
+var CACHE_VERSION = 1;
+var INDEX_FILE = "index.json";
+var AUDIO_DIR = "audio";
+var DEFAULT_VOICE_SETTINGS = {
+  stability: 0.5,
+  similarityBoost: 0.75,
+  style: 0,
+  useSpeakerBoost: true
+};
+function normalizeVoiceSettings(settings) {
+  return {
+    stability: settings?.stability ?? DEFAULT_VOICE_SETTINGS.stability,
+    similarityBoost: settings?.similarityBoost ?? DEFAULT_VOICE_SETTINGS.similarityBoost,
+    style: settings?.style ?? DEFAULT_VOICE_SETTINGS.style,
+    useSpeakerBoost: settings?.useSpeakerBoost ?? DEFAULT_VOICE_SETTINGS.useSpeakerBoost
+  };
+}
+function generateCacheKey(voiceId, modelId, text, voiceSettings) {
+  const normalizedText = text.trim();
+  const keyData = JSON.stringify({
+    voiceId,
+    modelId,
+    text: normalizedText,
+    voiceSettings: {
+      stability: voiceSettings.stability,
+      similarityBoost: voiceSettings.similarityBoost,
+      style: voiceSettings.style,
+      useSpeakerBoost: voiceSettings.useSpeakerBoost
+    }
+  });
+  return crypto.createHash("sha256").update(keyData).digest("hex");
+}
+var VoiceCache = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "index", null);
+    __publicField(this, "stats", { hits: 0, misses: 0 });
+    __publicField(this, "indexDirty", false);
+    this.config = {
+      ...config,
+      enabled: config.enabled ?? true
+    };
+  }
+  /**
+   * Gets the path to the cache index file
+   */
+  get indexPath() {
+    return path.join(this.config.cacheDir, INDEX_FILE);
+  }
+  /**
+   * Gets the path to the audio cache directory
+   */
+  get audioDir() {
+    return path.join(this.config.cacheDir, AUDIO_DIR);
+  }
+  /**
+   * Whether caching is enabled
+   */
+  get enabled() {
+    return this.config.enabled ?? true;
+  }
+  /**
+   * Initializes the cache directory and loads the index
+   */
+  async initialize() {
+    if (!this.enabled) {
+      return;
+    }
+    await fs.mkdir(this.config.cacheDir, { recursive: true });
+    await fs.mkdir(this.audioDir, { recursive: true });
+    await this.loadIndex();
+  }
+  /**
+   * Loads the cache index from disk
+   */
+  async loadIndex() {
+    try {
+      const content = await fs.readFile(this.indexPath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed.version !== CACHE_VERSION) {
+        console.warn(
+          `[voice-cache] Index version mismatch (${parsed.version} vs ${CACHE_VERSION}), rebuilding cache`
+        );
+        this.index = { version: CACHE_VERSION, entries: {} };
+        this.indexDirty = true;
+        return;
+      }
+      this.index = parsed;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        this.index = { version: CACHE_VERSION, entries: {} };
+        this.indexDirty = true;
+      } else {
+        console.warn(`[voice-cache] Failed to load index, creating new one:`, error);
+        this.index = { version: CACHE_VERSION, entries: {} };
+        this.indexDirty = true;
+      }
+    }
+  }
+  /**
+   * Saves the cache index to disk
+   */
+  async saveIndex() {
+    if (!this.enabled || !this.index || !this.indexDirty) {
+      return;
+    }
+    await fs.writeFile(this.indexPath, JSON.stringify(this.index, null, 2));
+    this.indexDirty = false;
+  }
+  /**
+   * Looks up a cached audio file by its synthesis parameters.
+   * Returns the cache entry if found, null otherwise.
+   */
+  async get(voiceId, modelId, text, voiceSettings) {
+    if (!this.enabled || !this.index) {
+      this.stats.misses++;
+      return null;
+    }
+    const key = generateCacheKey(voiceId, modelId, text, voiceSettings);
+    const entry = this.index.entries[key];
+    if (!entry) {
+      this.stats.misses++;
+      return null;
+    }
+    const audioPath = path.join(this.audioDir, entry.audioFileName);
+    try {
+      await fs.access(audioPath);
+    } catch {
+      delete this.index.entries[key];
+      this.indexDirty = true;
+      this.stats.misses++;
+      return null;
+    }
+    entry.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.indexDirty = true;
+    this.stats.hits++;
+    return entry;
+  }
+  /**
+   * Gets the full path to a cached audio file
+   */
+  getAudioPath(entry) {
+    return path.join(this.audioDir, entry.audioFileName);
+  }
+  /**
+   * Stores a synthesized audio file in the cache.
+   * The audio data should be provided as a Buffer.
+   */
+  async put(voiceId, modelId, text, voiceSettings, audioData, durationMs) {
+    if (!this.index) {
+      await this.initialize();
+    }
+    const key = generateCacheKey(voiceId, modelId, text, voiceSettings);
+    const audioFileName = `${key}.mp3`;
+    const audioPath = path.join(this.audioDir, audioFileName);
+    await fs.writeFile(audioPath, audioData);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      key,
+      voiceId,
+      modelId,
+      text: text.trim(),
+      voiceSettings,
+      audioFileName,
+      durationMs,
+      fileSizeBytes: audioData.length,
+      createdAt: now,
+      lastUsedAt: now
+    };
+    this.index.entries[key] = entry;
+    this.indexDirty = true;
+    return entry;
+  }
+  /**
+   * Removes a specific entry from the cache
+   */
+  async remove(key) {
+    if (!this.enabled || !this.index) {
+      return false;
+    }
+    const entry = this.index.entries[key];
+    if (!entry) {
+      return false;
+    }
+    const audioPath = path.join(this.audioDir, entry.audioFileName);
+    try {
+      await fs.unlink(audioPath);
+    } catch {
+    }
+    delete this.index.entries[key];
+    this.indexDirty = true;
+    return true;
+  }
+  /**
+   * Clears all entries from the cache
+   */
+  async clear() {
+    if (!this.index) {
+      await this.initialize();
+    }
+    const count = Object.keys(this.index.entries).length;
+    try {
+      const files = await fs.readdir(this.audioDir);
+      await Promise.all(
+        files.map((file) => fs.unlink(path.join(this.audioDir, file)).catch(() => {
+        }))
+      );
+    } catch {
+    }
+    this.index.entries = {};
+    this.indexDirty = true;
+    await this.saveIndex();
+    return count;
+  }
+  /**
+   * Lists all entries in the cache
+   */
+  async list() {
+    if (!this.index) {
+      await this.initialize();
+    }
+    return Object.values(this.index.entries).sort(
+      (a, b) => new Date(b.lastUsedAt).getTime() - new Date(a.lastUsedAt).getTime()
+    );
+  }
+  /**
+   * Gets statistics about the cache
+   */
+  async getStats() {
+    if (!this.index) {
+      await this.initialize();
+    }
+    const entries = Object.values(this.index.entries);
+    const totalSizeBytes = entries.reduce((sum, e) => sum + e.fileSizeBytes, 0);
+    let oldestEntry = null;
+    let newestEntry = null;
+    if (entries.length > 0) {
+      const sorted = [...entries].sort(
+        (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
+      );
+      oldestEntry = sorted[0].createdAt;
+      newestEntry = sorted[sorted.length - 1].createdAt;
+    }
+    return {
+      totalEntries: entries.length,
+      totalSizeBytes,
+      oldestEntry,
+      newestEntry,
+      hitCount: this.stats.hits,
+      missCount: this.stats.misses
+    };
+  }
+  /**
+   * Prunes entries older than the specified age (in days)
+   */
+  async pruneOlderThan(days) {
+    if (!this.index) {
+      await this.initialize();
+    }
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+    let removed = 0;
+    for (const [key, entry] of Object.entries(this.index.entries)) {
+      const lastUsed = new Date(entry.lastUsedAt).getTime();
+      if (lastUsed < cutoff) {
+        await this.remove(key);
+        removed++;
+      }
+    }
+    await this.saveIndex();
+    return removed;
+  }
+  /**
+   * Validates the cache by checking that all indexed files exist
+   * and removing orphaned entries
+   */
+  async validate() {
+    if (!this.index) {
+      await this.initialize();
+    }
+    let valid = 0;
+    let removed = 0;
+    for (const [key, entry] of Object.entries(this.index.entries)) {
+      const audioPath = path.join(this.audioDir, entry.audioFileName);
+      try {
+        await fs.access(audioPath);
+        valid++;
+      } catch {
+        delete this.index.entries[key];
+        this.indexDirty = true;
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      await this.saveIndex();
+    }
+    return { valid, removed };
+  }
+};
+function getDefaultCacheDir(projectRoot) {
+  const root = projectRoot || process.cwd();
+  return path.join(root, ".voice-cache");
+}
+
+// ../generation/src/voice-synthesis.ts
 var DEFAULT_MAX_OUTPUT_BYTES = 512 * 1024;
 var DEFAULT_MAX_CONCURRENCY = 2;
 var DEFAULT_RETRY_OPTIONS = {
@@ -660,10 +969,34 @@ var VoiceSynthesizer = class {
   constructor(config) {
     __publicField(this, "client");
     __publicField(this, "config");
+    __publicField(this, "cache", null);
+    __publicField(this, "cacheInitialized", false);
     this.config = config;
     this.client = new ElevenLabsClient({
       apiKey: config.apiKey
     });
+    if (config.cache !== false) {
+      const cacheConfig = config.cache ?? {
+        cacheDir: getDefaultCacheDir(),
+        enabled: true
+      };
+      this.cache = new VoiceCache(cacheConfig);
+    }
+  }
+  /**
+   * Ensures the cache is initialized before use
+   */
+  async ensureCacheInitialized() {
+    if (this.cache && !this.cacheInitialized) {
+      await this.cache.initialize();
+      this.cacheInitialized = true;
+    }
+  }
+  /**
+   * Gets the voice cache instance (if enabled)
+   */
+  getCache() {
+    return this.cache;
   }
   /**
    * List available voices (useful for finding voice IDs)
@@ -680,14 +1013,31 @@ var VoiceSynthesizer = class {
    * Synthesize a single text segment to audio
    */
   async synthesizeSegment(text, outputPath, options) {
+    const modelId = this.config.modelId || "eleven_multilingual_v2";
+    const voiceSettings = normalizeVoiceSettings(options);
+    if (this.cache && !options?.skipCache) {
+      await this.ensureCacheInitialized();
+      const cachedEntry = await this.cache.get(
+        this.config.voiceId,
+        modelId,
+        text,
+        voiceSettings
+      );
+      if (cachedEntry) {
+        const cachedPath = this.cache.getAudioPath(cachedEntry);
+        await fs2.copyFile(cachedPath, outputPath);
+        console.log(`[voice] Cache hit for "${text.slice(0, 40)}..." (saved API call)`);
+        return { durationMs: cachedEntry.durationMs, fromCache: true };
+      }
+    }
     const audio = await this.client.textToSpeech.convert(this.config.voiceId, {
       text,
-      model_id: this.config.modelId || "eleven_multilingual_v2",
+      model_id: modelId,
       voice_settings: {
-        stability: options?.stability ?? 0.5,
-        similarity_boost: options?.similarityBoost ?? 0.75,
-        style: options?.style ?? 0,
-        use_speaker_boost: options?.useSpeakerBoost ?? true
+        stability: voiceSettings.stability,
+        similarity_boost: voiceSettings.similarityBoost,
+        style: voiceSettings.style,
+        use_speaker_boost: voiceSettings.useSpeakerBoost
       }
     });
     const chunks = [];
@@ -695,15 +1045,29 @@ var VoiceSynthesizer = class {
       chunks.push(Buffer.from(chunk));
     }
     const audioBuffer = Buffer.concat(chunks);
-    await fs.writeFile(outputPath, audioBuffer);
+    await fs2.writeFile(outputPath, audioBuffer);
     const probedDurationMs = await probeMediaDurationMs(outputPath);
+    let durationMs;
     if (probedDurationMs !== null) {
-      return { durationMs: probedDurationMs };
+      durationMs = probedDurationMs;
+    } else {
+      const fileSizeBytes = audioBuffer.length;
+      durationMs = Math.round(fileSizeBytes * 8 / 128);
+      console.warn(`[voice] ffprobe unavailable, using estimated duration for ${outputPath}`);
+    }
+    if (this.cache) {
+      await this.ensureCacheInitialized();
+      await this.cache.put(
+        this.config.voiceId,
+        modelId,
+        text,
+        voiceSettings,
+        audioBuffer,
+        durationMs
+      );
+      await this.cache.saveIndex();
     }
-    const fileSizeBytes = audioBuffer.length;
-    const estimatedDurationMs = Math.round(fileSizeBytes * 8 / 128);
-    console.warn(`[voice] ffprobe unavailable, using estimated duration for ${outputPath}`);
-    return { durationMs: estimatedDurationMs };
+    return { durationMs, fromCache: false };
   }
   /**
    * Generate a sound effect from text description
@@ -721,16 +1085,16 @@ var VoiceSynthesizer = class {
     for await (const chunk of audio) {
       chunks.push(Buffer.from(chunk));
     }
-    await fs.writeFile(outputPath, Buffer.concat(chunks));
+    await fs2.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 scriptContent = await fs2.readFile(scriptPath, "utf-8");
     const script = JSON.parse(scriptContent);
-    const audioDir = path.join(outputDir, "audio", script.demoName);
-    await fs.mkdir(audioDir, { recursive: true });
+    const audioDir = path2.join(outputDir, "audio", script.demoName);
+    await fs2.mkdir(audioDir, { recursive: true });
     const synthesizedSegments = new Array(script.segments.length);
     const maxConcurrency = Math.max(
       1,
@@ -748,7 +1112,7 @@ var VoiceSynthesizer = class {
         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);
+        const audioPath = path2.join(audioDir, audioFileName);
         progressCount += 1;
         options?.onProgress?.(progressCount, script.segments.length, segment.stepId);
         try {
@@ -762,7 +1126,8 @@ var VoiceSynthesizer = class {
             durationMs: result.durationMs,
             text: segment.text
           };
-          console.log(`[voice] Synthesized: ${segment.stepId} (${result.durationMs.toFixed(0)}ms)`);
+          const cacheStatus = result.fromCache ? "[cached]" : "[new]";
+          console.log(`[voice] ${cacheStatus} ${segment.stepId} (${result.durationMs.toFixed(0)}ms)`);
         } catch (error) {
           console.error(`[voice] Failed to synthesize ${segment.stepId}:`, error);
           throw error;
@@ -772,7 +1137,7 @@ var VoiceSynthesizer = class {
     await Promise.all(workers);
     let soundEffectsPath;
     if (options?.generateClickSounds) {
-      soundEffectsPath = path.join(audioDir, "click.mp3");
+      soundEffectsPath = path2.join(audioDir, "click.mp3");
       await this.generateClickSound(soundEffectsPath);
     }
     return {
@@ -812,7 +1177,7 @@ var VoiceSynthesizer = class {
   }
 };
 async function generateTimingManifest(scriptPath, synthesisResult, outputPath) {
-  const scriptContent = await fs.readFile(scriptPath, "utf-8");
+  const scriptContent = await fs2.readFile(scriptPath, "utf-8");
   const script = JSON.parse(scriptContent);
   const manifest = {
     demoName: script.demoName,
@@ -829,7 +1194,7 @@ async function generateTimingManifest(scriptPath, synthesisResult, outputPath) {
     soundEffects: synthesisResult.soundEffectsPath ? { clickSound: synthesisResult.soundEffectsPath } : void 0,
     backgroundMusic: synthesisResult.backgroundMusicPath
   };
-  await fs.writeFile(outputPath, JSON.stringify(manifest, null, 2));
+  await fs2.writeFile(outputPath, JSON.stringify(manifest, null, 2));
   return manifest;
 }
 function createVoiceSynthesizer(config) {
@@ -837,8 +1202,8 @@ function createVoiceSynthesizer(config) {
 }
 
 // ../generation/src/script-generator.ts
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
 var ScriptGenerator = class {
   constructor(demoName, title, startTimeMs) {
     __publicField(this, "segments", []);
@@ -937,8 +1302,8 @@ var ScriptGenerator = class {
    */
   async exportJSON(outputPath) {
     const output = this.getOutput();
-    await fs2.mkdir(path2.dirname(outputPath), { recursive: true });
-    await fs2.writeFile(outputPath, JSON.stringify(output, null, 2));
+    await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
+    await fs3.writeFile(outputPath, JSON.stringify(output, null, 2));
   }
   /**
    * Exports script as SRT subtitle format.
@@ -957,8 +1322,8 @@ var ScriptGenerator = class {
 
 `;
     });
-    await fs2.mkdir(path2.dirname(outputPath), { recursive: true });
-    await fs2.writeFile(outputPath, srt.trim());
+    await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
+    await fs3.writeFile(outputPath, srt.trim());
   }
   /**
    * Exports script in a format suitable for AI voice generation services.
@@ -980,8 +1345,8 @@ var ScriptGenerator = class {
         syncPointMs: segment.startTimeMs
       }))
     };
-    await fs2.mkdir(path2.dirname(outputPath), { recursive: true });
-    await fs2.writeFile(outputPath, JSON.stringify(voiceScript, null, 2));
+    await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
+    await fs3.writeFile(outputPath, JSON.stringify(voiceScript, null, 2));
   }
   /**
    * Exports script as human-readable markdown for voice actors.
@@ -1028,8 +1393,8 @@ var ScriptGenerator = class {
 
 `;
     });
-    await fs2.mkdir(path2.dirname(outputPath), { recursive: true });
-    await fs2.writeFile(outputPath, markdown);
+    await fs3.mkdir(path3.dirname(outputPath), { recursive: true });
+    await fs3.writeFile(outputPath, markdown);
   }
 };
 function formatSRTTime(ms) {
@@ -1468,13 +1833,13 @@ async function withActionTimeout(timeoutMs, label, fn) {
 }
 async function captureDiagnostics(params) {
   const { context, stepId, stepIndex, actionIndex, action, error, runId } = params;
-  const diagnosticsDir = path3.join(context.outputDir, "diagnostics");
+  const diagnosticsDir = path4.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 });
+    await fs4.mkdir(diagnosticsDir, { recursive: true });
   } catch {
   }
   const metadata = {
@@ -1488,7 +1853,7 @@ async function captureDiagnostics(params) {
     capturedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    const screenshotPath = path3.join(diagnosticsDir, `${baseName}.png`);
+    const screenshotPath = path4.join(diagnosticsDir, `${baseName}.png`);
     await context.page.screenshot({ path: screenshotPath, fullPage: true });
   } catch {
   }
@@ -1497,28 +1862,28 @@ async function captureDiagnostics(params) {
     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");
+    const domPath = path4.join(diagnosticsDir, `${baseName}.dom.html`);
+    await fs4.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");
+    const metaPath = path4.join(diagnosticsDir, `${baseName}.json`);
+    await fs4.writeFile(metaPath, JSON.stringify(metadata, null, 2), "utf-8");
   } catch {
   }
 }
 async function loadDemoDefinition(filePath, options) {
-  const content = await fs3.readFile(filePath, "utf-8");
+  const content = await fs4.readFile(filePath, "utf-8");
   const definition = parseFromYAML(content, options);
   validateDemoDefinition(definition);
   return definition;
 }
 function resolveFilePath(filePath, baseDir) {
-  if (path3.isAbsolute(filePath)) {
+  if (path4.isAbsolute(filePath)) {
     return filePath;
   }
   const root = baseDir ?? process.cwd();
-  return path3.resolve(root, filePath);
+  return path4.resolve(root, filePath);
 }
 function resolveNavigatePath(actionPath, context) {
   const resolvedPath = resolvePath(actionPath, { baseURL: context.baseURL });
@@ -1960,8 +2325,8 @@ async function runDemo(definition, context, options = {}) {
     }
     if (scriptGenerator) {
       scriptGenerator.finishAllSteps();
-      const scriptOutputDir = options.scriptOutputDir ?? path3.join(context.outputDir, "scripts");
-      const scriptBasePath = path3.join(scriptOutputDir, definition.name);
+      const scriptOutputDir = options.scriptOutputDir ?? path4.join(context.outputDir, "scripts");
+      const scriptBasePath = path4.join(scriptOutputDir, definition.name);
       await scriptGenerator.exportJSON(`${scriptBasePath}.json`);
       await scriptGenerator.exportSRT(`${scriptBasePath}.srt`);
       await scriptGenerator.exportMarkdown(`${scriptBasePath}.md`);
@@ -2017,8 +2382,8 @@ async function runDemoFromFile(definitionPath, context, options) {
   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));
+  const files = await fs4.readdir(demoDir);
+  return files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => path4.join(demoDir, f));
 }
 export {
   DEMO_SCHEMA_VERSION,