@crvy/rprtr 0.2.3 → 0.3.0

package/dist/server.cjs

@@ -35,7 +35,7 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 
 // src/server/app.ts
-var import_path8 = require("path");
+var import_path9 = require("path");
 var import_url = require("url");
 
 // src/offline-reports.ts
@@ -276,13 +276,14 @@ var RunTestDescriptorSchema = import_zod.z.object({
   titlePath: import_zod.z.array(import_zod.z.string())
 });
 var RunRequestBodySchema = import_zod.z.object({
-  tests: import_zod.z.array(RunTestDescriptorSchema).optional()
+  tests: import_zod.z.array(RunTestDescriptorSchema).optional(),
+  update: import_zod.z.boolean().optional()
 });
 var RunResponseSchema = import_zod.z.discriminatedUnion("ok", [
   import_zod.z.object({ ok: import_zod.z.literal(true) }),
   import_zod.z.object({
     ok: import_zod.z.literal(false),
-    reason: import_zod.z.enum(["no-config", "already-running", "no-tests"])
+    reason: import_zod.z.enum(["no-config", "already-running", "no-tests", "docker-unavailable"])
   })
 ]);
 var StopResponseSchema = import_zod.z.discriminatedUnion("ok", [
@@ -389,7 +390,9 @@ var WebSocketMessageSchema = import_zod2.z.discriminatedUnion("type", [
   import_zod2.z.object({
     type: import_zod2.z.literal("run-status"),
     data: import_zod2.z.object({
-      running: import_zod2.z.boolean()
+      running: import_zod2.z.boolean(),
+      mode: import_zod2.z.enum(["local", "docker"]).optional(),
+      phase: import_zod2.z.string().optional()
     })
   })
 ]);
@@ -419,6 +422,7 @@ var RunEndDataSchema = import_zod2.z.object({
 var RegisterDataSchema = import_zod2.z.object({
   playwrightSnapshotDir: import_zod2.z.string().optional(),
   playwrightTestDir: import_zod2.z.string().optional(),
+  playwrightRootDir: import_zod2.z.string().optional(),
   playwrightSnapshotPathTemplate: import_zod2.z.string().optional(),
   playwrightToHaveScreenshotPathTemplate: import_zod2.z.string().optional(),
   configFile: import_zod2.z.string().optional(),
@@ -451,7 +455,8 @@ var ReportApiResponseSchema = import_zod2.z.object({
   tests: import_zod2.z.record(import_zod2.z.string(), TestDataSchema),
   isUpdateMode: import_zod2.z.boolean().optional(),
   isRunning: import_zod2.z.boolean().optional(),
-  runEnabled: import_zod2.z.boolean().optional()
+  runEnabled: import_zod2.z.boolean().optional(),
+  runMode: import_zod2.z.enum(["local", "docker"]).optional()
 });
 var ClientBootstrapDataSchema = import_zod2.z.object({
   report: ReportApiResponseSchema.extend({
@@ -654,201 +659,738 @@ function mergeOfflineReportsIntoTests(existingTests, offlineReports, options = {
   };
 }
 
-// src/server/handlers.ts
-var import_fs2 = require("fs");
-
-// src/server/artifact-routes.ts
-var import_fs = require("fs");
-var import_promises3 = require("fs/promises");
-var import_path5 = require("path");
-
-// src/snapshot-path-resolver.ts
-var import_crypto = require("crypto");
-var import_path3 = require("path");
-var DEFAULT_SCREENSHOT_TEMPLATE = "{snapshotDir}/{testFileDir}/{testFileName}-snapshots/{arg}{-projectName}{-snapshotSuffix}{ext}";
-var WINDOWS_FILESYSTEM_FRIENDLY_LENGTH = 60;
-function isUnsafeFilePathCharacter(character) {
-  const codePoint = character.codePointAt(0);
-  return codePoint !== void 0 && (codePoint <= 44 || codePoint >= 46 && codePoint <= 47 || codePoint >= 58 && codePoint <= 64 || codePoint >= 91 && codePoint <= 96 || codePoint >= 123 && codePoint <= 127);
-}
-function sanitizeForFilePath(value) {
-  return Array.from(value).reduce(
-    (state, character) => {
-      const unsafeCharacter = isUnsafeFilePathCharacter(character);
-      return unsafeCharacter ? state.previousCharacterWasUnsafe ? state : {
-        value: `${state.value}-`,
-        previousCharacterWasUnsafe: true
-      } : {
-        value: `${state.value}${character}`,
-        previousCharacterWasUnsafe: false
-      };
-    },
-    {
-      value: "",
-      previousCharacterWasUnsafe: false
-    }
-  ).value;
+// src/server/docker-support.ts
+var import_child_process = require("child_process");
+var import_node_fs = require("node:fs");
+var import_node_module = require("node:module");
+var import_node_path = require("node:path");
+var import_detect = require("package-manager-detector/detect");
+function createDockerExec() {
+  return (args) => new Promise((resolve6, reject) => {
+    const child = (0, import_child_process.spawn)("docker", args, { stdio: ["ignore", "pipe", "pipe"] });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolve6({
+        exitCode: code ?? 1,
+        stdout: Buffer.concat(stdout).toString(),
+        stderr: Buffer.concat(stderr).toString()
+      });
+    });
+  });
 }
-function trimLongString(value, length = WINDOWS_FILESYSTEM_FRIENDLY_LENGTH) {
-  if (value.length <= length) {
-    return value;
+async function probeDockerDaemon(exec) {
+  try {
+    const result = await exec(["info"]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
   }
-  const hash = (0, import_crypto.createHash)("sha1").update(value).digest("hex");
-  const middle = `-${hash.slice(0, 5)}-`;
-  const start = Math.floor((length - middle.length) / 2);
-  const end = length - middle.length - start;
-  return value.slice(0, start) + middle + value.slice(-end);
-}
-function sanitizeFilePathBeforeExtension(filePath, extension = (0, import_path3.extname)(filePath)) {
-  const base = filePath.slice(0, filePath.length - extension.length);
-  return sanitizeForFilePath(base) + extension;
-}
-function addSuffixToFilePath(filePath, suffix) {
-  const extension = (0, import_path3.extname)(filePath);
-  return filePath.slice(0, filePath.length - extension.length) + suffix + extension;
-}
-function normalizedSnapshotDir(config) {
-  return (0, import_path3.resolve)(config.configDir, config.snapshotDir);
 }
-function templateValue(template, token, value) {
-  return template.replace(
-    new RegExp(`\\{(.)?${token}\\}`, "g"),
-    (_, prefix) => value === "" ? "" : `${prefix ?? ""}${value}`
-  );
+async function isDockerImagePresent(exec, image) {
+  try {
+    const result = await exec(["image", "inspect", image]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
 }
-function applyTemplate(input, nameArgument, extension) {
-  const template = input.config.toHaveScreenshotPathTemplate ?? input.config.snapshotPathTemplate ?? DEFAULT_SCREENSHOT_TEMPLATE;
-  const relativeTestFilePath = (0, import_path3.relative)(input.config.testDir, input.testFile);
-  const parsed = (0, import_path3.parse)(relativeTestFilePath);
-  const tokens = [
-    ["testDir", input.config.testDir],
-    ["snapshotDir", normalizedSnapshotDir(input.config)],
-    ["snapshotSuffix", input.config.snapshotSuffix],
-    ["testFileDir", parsed.dir],
-    ["platform", process.platform],
-    ["projectName", sanitizeForFilePath(input.config.projectName)],
-    ["testName", ""],
-    ["testFileName", parsed.base],
-    ["testFilePath", relativeTestFilePath],
-    ["arg", nameArgument],
-    ["ext", extension]
-  ];
-  const snapshotPath = tokens.reduce(
-    (currentTemplate, [token, value]) => templateValue(currentTemplate, token, value),
-    template
-  );
-  return (0, import_path3.resolve)(input.config.configDir, snapshotPath);
+async function pullDockerImage(exec, image) {
+  try {
+    const result = await exec(["pull", image]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
 }
-function removeExtension(filePath, extension = (0, import_path3.extname)(filePath)) {
-  return filePath.slice(0, filePath.length - extension.length);
+async function forceRemoveContainer(exec, name) {
+  try {
+    await exec(["rm", "-f", name]);
+  } catch {
+  }
 }
-function snapshotNameParts(declaredName) {
-  const extension = (0, import_path3.extname)(declaredName) || ".png";
-  return {
-    extension,
-    filePath: (0, import_path3.extname)(declaredName) === "" ? `${declaredName}${extension}` : declaredName
-  };
+function resolveDockerImage(options) {
+  if (options.image !== void 0 && options.image !== "") return options.image;
+  if (options.version === null) return null;
+  return `mcr.microsoft.com/playwright:v${options.version}-noble`;
 }
-function filePathForOccurrence(filePath, occurrenceIndex) {
-  return occurrenceIndex === 1 ? filePath : addSuffixToFilePath(filePath, `-${occurrenceIndex - 1}`);
+var CONTAINER_INVOKERS = {
+  npm: ["npx"],
+  pnpm: ["pnpm", "exec"],
+  yarn: ["yarn"],
+  bun: ["bunx"]
+};
+var DEFAULT_CONTAINER_COMMAND = ["npx"];
+function resolveContainerCommand(input) {
+  if (input.command !== void 0 && input.command.length > 0) return input.command;
+  if (!input.hasCustomImage) return [...DEFAULT_CONTAINER_COMMAND];
+  if (input.detectedAgentName === void 0 || input.detectedAgentName === null) {
+    input.warn?.("Could not detect a package manager for the custom docker image; falling back to npx.");
+    return [...DEFAULT_CONTAINER_COMMAND];
+  }
+  const invoker = CONTAINER_INVOKERS[input.detectedAgentName];
+  if (invoker === void 0) {
+    input.warn?.(`Package manager "${input.detectedAgentName}" is not supported in docker mode; falling back to npx.`);
+    return [...DEFAULT_CONTAINER_COMMAND];
+  }
+  return [...invoker];
+}
+var detectProjectAgent = async (cwd) => {
+  try {
+    const result = await (0, import_detect.detect)({ cwd, strategies: ["lockfile", "packageManager-field"] });
+    return result === null ? null : { name: result.name, agent: result.agent };
+  } catch {
+    return null;
+  }
+};
+function rewriteContainerPath(path, mapping) {
+  if (path === mapping.from) return mapping.to;
+  if (path.startsWith(`${mapping.from}/`)) return mapping.to + path.slice(mapping.from.length);
+  return path;
 }
-function createResolvedBaselineTarget(input, declaration, nameArgument, extension) {
-  return {
-    visualName: declaration.visualName,
-    attachmentBaseName: declaration.visualName,
-    artifactBaseName: sanitizeForFilePath(declaration.visualName),
-    snapshotPath: applyTemplate(input, nameArgument, extension)
-  };
+function resolvePlaywrightVersion(cwd) {
+  try {
+    const req = (0, import_node_module.createRequire)((0, import_node_path.join)(cwd, "package.json"));
+    const pkgPath = req.resolve("@playwright/test/package.json");
+    const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf8"));
+    return typeof pkg === "object" && pkg !== null && "version" in pkg && typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
 }
-function resolveStringCallTarget(input, declaration) {
-  const { extension, filePath } = snapshotNameParts(declaration.declaredName);
-  const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
-  const sanitizedNameWithExtension = sanitizeFilePathBeforeExtension(occurrenceFilePath, extension);
-  const nameArgument = removeExtension(sanitizedNameWithExtension, extension);
-  return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+function rewriteContainerTestDescriptors(tests, mapping) {
+  if (tests === void 0 || mapping === void 0) return tests;
+  return tests.map((d) => ({ ...d, file: rewriteContainerPath(d.file, mapping) }));
 }
-function resolveArrayCallTarget(input, declaration) {
-  const { extension, filePath } = snapshotNameParts(declaration.declaredName);
-  const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
-  const nameArgument = (0, import_path3.join)((0, import_path3.dirname)(occurrenceFilePath), (0, import_path3.basename)(occurrenceFilePath, extension));
-  return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+function testListEntry(d, file) {
+  const loc = d.column === void 0 ? `${file}:${d.line}` : `${file}:${d.line}:${d.column}`;
+  const title = d.titlePath.join(" \u203A ");
+  const prefix = d.projectName !== void 0 && d.projectName !== "" ? `[${d.projectName}] \u203A ` : "";
+  return `${prefix}${loc} \u203A ${title}`;
 }
-function resolveNamedTarget(input, declaration) {
-  if (!declaration.declaredName.includes("/")) {
-    return resolveStringCallTarget(input, declaration);
-  }
-  const stringCallTarget = resolveStringCallTarget(input, declaration);
-  const arrayCallTarget = resolveArrayCallTarget(input, declaration);
-  if (stringCallTarget.snapshotPath === arrayCallTarget.snapshotPath) {
-    return stringCallTarget;
-  }
-  if (input.snapshotPathExists === void 0) {
-    return void 0;
-  }
-  const stringCallTargetExists = input.snapshotPathExists(stringCallTarget.snapshotPath);
-  const arrayCallTargetExists = input.snapshotPathExists(arrayCallTarget.snapshotPath);
-  if (stringCallTargetExists === arrayCallTargetExists) {
-    return void 0;
+function buildTestListEntries(tests, rootDir, cwd) {
+  if (rootDir !== void 0) {
+    return tests.map((d) => testListEntry(d, (0, import_node_path.isAbsolute)(d.file) ? (0, import_node_path.relative)(rootDir, d.file) || d.file : d.file));
   }
-  return stringCallTargetExists ? stringCallTarget : arrayCallTarget;
-}
-function reporterTitlesWithoutProjectAndFile(reporterTitlePath2) {
-  return reporterTitlePath2.slice(3).filter((part) => part !== "");
-}
-function anonymousNameFromTitles(titles, occurrenceIndex) {
-  return sanitizeFilePathBeforeExtension(trimLongString(`${titles.join(" ")} ${occurrenceIndex}.png`), ".png");
+  return tests.flatMap((d) => {
+    if (!(0, import_node_path.isAbsolute)(d.file)) return [testListEntry(d, d.file)];
+    const rel = (0, import_node_path.relative)(cwd ?? process.cwd(), d.file);
+    const segments = rel.split(import_node_path.sep);
+    return segments.map((_, i) => testListEntry(d, segments.slice(i).join(import_node_path.sep)));
+  });
 }
-function anonymousName(reporterTitlePath2, occurrenceIndex) {
-  return anonymousNameFromTitles(reporterTitlesWithoutProjectAndFile(reporterTitlePath2), occurrenceIndex);
+
+// src/server/run-controller.ts
+var import_child_process2 = require("child_process");
+var import_node_fs2 = require("node:fs");
+var import_node_module2 = require("node:module");
+var import_node_os = require("node:os");
+var import_node_path2 = require("node:path");
+
+// src/server/run-launcher.ts
+var import_commands = require("package-manager-detector/commands");
+var import_detect2 = require("package-manager-detector/detect");
+function resolvePlaywrightLaunch(cwd, playwrightArgs) {
+  const agent = (0, import_detect2.getUserAgent)();
+  const resolved = agent === null ? null : (0, import_commands.resolveCommand)(agent, "execute-local", ["playwright", ...playwrightArgs]);
+  if (resolved !== null) return { cmd: resolved.command, args: resolved.args };
+  return { cmd: "npx", args: ["playwright", ...playwrightArgs] };
 }
-function resolveTarget(input, declaration) {
-  switch (declaration.kind) {
-    case "named":
-      return typeof declaration.declaredName === "string" && declaration.declaredName !== "" ? resolveNamedTarget(input, declaration) : void 0;
-    case "unnamed": {
-      const anonymousFileName = anonymousName(input.reporterTitlePath, declaration.occurrenceIndex);
-      const extension = ".png";
-      const nameArgument = (0, import_path3.join)((0, import_path3.dirname)(anonymousFileName), (0, import_path3.basename)(anonymousFileName, extension));
-      return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
-    }
+function buildSpawnEnv(port, baseEnv = process.env) {
+  const env = {};
+  for (const [key, value] of Object.entries(baseEnv)) {
+    if (key === "CI") continue;
+    env[key] = value;
   }
+  env.CRVY_RPRTR_SERVER_URL = `ws://localhost:${port}`;
+  env.PLAYWRIGHT_HTML_OPEN = "never";
+  return env;
 }
-function resolveBaselineTargets(input) {
-  return input.declarations.flatMap((declaration) => {
-    const resolvedTarget = resolveTarget(input, declaration);
-    return resolvedTarget === void 0 ? [] : [resolvedTarget];
-  });
+function createLocalLauncher(options) {
+  return {
+    mode: "local",
+    launch({ ctx, playwrightArgs }) {
+      const resolve6 = options.resolveLaunch ?? resolvePlaywrightLaunch;
+      const { cmd, args } = resolve6(ctx.cwd, playwrightArgs);
+      return { cmd, args, env: buildSpawnEnv(options.port, options.env) };
+    }
+  };
 }
 
-// src/server/utils.ts
-var import_path4 = require("path");
-var LIVE_UPDATES_WEBSOCKET_PATH = "/";
-function broadcastToBrowsers(wsClients, msg) {
-  const payload = JSON.stringify(msg);
-  wsClients.forEach((ws) => {
-    ws.send(payload);
-  });
+// src/server/run-controller.ts
+var import_meta = { url: require("url").pathToFileURL(__filename).href };
+var STOP_GRACE_MS = 5e3;
+var KNOWN_SIGNALS = {
+  SIGTERM: "SIGTERM",
+  SIGKILL: "SIGKILL"
+};
+function sharedProject(tests) {
+  const names = new Set(tests.map((t) => t.projectName ?? ""));
+  if (names.size === 1) {
+    const name = [...names][0];
+    return name === "" ? void 0 : name;
+  }
+  return void 0;
 }
-function isWebSocketUpgradeRequest(req) {
-  return new URL(req.url).pathname === LIVE_UPDATES_WEBSOCKET_PATH && req.headers.get("upgrade")?.toLowerCase() === "websocket";
+function gteMinor(version, major, minor) {
+  const match = /^(\d+)\.(\d+)/.exec(version.trim());
+  if (match === null) return false;
+  const maj = parseInt(match[1], 10);
+  const min = parseInt(match[2], 10);
+  if (maj !== major) return maj > major;
+  return min >= minor;
 }
-function isPathWithinRoots(target, roots) {
-  const resolvedTarget = (0, import_path4.resolve)(target);
-  return roots.some((root) => {
-    const rel = (0, import_path4.relative)((0, import_path4.resolve)(root), resolvedTarget);
-    return rel === "" || !rel.startsWith(`..${import_path4.sep}`) && rel !== ".." && !(0, import_path4.isAbsolute)(rel);
-  });
+var defaultWriteTempFile = (content) => {
+  const path = (0, import_node_path2.join)((0, import_node_os.tmpdir)(), `crvy-rprtr-test-list-${process.pid}-${Date.now()}.txt`);
+  (0, import_node_fs2.writeFileSync)(path, content, "utf8");
+  return path;
+};
+function defaultDeleteTempFile(path) {
+  try {
+    (0, import_node_fs2.unlinkSync)(path);
+  } catch {
+  }
 }
-
-// src/server/artifact-routes.ts
-async function realpathOrNull(path) {
+function resolveReporterDefault(cwd) {
   try {
-    return await (0, import_promises3.realpath)(path);
+    return (0, import_node_module2.createRequire)((0, import_node_path2.join)(cwd, "package.json")).resolve("@crvy/rprtr");
+  } catch {
+  }
+  try {
+    return (0, import_node_module2.createRequire)(import_meta.url).resolve("@crvy/rprtr");
   } catch {
     return null;
   }
 }
-async function handleFile(ctx, req) {
+var RunController = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  child = null;
+  sigkillTimer = null;
+  testListPath = null;
+  get isRunning() {
+    return this.child !== null;
+  }
+  supportsTestList(cwd) {
+    const getVersion = this.deps.getPlaywrightVersion ?? resolvePlaywrightVersion;
+    const version = getVersion(cwd);
+    return version !== null && gteMinor(version, 1, 56);
+  }
+  cleanupTempFile() {
+    if (this.testListPath !== null) {
+      const del = this.deps.deleteTempFile ?? defaultDeleteTempFile;
+      del(this.testListPath);
+      this.testListPath = null;
+    }
+  }
+  buildPlaywrightArgs(ctx, filters, tests) {
+    const resolveReporter = this.deps.resolveReporter ?? resolveReporterDefault;
+    const reporterModule = resolveReporter(ctx.cwd);
+    const useTestList = tests !== void 0 && (tests.length > 1 || this.deps.containerPathMapping !== void 0) && this.supportsTestList(ctx.cwd);
+    const args = ["test", "--config", ctx.configFile];
+    if (reporterModule !== null) args.push("--reporter", reporterModule);
+    if (filters.update === true) args.push("--update-snapshots");
+    if (useTestList && tests !== void 0) {
+      const content = buildTestListEntries(tests, ctx.rootDir, ctx.cwd).join("\n");
+      const writeTemp = this.deps.writeTempFile ?? defaultWriteTempFile;
+      this.testListPath = writeTemp(content);
+      args.push("--test-list", this.testListPath);
+    } else if (tests !== void 0 && tests.length > 0) {
+      const project = sharedProject(tests);
+      if (project !== void 0) args.push(`--project=${project}`);
+      for (const d of tests) {
+        args.push(d.column === void 0 ? `${d.file}:${d.line}` : `${d.file}:${d.line}:${d.column}`);
+      }
+    }
+    return args;
+  }
+  start(filters) {
+    const ctx = this.deps.getRunContext();
+    if (ctx === null) return { ok: false, reason: "no-config" };
+    if (this.child !== null) return { ok: false, reason: "already-running" };
+    if (filters.tests !== void 0 && filters.tests.length === 0) return { ok: false, reason: "no-tests" };
+    if (this.deps.launcher.available === false) return { ok: false, reason: "docker-unavailable" };
+    const tests = rewriteContainerTestDescriptors(filters.tests, this.deps.containerPathMapping);
+    const args = this.buildPlaywrightArgs(ctx, filters, tests);
+    const spec = this.deps.launcher.launch({ ctx, playwrightArgs: args });
+    let child;
+    try {
+      child = this.deps.spawn(spec.cmd, spec.args, { cwd: ctx.cwd, env: spec.env, stdio: "inherit" });
+    } catch (err) {
+      this.cleanupTempFile();
+      throw err;
+    }
+    this.child = child;
+    child.on("exit", (code) => {
+      this.handleChildExit(code);
+    });
+    child.on("error", () => {
+      this.handleChildExit(null);
+    });
+    this.deps.setReportRunning(true);
+    this.deps.setRunFiltered?.(filters.tests !== void 0);
+    this.deps.broadcast({ type: "run-status", data: { running: true, mode: this.deps.launcher.mode } });
+    return { ok: true };
+  }
+  stop() {
+    if (this.child === null) return { ok: false, reason: "not-running" };
+    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
+    this.child.kill("SIGTERM");
+    this.sigkillTimer = this.deps.timers.setTimeout(() => {
+      if (this.child !== null) {
+        this.child.kill("SIGKILL");
+        this.deps.launcher.onForceKill?.();
+      }
+    }, STOP_GRACE_MS);
+    return { ok: true };
+  }
+  async prepareRun() {
+    const launcher = this.deps.launcher;
+    if (launcher.prepare === void 0) return { ok: true };
+    const ctx = this.deps.getRunContext();
+    if (ctx === null) return { ok: true };
+    try {
+      await launcher.prepare({
+        ctx,
+        onProgress: (phase) => {
+          this.deps.broadcast({ type: "run-status", data: { running: true, mode: launcher.mode, phase } });
+        }
+      });
+      return { ok: true };
+    } catch (error) {
+      this.deps.broadcast({ type: "run-status", data: { running: false, mode: launcher.mode } });
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[RunController] run preparation failed: ${message}`);
+      return { ok: false, reason: "docker-unavailable" };
+    }
+  }
+  dispose() {
+    if (this.child === null) return;
+    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
+    this.sigkillTimer = null;
+    this.child.kill("SIGKILL");
+    this.deps.launcher.onForceKill?.();
+    this.cleanupTempFile();
+  }
+  handleChildExit(code) {
+    if (this.child === null) return;
+    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
+    this.sigkillTimer = null;
+    this.child = null;
+    this.cleanupTempFile();
+    if (code !== null && code !== 0) console.warn(`[RunController] playwright test exited with code ${code}`);
+    this.deps.setReportRunning(false);
+    this.deps.broadcast({ type: "run-status", data: { running: false, mode: this.deps.launcher.mode } });
+    void this.deps.saveReport?.();
+  }
+};
+function createRealSpawn() {
+  return (cmd, args, opts) => {
+    const cp = (0, import_child_process2.spawn)(cmd, args, opts);
+    return {
+      on: (event, cb) => cp.on(event, cb),
+      kill: (signal) => {
+        const sig = KNOWN_SIGNALS[signal];
+        if (sig !== void 0) cp.kill(sig);
+      }
+    };
+  };
+}
+function createRealTimers() {
+  const pending = [];
+  return {
+    setTimeout: (fn, ms) => {
+      const id = setTimeout(fn, ms);
+      pending.push(id);
+      return id;
+    },
+    clearTimeout: () => {
+      for (const h of pending.splice(0)) clearTimeout(h);
+    }
+  };
+}
+
+// src/server/docker-launcher.ts
+var DOCKER_WORK_DIR = "/work";
+var DOCKER_HOST_GATEWAY = "host.docker.internal";
+var ENV_DENYLIST = /* @__PURE__ */ new Set([
+  "CI",
+  "PLAYWRIGHT_BROWSERS_PATH",
+  "CRVY_RPRTR_SERVER_URL",
+  "CRVY_RPRTR_PORTABLE_ARTIFACTS",
+  "TZ",
+  "LANG",
+  "LC_ALL",
+  "PLAYWRIGHT_HTML_OPEN"
+]);
+var DockerUnavailableError = class extends Error {
+  constructor() {
+    super("Docker daemon is not available");
+    this.name = "DockerUnavailableError";
+  }
+};
+function defaultWarn(message) {
+  console.warn(`[crvy-rprtr] ${message}`);
+}
+async function detectAgentName(detect2, cwd) {
+  const detected = await (detect2 ?? detectProjectAgent)(cwd);
+  return detected?.name ?? null;
+}
+async function prepareDocker(state, exec, ctx, deps, onProgress) {
+  if (!await probeDockerDaemon(exec)) {
+    state.available = false;
+    throw new DockerUnavailableError();
+  }
+  state.available = true;
+  const image = resolveDockerImage({ image: deps.docker?.image, version: deps.getPlaywrightVersion(ctx.cwd) });
+  if (image === null) {
+    throw new Error("Could not resolve the installed @playwright/test version; set docker.image explicitly.");
+  }
+  state.image = image;
+  state.command = resolveContainerCommand({
+    command: deps.docker?.command,
+    hasCustomImage: deps.docker?.image !== void 0,
+    detectedAgentName: deps.docker?.image === void 0 ? "npm" : await detectAgentName(deps.detectAgent, ctx.cwd),
+    warn: deps.warn
+  });
+  if (!await isDockerImagePresent(exec, image)) {
+    onProgress("pulling");
+    if (!await pullDockerImage(exec, image)) {
+      throw new Error(`Failed to pull docker image: ${image}`);
+    }
+  }
+}
+var REPORTER_BARE_SPECIFIER = "@crvy/rprtr";
+var PATH_FLAGS = /* @__PURE__ */ new Set(["--config", "--reporter", "--test-list"]);
+function rewritePlaywrightArgs(playwrightArgs, ctx, workDir, warn) {
+  const args = [];
+  const bindMounts = [];
+  for (let i = 0; i < playwrightArgs.length; i++) {
+    const flag = playwrightArgs[i];
+    if (!PATH_FLAGS.has(flag)) {
+      args.push(flag);
+      continue;
+    }
+    const value = playwrightArgs[i + 1];
+    if (value === void 0) break;
+    i += 1;
+    args.push(flag);
+    const rewritten = rewriteContainerPath(value, { from: ctx.cwd, to: workDir });
+    if (flag === "--reporter" && rewritten === value) {
+      args.push(REPORTER_BARE_SPECIFIER);
+    } else if (flag === "--test-list" && rewritten === value) {
+      args.push(value);
+      bindMounts.push(`${value}:${value}:ro`);
+    } else {
+      if (flag === "--config" && rewritten === value) {
+        warn(`--config "${value}" is outside the project directory and will not resolve inside the container.`);
+      }
+      args.push(rewritten);
+    }
+  }
+  return { args, bindMounts };
+}
+function buildDockerRunArgs(ctx, playwrightArgs, deps) {
+  const { args: rewrittenArgs, bindMounts } = rewritePlaywrightArgs(playwrightArgs, ctx, deps.workDir, deps.warn);
+  const args = [
+    "run",
+    "--rm",
+    "--init",
+    "--name",
+    deps.containerName,
+    "--add-host",
+    `${DOCKER_HOST_GATEWAY}:host-gateway`,
+    "--ipc=host"
+  ];
+  if (deps.docker?.platform !== void 0) {
+    args.push("--platform", deps.docker.platform);
+  }
+  args.push("-v", `${ctx.cwd}:${deps.workDir}:rw`, "-w", deps.workDir);
+  for (const mount of bindMounts) {
+    args.push("-v", mount);
+  }
+  args.push("-e", `CRVY_RPRTR_SERVER_URL=ws://${DOCKER_HOST_GATEWAY}:${deps.port}`);
+  args.push("-e", "CRVY_RPRTR_PORTABLE_ARTIFACTS=1", "-e", "TZ=UTC", "-e", "LANG=C.UTF-8", "-e", "LC_ALL=C.UTF-8");
+  args.push("-e", "PLAYWRIGHT_HTML_OPEN=never");
+  for (const [key, value] of Object.entries(deps.env)) {
+    if (ENV_DENYLIST.has(key) || value === void 0) continue;
+    args.push("-e", key);
+  }
+  if (deps.docker?.extraArgs !== void 0) args.push(...deps.docker.extraArgs);
+  args.push(deps.image, ...deps.command, "playwright", ...rewrittenArgs);
+  return args;
+}
+function stripCi(env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (key === "CI") continue;
+    out[key] = value;
+  }
+  return out;
+}
+function createState(docker) {
+  return { available: void 0, prepared: null, image: null, command: docker?.command ?? DEFAULT_CONTAINER_COMMAND };
+}
+function buildLauncher(state, deps) {
+  return {
+    mode: "docker",
+    get available() {
+      return state.available;
+    },
+    prepare({ ctx, onProgress }) {
+      state.prepared ??= prepareDocker(
+        state,
+        deps.exec,
+        ctx,
+        {
+          docker: deps.docker,
+          getPlaywrightVersion: deps.getVersion,
+          detectAgent: deps.detectAgent,
+          warn: deps.warn
+        },
+        onProgress
+      ).catch((error) => {
+        state.prepared = null;
+        throw error;
+      });
+      return state.prepared;
+    },
+    launch({ ctx, playwrightArgs }) {
+      const image = state.image ?? resolveDockerImage({ image: deps.docker?.image, version: deps.getVersion(ctx.cwd) });
+      if (image === null) {
+        throw new Error("Could not resolve the docker image; run prepare() first or set docker.image.");
+      }
+      const args = buildDockerRunArgs(ctx, playwrightArgs, {
+        docker: deps.docker,
+        workDir: deps.workDir,
+        containerName: deps.containerName,
+        port: deps.port,
+        env: deps.baseEnv,
+        image,
+        command: state.command,
+        warn: deps.warn
+      });
+      return { cmd: "docker", args, env: stripCi(deps.baseEnv) };
+    },
+    onForceKill() {
+      void forceRemoveContainer(deps.exec, deps.containerName);
+    }
+  };
+}
+function createDockerLauncher(options) {
+  return buildLauncher(createState(options.docker), {
+    exec: options.exec ?? createDockerExec(),
+    workDir: options.workDir ?? DOCKER_WORK_DIR,
+    containerName: options.containerName ?? `crvy-rprtr-run-${process.pid}`,
+    baseEnv: options.env ?? process.env,
+    getVersion: options.getPlaywrightVersion ?? resolvePlaywrightVersion,
+    detectAgent: options.detectAgent,
+    warn: options.warn ?? defaultWarn,
+    docker: options.docker,
+    port: options.port
+  });
+}
+
+// src/server/handlers.ts
+var import_fs2 = require("fs");
+var import_path6 = require("path");
+
+// src/server/artifact-routes.ts
+var import_fs = require("fs");
+var import_promises3 = require("fs/promises");
+var import_path5 = require("path");
+
+// src/snapshot-path-resolver.ts
+var import_crypto = require("crypto");
+var import_path3 = require("path");
+var DEFAULT_SCREENSHOT_TEMPLATE = "{snapshotDir}/{testFileDir}/{testFileName}-snapshots/{arg}{-projectName}{-snapshotSuffix}{ext}";
+var WINDOWS_FILESYSTEM_FRIENDLY_LENGTH = 60;
+function isUnsafeFilePathCharacter(character) {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== void 0 && (codePoint <= 44 || codePoint >= 46 && codePoint <= 47 || codePoint >= 58 && codePoint <= 64 || codePoint >= 91 && codePoint <= 96 || codePoint >= 123 && codePoint <= 127);
+}
+function sanitizeForFilePath(value) {
+  return Array.from(value).reduce(
+    (state, character) => {
+      const unsafeCharacter = isUnsafeFilePathCharacter(character);
+      return unsafeCharacter ? state.previousCharacterWasUnsafe ? state : {
+        value: `${state.value}-`,
+        previousCharacterWasUnsafe: true
+      } : {
+        value: `${state.value}${character}`,
+        previousCharacterWasUnsafe: false
+      };
+    },
+    {
+      value: "",
+      previousCharacterWasUnsafe: false
+    }
+  ).value;
+}
+function trimLongString(value, length = WINDOWS_FILESYSTEM_FRIENDLY_LENGTH) {
+  if (value.length <= length) {
+    return value;
+  }
+  const hash = (0, import_crypto.createHash)("sha1").update(value).digest("hex");
+  const middle = `-${hash.slice(0, 5)}-`;
+  const start = Math.floor((length - middle.length) / 2);
+  const end = length - middle.length - start;
+  return value.slice(0, start) + middle + value.slice(-end);
+}
+function sanitizeFilePathBeforeExtension(filePath, extension = (0, import_path3.extname)(filePath)) {
+  const base = filePath.slice(0, filePath.length - extension.length);
+  return sanitizeForFilePath(base) + extension;
+}
+function addSuffixToFilePath(filePath, suffix) {
+  const extension = (0, import_path3.extname)(filePath);
+  return filePath.slice(0, filePath.length - extension.length) + suffix + extension;
+}
+function normalizedSnapshotDir(config) {
+  return (0, import_path3.resolve)(config.configDir, config.snapshotDir);
+}
+function templateValue(template, token, value) {
+  return template.replace(
+    new RegExp(`\\{(.)?${token}\\}`, "g"),
+    (_, prefix) => value === "" ? "" : `${prefix ?? ""}${value}`
+  );
+}
+function applyTemplate(input, nameArgument, extension) {
+  const template = input.config.toHaveScreenshotPathTemplate ?? input.config.snapshotPathTemplate ?? DEFAULT_SCREENSHOT_TEMPLATE;
+  const relativeTestFilePath = (0, import_path3.relative)(input.config.testDir, input.testFile);
+  const parsed = (0, import_path3.parse)(relativeTestFilePath);
+  const tokens = [
+    ["testDir", input.config.testDir],
+    ["snapshotDir", normalizedSnapshotDir(input.config)],
+    ["snapshotSuffix", input.config.snapshotSuffix],
+    ["testFileDir", parsed.dir],
+    ["platform", process.platform],
+    ["projectName", sanitizeForFilePath(input.config.projectName)],
+    ["testName", ""],
+    ["testFileName", parsed.base],
+    ["testFilePath", relativeTestFilePath],
+    ["arg", nameArgument],
+    ["ext", extension]
+  ];
+  const snapshotPath = tokens.reduce(
+    (currentTemplate, [token, value]) => templateValue(currentTemplate, token, value),
+    template
+  );
+  return (0, import_path3.resolve)(input.config.configDir, snapshotPath);
+}
+function removeExtension(filePath, extension = (0, import_path3.extname)(filePath)) {
+  return filePath.slice(0, filePath.length - extension.length);
+}
+function snapshotNameParts(declaredName) {
+  const extension = (0, import_path3.extname)(declaredName) || ".png";
+  return {
+    extension,
+    filePath: (0, import_path3.extname)(declaredName) === "" ? `${declaredName}${extension}` : declaredName
+  };
+}
+function filePathForOccurrence(filePath, occurrenceIndex) {
+  return occurrenceIndex === 1 ? filePath : addSuffixToFilePath(filePath, `-${occurrenceIndex - 1}`);
+}
+function createResolvedBaselineTarget(input, declaration, nameArgument, extension) {
+  return {
+    visualName: declaration.visualName,
+    attachmentBaseName: declaration.visualName,
+    artifactBaseName: sanitizeForFilePath(declaration.visualName),
+    snapshotPath: applyTemplate(input, nameArgument, extension)
+  };
+}
+function resolveStringCallTarget(input, declaration) {
+  const { extension, filePath } = snapshotNameParts(declaration.declaredName);
+  const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
+  const sanitizedNameWithExtension = sanitizeFilePathBeforeExtension(occurrenceFilePath, extension);
+  const nameArgument = removeExtension(sanitizedNameWithExtension, extension);
+  return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+}
+function resolveArrayCallTarget(input, declaration) {
+  const { extension, filePath } = snapshotNameParts(declaration.declaredName);
+  const occurrenceFilePath = filePathForOccurrence(filePath, declaration.occurrenceIndex);
+  const nameArgument = (0, import_path3.join)((0, import_path3.dirname)(occurrenceFilePath), (0, import_path3.basename)(occurrenceFilePath, extension));
+  return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+}
+function resolveNamedTarget(input, declaration) {
+  if (!declaration.declaredName.includes("/")) {
+    return resolveStringCallTarget(input, declaration);
+  }
+  const stringCallTarget = resolveStringCallTarget(input, declaration);
+  const arrayCallTarget = resolveArrayCallTarget(input, declaration);
+  if (stringCallTarget.snapshotPath === arrayCallTarget.snapshotPath) {
+    return stringCallTarget;
+  }
+  if (input.snapshotPathExists === void 0) {
+    return void 0;
+  }
+  const stringCallTargetExists = input.snapshotPathExists(stringCallTarget.snapshotPath);
+  const arrayCallTargetExists = input.snapshotPathExists(arrayCallTarget.snapshotPath);
+  if (stringCallTargetExists === arrayCallTargetExists) {
+    return void 0;
+  }
+  return stringCallTargetExists ? stringCallTarget : arrayCallTarget;
+}
+function reporterTitlesWithoutProjectAndFile(reporterTitlePath2) {
+  return reporterTitlePath2.slice(3).filter((part) => part !== "");
+}
+function anonymousNameFromTitles(titles, occurrenceIndex) {
+  return sanitizeFilePathBeforeExtension(trimLongString(`${titles.join(" ")} ${occurrenceIndex}.png`), ".png");
+}
+function anonymousName(reporterTitlePath2, occurrenceIndex) {
+  return anonymousNameFromTitles(reporterTitlesWithoutProjectAndFile(reporterTitlePath2), occurrenceIndex);
+}
+function resolveTarget(input, declaration) {
+  switch (declaration.kind) {
+    case "named":
+      return typeof declaration.declaredName === "string" && declaration.declaredName !== "" ? resolveNamedTarget(input, declaration) : void 0;
+    case "unnamed": {
+      const anonymousFileName = anonymousName(input.reporterTitlePath, declaration.occurrenceIndex);
+      const extension = ".png";
+      const nameArgument = (0, import_path3.join)((0, import_path3.dirname)(anonymousFileName), (0, import_path3.basename)(anonymousFileName, extension));
+      return createResolvedBaselineTarget(input, declaration, nameArgument, extension);
+    }
+  }
+}
+function resolveBaselineTargets(input) {
+  return input.declarations.flatMap((declaration) => {
+    const resolvedTarget = resolveTarget(input, declaration);
+    return resolvedTarget === void 0 ? [] : [resolvedTarget];
+  });
+}
+
+// src/server/utils.ts
+var import_path4 = require("path");
+var LIVE_UPDATES_WEBSOCKET_PATH = "/";
+function broadcastToBrowsers(wsClients, msg) {
+  const payload = JSON.stringify(msg);
+  wsClients.forEach((ws) => {
+    ws.send(payload);
+  });
+}
+function isWebSocketUpgradeRequest(req) {
+  return new URL(req.url).pathname === LIVE_UPDATES_WEBSOCKET_PATH && req.headers.get("upgrade")?.toLowerCase() === "websocket";
+}
+function isPathWithinRoots(target, roots) {
+  const resolvedTarget = (0, import_path4.resolve)(target);
+  return roots.some((root) => {
+    const rel = (0, import_path4.relative)((0, import_path4.resolve)(root), resolvedTarget);
+    return rel === "" || !rel.startsWith(`..${import_path4.sep}`) && rel !== ".." && !(0, import_path4.isAbsolute)(rel);
+  });
+}
+
+// src/server/artifact-routes.ts
+async function realpathOrNull(path) {
+  try {
+    return await (0, import_promises3.realpath)(path);
+  } catch {
+    return null;
+  }
+}
+async function handleFile(ctx, req) {
   const notFound = () => new Response("Not Found", { status: 404 });
   let rawDecoded;
   let decodedPath;
@@ -886,11 +1428,14 @@ function reporterTitlePath(test) {
   return ["", projectName, testFile ?? "", ...test.titlePath, test.title];
 }
 function resolveBaselineSnapshotPath(routing, test, retry, imageName) {
-  const testFile = test.location?.file;
+  const mapping = routing?.containerPathMapping;
+  const rawTestFile = test.location?.file;
+  const testFile = rawTestFile === void 0 || mapping === void 0 ? rawTestFile : rewriteContainerPath(rawTestFile, mapping);
   const declaration = test.results?.[retry]?.visualDeclarations?.find((candidate) => candidate.visualName === imageName);
   if (routing === void 0 || testFile === void 0 || declaration === void 0) {
     return null;
   }
+  const isContainerPath = mapping !== void 0 && testFile !== rawTestFile;
   const targets = resolveBaselineTargets({
     testFile,
     reporterTitlePath: reporterTitlePath(test),
@@ -900,7 +1445,7 @@ function resolveBaselineSnapshotPath(routing, test, retry, imageName) {
       testDir: routing.playwrightTestDir ?? (0, import_path5.dirname)(testFile),
       snapshotDir: routing.playwrightSnapshotDir ?? (0, import_path5.dirname)(testFile),
       projectName: test.projectName ?? test.browser,
-      snapshotSuffix: process.platform,
+      snapshotSuffix: isContainerPath ? "linux" : process.platform,
       snapshotPathTemplate: routing.playwrightSnapshotPathTemplate,
       toHaveScreenshotPathTemplate: routing.playwrightToHaveScreenshotPathTemplate
     },
@@ -1023,7 +1568,19 @@ function handleSync(ctx) {
   };
   broadcastToBrowsers(ctx.wsClients, message);
 }
-function handleRegister(ctx, data) {
+function applyContainerPathMapping(rawData, mapping) {
+  return {
+    ...rawData,
+    playwrightSnapshotDir: rawData.playwrightSnapshotDir === void 0 ? void 0 : rewriteContainerPath(rawData.playwrightSnapshotDir, mapping),
+    playwrightTestDir: rawData.playwrightTestDir === void 0 ? void 0 : rewriteContainerPath(rawData.playwrightTestDir, mapping),
+    playwrightRootDir: rawData.playwrightRootDir === void 0 ? void 0 : rewriteContainerPath(rawData.playwrightRootDir, mapping),
+    configFile: rawData.configFile === void 0 ? void 0 : rewriteContainerPath(rawData.configFile, mapping),
+    cwd: rawData.cwd === void 0 ? void 0 : rewriteContainerPath(rawData.cwd, mapping)
+  };
+}
+function handleRegister(ctx, rawData) {
+  const mapping = ctx.routesContext.containerPathMapping;
+  const data = mapping === void 0 ? rawData : applyContainerPathMapping(rawData, mapping);
   const roots = [];
   if (data.playwrightSnapshotDir !== void 0 && data.playwrightSnapshotDir !== "") {
     roots.push(data.playwrightSnapshotDir);
@@ -1053,16 +1610,65 @@ function handleRegister(ctx, data) {
     }
   }
   if (data.configFile !== void 0 && data.cwd !== void 0) {
-    ctx.routesContext.runContext = { configFile: data.configFile, cwd: data.cwd };
+    ctx.routesContext.runContext = buildRunContext(data.configFile, data);
   }
   console.log("[Server] Reporter registered with config:", {
     playwrightSnapshotDir: data.playwrightSnapshotDir,
-    playwrightTestDir: data.playwrightTestDir
+    playwrightTestDir: data.playwrightTestDir,
+    configFile: data.configFile,
+    cwd: data.cwd
+  });
+}
+function buildRunContext(configFile, data) {
+  const configDir = (0, import_path6.dirname)(configFile);
+  return {
+    configFile,
+    cwd: configDir,
+    rootDir: data.playwrightRootDir ?? (data.playwrightTestDir === void 0 ? configDir : (0, import_path6.resolve)(configDir, data.playwrightTestDir))
+  };
+}
+
+// src/ci.ts
+function isCI(env = process.env) {
+  const ci = env.CI;
+  return ci !== void 0 && ci !== "" && ci !== "false" && ci !== "0";
+}
+
+// src/server/run-mode.ts
+async function resolveRunMode(options) {
+  if (options.runMode === "local") return "local";
+  if (options.runMode === "docker") return "docker";
+  if (options.isCI) return "local";
+  if (await options.probeDocker()) return "docker";
+  options.warn?.(
+    "Docker daemon unavailable \u2014 running tests locally; screenshots may differ from CI. Use --run-mode local to silence this warning."
+  );
+  return "local";
+}
+
+// src/server/launcher-resolver.ts
+async function resolveRunBackend(options) {
+  const dockerExec = createDockerExec();
+  const resolvedRunMode = await resolveRunMode({
+    runMode: options.runMode ?? "auto",
+    isCI: isCI(),
+    probeDocker: () => probeDockerDaemon(dockerExec),
+    warn: (message) => {
+      console.warn(`[crvy-rprtr] ${message}`);
+    }
   });
+  const launcher = resolvedRunMode === "docker" ? createDockerLauncher({ port: options.port, docker: options.docker, exec: dockerExec }) : createLocalLauncher({ port: options.port });
+  return {
+    launcher,
+    routesContextOptions: {
+      runInfo: { mode: resolvedRunMode },
+      containerPathMapping: resolvedRunMode === "docker" ? { from: DOCKER_WORK_DIR, to: process.cwd() } : void 0
+    }
+  };
 }
 
 // src/server/playwright-config.ts
-var import_path6 = require("path");
+var import_path7 = require("path");
 var CONFIG_FILES = [
   "playwright.config.ts",
   "playwright.config.mts",
@@ -1074,12 +1680,15 @@ var CONFIG_FILES = [
 async function resolvePlaywrightConfig(cwd) {
   const matches = await Promise.all(
     CONFIG_FILES.map(async (file) => {
-      const candidate = (0, import_path6.join)(cwd, file);
+      const candidate = (0, import_path7.join)(cwd, file);
       return await fileExists(candidate) ? candidate : null;
     })
   );
   return matches.find((path) => path !== null) ?? null;
 }
+function resolveSeedConfigFile(option, cwd) {
+  return option === void 0 ? resolvePlaywrightConfig(cwd) : Promise.resolve((0, import_path7.resolve)(cwd, option));
+}
 
 // src/server/report-persistence.ts
 function createDebouncedSaver(save, delayMs, setTimeoutFn = (fn, ms) => setTimeout(fn, ms), clearTimeoutFn = (handle) => {
@@ -1151,14 +1760,17 @@ function createRoutesContext(reportData, staticDir, saveReport, options) {
       playwrightTestDir: options.playwrightTestDir,
       playwrightSnapshotDir: options.playwrightSnapshotDir,
       playwrightSnapshotPathTemplate: options.playwrightSnapshotPathTemplate,
-      playwrightToHaveScreenshotPathTemplate: options.playwrightToHaveScreenshotPathTemplate
+      playwrightToHaveScreenshotPathTemplate: options.playwrightToHaveScreenshotPathTemplate,
+      containerPathMapping: options.containerPathMapping
     },
-    runContext: void 0
+    runContext: void 0,
+    runInfo: options.runInfo,
+    containerPathMapping: options.containerPathMapping
   };
 }
 
 // src/server/routes.ts
-var import_path7 = require("path");
+var import_path8 = require("path");
 
 // src/server/run-routes.ts
 function handleRunRoutes(pathname, method, runController, req) {
@@ -1180,6 +1792,10 @@ async function handleApiRun(runController, req) {
   if (parsed === null) {
     return Response.json({ ok: false, error: "Invalid request body" }, { status: 400 });
   }
+  const preparation = await runController.prepareRun();
+  if (!preparation.ok) {
+    return Response.json({ ok: false, reason: preparation.reason }, { status: 409 });
+  }
   const result = runController.start(parsed);
   if (result.ok) return Response.json(result);
   const status = result.reason === "no-tests" ? 400 : 409;
@@ -1193,7 +1809,7 @@ function handleApiStop(runController) {
 
 // src/server/routes.ts
 async function handleRoot(ctx) {
-  const html = await respondWithFile((0, import_path7.join)(ctx.staticDir, "index.html"), "text/html");
+  const html = await respondWithFile((0, import_path8.join)(ctx.staticDir, "index.html"), "text/html");
   return html ?? new Response("Not Found", { status: 404 });
 }
 async function handleAppCss() {
@@ -1210,13 +1826,14 @@ async function handleSrcFiles(req) {
 function handleApiReport(ctx) {
   return Response.json({
     ...ctx.reportData,
-    runEnabled: ctx.runContext !== void 0
+    runEnabled: ctx.runContext !== void 0,
+    runMode: ctx.runInfo?.mode
   });
 }
 var APPROVAL_TARGET_ERROR = "Could not resolve approval target";
 function actualPathFromUrl(ctx, actualUrl) {
   if (actualUrl.startsWith("/screenshots/")) {
-    return (0, import_path7.join)(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
+    return (0, import_path8.join)(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
   }
   if (actualUrl.startsWith("/file/")) {
     return decodeURIComponent(actualUrl.slice("/file/".length));
@@ -1338,7 +1955,7 @@ async function handleScreenshots(ctx, req) {
 }
 async function handleDist(ctx, req) {
   const path = new URL(req.url).pathname.slice("/dist/".length);
-  const filePath = (0, import_path7.join)(ctx.staticDir, path);
+  const filePath = (0, import_path8.join)(ctx.staticDir, path);
   const contentType = filePath.endsWith(".css") ? "text/css" : filePath.endsWith(".js") ? "application/javascript" : filePath.endsWith(".svelte") ? "text/plain" : "application/octet-stream";
   const file = await respondWithFile(filePath, contentType);
   return file ?? new Response("Not Found", { status: 404 });
@@ -1383,217 +2000,56 @@ function handleHttpRequest(ctx, req, runController) {
   return Promise.resolve(new Response("Not Found", { status: 404 }));
 }
 
-// src/server/run-controller.ts
-var import_child_process = require("child_process");
-var import_node_fs = require("node:fs");
-var import_node_module = require("node:module");
-var import_node_os = require("node:os");
-var import_node_path = require("node:path");
-var import_commands = require("package-manager-detector/commands");
-var import_detect = require("package-manager-detector/detect");
-var import_meta = { url: require("url").pathToFileURL(__filename).href };
-var STOP_GRACE_MS = 5e3;
-var KNOWN_SIGNALS = {
-  SIGTERM: "SIGTERM",
-  SIGKILL: "SIGKILL"
-};
-function resolvePlaywrightLaunch(cwd, playwrightArgs) {
-  const agent = (0, import_detect.getUserAgent)();
-  const resolved = agent === null ? null : (0, import_commands.resolveCommand)(agent, "execute-local", ["playwright", ...playwrightArgs]);
-  if (resolved !== null) return { cmd: resolved.command, args: resolved.args };
-  return { cmd: "npx", args: ["playwright", ...playwrightArgs] };
-}
-function descriptorLocation(d) {
-  return d.column === void 0 ? `${d.file}:${d.line}` : `${d.file}:${d.line}:${d.column}`;
-}
-function sharedProject(tests) {
-  const names = new Set(tests.map((t) => t.projectName ?? ""));
-  if (names.size === 1) {
-    const name = [...names][0];
-    return name === "" ? void 0 : name;
-  }
-  return void 0;
-}
-function gteMinor(version, major, minor) {
-  const match = /^(\d+)\.(\d+)/.exec(version.trim());
-  if (match === null) return false;
-  const maj = parseInt(match[1], 10);
-  const min = parseInt(match[2], 10);
-  if (maj !== major) return maj > major;
-  return min >= minor;
-}
-function resolvePlaywrightVersion(cwd) {
-  try {
-    const req = (0, import_node_module.createRequire)((0, import_node_path.join)(cwd, "package.json"));
-    const pkgPath = req.resolve("@playwright/test/package.json");
-    const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf8"));
-    return typeof pkg === "object" && pkg !== null && "version" in pkg && typeof pkg.version === "string" ? pkg.version : null;
-  } catch {
-    return null;
-  }
-}
-function buildTestListEntries(tests) {
-  return tests.map((d) => {
-    const loc = descriptorLocation(d);
-    const title = d.titlePath.join(" \u203A ");
-    const prefix = d.projectName !== void 0 && d.projectName !== "" ? `[${d.projectName}] \u203A ` : "";
-    return `${prefix}${loc} \u203A ${title}`;
+// src/server/server-factories.ts
+function createServerRunController(routesContext, wsClients, reportData, port, setRunFiltered, saveReport, launcher) {
+  return new RunController({
+    getRunContext: () => routesContext.runContext ?? null,
+    port,
+    broadcast: (message) => {
+      broadcastToBrowsers(wsClients, message);
+    },
+    setReportRunning: (running) => {
+      reportData.isRunning = running;
+    },
+    setRunFiltered,
+    containerPathMapping: routesContext.containerPathMapping,
+    saveReport,
+    spawn: createRealSpawn(),
+    timers: createRealTimers(),
+    launcher
   });
 }
-function defaultWriteTempFile(content) {
-  const path = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `crvy-rprtr-test-list-${process.pid}-${Date.now()}.txt`);
-  (0, import_node_fs.writeFileSync)(path, content, "utf8");
-  return path;
-}
-function defaultDeleteTempFile(path) {
-  try {
-    (0, import_node_fs.unlinkSync)(path);
-  } catch {
-  }
-}
-function resolveReporterDefault(cwd) {
-  try {
-    return (0, import_node_module.createRequire)((0, import_node_path.join)(cwd, "package.json")).resolve("@crvy/rprtr");
-  } catch {
-  }
-  try {
-    return (0, import_node_module.createRequire)(import_meta.url).resolve("@crvy/rprtr");
-  } catch {
-    return null;
-  }
-}
-function buildSpawnEnv(port) {
-  const env = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (key === "CI") continue;
-    env[key] = value;
-  }
-  env.CRVY_RPRTR_SERVER_URL = `ws://localhost:${port}`;
-  env.PLAYWRIGHT_HTML_OPEN = "never";
-  return env;
-}
-var RunController = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  child = null;
-  sigkillTimer = null;
-  testListPath = null;
-  get isRunning() {
-    return this.child !== null;
-  }
-  supportsTestList(cwd) {
-    const getVersion = this.deps.getPlaywrightVersion ?? resolvePlaywrightVersion;
-    const version = getVersion(cwd);
-    return version !== null && gteMinor(version, 1, 56);
-  }
-  cleanupTempFile() {
-    if (this.testListPath !== null) {
-      const del = this.deps.deleteTempFile ?? defaultDeleteTempFile;
-      del(this.testListPath);
-      this.testListPath = null;
-    }
-  }
-  start(filters) {
-    const ctx = this.deps.getRunContext();
-    if (ctx === null) return { ok: false, reason: "no-config" };
-    if (this.child !== null) return { ok: false, reason: "already-running" };
-    if (filters.tests !== void 0 && filters.tests.length === 0) {
-      return { ok: false, reason: "no-tests" };
-    }
-    const resolveReporter = this.deps.resolveReporter ?? resolveReporterDefault;
-    const reporterModule = resolveReporter(ctx.cwd);
-    const tests = filters.tests;
-    const useTestList = tests !== void 0 && tests.length > 1 && this.supportsTestList(ctx.cwd);
-    const args = ["test", "--config", ctx.configFile];
-    if (reporterModule !== null) args.push("--reporter", reporterModule);
-    if (useTestList && tests !== void 0) {
-      const content = buildTestListEntries(tests).join("\n");
-      const writeTemp = this.deps.writeTempFile ?? defaultWriteTempFile;
-      this.testListPath = writeTemp(content);
-      args.push("--test-list", this.testListPath);
-    } else if (tests !== void 0 && tests.length > 0) {
-      const project = sharedProject(tests);
-      if (project !== void 0) args.push("--project", project);
-      for (const d of tests) args.push(descriptorLocation(d));
-    }
-    const resolveLaunch = this.deps.resolveLaunch ?? resolvePlaywrightLaunch;
-    const { cmd, args: launchArgs } = resolveLaunch(ctx.cwd, args);
-    let child;
-    try {
-      child = this.deps.spawn(cmd, launchArgs, { cwd: ctx.cwd, env: buildSpawnEnv(this.deps.port), stdio: "inherit" });
-    } catch (err) {
-      this.cleanupTempFile();
-      throw err;
-    }
-    this.child = child;
-    child.on("exit", (code) => {
-      this.handleChildExit(code);
-    });
-    child.on("error", () => {
-      this.handleChildExit(null);
-    });
-    this.deps.setReportRunning(true);
-    this.deps.setRunFiltered?.(filters.tests !== void 0);
-    this.deps.broadcast({ type: "run-status", data: { running: true } });
-    return { ok: true };
-  }
-  stop() {
-    if (this.child === null) return { ok: false, reason: "not-running" };
-    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
-    this.child.kill("SIGTERM");
-    this.sigkillTimer = this.deps.timers.setTimeout(() => {
-      if (this.child !== null) this.child.kill("SIGKILL");
-    }, STOP_GRACE_MS);
-    return { ok: true };
-  }
-  dispose() {
-    if (this.child === null) return;
-    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
-    this.sigkillTimer = null;
-    this.child.kill("SIGKILL");
-    this.cleanupTempFile();
-  }
-  handleChildExit(code) {
-    if (this.child === null) return;
-    if (this.sigkillTimer !== null) {
-      this.deps.timers.clearTimeout(this.sigkillTimer);
-      this.sigkillTimer = null;
-    }
-    this.child = null;
-    this.cleanupTempFile();
-    if (code !== null && code !== 0) {
-      console.warn(`[RunController] playwright test exited with code ${code}`);
-    }
-    this.deps.setReportRunning(false);
-    this.deps.broadcast({ type: "run-status", data: { running: false } });
-    void this.deps.saveReport?.();
-  }
-};
-function createRealSpawn() {
-  return (cmd, args, opts) => {
-    const cp = (0, import_child_process.spawn)(cmd, args, opts);
-    return {
-      on: (event, cb) => cp.on(event, cb),
-      kill: (signal) => {
-        const sig = KNOWN_SIGNALS[signal];
-        if (sig !== void 0) cp.kill(sig);
-      }
-    };
+function createCloseHandler(persistence, runController) {
+  return async () => {
+    await persistence.dispose();
+    runController.dispose();
   };
 }
-function createRealTimers() {
-  const pending = [];
-  return {
-    setTimeout: (fn, ms) => {
-      const id = setTimeout(fn, ms);
-      pending.push(id);
-      return id;
+function createRunControllerAndHandlers(routesContext, wsClients, reportData, currentRunIds, port, persistence, launcher) {
+  let isFilteredRun = false;
+  const runController = createServerRunController(
+    routesContext,
+    wsClients,
+    reportData,
+    port,
+    (filtered) => {
+      isFilteredRun = filtered;
     },
-    clearTimeout: () => {
-      for (const h of pending.splice(0)) clearTimeout(h);
-    }
-  };
+    persistence.saveReport,
+    launcher
+  );
+  const getHandlerContext = () => ({
+    reportData,
+    wsClients,
+    currentRunIds,
+    isFilteredRun,
+    saveReport: persistence.saveReport,
+    scheduleReportSave: persistence.scheduleReportSave,
+    approvalRouting: routesContext.approvalRouting,
+    routesContext,
+    runController
+  });
+  return { runController, getHandlerContext };
 }
 
 // src/server/app.ts
@@ -1686,19 +2142,19 @@ function createWebSocketMessageHandler(getHandlerContext) {
   };
 }
 async function resolveStaticDir(staticDir) {
-  const currentDir = (0, import_path8.dirname)((0, import_url.fileURLToPath)(import_meta2.url));
+  const currentDir = (0, import_path9.dirname)((0, import_url.fileURLToPath)(import_meta2.url));
   const candidates = staticDir === void 0 ? [
     currentDir,
-    (0, import_path8.join)(currentDir, "dist"),
-    (0, import_path8.join)(currentDir, "..", "dist"),
-    (0, import_path8.join)(currentDir, "..", "..", "dist"),
-    (0, import_path8.join)(currentDir, ".."),
-    (0, import_path8.join)(currentDir, "..", "..")
-  ] : [staticDir, (0, import_path8.join)(staticDir, "dist")];
+    (0, import_path9.join)(currentDir, "dist"),
+    (0, import_path9.join)(currentDir, "..", "dist"),
+    (0, import_path9.join)(currentDir, "..", "..", "dist"),
+    (0, import_path9.join)(currentDir, ".."),
+    (0, import_path9.join)(currentDir, "..", "..")
+  ] : [staticDir, (0, import_path9.join)(staticDir, "dist")];
   const resolvedCandidates = await Promise.all(
     candidates.map(async (candidate) => ({
       candidate,
-      exists: await fileExists((0, import_path8.join)(candidate, "index.html"))
+      exists: await fileExists((0, import_path9.join)(candidate, "index.html"))
     }))
   );
   const resolved = resolvedCandidates.find(({ exists }) => exists);
@@ -1709,34 +2165,31 @@ async function resolveStaticDir(staticDir) {
 }
 async function resolveReportPath(reportPath) {
   if (await isDirectory(reportPath)) {
-    return { reportFile: (0, import_path8.join)(reportPath, "report.json"), offlineReportDir: reportPath };
+    return { reportFile: (0, import_path9.join)(reportPath, "report.json"), offlineReportDir: reportPath };
   }
-  return { reportFile: reportPath, offlineReportDir: (0, import_path8.dirname)(reportPath) };
+  return { reportFile: reportPath, offlineReportDir: (0, import_path9.dirname)(reportPath) };
 }
 async function seedRunContext(routesContext, options) {
   if (routesContext.runContext !== void 0) {
     return;
   }
-  const configFile = options.playwrightConfig ?? await resolvePlaywrightConfig(process.cwd());
+  const configFile = await resolveSeedConfigFile(options.playwrightConfig, process.cwd());
   if (configFile !== null) {
     routesContext.runContext = { configFile, cwd: process.cwd() };
   }
 }
-function createServerRunController(routesContext, wsClients, reportData, port, setRunFiltered, saveReport) {
-  return new RunController({
-    getRunContext: () => routesContext.runContext ?? null,
-    port,
-    broadcast: (message) => {
-      broadcastToBrowsers(wsClients, message);
-    },
-    setReportRunning: (running) => {
-      reportData.isRunning = running;
-    },
-    setRunFiltered,
-    saveReport,
-    spawn: createRealSpawn(),
-    timers: createRealTimers()
+async function setupRoutesContext(options, reportData, staticDir, saveReport, port) {
+  const { launcher, routesContextOptions } = await resolveRunBackend({
+    runMode: options.runMode,
+    docker: options.docker,
+    port
+  });
+  const routesContext = createRoutesContext(reportData, staticDir, saveReport, {
+    ...options,
+    ...routesContextOptions
   });
+  await seedRunContext(routesContext, options);
+  return { routesContext, launcher };
 }
 async function createServerApp(options = {}) {
   const port = options.port ?? 3e3;
@@ -1747,30 +2200,22 @@ async function createServerApp(options = {}) {
   const wsClients = /* @__PURE__ */ new Set();
   const currentRunIds = /* @__PURE__ */ new Set();
   const persistence = createReportPersistence(reportFile, reportData);
-  const routesContext = createRoutesContext(reportData, staticDir, persistence.saveReport, options);
-  await seedRunContext(routesContext, options);
-  let isFilteredRun = false;
-  const runController = createServerRunController(
+  const { routesContext, launcher } = await setupRoutesContext(
+    options,
+    reportData,
+    staticDir,
+    persistence.saveReport,
+    port
+  );
+  const { runController, getHandlerContext } = createRunControllerAndHandlers(
     routesContext,
     wsClients,
     reportData,
+    currentRunIds,
     port,
-    (filtered) => {
-      isFilteredRun = filtered;
-    },
-    persistence.saveReport
+    persistence,
+    launcher
   );
-  const getHandlerContext = () => ({
-    reportData,
-    wsClients,
-    currentRunIds,
-    isFilteredRun,
-    saveReport: persistence.saveReport,
-    scheduleReportSave: persistence.scheduleReportSave,
-    approvalRouting: routesContext.approvalRouting,
-    routesContext,
-    runController
-  });
   const handleRequest = (req) => handleHttpRequest(routesContext, req, runController);
   const handleWebSocketMessage = createWebSocketMessageHandler(getHandlerContext);
   await loadReport(reportFile, reportData);
@@ -1783,12 +2228,6 @@ async function createServerApp(options = {}) {
     handleWebSocketMessage
   };
 }
-function createCloseHandler(persistence, runController) {
-  return async () => {
-    await persistence.dispose();
-    runController.dispose();
-  };
-}
 
 // src/server/bun-adapter.ts
 function logWebSocketError(prefix, error) {
@@ -1965,7 +2404,7 @@ function attachWebSocketServer(server, app) {
   });
 }
 async function listen(server, port) {
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve6, reject) => {
     const onError = (error) => {
       server.off("error", onError);
       reject(error);
@@ -1973,7 +2412,7 @@ async function listen(server, port) {
     server.on("error", onError);
     server.listen(port, () => {
       server.off("error", onError);
-      resolve4();
+      resolve6();
     });
   });
 }