weapp-ide-cli 6.1.9 → 6.2.0

package/dist/devtoolsProjectOwnership-yDD6h0dO.js

@@ -0,0 +1,1726 @@
+import { a as assertWechatDevtoolsPort, c as withPowerShellUtf8Output, i as assertWechatDevtoolsHost, o as resolveWechatDevtoolsInstallationRoot, r as resolveWechatDevtoolsTarget, s as resolveWechatInspectionTimeout } from "./sessionStore-zdzy2UFM.js";
+import path from "node:path";
+import { TextDecoder, debuglog, isDeepStrictEqual, stripVTControlCharacters } from "node:util";
+import { assertMachineE2ELeaseRecoveryScope, mutateLease, withMachineE2ELease, withMachineE2ELeaseRecoveryOperation } from "@weapp-vite/devtools-runtime";
+import { execa } from "execa";
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import process from "node:process";
+import { Buffer } from "node:buffer";
+import net from "node:net";
+import { setTimeout } from "node:timers/promises";
+import { z } from "zod";
+import { performance } from "node:perf_hooks";
+//#region src/cli/agentStart.ts
+/** 提取独立的完整 JSON 对象，普通日志和嵌套对象不能替代命令响应。 */
+function readResponseObjects(stdout) {
+	const objects = [];
+	let candidate = "";
+	let depth = 0;
+	let quoted = false;
+	let escaped = false;
+	for (const line of stripVTControlCharacters(stdout).split(/\r?\n/)) {
+		if (!candidate && !/^[{[]/.test(line.trimStart())) continue;
+		candidate += `${line}\n`;
+		for (const char of line) if (escaped) escaped = false;
+		else if (quoted && char === "\\") escaped = true;
+		else if (char === "\"") quoted = !quoted;
+		else if (!quoted && (char === "{" || char === "[")) depth += 1;
+		else if (!quoted && (char === "}" || char === "]")) depth -= 1;
+		if (depth > 0) continue;
+		try {
+			const parsed = JSON.parse(candidate);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) objects.push(parsed);
+		} catch {}
+		candidate = "";
+		depth = 0;
+		quoted = false;
+		escaped = false;
+	}
+	return objects;
+}
+function parseAgentStartResponse(stdout, port) {
+	const responses = readResponseObjects(stdout).filter((value) => value.command === "agent-start");
+	const response = responses[0];
+	if (responses.length !== 1 || !response || response.status !== "ok" || response.autoPort !== port || typeof response.openedProjectWindow !== "boolean" || typeof response.version !== "string" || !response.version.trim()) throw Object.assign(/* @__PURE__ */ new Error("The official WeChat DevTools agent start response is invalid or ambiguous."), {
+		code: "WECHAT_DEVTOOLS_AGENT_START_INVALID_RESPONSE",
+		stdout
+	});
+	return {
+		autoPort: port,
+		openedProjectWindow: response.openedProjectWindow,
+		version: response.version
+	};
+}
+/** 命令失败仍可能带回完整成功回执；缺失或歧义输出不能授予窗口所有权。 */
+function readFailedCommandReceipt(error, port) {
+	if (!error || typeof error !== "object" || !("stdout" in error) || typeof error.stdout !== "string") return;
+	try {
+		return parseAgentStartResponse(error.stdout, port);
+	} catch {
+		return;
+	}
+}
+/** 使用所选安装的官方 agent start，并保留其窗口复用和端口冲突语义。 */
+async function startWechatIdeAgent(options) {
+	options.signal?.throwIfAborted();
+	if (!options.projectPath.trim()) throw new TypeError("Agent start projectPath must not be empty.");
+	if (options.cliPath !== void 0 && !options.cliPath.trim()) throw new TypeError("Agent start cliPath must not be empty.");
+	if (!Number.isInteger(options.port) || options.port < 1 || options.port > 65535) throw new TypeError("Agent start port must be an integer from 1 to 65535.");
+	const timeout = options.timeout ?? 12e4;
+	if (!Number.isFinite(timeout) || timeout <= 0) throw new TypeError("Agent start timeout must be a finite positive number.");
+	return await withMachineE2ELease(async () => {
+		options.signal?.throwIfAborted();
+		try {
+			const target = await resolveWechatDevtoolsTarget({
+				target: options.target,
+				cliPath: options.cliPath
+			});
+			options.signal?.throwIfAborted();
+			await assertWechatDevtoolsHost(target, {
+				signal: options.signal,
+				timeout
+			});
+			options.signal?.throwIfAborted();
+			const argv = [
+				"agent",
+				"start",
+				"--project",
+				path.resolve(options.projectPath),
+				"--auto-port",
+				String(options.port)
+			];
+			if (options.trustProject === true) argv.push("--trust-project");
+			const started = parseAgentStartResponse((await execa(target.cliPath, argv, {
+				cancelSignal: options.signal,
+				timeout,
+				killDescendants: false
+			}).catch(async (error) => {
+				const receipt = readFailedCommandReceipt(error, options.port);
+				if (receipt) try {
+					await options.onStarted?.(receipt);
+				} catch (confirmationError) {
+					throw new AggregateError([error, confirmationError], "Failed agent command receipt could not be recorded.", { cause: error });
+				}
+				throw error;
+			})).stdout, options.port);
+			await options.onStarted?.(started);
+			options.signal?.throwIfAborted();
+			return started;
+		} catch (error) {
+			options.signal?.throwIfAborted();
+			throw error;
+		}
+	});
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/host.ts
+const inspectionOptions$1 = {
+	timeout: 3e3,
+	reject: false,
+	windowsHide: true
+};
+const windowsInspectionOptions = {
+	...inspectionOptions$1,
+	timeout: resolveWechatInspectionTimeout("win32")
+};
+function invalidIdentity(result, timeout) {
+	const details = result ? ` Inspection: exitCode=${result.exitCode ?? "none"}, signal=${result.signal ?? "none"}, timedOut=${result.timedOut ?? false}, timeoutMs=${timeout}.` : "";
+	return /* @__PURE__ */ new Error(`Managed DevTools process identity could not be verified; no project was closed.${details}`);
+}
+/** PID 必须连同启动时间和可执行文件核验；进程号复用不继承所有权。 */
+async function readManagedProcessIdentity(pid, platform = process.platform) {
+	if (!Number.isSafeInteger(pid) || pid <= 0) throw invalidIdentity();
+	if (platform === "win32") {
+		const result = await execa("powershell.exe", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			withPowerShellUtf8Output(`$ErrorActionPreference='Stop'; Get-CimInstance Win32_Process -Filter "ProcessId=${pid}" | Select-Object ProcessId,ExecutablePath,@{Name='Started';Expression={$_.CreationDate.ToUniversalTime().ToString('o')}} | ConvertTo-Json -Compress`)
+		], windowsInspectionOptions);
+		if (result.exitCode !== 0) throw invalidIdentity(result, windowsInspectionOptions.timeout);
+		if (!result.stdout.trim()) return;
+		const value = JSON.parse(result.stdout);
+		if (!value || typeof value !== "object" || !("ProcessId" in value) || value.ProcessId !== pid || !("ExecutablePath" in value) || typeof value.ExecutablePath !== "string" || !value.ExecutablePath || !("Started" in value) || typeof value.Started !== "string" || !value.Started) throw invalidIdentity();
+		return {
+			pid,
+			executable: value.ExecutablePath,
+			started: value.Started
+		};
+	}
+	if (platform === "linux") try {
+		const [executable, stat] = await Promise.all([fs.readlink(`/proc/${pid}/exe`), fs.readFile(`/proc/${pid}/stat`, "utf8")]);
+		const boot = await fs.readFile("/proc/sys/kernel/random/boot_id", "utf8").catch(() => {
+			throw invalidIdentity();
+		});
+		const started = stat.slice(stat.lastIndexOf(")") + 2).split(/\s+/)[19];
+		if (!started || !/^\d+$/.test(started) || !boot.trim()) throw invalidIdentity();
+		return {
+			pid,
+			executable,
+			started: `${boot.trim()}:${started}`
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	const result = await execa("ps", [
+		"-p",
+		String(pid),
+		"-o",
+		"lstart=",
+		"-o",
+		"comm="
+	], {
+		...inspectionOptions$1,
+		env: { LC_ALL: "C" }
+	});
+	if (result.exitCode === 1 && !result.stdout.trim()) return;
+	const match = /^(\w{3}\s+\w{3}\s+\d+\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s+(\S[^\r\n]*)$/.exec(result.stdout.trim());
+	if (result.exitCode !== 0 || !match) throw invalidIdentity();
+	return {
+		pid,
+		started: match[1].replace(/\s+/g, " "),
+		executable: match[2].trim()
+	};
+}
+function sameManagedProcess(first, second) {
+	return first.pid === second.pid && first.started === second.started && first.executable === second.executable;
+}
+async function listenerPid(port, platform = process.platform) {
+	const result = platform === "win32" ? await execa("powershell.exe", [
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		withPowerShellUtf8Output(`$ErrorActionPreference='Stop'; @(Get-NetTCPConnection -LocalPort ${port} -State Listen | Select-Object -ExpandProperty OwningProcess -Unique) | ConvertTo-Json -Compress`)
+	], windowsInspectionOptions) : await execa("lsof", [
+		"-nP",
+		`-iTCP:${port}`,
+		"-sTCP:LISTEN",
+		"-Fp"
+	], inspectionOptions$1);
+	if (result.exitCode !== 0) throw invalidIdentity(result, resolveWechatInspectionTimeout(platform));
+	const parsed = platform === "win32" ? JSON.parse(result.stdout.trim() || "[]") : void 0;
+	const pids = platform === "win32" ? Array.isArray(parsed) ? parsed : [parsed] : result.stdout.split(/\r?\n/).filter((line) => /^p\d+$/.test(line)).map((line) => Number(line.slice(1)));
+	const unique = [...new Set(pids)];
+	if (unique.length !== 1 || typeof unique[0] !== "number" || !Number.isSafeInteger(unique[0]) || unique[0] <= 0) throw invalidIdentity();
+	return unique[0];
+}
+/** 所有权来自官方回执；监听身份仅用于约束后续关闭，不能单独授予所有权。 */
+async function inspectManagedProjectHost(target, port, platform = process.platform) {
+	await assertWechatDevtoolsPort(target, port, { platform });
+	const identity = await readManagedProcessIdentity(await listenerPid(port, platform), platform);
+	if (!identity) throw invalidIdentity();
+	return identity;
+}
+async function assertManagedInstallation(target) {
+	const current = await resolveWechatDevtoolsTarget({ cliPath: target.cliPath });
+	if (current.installationId !== target.installationId || current.appPath !== target.appPath || current.cliPath !== target.cliPath || current.profileDir !== target.profileDir || current.version !== target.version || current.channel !== target.channel) throw new Error("Managed DevTools installation changed; no project was closed.");
+}
+function isManagedPortClosed(port) {
+	return new Promise((resolve, reject) => {
+		const socket = net.createConnection({
+			host: "127.0.0.1",
+			port
+		});
+		const finish = (error, closed = false) => {
+			socket.destroy();
+			if (error) reject(error);
+			else resolve(closed);
+		};
+		socket.once("connect", () => finish());
+		socket.once("error", (error) => error.code === "ECONNREFUSED" ? finish(void 0, true) : finish(error));
+		socket.setTimeout(1e3, () => finish(/* @__PURE__ */ new Error("Managed DevTools port probe timed out.")));
+	});
+}
+async function waitForManagedPortClosed(port, timeoutMs = 1e4) {
+	const deadline = Date.now() + timeoutMs;
+	do {
+		if (await isManagedPortClosed(port)) return;
+		await setTimeout(100);
+	} while (Date.now() < deadline);
+	throw new Error("Managed DevTools project close returned but its automator port remained open.");
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/installationExit/schema.ts
+const installationExitRecoverySchema = z.object({
+	protocol: z.literal("wechat-devtools-installation-exit-v1"),
+	recoveredAt: z.string().datetime(),
+	recoveryScopeId: z.string().uuid(),
+	journalScopeId: z.string().uuid(),
+	journalRootPath: z.string().min(1),
+	installationId: z.string().min(1),
+	profileDir: z.string().min(1),
+	previous: z.object({
+		state: z.enum([
+			"starting",
+			"unconfirmed",
+			"failed"
+		]),
+		error: z.string().optional(),
+		updatedAt: z.string().min(1),
+		recordSha256: z.string().regex(/^[\da-f]{64}$/)
+	}).strict(),
+	stoppedOwnerPids: z.array(z.number().int().positive()).min(1),
+	closedPorts: z.array(z.number().int().min(1).max(65535)).min(1),
+	processInspection: z.object({
+		platform: z.literal("darwin"),
+		installationRoot: z.string().min(1),
+		checkedAt: z.string().datetime(),
+		inspectedProcessCount: z.number().int().nonnegative(),
+		kernelPathProcessCount: z.number().int().nonnegative(),
+		textImageProcessCount: z.number().int().nonnegative(),
+		exitedProcessCount: z.number().int().nonnegative(),
+		zombieProcessCount: z.number().int().nonnegative(),
+		selectedProcessCount: z.literal(0)
+	}).strict()
+}).strict();
+//#endregion
+//#region src/devtoolsProjectOwnership/journal/constants.ts
+/** 受管项目日志的环境变量名称；基础设施预检可在构建包之前读取。 */
+const MANAGED_PROJECT_JOURNAL_ENV = "WEAPP_IDE_MANAGED_PROJECT_JOURNAL";
+/** 仅供显式受管任务声明双项目窗口验收；不允许无限扩大并行窗口。 */
+const MANAGED_PROJECT_MAX_WINDOWS_ENV = "WEAPP_IDE_MANAGED_PROJECT_MAX_WINDOWS";
+//#endregion
+//#region src/devtoolsProjectOwnership/journal/scope.ts
+const markerName = ".ownership-scope";
+const scopeSchema = z.object({
+	schemaVersion: z.literal(1),
+	rootPath: z.string().min(1),
+	scopeId: z.string().uuid()
+}).strict();
+async function readScope(directory) {
+	const file = path.join(directory, markerName);
+	const stat = await fs.lstat(file).catch((error) => {
+		if (error.code === "ENOENT") return;
+		throw error;
+	});
+	if (!stat) return;
+	if (!stat.isFile()) throw new Error("Managed DevTools journal scope must be a regular metadata file.");
+	const scope = scopeSchema.parse(JSON.parse(await fs.readFile(file, "utf8")));
+	if (!path.isAbsolute(scope.rootPath)) throw new Error("Managed DevTools journal scope root must be absolute.");
+	return scope;
+}
+async function assertDirectory(directory) {
+	if (!(await fs.lstat(directory)).isDirectory()) throw new Error("Managed DevTools journal scope must use regular directories.");
+}
+/** 只接受创建时登记的根及 children 链；不通过搜索祖先收养未知任务。 */
+async function resolveManagedJournalScope(directory) {
+	const selected = path.resolve(directory);
+	await assertDirectory(selected);
+	const scope = await readScope(selected);
+	if (!scope) {
+		if (path.basename(selected).startsWith("task-scope-")) throw new Error("Managed DevTools journal scope metadata is missing; refusing an isolated fallback.");
+		return { rootPath: selected };
+	}
+	await assertDirectory(scope.rootPath);
+	const root = await readScope(scope.rootPath);
+	if (!root || root.scopeId !== scope.scopeId || root.rootPath !== scope.rootPath) throw new Error("Managed DevTools journal scope identity changed; refusing another task boundary.");
+	const rootPath = await fs.realpath(scope.rootPath);
+	const currentPath = await fs.realpath(selected);
+	const relative = path.relative(scope.rootPath, selected);
+	if (relative) {
+		const parts = relative.split(path.sep);
+		if (path.isAbsolute(relative) || parts.length % 2 !== 0 || parts.some((part, index) => index % 2 === 0 ? part !== "children" : !part || part === "..")) throw new Error("Managed DevTools journal is outside its registered task children.");
+		let current = scope.rootPath;
+		for (const [index, part] of parts.entries()) {
+			current = path.join(current, part);
+			await assertDirectory(current);
+			if (index % 2 === 1) {
+				const registered = await readScope(current);
+				if (!registered || registered.rootPath !== scope.rootPath || registered.scopeId !== scope.scopeId) throw new Error("Managed DevTools journal scope chain changed; refusing split task locks.");
+			}
+		}
+	}
+	if (path.resolve(rootPath, relative) !== currentPath) throw new Error("Managed DevTools journal path changed from its registered task children.");
+	return scope;
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/journal/windowsSelfIdentity/wire.ts
+const SELF_IDENTITY_WIRE = "WEAPP_JOURNAL_SELF_V1";
+const epochTicks = 621355968000000000n;
+const maximumTicks = 3155378975999999999n;
+function invalid() {
+	return /* @__PURE__ */ new Error("Managed journal writer identity could not be verified; the journal remains unchanged.");
+}
+/** 保留 CIM 的微秒精度与七位小数格式；整数 ticks 不经浮点数或 Date 丢失尾数。 */
+function cimStartedFromTicks(value) {
+	if (!/^[1-9]\d{0,18}$/.test(value)) throw invalid();
+	const ticks = BigInt(value);
+	if (ticks < epochTicks || ticks > maximumTicks) throw invalid();
+	const seconds = (ticks - epochTicks) / 10000000n;
+	return `${new Date(Number(seconds * 1000n)).toISOString().slice(0, 19)}.${(ticks % 10000000n / 10n * 10n).toString().padStart(7, "0")}Z`;
+}
+function decodeExecutable(value) {
+	const bytes = Buffer.from(value, "base64");
+	if (!value || bytes.toString("base64") !== value) throw invalid();
+	const executable = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	if (!executable.trim() || !Buffer.from(executable).equals(bytes) || [...executable].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) throw invalid();
+	return executable;
+}
+/** 只接受一次完整自查结果；额外输出、退出或代次变化均不能授予写入身份。 */
+function parseWindowsSelfIdentity(stdout, expectedPid) {
+	if (!Number.isSafeInteger(expectedPid) || expectedPid <= 0 || !/^[\t\r\n\x20-\x7E]*$/.test(stdout)) throw invalid();
+	const fields = stdout.replace(/\r?\n$/, "").split("	");
+	const [marker, status, pid, before, after, exited, started, encodedExecutable] = fields;
+	if (fields.length !== 8 || marker !== "WEAPP_JOURNAL_SELF_V1" || status !== "present" || pid !== String(expectedPid) || before !== after || exited !== "false" || !before || !started || !encodedExecutable || started !== cimStartedFromTicks(before)) throw invalid();
+	return {
+		pid: expectedPid,
+		executable: decodeExecutable(encodedExecutable),
+		started
+	};
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/journal/windowsSelfIdentity/command.ts
+/** 当前 writer 的 PID 由 Node 进程提供；脚本只读查询，不执行任何进程或 IDE 清理。 */
+function windowsSelfIdentityCommand(pid) {
+	if (!Number.isSafeInteger(pid) || pid <= 0) throw new TypeError("A positive writer PID is required.");
+	return `
+$ErrorActionPreference='Stop'
+$writerFirst=$null
+$writerSecond=$null
+$writerExitCode=0
+try {
+  $writerFirst=[System.Diagnostics.Process]::GetProcessById(${pid})
+  $writerBefore=$writerFirst.StartTime.ToUniversalTime()
+  $writerExecutable=$writerFirst.MainModule.FileName
+  $writerSecond=[System.Diagnostics.Process]::GetProcessById(${pid})
+  $writerAfter=$writerSecond.StartTime.ToUniversalTime()
+  if ($writerFirst.Id -ne ${pid} -or $writerSecond.Id -ne ${pid} -or [string]::IsNullOrWhiteSpace($writerExecutable) -or $writerBefore.Ticks -ne $writerAfter.Ticks) {
+    throw [System.InvalidOperationException]::new('Incomplete or changed writer identity')
+  }
+  if ($writerFirst.HasExited -or $writerSecond.HasExited) {
+    throw [System.InvalidOperationException]::new('Writer exited during identity inspection')
+  }
+  $writerLegacyTicks=[long]($writerBefore.Ticks - ($writerBefore.Ticks % 10))
+  $writerStarted=[DateTime]::new($writerLegacyTicks,[DateTimeKind]::Utc).ToString('o',[Globalization.CultureInfo]::InvariantCulture)
+  $writerPath=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($writerExecutable))
+  $writerFields=@('${SELF_IDENTITY_WIRE}','present','${pid}',$writerBefore.Ticks.ToString([Globalization.CultureInfo]::InvariantCulture),$writerAfter.Ticks.ToString([Globalization.CultureInfo]::InvariantCulture),'false',$writerStarted,$writerPath)
+  [Console]::Out.WriteLine([string]::Join([string][char]9,[string[]]$writerFields))
+  [Console]::Out.Flush()
+}
+catch {
+  $writerExitCode=1
+  $writerError=$_.Exception.GetBaseException()
+  [Console]::Error.WriteLine('${SELF_IDENTITY_WIRE}:error:'+ $writerError.GetType().FullName + ':' + $writerError.HResult.ToString([Globalization.CultureInfo]::InvariantCulture))
+}
+finally {
+  if ($null -ne $writerSecond) { $writerSecond.Dispose() }
+  if ($null -ne $writerFirst) { $writerFirst.Dispose() }
+}
+exit $writerExitCode
+`;
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/journal/windowsSelfIdentity/trace.ts
+const marker = `${SELF_IDENTITY_WIRE}:phase:`;
+const statements = /* @__PURE__ */ new Map([
+	["$writerFirst=[System.Diagnostics.Process]", "lookup-before"],
+	["$writerBefore=$writerFirst.StartTime", "start-before"],
+	["$writerExecutable=$writerFirst.MainModule", "module-path"],
+	["$writerSecond=[System.Diagnostics.Process]", "lookup-after"],
+	["$writerAfter=$writerSecond.StartTime", "start-after"],
+	["if ($writerFirst.Id", "generation-check"],
+	["if ($writerFirst.HasExited", "exit-check"],
+	["$writerLegacyTicks=", "serialize"],
+	["[Console]::Out.Flush()", "stdout-flush"],
+	["$writerExitCode=1", "error"],
+	["if ($null -ne $writerSecond)", "dispose-after"],
+	["if ($null -ne $writerFirst)", "dispose-before"],
+	["exit $writerExitCode", "complete"]
+]);
+const phases = ["entry", ...statements.values()];
+const phasePattern = new RegExp(`^${marker}(${phases.join("|")})$`);
+const phaseLines = new RegExp(`^${marker}(?:${phases.join("|")})\\r?\\n`, "gm");
+function phaseStatement(phase) {
+	return `[Console]::Error.WriteLine('${marker}${phase}'); [Console]::Error.Flush()`;
+}
+/** 仅增加已知阶段标记；移除标记后必须与原身份查询逐字相同。 */
+function traceWindowsSelfIdentityCommand(command) {
+	return `${phaseStatement("entry")}\n${command.split("\n").flatMap((line) => {
+		const phase = [...statements].find(([statement]) => line.trimStart().startsWith(statement))?.[1];
+		return phase ? [phaseStatement(phase), line] : [line];
+	}).join("\n")}`;
+}
+/** 只接收固定 ASCII 阶段名；未知 stderr 不进入诊断日志。 */
+function observeWindowsSelfIdentityPhases(report) {
+	let buffered = "";
+	return (chunk) => {
+		buffered += chunk.toString();
+		const lines = buffered.split("\n");
+		buffered = lines.pop();
+		for (const line of lines) {
+			const phase = phasePattern.exec(line.replace(/\r$/, ""))?.[1];
+			if (phase) report(phase);
+		}
+	};
+}
+/** 只有显式诊断调用可剥离完整已知标记；其余 stderr 继续触发失败。 */
+function stripWindowsSelfIdentityPhases(stderr) {
+	return stderr.replace(phaseLines, "");
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/journal/windowsSelfIdentity/index.ts
+const debug = debuglog("weapp-ide-journal-writer");
+/** 仅核验当前 Node 写入进程；不能用于任意宿主、旧锁存活判断或进程清理。 */
+async function readWindowsJournalWriterIdentity() {
+	const timeout = resolveWechatInspectionTimeout("win32");
+	const trace = debug.enabled;
+	const command = windowsSelfIdentityCommand(process.pid);
+	const started = performance.now();
+	const query = execa("powershell.exe", [
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		trace ? traceWindowsSelfIdentityCommand(command) : command
+	], {
+		timeout,
+		reject: false,
+		windowsHide: true,
+		maxBuffer: 65536,
+		stripFinalNewline: !trace
+	});
+	if (trace) {
+		const report = (phase) => debug("phase=%s elapsedMs=%s", phase, (performance.now() - started).toFixed(1));
+		report("launch");
+		query.nodeChildProcess.once("spawn", () => report("spawn"));
+		query.stderr?.on("data", observeWindowsSelfIdentityPhases(report));
+	}
+	const result = await query;
+	const stderr = trace ? stripWindowsSelfIdentityPhases(result.stderr) : result.stderr;
+	if (trace) debug("phase=settled elapsedMs=%s exitCode=%s signal=%s timedOut=%s", (performance.now() - started).toFixed(1), result.exitCode ?? "none", result.signal ?? "none", result.timedOut ?? false);
+	if (result.exitCode !== 0 || result.failed || result.timedOut || result.signal || stderr.trim()) {
+		const reason = /^WEAPP_JOURNAL_SELF_V1:error:([\w.]+):-?\d+\r?\n?$/.exec(stderr)?.[1] ?? "unconfirmed";
+		throw new Error(`Managed journal writer identity could not be verified; the journal remains unchanged. Inspection: exitCode=${result.exitCode ?? "none"}, signal=${result.signal ?? "none"}, timedOut=${result.timedOut ?? false}, timeoutMs=${timeout}, reason=${reason}.`);
+	}
+	return parseWindowsSelfIdentity(result.stdout, process.pid);
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/journal/writerIdentity.ts
+let currentIdentity$1;
+/** 共享在途与成功身份；失败仍拒绝当前调用，仅允许下一次显式操作重新核验。 */
+function readManagedJournalWriterIdentity() {
+	if (!currentIdentity$1) {
+		const pending = (process.platform === "win32" ? readWindowsJournalWriterIdentity() : readManagedProcessIdentity(process.pid)).then((identity) => {
+			if (!identity) throw new Error("Cannot identify the managed DevTools journal writer.");
+			return identity;
+		});
+		currentIdentity$1 = pending;
+		pending.catch(() => {
+			if (currentIdentity$1 === pending) currentIdentity$1 = void 0;
+		});
+	}
+	return currentIdentity$1;
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/windowClose/schema.ts
+const text = z.string().min(1);
+const cursorSchema = z.object({
+	name: z.string().regex(/^[^/\\]+\.log$/),
+	identity: text,
+	offset: z.number().int().nonnegative(),
+	anchor: z.string().regex(/^[a-f0-9]{64}$/),
+	skipPartialLine: z.boolean()
+});
+const callSchema = z.object({
+	fileIdentity: text,
+	winId: text,
+	browserWindowId: z.number().int().positive(),
+	calledAt: text,
+	cancelled: z.boolean().optional()
+});
+const managedWindowCloseSchema = z.object({
+	protocol: z.literal("wechat-devtools-window-close-trace-v1"),
+	profileDir: text,
+	productVersion: text,
+	capturedAt: text,
+	mainHost: z.object({
+		pid: z.number().int().positive(),
+		executable: text,
+		started: text
+	}).optional(),
+	dispatchedAt: text.optional(),
+	cursors: z.array(cursorSchema).min(1),
+	calls: z.array(callSchema),
+	window: callSchema.extend({
+		runtimeId: text,
+		requestedAt: text,
+		nativeClosedAt: text.optional(),
+		webContentsDestroyedAt: text.optional()
+	}).optional(),
+	failure: text.optional(),
+	logInventoryRecovery: z.object({
+		failure: text,
+		cursors: z.array(cursorSchema).min(1)
+	}).optional()
+});
+//#endregion
+//#region src/devtoolsProjectOwnership/journal.ts
+const managedProcessToken = randomUUID();
+const idSchema = z.string().uuid();
+const hostSchema = z.object({
+	pid: z.number().int().positive(),
+	executable: z.string().min(1),
+	started: z.string().min(1)
+});
+const recordSchema = z.object({
+	schemaVersion: z.literal(1),
+	id: idSchema,
+	generation: z.string().min(1),
+	journalPath: z.string().min(1),
+	ownerToken: idSchema,
+	ownerPid: z.number().int().positive(),
+	target: z.object({
+		cliPath: z.string().min(1),
+		installationId: z.string().min(1),
+		appPath: z.string().min(1),
+		profileDir: z.string().min(1),
+		version: z.string().optional(),
+		channel: z.enum([
+			"stable",
+			"rc",
+			"nightly",
+			"unknown"
+		]).optional()
+	}),
+	projectPath: z.string().min(1),
+	state: z.enum([
+		"starting",
+		"unconfirmed",
+		"owned",
+		"borrowed",
+		"closing",
+		"failed",
+		"released"
+	]),
+	openedProjectWindow: z.boolean().optional(),
+	port: z.number().int().min(1).max(65535).optional(),
+	host: hostSchema.optional(),
+	createdAt: z.string().min(1),
+	updatedAt: z.string().min(1),
+	closeAcknowledgedAt: z.string().min(1).optional(),
+	windowClose: managedWindowCloseSchema.optional(),
+	releasedReason: z.enum([
+		"borrowed",
+		"project-closed",
+		"installation-exited"
+	]).optional(),
+	installationExitRecovery: installationExitRecoverySchema.optional(),
+	error: z.string().optional()
+}).refine((record) => record.releasedReason === "installation-exited" ? record.state === "released" && record.installationExitRecovery !== void 0 : record.installationExitRecovery === void 0, { message: "Installation exit recovery requires its distinct release reason and forensic evidence." });
+function resolveManagedJournal(journalPath) {
+	const selected = journalPath ?? process.env["WEAPP_IDE_MANAGED_PROJECT_JOURNAL"];
+	return selected?.trim() ? path.resolve(selected) : void 0;
+}
+function managedRecordPath(journalPath, id) {
+	return path.join(journalPath, `${idSchema.parse(id)}.json`);
+}
+async function readManagedRecord(journalPath, id) {
+	const file = managedRecordPath(journalPath, id);
+	if (!(await fs.lstat(file)).isFile()) throw new Error("Managed DevTools journal record is not a regular file.");
+	const record = recordSchema.parse(JSON.parse(await fs.readFile(file, "utf8")));
+	if (record.id !== id || record.journalPath !== journalPath || !path.isAbsolute(record.projectPath)) throw new Error("Managed DevTools journal identity does not match its task directory.");
+	return record;
+}
+async function writeManagedRecord(record) {
+	record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	recordSchema.parse(record);
+	const file = managedRecordPath(record.journalPath, record.id);
+	const temporary = `${file}.${randomUUID()}.tmp`;
+	try {
+		await fs.writeFile(temporary, `${JSON.stringify(record, null, 2)}\n`, {
+			mode: 384,
+			flag: "wx"
+		});
+		await fs.rename(temporary, file);
+	} finally {
+		await fs.rm(temporary, { force: true });
+	}
+}
+/** 仅递归当前任务明确传递的 children；不扫描用户缓存，不跟随符号链接。 */
+async function readManagedWechatProjectRecords(journalPath) {
+	const directory = resolveManagedJournal(journalPath);
+	if (!directory) return [];
+	const entries = await fs.readdir(directory, { withFileTypes: true }).catch((error) => {
+		if (error.code === "ENOENT") return;
+		throw error;
+	});
+	if (!entries) return [];
+	const scope = await resolveManagedJournalScope(directory);
+	const records = [];
+	for (const entry of entries) if (entry.name.endsWith(".json")) records.push(await readManagedRecord(directory, entry.name.slice(0, -5)));
+	else if (entry.name === "children") {
+		if (!entry.isDirectory()) throw new Error("Managed DevTools child journals must be regular directories.");
+		const children = await fs.readdir(path.join(directory, "children"), { withFileTypes: true });
+		for (const child of children) {
+			if (!child.isDirectory()) throw new Error("Managed DevTools child journal is not a regular directory.");
+			const childPath = path.join(directory, "children", child.name);
+			const childScope = await resolveManagedJournalScope(childPath);
+			if ((scope.scopeId !== void 0 || childScope.scopeId !== void 0) && (scope.scopeId !== childScope.scopeId || scope.rootPath !== childScope.rootPath)) throw new Error("Managed DevTools journal scope changed inside its registered children; refusing another task tree.");
+			records.push(...await readManagedWechatProjectRecords(childPath));
+		}
+	}
+	return records;
+}
+const lockOwnerSchema = z.object({
+	token: idSchema,
+	identity: hostSchema
+});
+async function readLockOwner(lock) {
+	return fs.readFile(path.join(lock, "owner"), "utf8").then((value) => lockOwnerSchema.parse(JSON.parse(value))).catch((error) => {
+		if (error.code === "ENOENT") return;
+		throw error;
+	});
+}
+async function releaseDeadLock(lock) {
+	const owner = await readLockOwner(lock);
+	if (!owner) return false;
+	const live = await readManagedProcessIdentity(owner.identity.pid);
+	if (live && sameManagedProcess(live, owner.identity)) return false;
+	const current = await readLockOwner(lock);
+	if (!current || current.token !== owner.token || !sameManagedProcess(current.identity, owner.identity)) return false;
+	await fs.rm(lock, { recursive: true });
+	return true;
+}
+/** 工作进程退出后父进程可回收其锁；未知身份或不完整锁保持阻塞。 */
+async function withManagedJournalDirectoryLock(directory, run) {
+	await fs.mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const lock = path.join(directory, ".ownership-lock");
+	const token = randomUUID();
+	const identity = await readManagedJournalWriterIdentity();
+	const deadline = Date.now() + 45e3;
+	while (true) {
+		if (await mutateLease(lock, async () => {
+			try {
+				await fs.mkdir(lock, { mode: 448 });
+			} catch (error) {
+				if (error.code !== "EEXIST") throw error;
+				if (!await releaseDeadLock(lock)) return false;
+				await fs.mkdir(lock, { mode: 448 });
+			}
+			await fs.writeFile(path.join(lock, "owner"), JSON.stringify({
+				token,
+				identity
+			}), {
+				mode: 384,
+				flag: "wx"
+			});
+			return true;
+		}, { timeoutMs: Math.max(0, deadline - Date.now()) })) break;
+		if (Date.now() >= deadline) throw new Error("Managed DevTools journal is still owned by another operation; refusing concurrent cleanup.");
+		await setTimeout(25);
+	}
+	const releaseLock = () => mutateLease(lock, async () => {
+		const owner = await readLockOwner(lock);
+		if (!owner || owner.token !== token || !sameManagedProcess(owner.identity, identity)) throw new Error("Managed DevTools journal lock ownership changed; refusing cleanup.");
+		await fs.rm(lock, { recursive: true });
+	}, { timeoutMs: 45e3 });
+	try {
+		return await run();
+	} finally {
+		await releaseLock();
+	}
+}
+/** 兄弟 journal 的检查和登记共用根锁，关闭、确认和失败更新也不能绕过该边界。 */
+async function withManagedJournalLock(directory, run) {
+	await fs.mkdir(directory, {
+		recursive: true,
+		mode: 448
+	});
+	const scope = await resolveManagedJournalScope(directory);
+	return await withManagedJournalDirectoryLock(scope.rootPath, async () => {
+		const current = await resolveManagedJournalScope(directory);
+		if (current.rootPath !== scope.rootPath || scope.scopeId !== void 0 && current.scopeId !== scope.scopeId) throw new Error("Managed DevTools journal scope changed while waiting for its lock.");
+		return await run(scope.rootPath);
+	});
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/windowBudget.ts
+function maximumOwnedWindows(options) {
+	const selected = options.maxOwnedWindows ?? process.env["WEAPP_IDE_MANAGED_PROJECT_MAX_WINDOWS"] ?? 1;
+	if (selected !== 1 && selected !== 2 && selected !== "1" && selected !== "2") throw new Error("Managed DevTools maximum owned windows must be 1 or 2.");
+	return Number(selected);
+}
+function sameTarget(first, second) {
+	return first.installationId === second.installationId && first.cliPath === second.cliPath && first.appPath === second.appPath && first.profileDir === second.profileDir && first.version === second.version && first.channel === second.channel;
+}
+/** 调用方持有根日志锁；重复项目必须只连接已有端点，不能再次派发可能开窗的启动命令。 */
+function checkManagedWindowBudget(records, options) {
+	const maximum = maximumOwnedWindows(options);
+	const projectPath = path.resolve(options.projectPath);
+	if (records.some((record) => record.state !== "released" && record.projectPath === projectPath && sameTarget(record.target, options.target))) throw new Error("Managed DevTools project already has an active session; use its existing endpoint in connect-only mode instead of starting it again.");
+	const owned = records.filter((record) => record.state === "owned").length;
+	if (owned >= maximum) throw new Error(`Managed DevTools window budget exhausted (${owned}/${maximum}); close the previous owned project before another start.`);
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/windowClose/logCursor.ts
+const readLimit = 2097152;
+const scanLimit = 33554432;
+const scanChunkSize = 65536;
+const headerLimit = 4096;
+const emptyAnchor = createHash("sha256").digest("hex");
+async function selectedLogDirectory(profileDir) {
+	const selected = await fs.realpath(profileDir);
+	const directory = path.join(selected, "WeappLog", "logs");
+	if (await fs.realpath(directory) !== directory) throw new Error("Managed DevTools window-close logs must belong to the selected profile without redirected log directories.");
+	return directory;
+}
+async function logFiles(directory) {
+	const entries = (await fs.readdir(directory, { withFileTypes: true })).filter((entry) => entry.name.endsWith(".log"));
+	if (!entries.length || entries.some((entry) => !entry.isFile())) throw new Error("Managed DevTools window-close evidence requires regular logs in the selected profile.");
+	return entries.map((entry) => entry.name).sort();
+}
+function identity(stat) {
+	return `${stat.dev}:${stat.ino}`;
+}
+/** 文件身份保留完整整数；只有已核验范围的字节位置才能交给 Node 读取 API。 */
+function logSize(stat) {
+	if (stat.size < 0n || stat.size > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("Managed DevTools window-close log size exceeds the supported safe integer range.");
+	return Number(stat.size);
+}
+async function readBytes(file, offset, size) {
+	const buffer = Buffer.alloc(size);
+	const { bytesRead } = await file.read(buffer, 0, size, offset);
+	return buffer.subarray(0, bytesRead);
+}
+async function anchorAt(file, offset) {
+	const start = Math.max(0, offset - 256);
+	return createHash("sha256").update(await readBytes(file, start, offset - start)).digest("hex");
+}
+async function anchorAfterBytes(file, offset, bytes) {
+	const before = Math.min(offset, Math.max(0, 256 - bytes.length));
+	const prefix = before ? await readBytes(file, offset - before, before) : Buffer.alloc(0);
+	return createHash("sha256").update(prefix).update(bytes.subarray(Math.max(0, bytes.length - 256))).digest("hex");
+}
+async function openLogFile(directory, name) {
+	const filename = path.join(directory, name);
+	const before = await fs.lstat(filename, { bigint: true });
+	if (!before.isFile()) throw new Error("Managed DevTools window-close log must be a regular file without redirection.");
+	const file = await fs.open(filename, "r");
+	try {
+		const after = await file.stat({ bigint: true });
+		if (!after.isFile() || identity(after) !== identity(before)) throw new Error("Managed DevTools window-close log changed while opening its evidence stream.");
+		return file;
+	} catch (error) {
+		await file.close();
+		throw error;
+	}
+}
+/** 主进程日志汇聚多个来源，轮转后的首条记录可能来自 BACKEND；只识别固定偏移内的完整行。 */
+async function hasMainRecord(file, size, productVersion) {
+	const prefix = Buffer.alloc(headerLimit);
+	let prefixSize = 0;
+	for (let offset = 0; offset < size;) {
+		const bytes = await readBytes(file, offset, Math.min(size - offset, scanChunkSize));
+		if (!bytes.length) return false;
+		offset += bytes.length;
+		for (let start = 0; start < bytes.length;) {
+			const newline = bytes.indexOf(10, start);
+			const end = newline < 0 ? bytes.length : newline;
+			prefixSize += bytes.copy(prefix, prefixSize, start, Math.min(end, start + headerLimit - prefixSize));
+			if (newline < 0) break;
+			const line = prefix.toString("utf8", 0, prefixSize);
+			if (/^\[[^\]\r\n]+\]\[[A-Z]+\]\[([^\]\r\n]+)\]\[MAIN\]/.exec(line)?.[1] === productVersion) return true;
+			prefixSize = 0;
+			start = newline + 1;
+		}
+	}
+	return false;
+}
+function requireUniqueMain(cursors) {
+	if (cursors.length !== 1) throw new Error("Managed DevTools window-close evidence requires one unambiguous MAIN log for the selected product version.");
+	return cursors;
+}
+/** 只接受已核验主进程持有的同一常规文件，不按名称或历史日志内容猜测。 */
+async function captureActiveLogCursor(directory, active) {
+	if (!/^[^/\\]+\.log$/.test(active.name)) throw new Error("Managed DevTools active log must belong to the selected log directory.");
+	const file = await openLogFile(directory, active.name);
+	try {
+		const stat = await file.stat({ bigint: true });
+		if (identity(stat) !== active.identity) throw new Error("Managed DevTools active log changed before its close cursor was captured.");
+		const size = logSize(stat);
+		const last = size ? await readBytes(file, size - 1, 1) : void 0;
+		return [{
+			name: active.name,
+			identity: identity(stat),
+			offset: size,
+			anchor: await anchorAt(file, size),
+			skipPartialLine: last !== void 0 && last[0] !== 10
+		}];
+	} finally {
+		await file.close();
+	}
+}
+async function validateCursor(file, cursor) {
+	if (!Number.isSafeInteger(cursor.offset) || cursor.offset < 0) throw new Error("Managed DevTools window-close log cursor offset exceeds the supported safe integer range.");
+	const stat = await file.stat({ bigint: true });
+	const size = logSize(stat);
+	if (!stat.isFile() || identity(stat) !== cursor.identity || size < cursor.offset || await anchorAt(file, cursor.offset) !== cursor.anchor) throw new Error("Managed DevTools window-close log was replaced, truncated, or rewritten; destruction evidence is unresolved.");
+	return size;
+}
+/** 关闭前固定唯一 MAIN 流；辅助日志和历史空日志不属于窗口销毁证据。 */
+async function captureLogCursors(directory, productVersion) {
+	const cursors = [];
+	for (const name of await logFiles(directory)) {
+		const file = await openLogFile(directory, name);
+		try {
+			const stat = await file.stat({ bigint: true });
+			const size = logSize(stat);
+			if (!await hasMainRecord(file, size, productVersion)) continue;
+			const last = size ? await readBytes(file, size - 1, 1) : void 0;
+			cursors.push({
+				name,
+				identity: identity(stat),
+				offset: size,
+				anchor: await anchorAt(file, size),
+				skipPartialLine: last !== void 0 && last[0] !== 10
+			});
+		} finally {
+			await file.close();
+		}
+	}
+	return requireUniqueMain(cursors);
+}
+/** 旧整目录门禁只能从原游标收窄；非空证据丢失或新文件均不能补充候选。 */
+async function recoverLogCursors(directory, cursors, productVersion) {
+	const main = [];
+	for (const cursor of cursors) {
+		let file;
+		try {
+			file = await openLogFile(directory, cursor.name);
+		} catch (error) {
+			if (error.code === "ENOENT" && cursor.offset === 0 && cursor.anchor === emptyAnchor && !cursor.skipPartialLine) continue;
+			throw error;
+		}
+		try {
+			await validateCursor(file, cursor);
+			if (await hasMainRecord(file, cursor.offset, productVersion)) main.push({ ...cursor });
+		} finally {
+			await file.close();
+		}
+	}
+	return requireUniqueMain(main);
+}
+/** 固定本轮所有流的终点并逐块消费；未完成的新增尾行、文件替换或截断均不能提前证明关闭成功。 */
+async function consumeFreshLogLines(directory, cursors, consume) {
+	const streams = [];
+	let pending = 0;
+	let drained = true;
+	try {
+		for (const cursor of cursors) {
+			const file = await openLogFile(directory, cursor.name);
+			const stream = {
+				file,
+				cursor,
+				original: { ...cursor },
+				end: cursor.offset
+			};
+			streams.push(stream);
+			stream.end = await validateCursor(file, cursor);
+			pending += stream.end - cursor.offset;
+			if (pending > scanLimit) throw new Error("Managed DevTools window-close log backlog exceeds the supported evidence limit.");
+		}
+		for (const { file, cursor, end } of streams) while (cursor.offset < end) {
+			const size = Math.min(end - cursor.offset, readLimit);
+			const bytes = await readBytes(file, cursor.offset, size);
+			if (bytes.length !== size) throw new Error("Managed DevTools window-close log became shorter during its evidence read.");
+			const newline = bytes.lastIndexOf(10);
+			if (newline < 0) {
+				if (bytes.length === readLimit) throw new Error("Managed DevTools window-close log line exceeds the supported evidence limit.");
+				drained = false;
+				break;
+			}
+			const anchor = await anchorAfterBytes(file, cursor.offset, bytes.subarray(0, newline + 1));
+			for (let start = 0; start <= newline;) {
+				const lineEnd = bytes.indexOf(10, start);
+				if (cursor.skipPartialLine) cursor.skipPartialLine = false;
+				else {
+					const textEnd = bytes[lineEnd - 1] === 13 ? lineEnd - 1 : lineEnd;
+					consume({
+						fileIdentity: cursor.identity,
+						line: bytes.toString("utf8", start, textEnd)
+					});
+				}
+				start = lineEnd + 1;
+			}
+			cursor.offset += newline + 1;
+			cursor.anchor = anchor;
+		}
+		for (const { file, cursor, original, end } of streams) {
+			await validateCursor(file, original);
+			await validateCursor(file, cursor);
+			const stat = await fs.lstat(path.join(directory, cursor.name), { bigint: true });
+			if (!stat.isFile() || identity(stat) !== cursor.identity || logSize(stat) < end) throw new Error("Managed DevTools window-close log changed while reading its evidence stream.");
+		}
+		return drained;
+	} finally {
+		await Promise.all(streams.map(({ file }) => file.close()));
+	}
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/windowClose/activeLog.ts
+const inspectionOptions = {
+	timeout: 3e3,
+	reject: false,
+	windowsHide: true
+};
+function invalidLog(reason) {
+	return /* @__PURE__ */ new Error(`Managed DevTools active MAIN log ${reason}; destruction evidence is unresolved.`);
+}
+async function parentPid(pid) {
+	const result = await execa("ps", [
+		"-p",
+		String(pid),
+		"-o",
+		"ppid="
+	], inspectionOptions);
+	const value = result.stdout.trim();
+	const parent = Number(value);
+	if (result.exitCode !== 0 || !/^\d+$/.test(value) || !Number.isSafeInteger(parent) || parent <= 0 || parent === pid) throw invalidLog("parent process could not be verified");
+	return parent;
+}
+async function currentIdentity(expected) {
+	const live = await readManagedProcessIdentity(expected.pid, "darwin");
+	if (!live || !sameManagedProcess(expected, live)) throw invalidLog("process identity changed");
+	return live;
+}
+async function selectedInstallation(record) {
+	const cliPath = await fs.realpath(record.target.cliPath);
+	const macos = path.dirname(cliPath);
+	const contents = path.dirname(macos);
+	const bundle = path.dirname(contents);
+	const appPath = await fs.realpath(record.target.appPath);
+	if (path.basename(macos) !== "MacOS" || path.basename(contents) !== "Contents" || !bundle.endsWith(".app") || ![
+		"app.asar",
+		"app",
+		"package.nw"
+	].some((name) => appPath === path.join(contents, "Resources", name))) throw invalidLog("CLI and application resources do not identify one selected bundle");
+	return {
+		cliPath,
+		appPath,
+		bundle
+	};
+}
+async function assertLogDirectory(record, directory) {
+	const profile = await fs.realpath(record.target.profileDir);
+	if (directory !== path.join(profile, "WeappLog", "logs") || await fs.realpath(directory) !== directory) throw invalidLog("directory was redirected or does not belong to the selected profile");
+}
+async function mainHost(record, bundlePath) {
+	const backend = await currentIdentity(record.host);
+	const executable = await fs.realpath(backend.executable);
+	const expected = path.join(bundlePath, "Contents", "MacOS", "Electron");
+	if (executable === expected) return backend;
+	if (!executable.startsWith(`${bundlePath}${path.sep}`)) throw invalidLog("backend belongs to a different installation");
+	const main = await readManagedProcessIdentity(await parentPid(backend.pid), "darwin");
+	if (!main || await fs.realpath(main.executable) !== expected) throw invalidLog("parent does not belong to the selected main executable");
+	const mainStarted = Date.parse(main.started);
+	const backendStarted = Date.parse(backend.started);
+	if (!Number.isFinite(mainStarted) || !Number.isFinite(backendStarted) || mainStarted > backendStarted) throw invalidLog("parent process generation is inconsistent");
+	return main;
+}
+/** NUL 字段保留文件名中的空白与换行；每个描述符必须来自唯一指定进程。 */
+function parseOpenFiles(output, pid) {
+	const files = [];
+	const properties = {
+		a: "access",
+		t: "type",
+		D: "device",
+		i: "inode",
+		k: "links",
+		n: "filename"
+	};
+	let processSeen = false;
+	let current;
+	for (const raw of output.split("\0")) {
+		const field = raw.replace(/^\n/, "");
+		if (!field) continue;
+		const key = field[0];
+		const value = field.slice(1);
+		if (key === "p") {
+			if (processSeen || value !== String(pid)) throw invalidLog("file descriptors belong to an ambiguous process");
+			processSeen = true;
+		} else if (key === "f" && processSeen) {
+			current = { descriptor: value };
+			files.push(current);
+		} else if (current && key in properties) {
+			const property = properties[key];
+			if (current[property] !== void 0) throw invalidLog("file descriptor fields are ambiguous");
+			current[property] = value;
+		} else throw invalidLog("file descriptor output could not be verified");
+	}
+	if (!processSeen) throw invalidLog("main process has no file descriptor evidence");
+	return files;
+}
+async function existingLog(file, directory) {
+	if (!/^\d+$/.test(file.descriptor) || !["w", "u"].includes(file.access ?? "") || file.type !== "REG" || !file.filename?.endsWith(".log") || path.dirname(file.filename) !== directory) return;
+	if (!file.links || !/^\d+$/.test(file.links) || !file.device || !/^0x[\da-f]+$/i.test(file.device) || !file.inode || !/^\d+$/.test(file.inode)) throw invalidLog("file descriptor identity could not be verified");
+	if (BigInt(file.links) === 0n) return;
+	const stat = await fs.lstat(file.filename, { bigint: true });
+	if (!stat.isFile() || await fs.realpath(file.filename) !== file.filename || stat.dev !== BigInt(file.device) || stat.ino !== BigInt(file.inode) || stat.nlink !== BigInt(file.links)) throw invalidLog("file was redirected or replaced");
+	return {
+		name: path.basename(file.filename),
+		identity: `${stat.dev}:${stat.ino}`
+	};
+}
+async function readWritableLogs(pid, directory) {
+	const result = await execa("lsof", [
+		"-nP",
+		"-a",
+		"-p",
+		String(pid),
+		"-F0pftainDk"
+	], inspectionOptions);
+	if (result.exitCode !== 0) throw invalidLog("file descriptor inspection failed");
+	const files = parseOpenFiles(result.stdout, pid);
+	const candidates = [];
+	for (const file of files) {
+		const candidate = await existingLog(file, directory);
+		if (candidate) candidates.push({
+			file,
+			...candidate
+		});
+	}
+	if (!candidates.length) throw invalidLog("requires at least one verified writable file");
+	const descriptors = /* @__PURE__ */ new Set();
+	const identities = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		if (descriptors.has(candidate.file.descriptor) || identities.has(candidate.identity) && identities.get(candidate.identity) !== candidate.name) throw invalidLog("file descriptors contain ambiguous aliases");
+		descriptors.add(candidate.file.descriptor);
+		identities.set(candidate.identity, candidate.name);
+	}
+	return candidates.sort((a, b) => Number(a.file.descriptor) - Number(b.file.descriptor));
+}
+/** 仅用已登记 backend 的直接父进程固定全部活动流；游标捕获前后核验完整描述符集合，不授予父进程清理权。 */
+async function captureActiveMainLogCursors(record, directory, platform = process.platform) {
+	if (platform !== "darwin" || !record.host) return;
+	await assertLogDirectory(record, directory);
+	const installation = await selectedInstallation(record);
+	const main = await mainHost(record, installation.bundle);
+	const candidates = await readWritableLogs(main.pid, directory);
+	const cursors = [];
+	for (const candidate of candidates) if (!cursors.some((cursor) => cursor.identity === candidate.identity)) cursors.push(...await captureActiveLogCursor(directory, candidate));
+	const retained = await readWritableLogs(main.pid, directory);
+	if (retained.length !== candidates.length || retained.some((file, index) => {
+		const candidate = candidates[index];
+		return file.file.descriptor !== candidate.file.descriptor || file.name !== candidate.name || file.identity !== candidate.identity || file.file.access !== candidate.file.access || file.file.links !== candidate.file.links;
+	})) throw invalidLog("file descriptor set changed during capture");
+	const after = await mainHost(record, installation.bundle);
+	const selected = await selectedInstallation(record);
+	if (!sameManagedProcess(main, after) || selected.appPath !== installation.appPath || selected.cliPath !== installation.cliPath || selected.bundle !== installation.bundle) throw invalidLog("main process or selected directory changed");
+	await assertLogDirectory(record, directory);
+	for (const candidate of candidates) {
+		const verified = await existingLog(candidate.file, directory);
+		if (!verified || verified.identity !== candidate.identity) throw invalidLog("file changed during capture");
+	}
+	return {
+		cursors,
+		host: main
+	};
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/windowClose/protocol.ts
+function decodeString(value) {
+	const quote = value[0];
+	if (!quote || ![
+		"'",
+		"\"",
+		"`"
+	].includes(quote) || value.at(-1) !== quote) return;
+	let result = "";
+	for (let index = 1; index < value.length - 1; index++) {
+		const char = value[index];
+		if (char === quote) throw new Error("Unsupported quoted window-close evidence.");
+		if (char !== "\\") {
+			result += char;
+			continue;
+		}
+		const escaped = value[++index];
+		if ([
+			"\\",
+			"'",
+			"\"",
+			"`"
+		].includes(escaped)) result += escaped;
+		else if (escaped === "x" || escaped === "u") {
+			const length = escaped === "x" ? 2 : 4;
+			const digits = value.slice(index + 1, index + 1 + length);
+			if (digits.length !== length || !/^[\da-f]+$/i.test(digits)) throw new Error("Unsupported escaped window-close evidence.");
+			result += String.fromCharCode(Number.parseInt(digits, 16));
+			index += length;
+		} else {
+			const escapes = {
+				n: "\n",
+				r: "\r",
+				t: "	",
+				b: "\b",
+				f: "\f",
+				v: "\v",
+				0: "\0"
+			};
+			if (!(escaped in escapes)) throw new Error("Unsupported escaped window-close evidence.");
+			result += escapes[escaped];
+		}
+	}
+	return result;
+}
+/** 只读取 inspect 对象的顶层标量；日志从不作为 JavaScript 执行。 */
+function fields(source) {
+	if (!source.startsWith("{") || !source.endsWith("}")) throw new Error("Incomplete window-close trace object.");
+	const parts = [];
+	let quote = "";
+	let depth = 0;
+	let start = 1;
+	for (let index = 1; index < source.length - 1; index++) {
+		const char = source[index];
+		if (quote) {
+			if (char === "\\") index++;
+			else if (char === quote) quote = "";
+		} else if ([
+			"'",
+			"\"",
+			"`"
+		].includes(char)) quote = char;
+		else if (char === "{" || char === "[") depth++;
+		else if (char === "}" || char === "]") depth--;
+		else if (char === "," && depth === 0) {
+			parts.push(source.slice(start, index));
+			start = index + 1;
+		}
+	}
+	if (quote || depth !== 0) throw new Error("Incomplete window-close trace fields.");
+	parts.push(source.slice(start, -1));
+	const result = /* @__PURE__ */ new Map();
+	for (const part of parts) {
+		const match = /^(\w+):([\s\S]+)$/.exec(part.trim());
+		if (!match || result.has(match[1])) throw new Error("Ambiguous window-close trace fields.");
+		const value = match[2].trim();
+		result.set(match[1], value === "true" ? true : value === "false" ? false : /^\d+$/.test(value) ? Number(value) : decodeString(value));
+	}
+	return result;
+}
+/** 目前核对过的协议来自所选 Stable 2.02.2608070 的主进程关闭日志。 */
+function consumeWindowCloseTrace(evidence, projectPath, input) {
+	if (/^\[[^\]]+\]\[(?:WARN|INFO)\]\[[^\]]+\]\[MAIN\].*\benvMessagerService setuped\s*$/.test(input.line)) throw new Error("Managed DevTools MAIN log restarted after the close cursor; host generation is unresolved.");
+	const match = /^\[([^\]]+)\]\[(?:WARN|INFO)\]\[([^\]]+)\]\[MAIN\].*? \[win-close-trace\] ([\w:-]+) (.*)$/.exec(input.line);
+	if (!match) return;
+	const [, timestamp, version, event, source] = match;
+	if (![
+		"native-close-call",
+		"close-requested",
+		"native-window-close-cancelled",
+		"native-window-closed",
+		"webcontents-destroyed"
+	].includes(event)) return;
+	if (version !== evidence.productVersion) throw new Error("Managed DevTools window-close trace belongs to a different product version.");
+	const at = new Date(timestamp.replace(" ", "T")).toISOString();
+	if (at < evidence.capturedAt) throw new Error("Managed DevTools window-close trace predates this close attempt.");
+	const values = fields(source);
+	const winId = values.get("winId");
+	if (typeof winId !== "string" || !winId) throw new Error("Managed DevTools window-close trace has no window identity.");
+	const sameWindow = evidence.window?.winId === winId && evidence.window.fileIdentity === input.fileIdentity;
+	if (event === "native-close-call") {
+		const browserWindowId = values.get("browserWindowId");
+		if (typeof browserWindowId !== "number" || !Number.isSafeInteger(browserWindowId) || browserWindowId <= 0) throw new Error("Managed DevTools close call has no native window identity.");
+		if (sameWindow && (browserWindowId !== evidence.window.browserWindowId || values.get("forceClose") !== true)) throw new Error("Managed DevTools window-close identity was reused or another close was requested.");
+		if (values.get("forceClose") === false) {
+			evidence.calls.push({
+				fileIdentity: input.fileIdentity,
+				winId,
+				browserWindowId,
+				calledAt: at
+			});
+			if (evidence.calls.length > 100) throw new Error("Managed DevTools close call evidence is ambiguous.");
+		}
+	} else if (event === "close-requested") {
+		const projectId = values.get("projectId");
+		if (!(typeof projectId === "string" && path.isAbsolute(projectId) && path.normalize(projectId) === path.normalize(projectPath))) {
+			if (sameWindow) throw new Error("Managed DevTools window-close project identity changed.");
+			return;
+		}
+		const calls = evidence.calls.filter((call) => call.winId === winId && call.fileIdentity === input.fileIdentity);
+		const runtimeId = values.get("runtimeId");
+		if (evidence.window || calls.length !== 1 || calls[0].cancelled || typeof runtimeId !== "string" || !runtimeId || values.get("windowType") !== "project" || values.get("status") !== "opened" || calls[0].calledAt > at) throw new Error("Managed DevTools exact project close request has ambiguous window identity.");
+		evidence.window = {
+			...calls[0],
+			runtimeId,
+			requestedAt: at
+		};
+	} else if (event === "native-window-close-cancelled") {
+		for (const call of evidence.calls.filter((call) => call.winId === winId && call.fileIdentity === input.fileIdentity)) call.cancelled = true;
+		if (sameWindow) throw new Error("Managed DevTools exact project close was cancelled.");
+	} else if (sameWindow && evidence.window) {
+		if (at < evidence.window.requestedAt) throw new Error("Managed DevTools window destruction predates its exact close request.");
+		if (event === "native-window-closed") {
+			if (values.get("wasClosing") !== true) throw new Error("Managed DevTools native window closed without its pending close request.");
+			evidence.window.nativeClosedAt = at;
+		} else if (event === "webcontents-destroyed") {
+			if (values.get("browserWindowId") !== evidence.window.browserWindowId || values.get("destroyed") !== true) throw new Error("Managed DevTools webcontents destruction has a different native window identity.");
+			evidence.window.webContentsDestroyedAt = at;
+		}
+	}
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/windowClose.ts
+/** 只捕获本次显式安装的日志，必须先于关闭命令持久化。 */
+async function captureManagedWindowClose(record) {
+	if (!record.target.version) throw new Error("Managed DevTools window-close evidence requires the selected product version.");
+	const profileDir = await fs.realpath(record.target.profileDir);
+	const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const directory = await selectedLogDirectory(profileDir);
+	const active = await captureActiveMainLogCursors(record, directory);
+	const cursors = active ? active.cursors : await captureLogCursors(directory, record.target.version);
+	return {
+		protocol: "wechat-devtools-window-close-trace-v1",
+		profileDir,
+		productVersion: record.target.version,
+		capturedAt,
+		...active ? { mainHost: active.host } : {},
+		cursors,
+		calls: []
+	};
+}
+/** 持久化每轮证据，worker 退出后只能续读同一游标，不能重新关闭同路径。 */
+async function waitForManagedWindowClosed(record, persist, options = {}) {
+	const evidence = record.windowClose;
+	if (!evidence || !evidence.dispatchedAt) throw new Error("Managed DevTools project close has no durable native-window evidence cursor.");
+	if (evidence.failure) {
+		if (evidence.failure !== "Managed DevTools window-close log set changed; host generation or log rotation is unresolved.") throw new Error(evidence.failure);
+		if (await fs.realpath(record.target.profileDir) !== evidence.profileDir || record.target.version !== evidence.productVersion) throw new Error("Managed DevTools window-close evidence no longer matches its selected installation.");
+		const cursors = await recoverLogCursors(await selectedLogDirectory(evidence.profileDir), evidence.cursors, evidence.productVersion);
+		const mainIdentity = cursors[0].identity;
+		if (evidence.calls.some((call) => call.fileIdentity !== mainIdentity) || evidence.window && evidence.window.fileIdentity !== mainIdentity) throw new Error("Managed DevTools legacy window-close references do not belong to its original MAIN evidence stream.");
+		evidence.logInventoryRecovery = {
+			failure: evidence.failure,
+			cursors: evidence.cursors.map((cursor) => ({ ...cursor }))
+		};
+		evidence.cursors = cursors;
+		delete evidence.failure;
+		await persist();
+	}
+	const deadline = Date.now() + (options.timeoutMs ?? 15e3);
+	do {
+		let drained = false;
+		try {
+			if (await fs.realpath(record.target.profileDir) !== evidence.profileDir || record.target.version !== evidence.productVersion) throw new Error("Managed DevTools window-close evidence no longer matches its selected installation.");
+			if (evidence.mainHost) {
+				const current = await readManagedProcessIdentity(evidence.mainHost.pid);
+				if (!current || !sameManagedProcess(current, evidence.mainHost)) throw new Error("Managed DevTools main log owner changed; destruction evidence is unresolved.");
+			}
+			drained = await consumeFreshLogLines(await selectedLogDirectory(evidence.profileDir), evidence.cursors, (line) => {
+				consumeWindowCloseTrace(evidence, record.projectPath, line);
+			});
+		} catch (error) {
+			evidence.failure = error instanceof Error ? error.message : String(error);
+			await persist();
+			throw error;
+		}
+		await persist();
+		if (drained && evidence.window?.nativeClosedAt && evidence.window.webContentsDestroyedAt) return;
+		if (Date.now() >= deadline) break;
+		await setTimeout(options.pollMs ?? 100);
+	} while (true);
+	throw new Error("Managed DevTools project close has no complete native-window destruction evidence; stop the acceptance lane.");
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/installationExit/darwin.ts
+const options = {
+	timeout: 1e4,
+	reject: false,
+	env: { LC_ALL: "C" }
+};
+const pathSchema = z.array(z.object({
+	pid: z.number().int().positive(),
+	executable: z.string().nullable()
+}).strict());
+const kernelPathsScript = `
+ObjC.import('Foundation');
+ObjC.bindFunction('malloc', ['void *', ['unsigned long']]);
+ObjC.bindFunction('free', ['void', ['void *']]);
+ObjC.bindFunction('proc_pidpath', ['int', ['int', 'void *', 'uint32_t']]);
+ObjC.bindFunction('strchr', ['char *', ['void *', 'int']]);
+function run(argv) {
+  var pids = JSON.parse(argv[0]);
+  var buffer = $.malloc(4096);
+  if (!buffer) throw new Error('Cannot allocate process path buffer.');
+  try {
+    return JSON.stringify(pids.map(function(pid) {
+      var count = $.proc_pidpath(pid, buffer, 4096);
+      return { pid: pid, executable: count > 0 ? $.strchr(buffer, 47) : null };
+    }));
+  } finally { $.free(buffer); }
+}
+`;
+/** ps 仅用于 PID、启动时间和僵尸状态，不能用可修改的 comm 代替实际可执行文件。 */
+async function readDarwinProcessStates() {
+	const inspection = execa("/bin/ps", ["-axo", "pid=,stat=,lstart="], options);
+	const inspectorPid = inspection.pid;
+	const result = await inspection;
+	if (result.exitCode !== 0 || result.stderr?.trim() || !result.stdout.trim()) throw new Error("Installation-exit recovery could not read the complete process inventory.");
+	const records = result.stdout.trim().split(/\r?\n/).map((line) => {
+		const match = /^\s*(\d+)\s+(\S+)\s+(\w{3}\s+\w{3}\s+\d+\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s*$/.exec(line);
+		const pid = Number(match?.[1]);
+		if (!match || !Number.isSafeInteger(pid) || pid <= 0) throw new Error("Installation-exit recovery found an unverifiable process inventory entry.");
+		return {
+			pid,
+			zombie: match[2].startsWith("Z"),
+			started: match[3].replace(/\s+/g, " ")
+		};
+	});
+	if (new Set(records.map((record) => record.pid)).size !== records.length) throw new Error("Installation-exit recovery found duplicate process identities.");
+	return records.filter((record) => record.pid !== inspectorPid);
+}
+/** 系统 JXA/libproc 不可用时明确拒绝恢复，不安装工具或以进程标题降级。 */
+async function readDarwinKernelPaths(pids) {
+	const result = await execa("/usr/bin/osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		kernelPathsScript,
+		JSON.stringify(pids)
+	], options);
+	if (result.exitCode !== 0 || result.stderr?.trim()) throw new Error("Installation-exit recovery cannot inspect kernel executable paths.");
+	let parsed;
+	try {
+		parsed = pathSchema.parse(JSON.parse(result.stdout));
+	} catch {
+		throw new Error("Installation-exit recovery received incomplete kernel executable paths.");
+	}
+	const entries = new Map(parsed.map((entry) => [entry.pid, entry.executable]));
+	if (entries.size !== pids.length || parsed.length !== pids.length || pids.some((pid) => !entries.has(pid))) throw new Error("Installation-exit recovery received incomplete kernel process identities.");
+	return entries;
+}
+/** 已删除可执行文件无法经 proc_pidpath 读取时，核验全部 program-text 映像而非猜测首项。 */
+async function readDarwinTextImages(pid) {
+	const result = await execa("/usr/sbin/lsof", [
+		"-nP",
+		"-a",
+		"-p",
+		String(pid),
+		"-d",
+		"txt",
+		"-F0pftn"
+	], options);
+	if (result.exitCode !== 0 || result.stderr?.trim()) throw new Error("Installation-exit recovery cannot inspect all executable text images.");
+	const fields = result.stdout.split("\0").map((field) => field.replace(/^\r?\n/, "")).filter(Boolean);
+	if (fields.shift() !== `p${pid}` || fields.length === 0 || fields.length % 3 !== 0) throw new Error("Installation-exit recovery received incomplete executable text images.");
+	const paths = [];
+	for (let index = 0; index < fields.length; index += 3) {
+		if (fields[index] !== "ftxt" || fields[index + 1] !== "tREG" || !fields[index + 2]?.startsWith("n")) throw new Error("Installation-exit recovery received unverifiable executable text images.");
+		paths.push(fields[index + 2].slice(1));
+	}
+	return paths;
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/installationExit/processes.ts
+/** 已删除映像仍有内核 vnode 路径；从现存祖先解析符号链接，不把缺失文件当成已退出进程。 */
+async function canonicalImagePath(file) {
+	if (!path.isAbsolute(file) || /[\r\n\0]/.test(file)) throw new Error("Installation-exit recovery received an unverifiable executable image path.");
+	try {
+		return await fs.realpath(file);
+	} catch (error) {
+		if (error.code !== "ENOENT" || path.dirname(file) === file) throw new Error("Installation-exit recovery cannot resolve an executable image path.", { cause: error });
+		return path.join(await canonicalImagePath(path.dirname(file)), path.basename(file));
+	}
+}
+/** 仅支持已验证的 macOS 全安装清单；未知平台、权限错误或不完整映像均拒绝推断退出。 */
+async function inspectExitedWechatInstallation(target, platform = process.platform) {
+	if (platform !== "darwin") throw new Error("Installation-exit recovery requires the verified macOS process inventory.");
+	const selectedRoot = resolveWechatDevtoolsInstallationRoot(target, platform);
+	if (!selectedRoot || !path.isAbsolute(selectedRoot) || !selectedRoot.endsWith(".app") || !target.appPath.includes("/Contents/")) throw new Error("Installation-exit recovery cannot resolve the selected application bundle.");
+	const installationRoot = await fs.realpath(selectedRoot);
+	let pending = await readDarwinProcessStates();
+	const verified = /* @__PURE__ */ new Map();
+	let kernelPathProcessCount = 0;
+	let textImageProcessCount = 0;
+	let exitedProcessCount = 0;
+	let zombieProcessCount = 0;
+	for (let round = 0; round < 3; round++) {
+		const kernelPaths = await readDarwinKernelPaths(pending.map((entry) => entry.pid));
+		const after = new Map((await readDarwinProcessStates()).map((entry) => [entry.pid, entry]));
+		for (const entry of pending) {
+			const current = after.get(entry.pid);
+			if (!current) {
+				exitedProcessCount++;
+				continue;
+			}
+			if (current.started !== entry.started) throw new Error("Installation-exit recovery process identity changed during inspection.");
+			if (entry.zombie && current.zombie) {
+				zombieProcessCount++;
+				verified.set(entry.pid, current);
+				continue;
+			}
+			const executable = kernelPaths.get(entry.pid);
+			const images = executable ? [executable] : await readDarwinTextImages(entry.pid);
+			if (!images.length) throw new Error("Installation-exit recovery received no verifiable executable text images.");
+			for (const image of images) {
+				const resolved = await canonicalImagePath(image);
+				const relative = path.relative(installationRoot, resolved);
+				if (!relative || !path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`)) throw new Error("The selected WeChat DevTools installation still has a live process; no ownership was recovered.");
+			}
+			if (executable) kernelPathProcessCount++;
+			else textImageProcessCount++;
+			verified.set(entry.pid, {
+				started: entry.started,
+				zombie: false
+			});
+		}
+		const final = await readDarwinProcessStates();
+		for (const entry of final) {
+			const previous = verified.get(entry.pid);
+			if (previous && (previous.started !== entry.started || previous.zombie && !entry.zombie)) throw new Error("Installation-exit recovery process identity changed during inspection.");
+		}
+		pending = final.filter((entry) => !verified.has(entry.pid));
+		if (!pending.length) break;
+	}
+	if (pending.length) throw new Error("Installation-exit recovery found continuing new process activity; retry after it becomes idle.");
+	return {
+		platform,
+		installationRoot,
+		checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		inspectedProcessCount: kernelPathProcessCount + textImageProcessCount,
+		kernelPathProcessCount,
+		textImageProcessCount,
+		exitedProcessCount,
+		zombieProcessCount,
+		selectedProcessCount: 0
+	};
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/installationExit/index.ts
+async function fingerprint(record) {
+	const file = managedRecordPath(record.journalPath, record.id);
+	const stat = await fs.lstat(file);
+	if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) throw new Error("Installation-exit recovery requires an unchanged regular journal record.");
+	return createHash("sha256").update(await fs.readFile(file)).digest("hex");
+}
+function canRecoverAfterExit(record) {
+	return record.state === "starting" || record.state === "unconfirmed" || record.state === "failed" && record.openedProjectWindow === true && record.host !== void 0 && record.port !== void 0 && record.error !== void 0;
+}
+async function recoverAfterExit(options) {
+	const { target, recoveryScope } = options;
+	await assertMachineE2ELeaseRecoveryScope(recoveryScope);
+	const journalPath = recoveryScope.cleanupKey;
+	if (!journalPath || !path.isAbsolute(journalPath) || path.resolve(journalPath) !== journalPath) throw new Error("Installation-exit recovery requires its exact registered journal cleanup key.");
+	const binding = await resolveManagedJournalScope(journalPath);
+	if (!binding.scopeId) throw new Error("Installation-exit recovery requires an explicitly registered task journal scope.");
+	return withManagedJournalLock(journalPath, async (rootPath) => {
+		if (rootPath !== binding.rootPath || !isDeepStrictEqual(await resolveManagedJournalScope(journalPath), binding)) throw new Error("Installation-exit recovery journal ownership changed.");
+		const records = await readManagedWechatProjectRecords(rootPath);
+		if (new Set(records.map((record) => record.id)).size !== records.length) throw new Error("Installation-exit recovery found duplicate record identities.");
+		if (records.some((record) => !isDeepStrictEqual(record.target, target))) throw new Error("Installation-exit recovery cannot include another installation or profile.");
+		if (records.some((record) => record.state !== "released" && !canRecoverAfterExit(record))) throw new Error("Installation-exit recovery refuses confirmed or unresolved project-close ownership.");
+		const candidates = (await readManagedWechatProjectRecords(journalPath)).filter(canRecoverAfterExit);
+		if (!candidates.length) {
+			await assertMachineE2ELeaseRecoveryScope(recoveryScope);
+			return { recoveredRecordIds: [] };
+		}
+		const before = new Map(await Promise.all(records.map(async (record) => [record.id, await fingerprint(record)])));
+		const ownerPids = [...new Set(records.map((record) => record.ownerPid))].sort((a, b) => a - b);
+		const ports = [...new Set(records.map((record) => record.port))];
+		if (ports.includes(void 0)) throw new Error("Installation-exit recovery requires every registered automator port.");
+		const closedPorts = ports.sort((a, b) => a - b);
+		const verifyExit = async () => {
+			await assertMachineE2ELeaseRecoveryScope(recoveryScope);
+			await assertManagedInstallation(target);
+			for (const pid of ownerPids) if (await readManagedProcessIdentity(pid)) throw new Error("Installation-exit recovery requires every journal owner process to have stopped.");
+			for (const port of closedPorts) if (!await isManagedPortClosed(port)) throw new Error("Installation-exit recovery found a live registered automator port.");
+			return inspectExitedWechatInstallation(target);
+		};
+		const assertUnchanged = async () => {
+			if (!isDeepStrictEqual(await resolveManagedJournalScope(journalPath), binding)) throw new Error("Installation-exit recovery journal ownership changed.");
+			const current = await readManagedWechatProjectRecords(rootPath);
+			if (!isDeepStrictEqual(current, records)) throw new Error("Installation-exit recovery journal records changed during verification.");
+			for (const record of current) if (await fingerprint(record) !== before.get(record.id)) throw new Error("Installation-exit recovery journal bytes changed during verification.");
+		};
+		await verifyExit();
+		await assertUnchanged();
+		const inspection = await verifyExit();
+		await assertUnchanged();
+		const recoveredRecordIds = [];
+		for (const record of candidates) {
+			await assertMachineE2ELeaseRecoveryScope(recoveryScope);
+			if (await fingerprint(record) !== before.get(record.id)) throw new Error("Installation-exit recovery journal bytes changed before recording recovery.");
+			const previousState = record.state;
+			if (previousState !== "starting" && previousState !== "unconfirmed" && previousState !== "failed") throw new Error("Installation-exit recovery cannot replace a confirmed ownership state.");
+			record.installationExitRecovery = {
+				protocol: "wechat-devtools-installation-exit-v1",
+				recoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+				recoveryScopeId: recoveryScope.id,
+				journalScopeId: binding.scopeId,
+				journalRootPath: rootPath,
+				installationId: target.installationId,
+				profileDir: target.profileDir,
+				previous: {
+					state: previousState,
+					error: record.error,
+					updatedAt: record.updatedAt,
+					recordSha256: before.get(record.id)
+				},
+				stoppedOwnerPids: ownerPids,
+				closedPorts,
+				processInspection: inspection
+			};
+			record.state = "released";
+			record.releasedReason = "installation-exited";
+			await writeManagedRecord(record);
+			recoveredRecordIds.push(record.id);
+		}
+		return { recoveredRecordIds };
+	});
+}
+/** 在精确恢复租约中终结已退出安装的未知启动或失败关窗；保留原证据，不补造销毁事件。 */
+function recoverManagedWechatProjectsAfterInstallationExit(options) {
+	return withMachineE2ELeaseRecoveryOperation(options.recoveryScope, () => recoverAfterExit(options));
+}
+//#endregion
+//#region src/devtoolsProjectOwnership/index.ts
+const pendingClosures = /* @__PURE__ */ new Map();
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function release(record, reason) {
+	record.state = "released";
+	record.releasedReason = reason;
+	delete record.error;
+	await writeManagedRecord(record);
+}
+async function closeRecord(record) {
+	if (record.state === "released") return;
+	if (record.state === "borrowed" && record.openedProjectWindow === false) {
+		await release(record, "borrowed");
+		return;
+	}
+	if (record.state === "starting" || record.state === "unconfirmed" || record.openedProjectWindow !== true || !record.host || !record.port) throw new Error("Managed DevTools project ownership is unconfirmed; refusing to close a project or start another task.");
+	try {
+		if (record.closeAcknowledgedAt || record.windowClose?.dispatchedAt) {
+			await waitForManagedWindowClosed(record, () => writeManagedRecord(record));
+			await waitForManagedPortClosed(record.port);
+			await release(record, "project-closed");
+			return;
+		}
+		const live = await readManagedProcessIdentity(record.host.pid);
+		if (!live) throw new Error("Managed DevTools automator listener exited without a confirmed project close; window ownership remains unresolved.");
+		if (!sameManagedProcess(live, record.host)) throw new Error("Managed DevTools host identity changed; no project was closed.");
+		if (await isManagedPortClosed(record.port)) throw new Error("Managed DevTools automator port disappeared without a confirmed project close; window ownership remains unresolved.");
+		await assertManagedInstallation(record.target);
+		if (!sameManagedProcess(await inspectManagedProjectHost(record.target, record.port), record.host)) throw new Error("Managed DevTools port belongs to a different host; no project was closed.");
+		record.state = "closing";
+		record.windowClose = await captureManagedWindowClose(record);
+		record.windowClose.dispatchedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await writeManagedRecord(record);
+		await execa(record.target.cliPath, [
+			"close",
+			"--project",
+			record.projectPath
+		], {
+			timeout: 3e4,
+			windowsHide: true
+		});
+		record.closeAcknowledgedAt = (/* @__PURE__ */ new Date()).toISOString();
+		await writeManagedRecord(record);
+		await waitForManagedWindowClosed(record, () => writeManagedRecord(record));
+		await waitForManagedPortClosed(record.port);
+		await release(record, "project-closed");
+	} catch (error) {
+		record.state = "failed";
+		record.error = describe(error);
+		await writeManagedRecord(record);
+		throw error;
+	}
+}
+/** 窗口销毁与连接断开分别验证；失败保留登记供后续继续观察。 */
+function closeManagedWechatProject(options) {
+	const journalPath = resolveManagedJournal(options.journalPath);
+	if (!journalPath) return Promise.reject(/* @__PURE__ */ new Error("Managed DevTools project cleanup requires its explicit task journal."));
+	const key = `${journalPath}\0${options.id}`;
+	let closing = pendingClosures.get(key);
+	if (!closing) {
+		closing = withMachineE2ELease(async () => withManagedJournalLock(journalPath, async () => closeRecord(await readManagedRecord(journalPath, options.id)))).finally(() => pendingClosures.delete(key));
+		pendingClosures.set(key, closing);
+	}
+	return closing;
+}
+/** 未启用受管日志时不改变公共共享会话；意图登记本身没有项目关闭权。 */
+async function beginManagedWechatProject(options) {
+	const journalPath = resolveManagedJournal(options.journalPath);
+	if (!journalPath) return;
+	const id = randomUUID();
+	await withManagedJournalLock(journalPath, async (scopeRoot) => {
+		const previous = await readManagedWechatProjectRecords(scopeRoot);
+		if (previous.some((record) => [
+			"starting",
+			"unconfirmed",
+			"closing",
+			"failed"
+		].includes(record.state))) throw new Error("Managed DevTools journal contains unresolved ownership or cleanup; refusing another project start.");
+		checkManagedWindowBudget(previous, options);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await writeManagedRecord({
+			schemaVersion: 1,
+			id,
+			generation: options.generation ?? id,
+			journalPath,
+			ownerToken: managedProcessToken,
+			ownerPid: process.pid,
+			target: { ...options.target },
+			projectPath: path.resolve(options.projectPath),
+			state: "starting",
+			port: options.port,
+			createdAt: now,
+			updatedAt: now
+		});
+	});
+	return {
+		id,
+		journalPath,
+		confirm: async (result) => {
+			await withManagedJournalLock(journalPath, async () => {
+				const record = await readManagedRecord(journalPath, id);
+				if (record.state !== "starting" && record.state !== "unconfirmed") throw new Error("Managed DevTools start receipt was already recorded.");
+				if (typeof result.openedProjectWindow !== "boolean" || !Number.isInteger(result.port) || result.port <= 0 || result.port > 65535 || record.port !== void 0 && record.port !== result.port) throw new Error("Managed DevTools start receipt does not match its requested port.");
+				record.openedProjectWindow = result.openedProjectWindow;
+				record.port = result.port;
+				record.state = result.openedProjectWindow ? "unconfirmed" : "borrowed";
+				await writeManagedRecord(record);
+				record.host = await inspectManagedProjectHost(record.target, result.port);
+				if (result.openedProjectWindow) record.state = "owned";
+				await writeManagedRecord(record);
+			});
+		},
+		fail: async (error) => {
+			await withManagedJournalLock(journalPath, async () => {
+				const record = await readManagedRecord(journalPath, id);
+				if (record.state === "released") return;
+				if (record.state === "starting") record.state = "unconfirmed";
+				record.error = describe(error);
+				await writeManagedRecord(record);
+			});
+		},
+		close: () => closeManagedWechatProject({
+			journalPath,
+			id
+		})
+	};
+}
+/** 父进程可回收已退出工作进程的确认所有权；未知启动结果严格阻止后续任务。 */
+async function cleanupManagedWechatProjects(options = {}) {
+	const records = await readManagedWechatProjectRecords(options.journalPath);
+	const errors = [];
+	for (const record of records) {
+		if (options.scope === "process" && record.ownerToken !== managedProcessToken) continue;
+		try {
+			await closeManagedWechatProject({
+				journalPath: record.journalPath,
+				id: record.id
+			});
+		} catch (error) {
+			errors.push(error);
+		}
+	}
+	if (errors.length) throw new AggregateError(errors, "Managed DevTools project cleanup remains incomplete; stop the acceptance lane.");
+}
+//#endregion
+export { readManagedRecord as a, withManagedJournalLock as c, MANAGED_PROJECT_MAX_WINDOWS_ENV as d, assertManagedInstallation as f, startWechatIdeAgent as h, recoverManagedWechatProjectsAfterInstallationExit as i, writeManagedRecord as l, sameManagedProcess as m, cleanupManagedWechatProjects as n, readManagedWechatProjectRecords as o, inspectManagedProjectHost as p, closeManagedWechatProject as r, resolveManagedJournal as s, beginManagedWechatProject as t, MANAGED_PROJECT_JOURNAL_ENV as u };