@seed-app-studio/sdk 0.1.1-canary.0 → 0.1.1-canary.2

package/dist/index.cjs

@@ -0,0 +1,4120 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _seed_app_studio_protocol = require("@seed-app-studio/protocol");
+//#region src/agentStream.ts
+function matchesSeedAppHostEventSubscription(eventName, event) {
+	switch (eventName) {
+		case _seed_app_studio_protocol.SEED_APP_HOST_EVENT_NAMES.agentStream: return (0, _seed_app_studio_protocol.isSeedAppAgentStreamEvent)(event);
+		case _seed_app_studio_protocol.SEED_APP_HOST_EVENT_NAMES.aguiStream: return (0, _seed_app_studio_protocol.isSeedAguiEvent)(event);
+		case _seed_app_studio_protocol.SEED_APP_HOST_EVENT_NAMES.backgroundStream: return (0, _seed_app_studio_protocol.isSeedBackgroundStreamEvent)(event) || event.type === _seed_app_studio_protocol.SEED_AGENT_STREAM_EVENT_NAMES.backgroundOutput;
+		default: return event.type === eventName;
+	}
+}
+//#endregion
+//#region src/contracts.ts
+const SEED_APP_ERROR_CODES = /* @__PURE__ */ new Set([
+	"host_unavailable",
+	"app_not_installed",
+	"app_disabled",
+	"handshake_timeout",
+	"unsupported_runtime",
+	"unauthenticated",
+	"capability_denied",
+	"approval_required",
+	"approval_denied",
+	"tenant_policy_denied",
+	"origin_denied",
+	"grant_required",
+	"nonce_invalid",
+	"csrf_required",
+	"bridge_policy_denied",
+	"provider_unavailable",
+	"provider_failed",
+	"payload_too_large",
+	"rate_limited",
+	"invalid_payload_schema",
+	"reserved_bridge_key",
+	"mcp_unavailable",
+	"memory_scope_denied",
+	"resource_scope_denied",
+	"skill_scope_denied",
+	"bundle_integrity_failed",
+	"sdk_version_incompatible",
+	"invalid_request",
+	"invalid_target",
+	"not_found",
+	"already_exists",
+	"not_a_file",
+	"not_a_directory",
+	"parent_not_found",
+	"directory_not_empty",
+	"protected_path",
+	"permission_denied",
+	"mount_not_found",
+	"resource_not_found",
+	"resource_disabled",
+	"resource_unavailable",
+	"mode_not_allowed",
+	"unsupported_operation",
+	"unsupported_option_combination",
+	"execute_preflight_unknown",
+	"cross_mount_move_unsupported",
+	"version_conflict",
+	"edit_conflict",
+	"idempotency_conflict",
+	"stale_writer",
+	"write_fence_expired",
+	"write_fence_scope_denied",
+	"file_too_large",
+	"cursor_invalid",
+	"timeout",
+	"cancelled",
+	"provider_error",
+	"internal_error"
+]);
+function normalizeSeedAppErrorCode(value) {
+	return typeof value === "string" && SEED_APP_ERROR_CODES.has(value) ? value : "provider_failed";
+}
+function createSeedAppError(input) {
+	return {
+		retryable: false,
+		...input
+	};
+}
+const TRACEPARENT_PATTERN = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/i;
+const ZERO_TRACE_ID = "00000000000000000000000000000000";
+const ZERO_SPAN_ID = "0000000000000000";
+function isSeedAppTraceEnabled(env = readSeedAppEnv()) {
+	return env.SEED_TRACE === "1" || env.SEED_TRACE?.toLowerCase() === "true";
+}
+function createSeedAppRootTraceContext(input = {}) {
+	const traceId = isValidTraceId(input.traceId) ? input.traceId.toLowerCase() : createRandomHex(16, ZERO_TRACE_ID);
+	const spanId = createRandomHex(8, ZERO_SPAN_ID);
+	const sampled = input.sampled ?? true;
+	return {
+		traceId,
+		spanId,
+		traceparent: toSeedAppTraceparent({
+			traceId,
+			spanId,
+			sampled
+		}),
+		sampled
+	};
+}
+function extractSeedAppTraceContext(carrier) {
+	const record = readSeedAppRecord(carrier);
+	if (!record) return void 0;
+	const parsed = parseSeedAppTraceparent(firstString(nestedString(record.metadata, "traceparent"), nestedString(record.metadata, "traceParent"), record.traceparent, record.traceParent));
+	if (parsed) return parsed;
+	const traceId = firstString(nestedString(record.metadata, "traceId"), record.traceId);
+	return isValidTraceId(traceId) ? createSeedAppRootTraceContext({ traceId: traceId.toLowerCase() }) : void 0;
+}
+function ensureSeedAppTraceCarrier(value, env = readSeedAppEnv()) {
+	const record = readSeedAppRecord(value);
+	if (!record) return value;
+	const context = extractSeedAppTraceContext(record) ?? (isSeedAppTraceEnabled(env) ? createSeedAppRootTraceContext() : void 0);
+	if (!context) return value;
+	return injectSeedAppTraceContext(record, context);
+}
+function injectSeedAppTraceContext(record, context) {
+	const metadata = readSeedAppRecord(record.metadata) ?? {};
+	const traceId = firstString(metadata.traceId, record.traceId) ?? context.traceId;
+	const traceparent = firstString(metadata.traceparent, metadata.traceParent, record.traceparent, record.traceParent) ?? context.traceparent;
+	return {
+		...record,
+		traceId,
+		traceparent,
+		metadata: {
+			...metadata,
+			traceId,
+			traceparent
+		}
+	};
+}
+function parseSeedAppTraceparent(traceparent) {
+	if (typeof traceparent !== "string") return void 0;
+	const match = TRACEPARENT_PATTERN.exec(traceparent.trim());
+	if (!match) return void 0;
+	const [version, traceId, spanId, flags] = match.slice(1);
+	if (version.toLowerCase() === "ff") return void 0;
+	if (!isValidTraceId(traceId) || !isValidSpanId(spanId)) return void 0;
+	return {
+		traceId: traceId.toLowerCase(),
+		spanId: spanId.toLowerCase(),
+		traceparent: `00-${traceId.toLowerCase()}-${spanId.toLowerCase()}-${flags.toLowerCase()}`,
+		sampled: (Number.parseInt(flags, 16) & 1) === 1
+	};
+}
+function toSeedAppTraceparent(context) {
+	return `00-${context.traceId}-${context.spanId}-${context.sampled ? "01" : "00"}`;
+}
+function isValidTraceId(value) {
+	return typeof value === "string" && /^[0-9a-f]{32}$/i.test(value) && value.toLowerCase() !== ZERO_TRACE_ID;
+}
+function isValidSpanId(value) {
+	return typeof value === "string" && /^[0-9a-f]{16}$/i.test(value) && value.toLowerCase() !== ZERO_SPAN_ID;
+}
+function createRandomHex(byteLength, zeroValue) {
+	for (let attempt = 0; attempt < 4; attempt += 1) {
+		const bytes = new Uint8Array(byteLength);
+		const cryptoLike = globalThis.crypto;
+		const randomBytes = cryptoLike?.getRandomValues ? cryptoLike.getRandomValues(bytes) : fallbackRandomBytes(bytes);
+		const value = Array.from(randomBytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+		if (value !== zeroValue) return value;
+	}
+	return `${"1".padStart(byteLength * 2, "0")}`;
+}
+function fallbackRandomBytes(bytes) {
+	for (let index = 0; index < bytes.length; index += 1) bytes[index] = Math.floor(Math.random() * 256);
+	return bytes;
+}
+function firstString(...values) {
+	return values.find((value) => typeof value === "string");
+}
+function nestedString(value, key) {
+	const nestedValue = readSeedAppRecord(value)?.[key];
+	return typeof nestedValue === "string" ? nestedValue : void 0;
+}
+function readSeedAppRecord(value) {
+	return isRecord$4(value) ? value : void 0;
+}
+function readSeedAppEnv() {
+	return globalThis.process?.env ?? {};
+}
+const seedBridgeGoldenCaseReportSchemaVersion = "seed.bridge.golden-case.report.v1";
+const seedBridgeGoldenCasePrimaryTransportByRuntime = {
+	electron: "electron-ipc",
+	"local-webui": "local-websocket",
+	"web-saas": "web-saas-bridge-ws",
+	"react-native": "react-native-webview",
+	"app-host": "app-host-postmessage"
+};
+function createSeedBridgeGoldenCaseReport(input) {
+	return {
+		schemaVersion: seedBridgeGoldenCaseReportSchemaVersion,
+		...input
+	};
+}
+function validateSeedBridgeGoldenCaseReport(report) {
+	const errors = [];
+	const record = report;
+	if (!isRecord$4(record)) return {
+		ok: false,
+		errors: ["report must be an object."]
+	};
+	if (record.schemaVersion !== "seed.bridge.golden-case.report.v1") errors.push(`schemaVersion must be ${seedBridgeGoldenCaseReportSchemaVersion}.`);
+	validateRequiredText(record, "runtime", errors);
+	validateRequiredText(record, "transport", errors);
+	validateRequiredText(record, "appId", errors);
+	validateRequiredText(record, "appSessionId", errors);
+	validateRequiredText(record, "generatedAt", errors);
+	if (hasText(record.runtime) && !isSeedBridgeGoldenCaseRuntime(record.runtime)) errors.push("runtime must be one of electron, local-webui, web-saas, react-native, app-host.");
+	validateRuntimeTransport(record, errors);
+	validateGeneratedAt(record.generatedAt, errors);
+	validateMethodResults(record.methodResults, errors);
+	validateRequiredTextArray(record.eventTypes, "eventTypes", errors);
+	validateRequiredTextArray(record.terminalTypes, "terminalTypes", errors);
+	validateNegativeCases(record.negativeCases, errors);
+	validateArtifacts(record.artifacts, errors);
+	return {
+		ok: errors.length === 0,
+		errors
+	};
+}
+function isSeedBridgeGoldenCaseReport(value) {
+	if (!isRecord$4(value)) return false;
+	return validateSeedBridgeGoldenCaseReport(value).ok;
+}
+function validateRuntimeTransport(record, errors) {
+	if (!isSeedBridgeGoldenCaseRuntime(record.runtime) || typeof record.transport !== "string") return;
+	const expectedTransport = seedBridgeGoldenCasePrimaryTransportByRuntime[record.runtime];
+	if (record.transport !== expectedTransport) errors.push(`transport must be ${expectedTransport} for runtime ${record.runtime}.`);
+}
+function validateGeneratedAt(value, errors) {
+	if (typeof value !== "string" || value.trim().length === 0) return;
+	if (Number.isNaN(Date.parse(value))) errors.push("generatedAt must be an ISO-8601 timestamp.");
+}
+function validateMethodResults(value, errors) {
+	if (!Array.isArray(value)) {
+		errors.push("methodResults must be an array.");
+		return;
+	}
+	if (value.length === 0) errors.push("methodResults must contain at least one method result.");
+	value.forEach((entry, index) => {
+		if (!isRecord$4(entry)) {
+			errors.push(`methodResults[${index}] must be an object.`);
+			return;
+		}
+		if (!hasText(entry.method)) errors.push(`methodResults[${index}].method must be a non-empty string.`);
+		if (typeof entry.ok !== "boolean") errors.push(`methodResults[${index}].ok must be a boolean.`);
+		if (entry.durationMs !== void 0 && !isNonNegativeFiniteNumber(entry.durationMs)) errors.push(`methodResults[${index}].durationMs must be a non-negative finite number.`);
+	});
+}
+function validateRequiredTextArray(value, field, errors) {
+	if (!Array.isArray(value)) {
+		errors.push(`${field} must be an array.`);
+		return;
+	}
+	if (value.length === 0) errors.push(`${field} must contain at least one value.`);
+	value.forEach((entry, index) => {
+		if (!hasText(entry)) errors.push(`${field}[${index}] must be a non-empty string.`);
+	});
+}
+function validateNegativeCases(value, errors) {
+	if (!Array.isArray(value)) {
+		errors.push("negativeCases must be an array.");
+		return;
+	}
+	if (value.length === 0) errors.push("negativeCases must contain at least one case.");
+	value.forEach((entry, index) => {
+		if (!isRecord$4(entry)) {
+			errors.push(`negativeCases[${index}] must be an object.`);
+			return;
+		}
+		if (!hasText(entry.id)) errors.push(`negativeCases[${index}].id must be a non-empty string.`);
+		if (entry.status !== "passed" && entry.status !== "failed") errors.push(`negativeCases[${index}].status must be passed or failed.`);
+	});
+}
+function validateArtifacts(value, errors) {
+	if (!Array.isArray(value)) {
+		errors.push("artifacts must be an array.");
+		return;
+	}
+	if (value.length === 0) errors.push("artifacts must contain at least one artifact.");
+	value.forEach((entry, index) => {
+		if (!isRecord$4(entry)) {
+			errors.push(`artifacts[${index}] must be an object.`);
+			return;
+		}
+		if (!hasText(entry.kind)) errors.push(`artifacts[${index}].kind must be a non-empty string.`);
+		if (!hasText(entry.path) && !hasText(entry.url)) errors.push(`artifacts[${index}] must include path or url.`);
+	});
+}
+function validateRequiredText(record, field, errors) {
+	if (!hasText(readPath(record, field))) errors.push(`${field} must be a non-empty string.`);
+}
+function readPath(record, path) {
+	return path.split(".").reduce((current, segment) => {
+		if (!isRecord$4(current)) return void 0;
+		return current[segment];
+	}, record);
+}
+function isSeedBridgeGoldenCaseRuntime(value) {
+	return value === "electron" || value === "local-webui" || value === "web-saas" || value === "react-native" || value === "app-host";
+}
+function isNonNegativeFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function hasText(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/workspace.ts
+const WORKSPACE_CHANGED_METHOD = "seed.workspace.changed";
+function createSeedAppWorkspaceClient(request, eventSource = {}) {
+	return {
+		async list(input, options) {
+			assertWorkspaceLocation(input, "seed.workspace.list");
+			assertPositiveInteger(input.maxDepth, "maxDepth", "seed.workspace.list");
+			assertPositiveInteger(input.maxResults, "maxResults", "seed.workspace.list");
+			return request("seed.workspace.list", input, options);
+		},
+		async read(input, options) {
+			assertWorkspaceLocation(input, "seed.workspace.read");
+			assertPositiveInteger(input.maxBytes, "maxBytes", "seed.workspace.read");
+			return request("seed.workspace.read", input, options);
+		},
+		async search(input, options) {
+			assertOptionalWorkspaceLocation(input, "seed.workspace.search");
+			assertSearchNeedle(input);
+			assertPositiveInteger(input.maxDepth, "maxDepth", "seed.workspace.search");
+			assertPositiveInteger(input.maxResults, "maxResults", "seed.workspace.search");
+			return request("seed.workspace.search", input, options);
+		},
+		async capabilities(input = {}, options) {
+			assertOptionalWorkspaceLocation(input, "seed.workspace.capabilities.get");
+			return request("seed.workspace.capabilities.get", input, options);
+		},
+		async write(input, options) {
+			return request("seed.workspace.write", toWorkspaceWritePayload(input), options);
+		},
+		async stageUpload(input, options) {
+			return request("seed.workspace.upload.stage", toWorkspaceUploadStagePayload(input), options);
+		},
+		async delete(input, options) {
+			assertWorkspaceLocation(input, "seed.workspace.delete");
+			assertNonEmptyString(input.expectedVersion ?? input.expectedEtag ?? "", "expectedVersion", "seed.workspace.delete");
+			assertNonEmptyString(input.idempotencyKey, "idempotencyKey", "seed.workspace.delete");
+			return request("seed.workspace.delete", input, options);
+		},
+		async rename(input, options) {
+			assertWorkspaceLocation(input, "seed.workspace.rename");
+			assertWorkspaceFileName(input.newName, "newName", "seed.workspace.rename");
+			assertNonEmptyString(input.expectedVersion ?? input.expectedEtag ?? "", "expectedVersion", "seed.workspace.rename");
+			assertNonEmptyString(input.idempotencyKey, "idempotencyKey", "seed.workspace.rename");
+			return request("seed.workspace.rename", input, options);
+		},
+		async copy(input, options) {
+			assertWorkspaceLocation(input, "seed.workspace.copy");
+			assertOptionalWorkspaceId(input.targetWorkspaceId, "targetWorkspaceId", "seed.workspace.copy");
+			assertOptionalWorkspaceRelativePath(input.name, "name", "seed.workspace.copy");
+			return request("seed.workspace.copy", input, options);
+		},
+		async importLocalFiles(input, options) {
+			assertWorkspacePath(input.targetDirectory, "seed.workspace.importLocalFiles");
+			assertLocalSourcePaths(input.sourcePaths, "seed.workspace.importLocalFiles");
+			if (input.sourceRoot !== void 0) assertNonEmptyString(input.sourceRoot, "sourceRoot", "seed.workspace.importLocalFiles");
+			return request("seed.workspace.importLocalFiles", input, options);
+		},
+		subscribeChanged: (input, handler, options) => eventSource.subscribeBridgeEvent?.(WORKSPACE_CHANGED_METHOD, (event) => {
+			if (event.type !== WORKSPACE_CHANGED_METHOD || !isWorkspaceChangedPayload(event.payload)) return;
+			if (input.workspaceId && event.payload.workspaceId !== input.workspaceId) return;
+			handler(event.payload);
+		}, options, buildWorkspaceChangedSubscribeParams(input)) ?? Promise.resolve(eventSource.subscribe?.((event) => {
+			if (event.type !== WORKSPACE_CHANGED_METHOD || !isWorkspaceChangedPayload(event.payload)) return;
+			if (input.workspaceId && event.payload.workspaceId !== input.workspaceId) return;
+			handler(event.payload);
+		}) ?? (() => void 0)),
+		admin: {
+			async list(options) {
+				return request("seed.workspace.admin.list", void 0, options);
+			},
+			async create(input, options) {
+				assertNonEmptyString(input.name, "name", "seed.workspace.admin.create");
+				assertNonEmptyString(input.idempotencyKey, "idempotencyKey", "seed.workspace.admin.create");
+				if (input.ownershipScope === "tenant") assertNonEmptyString(input.tenantId ?? "", "tenantId", "seed.workspace.admin.create");
+				return request("seed.workspace.admin.create", input, options);
+			},
+			async update(input, options) {
+				assertNonEmptyString(input.workspaceId, "workspaceId", "seed.workspace.admin.update");
+				assertNonEmptyString(input.expectedVersion, "expectedVersion", "seed.workspace.admin.update");
+				if (input.name !== void 0) assertNonEmptyString(input.name, "name", "seed.workspace.admin.update");
+				if (input.name === void 0 && input.selectedDirectory === void 0 && input.status === void 0) throw createSeedAppError({
+					code: "invalid_payload_schema",
+					message: "seed.workspace.admin.update requires at least one update field",
+					requestId: "seed.workspace.admin.update"
+				});
+				return request("seed.workspace.admin.update", input, options);
+			},
+			async delete(input, options) {
+				assertNonEmptyString(input.workspaceId, "workspaceId", "seed.workspace.admin.delete");
+				assertNonEmptyString(input.expectedVersion, "expectedVersion", "seed.workspace.admin.delete");
+				assertNonEmptyString(input.idempotencyKey, "idempotencyKey", "seed.workspace.admin.delete");
+				await request("seed.workspace.admin.delete", input, options);
+			}
+		},
+		member: {
+			async assignableUsers(input, options) {
+				assertNonEmptyString(input.workspaceId, "workspaceId", "seed.workspace.member.assignableUsers");
+				return request("seed.workspace.member.assignableUsers", input, options);
+			},
+			async list(input, options) {
+				assertNonEmptyString(input.workspaceId, "workspaceId", "seed.workspace.member.list");
+				return request("seed.workspace.member.list", input, options);
+			},
+			async add(input, options) {
+				assertNonEmptyString(input.workspaceId, "workspaceId", "seed.workspace.member.add");
+				assertNonEmptyString(input.userId, "userId", "seed.workspace.member.add");
+				assertNonEmptyString(input.role, "role", "seed.workspace.member.add");
+				return request("seed.workspace.member.add", input, options);
+			},
+			async update(input, options) {
+				assertNonEmptyString(input.workspaceId, "workspaceId", "seed.workspace.member.update");
+				assertNonEmptyString(input.userId, "userId", "seed.workspace.member.update");
+				assertNonEmptyString(input.role, "role", "seed.workspace.member.update");
+				return request("seed.workspace.member.update", input, options);
+			},
+			async remove(input, options) {
+				assertNonEmptyString(input.workspaceId, "workspaceId", "seed.workspace.member.remove");
+				assertNonEmptyString(input.userId, "userId", "seed.workspace.member.remove");
+				await request("seed.workspace.member.remove", input, options);
+			}
+		}
+	};
+}
+function buildWorkspaceChangedSubscribeParams(input) {
+	const params = {};
+	if (input.workspaceId) params.workspaceId = input.workspaceId;
+	if (input.cursor) params.cursor = input.cursor;
+	return Object.keys(params).length > 0 ? params : void 0;
+}
+function isWorkspaceChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.workspaceId === "string" && typeof record.uri === "string" && (record.operation === "created" || record.operation === "updated" || record.operation === "deleted" || record.operation === "moved" || record.operation === "patched") && (record.paths === void 0 || isStringArray(record.paths)) && (record.parentDirs === void 0 || isStringArray(record.parentDirs)) && (record.affectedUris === void 0 || isStringArray(record.affectedUris)) && (record.updatedAt === void 0 || typeof record.updatedAt === "string") && (record.occurredAt === void 0 || typeof record.occurredAt === "string") && (record.source === void 0 || typeof record.source === "string");
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function toWorkspaceWritePayload(input) {
+	assertWorkspaceLocation(input, "seed.workspace.write");
+	assertWorkspaceContent(input.content);
+	assertNonEmptyString(input.idempotencyKey, "idempotencyKey", "seed.workspace.write");
+	if (typeof input.content === "string") return {
+		...input,
+		content: input.content,
+		encoding: input.encoding ?? "utf8"
+	};
+	return {
+		...input,
+		content: encodeBytesBase64(input.content),
+		encoding: "base64"
+	};
+}
+function toWorkspaceUploadStagePayload(input) {
+	assertWorkspaceFileName(input.fileName, "fileName", "seed.workspace.upload.stage");
+	assertWorkspaceBinaryContent(input.content, "seed.workspace.upload.stage");
+	if (input.mimeType !== void 0) assertNonEmptyString(input.mimeType, "mimeType", "seed.workspace.upload.stage");
+	if (input.conversationId !== void 0) assertNonEmptyString(input.conversationId, "conversationId", "seed.workspace.upload.stage");
+	return {
+		...input,
+		content: encodeBytesBase64(input.content),
+		encoding: "base64"
+	};
+}
+function assertWorkspacePath(path, requestId) {
+	if (typeof path !== "string" || !path.startsWith("/") || path.includes("://")) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Workspace path must be a Seed workspace absolute path.",
+		requestId
+	});
+	if (path.split("/").some((segment) => segment === "." || segment === "..")) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Workspace path must not contain . or .. segments.",
+		requestId
+	});
+}
+function assertWorkspaceLocation(input, requestId) {
+	if ("uri" in input && input.uri !== void 0) {
+		assertWorkspaceUri(input.uri, requestId);
+		return;
+	}
+	if ("path" in input && input.path !== void 0) {
+		assertWorkspacePath(input.path, requestId);
+		assertOptionalWorkspaceId(input.workspaceId, "workspaceId", requestId);
+		return;
+	}
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Workspace target must include path or workspace-fs URI.",
+		requestId
+	});
+}
+function assertOptionalWorkspaceLocation(input, requestId) {
+	if ("uri" in input && input.uri !== void 0) {
+		assertWorkspaceUri(input.uri, requestId);
+		return;
+	}
+	if ("path" in input && input.path !== void 0) {
+		assertWorkspacePath(input.path, requestId);
+		assertOptionalWorkspaceId(input.workspaceId, "workspaceId", requestId);
+	}
+}
+function assertWorkspaceUri(uri, requestId) {
+	if (typeof uri !== "string" || !/^workspace-fs:\/\/[^/?#]+\/[^?#]*$/.test(uri)) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Workspace URI must be a workspace-fs URI.",
+		requestId
+	});
+}
+function assertWorkspaceContent(content) {
+	if (typeof content === "string" || content instanceof Uint8Array) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Workspace write content must be a string or Uint8Array.",
+		requestId: "seed.workspace.write"
+	});
+}
+function assertWorkspaceBinaryContent(content, requestId) {
+	if (content instanceof Uint8Array) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Workspace upload content must be a Uint8Array.",
+		requestId
+	});
+}
+function assertSearchNeedle(input) {
+	const hasQuery = typeof input.query === "string" && input.query.trim().length > 0;
+	const hasPattern = typeof input.pattern === "string" && input.pattern.trim().length > 0;
+	if (hasQuery || hasPattern) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Workspace search requires query or pattern.",
+		requestId: "seed.workspace.search"
+	});
+}
+function assertPositiveInteger(value, field, requestId) {
+	if (value === void 0) return;
+	if (Number.isInteger(value) && value > 0) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: `${field} must be a positive integer.`,
+		requestId
+	});
+}
+function assertNonEmptyString(value, field, requestId) {
+	if (typeof value === "string" && value.trim().length > 0) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: `${field} is required.`,
+		requestId
+	});
+}
+function assertWorkspaceFileName(value, field, requestId) {
+	assertNonEmptyString(value, field, requestId);
+	if (value.includes("/") || value.includes("\\") || value.includes("://") || value === "." || value === "..") throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: `${field} must be a single workspace file name.`,
+		requestId
+	});
+}
+function assertOptionalWorkspaceRelativePath(value, field, requestId) {
+	if (value === void 0) return;
+	assertNonEmptyString(value, field, requestId);
+	if (value.startsWith("/") || value.includes("\\") || value.includes("://")) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: `${field} must be a relative workspace path.`,
+		requestId
+	});
+	if (value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: `${field} must not contain empty, . or .. path segments.`,
+		requestId
+	});
+}
+function assertOptionalWorkspaceId(value, field, requestId) {
+	if (value === void 0) return;
+	if (typeof value === "string" && value.trim().length > 0 && !value.includes("/") && !value.includes("://")) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: `${field} must be a workspace id.`,
+		requestId
+	});
+}
+function assertLocalSourcePaths(value, requestId) {
+	if (!Array.isArray(value) || value.length === 0 || !value.every((path) => typeof path === "string" && path.trim().length > 0 && !path.includes("\0") && !path.toLowerCase().startsWith("workspace-fs://"))) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "sourcePaths must be non-empty local file paths.",
+		requestId
+	});
+}
+function encodeBytesBase64(bytes) {
+	const maybeBuffer = globalThis.Buffer;
+	if (maybeBuffer) return maybeBuffer.from(bytes).toString("base64");
+	const btoaFn = globalThis.btoa;
+	if (!btoaFn) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Workspace write binary content requires base64 encoding support.",
+		requestId: "seed.workspace.write"
+	});
+	let binary = "";
+	bytes.forEach((byte) => {
+		binary += String.fromCharCode(byte);
+	});
+	return btoaFn(binary);
+}
+//#endregion
+//#region src/client.ts
+const SEED_EVENT_SUBSCRIBE_METHOD = "seed.event.subscribe";
+const SEED_EVENT_UNSUBSCRIBE_METHOD = "seed.event.unsubscribe";
+const SEED_AGENT_STREAM_EVENT_TYPE = "seed.agent.stream";
+const AGENT_APPROVAL_CHANGED_METHOD = "seed.agent.approval.changed";
+const CONVERSATION_CHANGED_METHOD = "seed.conversation.changed";
+const REMOTE_PC_PRESENCE_CHANGED_METHOD = "seed.remotePc.presence.changed";
+const EMPLOYEE_CHANGED_METHOD = "seed.employee.changed";
+const EMPLOYEE_MEMORY_EVENTS_CHANGED_METHOD = "seed.employee.memory.events.changed";
+const ROLE_MAKER_SESSION_CHANGED_METHOD = "seed.roleMaker.session.changed";
+const ROLE_TEMPLATE_CHANGED_METHOD = "seed.roleTemplate.changed";
+const TEAM_CHANGED_METHOD = "seed.team.changed";
+const TEAM_AGENT_SPAWNED_METHOD = "seed.team.agent.spawned";
+const TEAM_AGENT_REMOVED_METHOD = "seed.team.agent.removed";
+const TEAM_AGENT_RENAMED_METHOD = "seed.team.agent.renamed";
+const TEAM_AGENT_STATUS_CHANGED_METHOD = "seed.team.agent.statusChanged";
+function markAgentStreamReplayEvent(event) {
+	if (event.payload.replay === true) return event;
+	return {
+		...event,
+		payload: {
+			...event.payload,
+			replay: true
+		}
+	};
+}
+function mergeAgentStreamDuplicateMetadata(target, source) {
+	const sourceCursor = source.cursor ?? source.payload.cursor;
+	if (sourceCursor) {
+		target.cursor = sourceCursor;
+		target.payload.cursor = sourceCursor;
+	}
+	if (!target.id && source.id) target.id = source.id;
+	if (!target.payload.eventId && source.payload.eventId) target.payload.eventId = source.payload.eventId;
+	if (source.payload.replay === true) target.payload.replay = true;
+}
+function createSeedAppClient(options) {
+	const defaultTransport = options.transport;
+	const routeTransports = options.routeTransports ?? {};
+	let cachedRoutes;
+	const findCachedRoute = (method) => cachedRoutes?.find((route) => route.method === method);
+	const resolveConfiguredRouteTransport = (route) => {
+		if (!route) return void 0;
+		return routeTransports[route.implementation] ?? routeTransports[route.commandTransport];
+	};
+	const resolveTransportForMethod = (method) => {
+		const cachedRoute = findCachedRoute(method);
+		const metadata = (0, _seed_app_studio_protocol.getSeedBridgeRouteMetadataForMethod)(method);
+		if (cachedRoutes && !cachedRoute && metadata?.fallback === "none") throw createSeedAppError({
+			code: "unsupported_runtime",
+			message: `Seed App route ${method} is not available in host diagnostics.`,
+			requestId: method,
+			capability: metadata.capability
+		});
+		const route = cachedRoute ?? metadata;
+		if (!route) return defaultTransport;
+		const transport = resolveConfiguredRouteTransport(route);
+		if (transport) return transport;
+		return defaultTransport;
+	};
+	const cacheDiagnosticsRoutes = (diagnostics) => {
+		if (diagnostics.routes) cachedRoutes = [...diagnostics.routes];
+	};
+	const snapshotRoutes = async (requestOptions) => {
+		const diagnostics = await defaultTransport.request("seed.bridge.diagnostics", { includeRoutes: true }, requestOptions);
+		cacheDiagnosticsRoutes(diagnostics);
+		cachedRoutes = diagnostics.routes ? [...diagnostics.routes] : [];
+		return [...cachedRoutes];
+	};
+	const ensureRoutesBeforeFallbackNoneMethod = async (method, requestOptions) => {
+		const metadata = (0, _seed_app_studio_protocol.getSeedBridgeRouteMetadataForMethod)(method);
+		if (!cachedRoutes && metadata?.fallback === "none") await snapshotRoutes(requestOptions);
+	};
+	const resolveTransportForMethodAsync = async (method, requestOptions) => {
+		await ensureRoutesBeforeFallbackNoneMethod(method, requestOptions);
+		return resolveTransportForMethod(method);
+	};
+	const subscribeCanonicalBridgeEvent = async (event, handler, requestOptions) => {
+		const transport = await resolveTransportForMethodAsync(SEED_EVENT_SUBSCRIBE_METHOD, requestOptions);
+		if (!transport.subscribeBridgeEvent) return Promise.reject(createSeedAppError({
+			code: "unsupported_runtime",
+			message: `Seed App runtime does not support canonical bridge event subscriptions for ${event}.`,
+			requestId: SEED_EVENT_SUBSCRIBE_METHOD,
+			capability: "event.subscribe"
+		}));
+		return transport.subscribeBridgeEvent(event, handler, requestOptions);
+	};
+	const subscribeTypedBridgeEvent = (eventName, isPayload, handler, requestOptions, shouldEmit) => subscribeCanonicalBridgeEvent(eventName, (event) => {
+		if (event.type !== eventName || !isPayload(event.payload)) return;
+		if (shouldEmit && !shouldEmit(event.payload)) return;
+		handler(event.payload);
+	}, requestOptions);
+	const request = async (method, params, requestOptions) => {
+		const response = await (method === "seed.bridge.diagnostics" ? defaultTransport : await resolveTransportForMethodAsync(method, requestOptions)).request(method, method === "seed.agent.run" ? ensureSeedAppTraceCarrier(params) : params, requestOptions);
+		if (method === "seed.bridge.diagnostics") cacheDiagnosticsRoutes(response);
+		return response;
+	};
+	const requestEventStream = (method, params, requestOptions) => resolveTransportForMethodAsync(method, requestOptions).then((transport) => transport.request(method, method === SEED_EVENT_SUBSCRIBE_METHOD ? ensureSeedAppTraceCarrier(params) : params, requestOptions));
+	const getCachedRoutes = () => cachedRoutes ? [...cachedRoutes] : void 0;
+	const resolveRoute = async (method, requestOptions) => {
+		return (cachedRoutes ?? await snapshotRoutes(requestOptions)).find((route) => route.method === method);
+	};
+	const subscribeAgentStream = (handler, subscribeOptions) => resolveTransportForMethod(SEED_EVENT_SUBSCRIBE_METHOD).subscribe?.((event) => {
+		if (!(0, _seed_app_studio_protocol.isSeedAppAgentStreamEvent)(event)) return;
+		if (subscribeOptions?.conversationId && event.payload.conversationId !== subscribeOptions.conversationId) return;
+		if (subscribeOptions?.runId && event.payload.runId !== subscribeOptions.runId) return;
+		handler(event);
+	}) ?? (() => void 0);
+	const subscribeScopedAgentStream = async (input, handler, subscribeOptions) => {
+		assertAgentStreamSubscribeScope(input);
+		const emittedEventsById = /* @__PURE__ */ new Map();
+		const liveBuffer = [];
+		let snapshotResolved = false;
+		let closed = false;
+		let subscriptionId;
+		const emitOnce = (event) => {
+			if (!matchesAgentStreamScope(event, input)) return;
+			const eventId = (0, _seed_app_studio_protocol.resolveSeedAppAgentStreamEventIdentity)(event);
+			const previousEvent = emittedEventsById.get(eventId);
+			if (previousEvent) {
+				mergeAgentStreamDuplicateMetadata(previousEvent, event);
+				return;
+			}
+			emittedEventsById.set(eventId, event);
+			handler(event);
+		};
+		await ensureRoutesBeforeFallbackNoneMethod(SEED_EVENT_SUBSCRIBE_METHOD, { timeoutMs: subscribeOptions?.requestTimeoutMs });
+		const unsubscribeLive = subscribeAgentStream((event) => {
+			if (!matchesAgentStreamScope(event, input)) return;
+			if (!snapshotResolved) {
+				liveBuffer.push(event);
+				return;
+			}
+			emitOnce(event);
+		});
+		try {
+			const snapshot = await requestEventStream(SEED_EVENT_SUBSCRIBE_METHOD, {
+				type: SEED_AGENT_STREAM_EVENT_TYPE,
+				...input
+			}, { timeoutMs: subscribeOptions?.requestTimeoutMs });
+			subscriptionId = snapshot.subscriptionId;
+			snapshot.events.map(markAgentStreamReplayEvent).forEach(emitOnce);
+			snapshotResolved = true;
+			liveBuffer.splice(0).forEach(emitOnce);
+		} catch (error) {
+			unsubscribeLive();
+			if (subscriptionId) await requestEventStream(SEED_EVENT_UNSUBSCRIBE_METHOD, {
+				type: SEED_AGENT_STREAM_EVENT_TYPE,
+				subscriptionId
+			}).catch(() => void 0);
+			throw error;
+		}
+		return async () => {
+			if (closed) return;
+			closed = true;
+			unsubscribeLive();
+			if (!subscriptionId) return;
+			await requestEventStream(SEED_EVENT_UNSUBSCRIBE_METHOD, {
+				type: SEED_AGENT_STREAM_EVENT_TYPE,
+				subscriptionId
+			}, { timeoutMs: subscribeOptions?.requestTimeoutMs });
+		};
+	};
+	const subscribeAguiStream = (handler, subscribeOptions) => resolveTransportForMethod(SEED_EVENT_SUBSCRIBE_METHOD).subscribe?.((event) => {
+		if (!(0, _seed_app_studio_protocol.isSeedAguiEvent)(event)) return;
+		if (subscribeOptions?.conversationId && event.seed.conversationId !== subscribeOptions.conversationId) return;
+		if (subscribeOptions?.runId && event.runId !== subscribeOptions.runId) return;
+		handler(event);
+	}) ?? (() => void 0);
+	const subscribeScopedAguiStream = async (input, handler, subscribeOptions) => {
+		assertAguiStreamSubscribeScope(input);
+		const seenEventIds = /* @__PURE__ */ new Set();
+		const liveBuffer = [];
+		let snapshotResolved = false;
+		let closed = false;
+		let subscriptionId;
+		const emitOnce = (event) => {
+			if (!(0, _seed_app_studio_protocol.matchesSeedAguiStreamScope)(event, input)) return;
+			const eventId = (0, _seed_app_studio_protocol.resolveSeedAguiEventIdentity)(event);
+			if (seenEventIds.has(eventId)) return;
+			seenEventIds.add(eventId);
+			handler(event);
+		};
+		await ensureRoutesBeforeFallbackNoneMethod(SEED_EVENT_SUBSCRIBE_METHOD, { timeoutMs: subscribeOptions?.requestTimeoutMs });
+		const unsubscribeLive = subscribeAguiStream((event) => {
+			if (!(0, _seed_app_studio_protocol.matchesSeedAguiStreamScope)(event, input)) return;
+			if (!snapshotResolved) {
+				liveBuffer.push(event);
+				return;
+			}
+			emitOnce(event);
+		});
+		try {
+			const snapshot = await requestEventStream(SEED_EVENT_SUBSCRIBE_METHOD, {
+				type: _seed_app_studio_protocol.SEED_AGUI_STREAM_EVENT_TYPE,
+				...input
+			}, { timeoutMs: subscribeOptions?.requestTimeoutMs });
+			subscriptionId = snapshot.subscriptionId;
+			snapshot.events.forEach(emitOnce);
+			snapshotResolved = true;
+			liveBuffer.splice(0).forEach(emitOnce);
+		} catch (error) {
+			unsubscribeLive();
+			if (subscriptionId) await requestEventStream(SEED_EVENT_UNSUBSCRIBE_METHOD, {
+				type: _seed_app_studio_protocol.SEED_AGUI_STREAM_EVENT_TYPE,
+				subscriptionId
+			}).catch(() => void 0);
+			throw error;
+		}
+		return async () => {
+			if (closed) return;
+			closed = true;
+			unsubscribeLive();
+			if (!subscriptionId) return;
+			await requestEventStream(SEED_EVENT_UNSUBSCRIBE_METHOD, {
+				type: _seed_app_studio_protocol.SEED_AGUI_STREAM_EVENT_TYPE,
+				subscriptionId
+			}, { timeoutMs: subscribeOptions?.requestTimeoutMs });
+		};
+	};
+	const runAgent = (input, requestOptions) => request("seed.agent.run", input, requestOptions);
+	const runAndWatchAgent = async (input, handlers, watchOptions) => {
+		const tracedInput = ensureSeedAppTraceCarrier(input);
+		const traceContext = extractSeedAppTraceContext(tracedInput);
+		let activeRunId;
+		let activeRun;
+		const pendingEvents = [];
+		let finish;
+		let fail;
+		let streamTimeout;
+		let terminalDispatched = false;
+		let terminalResult;
+		let terminalError;
+		let acceptanceHandlerCompleted = false;
+		const completeRun = (result) => {
+			if (finish) {
+				finish(result);
+				return;
+			}
+			terminalResult = result;
+		};
+		const rejectRun = (error) => {
+			if (fail) {
+				fail(error);
+				return;
+			}
+			terminalError = error;
+		};
+		const handleEvent = (event) => {
+			if (!activeRunId || !acceptanceHandlerCompleted) {
+				pendingEvents.push(event);
+				return;
+			}
+			if (event.payload.runId !== activeRunId) return;
+			const isTerminalEvent = event.type === "agent.run.completed" || event.type === "agent.turn.completed" || event.type === "agent.run.failed" || event.type === "agent.run.cancelled";
+			const isDuplicateTerminal = isTerminalEvent && terminalDispatched;
+			dispatchAgentStreamEvent(event, handlers, { suppressTerminalHandler: isDuplicateTerminal });
+			if (isDuplicateTerminal) return;
+			if (isTerminalEvent) terminalDispatched = true;
+			if (event.type === "agent.run.completed" || event.type === "agent.turn.completed") completeRun({
+				...activeRun,
+				runId: activeRunId,
+				status: "completed",
+				output: event.payload
+			});
+			if (event.type === "agent.run.failed") rejectRun(createSeedAppError({
+				code: "provider_failed",
+				message: event.payload.message ?? "Agent run failed.",
+				requestId: activeRunId
+			}));
+			if (event.type === "agent.run.cancelled") rejectRun(createSeedAppError({
+				code: "provider_failed",
+				message: event.payload.reason ?? "Agent run cancelled.",
+				requestId: activeRunId
+			}));
+		};
+		let unsubscribe = () => void 0;
+		try {
+			if (input.conversationId) unsubscribe = await subscribeScopedAgentStream(traceContext ? injectSeedAppTraceContext({ conversationId: input.conversationId }, traceContext) : { conversationId: input.conversationId }, handleEvent, { requestTimeoutMs: watchOptions?.requestTimeoutMs });
+			const run = await runAgent(tracedInput, { timeoutMs: watchOptions?.requestTimeoutMs });
+			activeRun = run;
+			activeRunId = run.runId;
+			await handlers?.onAccepted?.(run);
+			acceptanceHandlerCompleted = true;
+			if (!input.conversationId) unsubscribe = await subscribeScopedAgentStream(traceContext ? injectSeedAppTraceContext({ runId: run.runId }, traceContext) : { runId: run.runId }, handleEvent, { requestTimeoutMs: watchOptions?.requestTimeoutMs });
+			if (run.status === "completed") {
+				pendingEvents.splice(0).forEach(handleEvent);
+				if (terminalError) throw terminalError;
+				return terminalResult ?? run;
+			}
+			return await new Promise((resolve, reject) => {
+				finish = resolve;
+				fail = reject;
+				pendingEvents.splice(0).forEach(handleEvent);
+				if (terminalError) {
+					reject(terminalError);
+					return;
+				}
+				if (terminalResult) {
+					resolve(terminalResult);
+					return;
+				}
+				if (watchOptions?.streamTimeoutMs !== void 0) streamTimeout = setTimeout(() => {
+					reject(createSeedAppError({
+						code: "handshake_timeout",
+						message: "Agent stream timed out before a terminal event.",
+						requestId: run.runId,
+						retryable: true
+					}));
+				}, watchOptions.streamTimeoutMs);
+			});
+		} finally {
+			if (streamTimeout) clearTimeout(streamTimeout);
+			await unsubscribe();
+		}
+	};
+	return {
+		handshake: (input, requestOptions) => request("seed.handshake", input, requestOptions),
+		capabilities: {
+			query: (requestOptions) => request("seed.capabilities.query", void 0, requestOptions),
+			request: (input, requestOptions) => request("seed.capabilities.request", input, requestOptions)
+		},
+		auth: {
+			getContext: (requestOptions) => request("seed.auth.getContext", void 0, requestOptions),
+			getAccessToken: (input, requestOptions) => request("seed.auth.getAccessToken", input, requestOptions)
+		},
+		network: { fetch: (input, requestOptions) => request("seed.network.fetch", input, requestOptions) },
+		agent: {
+			list: (input, requestOptions) => request("seed.agent.list", input, requestOptions),
+			preset: { update: (input, requestOptions) => request("seed.agent.preset.update", input, requestOptions) },
+			config: {
+				upsert: (input, requestOptions) => request("seed.agent.config.upsert", input, requestOptions),
+				delete: (input, requestOptions) => request("seed.agent.config.delete", input, requestOptions)
+			},
+			runtime: {
+				configOptions: { get: (input, requestOptions) => request("seed.agent.runtime.configOptions.get", input, requestOptions) },
+				configOption: { set: (input, requestOptions) => request("seed.agent.runtime.configOption.set", input, requestOptions) },
+				model: {
+					get: (input, requestOptions) => request("seed.agent.runtime.model.get", input, requestOptions),
+					set: (input, requestOptions) => request("seed.agent.runtime.model.set", input, requestOptions)
+				},
+				mode: {
+					get: (input, requestOptions) => request("seed.agent.runtime.mode.get", input, requestOptions),
+					set: (input, requestOptions) => request("seed.agent.runtime.mode.set", input, requestOptions)
+				},
+				bundled: {
+					get: (input, requestOptions) => request("seed.agent.runtime.bundled.get", input, requestOptions),
+					update: (input, requestOptions) => request("seed.agent.runtime.bundled.update", input, requestOptions)
+				},
+				local: {
+					status: { get: (input, requestOptions) => request("seed.agent.runtime.local.status.get", input, requestOptions) },
+					restart: (input, requestOptions) => request("seed.agent.runtime.local.restart", input, requestOptions),
+					stale: { mark: (input, requestOptions) => request("seed.agent.runtime.local.stale.mark", input, requestOptions) }
+				},
+				capabilities: { prefetch: (input, requestOptions) => request("seed.agent.runtime.capabilities.prefetch", input, requestOptions) },
+				custom: { test: (input, requestOptions) => request("seed.agent.runtime.custom.test", input, requestOptions) },
+				slashCommands: { list: (input, requestOptions) => request("seed.agent.runtime.slashCommands.list", input, requestOptions) },
+				slashCommand: { execute: (input, requestOptions) => request("seed.agent.runtime.slashCommand.execute", input, requestOptions) },
+				session: { ensure: (input, requestOptions) => request("seed.agent.runtime.session.ensure", input, requestOptions) },
+				conversation: { warmup: (input, requestOptions) => request("seed.agent.runtime.conversation.warmup", input, requestOptions) },
+				openclaw: { get: (input, requestOptions) => request("seed.agent.runtime.openclaw.get", input, requestOptions) },
+				process: {
+					snapshot: { get: (input, requestOptions) => request("seed.agent.runtime.process.snapshot.get", input, requestOptions) },
+					release: (input, requestOptions) => request("seed.agent.runtime.process.release", input, requestOptions)
+				}
+			},
+			subagent: { session: {
+				snapshot: { get: (input, requestOptions) => request("seed.agent.subagent.session.snapshot.get", input, requestOptions) },
+				load: (input, requestOptions) => request("seed.agent.subagent.session.load", input, requestOptions)
+			} },
+			run: runAgent,
+			input: { submit: (input, requestOptions) => request("seed.agent.input.submit", input, requestOptions) },
+			stop: (input, requestOptions) => request("seed.agent.stop", input, requestOptions),
+			sideQuestion: { ask: (input, requestOptions) => request("seed.agent.sideQuestion.ask", input, requestOptions) },
+			approval: {
+				check: (input, requestOptions) => request("seed.agent.approval.check", input, requestOptions),
+				list: (input, requestOptions) => request("seed.agent.approval.list", input, requestOptions),
+				respond: (input, requestOptions) => request("seed.agent.approval.respond", input, requestOptions),
+				subscribeChanged: (handler, requestOptions) => subscribeCanonicalBridgeEvent(AGENT_APPROVAL_CHANGED_METHOD, (event) => {
+					if (event.type !== AGENT_APPROVAL_CHANGED_METHOD || !isAgentApprovalChangedPayload(event.payload)) return;
+					handler(event.payload);
+				}, requestOptions)
+			},
+			elicitation: { respond: (input, requestOptions) => request("seed.agent.elicitation.respond", input, requestOptions) },
+			subscribe: subscribeAgentStream,
+			subscribeConversation: (input, handler, subscribeOptions) => subscribeScopedAgentStream(input, handler, subscribeOptions),
+			subscribeRun: (input, handler, subscribeOptions) => subscribeScopedAgentStream(input, handler, subscribeOptions),
+			runAndWatch: runAndWatchAgent
+		},
+		agui: {
+			subscribe: subscribeAguiStream,
+			subscribeConversation: (input, handler, subscribeOptions) => subscribeScopedAguiStream(input, handler, subscribeOptions),
+			subscribeRun: (input, handler, subscribeOptions) => subscribeScopedAguiStream(input, handler, subscribeOptions)
+		},
+		team: {
+			list: (input, requestOptions) => request("seed.team.list", input ?? {}, requestOptions),
+			create: (input, requestOptions) => request("seed.team.create", input, requestOptions),
+			subscribeChanged: (handler, requestOptions) => subscribeTypedBridgeEvent(TEAM_CHANGED_METHOD, isTeamChangedPayload, handler, requestOptions),
+			get: (input, requestOptions) => request("seed.team.get", input, requestOptions),
+			rename: (input, requestOptions) => request("seed.team.rename", input, requestOptions),
+			sessionMode: { set: (input, requestOptions) => request("seed.team.sessionMode.set", input, requestOptions) },
+			workspace: { update: (input, requestOptions) => request("seed.team.workspace.update", input, requestOptions) },
+			delete: (input, requestOptions) => request("seed.team.delete", input, requestOptions),
+			agent: {
+				add: (input, requestOptions) => request("seed.team.agent.add", input, requestOptions),
+				subscribeSpawned: (handler, requestOptions) => subscribeTypedBridgeEvent(TEAM_AGENT_SPAWNED_METHOD, isTeamAgentSpawnedPayload, handler, requestOptions),
+				subscribeRemoved: (handler, requestOptions) => subscribeTypedBridgeEvent(TEAM_AGENT_REMOVED_METHOD, isTeamAgentRemovedPayload, handler, requestOptions),
+				subscribeRenamed: (handler, requestOptions) => subscribeTypedBridgeEvent(TEAM_AGENT_RENAMED_METHOD, isTeamAgentRenamedPayload, handler, requestOptions),
+				subscribeStatusChanged: (handler, requestOptions) => subscribeTypedBridgeEvent(TEAM_AGENT_STATUS_CHANGED_METHOD, isTeamAgentStatusChangedPayload, handler, requestOptions),
+				rename: (input, requestOptions) => request("seed.team.agent.rename", input, requestOptions),
+				remove: (input, requestOptions) => request("seed.team.agent.remove", input, requestOptions)
+			},
+			message: {
+				send: (input, requestOptions) => request("seed.team.message.send", input, requestOptions),
+				sendToAgent: (input, requestOptions) => request("seed.team.message.sendToAgent", input, requestOptions)
+			},
+			stop: (input, requestOptions) => request("seed.team.stop", input, requestOptions),
+			session: {
+				ensure: (input, requestOptions) => request("seed.team.session.ensure", input, requestOptions),
+				reset: (input, requestOptions) => request("seed.team.session.reset", input, requestOptions)
+			}
+		},
+		speech: { transcribe: (input, requestOptions) => request("seed.speech.transcribe", input, requestOptions) },
+		conversation: {
+			list: (input, requestOptions) => request("seed.conversation.list", input, requestOptions),
+			listByCronJob: (input, requestOptions) => request("seed.conversation.listByCronJob", input, requestOptions),
+			subscribeChanged: (handler, requestOptions) => subscribeTypedBridgeEvent(CONVERSATION_CHANGED_METHOD, isConversationChangedPayload, handler, requestOptions),
+			create: (input, requestOptions) => request("seed.conversation.create", input, requestOptions),
+			get: (input, requestOptions) => request("seed.conversation.get", input, requestOptions),
+			messages: (input, requestOptions) => request("seed.conversation.messages", input, requestOptions),
+			searchMessages: (input, requestOptions) => request("seed.conversation.searchMessages", input, requestOptions),
+			rename: (input, requestOptions) => request("seed.conversation.rename", input, requestOptions),
+			updateMetadata: (input, requestOptions) => request("seed.conversation.metadata.update", input, requestOptions),
+			updateModel: (input, requestOptions) => request("seed.conversation.model.update", input, requestOptions),
+			delete: (input, requestOptions) => request("seed.conversation.delete", input, requestOptions),
+			importArchive: (input, requestOptions) => request("seed.conversation.archive.import", input, requestOptions),
+			artifact: {
+				list: (input, requestOptions) => request("seed.conversation.artifact.list", input, requestOptions),
+				listEvidence: (input, requestOptions) => request("seed.conversation.artifact.evidence.list", input, requestOptions),
+				listAccess: (input, requestOptions) => request("seed.conversation.artifact.access.list", input, requestOptions),
+				listShareTargets: (requestOptions) => request("seed.conversation.artifact.shareTargets.list", void 0, requestOptions),
+				share: (input, requestOptions) => request("seed.conversation.artifact.share", input, requestOptions),
+				revokeAccess: (input, requestOptions) => request("seed.conversation.artifact.access.revoke", input, requestOptions),
+				materialize: (input, requestOptions) => request("seed.conversation.artifact.materialize", input, requestOptions),
+				updatePolicy: (input, requestOptions) => request("seed.conversation.artifact.policy.update", input, requestOptions),
+				dryRunScrub: (input, requestOptions) => request("seed.conversation.artifact.scrub.dryRun", input, requestOptions),
+				applyScrub: (input, requestOptions) => request("seed.conversation.artifact.scrub.apply", input, requestOptions)
+			}
+		},
+		remotePc: {
+			presence: {
+				list: (requestOptions) => request("seed.remotePc.presence.list", void 0, requestOptions),
+				subscribeChanged: (handler, requestOptions) => subscribeTypedBridgeEvent(REMOTE_PC_PRESENCE_CHANGED_METHOD, isRemotePcPresenceChangedPayload, handler, requestOptions)
+			},
+			vibe: {
+				list: (input, requestOptions) => request("seed.remotePc.vibe.list", input, requestOptions),
+				get: (input, requestOptions) => request("seed.remotePc.vibe.get", input, requestOptions),
+				messages: (input, requestOptions) => request("seed.remotePc.vibe.messages", input, requestOptions),
+				subscribe: async (input, handler, subscribeOptions) => {
+					let stopped = false;
+					let cursor = subscribeOptions?.initialCursor;
+					const poll = async () => {
+						while (!stopped) {
+							const result = await request("seed.remotePc.vibe.events", {
+								...input,
+								...cursor ? { cursor } : {},
+								waitMs: subscribeOptions?.waitMs ?? 15e3
+							}, { timeoutMs: subscribeOptions?.requestTimeoutMs ?? 25e3 });
+							if (stopped) return;
+							if (result.cursor && result.cursor !== cursor) {
+								cursor = result.cursor;
+								await subscribeOptions?.onCursor?.(cursor);
+							}
+							if (result.messages.length > 0) handler(result);
+						}
+					};
+					poll().catch((error) => {
+						stopped = true;
+						subscribeOptions?.onError?.(error);
+					});
+					return async () => {
+						stopped = true;
+					};
+				}
+			}
+		},
+		memory: { search: (input, requestOptions) => request("seed.memory.search", input, requestOptions) },
+		resource: {
+			read: (input, requestOptions) => request("seed.resource.read", input, requestOptions),
+			stat: (input, requestOptions) => request("seed.resource.stat", input, requestOptions),
+			list: (input, requestOptions) => request("seed.resource.list", input, requestOptions),
+			open: (input, requestOptions) => request("seed.resource.open", input, requestOptions),
+			openableSchemes: (input, requestOptions) => request("seed.resource.openableSchemes", input, requestOptions)
+		},
+		skill: {
+			list: (requestOptions) => request("seed.skill.list", void 0, requestOptions),
+			listAutoInjected: (requestOptions) => request("seed.skill.autoInjected.list", void 0, requestOptions),
+			detectExternal: (requestOptions) => request("seed.skill.external.detect", void 0, requestOptions),
+			getPaths: (requestOptions) => request("seed.skill.paths.get", void 0, requestOptions),
+			addExternalPath: (input, requestOptions) => request("seed.skill.externalPath.add", input, requestOptions),
+			importLocal: (input, requestOptions) => request("seed.skill.importLocal", input, requestOptions),
+			delete: (input, requestOptions) => request("seed.skill.delete", input, requestOptions),
+			exportLocal: (input, requestOptions) => request("seed.skill.exportLocal", input, requestOptions),
+			addAutoInjected: (input, requestOptions) => request("seed.skill.autoInjected.add", input, requestOptions),
+			removeAutoInjected: (input, requestOptions) => request("seed.skill.autoInjected.remove", input, requestOptions),
+			setMarketEnabled: (input, requestOptions) => request("seed.skill.market.setEnabled", input, requestOptions)
+		},
+		assistant: { resource: {
+			read: (input, requestOptions) => request("seed.assistant.resource.read", input, requestOptions),
+			write: (input, requestOptions) => request("seed.assistant.resource.write", input, requestOptions),
+			delete: (input, requestOptions) => request("seed.assistant.resource.delete", input, requestOptions)
+		} },
+		builtin: { resource: { read: (input, requestOptions) => request("seed.builtin.resource.read", input, requestOptions) } },
+		workspace: createSeedAppWorkspaceClient(request, {
+			subscribe: options.transport.subscribe,
+			subscribeBridgeEvent: options.transport.subscribeBridgeEvent
+		}),
+		brainBundle: { previewSummaries: (input, requestOptions) => request("seed.brainBundle.previewSummaries", input, requestOptions) },
+		employee: {
+			list: (input, requestOptions) => request("seed.employee.list", input, requestOptions),
+			subscribeChanged: (handler, requestOptions) => subscribeTypedBridgeEvent(EMPLOYEE_CHANGED_METHOD, isEmployeeChangedPayload, handler, requestOptions),
+			get: (input, requestOptions) => request("seed.employee.get", input, requestOptions),
+			openConversation: (input, requestOptions) => request("seed.employee.openConversation", input, requestOptions),
+			createFromRoleTemplate: (input, requestOptions) => request("seed.employee.createFromRoleTemplate", input, requestOptions),
+			createFromAssistant: (input, requestOptions) => request("seed.employee.createFromAssistant", input, requestOptions),
+			update: (input, requestOptions) => request("seed.employee.update", input, requestOptions),
+			remove: (input, requestOptions) => request("seed.employee.remove", input, requestOptions),
+			memory: {
+				list: (input, requestOptions) => request("seed.employee.memory.list", input, requestOptions),
+				delete: (input, requestOptions) => request("seed.employee.memory.delete", input, requestOptions),
+				events: {
+					list: (input, requestOptions) => request("seed.employee.memory.events.list", input, requestOptions),
+					subscribeChanged: (input, handler, requestOptions) => subscribeTypedBridgeEvent(EMPLOYEE_MEMORY_EVENTS_CHANGED_METHOD, isEmployeeMemoryChangedPayload, handler, requestOptions, (event) => !input.employeeId || event.employeeId === input.employeeId)
+				}
+			},
+			activity: { list: (input, requestOptions) => request("seed.employee.activity.list", input, requestOptions) }
+		},
+		roleTemplate: {
+			list: (input, requestOptions) => request("seed.roleTemplate.list", input, requestOptions),
+			get: (input, requestOptions) => request("seed.roleTemplate.get", input, requestOptions),
+			create: (input, requestOptions) => request("seed.roleTemplate.create", input, requestOptions),
+			update: (input, requestOptions) => request("seed.roleTemplate.update", input, requestOptions),
+			delete: (input, requestOptions) => request("seed.roleTemplate.delete", input, requestOptions),
+			subscribeChanged: (handler, requestOptions) => subscribeTypedBridgeEvent(ROLE_TEMPLATE_CHANGED_METHOD, isRoleTemplateChangedPayload, handler, requestOptions)
+		},
+		roleMaker: { session: {
+			start: (input, requestOptions) => request("seed.roleMaker.session.start", input, requestOptions),
+			get: (input, requestOptions) => request("seed.roleMaker.session.get", input, requestOptions),
+			generate: (input, requestOptions) => request("seed.roleMaker.session.generate", input, requestOptions),
+			apply: (input, requestOptions) => request("seed.roleMaker.session.apply", input, requestOptions),
+			approve: (input, requestOptions) => request("seed.roleMaker.session.approve", input, requestOptions),
+			discard: (input, requestOptions) => request("seed.roleMaker.session.discard", input, requestOptions),
+			subscribeChanged: (handler, requestOptions) => subscribeTypedBridgeEvent(ROLE_MAKER_SESSION_CHANGED_METHOD, isRoleMakerSessionChangedPayload, handler, requestOptions)
+		} },
+		mcp: {
+			listTools: (input, requestOptions) => request("seed.mcp.listTools", input, requestOptions),
+			callTool: (input, requestOptions) => request("seed.mcp.callTool", input, requestOptions)
+		},
+		diagnostics: { snapshot: (input, requestOptions) => request("seed.bridge.diagnostics", input, requestOptions) },
+		routes: {
+			snapshot: snapshotRoutes,
+			resolve: resolveRoute,
+			getCached: getCachedRoutes
+		},
+		events: {
+			subscribe: (handler) => options.transport.subscribe?.(handler) ?? (() => void 0),
+			subscribeRealtimeChannel: async (channel, cursor) => await options.transport.subscribeRealtimeChannel?.(channel, cursor) ?? (() => void 0),
+			subscribeBridgeEvent: (event, handler, requestOptions) => subscribeCanonicalBridgeEvent(event, handler, requestOptions)
+		},
+		request,
+		close: () => options.transport.close?.()
+	};
+}
+function isRoleTemplateChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.roleTemplateId === "string" && (record.action === "created" || record.action === "updated" || record.action === "deleted");
+}
+function isRoleMakerSessionChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.sessionId === "string" && typeof record.conversationId === "string" && typeof record.status === "string" && (record.updatedAt === void 0 || typeof record.updatedAt === "string" || typeof record.updatedAt === "number") && typeof record.source === "string";
+}
+function isAgentApprovalChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.conversationId === "string" && typeof record.approvalId === "string" && (record.action === "added" || record.action === "updated" || record.action === "removed") && (record.approval === void 0 || record.approval !== null && typeof record.approval === "object");
+}
+function isConversationChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.conversationId === "string" && (record.action === "created" || record.action === "updated" || record.action === "deleted") && (record.source === void 0 || typeof record.source === "string");
+}
+function isRemotePcPresenceChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	const presence = record.presence;
+	if (!presence || typeof presence !== "object") return false;
+	const presenceRecord = presence;
+	const contentLease = presenceRecord.contentLease;
+	return (record.action === "connected" || record.action === "updated" || record.action === "lease-expired") && typeof presenceRecord.deviceId === "string" && typeof presenceRecord.displayName === "string" && (presenceRecord.status === "online" || presenceRecord.status === "offline") && typeof presenceRecord.lastSeenAt === "number" && Boolean(contentLease && typeof contentLease === "object");
+}
+function isEmployeeChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.employeeId === "string" && (record.action === "created" || record.action === "updated" || record.action === "deleted") && (record.employee === void 0 || record.employee !== null && typeof record.employee === "object");
+}
+function isTeamChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.teamId === "string" && (record.action === "created" || record.action === "updated" || record.action === "removed" || record.action === "agent_added" || record.action === "agent_removed" || record.action === "agent_renamed");
+}
+function isTeamAgentStatusChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.teamId === "string" && typeof record.slotId === "string" && typeof record.status === "string" && (record.lastMessage === void 0 || typeof record.lastMessage === "string");
+}
+function isTeamAgentSpawnedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.teamId === "string" && isTeamAgentPayload(record.agent);
+}
+function isTeamAgentRemovedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.teamId === "string" && typeof record.slotId === "string";
+}
+function isTeamAgentRenamedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.teamId === "string" && typeof record.slotId === "string" && typeof record.oldName === "string" && typeof record.newName === "string";
+}
+function isTeamAgentPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.slotId === "string" && typeof record.conversationId === "string" && typeof record.role === "string" && typeof record.agentType === "string" && typeof record.agentName === "string" && typeof record.conversationType === "string" && typeof record.status === "string";
+}
+function isEmployeeMemoryChangedPayload(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return (record.type === "memory.created" || record.type === "memory.deleted") && typeof record.employeeId === "string" && typeof record.memoryId === "string" && record.data !== null && typeof record.data === "object" && (typeof record.timestamp === "string" || typeof record.timestamp === "number");
+}
+function assertAgentStreamSubscribeScope(input) {
+	if (("conversationId" in input && typeof input.conversationId === "string" && input.conversationId.length > 0) !== ("runId" in input && typeof input.runId === "string" && input.runId.length > 0)) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Provide exactly one of conversationId or runId when subscribing to agent stream replay.",
+		requestId: SEED_EVENT_SUBSCRIBE_METHOD
+	});
+}
+function assertAguiStreamSubscribeScope(input) {
+	if (("conversationId" in input && typeof input.conversationId === "string" && input.conversationId.length > 0) !== ("runId" in input && typeof input.runId === "string" && input.runId.length > 0)) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Provide exactly one of conversationId or runId when subscribing to AGUI stream replay.",
+		requestId: SEED_EVENT_SUBSCRIBE_METHOD
+	});
+}
+function matchesAgentStreamScope(event, input) {
+	if ("conversationId" in input) return event.payload.conversationId === input.conversationId;
+	return event.payload.runId === input.runId;
+}
+function dispatchAgentStreamEvent(event, handlers, options) {
+	handlers?.onEvent?.(event);
+	switch (event.type) {
+		case "agent.message.delta":
+			handlers?.onMessageDelta?.(event);
+			break;
+		case "agent.thought.delta":
+			handlers?.onThoughtDelta?.(event);
+			break;
+		case "agent.tool.started":
+		case "agent.tool.updated":
+			handlers?.onTool?.(event);
+			break;
+		case "agent.permission.required":
+		case "agent.elicitation.required":
+			handlers?.onBlocked?.(event);
+			break;
+		case "agent.run.completed":
+		case "agent.run.failed":
+		case "agent.run.cancelled":
+		case "agent.turn.completed":
+			if (options?.suppressTerminalHandler) break;
+			handlers?.onTerminal?.(event);
+			break;
+	}
+}
+//#endregion
+//#region src/bridgeTarget.ts
+const SEED_APP_BRIDGE_TARGET_DEFAULT_TIMEOUT_MS = 3e4;
+const seedAppBridgeTargetModes = {
+	appHost: "app-host",
+	webEndpoint: "web-endpoint"
+};
+const seedAppBridgeTargetSearchParams = {
+	mode: "seedBridgeTarget",
+	endpoint: "seedBridgeEndpoint",
+	timeoutMs: "seedBridgeTimeoutMs"
+};
+const seedAppAppearanceSearchParams = {
+	theme: "seedTheme",
+	colorScheme: "seedColorScheme",
+	fontScale: "seedFontScale"
+};
+function appendSeedAppBridgeTargetSearchParams(entryUrl, target) {
+	if (target.mode !== seedAppBridgeTargetModes.webEndpoint) return entryUrl;
+	try {
+		const url = new URL(entryUrl);
+		url.searchParams.set(seedAppBridgeTargetSearchParams.mode, target.mode);
+		url.searchParams.set(seedAppBridgeTargetSearchParams.endpoint, target.endpoint);
+		url.searchParams.set(seedAppBridgeTargetSearchParams.timeoutMs, String(target.timeoutMs));
+		return url.toString();
+	} catch {
+		return entryUrl;
+	}
+}
+function appendSeedAppAppearanceSearchParams(entryUrl, appearance) {
+	if (!appearance) return entryUrl;
+	try {
+		const url = new URL(entryUrl);
+		url.searchParams.set(seedAppAppearanceSearchParams.theme, appearance.theme);
+		if (appearance.colorScheme) url.searchParams.set(seedAppAppearanceSearchParams.colorScheme, appearance.colorScheme);
+		else url.searchParams.delete(seedAppAppearanceSearchParams.colorScheme);
+		if (typeof appearance.fontScale === "number" && Number.isFinite(appearance.fontScale)) url.searchParams.set(seedAppAppearanceSearchParams.fontScale, String(appearance.fontScale));
+		else url.searchParams.delete(seedAppAppearanceSearchParams.fontScale);
+		return url.toString();
+	} catch {
+		return entryUrl;
+	}
+}
+function resolveSeedAppBridgeTargetFromSearch(search) {
+	const params = typeof search === "string" ? new URLSearchParams(search.startsWith("?") ? search.slice(1) : search) : search;
+	if (params.get(seedAppBridgeTargetSearchParams.mode) !== seedAppBridgeTargetModes.webEndpoint) return { mode: seedAppBridgeTargetModes.appHost };
+	const endpoint = params.get(seedAppBridgeTargetSearchParams.endpoint)?.trim();
+	if (!endpoint) return { mode: seedAppBridgeTargetModes.appHost };
+	return {
+		mode: seedAppBridgeTargetModes.webEndpoint,
+		endpoint,
+		timeoutMs: readTimeoutMs(params.get(seedAppBridgeTargetSearchParams.timeoutMs))
+	};
+}
+function resolveSeedAppAppearanceFromSearch(search) {
+	const params = typeof search === "string" ? new URLSearchParams(search.startsWith("?") ? search.slice(1) : search) : search;
+	const theme = readThemeMode(params.get(seedAppAppearanceSearchParams.theme));
+	if (!theme) return void 0;
+	const colorScheme = params.get(seedAppAppearanceSearchParams.colorScheme)?.trim() || void 0;
+	const fontScale = readFontScale(params.get(seedAppAppearanceSearchParams.fontScale));
+	return {
+		theme,
+		...colorScheme ? { colorScheme } : {},
+		...fontScale ? { fontScale } : {},
+		source: "query"
+	};
+}
+function readTimeoutMs(value) {
+	if (!value) return SEED_APP_BRIDGE_TARGET_DEFAULT_TIMEOUT_MS;
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed < 1e3) return SEED_APP_BRIDGE_TARGET_DEFAULT_TIMEOUT_MS;
+	return Math.round(parsed);
+}
+function readThemeMode(value) {
+	if (value === "light" || value === "dark") return value;
+}
+function readFontScale(value) {
+	if (!value) return void 0;
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) return void 0;
+	return parsed;
+}
+//#endregion
+//#region src/consoleBridge.ts
+const DEFAULT_LEVELS = [
+	"log",
+	"info",
+	"warn",
+	"error",
+	"debug"
+];
+const DEFAULT_MAX_ARG_LENGTH = 2e3;
+function installSeedAppConsoleBridge(options = {}) {
+	const currentWindow = options.currentWindow ?? globalThis.window;
+	if (!currentWindow) return { uninstall: () => void 0 };
+	const targetWindow = options.targetWindow ?? currentWindow.parent;
+	const targetOrigin = options.targetOrigin ?? "*";
+	const includeOriginal = options.includeOriginal ?? true;
+	const maxArgLength = options.maxArgLength ?? DEFAULT_MAX_ARG_LENGTH;
+	const levels = options.levels ?? DEFAULT_LEVELS;
+	const originals = /* @__PURE__ */ new Map();
+	levels.forEach((level) => {
+		const original = currentWindow.console[level];
+		originals.set(level, original);
+		currentWindow.console[level] = ((...args) => {
+			if (includeOriginal) original.apply(currentWindow.console, args);
+			targetWindow.postMessage(createConsoleEnvelope(level, args, maxArgLength), targetOrigin);
+		});
+	});
+	return { uninstall() {
+		originals.forEach((original, level) => {
+			currentWindow.console[level] = original;
+		});
+		originals.clear();
+	} };
+}
+function createConsoleEnvelope(level, args, maxArgLength) {
+	const serializedArgs = args.map((arg) => serializeConsoleArg(arg, maxArgLength));
+	return {
+		source: "seed-app-console",
+		channel: "seed-app-console",
+		level,
+		message: serializedArgs.join(" "),
+		args: serializedArgs,
+		timestamp: Date.now()
+	};
+}
+function serializeConsoleArg(value, maxLength) {
+	const serialized = serializeValue(value);
+	return serialized.length > maxLength ? `${serialized.slice(0, maxLength)}...` : serialized;
+}
+function serializeValue(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Error) return value.stack ?? value.message;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region src/endpointTransport.ts
+const WEBSOCKET_OPEN_STATE = 1;
+const REALTIME_RECOVERY_INTERVAL_MS = 3e4;
+const ENDPOINT_TRACE_SCHEMA = "seed-app.endpoint-transport.trace.v1";
+const ENDPOINT_TRACE_BRIDGE_CHANNEL = "seed-app-devtools";
+function createSeedAppEndpointTraceBridge(options = {}) {
+	const currentWindow = options.currentWindow ?? (typeof window === "undefined" ? void 0 : window);
+	const targetWindow = options.targetWindow ?? currentWindow?.parent;
+	if (!targetWindow || currentWindow && targetWindow === currentWindow) return () => void 0;
+	const targetOrigin = options.targetOrigin ?? "*";
+	return (trace) => {
+		targetWindow.postMessage({
+			source: ENDPOINT_TRACE_BRIDGE_CHANNEL,
+			channel: ENDPOINT_TRACE_BRIDGE_CHANNEL,
+			trace,
+			timestamp: Date.now()
+		}, targetOrigin);
+	};
+}
+function createSeedAppEndpointTransport(options) {
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	const endpoint = String(options.endpoint);
+	const endpointTraceTarget = summarizeEndpointForTrace(endpoint);
+	const webSocketFactory = options.webSocketFactory ?? createDefaultWebSocket;
+	const autoAckRealtime = options.autoAckRealtime ?? true;
+	const autoReconnect = options.autoReconnect ?? true;
+	const maxReconnectAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
+	const pending = /* @__PURE__ */ new Map();
+	const eventHandlers = /* @__PURE__ */ new Set();
+	const bridgeEventSubscriptions = /* @__PURE__ */ new Map();
+	const sendQueue = [];
+	const channelCursors = /* @__PURE__ */ new Map();
+	const realtimeChannels = new Set(options.realtimeChannels ?? []);
+	let appSessionId = options.appSessionId;
+	let socket = webSocketFactory(endpoint);
+	let nextId = 0;
+	let nextBridgeEventSubscriptionId = 0;
+	let closed = false;
+	let reconnectAttempts = 0;
+	let reconnectTimer;
+	let realtimeRecoveryTimer;
+	const emitTrace = (event) => {
+		options.onTrace?.(stripUndefined({
+			schema: ENDPOINT_TRACE_SCHEMA,
+			timestamp: Date.now(),
+			endpointOrigin: endpointTraceTarget.origin,
+			endpointPath: endpointTraceTarget.pathname,
+			...event
+		}));
+	};
+	const sendFrame = (frame) => {
+		const serialized = isJsonRpcSerializableFrame(frame) ? (0, _seed_app_studio_protocol.serializeJsonRpcFrame)(frame) : JSON.stringify(frame);
+		if (socket.readyState === WEBSOCKET_OPEN_STATE) {
+			socket.send(serialized);
+			emitTrace(createFrameTraceEvent("frame.send", "outbound", frame, serialized.length, appSessionId, options));
+			return;
+		}
+		sendQueue.push({
+			frame,
+			serialized
+		});
+		emitTrace(createFrameTraceEvent("frame.queue", "outbound", frame, serialized.length, appSessionId, options));
+	};
+	const requestJsonRpc = (method, params, requestOptions) => {
+		if (closed) return Promise.reject(createSeedAppError({
+			code: "host_unavailable",
+			message: "Seed App endpoint transport is closed.",
+			requestId: method
+		}));
+		const id = `${options.idPrefix ?? "seed-app-endpoint"}-${Date.now()}-${nextId}`;
+		nextId += 1;
+		const requestTimeoutMs = requestOptions?.timeoutMs ?? timeoutMs;
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				pending.delete(id);
+				emitTrace({
+					direction: "internal",
+					id,
+					method,
+					phase: "request.timeout",
+					traceId: id
+				});
+				reject(createSeedAppError({
+					code: "handshake_timeout",
+					message: "Seed App Host request timed out.",
+					requestId: id,
+					retryable: true
+				}));
+			}, requestTimeoutMs);
+			pending.set(id, {
+				method,
+				traceId: id,
+				resolve,
+				reject,
+				timeout
+			});
+			sendFrame((0, _seed_app_studio_protocol.createJsonRpcRequest)(method, id, toJsonRpcParams$2(params)));
+		});
+	};
+	const flushQueue = () => {
+		if (closed || socket.readyState !== WEBSOCKET_OPEN_STATE) return;
+		while (sendQueue.length > 0) {
+			const queued = sendQueue.shift();
+			if (queued) {
+				socket.send(queued.serialized);
+				emitTrace(createFrameTraceEvent("frame.send", "outbound", queued.frame, queued.serialized.length, appSessionId, options));
+			}
+		}
+	};
+	const handleOpen = () => {
+		emitTrace({
+			direction: "internal",
+			phase: "socket.open",
+			appSessionId
+		});
+		reconnectAttempts = 0;
+		subscribeConfiguredRealtimeChannels();
+		resubscribeBridgeEvents();
+		flushQueue();
+	};
+	const handleMessage = (event) => {
+		const frame = parseFrame(event?.data);
+		if (!frame) return;
+		emitTrace(createFrameTraceEvent("frame.receive", "inbound", frame, readFrameSize(event?.data), appSessionId, options, pending));
+		if (frame.type === "response") {
+			const id = String(frame.id);
+			syncHandshakeAppSession(id, frame.result, pending, (nextAppSessionId) => {
+				appSessionId = nextAppSessionId;
+				subscribeAppRealtime(nextAppSessionId);
+			});
+			settleSuccess(id, frame.result, pending);
+			return;
+		}
+		if (frame.type === "error") {
+			settleJsonRpcFailure(frame.id, frame.error, pending);
+			return;
+		}
+		if (frame.type === "notification") {
+			if (frame.method === "seed.event") {
+				const params = frame.params ?? {};
+				updateSeedEventRealtimeCursor(params);
+				emitSeedEventNotification(params, eventHandlers);
+				acknowledgeSeedEventRealtimeFrame(params);
+				return;
+			}
+			if (frame.method === "realtime.snapshot") {
+				const params = frame.params ?? {};
+				updateRealtimeSnapshotCursor(params);
+				emitRealtimeSnapshotTrace(params);
+				emitRealtimeSnapshot(params, eventHandlers);
+				acknowledgeRealtimeFrame(params);
+				return;
+			}
+			if (frame.method === "auth.expired") {
+				closed = true;
+				clearReconnectTimer();
+				emitTrace({
+					direction: "internal",
+					phase: "auth.expired",
+					appSessionId
+				});
+				rejectAll(pending, "host_unavailable", "Seed App endpoint authentication expired.");
+			}
+		}
+	};
+	const handleClose = () => {
+		emitTrace({
+			direction: "internal",
+			phase: "socket.close",
+			appSessionId
+		});
+		rejectAll(pending, "host_unavailable", "Seed App endpoint transport closed.");
+		for (const subscription of bridgeEventSubscriptions.values()) subscription.serverSubscriptionId = void 0;
+		scheduleReconnect();
+	};
+	const handleError = () => {
+		emitTrace({
+			direction: "internal",
+			phase: "socket.error",
+			appSessionId
+		});
+		rejectAll(pending, "host_unavailable", "Seed App endpoint transport failed.");
+		scheduleReconnect();
+	};
+	const attachSocket = (nextSocket) => {
+		nextSocket.addEventListener("open", handleOpen);
+		nextSocket.addEventListener("message", handleMessage);
+		nextSocket.addEventListener("close", handleClose);
+		nextSocket.addEventListener("error", handleError);
+	};
+	const detachSocket = (currentSocket) => {
+		currentSocket.removeEventListener("open", handleOpen);
+		currentSocket.removeEventListener("message", handleMessage);
+		currentSocket.removeEventListener("close", handleClose);
+		currentSocket.removeEventListener("error", handleError);
+	};
+	const reconnect = () => {
+		if (closed) return;
+		detachSocket(socket);
+		socket = webSocketFactory(endpoint);
+		attachSocket(socket);
+	};
+	const scheduleReconnect = () => {
+		if (closed || reconnectTimer) return;
+		if (!autoReconnect) {
+			closed = true;
+			return;
+		}
+		if (reconnectAttempts >= maxReconnectAttempts) {
+			closed = true;
+			emitTrace({
+				direction: "internal",
+				phase: "socket.reconnect.failed",
+				appSessionId
+			});
+			return;
+		}
+		reconnectAttempts += 1;
+		emitTrace({
+			direction: "internal",
+			phase: "socket.reconnecting",
+			appSessionId
+		});
+		const delayMs = resolveReconnectDelayMs(options.reconnectDelayMs, reconnectAttempts);
+		if (delayMs <= 0) {
+			reconnect();
+			return;
+		}
+		reconnectTimer = setTimeout(() => {
+			reconnectTimer = void 0;
+			reconnect();
+		}, delayMs);
+	};
+	const clearReconnectTimer = () => {
+		if (!reconnectTimer) return;
+		clearTimeout(reconnectTimer);
+		reconnectTimer = void 0;
+	};
+	const clearRealtimeRecoveryTimer = () => {
+		if (!realtimeRecoveryTimer) return;
+		clearInterval(realtimeRecoveryTimer);
+		realtimeRecoveryTimer = void 0;
+	};
+	const subscribeAppRealtime = (nextAppSessionId) => {
+		realtimeChannels.add(`app:${nextAppSessionId}`);
+		sendRealtimeSubscribeFrame(`app:${nextAppSessionId}`, nextAppSessionId);
+	};
+	const subscribeConfiguredRealtimeChannels = () => {
+		if (appSessionId) realtimeChannels.add(`app:${appSessionId}`);
+		for (const channel of realtimeChannels) sendRealtimeSubscribeFrame(channel, appSessionId);
+	};
+	const sendRealtimeSubscribeFrame = (channel, currentAppSessionId) => {
+		const cursor = channelCursors.get(channel);
+		requestJsonRpc("realtime.subscribe", stripUndefined({
+			channel,
+			cursor
+		})).then((snapshot) => {
+			updateRealtimeSnapshotCursor(snapshot);
+			emitRealtimeSnapshotTrace(snapshot);
+			emitRealtimeSnapshot(snapshot, eventHandlers);
+		}).catch(() => void 0);
+		emitTrace({
+			direction: "outbound",
+			phase: "realtime.resubscribe",
+			appSessionId: currentAppSessionId,
+			channel
+		});
+	};
+	const updateSeedEventRealtimeCursor = (frame) => {
+		const meta = isRecord$3(frame.meta) ? frame.meta : void 0;
+		const channel = readString$1(meta?.channel);
+		const cursor = readString$1(meta?.cursor) ?? readString$1(meta?.eventId);
+		if (channel && cursor) channelCursors.set(channel, cursor);
+	};
+	const updateRealtimeSnapshotCursor = (frame) => {
+		const channel = readString$1(frame.channel);
+		const cursor = readString$1(frame.cursor);
+		if (channel && cursor) channelCursors.set(channel, cursor);
+	};
+	const emitRealtimeSnapshotTrace = (frame) => {
+		const channel = readString$1(frame.channel);
+		const replayRequired = frame.replayRequired === true;
+		emitTrace({
+			direction: "inbound",
+			phase: replayRequired ? "realtime.snapshot.gap" : "realtime.snapshot.replayed",
+			appSessionId,
+			channel
+		});
+	};
+	const acknowledgeRealtimeFrame = (frame) => {
+		if (!autoAckRealtime) return;
+		const channel = readString$1(frame.channel);
+		const cursor = channel ? channelCursors.get(channel) : void 0;
+		if (!channel || !cursor) return;
+		requestJsonRpc("realtime.ack", {
+			channel,
+			cursor
+		}).catch(() => void 0);
+		emitTrace({
+			direction: "outbound",
+			phase: "realtime.ack",
+			appSessionId,
+			channel
+		});
+	};
+	const acknowledgeSeedEventRealtimeFrame = (frame) => {
+		if (!autoAckRealtime) return;
+		const channel = readString$1((isRecord$3(frame.meta) ? frame.meta : void 0)?.channel);
+		const cursor = channel ? channelCursors.get(channel) : void 0;
+		if (!channel || !cursor) return;
+		requestJsonRpc("realtime.ack", {
+			channel,
+			cursor
+		}).catch(() => void 0);
+		emitTrace({
+			direction: "outbound",
+			phase: "realtime.ack",
+			appSessionId,
+			channel
+		});
+	};
+	attachSocket(socket);
+	realtimeRecoveryTimer = setInterval(() => {
+		if (closed || socket.readyState !== WEBSOCKET_OPEN_STATE) return;
+		subscribeConfiguredRealtimeChannels();
+	}, REALTIME_RECOVERY_INTERVAL_MS);
+	const applyBridgeSubscriptionResult = (subscription, result) => {
+		subscription.serverSubscriptionId = readBridgeSubscriptionId$4(result);
+		if (!isRecord$3(result)) return;
+		const channel = readString$1(result.channel);
+		if (!channel) return;
+		subscription.channel = channel;
+		realtimeChannels.add(channel);
+		updateRealtimeSnapshotCursor(result);
+		if (Array.isArray(result.events) && result.events.length > 0) emitRealtimeSnapshot(result, eventHandlers);
+	};
+	const resubscribeBridgeEvents = () => {
+		for (const [localSubscriptionId, subscription] of bridgeEventSubscriptions) requestJsonRpc("seed.event.subscribe", buildBridgeSubscribeParams$4(subscription.event, subscription.params), subscription.requestOptions).then((result) => {
+			const active = bridgeEventSubscriptions.get(localSubscriptionId);
+			if (active === subscription) applyBridgeSubscriptionResult(active, result);
+		}).catch(() => void 0);
+	};
+	return {
+		request(method, params, requestOptions) {
+			return requestJsonRpc(method, withAppSession(params, appSessionId), requestOptions);
+		},
+		subscribe(handler) {
+			eventHandlers.add(handler);
+			return () => eventHandlers.delete(handler);
+		},
+		subscribeRealtimeChannel(channel, cursor) {
+			if (cursor) channelCursors.set(channel, cursor);
+			realtimeChannels.add(channel);
+			sendRealtimeSubscribeFrame(channel, appSessionId);
+			return () => {
+				realtimeChannels.delete(channel);
+				requestJsonRpc("realtime.unsubscribe", { channel }).catch(() => void 0);
+			};
+		},
+		async subscribeBridgeEvent(event, handler, requestOptions, params) {
+			const scopedHandler = (nextEvent) => {
+				if (matchesSeedAppHostEventSubscription(event, nextEvent)) handler(nextEvent);
+			};
+			eventHandlers.add(scopedHandler);
+			const localSubscriptionId = nextBridgeEventSubscriptionId;
+			nextBridgeEventSubscriptionId += 1;
+			try {
+				const result = await requestJsonRpc("seed.event.subscribe", buildBridgeSubscribeParams$4(event, params), requestOptions);
+				const subscription = {
+					event,
+					...params ? { params } : {},
+					...requestOptions ? { requestOptions } : {}
+				};
+				applyBridgeSubscriptionResult(subscription, result);
+				bridgeEventSubscriptions.set(localSubscriptionId, subscription);
+				return () => {
+					eventHandlers.delete(scopedHandler);
+					bridgeEventSubscriptions.delete(localSubscriptionId);
+					const serverSubscriptionId = subscription.serverSubscriptionId;
+					if (!serverSubscriptionId) return;
+					requestJsonRpc("seed.event.unsubscribe", buildBridgeUnsubscribeParams$4(event, serverSubscriptionId), requestOptions).catch(() => void 0);
+				};
+			} catch (error) {
+				eventHandlers.delete(scopedHandler);
+				throw error;
+			}
+		},
+		close() {
+			if (closed) return;
+			closed = true;
+			clearReconnectTimer();
+			clearRealtimeRecoveryTimer();
+			detachSocket(socket);
+			socket.close();
+			rejectAll(pending, "host_unavailable", "Seed App endpoint transport closed.");
+			eventHandlers.clear();
+			bridgeEventSubscriptions.clear();
+		}
+	};
+}
+function buildBridgeSubscribeParams$4(event, params) {
+	return {
+		...params,
+		type: event
+	};
+}
+function buildBridgeUnsubscribeParams$4(event, subscriptionId) {
+	return subscriptionId ? {
+		type: event,
+		subscriptionId
+	} : { type: event };
+}
+function readBridgeSubscriptionId$4(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const subscriptionId = value.subscriptionId;
+	return typeof subscriptionId === "string" && subscriptionId.trim() ? subscriptionId.trim() : void 0;
+}
+function resolveReconnectDelayMs(reconnectDelayMs, attempt) {
+	if (typeof reconnectDelayMs === "function") return Math.max(0, reconnectDelayMs(attempt));
+	if (typeof reconnectDelayMs === "number") return Math.max(0, reconnectDelayMs);
+	return Math.min(3e4, 500 * 2 ** Math.max(0, attempt - 1));
+}
+function syncHandshakeAppSession(id, payload, pending, onAppSession) {
+	if (pending.get(id)?.method !== "seed.handshake" || !isRecord$3(payload) || typeof payload.appSessionId !== "string") return;
+	onAppSession(payload.appSessionId);
+}
+function createDefaultWebSocket(url) {
+	const ctor = globalThis.WebSocket;
+	if (!ctor) throw createSeedAppError({
+		code: "host_unavailable",
+		message: "WebSocket is not available in this runtime.",
+		requestId: "endpoint-unavailable"
+	});
+	return new ctor(url);
+}
+function withAppSession(params, appSessionId) {
+	if (!appSessionId) return params;
+	if (isRecord$3(params)) return params.appSessionId === void 0 ? {
+		...params,
+		appSessionId
+	} : params;
+	if (params === void 0) return { appSessionId };
+	return params;
+}
+function createFrameTraceEvent(phase, direction, frame, sizeBytes, appSessionId, options, pending) {
+	const record = isRecord$3(frame) ? frame : void 0;
+	const params = isRecord$3(record?.params) ? record.params : void 0;
+	const error = isRecord$3(record?.error) ? record.error : void 0;
+	const errorData = isRecord$3(error?.data) ? error.data : void 0;
+	const frameType = readJsonRpcFrameType(record) ?? readString$1(record?.type);
+	const id = readString$1(record?.id) ?? (typeof record?.id === "number" ? String(record.id) : void 0);
+	const pendingRequest = id ? pending?.get(id) : void 0;
+	const method = readString$1(record?.method) ?? pendingRequest?.method;
+	return stripUndefined({
+		direction,
+		phase,
+		appSessionId,
+		capability: method ? resolveMethodCapability(method) : void 0,
+		channel: readString$1(params?.channel),
+		errorCode: frameType === "jsonrpc.error" ? readString$1(errorData?.code) : void 0,
+		frameType,
+		id,
+		method,
+		payloadPreview: options.includeTracePayloads ? frame : void 0,
+		sizeBytes,
+		status: readFrameTraceStatus(phase, frameType),
+		traceId: pendingRequest?.traceId ?? id
+	});
+}
+function resolveMethodCapability(method) {
+	return (0, _seed_app_studio_protocol.getSeedBridgeCapabilityForMethod)(method);
+}
+function readJsonRpcFrameType(record) {
+	if (record?.jsonrpc === "2.0") {
+		if (typeof record.method === "string") return record.id === void 0 ? "jsonrpc.notification" : "jsonrpc.request";
+		if (isRecord$3(record.error)) return "jsonrpc.error";
+		if (Object.prototype.hasOwnProperty.call(record, "result")) return "jsonrpc.response";
+	}
+	if (record?.type === "request") return "jsonrpc.request";
+	if (record?.type === "response") return "jsonrpc.response";
+	if (record?.type === "error") return "jsonrpc.error";
+	if (record?.type === "notification") return "jsonrpc.notification";
+}
+function readFrameTraceStatus(phase, frameType) {
+	if (frameType === "jsonrpc.error") return "failed";
+	if (phase === "frame.receive") return "completed";
+	if (phase === "frame.queue") return "received";
+}
+function summarizeEndpointForTrace(endpoint) {
+	try {
+		const url = new URL(endpoint);
+		return {
+			origin: url.origin,
+			pathname: url.pathname
+		};
+	} catch {
+		return {};
+	}
+}
+function readFrameSize(data) {
+	return typeof data === "string" ? data.length : 0;
+}
+function toJsonRpcParams$2(params) {
+	if (params === void 0) return void 0;
+	if (isRecord$3(params)) return params;
+	return { value: params };
+}
+function isJsonRpcSerializableFrame(frame) {
+	return isRecord$3(frame) && frame.jsonrpc === "2.0";
+}
+function stripUndefined(input) {
+	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+function readString$1(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readPayloadStatus(value) {
+	return isRecord$3(value) ? readString$1(value.status) : void 0;
+}
+function settleSuccess(id, payload, pending) {
+	const request = pending.get(id);
+	if (!request) return;
+	pending.delete(id);
+	clearTimeout(request.timeout);
+	request.resolve(payload);
+}
+function settleJsonRpcFailure(id, error, pending) {
+	const requestId = id === null ? void 0 : String(id);
+	const request = requestId ? pending.get(requestId) : void 0;
+	if (!requestId || !request) return;
+	pending.delete(requestId);
+	clearTimeout(request.timeout);
+	const data = isRecord$3(error.data) ? error.data : void 0;
+	request.reject(createSeedAppError({
+		code: toSeedAppErrorCode(readString$1(data?.code)),
+		message: error.message,
+		requestId: readString$1(data?.requestId) ?? requestId,
+		retryable: typeof data?.retryable === "boolean" ? data.retryable : error.code === -32603,
+		operationId: readString$1(data?.operationId),
+		details: data?.details
+	}));
+}
+function emitSeedEventNotification(params, handlers) {
+	const projected = (0, _seed_app_studio_protocol.projectSeedEventParamsToClientEvent)(params);
+	if (projected) emitEvent(projected, handlers);
+}
+function emitRealtimeEvent(frame, handlers) {
+	const event = isRecord$3(frame.event) ? frame.event : void 0;
+	if (!event) return;
+	const typed = toSeedAppEvent$1(isRecord$3(event.payload) ? event.payload : void 0);
+	if (typed) {
+		emitEvent(typed, handlers);
+		return;
+	}
+	if (typeof event.type === "string") emitEvent(stripUndefined({
+		type: event.type,
+		payload: event.payload,
+		status: readString$1(event.status) ?? readPayloadStatus(event.payload),
+		timestamp: Date.now()
+	}), handlers);
+}
+function emitRealtimeSnapshot(frame, handlers) {
+	if (!Array.isArray(frame.events)) return;
+	for (const item of frame.events) emitRealtimeEvent({ event: item }, handlers);
+}
+function toSeedAppEvent$1(value) {
+	if (!value || typeof value.type !== "string") return void 0;
+	return stripUndefined({
+		type: value.type,
+		payload: value.payload,
+		status: readString$1(value.status) ?? readPayloadStatus(value.payload),
+		timestamp: typeof value.timestamp === "number" ? value.timestamp : Date.now()
+	});
+}
+function emitEvent(event, handlers) {
+	handlers.forEach((handler) => handler(event));
+}
+function rejectAll(pending, code, message, retryable = false) {
+	pending.forEach((request, id) => {
+		clearTimeout(request.timeout);
+		request.reject(createSeedAppError({
+			code,
+			message,
+			requestId: id,
+			retryable
+		}));
+	});
+	pending.clear();
+}
+function parseFrame(data) {
+	if (typeof data !== "string") return void 0;
+	return (0, _seed_app_studio_protocol.deserializeJsonRpcFrame)(data);
+}
+function toSeedAppErrorCode(value) {
+	return normalizeSeedAppErrorCode(value);
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/electronTransport.ts
+function createSeedAppElectronTransport(options = {}) {
+	const electronAPI = options.electronAPI ?? readGlobalElectronApi();
+	if (!electronAPI) throw createSeedAppError({
+		code: "host_unavailable",
+		message: "Electron transport requires window.electronAPI.",
+		requestId: "electron-unavailable"
+	});
+	const eventHandlers = /* @__PURE__ */ new Set();
+	let nextId = 0;
+	let closed = false;
+	const maybeUnsubscribe = electronAPI.on?.((event) => {
+		const frame = (0, _seed_app_studio_protocol.deserializeJsonRpcFrame)(event.value);
+		if (!frame || frame.type !== "notification") return;
+		if (frame.method !== "seed.event") return;
+		const projectedEvent = (0, _seed_app_studio_protocol.projectSeedEventParamsToClientEvent)(frame.params);
+		if (projectedEvent) eventHandlers.forEach((handler) => handler(projectedEvent));
+	});
+	const unsubscribe = typeof maybeUnsubscribe === "function" ? maybeUnsubscribe : void 0;
+	const requestBridge = (method, params, requestOptions) => {
+		if (closed) return Promise.reject(createSeedAppError({
+			code: "host_unavailable",
+			message: "Electron transport is closed.",
+			requestId: method
+		}));
+		const id = `${options.idPrefix ?? "seed-electron"}-${Date.now()}-${nextId}`;
+		nextId += 1;
+		const serialized = (0, _seed_app_studio_protocol.serializeJsonRpcFrame)((0, _seed_app_studio_protocol.createJsonRpcRequest)(method, id, shouldPropagateTraceForMethod(method) ? ensureSeedAppTraceCarrier(params) : params));
+		return withTimeout$1(Promise.resolve(electronAPI.emit(serialized)).then((response) => {
+			const resultFrame = (0, _seed_app_studio_protocol.deserializeJsonRpcFrame)(typeof response === "string" ? response : JSON.stringify(response));
+			if (!resultFrame) throw createSeedAppError({
+				code: "invalid_payload_schema",
+				message: "Electron transport expected a JSON-RPC response frame.",
+				requestId: id
+			});
+			if (resultFrame.type === "response") {
+				if (resultFrame.id !== id) throw createSeedAppError({
+					code: "invalid_payload_schema",
+					message: "Electron transport response id did not match the request.",
+					requestId: id
+				});
+				return resultFrame.result;
+			}
+			if (resultFrame.type === "error") {
+				if (resultFrame.id !== id) throw createSeedAppError({
+					code: "invalid_payload_schema",
+					message: "Electron transport error id did not match the request.",
+					requestId: id
+				});
+				throw jsonRpcErrorToSeedAppError(resultFrame.error, id);
+			}
+			throw createSeedAppError({
+				code: "invalid_payload_schema",
+				message: "Electron transport received unexpected frame type.",
+				requestId: id
+			});
+		}), requestOptions?.timeoutMs ?? options.timeoutMs, id);
+	};
+	return {
+		request: requestBridge,
+		subscribe(handler) {
+			eventHandlers.add(handler);
+			return () => eventHandlers.delete(handler);
+		},
+		async subscribeBridgeEvent(event, handler, requestOptions, params) {
+			const scopedHandler = (nextEvent) => {
+				if (matchesSeedAppHostEventSubscription(event, nextEvent)) handler(nextEvent);
+			};
+			eventHandlers.add(scopedHandler);
+			let subscriptionId;
+			try {
+				subscriptionId = readBridgeSubscriptionId$3(await requestBridge("seed.event.subscribe", buildBridgeSubscribeParams$3(event, params), requestOptions));
+			} catch (error) {
+				eventHandlers.delete(scopedHandler);
+				throw error;
+			}
+			return () => {
+				eventHandlers.delete(scopedHandler);
+				requestBridge("seed.event.unsubscribe", buildBridgeUnsubscribeParams$3(event, subscriptionId), requestOptions).catch(() => void 0);
+			};
+		},
+		close() {
+			closed = true;
+			eventHandlers.clear();
+			unsubscribe?.();
+		}
+	};
+}
+function shouldPropagateTraceForMethod(method) {
+	return method === "seed.agent.run" || method === "seed.event.subscribe";
+}
+function buildBridgeSubscribeParams$3(event, params) {
+	return {
+		...params,
+		type: event
+	};
+}
+function buildBridgeUnsubscribeParams$3(event, subscriptionId) {
+	return subscriptionId ? {
+		type: event,
+		subscriptionId
+	} : { type: event };
+}
+function readBridgeSubscriptionId$3(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const subscriptionId = value.subscriptionId;
+	return typeof subscriptionId === "string" && subscriptionId.trim() ? subscriptionId.trim() : void 0;
+}
+function readGlobalElectronApi() {
+	return globalThis.window?.electronAPI;
+}
+function jsonRpcErrorToSeedAppError(error, requestId) {
+	const data = error.data;
+	return createSeedAppError({
+		code: normalizeSeedErrorCode$1(typeof data?.code === "string" ? data.code : void 0),
+		message: error.message,
+		requestId: typeof data?.requestId === "string" ? data.requestId : requestId,
+		retryable: typeof data?.retryable === "boolean" ? data.retryable : false,
+		capability: typeof data?.capability === "string" ? data.capability : void 0,
+		action: typeof data?.action === "string" ? data.action : void 0,
+		operationId: typeof data?.operationId === "string" ? data.operationId : void 0,
+		details: data?.details
+	});
+}
+function normalizeSeedErrorCode$1(code) {
+	return normalizeSeedAppErrorCode(code);
+}
+function withTimeout$1(promise, timeoutMs, requestId) {
+	if (timeoutMs === void 0) return promise;
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			reject(createSeedAppError({
+				code: "handshake_timeout",
+				message: "Electron transport request timed out.",
+				requestId,
+				retryable: true
+			}));
+		}, timeoutMs);
+		promise.then((value) => {
+			clearTimeout(timeout);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timeout);
+			reject(error);
+		});
+	});
+}
+//#endregion
+//#region src/reactNativeTransport.ts
+function createSeedAppReactNativeTransport(options = {}) {
+	const port = options.port ?? readGlobalReactNativeWebViewPort();
+	if (!port) throw createSeedAppError({
+		code: "host_unavailable",
+		message: "React Native transport requires a WebView postMessage port.",
+		requestId: "react-native-unavailable"
+	});
+	const messageTarget = options.messageTarget ?? readGlobalReactNativeMessageTarget();
+	const adapter = (0, _seed_app_studio_protocol.createJsonRpcReactNativeWebViewAdapter)({
+		port,
+		onInvalidFrame: options.onInvalidFrame
+	});
+	const eventHandlers = /* @__PURE__ */ new Set();
+	const pending = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	let closed = false;
+	const requestBridge = (method, params, requestOptions) => {
+		if (closed) return Promise.reject(createSeedAppError({
+			code: "host_unavailable",
+			message: "React Native transport is closed.",
+			requestId: method
+		}));
+		const id = `${options.idPrefix ?? "seed-react-native"}-${Date.now()}-${nextId}`;
+		nextId += 1;
+		const timeoutMs = requestOptions?.timeoutMs ?? options.timeoutMs ?? 3e4;
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				pending.delete(id);
+				reject(createSeedAppError({
+					code: "handshake_timeout",
+					message: "React Native transport request timed out.",
+					requestId: id,
+					retryable: true
+				}));
+			}, timeoutMs);
+			pending.set(id, {
+				resolve,
+				reject,
+				timeout
+			});
+			try {
+				adapter.postRequest((0, _seed_app_studio_protocol.createJsonRpcRequest)(method, id, toJsonRpcParams$1(params)));
+			} catch (error) {
+				pending.delete(id);
+				clearTimeout(timeout);
+				reject(createSeedAppError({
+					code: "host_unavailable",
+					message: `React Native transport postMessage failed: ${error instanceof Error ? error.message : String(error)}`,
+					requestId: id,
+					retryable: true
+				}));
+			}
+		});
+	};
+	const handleMessage = (event) => {
+		const rawMessage = readReactNativeMessageData(event);
+		const frame = adapter.parseMessage(rawMessage);
+		if (!frame) return;
+		handleFrame(frame);
+	};
+	messageTarget?.addEventListener("message", handleMessage);
+	return {
+		request: requestBridge,
+		subscribe(handler) {
+			eventHandlers.add(handler);
+			return () => eventHandlers.delete(handler);
+		},
+		async subscribeBridgeEvent(event, handler, requestOptions, params) {
+			const scopedHandler = (nextEvent) => {
+				if (matchesSeedAppHostEventSubscription(event, nextEvent)) handler(nextEvent);
+			};
+			eventHandlers.add(scopedHandler);
+			let subscriptionId;
+			try {
+				subscriptionId = readBridgeSubscriptionId$2(await requestBridge("seed.event.subscribe", buildBridgeSubscribeParams$2(event, params), requestOptions));
+			} catch (error) {
+				eventHandlers.delete(scopedHandler);
+				throw error;
+			}
+			return () => {
+				eventHandlers.delete(scopedHandler);
+				requestBridge("seed.event.unsubscribe", buildBridgeUnsubscribeParams$2(event, subscriptionId), requestOptions).catch(() => void 0);
+			};
+		},
+		close() {
+			closed = true;
+			messageTarget?.removeEventListener("message", handleMessage);
+			pending.forEach((request, id) => {
+				clearTimeout(request.timeout);
+				request.reject(createSeedAppError({
+					code: "host_unavailable",
+					message: "React Native transport closed.",
+					requestId: id
+				}));
+			});
+			pending.clear();
+			eventHandlers.clear();
+		}
+	};
+	function handleFrame(frame) {
+		switch (frame.type) {
+			case "response":
+				settleSuccess(frame.id, frame.result);
+				return;
+			case "error": {
+				const data = frame.error.data;
+				settleFailure(frame.id, createSeedAppError({
+					code: normalizeSeedErrorCode(typeof data?.code === "string" ? data.code : void 0),
+					message: frame.error.message,
+					requestId: typeof data?.requestId === "string" ? data.requestId : frame.id,
+					retryable: typeof data?.retryable === "boolean" ? data.retryable : false,
+					capability: typeof data?.capability === "string" ? data.capability : void 0,
+					action: typeof data?.action === "string" ? data.action : void 0,
+					operationId: typeof data?.operationId === "string" ? data.operationId : void 0,
+					details: data?.details
+				}));
+				return;
+			}
+			case "notification": {
+				if (frame.method !== "seed.event") return;
+				const projected = (0, _seed_app_studio_protocol.projectSeedEventParamsToClientEvent)(frame.params);
+				if (projected) eventHandlers.forEach((handler) => handler(projected));
+			}
+		}
+	}
+	function settleSuccess(id, result) {
+		const request = pending.get(id);
+		if (!request) return;
+		pending.delete(id);
+		clearTimeout(request.timeout);
+		request.resolve(result);
+	}
+	function settleFailure(id, error) {
+		const request = pending.get(id);
+		if (!request) return;
+		pending.delete(id);
+		clearTimeout(request.timeout);
+		request.reject(error);
+	}
+}
+function buildBridgeSubscribeParams$2(event, params) {
+	return {
+		...params,
+		type: event
+	};
+}
+function buildBridgeUnsubscribeParams$2(event, subscriptionId) {
+	return subscriptionId ? {
+		type: event,
+		subscriptionId
+	} : { type: event };
+}
+function readBridgeSubscriptionId$2(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const subscriptionId = value.subscriptionId;
+	return typeof subscriptionId === "string" && subscriptionId.trim() ? subscriptionId.trim() : void 0;
+}
+function readGlobalReactNativeWebViewPort() {
+	return globalThis.window?.ReactNativeWebView;
+}
+function readGlobalReactNativeMessageTarget() {
+	return globalThis.window;
+}
+function readReactNativeMessageData(event) {
+	if (typeof event === "string") return event;
+	return event.nativeEvent?.data ?? event.data;
+}
+function toJsonRpcParams$1(params) {
+	if (params === void 0) return void 0;
+	if (typeof params === "object" && params !== null && !Array.isArray(params)) return params;
+	return { value: params };
+}
+function normalizeSeedErrorCode(code) {
+	return normalizeSeedAppErrorCode(code);
+}
+//#endregion
+//#region src/webSocketTransport.ts
+function createSeedAppWebSocketTransport(options) {
+	const getWebSocketImpl = () => {
+		return options.WebSocket ?? globalThis.WebSocket;
+	};
+	const eventHandlers = /* @__PURE__ */ new Set();
+	const pending = /* @__PURE__ */ new Map();
+	const subscribedRealtimeChannels = /* @__PURE__ */ new Map();
+	const sendQueue = [];
+	let nextId = 0;
+	let closed = false;
+	let ws = null;
+	let wsReady = false;
+	const defaultTimeoutMs = options.timeoutMs ?? 3e4;
+	const idPrefix = options.idPrefix ?? "seed-ws";
+	function generateId() {
+		nextId += 1;
+		return `${idPrefix}-${Date.now()}-${nextId}`;
+	}
+	async function resolveToken() {
+		if (typeof options.token === "function") return await options.token();
+		return options.token;
+	}
+	async function buildUrl() {
+		const token = await resolveToken();
+		let resolvedUrl = options.url;
+		if (typeof globalThis.location !== "undefined" && !/^https?:\/\//i.test(resolvedUrl) && !/^wss?:\/\//i.test(resolvedUrl)) {
+			const origin = globalThis.location.origin;
+			resolvedUrl = resolvedUrl.startsWith("/") ? `${origin.replace(/^http/, "ws")}${resolvedUrl}` : `${origin.replace(/^http/, "ws")}/${resolvedUrl}`;
+		}
+		const url = new URL(resolvedUrl);
+		if (token) url.searchParams.set("token", token);
+		return url.toString();
+	}
+	function connect() {
+		if (closed) return;
+		if (!getWebSocketImpl()) return;
+		buildUrl().then((wsUrl) => {
+			if (closed) return;
+			const WsCtor = getWebSocketImpl();
+			if (!WsCtor) return;
+			try {
+				ws = new WsCtor(wsUrl);
+			} catch (error) {
+				const seedError = createSeedAppError({
+					code: "host_unavailable",
+					message: `WebSocket connection failed: ${error instanceof Error ? error.message : String(error)}`,
+					requestId: "ws-connect",
+					retryable: true
+				});
+				rejectAllPending(seedError);
+				rejectAllRealtimeSubscriptions(seedError);
+				return;
+			}
+			attachWsHandlers();
+		}).catch((error) => {
+			const seedError = createSeedAppError({
+				code: "host_unavailable",
+				message: `WebSocket URL build failed: ${error instanceof Error ? error.message : String(error)}`,
+				requestId: "ws-url-build",
+				retryable: true
+			});
+			rejectAllPending(seedError);
+			rejectAllRealtimeSubscriptions(seedError);
+		});
+	}
+	function attachWsHandlers() {
+		if (!ws) return;
+		ws.onmessage = (event) => {
+			const frame = (0, _seed_app_studio_protocol.deserializeJsonRpcFrame)(event.data);
+			if (!frame) return;
+			handleServerFrame(frame);
+		};
+		ws.onclose = () => {
+			wsReady = false;
+			if (!closed) {
+				const seedError = createSeedAppError({
+					code: "host_unavailable",
+					message: "WebSocket connection closed unexpectedly.",
+					requestId: "ws-close",
+					retryable: true
+				});
+				rejectAllPending(seedError);
+				rejectAllRealtimeSubscriptions(seedError);
+			}
+		};
+		ws.onerror = () => {
+			const seedError = createSeedAppError({
+				code: "host_unavailable",
+				message: "WebSocket connection error.",
+				requestId: "ws-error",
+				retryable: true
+			});
+			rejectAllPending(seedError);
+			rejectAllRealtimeSubscriptions(seedError);
+		};
+		ws.onopen = () => {
+			wsReady = true;
+			for (const [channel, subscription] of subscribedRealtimeChannels) sendRealtimeSubscribeFrame(channel, subscription);
+			flushSendQueue();
+		};
+	}
+	function flushSendQueue() {
+		while (sendQueue.length > 0) {
+			const frame = sendQueue.shift();
+			try {
+				ws?.send(frame);
+			} catch {
+				sendQueue.unshift(frame);
+				break;
+			}
+		}
+	}
+	function sendSerialized(serialized) {
+		if (!wsReady || !ws) {
+			sendQueue.push(serialized);
+			return;
+		}
+		ws.send(serialized);
+	}
+	function requestJsonRpc(method, params, requestOptions) {
+		if (closed) return Promise.reject(createSeedAppError({
+			code: "host_unavailable",
+			message: "WebSocket transport is closed.",
+			requestId: method
+		}));
+		ensureConnected();
+		const id = generateId();
+		const timeoutMs = requestOptions?.timeoutMs ?? defaultTimeoutMs;
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				pending.delete(id);
+				reject(createSeedAppError({
+					code: "handshake_timeout",
+					message: "WebSocket request timed out.",
+					requestId: id,
+					retryable: true
+				}));
+			}, timeoutMs);
+			pending.set(id, {
+				resolve,
+				reject,
+				timeout
+			});
+			try {
+				sendSerialized((0, _seed_app_studio_protocol.serializeJsonRpcFrame)((0, _seed_app_studio_protocol.createJsonRpcRequest)(method, id, toJsonRpcParams(params))));
+			} catch (error) {
+				pending.delete(id);
+				clearTimeout(timeout);
+				reject(error);
+			}
+		});
+	}
+	function handleServerFrame(frame) {
+		switch (frame.type) {
+			case "response": {
+				const request = pending.get(frame.id);
+				if (!request) return;
+				pending.delete(frame.id);
+				clearTimeout(request.timeout);
+				request.resolve(frame.result);
+				return;
+			}
+			case "error": {
+				const request = pending.get(frame.id);
+				if (!request) return;
+				pending.delete(frame.id);
+				clearTimeout(request.timeout);
+				const data = frame.error.data;
+				request.reject(createSeedAppError({
+					code: normalizeErrorCode(typeof data?.code === "string" ? data.code : void 0),
+					message: frame.error.message,
+					requestId: typeof data?.requestId === "string" ? data.requestId : frame.id,
+					retryable: typeof data?.retryable === "boolean" ? data.retryable : isRetryableJsonRpcCode(frame.error.code),
+					operationId: typeof data?.operationId === "string" ? data.operationId : void 0,
+					details: data?.details
+				}));
+				return;
+			}
+			case "notification":
+				if (frame.method === "seed.event") {
+					const projected = (0, _seed_app_studio_protocol.projectSeedEventParamsToClientEvent)(frame.params);
+					if (projected) eventHandlers.forEach((handler) => handler(projected));
+					return;
+				}
+				if (frame.method === "realtime.snapshot") {
+					const params = frame.params;
+					const channel = typeof params?.channel === "string" ? params.channel : void 0;
+					handleRealtimeSnapshot(params);
+					resolveRealtimeSubscription(channel);
+					return;
+				}
+				if (frame.method === "realtime.ack.ok") {
+					resolveRealtimeSubscription(typeof frame.params?.channel === "string" ? frame.params.channel : void 0);
+					return;
+				}
+				if (frame.method === "realtime.error") {
+					const params = frame.params;
+					const channel = typeof params?.channel === "string" ? params.channel : void 0;
+					rejectRealtimeSubscription(channel, createSeedAppError({
+						code: normalizeErrorCode(typeof params?.code === "string" ? params.code : "provider_failed"),
+						message: typeof params?.message === "string" ? params.message : "Realtime subscription failed.",
+						requestId: channel ?? "realtime.subscribe",
+						retryable: true
+					}));
+					return;
+				}
+				if (frame.method === "pong") return;
+				return;
+		}
+	}
+	function rejectAllPending(error) {
+		const entries = Array.from(pending.entries());
+		pending.clear();
+		for (const [, request] of entries) {
+			clearTimeout(request.timeout);
+			request.reject(error);
+		}
+	}
+	function createRealtimeSubscription(channel, cursor) {
+		let resolveReady = () => void 0;
+		let rejectReady = (_error) => void 0;
+		const subscription = {
+			acknowledged: false,
+			cursor,
+			ready: new Promise((resolve, reject) => {
+				resolveReady = resolve;
+				rejectReady = reject;
+			}),
+			refCount: 1,
+			rejectReady,
+			resolveReady
+		};
+		subscription.ackTimeout = setTimeout(() => {
+			const current = subscribedRealtimeChannels.get(channel);
+			if (current !== subscription || current.acknowledged) return;
+			subscribedRealtimeChannels.delete(channel);
+			current.rejectReady(createSeedAppError({
+				code: "handshake_timeout",
+				message: "Realtime subscription timed out before acknowledgement.",
+				requestId: channel,
+				retryable: true
+			}));
+		}, defaultTimeoutMs);
+		return subscription;
+	}
+	function sendRealtimeSubscribeFrame(channel, subscription) {
+		const params = { channel };
+		if (subscription.cursor) params.cursor = subscription.cursor;
+		requestJsonRpc("realtime.subscribe", params).then((snapshot) => {
+			handleRealtimeSnapshot(snapshot);
+			resolveRealtimeSubscription(channel);
+		}).catch((error) => {
+			rejectRealtimeSubscription(channel, normalizeSeedAppError(error, channel));
+		});
+	}
+	function handleRealtimeSnapshot(params) {
+		(Array.isArray(params?.events) ? params.events : []).map(projectRealtimeEvent).filter(isSeedAppEvent).forEach((event) => {
+			eventHandlers.forEach((handler) => handler(event));
+		});
+	}
+	function resolveRealtimeSubscription(channel) {
+		if (!channel) return;
+		const subscription = subscribedRealtimeChannels.get(channel);
+		if (!subscription || subscription.acknowledged) return;
+		subscription.acknowledged = true;
+		if (subscription.ackTimeout) {
+			clearTimeout(subscription.ackTimeout);
+			subscription.ackTimeout = void 0;
+		}
+		subscription.resolveReady();
+	}
+	function rejectRealtimeSubscription(channel, error) {
+		if (!channel) return;
+		const subscription = subscribedRealtimeChannels.get(channel);
+		if (!subscription || subscription.acknowledged) return;
+		if (subscription.ackTimeout) {
+			clearTimeout(subscription.ackTimeout);
+			subscription.ackTimeout = void 0;
+		}
+		subscribedRealtimeChannels.delete(channel);
+		subscription.rejectReady(error);
+	}
+	function rejectAllRealtimeSubscriptions(error) {
+		const entries = Array.from(subscribedRealtimeChannels.entries());
+		subscribedRealtimeChannels.clear();
+		for (const [, subscription] of entries) {
+			if (subscription.ackTimeout) {
+				clearTimeout(subscription.ackTimeout);
+				subscription.ackTimeout = void 0;
+			}
+			if (!subscription.acknowledged) subscription.rejectReady(error);
+		}
+	}
+	let connectionInitiated = false;
+	function ensureConnected() {
+		if (!connectionInitiated) {
+			connectionInitiated = true;
+			connect();
+		}
+	}
+	return {
+		request(method, params, requestOptions) {
+			return requestJsonRpc(method, params, requestOptions);
+		},
+		subscribe(handler) {
+			eventHandlers.add(handler);
+			return () => {
+				eventHandlers.delete(handler);
+			};
+		},
+		async subscribeBridgeEvent(event, handler, requestOptions, params) {
+			const scopedHandler = (nextEvent) => {
+				if (matchesSeedAppHostEventSubscription(event, nextEvent)) handler(nextEvent);
+			};
+			eventHandlers.add(scopedHandler);
+			let subscriptionId;
+			try {
+				subscriptionId = readBridgeSubscriptionId$1(await requestJsonRpc("seed.event.subscribe", buildBridgeSubscribeParams$1(event, params), requestOptions));
+			} catch (error) {
+				eventHandlers.delete(scopedHandler);
+				throw error;
+			}
+			return () => {
+				eventHandlers.delete(scopedHandler);
+				requestJsonRpc("seed.event.unsubscribe", buildBridgeUnsubscribeParams$1(event, subscriptionId), requestOptions).catch(() => void 0);
+			};
+		},
+		async subscribeRealtimeChannel(channel, cursor) {
+			let subscription = subscribedRealtimeChannels.get(channel);
+			if (subscription) {
+				subscription.refCount += 1;
+				if (cursor) subscription.cursor = cursor;
+			} else {
+				subscription = createRealtimeSubscription(channel, cursor);
+				subscribedRealtimeChannels.set(channel, subscription);
+				ensureConnected();
+				if (wsReady && ws) sendRealtimeSubscribeFrame(channel, subscription);
+			}
+			await subscription.ready;
+			return () => {
+				const current = subscribedRealtimeChannels.get(channel);
+				if (!current) return;
+				current.refCount -= 1;
+				if (current.refCount > 0) return;
+				subscribedRealtimeChannels.delete(channel);
+				if (wsReady && ws && ws.readyState === (getWebSocketImpl()?.OPEN ?? 1)) requestJsonRpc("realtime.unsubscribe", { channel }).catch(() => void 0);
+			};
+		},
+		close() {
+			closed = true;
+			wsReady = false;
+			sendQueue.length = 0;
+			const seedError = createSeedAppError({
+				code: "host_unavailable",
+				message: "WebSocket transport closed.",
+				requestId: "ws-close"
+			});
+			rejectAllPending(seedError);
+			rejectAllRealtimeSubscriptions(seedError);
+			eventHandlers.clear();
+			subscribedRealtimeChannels.clear();
+			if (ws) {
+				ws.onmessage = null;
+				ws.onclose = null;
+				ws.onerror = null;
+				ws.onopen = null;
+				try {
+					ws.close(1e3, "Transport closed");
+				} catch {}
+				ws = null;
+			}
+		}
+	};
+}
+function buildBridgeSubscribeParams$1(event, params) {
+	return {
+		...params,
+		type: event
+	};
+}
+function buildBridgeUnsubscribeParams$1(event, subscriptionId) {
+	return subscriptionId ? {
+		type: event,
+		subscriptionId
+	} : { type: event };
+}
+function readBridgeSubscriptionId$1(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const subscriptionId = value.subscriptionId;
+	return typeof subscriptionId === "string" && subscriptionId.trim() ? subscriptionId.trim() : void 0;
+}
+function projectRealtimeEvent(params) {
+	const envelope = isRecord$2(params?.event) ? params.event : params;
+	if (!envelope || typeof envelope.type !== "string") return void 0;
+	const payload = envelope.payload;
+	const typedPayload = isRecord$2(payload) ? toSeedAppEvent(payload) : void 0;
+	if (typedPayload) return typedPayload;
+	return {
+		type: envelope.type,
+		payload,
+		status: typeof envelope.status === "string" ? envelope.status : void 0,
+		timestamp: typeof envelope.timestamp === "number" ? envelope.timestamp : Date.now()
+	};
+}
+function toSeedAppEvent(value) {
+	if (typeof value.type !== "string") return void 0;
+	return {
+		type: value.type,
+		payload: value.payload,
+		status: typeof value.status === "string" ? value.status : void 0,
+		timestamp: typeof value.timestamp === "number" ? value.timestamp : Date.now()
+	};
+}
+function normalizeErrorCode(code) {
+	return normalizeSeedAppErrorCode(code);
+}
+function isRetryableJsonRpcCode(code) {
+	return code === -32700 || code === -32603;
+}
+function isSeedAppEvent(value) {
+	return Boolean(value);
+}
+function toJsonRpcParams(params) {
+	if (params === void 0) return void 0;
+	if (params && typeof params === "object" && !Array.isArray(params)) return params;
+	return { value: params };
+}
+function normalizeSeedAppError(error, requestId) {
+	if (isSeedAppError(error)) return error;
+	return createSeedAppError({
+		code: "provider_failed",
+		message: error instanceof Error ? error.message : String(error),
+		requestId,
+		retryable: false
+	});
+}
+function isSeedAppError(value) {
+	return Boolean(value) && typeof value === "object" && typeof value.code === "string" && typeof value.message === "string";
+}
+function isRecord$2(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+//#endregion
+//#region src/mockHost.ts
+const DEFAULT_MOCK_METHODS = Array.from(/* @__PURE__ */ new Set([
+	"seed.handshake",
+	"seed.capabilities.query",
+	"seed.capabilities.request",
+	"seed.auth.getContext",
+	"seed.auth.getAccessToken",
+	"seed.network.fetch",
+	"seed.bridge.diagnostics",
+	..._seed_app_studio_protocol.seedBridgeMethodRuntimeRoutes.map((route) => route.method),
+	"seed.agent.list",
+	"seed.agent.config.delete",
+	"seed.agent.config.upsert",
+	"seed.agent.preset.update",
+	"seed.agent.runtime.configOption.set",
+	"seed.agent.runtime.configOptions.get",
+	"seed.agent.runtime.mode.get",
+	"seed.agent.runtime.mode.set",
+	"seed.agent.runtime.model.get",
+	"seed.agent.runtime.model.set",
+	"seed.agent.runtime.bundled.get",
+	"seed.agent.runtime.bundled.update",
+	"seed.agent.runtime.local.status.get",
+	"seed.agent.runtime.local.restart",
+	"seed.agent.runtime.capabilities.prefetch",
+	"seed.agent.runtime.local.stale.mark",
+	"seed.agent.runtime.slashCommands.list",
+	"seed.agent.runtime.slashCommand.execute",
+	"seed.agent.runtime.session.ensure",
+	"seed.agent.runtime.conversation.warmup",
+	"seed.agent.runtime.openclaw.get",
+	"seed.agent.runtime.process.snapshot.get",
+	"seed.agent.runtime.process.release",
+	"seed.agent.subagent.session.snapshot.get",
+	"seed.agent.subagent.session.load",
+	"seed.agent.run",
+	"seed.agent.input.submit",
+	"seed.agent.sideQuestion.ask",
+	"seed.agent.approval.check",
+	"seed.agent.approval.list",
+	"seed.agent.approval.respond",
+	"seed.agent.approval.changed",
+	"seed.agent.elicitation.respond",
+	"seed.event.subscribe",
+	"seed.event.unsubscribe",
+	"seed.conversation.changed",
+	"seed.remotePc.presence.list",
+	"seed.remotePc.presence.changed",
+	"seed.remotePc.vibe.list",
+	"seed.remotePc.vibe.get",
+	"seed.remotePc.vibe.messages",
+	"seed.remotePc.vibe.events",
+	"seed.conversation.archive.import",
+	"seed.conversation.artifact.list",
+	"seed.conversation.artifact.access.list",
+	"seed.conversation.artifact.access.revoke",
+	"seed.conversation.artifact.evidence.list",
+	"seed.conversation.artifact.materialize",
+	"seed.conversation.artifact.policy.update",
+	"seed.conversation.artifact.scrub.apply",
+	"seed.conversation.artifact.scrub.dryRun",
+	"seed.conversation.artifact.share",
+	"seed.conversation.artifact.shareTargets.list",
+	"seed.conversation.listByCronJob",
+	"seed.conversation.searchMessages",
+	"seed.team.list",
+	"seed.team.get",
+	"seed.team.create",
+	"seed.team.rename",
+	"seed.team.sessionMode.set",
+	"seed.team.workspace.update",
+	"seed.team.delete",
+	"seed.team.agent.add",
+	"seed.team.agent.remove",
+	"seed.team.agent.rename",
+	"seed.team.message.send",
+	"seed.team.message.sendToAgent",
+	"seed.team.stop",
+	"seed.team.session.ensure",
+	"seed.team.session.reset",
+	"seed.memory.search",
+	"seed.resource.read",
+	"seed.resource.stat",
+	"seed.resource.list",
+	"seed.resource.open",
+	"seed.resource.openableSchemes",
+	"seed.skill.list",
+	"seed.skill.autoInjected.list",
+	"seed.skill.external.detect",
+	"seed.skill.paths.get",
+	"seed.skill.externalPath.add",
+	"seed.skill.importLocal",
+	"seed.skill.delete",
+	"seed.skill.exportLocal",
+	"seed.skill.autoInjected.add",
+	"seed.skill.autoInjected.remove",
+	"seed.skill.market.setEnabled",
+	"seed.assistant.resource.read",
+	"seed.assistant.resource.write",
+	"seed.assistant.resource.delete",
+	"seed.builtin.resource.read",
+	"seed.roleTemplate.list",
+	"seed.employee.list",
+	"seed.employee.createFromAssistant",
+	"seed.employee.createFromRoleTemplate",
+	"seed.employee.get",
+	"seed.employee.activity.list",
+	"seed.employee.memory.delete",
+	"seed.employee.memory.events.list",
+	"seed.employee.memory.list",
+	"seed.employee.openConversation",
+	"seed.employee.remove",
+	"seed.employee.update",
+	"seed.roleTemplate.get",
+	"seed.roleTemplate.create",
+	"seed.roleTemplate.update",
+	"seed.roleTemplate.delete",
+	"seed.roleMaker.session.start",
+	"seed.roleMaker.session.get",
+	"seed.roleMaker.session.generate",
+	"seed.roleMaker.session.apply",
+	"seed.roleMaker.session.approve",
+	"seed.roleMaker.session.discard",
+	"seed.brainBundle.previewSummaries",
+	"seed.mcp.listTools",
+	"seed.mcp.callTool",
+	"seed.workspace.capabilities.get"
+]));
+function createSeedAppMockTransport(options) {
+	const listeners = /* @__PURE__ */ new Set();
+	let closed = false;
+	const handlers = {
+		"seed.handshake": () => ({
+			appId: options.appId,
+			hostVersion: options.hostVersion ?? "mock-host",
+			grants: options.grants ?? []
+		}),
+		"seed.capabilities.query": () => options.grants ?? [],
+		"seed.capabilities.request": (params) => {
+			const requested = readRequestedCapabilities(params);
+			const grants = options.grants ?? [];
+			return {
+				grants,
+				approved: requested.filter((capability) => grants.some((grant) => grant.capability === capability && grant.policy === "enabled")),
+				denied: requested.filter((capability) => grants.some((grant) => grant.capability === capability && grant.policy === "disabled")),
+				pending: requested.filter((capability) => grants.some((grant) => grant.capability === capability && grant.policy === "ask"))
+			};
+		},
+		"seed.auth.getContext": () => ({
+			authenticated: false,
+			source: "desktop",
+			accountState: "unauthenticated"
+		}),
+		"seed.auth.getAccessToken": () => ({
+			token: "mock-seed-app-token",
+			tokenType: "seed-app",
+			appId: options.appId,
+			userId: "mock-user",
+			scopes: [],
+			issuedAt: 0,
+			expiresAt: 0
+		}),
+		"seed.network.fetch": () => ({
+			url: "https://example.test/",
+			status: 200,
+			statusText: "OK",
+			headers: { "content-type": "application/json" },
+			body: "{}"
+		}),
+		"seed.bridge.diagnostics": (params) => createMockBridgeDiagnostics(options, params),
+		"seed.agent.list": () => [],
+		"seed.agent.config.upsert": (params) => ({
+			ok: true,
+			assistant: {
+				id: readRequiredNestedString(params, ["agent", "id"]),
+				agentId: readRequiredNestedString(params, ["agent", "id"]),
+				name: readRequiredNestedString(params, ["agent", "name"]),
+				source: readRequiredString(params, "collection") === "preset" ? "preset" : "custom-config",
+				kind: "acp",
+				status: "available"
+			}
+		}),
+		"seed.agent.config.delete": () => ({
+			ok: true,
+			deleted: true
+		}),
+		"seed.agent.runtime.configOptions.get": () => ({ configOptions: [{
+			id: "reasoning_effort",
+			name: "Reasoning",
+			type: "select",
+			currentValue: "medium",
+			options: [{
+				value: "low",
+				name: "Low"
+			}, {
+				value: "medium",
+				name: "Medium"
+			}]
+		}] }),
+		"seed.agent.runtime.configOption.set": (params) => ({ configOptions: [{
+			id: readRequiredString(params, "configId"),
+			type: "select",
+			currentValue: readRequiredString(params, "value"),
+			options: [{
+				value: readRequiredString(params, "value"),
+				name: readRequiredString(params, "value")
+			}]
+		}] }),
+		"seed.agent.runtime.model.get": () => ({ modelInfo: {
+			currentModelId: "mock-model",
+			currentModelLabel: "Mock Model",
+			availableModels: [{
+				id: "mock-model",
+				label: "Mock Model"
+			}],
+			canSwitch: true,
+			source: "models",
+			sourceDetail: "acp-models"
+		} }),
+		"seed.agent.runtime.model.set": (params) => ({ modelInfo: {
+			currentModelId: readRequiredString(params, "modelId"),
+			currentModelLabel: readRequiredString(params, "modelId"),
+			availableModels: [{
+				id: readRequiredString(params, "modelId"),
+				label: readRequiredString(params, "modelId")
+			}],
+			canSwitch: true,
+			source: "models",
+			sourceDetail: "acp-models"
+		} }),
+		"seed.agent.runtime.mode.get": () => ({
+			mode: "default",
+			initialized: true
+		}),
+		"seed.agent.runtime.mode.set": (params) => ({
+			mode: readRequiredString(params, "mode"),
+			initialized: true
+		}),
+		"seed.agent.runtime.bundled.get": () => ({ runtime: {
+			backend: "seed",
+			packageName: "@happy-creative/seed-code",
+			available: true,
+			bundled: true,
+			updateSupported: true,
+			source: "app",
+			version: "1.2.3"
+		} }),
+		"seed.agent.runtime.bundled.update": (params) => ({ runtime: {
+			backend: "seed",
+			packageName: "@happy-creative/seed-code",
+			available: true,
+			bundled: true,
+			updateSupported: true,
+			source: "app",
+			version: typeof params === "object" && params && "version" in params ? String(params.version) : "latest"
+		} }),
+		"seed.agent.runtime.local.status.get": () => ({ status: {
+			backend: "seed",
+			running: false,
+			stale: false,
+			restartRequired: false,
+			processCount: 0,
+			taskCount: 0,
+			conversationIds: [],
+			pids: [],
+			sharedProcessEnabled: true,
+			mcpStartupMode: "eager"
+		} }),
+		"seed.agent.runtime.local.restart": () => ({
+			backend: "seed",
+			restartedTaskCount: 0,
+			releasedProcessCount: 0,
+			conversationIds: []
+		}),
+		"seed.agent.runtime.capabilities.prefetch": (params) => ({ prefetch: {
+			backend: readRequiredString(params, "backend"),
+			status: "success",
+			updatedAt: Date.now()
+		} }),
+		"seed.agent.runtime.local.stale.mark": (params) => ({
+			backend: "seed",
+			stale: true,
+			restartRequired: true,
+			staleReason: readRequiredString(params, "reason"),
+			staleAt: Date.now(),
+			mcpStartupMode: "eager"
+		}),
+		"seed.agent.runtime.custom.test": (params) => ({
+			success: true,
+			step: "acp_initialize",
+			message: `Connection successful for ${readRequiredString(params, "command")}`
+		}),
+		"seed.agent.runtime.slashCommands.list": () => ({ commands: [{
+			name: "help",
+			description: "Display available slash commands",
+			kind: "builtin",
+			source: "builtin",
+			selectionBehavior: "execute"
+		}] }),
+		"seed.agent.runtime.slashCommand.execute": (params) => ({
+			ok: true,
+			message: `Executed /${readRequiredString(params, "name")}`
+		}),
+		"seed.agent.runtime.session.ensure": (params) => ({
+			conversationId: readRequiredString(params, "conversationId"),
+			backend: readRequiredString(params, "backend"),
+			status: "success"
+		}),
+		"seed.agent.runtime.conversation.warmup": (params) => ({
+			conversationId: readRequiredString(params, "conversationId"),
+			status: "success"
+		}),
+		"seed.agent.runtime.openclaw.get": (params) => ({
+			conversationId: readRequiredString(params, "conversationId"),
+			runtime: {}
+		}),
+		"seed.agent.runtime.process.snapshot.get": (params) => ({ snapshot: {
+			conversationId: readRequiredString(params, "conversationId"),
+			processCount: 0,
+			pid: null,
+			running: false,
+			lastExitSignal: null,
+			lastExitCode: null
+		} }),
+		"seed.agent.runtime.process.release": (params) => ({
+			conversationId: readRequiredString(params, "conversationId"),
+			releasedProcessCount: 0
+		}),
+		"seed.agent.subagent.session.snapshot.get": () => ({ record: null }),
+		"seed.agent.subagent.session.load": () => ({ record: null }),
+		"seed.agent.preset.update": (params) => ({
+			ok: true,
+			assistant: {
+				id: readRequiredString(params, "assistantId"),
+				agentId: readRequiredString(params, "assistantId"),
+				name: readRequiredString(params, "assistantId"),
+				source: "preset",
+				kind: "acp",
+				backend: readRequiredString(params, "presetAgentType"),
+				status: "available",
+				isPreset: true,
+				presetAgentType: readRequiredString(params, "presetAgentType")
+			}
+		}),
+		"seed.agent.run": () => ({
+			runId: "mock-run",
+			status: "started"
+		}),
+		"seed.agent.input.submit": (params) => ({
+			conversationId: readRequiredString(params, "conversationId"),
+			mode: readRequiredString(params, "mode"),
+			status: "started",
+			seedEmulated: true,
+			qwenNative: false
+		}),
+		"seed.agent.sideQuestion.ask": (params) => ({
+			status: "ok",
+			answer: `Mock side answer for ${readRequiredString(params, "question")}`
+		}),
+		"seed.agent.approval.check": () => ({ approved: false }),
+		"seed.agent.approval.list": () => [],
+		"seed.agent.approval.respond": () => ({
+			ok: true,
+			eventCount: 0
+		}),
+		"seed.agent.elicitation.respond": () => ({
+			ok: true,
+			eventCount: 0
+		}),
+		"seed.event.subscribe": (params) => ({
+			subscriptionId: "mock-agent-stream-subscription",
+			channel: readAgentStreamChannel(params),
+			events: []
+		}),
+		"seed.event.unsubscribe": () => void 0,
+		"seed.conversation.listByCronJob": () => [],
+		"seed.remotePc.presence.list": () => [],
+		"seed.remotePc.vibe.list": () => [],
+		"seed.remotePc.vibe.events": () => ({
+			messages: [],
+			timedOut: true
+		}),
+		"seed.conversation.archive.import": () => ({
+			success: true,
+			data: {
+				conversationId: "mock-imported-conversation",
+				sourceConversationId: "mock-source-conversation",
+				importedMessages: 0
+			}
+		}),
+		"seed.conversation.searchMessages": () => ({
+			items: [],
+			total: 0,
+			page: 0,
+			pageSize: 20,
+			hasMore: false
+		}),
+		"seed.conversation.artifact.list": (params) => [{
+			id: "mock-artifact",
+			name: `${readRequiredString(params, "conversationId")}-artifact.txt`,
+			kind: "file",
+			sizeBytes: 12,
+			mimeType: "text/plain",
+			previewStatus: "ready",
+			createdAt: "2026-01-01T00:00:00.000Z"
+		}],
+		"seed.conversation.artifact.evidence.list": (params) => [{
+			id: "mock-artifact-evidence",
+			artifactId: readRequiredString(params, "artifactId"),
+			action: "artifact.previewed",
+			message: "Mock artifact evidence",
+			createdAt: "2026-01-01T00:00:00.000Z"
+		}],
+		"seed.conversation.artifact.access.list": (params) => [{
+			id: "mock-artifact-access",
+			artifactId: readRequiredString(params, "artifactId"),
+			userId: "mock-user",
+			role: "viewer",
+			createdAt: "2026-01-01T00:00:00.000Z"
+		}],
+		"seed.conversation.artifact.shareTargets.list": () => [{
+			id: "mock-user",
+			username: "Mock User",
+			role: "member"
+		}],
+		"seed.conversation.artifact.share": (params) => ({
+			id: "mock-artifact-access",
+			artifactId: readRequiredString(params, "artifactId"),
+			userId: readRequiredString(params, "userId"),
+			role: readArtifactShareRole(params),
+			createdAt: "2026-01-01T00:00:00.000Z"
+		}),
+		"seed.conversation.artifact.access.revoke": (params) => ({
+			id: "mock-artifact-access",
+			artifactId: readRequiredString(params, "artifactId"),
+			userId: readRequiredString(params, "userId"),
+			role: "viewer",
+			createdAt: "2026-01-01T00:00:00.000Z"
+		}),
+		"seed.conversation.artifact.materialize": (params) => ({
+			id: "mock-artifact-materialization",
+			artifactId: readRequiredString(params, "artifactId"),
+			workspaceId: readRequiredString(params, "workspaceId"),
+			fileId: "mock-workspace-file",
+			createdAt: "2026-01-01T00:00:00.000Z"
+		}),
+		"seed.conversation.artifact.policy.update": (params) => {
+			readRequiredString(params, "artifactId");
+			assertArtifactPolicyUpdate(params);
+			return {
+				id: readRequiredString(params, "artifactId"),
+				name: "mock-artifact.txt",
+				kind: "file",
+				mimeType: "text/plain",
+				previewStatus: "ready",
+				policy: {
+					retentionStatus: isRecord$1(params) && typeof params.retentionStatus === "string" ? params.retentionStatus : "default",
+					redactionStatus: isRecord$1(params) && typeof params.redactionStatus === "string" ? params.redactionStatus : "none",
+					downloadPolicy: isRecord$1(params) && typeof params.downloadPolicy === "string" ? params.downloadPolicy : "allow"
+				},
+				createdAt: "2026-01-01T00:00:00.000Z"
+			};
+		},
+		"seed.conversation.artifact.scrub.dryRun": (params) => ({
+			artifactId: readRequiredString(params, "artifactId"),
+			scannedBytes: 64,
+			findingCount: 1,
+			findings: [{
+				className: "api-key",
+				count: 1
+			}],
+			wouldRedact: true
+		}),
+		"seed.conversation.artifact.scrub.apply": (params) => ({
+			artifactId: readRequiredString(params, "artifactId"),
+			scannedBytes: 64,
+			findingCount: 1,
+			findings: [{
+				className: "api-key",
+				count: 1
+			}],
+			wouldRedact: true,
+			safeObjectCreated: true,
+			contentAddress: "sha256:mock-safe-object"
+		}),
+		"seed.team.list": () => [],
+		"seed.team.get": (params) => ({
+			id: readTeamId(params),
+			name: "Mock Team",
+			workspaceMode: "shared",
+			teammateSourcePolicy: "all",
+			leaderAgentId: "slot-leader",
+			agents: [],
+			createdAt: "2026-01-01T00:00:00.000Z",
+			updatedAt: "2026-01-01T00:00:00.000Z"
+		}),
+		"seed.team.create": (params) => ({
+			id: "mock-team-created",
+			name: readName(params) ?? "Mock Team",
+			workspaceMode: readWorkspaceMode(params),
+			teammateSourcePolicy: readTeammateSourcePolicy(params),
+			leaderAgentId: "slot-leader",
+			agents: [],
+			workspaceRef: readWorkspace(params),
+			createdAt: "2026-01-01T00:00:00.000Z",
+			updatedAt: "2026-01-01T00:00:00.000Z"
+		}),
+		"seed.team.rename": () => ({ ok: true }),
+		"seed.team.sessionMode.set": () => ({ ok: true }),
+		"seed.team.workspace.update": () => ({ ok: true }),
+		"seed.team.delete": () => ({ ok: true }),
+		"seed.team.agent.add": () => ({
+			slotId: "slot-new",
+			conversationId: "conversation-new",
+			role: "teammate",
+			agentType: "acp",
+			agentName: "Mock Teammate",
+			conversationType: "acp",
+			status: "pending"
+		}),
+		"seed.team.agent.remove": () => ({ ok: true }),
+		"seed.team.agent.rename": () => ({ ok: true }),
+		"seed.team.message.send": () => ({ ok: true }),
+		"seed.team.message.sendToAgent": () => ({ ok: true }),
+		"seed.team.stop": () => ({ ok: true }),
+		"seed.team.session.ensure": () => ({ ok: true }),
+		"seed.team.session.reset": (params) => ({
+			id: readTeamId(params),
+			name: "Mock Team",
+			workspaceMode: "shared",
+			teammateSourcePolicy: "all",
+			leaderAgentId: "slot-leader",
+			agents: [],
+			createdAt: "2026-01-01T00:00:00.000Z",
+			updatedAt: "2026-01-01T00:00:00.000Z"
+		}),
+		"seed.memory.search": () => ({ items: [] }),
+		"seed.resource.read": (params) => ({
+			uri: readResourceUri(params),
+			resolved: {
+				uri: readResourceUri(params),
+				provider: "mock"
+			},
+			content: {
+				kind: "text",
+				text: "",
+				encoding: "utf8"
+			},
+			trace: []
+		}),
+		"seed.resource.stat": (params) => ({
+			uri: readResourceUri(params),
+			kind: "file",
+			name: readResourceUri(params).split("/").filter(Boolean).pop(),
+			downloadable: true
+		}),
+		"seed.resource.list": (params) => ({
+			uri: readResourceUri(params),
+			entries: []
+		}),
+		"seed.resource.open": (params) => ({
+			action: "preview",
+			resolved: {
+				uri: readResourceUri(params),
+				provider: "mock"
+			}
+		}),
+		"seed.resource.openableSchemes": () => ({ schemes: ["workspace-fs"] }),
+		"seed.skill.list": () => [],
+		"seed.skill.autoInjected.list": () => [],
+		"seed.skill.external.detect": () => ({
+			success: true,
+			data: []
+		}),
+		"seed.skill.paths.get": () => ({
+			userSkillsDir: "",
+			builtinSkillsDir: ""
+		}),
+		"seed.skill.externalPath.add": () => ({ success: true }),
+		"seed.skill.importLocal": () => ({
+			success: true,
+			data: { skillName: "mock" }
+		}),
+		"seed.skill.delete": () => ({ success: true }),
+		"seed.skill.exportLocal": () => ({ success: true }),
+		"seed.skill.autoInjected.add": () => ({ success: true }),
+		"seed.skill.autoInjected.remove": () => ({ success: true }),
+		"seed.skill.market.setEnabled": () => ({ success: true }),
+		"seed.assistant.resource.read": () => ({ content: "" }),
+		"seed.assistant.resource.write": () => ({ ok: true }),
+		"seed.assistant.resource.delete": () => ({ ok: true }),
+		"seed.builtin.resource.read": () => ({ content: "" }),
+		"seed.employee.list": () => [],
+		"seed.employee.createFromAssistant": (params) => {
+			const record = typeof params === "object" && params !== null && !Array.isArray(params) ? params : {};
+			const assistant = "assistant" in record && typeof record.assistant === "object" && record.assistant !== null ? record.assistant : {};
+			const assistantId = typeof assistant.id === "string" ? assistant.id : "mock-assistant";
+			const assistantName = typeof assistant.name === "string" ? assistant.name : "Mock Assistant";
+			return {
+				id: "mock-employee",
+				name: "name" in record && typeof record.name === "string" ? record.name : assistantName,
+				roleTitle: "roleTitle" in record && typeof record.roleTitle === "string" ? record.roleTitle : typeof assistant.roleTitle === "string" ? assistant.roleTitle : assistantName,
+				templateSourceKind: "assistant",
+				templateSourceId: assistantId,
+				templateSourceName: assistantName,
+				avatar: "avatar" in record && typeof record.avatar === "string" ? record.avatar : typeof assistant.sourceAvatar === "string" ? assistant.sourceAvatar : void 0,
+				modelId: "modelId" in record && typeof record.modelId === "string" ? record.modelId : typeof assistant.modelId === "string" ? assistant.modelId : void 0,
+				description: "description" in record && typeof record.description === "string" ? record.description : typeof assistant.sourceDescription === "string" ? assistant.sourceDescription : void 0,
+				status: "idle",
+				source: "assistant"
+			};
+		},
+		"seed.employee.createFromRoleTemplate": (params) => {
+			const record = typeof params === "object" && params !== null && !Array.isArray(params) ? params : {};
+			const roleTemplateId = "roleTemplateId" in record && typeof record.roleTemplateId === "string" ? record.roleTemplateId : "mock-role-template";
+			return {
+				id: "mock-employee",
+				name: "name" in record && typeof record.name === "string" ? record.name : "Mock Employee",
+				roleTitle: "roleTitle" in record && typeof record.roleTitle === "string" ? record.roleTitle : "Mock Role",
+				templateSourceKind: "role-template",
+				templateSourceId: roleTemplateId,
+				templateSourceName: roleTemplateId,
+				avatar: "avatar" in record && typeof record.avatar === "string" ? record.avatar : void 0,
+				modelId: "modelId" in record && typeof record.modelId === "string" ? record.modelId : void 0,
+				description: "description" in record && typeof record.description === "string" ? record.description : void 0,
+				status: "idle",
+				source: "role-template"
+			};
+		},
+		"seed.employee.get": (params) => ({
+			employee: {
+				id: readEmployeeId(params),
+				name: "Mock Employee",
+				roleTitle: "Mock Role",
+				status: "idle"
+			},
+			memories: [],
+			activities: []
+		}),
+		"seed.employee.activity.list": (params) => [{
+			id: "mock-employee-activity",
+			employeeId: readEmployeeActivityEmployeeId(params),
+			kind: "task",
+			title: "Mock Activity",
+			description: "Mock employee activity."
+		}],
+		"seed.employee.memory.list": (params) => [{
+			id: "mock-employee-memory",
+			employeeId: readEmployeeMemoryEmployeeId(params),
+			kind: "project",
+			title: "Mock Memory",
+			content: "Remember the mock project.",
+			confidence: 1,
+			pinned: false
+		}],
+		"seed.employee.memory.delete": () => ({ ok: true }),
+		"seed.employee.remove": () => ({ ok: true }),
+		"seed.employee.update": (params) => {
+			const record = typeof params === "object" && params !== null && !Array.isArray(params) ? params : {};
+			const updates = "updates" in record && typeof record.updates === "object" && record.updates !== null ? record.updates : {};
+			return {
+				id: readEmployeeId(params),
+				name: updates.name ?? "Mock Employee",
+				roleTitle: updates.roleTitle ?? "Mock Role",
+				status: updates.status ?? "idle",
+				enabledSkills: updates.enabledSkills,
+				disabledBuiltinSkills: updates.disabledBuiltinSkills
+			};
+		},
+		"seed.employee.memory.events.list": (params) => [{
+			type: "memory.created",
+			employeeId: readEmployeeMemoryEmployeeId(params),
+			memoryId: "mock-employee-memory",
+			data: {
+				id: "mock-employee-memory",
+				employeeId: readEmployeeMemoryEmployeeId(params),
+				kind: "project",
+				title: "Mock Memory",
+				content: "Remember the mock project.",
+				confidence: 1,
+				pinned: false
+			},
+			timestamp: 0
+		}],
+		"seed.employee.openConversation": (params) => {
+			return {
+				id: "mock-employee-conversation",
+				title: "Mock Employee Conversation",
+				status: "running",
+				metadata: { employeeId: readEmployeeIdFromOpenConversation(params) }
+			};
+		},
+		"seed.roleTemplate.list": () => [],
+		"seed.roleTemplate.get": () => null,
+		"seed.roleTemplate.create": () => ({
+			id: "mock-role-template",
+			name: "Mock Role Template"
+		}),
+		"seed.roleTemplate.update": (params) => ({
+			id: readRoleTemplateId(params),
+			name: "Mock Role Template"
+		}),
+		"seed.roleTemplate.delete": () => ({ ok: true }),
+		"seed.roleMaker.session.start": () => ({
+			session: {
+				id: "mock-role-maker-session",
+				conversationId: "mock-role-maker-conversation",
+				status: "drafting"
+			},
+			conversationId: "mock-role-maker-conversation"
+		}),
+		"seed.roleMaker.session.get": (params) => ({ session: {
+			id: readRoleMakerSessionId(params),
+			conversationId: "mock-role-maker-conversation",
+			status: "drafting"
+		} }),
+		"seed.roleMaker.session.generate": (params) => ({ session: {
+			id: readRoleMakerSessionId(params),
+			conversationId: "mock-role-maker-conversation",
+			status: "needs_review",
+			draft: readRoleMakerDraftPayload(params)
+		} }),
+		"seed.roleMaker.session.apply": (params) => ({ session: {
+			id: readRoleMakerSessionId(params),
+			conversationId: "mock-role-maker-conversation",
+			status: "needs_review",
+			draft: readRoleMakerDraftPayload(params)
+		} }),
+		"seed.roleMaker.session.approve": (params) => ({
+			template: {
+				id: "mock-role-template",
+				name: "Mock Role Template"
+			},
+			session: {
+				id: readRoleMakerSessionId(params),
+				conversationId: "mock-role-maker-conversation",
+				status: "approved",
+				roleTemplateId: "mock-role-template"
+			}
+		}),
+		"seed.roleMaker.session.discard": (params) => ({ session: {
+			id: readRoleMakerSessionId(params),
+			conversationId: "mock-role-maker-conversation",
+			status: "discarded"
+		} }),
+		"seed.brainBundle.previewSummaries": (params) => createMockBrainBundlePreviewSummaries(params),
+		"seed.mcp.listTools": () => [],
+		"seed.mcp.callTool": () => ({ content: [] }),
+		"seed.workspace.capabilities.get": () => ({
+			listDir: true,
+			stat: true,
+			readFile: true,
+			readFileBytes: true,
+			writeFile: false,
+			deleteEntry: false,
+			renameEntry: false,
+			search: true
+		}),
+		...options.handlers
+	};
+	return {
+		async request(method, params, requestOptions) {
+			if (closed) throw createSeedAppError({
+				code: "host_unavailable",
+				message: "Mock transport is closed.",
+				requestId: "mock-closed"
+			});
+			const handler = handlers[method];
+			if (!handler) throw createSeedAppError({
+				code: "host_unavailable",
+				message: `No mock handler registered for ${method}.`,
+				requestId: method
+			});
+			const timeoutMs = requestOptions?.timeoutMs;
+			const result = Promise.resolve(handler(params));
+			if (timeoutMs === void 0) return result;
+			return withTimeout(result, timeoutMs, method);
+		},
+		subscribe(handler) {
+			listeners.add(handler);
+			return () => listeners.delete(handler);
+		},
+		async subscribeBridgeEvent(_event, handler) {
+			listeners.add(handler);
+			return () => listeners.delete(handler);
+		},
+		emit(event) {
+			listeners.forEach((listener) => listener(event));
+		},
+		emitAgentStream(event) {
+			listeners.forEach((listener) => listener(event));
+		},
+		close() {
+			closed = true;
+			listeners.clear();
+		}
+	};
+}
+function createMockBrainBundlePreviewSummaries(params) {
+	const conversationId = readConversationId(params);
+	if (isRecord$1(params) && params.format === "rollup") return {
+		schemaVersion: "brain-bundle-preview-summary-rollup.v0",
+		conversationId,
+		total: 0,
+		byStatus: {},
+		byState: {},
+		blockedReasons: {},
+		rawBlobIncluded: false
+	};
+	return {
+		schemaVersion: "brain-bundle-preview-summary-page.v0",
+		conversationId,
+		items: [],
+		rawBlobIncluded: false
+	};
+}
+function readConversationId(params) {
+	if (isRecord$1(params) && typeof params.conversationId === "string" && params.conversationId.length > 0) return params.conversationId;
+	return "mock-conversation";
+}
+function readRequiredString(params, key) {
+	if (!isRecord$1(params) || typeof params[key] !== "string" || !params[key].trim()) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: `Missing ${key}`,
+		requestId: "mock-request"
+	});
+	return params[key].trim();
+}
+function readArtifactShareRole(params) {
+	if (isRecord$1(params) && params.role === "materializer") return "materializer";
+	if (isRecord$1(params) && params.role === "viewer") return "viewer";
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Missing role",
+		requestId: "mock-request"
+	});
+}
+function assertArtifactPolicyUpdate(params) {
+	if (isRecord$1(params) && (params.retentionStatus !== void 0 || params.retentionExpiresAt !== void 0 || params.redactionStatus !== void 0 || params.downloadPolicy !== void 0)) return;
+	throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: "Artifact policy update is empty",
+		requestId: "mock-request"
+	});
+}
+function readRequiredNestedString(params, path) {
+	let current = params;
+	for (const key of path) {
+		if (!isRecord$1(current)) throw createSeedAppError({
+			code: "invalid_payload_schema",
+			message: `Missing ${path.join(".")}`,
+			requestId: "mock-request"
+		});
+		current = current[key];
+	}
+	if (typeof current !== "string" || !current.trim()) throw createSeedAppError({
+		code: "invalid_payload_schema",
+		message: `Missing ${path.join(".")}`,
+		requestId: "mock-request"
+	});
+	return current.trim();
+}
+function readAgentStreamChannel(params) {
+	if (isRecord$1(params) && typeof params.conversationId === "string" && params.conversationId.length > 0) return `conversation:${params.conversationId}`;
+	if (isRecord$1(params) && typeof params.runId === "string" && params.runId.length > 0) return `run:${params.runId}`;
+	return "run:mock-run";
+}
+function readResourceUri(params) {
+	if (isRecord$1(params) && typeof params.uri === "string" && params.uri.length > 0) return params.uri;
+	return "mock://resource";
+}
+function readRoleTemplateId(params) {
+	if (isRecord$1(params) && typeof params.id === "string" && params.id.length > 0) return params.id;
+	return "mock-role-template";
+}
+function readTeamId(params) {
+	if (isRecord$1(params) && typeof params.id === "string" && params.id.length > 0) return params.id;
+	return "mock-team";
+}
+function readName(params) {
+	if (isRecord$1(params) && typeof params.name === "string" && params.name.length > 0) return params.name;
+}
+function readWorkspace(params) {
+	if (isRecord$1(params) && typeof params.workspace === "string" && params.workspace.length > 0) return params.workspace;
+}
+function readWorkspaceMode(params) {
+	if (isRecord$1(params) && typeof params.workspaceMode === "string" && params.workspaceMode.length > 0) return params.workspaceMode;
+	return "shared";
+}
+function readTeammateSourcePolicy(params) {
+	if (isRecord$1(params) && typeof params.teammateSourcePolicy === "string" && params.teammateSourcePolicy.length > 0) return params.teammateSourcePolicy;
+	return "all";
+}
+function readEmployeeId(params) {
+	if (isRecord$1(params) && typeof params.id === "string" && params.id.length > 0) return params.id;
+	return "mock-employee";
+}
+function readEmployeeIdFromOpenConversation(params) {
+	if (isRecord$1(params) && typeof params.employeeId === "string" && params.employeeId.length > 0) return params.employeeId;
+	return "mock-employee";
+}
+function readEmployeeMemoryEmployeeId(params) {
+	if (isRecord$1(params) && typeof params.employeeId === "string" && params.employeeId.length > 0) return params.employeeId;
+	return "mock-employee";
+}
+function readEmployeeActivityEmployeeId(params) {
+	if (isRecord$1(params) && typeof params.employeeId === "string" && params.employeeId.length > 0) return params.employeeId;
+	return "mock-employee";
+}
+function readRoleMakerSessionId(params) {
+	if (isRecord$1(params) && typeof params.sessionId === "string" && params.sessionId.length > 0) return params.sessionId;
+	return "mock-role-maker-session";
+}
+function readRoleMakerDraftPayload(params) {
+	if (isRecord$1(params) && "payload" in params) return params.payload;
+	if (isRecord$1(params) && "currentDraft" in params) return params.currentDraft;
+	if (isRecord$1(params) && typeof params.text === "string") return { text: params.text };
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readRequestedCapabilities(params) {
+	if (!params || typeof params !== "object" || Array.isArray(params)) return [];
+	const capabilities = params.capabilities;
+	if (!Array.isArray(capabilities)) return [];
+	return capabilities.filter((capability) => typeof capability === "string");
+}
+function createMockBridgeDiagnostics(options, params) {
+	const grants = options.grants ?? [];
+	const diagnostics = {
+		appId: options.appId,
+		hostVersion: options.hostVersion ?? "mock-host",
+		runtime: "mock",
+		transport: "mock",
+		grants: {
+			total: grants.length,
+			enabled: grants.filter((grant) => grant.policy === "enabled").length,
+			ask: grants.filter((grant) => grant.policy === "ask").length,
+			disabled: grants.filter((grant) => grant.policy === "disabled").length
+		},
+		methods: DEFAULT_MOCK_METHODS.map((method) => ({
+			method,
+			support: "mock"
+		})),
+		transports: [{
+			id: "mock",
+			supportsStreaming: true,
+			supportsBroadcast: true
+		}],
+		unsupportedMethods: ["seed.calendar.read"],
+		checks: [{
+			id: "mock-transport",
+			status: "ok",
+			message: "Mock host can resolve SDK diagnostics without a live App Studio frame."
+		}, {
+			id: "unsupported-method",
+			status: "blocked",
+			message: "seed.calendar.read is intentionally unsupported by the mock host."
+		}],
+		agentRuntime: {
+			models: [],
+			skills: [],
+			mcp: {
+				servers: [],
+				tools: []
+			}
+		}
+	};
+	if (isRecord$1(params) && params.includeRoutes === true) diagnostics.routes = _seed_app_studio_protocol.seedBridgeMethodRuntimeRoutes.map((route) => ({ ...route }));
+	return diagnostics;
+}
+function withTimeout(input, timeoutMs, method) {
+	if (timeoutMs <= 0) return Promise.reject(createSeedAppError({
+		code: "handshake_timeout",
+		message: "Request timed out.",
+		requestId: method,
+		retryable: true
+	}));
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			reject(createSeedAppError({
+				code: "handshake_timeout",
+				message: "Request timed out.",
+				requestId: method,
+				retryable: true
+			}));
+		}, timeoutMs);
+		input.then((value) => {
+			clearTimeout(timeout);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timeout);
+			reject(error);
+		});
+	});
+}
+//#endregion
+//#region src/windowTransport.ts
+const HOST_THEME_CHANGED_EVENT = "host.theme.changed";
+function createWindowSeedAppTransport(options = {}) {
+	const currentWindow = options.currentWindow ?? globalThis.window;
+	if (!currentWindow) throw createSeedAppError({
+		code: "host_unavailable",
+		message: "Window transport requires a browser window.",
+		requestId: "window-unavailable"
+	});
+	const targetWindow = options.targetWindow ?? currentWindow.parent;
+	const channel = options.channel ?? "seed-app-host";
+	const targetOrigin = options.targetOrigin ?? "*";
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	const pending = /* @__PURE__ */ new Map();
+	const eventHandlers = /* @__PURE__ */ new Set();
+	let nextId = 0;
+	let sessionId;
+	let nonce;
+	const requestHost = (method, params, requestOptions) => {
+		const id = `${options.idPrefix ?? "seed-app"}-${Date.now()}-${nextId}`;
+		nextId += 1;
+		const requestTimeoutMs = requestOptions?.timeoutMs ?? timeoutMs;
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				pending.delete(id);
+				reject(createSeedAppError({
+					code: "handshake_timeout",
+					message: "Seed App Host request timed out.",
+					requestId: id,
+					retryable: true
+				}));
+			}, requestTimeoutMs);
+			pending.set(id, {
+				resolve,
+				reject,
+				timeout
+			});
+			const envelope = {
+				source: "seed-app-sdk",
+				channel,
+				sessionId,
+				nonce,
+				request: {
+					jsonrpc: "2.0",
+					id,
+					method,
+					params
+				}
+			};
+			targetWindow.postMessage(envelope, targetOrigin);
+		});
+	};
+	const handleMessage = (event) => {
+		const envelope = parseHostEnvelope(event.data, channel);
+		if (!envelope) return;
+		if (options.targetOrigin && options.targetOrigin !== "*" && event.origin !== options.targetOrigin) return;
+		if (envelope.sessionId && sessionId && envelope.sessionId !== sessionId) return;
+		if (envelope.nonce && nonce && envelope.nonce !== nonce) return;
+		if (envelope.sessionId) sessionId = envelope.sessionId;
+		if (envelope.nonce) nonce = envelope.nonce;
+		if ("event" in envelope) {
+			eventHandlers.forEach((handler) => handler(envelope.event));
+			return;
+		}
+		settleResponse(envelope.response, pending);
+	};
+	currentWindow.addEventListener("message", handleMessage);
+	return {
+		request: requestHost,
+		subscribe(handler) {
+			eventHandlers.add(handler);
+			return () => eventHandlers.delete(handler);
+		},
+		async subscribeBridgeEvent(event, handler, requestOptions, params) {
+			const scopedHandler = (nextEvent) => {
+				if (matchesSeedAppHostEventSubscription(event, nextEvent)) handler(nextEvent);
+			};
+			eventHandlers.add(scopedHandler);
+			let subscriptionId;
+			try {
+				subscriptionId = readBridgeSubscriptionId(await requestHost("seed.event.subscribe", buildBridgeSubscribeParams(event, params), requestOptions));
+			} catch (error) {
+				eventHandlers.delete(scopedHandler);
+				throw error;
+			}
+			return () => {
+				eventHandlers.delete(scopedHandler);
+				requestHost("seed.event.unsubscribe", buildBridgeUnsubscribeParams(event, subscriptionId), requestOptions).catch(() => void 0);
+			};
+		},
+		close() {
+			currentWindow.removeEventListener("message", handleMessage);
+			pending.forEach((request, id) => {
+				clearTimeout(request.timeout);
+				request.reject(createSeedAppError({
+					code: "host_unavailable",
+					message: "Seed App Host transport closed.",
+					requestId: id
+				}));
+			});
+			pending.clear();
+			eventHandlers.clear();
+		}
+	};
+}
+function buildBridgeSubscribeParams(event, params) {
+	return {
+		...params,
+		type: event
+	};
+}
+function buildBridgeUnsubscribeParams(event, subscriptionId) {
+	return subscriptionId ? {
+		type: event,
+		subscriptionId
+	} : { type: event };
+}
+function readBridgeSubscriptionId(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const subscriptionId = value.subscriptionId;
+	return typeof subscriptionId === "string" && subscriptionId.trim() ? subscriptionId.trim() : void 0;
+}
+function installSeedAppThemeSync(options = {}) {
+	const currentWindow = options.currentWindow ?? (typeof window === "undefined" ? void 0 : window);
+	const targetDocument = options.targetDocument ?? currentWindow?.document ?? (typeof document === "undefined" ? void 0 : document);
+	const targetOrigin = options.targetOrigin;
+	let snapshot;
+	const apply = (appearance) => {
+		snapshot = { ...appearance };
+		applyAppearanceToDocument(snapshot, targetDocument);
+		options.onChange?.(snapshot);
+	};
+	const initialAppearance = options.initialAppearance ?? (currentWindow?.location ? resolveSeedAppAppearanceFromSearch(currentWindow.location.search) : void 0);
+	if (initialAppearance) apply(initialAppearance);
+	const handleMessage = (event) => {
+		if (targetOrigin && targetOrigin !== "*" && event.origin !== targetOrigin) return;
+		const appearance = readHostThemeChangedAppearance(event.data);
+		if (appearance) apply(appearance);
+	};
+	currentWindow?.addEventListener("message", handleMessage);
+	return {
+		apply,
+		getSnapshot: () => snapshot,
+		uninstall() {
+			currentWindow?.removeEventListener("message", handleMessage);
+		}
+	};
+}
+function settleResponse(response, pending) {
+	const request = pending.get(response.id);
+	if (!request) return;
+	pending.delete(response.id);
+	clearTimeout(request.timeout);
+	if (response.error) {
+		request.reject(response.error);
+		return;
+	}
+	request.resolve(response.result);
+}
+function parseHostEnvelope(value, channel) {
+	if (!isRecord(value) || value.source !== "seed-app-host" || value.channel !== channel) return void 0;
+	if (isRecord(value.response) && value.response.jsonrpc === "2.0" && typeof value.response.id === "string") return value;
+	if (isRecord(value.event) && typeof value.event.type === "string") return value;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readHostThemeChangedAppearance(value) {
+	if (!isRecord(value) || value.source !== "seed-app-host") return void 0;
+	if (!isRecord(value.event) || value.event.type !== HOST_THEME_CHANGED_EVENT) return void 0;
+	if (!isRecord(value.event.payload)) return void 0;
+	const theme = value.event.payload.theme;
+	if (theme !== "light" && theme !== "dark") return void 0;
+	const colorScheme = readString(value.event.payload.colorScheme);
+	const fontScale = readNumber(value.event.payload.fontScale);
+	const source = readString(value.event.payload.source);
+	const updatedAt = readNumber(value.event.payload.updatedAt);
+	return {
+		theme,
+		...colorScheme ? { colorScheme } : {},
+		...typeof fontScale === "number" ? { fontScale } : {},
+		...source ? { source } : {},
+		...typeof updatedAt === "number" ? { updatedAt } : {}
+	};
+}
+function applyAppearanceToDocument(appearance, targetDocument) {
+	const root = targetDocument?.documentElement;
+	if (!root) return;
+	root.setAttribute("data-theme", appearance.theme);
+	root.setAttribute("data-seed-theme", appearance.theme);
+	root.style.setProperty("color-scheme", appearance.theme);
+	if (appearance.colorScheme) root.setAttribute("data-color-scheme", appearance.colorScheme);
+	else root.removeAttribute("data-color-scheme");
+	if (typeof appearance.fontScale === "number" && Number.isFinite(appearance.fontScale)) root.style.setProperty("--seed-font-scale", String(appearance.fontScale));
+	else root.style.removeProperty("--seed-font-scale");
+}
+function readString(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function readNumber(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+	return value;
+}
+//#endregion
+Object.defineProperty(exports, "SEED_AGUI_STREAM_EVENT_TYPE", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.SEED_AGUI_STREAM_EVENT_TYPE;
+	}
+});
+exports.SEED_APP_BRIDGE_TARGET_DEFAULT_TIMEOUT_MS = SEED_APP_BRIDGE_TARGET_DEFAULT_TIMEOUT_MS;
+Object.defineProperty(exports, "SeedAppAgentStreamConsumptionGuard", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.SeedAppAgentStreamConsumptionGuard;
+	}
+});
+exports.appendSeedAppAppearanceSearchParams = appendSeedAppAppearanceSearchParams;
+exports.appendSeedAppBridgeTargetSearchParams = appendSeedAppBridgeTargetSearchParams;
+Object.defineProperty(exports, "createSeedAppAgentStreamConsumptionGuard", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.createSeedAppAgentStreamConsumptionGuard;
+	}
+});
+Object.defineProperty(exports, "createSeedAppAgentStreamEvent", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.createSeedAppAgentStreamEvent;
+	}
+});
+exports.createSeedAppClient = createSeedAppClient;
+exports.createSeedAppElectronTransport = createSeedAppElectronTransport;
+exports.createSeedAppEndpointTraceBridge = createSeedAppEndpointTraceBridge;
+exports.createSeedAppEndpointTransport = createSeedAppEndpointTransport;
+exports.createSeedAppError = createSeedAppError;
+exports.createSeedAppMockTransport = createSeedAppMockTransport;
+exports.createSeedAppReactNativeTransport = createSeedAppReactNativeTransport;
+exports.createSeedAppRootTraceContext = createSeedAppRootTraceContext;
+exports.createSeedAppWebSocketTransport = createSeedAppWebSocketTransport;
+exports.createSeedAppWorkspaceClient = createSeedAppWorkspaceClient;
+exports.createSeedBridgeGoldenCaseReport = createSeedBridgeGoldenCaseReport;
+exports.createWindowSeedAppTransport = createWindowSeedAppTransport;
+exports.ensureSeedAppTraceCarrier = ensureSeedAppTraceCarrier;
+exports.extractSeedAppTraceContext = extractSeedAppTraceContext;
+exports.injectSeedAppTraceContext = injectSeedAppTraceContext;
+exports.installSeedAppConsoleBridge = installSeedAppConsoleBridge;
+exports.installSeedAppThemeSync = installSeedAppThemeSync;
+Object.defineProperty(exports, "isSeedAguiEvent", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.isSeedAguiEvent;
+	}
+});
+Object.defineProperty(exports, "isSeedAppAgentStreamEvent", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.isSeedAppAgentStreamEvent;
+	}
+});
+exports.isSeedAppTraceEnabled = isSeedAppTraceEnabled;
+exports.isSeedBridgeGoldenCaseReport = isSeedBridgeGoldenCaseReport;
+Object.defineProperty(exports, "matchesSeedAguiStreamScope", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.matchesSeedAguiStreamScope;
+	}
+});
+Object.defineProperty(exports, "resolveSeedAguiEventIdentity", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.resolveSeedAguiEventIdentity;
+	}
+});
+Object.defineProperty(exports, "resolveSeedAppAgentStreamEventIdentity", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.resolveSeedAppAgentStreamEventIdentity;
+	}
+});
+Object.defineProperty(exports, "resolveSeedAppAgentStreamSemanticKey", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.resolveSeedAppAgentStreamSemanticKey;
+	}
+});
+exports.resolveSeedAppAppearanceFromSearch = resolveSeedAppAppearanceFromSearch;
+exports.resolveSeedAppBridgeTargetFromSearch = resolveSeedAppBridgeTargetFromSearch;
+Object.defineProperty(exports, "seedAppAgentStreamEventTypes", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.seedAppAgentStreamEventTypes;
+	}
+});
+Object.defineProperty(exports, "seedAppAguiStreamEventTypes", {
+	enumerable: true,
+	get: function() {
+		return _seed_app_studio_protocol.seedAppAguiStreamEventTypes;
+	}
+});
+exports.seedAppAppearanceSearchParams = seedAppAppearanceSearchParams;
+exports.seedAppBridgeTargetModes = seedAppBridgeTargetModes;
+exports.seedAppBridgeTargetSearchParams = seedAppBridgeTargetSearchParams;
+exports.seedBridgeGoldenCasePrimaryTransportByRuntime = seedBridgeGoldenCasePrimaryTransportByRuntime;
+exports.seedBridgeGoldenCaseReportSchemaVersion = seedBridgeGoldenCaseReportSchemaVersion;
+exports.validateSeedBridgeGoldenCaseReport = validateSeedBridgeGoldenCaseReport;