opentray 0.28.0 → 0.29.0

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import { createRequire } from "node:module";
-import { PROTOCOL_VERSION, PROTOCOL_VERSION as PROTOCOL_VERSION$1, brokerArtifactIdentityEquals, createBrokerEndpointIdentity, createBrokerEndpointIdentity as createBrokerEndpointIdentity$1, formatBrokerEndpointName, formatBrokerStateRoot, formatUnixSocketPath, formatUnixSocketPath as formatUnixSocketPath$1, formatWindowsPipeName, formatWindowsPipeName as formatWindowsPipeName$1, isBrokerArtifactIdentity, isSupportedProtocolVersion, parseServerFrame, sanitizeCallerLabel } from "@opentray/spec";
+import { EXTENSION_EVENT_RECORD_MAX_BYTES, PROTOCOL_VERSION, PROTOCOL_VERSION as PROTOCOL_VERSION$1, brokerArtifactIdentityEquals, createBrokerEndpointIdentity, createBrokerEndpointIdentity as createBrokerEndpointIdentity$1, formatBrokerEndpointName, formatBrokerStateRoot, formatUnixSocketPath, formatUnixSocketPath as formatUnixSocketPath$1, formatWindowsPipeName, formatWindowsPipeName as formatWindowsPipeName$1, isBrokerArtifactIdentity, isSupportedProtocolVersion, parseServerFrame, sanitizeCallerLabel } from "@opentray/spec";
 import { access, appendFile, link, mkdir, open, readFile, realpath, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { createConnection } from "node:net";
 import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
 import { clearDarwinAppBundleOwner, convergeDarwinAppBundleIdentity, ensureDarwinAppBundle, resolveDefaultDarwinAppBundlePath, resolveOpenTrayPackageIdentity, updateDarwinAppLaunchDescriptor, writeDarwinAppBundleOwner } from "@opentray/packaging";
-import { createHash, randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { spawn } from "node:child_process";
 import { generateDefaultAppIcon } from "@opentray/icon";
@@ -237,6 +237,20 @@ const normalizePlatform = (platform) => {
 };
 //#endregion
 //#region src/native-extension-artifact.ts
+/**
+* Frozen embedded staging matrix (add-ext-dialog section 6.4): a facade that
+* embeds platform binaries stages exactly these four targets. The runtime
+* resolver requires the staging manifest to be complete over this matrix
+* (release staging enforces the same set before anything is packed); one
+* missing cell is a manifest-invalid artifact, never a silently thinner
+* catalog.
+*/
+const NATIVE_EXTENSION_EMBEDDED_TARGET_MATRIX = [
+	"darwin-arm64",
+	"darwin-x64",
+	"win32-arm64",
+	"win32-x64"
+];
 var NativeExtensionArtifactResolutionError = class extends Error {
 	target;
 	code = "OPENTRAY_NATIVE_EXTENSION_ARTIFACT_RESOLUTION_FAILED";
@@ -250,6 +264,27 @@ var NativeExtensionArtifactResolutionError = class extends Error {
 		if (options.facadePackageJsonUrl !== void 0) this.facadePackageJsonUrl = options.facadePackageJsonUrl;
 	}
 };
+/** Stable machine code per embedded rejection reason (same family style as the resolution error). */
+const NATIVE_EXTENSION_EMBEDDED_ERROR_CODES = {
+	"target-unsupported": "OPENTRAY_NATIVE_EXTENSION_TARGET_UNSUPPORTED",
+	"path-outside-facade": "OPENTRAY_NATIVE_EXTENSION_PATH_OUTSIDE_FACADE",
+	"manifest-invalid": "OPENTRAY_NATIVE_EXTENSION_MANIFEST_INVALID",
+	"library-unreadable": "OPENTRAY_NATIVE_EXTENSION_LIBRARY_UNREADABLE"
+};
+var NativeExtensionEmbeddedArtifactError = class extends Error {
+	reason;
+	code;
+	target;
+	facadePackageJsonUrl;
+	constructor(reason, message, options) {
+		super(message, options);
+		this.name = "NativeExtensionEmbeddedArtifactError";
+		this.reason = reason;
+		this.code = NATIVE_EXTENSION_EMBEDDED_ERROR_CODES[reason];
+		this.target = options.target;
+		if (options.facadePackageJsonUrl !== void 0) this.facadePackageJsonUrl = options.facadePackageJsonUrl;
+	}
+};
 /** Resolve one exact native library from the dependency closure that owns the facade. */
 const resolveNativeExtensionArtifact = async (artifact, platform = process.platform, arch = process.arch) => {
 	const target = nativeExtensionTarget(platform, arch);
@@ -258,6 +293,7 @@ const resolveNativeExtensionArtifact = async (artifact, platform = process.platf
 		expectedIdentity: artifact.expectedIdentity ?? await resolveExpectedIdentity(artifact.identitySource, target),
 		target
 	};
+	if (artifact.kind === "embedded") return resolveEmbeddedExtensionArtifact(artifact, target);
 	const packageTarget = artifact.targets[target];
 	if (packageTarget === void 0) throw new NativeExtensionArtifactResolutionError(`native extension does not support target ${target}`, target);
 	const expectedIdentity = await resolveExpectedIdentity(artifact, target);
@@ -295,6 +331,102 @@ const resolveExpectedIdentity = async (source, target) => {
 		}
 	};
 };
+/** Fixed location of the embedded staging manifest inside the facade package. */
+const EMBEDDED_STAGING_MANIFEST_PATH = "platforms/manifest.json";
+const sha256HexPattern = /^[a-f0-9]{64}$/u;
+const isEmbeddedMatrixTarget = (target) => NATIVE_EXTENSION_EMBEDDED_TARGET_MATRIX.includes(target);
+const lexicalContained = (root, candidate) => {
+	const rel = relative(root, candidate);
+	if (rel.length === 0) return false;
+	return !(rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel));
+};
+const resolveEmbeddedExtensionArtifact = async (artifact, target) => {
+	const facadePackageJsonUrl = artifact.packageJsonUrl;
+	const embeddedError = (reason, message, options = {}) => new NativeExtensionEmbeddedArtifactError(reason, message, {
+		target,
+		facadePackageJsonUrl,
+		...options.cause === void 0 ? {} : { cause: options.cause }
+	});
+	if (!isEmbeddedMatrixTarget(target)) throw embeddedError("target-unsupported", `embedded native extension supports only the frozen staging matrix (${NATIVE_EXTENSION_EMBEDDED_TARGET_MATRIX.join(", ")}); ${target} is outside it`);
+	const embeddedTarget = artifact.targets[target];
+	if (embeddedTarget === void 0) throw embeddedError("target-unsupported", `embedded native extension does not declare target ${target}`);
+	const facadeRoot = dirname(fileURLToPath(new URL(facadePackageJsonUrl)));
+	if (isAbsolute(embeddedTarget.libraryPath)) throw embeddedError("path-outside-facade", `embedded library path must be relative to the facade package root: ${embeddedTarget.libraryPath}`);
+	const candidatePath = resolve(facadeRoot, embeddedTarget.libraryPath);
+	if (!lexicalContained(facadeRoot, candidatePath)) throw embeddedError("path-outside-facade", `embedded library path escapes the facade package root: ${embeddedTarget.libraryPath}`);
+	const [facadeManifest, contractManifest] = await Promise.all([readEmbeddedJson(facadePackageJsonUrl, embeddedError).then((parsed) => {
+		if (!isFacadePackageManifest(parsed)) throw embeddedError("manifest-invalid", `embedded facade package manifest is invalid at ${facadePackageJsonUrl}`);
+		return parsed;
+	}), readEmbeddedJson(artifact.contractManifestUrl, embeddedError).then((parsed) => {
+		if (!isExtensionContractManifest(parsed)) throw embeddedError("manifest-invalid", `embedded extension contract manifest is invalid at ${artifact.contractManifestUrl}`);
+		return parsed;
+	})]);
+	const manifestPath = join(facadeRoot, EMBEDDED_STAGING_MANIFEST_PATH);
+	const manifest = await readEmbeddedJson(pathToFileURL(manifestPath).href, embeddedError).then((parsed) => {
+		if (!isEmbeddedStagingManifest(parsed)) throw embeddedError("manifest-invalid", `embedded staging manifest is invalid at ${manifestPath}`);
+		return parsed;
+	});
+	if (manifest.facadeVersion !== facadeManifest.version) throw embeddedError("manifest-invalid", `embedded staging manifest facade version ${manifest.facadeVersion} does not match facade package version ${facadeManifest.version}`);
+	if (manifest.contractFingerprint !== contractManifest.contractFingerprint) throw embeddedError("manifest-invalid", `embedded staging manifest contract fingerprint does not match the contract manifest at ${artifact.contractManifestUrl}`);
+	for (const matrixTarget of NATIVE_EXTENSION_EMBEDDED_TARGET_MATRIX) if (manifest.targets[matrixTarget] === void 0) throw embeddedError("manifest-invalid", `embedded staging manifest is missing required matrix target ${matrixTarget}`);
+	for (const manifestTarget of Object.keys(manifest.targets)) {
+		if (!isEmbeddedMatrixTarget(manifestTarget)) throw embeddedError("manifest-invalid", `embedded staging manifest declares target ${manifestTarget} outside the frozen staging matrix`);
+		if (artifact.targets[manifestTarget] === void 0) throw embeddedError("manifest-invalid", `embedded staging manifest declares undeclared target ${manifestTarget}`);
+	}
+	const manifestEntry = manifest.targets[target];
+	if (manifestEntry === void 0) throw embeddedError("manifest-invalid", `embedded staging manifest has no entry for target ${target}`);
+	if (isAbsolute(manifestEntry.path)) throw embeddedError("path-outside-facade", `embedded staging manifest library path must be relative to the facade package root: ${manifestEntry.path}`);
+	const manifestLibraryPath = resolve(facadeRoot, manifestEntry.path);
+	if (!lexicalContained(facadeRoot, manifestLibraryPath)) throw embeddedError("path-outside-facade", `embedded staging manifest library path escapes the facade package root: ${manifestEntry.path}`);
+	if (manifestLibraryPath !== candidatePath) throw embeddedError("manifest-invalid", `embedded staging manifest path ${manifestEntry.path} does not match the declared library path ${embeddedTarget.libraryPath} for target ${target}`);
+	const realRoot = await realpath(facadeRoot).catch(() => facadeRoot);
+	let realCandidate;
+	try {
+		realCandidate = await realpath(candidatePath);
+	} catch (cause) {
+		throw embeddedError("library-unreadable", `embedded native extension library is not accessible at ${candidatePath}`, { cause });
+	}
+	if (!lexicalContained(realRoot, realCandidate)) throw embeddedError("path-outside-facade", `embedded library resolves outside the facade package root: ${embeddedTarget.libraryPath}`);
+	let libraryBytes;
+	try {
+		libraryBytes = await readFile(realCandidate);
+	} catch (cause) {
+		throw embeddedError("library-unreadable", `embedded native extension library is not readable at ${realCandidate}`, { cause });
+	}
+	const sha256 = createHash("sha256").update(libraryBytes).digest("hex");
+	if (sha256 !== manifestEntry.sha256) throw embeddedError("manifest-invalid", `embedded library bytes do not match the staging manifest SHA-256 for target ${target}`);
+	const [os, arch] = splitTarget(target);
+	const expectedIdentity = {
+		extensionName: contractManifest.extensionName,
+		artifactSetVersion: facadeManifest.version,
+		contractFingerprint: contractManifest.contractFingerprint,
+		target: {
+			os,
+			arch
+		},
+		sha256,
+		buildIdentity: manifestEntry.buildIdentity
+	};
+	return {
+		path: realCandidate,
+		expectedIdentity,
+		target
+	};
+};
+const readEmbeddedJson = async (url, embeddedError) => {
+	try {
+		return JSON.parse(await readFile(new URL(url), "utf8"));
+	} catch (cause) {
+		throw embeddedError("manifest-invalid", `unable to read embedded identity-chain manifest at ${url}`, { cause });
+	}
+};
+const isEmbeddedStagingManifest = (value) => {
+	if (!isRecordLike(value) || !isRecordLike(value.targets)) return false;
+	if (typeof value.facadeVersion !== "string" || typeof value.contractFingerprint !== "string") return false;
+	for (const entry of Object.values(value.targets)) if (!isRecordLike(entry) || typeof entry.path !== "string" || typeof entry.sha256 !== "string" || !sha256HexPattern.test(entry.sha256) || typeof entry.buildIdentity !== "string" || entry.buildIdentity.length === 0) return false;
+	return true;
+};
+const isRecordLike = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const nativeExtensionTarget = (platform, arch) => {
 	if (arch !== "arm64" && arch !== "x64") throw new Error(`unsupported native extension architecture: ${arch}`);
 	return `${platform}-${arch}`;
@@ -351,6 +483,23 @@ const resolveAccessibleLibrary = async (path, target, packageName) => {
 };
 //#endregion
 //#region src/client.ts
+/**
+* Typed rejection for synchronous broker error frames: carries the wire
+* `code`, the structured `details` payload when the error family freezes one,
+* and the transport cause when relevant. Consumers match on `code`; the human
+* `message` is not a contract. The deferred-operation rejection counterpart
+* is `ExtensionOperationError` (same `{ code, message, details }` family).
+*/
+var BrokerServerError = class extends Error {
+	code;
+	details;
+	constructor(code, message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "BrokerServerError";
+		this.code = code;
+		if (options.details !== void 0) this.details = options.details;
+	}
+};
 const createInitFrame = (clientVersion) => ({
 	type: "init",
 	protocolVersion: PROTOCOL_VERSION$1,
@@ -472,9 +621,24 @@ function createTrayHandle(transport, appId, trayId, nextRequestId = createReques
 			});
 			if (response.type === "ack") {
 				expectResponse(response, requestId, "ack");
-				return [];
+				return {
+					kind: "immediate",
+					events: []
+				};
 			}
-			return expectResponse(response, requestId, "ext-command-result").events;
+			if (response.type === "ext-operation-terminal") {
+				const payload = response.payload;
+				if (payload.kind !== "result") throw new Error(`transport settled a deferred request with an error terminal for ${requestId}`);
+				return {
+					kind: "terminal",
+					operationId: response.operationId,
+					value: payload.value
+				};
+			}
+			return {
+				kind: "immediate",
+				events: expectResponse(response, requestId, "ext-command-result").events
+			};
 		},
 		extend(extension, options) {
 			const context = createTrayExtensionContext(handle, appId, extension, options, nextMountId, sessionId);
@@ -665,7 +829,7 @@ const createRequestIdFactory = (prefix) => {
 	};
 };
 const expectResponse = (frame, requestId, type) => {
-	if (frame.type === "error") throw new Error(`${frame.code}: ${frame.message}`);
+	if (frame.type === "error") throw new BrokerServerError(frame.code, frame.message, { details: frame.details });
 	if (frame.type !== type) throw new Error(`expected ${type} for ${requestId}, received ${frame.type}`);
 	if (requestIdOf(frame) !== requestId) throw new Error(`expected response for ${requestId}, received ${requestIdOf(frame) ?? "none"}`);
 	return frame;
@@ -681,6 +845,8 @@ const requestIdOf = (frame) => {
 		case "ext-command-result":
 		case "runtime-host-health": return frame.requestId;
 		case "error": return frame.requestId;
+		case "ext-command-accepted":
+		case "ext-operation-terminal":
 		case "ready":
 		case "event":
 		case "app-event":
@@ -1365,6 +1531,50 @@ const packageJsonUrl = new URL("../package.json", import.meta.url);
 * state instead of a failure (P3.6 quit-path finding, 2026-09-12).
 */
 const BROKER_CONNECTION_CLOSED_MESSAGE = "broker connection closed";
+/**
+* Generic transport-close rejection code for every pending deferred operation
+* (add-ext-dialog section 5.1 frozen): the core client carries no extension-specific
+* branch. Extension facades map this shared code onto their public surface
+* (e.g. ext-dialog's `dialog_transport_closed`) - that mapping is facade work,
+* never core work.
+*/
+const EXTENSION_TRANSPORT_CLOSED_CODE = "extension_transport_closed";
+/**
+* Typed rejection every deferred operation settles with: the `error` payload
+* branch of an `ext-operation-terminal` frame, or the generic
+* `extension_transport_closed` rejection when the transport dies while an
+* operation is pending. Consumers match on `code`; the human `message` is not
+* a contract. `details` carries the wire error's structured payload when the
+* extension supplied one.
+*/
+var ExtensionOperationError = class extends Error {
+	code;
+	details;
+	constructor(code, message, options = {}) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "ExtensionOperationError";
+		this.code = code;
+		if (options.details !== void 0) this.details = options.details;
+	}
+};
+const extensionTransportClosedError = (cause) => new ExtensionOperationError(EXTENSION_TRANSPORT_CLOSED_CODE, "the broker transport closed while a deferred extension operation was pending", { cause });
+/**
+* Typed handshake rejection for a Ready frame whose protocol version does not
+* equal the version this client sent in its Init frame: a structurally valid
+* Ready frame alone must never accept the session (add-ext-dialog batch A
+* review P1-9). The message names both sides; consumers may match
+* `instanceof` or the two numeric fields.
+*/
+var BrokerProtocolVersionError = class extends Error {
+	clientProtocolVersion;
+	brokerProtocolVersion;
+	constructor(clientProtocolVersion, brokerProtocolVersion) {
+		super(`broker protocol version mismatch: client=${clientProtocolVersion} broker=${brokerProtocolVersion}`);
+		this.name = "BrokerProtocolVersionError";
+		this.clientProtocolVersion = clientProtocolVersion;
+		this.brokerProtocolVersion = brokerProtocolVersion;
+	}
+};
 const connectLocalBroker = async (options = {}) => {
 	const packageVersion = options.packageVersion ?? await readPackageVersion(packageJsonUrl);
 	const clientVersion = options.clientVersion ?? packageVersion;
@@ -1456,6 +1666,8 @@ var LocalBrokerConnection = class {
 	buffer = "";
 	listeners = /* @__PURE__ */ new Set();
 	pending = /* @__PURE__ */ new Map();
+	/** operationId -> requestId of accepted-but-unsettled deferred operations. */
+	deferredOperations = /* @__PURE__ */ new Map();
 	deadListeners = /* @__PURE__ */ new Set();
 	deadError;
 	ready;
@@ -1496,6 +1708,7 @@ var LocalBrokerConnection = class {
 			clientVersion
 		});
 		const frame = await ready;
+		if (frame.protocolVersion !== protocolVersion) throw new BrokerProtocolVersionError(protocolVersion, frame.protocolVersion);
 		if (!brokerArtifactIdentityEquals(frame.brokerArtifactIdentity, expectedBrokerArtifactIdentity)) throw new Error(`broker artifact identity mismatch: expected=${JSON.stringify(expectedBrokerArtifactIdentity)} actual=${JSON.stringify(frame.brokerArtifactIdentity)}`);
 		this.sessionId = frame.sessionId;
 	}
@@ -1549,7 +1762,7 @@ var LocalBrokerConnection = class {
 			return;
 		}
 		if (frame.type === "error") {
-			const error = /* @__PURE__ */ new Error(`${frame.code}: ${frame.message}`);
+			const error = new BrokerServerError(frame.code, frame.message, { details: frame.details });
 			if (frame.requestId !== void 0) {
 				this.pending.get(frame.requestId)?.reject(error);
 				this.pending.delete(frame.requestId);
@@ -1563,6 +1776,14 @@ var LocalBrokerConnection = class {
 			this.rejectAll(error);
 			return;
 		}
+		if (frame.type === "ext-command-accepted") {
+			this.acceptDeferredOperation(frame.requestId, frame.operationId);
+			return;
+		}
+		if (frame.type === "ext-operation-terminal") {
+			this.settleDeferredOperation(frame.operationId, frame.payload);
+			return;
+		}
 		const requestId = responseRequestId(frame);
 		if (requestId !== void 0) {
 			this.pending.get(requestId)?.resolve(frame);
@@ -1574,21 +1795,72 @@ var LocalBrokerConnection = class {
 	write(frame) {
 		this.socket.write(`${JSON.stringify(frame)}\n`);
 	}
+	/**
+	* Pending-until-final acceptance (add-ext-dialog section 5.1): acceptance never
+	* settles the request. The broker's owner loop guarantees exactly one
+	* terminal per operation; a second acceptance for the same request or an
+	* already-bound operationId is defensively ignored, never a second
+	* registration.
+	*/
+	acceptDeferredOperation(requestId, operationId) {
+		const entry = this.pending.get(requestId);
+		if (entry === void 0 || entry.deferredOperation !== void 0) return;
+		if (this.deferredOperations.has(operationId)) return;
+		entry.deferredOperation = operationId;
+		this.deferredOperations.set(operationId, requestId);
+	}
+	/**
+	* The single terminal settlement: resolves the still-pending request with
+	* the terminal frame (`payload.kind === "result"`), or rejects it with the
+	* typed wire error (`"error"`). Terminals for unknown or already-settled
+	* operationIds are silently dropped - the broker side already settles
+	* through a one-shot CAS; the client mirrors that stateless drop instead of
+	* guessing an owner.
+	*/
+	settleDeferredOperation(operationId, payload) {
+		const requestId = this.deferredOperations.get(operationId);
+		if (requestId === void 0) return;
+		const entry = this.pending.get(requestId);
+		this.deferredOperations.delete(operationId);
+		this.pending.delete(requestId);
+		if (entry === void 0) return;
+		if (payload.kind === "result") {
+			const terminal = {
+				type: "ext-operation-terminal",
+				operationId,
+				payload
+			};
+			entry.resolve(terminal);
+			return;
+		}
+		const wireError = payload.error;
+		entry.reject(new ExtensionOperationError(wireError.code, wireError.message, { details: wireError.details }));
+	}
 	rejectAll(error) {
 		this.ready?.reject(error);
 		this.ready = void 0;
 		for (const pending of this.pending.values()) pending.reject(error);
 		this.pending.clear();
+		this.deferredOperations.clear();
 	}
 	/**
 	* Terminal connection-death transition (D3): first socket error/close wins,
 	* rejects everything pending, and notifies every terminal listener exactly
 	* once. Later terminal events are no-ops.
+	*
+	* Pending-until-final (add-ext-dialog section 5.1): accepted deferred operations
+	* reject with the generic typed `extension_transport_closed` (the core
+	* client has no extension-name branch); every ordinary pending request
+	* keeps the plain transport sentinel.
 	*/
 	markDead(error) {
 		if (this.deadError !== void 0) return;
 		this.deadError = error;
-		this.rejectAll(error);
+		this.ready?.reject(error);
+		this.ready = void 0;
+		for (const pending of this.pending.values()) pending.reject(pending.deferredOperation === void 0 ? error : extensionTransportClosedError(error));
+		this.pending.clear();
+		this.deferredOperations.clear();
 		for (const listener of [...this.deadListeners]) try {
 			listener(error);
 		} catch {}
@@ -1612,6 +1884,8 @@ const responseRequestId = (frame) => {
 		case "ack":
 		case "ext-command-result":
 		case "runtime-host-health": return frame.requestId;
+		case "ext-command-accepted":
+		case "ext-operation-terminal":
 		case "ready":
 		case "event":
 		case "app-event":
@@ -1861,6 +2135,6 @@ const bindMenuClickHandlers = (tray, handlers) => {
 };
 const noop = () => {};
 //#endregion
-export { AppIconVariantNotFoundError, BROKER_CONNECTION_CLOSED_MESSAGE, DEFAULT_APP_ICON_VARIANT, InvalidAppIconError, NativeExtensionArtifactResolutionError, PROTOCOL_VERSION, createBrokerEndpointIdentity, createClient, createInitFrame, createTray, createTrayHandle, formatBrokerEndpointName, formatBrokerStateRoot, formatUnixSocketPath, formatWindowsPipeName, isSupportedProtocolVersion, resolveNativeExtensionArtifact, validateAppIcon };
+export { AppIconVariantNotFoundError, BROKER_CONNECTION_CLOSED_MESSAGE, BrokerProtocolVersionError, BrokerServerError, DEFAULT_APP_ICON_VARIANT, EMBEDDED_STAGING_MANIFEST_PATH, EXTENSION_EVENT_RECORD_MAX_BYTES, EXTENSION_TRANSPORT_CLOSED_CODE, ExtensionOperationError, InvalidAppIconError, NATIVE_EXTENSION_EMBEDDED_ERROR_CODES, NATIVE_EXTENSION_EMBEDDED_TARGET_MATRIX, NativeExtensionArtifactResolutionError, NativeExtensionEmbeddedArtifactError, PROTOCOL_VERSION, createBrokerEndpointIdentity, createClient, createInitFrame, createTray, createTrayHandle, formatBrokerEndpointName, formatBrokerStateRoot, formatUnixSocketPath, formatWindowsPipeName, isSupportedProtocolVersion, resolveNativeExtensionArtifact, validateAppIcon };
 
 //# sourceMappingURL=index.mjs.map