@veolab/discoverylab 1.4.1 → 1.4.2

package/dist/{chunk-XWBFSSNB.js → chunk-MDKX7CCB.js}

@@ -8707,11 +8707,11 @@ var require_mime_types = __commonJS({
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync2, existsSync as existsSync5, statSync as statSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, copyFileSync, cpSync, mkdtempSync, rmSync as rmSync2 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync5, statSync as statSync3, readdirSync as readdirSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, copyFileSync, cpSync, mkdtempSync, rmSync as rmSync2 } from "fs";
 import { exec, execSync as execSync2, spawn } from "child_process";
 import { createConnection } from "net";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
-import { join as join5, dirname as dirname2, basename as basename3 } from "path";
+import { join as join6, dirname as dirname2, basename as basename3 } from "path";
 import { fileURLToPath } from "url";
 import { eq, desc, and, inArray } from "drizzle-orm";
 
@@ -9318,7 +9318,7 @@ function attachPlaywrightNetworkCapture(page, options) {
 
 // src/core/export/pipeline.ts
 var import_mime_types = __toESM(require_mime_types(), 1);
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync3, statSync as statSync2, readdirSync as readdirSync2 } from "fs";
 import { join as join3, basename as basename2, extname as extname2 } from "path";
 var adapters = /* @__PURE__ */ new Map();
 function registerAdapter(adapter) {
@@ -9380,16 +9380,15 @@ async function prepareAsset(asset, ctx) {
 }
 function resolveVideoFile(videoPath) {
   if (!existsSync3(videoPath)) return null;
-  const { statSync: statSync3, readdirSync: readdirSync3 } = __require("fs");
-  const stat = statSync3(videoPath);
+  const stat = statSync2(videoPath);
   if (stat.isFile()) return videoPath;
   const videoExts = [".mp4", ".mov", ".webm", ".avi", ".mkv"];
   const searchDirs = [join3(videoPath, "video"), videoPath];
   for (const dir of searchDirs) {
     if (!existsSync3(dir)) continue;
-    const dirStat = statSync3(dir);
+    const dirStat = statSync2(dir);
     if (!dirStat.isDirectory()) continue;
-    const files = readdirSync3(dir);
+    const files = readdirSync2(dir);
     for (const file of files) {
       if (videoExts.some((ext) => file.toLowerCase().endsWith(ext))) {
         return join3(dir, file);
@@ -9493,6 +9492,8 @@ async function executeBatchExport(manifest, dataProvider, onProgress) {
 }
 
 // src/core/export/adapters/notion.ts
+import { readdirSync as readdirSync3 } from "fs";
+import { join as join4 } from "path";
 var SUPPORTED_TYPES = [
   "frames",
   // Images upload directly
@@ -9561,11 +9562,9 @@ var notionAdapter = {
           if (!asset.filePath) continue;
           switch (asset.type) {
             case "frames": {
-              const { readdirSync: readdirSync3 } = __require("fs");
-              const { join: join6 } = __require("path");
               try {
                 const files = readdirSync3(asset.filePath);
-                const imageFiles = files.filter((f) => /\.(png|jpg|jpeg|gif|webp)$/i.test(f)).sort().map((f) => join6(asset.filePath, f));
+                const imageFiles = files.filter((f) => /\.(png|jpg|jpeg|gif|webp)$/i.test(f)).sort().map((f) => join4(asset.filePath, f));
                 const maxFrames = asset.metadata?.maxFrames || 20;
                 screenshots.push(...imageFiles.slice(0, maxFrames));
               } catch {
@@ -9630,7 +9629,7 @@ var notionAdapter = {
 // src/core/testing/playwrightRecorder.ts
 import { chromium } from "playwright";
 import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { homedir as homedir2 } from "os";
 import { EventEmitter } from "events";
 var PlaywrightRecorder = class _PlaywrightRecorder extends EventEmitter {
@@ -9673,8 +9672,8 @@ var PlaywrightRecorder = class _PlaywrightRecorder extends EventEmitter {
       throw new Error("Recording already in progress");
     }
     const sessionId = `rec_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    const baseDir = join4(homedir2(), ".discoverylab", "recordings", sessionId);
-    const screenshotsDir = join4(baseDir, "screenshots");
+    const baseDir = join5(homedir2(), ".discoverylab", "recordings", sessionId);
+    const screenshotsDir = join5(baseDir, "screenshots");
     mkdirSync3(screenshotsDir, { recursive: true });
     this.session = {
       id: sessionId,
@@ -9706,7 +9705,7 @@ var PlaywrightRecorder = class _PlaywrightRecorder extends EventEmitter {
       this.session.viewportMode = viewportMode;
       const contextOptions = {
         recordVideo: {
-          dir: join4(baseDir, "video"),
+          dir: join5(baseDir, "video"),
           size: captureResolution
         }
       };
@@ -9994,7 +9993,7 @@ var PlaywrightRecorder = class _PlaywrightRecorder extends EventEmitter {
     this.actionCounter++;
     const actionId = `action_${this.actionCounter.toString().padStart(3, "0")}`;
     const screenshotName = `${actionId}_${actionData.type}.png`;
-    const screenshotPath = join4(this.session.screenshotsDir, screenshotName);
+    const screenshotPath = join5(this.session.screenshotsDir, screenshotName);
     try {
       await this.page.screenshot({
         path: screenshotPath,
@@ -10069,10 +10068,10 @@ var PlaywrightRecorder = class _PlaywrightRecorder extends EventEmitter {
     this.session.status = "stopped";
     this.session.endedAt = Date.now();
     const specCode = this.generateSpecCode();
-    const specPath = join4(this.session.screenshotsDir, "..", "test.spec.ts");
+    const specPath = join5(this.session.screenshotsDir, "..", "test.spec.ts");
     writeFileSync3(specPath, specCode);
     this.session.specPath = specPath;
-    const metadataPath = join4(this.session.screenshotsDir, "..", "session.json");
+    const metadataPath = join5(this.session.screenshotsDir, "..", "session.json");
     writeFileSync3(metadataPath, JSON.stringify(this.session, null, 2));
     try {
       await this.context?.close();
@@ -10159,7 +10158,7 @@ var PlaywrightRecorder = class _PlaywrightRecorder extends EventEmitter {
     if (!this.page || !this.session) return null;
     this.actionCounter++;
     const screenshotName = name || `manual_${this.actionCounter.toString().padStart(3, "0")}.png`;
-    const screenshotPath = join4(this.session.screenshotsDir, screenshotName);
+    const screenshotPath = join5(this.session.screenshotsDir, screenshotName);
     await this.page.screenshot({ path: screenshotPath });
     this.emit("screenshot", screenshotPath, `manual_${this.actionCounter}`);
     return screenshotPath;
@@ -10283,10 +10282,10 @@ var TEST_VAR_KEY_REGEX = /^[A-Z][A-Z0-9_]{0,63}$/;
 var SCRIPT_PLACEHOLDER_REGEX = /\$\{([A-Z][A-Z0-9_]*)\}/g;
 var mobileReplayRuns = /* @__PURE__ */ new Map();
 function getMobileRecordingDir(recordingId) {
-  return join5(PROJECTS_DIR, "maestro-recordings", recordingId);
+  return join6(PROJECTS_DIR, "maestro-recordings", recordingId);
 }
 function getMobileRecordingSessionPath(recordingId) {
-  return join5(getMobileRecordingDir(recordingId), "session.json");
+  return join6(getMobileRecordingDir(recordingId), "session.json");
 }
 async function readMobileRecordingSessionData(recordingId) {
   const sessionPath = getMobileRecordingSessionPath(recordingId);
@@ -10314,9 +10313,9 @@ function getFirstRecordingScreenshotPath(session) {
   if (typeof session?.screenshotsDir !== "string" || !existsSync5(session.screenshotsDir)) {
     return void 0;
   }
-  const files = readdirSync2(session.screenshotsDir).filter((file) => file.toLowerCase().endsWith(".png")).sort();
+  const files = readdirSync4(session.screenshotsDir).filter((file) => file.toLowerCase().endsWith(".png")).sort();
   if (files.length === 0) return void 0;
-  return join5(session.screenshotsDir, files[0]);
+  return join6(session.screenshotsDir, files[0]);
 }
 function buildDefaultESVPNetworkProfile(session) {
   return buildAppLabNetworkProfile(
@@ -11382,15 +11381,15 @@ app.get("/setup", async (c) => {
 app.get("/", (c) => {
   const cwd = process.cwd();
   const possiblePaths = [
-    join5(__dirname, "index.html"),
+    join6(__dirname, "index.html"),
     // Production: bundled (dist/index.html alongside server)
-    join5(__dirname, "..", "web", "index.html"),
+    join6(__dirname, "..", "web", "index.html"),
     // Parent/web
-    join5(__dirname, "..", "..", "src", "web", "index.html"),
+    join6(__dirname, "..", "..", "src", "web", "index.html"),
     // Two levels up/src/web
-    join5(cwd, "src", "web", "index.html"),
+    join6(cwd, "src", "web", "index.html"),
     // Development: running from project root
-    join5(cwd, "dist", "index.html")
+    join6(cwd, "dist", "index.html")
     // Production: running from project root
   ];
   for (const path of possiblePaths) {
@@ -11439,14 +11438,14 @@ function resolveVideoPath(videoPath) {
   if (!videoPath) return null;
   try {
     if (!existsSync5(videoPath)) return videoPath;
-    if (!statSync2(videoPath).isDirectory()) return videoPath;
-    const videoDir = join5(videoPath, "video");
-    if (existsSync5(videoDir) && statSync2(videoDir).isDirectory()) {
-      const videoFiles = readdirSync2(videoDir).filter((f) => /\.(mp4|mov|webm)$/i.test(f));
-      if (videoFiles.length > 0) return join5(videoDir, videoFiles[0]);
-    }
-    const directFiles = readdirSync2(videoPath).filter((f) => /\.(mp4|mov|webm)$/i.test(f));
-    if (directFiles.length > 0) return join5(videoPath, directFiles[0]);
+    if (!statSync3(videoPath).isDirectory()) return videoPath;
+    const videoDir = join6(videoPath, "video");
+    if (existsSync5(videoDir) && statSync3(videoDir).isDirectory()) {
+      const videoFiles = readdirSync4(videoDir).filter((f) => /\.(mp4|mov|webm)$/i.test(f));
+      if (videoFiles.length > 0) return join6(videoDir, videoFiles[0]);
+    }
+    const directFiles = readdirSync4(videoPath).filter((f) => /\.(mp4|mov|webm)$/i.test(f));
+    if (directFiles.length > 0) return join6(videoPath, directFiles[0]);
     return videoPath;
   } catch {
     return videoPath;
@@ -11455,7 +11454,7 @@ function resolveVideoPath(videoPath) {
 function resolveRecordingBaseDir(videoPath) {
   if (!videoPath || !existsSync5(videoPath)) return null;
   try {
-    if (statSync2(videoPath).isDirectory()) {
+    if (statSync3(videoPath).isDirectory()) {
       return videoPath;
     }
     const parentDir = dirname2(videoPath);
@@ -11502,7 +11501,7 @@ async function maybeRepairMobileProjectThumbnail(project) {
   if (!recordingBaseDir || !existsSync5(recordingBaseDir)) {
     return project;
   }
-  const sessionPath = join5(recordingBaseDir, "session.json");
+  const sessionPath = join6(recordingBaseDir, "session.json");
   if (!existsSync5(sessionPath)) {
     return project;
   }
@@ -11610,7 +11609,7 @@ app.get("/api/projects/:id", async (c) => {
     let networkCapture = null;
     let esvp = null;
     if (recordingBaseDir && existsSync6(recordingBaseDir)) {
-      const sessionPath = join5(recordingBaseDir, "session.json");
+      const sessionPath = join6(recordingBaseDir, "session.json");
       if (existsSync6(sessionPath)) {
         try {
           const sessionData = JSON.parse(readFileSync3(sessionPath, "utf8"));
@@ -11675,13 +11674,13 @@ app.post("/api/projects", async (c) => {
 app.post("/api/projects/sync-orphans", async (c) => {
   try {
     const db = getDatabase();
-    const { readdirSync: readdirSync3, statSync: statSync3, existsSync: existsSync6 } = await import("fs");
+    const { readdirSync: readdirSync5, statSync: statSync4, existsSync: existsSync6 } = await import("fs");
     if (!existsSync6(PROJECTS_DIR)) {
       return c.json({ synced: 0, projects: [], message: "Projects directory does not exist" });
     }
-    const dirs = readdirSync3(PROJECTS_DIR).filter((d) => {
-      const p = join5(PROJECTS_DIR, d);
-      return statSync3(p).isDirectory() && !d.startsWith(".");
+    const dirs = readdirSync5(PROJECTS_DIR).filter((d) => {
+      const p = join6(PROJECTS_DIR, d);
+      return statSync4(p).isDirectory() && !d.startsWith(".");
     });
     const existing = await db.select({ id: projects.id }).from(projects);
     const existingIds = new Set(existing.map((p) => p.id));
@@ -11689,7 +11688,7 @@ app.post("/api/projects/sync-orphans", async (c) => {
     const orphans = dirs.filter((d) => !existingIds.has(d) && !specialDirs.has(d));
     const created = [];
     for (const id of orphans) {
-      const dirPath = join5(PROJECTS_DIR, id);
+      const dirPath = join6(PROJECTS_DIR, id);
       const platform = id.includes("_web_") ? "web" : "mobile";
       const now = /* @__PURE__ */ new Date();
       await db.insert(projects).values({
@@ -12269,15 +12268,15 @@ app.delete("/api/projects/:id", async (c) => {
     const db = getDatabase();
     const id = c.req.param("id");
     const { rmSync: rmSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     await db.delete(frames).where(eq(frames.projectId, id));
     await db.delete(projects).where(eq(projects.id, id));
     await deleteTestVariablesForOwner("project", id);
     await deleteTestVariablesForOwner("mobile-recording", id);
     await deleteTestVariablesForOwner("web-recording", id);
-    const mobileRecordingDir = join6(PROJECTS_DIR, "maestro-recordings", id);
-    const webRecordingDir = join6(PROJECTS_DIR, "web-recordings", id);
-    const projectDir = join6(PROJECTS_DIR, id);
+    const mobileRecordingDir = join7(PROJECTS_DIR, "maestro-recordings", id);
+    const webRecordingDir = join7(PROJECTS_DIR, "web-recordings", id);
+    const projectDir = join7(PROJECTS_DIR, id);
     if (existsSync5(mobileRecordingDir)) {
       rmSync3(mobileRecordingDir, { recursive: true, force: true });
       console.log(`[Delete] Removed mobile recording: ${id}`);
@@ -12291,12 +12290,12 @@ app.delete("/api/projects/:id", async (c) => {
       console.log(`[Delete] Removed project directory: ${id}`);
     }
     const { EXPORTS_DIR: exportsDir, FRAMES_DIR: framesDir } = await import("./db-745LC5YC.js");
-    const projectExportsDir = join6(exportsDir, id);
+    const projectExportsDir = join7(exportsDir, id);
     if (existsSync5(projectExportsDir)) {
       rmSync3(projectExportsDir, { recursive: true, force: true });
       console.log(`[Delete] Removed exports directory: ${id}`);
     }
-    const projectFramesDir = join6(framesDir, id);
+    const projectFramesDir = join7(framesDir, id);
     if (existsSync5(projectFramesDir)) {
       rmSync3(projectFramesDir, { recursive: true, force: true });
       console.log(`[Delete] Removed frames directory: ${id}`);
@@ -12315,19 +12314,19 @@ app.post("/api/upload", async (c) => {
       return c.json({ error: "No file provided" }, 400);
     }
     const db = getDatabase();
-    const { mkdirSync: mkdirSync5, writeFileSync: writeFileSync5, existsSync: fsExists, readdirSync: readdirSync3 } = await import("fs");
+    const { mkdirSync: mkdirSync5, writeFileSync: writeFileSync5, existsSync: fsExists, readdirSync: readdirSync5 } = await import("fs");
     const { exec: exec2 } = await import("child_process");
     const { promisify } = await import("util");
     const execAsync = promisify(exec2);
     const { PROJECTS_DIR: PROJECTS_DIR2, FRAMES_DIR } = await import("./db-745LC5YC.js");
     const id = crypto.randomUUID();
     const now = /* @__PURE__ */ new Date();
-    const projectDir = join5(PROJECTS_DIR2, id);
+    const projectDir = join6(PROJECTS_DIR2, id);
     if (!fsExists(projectDir)) {
       mkdirSync5(projectDir, { recursive: true });
     }
     const fileName = file.name;
-    const filePath = join5(projectDir, fileName);
+    const filePath = join6(projectDir, fileName);
     const arrayBuffer = await file.arrayBuffer();
     writeFileSync5(filePath, Buffer.from(arrayBuffer));
     let platform = null;
@@ -12348,17 +12347,17 @@ app.post("/api/upload", async (c) => {
     let framePaths = [];
     try {
       if (isVideo) {
-        const projectFramesDir = join5(FRAMES_DIR, id);
+        const projectFramesDir = join6(FRAMES_DIR, id);
         if (!fsExists(projectFramesDir)) {
           mkdirSync5(projectFramesDir, { recursive: true });
         }
-        const framePattern = join5(projectFramesDir, "frame_%04d.png");
+        const framePattern = join6(projectFramesDir, "frame_%04d.png");
         try {
           await execAsync(`ffmpeg -i "${filePath}" -vf "fps=1" -frames:v 15 "${framePattern}" -y 2>/dev/null`);
         } catch {
         }
         if (fsExists(projectFramesDir)) {
-          framePaths = readdirSync3(projectFramesDir).filter((f) => f.endsWith(".png")).sort().map((f) => join5(projectFramesDir, f));
+          framePaths = readdirSync5(projectFramesDir).filter((f) => f.endsWith(".png")).sort().map((f) => join6(projectFramesDir, f));
         }
         if (framePaths.length > 0) {
           const { bestFrame, analyses } = await selectBestFrame(framePaths);
@@ -12417,11 +12416,11 @@ app.post("/api/capture/start", async (c) => {
     const db = getDatabase();
     const id = crypto.randomUUID();
     const now = /* @__PURE__ */ new Date();
-    const projectDir = join5(PROJECTS_DIR2, id);
+    const projectDir = join6(PROJECTS_DIR2, id);
     if (!fsExists(projectDir)) {
       mkdirSync5(projectDir, { recursive: true });
     }
-    const screenshotPath = join5(projectDir, "capture.png");
+    const screenshotPath = join6(projectDir, "capture.png");
     const captureType = body.sourceType || body.type || "screen";
     const sourceId = typeof body.sourceId === "string" ? body.sourceId.trim() : "";
     const osPlatform = process.platform === "darwin" ? "macos" : process.platform;
@@ -12585,10 +12584,10 @@ app.post("/api/capture/mobile/start", async (c) => {
     const { mkdirSync: mkdirSync5 } = await import("fs");
     const execAsync = promisify(exec2);
     const projectId = `capture_${Date.now()}`;
-    const projectDir = join5(PROJECTS_DIR, projectId);
-    const screenshotsDir = join5(projectDir, "screenshots");
+    const projectDir = join6(PROJECTS_DIR, projectId);
+    const screenshotsDir = join6(projectDir, "screenshots");
     mkdirSync5(screenshotsDir, { recursive: true });
-    const videoPath = join5(projectDir, "recording.mp4");
+    const videoPath = join6(projectDir, "recording.mp4");
     const initialAppId = getForegroundAppIdForPlatform(platform, targetDeviceId);
     let recordProcess = null;
     if (platform === "ios") {
@@ -12705,8 +12704,8 @@ app.post("/api/capture/web/start", async (c) => {
     const vpRes = CAPTURE_RESOLUTIONS[vpResKey || captureResKey || "1080"] || captureRes;
     const { mkdirSync: mkdirSync5 } = await import("fs");
     const projectId = `capture_web_${Date.now()}`;
-    const projectDir = join5(PROJECTS_DIR, projectId);
-    const screenshotsDir = join5(projectDir, "screenshots");
+    const projectDir = join6(PROJECTS_DIR, projectId);
+    const screenshotsDir = join6(projectDir, "screenshots");
     mkdirSync5(screenshotsDir, { recursive: true });
     let browser = null;
     let page = null;
@@ -12802,7 +12801,7 @@ app.post("/api/capture/web/stop", async (c) => {
     const projectId = session.projectId;
     const endedAt = Date.now();
     const { writeFileSync: writeFileSync5 } = await import("fs");
-    const projectDir = join5(PROJECTS_DIR, projectId);
+    const projectDir = join6(PROJECTS_DIR, projectId);
     let finalPageUrl = session.url || null;
     let faviconCandidates = [];
     if (session.page) {
@@ -12833,7 +12832,7 @@ app.post("/api/capture/web/stop", async (c) => {
     await new Promise((resolve) => setTimeout(resolve, 1e3));
     session.networkDetach?.();
     if (projectId) {
-      const sessionPath = join5(projectDir, "session.json");
+      const sessionPath = join6(projectDir, "session.json");
       writeFileSync5(sessionPath, JSON.stringify({
         id: projectId,
         name: `Web Capture - ${new Date(session.startTime).toISOString()}`,
@@ -12901,8 +12900,8 @@ async function analyzeProjectInBackground(projectId) {
       });
       return;
     }
-    const { readdirSync: readdirSync3 } = await import("fs");
-    const files = readdirSync3(projectDir);
+    const { readdirSync: readdirSync5 } = await import("fs");
+    const files = readdirSync5(projectDir);
     const videoFile = files.find((f) => f.endsWith(".mp4") || f.endsWith(".webm") || f.endsWith(".mov"));
     if (!videoFile) {
       broadcastProgress("save", "done", "Capture saved without video analysis");
@@ -12922,25 +12921,25 @@ async function analyzeProjectInBackground(projectId) {
       });
       return;
     }
-    const videoPath = join5(projectDir, videoFile);
+    const videoPath = join6(projectDir, videoFile);
     const { exec: exec2 } = await import("child_process");
     const { promisify } = await import("util");
     const { mkdirSync: mkdirSync5 } = await import("fs");
     const execAsync = promisify(exec2);
-    const framesDir = join5(projectDir, "frames");
+    const framesDir = join6(projectDir, "frames");
     mkdirSync5(framesDir, { recursive: true });
     broadcastProgress("extract", "running", "Extracting frames from video...");
     await execAsync(`ffmpeg -i "${videoPath}" -vf "fps=1" -q:v 2 "${framesDir}/frame_%04d.jpg" -y`);
     broadcastProgress("extract", "done", "Frames extracted");
     const { isBlankFrame } = await import("./frames-RCNLSDD6.js");
     const { unlinkSync } = await import("fs");
-    const allFrameFiles = readdirSync3(framesDir).filter((f) => f.endsWith(".jpg")).sort();
+    const allFrameFiles = readdirSync5(framesDir).filter((f) => f.endsWith(".jpg")).sort();
     const frameFiles = [];
     for (const f of allFrameFiles) {
-      const { isBlank } = isBlankFrame(join5(framesDir, f));
+      const { isBlank } = isBlankFrame(join6(framesDir, f));
       if (isBlank) {
         try {
-          unlinkSync(join5(framesDir, f));
+          unlinkSync(join6(framesDir, f));
         } catch {
         }
       } else {
@@ -12977,7 +12976,7 @@ async function analyzeProjectInBackground(projectId) {
       const ocrFrames = frameFiles.slice(0, 10);
       broadcastProgress("ocr", "running", `Processing 0/${ocrFrames.length} frames...`, void 0, 0, ocrFrames.length);
       for (const [index, frameFile] of ocrFrames.entries()) {
-        const framePath = join5(framesDir, frameFile);
+        const framePath = join6(framesDir, frameFile);
         const ocrResult = await recognizeText(framePath);
         if (ocrResult.success && ocrResult.text) {
           allOcrText += ocrResult.text + "\n\n";
@@ -13042,7 +13041,7 @@ async function analyzeProjectInBackground(projectId) {
     } else {
       broadcastProgress("summary", "skipped", "Skipped \u2014 no text to analyze");
     }
-    const extractedThumbnailPath = join5(framesDir, bestFrame);
+    const extractedThumbnailPath = join6(framesDir, bestFrame);
     const resolvedThumbnailPath = project.thumbnailPath && existsSync5(project.thumbnailPath) ? project.thumbnailPath : existsSync5(extractedThumbnailPath) ? extractedThumbnailPath : null;
     const ocrEngine = ocrEngines.has("vision") ? "vision" : ocrEngines.has("tesseract") ? "tesseract" : null;
     const ocrConfidence = ocrConfidences.length > 0 ? ocrConfidences.reduce((sum, value) => sum + value, 0) / ocrConfidences.length : null;
@@ -13113,14 +13112,14 @@ app.post("/api/analyze/:id", async (c) => {
         try {
           const { exec: exec2 } = await import("child_process");
           const { promisify } = await import("util");
-          const { mkdirSync: mkdirSync5, readdirSync: readdirSync3 } = await import("fs");
+          const { mkdirSync: mkdirSync5, readdirSync: readdirSync5 } = await import("fs");
           const execAsync = promisify(exec2);
           const { FRAMES_DIR } = await import("./db-745LC5YC.js");
-          const projectFramesDir = join5(FRAMES_DIR, id);
+          const projectFramesDir = join6(FRAMES_DIR, id);
           if (!existsSync5(projectFramesDir)) {
             mkdirSync5(projectFramesDir, { recursive: true });
           }
-          const framePattern = join5(projectFramesDir, "frame_%04d.png");
+          const framePattern = join6(projectFramesDir, "frame_%04d.png");
           try {
             const { stderr } = await execAsync(`ffmpeg -i "${filePath}" -vf "fps=1" -frames:v 10 "${framePattern}" -y 2>&1`);
             if (stderr) console.log("[FFmpeg] Output:", stderr.slice(0, 500));
@@ -13133,7 +13132,7 @@ app.post("/api/analyze/:id", async (c) => {
               console.error("[FFmpeg] Keyframe fallback also failed:", fallbackError);
             }
           }
-          const frameFiles = readdirSync3(projectFramesDir).filter((f) => f.endsWith(".png")).sort().map((f) => join5(projectFramesDir, f));
+          const frameFiles = readdirSync5(projectFramesDir).filter((f) => f.endsWith(".png")).sort().map((f) => join6(projectFramesDir, f));
           frameCount = frameFiles.length;
           console.log(`[FFmpeg] Extracted ${frameCount} frames from video`);
           if (frameFiles.length > 0) {
@@ -13244,9 +13243,9 @@ app.get("/api/grid/backgrounds", async (c) => {
   try {
     const { getAvailableBackgrounds, PRESET_GRADIENTS, PRESET_SOLID_COLORS } = await import("./gridCompositor-VUWBZXYL.js");
     const possibleBgDirs = [
-      join5(__dirname, "..", "assets", "backgrounds"),
-      join5(__dirname, "..", "..", "assets", "backgrounds"),
-      join5(process.cwd(), "assets", "backgrounds")
+      join6(__dirname, "..", "assets", "backgrounds"),
+      join6(__dirname, "..", "..", "assets", "backgrounds"),
+      join6(process.cwd(), "assets", "backgrounds")
     ];
     const backgroundsDir = possibleBgDirs.find((d) => existsSync5(d)) || possibleBgDirs[0];
     const imageBackgrounds = getAvailableBackgrounds(backgroundsDir);
@@ -13273,21 +13272,21 @@ app.post("/api/grid/preview", async (c) => {
     const { composeGrid, recommendLayout } = await import("./gridCompositor-VUWBZXYL.js");
     const { EXPORTS_DIR: EXPORTS_DIR2 } = await import("./db-745LC5YC.js");
     const { mkdirSync: mkdirSync5 } = await import("fs");
-    const previewDir = join5(EXPORTS_DIR2, "grid-previews");
+    const previewDir = join6(EXPORTS_DIR2, "grid-previews");
     if (!existsSync5(previewDir)) {
       mkdirSync5(previewDir, { recursive: true });
     }
     const previewId = crypto.randomUUID();
-    const outputPath = join5(previewDir, `preview-${previewId}.png`);
+    const outputPath = join6(previewDir, `preview-${previewId}.png`);
     const gridConfig = {
       ...config,
       layout: config?.layout || recommendLayout(images.length, config?.aspectRatio || "9:16")
     };
     if (gridConfig.background?.type === "image" && gridConfig.background?.imageId) {
       const possibleBgDirs = [
-        join5(__dirname, "..", "assets", "backgrounds"),
-        join5(__dirname, "..", "..", "assets", "backgrounds"),
-        join5(process.cwd(), "assets", "backgrounds")
+        join6(__dirname, "..", "assets", "backgrounds"),
+        join6(__dirname, "..", "..", "assets", "backgrounds"),
+        join6(process.cwd(), "assets", "backgrounds")
       ];
       const backgroundsDir = possibleBgDirs.find((d) => existsSync5(d)) || possibleBgDirs[0];
       const { getAvailableBackgrounds } = await import("./gridCompositor-VUWBZXYL.js");
@@ -13430,13 +13429,13 @@ app.post("/api/grid/export", async (c) => {
     const { composeGrid, recommendLayout } = await import("./gridCompositor-VUWBZXYL.js");
     const { EXPORTS_DIR: EXPORTS_DIR2 } = await import("./db-745LC5YC.js");
     const { mkdirSync: mkdirSync5 } = await import("fs");
-    const exportDir = projectId ? join5(EXPORTS_DIR2, projectId) : join5(EXPORTS_DIR2, "grids");
+    const exportDir = projectId ? join6(EXPORTS_DIR2, projectId) : join6(EXPORTS_DIR2, "grids");
     if (!existsSync5(exportDir)) {
       mkdirSync5(exportDir, { recursive: true });
     }
     const timestamp = Date.now();
     const exportFilename = filename || `grid-${timestamp}.png`;
-    const outputPath = join5(exportDir, exportFilename);
+    const outputPath = join6(exportDir, exportFilename);
     const gridConfig = {
       ...config,
       layout: config?.layout || recommendLayout(images.length, config?.aspectRatio || "9:16"),
@@ -13445,9 +13444,9 @@ app.post("/api/grid/export", async (c) => {
     };
     if (gridConfig.background?.type === "image" && gridConfig.background?.imageId) {
       const possibleBgDirs = [
-        join5(__dirname, "..", "assets", "backgrounds"),
-        join5(__dirname, "..", "..", "assets", "backgrounds"),
-        join5(process.cwd(), "assets", "backgrounds")
+        join6(__dirname, "..", "assets", "backgrounds"),
+        join6(__dirname, "..", "..", "assets", "backgrounds"),
+        join6(process.cwd(), "assets", "backgrounds")
       ];
       const backgroundsDir = possibleBgDirs.find((d) => existsSync5(d)) || possibleBgDirs[0];
       const { getAvailableBackgrounds } = await import("./gridCompositor-VUWBZXYL.js");
@@ -13514,11 +13513,11 @@ app.post("/api/grid/infographic", async (c) => {
     }
     const { composeInfographic } = await import("./gridCompositor-VUWBZXYL.js");
     const { EXPORTS_DIR: EXPORTS_DIR2 } = await import("./db-745LC5YC.js");
-    const exportDir = projectId ? join5(EXPORTS_DIR2, projectId) : join5(EXPORTS_DIR2, "grids");
+    const exportDir = projectId ? join6(EXPORTS_DIR2, projectId) : join6(EXPORTS_DIR2, "grids");
     if (!existsSync5(exportDir)) {
       mkdirSync4(exportDir, { recursive: true });
     }
-    const outputPath = join5(exportDir, `infographic-${Date.now()}.png`);
+    const outputPath = join6(exportDir, `infographic-${Date.now()}.png`);
     const result = await composeInfographic(
       images.map((img, i) => ({
         imagePath: img.path || img.imagePath,
@@ -13620,14 +13619,14 @@ app.get("/api/grid/project-frames/:id", async (c) => {
     }
     const project = result[0];
     const { FRAMES_DIR } = await import("./db-745LC5YC.js");
-    const { readdirSync: readdirSync3 } = await import("fs");
+    const { readdirSync: readdirSync5 } = await import("fs");
     const availableFrames = [];
     const { isBlankFrame } = await import("./frames-RCNLSDD6.js");
-    const projectFramesDir = join5(FRAMES_DIR, id);
+    const projectFramesDir = join6(FRAMES_DIR, id);
     if (existsSync5(projectFramesDir)) {
-      const frameFiles = readdirSync3(projectFramesDir).filter((f) => /\.(png|jpg|jpeg)$/i.test(f)).sort();
+      const frameFiles = readdirSync5(projectFramesDir).filter((f) => /\.(png|jpg|jpeg)$/i.test(f)).sort();
       for (const f of frameFiles) {
-        const framePath = join5(projectFramesDir, f);
+        const framePath = join6(projectFramesDir, f);
         if (isBlankFrame(framePath).isBlank) continue;
         availableFrames.push({
           path: framePath,
@@ -13636,11 +13635,11 @@ app.get("/api/grid/project-frames/:id", async (c) => {
         });
       }
     }
-    const projectFramesDir2 = join5(PROJECTS_DIR, id, "frames");
+    const projectFramesDir2 = join6(PROJECTS_DIR, id, "frames");
     if (existsSync5(projectFramesDir2)) {
-      const frameFiles = readdirSync3(projectFramesDir2).filter((f) => /\.(png|jpg|jpeg)$/i.test(f)).sort();
+      const frameFiles = readdirSync5(projectFramesDir2).filter((f) => /\.(png|jpg|jpeg)$/i.test(f)).sort();
       for (const f of frameFiles) {
-        const framePath = join5(projectFramesDir2, f);
+        const framePath = join6(projectFramesDir2, f);
         if (!availableFrames.some((frame) => frame.path === framePath)) {
           availableFrames.push({
             path: framePath,
@@ -13668,14 +13667,14 @@ app.get("/api/grid/project-frames/:id", async (c) => {
       });
     }
     if (project.videoPath && existsSync5(project.videoPath)) {
-      const { statSync: statSync3 } = await import("fs");
-      const stats = statSync3(project.videoPath);
+      const { statSync: statSync4 } = await import("fs");
+      const stats = statSync4(project.videoPath);
       if (stats.isDirectory()) {
-        const screenshotsDir = join5(project.videoPath, "screenshots");
+        const screenshotsDir = join6(project.videoPath, "screenshots");
         if (existsSync5(screenshotsDir)) {
-          const screenshotFiles = readdirSync3(screenshotsDir).filter((f) => /\.(png|jpg|jpeg)$/i.test(f)).sort();
+          const screenshotFiles = readdirSync5(screenshotsDir).filter((f) => /\.(png|jpg|jpeg)$/i.test(f)).sort();
           for (const f of screenshotFiles) {
-            const screenshotPath = join5(screenshotsDir, f);
+            const screenshotPath = join6(screenshotsDir, f);
             if (!availableFrames.some((frame) => frame.path === screenshotPath)) {
               availableFrames.push({
                 path: screenshotPath,
@@ -13715,7 +13714,7 @@ function writeExportText(filePath, text) {
 function copyPathIntoExportBundle(sourcePath, destinationPath) {
   if (!sourcePath || !existsSync5(sourcePath)) return false;
   ensureExportParentDir(destinationPath);
-  if (statSync2(sourcePath).isDirectory()) {
+  if (statSync3(sourcePath).isDirectory()) {
     cpSync(sourcePath, destinationPath, { recursive: true });
   } else {
     copyFileSync(sourcePath, destinationPath);
@@ -13725,16 +13724,16 @@ function copyPathIntoExportBundle(sourcePath, destinationPath) {
 function looksLikeRecordingDirectory(dirPath) {
   if (!dirPath || !existsSync5(dirPath)) return false;
   try {
-    if (!statSync2(dirPath).isDirectory()) return false;
+    if (!statSync3(dirPath).isDirectory()) return false;
   } catch {
     return false;
   }
   return [
-    join5(dirPath, "session.json"),
-    join5(dirPath, "screenshots"),
-    join5(dirPath, "video"),
-    join5(dirPath, "test.yaml"),
-    join5(dirPath, "test.spec.ts")
+    join6(dirPath, "session.json"),
+    join6(dirPath, "screenshots"),
+    join6(dirPath, "video"),
+    join6(dirPath, "test.yaml"),
+    join6(dirPath, "test.spec.ts")
   ].some((candidate) => existsSync5(candidate));
 }
 function resolveProjectBundleRecordingDir(originalVideoPath, resolvedVideoPath) {
@@ -13751,13 +13750,13 @@ function resolveProjectBundleRecordingDir(originalVideoPath, resolvedVideoPath)
   return null;
 }
 function copyProjectExportArtifacts(sourceDir, destinationDir) {
-  if (!existsSync5(sourceDir) || !statSync2(sourceDir).isDirectory()) {
+  if (!existsSync5(sourceDir) || !statSync3(sourceDir).isDirectory()) {
     return 0;
   }
   let copiedCount = 0;
-  for (const entry of readdirSync2(sourceDir)) {
+  for (const entry of readdirSync4(sourceDir)) {
     if (/\.(applab|esvp)$/i.test(entry)) continue;
-    if (copyPathIntoExportBundle(join5(sourceDir, entry), join5(destinationDir, entry))) {
+    if (copyPathIntoExportBundle(join6(sourceDir, entry), join6(destinationDir, entry))) {
       copiedCount += 1;
     }
   }
@@ -13881,7 +13880,7 @@ app.post("/api/export", async (c) => {
     }
     const { promisify } = await import("util");
     const execAsync = promisify(exec);
-    const exportDir = join5(EXPORTS_DIR, projectId);
+    const exportDir = join6(EXPORTS_DIR, projectId);
     if (!existsSync5(exportDir)) {
       mkdirSync4(exportDir, { recursive: true });
     }
@@ -13889,13 +13888,13 @@ app.post("/api/export", async (c) => {
     let outputPath = "";
     let mimeType = "image/png";
     const resolvedVideoPath = resolveVideoPath(rawProject.videoPath);
-    const isVideoPathDirectory = !!rawProject.videoPath && existsSync5(rawProject.videoPath) && statSync2(rawProject.videoPath).isDirectory();
+    const isVideoPathDirectory = !!rawProject.videoPath && existsSync5(rawProject.videoPath) && statSync3(rawProject.videoPath).isDirectory();
     if (format === "applab" || format === "esvp") {
       const projectFrames = await db.select().from(frames).where(eq(frames.projectId, projectId)).orderBy(frames.frameNumber);
       const exportRecords = await db.select().from(projectExports).where(eq(projectExports.projectId, projectId)).orderBy(desc(projectExports.createdAt));
       const recordingBaseDir = resolveProjectBundleRecordingDir(rawProject.videoPath, resolvedVideoPath);
-      const exportArtifactsDir = join5(EXPORTS_DIR, projectId);
-      const sessionPath = recordingBaseDir ? join5(recordingBaseDir, "session.json") : null;
+      const exportArtifactsDir = join6(EXPORTS_DIR, projectId);
+      const sessionPath = recordingBaseDir ? join6(recordingBaseDir, "session.json") : null;
       let sessionData = null;
       let networkEntries = [];
       let networkCapture = null;
@@ -13911,9 +13910,9 @@ app.post("/api/export", async (c) => {
           sessionData = null;
         }
       }
-      const stagingRoot = mkdtempSync(join5(tmpdir2(), `${format}-export-`));
+      const stagingRoot = mkdtempSync(join6(tmpdir2(), `${format}-export-`));
       const bundleFolderName = `${sanitizeProjectExportSlug(rawProject.name)}-${new Date(timestamp).toISOString().slice(0, 10)}`;
-      const bundleRoot = join5(stagingRoot, bundleFolderName);
+      const bundleRoot = join6(stagingRoot, bundleFolderName);
       mkdirSync4(bundleRoot, { recursive: true });
       try {
         const summaryPath = rawProject.aiSummary ? "analysis/app-intelligence.md" : null;
@@ -13924,25 +13923,25 @@ app.post("/api/export", async (c) => {
           const extensionMatch = basename3(frame.imagePath).match(/(\.[^.]+)$/);
           const extension = extensionMatch ? extensionMatch[1] : ".png";
           const relativeImagePath = `frames/frame-${String(frame.frameNumber).padStart(4, "0")}${extension}`;
-          copyPathIntoExportBundle(frame.imagePath, join5(bundleRoot, relativeImagePath));
+          copyPathIntoExportBundle(frame.imagePath, join6(bundleRoot, relativeImagePath));
           return {
             ...frame,
             imagePath: relativeImagePath
           };
         });
         const mediaFiles = [];
-        if (resolvedVideoPath && existsSync5(resolvedVideoPath) && !statSync2(resolvedVideoPath).isDirectory()) {
+        if (resolvedVideoPath && existsSync5(resolvedVideoPath) && !statSync3(resolvedVideoPath).isDirectory()) {
           const relativePath = `media/${resolvedMediaName}`;
-          copyPathIntoExportBundle(resolvedVideoPath, join5(bundleRoot, relativePath));
+          copyPathIntoExportBundle(resolvedVideoPath, join6(bundleRoot, relativePath));
           mediaFiles.push({ role: "primary-media", path: relativePath });
         }
         if (rawProject.thumbnailPath && existsSync5(rawProject.thumbnailPath) && thumbnailName) {
           const relativePath = `media/${thumbnailName}`;
-          copyPathIntoExportBundle(rawProject.thumbnailPath, join5(bundleRoot, relativePath));
+          copyPathIntoExportBundle(rawProject.thumbnailPath, join6(bundleRoot, relativePath));
           mediaFiles.push({ role: "thumbnail", path: relativePath });
         }
-        const recordingIncluded = recordingBaseDir ? copyPathIntoExportBundle(recordingBaseDir, join5(bundleRoot, "recording")) : false;
-        const exportArtifactCount = copyProjectExportArtifacts(exportArtifactsDir, join5(bundleRoot, "exports"));
+        const recordingIncluded = recordingBaseDir ? copyPathIntoExportBundle(recordingBaseDir, join6(bundleRoot, "recording")) : false;
+        const exportArtifactCount = copyProjectExportArtifacts(exportArtifactsDir, join6(bundleRoot, "exports"));
         const esvpSessionId = resolveProjectESVPSessionId(esvp);
         const esvpServerUrl = resolveProjectESVPServerUrl(esvp);
         let esvpSnapshot = null;
@@ -13968,7 +13967,7 @@ app.post("/api/export", async (c) => {
           thumbnailPath: thumbnailName ? `media/${thumbnailName}` : normalizedProject.thumbnailPath,
           frames: bundledFrames
         };
-        writeExportJson(join5(bundleRoot, "manifest.json"), {
+        writeExportJson(join6(bundleRoot, "manifest.json"), {
           bundleVersion: 1,
           packageFormat: format,
           exportedAt: new Date(timestamp).toISOString(),
@@ -13996,42 +13995,42 @@ app.post("/api/export", async (c) => {
             esvpSessionId: esvpSessionId || null
           }
         });
-        writeExportJson(join5(bundleRoot, "metadata", "project.json"), packagedProject);
-        writeExportJson(join5(bundleRoot, "metadata", "exports.json"), exportRecords);
+        writeExportJson(join6(bundleRoot, "metadata", "project.json"), packagedProject);
+        writeExportJson(join6(bundleRoot, "metadata", "exports.json"), exportRecords);
         if (sessionData) {
-          writeExportJson(join5(bundleRoot, "metadata", "session.json"), sessionData);
+          writeExportJson(join6(bundleRoot, "metadata", "session.json"), sessionData);
         }
         if (rawProject.taskHubLinks) {
-          writeExportJson(join5(bundleRoot, "taskhub", "links.json"), normalizedProject.taskHubLinks);
+          writeExportJson(join6(bundleRoot, "taskhub", "links.json"), normalizedProject.taskHubLinks);
         }
         if (rawProject.taskRequirements) {
-          writeExportJson(join5(bundleRoot, "taskhub", "requirements.json"), normalizedProject.taskRequirements);
+          writeExportJson(join6(bundleRoot, "taskhub", "requirements.json"), normalizedProject.taskRequirements);
         }
         if (rawProject.taskTestMap) {
-          writeExportJson(join5(bundleRoot, "taskhub", "test-map.json"), normalizedProject.taskTestMap);
+          writeExportJson(join6(bundleRoot, "taskhub", "test-map.json"), normalizedProject.taskTestMap);
         }
         if (summaryPath) {
-          writeExportText(join5(bundleRoot, summaryPath), rawProject.aiSummary || "");
+          writeExportText(join6(bundleRoot, summaryPath), rawProject.aiSummary || "");
         }
         if (ocrPath) {
-          writeExportText(join5(bundleRoot, ocrPath), rawProject.ocrText || "");
+          writeExportText(join6(bundleRoot, ocrPath), rawProject.ocrText || "");
         }
         if (bundledFrames.length > 0) {
-          writeExportJson(join5(bundleRoot, "analysis", "frames.json"), bundledFrames);
+          writeExportJson(join6(bundleRoot, "analysis", "frames.json"), bundledFrames);
         }
         if (networkEntries.length > 0) {
-          writeExportJson(join5(bundleRoot, "network", "entries.json"), networkEntries);
+          writeExportJson(join6(bundleRoot, "network", "entries.json"), networkEntries);
         }
         if (networkCapture) {
-          writeExportJson(join5(bundleRoot, "network", "capture.json"), networkCapture);
+          writeExportJson(join6(bundleRoot, "network", "capture.json"), networkCapture);
         }
         if (esvp) {
-          writeExportJson(join5(bundleRoot, "network", "esvp.json"), esvp);
+          writeExportJson(join6(bundleRoot, "network", "esvp.json"), esvp);
         }
         if (esvpSnapshot) {
-          writeExportJson(join5(bundleRoot, "esvp", "snapshot.json"), esvpSnapshot);
+          writeExportJson(join6(bundleRoot, "esvp", "snapshot.json"), esvpSnapshot);
         }
-        writeExportText(join5(bundleRoot, "README.txt"), [
+        writeExportText(join6(bundleRoot, "README.txt"), [
           `${rawProject.name}`,
           `Exported from DiscoveryLab ${APP_VERSION} on ${new Date(timestamp).toISOString()}.`,
           "",
@@ -14045,24 +14044,24 @@ app.post("/api/export", async (c) => {
           "- previously generated export assets such as grids and renders",
           "- Task Hub links, requirements, and test map"
         ].join("\n"));
-        outputPath = join5(exportDir, `export-${timestamp}.${format}`);
+        outputPath = join6(exportDir, `export-${timestamp}.${format}`);
         mimeType = "application/zip";
         await createProjectArchive(bundleRoot, outputPath);
       } finally {
         rmSync2(stagingRoot, { recursive: true, force: true });
       }
     } else if (isVideoPathDirectory && format === "gif") {
-      outputPath = join5(exportDir, `export-${timestamp}.gif`);
+      outputPath = join6(exportDir, `export-${timestamp}.gif`);
       mimeType = "image/gif";
-      const screenshotsDir = join5(rawProject.videoPath, "screenshots");
-      const screenshotsDirExists = existsSync5(screenshotsDir) && statSync2(screenshotsDir).isDirectory();
+      const screenshotsDir = join6(rawProject.videoPath, "screenshots");
+      const screenshotsDirExists = existsSync5(screenshotsDir) && statSync3(screenshotsDir).isDirectory();
       const sourceDir = screenshotsDirExists ? screenshotsDir : rawProject.videoPath;
-      const { readdirSync: readdirSync3 } = await import("fs");
-      const pngFiles = readdirSync3(sourceDir).filter((f) => f.endsWith(".png")).sort().map((f) => join5(sourceDir, f));
+      const { readdirSync: readdirSync5 } = await import("fs");
+      const pngFiles = readdirSync5(sourceDir).filter((f) => f.endsWith(".png")).sort().map((f) => join6(sourceDir, f));
       if (pngFiles.length === 0) {
         return c.json({ error: "No screenshots found in recording" }, 400);
       }
-      const concatPath = join5(exportDir, `concat-${timestamp}.txt`);
+      const concatPath = join6(exportDir, `concat-${timestamp}.txt`);
       const concatContent = pngFiles.map((f) => `file '${f}'
 duration 0.5`).join("\n");
       writeFileSync4(concatPath, concatContent);
@@ -14079,17 +14078,17 @@ duration 0.5`).join("\n");
         return c.json({ error: "GIF creation failed - FFmpeg required. Install with: brew install ffmpeg" }, 400);
       }
     } else if (isVideoPathDirectory && format === "mp4") {
-      outputPath = join5(exportDir, `export-${timestamp}.mp4`);
+      outputPath = join6(exportDir, `export-${timestamp}.mp4`);
       mimeType = "video/mp4";
-      const screenshotsDir = join5(rawProject.videoPath, "screenshots");
-      const screenshotsDirExists = existsSync5(screenshotsDir) && statSync2(screenshotsDir).isDirectory();
+      const screenshotsDir = join6(rawProject.videoPath, "screenshots");
+      const screenshotsDirExists = existsSync5(screenshotsDir) && statSync3(screenshotsDir).isDirectory();
       const sourceDir = screenshotsDirExists ? screenshotsDir : rawProject.videoPath;
-      const { readdirSync: readdirSync3 } = await import("fs");
-      const pngFiles = readdirSync3(sourceDir).filter((f) => f.endsWith(".png")).sort().map((f) => join5(sourceDir, f));
+      const { readdirSync: readdirSync5 } = await import("fs");
+      const pngFiles = readdirSync5(sourceDir).filter((f) => f.endsWith(".png")).sort().map((f) => join6(sourceDir, f));
       if (pngFiles.length === 0) {
         return c.json({ error: "No screenshots found in recording" }, 400);
       }
-      const concatPath = join5(exportDir, `concat-${timestamp}.txt`);
+      const concatPath = join6(exportDir, `concat-${timestamp}.txt`);
       const concatContent = pngFiles.map((f) => `file '${f}'
 duration 0.5`).join("\n");
       writeFileSync4(concatPath, concatContent);
@@ -14106,12 +14105,12 @@ duration 0.5`).join("\n");
         return c.json({ error: "Video creation failed - FFmpeg required. Install with: brew install ffmpeg" }, 400);
       }
     } else if (isVideoPathDirectory) {
-      outputPath = join5(exportDir, `export-${timestamp}`);
+      outputPath = join6(exportDir, `export-${timestamp}`);
       cpSync(rawProject.videoPath, outputPath, { recursive: true });
       mimeType = "application/octet-stream";
     } else if (format === "png" || format === "jpg" || format === "jpeg") {
       const ext = format === "jpg" ? "jpeg" : format;
-      outputPath = join5(exportDir, `export-${timestamp}.${format}`);
+      outputPath = join6(exportDir, `export-${timestamp}.${format}`);
       mimeType = `image/${ext}`;
       if (resolvedVideoPath?.endsWith(`.${format}`)) {
         copyFileSync(resolvedVideoPath, outputPath);
@@ -14120,11 +14119,11 @@ duration 0.5`).join("\n");
           await execAsync(`sips -s format ${format} "${resolvedVideoPath}" --out "${outputPath}"`);
         } catch {
           copyFileSync(resolvedVideoPath, outputPath);
-          outputPath = join5(exportDir, `export-${timestamp}${resolvedVideoPath?.substring(resolvedVideoPath.lastIndexOf("."))}`);
+          outputPath = join6(exportDir, `export-${timestamp}${resolvedVideoPath?.substring(resolvedVideoPath.lastIndexOf("."))}`);
         }
       }
     } else if (format === "gif") {
-      outputPath = join5(exportDir, `export-${timestamp}.gif`);
+      outputPath = join6(exportDir, `export-${timestamp}.gif`);
       mimeType = "image/gif";
       try {
         await execAsync(`ffmpeg -i "${resolvedVideoPath}" -vf "fps=10,scale=320:-1:flags=lanczos" "${outputPath}" -y`);
@@ -14134,7 +14133,7 @@ duration 0.5`).join("\n");
         mimeType = "image/png";
       }
     } else if (format === "mp4") {
-      outputPath = join5(exportDir, `export-${timestamp}.mp4`);
+      outputPath = join6(exportDir, `export-${timestamp}.mp4`);
       mimeType = "video/mp4";
       if (resolvedVideoPath?.endsWith(".mp4")) {
         copyFileSync(resolvedVideoPath, outputPath);
@@ -14147,7 +14146,7 @@ duration 0.5`).join("\n");
       }
     } else {
       const ext = resolvedVideoPath?.substring(resolvedVideoPath.lastIndexOf(".")) || "";
-      outputPath = join5(exportDir, `export-${timestamp}${ext}`);
+      outputPath = join6(exportDir, `export-${timestamp}${ext}`);
       if (resolvedVideoPath) {
         copyFileSync(resolvedVideoPath, outputPath);
       }
@@ -14170,7 +14169,7 @@ ${rawProject.aiSummary}
 ${rawProject.ocrText}
 `;
       }
-      const textPath = join5(exportDir, `export-${timestamp}.txt`);
+      const textPath = join6(exportDir, `export-${timestamp}.txt`);
       writeFileSync4(textPath, textContent);
     }
     if (destination === "local" || destination === "clipboard") {
@@ -14205,7 +14204,7 @@ app.get("/api/visualization/:projectId/:templateId", async (c) => {
     const [project] = await db.select().from(projects).where(eq(projects.id, projectId)).limit(1);
     if (!project) return c.json({ error: "Project not found" }, 404);
     const { FRAMES_DIR } = await import("./db-745LC5YC.js");
-    const projectFramesDir = join5(FRAMES_DIR, projectId);
+    const projectFramesDir = join6(FRAMES_DIR, projectId);
     const dbFrames = await db.select().from(frames).where(eq(frames.projectId, projectId)).orderBy(frames.frameNumber).limit(10);
     let frameImages = [];
     if (dbFrames.length > 0) {
@@ -14216,20 +14215,20 @@ app.get("/api/visualization/:projectId/:templateId", async (c) => {
       }));
     } else {
       const screenshotsDirs = [
-        join5(projectFramesDir),
+        join6(projectFramesDir),
         ...project.videoPath ? [
-          join5(project.videoPath, "screenshots"),
+          join6(project.videoPath, "screenshots"),
           project.videoPath
         ] : [],
-        join5(PROJECTS_DIR, "maestro-recordings", projectId, "screenshots"),
-        join5(PROJECTS_DIR, "web-recordings", projectId, "screenshots")
+        join6(PROJECTS_DIR, "maestro-recordings", projectId, "screenshots"),
+        join6(PROJECTS_DIR, "web-recordings", projectId, "screenshots")
       ];
       for (const dir of screenshotsDirs) {
-        if (!existsSync5(dir) || !statSync2(dir).isDirectory()) continue;
-        const files = readdirSync2(dir).filter((f) => /\.(png|jpg|jpeg|gif|webp)$/i.test(f)).sort().slice(0, 10);
+        if (!existsSync5(dir) || !statSync3(dir).isDirectory()) continue;
+        const files = readdirSync4(dir).filter((f) => /\.(png|jpg|jpeg|gif|webp)$/i.test(f)).sort().slice(0, 10);
         if (files.length > 0) {
           frameImages = files.map((f, i) => ({
-            imageUrl: `/api/file?path=${encodeURIComponent(join5(dir, f))}`,
+            imageUrl: `/api/file?path=${encodeURIComponent(join6(dir, f))}`,
             label: `Screen ${i + 1}`,
             number: i + 1
           }));
@@ -14290,7 +14289,7 @@ app.get("/api/visualization/:projectId/:templateId", async (c) => {
       case "app-flow-map": {
         let phases = [];
         const { EXPORTS_DIR: expDir } = await import("./db-745LC5YC.js");
-        const cachePath = join5(expDir, projectId, "flowmap-cache.json");
+        const cachePath = join6(expDir, projectId, "flowmap-cache.json");
         let cachedFlowMap = null;
         try {
           if (existsSync5(cachePath)) {
@@ -14379,7 +14378,7 @@ Rules:
             }
           }
           try {
-            const cacheDir = join5(expDir, projectId);
+            const cacheDir = join6(expDir, projectId);
             if (!existsSync5(cacheDir)) mkdirSync4(cacheDir, { recursive: true });
             const cacheData = {
               title: vizData.title,
@@ -14417,11 +14416,11 @@ Rules:
       default:
         return c.json({ error: `Unknown template: ${templateId}` }, 400);
     }
-    const templatePath = join5(__dirname, "..", "core", "visualizations", "templates", `${templateId}.html`);
+    const templatePath = join6(__dirname, "..", "core", "visualizations", "templates", `${templateId}.html`);
     const possiblePaths = [
       templatePath,
-      join5(__dirname, "..", "..", "src", "core", "visualizations", "templates", `${templateId}.html`),
-      join5(process.cwd(), "src", "core", "visualizations", "templates", `${templateId}.html`)
+      join6(__dirname, "..", "..", "src", "core", "visualizations", "templates", `${templateId}.html`),
+      join6(process.cwd(), "src", "core", "visualizations", "templates", `${templateId}.html`)
     ];
     let htmlContent = "";
     for (const p of possiblePaths) {
@@ -14459,12 +14458,12 @@ app.post("/api/visualization/screenshot", async (c) => {
       return c.json({ error: "projectId and templateId required" }, 400);
     }
     const { EXPORTS_DIR: EXPORTS_DIR2 } = await import("./db-745LC5YC.js");
-    const exportDir = join5(EXPORTS_DIR2, projectId);
+    const exportDir = join6(EXPORTS_DIR2, projectId);
     if (!existsSync5(exportDir)) {
       mkdirSync4(exportDir, { recursive: true });
     }
     const ext = format === "gif" ? "gif" : "png";
-    const outputPath = join5(exportDir, `viz-${templateId}-${Date.now()}.${ext}`);
+    const outputPath = join6(exportDir, `viz-${templateId}-${Date.now()}.${ext}`);
     const serverPort = process.env.PORT || "3847";
     const vizUrl = `http://localhost:${serverPort}/api/visualization/${projectId}/${templateId}`;
     const { chromium: chromium2 } = await import("playwright");
@@ -14473,12 +14472,12 @@ app.post("/api/visualization/screenshot", async (c) => {
     await page.goto(vizUrl, { waitUntil: "networkidle" });
     await page.waitForTimeout(2500);
     if (format === "gif") {
-      const framesDir = join5(exportDir, `viz-gif-frames-${Date.now()}`);
+      const framesDir = join6(exportDir, `viz-gif-frames-${Date.now()}`);
       mkdirSync4(framesDir, { recursive: true });
       const frameCount = 20;
       const intervalMs = 200;
       for (let i = 0; i < frameCount; i++) {
-        await page.screenshot({ path: join5(framesDir, `frame-${String(i).padStart(3, "0")}.png`) });
+        await page.screenshot({ path: join6(framesDir, `frame-${String(i).padStart(3, "0")}.png`) });
         await page.waitForTimeout(intervalMs);
       }
       await browser.close();
@@ -14486,13 +14485,13 @@ app.post("/api/visualization/screenshot", async (c) => {
       const execPromise = promisify(exec);
       try {
         await execPromise(
-          `ffmpeg -framerate 5 -i "${join5(framesDir, "frame-%03d.png")}" -vf "scale=600:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 "${outputPath}" -y`,
+          `ffmpeg -framerate 5 -i "${join6(framesDir, "frame-%03d.png")}" -vf "scale=600:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 "${outputPath}" -y`,
           { timeout: 3e4 }
         );
       } catch (ffmpegError) {
         const { copyFileSync: copyFileSync2 } = await import("fs");
         const fallbackPath = outputPath.replace(".gif", ".png");
-        copyFileSync2(join5(framesDir, "frame-000.png"), fallbackPath);
+        copyFileSync2(join6(framesDir, "frame-000.png"), fallbackPath);
         const { rmSync: rmSync4 } = await import("fs");
         rmSync4(framesDir, { recursive: true, force: true });
         return c.json({
@@ -14531,16 +14530,16 @@ app.get("/api/export/document/:projectId", async (c) => {
     if (frameData.length === 0 && project.videoPath) {
       const { FRAMES_DIR } = await import("./db-745LC5YC.js");
       const dirs = [
-        join5(FRAMES_DIR, projectId),
-        join5(project.videoPath, "screenshots"),
-        join5(PROJECTS_DIR, "maestro-recordings", projectId, "screenshots"),
-        join5(PROJECTS_DIR, "web-recordings", projectId, "screenshots")
+        join6(FRAMES_DIR, projectId),
+        join6(project.videoPath, "screenshots"),
+        join6(PROJECTS_DIR, "maestro-recordings", projectId, "screenshots"),
+        join6(PROJECTS_DIR, "web-recordings", projectId, "screenshots")
       ];
       for (const dir of dirs) {
-        if (existsSync5(dir) && statSync2(dir).isDirectory()) {
-          const files = readdirSync2(dir).filter((f) => /\.(png|jpg|jpeg|webp)$/i.test(f)).sort().slice(0, 20);
+        if (existsSync5(dir) && statSync3(dir).isDirectory()) {
+          const files = readdirSync4(dir).filter((f) => /\.(png|jpg|jpeg|webp)$/i.test(f)).sort().slice(0, 20);
           if (files.length > 0) {
-            frameData = files.map((f, i) => ({ imagePath: join5(dir, f), ocrText: null }));
+            frameData = files.map((f, i) => ({ imagePath: join6(dir, f), ocrText: null }));
             break;
           }
         }
@@ -14576,7 +14575,7 @@ app.post("/api/export/notion-page", async (c) => {
     if (!doc || !parentPageId) {
       return c.json({ error: "document and parentPageId required" }, 400);
     }
-    const notionSettingsPath = join5(DATA_DIR, "notion-settings.json");
+    const notionSettingsPath = join6(DATA_DIR, "notion-settings.json");
     let apiToken = "";
     if (existsSync5(notionSettingsPath)) {
       const settings = JSON.parse(readFileSync2(notionSettingsPath, "utf-8"));
@@ -14616,7 +14615,7 @@ app.post("/api/export/batch", async (c) => {
         return p || null;
       },
       getFramesDir(projectId) {
-        return join5(FRAMES_DIR, projectId);
+        return join6(FRAMES_DIR, projectId);
       }
     };
     const result = await executeBatchExport(manifest, dataProvider, (progress) => {
@@ -14653,13 +14652,13 @@ app.get("/assets/*", async (c) => {
     const assetPath = c.req.path.replace("/assets/", "");
     const cwd = process.cwd();
     const possiblePaths = [
-      join5(__dirname, "..", "assets", assetPath),
+      join6(__dirname, "..", "assets", assetPath),
       // Production: dist/../assets
-      join5(__dirname, "..", "..", "assets", assetPath),
+      join6(__dirname, "..", "..", "assets", assetPath),
       // Alternative structure
-      join5(cwd, "assets", assetPath),
+      join6(cwd, "assets", assetPath),
       // Development: running from project root
-      join5(cwd, "src", "assets", assetPath)
+      join6(cwd, "src", "assets", assetPath)
       // Development: src/assets
     ];
     for (const path of possiblePaths) {
@@ -14701,9 +14700,9 @@ app.get("/api/file", async (c) => {
     if (!existsSync5(resolvedPath)) {
       return c.json({ error: "File not found" }, 404);
     }
-    const { readFileSync: readFileSync3, statSync: statSync3 } = await import("fs");
+    const { readFileSync: readFileSync3, statSync: statSync4 } = await import("fs");
     const { basename: basename4, extname: extname3 } = await import("path");
-    const stat = statSync3(resolvedPath);
+    const stat = statSync4(resolvedPath);
     if (stat.isDirectory()) {
       return c.json({ error: "Path resolves to a directory" }, 400);
     }
@@ -14746,10 +14745,10 @@ app.get("/api/files", async (c) => {
     if (!existsSync5(decodedPath)) {
       return c.json({ error: "Directory not found" }, 404);
     }
-    const { readdirSync: readdirSync3, statSync: statSync3 } = await import("fs");
-    const files = readdirSync3(decodedPath).filter((name) => {
+    const { readdirSync: readdirSync5, statSync: statSync4 } = await import("fs");
+    const files = readdirSync5(decodedPath).filter((name) => {
       try {
-        return statSync3(join5(decodedPath, name)).isFile();
+        return statSync4(join6(decodedPath, name)).isFile();
       } catch {
         return false;
       }
@@ -14865,7 +14864,7 @@ app.get("/api/integrations/jira-mcp/status", async (c) => {
     const { execSync: execSync3 } = await import("child_process");
     const { existsSync: existsSync6, readFileSync: readFileSync3 } = await import("fs");
     const { homedir: homedir4 } = await import("os");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     const claudeCliAvailable = isClaudeCliAvailable();
     let configured = false;
     let available = false;
@@ -14914,8 +14913,8 @@ app.get("/api/integrations/jira-mcp/status", async (c) => {
     }
     if (!configured) {
       const settingsPaths = [
-        join6(homedir4(), ".claude", "settings.json"),
-        join6(homedir4(), ".claude", "settings.local.json")
+        join7(homedir4(), ".claude", "settings.json"),
+        join7(homedir4(), ".claude", "settings.local.json")
       ];
       for (const filePath of settingsPaths) {
         if (!existsSync6(filePath)) continue;
@@ -15472,12 +15471,12 @@ app.post("/api/testing/mobile/device/tap", async (c) => {
         await lock.acquired;
         try {
           const { mkdir, writeFile, rm } = await import("fs/promises");
-          const { join: join6 } = await import("path");
-          const tempBase = join6(tmpdir2(), "discoverylab-maestro-live");
-          const flowPath = join6(tempBase, `tap-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.yaml`);
-          const outputDir = join6(tempBase, `out-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+          const { join: join7 } = await import("path");
+          const tempBase = join7(tmpdir2(), "discoverylab-maestro-live");
+          const flowPath = join7(tempBase, `tap-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.yaml`);
+          const outputDir = join7(tempBase, `out-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
           await mkdir(tempBase, { recursive: true });
-          const maestroLogDir = join6(homedir3(), "Library", "Logs", "maestro");
+          const maestroLogDir = join7(homedir3(), "Library", "Logs", "maestro");
           await mkdir(maestroLogDir, { recursive: true });
           const flowLines = [];
           let resolvedAppId = appId || session?.appId;
@@ -15581,8 +15580,8 @@ app.post("/api/testing/mobile/record/stop", async (c) => {
     }
     const session = await recorder.stopRecording();
     const projectId = session.id;
-    const { dirname: dirname3, join: join6 } = await import("path");
-    const { readdirSync: readdirSync3, writeFileSync: writeFileSync5, existsSync: existsSync6, readFileSync: readFileSync3 } = await import("fs");
+    const { dirname: dirname3, join: join7 } = await import("path");
+    const { readdirSync: readdirSync5, writeFileSync: writeFileSync5, existsSync: existsSync6, readFileSync: readFileSync3 } = await import("fs");
     const outputDir = dirname3(session.flowPath || session.screenshotsDir);
     if (!session.appId && session.deviceId && session.platform) {
       session.appId = getForegroundAppIdForPlatform(session.platform, session.deviceId) || void 0;
@@ -15591,10 +15590,10 @@ app.post("/api/testing/mobile/record/stop", async (c) => {
     let screenshotCount = 0;
     let screenshotFiles = [];
     try {
-      screenshotFiles = readdirSync3(session.screenshotsDir).filter((f) => f.endsWith(".png")).sort();
+      screenshotFiles = readdirSync5(session.screenshotsDir).filter((f) => f.endsWith(".png")).sort();
       screenshotCount = screenshotFiles.length;
       if (screenshotFiles.length > 0) {
-        thumbnailPath = join6(session.screenshotsDir, screenshotFiles[0]);
+        thumbnailPath = join7(session.screenshotsDir, screenshotFiles[0]);
       }
     } catch {
     }
@@ -15614,7 +15613,7 @@ app.post("/api/testing/mobile/record/stop", async (c) => {
     const actionsCount = actions.length;
     const deviceShort = session.deviceName?.split(" ")[0] || session.platform?.toUpperCase() || "Mobile";
     const projectName = actionsCount > 0 ? `${deviceShort} Test - ${actionsCount} actions - ${dateStr}` : `${deviceShort} Recording - ${dateStr}`;
-    const flowPath = join6(outputDir, "test.yaml");
+    const flowPath = join7(outputDir, "test.yaml");
     let flowContent = "";
     if (existsSync6(flowPath)) {
       try {
@@ -15804,9 +15803,9 @@ app.post("/api/projects/:id/retry-analysis", async (c) => {
     const candidateScreenshotDirs = [];
     if (projectPath && existsSync5(projectPath)) {
       try {
-        const projectStats = statSync2(projectPath);
+        const projectStats = statSync3(projectPath);
         if (projectStats.isDirectory()) {
-          candidateScreenshotDirs.push(join5(projectPath, "screenshots"));
+          candidateScreenshotDirs.push(join6(projectPath, "screenshots"));
           candidateScreenshotDirs.push(projectPath);
         }
       } catch (err) {
@@ -15818,7 +15817,7 @@ app.post("/api/projects/:id/retry-analysis", async (c) => {
     for (const candidateDir of candidateScreenshotDirs) {
       if (!existsSync5(candidateDir)) continue;
       try {
-        const pngs = readdirSync2(candidateDir).filter((file) => file.toLowerCase().endsWith(".png")).sort();
+        const pngs = readdirSync4(candidateDir).filter((file) => file.toLowerCase().endsWith(".png")).sort();
         if (pngs.length > 0) {
           screenshotsDir = candidateDir;
           screenshotFiles = pngs;
@@ -15850,7 +15849,7 @@ app.post("/api/projects/:id/retry-analysis", async (c) => {
     }
     if (projectPath && existsSync5(projectPath)) {
       try {
-        const projectStats = statSync2(projectPath);
+        const projectStats = statSync3(projectPath);
         if (projectStats.isDirectory()) {
           console.log(`[RetryAnalysis] Restarting directory analysis for ${projectId}`);
           runProjectAnalysisInBackgroundWithWatchdog(projectId, "RetryAnalysis(directory)");
@@ -15880,14 +15879,14 @@ app.post("/api/projects/:id/retry-analysis", async (c) => {
 app.post("/api/testing/mobile/recordings/:id/analyze", async (c) => {
   try {
     const recordingId = c.req.param("id");
-    const { readdirSync: readdirSync3, writeFileSync: writeFileSync5, existsSync: fsExistsSync } = await import("fs");
-    const { join: join6 } = await import("path");
-    const recordingDir = join6(PROJECTS_DIR, "maestro-recordings", recordingId);
-    const screenshotsDir = join6(recordingDir, "screenshots");
+    const { readdirSync: readdirSync5, writeFileSync: writeFileSync5, existsSync: fsExistsSync } = await import("fs");
+    const { join: join7 } = await import("path");
+    const recordingDir = join7(PROJECTS_DIR, "maestro-recordings", recordingId);
+    const screenshotsDir = join7(recordingDir, "screenshots");
     if (!fsExistsSync(screenshotsDir)) {
       return c.json({ error: "Screenshots directory not found" }, 404);
     }
-    const screenshotFiles = readdirSync3(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
+    const screenshotFiles = readdirSync5(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
     if (screenshotFiles.length < 2) {
       return c.json({ error: "Not enough screenshots for analysis (need at least 2)" }, 400);
     }
@@ -15912,7 +15911,7 @@ app.post("/api/testing/mobile/recordings/:id/analyze", async (c) => {
       analysisResult.appName,
       analysisResult.actionDetectionProvider
     );
-    const flowPath = join6(recordingDir, "test.yaml");
+    const flowPath = join7(recordingDir, "test.yaml");
     writeFileSync5(flowPath, maestroYaml, "utf-8");
     console.log(`[MobileRecording] AI detected ${analysisResult.actions.length} actions, YAML saved to ${flowPath}`);
     return c.json({
@@ -15943,16 +15942,16 @@ app.post("/api/testing/playwright/codegen", async (c) => {
 });
 app.get("/api/testing/mobile/recordings", async (c) => {
   try {
-    const { readdirSync: readdirSync3, readFileSync: readFileSync3, statSync: statSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
-    const recordingsDir = join6(PROJECTS_DIR, "maestro-recordings");
+    const { readdirSync: readdirSync5, readFileSync: readFileSync3, statSync: statSync4 } = await import("fs");
+    const { join: join7 } = await import("path");
+    const recordingsDir = join7(PROJECTS_DIR, "maestro-recordings");
     if (!existsSync5(recordingsDir)) {
       return c.json({ recordings: [] });
     }
     const recordings = [];
-    const dirs = readdirSync3(recordingsDir);
+    const dirs = readdirSync5(recordingsDir);
     for (const dir of dirs) {
-      const sessionPath = join6(recordingsDir, dir, "session.json");
+      const sessionPath = join7(recordingsDir, dir, "session.json");
       if (existsSync5(sessionPath)) {
         try {
           const session = JSON.parse(readFileSync3(sessionPath, "utf-8"));
@@ -15984,9 +15983,9 @@ app.get("/api/testing/mobile/recordings/:id", async (c) => {
   try {
     const { id } = c.req.param();
     const { readFileSync: readFileSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
-    const sessionPath = join6(PROJECTS_DIR, "maestro-recordings", id, "session.json");
-    const flowPath = join6(PROJECTS_DIR, "maestro-recordings", id, "test.yaml");
+    const { join: join7 } = await import("path");
+    const sessionPath = join7(PROJECTS_DIR, "maestro-recordings", id, "session.json");
+    const flowPath = join7(PROJECTS_DIR, "maestro-recordings", id, "test.yaml");
     if (!existsSync5(sessionPath)) {
       return c.json({ error: "Recording not found" }, 404);
     }
@@ -16663,8 +16662,8 @@ app.put("/api/testing/mobile/recordings/:id/flow", async (c) => {
     const body = await c.req.json();
     const { flowCode } = body;
     const { writeFileSync: writeFileSync5 } = await import("fs");
-    const { join: join6 } = await import("path");
-    const flowPath = join6(PROJECTS_DIR, "maestro-recordings", id, "test.yaml");
+    const { join: join7 } = await import("path");
+    const flowPath = join7(PROJECTS_DIR, "maestro-recordings", id, "test.yaml");
     writeFileSync5(flowPath, flowCode, "utf-8");
     return c.json({ success: true });
   } catch (error) {
@@ -16676,8 +16675,8 @@ app.delete("/api/testing/mobile/recordings/:id", async (c) => {
   try {
     const { id } = c.req.param();
     const { rmSync: rmSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
-    const recordingDir = join6(PROJECTS_DIR, "maestro-recordings", id);
+    const { join: join7 } = await import("path");
+    const recordingDir = join7(PROJECTS_DIR, "maestro-recordings", id);
     if (!existsSync5(recordingDir)) {
       return c.json({ error: "Recording not found" }, 404);
     }
@@ -16752,8 +16751,8 @@ app.post("/api/testing/mobile/recordings/:id/replay", async (c) => {
     const requestedDevicePlatform = body?.devicePlatform === "ios" || body?.devicePlatform === "android" ? body.devicePlatform : void 0;
     const skipDeviceValidation = body?.skipDeviceValidation === true;
     const { readFileSync: readFileSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
-    const flowPath = join6(PROJECTS_DIR, "maestro-recordings", id, "test.yaml");
+    const { join: join7 } = await import("path");
+    const flowPath = join7(PROJECTS_DIR, "maestro-recordings", id, "test.yaml");
     if (!existsSync5(flowPath)) {
       return c.json({ error: "Flow file not found" }, 404);
     }
@@ -16891,7 +16890,7 @@ var autoCaptureScreenshotCount = 0;
 app.post("/api/testing/mobile/auto-capture/start", async (c) => {
   try {
     const { recordingId, platform } = await c.req.json();
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     const { mkdirSync: mkdirSync5, existsSync: fsExistsSync, writeFileSync: writeFileSync5 } = await import("fs");
     if (!recordingId) {
       return c.json({ error: "recordingId required" }, 400);
@@ -16902,7 +16901,7 @@ app.post("/api/testing/mobile/auto-capture/start", async (c) => {
     }
     autoCaptureRecordingId = recordingId;
     autoCaptureScreenshotCount = 0;
-    const screenshotsDir = join6(PROJECTS_DIR, "maestro-recordings", recordingId, "screenshots");
+    const screenshotsDir = join7(PROJECTS_DIR, "maestro-recordings", recordingId, "screenshots");
     if (!fsExistsSync(screenshotsDir)) {
       mkdirSync5(screenshotsDir, { recursive: true });
     }
@@ -16910,7 +16909,7 @@ app.post("/api/testing/mobile/auto-capture/start", async (c) => {
     const execCaptureAsync = promisify(exec);
     autoCaptureInterval = setInterval(async () => {
       try {
-        const screenshotPath = join6(screenshotsDir, `auto_${Date.now()}_${autoCaptureScreenshotCount}.png`);
+        const screenshotPath = join7(screenshotsDir, `auto_${Date.now()}_${autoCaptureScreenshotCount}.png`);
         autoCaptureScreenshotCount++;
         if (platform === "ios") {
           await execCaptureAsync(`xcrun simctl io booted screenshot "${screenshotPath}"`, { timeout: 5e3 });
@@ -16944,8 +16943,8 @@ app.post("/api/testing/mobile/auto-capture/start", async (c) => {
 app.post("/api/testing/mobile/auto-capture/stop", async (c) => {
   try {
     const { recordingId } = await c.req.json();
-    const { join: join6 } = await import("path");
-    const { readdirSync: readdirSync3, existsSync: fsExistsSync } = await import("fs");
+    const { join: join7 } = await import("path");
+    const { readdirSync: readdirSync5, existsSync: fsExistsSync } = await import("fs");
     if (autoCaptureInterval) {
       clearInterval(autoCaptureInterval);
       autoCaptureInterval = null;
@@ -16956,9 +16955,9 @@ app.post("/api/testing/mobile/auto-capture/stop", async (c) => {
     autoCaptureScreenshotCount = 0;
     let savedScreenshots = 0;
     if (stoppedId) {
-      const screenshotsDir = join6(PROJECTS_DIR, "maestro-recordings", stoppedId, "screenshots");
+      const screenshotsDir = join7(PROJECTS_DIR, "maestro-recordings", stoppedId, "screenshots");
       if (fsExistsSync(screenshotsDir)) {
-        savedScreenshots = readdirSync3(screenshotsDir).filter((f) => f.endsWith(".png")).length;
+        savedScreenshots = readdirSync5(screenshotsDir).filter((f) => f.endsWith(".png")).length;
       }
     }
     console.log(`[AutoCapture] Stopped for ${stoppedId || recordingId}, ${savedScreenshots} screenshots saved`);
@@ -17001,11 +17000,11 @@ function shellQuote(value) {
 async function runClaudeCliWithArgs(prompt, args, timeoutMs) {
   const { mkdtemp, writeFile, readFile, rm } = await import("fs/promises");
   const { tmpdir: tmpdir3 } = await import("os");
-  const { join: join6 } = await import("path");
-  const tempDir = await mkdtemp(join6(tmpdir3(), "claude-cli-"));
-  const promptPath = join6(tempDir, "prompt.txt");
-  const stdoutPath = join6(tempDir, "stdout.txt");
-  const stderrPath = join6(tempDir, "stderr.txt");
+  const { join: join7 } = await import("path");
+  const tempDir = await mkdtemp(join7(tmpdir3(), "claude-cli-"));
+  const promptPath = join7(tempDir, "prompt.txt");
+  const stdoutPath = join7(tempDir, "stdout.txt");
+  const stderrPath = join7(tempDir, "stderr.txt");
   await writeFile(promptPath, prompt, "utf8");
   const quotedArgs = args.map((arg) => shellQuote(arg)).join(" ");
   const shellScript = [
@@ -17557,9 +17556,9 @@ async function runOCRInBackground(projectId, screenshotsDir, screenshotFiles) {
   };
   try {
     const { recognizeTextBatch } = await import("./ocr-FXRLEP66.js");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     broadcastProgress("ocr", "running", `Processing 0/${screenshotFiles.length} screenshots...`, void 0, 0, screenshotFiles.length);
-    const fullPaths = screenshotFiles.map((f) => join6(screenshotsDir, f));
+    const fullPaths = screenshotFiles.map((f) => join7(screenshotsDir, f));
     const ocrResult = await recognizeTextBatch(
       fullPaths,
       { recognitionLevel: "accurate" },
@@ -17642,8 +17641,8 @@ async function runOCRInBackground(projectId, screenshotsDir, screenshotFiles) {
             analysisResult.actionDetectionProvider
           );
           const { writeFileSync: writeFileSync5 } = await import("fs");
-          const recordingDir2 = join6(screenshotsDir, "..");
-          const flowPath = join6(recordingDir2, "test.yaml");
+          const recordingDir2 = join7(screenshotsDir, "..");
+          const flowPath = join7(recordingDir2, "test.yaml");
           writeFileSync5(flowPath, maestroYaml, "utf-8");
           detectedActionsCount = analysisResult.actions.length;
           console.log(`[BackgroundOCR] AI detected ${detectedActionsCount} actions, YAML saved to ${flowPath}`);
@@ -17664,10 +17663,10 @@ async function runOCRInBackground(projectId, screenshotsDir, screenshotFiles) {
     } else {
       broadcastProgress("actions", "skipped", "Not enough screenshots for action detection");
     }
-    const recordingDir = join6(screenshotsDir, "..");
+    const recordingDir = join7(screenshotsDir, "..");
     let iconCoverPath = null;
     try {
-      const sessionPath = join6(recordingDir, "session.json");
+      const sessionPath = join7(recordingDir, "session.json");
       if (existsSync5(sessionPath)) {
         const sessionData = JSON.parse(readFileSync2(sessionPath, "utf8"));
         if ((sessionData?.platform === "ios" || sessionData?.platform === "android") && typeof sessionData?.deviceId === "string") {
@@ -18363,8 +18362,8 @@ User: ${truncateForPrompt(message, 800)}`;
       executionStarted = true;
       const flowYaml = generateChatMaestroYaml(commands, appIdForFlow);
       const { writeFile, rm } = await import("fs/promises");
-      const { join: join6 } = await import("path");
-      const flowPath = join6(
+      const { join: join7 } = await import("path");
+      const flowPath = join7(
         PROJECTS_DIR,
         `temp-chat-flow-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.yaml`
       );
@@ -18514,7 +18513,7 @@ function sanitizeAppLabNetworkProxySettings(value) {
   };
 }
 function getAppLabNetworkProxySettingsPath() {
-  return join5(DATA_DIR, "network-proxy-settings.json");
+  return join6(DATA_DIR, "network-proxy-settings.json");
 }
 function resolveAppLabNetworkProxyTimeoutMs() {
   const raw = typeof process.env.DISCOVERYLAB_NETWORK_PROXY_MAX_DURATION_MS === "string" ? process.env.DISCOVERYLAB_NETWORK_PROXY_MAX_DURATION_MS.trim() : "";
@@ -18589,8 +18588,8 @@ var llmSettings = {};
 (async () => {
   try {
     const { readFileSync: readFileSync3, existsSync: existsSync6 } = await import("fs");
-    const { join: join6 } = await import("path");
-    const settingsPath = join6(DATA_DIR, "llm-settings.json");
+    const { join: join7 } = await import("path");
+    const settingsPath = join7(DATA_DIR, "llm-settings.json");
     if (existsSync6(settingsPath)) {
       llmSettings = JSON.parse(readFileSync3(settingsPath, "utf8"));
       if (llmSettings.anthropicApiKey) process.env.ANTHROPIC_API_KEY = llmSettings.anthropicApiKey;
@@ -18618,7 +18617,7 @@ app.get("/api/settings/llm", async (c) => {
 app.put("/api/settings/llm", async (c) => {
   try {
     const { writeFileSync: writeFileSync5 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     const body = await c.req.json();
     if (body.anthropicApiKey && !body.anthropicApiKey.startsWith("\u2022\u2022")) {
       llmSettings.anthropicApiKey = body.anthropicApiKey;
@@ -18652,7 +18651,7 @@ app.put("/api/settings/llm", async (c) => {
     if (body.preferredProvider !== void 0) {
       llmSettings.preferredProvider = body.preferredProvider;
     }
-    const settingsPath = join6(DATA_DIR, "llm-settings.json");
+    const settingsPath = join7(DATA_DIR, "llm-settings.json");
     writeFileSync5(settingsPath, JSON.stringify(llmSettings, null, 2));
     return c.json({ success: true, message: "LLM settings saved" });
   } catch (error) {
@@ -18664,8 +18663,8 @@ var jiraSettings = {};
 (async () => {
   try {
     const { readFileSync: readFileSync3, existsSync: existsSync6 } = await import("fs");
-    const { join: join6 } = await import("path");
-    const settingsPath = join6(DATA_DIR, "jira-settings.json");
+    const { join: join7 } = await import("path");
+    const settingsPath = join7(DATA_DIR, "jira-settings.json");
     if (existsSync6(settingsPath)) {
       jiraSettings = JSON.parse(readFileSync3(settingsPath, "utf8"));
       if (jiraSettings.baseUrl) process.env.JIRA_BASE_URL = jiraSettings.baseUrl;
@@ -18688,7 +18687,7 @@ app.get("/api/settings/jira", async (c) => {
 app.put("/api/settings/jira", async (c) => {
   try {
     const { writeFileSync: writeFileSync5 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     const body = await c.req.json();
     if (body.baseUrl !== void 0) {
       jiraSettings.baseUrl = body.baseUrl;
@@ -18702,7 +18701,7 @@ app.put("/api/settings/jira", async (c) => {
       jiraSettings.apiToken = body.apiToken;
       process.env.JIRA_API_TOKEN = body.apiToken;
     }
-    const settingsPath = join6(DATA_DIR, "jira-settings.json");
+    const settingsPath = join7(DATA_DIR, "jira-settings.json");
     writeFileSync5(settingsPath, JSON.stringify(jiraSettings, null, 2));
     return c.json({ success: true, message: "Jira settings saved" });
   } catch (error) {
@@ -18713,7 +18712,7 @@ app.put("/api/settings/jira", async (c) => {
 var notionSettings = {};
 (async () => {
   try {
-    const settingsPath = join5(DATA_DIR, "notion-settings.json");
+    const settingsPath = join6(DATA_DIR, "notion-settings.json");
     if (existsSync5(settingsPath)) {
       notionSettings = JSON.parse(readFileSync2(settingsPath, "utf8"));
       console.log("[Notion Settings] Loaded from file");
@@ -18740,7 +18739,7 @@ app.put("/api/settings/notion", async (c) => {
       notionSettings.lastParentPageId = body.lastParentPageId;
       notionSettings.lastParentPageTitle = body.lastParentPageTitle || "";
     }
-    const settingsPath = join5(DATA_DIR, "notion-settings.json");
+    const settingsPath = join6(DATA_DIR, "notion-settings.json");
     writeFileSync4(settingsPath, JSON.stringify(notionSettings, null, 2));
     return c.json({ success: true });
   } catch (error) {
@@ -19038,13 +19037,13 @@ app.post("/api/recorder/stop", async (c) => {
     let projectId = null;
     let ocrInProgress = false;
     try {
-      const { readFileSync: readFileSync3, existsSync: existsSync6, readdirSync: readdirSync3, copyFileSync: copyFileSync2, mkdirSync: mkdirSync5 } = await import("fs");
-      const { join: join6 } = await import("path");
+      const { readFileSync: readFileSync3, existsSync: existsSync6, readdirSync: readdirSync5, copyFileSync: copyFileSync2, mkdirSync: mkdirSync5 } = await import("fs");
+      const { join: join7 } = await import("path");
       const { homedir: homedir4 } = await import("os");
       const recordingId = session?.id;
       if (recordingId) {
-        const recordingDir = join6(homedir4(), ".discoverylab", "recordings", recordingId);
-        const sessionPath = join6(recordingDir, "session.json");
+        const recordingDir = join7(homedir4(), ".discoverylab", "recordings", recordingId);
+        const sessionPath = join7(recordingDir, "session.json");
         if (existsSync6(sessionPath)) {
           const sessionData = JSON.parse(readFileSync3(sessionPath, "utf8"));
           const sessionName = sessionData?.name || sessionData?.session?.name || `Recording ${recordingId}`;
@@ -19060,19 +19059,19 @@ app.post("/api/recorder/stop", async (c) => {
             INSERT INTO projects (id, name, video_path, platform, status, created_at, updated_at)
             VALUES (?, ?, ?, ?, ?, ?, ?)
           `).run(projectId, sessionName, recordingDir, "web", "ready", now, now);
-          const framesDir = join6(DATA_DIR, "projects", projectId, "frames");
+          const framesDir = join7(DATA_DIR, "projects", projectId, "frames");
           mkdirSync5(framesDir, { recursive: true });
-          const screenshotsDir = join6(recordingDir, "screenshots");
+          const screenshotsDir = join7(recordingDir, "screenshots");
           let thumbnailPath = null;
           let frameCount = 0;
           const screenshotFiles = [];
           if (existsSync6(screenshotsDir)) {
-            const screenshots = readdirSync3(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
+            const screenshots = readdirSync5(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
             frameCount = screenshots.length;
             screenshotFiles.push(...screenshots);
             screenshots.forEach((file, index) => {
-              const src = join6(screenshotsDir, file);
-              const dest = join6(framesDir, `frame_${(index + 1).toString().padStart(4, "0")}.png`);
+              const src = join7(screenshotsDir, file);
+              const dest = join7(framesDir, `frame_${(index + 1).toString().padStart(4, "0")}.png`);
               copyFileSync2(src, dest);
               if (index === 0) {
                 thumbnailPath = dest;
@@ -19164,15 +19163,15 @@ app.post("/api/recorder/screenshot", async (c) => {
 });
 app.get("/api/recorder/recordings", async (c) => {
   try {
-    const { readdirSync: readdirSync3, readFileSync: readFileSync3, existsSync: existsSync6 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { readdirSync: readdirSync5, readFileSync: readFileSync3, existsSync: existsSync6 } = await import("fs");
+    const { join: join7 } = await import("path");
     const { homedir: homedir4 } = await import("os");
-    const recordingsDir = join6(homedir4(), ".discoverylab", "recordings");
+    const recordingsDir = join7(homedir4(), ".discoverylab", "recordings");
     if (!existsSync6(recordingsDir)) {
       return c.json({ recordings: [] });
     }
-    const recordings = readdirSync3(recordingsDir).filter((dir) => dir.startsWith("rec_")).map((dir) => {
-      const sessionPath = join6(recordingsDir, dir, "session.json");
+    const recordings = readdirSync5(recordingsDir).filter((dir) => dir.startsWith("rec_")).map((dir) => {
+      const sessionPath = join7(recordingsDir, dir, "session.json");
       if (existsSync6(sessionPath)) {
         try {
           const session = JSON.parse(readFileSync3(sessionPath, "utf8"));
@@ -19192,18 +19191,18 @@ app.get("/api/recorder/recordings", async (c) => {
 app.get("/api/recorder/recordings/:id", async (c) => {
   try {
     const { id } = c.req.param();
-    const { readFileSync: readFileSync3, existsSync: existsSync6, readdirSync: readdirSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { readFileSync: readFileSync3, existsSync: existsSync6, readdirSync: readdirSync5 } = await import("fs");
+    const { join: join7 } = await import("path");
     const { homedir: homedir4 } = await import("os");
-    const recordingDir = join6(homedir4(), ".discoverylab", "recordings", id);
-    const sessionPath = join6(recordingDir, "session.json");
+    const recordingDir = join7(homedir4(), ".discoverylab", "recordings", id);
+    const sessionPath = join7(recordingDir, "session.json");
     if (!existsSync6(sessionPath)) {
       return c.json({ error: "Recording not found" }, 404);
     }
     const session = JSON.parse(readFileSync3(sessionPath, "utf8"));
-    const screenshotsDir = join6(recordingDir, "screenshots");
-    const screenshots = existsSync6(screenshotsDir) ? readdirSync3(screenshotsDir).filter((f) => f.endsWith(".png")) : [];
-    const specPath = join6(recordingDir, "test.spec.ts");
+    const screenshotsDir = join7(recordingDir, "screenshots");
+    const screenshots = existsSync6(screenshotsDir) ? readdirSync5(screenshotsDir).filter((f) => f.endsWith(".png")) : [];
+    const specPath = join7(recordingDir, "test.spec.ts");
     const specContent = existsSync6(specPath) ? readFileSync3(specPath, "utf8") : null;
     return c.json({
       session,
@@ -19221,13 +19220,13 @@ app.put("/api/recorder/recordings/:id/spec", async (c) => {
     const body = await c.req.json();
     const specCode = typeof body?.specCode === "string" ? body.specCode : "";
     const { writeFileSync: writeFileSync5, existsSync: fsExistsSync, mkdirSync: mkdirSync5 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     const { homedir: homedir4 } = await import("os");
-    const recordingDir = join6(homedir4(), ".discoverylab", "recordings", id);
+    const recordingDir = join7(homedir4(), ".discoverylab", "recordings", id);
     if (!fsExistsSync(recordingDir)) {
       return c.json({ error: "Recording not found" }, 404);
     }
-    const specPath = join6(recordingDir, "test.spec.ts");
+    const specPath = join7(recordingDir, "test.spec.ts");
     mkdirSync5(recordingDir, { recursive: true });
     writeFileSync5(specPath, specCode, "utf8");
     const placeholders = parseScriptPlaceholders(specCode);
@@ -19245,10 +19244,10 @@ app.post("/api/recorder/recordings/:id/run", async (c) => {
     const timeout = Number.isFinite(Number(body?.timeout)) ? Number(body.timeout) : void 0;
     const browser = body?.browser === "firefox" || body?.browser === "webkit" || body?.browser === "chromium" ? body.browser : void 0;
     const { readFileSync: readFileSync3, existsSync: fsExistsSync, mkdirSync: mkdirSync5, writeFileSync: writeFileSync5 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     const { homedir: homedir4 } = await import("os");
-    const recordingDir = join6(homedir4(), ".discoverylab", "recordings", id);
-    const specPath = join6(recordingDir, "test.spec.ts");
+    const recordingDir = join7(homedir4(), ".discoverylab", "recordings", id);
+    const specPath = join7(recordingDir, "test.spec.ts");
     if (!fsExistsSync(recordingDir) || !fsExistsSync(specPath)) {
       return c.json({ error: "Recording spec not found" }, 404);
     }
@@ -19269,11 +19268,11 @@ app.post("/api/recorder/recordings/:id/run", async (c) => {
         envTest: resolved.envTestText
       }, 400);
     }
-    const runtimeDir = join6(recordingDir, ".runtime");
+    const runtimeDir = join7(recordingDir, ".runtime");
     mkdirSync5(runtimeDir, { recursive: true });
     const runStamp = Date.now();
-    const runtimeSpecPath = join6(runtimeDir, `test.runtime.${runStamp}.spec.ts`);
-    const runtimeEnvPath = join6(runtimeDir, `.env.test.${runStamp}`);
+    const runtimeSpecPath = join7(runtimeDir, `test.runtime.${runStamp}.spec.ts`);
+    const runtimeEnvPath = join7(runtimeDir, `.env.test.${runStamp}`);
     writeFileSync5(runtimeSpecPath, applied.code, "utf8");
     writeFileSync5(runtimeEnvPath, resolved.envTestText || "", "utf8");
     const result = await runPlaywrightTest({
@@ -19289,7 +19288,7 @@ app.post("/api/recorder/recordings/:id/run", async (c) => {
         screenshot: body?.screenshot === "on" || body?.screenshot === "only-on-failure" ? body.screenshot : "only-on-failure",
         trace: body?.trace === "on" || body?.trace === "retain-on-failure" ? body.trace : "retain-on-failure"
       },
-      outputDir: join6(recordingDir, "playwright-runs", String(runStamp)),
+      outputDir: join7(recordingDir, "playwright-runs", String(runStamp)),
       reporter: "json"
     });
     return c.json({
@@ -19310,9 +19309,9 @@ app.delete("/api/recorder/recordings/:id", async (c) => {
   try {
     const { id } = c.req.param();
     const { rmSync: rmSync3, existsSync: fsExistsSync } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     const { homedir: homedir4 } = await import("os");
-    const recordingDir = join6(homedir4(), ".discoverylab", "recordings", id);
+    const recordingDir = join7(homedir4(), ".discoverylab", "recordings", id);
     if (!fsExistsSync(recordingDir)) {
       return c.json({ error: "Recording not found" }, 404);
     }
@@ -19322,7 +19321,7 @@ app.delete("/api/recorder/recordings/:id", async (c) => {
     await db.delete(projects).where(eq(projects.id, id));
     await deleteTestVariablesForOwner("web-recording", id);
     await deleteTestVariablesForOwner("project", id);
-    const projectDir = join6(PROJECTS_DIR, id);
+    const projectDir = join7(PROJECTS_DIR, id);
     if (fsExistsSync(projectDir)) {
       rmSync3(projectDir, { recursive: true, force: true });
     }
@@ -19335,23 +19334,23 @@ app.delete("/api/recorder/recordings/:id", async (c) => {
 });
 app.delete("/api/recorder/recordings", async (c) => {
   try {
-    const { rmSync: rmSync3, existsSync: fsExistsSync, readdirSync: readdirSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { rmSync: rmSync3, existsSync: fsExistsSync, readdirSync: readdirSync5 } = await import("fs");
+    const { join: join7 } = await import("path");
     const { homedir: homedir4 } = await import("os");
     const deletedIds = [];
-    const recordingsDir = join6(homedir4(), ".discoverylab", "recordings");
+    const recordingsDir = join7(homedir4(), ".discoverylab", "recordings");
     if (fsExistsSync(recordingsDir)) {
-      const dirs = readdirSync3(recordingsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = readdirSync5(recordingsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       for (const dir of dirs) {
-        rmSync3(join6(recordingsDir, dir), { recursive: true, force: true });
+        rmSync3(join7(recordingsDir, dir), { recursive: true, force: true });
         deletedIds.push(dir);
       }
     }
-    const mobileRecordingsDir = join6(PROJECTS_DIR, "maestro-recordings");
+    const mobileRecordingsDir = join7(PROJECTS_DIR, "maestro-recordings");
     if (fsExistsSync(mobileRecordingsDir)) {
-      const dirs = readdirSync3(mobileRecordingsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const dirs = readdirSync5(mobileRecordingsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       for (const dir of dirs) {
-        rmSync3(join6(mobileRecordingsDir, dir), { recursive: true, force: true });
+        rmSync3(join7(mobileRecordingsDir, dir), { recursive: true, force: true });
         deletedIds.push(dir);
       }
     }
@@ -19363,7 +19362,7 @@ app.delete("/api/recorder/recordings", async (c) => {
         await deleteTestVariablesForOwner("web-recording", id);
         await deleteTestVariablesForOwner("mobile-recording", id);
         await deleteTestVariablesForOwner("project", id);
-        const projectDir = join6(PROJECTS_DIR, id);
+        const projectDir = join7(PROJECTS_DIR, id);
         if (fsExistsSync(projectDir)) {
           rmSync3(projectDir, { recursive: true, force: true });
         }
@@ -19380,9 +19379,9 @@ app.get("/api/recorder/screenshots/:sessionId/:filename", async (c) => {
   try {
     const { sessionId, filename } = c.req.param();
     const { readFileSync: readFileSync3, existsSync: existsSync6 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { join: join7 } = await import("path");
     const { homedir: homedir4 } = await import("os");
-    const filePath = join6(homedir4(), ".discoverylab", "recordings", sessionId, "screenshots", filename);
+    const filePath = join7(homedir4(), ".discoverylab", "recordings", sessionId, "screenshots", filename);
     if (!existsSync6(filePath)) {
       return c.json({ error: "Screenshot not found" }, 404);
     }
@@ -19398,16 +19397,16 @@ app.get("/api/recorder/screenshots/:sessionId/:filename", async (c) => {
 app.get("/api/recorder/screenshot/:filename", async (c) => {
   try {
     const { filename } = c.req.param();
-    const { readFileSync: readFileSync3, existsSync: existsSync6, readdirSync: readdirSync3 } = await import("fs");
-    const { join: join6 } = await import("path");
+    const { readFileSync: readFileSync3, existsSync: existsSync6, readdirSync: readdirSync5 } = await import("fs");
+    const { join: join7 } = await import("path");
     const { homedir: homedir4 } = await import("os");
-    const recordingsDir = join6(homedir4(), ".discoverylab", "recordings");
+    const recordingsDir = join7(homedir4(), ".discoverylab", "recordings");
     if (!existsSync6(recordingsDir)) {
       return c.json({ error: "No recordings directory" }, 404);
     }
-    const sessions = readdirSync3(recordingsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const sessions = readdirSync5(recordingsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     for (const sessionId of sessions) {
-      const filePath = join6(recordingsDir, sessionId, "screenshots", filename);
+      const filePath = join7(recordingsDir, sessionId, "screenshots", filename);
       if (existsSync6(filePath)) {
         const buffer = readFileSync3(filePath);
         return new Response(buffer, {
@@ -19427,11 +19426,11 @@ app.get("/api/recorder/screenshot/:filename", async (c) => {
 app.post("/api/recorder/recordings/:id/create-project", async (c) => {
   try {
     const { id } = c.req.param();
-    const { readFileSync: readFileSync3, existsSync: existsSync6, readdirSync: readdirSync3, copyFileSync: copyFileSync2, mkdirSync: mkdirSync5 } = await import("fs");
-    const { join: join6, basename: basename4 } = await import("path");
+    const { readFileSync: readFileSync3, existsSync: existsSync6, readdirSync: readdirSync5, copyFileSync: copyFileSync2, mkdirSync: mkdirSync5 } = await import("fs");
+    const { join: join7, basename: basename4 } = await import("path");
     const { homedir: homedir4 } = await import("os");
-    const recordingDir = join6(homedir4(), ".discoverylab", "recordings", id);
-    const sessionPath = join6(recordingDir, "session.json");
+    const recordingDir = join7(homedir4(), ".discoverylab", "recordings", id);
+    const sessionPath = join7(recordingDir, "session.json");
     if (!existsSync6(sessionPath)) {
       return c.json({ error: "Recording not found" }, 404);
     }
@@ -19457,17 +19456,17 @@ app.post("/api/recorder/recordings/:id/create-project", async (c) => {
       now,
       now
     );
-    const framesDir = join6(DATA_DIR, "projects", projectId, "frames");
+    const framesDir = join7(DATA_DIR, "projects", projectId, "frames");
     mkdirSync5(framesDir, { recursive: true });
-    const screenshotsDir = join6(recordingDir, "screenshots");
+    const screenshotsDir = join7(recordingDir, "screenshots");
     let thumbnailPath = null;
     let frameCount = 0;
     if (existsSync6(screenshotsDir)) {
-      const screenshots = readdirSync3(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
+      const screenshots = readdirSync5(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
       frameCount = screenshots.length;
       screenshots.forEach((file, index) => {
-        const src = join6(screenshotsDir, file);
-        const dest = join6(framesDir, `frame_${(index + 1).toString().padStart(4, "0")}.png`);
+        const src = join7(screenshotsDir, file);
+        const dest = join7(framesDir, `frame_${(index + 1).toString().padStart(4, "0")}.png`);
         copyFileSync2(src, dest);
         if (index === 0) {
           thumbnailPath = dest;
@@ -19499,7 +19498,7 @@ app.post("/api/recorder/recordings/:id/create-project", async (c) => {
     }
     let ocrInProgress = false;
     if (frameCount > 0 && existsSync6(screenshotsDir)) {
-      const screenshotFiles = readdirSync3(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
+      const screenshotFiles = readdirSync5(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
       if (screenshotFiles.length > 0) {
         sqlite.prepare(`UPDATE projects SET status = ?, updated_at = ? WHERE id = ?`).run("analyzing", Date.now(), projectId);
         ocrInProgress = true;
@@ -19858,11 +19857,11 @@ app.put("/api/projects/:id/template-content", async (c) => {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const { writeFileSync: writeFileSync5, mkdirSync: mkdirSync5 } = await import("fs");
-    const projectDir = join5(PROJECTS_DIR, id);
+    const projectDir = join6(PROJECTS_DIR, id);
     if (!existsSync5(projectDir)) {
       mkdirSync5(projectDir, { recursive: true });
     }
-    const contentPath = join5(projectDir, "template-content.json");
+    const contentPath = join6(projectDir, "template-content.json");
     writeFileSync5(contentPath, JSON.stringify(savedContent));
     return c.json({ success: true, message: "Template content saved", content: savedContent });
   } catch (error) {
@@ -19940,7 +19939,7 @@ app.get("/api/templates/player/*", async (c) => {
     return c.json({ error: "Templates not installed" }, 404);
   }
   const requestedPath = c.req.path.replace("/api/templates/player/", "");
-  const filePath = join5(bundlePath, requestedPath || "index.html");
+  const filePath = join6(bundlePath, requestedPath || "index.html");
   if (!existsSync5(filePath)) {
     return c.json({ error: "File not found" }, 404);
   }
@@ -20044,7 +20043,6 @@ var TEMPLATE_MAX_DURATION_SECONDS = 60;
 var DEFAULT_ANDROID_DEVICE_MOCKUP = "mockup-android-galaxy.png";
 var ANDROID_DEVICE_MOCKUP_FALLBACKS = [
   DEFAULT_ANDROID_DEVICE_MOCKUP,
-  "mockup-android.png",
   "mockup-android-google-pixel-9-pro.png"
 ];
 function getTemplateProjectState(project) {
@@ -20076,7 +20074,7 @@ function resolveTemplateVideoPath(project) {
     return null;
   }
   try {
-    if (statSync2(resolvedVideoPath).isDirectory()) {
+    if (statSync3(resolvedVideoPath).isDirectory()) {
       return null;
     }
   } catch {
@@ -20194,11 +20192,11 @@ function listAndroidDeviceMockupIds() {
   if (!bundlePath) {
     return [...ANDROID_DEVICE_MOCKUP_FALLBACKS];
   }
-  const publicDir = join5(bundlePath, "public");
+  const publicDir = join6(bundlePath, "public");
   if (!existsSync5(publicDir)) {
     return [...ANDROID_DEVICE_MOCKUP_FALLBACKS];
   }
-  const files = readdirSync2(publicDir).filter((file) => /^mockup-android.*\.png$/i.test(file));
+  const files = readdirSync4(publicDir).filter((file) => /^mockup-android.*\.png$/i.test(file));
   const unique = new Set(files.length > 0 ? files : ANDROID_DEVICE_MOCKUP_FALLBACKS);
   return [...unique].sort((left, right) => {
     const leftIndex = ANDROID_DEVICE_MOCKUP_FALLBACKS.indexOf(left);
@@ -20358,7 +20356,7 @@ function groupNetworkIntoTabs(entries) {
   });
 }
 function loadEditedTemplateContent(projectId) {
-  const contentPath = join5(PROJECTS_DIR, projectId, "template-content.json");
+  const contentPath = join6(PROJECTS_DIR, projectId, "template-content.json");
   if (!existsSync5(contentPath)) return null;
   try {
     const raw = readFileSync2(contentPath, "utf-8");
@@ -20377,7 +20375,7 @@ function loadEditedTemplateContent(projectId) {
 function loadProjectNetworkData(project) {
   const recordingDir = resolveRecordingBaseDir(project.videoPath);
   if (recordingDir) {
-    const sessionPath = join5(recordingDir, "session.json");
+    const sessionPath = join6(recordingDir, "session.json");
     if (existsSync5(sessionPath)) {
       try {
         const session = JSON.parse(readFileSync2(sessionPath, "utf-8"));