@treeport/treeport 0.5.0 → 0.7.0

package/dist/dist-BsLn2Gbc.js

@@ -0,0 +1,1630 @@
+import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "@effect/rpc";
+import * as Schema from "effect/Schema";
+import * as Either from "effect/Either";
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import * as Layer from "effect/Layer";
+import "effect/Effect";
+import "effect/FiberId";
+import "effect/Queue";
+import "@effect/platform/Socket";
+const BROWSER_MAX_FRAME_BYTES = 8 * 1024 * 1024;
+const BROWSER_MAX_MESSAGE_BYTES = 128 * 1024;
+const opaqueTokenSchema = Schema.String.pipe(Schema.minLength(32), Schema.maxLength(256));
+const browserPanelIdSchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128));
+const browserRequestIdSchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128));
+const browserGenerationSchema = Schema.Int.pipe(Schema.positive());
+const browserRevisionSchema = Schema.NonNegativeInt;
+const browserUrlSchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(4096), Schema.filter((value) => {
+	if (!URL.canParse(value)) return false;
+	const url = new URL(value);
+	return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "";
+}, { message: () => "Expected an absolute HTTP or HTTPS URL without credentials" }));
+const browserClientMessageSchema = Schema.Union(Schema.Struct({
+	type: Schema.Literal("navigate"),
+	url: browserUrlSchema
+}), Schema.Struct({ type: Schema.Literal("back") }), Schema.Struct({ type: Schema.Literal("forward") }), Schema.Struct({ type: Schema.Literal("reload") }), Schema.Struct({ type: Schema.Literal("stop") }), Schema.Struct({
+	type: Schema.Literal("resize"),
+	width: Schema.Int.pipe(Schema.between(320, 3840)),
+	height: Schema.Int.pipe(Schema.between(200, 2160))
+}), Schema.Struct({
+	type: Schema.Literal("pointer"),
+	phase: Schema.Literal("move", "down", "up"),
+	x: Schema.Finite.pipe(Schema.between(0, 3840)),
+	y: Schema.Finite.pipe(Schema.between(0, 2160)),
+	button: Schema.optional(Schema.Literal("left", "right", "middle"))
+}), Schema.Struct({
+	type: Schema.Literal("wheel"),
+	deltaX: Schema.Finite.pipe(Schema.between(-1e4, 1e4)),
+	deltaY: Schema.Finite.pipe(Schema.between(-1e4, 1e4))
+}), Schema.Struct({
+	type: Schema.Literal("key"),
+	phase: Schema.Literal("down", "up"),
+	key: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128))
+}), Schema.Struct({
+	type: Schema.Literal("insertText"),
+	text: Schema.String.pipe(Schema.maxLength(64 * 1024))
+}), Schema.Struct({
+	type: Schema.Literal("find"),
+	text: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(4096)),
+	forward: Schema.Boolean,
+	findNext: Schema.Boolean
+}), Schema.Struct({ type: Schema.Literal("stopFind") }), Schema.Struct({ type: Schema.Literal("takeControl") }), Schema.Struct({
+	type: Schema.Literal("setVisible"),
+	visible: Schema.Boolean
+}), Schema.Struct({ type: Schema.Literal("requestVideoKeyframe") }), Schema.Struct({
+	type: Schema.Literal("frameAck"),
+	sequence: Schema.Int.pipe(Schema.positive())
+}));
+const browserRuntimeStateSchema = Schema.Struct({
+	url: Schema.Union(Schema.Literal("about:blank"), browserUrlSchema),
+	title: Schema.String.pipe(Schema.maxLength(256)),
+	loading: Schema.Boolean,
+	canGoBack: Schema.Boolean,
+	canGoForward: Schema.Boolean,
+	viewport: Schema.Struct({
+		width: Schema.Finite.pipe(Schema.between(0, 3840)),
+		height: Schema.Finite.pipe(Schema.between(0, 2160))
+	})
+});
+const browserSessionStateSchema = Schema.Struct({
+	...browserRuntimeStateSchema.fields,
+	controlled: Schema.Boolean,
+	hasController: Schema.Boolean,
+	controller: Schema.Literal("you", "agent", "other", "none")
+});
+Schema.Union(Schema.Struct({
+	type: Schema.Literal("ready"),
+	state: browserSessionStateSchema
+}), Schema.Struct({
+	type: Schema.Literal("state"),
+	state: browserSessionStateSchema
+}), Schema.Struct({
+	type: Schema.Literal("controlChanged"),
+	state: browserSessionStateSchema
+}), Schema.Struct({
+	type: Schema.Literal("navigationError"),
+	message: Schema.String
+}), Schema.Struct({
+	type: Schema.Literal("browserUnavailable"),
+	message: Schema.String,
+	installCommand: Schema.NullOr(Schema.String)
+}), Schema.Struct({
+	type: Schema.Literal("videoUnavailable"),
+	message: Schema.String
+}), Schema.Struct({
+	type: Schema.Literal("browserCrashed"),
+	message: Schema.String
+}), Schema.Struct({
+	type: Schema.Literal("closed"),
+	reason: Schema.String
+}));
+const browserVideoFields = {
+	mimeType: Schema.Literal("video/vp8"),
+	keyframe: Schema.Boolean,
+	timestamp: Schema.NonNegativeInt,
+	width: Schema.Int.pipe(Schema.between(1, 3840)),
+	height: Schema.Int.pipe(Schema.between(1, 2160))
+};
+const browserCaptureMessageSchema = Schema.Struct({
+	frame: Schema.NullOr(Schema.Struct({
+		...browserVideoFields,
+		data: Schema.String.pipe(Schema.maxLength(Math.ceil(BROWSER_MAX_FRAME_BYTES / 3) * 4))
+	})),
+	error: Schema.NullOr(Schema.String.pipe(Schema.maxLength(4096)))
+});
+Schema.Struct({
+	sequence: Schema.Int.pipe(Schema.positive()),
+	...browserVideoFields,
+	byteLength: Schema.Int.pipe(Schema.between(0, BROWSER_MAX_FRAME_BYTES))
+});
+const browserFrameDataSchema = Schema.Union(Schema.Uint8ArrayFromSelf, Schema.declare((value) => value instanceof ArrayBuffer, { identifier: "ArrayBufferFromSelf" })).pipe(Schema.transform(Schema.Uint8ArrayFromSelf, {
+	strict: true,
+	decode: (value) => value instanceof Uint8Array ? value : new Uint8Array(value),
+	encode: (value) => value
+}), Schema.filter((value) => value.byteLength <= BROWSER_MAX_FRAME_BYTES, { message: () => `Browser frames cannot exceed ${BROWSER_MAX_FRAME_BYTES} bytes` }));
+Schema.Struct({
+	sequence: Schema.Int.pipe(Schema.positive()),
+	...browserVideoFields,
+	data: browserFrameDataSchema
+});
+const browserTicketRequestSchema = Schema.Struct({
+	clientId: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128)),
+	visible: Schema.Boolean
+});
+const browserOwnerTicketRequestSchema = Schema.Struct({ clientId: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128)) });
+const browserTicketResponseSchema = Schema.Struct({ ticket: opaqueTokenSchema });
+const browserOwnerTicketResponseSchema = Schema.Struct({
+	ticket: opaqueTokenSchema,
+	challenge: opaqueTokenSchema
+});
+const browserOwnerIdentitySchema = Schema.Struct({
+	panelId: browserPanelIdSchema,
+	challenge: opaqueTokenSchema
+});
+const browserOwnerEndpointSchema = Schema.String.pipe(Schema.maxLength(1024), Schema.filter((value) => {
+	if (!URL.canParse(value)) return false;
+	const url = new URL(value);
+	return url.protocol === "http:" && url.hostname === "127.0.0.1" && url.username === "" && url.password === "" && url.search === "" && url.hash === "" && url.pathname !== "/";
+}, { message: () => "Expected a private loopback Browser endpoint" }));
+const browserAgentArgumentSchema = Schema.String.pipe(Schema.maxLength(4096));
+const browserAgentCommandSchema = Schema.Union(Schema.Struct({
+	command: Schema.Literal("snapshot"),
+	args: Schema.Tuple()
+}), Schema.Struct({
+	command: Schema.Literal("click"),
+	args: Schema.Tuple(browserAgentArgumentSchema)
+}), Schema.Struct({
+	command: Schema.Literal("fill"),
+	args: Schema.Tuple(browserAgentArgumentSchema, browserAgentArgumentSchema)
+}), Schema.Struct({
+	command: Schema.Literal("press"),
+	args: Schema.Tuple(browserAgentArgumentSchema)
+}), Schema.Struct({
+	command: Schema.Literal("console"),
+	args: Schema.Union(Schema.Tuple(), Schema.Tuple(browserAgentArgumentSchema.pipe(Schema.maxLength(32))))
+}), Schema.Struct({
+	command: Schema.Literal("requests"),
+	args: Schema.Tuple()
+}), Schema.Struct({
+	command: Schema.Literal("screenshot"),
+	args: Schema.Tuple()
+}), Schema.Struct({
+	command: Schema.Literal("goto"),
+	args: Schema.Tuple(browserUrlSchema)
+}), Schema.Struct({
+	command: Schema.Literal("go-back"),
+	args: Schema.Tuple()
+}), Schema.Struct({
+	command: Schema.Literal("go-forward"),
+	args: Schema.Tuple()
+}), Schema.Struct({
+	command: Schema.Literal("reload"),
+	args: Schema.Tuple()
+}));
+const browserAuthSchema = Schema.Struct({
+	ticket: opaqueTokenSchema,
+	protocolVersion: Schema.Literal(6)
+});
+const browserOwnerAuthSchema = Schema.Struct({
+	ticket: opaqueTokenSchema,
+	protocolVersion: Schema.Literal(6),
+	endpoint: browserOwnerEndpointSchema,
+	challenge: opaqueTokenSchema
+});
+const browserOwnerClientMessageSchema = Schema.Union(Schema.Struct({
+	type: Schema.Literal("ready"),
+	generation: browserGenerationSchema,
+	revision: browserRevisionSchema,
+	state: browserRuntimeStateSchema
+}), Schema.Struct({
+	type: Schema.Literal("state"),
+	generation: browserGenerationSchema,
+	revision: browserRevisionSchema,
+	state: browserRuntimeStateSchema
+}), Schema.Struct({
+	type: Schema.Literal("popup"),
+	generation: browserGenerationSchema,
+	url: browserUrlSchema
+}), Schema.Struct({
+	type: Schema.Literal("crashed"),
+	generation: browserGenerationSchema,
+	message: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(1024))
+}), Schema.Struct({
+	type: Schema.Literal("runtimeControlResult"),
+	generation: browserGenerationSchema,
+	requestId: browserRequestIdSchema,
+	accepted: Schema.Boolean
+}), Schema.Struct({
+	type: Schema.Literal("takeControl"),
+	generation: browserGenerationSchema
+}), Schema.Struct({
+	type: Schema.Literal("released"),
+	generation: browserGenerationSchema
+}), Schema.Struct({
+	type: Schema.Literal("closeResult"),
+	generation: browserGenerationSchema,
+	requestId: browserRequestIdSchema,
+	canClose: Schema.Boolean
+}));
+Schema.Union(Schema.Struct({
+	type: Schema.Literal("claimGranted"),
+	panelId: browserPanelIdSchema,
+	generation: browserGenerationSchema,
+	resumed: Schema.Boolean,
+	state: browserRuntimeStateSchema
+}), Schema.Struct({
+	type: Schema.Literal("claimRejected"),
+	message: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(1024))
+}), Schema.Struct({
+	type: Schema.Literal("runtimeControl"),
+	generation: browserGenerationSchema,
+	requestId: browserRequestIdSchema,
+	controller: Schema.Literal("agent", "other", "none"),
+	retainPaint: Schema.Boolean
+}), Schema.Struct({
+	type: Schema.Literal("closeRequest"),
+	generation: browserGenerationSchema,
+	requestId: browserRequestIdSchema,
+	force: Schema.Boolean
+}), Schema.Struct({
+	type: Schema.Literal("closed"),
+	reason: Schema.String.pipe(Schema.maxLength(1024))
+}));
+function decodeOrNull$2(schema, value) {
+	const result = Schema.decodeUnknownEither(schema, { onExcessProperty: "error" })(value);
+	return Either.isRight(result) ? result.right : null;
+}
+function parseBrowserCaptureMessage(payload) {
+	if (payload.length > 11748147.2) return null;
+	try {
+		return decodeOrNull$2(browserCaptureMessageSchema, JSON.parse(payload));
+	} catch {
+		return null;
+	}
+}
+function parseBrowserAuth(value) {
+	return decodeOrNull$2(browserAuthSchema, value);
+}
+function parseBrowserOwnerAuth(value) {
+	return decodeOrNull$2(browserOwnerAuthSchema, value);
+}
+function parseBrowserClientMessage(value) {
+	return decodeOrNull$2(browserClientMessageSchema, value);
+}
+function parseBrowserOwnerClientMessage(value) {
+	return decodeOrNull$2(browserOwnerClientMessageSchema, value);
+}
+function encodeBrowserFrame(frame) {
+	const metadata = new TextEncoder().encode(JSON.stringify({
+		sequence: frame.sequence,
+		mimeType: frame.mimeType,
+		keyframe: frame.keyframe,
+		timestamp: frame.timestamp,
+		width: frame.width,
+		height: frame.height,
+		byteLength: frame.data.byteLength
+	}));
+	const encoded = new Uint8Array(4 + metadata.byteLength + frame.data.byteLength);
+	new DataView(encoded.buffer).setUint32(0, metadata.byteLength);
+	encoded.set(metadata, 4);
+	encoded.set(frame.data, 4 + metadata.byteLength);
+	return encoded;
+}
+//#endregion
+//#region ../../packages/shared/dist/json-schema.js
+const jsonValueSchema = Schema.suspend(() => Schema.Union(Schema.Null, Schema.String, Schema.Number, Schema.Boolean, Schema.mutable(Schema.Array(jsonValueSchema)), Schema.Record({
+	key: Schema.String,
+	value: jsonValueSchema
+})));
+//#endregion
+//#region ../../packages/shared/dist/web-panel-protocol.js
+const webPanelPermissionSchema = Schema.Literal("same-origin", "tree-files");
+const panelMessageSourceSchema = Schema.Literal("treeport-panel-v1");
+Schema.Struct({
+	source: panelMessageSourceSchema,
+	method: Schema.Literal("panel.title.set"),
+	title: Schema.NullOr(Schema.String)
+});
+Schema.Struct({
+	source: panelMessageSourceSchema,
+	method: Schema.Literal("workspace.select"),
+	index: Schema.Int.pipe(Schema.between(0, 8))
+});
+Schema.Struct({
+	source: panelMessageSourceSchema,
+	method: Schema.Literal("panel.dirty.set"),
+	dirty: Schema.Boolean
+});
+const panelRequestFields = {
+	source: panelMessageSourceSchema,
+	id: Schema.String
+};
+const gitDiffImageRequestSchema = Schema.Struct({
+	path: Schema.String,
+	commit: Schema.NullOr(Schema.String.pipe(Schema.pattern(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/)))
+});
+Schema.Union(Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("context")
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("diff")
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("diff.image"),
+	...gitDiffImageRequestSchema.fields
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("network.listeners")
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("files.list")
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("files.search"),
+	query: Schema.String
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("files.read"),
+	path: Schema.String
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("files.write"),
+	path: Schema.String,
+	content: Schema.String,
+	expectedRevision: Schema.String
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("storage.get"),
+	key: Schema.String
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("storage.set"),
+	key: Schema.String,
+	value: jsonValueSchema
+}), Schema.Struct({
+	...panelRequestFields,
+	method: Schema.Literal("storage.delete"),
+	key: Schema.String
+}));
+//#endregion
+//#region ../../packages/shared/dist/terminal-protocol.js
+const SOCKET_PATH = "/api/socket";
+const TERMINAL_CONTROLLER_GRACE_MS = 1e4;
+const TERMINAL_OUTPUT_HIGH_WATERMARK = 256 * 1024;
+const TERMINAL_OUTPUT_LOW_WATERMARK = 64 * 1024;
+const TERMINAL_OUTPUT_MAX_UNACKNOWLEDGED_BYTES = 4 * 1024 * 1024;
+const TERMINAL_MAX_CLIENT_MESSAGE_BYTES = 128 * 1024;
+const TERMINAL_MAX_INPUT_BYTES = 64 * 1024;
+const terminalId = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128));
+const clientId = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128));
+const streamId = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128));
+const generation = Schema.NonNegativeInt;
+const positiveInt = Schema.Int.pipe(Schema.positive());
+const dimensions = {
+	cols: Schema.Int.pipe(Schema.between(2, 1e3)),
+	rows: Schema.Int.pipe(Schema.between(2, 500))
+};
+const dateTimeString$1 = Schema.String.pipe(Schema.filter((value) => !Number.isNaN(Date.parse(value)), { message: () => "Expected an ISO date and time" }));
+const terminalSizeSchema = Schema.Struct(dimensions);
+const terminalProgressSchema = Schema.Struct({
+	state: Schema.Literal("normal", "error", "indeterminate", "paused"),
+	value: Schema.NullOr(Schema.Int.pipe(Schema.between(0, 100)))
+});
+const terminalProgramSchema = Schema.Literal("pi", "claude", "codex");
+const terminalRuntimeMetadataFields = {
+	terminalId: Schema.String.pipe(Schema.minLength(1)),
+	title: Schema.NullOr(Schema.String.pipe(Schema.maxLength(256))),
+	program: Schema.optionalWith(Schema.NullOr(terminalProgramSchema), { default: () => null }),
+	hasForegroundProcess: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	progress: Schema.NullOr(terminalProgressSchema),
+	progressStartedAt: Schema.optionalWith(Schema.NullOr(dateTimeString$1), { default: () => null }),
+	progressClearedAt: Schema.optionalWith(Schema.NullOr(dateTimeString$1), { default: () => null }),
+	bell: Schema.optionalWith(Schema.NullOr(Schema.Struct({
+		sequence: positiveInt,
+		at: dateTimeString$1,
+		unread: Schema.Boolean
+	})), { default: () => null })
+};
+const terminalRuntimeMetadataSchema = Schema.mutable(Schema.Struct(terminalRuntimeMetadataFields));
+const terminalBellAcknowledgementSchema = Schema.Struct({ sequence: positiveInt });
+function decodeOrNull$1(schema, value) {
+	const parsed = Schema.decodeUnknownEither(schema, { onExcessProperty: "error" })(value);
+	return Either.isRight(parsed) ? parsed.right : null;
+}
+function parseTerminalProgress(data) {
+	const [command, rawState, rawValue, ...extra] = data.split(";");
+	if (command !== "4" || extra.length > 0 || !/^[0-4]$/.test(rawState ?? "")) return;
+	const state = Number(rawState);
+	if (state === 0) return null;
+	if (rawValue !== void 0 && rawValue !== "" && !/^\d{1,3}$/.test(rawValue)) return;
+	const value = rawValue === void 0 || rawValue === "" ? null : Number(rawValue);
+	if (value !== null && value > 100) return;
+	return {
+		state: [
+			void 0,
+			"normal",
+			"error",
+			"indeterminate",
+			"paused"
+		][state],
+		value
+	};
+}
+const terminalAuthSchema = Schema.Struct({
+	terminalId,
+	clientId,
+	...dimensions
+});
+const terminalInputSchema = Schema.Struct({
+	generation,
+	data: Schema.String.pipe(Schema.maxLength(TERMINAL_MAX_INPUT_BYTES))
+});
+const terminalBinarySchema = Schema.Struct({
+	generation,
+	data: Schema.String.pipe(Schema.maxLength(TERMINAL_MAX_INPUT_BYTES))
+});
+const terminalResizeSchema = Schema.Struct({
+	generation,
+	...dimensions
+});
+const terminalTakeControlSchema = Schema.Struct({
+	generation,
+	...dimensions
+});
+const terminalOutputAckSchema = Schema.Struct({
+	streamId,
+	sequence: Schema.NonNegativeInt
+});
+const terminalQueryAuthorityRequestSchema = Schema.Struct({
+	generation,
+	transitionId: Schema.NullOr(Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128)))
+});
+const terminalReadyBase = {
+	connectionId: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128)),
+	streamId,
+	generation,
+	controller: Schema.Boolean,
+	reset: Schema.Literal("full")
+};
+const terminalSnapshotLinkSchema = Schema.Struct({
+	buffer: Schema.Literal("normal", "alternate"),
+	uri: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(4096)),
+	line: Schema.NonNegativeInt,
+	startColumn: Schema.NonNegativeInt,
+	endColumn: positiveInt
+});
+Schema.Struct({
+	...terminalReadyBase,
+	...dimensions,
+	revision: positiveInt,
+	snapshot: Schema.String,
+	snapshotLinks: Schema.optionalWith(Schema.Array(terminalSnapshotLinkSchema).pipe(Schema.maxItems(1e4)), { default: () => [] })
+});
+Schema.Struct({
+	...dimensions,
+	revision: positiveInt
+});
+Schema.Struct({
+	streamId,
+	sequence: positiveInt,
+	data: Schema.String
+});
+Schema.Struct({ title: Schema.String.pipe(Schema.maxLength(256)) });
+Schema.Struct({ progress: Schema.NullOr(terminalProgressSchema) });
+Schema.Struct({
+	generation,
+	controller: Schema.Boolean
+});
+Schema.Struct({ exitCode: Schema.NullOr(Schema.Int) });
+Schema.Struct({
+	generation,
+	transitionId: Schema.NullOr(Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128))),
+	active: Schema.Boolean
+});
+Schema.Struct({
+	code: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(80)),
+	message: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(1e3)),
+	retryable: Schema.Boolean
+});
+function parseTerminalAuth(value) {
+	return decodeOrNull$1(terminalAuthSchema, value);
+}
+function parseTerminalClientEvent(event, value) {
+	const selected = {
+		input: terminalInputSchema,
+		binary: terminalBinarySchema,
+		resize: terminalResizeSchema,
+		take_control: terminalTakeControlSchema,
+		output_ack: terminalOutputAckSchema,
+		query_authority: terminalQueryAuthorityRequestSchema
+	}[event];
+	const parsed = Schema.decodeUnknownEither(selected, { onExcessProperty: "error" })(value);
+	return Either.isRight(parsed) ? parsed.right : null;
+}
+//#endregion
+//#region ../../packages/shared/dist/browser-video.js
+async function captureBrowserVideo(sourceId, width, height, publish) {
+	if (typeof VideoEncoder === "undefined") throw new Error("This browser does not support native video encoding.");
+	const track = (await navigator.mediaDevices.getUserMedia({
+		audio: false,
+		video: { mandatory: {
+			chromeMediaSource: "tab",
+			chromeMediaSourceId: sourceId,
+			maxWidth: width,
+			maxHeight: height,
+			maxFrameRate: 30
+		} }
+	})).getVideoTracks()[0];
+	track.contentHint = "detail";
+	const Processor = globalThis.MediaStreamTrackProcessor;
+	let stopped = false;
+	let lastFrame = null;
+	let encodedWidth = 0;
+	let encodedHeight = 0;
+	let frames = 0;
+	let keyframe = true;
+	let outstanding = 0;
+	let lastTimestamp = 0;
+	const dimensions = /* @__PURE__ */ new Map();
+	const reader = new Processor({ track }).readable.getReader();
+	const fail = (error) => {
+		if (!stopped) {
+			publish(JSON.stringify({
+				frame: null,
+				error: error.message.slice(0, 4096)
+			}));
+			stop();
+		}
+	};
+	const encoder = new VideoEncoder({
+		output(chunk) {
+			if (stopped) return;
+			const size = dimensions.get(chunk.timestamp);
+			dimensions.delete(chunk.timestamp);
+			if (!size || chunk.byteLength > 8 * 1024 * 1024) {
+				fail(/* @__PURE__ */ new Error("Browser video frame exceeds the capture limit."));
+				return;
+			}
+			const bytes = new Uint8Array(chunk.byteLength);
+			chunk.copyTo(bytes);
+			let binary = "";
+			for (let offset = 0; offset < bytes.length; offset += 16384) binary += String.fromCharCode(...bytes.subarray(offset, offset + 16384));
+			publish(JSON.stringify({
+				error: null,
+				frame: {
+					mimeType: "video/vp8",
+					keyframe: chunk.type === "key",
+					timestamp: chunk.timestamp,
+					...size,
+					data: btoa(binary)
+				}
+			}));
+		},
+		error: fail
+	});
+	const encode = (frame, force) => {
+		if (stopped || encoder.encodeQueueSize >= 2 || outstanding >= 4) {
+			keyframe = true;
+			return;
+		}
+		if (encodedWidth !== frame.displayWidth || encodedHeight !== frame.displayHeight) {
+			encodedWidth = frame.displayWidth;
+			encodedHeight = frame.displayHeight;
+			encoder.configure({
+				codec: "vp8",
+				width: encodedWidth,
+				height: encodedHeight,
+				framerate: 30,
+				bitrate: 3e6,
+				latencyMode: "realtime"
+			});
+			keyframe = true;
+		}
+		lastTimestamp = Math.max(lastTimestamp + 1, Math.round(performance.now() * 1e3));
+		const input = new VideoFrame(frame, { timestamp: lastTimestamp });
+		outstanding++;
+		dimensions.set(lastTimestamp, {
+			width: encodedWidth,
+			height: encodedHeight
+		});
+		encoder.encode(input, { keyFrame: force || keyframe || frames++ % 30 === 0 });
+		input.close();
+		keyframe = false;
+	};
+	const stop = () => {
+		if (stopped) return;
+		stopped = true;
+		track.stop();
+		reader.cancel().catch(() => void 0);
+		lastFrame?.close();
+		lastFrame = null;
+		dimensions.clear();
+		if (encoder.state !== "closed") encoder.close();
+	};
+	track.addEventListener("ended", () => fail(/* @__PURE__ */ new Error("Browser video capture ended.")));
+	(async () => {
+		while (!stopped) {
+			const { value: frame, done } = await reader.read();
+			if (done) break;
+			lastFrame?.close();
+			lastFrame = frame;
+			encode(frame, false);
+		}
+	})().catch(fail);
+	return {
+		stop,
+		acknowledge() {
+			outstanding = Math.max(0, outstanding - 1);
+			if (keyframe && lastFrame && outstanding === 0) encode(lastFrame, true);
+		},
+		requestKeyframe() {
+			keyframe = true;
+			if (lastFrame) encode(lastFrame, true);
+		}
+	};
+}
+const BROWSER_VIDEO_CAPTURE_SOURCE = `(${captureBrowserVideo.toString()})`;
+//#endregion
+//#region ../../packages/shared/dist/http-protocol.js
+const projectColorSchema = Schema.Literal("rose", "orange", "amber", "emerald", "cyan", "blue", "violet", "pink");
+const stringArraySchema = Schema.Array(Schema.String);
+const nullableStringSchema = Schema.NullOr(Schema.String);
+const jsonObjectSchema = Schema.Record({
+	key: Schema.String,
+	value: jsonValueSchema
+});
+const terminalPresetDefinitionsQuerySchema = Schema.Struct({
+	projectId: Schema.optional(Schema.String),
+	worktreeId: Schema.optional(Schema.String)
+});
+const treeContextFieldsQuerySchema = Schema.Struct({ projectId: Schema.String.pipe(Schema.minLength(1)) });
+const operationQuerySchema = Schema.Struct({
+	kind: Schema.optional(Schema.Literal("create", "finish", "discard", "project_cleanup", "remove", "external_remove")),
+	projectId: Schema.optional(Schema.String)
+});
+const deletePanelQuerySchema = Schema.Struct({
+	discardStoredData: Schema.optional(Schema.String),
+	force: Schema.optional(Schema.String)
+});
+const okResponseSchema = Schema.Struct({ ok: Schema.Literal(true) });
+const terminalRecordSchema$1 = Schema.Struct({
+	id: Schema.String,
+	worktreeId: Schema.String,
+	name: Schema.String,
+	argv: stringArraySchema,
+	shellCommand: nullableStringSchema,
+	interactiveShell: Schema.Boolean,
+	status: Schema.Literal("running", "exited", "missing"),
+	exitCode: Schema.NullOr(Schema.Int),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const terminalPresetSchema = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	executable: Schema.String,
+	args: stringArraySchema,
+	closeOnSuccess: Schema.Boolean,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const webPanelLaunchSchema = Schema.Struct({
+	input: Schema.NullOr(jsonObjectSchema),
+	cwd: nullableStringSchema
+});
+const webPanelSandboxSchema = Schema.Struct({ allowSameOrigin: Schema.Boolean });
+const webPanelSchema = Schema.Struct({
+	id: Schema.String,
+	kind: Schema.Literal("web"),
+	worktreeId: Schema.String,
+	definitionId: Schema.String,
+	title: Schema.String,
+	launch: webPanelLaunchSchema,
+	permissions: Schema.Array(webPanelPermissionSchema),
+	sandbox: webPanelSandboxSchema,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const browserPanelSchema = Schema.Struct({
+	id: Schema.String,
+	kind: Schema.Literal("browser"),
+	worktreeId: Schema.String,
+	title: Schema.String,
+	url: Schema.Union(Schema.Literal("about:blank"), browserUrlSchema),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const terminalPanelSchema = Schema.Struct({
+	id: Schema.String,
+	kind: Schema.Literal("terminal"),
+	worktreeId: Schema.String,
+	terminalId: Schema.String,
+	title: Schema.String,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const panelSchema = Schema.Union(terminalPanelSchema, webPanelSchema, browserPanelSchema);
+const prInfoSchema = Schema.Struct({
+	state: Schema.Literal("no_pr", "open", "merged", "closed", "unknown"),
+	number: Schema.NullOr(Schema.Int),
+	url: nullableStringSchema,
+	baseBranch: nullableStringSchema,
+	headBranch: nullableStringSchema,
+	mergedAt: nullableStringSchema,
+	refreshedAt: nullableStringSchema
+});
+const dirtyStateSchema = Schema.Struct({
+	dirty: Schema.Boolean,
+	staged: Schema.NonNegativeInt,
+	unstaged: Schema.NonNegativeInt,
+	untracked: Schema.NonNegativeInt,
+	conflicts: Schema.NonNegativeInt,
+	total: Schema.NonNegativeInt
+});
+const worktreeRecordSchema = Schema.Struct({
+	id: Schema.String,
+	projectId: Schema.String,
+	name: Schema.String,
+	path: Schema.String,
+	head: Schema.String,
+	branch: nullableStringSchema,
+	detached: Schema.Boolean,
+	locked: Schema.Boolean,
+	lockReason: nullableStringSchema,
+	prunable: Schema.Boolean,
+	kind: Schema.Literal("main", "linked", "folder"),
+	managedWrapperPath: nullableStringSchema,
+	pr: prInfoSchema,
+	dirty: Schema.NullOr(dirtyStateSchema),
+	terminals: Schema.Array(terminalRecordSchema$1),
+	panels: Schema.Array(panelSchema),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const projectRecordSchema = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	kind: Schema.Literal("repository", "folder"),
+	rootPath: Schema.String,
+	repositoryPath: Schema.String,
+	mainWorktreePath: Schema.String,
+	defaultBranch: Schema.String,
+	color: Schema.NullOr(projectColorSchema),
+	availability: Schema.Struct({
+		state: Schema.Literal("available", "unavailable"),
+		message: nullableStringSchema
+	}),
+	worktrees: Schema.Array(worktreeRecordSchema),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const recentProjectRecordSchema = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	kind: Schema.Literal("repository", "folder"),
+	rootPath: Schema.String,
+	repositoryPath: Schema.String,
+	lastOpenedAt: Schema.String
+});
+const cleanupCommandProgressSchema = Schema.Struct({
+	name: Schema.String,
+	status: Schema.Literal("pending", "running", "completed", "failed"),
+	stdout: Schema.String,
+	stderr: Schema.String,
+	exitCode: Schema.NullOr(Schema.Int),
+	error: nullableStringSchema,
+	outputTruncated: Schema.Boolean
+});
+const removeCleanupProgressSchema = Schema.Struct({
+	status: Schema.Literal("pending", "running", "completed", "failed", "skipped"),
+	definitionHash: nullableStringSchema,
+	skippedReason: nullableStringSchema,
+	commands: Schema.Array(cleanupCommandProgressSchema)
+});
+const removePreviewSchema = Schema.Struct({
+	worktreeId: Schema.String,
+	name: Schema.String,
+	path: Schema.String,
+	head: Schema.String,
+	branch: nullableStringSchema,
+	detached: Schema.Boolean,
+	locked: Schema.Boolean,
+	lockReason: nullableStringSchema,
+	dirty: dirtyStateSchema,
+	detachedHeadReachable: Schema.NullOr(Schema.Boolean),
+	forceRequired: Schema.Boolean,
+	eligible: Schema.Boolean,
+	reasons: stringArraySchema,
+	warnings: stringArraySchema,
+	cleanup: Schema.Struct({
+		commands: stringArraySchema,
+		available: Schema.Boolean,
+		unavailableReason: nullableStringSchema
+	}),
+	terminals: Schema.Array(Schema.Struct({
+		id: Schema.String,
+		name: Schema.String,
+		status: Schema.Literal("running", "exited", "missing")
+	})),
+	confirmationToken: Schema.String
+});
+const operationBaseFields = {
+	id: Schema.String,
+	projectId: nullableStringSchema,
+	worktreeId: nullableStringSchema,
+	status: Schema.Literal("pending", "running", "completed", "failed"),
+	error: nullableStringSchema,
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+};
+const createOperationRequestSchema = Schema.Struct({
+	name: Schema.String,
+	base: Schema.Literal("default", "current"),
+	context: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.String
+	})),
+	initialTerminal: Schema.optional(Schema.Struct({
+		name: Schema.String,
+		initialTitle: Schema.optional(Schema.String),
+		argv: Schema.optional(stringArraySchema),
+		returnToShell: Schema.optional(Schema.Boolean),
+		initialSize: Schema.optional(Schema.Struct({
+			cols: Schema.Int,
+			rows: Schema.Int
+		}))
+	})),
+	sourceWorktreeId: Schema.optional(Schema.String)
+});
+const createOperationResultSchema = Schema.Struct({
+	worktreeId: Schema.String,
+	terminalId: nullableStringSchema,
+	terminalError: nullableStringSchema,
+	setupError: nullableStringSchema
+});
+const removalCheckoutIdentitySchema = Schema.Struct({
+	path: Schema.String,
+	device: Schema.String,
+	inode: Schema.String,
+	gitWorktreeKey: Schema.String,
+	gitMarker: Schema.String,
+	repositoryIdentity: nullableStringSchema,
+	managedWrapperPath: nullableStringSchema,
+	quarantinePath: Schema.String
+});
+const removeOperationRequestSchema = Schema.Struct({
+	confirmation: Schema.NullOr(Schema.Boolean),
+	confirmationToken: nullableStringSchema,
+	confirmDestructive: Schema.NullOr(Schema.Boolean),
+	skipCleanup: Schema.Boolean,
+	preview: Schema.NullOr(removePreviewSchema),
+	checkoutIdentity: Schema.NullOr(removalCheckoutIdentitySchema),
+	prunable: Schema.NullOr(Schema.Boolean),
+	gitWorktreeKey: nullableStringSchema,
+	repositoryIdentity: nullableStringSchema,
+	phase: Schema.NullOr(Schema.Literal("accepted", "terminals_stopped", "cleanup_commands_completed", "git_removed", "cleanup_pending")),
+	managedWrapperPath: nullableStringSchema,
+	cleanupCommands: removeCleanupProgressSchema
+});
+const removeOperationResultSchema = Schema.Struct({
+	removed: Schema.Literal(true),
+	worktreeId: Schema.String,
+	name: Schema.String,
+	branchPreserved: nullableStringSchema,
+	path: Schema.String,
+	recovered: Schema.Boolean,
+	cleanup: Schema.Struct({
+		status: Schema.Literal("completed", "preserved"),
+		residualPath: nullableStringSchema,
+		warning: nullableStringSchema,
+		commands: Schema.Array(cleanupCommandProgressSchema)
+	})
+});
+const externalRemoveResultSchema = Schema.Struct({
+	removed: Schema.Literal(true),
+	external: Schema.Literal(true),
+	worktreeId: Schema.String,
+	path: Schema.String,
+	head: Schema.String,
+	branch: nullableStringSchema,
+	cleanup: Schema.Struct({
+		status: Schema.Literal("skipped"),
+		skippedReason: Schema.String
+	})
+});
+const operationRecordSchema = Schema.Union(Schema.Struct({
+	...operationBaseFields,
+	kind: Schema.Literal("create"),
+	request: createOperationRequestSchema,
+	result: Schema.NullOr(createOperationResultSchema)
+}), Schema.Struct({
+	...operationBaseFields,
+	kind: Schema.Literal("remove"),
+	request: removeOperationRequestSchema,
+	result: Schema.NullOr(removeOperationResultSchema)
+}), Schema.Struct({
+	...operationBaseFields,
+	kind: Schema.Literal("external_remove"),
+	request: Schema.Struct({ source: Schema.Literal("git") }),
+	result: Schema.NullOr(externalRemoveResultSchema)
+}), Schema.Struct({
+	...operationBaseFields,
+	kind: Schema.Literal("finish", "discard", "project_cleanup"),
+	request: jsonObjectSchema,
+	result: Schema.NullOr(jsonObjectSchema)
+}));
+const directoryBrowseResponseSchema = Schema.Struct({
+	input: Schema.String,
+	exact: Schema.Boolean,
+	directory: Schema.Struct({
+		path: Schema.String,
+		parentPath: nullableStringSchema,
+		homePath: Schema.String,
+		rootPath: Schema.String,
+		breadcrumbs: Schema.Array(Schema.Struct({
+			name: Schema.String,
+			path: Schema.String
+		})),
+		entries: Schema.Array(Schema.Struct({
+			name: Schema.String,
+			path: Schema.String
+		})),
+		truncated: Schema.Boolean
+	}),
+	project: Schema.Union(Schema.Struct({
+		state: Schema.Literal("valid"),
+		kind: Schema.Literal("repository", "folder"),
+		path: Schema.String
+	}), Schema.Struct({
+		state: Schema.Literal("incomplete"),
+		message: Schema.String
+	})),
+	repository: Schema.Union(Schema.Struct({
+		state: Schema.Literal("valid"),
+		repositoryPath: Schema.String
+	}), Schema.Struct({
+		state: Schema.Literal("incomplete"),
+		message: Schema.String
+	}), Schema.Struct({
+		state: Schema.Literal("not-repository"),
+		message: Schema.String
+	}))
+});
+const packageDefinitionSourceSchema = Schema.Union(Schema.Struct({ type: Schema.Literal("user") }), Schema.Struct({
+	type: Schema.Literal("repository"),
+	format: Schema.Literal("treeport", "zed")
+}), Schema.Struct({
+	type: Schema.Literal("package"),
+	packageId: Schema.String,
+	source: Schema.String,
+	scope: Schema.Literal("global", "project")
+}));
+const terminalPresetDefinitionListingSchema = Schema.Struct({
+	definitions: Schema.Array(Schema.Struct({
+		id: Schema.String,
+		name: Schema.String,
+		executable: nullableStringSchema,
+		args: stringArraySchema,
+		shellCommand: nullableStringSchema,
+		cwd: nullableStringSchema,
+		env: Schema.Record({
+			key: Schema.String,
+			value: Schema.String
+		}),
+		closeOnSuccess: Schema.Boolean,
+		source: packageDefinitionSourceSchema
+	})),
+	diagnostics: Schema.Array(Schema.Struct({
+		path: Schema.String,
+		itemId: nullableStringSchema,
+		message: Schema.String
+	}))
+});
+const treeContextFieldListingSchema = Schema.Struct({
+	fields: Schema.Array(Schema.Struct({
+		id: Schema.String,
+		label: Schema.String,
+		input: Schema.Literal("text", "textarea")
+	})),
+	diagnostics: Schema.Array(Schema.Struct({
+		scope: Schema.Literal("global", "project"),
+		path: Schema.String,
+		message: Schema.String
+	}))
+});
+const webPanelDefinitionSchema = Schema.Struct({
+	id: Schema.String,
+	title: Schema.String,
+	icon: nullableStringSchema,
+	source: Schema.Union(Schema.Struct({ type: Schema.Literal("project") }), Schema.Struct({
+		type: Schema.Literal("package"),
+		packageId: Schema.String,
+		source: Schema.String,
+		scope: Schema.Literal("global", "project")
+	})),
+	permissions: Schema.Array(webPanelPermissionSchema),
+	permissionsGranted: Schema.Boolean,
+	sandbox: webPanelSandboxSchema
+});
+const webPanelContextSchema = Schema.Struct({
+	apiVersion: Schema.Literal(1),
+	panel: webPanelSchema,
+	launch: webPanelLaunchSchema,
+	project: Schema.Struct({
+		id: Schema.String,
+		name: Schema.String,
+		kind: Schema.Literal("repository", "folder"),
+		defaultBranch: nullableStringSchema
+	}),
+	worktree: Schema.Struct({
+		id: Schema.String,
+		name: Schema.String,
+		kind: Schema.Literal("main", "linked", "folder"),
+		branch: nullableStringSchema,
+		head: nullableStringSchema
+	})
+});
+const gitDiffImageSchema = Schema.Struct({
+	dataUrl: Schema.String,
+	byteLength: Schema.Number
+});
+const gitDiffSchema = Schema.Struct({
+	baseRef: Schema.String,
+	baseCommit: Schema.String,
+	headCommit: Schema.String,
+	generatedAt: Schema.String,
+	unified: Schema.String,
+	changeSets: Schema.Struct({
+		branch: stringArraySchema,
+		staged: stringArraySchema,
+		unstaged: stringArraySchema,
+		untracked: stringArraySchema
+	})
+});
+const worktreeListenerDiscoverySchema = Schema.Struct({
+	supported: Schema.Boolean,
+	message: nullableStringSchema,
+	listeners: Schema.Array(Schema.Struct({
+		pid: Schema.Int,
+		command: Schema.String,
+		host: Schema.String,
+		port: Schema.Int,
+		terminalId: nullableStringSchema
+	}))
+});
+const treeFileListingSchema = Schema.Struct({
+	paths: stringArraySchema,
+	truncated: Schema.Boolean
+});
+const treeFileSchema = Schema.Struct({
+	path: Schema.String,
+	content: Schema.String,
+	revision: Schema.String
+});
+const treeFileSearchResultSchema = Schema.Struct({
+	files: Schema.Array(Schema.Struct({
+		path: Schema.String,
+		matches: Schema.Array(Schema.Struct({
+			lineNumber: Schema.Int,
+			column: Schema.NonNegativeInt,
+			length: Schema.NonNegativeInt,
+			preview: Schema.String,
+			previewStart: Schema.NonNegativeInt,
+			lineLength: Schema.NonNegativeInt
+		}))
+	})),
+	truncated: Schema.Boolean
+});
+const treeFileWriteResultSchema = Schema.Struct({
+	path: Schema.String,
+	revision: Schema.String
+});
+const packageResourceDiagnosticSchema = Schema.Struct({
+	severity: Schema.Literal("warning", "error"),
+	message: Schema.String,
+	scope: Schema.Literal("global", "project"),
+	source: Schema.optional(Schema.String),
+	projectId: Schema.optional(Schema.String),
+	resourceType: Schema.optional(Schema.Literal("web-panel", "terminal-preset")),
+	path: Schema.optional(Schema.String)
+});
+const packageListingSchema = Schema.Struct({
+	source: Schema.String,
+	identity: Schema.String,
+	scope: Schema.Literal("global", "project"),
+	projectId: nullableStringSchema,
+	projectName: nullableStringSchema,
+	installedPath: nullableStringSchema,
+	resources: Schema.Struct({
+		webPanels: Schema.NonNegativeInt,
+		terminalPresets: Schema.NonNegativeInt
+	}),
+	diagnostics: Schema.Array(packageResourceDiagnosticSchema)
+});
+const packageOperationResultSchema = Schema.Struct({
+	action: Schema.Literal("install", "remove", "update", "reload"),
+	source: nullableStringSchema,
+	scope: Schema.Literal("global", "project"),
+	projectId: nullableStringSchema,
+	status: Schema.Literal("installed", "removed", "updated", "reloaded", "skipped"),
+	reason: Schema.optional(Schema.String)
+});
+const healthResponseSchema = Schema.Struct({
+	ok: Schema.Literal(true),
+	version: Schema.String,
+	protocolVersion: Schema.Int,
+	hostname: Schema.String,
+	pid: Schema.Int,
+	instanceId: nullableStringSchema,
+	installationMethod: Schema.String,
+	daemonLifecycle: Schema.Literal("treeport", "service", "external"),
+	url: Schema.String
+});
+Schema.Struct({
+	ok: Schema.Literal(true),
+	version: Schema.optionalWith(Schema.NullOr(Schema.String), { default: () => null }),
+	protocolVersion: Schema.optional(Schema.Int),
+	hostname: Schema.optional(Schema.String),
+	pid: Schema.optional(Schema.Int),
+	instanceId: Schema.optional(nullableStringSchema),
+	installationMethod: Schema.optional(Schema.String),
+	daemonLifecycle: Schema.optional(Schema.Literal("treeport", "service", "external")),
+	url: Schema.optional(Schema.String)
+});
+const browserInstallStatusSchema = Schema.Struct({
+	installed: Schema.Boolean,
+	executablePath: Schema.String,
+	playwrightVersion: Schema.String,
+	browserRevision: Schema.String,
+	channel: Schema.Literal("chromium"),
+	launchReady: Schema.Boolean,
+	launchError: nullableStringSchema
+});
+const browserInstallResponseSchema = Schema.Struct({ message: Schema.String });
+const browserAgentResponseSchema = Schema.Struct({ output: Schema.String });
+const packageListingResponseSchema = Schema.Struct({
+	packages: Schema.Array(packageListingSchema),
+	diagnostics: Schema.Array(packageResourceDiagnosticSchema)
+});
+const packageOperationResponseSchema = Schema.Struct({ result: packageOperationResultSchema });
+const packageOperationsResponseSchema = Schema.Struct({ results: Schema.Array(packageOperationResultSchema) });
+const packageReloadResponseSchema = Schema.Struct({
+	results: Schema.Array(packageOperationResultSchema),
+	diagnostics: Schema.Array(packageResourceDiagnosticSchema)
+});
+const packageProjectResponseSchema = Schema.Struct({ project: projectRecordSchema });
+const projectsResponseSchema = Schema.Struct({ projects: Schema.Array(projectRecordSchema) });
+const recentProjectsResponseSchema = Schema.Struct({ projects: Schema.Array(recentProjectRecordSchema) });
+const projectResponseSchema = Schema.Struct({ project: projectRecordSchema });
+const worktreeResponseSchema = Schema.Struct({ worktree: worktreeRecordSchema });
+const worktreesResponseSchema = Schema.Struct({ worktrees: Schema.Array(worktreeRecordSchema) });
+const treeContextResponseSchema = Schema.Struct({ context: Schema.Record({
+	key: Schema.String,
+	value: Schema.String
+}) });
+const operationResponseSchema = Schema.Struct({ operation: operationRecordSchema });
+const operationsResponseSchema = Schema.Struct({ operations: Schema.Array(operationRecordSchema) });
+const terminalPresetsResponseSchema = Schema.Struct({ presets: Schema.Array(terminalPresetSchema) });
+const terminalPresetResponseSchema = Schema.Struct({ preset: terminalPresetSchema });
+const webPanelDefinitionsResponseSchema = Schema.Struct({ definitions: Schema.Array(webPanelDefinitionSchema) });
+const openWebPanelResponseSchema = Schema.Struct({
+	panel: webPanelSchema,
+	created: Schema.Boolean,
+	reused: Schema.Boolean
+});
+const openBrowserPanelResponseSchema = Schema.Struct({ panel: browserPanelSchema });
+const terminalResponseSchema = Schema.Struct({ terminal: terminalRecordSchema$1 });
+const terminalObservationResponseSchema = Schema.Struct({
+	terminal: terminalRecordSchema$1,
+	metadata: terminalRuntimeMetadataSchema
+});
+const terminalCaptureResponseSchema = Schema.Struct({
+	terminalId: Schema.String,
+	capturedAt: Schema.String,
+	lineLimit: Schema.Int.pipe(Schema.positive()),
+	content: Schema.String
+});
+const removePreviewResponseSchema = Schema.Struct({ preview: removePreviewSchema });
+const webPanelContextResponseSchema = Schema.Struct({ context: webPanelContextSchema });
+const gitDiffResponseSchema = Schema.Struct({ diff: gitDiffSchema });
+const listenerDiscoveryResponseSchema = Schema.Struct({ discovery: worktreeListenerDiscoverySchema });
+const webPanelResponseSchema = Schema.Struct({ panel: webPanelSchema });
+const webPanelDefinitionResponseSchema = Schema.Struct({ definition: webPanelDefinitionSchema });
+const prResponseSchema = Schema.Struct({ pr: prInfoSchema });
+const terminatedTerminalsResponseSchema = Schema.Struct({ terminated: Schema.NonNegativeInt });
+const hasDataResponseSchema = Schema.Struct({ hasData: Schema.Boolean });
+const storageValueResponseSchema = Schema.Struct({
+	found: Schema.Boolean,
+	value: jsonValueSchema
+});
+const uploadedFileResponseSchema = Schema.Struct({ file: Schema.Struct({ path: Schema.String }) });
+const applicationUpdateStatusSchema = Schema.Struct({
+	currentVersion: Schema.String,
+	latestVersion: nullableStringSchema,
+	updateAvailable: Schema.Boolean,
+	checkedAt: nullableStringSchema,
+	canUpdate: Schema.Boolean,
+	blockedReason: nullableStringSchema,
+	phase: Schema.Literal("idle", "checking", "starting", "inspect", "resolve", "stage", "verify", "stop", "activate", "restart", "health_check", "rollback", "complete", "recovery_required", "failed"),
+	operationId: nullableStringSchema,
+	targetVersion: nullableStringSchema,
+	error: nullableStringSchema
+});
+//#endregion
+//#region ../../packages/shared/dist/presence-protocol.js
+const identifier = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128));
+const viewerIdentitySchema = Schema.Struct({
+	source: Schema.Literal("local", "tailscale"),
+	login: Schema.NullOr(Schema.String),
+	name: Schema.NullOr(Schema.String),
+	profilePicture: Schema.NullOr(Schema.String)
+});
+const presenceUpdateSchema = Schema.Struct({
+	sessionId: Schema.UUID,
+	worktreeId: Schema.NullOr(identifier),
+	focusedPanelId: Schema.NullOr(identifier),
+	visible: Schema.Boolean,
+	focused: Schema.Boolean
+});
+const workspacePresenceSchema = Schema.Struct({
+	...presenceUpdateSchema.fields,
+	identity: viewerIdentitySchema
+});
+const presenceResponseSchema = Schema.Struct({ identity: viewerIdentitySchema });
+const PRESENCE_TIMEOUT_MS = 45e3;
+//#endregion
+//#region ../../packages/shared/dist/socket-protocol.js
+const identifierSchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128));
+const dateTimeString = Schema.String.pipe(Schema.filter((value) => !Number.isNaN(Date.parse(value))));
+const eventEnvelope = (type, data) => Schema.Struct({
+	id: identifierSchema,
+	type: Schema.Literal(type),
+	at: dateTimeString,
+	data
+});
+const projectEventDataSchema = Schema.Struct({
+	projectId: identifierSchema,
+	worktreeId: Schema.Null
+});
+const worktreeEventDataSchema = Schema.Struct({ worktreeId: identifierSchema });
+const projectWorktreeEventDataSchema = Schema.Struct({
+	projectId: identifierSchema,
+	worktreeId: identifierSchema
+});
+const operationEventDataSchema = Schema.Struct({
+	operationId: identifierSchema,
+	worktreeId: identifierSchema
+});
+const webPanelSnapshotSchema = Schema.Struct({
+	id: identifierSchema,
+	kind: Schema.Literal("web"),
+	worktreeId: identifierSchema,
+	definitionId: identifierSchema,
+	title: nonEmptyString(),
+	launch: Schema.Struct({
+		input: Schema.NullOr(Schema.mutable(Schema.Record({
+			key: Schema.String,
+			value: jsonValueSchema
+		}))),
+		cwd: Schema.NullOr(Schema.String)
+	}),
+	permissions: Schema.mutable(Schema.Array(webPanelPermissionSchema)),
+	sandbox: Schema.Struct({ allowSameOrigin: Schema.Boolean }),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const browserPanelSnapshotSchema = Schema.Struct({
+	id: identifierSchema,
+	kind: Schema.Literal("browser"),
+	worktreeId: identifierSchema,
+	title: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(256)),
+	url: Schema.Union(Schema.Literal("about:blank"), browserUrlSchema),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+const openPanelSnapshotSchema = Schema.Union(webPanelSnapshotSchema, browserPanelSnapshotSchema);
+const terminalRecordSchema = Schema.Struct({
+	id: identifierSchema,
+	worktreeId: identifierSchema,
+	name: nonEmptyString(),
+	argv: Schema.mutable(Schema.Array(Schema.String)),
+	shellCommand: Schema.NullOr(Schema.String),
+	interactiveShell: Schema.Boolean,
+	status: Schema.Literal("running", "exited", "missing"),
+	exitCode: Schema.NullOr(Schema.Int),
+	createdAt: Schema.String,
+	updatedAt: Schema.String
+});
+function nonEmptyString() {
+	return Schema.String.pipe(Schema.minLength(1));
+}
+const productEventSchema = Schema.Union(eventEnvelope("presence.changed", Schema.Struct({
+	viewers: Schema.Array(workspacePresenceSchema),
+	worktreeId: Schema.Null
+})), eventEnvelope("project.created", projectEventDataSchema), eventEnvelope("project.updated", projectEventDataSchema), eventEnvelope("project.removed", projectEventDataSchema), eventEnvelope("worktree.created", projectWorktreeEventDataSchema), eventEnvelope("worktree.updated", worktreeEventDataSchema), eventEnvelope("worktree.removed", projectWorktreeEventDataSchema), eventEnvelope("create.started", Schema.Struct({
+	projectId: identifierSchema,
+	operationId: identifierSchema,
+	worktreeId: Schema.Null
+})), eventEnvelope("create.completed", Schema.Struct({
+	projectId: identifierSchema,
+	operationId: identifierSchema,
+	worktreeId: identifierSchema
+})), eventEnvelope("create.failed", Schema.Struct({
+	projectId: identifierSchema,
+	operationId: identifierSchema,
+	worktreeId: Schema.Null
+})), eventEnvelope("terminal.created", Schema.Struct({
+	projectId: Schema.optional(identifierSchema),
+	worktreeId: identifierSchema,
+	terminalId: identifierSchema,
+	terminal: terminalRecordSchema
+})), eventEnvelope("terminal.updated", Schema.Struct({
+	worktreeId: identifierSchema,
+	terminalId: identifierSchema
+})), eventEnvelope("terminal.removed", Schema.Struct({
+	worktreeId: identifierSchema,
+	terminalId: identifierSchema
+})), eventEnvelope("terminal.metadata", Schema.Struct({
+	...terminalRuntimeMetadataFields,
+	worktreeId: Schema.Null
+})), eventEnvelope("terminal.controller_changed", Schema.Struct({
+	terminalId: identifierSchema,
+	controlled: Schema.Boolean,
+	worktreeId: Schema.Null
+})), eventEnvelope("panel.created", Schema.Struct({
+	worktreeId: identifierSchema,
+	panelId: identifierSchema
+})), eventEnvelope("panel.updated", Schema.Struct({
+	worktreeId: identifierSchema,
+	panelId: identifierSchema
+})), eventEnvelope("panel.open_requested", Schema.Struct({
+	worktreeId: identifierSchema,
+	panelId: identifierSchema,
+	panel: openPanelSnapshotSchema,
+	sourceTerminalId: Schema.NullOr(identifierSchema),
+	sourcePanelId: Schema.NullOr(identifierSchema)
+})), eventEnvelope("panel.removed", Schema.Struct({
+	worktreeId: identifierSchema,
+	panelId: identifierSchema
+})), eventEnvelope("workspace.open_requested", Schema.Struct({
+	worktreeId: identifierSchema,
+	sourceTerminalId: identifierSchema
+})), eventEnvelope("remove.started", Schema.Struct({
+	...operationEventDataSchema.fields,
+	kind: Schema.Literal("remove")
+})), eventEnvelope("remove.completed", operationEventDataSchema), eventEnvelope("remove.failed", Schema.Struct({
+	...operationEventDataSchema.fields,
+	error: Schema.String
+})));
+const eventsSnapshotSchema = Schema.Struct({
+	at: dateTimeString,
+	terminalMetadata: Schema.Array(terminalRuntimeMetadataSchema),
+	webPanels: Schema.Array(webPanelSnapshotSchema),
+	browserPanels: Schema.Array(browserPanelSnapshotSchema),
+	presence: Schema.Array(workspacePresenceSchema)
+});
+const socketHandshakeSchema = Schema.Struct({
+	type: Schema.Literal("handshake"),
+	auth: jsonValueSchema,
+	query: Schema.Record({
+		key: Schema.String,
+		value: Schema.String
+	})
+});
+const socketMessageSchema = Schema.Struct({
+	event: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(80)),
+	payload: jsonValueSchema
+});
+function decodeOrNull(schema, value) {
+	const parsed = Schema.decodeUnknownEither(schema, { onExcessProperty: "error" })(value);
+	return Either.isRight(parsed) ? parsed.right : null;
+}
+function parseProductEvent(value) {
+	return decodeOrNull(productEventSchema, value);
+}
+function parseSocketHandshake(value) {
+	return decodeOrNull(socketHandshakeSchema, value);
+}
+function parseSocketMessage(value) {
+	return decodeOrNull(socketMessageSchema, value);
+}
+//#endregion
+//#region ../../packages/shared/dist/network-rpc.js
+const projectEventsItemSchema = Schema.Union(Schema.Struct({
+	_tag: Schema.Literal("Snapshot"),
+	snapshot: eventsSnapshotSchema
+}), Schema.Struct({
+	_tag: Schema.Literal("ProductEvent"),
+	event: productEventSchema
+}));
+const projectEventsFailureSchema = Schema.Struct({
+	_tag: Schema.Literal("ProjectEventsFailure"),
+	message: Schema.String
+});
+const WatchProjectEvents = Rpc.make("WatchProjectEvents", {
+	payload: { protocol: Schema.Literal(3) },
+	success: projectEventsItemSchema,
+	error: projectEventsFailureSchema,
+	stream: true
+});
+var TreeportRpcs = class extends RpcGroup.make(WatchProjectEvents) {};
+//#endregion
+//#region ../../packages/shared/dist/network-rpc-client.js
+function treeportRpcClientLayer(url) {
+	return RpcClient.layerProtocolHttp({ url }).pipe(Layer.provide([FetchHttpClient.layer, RpcSerialization.layerNdjson]));
+}
+//#endregion
+//#region ../../packages/shared/dist/schema.js
+function decodeUnknownOrNull(schema, value) {
+	const result = Schema.decodeUnknownEither(schema, { onExcessProperty: "error" })(value);
+	return Either.isRight(result) ? result.right : null;
+}
+function isSchemaValue(schema, value) {
+	return Schema.is(schema, { onExcessProperty: "error" })(value);
+}
+Schema.Struct({ message: Schema.String });
+//#endregion
+//#region ../../packages/shared/dist/index.js
+const TERMINAL_MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+const TERMINAL_EXECUTABLE_MAX_LENGTH = 4096;
+const TERMINAL_ARGUMENT_MAX_LENGTH = 4096;
+const TERMINAL_CAPTURE_MAX_LINES = 5e3;
+const WEB_PANEL_INPUT_MAX_BYTES = 64 * 1024;
+const TREE_CONTEXT_VALUE_MAX_LENGTH = 16 * 1024;
+const TREE_FILE_MAX_BYTES = 2 * 1024 * 1024;
+const TREE_FILE_LIST_MAX_ENTRIES = 5e4;
+function formatCommandLine(argv) {
+	return argv.map((value) => {
+		if (value === "") return "\"\"";
+		if (!/[\s"'\\]/.test(value)) return value;
+		return `"${value.replace(/["\\]/g, "\\$&")}"`;
+	}).join(" ");
+}
+const PROJECT_COLORS = [
+	"rose",
+	"orange",
+	"amber",
+	"emerald",
+	"cyan",
+	"blue",
+	"violet",
+	"pink"
+];
+const apiErrorBodySchema = Schema.Struct({ error: Schema.Struct({
+	code: Schema.String,
+	message: Schema.String,
+	details: Schema.optional(Schema.Unknown)
+}) });
+const browseDirectoryQuerySchema = Schema.Struct({
+	input: Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(4096)),
+	hidden: Schema.optionalWith(Schema.Literal("true", "false").pipe(Schema.transform(Schema.Boolean, {
+		strict: true,
+		decode: (value) => value === "true",
+		encode: (value) => value ? "true" : "false"
+	})), { default: () => false })
+});
+const terminalCaptureQuerySchema = Schema.Struct({ lines: Schema.optionalWith(Schema.NumberFromString.pipe(Schema.int(), Schema.between(1, TERMINAL_CAPTURE_MAX_LINES)), { default: () => 200 }) });
+const registerProjectSchema = Schema.Struct({
+	path: Schema.Trim.pipe(Schema.minLength(1)),
+	name: Schema.optional(Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(120)))
+});
+const updateProjectSchema = Schema.Struct({ color: Schema.NullOr(Schema.Literal(...PROJECT_COLORS)) });
+const terminalNameSchema = Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(120));
+const terminalArgvSchema = Schema.Array(Schema.String).pipe(Schema.minItems(1), Schema.maxItems(128));
+const terminalPresetArgumentSchema = Schema.String.pipe(Schema.maxLength(TERMINAL_ARGUMENT_MAX_LENGTH));
+const terminalPresetFields = {
+	name: terminalNameSchema,
+	executable: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(TERMINAL_EXECUTABLE_MAX_LENGTH), Schema.filter((value) => value.trim().length > 0, { message: () => "Executable cannot be blank" })),
+	args: Schema.Array(terminalPresetArgumentSchema).pipe(Schema.maxItems(127)),
+	closeOnSuccess: Schema.optionalWith(Schema.Boolean, { default: () => false })
+};
+const repositoryTerminalPresetSchema = Schema.Struct(terminalPresetFields);
+const repositoryTerminalPresetIdSchema = Schema.String.pipe(Schema.pattern(/^[a-z0-9][a-z0-9._-]{0,119}$/, { message: () => "Preset IDs must contain only lowercase letters, numbers, dots, underscores, and hyphens" }));
+const repositoryTerminalPresetsFileSchema = Schema.Struct({
+	version: Schema.Literal(1),
+	presets: Schema.Record({
+		key: repositoryTerminalPresetIdSchema,
+		value: Schema.Unknown
+	})
+});
+const terminalPresetRevisionSchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(64));
+const treeContextFieldIdSchema = Schema.String.pipe(Schema.pattern(/^[a-z0-9][a-z0-9._-]{0,119}$/, { message: () => "Field IDs must contain only lowercase letters, numbers, dots, underscores, and hyphens" }));
+const treeContextFieldDefinitionSchema = Schema.Struct({
+	id: treeContextFieldIdSchema,
+	label: Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(120), Schema.filter((value) => !value.includes("\0"), { message: () => "Field labels cannot contain NUL" })),
+	input: Schema.Literal("text", "textarea")
+});
+const treeContextValuesSchema = Schema.Record({
+	key: treeContextFieldIdSchema,
+	value: Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(TREE_CONTEXT_VALUE_MAX_LENGTH), Schema.filter((value) => !value.includes("\0"), { message: () => "Tree context values cannot contain NUL" }))
+}).pipe(Schema.filter((values) => {
+	const entries = Object.entries(values);
+	return entries.length <= 64 && entries.reduce((length, [key, value]) => length + key.length + value.length, 0) <= 65536;
+}, { message: () => "Tree context exceeds its size limit" }));
+const initialTerminalSchema = Schema.Struct({
+	name: terminalNameSchema,
+	initialTitle: Schema.optional(terminalNameSchema),
+	argv: Schema.optional(terminalArgvSchema),
+	returnToShell: Schema.optional(Schema.Boolean),
+	initialSize: Schema.optional(terminalSizeSchema)
+});
+const createWorktreeSchema = Schema.Struct({
+	name: Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(120)),
+	base: Schema.optionalWith(Schema.Literal("default", "current"), { default: () => "default" }),
+	context: Schema.optional(treeContextValuesSchema),
+	sourceWorktreeId: Schema.optional(Schema.String.pipe(Schema.minLength(1))),
+	initialTerminal: Schema.optional(initialTerminalSchema)
+}).pipe(Schema.filter((value) => value.base !== "current" || Boolean(value.sourceWorktreeId), { message: () => "A source tree is required when starting from current" }));
+const terminalCwdSchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(4096), Schema.filter((value) => value.trim().length > 0 && !value.includes("\0"), { message: () => "Working directory cannot be blank or contain NUL" }));
+const terminalEnvironmentKeySchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(256), Schema.filter((value) => !value.includes("=") && !value.includes("\0"), { message: () => "Environment keys cannot contain equals or NUL" }));
+const terminalShellCommandSchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(TERMINAL_ARGUMENT_MAX_LENGTH), Schema.filter((value) => value.trim().length > 0 && !value.includes("\0"), { message: () => "Shell command cannot be blank or contain NUL" }));
+const terminalEnvironmentSchema = Schema.Record({
+	key: terminalEnvironmentKeySchema,
+	value: Schema.String.pipe(Schema.maxLength(TERMINAL_ARGUMENT_MAX_LENGTH), Schema.filter((value) => !value.includes("\0"), { message: () => "Environment values cannot contain NUL" }))
+}).pipe(Schema.filter((value) => Object.keys(value).length <= 128, { message: () => "Environment cannot contain more than 128 variables" }));
+const createTerminalSchema = Schema.Struct({
+	name: terminalNameSchema,
+	initialTitle: Schema.optional(terminalNameSchema),
+	argv: Schema.optional(terminalArgvSchema),
+	shellCommand: Schema.optional(terminalShellCommandSchema),
+	cwd: Schema.optional(terminalCwdSchema),
+	env: Schema.optional(terminalEnvironmentSchema),
+	returnToShell: Schema.optional(Schema.Boolean),
+	closeOnSuccess: Schema.optional(Schema.Boolean),
+	initialSize: Schema.optional(terminalSizeSchema)
+}).pipe(Schema.filter((value) => !(value.argv && value.shellCommand), { message: () => "A terminal cannot have both argv and a shell command" }), Schema.filter((value) => !(value.returnToShell && value.closeOnSuccess), { message: () => "A terminal cannot return to a shell and close on success" }));
+const updateTerminalSchema = Schema.Struct({ name: terminalNameSchema });
+const reorderWorkspaceItemsSchema = Schema.Struct({ itemIds: Schema.Array(Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128))).pipe(Schema.minItems(1), Schema.filter((itemIds) => new Set(itemIds).size === itemIds.length, { message: () => "Item order cannot contain duplicates" })) });
+const webPanelInputSchema = Schema.Record({
+	key: Schema.String,
+	value: jsonValueSchema
+});
+const createWebPanelSchema = Schema.Struct({
+	definitionId: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(256)),
+	input: Schema.optional(Schema.NullOr(webPanelInputSchema)),
+	launchCwd: Schema.optional(Schema.NullOr(Schema.String.pipe(Schema.maxLength(4096))))
+});
+const updateWebPanelPermissionGrantSchema = Schema.Struct({
+	granted: Schema.Boolean,
+	permissions: Schema.Array(webPanelPermissionSchema)
+});
+const createBrowserPanelSchema = Schema.Struct({
+	url: Schema.optional(browserUrlSchema),
+	sourceTerminalId: Schema.optional(Schema.NullOr(Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128))))
+});
+const openBrowserPanelFromTerminalSchema = Schema.Struct({ url: browserUrlSchema });
+const openWebPanelSchema = Schema.Struct({
+	...createWebPanelSchema.fields,
+	newInstance: Schema.optional(Schema.Boolean),
+	sourceTerminalId: Schema.optional(Schema.NullOr(Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128))))
+});
+const requestWorkspaceOpenSchema = Schema.Struct({ sourceTerminalId: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128)) });
+const webPanelStorageKeySchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128));
+const getWebPanelStorageSchema = Schema.Struct({ key: webPanelStorageKeySchema });
+const setWebPanelStorageSchema = Schema.Struct({
+	key: webPanelStorageKeySchema,
+	value: jsonValueSchema
+});
+const deleteWebPanelStorageSchema = Schema.Struct({ key: webPanelStorageKeySchema });
+const treeFilePathSchema = Schema.String.pipe(Schema.minLength(1), Schema.maxLength(4096), Schema.filter((value) => !value.includes("\0") && !value.startsWith("/") && value.split("/").every((segment) => segment !== "" && segment !== ".."), { message: () => "File path must be a relative path inside the tree" }));
+const readTreeFileSchema = Schema.Struct({ path: treeFilePathSchema });
+const searchTreeFilesSchema = Schema.Struct({ query: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(256), Schema.filter((value) => !/[\0\r\n]/.test(value), { message: () => "Search query must be one line and cannot contain NUL" })) });
+const writeTreeFileSchema = Schema.Struct({
+	path: treeFilePathSchema,
+	content: Schema.String,
+	expectedRevision: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(128))
+});
+const createTerminalPresetSchema = Schema.Struct(terminalPresetFields);
+const updateTerminalPresetSchema = Schema.Struct({
+	...terminalPresetFields,
+	closeOnSuccess: Schema.optional(Schema.Boolean),
+	expectedUpdatedAt: terminalPresetRevisionSchema
+});
+const deleteTerminalPresetSchema = Schema.Struct({ expectedUpdatedAt: terminalPresetRevisionSchema });
+const packageProjectQuerySchema = Schema.Struct({ path: Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(4096)) });
+const packageInstallSchema = Schema.Struct({
+	source: Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(4096)),
+	projectId: Schema.optional(Schema.String.pipe(Schema.minLength(1)))
+});
+const packageRemoveSchema = Schema.Struct({
+	source: Schema.String.pipe(Schema.minLength(1)),
+	projectId: Schema.optional(Schema.String.pipe(Schema.minLength(1)))
+});
+const packageUpdateSchema = Schema.Struct({ source: Schema.optional(Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(4096))) });
+const packageReloadSchema = Schema.Struct({ projectId: Schema.optional(Schema.String.pipe(Schema.minLength(1))) });
+const removeWorktreeSchema = Schema.Struct({
+	confirmationToken: Schema.String.pipe(Schema.length(64)),
+	confirmDestructive: Schema.Boolean,
+	skipCleanup: Schema.optionalWith(Schema.Boolean, { default: () => false })
+});
+Schema.Struct({
+	project: Schema.String.pipe(Schema.minLength(1)),
+	worktreeName: Schema.Trim.pipe(Schema.minLength(1), Schema.maxLength(120)),
+	name: terminalNameSchema,
+	argv: Schema.optional(terminalArgvSchema),
+	base: Schema.optionalWith(Schema.Literal("default", "current"), { default: () => "default" }),
+	sourceWorktreeId: Schema.optional(Schema.String.pipe(Schema.minLength(1)))
+}).pipe(Schema.filter((value) => value.base !== "current" || Boolean(value.sourceWorktreeId), { message: () => "A source tree is required when starting from current" }));
+//#endregion
+export { applicationUpdateStatusSchema as $, TERMINAL_MAX_INPUT_BYTES as $t, requestWorkspaceOpenSchema as A, parseBrowserOwnerAuth as An, terminalPresetDefinitionsQuerySchema as At, updateWebPanelPermissionGrantSchema as B, treeFileSearchResultSchema as Bt, packageUpdateSchema as C, browserTicketRequestSchema as Cn, projectsResponseSchema as Ct, reorderWorkspaceItemsSchema as D, parseBrowserAuth as Dn, terminalCaptureResponseSchema as Dt, removeWorktreeSchema as E, encodeBrowserFrame as En, storageValueResponseSchema as Et, treeContextValuesSchema as F, treeContextFieldListingSchema as Ft, treeportRpcClientLayer as G, webPanelDefinitionsResponseSchema as Gt, writeTreeFileSchema as H, uploadedFileResponseSchema as Ht, treeFilePathSchema as I, treeContextFieldsQuerySchema as It, parseSocketHandshake as J, worktreesResponseSchema as Jt, TreeportRpcs as K, webPanelResponseSchema as Kt, updateProjectSchema as L, treeContextResponseSchema as Lt, setWebPanelStorageSchema as M, terminalPresetsResponseSchema as Mt, terminalCaptureQuerySchema as N, terminalResponseSchema as Nt, repositoryTerminalPresetSchema as O, parseBrowserCaptureMessage as On, terminalObservationResponseSchema as Ot, treeContextFieldDefinitionSchema as P, terminatedTerminalsResponseSchema as Pt, presenceUpdateSchema as Q, TERMINAL_MAX_CLIENT_MESSAGE_BYTES as Qt, updateTerminalPresetSchema as R, treeFileListingSchema as Rt, packageRemoveSchema as S, browserOwnerTicketResponseSchema as Sn, projectResponseSchema as St, registerProjectSchema as T, browserUrlSchema as Tn, removePreviewResponseSchema as Tt, decodeUnknownOrNull as U, webPanelContextResponseSchema as Ut, webPanelInputSchema as V, treeFileWriteResultSchema as Vt, isSchemaValue as W, webPanelDefinitionResponseSchema as Wt, PRESENCE_TIMEOUT_MS as X, SOCKET_PATH as Xt, parseSocketMessage as Y, BROWSER_VIDEO_CAPTURE_SOURCE as Yt, presenceResponseSchema as Z, TERMINAL_CONTROLLER_GRACE_MS as Zt, openBrowserPanelFromTerminalSchema as _, BROWSER_MAX_MESSAGE_BYTES as _n, packageOperationResponseSchema as _t, WEB_PANEL_INPUT_MAX_BYTES as a, parseTerminalProgress as an, gitDiffImageSchema as at, packageProjectQuerySchema as b, browserOwnerIdentitySchema as bn, packageReloadResponseSchema as bt, createBrowserPanelSchema as c, terminalInputSchema as cn, healthResponseSchema as ct, createWebPanelSchema as d, terminalResizeSchema as dn, openBrowserPanelResponseSchema as dt, TERMINAL_OUTPUT_HIGH_WATERMARK as en, browserAgentResponseSchema as et, createWorktreeSchema as f, terminalSizeSchema as fn, openWebPanelResponseSchema as ft, getWebPanelStorageSchema as g, BROWSER_MAX_FRAME_BYTES as gn, packageListingResponseSchema as gt, formatCommandLine as h, webPanelPermissionSchema as hn, operationsResponseSchema as ht, TREE_FILE_MAX_BYTES as i, parseTerminalClientEvent as in, directoryBrowseResponseSchema as it, searchTreeFilesSchema as j, parseBrowserOwnerClientMessage as jn, terminalPresetResponseSchema as jt, repositoryTerminalPresetsFileSchema as k, parseBrowserClientMessage as kn, terminalPresetDefinitionListingSchema as kt, createTerminalPresetSchema as l, terminalOutputAckSchema as ln, listenerDiscoveryResponseSchema as lt, deleteWebPanelStorageSchema as m, gitDiffImageRequestSchema as mn, operationResponseSchema as mt, TERMINAL_MAX_UPLOAD_BYTES as n, TERMINAL_OUTPUT_MAX_UNACKNOWLEDGED_BYTES as nn, browserInstallStatusSchema as nt, apiErrorBodySchema as o, terminalBellAcknowledgementSchema as on, gitDiffResponseSchema as ot, deleteTerminalPresetSchema as p, terminalTakeControlSchema as pn, operationQuerySchema as pt, parseProductEvent as q, worktreeResponseSchema as qt, TREE_FILE_LIST_MAX_ENTRIES as r, parseTerminalAuth as rn, deletePanelQuerySchema as rt, browseDirectoryQuerySchema as s, terminalBinarySchema as sn, hasDataResponseSchema as st, TERMINAL_CAPTURE_MAX_LINES as t, TERMINAL_OUTPUT_LOW_WATERMARK as tn, browserInstallResponseSchema as tt, createTerminalSchema as u, terminalQueryAuthorityRequestSchema as un, okResponseSchema as ut, openWebPanelSchema as v, browserAgentCommandSchema as vn, packageOperationsResponseSchema as vt, readTreeFileSchema as w, browserTicketResponseSchema as wn, recentProjectsResponseSchema as wt, packageReloadSchema as x, browserOwnerTicketRequestSchema as xn, prResponseSchema as xt, packageInstallSchema as y, browserOwnerEndpointSchema as yn, packageProjectResponseSchema as yt, updateTerminalSchema as z, treeFileSchema as zt };