@veolab/discoverylab 1.2.1 → 1.3.0

package/dist/{chunk-TJ3H23LL.js → chunk-VVIOB362.js}

@@ -159,8 +159,9 @@ var DB_PATH = join(DATA_DIR, "data.db");
 var PROJECTS_DIR = join(DATA_DIR, "projects");
 var EXPORTS_DIR = join(DATA_DIR, "exports");
 var FRAMES_DIR = join(DATA_DIR, "frames");
+var TEMPLATES_DIR = join(DATA_DIR, "templates");
 function ensureDirectories() {
-  const dirs = [DATA_DIR, PROJECTS_DIR, EXPORTS_DIR, FRAMES_DIR];
+  const dirs = [DATA_DIR, PROJECTS_DIR, EXPORTS_DIR, FRAMES_DIR, TEMPLATES_DIR];
   for (const dir of dirs) {
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });
@@ -356,6 +357,7 @@ export {
   PROJECTS_DIR,
   EXPORTS_DIR,
   FRAMES_DIR,
+  TEMPLATES_DIR,
   getDatabase,
   getSqlite,
   closeDatabase

package/dist/{chunk-W3WJGYR6.js → chunk-XFVDP332.js}

@@ -181,12 +181,18 @@ async function recognizeText(imagePath, options = {}) {
   }
   return recognizeTextWithTesseract(imagePath, options);
 }
-async function recognizeTextBatch(imagePaths, options = {}) {
+async function recognizeTextBatch(imagePaths, options = {}, onProgress) {
   const results = [];
   const textParts = [];
-  for (const imagePath of imagePaths) {
+  for (const [index, imagePath] of imagePaths.entries()) {
     const ocr = await recognizeText(imagePath, options);
     results.push({ imagePath, ocr });
+    onProgress?.({
+      current: index + 1,
+      total: imagePaths.length,
+      imagePath,
+      ocr
+    });
     if (ocr.success && ocr.text) {
       textParts.push(ocr.text);
     }

package/dist/{chunk-QJXXHOV7.js → chunk-XKX6NBHF.js}

@@ -1,10 +1,14 @@
+import {
+  APP_VERSION
+} from "./chunk-6EGBXRDK.js";
+
 // src/mcp/server.ts
 import { z } from "zod";
 var MCPServer = class {
   tools = /* @__PURE__ */ new Map();
   serverInfo = {
     name: "discoverylab",
-    version: "0.1.0"
+    version: APP_VERSION
   };
   registerTool(tool) {
     this.tools.set(tool.name, tool);

package/dist/cli.js

@@ -1,17 +1,395 @@
 #!/usr/bin/env node
+import {
+  APP_VERSION
+} from "./chunk-6EGBXRDK.js";
+import {
+  buildAppLabNetworkProfile
+} from "./chunk-LB3RNE3O.js";
+import "./chunk-MLKGABMK.js";
 
 // src/cli.ts
 import { Command } from "commander";
 import chalk from "chalk";
 import open from "open";
 var program = new Command();
-program.name("discoverylab").description("AI-powered app testing & evidence generator - Claude Code Plugin").version("0.1.0");
-program.command("serve").description("Start the DiscoveryLab web UI server").option("-p, --port <number>", "Port to listen on", "3847").option("-o, --open", "Open browser automatically", false).action(async (options) => {
+var binName = process.argv[1]?.replace(/.*[\\/]/, "").replace(/\.[^.]+$/, "") === "applab" ? "applab" : "discoverylab";
+program.name(binName).description("AI-powered app testing & evidence generator - Claude Code Plugin").version(APP_VERSION);
+function printCliOutput(value) {
+  if (typeof value === "string") {
+    console.log(value);
+    return;
+  }
+  console.log(JSON.stringify(value, null, 2));
+}
+function failCli(message) {
+  throw new Error(message);
+}
+async function readJsonSource(json, filePath, label = "payload") {
+  if (json && filePath) {
+    failCli(`Use either --json or --file for ${label}, not both.`);
+  }
+  if (json) {
+    try {
+      return JSON.parse(json);
+    } catch (error) {
+      failCli(`Invalid ${label} JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (filePath) {
+    const { readFile } = await import("fs/promises");
+    const { resolve } = await import("path");
+    const raw = await readFile(resolve(process.cwd(), filePath), "utf8");
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return null;
+}
+async function withESVPCli(action) {
+  try {
+    const result = await action();
+    printCliOutput(result);
+  } catch (error) {
+    console.error(chalk.red(`  ESVP command failed: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function getESVPBaseResult(serverUrl) {
+  const { getESVPConnection } = await import("./esvp-GSISVXLC.js");
+  const connection = await getESVPConnection(serverUrl);
+  return {
+    serverUrl: connection.serverUrl,
+    connectionMode: connection.mode
+  };
+}
+function executorToPlatform(executor) {
+  if (executor === "ios-sim" || executor === "maestro-ios") return "ios";
+  if (executor === "adb") return "android";
+  return void 0;
+}
+var esvp = program.command("esvp").description("Access the public ESVP protocol and runtime from the CLI");
+esvp.command("status").description("Check the configured ESVP server health").option("-s, --server <url>", "ESVP base URL").action(async (options) => {
+  await withESVPCli(async () => {
+    const { getESVPHealth } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      health: await getESVPHealth(options.server)
+    };
+  });
+});
+esvp.command("devices").description("List ESVP-visible devices").option("-s, --server <url>", "ESVP base URL").option("-p, --platform <platform>", "adb | ios-sim | maestro-ios | all", "all").action(async (options) => {
+  await withESVPCli(async () => {
+    const { listESVPDevices } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      devices: await listESVPDevices(options.platform, options.server)
+    };
+  });
+});
+esvp.command("sessions").description("List public ESVP sessions").option("-s, --server <url>", "ESVP base URL").action(async (options) => {
+  await withESVPCli(async () => {
+    const { listESVPSessions } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await listESVPSessions(options.server)
+    };
+  });
+});
+esvp.command("create").description("Create a new ESVP session").requiredOption("-e, --executor <executor>", "fake | adb | ios-sim | maestro-ios").option("-s, --server <url>", "ESVP base URL").option("-d, --device-id <id>", "Device or simulator ID").option("--meta-json <json>", "Session metadata as JSON").option("--meta-file <path>", "Path to session metadata JSON").option("--crash-clip-json <json>", "Crash clip config as JSON").option("--crash-clip-file <path>", "Path to crash clip config JSON").option("--with-network", "Auto-configure the default App Lab external-proxy profile after creating the session").action(async (options) => {
+  await withESVPCli(async () => {
+    const { createESVPSession, configureESVPNetwork } = await import("./esvp-GSISVXLC.js");
+    const meta = await readJsonSource(options.metaJson, options.metaFile, "meta");
+    const crashClip = await readJsonSource(options.crashClipJson, options.crashClipFile, "crash clip");
+    const createResult = await createESVPSession(
+      {
+        executor: options.executor,
+        ...options.deviceId ? { deviceId: options.deviceId } : {},
+        ...meta ? { meta } : {},
+        ...crashClip ? { crash_clip: crashClip } : {}
+      },
+      options.server
+    );
+    let networkConfigured = null;
+    if (options.withNetwork) {
+      const sessionId = String(createResult?.session?.id || createResult?.id || "");
+      if (sessionId) {
+        networkConfigured = await configureESVPNetwork(
+          sessionId,
+          buildAppLabNetworkProfile(
+            {
+              enabled: true,
+              mode: "external-proxy",
+              profile: "applab-standard-capture",
+              label: "App Lab Standard Capture"
+            },
+            {
+              platform: executorToPlatform(options.executor),
+              deviceId: options.deviceId
+            }
+          ) || {},
+          options.server
+        ).catch((err) => ({ error: err.message }));
+      }
+    }
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...createResult,
+      ...networkConfigured ? { networkConfigured } : {}
+    };
+  });
+});
+esvp.command("get <sessionId>").description("Get a public ESVP session summary").option("-s, --server <url>", "ESVP base URL").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { getESVPSession } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await getESVPSession(sessionId, options.server)
+    };
+  });
+});
+esvp.command("inspect <sessionId>").description("Inspect a session and optionally load transcript and artifacts").option("-s, --server <url>", "ESVP base URL").option("--transcript", "Include transcript").option("--artifacts", "Include artifacts").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { inspectESVPSession } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await inspectESVPSession(
+        sessionId,
+        {
+          includeTranscript: options.transcript === true,
+          includeArtifacts: options.artifacts === true
+        },
+        options.server
+      )
+    };
+  });
+});
+esvp.command("transcript <sessionId>").description("Fetch the canonical session transcript").option("-s, --server <url>", "ESVP base URL").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { getESVPTranscript } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      sessionId,
+      transcript: (await getESVPTranscript(sessionId, options.server))?.events || []
+    };
+  });
+});
+esvp.command("artifacts <sessionId>").description("List session artifacts").option("-s, --server <url>", "ESVP base URL").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { listESVPArtifacts } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      sessionId,
+      artifacts: (await listESVPArtifacts(sessionId, options.server))?.artifacts || []
+    };
+  });
+});
+esvp.command("artifact <sessionId> <artifactPath>").description("Read a public artifact payload").option("-s, --server <url>", "ESVP base URL").action(async (sessionId, artifactPath, options) => {
+  await withESVPCli(async () => {
+    const { getESVPArtifactContent } = await import("./esvp-GSISVXLC.js");
+    return await getESVPArtifactContent(sessionId, artifactPath, options.server);
+  });
+});
+esvp.command("actions <sessionId>").description("Run public ESVP actions inside a session").option("-s, --server <url>", "ESVP base URL").option("--actions-json <json>", "JSON array of ESVP actions").option("--actions-file <path>", "Path to a JSON file with ESVP actions").option("--finish", "Finish the session after actions").option("--capture-logcat", "Capture logcat on finish when supported").option("--checkpoint-after-each", "Set checkpointAfter on every action").option("--with-network", "Auto-configure the default App Lab external-proxy profile before running actions if not already configured").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { runESVPActions, getESVPSessionNetwork, configureESVPNetwork } = await import("./esvp-GSISVXLC.js");
+    const actions = await readJsonSource(options.actionsJson, options.actionsFile, "actions");
+    if (!Array.isArray(actions) || actions.length === 0) {
+      failCli("Provide --actions-json or --actions-file with a non-empty array of ESVP actions.");
+    }
+    let networkConfigured = null;
+    if (options.withNetwork) {
+      const networkState = await getESVPSessionNetwork(sessionId, options.server).catch(() => null);
+      const hasActiveProfile = networkState?.network?.active_profile || networkState?.network?.effective_profile;
+      if (!hasActiveProfile) {
+        networkConfigured = await configureESVPNetwork(
+          sessionId,
+          buildAppLabNetworkProfile(
+            {
+              enabled: true,
+              mode: "external-proxy",
+              profile: "applab-standard-capture",
+              label: "App Lab Standard Capture"
+            },
+            {
+              platform: executorToPlatform(typeof networkState?.session?.executor === "string" ? networkState.session.executor : void 0),
+              deviceId: typeof networkState?.session?.device_id === "string" ? networkState.session.device_id : void 0
+            }
+          ) || {},
+          options.server
+        ).catch((err) => ({ error: err.message }));
+      }
+    }
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...networkConfigured ? { networkConfigured } : {},
+      ...await runESVPActions(
+        sessionId,
+        {
+          actions,
+          finish: options.finish === true,
+          captureLogcat: options.captureLogcat === true,
+          checkpointAfterEach: options.checkpointAfterEach === true
+        },
+        options.server
+      )
+    };
+  });
+});
+esvp.command("checkpoint <sessionId>").description("Capture an ESVP checkpoint").option("-s, --server <url>", "ESVP base URL").option("-l, --label <label>", "Checkpoint label").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { captureESVPCheckpoint } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await captureESVPCheckpoint(
+        sessionId,
+        {
+          ...options.label ? { label: options.label } : {}
+        },
+        options.server
+      )
+    };
+  });
+});
+esvp.command("finish <sessionId>").description("Finish an ESVP session").option("-s, --server <url>", "ESVP base URL").option("--capture-logcat", "Capture logcat on finish when supported").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { finishESVPSession } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await finishESVPSession(
+        sessionId,
+        {
+          captureLogcat: options.captureLogcat === true
+        },
+        options.server
+      )
+    };
+  });
+});
+esvp.command("preflight <sessionId>").description("Run preflight/bootstrap rules on an ESVP session").option("-s, --server <url>", "ESVP base URL").option("--policy <policy>", "Preflight policy name (e.g. fresh_install)").option("--app-id <appId>", "Target app ID").option("--json <json>", "Preflight config as JSON string").option("--file <path>", "Path to preflight config JSON file").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { runESVPPreflight } = await import("./esvp-GSISVXLC.js");
+    const fromSource = await readJsonSource(options.json, options.file, "preflight config");
+    const config = {
+      ...typeof fromSource === "object" && fromSource ? fromSource : {},
+      ...options.policy ? { policy: options.policy } : {},
+      ...options.appId ? { appId: options.appId } : {}
+    };
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await runESVPPreflight(sessionId, config, options.server)
+    };
+  });
+});
+esvp.command("replay-run <sessionId>").description("Replay a session to a new ESVP session").option("-s, --server <url>", "ESVP base URL").option("-e, --executor <executor>", "fake | adb | ios-sim | maestro-ios").option("-d, --device-id <id>", "Replay target device ID").option("--capture-logcat", "Capture logcat on finish when supported").option("--meta-json <json>", "Replay metadata as JSON").option("--meta-file <path>", "Path to replay metadata JSON").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { replayESVPSession, getESVPReplayConsistency } = await import("./esvp-GSISVXLC.js");
+    const meta = await readJsonSource(options.metaJson, options.metaFile, "replay meta");
+    const replay = await replayESVPSession(
+      sessionId,
+      {
+        ...options.executor ? { executor: options.executor } : {},
+        ...options.deviceId ? { deviceId: options.deviceId } : {},
+        ...options.captureLogcat === true ? { captureLogcat: true } : {},
+        ...meta ? { meta } : {}
+      },
+      options.server
+    );
+    const replaySessionId = replay?.replay_session?.id;
+    const replayConsistency = replaySessionId ? (await getESVPReplayConsistency(replaySessionId, options.server)).replay_consistency : null;
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...replay,
+      replayConsistency
+    };
+  });
+});
+esvp.command("replay-validate <sessionId>").description("Validate whether a session supports public replay").option("-s, --server <url>", "ESVP base URL").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { validateESVPReplay } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await validateESVPReplay(sessionId, options.server)
+    };
+  });
+});
+esvp.command("replay-consistency <sessionId>").description("Inspect replay consistency for a replay session").option("-s, --server <url>", "ESVP base URL").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { getESVPReplayConsistency } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await getESVPReplayConsistency(sessionId, options.server)
+    };
+  });
+});
+esvp.command("network <sessionId>").description("Read the public network state for a session").option("-s, --server <url>", "ESVP base URL").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { getESVPSessionNetwork } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await getESVPSessionNetwork(sessionId, options.server)
+    };
+  });
+});
+esvp.command("network-configure <sessionId>").description("Apply a public ESVP network profile").option("-s, --server <url>", "ESVP base URL").option("--json <json>", "Raw network profile JSON").option("--file <path>", "Path to network profile JSON").option("--profile <name>", "Profile name").option("--label <label>", "Profile label").option("--connectivity <state>", "online | offline | reset").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { configureESVPNetwork } = await import("./esvp-GSISVXLC.js");
+    const payload = await readJsonSource(options.json, options.file, "network profile") || {};
+    const merged = {
+      ...typeof payload === "object" && payload ? payload : {},
+      ...options.profile ? { profile: options.profile } : {},
+      ...options.label ? { label: options.label } : {},
+      ...options.connectivity ? { connectivity: options.connectivity } : {}
+    };
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await configureESVPNetwork(sessionId, merged, options.server)
+    };
+  });
+});
+esvp.command("network-clear <sessionId>").description("Clear the active ESVP network profile").option("-s, --server <url>", "ESVP base URL").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { clearESVPNetwork } = await import("./esvp-GSISVXLC.js");
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await clearESVPNetwork(sessionId, options.server)
+    };
+  });
+});
+esvp.command("trace-attach <sessionId>").description("Attach a public network trace artifact to a session").requiredOption("--trace-kind <kind>", "Trace kind, e.g. http_trace or har").option("-s, --server <url>", "ESVP base URL").option("--json <json>", "Trace payload JSON").option("--file <path>", "Path to trace payload JSON/text").option("--label <label>", "Trace label").option("--source <source>", "Trace source").option("--request-id <id>", "Correlated request ID").option("--method <method>", "HTTP method").option("--url <url>", "Request URL").option("--status-code <code>", "HTTP status code").option("--format <format>", "Payload format label").action(async (sessionId, options) => {
+  await withESVPCli(async () => {
+    const { attachESVPNetworkTrace } = await import("./esvp-GSISVXLC.js");
+    const payload = await readJsonSource(options.json, options.file, "trace payload");
+    if (payload == null) {
+      failCli("Provide --json or --file with the trace payload to attach.");
+    }
+    return {
+      ...await getESVPBaseResult(options.server),
+      ...await attachESVPNetworkTrace(
+        sessionId,
+        {
+          trace_kind: options.traceKind,
+          ...options.label ? { label: options.label } : {},
+          ...options.source ? { source: options.source } : {},
+          ...options.requestId ? { request_id: options.requestId } : {},
+          ...options.method ? { method: options.method } : {},
+          ...options.url ? { url: options.url } : {},
+          ...options.statusCode ? { status_code: Number(options.statusCode) } : {},
+          ...options.format ? { format: options.format } : {},
+          payload
+        },
+        options.server
+      )
+    };
+  });
+});
+program.command("serve").alias("server").description("Start the DiscoveryLab web UI server").option("-p, --port <number>", "Port to listen on", "3847").option("-o, --open", "Open browser automatically", false).action(async (options) => {
   const port = parseInt(options.port, 10);
   console.log(chalk.cyan("\n  DiscoveryLab"));
   console.log(chalk.gray("  AI-powered app testing & evidence generator\n"));
   try {
-    const { startServer } = await import("./server-JG7UKFGK.js");
+    const { startServer } = await import("./server-FO3UVUZU.js");
     await startServer(port);
     console.log(chalk.green(`  Server running at http://localhost:${port}`));
     console.log(chalk.gray("  Press Ctrl+C to stop\n"));
@@ -26,7 +404,7 @@ program.command("serve").description("Start the DiscoveryLab web UI server").opt
 program.command("setup").description("Check and configure DiscoveryLab dependencies").action(async () => {
   console.log(chalk.cyan("\n  DiscoveryLab Setup\n"));
   try {
-    const { setupStatusTool } = await import("./setup-AQX4JQVR.js");
+    const { setupStatusTool } = await import("./setup-2SQC5UHJ.js");
     const result = await setupStatusTool.handler({});
     if (result.isError) {
       console.error(chalk.red("  Setup check failed"));
@@ -62,7 +440,7 @@ program.command("setup").description("Check and configure DiscoveryLab dependenc
 program.command("init").description("Initialize DiscoveryLab data directories").action(async () => {
   console.log(chalk.cyan("\n  Initializing DiscoveryLab...\n"));
   try {
-    const { getDatabase, DATA_DIR, PROJECTS_DIR, EXPORTS_DIR } = await import("./db-ADBEBNH6.js");
+    const { getDatabase, DATA_DIR, PROJECTS_DIR, EXPORTS_DIR } = await import("./db-6WLEVKUV.js");
     getDatabase();
     console.log(chalk.green("  Created directories:"));
     console.log(chalk.gray(`    ${DATA_DIR}`));
@@ -108,10 +486,22 @@ program.command("install").description("Install DiscoveryLab as Claude Code MCP
 });
 program.command("mcp").description("Run as MCP server (for Claude Code integration)").action(async () => {
   try {
-    const { getDatabase } = await import("./db-ADBEBNH6.js");
+    const { getDatabase } = await import("./db-6WLEVKUV.js");
     getDatabase();
-    const { mcpServer } = await import("./server-3FBHBA7L.js");
-    const { uiTools, projectTools, setupTools, captureTools, analyzeTools, canvasTools, exportTools, testingTools, integrationTools } = await import("./tools-N5N2IO7V.js");
+    const { mcpServer } = await import("./server-6N3KIEGP.js");
+    const {
+      uiTools,
+      projectTools,
+      setupTools,
+      captureTools,
+      analyzeTools,
+      canvasTools,
+      exportTools,
+      testingTools,
+      integrationTools,
+      taskHubTools,
+      esvpTools
+    } = await import("./tools-OCRMOQ4U.js");
     mcpServer.registerTools([
       ...uiTools,
       ...projectTools,
@@ -121,7 +511,9 @@ program.command("mcp").description("Run as MCP server (for Claude Code integrati
       ...canvasTools,
       ...exportTools,
       ...testingTools,
-      ...integrationTools
+      ...integrationTools,
+      ...taskHubTools,
+      ...esvpTools
     ]);
     await mcpServer.runStdio();
   } catch (error) {
@@ -130,11 +522,13 @@ program.command("mcp").description("Run as MCP server (for Claude Code integrati
   }
 });
 program.command("info").description("Show version and configuration info").action(async () => {
-  console.log(chalk.cyan("\n  DiscoveryLab v0.1.0\n"));
+  console.log(chalk.cyan(`
+  DiscoveryLab v${APP_VERSION}
+`));
   console.log(chalk.gray("  AI-powered app testing & evidence generator"));
   console.log(chalk.gray("  Claude Code Plugin\n"));
   try {
-    const { DATA_DIR, DB_PATH } = await import("./db-ADBEBNH6.js");
+    const { DATA_DIR, DB_PATH } = await import("./db-6WLEVKUV.js");
     console.log(chalk.white("  Paths:"));
     console.log(chalk.gray(`    Data: ${DATA_DIR}`));
     console.log(chalk.gray(`    Database: ${DB_PATH}`));

package/dist/{db-ADBEBNH6.js → db-6WLEVKUV.js}

@@ -4,6 +4,7 @@ import {
   EXPORTS_DIR,
   FRAMES_DIR,
   PROJECTS_DIR,
+  TEMPLATES_DIR,
   closeDatabase,
   exportDestinations,
   exportRules,
@@ -14,7 +15,7 @@ import {
   projects,
   settings,
   testVariables
-} from "./chunk-TJ3H23LL.js";
+} from "./chunk-VVIOB362.js";
 import "./chunk-MLKGABMK.js";
 export {
   DATA_DIR,
@@ -22,6 +23,7 @@ export {
   EXPORTS_DIR,
   FRAMES_DIR,
   PROJECTS_DIR,
+  TEMPLATES_DIR,
   closeDatabase,
   exportDestinations,
   exportRules,

package/dist/esvp-GSISVXLC.js

@@ -0,0 +1,52 @@
+import {
+  attachESVPNetworkTrace,
+  captureESVPCheckpoint,
+  clearESVPNetwork,
+  configureESVPNetwork,
+  createESVPSession,
+  finishESVPSession,
+  getESVPArtifactContent,
+  getESVPBaseUrl,
+  getESVPConnection,
+  getESVPHealth,
+  getESVPReplayConsistency,
+  getESVPSession,
+  getESVPSessionNetwork,
+  getESVPTranscript,
+  inspectESVPSession,
+  listESVPArtifacts,
+  listESVPDevices,
+  listESVPSessions,
+  replayESVPSession,
+  resolveESVPBaseUrl,
+  runESVPActions,
+  runESVPPreflight,
+  validateESVPReplay
+} from "./chunk-GAKEFJ5T.js";
+import "./chunk-VVIOB362.js";
+import "./chunk-MLKGABMK.js";
+export {
+  attachESVPNetworkTrace,
+  captureESVPCheckpoint,
+  clearESVPNetwork,
+  configureESVPNetwork,
+  createESVPSession,
+  finishESVPSession,
+  getESVPArtifactContent,
+  getESVPBaseUrl,
+  getESVPConnection,
+  getESVPHealth,
+  getESVPReplayConsistency,
+  getESVPSession,
+  getESVPSessionNetwork,
+  getESVPTranscript,
+  inspectESVPSession,
+  listESVPArtifacts,
+  listESVPDevices,
+  listESVPSessions,
+  replayESVPSession,
+  resolveESVPBaseUrl,
+  runESVPActions,
+  runESVPPreflight,
+  validateESVPReplay
+};

package/dist/esvp-mobile-GC7MAGMI.js

@@ -0,0 +1,20 @@
+import {
+  collectESVPSessionNetworkData,
+  createMobileNetworkCaptureMeta,
+  diagnoseESVPNetworkState,
+  translateMaestroActionsToESVP,
+  validateMaestroRecordingWithESVP
+} from "./chunk-N6JJ2RGV.js";
+import "./chunk-LB3RNE3O.js";
+import "./chunk-GAKEFJ5T.js";
+import "./chunk-SLNJEF32.js";
+import "./chunk-VVIOB362.js";
+import "./chunk-XFVDP332.js";
+import "./chunk-MLKGABMK.js";
+export {
+  collectESVPSessionNetworkData,
+  createMobileNetworkCaptureMeta,
+  diagnoseESVPNetworkState,
+  translateMaestroActionsToESVP,
+  validateMaestroRecordingWithESVP
+};