@treeport/treeport 0.4.0 → 0.6.1

package/dist/dist-Crk_Xr82.js

@@ -0,0 +1,735 @@
+import { z } from "zod";
+const BROWSER_MAX_FRAME_BYTES = 8 * 1024 * 1024;
+const browserUrlSchema = z.string().min(1).max(4096).refine((value) => {
+	if (!URL.canParse(value)) return false;
+	const url = new URL(value);
+	return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "";
+}, "Expected an absolute HTTP or HTTPS URL without credentials");
+const browserClientMessageSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("navigate"),
+		url: browserUrlSchema
+	}),
+	z.strictObject({ type: z.literal("back") }),
+	z.strictObject({ type: z.literal("forward") }),
+	z.strictObject({ type: z.literal("reload") }),
+	z.strictObject({ type: z.literal("stop") }),
+	z.strictObject({
+		type: z.literal("resize"),
+		width: z.number().int().min(320).max(3840),
+		height: z.number().int().min(200).max(2160)
+	}),
+	z.strictObject({
+		type: z.literal("pointer"),
+		phase: z.enum([
+			"move",
+			"down",
+			"up"
+		]),
+		x: z.number().finite().min(0).max(3840),
+		y: z.number().finite().min(0).max(2160),
+		button: z.enum([
+			"left",
+			"right",
+			"middle"
+		]).optional()
+	}),
+	z.strictObject({
+		type: z.literal("wheel"),
+		deltaX: z.number().finite().min(-1e4).max(1e4),
+		deltaY: z.number().finite().min(-1e4).max(1e4)
+	}),
+	z.strictObject({
+		type: z.literal("key"),
+		phase: z.enum(["down", "up"]),
+		key: z.string().min(1).max(128)
+	}),
+	z.strictObject({
+		type: z.literal("insertText"),
+		text: z.string().max(64 * 1024)
+	}),
+	z.strictObject({ type: z.literal("takeControl") }),
+	z.strictObject({
+		type: z.literal("setVisible"),
+		visible: z.boolean()
+	}),
+	z.strictObject({
+		type: z.literal("frameAck"),
+		sequence: z.number().int().positive()
+	})
+]);
+const browserRuntimeStateSchema = z.strictObject({
+	url: z.union([z.literal("about:blank"), browserUrlSchema]),
+	title: z.string().max(256),
+	loading: z.boolean(),
+	canGoBack: z.boolean(),
+	canGoForward: z.boolean(),
+	viewport: z.strictObject({
+		width: z.number().finite().min(0).max(3840),
+		height: z.number().finite().min(0).max(2160)
+	})
+});
+const browserSessionStateSchema = browserRuntimeStateSchema.extend({
+	controlled: z.boolean(),
+	hasController: z.boolean(),
+	controller: z.enum([
+		"you",
+		"agent",
+		"other",
+		"none"
+	])
+});
+z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("ready"),
+		state: browserSessionStateSchema
+	}),
+	z.strictObject({
+		type: z.literal("state"),
+		state: browserSessionStateSchema
+	}),
+	z.strictObject({
+		type: z.literal("controlChanged"),
+		state: browserSessionStateSchema
+	}),
+	z.strictObject({
+		type: z.literal("navigationError"),
+		message: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("browserUnavailable"),
+		message: z.string(),
+		installCommand: z.string().nullable()
+	}),
+	z.strictObject({
+		type: z.literal("browserCrashed"),
+		message: z.string()
+	}),
+	z.strictObject({
+		type: z.literal("closed"),
+		reason: z.string()
+	})
+]);
+z.strictObject({
+	sequence: z.number().int().positive(),
+	mimeType: z.literal("image/jpeg"),
+	timestamp: z.number(),
+	width: z.number().int().positive(),
+	height: z.number().int().positive(),
+	data: z.union([z.instanceof(Uint8Array), z.instanceof(ArrayBuffer)]).transform((value) => value instanceof Uint8Array ? value : new Uint8Array(value)).refine((value) => value.byteLength <= BROWSER_MAX_FRAME_BYTES)
+});
+const browserTicketRequestSchema = z.strictObject({
+	clientId: z.string().min(1).max(128),
+	visible: z.boolean()
+});
+const browserOwnerTicketRequestSchema = z.strictObject({ clientId: z.string().min(1).max(128) });
+const opaqueTokenSchema = z.string().min(32).max(256);
+const browserPanelIdSchema = z.string().min(1).max(128);
+const browserRequestIdSchema = z.string().min(1).max(128);
+const browserGenerationSchema = z.number().int().positive();
+const browserRevisionSchema = z.number().int().nonnegative();
+const browserOwnerEndpointSchema = z.string().url().max(1024).refine((value) => {
+	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 !== "/";
+}, "Expected a private loopback Browser endpoint");
+const browserAgentArgumentSchema = z.string().max(4096);
+const browserAgentCommandSchema = z.discriminatedUnion("command", [
+	z.strictObject({
+		command: z.literal("snapshot"),
+		args: z.tuple([])
+	}),
+	z.strictObject({
+		command: z.literal("click"),
+		args: z.tuple([browserAgentArgumentSchema])
+	}),
+	z.strictObject({
+		command: z.literal("fill"),
+		args: z.tuple([browserAgentArgumentSchema, browserAgentArgumentSchema])
+	}),
+	z.strictObject({
+		command: z.literal("press"),
+		args: z.tuple([browserAgentArgumentSchema])
+	}),
+	z.strictObject({
+		command: z.literal("console"),
+		args: z.union([z.tuple([]), z.tuple([browserAgentArgumentSchema.max(32)])])
+	}),
+	z.strictObject({
+		command: z.literal("requests"),
+		args: z.tuple([])
+	}),
+	z.strictObject({
+		command: z.literal("screenshot"),
+		args: z.tuple([])
+	}),
+	z.strictObject({
+		command: z.literal("goto"),
+		args: z.tuple([browserUrlSchema])
+	}),
+	z.strictObject({
+		command: z.literal("go-back"),
+		args: z.tuple([])
+	}),
+	z.strictObject({
+		command: z.literal("go-forward"),
+		args: z.tuple([])
+	}),
+	z.strictObject({
+		command: z.literal("reload"),
+		args: z.tuple([])
+	})
+]);
+const browserAuthSchema = z.strictObject({
+	ticket: opaqueTokenSchema,
+	protocolVersion: z.literal(3)
+});
+const browserOwnerAuthSchema = z.strictObject({
+	ticket: opaqueTokenSchema,
+	protocolVersion: z.literal(3),
+	endpoint: browserOwnerEndpointSchema,
+	challenge: opaqueTokenSchema
+});
+const browserOwnerClientMessageSchema = z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("ready"),
+		generation: browserGenerationSchema,
+		revision: browserRevisionSchema,
+		state: browserRuntimeStateSchema
+	}),
+	z.strictObject({
+		type: z.literal("state"),
+		generation: browserGenerationSchema,
+		revision: browserRevisionSchema,
+		state: browserRuntimeStateSchema
+	}),
+	z.strictObject({
+		type: z.literal("popup"),
+		generation: browserGenerationSchema,
+		url: browserUrlSchema
+	}),
+	z.strictObject({
+		type: z.literal("crashed"),
+		generation: browserGenerationSchema,
+		message: z.string().min(1).max(1024)
+	}),
+	z.strictObject({
+		type: z.literal("runtimeControlResult"),
+		generation: browserGenerationSchema,
+		requestId: browserRequestIdSchema,
+		accepted: z.boolean()
+	}),
+	z.strictObject({
+		type: z.literal("takeControl"),
+		generation: browserGenerationSchema
+	}),
+	z.strictObject({
+		type: z.literal("released"),
+		generation: browserGenerationSchema
+	}),
+	z.strictObject({
+		type: z.literal("closeResult"),
+		generation: browserGenerationSchema,
+		requestId: browserRequestIdSchema,
+		canClose: z.boolean()
+	})
+]);
+z.discriminatedUnion("type", [
+	z.strictObject({
+		type: z.literal("claimGranted"),
+		panelId: browserPanelIdSchema,
+		generation: browserGenerationSchema,
+		resumed: z.boolean(),
+		state: browserRuntimeStateSchema
+	}),
+	z.strictObject({
+		type: z.literal("claimRejected"),
+		message: z.string().min(1).max(1024)
+	}),
+	z.strictObject({
+		type: z.literal("runtimeControl"),
+		generation: browserGenerationSchema,
+		requestId: browserRequestIdSchema,
+		controller: z.enum([
+			"agent",
+			"other",
+			"none"
+		]),
+		retainPaint: z.boolean()
+	}),
+	z.strictObject({
+		type: z.literal("closeRequest"),
+		generation: browserGenerationSchema,
+		requestId: browserRequestIdSchema,
+		force: z.boolean()
+	}),
+	z.strictObject({
+		type: z.literal("closed"),
+		reason: z.string().max(1024)
+	})
+]);
+function parseBrowserAuth(value) {
+	const result = browserAuthSchema.safeParse(value);
+	return result.success ? result.data : null;
+}
+function parseBrowserOwnerAuth(value) {
+	const result = browserOwnerAuthSchema.safeParse(value);
+	return result.success ? result.data : null;
+}
+function parseBrowserClientMessage(value) {
+	const result = browserClientMessageSchema.safeParse(value);
+	return result.success ? result.data : null;
+}
+function parseBrowserOwnerClientMessage(value) {
+	const result = browserOwnerClientMessageSchema.safeParse(value);
+	return result.success ? result.data : null;
+}
+//#endregion
+//#region ../../packages/shared/dist/web-panel-protocol.js
+const webPanelPermissionSchema = z.enum(["same-origin", "tree-files"]);
+//#endregion
+//#region ../../packages/shared/dist/terminal-protocol.js
+const SOCKET_IO_PATH = "/api/socket.io/";
+const TERMINAL_CONTROLLER_GRACE_MS = 1e4;
+const TERMINAL_OUTPUT_HIGH_WATERMARK = 256 * 1024;
+const TERMINAL_OUTPUT_LOW_WATERMARK = 64 * 1024;
+const TERMINAL_OUTPUT_STALL_TIMEOUT_MS = 3e4;
+const TERMINAL_MAX_CLIENT_MESSAGE_BYTES = 128 * 1024;
+const TERMINAL_MAX_INPUT_BYTES = 64 * 1024;
+const TERMINAL_SCROLL_EXIT_SEQUENCE = "\x1B[9000~";
+const TERMINAL_SELECTION_START_SEQUENCE = "\x1B[9001~";
+const TERMINAL_SELECTION_STOP_SEQUENCE = "\x1B[9002~";
+const TERMINAL_SELECTION_CLEAR_SEQUENCE = "\x1B[9003~";
+const TERMINAL_SELECTION_RESTORE_SEQUENCE = "\x1B[9004~";
+z.unknown();
+const terminalId = z.string().min(1).max(128);
+const clientId = z.string().min(1).max(128);
+const streamId = z.string().min(1).max(128);
+const generation = z.number().int().nonnegative();
+const dimensions = {
+	cols: z.number().int().min(2).max(1e3),
+	rows: z.number().int().min(2).max(500)
+};
+const terminalSizeSchema = z.strictObject(dimensions);
+const terminalProgressSchema = z.strictObject({
+	state: z.enum([
+		"normal",
+		"error",
+		"indeterminate",
+		"paused"
+	]),
+	value: z.number().int().min(0).max(100).nullable()
+});
+const terminalProgramSchema = z.enum([
+	"pi",
+	"claude",
+	"codex"
+]);
+const terminalRuntimeMetadataSchema = z.strictObject({
+	terminalId: z.string().min(1),
+	title: z.string().max(256).nullable(),
+	program: terminalProgramSchema.nullable().default(null),
+	hasForegroundProcess: z.boolean().nullable().optional(),
+	progress: terminalProgressSchema.nullable(),
+	progressStartedAt: z.string().datetime().nullable().default(null),
+	progressClearedAt: z.string().datetime().nullable().default(null),
+	bell: z.strictObject({
+		sequence: z.number().int().positive(),
+		at: z.string().datetime(),
+		unread: z.boolean()
+	}).nullable().default(null)
+});
+const terminalBellAcknowledgementSchema = z.strictObject({ sequence: z.number().int().positive() });
+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 = z.strictObject({
+	terminalId,
+	clientId,
+	...dimensions
+});
+const terminalInputSchema = z.strictObject({
+	generation,
+	data: z.string().max(TERMINAL_MAX_INPUT_BYTES)
+});
+const terminalBinarySchema = z.strictObject({
+	generation,
+	data: z.string().max(TERMINAL_MAX_INPUT_BYTES)
+});
+const terminalResizeSchema = z.strictObject({
+	generation,
+	...dimensions
+});
+const terminalTakeControlSchema = z.strictObject({
+	generation,
+	...dimensions
+});
+const terminalLegacyTakeControlSchema = z.strictObject({ generation });
+const terminalOutputAckSchema = z.strictObject({
+	streamId,
+	sequence: z.number().int().nonnegative()
+});
+const terminalReadyBase = {
+	connectionId: z.string().min(1).max(128),
+	streamId,
+	generation,
+	controller: z.boolean(),
+	reset: z.literal("full")
+};
+const terminalLegacyReadySchema = z.strictObject(terminalReadyBase);
+const terminalReadyV2Schema = z.strictObject({
+	...terminalReadyBase,
+	...dimensions,
+	revision: z.number().int().positive()
+});
+z.union([terminalLegacyReadySchema, terminalReadyV2Schema]);
+z.strictObject({
+	...dimensions,
+	revision: z.number().int().positive()
+});
+z.strictObject({
+	streamId,
+	sequence: z.number().int().positive(),
+	data: z.string()
+});
+z.strictObject({ title: z.string().max(256) });
+z.strictObject({ progress: terminalProgressSchema.nullable() });
+z.strictObject({ viewing: z.boolean() });
+z.strictObject({
+	generation,
+	controller: z.boolean()
+});
+z.strictObject({ exitCode: z.number().int().nullable() });
+z.strictObject({
+	code: z.string().min(1).max(80),
+	message: z.string().min(1).max(1e3),
+	retryable: z.boolean()
+});
+function parseTerminalAuth(value) {
+	const parsed = terminalAuthSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+//#endregion
+//#region ../../packages/shared/dist/socket-protocol.js
+const identifierSchema = z.string().min(1).max(128);
+const eventEnvelope = (type, data) => z.strictObject({
+	id: identifierSchema,
+	type: z.literal(type),
+	at: z.string().datetime(),
+	data
+});
+const projectEventDataSchema = z.strictObject({
+	projectId: identifierSchema,
+	worktreeId: z.null()
+});
+const worktreeEventDataSchema = z.strictObject({ worktreeId: identifierSchema });
+const projectWorktreeEventDataSchema = z.strictObject({
+	projectId: identifierSchema,
+	worktreeId: identifierSchema
+});
+const operationEventDataSchema = z.strictObject({
+	operationId: identifierSchema,
+	worktreeId: identifierSchema
+});
+const webPanelSnapshotSchema = z.strictObject({
+	id: z.string().min(1),
+	kind: z.literal("web"),
+	worktreeId: z.string().min(1),
+	definitionId: z.string().min(1),
+	title: z.string().min(1),
+	launch: z.strictObject({
+		input: z.record(z.string(), z.json()).nullable(),
+		cwd: z.string().nullable()
+	}),
+	permissions: z.array(webPanelPermissionSchema),
+	sandbox: z.strictObject({ allowSameOrigin: z.boolean() }),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+const browserPanelSnapshotSchema = z.strictObject({
+	id: z.string().min(1),
+	kind: z.literal("browser"),
+	worktreeId: z.string().min(1),
+	title: z.string().min(1).max(256),
+	url: z.union([z.literal("about:blank"), browserUrlSchema]),
+	createdAt: z.string(),
+	updatedAt: z.string()
+});
+const openPanelSnapshotSchema = z.discriminatedUnion("kind", [webPanelSnapshotSchema, browserPanelSnapshotSchema]);
+const productEventSchema = z.discriminatedUnion("type", [
+	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", z.strictObject({
+		projectId: identifierSchema,
+		operationId: identifierSchema,
+		worktreeId: z.null()
+	})),
+	eventEnvelope("create.completed", z.strictObject({
+		projectId: identifierSchema,
+		operationId: identifierSchema,
+		worktreeId: identifierSchema
+	})),
+	eventEnvelope("create.failed", z.strictObject({
+		projectId: identifierSchema,
+		operationId: identifierSchema,
+		worktreeId: z.null()
+	})),
+	eventEnvelope("terminal.created", z.strictObject({
+		projectId: identifierSchema.optional(),
+		worktreeId: identifierSchema,
+		terminalId: identifierSchema
+	})),
+	eventEnvelope("terminal.updated", z.strictObject({
+		worktreeId: identifierSchema,
+		terminalId: identifierSchema
+	})),
+	eventEnvelope("terminal.removed", z.strictObject({
+		worktreeId: identifierSchema,
+		terminalId: identifierSchema
+	})),
+	eventEnvelope("terminal.metadata", terminalRuntimeMetadataSchema.extend({ worktreeId: z.null() })),
+	eventEnvelope("terminal.controller_changed", z.strictObject({
+		terminalId: identifierSchema,
+		controlled: z.boolean(),
+		worktreeId: z.null()
+	})),
+	eventEnvelope("panel.created", z.strictObject({
+		worktreeId: identifierSchema,
+		panelId: identifierSchema
+	})),
+	eventEnvelope("panel.updated", z.strictObject({
+		worktreeId: identifierSchema,
+		panelId: identifierSchema
+	})),
+	eventEnvelope("panel.open_requested", z.strictObject({
+		worktreeId: identifierSchema,
+		panelId: identifierSchema,
+		panel: openPanelSnapshotSchema,
+		sourceTerminalId: identifierSchema.nullable(),
+		sourcePanelId: identifierSchema.nullable()
+	})),
+	eventEnvelope("panel.removed", z.strictObject({
+		worktreeId: identifierSchema,
+		panelId: identifierSchema
+	})),
+	eventEnvelope("workspace.open_requested", z.strictObject({
+		worktreeId: identifierSchema,
+		sourceTerminalId: identifierSchema
+	})),
+	eventEnvelope("remove.started", operationEventDataSchema.extend({ kind: z.literal("remove") })),
+	eventEnvelope("remove.completed", operationEventDataSchema),
+	eventEnvelope("remove.failed", operationEventDataSchema.extend({ error: z.string() }))
+]);
+const eventsSnapshotSchema = z.strictObject({
+	at: z.string().datetime(),
+	terminalMetadata: z.array(terminalRuntimeMetadataSchema),
+	webPanels: z.array(webPanelSnapshotSchema),
+	browserPanels: z.array(browserPanelSnapshotSchema)
+});
+z.unknown();
+function parseEventsSnapshot(value) {
+	const parsed = eventsSnapshotSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+function parseProductEvent(value) {
+	const parsed = productEventSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+//#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_CONTEXT_VALUES_MAX_LENGTH = 64 * 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 browseDirectoryQuerySchema = z.object({
+	input: z.string().trim().min(1).max(4096),
+	hidden: z.enum(["true", "false"]).optional().default("false").transform((value) => value === "true")
+});
+const terminalCaptureQuerySchema = z.object({ lines: z.coerce.number().int().min(1).max(TERMINAL_CAPTURE_MAX_LINES).optional().default(200) });
+const registerProjectSchema = z.object({
+	path: z.string().trim().min(1),
+	name: z.string().trim().min(1).max(120).optional()
+});
+const updateProjectSchema = z.object({ color: z.enum(PROJECT_COLORS).nullable() });
+const terminalNameSchema = z.string().trim().min(1).max(120);
+const terminalArgvSchema = z.array(z.string()).min(1).max(128);
+const terminalPresetArgumentSchema = z.string().max(TERMINAL_ARGUMENT_MAX_LENGTH);
+const terminalPresetFields = {
+	name: terminalNameSchema,
+	executable: z.string().min(1).max(TERMINAL_EXECUTABLE_MAX_LENGTH).refine((value) => value.trim().length > 0, { message: "Executable cannot be blank" }),
+	args: z.array(terminalPresetArgumentSchema).max(127),
+	closeOnSuccess: z.boolean().default(false)
+};
+const repositoryTerminalPresetSchema = z.strictObject(terminalPresetFields);
+const repositoryTerminalPresetIdSchema = z.string().regex(/^[a-z0-9][a-z0-9._-]{0,119}$/, { message: "Preset IDs must contain only lowercase letters, numbers, dots, underscores, and hyphens" });
+const repositoryTerminalPresetsFileSchema = z.strictObject({
+	version: z.literal(1),
+	presets: z.record(repositoryTerminalPresetIdSchema, z.unknown())
+});
+const terminalPresetRevisionSchema = z.string().min(1).max(64);
+const treeContextFieldIdSchema = z.string().trim().regex(/^[a-z0-9][a-z0-9._-]{0,119}$/, { message: "Field IDs must contain only lowercase letters, numbers, dots, underscores, and hyphens" });
+const treeContextFieldDefinitionSchema = z.strictObject({
+	id: treeContextFieldIdSchema,
+	label: z.string().trim().min(1).max(120).refine((value) => !value.includes("\0"), { message: "Field labels cannot contain NUL" }),
+	input: z.enum(["text", "textarea"])
+});
+const treeContextValuesSchema = z.record(treeContextFieldIdSchema, z.string().trim().min(1).max(TREE_CONTEXT_VALUE_MAX_LENGTH).refine((value) => !value.includes("\0"), { message: "Tree context values cannot contain NUL" })).superRefine((values, context) => {
+	const entries = Object.entries(values);
+	if (entries.length > 64) context.addIssue({
+		code: "custom",
+		message: `Tree context cannot contain more than 64 values`
+	});
+	if (entries.reduce((length, [key, value]) => length + key.length + value.length, 0) > 65536) context.addIssue({
+		code: "custom",
+		message: `Tree context cannot contain more than ${TREE_CONTEXT_VALUES_MAX_LENGTH} characters`
+	});
+});
+const initialTerminalSchema = z.object({
+	name: terminalNameSchema,
+	initialTitle: terminalNameSchema.optional(),
+	argv: terminalArgvSchema.optional(),
+	returnToShell: z.boolean().optional(),
+	initialSize: terminalSizeSchema.optional()
+});
+const createWorktreeSchema = z.object({
+	name: z.string().trim().min(1).max(120),
+	base: z.enum(["default", "current"]).default("default"),
+	context: treeContextValuesSchema.optional(),
+	sourceWorktreeId: z.string().min(1).optional(),
+	initialTerminal: initialTerminalSchema.optional()
+}).superRefine((value, context) => {
+	if (value.base === "current" && !value.sourceWorktreeId) context.addIssue({
+		code: "custom",
+		path: ["sourceWorktreeId"],
+		message: "A source tree is required when starting from current"
+	});
+});
+const terminalCwdSchema = z.string().min(1).max(4096).refine((value) => value.trim().length > 0 && !value.includes("\0"), { message: "Working directory cannot be blank or contain NUL" });
+const terminalEnvironmentKeySchema = z.string().min(1).max(256).refine((value) => !value.includes("=") && !value.includes("\0"), { message: "Environment keys cannot contain equals or NUL" });
+const terminalShellCommandSchema = z.string().min(1).max(TERMINAL_ARGUMENT_MAX_LENGTH).refine((value) => value.trim().length > 0 && !value.includes("\0"), { message: "Shell command cannot be blank or contain NUL" });
+const terminalEnvironmentSchema = z.record(terminalEnvironmentKeySchema, z.string().max(TERMINAL_ARGUMENT_MAX_LENGTH).refine((value) => !value.includes("\0"), { message: "Environment values cannot contain NUL" })).refine((value) => Object.keys(value).length <= 128, { message: "Environment cannot contain more than 128 variables" });
+const createTerminalSchema = z.object({
+	name: terminalNameSchema,
+	initialTitle: terminalNameSchema.optional(),
+	argv: terminalArgvSchema.optional(),
+	shellCommand: terminalShellCommandSchema.optional(),
+	cwd: terminalCwdSchema.optional(),
+	env: terminalEnvironmentSchema.optional(),
+	returnToShell: z.boolean().optional(),
+	closeOnSuccess: z.boolean().optional(),
+	initialSize: terminalSizeSchema.optional()
+}).refine((value) => !(value.argv && value.shellCommand), { message: "A terminal cannot have both argv and a shell command" }).refine((value) => !(value.returnToShell && value.closeOnSuccess), { message: "A terminal cannot return to a shell and close on success" });
+const updateTerminalSchema = z.object({ name: terminalNameSchema });
+const webPanelInputSchema = z.record(z.string(), z.json());
+const createWebPanelSchema = z.object({
+	definitionId: z.string().min(1).max(256),
+	input: webPanelInputSchema.nullable().optional(),
+	launchCwd: z.string().max(4096).nullable().optional()
+});
+const updateWebPanelPermissionGrantSchema = z.strictObject({
+	granted: z.boolean(),
+	permissions: z.array(webPanelPermissionSchema)
+});
+const createBrowserPanelSchema = z.strictObject({
+	url: browserUrlSchema.optional(),
+	sourceTerminalId: z.string().min(1).max(128).nullable().optional()
+});
+const openBrowserPanelFromTerminalSchema = z.strictObject({ url: browserUrlSchema });
+const openWebPanelSchema = createWebPanelSchema.extend({
+	newInstance: z.boolean().optional(),
+	sourceTerminalId: z.string().min(1).max(128).nullable().optional()
+});
+const requestWorkspaceOpenSchema = z.object({ sourceTerminalId: z.string().min(1).max(128) });
+const webPanelStorageKeySchema = z.string().min(1).max(128);
+const getWebPanelStorageSchema = z.object({ key: webPanelStorageKeySchema });
+const setWebPanelStorageSchema = z.object({
+	key: webPanelStorageKeySchema,
+	value: z.json()
+});
+const deleteWebPanelStorageSchema = z.object({ key: webPanelStorageKeySchema });
+const treeFilePathSchema = z.string().min(1).max(4096).refine((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 = z.strictObject({ path: treeFilePathSchema });
+const writeTreeFileSchema = z.strictObject({
+	path: treeFilePathSchema,
+	content: z.string(),
+	expectedRevision: z.string().min(1).max(128)
+});
+const createTerminalPresetSchema = z.object(terminalPresetFields);
+const updateTerminalPresetSchema = z.object({
+	...terminalPresetFields,
+	closeOnSuccess: z.boolean().optional(),
+	expectedUpdatedAt: terminalPresetRevisionSchema
+});
+const deleteTerminalPresetSchema = z.object({ expectedUpdatedAt: terminalPresetRevisionSchema });
+const packageProjectQuerySchema = z.object({ path: z.string().trim().min(1).max(4096) });
+const packageInstallSchema = z.object({
+	source: z.string().trim().min(1).max(4096),
+	projectId: z.string().min(1).optional()
+});
+const packageRemoveSchema = z.object({
+	source: z.string().trim().min(1).max(4096),
+	projectId: z.string().min(1).optional()
+});
+const packageUpdateSchema = z.object({ source: z.string().trim().min(1).max(4096).optional() });
+const packageReloadSchema = z.object({ projectId: z.string().min(1).optional() });
+const removeWorktreeSchema = z.object({
+	confirmationToken: z.string().length(64),
+	confirmDestructive: z.boolean()
+});
+z.object({
+	project: z.string().min(1),
+	worktreeName: z.string().trim().min(1).max(120),
+	name: terminalNameSchema,
+	argv: terminalArgvSchema.optional(),
+	base: z.enum(["default", "current"]).default("default"),
+	sourceWorktreeId: z.string().min(1).optional()
+}).superRefine((value, context) => {
+	if (value.base === "current" && !value.sourceWorktreeId) context.addIssue({
+		code: "custom",
+		path: ["sourceWorktreeId"],
+		message: "A source tree is required when starting from current"
+	});
+});
+//#endregion
+export { TERMINAL_SELECTION_STOP_SEQUENCE as $, terminalCaptureQuerySchema as A, parseEventsSnapshot as B, readTreeFileSchema as C, repositoryTerminalPresetsFileSchema as D, repositoryTerminalPresetSchema as E, updateTerminalPresetSchema as F, TERMINAL_MAX_INPUT_BYTES as G, SOCKET_IO_PATH as H, updateTerminalSchema as I, TERMINAL_OUTPUT_STALL_TIMEOUT_MS as J, TERMINAL_OUTPUT_HIGH_WATERMARK as K, updateWebPanelPermissionGrantSchema as L, treeContextValuesSchema as M, treeFilePathSchema as N, requestWorkspaceOpenSchema as O, updateProjectSchema as P, TERMINAL_SELECTION_START_SEQUENCE as Q, webPanelInputSchema as R, packageUpdateSchema as S, removeWorktreeSchema as T, TERMINAL_CONTROLLER_GRACE_MS as U, parseProductEvent as V, TERMINAL_MAX_CLIENT_MESSAGE_BYTES as W, TERMINAL_SELECTION_CLEAR_SEQUENCE as X, TERMINAL_SCROLL_EXIT_SEQUENCE as Y, TERMINAL_SELECTION_RESTORE_SEQUENCE as Z, openWebPanelSchema as _, parseBrowserAuth as _t, WEB_PANEL_INPUT_MAX_BYTES as a, terminalLegacyTakeControlSchema as at, packageReloadSchema as b, parseBrowserOwnerClientMessage as bt, createTerminalPresetSchema as c, terminalSizeSchema as ct, createWorktreeSchema as d, BROWSER_MAX_FRAME_BYTES as dt, parseTerminalAuth as et, deleteTerminalPresetSchema as f, browserAgentCommandSchema as ft, openBrowserPanelFromTerminalSchema as g, browserUrlSchema as gt, getWebPanelStorageSchema as h, browserTicketRequestSchema as ht, TREE_FILE_MAX_BYTES as i, terminalInputSchema as it, treeContextFieldDefinitionSchema as j, setWebPanelStorageSchema as k, createTerminalSchema as l, terminalTakeControlSchema as lt, formatCommandLine as m, browserOwnerTicketRequestSchema as mt, TERMINAL_MAX_UPLOAD_BYTES as n, terminalBellAcknowledgementSchema as nt, browseDirectoryQuerySchema as o, terminalOutputAckSchema as ot, deleteWebPanelStorageSchema as p, browserOwnerEndpointSchema as pt, TERMINAL_OUTPUT_LOW_WATERMARK as q, TREE_FILE_LIST_MAX_ENTRIES as r, terminalBinarySchema as rt, createBrowserPanelSchema as s, terminalResizeSchema as st, TERMINAL_CAPTURE_MAX_LINES as t, parseTerminalProgress as tt, createWebPanelSchema as u, webPanelPermissionSchema as ut, packageInstallSchema as v, parseBrowserClientMessage as vt, registerProjectSchema as w, packageRemoveSchema as x, packageProjectQuerySchema as y, parseBrowserOwnerAuth as yt, writeTreeFileSchema as z };