@senguoyun/dsh-arkme 0.1.74 → 0.1.75

package/lib/harness-sidebar-client.js

@@ -5,6 +5,2054 @@ window.__ModuleLoader__.load({
 		var exports = module.exports;
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 		let react = require("react");
+		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		//#region src/client/harness-session-origin.ts
+		function sessionOrigin(row) {
+			if (row.local) return [];
+			return [`实例：${row.runtimeName}`, ...row.sameDesktop ? [] : [`电脑：${row.desktopName}`]];
+		}
+		/** Current-version presentation adapter. Native card, title, time, status and copy remain owned by DSH. */
+		function installSessionOriginHover(doc, resolve) {
+			let active;
+			const owned = /* @__PURE__ */ new Set();
+			const clear = () => {
+				for (const node of owned) node.remove();
+				owned.clear();
+			};
+			const update = () => {
+				if (!active?.isConnected) {
+					clear();
+					return;
+				}
+				if (!doc.querySelector("body > div[role=\"button\"][aria-label]")) return;
+				const { lines = [], title } = resolve(active) ?? {};
+				if (!title || !lines.length) {
+					clear();
+					return;
+				}
+				for (const card of doc.querySelectorAll("body > div[role=\"button\"][aria-label]")) {
+					const content = card.firstElementChild, heading = content?.firstElementChild;
+					const time = heading?.nextElementSibling;
+					if (heading?.textContent !== title || !time || time.children.length || !card.getAttribute("aria-label")?.endsWith(`: ${title}`)) continue;
+					let extra = content.querySelector("[data-arkme-session-origin]");
+					if (!extra) {
+						extra = doc.createElement("div");
+						extra.dataset.arkmeSessionOrigin = "";
+						content.append(extra);
+						owned.add(extra);
+					}
+					if (extra.textContent !== lines.join("")) extra.replaceChildren(...lines.map((line) => {
+						const node = doc.createElement("div");
+						node.className = time.className;
+						node.textContent = line;
+						return node;
+					}));
+				}
+				for (const node of owned) if (!node.isConnected) owned.delete(node);
+			};
+			const over = (event) => {
+				const row = event.target?.closest("[data-slot=\"sidebar.workspaces\"] [role=\"treeitem\"][aria-selected]");
+				if (row && row !== active) {
+					clear();
+					active = row;
+					update();
+				}
+			};
+			const observer = new MutationObserver(update);
+			observer.observe(doc.body, {
+				subtree: true,
+				childList: true
+			});
+			doc.addEventListener("pointerover", over, true);
+			return () => {
+				observer.disconnect();
+				doc.removeEventListener("pointerover", over, true);
+				clear();
+			};
+		}
+		//#endregion
+		//#region src/dsh-remote/account-session-observer.ts
+		/** Browser/SDK receive-only invalidation adapter; disposal aborts the subscription. */
+		function observeDshAccountSession(route, fetchImpl, target, changed, options = {}) {
+			const controller = new AbortController();
+			const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+			(async () => {
+				const response = await fetchImpl(route, {
+					method: "POST",
+					credentials: "same-origin",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({
+						operation: "remote.session.observe",
+						params: target
+					}),
+					signal
+				});
+				if (!response.ok || !response.headers.get("content-type")?.includes("application/x-ndjson") || !response.body) throw new Error("远程连接不可用");
+				const reader = response.body.getReader(), decoder = new TextDecoder();
+				let buffer = "";
+				try {
+					while (!signal.aborted) {
+						const { value, done } = await reader.read();
+						if (done) throw new Error("远程连接已断开");
+						buffer += decoder.decode(value, { stream: true });
+						if (buffer.length > 4096) throw new Error("远程通知格式无效");
+						let end;
+						while ((end = buffer.indexOf("\n")) >= 0) {
+							const message = JSON.parse(buffer.slice(0, end));
+							buffer = buffer.slice(end + 1);
+							if (message.error) throw new Error(message.error);
+							if (message.changed && !signal.aborted) changed();
+						}
+					}
+				} finally {
+					await reader.cancel().catch(() => void 0);
+					reader.releaseLock();
+				}
+			})().catch((error) => {
+				if (!signal.aborted) options.onError?.(error);
+			});
+			return () => controller.abort();
+		}
+		//#endregion
+		//#region src/record-owner-id.ts
+		function recordOwnerId(value) {
+			if (typeof value === "number") return Number.isSafeInteger(value) && value > 0 ? value : 0;
+			if (typeof value !== "string" || !/^[1-9]\d*$/.test(value)) return 0;
+			const id = BigInt(value);
+			if (id > 9223372036854775807n) return 0;
+			return id <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(id) : value;
+		}
+		//#endregion
+		//#region src/bot-avatar-ref.ts
+		const ARKME_BOT_AVATAR_REF_PATTERN = /^file_asset:\/\/[A-Za-z0-9_-]{8,128}$/;
+		/** Bot avatars cross process boundaries only as account-scoped file asset references. */
+		function isArkmeBotAvatarRef(value) {
+			return ARKME_BOT_AVATAR_REF_PATTERN.test(value.trim());
+		}
+		//#endregion
+		//#region src/extensions/source.ts
+		function normalizeGitHubRepositoryURL(raw) {
+			const value = raw?.trim() ?? "";
+			if (value === "") return void 0;
+			let parsed;
+			try {
+				parsed = new URL(value);
+			} catch {
+				throw new TypeError("GitHub repository URL is invalid");
+			}
+			const host = parsed.hostname.toLowerCase();
+			if (parsed.protocol !== "https:" || !["github.com", "www.github.com"].includes(host) || parsed.username !== "" || parsed.password !== "" || parsed.port !== "" || parsed.search !== "" || parsed.hash !== "") throw new TypeError("GitHub repository URL is invalid");
+			const parts = parsed.pathname.replace(/\/$/, "").replace(/^\//, "").split("/");
+			if (parts.length !== 2) throw new TypeError("GitHub repository URL must point to a repository root");
+			const owner = parts[0];
+			const repository = parts[1].replace(/\.git$/, "");
+			if (!/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/.test(owner) || !/^[A-Za-z0-9._-]{1,100}$/.test(repository) || repository.endsWith(".")) throw new TypeError("GitHub repository URL is invalid");
+			return `https://github.com/${owner.toLowerCase()}/${repository.toLowerCase()}`;
+		}
+		//#endregion
+		//#region src/sdk/index.ts
+		const DEFAULT_ROUTE = "/arkme-self/api";
+		function expectedUserIdHeaders(expectedUserId) {
+			if (expectedUserId === void 0) return {};
+			if (!Number.isSafeInteger(expectedUserId) || expectedUserId <= 0) throw new TypeError("Arkme expected user ID must be a positive safe integer");
+			return { "X-Arkme-Expected-User-Id": String(expectedUserId) };
+		}
+		function expectedUserIdParam(expectedUserId) {
+			if (expectedUserId === void 0) return {};
+			expectedUserIdHeaders(expectedUserId);
+			return { expectedUserId };
+		}
+		var ArkmeClientError = class extends Error {
+			body;
+			constructor(body) {
+				super(body.message);
+				this.body = body;
+				this.name = "ArkmeClientError";
+			}
+		};
+		function safeSdkCallDetail(detail) {
+			if (detail.videoRecord === void 0) return detail;
+			return {
+				...detail,
+				videoRecord: {
+					available: detail.videoRecord.available,
+					source: detail.videoRecord.source
+				}
+			};
+		}
+		var ArkmeSdk = class {
+			route;
+			fetchImpl;
+			constructor(options = {}) {
+				const route = options.route ?? DEFAULT_ROUTE;
+				if (!/^\/[A-Za-z0-9/_-]+$/.test(route) || route.startsWith("//")) throw new TypeError("Arkme SDK route must be a same-origin absolute path");
+				this.route = route;
+				this.fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+			}
+			async capabilities(signal) {
+				const capabilities = await this.call("provider.capabilities", void 0, signal);
+				if (capabilities.contractVersion !== 1) throw new Error(`Unsupported Arkme provider contract version ${String(capabilities.contractVersion)}`);
+				return capabilities;
+			}
+			async state(signal) {
+				return await this.call("provider.state", void 0, signal);
+			}
+			/** Read the credential-free managed OpenAPI MCP lifecycle projection. */
+			async openApiMcpStatus(signal) {
+				return await this.call("openapi.mcp.status", void 0, signal);
+			}
+			/** Retry a degraded managed MCP connection without exposing or accepting credentials. */
+			async retryOpenApiMcp(signal) {
+				return await this.call("openapi.mcp.retry", void 0, signal);
+			}
+			/** List every Team visible to the current account using opaque OpenAPI references. */
+			async listTeams(options = {}) {
+				return await this.call("team.list", {
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.pageCursor === void 0 ? {} : { pageCursor: options.pageCursor }
+				}, options.signal);
+			}
+			/** Safe directory projection shared with the built-in UI; never an implicit full candidate baseline. */
+			async listDirectory(section, options = {}) {
+				if (![
+					"groups",
+					"bots",
+					"unmarked-speakers",
+					"teams",
+					"contacts"
+				].includes(section)) throw new TypeError("Unknown directory section");
+				if (options.refresh === true && options.cursor !== void 0) throw new TypeError("Refresh must start a new directory page");
+				if ((await this.capabilities(options.signal)).features.contactDirectoryReads !== true) throw new Error("当前 Provider 不支持联系人目录读取");
+				return await this.call("directory.list", {
+					section,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.cursor === void 0 ? {} : { cursor: options.cursor },
+					...options.refresh === void 0 ? {} : { refresh: options.refresh }
+				}, options.signal);
+			}
+			/** Resolve exact Team Jotmo IDs or names only within the current account's Teams. */
+			async resolveTeams(items, signal) {
+				return await this.call("team.resolve", { items }, signal);
+			}
+			/** Read an authorized Team member page without exposing backend numeric identities. */
+			async listTeamMembers(teamRef, options = {}) {
+				return await this.call("team.members.list", {
+					teamRef,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.pageCursor === void 0 ? {} : { pageCursor: options.pageCursor }
+				}, options.signal);
+			}
+			/** Create Teams as an explicit current-human mutation; each item is independently idempotent. */
+			async createTeams(items, signal) {
+				return await this.call("team.create", { items }, signal);
+			}
+			/** Join Teams by exact public Jotmo ID as an explicit current-human mutation. */
+			async joinTeamsByJotmoID(items, signal) {
+				return await this.call("team.join-by-jotmo-id", { items }, signal);
+			}
+			/** Read Browser-safe installed extension projections without Host filesystem paths or runtime IDs. */
+			async installedExtensions(signal) {
+				return await this.call("extensions.installed-list", void 0, signal);
+			}
+			/** Search the market through the same Host owner used by Arkme UI and Tools. */
+			async searchExtensions(query = "", limit = 20, signal) {
+				if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 50) throw new TypeError("Arkme extension search limit must be 1-50");
+				return await this.call("extensions.catalog.list", {
+					query: query.trim(),
+					limit
+				}, signal);
+			}
+			async extensionDetail(extensionId, signal) {
+				if (extensionId.trim() === "") throw new TypeError("Arkme extension ID must not be empty");
+				return await this.call("extensions.catalog.detail", { extensionId: extensionId.trim() }, signal);
+			}
+			/** Query V1/V2/V3 install authority before asking the user to approve installation. */
+			async extensionInstallPreview(extensionId, version, signal) {
+				if (extensionId.trim() === "") throw new TypeError("Arkme extension ID must not be empty");
+				return await this.call("extensions.install.preview", {
+					extensionId: extensionId.trim(),
+					...version === void 0 || version.trim() === "" ? {} : { version: version.trim() }
+				}, signal);
+			}
+			async extensionEnabledState(extensionId, signal) {
+				if (extensionId.trim() === "") throw new TypeError("Arkme extension ID must not be empty");
+				return await this.call("extensions.enabled-state", { extensionId }, signal);
+			}
+			/** Change desired activation without uninstalling the verified extension artifact. */
+			async setExtensionEnabled(extensionId, enabled, signal) {
+				if (extensionId.trim() === "") throw new TypeError("Arkme extension ID must not be empty");
+				return await this.call("extensions.enabled.set", {
+					extensionId,
+					enabled
+				}, signal);
+			}
+			/**
+			* Delete an owned marketplace extension and remove its current local runtime/Profile/source references.
+			* Consumers must call this only from an explicit current human delete action.
+			*/
+			async deleteExtension(extensionId, signal) {
+				const normalized = extensionId.trim();
+				if (normalized === "") throw new TypeError("Arkme extension ID must not be empty");
+				return await this.call("extensions.delete", { extensionId: normalized }, signal);
+			}
+			/** Build the same-origin URL used by every extension list/detail avatar surface. */
+			extensionIconUrl(extensionId, iconRef) {
+				if (extensionId.trim() === "" || !/^icon_v1_[a-f0-9]{64}$/.test(iconRef.trim())) throw new TypeError("Arkme extension icon identity is invalid");
+				return `${this.route}/extension-icon?extension_id=${encodeURIComponent(extensionId.trim())}&icon_ref=${encodeURIComponent(iconRef.trim())}`;
+			}
+			/** Upload or replace an owned extension icon without exposing registry signed transport. */
+			async setExtensionIcon(extensionId, file, options = {}) {
+				const mediaType = file.type.toLowerCase();
+				if (extensionId.trim() === "" || ![
+					"image/png",
+					"image/jpeg",
+					"image/webp"
+				].includes(mediaType)) throw new TypeError("Arkme extension icon must be PNG, JPEG, or WebP");
+				if (file.size <= 0 || file.size > 2 * 1024 * 1024) throw new TypeError("Arkme extension icon must be smaller than 2 MiB");
+				const mutationId = options.clientMutationId ?? crypto.randomUUID();
+				if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(mutationId)) throw new TypeError("Arkme extension icon mutation id must be a UUID");
+				const response = await this.fetchImpl(`${this.route}/extension-icon/upload`, {
+					method: "POST",
+					credentials: "same-origin",
+					headers: {
+						"Content-Type": mediaType,
+						"X-Arkme-Extension-Id": extensionId.trim(),
+						"X-Arkme-Idempotency-Key": mutationId
+					},
+					body: file,
+					...options.signal === void 0 ? {} : { signal: options.signal }
+				});
+				let body;
+				try {
+					body = await response.json();
+				} catch {
+					throw new ArkmeClientError({
+						code: "local-response-invalid",
+						message: "Arkme 插件返回了无效响应",
+						retryable: true
+					});
+				}
+				if (!body.ok) throw new ArkmeClientError(body.error);
+				return body.value;
+			}
+			extensionPreviewUrl(extensionId, previewRef) {
+				if (extensionId.trim() === "" || !/^preview_v1_[a-f0-9]{64}$/.test(previewRef.trim())) throw new TypeError("Arkme extension preview identity is invalid");
+				return `${this.route}/extension-preview?extension_id=${encodeURIComponent(extensionId.trim())}&preview_ref=${encodeURIComponent(previewRef.trim())}`;
+			}
+			async addExtensionPreview(extensionId, file, options = {}) {
+				const mediaType = file.type.toLowerCase();
+				if (extensionId.trim() === "" || ![
+					"image/png",
+					"image/jpeg",
+					"image/webp"
+				].includes(mediaType)) throw new TypeError("Arkme extension preview must be PNG, JPEG, or WebP");
+				if (file.size <= 0 || file.size > 5 * 1024 * 1024) throw new TypeError("Arkme extension preview must be smaller than 5 MiB");
+				const mutationId = options.clientMutationId ?? crypto.randomUUID();
+				if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(mutationId)) throw new TypeError("Arkme extension preview mutation id must be a UUID");
+				const response = await this.fetchImpl(`${this.route}/extension-preview/upload`, {
+					method: "POST",
+					credentials: "same-origin",
+					headers: {
+						"Content-Type": mediaType,
+						"X-Arkme-Extension-Id": extensionId.trim(),
+						"X-Arkme-Idempotency-Key": mutationId
+					},
+					body: file,
+					...options.signal === void 0 ? {} : { signal: options.signal }
+				});
+				let body;
+				try {
+					body = await response.json();
+				} catch {
+					throw new ArkmeClientError({
+						code: "local-response-invalid",
+						message: "Arkme 插件返回了无效响应",
+						retryable: true
+					});
+				}
+				if (!body.ok) throw new ArkmeClientError(body.error);
+				return body.value;
+			}
+			async deleteExtensionPreview(extensionId, previewRef, expectedRevision, signal) {
+				if (extensionId.trim() === "" || !/^preview_v1_[a-f0-9]{64}$/.test(previewRef.trim()) || !Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new TypeError("Arkme extension preview delete parameters are invalid");
+				return await this.call("extensions.preview.delete", {
+					extensionId: extensionId.trim(),
+					previewRef: previewRef.trim(),
+					expectedRevision
+				}, signal);
+			}
+			async reorderExtensionPreviews(extensionId, orderedPreviewRefs, expectedRevision, signal) {
+				const refs = orderedPreviewRefs.map((value) => value.trim());
+				if (extensionId.trim() === "" || refs.length <= 0 || refs.length > 20 || refs.some((value) => !/^preview_v1_[a-f0-9]{64}$/.test(value)) || new Set(refs).size !== refs.length || !Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new TypeError("Arkme extension preview reorder parameters are invalid");
+				return await this.call("extensions.preview.reorder", {
+					extensionId: extensionId.trim(),
+					orderedPreviewRefs: refs,
+					expectedRevision
+				}, signal);
+			}
+			/** Run a user-triggered AI audit for one marketplace extension without installing it. */
+			async auditExtension(extensionId, signal) {
+				if (extensionId.trim() === "") throw new TypeError("Arkme extension ID must not be empty");
+				return await this.call("extensions.audit.check", { extensionId: extensionId.trim() }, signal);
+			}
+			async authStatus(signal) {
+				return await this.call("auth.status", void 0, signal);
+			}
+			/** Read recent call history through Browser-safe opaque call references. */
+			async callHistory(options = {}, signal) {
+				const limit = options.limit === void 0 ? void 0 : Math.trunc(options.limit);
+				if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit <= 0 || limit > 50)) throw new TypeError("Arkme call history limit must be 1-50");
+				const cursor = options.cursor?.trim() ?? "";
+				return await this.call("calls.history.list", {
+					...limit === void 0 ? {} : { limit },
+					...cursor === "" ? {} : { cursor },
+					...options.includeRecentContacts === void 0 ? {} : { includeRecentContacts: options.includeRecentContacts }
+				}, signal);
+			}
+			/** Read one call detail using an unchanged callRef returned by callHistory(). */
+			async callDetail(callRef, signal) {
+				const normalized = callRef.trim();
+				if (normalized === "") throw new TypeError("Arkme call reference must not be empty");
+				return safeSdkCallDetail(await this.call("calls.history.detail", { callRef: normalized }, signal));
+			}
+			/** Retry call summary generation only from an explicit current human action. */
+			async retryCallSummary(callRef, signal) {
+				const normalized = callRef.trim();
+				if (normalized === "") throw new TypeError("Arkme call reference must not be empty");
+				return await this.call("calls.history.summary.retry", { callRef: normalized }, signal);
+			}
+			async profile(options = {}) {
+				return await this.call(options.refresh === true ? "user.profile.refresh" : "user.profile", void 0, options.signal);
+			}
+			/** Employee-only current-state lookup for the user bound to a private-chat source. */
+			async userBanStatus(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme private-chat source reference must not be empty");
+				return await this.call("user-ban.status", { sourceRef }, signal);
+			}
+			async directMessageAdmission(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme private-chat source reference must not be empty");
+				if ((await this.capabilities(signal)).features.directMessageAdmission !== true) throw new ArkmeClientError({
+					code: "CAPABILITY_UNSUPPORTED",
+					message: "当前 Arkme Provider 不支持私聊拒收，请升级",
+					retryable: false
+				});
+				return await this.call("chat.direct-message-admission", { sourceRef }, signal);
+			}
+			async setDirectMessageRefusal(sourceRef, refused, expectedRevision, signal) {
+				if (sourceRef.trim() === "" || typeof refused !== "boolean" || !Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new TypeError("Arkme private-chat refusal input is invalid");
+				if ((await this.capabilities(signal)).features.directMessageAdmission !== true) throw new ArkmeClientError({
+					code: "CAPABILITY_UNSUPPORTED",
+					message: "当前 Arkme Provider 不支持私聊拒收，请升级",
+					retryable: false
+				});
+				return await this.call("chat.direct-message-refusal.set", {
+					sourceRef,
+					refused,
+					expectedRevision
+				}, signal);
+			}
+			/** Employee-only idempotent ban. Callers must obtain explicit human approval first. */
+			async banPrivateChatUser(sourceRef, remark = "", signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme private-chat source reference must not be empty");
+				if (Array.from(remark.trim()).length > 255) throw new TypeError("Arkme user-ban remark must be at most 255 characters");
+				return await this.call("user-ban.ban", {
+					sourceRef,
+					remark: remark.trim()
+				}, signal);
+			}
+			/** Employee-only idempotent unban. Callers must obtain explicit human approval first. */
+			async unbanPrivateChatUser(sourceRef, remark = "", signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme private-chat source reference must not be empty");
+				if (Array.from(remark.trim()).length > 255) throw new TypeError("Arkme user-ban remark must be at most 255 characters");
+				return await this.call("user-ban.unban", {
+					sourceRef,
+					remark: remark.trim()
+				}, signal);
+			}
+			async backgroundSoundPreference(signal) {
+				return await this.call("settings.background-sound.get", {}, signal);
+			}
+			async updateBackgroundSoundPreference(enabled, signal, expectedUserId) {
+				if (typeof enabled !== "boolean") throw new TypeError("Arkme background-sound preference must be boolean");
+				return await this.call("settings.background-sound.update", {
+					enabled,
+					...expectedUserIdParam(expectedUserId)
+				}, signal);
+			}
+			/** Validate a candidate Arkme ID with the same one-time account rule used by the built-in UI. */
+			async checkArkmeIdAvailability(arkmeId, signal) {
+				const normalized = arkmeId.trim();
+				if (normalized === "") throw new TypeError("Arkme ID must not be empty");
+				return await this.call("user.arkme-id.check", { arkmeId: normalized }, signal);
+			}
+			/** Set the current account Arkme ID once after explicit user confirmation. */
+			async setArkmeIdOnce(arkmeId, signal) {
+				const normalized = arkmeId.trim();
+				if (normalized === "") throw new TypeError("Arkme ID must not be empty");
+				return await this.call("user.arkme-id.set", { arkmeId: normalized }, signal);
+			}
+			/** Send a phone verification code for login, first bind, or phone rebind depending on auth state. */
+			async sendPhoneCode(phone, captcha, signal) {
+				const normalized = phone.replace(/[\s-]/g, "");
+				if (!/^1[3-9][0-9]{9}$/.test(normalized)) throw new TypeError("Phone number is invalid");
+				return await this.call("auth.phone.send", {
+					phone: normalized,
+					captcha
+				}, signal);
+			}
+			/** Verify a phone code and refresh the account auth/profile state. */
+			async verifyPhoneCode(phone, code, signal) {
+				const normalized = phone.replace(/[\s-]/g, "");
+				const normalizedCode = code.trim();
+				if (!/^1[3-9][0-9]{9}$/.test(normalized)) throw new TypeError("Phone number is invalid");
+				if (!/^[0-9]{6}$/.test(normalizedCode)) throw new TypeError("Phone verification code is invalid");
+				return await this.call("auth.phone.verify", {
+					phone: normalized,
+					code: normalizedCode
+				}, signal);
+			}
+			/** Search by an exact phone number or Arkme ID without exposing internal account identifiers. */
+			async searchContact(identifier, signal) {
+				const value = identifier.trim();
+				if (value === "" || value.length > 64) throw new TypeError("Arkme contact identifier is invalid");
+				return await this.call("contacts.search", { identifier: value }, signal);
+			}
+			/** Add the exact candidate returned by searchContact and open its idempotent private/pending chat. */
+			async addContact(contactRef, options = {}) {
+				const ref = contactRef.trim();
+				if (!/^arkme-contact-v1\.[0-9a-f-]{36}$/i.test(ref)) throw new TypeError("Arkme contact reference is invalid");
+				const remark = options.remark?.trim() ?? "";
+				if (Array.from(remark).length > 100) throw new TypeError("Arkme contact remark is too long");
+				const requestUid = options.requestUid ?? crypto.randomUUID();
+				if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(requestUid)) throw new TypeError("Arkme contact request id must be a UUID");
+				return await this.call("contacts.add", {
+					contactRef: ref,
+					...remark === "" ? {} : { remark },
+					requestUid
+				}, options.signal);
+			}
+			/** Open a private chat for a registered candidate returned by searchContact without adding it as a contact. */
+			async openPrivateChatFromContact(contactRef, signal) {
+				const ref = contactRef.trim();
+				if (!/^arkme-contact-v1\.[0-9a-f-]{36}$/i.test(ref)) throw new TypeError("Arkme contact reference is invalid");
+				return await this.call("chat.private.open-from-contact", { contactRef: ref }, signal);
+			}
+			/** Create an initially owner-only group chat with an idempotent client mutation id. */
+			async createGroup(title, options = {}) {
+				const normalizedTitle = title.trim();
+				if (normalizedTitle === "" || Array.from(normalizedTitle).length > 80) throw new TypeError("Arkme group title is invalid");
+				const clientMutationId = options.clientMutationId ?? crypto.randomUUID();
+				if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(clientMutationId)) throw new TypeError("Arkme group mutation id must be a UUID");
+				return await this.call("group.create", {
+					title: normalizedTitle,
+					clientMutationId
+				}, options.signal);
+			}
+			async listBots(signal) {
+				return await this.call("bots.list", void 0, signal);
+			}
+			/** Create a Bot without exposing the Host-owned one-time credential to the Consumer. */
+			async createBot(input, signal) {
+				const name = input.name.trim();
+				if (name === "") throw new TypeError("Arkme Bot name must not be empty");
+				if (input.provider !== "openclaw" && input.provider !== "webhook") throw new TypeError("Arkme Bot provider is unsupported");
+				const description = input.description?.trim() ?? "";
+				const avatar = input.avatar?.trim() ?? "";
+				if (avatar !== "" && !isArkmeBotAvatarRef(avatar)) throw new TypeError("Arkme Bot avatar must be a file_asset reference");
+				return await this.call("bots.create", {
+					name,
+					provider: input.provider,
+					...description === "" ? {} : { description },
+					...avatar === "" ? {} : { avatar }
+				}, signal);
+			}
+			/** Browse public marketplace extensions with server-owned query, ordering and cursor semantics. */
+			async extensionCatalog(options = {}) {
+				if (options.ownerUserId !== void 0 && (!Number.isSafeInteger(options.ownerUserId) || options.ownerUserId <= 0)) throw new TypeError("Arkme extension owner user id must be a positive safe integer");
+				return await this.call("extensions.catalog.list", {
+					...options.query === void 0 || options.query.trim() === "" ? {} : { query: options.query.trim() },
+					...options.sort === void 0 ? {} : { sort: options.sort },
+					...options.cursor === void 0 || options.cursor.trim() === "" ? {} : { cursor: options.cursor.trim() },
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.ownerUserId === void 0 ? {} : { ownerUserId: options.ownerUserId },
+					...options.excludeExtensionId === void 0 || options.excludeExtensionId.trim() === "" ? {} : { excludeExtensionId: options.excludeExtensionId.trim() }
+				}, options.signal);
+			}
+			/** Read the AI-generated marketplace category tree. */
+			async extensionCategories(options = {}) {
+				return await this.call("extensions.classification.tree", { ...options.limit === void 0 ? {} : { limit: options.limit } }, options.signal);
+			}
+			/** Browse one AI category while retaining the same server-side ordering contract. */
+			async extensionCategoryItems(categoryId, options = {}) {
+				if (categoryId.trim() === "") throw new TypeError("Arkme extension category id must not be empty");
+				return await this.call("extensions.classification.items", {
+					categoryId: categoryId.trim(),
+					...options.query === void 0 || options.query.trim() === "" ? {} : { query: options.query.trim() },
+					...options.sort === void 0 ? {} : { sort: options.sort },
+					...options.cursor === void 0 || options.cursor.trim() === "" ? {} : { cursor: options.cursor.trim() },
+					...options.limit === void 0 ? {} : { limit: options.limit }
+				}, options.signal);
+			}
+			/** List current-account sources with their Host-derived dynamic-cordis-v2 or profile-native-v3 publication route. */
+			async myExtensions(options = {}) {
+				return await this.call("extensions.mine.list", { ...options.currentSessionId === void 0 || options.currentSessionId.trim() === "" ? {} : { currentSessionId: options.currentSessionId.trim() } }, options.signal);
+			}
+			/** Publish one exact owned source through its Host-derived V2 or V3 route after explicit current-user intent. */
+			publishMyExtension(input, signal) {
+				if (input.ownedRef.trim() === "") throw new TypeError("Arkme extension reference must not be empty");
+				if (input.name.trim() === "" || input.name.trim().length > 120) throw new TypeError("Arkme extension name is invalid");
+				if (input.description.length > 2e3) throw new TypeError("Arkme extension description is too long");
+				if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(input.version.trim())) throw new TypeError("Arkme extension version must be SemVer");
+				if (![
+					"private",
+					"unlisted",
+					"public"
+				].includes(input.visibility)) throw new TypeError("Arkme extension visibility is invalid");
+				if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(input.clientMutationId)) throw new TypeError("Arkme extension client mutation id must be a UUID");
+				let githubRepositoryUrl;
+				try {
+					githubRepositoryUrl = normalizeGitHubRepositoryURL(input.githubRepositoryUrl);
+				} catch {
+					throw new TypeError("Arkme extension GitHub repository URL is invalid");
+				}
+				return this.call("extensions.mine.publish", {
+					ownedRef: input.ownedRef,
+					name: input.name,
+					description: input.description,
+					version: input.version,
+					visibility: input.visibility,
+					...input.changelog === void 0 || input.changelog.trim() === "" ? {} : { changelog: input.changelog },
+					...githubRepositoryUrl === void 0 ? {} : { githubRepositoryUrl },
+					clientMutationId: input.clientMutationId
+				}, signal);
+			}
+			async updateExtensionMetadata(extensionId, input, signal) {
+				const name = input.name.trim();
+				const description = input.description.trim();
+				if (extensionId.trim() === "" || name === "" || [...name].length > 120 || [...description].length > 2e3 || input.visibility !== "private" && input.visibility !== "public") throw new TypeError("Arkme extension metadata or visibility is invalid");
+				if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(input.clientMutationId)) throw new TypeError("Arkme extension metadata mutation id must be a UUID");
+				return await this.call("extensions.metadata.update", {
+					extensionId: extensionId.trim(),
+					name,
+					description,
+					visibility: input.visibility,
+					clientMutationId: input.clientMutationId
+				}, signal);
+			}
+			async rotateExtensionShare(extensionId, clientMutationId, signal) {
+				if (extensionId.trim() === "" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(clientMutationId)) throw new TypeError("Arkme extension share rotation input is invalid");
+				return await this.call("extensions.share.rotate", {
+					extensionId: extensionId.trim(),
+					clientMutationId
+				}, signal);
+			}
+			async extensionShareDetail(shareRef, signal) {
+				const normalized = shareRef.trim();
+				if (!/^extshare_[0-9a-f]{32}$/.test(normalized)) throw new TypeError("Arkme extension share reference is invalid");
+				return await this.call("extensions.share.detail", { shareRef: normalized }, signal);
+			}
+			async extensionShareCatalogDetail(shareRef, signal) {
+				const normalized = shareRef.trim();
+				if (!/^extshare_[0-9a-f]{32}$/.test(normalized)) throw new TypeError("Arkme extension share reference is invalid");
+				return await this.call("extensions.share.resolve", { shareRef: normalized }, signal);
+			}
+			/** Read one current-user Arkme image through the authenticated Provider without exposing a signed OSS URL. */
+			async readImage(imageRef, signal) {
+				if (imageRef.trim() === "") throw new TypeError("Arkme image reference must not be empty");
+				return await this.call("image.read", { imageRef }, signal);
+			}
+			/** Convert a Provider image payload into a browser-renderable data URL. */
+			imageDataUrl(image) {
+				return `data:${image.mediaType};base64,${image.dataBase64}`;
+			}
+			/** Read the public World feed through the authenticated Provider boundary. */
+			async worldFeed(options = {}) {
+				return await this.call("world.feed", {
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.offset === void 0 ? {} : { offset: options.offset }
+				}, options.signal);
+			}
+			/** Read the current account's public World posts through the authenticated Provider boundary. */
+			async myWorldFeed(options = {}) {
+				return await this.call("world.mine", {
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.offset === void 0 ? {} : { offset: options.offset }
+				}, options.signal);
+			}
+			/** Read one user's public World homepage through the authenticated Provider boundary. */
+			async userWorldFeed(userId, options = {}) {
+				if (!Number.isSafeInteger(userId) || userId <= 0) throw new TypeError("Arkme World userId must be a positive integer");
+				return await this.call("world.user", {
+					userId,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.offset === void 0 ? {} : { offset: options.offset }
+				}, options.signal);
+			}
+			/** Open or reuse a private chat with a non-self World author from an unchanged authorRef. */
+			async openWorldAuthorPrivateChat(authorRef, signal) {
+				if (authorRef.trim() === "") throw new TypeError("Arkme World author reference must not be empty");
+				return await this.call("chat.world.private.open", { authorRef }, signal);
+			}
+			/** Open or reuse the same private chat used by the mobile "联系作者" entry. */
+			async openOfficialAuthorPrivateChat(signal) {
+				return await this.call("chat.official-author.private.open", {}, signal);
+			}
+			/** Read the browser-safe public profile for the mobile "联系作者" entry without creating a chat. */
+			async officialAuthorProfile(signal) {
+				return await this.call("chat.official-author.profile", {}, signal);
+			}
+			/** Resolve viewer-local labels for visible World authors without exposing their user IDs. */
+			async worldAuthorLabels(authorRefs, signal) {
+				const normalized = [...new Set(authorRefs.map((value) => value.trim()).filter((value) => value !== ""))];
+				if (normalized.length === 0) return [];
+				return await this.call("world.author-labels", { authorRefs: normalized.slice(0, 20) }, signal);
+			}
+			async worldVoiceprintPlaybackAvailability(recordRefs, signal) {
+				const normalized = [...new Set(recordRefs.map((value) => value.trim()).filter((value) => value !== ""))];
+				if (normalized.length === 0) return { items: [] };
+				return await this.call("world.voiceprint.availability", { recordRefs: normalized.slice(0, 20) }, signal);
+			}
+			async generateWorldVoiceprintPlayback(input, signal) {
+				if (input.recordRef.trim() === "") throw new TypeError("Arkme World record reference must not be empty");
+				return await this.call("world.voiceprint.playback.generate", {
+					recordRef: input.recordRef,
+					...input.chunkIndex === void 0 ? {} : { chunkIndex: input.chunkIndex }
+				}, signal);
+			}
+			async inviteWorldVoiceprint(recordRef, signal) {
+				if (recordRef.trim() === "") throw new TypeError("Arkme World record reference must not be empty");
+				return await this.call("world.voiceprint.invite", { recordRef }, signal);
+			}
+			async worldVoiceprintSocialContext(recordRef, options = {}) {
+				if (recordRef.trim() === "") throw new TypeError("Arkme World record reference must not be empty");
+				return await this.call("world.voiceprint.social-context", {
+					recordRef,
+					...options.forceRefresh === void 0 ? {} : { forceRefresh: options.forceRefresh }
+				}, options.signal);
+			}
+			/** Read comments and replies for one Provider-issued World record reference. */
+			async worldInteractions(recordRef, options = {}) {
+				if (recordRef.trim() === "") throw new TypeError("Arkme World record reference must not be empty");
+				return await this.call("world.interactions.list", {
+					recordRef,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.offset === void 0 ? {} : { offset: options.offset }
+				}, options.signal);
+			}
+			/** Publish a text comment or reply using a caller-stable mutation id. */
+			async createWorldTextInteraction(input, signal) {
+				if (input.targetRef.trim() === "" || input.textContent.trim() === "" || input.clientMutationId.trim() === "") throw new TypeError("Arkme World interaction target, text, and mutation id must not be empty");
+				return await this.call("world.interactions.create-text", {
+					targetRef: input.targetRef,
+					textContent: input.textContent,
+					clientMutationId: input.clientMutationId
+				}, signal);
+			}
+			async publishWorldText(input, signal) {
+				if (input.clientMutationId.trim() === "" || input.textContent.trim() === "") throw new TypeError("Arkme World publish text and mutation id must not be empty");
+				return await this.call("world.publish-text", {
+					clientMutationId: input.clientMutationId,
+					textContent: input.textContent
+				}, signal);
+			}
+			async publishWorldFileAssets(input, signal) {
+				if (input.clientMutationId.trim() === "" || input.textContent.trim() === "" || input.fileAssets.length === 0) throw new TypeError("Arkme World publish text, mutation id, and file assets must not be empty");
+				return await this.call("world.publish-file-assets", {
+					clientMutationId: input.clientMutationId,
+					textContent: input.textContent,
+					fileAssets: input.fileAssets
+				}, signal);
+			}
+			/** Resolve one Provider-issued World image ref without exposing its signed source URL. */
+			async readWorldImage(imageRef, signal) {
+				if (imageRef.trim() === "") throw new TypeError("Arkme World image reference must not be empty");
+				return await this.call("world.image.read", { imageRef }, signal);
+			}
+			/** Read the current account's Arrangement owner projection. */
+			async arrangements(options = {}) {
+				return await this.call("arrangements.list", {
+					...options.status === void 0 ? {} : { status: options.status },
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.offset === void 0 ? {} : { offset: options.offset }
+				}, options.signal);
+			}
+			/** Read public reviews and rating summary for one extension. */
+			async extensionReviews(extensionId, options = {}) {
+				if (extensionId.trim() === "") throw new TypeError("Arkme extension id must not be empty");
+				return await this.call("extensions.reviews.list", {
+					extensionId,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.offset === void 0 ? {} : { offset: options.offset }
+				}, options.signal);
+			}
+			/** Read one Arrangement through a Provider-issued, account-bound reference. */
+			async arrangementDetail(arrangementRef, signal) {
+				if (arrangementRef.trim() === "") throw new TypeError("Arrangement reference must not be empty");
+				return await this.call("arrangements.detail", { arrangementRef }, signal);
+			}
+			async arrangementReminders(options = {}) {
+				return await this.call("arrangements.reminders.list", {
+					...options.unreadOnly === void 0 ? {} : { unreadOnly: options.unreadOnly },
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.offset === void 0 ? {} : { offset: options.offset }
+				}, options.signal);
+			}
+			async arrangementReminderSummary(signal) {
+				return await this.call("arrangements.reminders.summary", void 0, signal);
+			}
+			async mutateArrangement(arrangementRef, intent, signal) {
+				const normalizedRef = arrangementRef.trim();
+				if (normalizedRef === "") throw new TypeError("Arrangement reference must not be empty");
+				if (![
+					"start-follow",
+					"cancel-follow",
+					"complete",
+					"cancel-complete",
+					"delete"
+				].includes(intent)) throw new TypeError("Arrangement mutation intent is invalid");
+				return await this.call("arrangements.mutate", {
+					arrangementRef: normalizedRef,
+					intent
+				}, signal);
+			}
+			async setArrangementReminderEnabled(arrangementRef, enabled, signal) {
+				const normalizedRef = arrangementRef.trim();
+				if (normalizedRef === "") throw new TypeError("Arrangement reference must not be empty");
+				return await this.call("arrangements.reminder-enabled", {
+					arrangementRef: normalizedRef,
+					enabled
+				}, signal);
+			}
+			async markArrangementRemindersRead(eventRefs, signal) {
+				const normalizedRefs = eventRefs.map((eventRef) => eventRef.trim());
+				if (normalizedRefs.length === 0 || normalizedRefs.some((eventRef) => eventRef === "")) throw new TypeError("Reminder references must not be empty");
+				if (new Set(normalizedRefs).size !== normalizedRefs.length) throw new TypeError("Reminder references must be unique");
+				if (normalizedRefs.length > 50) throw new TypeError("At most 50 reminder references are allowed");
+				return await this.call("arrangements.reminders.mark-read", { eventRefs: normalizedRefs }, signal);
+			}
+			async markAllArrangementRemindersRead(signal) {
+				return await this.call("arrangements.reminders.mark-all-read", void 0, signal);
+			}
+			async clearArrangementReminders(signal) {
+				return await this.call("arrangements.reminders.clear", void 0, signal);
+			}
+			/** Create a top-level review or reply through the account-bound Host owner. */
+			async createExtensionReview(input, signal) {
+				if (input.extensionId.trim() === "" || input.textContent.trim() === "" || input.clientMutationId.trim() === "") throw new TypeError("Arkme extension review id, text, and mutation id must not be empty");
+				return await this.call("extensions.reviews.create", {
+					extensionId: input.extensionId,
+					textContent: input.textContent,
+					...input.rating === void 0 ? {} : { rating: input.rating },
+					...input.parentReviewRef === void 0 ? {} : { parentReviewRef: input.parentReviewRef },
+					clientMutationId: input.clientMutationId
+				}, signal);
+			}
+			async listSources(directory, options = {}) {
+				if (options.localFirst === true && (await this.capabilities(options.signal)).features.localFirstDirectory !== true) throw new Error("当前 Provider 不支持本地会话目录");
+				return await this.call("sources.list", {
+					directory,
+					...options.localFirst === void 0 ? {} : { localFirst: options.localFirst },
+					...options.refresh === void 0 ? {} : { refresh: options.refresh },
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.cursor === void 0 ? {} : { cursor: options.cursor }
+				}, options.signal);
+			}
+			async setBotDirectoryPin(botRef, pinned, signal) {
+				if ((await this.capabilities(signal)).features.localFirstDirectory !== true) throw new Error("当前 Provider 不支持本地会话目录");
+				await this.call("conversation.directory.bot-pin", {
+					botRef,
+					pinned
+				}, signal);
+			}
+			/** Read or explicitly set the existing topic home preference. */
+			async topicHomeVisibility(sourceRef, showInHome, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme topic source reference must not be empty");
+				return await this.call("topic.home-visibility", {
+					sourceRef,
+					...showInHome === void 0 ? {} : { showInHome }
+				}, signal);
+			}
+			async listGroupMembers(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme group source reference must not be empty");
+				return await this.call("group.members", {
+					sourceRef,
+					activeOnly: true
+				}, signal);
+			}
+			async groupAiPolishSettings(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme group source reference must not be empty");
+				return await this.call("source.ai-polish.settings", { sourceRef }, signal);
+			}
+			async generateGroupAiPolishRule(sourceRef, requirement, options = {}) {
+				if (sourceRef.trim() === "" || requirement.trim() === "") throw new TypeError("Arkme group source reference and polish requirement must not be empty");
+				return await this.call("source.ai-polish.generate-rule", {
+					sourceRef,
+					requirement,
+					...options.threadMessages === void 0 ? {} : { threadMessages: options.threadMessages },
+					...options.targetRuleRef === void 0 || options.targetRuleRef.trim() === "" ? {} : { targetRuleRef: options.targetRuleRef.trim() }
+				}, options.signal);
+			}
+			async prepareEnableGroupAiPolishRule(sourceRef, ruleRef, signal) {
+				if (sourceRef.trim() === "" || ruleRef.trim() === "") throw new TypeError("Arkme group source and AI polish rule references must not be empty");
+				return await this.call("source.ai-polish.prepare-enable", {
+					sourceRef,
+					ruleRef
+				}, signal);
+			}
+			async confirmEnableGroupAiPolish(confirmationRef, signal) {
+				if (confirmationRef.trim() === "") throw new TypeError("Arkme AI polish confirmation reference must not be empty");
+				return await this.call("source.ai-polish.confirm-enable", { confirmationRef }, signal);
+			}
+			async prepareDisableGroupAiPolish(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme group source reference must not be empty");
+				return await this.call("source.ai-polish.prepare-disable", { sourceRef }, signal);
+			}
+			async confirmDisableGroupAiPolish(confirmationRef, signal) {
+				if (confirmationRef.trim() === "") throw new TypeError("Arkme AI polish confirmation reference must not be empty");
+				return await this.call("source.ai-polish.confirm-disable", { confirmationRef }, signal);
+			}
+			async cachedSourceMembers(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme source reference must not be empty");
+				return await this.call("source.members.cached", { sourceRef }, signal);
+			}
+			async pageSourceMembers(sourceRef, options = {}) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme source reference must not be empty");
+				if (options.limit !== void 0 && (!Number.isSafeInteger(options.limit) || options.limit < 1 || options.limit > 100)) throw new TypeError("Arkme member page limit must be 1-100");
+				return await this.call("source.members.page", {
+					sourceRef,
+					...options.cursor === void 0 ? {} : { cursor: options.cursor },
+					...options.limit === void 0 ? {} : { limit: options.limit }
+				}, options.signal);
+			}
+			async sourceMembersPresentation(sourceRef, memberRefs, signal) {
+				if (!sourceRef.trim() || memberRefs.length < 1 || memberRefs.length > 50 || memberRefs.some((ref) => !ref.trim())) throw new TypeError("Arkme member presentation needs 1-50 member references");
+				return await this.call("source.members.presentation", {
+					sourceRef,
+					memberRefs: [...memberRefs]
+				}, signal);
+			}
+			async listSourceMembers(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme chat source reference must not be empty");
+				return await this.call("source.members", {
+					sourceRef,
+					activeOnly: true
+				}, signal);
+			}
+			async sourceMemberRecords(sourceRef, memberRef, mode, options = {}) {
+				if (sourceRef.trim() === "" || memberRef.trim() === "" || !["owner", "mentioned"].includes(mode)) throw new TypeError("Arkme source, member reference, and member-record mode must be valid");
+				return await this.call("source.member-records", {
+					sourceRef,
+					memberRef,
+					mode,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.beforeSequence === void 0 ? {} : { beforeSequence: options.beforeSequence }
+				}, options.signal);
+			}
+			async listGroupMemberCandidates(sourceRef, options = {}) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme group source reference must not be empty");
+				return await this.call("group.member-candidates", {
+					sourceRef,
+					...options.query === void 0 ? {} : { query: options.query },
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.groupSourceRefs === void 0 ? {} : { groupSourceRefs: options.groupSourceRefs.map((value) => value.trim()).filter((value) => value !== "") }
+				}, options.signal);
+			}
+			async groupInvitePreview(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme group source reference must not be empty");
+				return await this.call("group.invite-preview", { sourceRef }, signal);
+			}
+			async addGroupMembers(sourceRef, candidateRefs, signal) {
+				const refs = candidateRefs.map((value) => value.trim());
+				if (sourceRef.trim() === "" || refs.length === 0 || refs.some((value) => value === "")) throw new TypeError("Arkme group source and candidate references must not be empty");
+				return await this.call("group.members.add", {
+					sourceRef,
+					candidateRefs: refs
+				}, signal);
+			}
+			async groupSelfNickname(sourceRef, signal) {
+				if ((await this.capabilities(signal)).features.groupSelfNickname !== true) throw new Error("当前 Provider 不支持群昵称");
+				return await this.call("group.self-nickname", { sourceRef: sourceRef.trim() }, signal);
+			}
+			async setGroupSelfNickname(sourceRef, nickname, signal) {
+				if ((await this.capabilities(signal)).features.groupSelfNickname !== true) throw new Error("当前 Provider 不支持群昵称");
+				return await this.call("group.self-nickname.set", {
+					sourceRef: sourceRef.trim(),
+					nickname
+				}, signal);
+			}
+			async removeGroupMember(sourceRef, memberRef, options = {}) {
+				if (sourceRef.trim() === "" || memberRef.trim() === "") throw new TypeError("Arkme group source and member references must not be empty");
+				return await this.call("group.member-remove", {
+					sourceRef: sourceRef.trim(),
+					memberRef: memberRef.trim(),
+					preventRejoin: options.preventRejoin === true
+				}, options.signal);
+			}
+			async listGroupJoinRestrictions(sourceRef, options = {}) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme group source reference must not be empty");
+				return await this.call("group.join-restrictions", {
+					sourceRef: sourceRef.trim(),
+					...options.cursor === void 0 ? {} : { cursor: options.cursor.trim() },
+					...options.limit === void 0 ? {} : { limit: options.limit }
+				}, options.signal);
+			}
+			async setGroupJoinRestriction(sourceRef, memberRef, restricted, signal) {
+				if (sourceRef.trim() === "" || memberRef.trim() === "" || typeof restricted !== "boolean") throw new TypeError("Arkme group source, member reference, and restriction are required");
+				return await this.call("group.join-restriction.set", {
+					sourceRef: sourceRef.trim(),
+					memberRef: memberRef.trim(),
+					restricted
+				}, signal);
+			}
+			async listGroupBots(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme group source reference must not be empty");
+				return await this.call("group.bots", { sourceRef }, signal);
+			}
+			async addGroupBot(sourceRef, botRef, signal) {
+				if (sourceRef.trim() === "" || botRef.trim() === "") throw new TypeError("Arkme group source and Bot references must not be empty");
+				return await this.call("group.bot.add", {
+					sourceRef,
+					botRef
+				}, signal);
+			}
+			async readSource(sourceRef, options = {}) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme source reference must not be empty");
+				return await this.call("source.timeline", {
+					sourceRef,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.cursor === void 0 ? {} : { cursor: options.cursor }
+				}, options.signal);
+			}
+			async readSourceAround(sourceRef, itemUid, recordOwnerUserId, options = {}) {
+				if (sourceRef.trim() === "" || itemUid.trim() === "" || recordOwnerId(recordOwnerUserId) === 0) throw new TypeError("Arkme timeline around requires a source, record uid, and record owner");
+				return await this.call("source.timeline-around", {
+					sourceRef,
+					itemUid,
+					recordOwnerUserId,
+					...options.beforeLimit === void 0 ? {} : { beforeLimit: options.beforeLimit },
+					...options.afterLimit === void 0 ? {} : { afterLimit: options.afterLimit }
+				}, options.signal);
+			}
+			async messageReadReceiptSummaries(sourceRef, items, signal) {
+				const normalizedSourceRef = sourceRef.trim();
+				if (normalizedSourceRef === "" || items.length < 1 || items.length > 50) throw new TypeError(`Arkme message read receipts require one source and 1-${String(50)} messages`);
+				const seen = /* @__PURE__ */ new Set();
+				const normalizedItems = items.map((item) => {
+					const itemUid = item.itemUid.trim();
+					const sequence = Math.trunc(item.sequence);
+					const key = `${itemUid}\u0000${String(sequence)}`;
+					if (itemUid === "" || !Number.isSafeInteger(item.sequence) || sequence <= 0 || seen.has(key)) throw new TypeError("Arkme message read receipt item identity is invalid or duplicated");
+					seen.add(key);
+					return {
+						itemUid,
+						sequence
+					};
+				});
+				return await this.call("source.read-receipts.summary-list", {
+					sourceRef: normalizedSourceRef,
+					items: normalizedItems
+				}, signal);
+			}
+			async messageReadReceiptDetail(sourceRef, itemUid, sequence, signal, options = {}) {
+				const normalizedSourceRef = sourceRef.trim();
+				const normalizedItemUid = itemUid.trim();
+				if (normalizedSourceRef === "" || normalizedItemUid === "" || !Number.isSafeInteger(sequence) || sequence <= 0) throw new TypeError("Arkme group message read receipt identity is invalid");
+				return await this.call("source.read-receipts.detail", {
+					sourceRef: normalizedSourceRef,
+					itemUid: normalizedItemUid,
+					sequence,
+					...options.basicOnly === void 0 ? {} : { basicOnly: options.basicOnly }
+				}, signal);
+			}
+			async sendText(sourceRef, textContent, options = {}) {
+				if (sourceRef.trim() === "" || textContent.trim() === "") throw new TypeError("Arkme source reference and text must not be empty");
+				return await this.call("source.send-text", {
+					sourceRef,
+					textContent,
+					recordUid: options.recordUid ?? crypto.randomUUID(),
+					relationUid: options.relationUid ?? crypto.randomUUID(),
+					...options.agentAuthored === true ? { agentAuthored: true } : {},
+					...options.humanMentions === void 0 ? {} : { humanMentions: options.humanMentions },
+					...options.botMentions === void 0 ? {} : { botMentions: options.botMentions },
+					...options.botRefs === void 0 ? {} : { botRefs: options.botRefs },
+					...expectedUserIdParam(options.expectedUserId)
+				}, options.signal);
+			}
+			async copyMessageLink(sourceRef, actionRefs, signal) {
+				const refs = actionRefs.map((value) => value.trim()).filter((value) => value !== "");
+				if (sourceRef.trim() === "" || refs.length === 0 || refs.length > 100 || new Set(refs).size !== refs.length) throw new TypeError("Arkme message link action references must be 1-100 unique values");
+				return await this.call("source.message-copy-link", {
+					sourceRef,
+					actionRefs: refs
+				}, signal);
+			}
+			async reportMessage(messageRef, reportType, options = {}) {
+				const normalizedMessageRef = messageRef.trim();
+				const reason = options.reason?.trim() ?? "";
+				if (normalizedMessageRef === "" || normalizedMessageRef.length > 4096) throw new TypeError("Arkme message reference must not be empty or exceed 4096 characters");
+				if (![
+					1,
+					2,
+					3,
+					4
+				].includes(reportType) || reportType === 4 && reason === "" || [...reason].length > 500) throw new TypeError("Arkme message report type or reason is invalid");
+				const requestUid = (options.requestUid ?? crypto.randomUUID()).trim().toLowerCase();
+				if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(requestUid)) throw new TypeError("Arkme message report request UID is invalid");
+				return await this.call("source.message-report", {
+					messageRef: normalizedMessageRef,
+					reportType,
+					...reason === "" ? {} : { reason },
+					requestUid
+				}, options.signal);
+			}
+			async withdrawGroupMessage(messageWithdrawalRef, signal) {
+				const normalized = messageWithdrawalRef.trim();
+				if (normalized === "" || normalized.length > 4096) throw new TypeError("Arkme message withdrawal reference must not be empty or exceed 4096 characters");
+				return await this.call("source.message-withdraw", { messageWithdrawalRef: normalized }, signal);
+			}
+			async resolveMessageCopyLink(sid, signal) {
+				const normalizedSid = sid.trim();
+				if (!/^[0-9A-Za-z]{16}$/.test(normalizedSid)) throw new TypeError("Arkme message copy-link sid must be 16 alphanumeric characters");
+				return await this.call("source.message-copy-link.resolve", { sid: normalizedSid }, signal);
+			}
+			async extendMessageCopyLink(sid, textContent, options = {}) {
+				const normalizedSid = sid.trim();
+				const text = textContent.trim();
+				const itemIndex = Math.trunc(options.itemIndex ?? 0);
+				if (!/^[0-9A-Za-z]{16}$/.test(normalizedSid)) throw new TypeError("Arkme message copy-link sid must be 16 alphanumeric characters");
+				if (text === "") throw new TypeError("Arkme message copy-link extension text must not be empty");
+				if (itemIndex < 0 || itemIndex >= 100) throw new TypeError("Arkme message copy-link item index must be 0-99");
+				return await this.call("source.message-copy-link.extend", {
+					sid: normalizedSid,
+					itemIndex,
+					textContent: text,
+					recordUid: options.recordUid ?? crypto.randomUUID()
+				}, options.signal);
+			}
+			async sourceMessageExtensionContext(sourceRef, messageActionRef, signal) {
+				if (sourceRef.trim() === "" || messageActionRef.trim() === "") throw new TypeError("Arkme source message extension requires a source and action reference");
+				return await this.call("source.message-extension.context", {
+					sourceRef,
+					messageActionRef
+				}, signal);
+			}
+			async extendSourceMessage(sourceRef, messageActionRef, textContent, options = {}) {
+				const fileRefs = [...new Set((options.fileRefs ?? []).map((value) => value.trim()).filter((value) => value !== ""))];
+				if (sourceRef.trim() === "" || messageActionRef.trim() === "" || textContent.trim() === "" && fileRefs.length === 0) throw new TypeError("Arkme source message extension requires a target and text or attachments");
+				if (fileRefs.length > 9) throw new TypeError("Arkme source message extension accepts at most 9 attachments");
+				return await this.call("source.message-extension.extend", {
+					sourceRef,
+					messageActionRef,
+					textContent,
+					recordUid: options.recordUid ?? crypto.randomUUID(),
+					relationUid: options.relationUid ?? crypto.randomUUID(),
+					...options.parentRecordUid?.trim() ? { parentRecordUid: options.parentRecordUid.trim() } : {},
+					fileRefs
+				}, options.signal);
+			}
+			async resolveLinkMetadata(url, signal) {
+				const normalizedUrl = url.trim();
+				if (normalizedUrl === "" || normalizedUrl.length > 2048) throw new TypeError("Arkme link metadata URL must not be empty");
+				return await this.call("source.link-metadata.resolve", { url: normalizedUrl }, signal);
+			}
+			async forwardMessages(sourceRef, actionRefs, options = {}) {
+				const refs = actionRefs.map((value) => value.trim()).filter((value) => value !== "");
+				if (sourceRef.trim() === "" || refs.length === 0 || refs.length > 100 || new Set(refs).size !== refs.length) throw new TypeError("Arkme forward action references must be 1-100 unique values");
+				return await this.call("source.forward-messages", {
+					sourceRef,
+					...options.targetSourceRef === void 0 || options.targetSourceRef.trim() === "" ? {} : { targetSourceRef: options.targetSourceRef.trim() },
+					actionRefs: refs,
+					recordUid: options.recordUid ?? crypto.randomUUID(),
+					relationUid: options.relationUid ?? crypto.randomUUID(),
+					...options.commentText === void 0 || options.commentText.trim() === "" ? {} : { commentText: options.commentText.trim() }
+				}, options.signal);
+			}
+			async relatedRecordingEligibility(sourceRef, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme private-chat source reference must not be empty");
+				return await this.call("related-recordings.eligibility", { sourceRef }, signal);
+			}
+			async relatedRecordings(sourceRef, options = {}) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme private-chat source reference must not be empty");
+				return await this.call("related-recordings.page", {
+					sourceRef,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.cursor === void 0 ? {} : { cursor: options.cursor },
+					...options.monthKey === void 0 ? {} : { monthKey: options.monthKey },
+					...options.timezoneOffsetMillis === void 0 ? {} : { timezoneOffsetMillis: options.timezoneOffsetMillis },
+					...options.includeTimeIndex === void 0 ? {} : { includeTimeIndex: options.includeTimeIndex }
+				}, options.signal);
+			}
+			async sendRich(sourceRef, input, options = {}) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme source reference must not be empty");
+				return await this.call("source.send-rich", {
+					sourceRef,
+					...input,
+					recordUid: options.recordUid ?? crypto.randomUUID(),
+					relationUid: options.relationUid ?? crypto.randomUUID(),
+					...expectedUserIdParam(options.expectedUserId)
+				}, options.signal);
+			}
+			async favoriteStickers(signal) {
+				return await this.call("favorite-stickers.list", void 0, signal);
+			}
+			async addFavoriteSticker(item, signal) {
+				if (item.fileAssetUid.trim() === "") throw new TypeError("Arkme favorite sticker asset must not be empty");
+				return await this.call("favorite-stickers.add", { item }, signal);
+			}
+			async sendFavoriteSticker(sourceRef, fileAssetUid, options = {}) {
+				if (sourceRef.trim() === "" || fileAssetUid.trim() === "") throw new TypeError("Arkme sticker destination and asset must not be empty");
+				return await this.call("favorite-stickers.send", {
+					sourceRef,
+					fileAssetUid,
+					recordUid: options.recordUid ?? crypto.randomUUID(),
+					relationUid: options.relationUid ?? crypto.randomUUID()
+				}, options.signal);
+			}
+			async manageFavoriteSticker(fileAssetUid, action, signal) {
+				if (fileAssetUid.trim() === "") throw new TypeError("Arkme favorite sticker asset must not be empty");
+				return await this.call("favorite-stickers.manage", {
+					fileAssetUid,
+					action
+				}, signal);
+			}
+			async longArticleDetail(sourceRef, itemUid, signal) {
+				if (sourceRef.trim() === "" || itemUid.trim() === "") throw new TypeError("Arkme source and article references must not be empty");
+				return await this.call("source.long-article.detail", {
+					sourceRef,
+					itemUid
+				}, signal);
+			}
+			async publishLongArticle(sourceRef, input, signal) {
+				return await this.call("source.long-article.publish", {
+					sourceRef,
+					...input
+				}, signal);
+			}
+			async updateLongArticle(sourceRef, itemUid, input, signal) {
+				if (sourceRef.trim() === "" || itemUid.trim() === "") throw new TypeError("Arkme source and article references must not be empty");
+				return await this.call("source.long-article.update", {
+					sourceRef,
+					itemUid,
+					...input
+				}, signal);
+			}
+			async longArticleDraft(sourceRef, itemUid, signal) {
+				return await this.call("source.long-article.draft.get", {
+					sourceRef,
+					...itemUid === void 0 ? {} : { itemUid }
+				}, signal);
+			}
+			async saveLongArticleDraft(draft, signal) {
+				if (draft.sourceRef.trim() === "") throw new TypeError("Arkme source reference must not be empty");
+				await this.call("source.long-article.draft.put", draft, signal);
+			}
+			async deleteLongArticleDraft(sourceRef, itemUid, signal) {
+				if (sourceRef.trim() === "") throw new TypeError("Arkme source reference must not be empty");
+				await this.call("source.long-article.draft.delete", {
+					sourceRef,
+					...itemUid === void 0 ? {} : { itemUid }
+				}, signal);
+			}
+			async fileCapabilities(signal) {
+				const policy = await this.call("files.capabilities", void 0, signal);
+				if (policy.version !== 1) throw new Error(`Unsupported Arkme file contract version ${String(policy.version)}`);
+				return policy;
+			}
+			async searchFiles(options = {}) {
+				const { signal, ...params } = options;
+				return this.call("files.search", params, signal);
+			}
+			async localFiles(signal) {
+				return this.call("files.local.list", void 0, signal);
+			}
+			async openLocalFileFolder(fileRef, signal) {
+				return this.call("files.local.open-folder", { fileRef }, signal);
+			}
+			async openLocalFile(fileRef, signal) {
+				return this.call("files.local.open", { fileRef }, signal);
+			}
+			async removeLocalFile(fileRef) {
+				return this.call("files.local.remove", { fileRef });
+			}
+			async sendFiles(input) {
+				return this.call("files.send", {
+					...input.content,
+					...input
+				});
+			}
+			async fileSendTasks(sourceRef, signal) {
+				return this.call("files.send.tasks", sourceRef === void 0 ? {} : { sourceRef }, signal);
+			}
+			async retryFileSend(taskRef) {
+				return this.call("files.send.retry", { taskRef });
+			}
+			async discardFileSend(taskRef) {
+				return this.call("files.send.discard", { taskRef });
+			}
+			async reconcileFileSend(taskRef) {
+				return this.call("files.send.reconcile", { taskRef });
+			}
+			async stageFileBytes(contentBase64, metadata) {
+				return this.call("files.stage-bytes", {
+					contentBase64,
+					...metadata
+				});
+			}
+			async receiveFile(mediaRef, start = false, signal) {
+				return this.call("files.receive", {
+					mediaRef,
+					start
+				}, signal);
+			}
+			subscribeFileSends(sourceRef, listener, options = {}) {
+				const controller = new AbortController();
+				let timer;
+				const poll = async () => {
+					try {
+						const tasks = await this.fileSendTasks(sourceRef, controller.signal);
+						if (!controller.signal.aborted) listener(tasks);
+					} catch (error) {
+						if (!controller.signal.aborted) options.onError?.(error);
+					} finally {
+						if (!controller.signal.aborted) timer = setTimeout(() => {
+							poll();
+						}, Math.max(250, options.intervalMs ?? 750));
+					}
+				};
+				if (options.immediate !== false) poll();
+				else timer = setTimeout(() => {
+					poll();
+				}, Math.max(250, options.intervalMs ?? 750));
+				return () => {
+					controller.abort();
+					if (timer !== void 0) clearTimeout(timer);
+				};
+			}
+			localFileUrl(fileRef, download = false) {
+				if (!/^arkme-file-v1\.[0-9a-f-]{36}$/.test(fileRef)) throw new TypeError("Invalid local file reference");
+				return `${this.route}/files/local?ref=${encodeURIComponent(fileRef)}${download ? "&download=1" : ""}`;
+			}
+			/** Stage locally. Reference-managed files require a Host-persisted draft or task to retain them beyond seven days. */
+			async stageLongArticleImage(file, options = {}) {
+				const payload = await (await this.fetchImpl(`${this.route}/files/long-article-stage`, {
+					method: "POST",
+					headers: {
+						"Content-Type": file.type || "application/octet-stream",
+						"X-Arkme-File-Name": encodeURIComponent(options.fileName ?? file.name ?? "image"),
+						...expectedUserIdHeaders(options.expectedUserId)
+					},
+					body: file,
+					...options.signal === void 0 ? {} : { signal: options.signal }
+				})).json();
+				if (!payload.ok) throw new ArkmeClientError(payload.error);
+				return payload.value;
+			}
+			async stageFile(file, options = {}) {
+				const payload = await (await this.fetchImpl(`${this.route}/files/stage`, {
+					method: "POST",
+					headers: {
+						"Content-Type": file.type || "application/octet-stream",
+						"X-Arkme-File-Name": encodeURIComponent(options.fileName ?? file.name ?? "attachment"),
+						...expectedUserIdHeaders(options.expectedUserId),
+						...options.retention ? { "X-Arkme-File-Retention": options.retention } : {}
+					},
+					body: file,
+					...options.signal === void 0 ? {} : { signal: options.signal }
+				})).json();
+				if (!payload.ok) throw new ArkmeClientError(payload.error);
+				return payload.value;
+			}
+			async upload(file, options = {}) {
+				const fileName = (options.fileName ?? file.name ?? "attachment").trim();
+				const payload = await (await this.fetchImpl(`${this.route}/upload`, {
+					method: "POST",
+					headers: {
+						"Content-Type": file.type || "application/octet-stream",
+						"X-Arkme-File-Name": encodeURIComponent(fileName),
+						...expectedUserIdHeaders(options.expectedUserId)
+					},
+					body: file,
+					...options.signal === void 0 ? {} : { signal: options.signal }
+				})).json();
+				if (!payload.ok) throw new ArkmeClientError(payload.error);
+				return payload.value;
+			}
+			mediaUrl(mediaRef) {
+				if (mediaRef.trim() === "") throw new TypeError("Arkme media reference must not be empty");
+				return `${this.route}/media?ref=${encodeURIComponent(mediaRef)}`;
+			}
+			async snapshot(options = {}) {
+				return await this.call(options.refresh === true ? "records.refresh" : "records.cache", void 0, options.signal);
+			}
+			async calendarBuckets(options) {
+				return await this.call("calendar.buckets", {
+					startDate: options.startDate,
+					endDate: options.endDate,
+					...options.sourceRef === void 0 ? {} : { sourceRef: options.sourceRef },
+					...options.timezone === void 0 ? {} : { timezone: options.timezone }
+				}, options.signal);
+			}
+			async calendarRecords(options) {
+				return await this.call("calendar.records", {
+					bucketDate: options.bucketDate,
+					...options.sourceRef === void 0 ? {} : { sourceRef: options.sourceRef },
+					...options.oldestFirst === void 0 ? {} : { oldestFirst: options.oldestFirst },
+					...options.timezone === void 0 ? {} : { timezone: options.timezone },
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.cursor === void 0 ? {} : { cursor: options.cursor }
+				}, options.signal);
+			}
+			/** Read a device-location fact using a short-lived capability from the personal calendar. */
+			async calendarRecordLocation(locationRef, signal) {
+				return await this.call("calendar.record-location", { locationRef }, signal);
+			}
+			/** Service-owned daily chat counts and exact first-message anchors, shared with Flutter. */
+			async calendarChatStatistics(options) {
+				const { signal, ...params } = options;
+				return await this.call("calendar.chat-statistics", params, signal);
+			}
+			/** Search one viewer-owned conversation directory page by remark or nickname. */
+			async searchConversationNames(query, options = {}) {
+				const { signal, ...params } = options;
+				return await this.call("search.conversations", {
+					query,
+					...params
+				}, signal);
+			}
+			/** Search current-account server records, including retained DSH navigation identity. */
+			async searchRemote(query, options = {}) {
+				const { signal, ...params } = options;
+				if ((await this.capabilities(signal)).features.remoteRecordSearch !== true) throw new Error("当前 Provider 不支持远端快记搜索");
+				return await this.call("search.records", {
+					query,
+					...params
+				}, signal);
+			}
+			async search(query, options = {}) {
+				return await this.call("records.search", {
+					query,
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.beforeMillis === void 0 ? {} : { beforeMillis: options.beforeMillis },
+					...options.syncAll === void 0 ? {} : { syncAll: options.syncAll }
+				}, options.signal);
+			}
+			/** List the signed-in user's image library without exposing storage URLs. */
+			async images(options = {}) {
+				return await this.call("images.list", {
+					...options.limit === void 0 ? {} : { limit: options.limit },
+					...options.cursor?.trim() ? { cursor: options.cursor.trim() } : {}
+				}, options.signal);
+			}
+			async createText(textContent, options = {}) {
+				return await this.call("records.create", {
+					recordUid: options.recordUid ?? crypto.randomUUID(),
+					textContent
+				}, options.signal);
+			}
+			async tags(options = {}) {
+				return await this.call("records.tags.list", {
+					limit: options.limit ?? 100,
+					...options.query === void 0 ? {} : { query: options.query },
+					...options.cursor === void 0 ? {} : { cursor: options.cursor }
+				}, options.signal);
+			}
+			async tagRecords(normalizedTag, options = {}) {
+				return await this.call("records.tags.query", {
+					normalizedTag,
+					limit: options.limit ?? 50,
+					...options.cursorSendAt === void 0 ? {} : { cursorSendAt: options.cursorSendAt },
+					...options.cursorRecordUid?.trim() ? { cursorRecordUid: options.cursorRecordUid.trim() } : {}
+				}, options.signal);
+			}
+			async outbox(signal) {
+				return await this.call("records.outbox", void 0, signal);
+			}
+			async retry(recordUid, signal) {
+				return await this.call("records.retry", { recordUid }, signal);
+			}
+			subscribe(listener, options = {}) {
+				const intervalMs = Math.min(6e4, Math.max(500, Math.trunc(options.intervalMs ?? 1e3)));
+				let stopped = false;
+				let timeout;
+				let previousKey = "";
+				const poll = async () => {
+					if (stopped) return;
+					try {
+						const state = await this.state();
+						if (stopped) return;
+						const key = `${state.authStatus}:${String(state.userId ?? "")}:${String(state.revision)}`;
+						if (key !== previousKey) {
+							previousKey = key;
+							listener(state);
+						}
+					} catch (error) {
+						options.onError?.(error);
+					} finally {
+						if (!stopped) timeout = setTimeout(() => {
+							poll();
+						}, intervalMs);
+					}
+				};
+				if (options.immediate === false) timeout = setTimeout(() => {
+					poll();
+				}, intervalMs);
+				else poll();
+				return () => {
+					stopped = true;
+					if (timeout !== void 0) clearTimeout(timeout);
+				};
+			}
+			async listDshAccountSessions(options = {}, signal) {
+				const result = await this.call("remote.sessions.list", options, signal);
+				if (result.contractVersion !== 1) throw new Error("账号会话协议版本不受支持");
+				return result;
+			}
+			async readDshAccountSession(options, signal) {
+				return await this.call("remote.session.read", options, signal);
+			}
+			async commandDshAccountSession(options, signal) {
+				return await this.call("remote.session.command", options, signal);
+			}
+			/** Event-driven invalidation only. Abort or dispose closes the Host subscription. */
+			observeDshAccountSession(target, changed, options = {}) {
+				return observeDshAccountSession(this.route, this.fetchImpl, target, changed, options);
+			}
+			/** Account-authorized native DSH carrier. Callers retain native RPC result semantics. */
+			async nativeDshRequest(options, signal) {
+				return await this.call("remote.session.native", options, signal);
+			}
+			async currentDesktopSession(signal) {
+				return await this.call("remote.currentSession", void 0, signal);
+			}
+			async remoteStatus(signal) {
+				return await this.call("remote.getStatus", void 0, signal);
+			}
+			async renameRemoteDesktop(displayName, signal) {
+				const normalized = displayName.trim();
+				if (normalized === "" || [...normalized].length > 80) throw new TypeError("Remote desktop name must contain 1 to 80 characters");
+				return await this.call("remote.renameDesktop", { displayName: normalized }, signal);
+			}
+			subscribeRemote(listener, options = {}) {
+				const intervalMs = Math.min(6e4, Math.max(1e3, Math.trunc(options.intervalMs ?? 2e3)));
+				let stopped = false;
+				let timer;
+				let revision = -1;
+				const poll = async () => {
+					if (stopped) return;
+					try {
+						const status = await this.remoteStatus();
+						if (!stopped && status.revision !== revision) {
+							revision = status.revision;
+							listener(status);
+						}
+					} catch (error) {
+						options.onError?.(error);
+					} finally {
+						if (!stopped) timer = setTimeout(() => {
+							poll();
+						}, intervalMs);
+					}
+				};
+				if (options.immediate === false) timer = setTimeout(() => {
+					poll();
+				}, intervalMs);
+				else poll();
+				return () => {
+					stopped = true;
+					if (timer !== void 0) clearTimeout(timer);
+				};
+			}
+			async call(operation, params, signal) {
+				const response = await this.fetchImpl(this.route, {
+					method: "POST",
+					credentials: "same-origin",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({
+						operation,
+						...params === void 0 ? {} : { params }
+					}),
+					...signal === void 0 ? {} : { signal }
+				});
+				let body;
+				try {
+					body = await response.json();
+				} catch {
+					throw new ArkmeClientError({
+						code: "local-response-invalid",
+						message: "Arkme 插件返回了无效响应",
+						retryable: true
+					});
+				}
+				if (!body.ok) throw new ArkmeClientError(body.error);
+				return body.value;
+			}
+		};
+		function createArkmeSdk(options) {
+			return new ArkmeSdk(options);
+		}
+		const defaultSdk = createArkmeSdk();
+		async function callArkme(operation, params, signal) {
+			return await defaultSdk.call(operation, params, signal);
+		}
+		//#endregion
+		//#region src/client/harness-native-navigation.ts
+		const HARNESS_NATIVE_OPEN = "arkme:native-session-open";
+		/** The parent retains native documents; a selection never navigates or reloads them. */
+		async function openNativeAccountSession(session, localRuntimeRef) {
+			const surface = window.frameElement?.parentElement;
+			if (!surface) throw new Error("DSH 对话容器尚未就绪");
+			const doc = surface.ownerDocument;
+			const runtimeRef = session.runtimeRef === localRuntimeRef ? "" : session.runtimeRef;
+			doc.dispatchEvent(new doc.defaultView.CustomEvent(HARNESS_NATIVE_OPEN, { detail: {
+				runtimeRef,
+				sessionRef: session.sessionRef,
+				accountId: surface.getAttribute("data-arkme-account-id") ?? "",
+				accountScope: surface.getAttribute("data-arkme-account-scope") ?? ""
+			} }));
+		}
+		//#endregion
+		//#region src/client/harness-session-menu-bridge.ts
+		const HARNESS_LOCAL_SESSION_OPEN = "arkme:harness-local-session-open";
+		/** Private presentation bridge between Arkme and its existing same-origin Harness frame. */
+		const HARNESS_MENU_OPEN = "arkme:harness-menu-open";
+		const HARNESS_MENU_CLOSE = "arkme:harness-menu-close";
+		const HARNESS_MENU_POSITION = "arkme:harness-menu-position";
+		//#endregion
+		//#region src/client/harness-account-sessions.tsx
+		const SLOT$1 = "sidebar.workspaces";
+		const FLOW = "sidebar.workspaces.directoryFlow";
+		const OWN_FLOW = "arkme.accountSessions.directoryFlow";
+		const accountSessionKey = (row) => `arkme:${encodeURIComponent(row.runtimeRef)}:${encodeURIComponent(row.sessionRef)}`;
+		/** The native updated mode promotes newly discovered rows, even old remote
+		* history. Project its display orders by actual activity time, not arrival. */
+		function projectAccountSessionOrder(view, sessions) {
+			if (view.orderBy !== "updated") return view;
+			return {
+				...view,
+				sessionOrderByAccount: Object.fromEntries(Object.entries(view.sessionOrderByAccount).map(([key, ids]) => [key, [...ids].sort((a, b) => {
+					const aTime = sessions.byId[a]?.updatedAt ?? -Infinity;
+					const bTime = sessions.byId[b]?.updatedAt ?? -Infinity;
+					return aTime === bTime ? a < b ? -1 : a > b ? 1 : 0 : bTime - aTime;
+				})]))
+			};
+		}
+		/** Local rows keep native identity, blank/activity state and all native actions. */
+		function projectAccountSessions(local, rows, selected) {
+			const byId = { ...local.byId }, ids = [...local.ids];
+			for (const row of selected && !rows.some((row) => accountSessionKey(row) === accountSessionKey(selected)) ? [...rows, selected] : rows) {
+				if (row.archived || row.origin === "subagent") continue;
+				const id = row.local ? row.sessionRef : accountSessionKey(row);
+				if (byId[id]) continue;
+				if (!row.local && window.__ARKME_NATIVE_DIRECTORY__) continue;
+				byId[id] = {
+					id,
+					title: row.title,
+					displayTitle: row.title,
+					updatedAt: row.updatedAt,
+					running: row.running,
+					blank: row.blank
+				};
+				ids.push(id);
+			}
+			return {
+				...local,
+				byId,
+				ids: [...new Set(ids)],
+				current: selected ? accountSessionKey(selected) : local.current
+			};
+		}
+		function projectAccountWorkspaces(local, rows) {
+			const groups = /* @__PURE__ */ new Map();
+			const names = /* @__PURE__ */ new Map();
+			for (const row of rows) {
+				if (!row.workspaceRef || row.archived) continue;
+				const id = `${row.runtimeRef}:${row.workspaceRef}`;
+				const owners = names.get(row.workspaceName) ?? /* @__PURE__ */ new Set();
+				owners.add(id);
+				names.set(row.workspaceName, owners);
+				const workspaceId = row.local ? row.workspaceRef : `arkme:${id}`;
+				const group = groups.get(id) ?? {
+					workspaceId,
+					title: row.workspaceName,
+					path: row.workspaceName,
+					sessionIds: []
+				};
+				group.sessionIds.push(row.local ? row.sessionRef : accountSessionKey(row));
+				groups.set(id, group);
+			}
+			const items = [...local.items.map((item) => {
+				const row = rows.find((row) => row.local && row.workspaceRef === item.workspaceId);
+				const extra = [...groups.values()].find((group) => group.workspaceId === item.workspaceId);
+				const merged = extra ? {
+					...item,
+					sessionIds: [.../* @__PURE__ */ new Set([...item.sessionIds, ...extra.sessionIds])]
+				} : item;
+				return row && (names.get(row.workspaceName)?.size ?? 0) > 1 ? {
+					...merged,
+					title: `${row.desktopName} · ${item.title}`
+				} : merged;
+			}), ...[...groups.values()].filter((group) => !local.items.some((item) => item.workspaceId === group.workspaceId))].map((item) => {
+				if (!item.workspaceId.startsWith("arkme:")) return item;
+				const row = rows.find((row) => `arkme:${row.runtimeRef}:${row.workspaceRef}` === item.workspaceId);
+				return (names.get(row.workspaceName)?.size ?? 0) > 1 ? {
+					...item,
+					title: `${row.desktopName} · ${item.title}`
+				} : item;
+			});
+			return {
+				...local,
+				items
+			};
+		}
+		const catalogKey = Symbol.for("arkme.account-session-catalog");
+		/** Apply a complete authoritative catalog as add/update/delete; unchanged rows retain identity. */
+		function reconcileAccountSessions(previous, incoming) {
+			const known = new Map(previous.map((row) => [accountSessionKey(row), row]));
+			const next = [...new Map(incoming.map((row) => [accountSessionKey(row), row])).values()].map((row) => {
+				const old = known.get(accountSessionKey(row));
+				return old && Object.keys(row).every((key) => key === "capabilities" ? row.capabilities.join("\0") === old.capabilities.join("\0") : row[key] === old[key]) ? old : row;
+			});
+			return next.length === previous.length && next.every((row, i) => row === previous[i]) ? previous : next;
+		}
+		function createCatalog(surface, remove) {
+			const owner = surface.ownerDocument;
+			let rows = [], localRuntimeRef, users = 0;
+			let snapshot = {
+				rows,
+				localRuntimeRef
+			}, active = true, busy = false;
+			const listeners = /* @__PURE__ */ new Set();
+			let controller = new AbortController();
+			let stopRefresh;
+			const publish = () => {
+				snapshot = {
+					rows,
+					localRuntimeRef
+				};
+				listeners.forEach((listener) => listener());
+			};
+			const refresh = async () => {
+				if (!active || busy || owner.hidden) return;
+				busy = true;
+				const signal = controller.signal;
+				try {
+					const next = [], seen = /* @__PURE__ */ new Set();
+					let cursor;
+					do {
+						const page = await callArkme("remote.sessions.list", {
+							limit: 100,
+							...cursor ? { cursor } : {}
+						}, signal);
+						if (page.contractVersion !== 1 || !Array.isArray(page.items)) throw new Error("会话目录不可用");
+						localRuntimeRef = page.localRuntimeRef;
+						next.push(...page.items.map((row) => {
+							const previous = rows.find((old) => accountSessionKey(old) === accountSessionKey(row));
+							return page.warning && previous && row.workspaceName === "工作区信息暂不可用" ? {
+								...row,
+								workspaceName: previous.workspaceName
+							} : row;
+						}));
+						cursor = page.nextCursor;
+						if (cursor) {
+							const key = JSON.stringify(cursor);
+							if (seen.has(key)) throw new Error("会话目录游标重复");
+							seen.add(key);
+						}
+						if (next.length > 1e4) throw new Error("会话目录过大");
+					} while (cursor && active);
+					if (!active || signal.aborted) return;
+					const merged = reconcileAccountSessions(rows, next);
+					if (merged !== rows || snapshot.localRuntimeRef !== localRuntimeRef) {
+						rows = merged;
+						window.__ARKME_NATIVE_DIRECTORY__?.publish(rows);
+						publish();
+					}
+				} catch {} finally {
+					if (signal === controller.signal) busy = false;
+				}
+			};
+			return {
+				get signal() {
+					return controller.signal;
+				},
+				start: () => {
+					if (users++ !== 0) return;
+					active = true;
+					busy = false;
+					controller = new AbortController();
+					const resume = () => {
+						if (surface.getAttribute("data-arkme-visible") !== "false") refresh();
+					};
+					const timer = setInterval(resume, 5e3);
+					const observer = new MutationObserver(resume);
+					observer.observe(surface, {
+						attributes: true,
+						attributeFilter: ["data-arkme-visible"]
+					});
+					document.addEventListener(HARNESS_MENU_OPEN, resume);
+					owner.addEventListener("visibilitychange", resume);
+					owner.defaultView?.addEventListener("focus", resume);
+					stopRefresh = () => {
+						clearInterval(timer);
+						observer.disconnect();
+						document.removeEventListener(HARNESS_MENU_OPEN, resume);
+						owner.removeEventListener("visibilitychange", resume);
+						owner.defaultView?.removeEventListener("focus", resume);
+					};
+				},
+				getSnapshot: () => snapshot,
+				subscribe: (listener) => {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				},
+				refresh,
+				dispose: () => {
+					if (--users === 0) {
+						active = false;
+						controller.abort();
+						stopRefresh?.();
+						remove();
+					}
+				}
+			};
+		}
+		function accountSessionCatalog(surface) {
+			const doc = surface.ownerDocument;
+			const catalogs = doc[catalogKey] ??= /* @__PURE__ */ new Map();
+			const account = `${surface.getAttribute("data-arkme-account-id")}:${surface.getAttribute("data-arkme-account-scope")}`;
+			let entry = catalogs.get(account);
+			if (!entry) {
+				entry = createCatalog(surface, () => catalogs.delete(account));
+				catalogs.set(account, entry);
+			}
+			return entry;
+		}
+		/** All native sources share one account-scoped catalog. */
+		function AccountSessionBrowser({ Native, surface, ...props }) {
+			const account = (0, react.useSyncExternalStore)((listener) => {
+				const observer = new MutationObserver(listener);
+				observer.observe(surface, {
+					attributes: true,
+					attributeFilter: ["data-arkme-account-id", "data-arkme-account-scope"]
+				});
+				return () => observer.disconnect();
+			}, () => `${surface.getAttribute("data-arkme-account-id")}:${surface.getAttribute("data-arkme-account-scope")}`);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AccountBrowser, {
+				Native,
+				surface,
+				...props
+			}, account);
+		}
+		function AccountBrowser({ Native, surface, ...props }) {
+			const sourceRuntime = null;
+			const creating = (0, react.useRef)(false);
+			const [operationError, setOperationError] = (0, react.useState)("");
+			const local = props.useSessions((state) => state);
+			const workspaces = props.useWorkspaces((state) => state);
+			const catalog = (0, react.useMemo)(() => accountSessionCatalog(surface), []);
+			const snapshot = (0, react.useSyncExternalStore)(catalog.subscribe, catalog.getSnapshot);
+			const rows = (0, react.useMemo)(() => snapshot.rows, [snapshot.rows, sourceRuntime]);
+			(0, react.useEffect)(() => {
+				catalog.start();
+				catalog.refresh();
+				return () => catalog.dispose();
+			}, [catalog]);
+			(0, react.useEffect)(() => {
+				catalog.refresh();
+			}, [local.current, catalog]);
+			const sessionState = (0, react.useMemo)(() => projectAccountSessions(local, rows), [local, rows]);
+			const workspaceState = (0, react.useMemo)(() => projectAccountWorkspaces(workspaces, rows), [workspaces, rows]);
+			const view = props.useStore((state) => state);
+			const viewState = (0, react.useMemo)(() => projectAccountSessionOrder(view, sessionState), [view, sessionState]);
+			const originResolver = (0, react.useRef)(() => void 0);
+			originResolver.current = (element) => {
+				const tree = element.closest("[role=\"tree\"]");
+				if (!tree) return void 0;
+				let candidates = sessionState.ids.filter((id) => {
+					const row = sessionState.byId[id];
+					return row && row.origin !== "subagent" && !workspaceState.archivedSessionIds.includes(id) && (!row.blank || id === sessionState.current);
+				});
+				let orderKey = "__flat_session_order__";
+				if (viewState.groupBy === "workspace") {
+					const heading = (element.parentElement?.parentElement)?.querySelector("[role=\"treeitem\"][aria-expanded]");
+					const title = heading?.textContent;
+					const workspace = workspaceState.items.filter((item) => item.title === title)[[...tree.querySelectorAll("[role=\"treeitem\"][aria-expanded]")].filter((node) => node.textContent === title).indexOf(heading)];
+					orderKey = workspace?.workspaceId ?? "";
+					candidates = candidates.filter((id) => workspace ? workspace.sessionIds.includes(id) : !workspaceState.items.some((item) => item.sessionIds.includes(id)));
+				}
+				const stored = viewState.sessionOrderByAccount[orderKey] ?? [];
+				const ordered = [...stored.filter((id) => candidates.includes(id)), ...candidates.filter((id) => !stored.includes(id)).sort((a, b) => sessionState.byId[b].updatedAt - sessionState.byId[a].updatedAt || (a < b ? -1 : a > b ? 1 : 0))];
+				const index = [...element.parentElement.parentElement.querySelectorAll(":scope > span > [role=\"treeitem\"][aria-selected]")].indexOf(element);
+				const matches = ordered.filter((id) => [...element.children].some((node) => node.textContent === sessionState.byId[id]?.displayTitle));
+				const id = matches.includes(ordered[index]) ? ordered[index] : matches.length === 1 ? matches[0] : void 0;
+				if (!id) return void 0;
+				const native = sessionState.byId[id];
+				if (!native || ![...element.children].some((node) => node.textContent === native.displayTitle)) return void 0;
+				const row = snapshot.rows.find((row) => (row.runtimeRef === snapshot.localRuntimeRef ? row.sessionRef : accountSessionKey(row)) === id);
+				return row ? {
+					title: native.displayTitle,
+					lines: sessionOrigin(row)
+				} : void 0;
+			};
+			(0, react.useEffect)(() => installSessionOriginHover(document, (element) => originResolver.current(element)), []);
+			const useSessions = (select) => select(sessionState);
+			const useWorkspaces = (select) => select(workspaceState);
+			const useStore = (select) => select(viewState);
+			const remote = (id) => rows.find((row) => row.local ? row.sessionRef === id && !local.byId[id] : accountSessionKey(row) === id);
+			const navigate = (target) => Promise.resolve(openNativeAccountSession(target, snapshot.localRuntimeRef)).catch((error) => {
+				if (!catalog.signal.aborted && error?.name !== "AbortError") setOperationError(error instanceof Error ? error.message : "打开会话失败");
+			});
+			const command = async (id, operation, body = {}) => {
+				const target = remote(id);
+				if (!target) throw new Error("会话不存在");
+				const value = await callArkme("remote.session.command", {
+					runtimeRef: target.runtimeRef,
+					sessionRef: target.sessionRef,
+					operation,
+					body,
+					requestRef: crypto.randomUUID()
+				}, catalog.signal);
+				await catalog.refresh();
+				return value;
+			};
+			const open = (id) => {
+				const target = remote(id);
+				if (local.byId[id]) props.open(id);
+				else if (target) navigate(target);
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Native, {
+				...props,
+				useSessions,
+				useWorkspaces,
+				useStore,
+				open,
+				renameSession: (id, title) => remote(id) ? command(id, "session.rename", { title }).then(() => void 0) : props.renameSession(id, title),
+				archiveSession: async (id) => {
+					if (!remote(id)) return props.archiveSession(id);
+					await command(id, "session.archive");
+				},
+				forkSession: (id) => {
+					if (!remote(id)) props.forkSession(id);
+					else setOperationError("此操作需要在对话所属电脑上执行。");
+				},
+				startSession: (id) => {
+					if (!id?.startsWith("arkme:")) {
+						props.startSession(id);
+						return;
+					}
+					const source = rows.find((row) => `arkme:${row.runtimeRef}:${row.workspaceRef}` === id);
+					if (!source || creating.current) return;
+					const blank = rows.find((row) => row.runtimeRef === source.runtimeRef && row.workspaceRef === source.workspaceRef && row.blank && !row.archived);
+					if (blank) {
+						navigate(blank);
+						return;
+					}
+					creating.current = true;
+					callArkme("remote.session.command", {
+						runtimeRef: source.runtimeRef,
+						operation: "session.create",
+						requestRef: crypto.randomUUID(),
+						body: { workspace_ref: source.workspaceRef }
+					}, catalog.signal).then((value) => {
+						if (!catalog.signal.aborted) return navigate({
+							...source,
+							sessionRef: value.sessionId
+						});
+					}).catch((error) => {
+						if (!catalog.signal.aborted) setOperationError(error instanceof Error ? error.message : "新建会话失败");
+					}).finally(() => {
+						creating.current = false;
+					});
+				}
+			}), operationError && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_deepseek_ai_dsh_client_ui_primitives.Modal, {
+				open: true,
+				onClose: () => setOperationError(""),
+				title: "无法执行操作",
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", { children: operationError }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+					onClick: () => setOperationError(""),
+					children: "知道了"
+				})]
+			})] });
+		}
+		/** Shadow the native entry using its public component/store/inject seats. The
+		* directory picker gets its own declared slot; never borrow another entry's
+		* render authorization or mutate the original registration. */
+		function installHarnessAccountSessions(ctx, surface) {
+			const slots = ctx.slots;
+			if (typeof slots.entries !== "function" || typeof slots.subscribe !== "function") return () => {};
+			const catalog = accountSessionCatalog(surface);
+			catalog.start();
+			catalog.refresh();
+			let native, remove, updating = false;
+			const sync = () => {
+				if (updating) return;
+				const next = slots.entries(SLOT$1).find((entry) => (entry.options.priority ?? 0) >= 0);
+				if (next === native) return;
+				updating = true;
+				remove?.();
+				remove = void 0;
+				native = next;
+				try {
+					if (!next || typeof next.component !== "function" || typeof next.inject !== "function" || !next.store || !next.children?.[FLOW] || Object.keys(next.children).length !== 1) return;
+					const Native = next.component;
+					const Wrapped = (props) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AccountSessionBrowser, {
+						...props,
+						Native,
+						surface,
+						renderSlot: (name, owner) => name === FLOW ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							"data-slot": FLOW,
+							style: { display: "contents" },
+							children: props.renderSlot(OWN_FLOW, owner)
+						}) : null
+					});
+					const register = slots.register.bind(slots);
+					const restoreBrowser = register({
+						name: SLOT$1,
+						priority: -100,
+						store: next.store,
+						inject: next.inject,
+						locale: next.locale,
+						children: { [OWN_FLOW]: next.children[FLOW] }
+					}, Wrapped);
+					let picker, restorePicker;
+					const syncPicker = () => {
+						const current = slots.entriesOfSlot(FLOW)[0];
+						if (current === picker) return;
+						restorePicker?.();
+						restorePicker = void 0;
+						picker = current;
+						if (current && !current.children) restorePicker = register({
+							name: OWN_FLOW,
+							...current.options,
+							store: current.store,
+							inject: current.inject,
+							locale: current.locale
+						}, current.component);
+					};
+					const unsubscribe = slots.subscribe(FLOW, syncPicker);
+					syncPicker();
+					remove = () => {
+						unsubscribe();
+						restorePicker?.();
+						restoreBrowser();
+					};
+				} finally {
+					updating = false;
+				}
+			};
+			const unsubscribe = slots.subscribe(SLOT$1, sync);
+			sync();
+			return () => {
+				unsubscribe();
+				updating = true;
+				remove?.();
+				catalog.dispose();
+			};
+		}
+		//#endregion
 		//#region src/client/harness-session-list-default.ts
 		const SESSION_LIST_DEFAULT_MARKER = "arkme.harness.session-list-default.v1";
 		function adoptFlatSessionDefault(groupBy, setGroupBy, storage) {
@@ -65,12 +2113,6 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
-		//#region src/client/harness-session-menu-bridge.ts
-		/** Private presentation bridge between Arkme and its existing same-origin Harness frame. */
-		const HARNESS_MENU_OPEN = "arkme:harness-menu-open";
-		const HARNESS_MENU_CLOSE = "arkme:harness-menu-close";
-		const HARNESS_MENU_POSITION = "arkme:harness-menu-position";
-		//#endregion
 		//#region src/client/arkme-theme.ts
 		/**
 		* Arkme semantic colors. DSH owns the active light/dark/system preference and
@@ -788,6 +2830,7 @@ body:has([data-arkme-self-topic-menu]) > [role="menu"] { z-index: 10030; }
 				}
 				close();
 				show();
+				doc.dispatchEvent(new win.Event(HARNESS_MENU_OPEN));
 			});
 			function externalOpen(event) {
 				const request = event.detail;
@@ -818,6 +2861,7 @@ body:has([data-arkme-self-topic-menu]) > [role="menu"] { z-index: 10030; }
 				const row = target.closest("[role=\"treeitem\"][aria-selected]");
 				const buttonLabel = target.closest("button")?.getAttribute("aria-label") ?? "";
 				const workspaceCreate = /^在“.+”中新建会话$/.test(buttonLabel) || /^New session in /.test(buttonLabel);
+				if (current.create.contains(target)) doc.dispatchEvent(new doc.defaultView.Event(HARNESS_LOCAL_SESSION_OPEN));
 				if (row && !target.closest("button, input, [role=\"menu\"]") || current.create.contains(target) || workspaceCreate || target.closest("nav button")) {
 					const request = external;
 					close(!request);
@@ -1154,6 +3198,7 @@ body:has([data-arkme-self-topic-menu]) > [role="menu"] { z-index: 10030; }
 				let restoreDropdown;
 				let restoreDefault;
 				let restoreSummary;
+				let restoreAccountSessions;
 				let restoreActivity;
 				const sync = () => {
 					const accountId = Number(surface.getAttribute("data-arkme-account-id"));
@@ -1164,10 +3209,13 @@ body:has([data-arkme-self-topic-menu]) > [role="menu"] { z-index: 10030; }
 							priority: -100
 						}, () => null));
 						restoreDefault = installHarnessSessionListDefault(ctx);
+						restoreAccountSessions = installHarnessAccountSessions(ctx, surface);
 						restoreSummary = installHarnessSessionSummary(ctx);
 						restoreActivity = installHarnessActivityReporter(ctx, surface);
 						restoreDropdown = installHarnessSessionDropdown(document);
 					} else if (!authenticated) {
+						restoreAccountSessions?.();
+						restoreAccountSessions = void 0;
 						restoreActivity?.();
 						restoreActivity = void 0;
 						restoreSummary?.();
@@ -1188,6 +3236,7 @@ body:has([data-arkme-self-topic-menu]) > [role="menu"] { z-index: 10030; }
 				sync();
 				return () => {
 					observer.disconnect();
+					restoreAccountSessions?.();
 					restoreActivity?.();
 					restoreSummary?.();
 					restoreDefault?.();