@octane-xplat/auth 0.10.0 → 0.11.0

package/dist/native/platform/src/lifecycle.tsrx.js

@@ -0,0 +1,7 @@
+import { hookSlots } from "@nativescript-community/octane";
+import "@nativescript/core";
+//#region ../platform/src/lifecycle.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(3);
+_hs$ + 1;
+_hs$ + 2;
+//#endregion

package/dist/native/platform/src/locale.js

@@ -0,0 +1,3 @@
+import { Device } from "@nativescript/core";
+`${Device.language}${Device.region}`, Device.language.split("-")[0], Device.region;
+//#endregion

package/dist/native/platform/src/open-url.js

@@ -0,0 +1 @@
+import "@nativescript/core";

package/dist/native/platform/src/random.js

@@ -0,0 +1,38 @@
+import { Application } from "@nativescript/core";
+//#region ../platform/src/random.ts
+var iosReady = () => Application.ios != null && typeof SecRandomCopyBytes === "function" && typeof NSMutableData !== "undefined";
+var androidReady = () => Application.android != null && typeof java !== "undefined" && typeof Array.create === "function";
+var secureRandom;
+function fillBytes(target) {
+	if (target.length === 0) return;
+	if (iosReady()) {
+		const data = NSMutableData.dataWithLength(target.length);
+		if (SecRandomCopyBytes(kSecRandomDefault, target.length, data.mutableBytes) !== 0) throw new Error("random: SecRandomCopyBytes failed");
+		target.set(new Uint8Array(interop.bufferFromData(data)));
+		return;
+	}
+	if (androidReady()) {
+		secureRandom ??= new java.security.SecureRandom();
+		const buffer = Array.create("byte", target.length);
+		secureRandom.nextBytes(buffer);
+		for (let i = 0; i < target.length; i++) target[i] = buffer[i];
+		return;
+	}
+	throw new Error("random: no OS CSPRNG bound on this target");
+}
+var random = {
+	get supported() {
+		return iosReady() || androidReady();
+	},
+	fill(view) {
+		if (!ArrayBuffer.isView(view)) throw new TypeError("random.fill: expected an ArrayBufferView");
+		fillBytes(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+		return view;
+	},
+	bytes(length) {
+		if (!Number.isInteger(length) || length < 0) throw new RangeError("random.bytes: length must be a non-negative integer");
+		return random.fill(new Uint8Array(length));
+	}
+};
+//#endregion
+export { random };

package/dist/native/platform/src/safe-area.tsrx.js

@@ -0,0 +1,4 @@
+import { hookSlots } from "@nativescript-community/octane";
+import "@nativescript/core";
+/* @__PURE__ */ hookSlots(2) + 1;
+//#endregion

package/dist/native/platform/src/screen.tsrx.js

@@ -0,0 +1,4 @@
+import { hookSlots } from "@nativescript-community/octane";
+import "@nativescript/core";
+/* @__PURE__ */ hookSlots(2) + 1;
+//#endregion

package/dist/native/platform/src/storage.js

@@ -0,0 +1 @@
+import "@nativescript/core";

package/dist/native/platform/src/system-bars.js

@@ -0,0 +1 @@
+import "@nativescript/core";

package/dist/native/secure-storage/src/index.js

@@ -0,0 +1,2 @@
+import { secureStorage } from "./secure-storage.js";
+export { secureStorage };

package/dist/native/secure-storage/src/secure-storage.js

@@ -0,0 +1,17 @@
+import { SecureStorage } from "@nativescript/secure-storage";
+//#region ../secure-storage/src/secure-storage.ts
+var store = new SecureStorage();
+var secureStorage = {
+	supported: true,
+	ensure: async () => "granted",
+	impl: {
+		get: (key) => store.get({ key }).then((v) => v ?? null),
+		set: (key, value) => store.set({
+			key,
+			value
+		}),
+		remove: (key) => store.remove({ key })
+	}
+};
+//#endregion
+export { secureStorage };

package/dist/web/auth/src/base64.js

@@ -0,0 +1,17 @@
+//#region src/base64.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function bytesToBase64Url(bytes) {
+	let out = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const a = bytes[i];
+		const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+		const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+		out += ALPHABET[a >> 2];
+		out += ALPHABET[(a & 3) << 4 | b >> 4];
+		if (i + 1 < bytes.length) out += ALPHABET[(b & 15) << 2 | c >> 6];
+		if (i + 2 < bytes.length) out += ALPHABET[c & 63];
+	}
+	return out;
+}
+//#endregion
+export { bytesToBase64Url };

package/dist/web/auth/src/hosted.js

@@ -0,0 +1,251 @@
+import { random } from "../../platform/src/random.web.js";
+import { authSession } from "../../platform/src/auth-session.web.js";
+import "../../platform/src/index.web.js";
+import { secureStorage } from "../../secure-storage/src/secure-storage.web.js";
+import { bytesToBase64Url } from "./base64.js";
+import { sha256, utf8Bytes } from "./sha256.js";
+//#region src/hosted.ts
+var DEFAULT_STORAGE_KEY = "hosted-auth";
+var REFRESH_SKEW_MS = 3e4;
+function createHostedAuth(config) {
+	const apiOrigin = normalizeOrigin(config.apiOrigin);
+	const authorizePath = config.authorizePath ?? defaultAuthorizePath;
+	const storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
+	const now = config.now ?? Date.now;
+	const transport = config.fetch ?? ((url, init) => {
+		const impl = globalThis.fetch;
+		if (!impl) return Promise.reject(/* @__PURE__ */ new Error("hostedAuth: fetch is unavailable on this target"));
+		return impl(url, init);
+	});
+	let credentials;
+	let refreshPromise = null;
+	function store() {
+		return config.storage ?? secureStorage.impl;
+	}
+	async function persist(creds) {
+		credentials = creds;
+		const storage = store();
+		if (!storage) return;
+		try {
+			if (creds) await storage.set(storageKey, JSON.stringify(creds));
+			else await storage.remove(storageKey);
+		} catch {}
+	}
+	async function load() {
+		if (credentials !== void 0) return credentials;
+		const storage = store();
+		if (!storage) {
+			credentials = null;
+			return null;
+		}
+		try {
+			const raw = await storage.get(storageKey);
+			const parsed = raw ? parseCredentials(raw) : null;
+			if (credentials === void 0) credentials = parsed;
+			if (!parsed && raw) await storage.remove(storageKey);
+		} catch {
+			credentials ??= null;
+		}
+		return credentials ?? null;
+	}
+	async function refresh() {
+		const creds = await load();
+		if (!creds || !config.flow.refresh) return null;
+		const next = await config.flow.refresh(creds, { fetch: transport });
+		if (!isCredentials(next)) {
+			await persist(null);
+			return null;
+		}
+		await persist(next);
+		return next.token;
+	}
+	function refreshedAccessToken() {
+		refreshPromise ??= refresh().finally(() => {
+			refreshPromise = null;
+		});
+		return refreshPromise;
+	}
+	async function getAccessToken() {
+		const creds = await load();
+		if (!creds) return null;
+		if (creds.expiresAt - now() > REFRESH_SKEW_MS) return creds.token;
+		return refreshedAccessToken();
+	}
+	async function signIn() {
+		const session = config.authSession ?? {
+			supported: authSession.supported,
+			open: (url, options) => {
+				const impl = authSession.impl;
+				if (!impl) return Promise.resolve({
+					type: "error",
+					message: "hostedAuth: hosted sign-in is not supported on this target"
+				});
+				return impl.open(url, options);
+			}
+		};
+		if (!session.supported || !random.supported) return {
+			status: "error",
+			message: "hostedAuth: hosted sign-in is not supported on this target"
+		};
+		const verifier = bytesToBase64Url(random.bytes(32));
+		const pkce = {
+			challenge: bytesToBase64Url(sha256(utf8Bytes(verifier))),
+			verifier
+		};
+		let attempt;
+		try {
+			attempt = await config.flow.begin({
+				fetch: transport,
+				pkce
+			});
+		} catch (error) {
+			return {
+				status: "error",
+				message: errorMessage(error)
+			};
+		}
+		const result = await session.open(attempt.url, { callbackScheme: attempt.callbackScheme });
+		if (result.type === "cancel") return { status: "cancelled" };
+		if (result.type === "error") return {
+			status: "error",
+			message: result.message
+		};
+		if (attempt.state !== void 0 && queryParam(result.url, "state") !== attempt.state) return {
+			status: "error",
+			message: "hostedAuth: callback did not carry the expected state"
+		};
+		try {
+			const creds = await config.flow.complete(result.url, attempt, {
+				fetch: transport,
+				pkce
+			});
+			if (!isCredentials(creds)) return {
+				status: "error",
+				message: "hostedAuth: sign-in did not produce credentials"
+			};
+			await persist(creds);
+			return { status: "success" };
+		} catch (error) {
+			return {
+				status: "error",
+				message: errorMessage(error)
+			};
+		}
+	}
+	async function fetchWithAuth(url, init) {
+		const pathname = apiPath(url, apiOrigin);
+		if (pathname === null || !authorizePath(pathname)) return transport(url, init);
+		const target = url.startsWith("/") ? `${apiOrigin}${url}` : url;
+		const token = await getAccessToken();
+		const response = await transport(target, token === null ? init : withBearer(init, token));
+		if (!isInvalidAccessTokenChallenge(response.status, response.headers)) return response;
+		const refreshed = await refreshedAccessToken();
+		if (refreshed === null) return response;
+		return transport(target, withBearer(init, refreshed));
+	}
+	async function signOut() {
+		const creds = await load();
+		await persist(null);
+		if (!creds || !config.flow.revoke) return;
+		try {
+			await config.flow.revoke(creds, { fetch: transport });
+		} catch {}
+	}
+	return {
+		get supported() {
+			return (config.authSession?.supported ?? authSession.supported) && random.supported;
+		},
+		restore: async () => await load() ? "authenticated" : "unauthenticated",
+		signIn,
+		getAccessToken,
+		fetch: fetchWithAuth,
+		signOut
+	};
+}
+function normalizeOrigin(value) {
+	const trimmed = value.trim().replace(/\/+$/u, "");
+	if (!/^https?:\/\/[^\s/?#]+$/u.test(trimmed)) throw new TypeError(`hostedAuth: apiOrigin must be an HTTP(S) origin without path or parameters, got ${JSON.stringify(value)}`);
+	return trimmed;
+}
+/** `POST` a JSON body through the flow's transport. */
+function postJson(transport, url, body) {
+	return transport(url, {
+		body: JSON.stringify(body),
+		headers: { "content-type": "application/json" },
+		method: "POST"
+	});
+}
+/** `?name=value` extraction without URLSearchParams (not in the native program). */
+function queryParam(url, name) {
+	const start = url.indexOf("?");
+	if (start === -1) return null;
+	const query = url.slice(start + 1).split("#", 1)[0];
+	for (const pair of query.split("&")) {
+		const eq = pair.indexOf("=");
+		if ((eq === -1 ? pair : pair.slice(0, eq)) === name) return eq === -1 ? "" : decodeURIComponent(pair.slice(eq + 1).replaceAll("+", " "));
+	}
+	return null;
+}
+function isCredentials(value) {
+	const creds = value;
+	return !!creds && typeof creds.token === "string" && typeof creds.expiresAt === "number" && typeof creds.sessionToken === "string";
+}
+function parseCredentials(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (isCredentials(parsed)) return {
+			expiresAt: parsed.expiresAt,
+			sessionToken: parsed.sessionToken,
+			token: parsed.token
+		};
+	} catch {}
+	return null;
+}
+/**
+* Pathname of `url` when it belongs to `apiOrigin` — `null` for other
+* origins. Relative (`/path`) and origin-prefixed inputs both resolve.
+*/
+function apiPath(url, apiOrigin) {
+	if (url.startsWith("//")) return null;
+	let path;
+	if (url.startsWith("/")) path = url;
+	else if (url.startsWith(apiOrigin + "/") || url === apiOrigin) path = url.slice(apiOrigin.length) || "/";
+	else return null;
+	const end = path.search(/[?#]/u);
+	return end === -1 ? path : path.slice(0, end);
+}
+/**
+* Default `authorizePath` — every same-origin path under `/api/` except the
+* `/api/auth` mount hosted backends reserve for auth endpoints.
+*/
+function defaultAuthorizePath(pathname) {
+	return pathname.startsWith("/api/") && !(pathname === "/api/auth" || pathname.startsWith("/api/auth/"));
+}
+function withBearer(init, token) {
+	const headers = {};
+	const incoming = init?.headers;
+	if (incoming) {
+		if (Symbol.iterator in incoming) for (const [name, value] of incoming) headers[name.toLowerCase()] = value;
+		else for (const name of Object.keys(incoming)) headers[name.toLowerCase()] = incoming[name];
+	}
+	headers.authorization = `Bearer ${token}`;
+	return {
+		...init,
+		headers
+	};
+}
+/**
+* RFC 6750 `401 + WWW-Authenticate: Bearer error="invalid_token"` — the
+* challenge that distinguishes a dead access token from an ordinary
+* authorization failure.
+*/
+function isInvalidAccessTokenChallenge(status, headers) {
+	if (status !== 401) return false;
+	const challenge = headers.get("www-authenticate");
+	return !!challenge && /error\s*=\s*"invalid_token"/iu.test(challenge);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : "hostedAuth: the hosted ceremony failed";
+}
+//#endregion
+export { createHostedAuth, postJson, queryParam };

package/dist/web/auth/src/sha256.js

@@ -0,0 +1,141 @@
+//#region src/sha256.ts
+function utf8Bytes(input) {
+	const bytes = [];
+	for (let i = 0; i < input.length; i++) {
+		let cp = input.charCodeAt(i);
+		if (cp >= 55296 && cp <= 56319 && i + 1 < input.length) {
+			const low = input.charCodeAt(i + 1);
+			if (low >= 56320 && low <= 57343) {
+				cp = 65536 + (cp - 55296 << 10) + (low - 56320);
+				i++;
+			}
+		}
+		if (cp < 128) bytes.push(cp);
+		else if (cp < 2048) bytes.push(192 | cp >> 6, 128 | cp & 63);
+		else if (cp < 65536) bytes.push(224 | cp >> 12, 128 | cp >> 6 & 63, 128 | cp & 63);
+		else bytes.push(240 | cp >> 18, 128 | cp >> 12 & 63, 128 | cp >> 6 & 63, 128 | cp & 63);
+	}
+	return new Uint8Array(bytes);
+}
+function sha256(bytes) {
+	const K = new Uint32Array([
+		1116352408,
+		1899447441,
+		3049323471,
+		3921009573,
+		961987163,
+		1508970993,
+		2453635748,
+		2870763221,
+		3624381080,
+		310598401,
+		607225278,
+		1426881987,
+		1925078388,
+		2162078206,
+		2614888103,
+		3248222580,
+		3835390401,
+		4022224774,
+		264347078,
+		604807628,
+		770255983,
+		1249150122,
+		1555081692,
+		1996064986,
+		2554220882,
+		2821834349,
+		2952996808,
+		3210313671,
+		3336571891,
+		3584528711,
+		113926993,
+		338241895,
+		666307205,
+		773529912,
+		1294757372,
+		1396182291,
+		1695183700,
+		1986661051,
+		2177026350,
+		2456956037,
+		2730485921,
+		2820302411,
+		3259730800,
+		3345764771,
+		3516065817,
+		3600352804,
+		4094571909,
+		275423344,
+		430227734,
+		506948616,
+		659060556,
+		883997877,
+		958139571,
+		1322822218,
+		1537002063,
+		1747873779,
+		1955562222,
+		2024104815,
+		2227730452,
+		2361852424,
+		2428436474,
+		2756734187,
+		3204031479,
+		3329325298
+	]);
+	const H = new Uint32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	const bitLen = bytes.length * 8;
+	const padded = new Uint8Array(bytes.length + 9 + 63 & -64);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const dv = new DataView(padded.buffer);
+	dv.setUint32(padded.length - 8, Math.floor(bitLen / 4294967296));
+	dv.setUint32(padded.length - 4, bitLen >>> 0);
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let block = 0; block < padded.length; block += 64) {
+		for (let t = 0; t < 16; t++) w[t] = dv.getUint32(block + t * 4);
+		for (let t = 16; t < 64; t++) {
+			const s0 = (w[t - 15] >>> 7 | w[t - 15] << 25) ^ (w[t - 15] >>> 18 | w[t - 15] << 14) ^ w[t - 15] >>> 3;
+			const s1 = (w[t - 2] >>> 17 | w[t - 2] << 15) ^ (w[t - 2] >>> 19 | w[t - 2] << 13) ^ w[t - 2] >>> 10;
+			w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+		}
+		let [a, b, c, d, e, f, g, h] = H;
+		for (let t = 0; t < 64; t++) {
+			const S1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+			const t1 = h + S1 + (e & f ^ ~e & g) + K[t] + w[t] >>> 0;
+			const t2 = ((a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10)) + (a & b ^ a & c ^ b & c) >>> 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 >>> 0;
+		}
+		H[0] = H[0] + a >>> 0;
+		H[1] = H[1] + b >>> 0;
+		H[2] = H[2] + c >>> 0;
+		H[3] = H[3] + d >>> 0;
+		H[4] = H[4] + e >>> 0;
+		H[5] = H[5] + f >>> 0;
+		H[6] = H[6] + g >>> 0;
+		H[7] = H[7] + h >>> 0;
+	}
+	const digest = /* @__PURE__ */ new Uint8Array(32);
+	const out = new DataView(digest.buffer);
+	for (let i = 0; i < 8; i++) out.setUint32(i * 4, H[i]);
+	return digest;
+}
+//#endregion
+export { sha256, utf8Bytes };

package/dist/web/index.js

@@ -1,5 +1,6 @@
-import { appleAuth } from "./apple.web.js";
-import { googleAuth } from "./google.web.js";
-import { AppleSignInButton } from "./AppleSignInButton.web.tsrx.js";
-import { GoogleSignInButton } from "./GoogleSignInButton.web.tsrx.js";
-export { AppleSignInButton, GoogleSignInButton, appleAuth, googleAuth };
+import { appleAuth } from "./auth/src/apple.web.js";
+import { googleAuth } from "./auth/src/google.web.js";
+import { AppleSignInButton } from "./auth/src/AppleSignInButton.web.tsrx.js";
+import { GoogleSignInButton } from "./auth/src/GoogleSignInButton.web.tsrx.js";
+import { createHostedAuth, postJson, queryParam } from "./auth/src/hosted.js";
+export { AppleSignInButton, GoogleSignInButton, appleAuth, createHostedAuth, googleAuth, postJson, queryParam };

package/dist/web/octane-client-build.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "buildId": "500fb75c-1e7a-46fe-8b9a-4a439f2dfd7e",
+  "buildId": "7ebd11a6-c6c1-4302-aa4a-1fb3fa0410da",
   "mode": "production",
   "capabilities": {
     "independentHydration": false

package/dist/web/platform/src/app-info.web.js

@@ -0,0 +1,3 @@
+import { desktopHostBootstrap } from "./host-runtime.web.js";
+desktopHostBootstrap()?.appInfo;
+//#endregion

package/dist/web/platform/src/auth-session.web.js

@@ -0,0 +1,10 @@
+//#region ../platform/src/auth-session.web.ts
+var authSession = {
+	supported: false,
+	async ensure() {
+		return "unsupported";
+	},
+	impl: null
+};
+//#endregion
+export { authSession };

package/dist/web/platform/src/breakpoints.web.tsrx.js

@@ -0,0 +1,7 @@
+import { hookSlots } from "octane";
+import { enableNativeReadCollection } from "octane/internal/client";
+import "octane/signals/client";
+//#region ../platform/src/breakpoints.web.tsrx
+enableNativeReadCollection(1);
+/* @__PURE__ */ hookSlots(2) + 1;
+//#endregion

package/dist/web/platform/src/clipboard.web.js

@@ -0,0 +1,3 @@
+import { desktopHostClient } from "./host-runtime.web.js";
+typeof navigator !== "undefined" && typeof navigator.clipboard?.writeText === "function" || desktopHostClient();
+//#endregion

package/dist/web/platform/src/deep-links.web.js

@@ -0,0 +1,3 @@
+import { desktopHostBootstrap } from "./host-runtime.web.js";
+desktopHostBootstrap()?.initialUrl;
+//#endregion

package/dist/web/platform/src/device.web.js

@@ -0,0 +1,2 @@
+navigator.userAgent.match(/(?:Mac OS X|Windows NT|Android|OS) ([\d._]+)/)?.[1]?.replace(/_/g, "."), navigator.language.split("-")[0], navigator.language.split("-")[1];
+//#endregion

package/dist/web/platform/src/host-bridge.web.js

@@ -0,0 +1,18 @@
+//#region ../platform/src/host-bridge.web.ts
+/** Return the native message channel when this page is hosted by a desktop app. */
+function createWebKitTransport() {
+	if (typeof window === "undefined") return null;
+	const handler = window.webkit?.messageHandlers?.xplat;
+	const host = window.__xplatHostTransport;
+	if (!handler || !host) return null;
+	return {
+		postMessage(message) {
+			handler.postMessage(message);
+		},
+		listen(listener) {
+			return host.listen(listener);
+		}
+	};
+}
+//#endregion
+export { createWebKitTransport };

package/dist/web/platform/src/host-protocol.js

@@ -0,0 +1,73 @@
+//#region ../platform/src/host-protocol.ts
+/**
+* Create the webview-side client. Host methods are typed at compile time; this
+* deliberately does not add runtime schema validation.
+*/
+function createHostClient(transport) {
+	const pending = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	let disposed = false;
+	const removeListener = transport.listen((message) => {
+		const packet = JSON.parse(message);
+		if (packet.type === "reply") {
+			const task = pending.get(packet.id);
+			if (!task) return;
+			pending.delete(packet.id);
+			if (packet.ok) task.resolve(packet.value);
+			else task.reject(new Error(packet.error));
+			return;
+		}
+		for (const listener of listeners.get(packet.name) ?? []) listener(packet.payload);
+	});
+	const request = (value) => {
+		if (disposed) return Promise.reject(/* @__PURE__ */ new Error("desktop host client is disposed"));
+		const id = ++nextId;
+		const promise = new Promise((resolve, reject) => pending.set(id, {
+			resolve,
+			reject
+		}));
+		try {
+			transport.postMessage(JSON.stringify({
+				...value,
+				id
+			}));
+		} catch (error) {
+			const task = pending.get(id);
+			pending.delete(id);
+			task?.reject(error instanceof Error ? error : new Error(String(error)));
+		}
+		return promise;
+	};
+	return {
+		call: ((service, method, ...args) => request({
+			type: "call",
+			service,
+			method,
+			args
+		})),
+		capabilities() {
+			return request({ type: "capabilities" });
+		},
+		on(name, listener) {
+			const eventListeners = listeners.get(name) ?? /* @__PURE__ */ new Set();
+			const receive = listener;
+			eventListeners.add(receive);
+			listeners.set(name, eventListeners);
+			return () => {
+				eventListeners.delete(receive);
+				if (!eventListeners.size) listeners.delete(name);
+			};
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			removeListener();
+			listeners.clear();
+			for (const task of pending.values()) task.reject(/* @__PURE__ */ new Error("desktop host client is disposed"));
+			pending.clear();
+		}
+	};
+}
+//#endregion
+export { createHostClient };