@gaodefa/daocore 2026.5.29 → 2026.5.30

package/dist/config-ATBTvUGh.js

@@ -0,0 +1,2 @@
+import "./config-DlNgjF8W.js";
+export {};

package/dist/config-DlNgjF8W.js

@@ -0,0 +1,373 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DyL154ka.js";
+import { u as resolveGatewayPort } from "./paths-ZwPDM6zn.js";
+import { p as resolveUserPath } from "./utils-CNnMhEDp.js";
+import { a as normalizeOptionalTrimmedStringList } from "./string-normalization-DiPHgdft.js";
+import { n as resolvePreferredDaoCoreTmpDir } from "./tmp-daocore-dir-kDRsiZXM.js";
+import { i as isLoopbackHost } from "./net-DCUMtgJy.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import "./core-D0Y2H55f.js";
+import "./plugin-config-runtime-BhkqZ7bA.js";
+import "./config-mutation-CwZjp067.js";
+import "./runtime-config-snapshot-B5412xcP.js";
+import "./text-utility-runtime-DMDtY7pX.js";
+import "./sdk-security-runtime-D1Z-V8Bd.js";
+import { G as DEFAULT_DAOCORE_BROWSER_COLOR, H as DEFAULT_BROWSER_LOCAL_CDP_READY_TIMEOUT_MS, U as DEFAULT_BROWSER_LOCAL_LAUNCH_TIMEOUT_MS, d as parseBrowserHttpUrl, q as DEFAULT_DAOCORE_BROWSER_PROFILE_NAME, z as DEFAULT_BROWSER_ACTION_TIMEOUT_MS } from "./cdp.helpers-Dc4Aa7R9.js";
+import "./tmp-daocore-dir-0uyqO_dp.js";
+import path from "node:path";
+import os from "node:os";
+//#region extensions/browser/src/sdk-config.ts
+const DEFAULT_BROWSER_CDP_PORT_RANGE_START$1 = 18800;
+const DEFAULT_BROWSER_CDP_PORT_RANGE_END = 18899;
+const DEFAULT_BROWSER_CDP_PORT_RANGE_SPAN = DEFAULT_BROWSER_CDP_PORT_RANGE_END - DEFAULT_BROWSER_CDP_PORT_RANGE_START$1;
+const DEFAULT_BROWSER_CONTROL_PORT = 18791;
+function isValidPort(port) {
+	return Number.isFinite(port) && port > 0 && port <= 65535;
+}
+function clampPort(port, fallback) {
+	return isValidPort(port) ? port : fallback;
+}
+function derivePort(base, offset, fallback) {
+	return clampPort(base + offset, fallback);
+}
+function deriveDefaultBrowserControlPort(gatewayPort) {
+	return derivePort(gatewayPort, 2, DEFAULT_BROWSER_CONTROL_PORT);
+}
+function deriveDefaultBrowserCdpPortRange(browserControlPort) {
+	const start = derivePort(browserControlPort, 9, DEFAULT_BROWSER_CDP_PORT_RANGE_START$1);
+	const end = start + DEFAULT_BROWSER_CDP_PORT_RANGE_SPAN;
+	if (end <= 65535) return {
+		start,
+		end
+	};
+	return {
+		start: DEFAULT_BROWSER_CDP_PORT_RANGE_START$1,
+		end: DEFAULT_BROWSER_CDP_PORT_RANGE_END
+	};
+}
+const DEFAULT_TRUTHY = [
+	"true",
+	"1",
+	"yes",
+	"on"
+];
+const DEFAULT_FALSY = [
+	"false",
+	"0",
+	"no",
+	"off"
+];
+function matchesBooleanToken(value, tokens) {
+	return tokens.includes(value);
+}
+function parseBooleanValue(value, options = {}) {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return;
+	const normalized = normalizeOptionalLowercaseString(value);
+	if (!normalized) return;
+	const candidates = [[true, options.truthy ?? DEFAULT_TRUTHY], [false, options.falsy ?? DEFAULT_FALSY]];
+	for (const [parsed, tokens] of candidates) if (matchesBooleanToken(normalized, tokens)) return parsed;
+}
+//#endregion
+//#region extensions/browser/src/browser/paths.ts
+const DEFAULT_FALLBACK_BROWSER_TMP_DIR = "/tmp/daocore";
+function canUseNodeFs() {
+	const getBuiltinModule = process.getBuiltinModule;
+	if (typeof getBuiltinModule !== "function") return false;
+	try {
+		return getBuiltinModule("fs") !== void 0;
+	} catch {
+		return false;
+	}
+}
+const DEFAULT_BROWSER_TMP_DIR = canUseNodeFs() ? resolvePreferredDaoCoreTmpDir() : DEFAULT_FALLBACK_BROWSER_TMP_DIR;
+const DEFAULT_TRACE_DIR = DEFAULT_BROWSER_TMP_DIR;
+const DEFAULT_DOWNLOAD_DIR = path.join(DEFAULT_BROWSER_TMP_DIR, "downloads");
+const DEFAULT_UPLOAD_DIR = path.join(DEFAULT_BROWSER_TMP_DIR, "uploads");
+//#endregion
+//#region extensions/browser/src/browser/config.ts
+const DEFAULT_BROWSER_CDP_PORT_RANGE_START = 18800;
+const MAX_BROWSER_STARTUP_TIMEOUT_MS = 12e4;
+const DAOCORE_BROWSER_HEADLESS_ENV = "DAOCORE_BROWSER_HEADLESS";
+function normalizeHexColor(raw) {
+	const value = (raw ?? "").trim();
+	if (!value) return DEFAULT_DAOCORE_BROWSER_COLOR;
+	const normalized = value.startsWith("#") ? value : `#${value}`;
+	if (!/^#[0-9a-fA-F]{6}$/.test(normalized)) return DEFAULT_DAOCORE_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 normalizeStartupTimeoutMs(raw, fallback) {
+	const value = typeof raw === "number" && Number.isFinite(raw) ? Math.floor(raw) : fallback;
+	if (value <= 0) return fallback;
+	return Math.min(value, MAX_BROWSER_STARTUP_TIMEOUT_MS);
+}
+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 normalizeExistingSessionCdpUrl(raw, profileName) {
+	const value = normalizeOptionalString(raw);
+	if (!value) return;
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		throw new Error(`browser.profiles.${profileName}.cdpUrl must be a valid URL.`);
+	}
+	if (![
+		"http:",
+		"https:",
+		"ws:",
+		"wss:"
+	].includes(parsed.protocol)) throw new Error(`browser.profiles.${profileName}.cdpUrl must use http, https, ws, or wss.`);
+	return {
+		cdpUrl: parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.toString().replace(/\/$/, "") : parsed.toString(),
+		cdpHost: parsed.hostname,
+		cdpIsLoopback: isLoopbackHost(parsed.hostname)
+	};
+}
+function hasLinuxDisplay(env) {
+	return Boolean(env.DISPLAY?.trim() || env.WAYLAND_DISPLAY?.trim());
+}
+function isLocalManagedProfile(profile) {
+	return profile.driver === "daocore" && profile.cdpIsLoopback && !profile.attachOnly;
+}
+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["daocore"]) result[DEFAULT_DAOCORE_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 localLaunchTimeoutMs = normalizeStartupTimeoutMs(cfg?.localLaunchTimeoutMs, DEFAULT_BROWSER_LOCAL_LAUNCH_TIMEOUT_MS);
+	const localCdpReadyTimeoutMs = normalizeStartupTimeoutMs(cfg?.localCdpReadyTimeoutMs, DEFAULT_BROWSER_LOCAL_CDP_READY_TIMEOUT_MS);
+	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 headlessSource = typeof cfg?.headless === "boolean" ? "config" : "default";
+	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["daocore"] ? "daocore" : profiles["daocore"] ? "daocore" : "user");
+	const extraArgs = Array.isArray(cfg?.extraArgs) ? cfg.extraArgs.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
+	return {
+		enabled,
+		evaluateEnabled,
+		controlPort,
+		cdpPortRangeStart,
+		cdpPortRangeEnd,
+		cdpProtocol,
+		cdpHost: cdpInfo.parsed.hostname,
+		cdpIsLoopback: isLoopbackHost(cdpInfo.parsed.hostname),
+		remoteCdpTimeoutMs,
+		remoteCdpHandshakeTimeoutMs,
+		localLaunchTimeoutMs,
+		localCdpReadyTimeoutMs,
+		actionTimeoutMs,
+		color: defaultColor,
+		executablePath,
+		headless,
+		headlessSource,
+		noSandbox,
+		attachOnly,
+		defaultProfile,
+		profiles,
+		tabCleanup: resolveBrowserTabCleanupConfig(cfg),
+		ssrfPolicy: resolveBrowserSsrFPolicy(cfg),
+		extraArgs
+	};
+}
+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" : "daocore";
+	const headless = profile.headless ?? resolved.headless;
+	const headlessSource = typeof profile.headless === "boolean" ? "profile" : resolved.headlessSource;
+	const executablePath = normalizeExecutablePath(profile.executablePath) ?? resolved.executablePath;
+	if (driver === "existing-session") {
+		const existingSessionCdp = normalizeExistingSessionCdpUrl(rawProfileUrl, profileName);
+		return {
+			name: profileName,
+			cdpPort: 0,
+			cdpUrl: existingSessionCdp?.cdpUrl ?? "",
+			cdpHost: existingSessionCdp?.cdpHost ?? "",
+			cdpIsLoopback: existingSessionCdp?.cdpIsLoopback ?? true,
+			userDataDir: resolveUserPath(profile.userDataDir?.trim() || "") || void 0,
+			mcpCommand: normalizeOptionalString(profile.mcpCommand),
+			mcpArgs: normalizeStringList(profile.mcpArgs) ?? void 0,
+			color: profile.color,
+			driver,
+			executablePath,
+			headless,
+			headlessSource,
+			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;
+		if (parsed.hasExplicitPort) {
+			cdpPort = parsed.port;
+			cdpUrl = parsed.normalizedWithPort;
+		} else if (cdpPort) {
+			const rebuilt = new URL(rawProfileUrl);
+			rebuilt.port = String(cdpPort);
+			cdpUrl = rebuilt.toString().replace(/\/$/, "");
+		} else {
+			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.`);
+	return {
+		name: profileName,
+		cdpPort,
+		cdpUrl,
+		cdpHost,
+		cdpIsLoopback: isLoopbackHost(cdpHost),
+		color: profile.color,
+		driver,
+		executablePath,
+		headless,
+		headlessSource,
+		attachOnly: profile.attachOnly ?? resolved.attachOnly
+	};
+}
+function resolveManagedBrowserHeadlessMode(resolved, profile, params = {}) {
+	if (!isLocalManagedProfile(profile)) return {
+		headless: profile.headless,
+		source: profile.headlessSource ?? "default"
+	};
+	if (typeof params.headlessOverride === "boolean") return {
+		headless: params.headlessOverride,
+		source: "request"
+	};
+	const env = params.env ?? process.env;
+	const platform = params.platform ?? process.platform;
+	const envHeadless = parseBooleanValue(env[DAOCORE_BROWSER_HEADLESS_ENV]);
+	if (envHeadless !== void 0) return {
+		headless: envHeadless,
+		source: "env"
+	};
+	const profileHeadlessSource = profile.headlessSource ?? "default";
+	if (profileHeadlessSource !== "default") return {
+		headless: profile.headless,
+		source: profileHeadlessSource
+	};
+	if (platform === "linux" && !hasLinuxDisplay(env)) return {
+		headless: true,
+		source: "linux-display-fallback"
+	};
+	return {
+		headless: resolved.headless,
+		source: "default"
+	};
+}
+function getManagedBrowserMissingDisplayError(resolved, profile, params = {}) {
+	if (!isLocalManagedProfile(profile)) return null;
+	const env = params.env ?? process.env;
+	const platform = params.platform ?? process.platform;
+	if (platform !== "linux" || hasLinuxDisplay(env)) return null;
+	const mode = resolveManagedBrowserHeadlessMode(resolved, profile, {
+		env,
+		platform
+	});
+	if (mode.headless) return null;
+	const sourceHint = mode.source === "request" ? "request override" : mode.source === "env" ? `${DAOCORE_BROWSER_HEADLESS_ENV}=0` : mode.source === "profile" ? `browser.profiles.${profile.name}.headless=false` : "browser.headless=false";
+	return `Headed browser start requested for profile "${profile.name}" via ${sourceHint}, but no Linux display server was detected (\$DISPLAY/\$WAYLAND_DISPLAY unset). Set ${DAOCORE_BROWSER_HEADLESS_ENV}=1, remove the headed override, or launch under Xvfb.`;
+}
+//#endregion
+export { DEFAULT_DOWNLOAD_DIR as a, deriveDefaultBrowserCdpPortRange as c, resolveProfile as i, parseBooleanValue as l, resolveBrowserConfig as n, DEFAULT_TRACE_DIR as o, resolveManagedBrowserHeadlessMode as r, DEFAULT_UPLOAD_DIR as s, getManagedBrowserMissingDisplayError as t };

package/dist/config-mutations-tl_OqI6d.js

@@ -0,0 +1,159 @@
+import { i as formatErrorMessage } from "./errors-D_oyTIw2.js";
+import { n as mutateConfigFile } from "./mutate-DSZiMIjv.js";
+import { S as BrowserResourceExhaustedError, T as BrowserValidationError, _ as BrowserConflictError, n as assertCdpEndpointAllowed } from "./cdp.helpers-Dc4Aa7R9.js";
+import { c as deriveDefaultBrowserCdpPortRange, n as resolveBrowserConfig } from "./config-DlNgjF8W.js";
+import "./config-ATBTvUGh.js";
+import "./errors-CdV5A9eu.js";
+const PROFILE_NAME_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+function isValidProfileName(name) {
+	if (!name || name.length > 64) return false;
+	return PROFILE_NAME_REGEX.test(name);
+}
+function allocateCdpPort(usedPorts, range) {
+	const start = range?.start ?? 18800;
+	const end = range?.end ?? 18899;
+	if (!Number.isFinite(start) || !Number.isFinite(end) || start <= 0 || end <= 0) return null;
+	if (start > end) return null;
+	for (let port = start; port <= end; port++) if (!usedPorts.has(port)) return port;
+	return null;
+}
+function getUsedPorts(profiles) {
+	if (!profiles) return /* @__PURE__ */ new Set();
+	const used = /* @__PURE__ */ new Set();
+	for (const profile of Object.values(profiles)) {
+		if (typeof profile.cdpPort === "number") {
+			used.add(profile.cdpPort);
+			continue;
+		}
+		const rawUrl = profile.cdpUrl?.trim();
+		if (!rawUrl) continue;
+		try {
+			const parsed = new URL(rawUrl);
+			const port = parsed.port && Number.parseInt(parsed.port, 10) > 0 ? Number.parseInt(parsed.port, 10) : parsed.protocol === "https:" ? 443 : 80;
+			if (!Number.isNaN(port) && port > 0 && port <= 65535) used.add(port);
+		} catch {}
+	}
+	return used;
+}
+const PROFILE_COLORS = [
+	"#FF4500",
+	"#0066CC",
+	"#00AA00",
+	"#9933FF",
+	"#FF6699",
+	"#00CCCC",
+	"#FF9900",
+	"#6666FF",
+	"#CC3366",
+	"#339966"
+];
+function allocateColor(usedColors) {
+	for (const color of PROFILE_COLORS) if (!usedColors.has(color.toUpperCase())) return color;
+	return PROFILE_COLORS[usedColors.size % PROFILE_COLORS.length] ?? PROFILE_COLORS[0];
+}
+function getUsedColors(profiles) {
+	if (!profiles) return /* @__PURE__ */ new Set();
+	return new Set(Object.values(profiles).map((p) => p.color.toUpperCase()));
+}
+//#endregion
+//#region extensions/browser/src/browser/config-mutations.ts
+const cdpPortRange = (resolved) => {
+	const start = resolved.cdpPortRangeStart;
+	const end = resolved.cdpPortRangeEnd;
+	if (typeof start === "number" && Number.isFinite(start) && Number.isInteger(start) && typeof end === "number" && Number.isFinite(end) && Number.isInteger(end) && start > 0 && end >= start && end <= 65535) return {
+		start,
+		end
+	};
+	return deriveDefaultBrowserCdpPortRange(resolved.controlPort);
+};
+async function persistBrowserControlCredential(credential) {
+	await mutateConfigFile({
+		afterWrite: { mode: "auto" },
+		mutate: (draft) => {
+			draft.gateway = {
+				...draft.gateway,
+				auth: {
+					...draft.gateway?.auth,
+					[credential.kind]: credential.value
+				}
+			};
+		}
+	});
+}
+async function createBrowserProfileConfig(params) {
+	return (await mutateConfigFile({
+		afterWrite: { mode: "auto" },
+		mutate: async (draft) => {
+			const rawDraftBrowser = draft.browser;
+			const draftCdpPortRangeEnd = typeof rawDraftBrowser?.cdpPortRangeEnd === "number" ? rawDraftBrowser.cdpPortRangeEnd : void 0;
+			const useRebasedPortRange = draft.gateway?.port !== void 0 || draft.browser?.cdpPortRangeStart !== void 0 || draftCdpPortRangeEnd !== void 0;
+			const latestResolved = resolveBrowserConfig({
+				...params.resolved,
+				...draft.browser,
+				profiles: draft.browser?.profiles ?? params.resolved.profiles
+			}, draft);
+			const latestRootResolved = resolveBrowserConfig(draft.browser, draft);
+			const latestProfileSource = useRebasedPortRange ? latestRootResolved : latestResolved;
+			const latestProfiles = draft.browser?.profiles ?? {};
+			if (params.name in latestProfiles || params.name in latestProfileSource.profiles) throw new BrowserConflictError(`profile "${params.name}" already exists`);
+			const profileColor = params.color ?? allocateColor(getUsedColors(latestProfileSource.profiles));
+			let nextProfileConfig;
+			if (params.parsedCdpUrl) {
+				try {
+					await assertCdpEndpointAllowed(params.parsedCdpUrl, latestResolved.ssrfPolicy);
+				} catch (err) {
+					throw new BrowserValidationError(formatErrorMessage(err));
+				}
+				nextProfileConfig = {
+					cdpUrl: params.parsedCdpUrl,
+					...params.driver ? { driver: params.driver } : {},
+					color: profileColor
+				};
+			} else if (params.driver === "existing-session") nextProfileConfig = {
+				driver: params.driver,
+				attachOnly: true,
+				...params.userDataDir ? { userDataDir: params.userDataDir } : {},
+				color: profileColor
+			};
+			else {
+				const usedPorts = getUsedPorts(latestProfileSource.profiles);
+				const rangeSource = useRebasedPortRange ? latestRootResolved : params.resolved;
+				const cdpPort = allocateCdpPort(usedPorts, cdpPortRange({
+					controlPort: rangeSource.controlPort,
+					cdpPortRangeStart: rangeSource.cdpPortRangeStart,
+					cdpPortRangeEnd: draftCdpPortRangeEnd ?? rangeSource.cdpPortRangeEnd
+				}));
+				if (cdpPort === null) throw new BrowserResourceExhaustedError("no available CDP ports in range");
+				nextProfileConfig = {
+					cdpPort,
+					...params.driver ? { driver: params.driver } : {},
+					color: profileColor
+				};
+			}
+			draft.browser = {
+				...draft.browser,
+				profiles: {
+					...draft.browser?.profiles,
+					[params.name]: nextProfileConfig
+				}
+			};
+			return nextProfileConfig;
+		}
+	})).result;
+}
+async function deleteBrowserProfileConfig(name) {
+	await mutateConfigFile({
+		afterWrite: { mode: "auto" },
+		mutate: (draft) => {
+			const { [name]: _removed, ...remainingProfiles } = draft.browser?.profiles ?? {};
+			const nextBrowser = {
+				...draft.browser,
+				profiles: remainingProfiles
+			};
+			if (nextBrowser.defaultProfile === name) delete nextBrowser.defaultProfile;
+			draft.browser = nextBrowser;
+		}
+	});
+}
+//#endregion
+export { isValidProfileName as i, deleteBrowserProfileConfig as n, persistBrowserControlCredential as r, createBrowserProfileConfig as t };