@pixelzx/genesis 2026.6.4 → 2026.6.6

package/dist/compact.runtime-CYI8Yi9d.js

@@ -0,0 +1,12 @@
+//#region src/agents/pi-embedded-runner/compact.runtime.ts
+let compactRuntimePromise = null;
+function loadCompactRuntime() {
+	compactRuntimePromise ??= import("./compact-BNJH56SX.js");
+	return compactRuntimePromise;
+}
+async function compactEmbeddedPiSessionDirect(...args) {
+	const { compactEmbeddedPiSessionDirect } = await loadCompactRuntime();
+	return compactEmbeddedPiSessionDirect(...args);
+}
+//#endregion
+export { compactEmbeddedPiSessionDirect };

package/dist/compact.runtime.js

@@ -1 +1 @@
-export * from "./compact.runtime-jDUYMSjR.js";
+export * from "./compact.runtime-CYI8Yi9d.js";

package/dist/completion-cli-BS9GGHM0.js

@@ -0,0 +1,328 @@
+import { c as routeLogsToStderr } from "./subsystem-CNq69MoE.js";
+import { t as formatDocsLink } from "./links-C1-jbHJx.js";
+import { r as theme } from "./theme-DD6pQv2_.js";
+import { a as isCompletionShell, o as resolveCompletionCachePath, r as installCompletion, s as resolveShellFromEnv, t as COMPLETION_SHELLS } from "./completion-runtime-CUdMWalC.js";
+import { n as registerSubCliByName, t as getSubCliEntries } from "./register.subclis-core-DKMsWmjc.js";
+import { t as getCoreCliCommandDescriptors } from "./core-command-descriptors-DYk2dX5P.js";
+import "./command-registry-core-BfZgHqmv.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Option } from "commander";
+//#region src/cli/completion-fish.ts
+function escapeFishDescription(value) {
+	return value.replace(/'/g, "'\\''");
+}
+function parseOptionFlags(flags) {
+	const parts = flags.split(/[ ,|]+/);
+	return {
+		long: parts.find((flag) => flag.startsWith("--"))?.replace(/^--/, ""),
+		short: parts.find((flag) => flag.startsWith("-") && !flag.startsWith("--"))?.replace(/^-/, "")
+	};
+}
+function buildFishSubcommandCompletionLine(params) {
+	const desc = escapeFishDescription(params.description);
+	return `complete -c ${params.rootCmd} -n "${params.condition}" -a "${params.name}" -d '${desc}'\n`;
+}
+function buildFishOptionCompletionLine(params) {
+	const { short, long } = parseOptionFlags(params.flags);
+	const desc = escapeFishDescription(params.description);
+	let line = `complete -c ${params.rootCmd} -n "${params.condition}"`;
+	if (short) line += ` -s ${short}`;
+	if (long) line += ` -l ${long}`;
+	line += ` -d '${desc}'\n`;
+	return line;
+}
+//#endregion
+//#region src/cli/completion-cli.ts
+function getCompletionScript(shell, program) {
+	if (shell === "zsh") return generateZshCompletion(program);
+	if (shell === "bash") return generateBashCompletion(program);
+	if (shell === "powershell") return generatePowerShellCompletion(program);
+	return generateFishCompletion(program);
+}
+async function writeCompletionCache(params) {
+	const firstShell = params.shells[0] ?? "zsh";
+	const cacheDir = path.dirname(resolveCompletionCachePath(firstShell, params.binName));
+	await fs.mkdir(cacheDir, { recursive: true });
+	for (const shell of params.shells) {
+		const script = getCompletionScript(shell, params.program);
+		const targetPath = resolveCompletionCachePath(shell, params.binName);
+		await fs.writeFile(targetPath, script, "utf-8");
+	}
+}
+function writeCompletionRegistrationWarning(message) {
+	process.stderr.write(`[completion] ${message}\n`);
+}
+async function registerSubcommandsForCompletion(program) {
+	const entries = getSubCliEntries();
+	for (const entry of entries) {
+		if (entry.name === "completion") continue;
+		try {
+			await registerSubCliByName(program, entry.name, { registerPluginCliCommands: false });
+		} catch (error) {
+			writeCompletionRegistrationWarning(`skipping subcommand \`${entry.name}\` while building completion cache: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+}
+function hasCommand(program, name) {
+	return program.commands.some((command) => command.name() === name || command.aliases().includes(name));
+}
+function registerCommandPlaceholder(program, descriptor) {
+	if (hasCommand(program, descriptor.name)) return;
+	program.command(descriptor.name).description(descriptor.description);
+}
+function registerCoreCommandPlaceholdersForCompletion(program) {
+	for (const descriptor of getCoreCliCommandDescriptors()) registerCommandPlaceholder(program, descriptor);
+}
+async function registerPluginCommandPlaceholdersForCompletion(program) {
+	const { getPluginCliCommandDescriptors, loadValidatedConfigForPluginRegistration } = await import("./cli-CFsq8f2H.js");
+	const config = await loadValidatedConfigForPluginRegistration();
+	if (!config) return;
+	const descriptors = await getPluginCliCommandDescriptors(config, void 0, { installBundledRuntimeDeps: false });
+	for (const descriptor of descriptors) registerCommandPlaceholder(program, descriptor);
+}
+function registerCompletionCli(program) {
+	program.command("completion").description("Generate shell completion script").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/completion", "genesis.pixelzx.com/docs/cli/completion")}\n`).addOption(new Option("-s, --shell <shell>", "Shell to generate completion for (default: zsh)").choices(COMPLETION_SHELLS)).option("-i, --install", "Install completion script to shell profile").option("--write-state", "Write completion scripts to $GENESIS_STATE_DIR/completions (no stdout)").option("-y, --yes", "Skip confirmation (non-interactive)", false).action(async (options) => {
+		routeLogsToStderr();
+		const shell = options.shell ?? "zsh";
+		registerCoreCommandPlaceholdersForCompletion(program);
+		await registerSubcommandsForCompletion(program);
+		await registerPluginCommandPlaceholdersForCompletion(program);
+		if (options.writeState) await writeCompletionCache({
+			program,
+			shells: options.shell ? [shell] : [...COMPLETION_SHELLS],
+			binName: program.name()
+		});
+		if (options.install) {
+			await installCompletion(options.shell ?? resolveShellFromEnv(), Boolean(options.yes), program.name());
+			return;
+		}
+		if (options.writeState) return;
+		if (!isCompletionShell(shell)) throw new Error(`Unsupported shell: ${shell}`);
+		const script = getCompletionScript(shell, program);
+		process.stdout.write(script + "\n");
+	});
+}
+function generateZshCompletion(program) {
+	const rootCmd = program.name();
+	return `
+#compdef ${rootCmd}
+
+_${rootCmd}_root_completion() {
+  local -a commands
+  local -a options
+  
+  _arguments -C \\
+    ${generateZshArgs(program)} \\
+    ${generateZshSubcmdList(program)} \\
+    "*::arg:->args"
+
+  case $state in
+    (args)
+      case $line[1] in
+        ${program.commands.map((cmd) => `(${cmd.name()}) _${rootCmd}_${cmd.name().replace(/-/g, "_")} ;;`).join("\n        ")}
+      esac
+      ;;
+  esac
+}
+
+${generateZshSubcommands(program, rootCmd)}
+
+_${rootCmd}_register_completion() {
+  if (( ! $+functions[compdef] )); then
+    return 0
+  fi
+
+  compdef _${rootCmd}_root_completion ${rootCmd}
+  precmd_functions=(\${precmd_functions:#_${rootCmd}_register_completion})
+  unfunction _${rootCmd}_register_completion 2>/dev/null
+}
+
+_${rootCmd}_register_completion
+if (( ! $+functions[compdef] )); then
+  typeset -ga precmd_functions
+  if [[ -z "\${precmd_functions[(r)_${rootCmd}_register_completion]}" ]]; then
+    precmd_functions+=(_${rootCmd}_register_completion)
+  fi
+fi
+`;
+}
+function generateZshArgs(cmd) {
+	return (cmd.options || []).map((opt) => {
+		const flags = opt.flags.split(/[ ,|]+/);
+		const name = flags.find((f) => f.startsWith("--")) || flags[0];
+		const short = flags.find((f) => f.startsWith("-") && !f.startsWith("--"));
+		const desc = opt.description.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/'/g, "'\\''").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+		if (short) return `"(${name} ${short})"{${name},${short}}"[${desc}]"`;
+		return `"${name}[${desc}]"`;
+	}).join(" \\\n    ");
+}
+function generateZshSubcmdList(cmd) {
+	return `"1: :_values 'command' ${cmd.commands.map((c) => {
+		const desc = c.description().replace(/\\/g, "\\\\").replace(/'/g, "'\\''").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+		return `'${c.name()}[${desc}]'`;
+	}).join(" ")}"`;
+}
+function generateZshSubcommands(program, prefix) {
+	const segments = [];
+	const visit = (current, currentPrefix) => {
+		for (const cmd of current.commands) {
+			const nextPrefix = `${currentPrefix}_${cmd.name().replace(/-/g, "_")}`;
+			const funcName = `_${nextPrefix}`;
+			visit(cmd, nextPrefix);
+			const subCommands = cmd.commands;
+			if (subCommands.length > 0) {
+				segments.push(`
+${funcName}() {
+  local -a commands
+  local -a options
+  
+  _arguments -C \\
+    ${generateZshArgs(cmd)} \\
+    ${generateZshSubcmdList(cmd)} \\
+    "*::arg:->args"
+
+  case $state in
+    (args)
+      case $line[1] in
+        ${subCommands.map((sub) => `(${sub.name()}) ${funcName}_${sub.name().replace(/-/g, "_")} ;;`).join("\n        ")}
+      esac
+      ;;
+  esac
+}
+`);
+				continue;
+			}
+			segments.push(`
+${funcName}() {
+  _arguments -C \\
+    ${generateZshArgs(cmd)}
+}
+`);
+		}
+	};
+	visit(program, prefix);
+	return segments.join("");
+}
+function generateBashCompletion(program) {
+	const rootCmd = program.name();
+	return `
+_${rootCmd}_completion() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    
+    # Simple top-level completion for now
+    opts="${program.commands.map((c) => c.name()).join(" ")} ${program.options.map((o) => o.flags.split(" ")[0]).join(" ")}"
+    
+    case "\${prev}" in
+      ${program.commands.map((cmd) => generateBashSubcommand(cmd)).join("\n      ")}
+    esac
+
+    if [[ \${cur} == -* ]] ; then
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+    fi
+    
+    COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+}
+
+complete -F _${rootCmd}_completion ${rootCmd}
+`;
+}
+function generateBashSubcommand(cmd) {
+	return `${cmd.name()})
+        opts="${cmd.commands.map((c) => c.name()).join(" ")} ${cmd.options.map((o) => o.flags.split(" ")[0]).join(" ")}"
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+        ;;`;
+}
+function generatePowerShellCompletion(program) {
+	const rootCmd = program.name();
+	const segments = [];
+	const visit = (cmd, pathSegments) => {
+		const fullPath = pathSegments.join(" ");
+		const subCommands = cmd.commands.map((c) => c.name());
+		const options = cmd.options.map((o) => o.flags.split(/[ ,|]+/)[0]);
+		const allCompletions = [...subCommands, ...options].map((s) => `'${s}'`).join(",");
+		if (fullPath.length > 0 && allCompletions.length > 0) segments.push(`
+            if ($commandPath -eq '${fullPath}') {
+                $completions = @(${allCompletions})
+                $completions | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+                }
+            }
+`);
+		for (const sub of cmd.commands) visit(sub, [...pathSegments, sub.name()]);
+	};
+	visit(program, []);
+	const rootBody = segments.join("");
+	return `
+Register-ArgumentCompleter -Native -CommandName ${rootCmd} -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+    
+    $commandElements = $commandAst.CommandElements
+    $commandPath = ""
+    
+    # Reconstruct command path (simple approximation)
+    # Skip the executable name
+    for ($i = 1; $i -lt $commandElements.Count; $i++) {
+        $element = $commandElements[$i].Extent.Text
+        if ($element -like "-*") { break }
+        if ($i -eq $commandElements.Count - 1 -and $wordToComplete -ne "") { break } # Don't include current word being typed
+        $commandPath += "$element "
+    }
+    $commandPath = $commandPath.Trim()
+    
+    # Root command
+    if ($commandPath -eq "") {
+         $completions = @(${program.commands.map((c) => `'${c.name()}'`).join(",")}, ${program.options.map((o) => `'${o.flags.split(" ")[0]}'`).join(",")}) 
+         $completions | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+         }
+    }
+    
+    ${rootBody}
+}
+`;
+}
+function generateFishCompletion(program) {
+	const rootCmd = program.name();
+	const segments = [];
+	const visit = (cmd, parents) => {
+		const cmdName = cmd.name();
+		if (parents.length === 0) {
+			for (const sub of cmd.commands) segments.push(buildFishSubcommandCompletionLine({
+				rootCmd,
+				condition: "__fish_use_subcommand",
+				name: sub.name(),
+				description: sub.description()
+			}));
+			for (const opt of cmd.options) segments.push(buildFishOptionCompletionLine({
+				rootCmd,
+				condition: "__fish_use_subcommand",
+				flags: opt.flags,
+				description: opt.description
+			}));
+		} else {
+			for (const sub of cmd.commands) segments.push(buildFishSubcommandCompletionLine({
+				rootCmd,
+				condition: `__fish_seen_subcommand_from ${cmdName}`,
+				name: sub.name(),
+				description: sub.description()
+			}));
+			for (const opt of cmd.options) segments.push(buildFishOptionCompletionLine({
+				rootCmd,
+				condition: `__fish_seen_subcommand_from ${cmdName}`,
+				flags: opt.flags,
+				description: opt.description
+			}));
+		}
+		for (const sub of cmd.commands) visit(sub, [...parents, cmdName]);
+	};
+	visit(program, []);
+	return segments.join("");
+}
+//#endregion
+export { getCompletionScript, registerCompletionCli };

package/dist/config-DxkleHmo.js

@@ -0,0 +1,252 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { m as resolveUserPath } from "./utils-CWrkFsp0.js";
+import { u as resolveGatewayPort } from "./paths-Bv2rGpO9.js";
+import { a as isLoopbackHost } from "./net-BzaeD_3Q.js";
+import { a as normalizeOptionalTrimmedStringList } from "./string-normalization-Bsx26hdl.js";
+import { n as deriveDefaultBrowserCdpPortRange, r as deriveDefaultBrowserControlPort } from "./port-defaults-TPyW6SVT.js";
+import "./text-runtime-DuYzmNnc.js";
+import "./browser-config-support-DtMzlYMS.js";
+import "./control-auth-Iqyldslx.js";
+import { h as DEFAULT_GENESIS_BROWSER_PROFILE_NAME, l as DEFAULT_BROWSER_ACTION_TIMEOUT_MS, p as DEFAULT_GENESIS_BROWSER_COLOR } from "./paths-CQ_G-HVX.js";
+import "./paths-B0YbMb-d.js";
+import { d as parseBrowserHttpUrl } from "./cdp.helpers-Ch0SX_4B.js";
+import path from "node:path";
+import os from "node:os";
+//#region extensions/browser/src/browser/config.ts
+const DEFAULT_BROWSER_CDP_PORT_RANGE_START = 18800;
+const DEFAULT_TOR_SOCKS_HOST = "127.0.0.1";
+const DEFAULT_EXTERNAL_TOR_SOCKS_PORT = 9050;
+const MANAGED_TOR_SOCKS_PORT_OFFSET = 100;
+const DEFAULT_TOR_ENABLED = true;
+const DEFAULT_TOR_ROUTE_MODE = "onion-only";
+function normalizeHexColor(raw) {
+	const value = (raw ?? "").trim();
+	if (!value) return DEFAULT_GENESIS_BROWSER_COLOR;
+	const normalized = value.startsWith("#") ? value : `#${value}`;
+	if (!/^#[0-9a-fA-F]{6}$/.test(normalized)) return DEFAULT_GENESIS_BROWSER_COLOR;
+	return normalized.toUpperCase();
+}
+function normalizeTimeoutMs(raw, fallback) {
+	const value = typeof raw === "number" && Number.isFinite(raw) ? Math.floor(raw) : fallback;
+	return value < 0 ? fallback : value;
+}
+function normalizeNonNegativeInteger(raw, fallback) {
+	const value = typeof raw === "number" && Number.isFinite(raw) ? Math.floor(raw) : fallback;
+	return value < 0 ? fallback : value;
+}
+function normalizePositiveInteger(raw, fallback) {
+	const value = typeof raw === "number" && Number.isFinite(raw) ? Math.floor(raw) : fallback;
+	return value <= 0 ? fallback : value;
+}
+function normalizeExecutablePath(raw) {
+	const value = normalizeOptionalString(raw);
+	if (!value) return;
+	if (!/^~(?=$|[\\/])/.test(value)) return value;
+	return path.resolve(value.replace(/^~(?=$|[\\/])/, os.homedir()));
+}
+function normalizeUserPath(raw) {
+	const value = normalizeOptionalString(raw);
+	if (!value) return;
+	if (!/^~(?=$|[\\/])/.test(value)) return value;
+	return path.resolve(value.replace(/^~(?=$|[\\/])/, os.homedir()));
+}
+function normalizePort(raw, fallback, label) {
+	const value = typeof raw === "number" && Number.isFinite(raw) ? Math.floor(raw) : fallback;
+	if (value < 1 || value > 65535) throw new Error(`${label} must be between 1 and 65535, got: ${value}`);
+	return value;
+}
+function normalizeTorExtraArgs(raw) {
+	return Array.isArray(raw) ? raw.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+}
+function normalizeBrowserTorConfig(raw, inherited, opts) {
+	if (!(raw?.enabled ?? inherited?.enabled ?? opts?.defaultEnabled ?? DEFAULT_TOR_ENABLED)) return;
+	const mode = raw?.mode ?? inherited?.mode ?? "managed";
+	const routeMode = raw?.routeMode ?? inherited?.routeMode ?? DEFAULT_TOR_ROUTE_MODE;
+	const socksHost = normalizeOptionalString(raw?.socksHost) ?? inherited?.socksHost ?? DEFAULT_TOR_SOCKS_HOST;
+	if (mode === "managed" && !isLoopbackHost(socksHost)) throw new Error("browser.tor.socksHost must be loopback when browser.tor.mode is managed.");
+	const fallbackSocksPort = mode === "managed" && opts?.cdpPort && opts.cdpPort + MANAGED_TOR_SOCKS_PORT_OFFSET <= 65535 ? opts.cdpPort + MANAGED_TOR_SOCKS_PORT_OFFSET : inherited?.socksPort ?? DEFAULT_EXTERNAL_TOR_SOCKS_PORT;
+	const socksPort = normalizePort(raw?.socksPort, fallbackSocksPort, "browser.tor.socksPort");
+	const executablePath = normalizeExecutablePath(raw?.executablePath) ?? inherited?.executablePath;
+	const dataDir = normalizeUserPath(raw?.dataDir) ?? inherited?.dataDir;
+	const extraArgs = normalizeTorExtraArgs(raw?.extraArgs ?? inherited?.extraArgs);
+	return {
+		enabled: true,
+		mode,
+		routeMode,
+		...executablePath ? { executablePath } : {},
+		socksHost,
+		socksPort,
+		...dataDir ? { dataDir } : {},
+		extraArgs
+	};
+}
+function resolveBrowserTabCleanupConfig(cfg) {
+	const raw = cfg?.tabCleanup;
+	return {
+		enabled: raw?.enabled ?? true,
+		idleMinutes: normalizeNonNegativeInteger(raw?.idleMinutes, 120),
+		maxTabsPerSession: normalizeNonNegativeInteger(raw?.maxTabsPerSession, 8),
+		sweepMinutes: normalizePositiveInteger(raw?.sweepMinutes, 5)
+	};
+}
+function resolveCdpPortRangeStart(rawStart, fallbackStart, rangeSpan) {
+	const start = typeof rawStart === "number" && Number.isFinite(rawStart) ? Math.floor(rawStart) : fallbackStart;
+	if (start < 1 || start > 65535) throw new Error(`browser.cdpPortRangeStart must be between 1 and 65535, got: ${start}`);
+	const maxStart = 65535 - rangeSpan;
+	if (start > maxStart) throw new Error(`browser.cdpPortRangeStart (${start}) is too high for a ${rangeSpan + 1}-port range; max is ${maxStart}.`);
+	return start;
+}
+const normalizeStringList = normalizeOptionalTrimmedStringList;
+function resolveBrowserSsrFPolicy(cfg) {
+	const rawPolicy = cfg?.ssrfPolicy;
+	const allowPrivateNetwork = rawPolicy?.allowPrivateNetwork;
+	const dangerouslyAllowPrivateNetwork = rawPolicy?.dangerouslyAllowPrivateNetwork;
+	const allowedHostnames = normalizeStringList(rawPolicy?.allowedHostnames);
+	const hostnameAllowlist = normalizeStringList(rawPolicy?.hostnameAllowlist);
+	const hasExplicitPrivateSetting = allowPrivateNetwork !== void 0 || dangerouslyAllowPrivateNetwork !== void 0;
+	const resolvedAllowPrivateNetwork = dangerouslyAllowPrivateNetwork === true || allowPrivateNetwork === true;
+	if (!resolvedAllowPrivateNetwork && !hasExplicitPrivateSetting && !allowedHostnames && !hostnameAllowlist) return {};
+	return {
+		...resolvedAllowPrivateNetwork || dangerouslyAllowPrivateNetwork === false || allowPrivateNetwork === false ? { dangerouslyAllowPrivateNetwork: resolvedAllowPrivateNetwork } : {},
+		...allowedHostnames ? { allowedHostnames } : {},
+		...hostnameAllowlist ? { hostnameAllowlist } : {}
+	};
+}
+function ensureDefaultProfile(profiles, defaultColor, legacyCdpPort, derivedDefaultCdpPort, legacyCdpUrl) {
+	const result = { ...profiles };
+	if (!result["genesis"]) result[DEFAULT_GENESIS_BROWSER_PROFILE_NAME] = {
+		cdpPort: legacyCdpPort ?? derivedDefaultCdpPort ?? DEFAULT_BROWSER_CDP_PORT_RANGE_START,
+		color: defaultColor,
+		...legacyCdpUrl ? { cdpUrl: legacyCdpUrl } : {}
+	};
+	return result;
+}
+function ensureDefaultUserBrowserProfile(profiles) {
+	const result = { ...profiles };
+	if (result.user) return result;
+	result.user = {
+		driver: "existing-session",
+		attachOnly: true,
+		color: "#00AA00"
+	};
+	return result;
+}
+function resolveBrowserConfig(cfg, rootConfig) {
+	const enabled = cfg?.enabled ?? true;
+	const evaluateEnabled = cfg?.evaluateEnabled ?? true;
+	const controlPort = deriveDefaultBrowserControlPort(resolveGatewayPort(rootConfig) ?? 18791);
+	const defaultColor = normalizeHexColor(cfg?.color);
+	const remoteCdpTimeoutMs = normalizeTimeoutMs(cfg?.remoteCdpTimeoutMs, 1500);
+	const remoteCdpHandshakeTimeoutMs = normalizeTimeoutMs(cfg?.remoteCdpHandshakeTimeoutMs, Math.max(2e3, remoteCdpTimeoutMs * 2));
+	const actionTimeoutMs = normalizeTimeoutMs(cfg?.actionTimeoutMs, DEFAULT_BROWSER_ACTION_TIMEOUT_MS);
+	const derivedCdpRange = deriveDefaultBrowserCdpPortRange(controlPort);
+	const cdpRangeSpan = derivedCdpRange.end - derivedCdpRange.start;
+	const cdpPortRangeStart = resolveCdpPortRangeStart(cfg?.cdpPortRangeStart, derivedCdpRange.start, cdpRangeSpan);
+	const cdpPortRangeEnd = cdpPortRangeStart + cdpRangeSpan;
+	const rawCdpUrl = (cfg?.cdpUrl ?? "").trim();
+	let cdpInfo;
+	if (rawCdpUrl) cdpInfo = parseBrowserHttpUrl(rawCdpUrl, "browser.cdpUrl");
+	else {
+		const derivedPort = controlPort + 1;
+		if (derivedPort > 65535) throw new Error(`Derived CDP port (${derivedPort}) is too high; check gateway port configuration.`);
+		const derived = new URL(`http://127.0.0.1:${derivedPort}`);
+		cdpInfo = {
+			parsed: derived,
+			port: derivedPort,
+			normalized: derived.toString().replace(/\/$/, "")
+		};
+	}
+	const headless = cfg?.headless === true;
+	const noSandbox = cfg?.noSandbox === true;
+	const attachOnly = cfg?.attachOnly === true;
+	const executablePath = normalizeExecutablePath(cfg?.executablePath);
+	const defaultProfileFromConfig = normalizeOptionalString(cfg?.defaultProfile);
+	const legacyCdpPort = rawCdpUrl ? cdpInfo.port : void 0;
+	const isWsUrl = cdpInfo.parsed.protocol === "ws:" || cdpInfo.parsed.protocol === "wss:";
+	const legacyCdpUrl = rawCdpUrl && isWsUrl ? cdpInfo.normalized : void 0;
+	const profiles = ensureDefaultUserBrowserProfile(ensureDefaultProfile(cfg?.profiles, defaultColor, legacyCdpPort, cdpPortRangeStart, legacyCdpUrl));
+	const cdpProtocol = cdpInfo.parsed.protocol === "https:" ? "https" : "http";
+	const defaultProfile = defaultProfileFromConfig ?? (profiles["genesis"] ? "genesis" : profiles["genesis"] ? "genesis" : "user");
+	const extraArgs = Array.isArray(cfg?.extraArgs) ? cfg.extraArgs.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+	const torDefaultEnabled = cfg?.tor?.enabled ?? DEFAULT_TOR_ENABLED;
+	const tor = normalizeBrowserTorConfig(cfg?.tor, void 0, { defaultEnabled: torDefaultEnabled });
+	return {
+		enabled,
+		evaluateEnabled,
+		controlPort,
+		cdpPortRangeStart,
+		cdpPortRangeEnd,
+		cdpProtocol,
+		cdpHost: cdpInfo.parsed.hostname,
+		cdpIsLoopback: isLoopbackHost(cdpInfo.parsed.hostname),
+		remoteCdpTimeoutMs,
+		remoteCdpHandshakeTimeoutMs,
+		actionTimeoutMs,
+		color: defaultColor,
+		executablePath,
+		headless,
+		noSandbox,
+		attachOnly,
+		defaultProfile,
+		profiles,
+		tabCleanup: resolveBrowserTabCleanupConfig(cfg),
+		ssrfPolicy: resolveBrowserSsrFPolicy(cfg),
+		extraArgs,
+		torDefaultEnabled,
+		...tor ? { tor } : {}
+	};
+}
+function resolveProfile(resolved, profileName) {
+	const profile = resolved.profiles[profileName];
+	if (!profile) return null;
+	const rawProfileUrl = profile.cdpUrl?.trim() ?? "";
+	let cdpHost = resolved.cdpHost;
+	let cdpPort = profile.cdpPort ?? 0;
+	let cdpUrl = "";
+	const driver = profile.driver === "existing-session" ? "existing-session" : "genesis";
+	const headless = profile.headless ?? resolved.headless;
+	const executablePath = normalizeExecutablePath(profile.executablePath) ?? resolved.executablePath;
+	if (driver === "existing-session") return {
+		name: profileName,
+		cdpPort: 0,
+		cdpUrl: "",
+		cdpHost: "",
+		cdpIsLoopback: true,
+		userDataDir: resolveUserPath(profile.userDataDir?.trim() || "") || void 0,
+		color: profile.color,
+		driver,
+		executablePath,
+		headless,
+		attachOnly: true
+	};
+	if (rawProfileUrl !== "" && cdpPort > 0 && /^wss?:\/\//i.test(rawProfileUrl) && /\/devtools\/browser\//i.test(rawProfileUrl)) {
+		cdpHost = new URL(rawProfileUrl).hostname;
+		cdpUrl = `${resolved.cdpProtocol}://${cdpHost}:${cdpPort}`;
+	} else if (rawProfileUrl) {
+		const parsed = parseBrowserHttpUrl(rawProfileUrl, `browser.profiles.${profileName}.cdpUrl`);
+		cdpHost = parsed.parsed.hostname;
+		cdpPort = parsed.port;
+		cdpUrl = parsed.normalized;
+	} else if (cdpPort) cdpUrl = `${resolved.cdpProtocol}://${resolved.cdpHost}:${cdpPort}`;
+	else throw new Error(`Profile "${profileName}" must define cdpPort or cdpUrl.`);
+	const attachOnly = profile.attachOnly ?? resolved.attachOnly;
+	const tor = driver === "genesis" && isLoopbackHost(cdpHost) && !attachOnly ? normalizeBrowserTorConfig(profile.tor, resolved.tor, {
+		cdpPort,
+		defaultEnabled: resolved.torDefaultEnabled
+	}) : void 0;
+	return {
+		name: profileName,
+		cdpPort,
+		cdpUrl,
+		cdpHost,
+		cdpIsLoopback: isLoopbackHost(cdpHost),
+		color: profile.color,
+		driver,
+		executablePath,
+		headless,
+		attachOnly,
+		...tor ? { tor } : {}
+	};
+}
+//#endregion
+export { resolveProfile as n, resolveBrowserConfig as t };