@loucompanion/forge-bridge 0.1.3-dev.9d8f2e7e5241 → 0.1.3-dev.a58d7cd1092f

package/dist/runtime/node-host-runtime-adapter.js

@@ -0,0 +1,284 @@
+import path from "node:path";
+import { withAspNetPrebuiltRunArguments } from "./aspnet-runtime-prebuild.js";
+import { hostPortEnvironment, } from "./host-runtime-contract.js";
+/**
+ * Launches an explicitly configured HTTP project command beneath the caller's
+ * attempt supervisor. It never shells a command and never promotes a project
+ * by framework detection alone.
+ */
+export class NodeHostRuntimeAdapter {
+    broker;
+    readinessTimeoutMs;
+    hardReadinessTimeoutMs;
+    readinessPollIntervalMs;
+    httpProbeTimeoutMs;
+    probeHttp;
+    constructor(broker, options = {}) {
+        this.broker = broker;
+        this.readinessTimeoutMs = boundedInteger(options.readinessTimeoutMs ?? 120_000, 100, 120_000, "readinessTimeoutMs");
+        this.hardReadinessTimeoutMs = boundedInteger(options.hardReadinessTimeoutMs ?? 600_000, this.readinessTimeoutMs, 900_000, "hardReadinessTimeoutMs");
+        this.readinessPollIntervalMs = boundedInteger(options.readinessPollIntervalMs ?? 100, 10, 5_000, "readinessPollIntervalMs");
+        this.httpProbeTimeoutMs = boundedInteger(options.httpProbeTimeoutMs ?? 1_000, 50, 10_000, "httpProbeTimeoutMs");
+        this.probeHttp = options.probeHttp ?? probeHttpReadiness;
+    }
+    async launch(owner, portConfig, command, launcher, signal) {
+        const framework = portConfig.adapter;
+        if (framework !== "node" && framework !== "vite" && framework !== "next" && framework !== "aspnetcore") {
+            throw new Error("node_runtime_adapter_invalid: port config must explicitly select node, vite, next, or aspnetcore.");
+        }
+        validateCommand(command);
+        if (!portConfig.baseUrlEnv || !portConfig.format) {
+            throw new Error("node_runtime_adapter_invalid: an HTTP baseUrlEnv and loopback format are required.");
+        }
+        let activeRequest = null;
+        const launched = await this.broker.launchWithRetry(owner, {
+            name: portConfig.name,
+            protocol: "tcp",
+        }, {
+            launch: async (port, launchSignal) => {
+                const request = buildNodeRuntimeLaunchRequest(framework, portConfig, command, port);
+                activeRequest = request;
+                return await launcher.launch(request, launchSignal);
+            },
+            verifyOwnership: async (value, _port, verifySignal) => {
+                if (!activeRequest)
+                    throw new Error("node_runtime_adapter_state: launch request was not recorded.");
+                return await this.waitUntilReady(value, activeRequest, launcher, verifySignal);
+            },
+            stop: launcher.stop,
+        }, signal);
+        if (!activeRequest)
+            throw new Error("node_runtime_adapter_state: active launch request is missing.");
+        return { ...launched, request: activeRequest };
+    }
+    async waitUntilReady(value, request, launcher, signal) {
+        const startedAt = Date.now();
+        const hardDeadline = startedAt + this.hardReadinessTimeoutMs;
+        let idleDeadline = startedAt + this.readinessTimeoutMs;
+        let outputRevision = -1;
+        let observedOwnership = "unbound";
+        while (Date.now() <= idleDeadline && Date.now() <= hardDeadline) {
+            if (signal?.aborted)
+                throw cancellationError(signal);
+            const diagnostics = await launcher.readinessDiagnostics?.(value);
+            if (diagnostics?.exited) {
+                throw new Error(readinessFailure("host_runtime_process_exited", `the supervised process exited with code ${diagnostics.exitCode ?? "unknown"} before its assigned runtime became ready`, request, diagnostics));
+            }
+            if (diagnostics?.outputRevision !== undefined && diagnostics.outputRevision > outputRevision) {
+                outputRevision = diagnostics.outputRevision;
+                idleDeadline = Math.min(hardDeadline, Date.now() + this.readinessTimeoutMs);
+            }
+            const ownership = await launcher.inspectListener(value, request, signal);
+            observedOwnership = ownership;
+            if (ownership === "foreign")
+                return false;
+            if (ownership === "owned" && await this.probeHttp(request.baseUrl, this.httpProbeTimeoutMs, signal)) {
+                return true;
+            }
+            await wait(this.readinessPollIntervalMs, signal);
+        }
+        const diagnostics = await launcher.readinessDiagnostics?.(value);
+        if (diagnostics?.exited) {
+            throw new Error(readinessFailure("host_runtime_process_exited", `the supervised process exited with code ${diagnostics.exitCode ?? "unknown"} before its assigned runtime became ready`, request, diagnostics));
+        }
+        const code = observedOwnership === "owned"
+            ? "host_runtime_http_readiness_timeout"
+            : "host_runtime_listener_timeout";
+        const reachedHardDeadline = Date.now() >= hardDeadline;
+        const detail = observedOwnership === "owned"
+            ? reachedHardDeadline
+                ? `the supervised process owned its assigned loopback port but HTTP readiness did not succeed within the ${this.hardReadinessTimeoutMs}ms hard limit`
+                : `the supervised process owned its assigned loopback port but made no readiness progress for ${this.readinessTimeoutMs}ms`
+            : reachedHardDeadline
+                ? `the supervised process did not bind its assigned loopback port within the ${this.hardReadinessTimeoutMs}ms hard limit`
+                : `the supervised process did not bind its assigned loopback port and made no output progress for ${this.readinessTimeoutMs}ms`;
+        throw new Error(readinessFailure(code, detail, request, diagnostics));
+    }
+}
+function readinessFailure(code, detail, request, diagnostics) {
+    const evidence = [
+        boundedDiagnostic("stderr", diagnostics?.stderrTail),
+        boundedDiagnostic("stdout", diagnostics?.stdoutTail),
+    ].filter((value) => value !== null);
+    return `${code}: ${detail} (${request.baseUrl}).${evidence.length > 0 ? ` ${evidence.join(" ")}` : ""}`;
+}
+function boundedDiagnostic(label, value) {
+    const normalized = value?.replaceAll(/\s+/gu, " ").trim();
+    if (!normalized)
+        return null;
+    return `${label} tail: ${normalized.slice(-2_000)}`;
+}
+export function buildNodeRuntimeLaunchRequest(framework, portConfig, command, port) {
+    validateCommand(command);
+    if (port.hostIp !== "127.0.0.1" || port.protocol !== "tcp") {
+        throw new Error("node_runtime_adapter_invalid: project adapters require a TCP IPv4 loopback reservation.");
+    }
+    if (!portConfig.baseUrlEnv || !portConfig.format) {
+        throw new Error("node_runtime_adapter_invalid: an HTTP baseUrlEnv and loopback format are required.");
+    }
+    rejectConflictingFrameworkArguments(framework, command.args);
+    const portEnvironment = hostPortEnvironment(portConfig, port.hostIp, port.hostPort);
+    const baseUrl = portEnvironment[portConfig.baseUrlEnv];
+    if (!baseUrl)
+        throw new Error("node_runtime_adapter_invalid: base URL environment could not be rendered.");
+    const args = framework === "aspnetcore"
+        ? aspNetCoreArguments(command.command, command.args)
+        : [...command.args, ...frameworkArguments(framework, port.hostIp, port.hostPort)];
+    const adapterEnvironment = framework === "aspnetcore"
+        ? {
+            ASPNETCORE_URLS: baseUrl,
+            Hosting__Port: String(port.hostPort),
+            Harness__Reconciler__Hosted: "false",
+            Projects__RuntimeReadiness__Hosted: "false",
+            Runners__ServerLocalHeartbeat__Hosted: "false",
+            FORGE_RUNTIME_MODE: "host",
+            FORGE_DISPATCH_ATTEMPT_ID: port.dispatchAttemptId,
+            DOTNET_CLI_USE_MSBUILD_SERVER: "0",
+            DOTNET_NOLOGO: "1",
+        }
+        : { HOST: port.hostIp };
+    const forgeEnvironment = {
+        FORGE_RUNTIME_PORT_NAME: portConfig.name,
+        FORGE_RUNTIME_PORT: String(port.hostPort),
+        FORGE_RUNTIME_BASE_URL: baseUrl,
+    };
+    const expansionScope = {
+        ...command.environment,
+        ...portEnvironment,
+        ...adapterEnvironment,
+        ...forgeEnvironment,
+    };
+    return {
+        framework,
+        command: command.command,
+        args,
+        cwd: path.resolve(command.cwd),
+        environment: {
+            ...expandCommandEnvironment(command.environment, expansionScope),
+            ...portEnvironment,
+            ...adapterEnvironment,
+            ...forgeEnvironment,
+        },
+        port,
+        baseUrl,
+    };
+}
+function expandCommandEnvironment(environment, scope) {
+    return Object.fromEntries(Object.entries(environment ?? {}).map(([name, value]) => [
+        name,
+        value.replaceAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/gu, (_match, variable) => {
+            const resolved = scope[variable];
+            if (!resolved) {
+                throw new Error(`node_runtime_adapter_invalid: launch environment references unavailable variable '${variable}'.`);
+            }
+            return resolved;
+        }),
+    ]));
+}
+function frameworkArguments(framework, hostIp, hostPort) {
+    if (framework === "vite")
+        return ["--host", hostIp, "--port", String(hostPort), "--strictPort"];
+    if (framework === "next")
+        return ["--hostname", hostIp, "--port", String(hostPort)];
+    return [];
+}
+function rejectConflictingFrameworkArguments(framework, args) {
+    if (framework === "aspnetcore") {
+        const forbidden = new Set(["--urls", "--launch-profile", "-lp", "--no-launch-profile"]);
+        const conflict = args.find(argument => forbidden.has(argument)
+            || [...forbidden].some(flag => argument.startsWith(`${flag}=`)));
+        if (conflict) {
+            throw new Error(`node_runtime_adapter_invalid: command already supplies Forge-owned argument '${conflict}'.`);
+        }
+        return;
+    }
+    if (framework === "node")
+        return;
+    const forbidden = framework === "vite"
+        ? new Set(["--host", "--port", "--strictPort"])
+        : new Set(["--hostname", "--port", "-H", "-p"]);
+    const conflict = args.find(argument => forbidden.has(argument) || [...forbidden].some(flag => argument.startsWith(`${flag}=`)));
+    if (conflict) {
+        throw new Error(`node_runtime_adapter_invalid: command already supplies Forge-owned argument '${conflict}'.`);
+    }
+}
+function aspNetCoreArguments(command, args) {
+    const executable = path.basename(command).toLowerCase();
+    if (executable !== "dotnet" && executable !== "dotnet.exe") {
+        throw new Error("node_runtime_adapter_invalid: aspnetcore adapter requires the dotnet executable.");
+    }
+    if (args[0]?.toLowerCase() !== "run") {
+        throw new Error("node_runtime_adapter_invalid: aspnetcore adapter requires a dotnet run command.");
+    }
+    const prebuiltArgs = withAspNetPrebuiltRunArguments(command, args);
+    const applicationArguments = prebuiltArgs.indexOf("--");
+    const insertionIndex = applicationArguments < 0 ? prebuiltArgs.length : applicationArguments;
+    return [
+        ...prebuiltArgs.slice(0, insertionIndex),
+        "--disable-build-servers",
+        "-p:UseSharedCompilation=false",
+        "-p:DefaultItemExcludesInProjectFolder=TestResults/**",
+        "--no-launch-profile",
+        ...prebuiltArgs.slice(insertionIndex),
+    ];
+}
+function validateCommand(command) {
+    if (!boundedText(command.command, 1024)
+        || !path.isAbsolute(command.cwd)
+        || command.args.length > 128
+        || command.args.some(argument => !boundedText(argument, 4096))) {
+        throw new Error("node_runtime_adapter_invalid: command, arguments, or absolute working directory are invalid.");
+    }
+    for (const [name, value] of Object.entries(command.environment ?? {})) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]{0,127}$/u.test(name) || !boundedText(value, 8192)) {
+            throw new Error("node_runtime_adapter_invalid: command environment is invalid.");
+        }
+    }
+}
+async function probeHttpReadiness(url, timeoutMs, signal) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+    try {
+        const response = await fetch(url, { redirect: "manual", signal: combined });
+        await response.body?.cancel().catch(() => undefined);
+        return true;
+    }
+    catch (_error) {
+        if (signal?.aborted)
+            throw cancellationError(signal);
+        return false;
+    }
+}
+function wait(milliseconds, signal) {
+    if (signal?.aborted)
+        return Promise.reject(cancellationError(signal));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }, milliseconds);
+        const abort = () => {
+            clearTimeout(timer);
+            reject(cancellationError(signal));
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+function boundedInteger(value, minimum, maximum, name) {
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+        throw new Error(`node_runtime_adapter_invalid: ${name} must be between ${minimum} and ${maximum}.`);
+    }
+    return value;
+}
+function boundedText(value, maximumLength) {
+    return typeof value === "string"
+        && value.length > 0
+        && value.length <= maximumLength
+        && Array.from(value).every(character => {
+            const codePoint = character.codePointAt(0) ?? 0;
+            return codePoint > 31 && codePoint !== 127;
+        });
+}
+function cancellationError(signal) {
+    return new Error(String(signal?.reason ?? "Node runtime launch cancelled."));
+}

package/dist/runtime/playwright-host-runtime-adapter.d.ts

@@ -0,0 +1,21 @@
+import type { HostRuntimePlaywrightConfig } from "./host-runtime-contract.js";
+export interface PlaywrightHostRuntimeContext {
+    readonly worktreePath: string;
+    readonly temporaryDirectory: string;
+    readonly testOutputDirectory: string;
+    readonly browserProfileDirectory: string;
+    readonly baseUrl: string;
+    readonly ownershipToken: string;
+}
+export interface PreparedPlaywrightHostRuntime {
+    readonly configPath: string;
+    readonly environment: Readonly<Record<string, string>>;
+}
+/**
+ * Prepares a finite Playwright test boundary for a managed-host attempt.
+ * The generated overlay points tests at Forge's verified listener, disables
+ * Playwright-managed web servers, and keeps writable artifacts attempt-local.
+ */
+export declare class PlaywrightHostRuntimeAdapter {
+    prepare(config: HostRuntimePlaywrightConfig, context: PlaywrightHostRuntimeContext): Promise<PreparedPlaywrightHostRuntime>;
+}

package/dist/runtime/playwright-host-runtime-adapter.js

@@ -0,0 +1,231 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const maximumConfigBytes = 1024 * 1024;
+/**
+ * Prepares a finite Playwright test boundary for a managed-host attempt.
+ * The generated overlay points tests at Forge's verified listener, disables
+ * Playwright-managed web servers, and keeps writable artifacts attempt-local.
+ */
+export class PlaywrightHostRuntimeAdapter {
+    async prepare(config, context) {
+        const worktreePath = path.resolve(context.worktreePath);
+        const sourceConfig = path.resolve(worktreePath, config.config);
+        const [realWorktree, realSource] = await Promise.all([
+            fs.realpath(worktreePath),
+            fs.realpath(sourceConfig),
+        ]);
+        assertContained(realWorktree, realSource, "project Playwright config");
+        const sourceStat = await fs.stat(realSource);
+        if (!sourceStat.isFile() || sourceStat.size < 1 || sourceStat.size > maximumConfigBytes) {
+            throw new Error(`playwright_runtime_adapter_invalid: project config must be a regular 1-${maximumConfigBytes} byte file.`);
+        }
+        const sourceConfigText = await fs.readFile(realSource, "utf8");
+        const projectNames = [...sourceConfigText.matchAll(/\bname\s*:\s*["']([^"']+)["']/gu)]
+            .map(match => match[1])
+            .filter((name, index, names) => names.indexOf(name) === index);
+        const temporaryDirectory = await realContainedDirectory(context.temporaryDirectory, realWorktree, "temporary directory");
+        const testOutputDirectory = await realContainedDirectory(context.testOutputDirectory, realWorktree, "test output directory");
+        const browserProfileDirectory = await realContainedDirectory(context.browserProfileDirectory, realWorktree, "browser profile directory");
+        const attemptRoot = path.dirname(temporaryDirectory);
+        if (path.dirname(testOutputDirectory) !== attemptRoot || path.dirname(browserProfileDirectory) !== attemptRoot) {
+            throw new Error("playwright_runtime_adapter_invalid: writable directories must belong to the same attempt root.");
+        }
+        const baseUrl = loopbackHttpUrl(context.baseUrl);
+        if (!/^[0-9a-f]{32}$/u.test(context.ownershipToken)) {
+            throw new Error("playwright_runtime_adapter_invalid: ownership token must be a normalized dispatch attempt UUID.");
+        }
+        const overlayPath = path.join(temporaryDirectory, "forge.playwright.config.mjs");
+        const browserCache = await resolvePlaywrightBrowserCache(attemptRoot);
+        const browserInstallCommand = await resolvePlaywrightBrowserInstallCommand(context.worktreePath, path.dirname(realSource));
+        await fs.writeFile(overlayPath, renderOverlay({
+            projectConfigUrl: pathToFileURL(realSource).href,
+            projectConfigDirectory: path.dirname(realSource),
+            testOutputDirectory,
+            baseUrl,
+            workers: config.workers,
+            projectNames,
+        }), { encoding: "utf8", mode: 0o600 });
+        return {
+            configPath: overlayPath,
+            environment: {
+                FORGE_PLAYWRIGHT_CONFIG: overlayPath,
+                FORGE_PLAYWRIGHT_BASE_URL: baseUrl,
+                FORGE_E2E_WEB_URL: baseUrl,
+                FORGE_E2E_OWNERSHIP_MODE: "attempt",
+                FORGE_E2E_OWNERSHIP_TOKEN: context.ownershipToken,
+                FORGE_PLAYWRIGHT_BROWSER_READY: browserCache.ready ? "true" : "false",
+                FORGE_PLAYWRIGHT_BROWSER_INSTALL_COMMAND: browserInstallCommand,
+                PLAYWRIGHT_BROWSERS_PATH: browserCache.path,
+                PLAYWRIGHT_HTML_OUTPUT_DIR: path.join(testOutputDirectory, "html-report"),
+                PLAYWRIGHT_BLOB_OUTPUT_DIR: path.join(testOutputDirectory, "blob-report"),
+                PLAYWRIGHT_JUNIT_OUTPUT_NAME: path.join(testOutputDirectory, "results.xml"),
+                PLAYWRIGHT_JSON_OUTPUT_NAME: path.join(testOutputDirectory, "results.json"),
+                FORGE_BROWSER_PROFILE_DIR: browserProfileDirectory,
+                FORGE_TEST_OUTPUT_DIR: testOutputDirectory,
+            },
+        };
+    }
+}
+async function resolvePlaywrightBrowserInstallCommand(worktreePath, configDirectory) {
+    const relativeDirectory = path.relative(worktreePath, configDirectory).replaceAll(path.sep, "/") || ".";
+    if (await isFile(path.join(configDirectory, "pnpm-lock.yaml"))) {
+        return `pnpm --dir ${quoteCommandArgument(relativeDirectory)} exec playwright install chromium`;
+    }
+    if (await isFile(path.join(configDirectory, "yarn.lock"))) {
+        return `yarn --cwd ${quoteCommandArgument(relativeDirectory)} playwright install chromium`;
+    }
+    return `npm --prefix ${quoteCommandArgument(relativeDirectory)} exec playwright install chromium`;
+}
+async function isFile(candidate) {
+    try {
+        return (await fs.stat(candidate)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function quoteCommandArgument(value) {
+    return /[\s"']/u.test(value) ? JSON.stringify(value) : value;
+}
+async function resolvePlaywrightBrowserCache(attemptRoot) {
+    const candidates = [
+        process.env.PLAYWRIGHT_BROWSERS_PATH,
+        process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, "ms-playwright") : null,
+        path.join(os.homedir(), ".cache", "ms-playwright"),
+    ].filter((candidate) => Boolean(candidate?.trim()));
+    for (const candidate of [...new Set(candidates.map(candidate => path.resolve(candidate)))]) {
+        if (await hasChromiumExecutable(candidate)) {
+            return { path: candidate, ready: true };
+        }
+    }
+    const attemptCache = path.join(attemptRoot, "cache", "ms-playwright");
+    await fs.mkdir(attemptCache, { recursive: true });
+    return { path: attemptCache, ready: false };
+}
+async function hasChromiumExecutable(cachePath) {
+    let entries;
+    try {
+        entries = await fs.readdir(cachePath, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    const executableSuffixes = process.platform === "win32"
+        ? [path.join("chrome-win64", "chrome.exe"), path.join("chrome-win", "chrome.exe")]
+        : process.platform === "darwin"
+            ? [path.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium")]
+            : [path.join("chrome-linux", "chrome"), path.join("chrome-linux64", "chrome")];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith("chromium-"))
+            continue;
+        for (const suffix of executableSuffixes) {
+            try {
+                const stat = await fs.stat(path.join(cachePath, entry.name, suffix));
+                if (stat.isFile())
+                    return true;
+            }
+            catch {
+                // Continue through known Playwright layouts.
+            }
+        }
+    }
+    return false;
+}
+function renderOverlay(values) {
+    return [
+        "// Generated by forge-bridge for one fenced host attempt.",
+        `// forge-playwright-projects: ${JSON.stringify(values.projectNames)}`,
+        "import path from \"node:path\";",
+        `import projectConfig from ${JSON.stringify(values.projectConfigUrl)};`,
+        `const projectConfigDirectory = ${JSON.stringify(values.projectConfigDirectory)};`,
+        "const resolveConfigPath = value => typeof value === \"string\" && !path.isAbsolute(value)",
+        "  ? path.resolve(projectConfigDirectory, value)",
+        "  : value;",
+        "const resolveModulePath = value => typeof value === \"string\" && value.startsWith(\".\")",
+        "  ? path.resolve(projectConfigDirectory, value)",
+        "  : value;",
+        "const resolveUse = use => ({",
+        "  ...(use ?? {}),",
+        "  storageState: typeof use?.storageState === \"string\" ? resolveConfigPath(use.storageState) : use?.storageState,",
+        "  baseURL: " + JSON.stringify(values.baseUrl) + ",",
+        "});",
+        "const forgeUse = resolveUse(projectConfig.use);",
+        "const forgeProjects = Array.isArray(projectConfig.projects)",
+        "  ? projectConfig.projects.map(project => ({",
+        "      ...project,",
+        "      testDir: resolveConfigPath(project.testDir),",
+        "      snapshotDir: resolveConfigPath(project.snapshotDir),",
+        "      use: resolveUse(project.use),",
+        "    }))",
+        "  : projectConfig.projects;",
+        "const forgeReporter = Array.isArray(projectConfig.reporter)",
+        "  ? projectConfig.reporter.map(reporter => Array.isArray(reporter)",
+        "      ? [resolveModulePath(reporter[0]), ...reporter.slice(1)]",
+        "      : resolveModulePath(reporter))",
+        "  : resolveModulePath(projectConfig.reporter);",
+        "const forgeProviderOnlySpecs = (() => {",
+        "  try {",
+        "    const parsed = JSON.parse(process.env.FORGE_CI_REPAIR_PROVIDER_ONLY_SPECS ?? '[]');",
+        "    return Array.isArray(parsed) ? parsed.filter(value => typeof value === 'string' && value.length > 0) : [];",
+        "  } catch {",
+        "    return [];",
+        "  }",
+        "})();",
+        "const forgeTestIgnore = forgeProviderOnlySpecs.length === 0",
+        "  ? projectConfig.testIgnore",
+        "  : [...(Array.isArray(projectConfig.testIgnore) ? projectConfig.testIgnore : projectConfig.testIgnore ? [projectConfig.testIgnore] : []), ...forgeProviderOnlySpecs];",
+        "export default {",
+        "  ...projectConfig,",
+        "  testDir: resolveConfigPath(projectConfig.testDir),",
+        "  snapshotDir: resolveConfigPath(projectConfig.snapshotDir),",
+        "  globalSetup: resolveModulePath(projectConfig.globalSetup),",
+        "  globalTeardown: resolveModulePath(projectConfig.globalTeardown),",
+        "  reporter: forgeReporter,",
+        "  testIgnore: forgeTestIgnore,",
+        `  outputDir: ${JSON.stringify(values.testOutputDirectory)},`,
+        `  workers: ${values.workers},`,
+        "  webServer: undefined,",
+        "  use: forgeUse,",
+        "  projects: forgeProjects,",
+        "};",
+        "",
+    ].join("\n");
+}
+async function realContainedDirectory(target, realWorktree, label) {
+    const realTarget = await fs.realpath(path.resolve(target));
+    if (realTarget === realWorktree || isContained(realWorktree, realTarget)) {
+        throw new Error(`playwright_runtime_adapter_invalid: ${label} must be attempt-private and outside the worktree.`);
+    }
+    const stat = await fs.stat(realTarget);
+    if (!stat.isDirectory())
+        throw new Error(`playwright_runtime_adapter_invalid: ${label} must be a directory.`);
+    return realTarget;
+}
+function assertContained(parent, child, label) {
+    if (!isContained(parent, child)) {
+        throw new Error(`playwright_runtime_adapter_invalid: ${label} must stay inside the prepared worktree.`);
+    }
+}
+function isContained(parent, child) {
+    const relative = path.relative(parent, child);
+    return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function loopbackHttpUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("playwright_runtime_adapter_invalid: base URL must be an HTTP loopback URL.");
+    }
+    if ((url.protocol !== "http:" && url.protocol !== "https:")
+        || url.hostname !== "127.0.0.1"
+        || !url.port
+        || url.username
+        || url.password) {
+        throw new Error("playwright_runtime_adapter_invalid: base URL must be an HTTP loopback URL.");
+    }
+    return url.href.replace(/\/$/u, "");
+}

package/dist/runtime/runtime-isolation-lease.d.ts

@@ -0,0 +1,67 @@
+export declare const runtimeIsolationLeaseStates: readonly ["reserved", "starting", "active", "releasing", "released", "degraded"];
+export type RuntimeIsolationLeaseState = typeof runtimeIsolationLeaseStates[number];
+export type RuntimeIsolationMode = "docker" | "host";
+export interface RuntimeIsolationPort {
+    readonly name: string;
+    readonly protocol: "tcp" | "udp";
+    readonly hostIp: "127.0.0.1" | "::1";
+    readonly hostPort: number;
+    readonly targetPort: number;
+}
+export interface RuntimeIsolationPath {
+    readonly path: string;
+    readonly role: string;
+}
+export interface RuntimeIsolationDockerResource {
+    readonly type: "container" | "network" | "volume";
+    readonly name: string;
+    readonly role: string;
+    readonly id?: string | null;
+}
+export interface RuntimeIsolationResources {
+    readonly memoryReservationBytes: number;
+    readonly cpuMillis: number;
+    readonly pids: number;
+    readonly ports: readonly RuntimeIsolationPort[];
+    readonly paths: readonly RuntimeIsolationPath[];
+    readonly processSupervisorId: string | null;
+    readonly dockerResources: readonly RuntimeIsolationDockerResource[];
+    readonly singletonKeys: readonly string[];
+}
+export interface RuntimeIsolationLease {
+    readonly schemaVersion: 1;
+    readonly leaseId: string;
+    readonly dispatchAttemptId: string;
+    readonly executionLeaseId: string;
+    readonly fencingToken: string;
+    readonly runnerId: string;
+    readonly runnerInstanceId: string;
+    readonly worktreeKey: string;
+    readonly worktreePath: string;
+    readonly mode: RuntimeIsolationMode;
+    readonly state: RuntimeIsolationLeaseState;
+    readonly createdAt: string;
+    readonly stateChangedAt: string;
+    readonly expiresAt: string;
+    readonly releasedAt: string | null;
+    readonly resources: RuntimeIsolationResources;
+}
+export interface RuntimeIsolationLeaseInput {
+    readonly leaseId: string;
+    readonly dispatchAttemptId: string;
+    readonly executionLeaseId: string;
+    readonly fencingToken: string;
+    readonly runnerId: string;
+    readonly runnerInstanceId: string;
+    readonly worktreeKey: string;
+    readonly worktreePath: string;
+    readonly mode: RuntimeIsolationMode;
+    readonly expiresAt: string;
+    readonly resources: RuntimeIsolationResources;
+    readonly createdAt?: string;
+}
+export declare function createRuntimeIsolationLease(input: RuntimeIsolationLeaseInput): RuntimeIsolationLease;
+export declare function transitionRuntimeIsolationLease(lease: RuntimeIsolationLease, nextState: RuntimeIsolationLeaseState, occurredAt?: string): RuntimeIsolationLease;
+export declare function renewRuntimeIsolationLease(lease: RuntimeIsolationLease, fencingToken: string, expiresAt: string): RuntimeIsolationLease | null;
+export declare function withRuntimeIsolationResources(lease: RuntimeIsolationLease, resources: RuntimeIsolationResources): RuntimeIsolationLease;
+export declare function validRuntimeIsolationLease(value: unknown): value is RuntimeIsolationLease;