@unified-desktop/bridge 0.0.0-stage → 0.2.4

package/dist/chunk-XDKQZC4S.js

@@ -0,0 +1,936 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/config.ts
+var defaults = {
+  runtimePermissions: Object.fromEntries(["microphone", "notifications", "clipboard-read", "clipboard-write", "file-read", "file-write", "file-download", "directory-read", "directory-write"].map((name) => [name, { enabled: true }])),
+  externalProtocols: ["https:", "mailto:"],
+  updater: { enabled: false, channel: "stable", requestTimeoutMs: 3e4 }
+};
+var configuration = defaults;
+var locked = false;
+function configureBridge(config) {
+  if (locked) throw new Error("Configure the bridge before resolving it.");
+  configuration = { ...defaults, ...config };
+}
+function getBridgeConfig() {
+  return configuration;
+}
+function lockBridgeConfig() {
+  locked = true;
+}
+
+// src/errors.ts
+var BridgeError = class extends Error {
+  constructor({ code, message, retryable }) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "retryable");
+    this.name = "BridgeError";
+    this.code = code;
+    this.retryable = retryable;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var knownErrorCodes = /* @__PURE__ */ new Set([
+  "CANCELLED",
+  "PERMISSION_DENIED",
+  "NOT_FOUND",
+  "UNSUPPORTED",
+  "INVALID_INPUT",
+  "NETWORK_ERROR",
+  "UNKNOWN"
+]);
+function isErrorPayload(value) {
+  return typeof value === "object" && value !== null && "message" in value;
+}
+function toBridgeError(error, fallback = {
+  code: "UNKNOWN",
+  retryable: false
+}) {
+  if (error instanceof BridgeError) return error;
+  if (isErrorPayload(error)) {
+    const code = knownErrorCodes.has(error.code) ? error.code : fallback.code;
+    return new BridgeError({
+      code,
+      message: String(error.message),
+      retryable: typeof error.retryable === "boolean" ? error.retryable : fallback.retryable
+    });
+  }
+  return new BridgeError({
+    ...fallback,
+    message: error instanceof Error ? error.message : String(error)
+  });
+}
+
+// src/common/clipboard.ts
+function createClipboardBridge() {
+  return {
+    async readText() {
+      try {
+        if (!navigator.clipboard?.readText) throw new Error("Clipboard API is unavailable.");
+        return await navigator.clipboard.readText();
+      } catch (error) {
+        throw new BridgeError({
+          code: "PERMISSION_DENIED",
+          message: error instanceof Error ? error.message : "Unable to read clipboard.",
+          retryable: false
+        });
+      }
+    },
+    async writeText(text) {
+      try {
+        if (!navigator.clipboard?.writeText) throw new Error("Clipboard API is unavailable.");
+        await navigator.clipboard.writeText(text);
+      } catch (error) {
+        throw new BridgeError({
+          code: "PERMISSION_DENIED",
+          message: error instanceof Error ? error.message : "Unable to write clipboard.",
+          retryable: false
+        });
+      }
+    }
+  };
+}
+
+// src/common/deep-link.ts
+function createWebDeepLinkBridge() {
+  return {
+    async getInitialUrl() {
+      return null;
+    },
+    subscribe(listener) {
+      const handleChange = () => listener(window.location.href);
+      window.addEventListener("popstate", handleChange);
+      window.addEventListener("hashchange", handleChange);
+      return () => {
+        window.removeEventListener("popstate", handleChange);
+        window.removeEventListener("hashchange", handleChange);
+      };
+    }
+  };
+}
+
+// src/common/dialog.ts
+function createDialogBridge() {
+  return {
+    async alert(message, title) {
+      window.alert(title ? `${title}
+
+${message}` : message);
+    },
+    async confirm(message, title) {
+      return window.confirm(title ? `${title}
+
+${message}` : message);
+    },
+    async prompt(message, defaultValue, title) {
+      return window.prompt(title ? `${title}
+
+${message}` : message, defaultValue ?? "");
+    }
+  };
+}
+
+// src/common/file-system.ts
+function createWebFileSystemBridge() {
+  const handles = /* @__PURE__ */ new Map();
+  const assertEnabled = (name) => {
+    if (getBridgeConfig().runtimePermissions?.[name]?.enabled !== true) throw new BridgeError({ code: "PERMISSION_DENIED", message: `The ${name} capability is disabled by security policy.`, retryable: false });
+  };
+  const bridge = {
+    hasPermission(name, id) {
+      const handle = handles.get(id);
+      return Boolean(handle && handle.permission === name);
+    },
+    async readTextFile(path) {
+      assertEnabled("file-read");
+      if (getBridgeConfig().runtimePermissions?.["file-read"]?.requirePicker !== false) throw new BridgeError({ code: "PERMISSION_DENIED", message: "Select a file and use its handle to read it.", retryable: false });
+      try {
+        const response = await fetch(path);
+        if (!response.ok) {
+          throw new BridgeError({
+            code: response.status === 404 ? "NOT_FOUND" : "NETWORK_ERROR",
+            message: `Unable to read ${path} (${response.status}).`,
+            retryable: response.status >= 500
+          });
+        }
+        return response.text();
+      } catch (error) {
+        throw toBridgeError(error, { code: "NETWORK_ERROR", retryable: true });
+      }
+    },
+    async saveTextFile({ suggestedName, contents }) {
+      assertEnabled("file-download");
+      if (getBridgeConfig().runtimePermissions?.["file-download"]?.requirePicker !== false) {
+        const handle = await bridge.pickSaveFile({ defaultPath: suggestedName, permission: "file-download" });
+        if (!handle) throw new BridgeError({ code: "CANCELLED", message: "File save was cancelled.", retryable: false });
+        try {
+          await bridge.writeFile(handle, new TextEncoder().encode(contents));
+        } finally {
+          await bridge.releaseFileHandle(handle);
+        }
+        return;
+      }
+      try {
+        const blob = new Blob([contents], { type: "text/plain;charset=utf-8" });
+        const objectUrl = URL.createObjectURL(blob);
+        const anchor = document.createElement("a");
+        anchor.href = objectUrl;
+        anchor.download = suggestedName;
+        anchor.click();
+        URL.revokeObjectURL(objectUrl);
+      } catch (error) {
+        throw toBridgeError(error);
+      }
+    },
+    async pickFiles(options) {
+      assertEnabled("file-read");
+      if (typeof document === "undefined") return [];
+      return new Promise((resolve) => {
+        const input = document.createElement("input");
+        input.type = "file";
+        input.multiple = options?.multiple === true;
+        input.accept = options?.filters?.flatMap((filter) => filter.extensions.map((extension) => `.${extension.replace(/^\./, "")}`)).join(",") ?? "";
+        input.onchange = () => {
+          const selected = Array.from(input.files ?? []).map((file) => {
+            const id = crypto.randomUUID();
+            handles.set(id, { file, permission: "file-read" });
+            return { id, name: file.name, kind: "file", writable: false, size: file.size };
+          });
+          resolve(selected);
+        };
+        input.oncancel = () => resolve([]);
+        input.click();
+      });
+    },
+    async pickDirectory(options) {
+      assertEnabled(options?.writable ? "directory-write" : "directory-read");
+      throw new BridgeError({ code: "UNSUPPORTED", message: "A native directory dialog is unavailable in the browser.", retryable: false });
+    },
+    async pickSaveFile(options) {
+      const permission = options?.permission ?? "file-write";
+      if (!["file-write", "file-download"].includes(permission)) throw new BridgeError({ code: "INVALID_INPUT", message: "Invalid save permission.", retryable: false });
+      assertEnabled(permission);
+      const browser = typeof window === "undefined" ? void 0 : window;
+      if (!browser?.showSaveFilePicker) throw new BridgeError({ code: "UNSUPPORTED", message: "A save picker is unavailable in this browser.", retryable: false });
+      try {
+        const save = await browser.showSaveFilePicker({ suggestedName: options?.defaultPath });
+        const id = crypto.randomUUID();
+        handles.set(id, { save, permission });
+        return { id, name: save.name, kind: "file", writable: true };
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") return null;
+        throw toBridgeError(error);
+      }
+    },
+    async readFile(handle) {
+      assertEnabled("file-read");
+      const file = handles.get(handle.id)?.file;
+      if (!file) throw new BridgeError({ code: "NOT_FOUND", message: "The file handle is no longer available.", retryable: false });
+      return new Uint8Array(await file.arrayBuffer());
+    },
+    async writeFile(handle, data) {
+      const owned = handles.get(handle.id);
+      if (!owned) throw new BridgeError({ code: "NOT_FOUND", message: "The file handle is no longer available.", retryable: false });
+      assertEnabled(owned.permission);
+      if (!owned.save) throw new BridgeError({ code: "PERMISSION_DENIED", message: "This file handle is read-only.", retryable: false });
+      const writer = await owned.save.createWritable();
+      try {
+        await writer.write(data);
+        await writer.close();
+      } catch (error) {
+        await writer.abort?.().catch(() => void 0);
+        throw toBridgeError(error);
+      }
+    },
+    async releaseFileHandle(handle) {
+      handles.delete(handle.id);
+    }
+  };
+  return bridge;
+}
+
+// src/common/http.ts
+function buildUrl(baseUrl, input) {
+  const fallbackBase = typeof window !== "undefined" ? window.location.href : "http://localhost/";
+  const url = new URL(input.url, baseUrl || fallbackBase);
+  for (const [key, value] of Object.entries(input.query ?? {})) {
+    if (value !== null && value !== void 0) url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function prepareBody(body, headers) {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string" || body instanceof Blob || body instanceof ArrayBuffer || body instanceof FormData || body instanceof URLSearchParams) {
+    return body;
+  }
+  if (!headers.has("content-type")) headers.set("content-type", "application/json");
+  return JSON.stringify(body);
+}
+function createTimeoutSignal(signal, timeoutMs) {
+  if (!timeoutMs && !signal) return { signal: void 0, cleanup: () => void 0 };
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  const timeout = timeoutMs ? globalThis.setTimeout(() => controller.abort(), timeoutMs) : void 0;
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      signal?.removeEventListener("abort", abort);
+      if (timeout !== void 0) globalThis.clearTimeout(timeout);
+    }
+  };
+}
+function createHttpClient(options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  return {
+    async request(input) {
+      const headers = new Headers(input.headers);
+      const { signal, cleanup } = createTimeoutSignal(input.signal, input.timeoutMs);
+      try {
+        const response = await fetchImpl(buildUrl(options.baseUrl ?? "", input), {
+          method: input.method ?? "GET",
+          headers,
+          body: prepareBody(input.body, headers),
+          signal
+        });
+        if (!response.ok) {
+          throw new BridgeError({
+            code: response.status >= 500 ? "NETWORK_ERROR" : "UNKNOWN",
+            message: `HTTP ${response.status} for ${input.method ?? "GET"} ${input.url}`,
+            retryable: response.status >= 500
+          });
+        }
+        const responseType = input.responseType ?? "json";
+        const data = responseType === "arrayBuffer" ? await response.arrayBuffer() : responseType === "text" ? await response.text() : await response.text().then((text) => text ? JSON.parse(text) : void 0);
+        return { status: response.status, headers: response.headers, data };
+      } catch (error) {
+        if (error instanceof BridgeError) throw error;
+        throw new BridgeError({
+          code: input.signal?.aborted ? "CANCELLED" : "NETWORK_ERROR",
+          message: error instanceof Error ? error.message : "HTTP request failed.",
+          retryable: !input.signal?.aborted
+        });
+      } finally {
+        cleanup();
+      }
+    }
+  };
+}
+
+// src/common/logging.ts
+function createLogger(runtime, sink) {
+  const write = (level, message, context) => {
+    sink?.(level, message, { runtime, ...context });
+    const method = level === "debug" ? console.debug : console[level];
+    method(`[${runtime}] ${message}`, context ?? "");
+  };
+  return {
+    debug: (message, context) => write("debug", message, context),
+    info: (message, context) => write("info", message, context),
+    warn: (message, context) => write("warn", message, context),
+    error: (message, context) => write("error", message, context)
+  };
+}
+
+// src/common/notification.ts
+function createNotificationBridge() {
+  return {
+    async requestPermission() {
+      if (!("Notification" in window)) return "denied";
+      return Notification.requestPermission();
+    },
+    async show(input) {
+      if (!("Notification" in window)) {
+        throw new BridgeError({ code: "UNSUPPORTED", message: "Notifications are unavailable.", retryable: false });
+      }
+      const permission = Notification.permission === "default" ? await Notification.requestPermission() : Notification.permission;
+      if (permission !== "granted") {
+        throw new BridgeError({ code: "PERMISSION_DENIED", message: "Notification permission was not granted.", retryable: false });
+      }
+      new Notification(input.title, { body: input.body, tag: input.tag });
+    }
+  };
+}
+
+// src/common/process.ts
+function createWebProcessBridge(runtime) {
+  const unsupported = (operation) => new BridgeError({
+    code: "UNSUPPORTED",
+    message: `${operation} is unavailable in a browser.`,
+    retryable: false
+  });
+  return {
+    async info() {
+      return { runtime, userAgent: navigator.userAgent };
+    },
+    async exit() {
+      throw unsupported("Exiting the process");
+    },
+    async restart() {
+      throw unsupported("Restarting the process");
+    }
+  };
+}
+
+// src/security.ts
+function assertSafeExternalUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new BridgeError({
+      code: "INVALID_INPUT",
+      message: "A valid external URL is required.",
+      retryable: false
+    });
+  }
+  if (!getBridgeConfig().externalProtocols?.includes(url.protocol)) {
+    throw new BridgeError({
+      code: "UNSUPPORTED",
+      message: `External protocol is not allowed: ${url.protocol}`,
+      retryable: false
+    });
+  }
+  return url.toString();
+}
+
+// src/common/shell.ts
+function createWebShellBridge() {
+  return {
+    async openExternal(url) {
+      const opened = window.open(assertSafeExternalUrl(url), "_blank", "noopener,noreferrer");
+      if (!opened) {
+        throw new BridgeError({ code: "PERMISSION_DENIED", message: "The browser blocked opening an external window.", retryable: false });
+      }
+    },
+    async openPath() {
+      throw new BridgeError({ code: "UNSUPPORTED", message: "Opening local paths is unavailable in a browser.", retryable: false });
+    },
+    async revealItem() {
+      throw new BridgeError({ code: "UNSUPPORTED", message: "Revealing local paths is unavailable in a browser.", retryable: false });
+    }
+  };
+}
+
+// src/common/updater.ts
+function createStubUpdaterBridge() {
+  return {
+    async check() {
+      return null;
+    },
+    async downloadAndInstall() {
+      throw new BridgeError({ code: "UNSUPPORTED", message: "The updater is not configured for this shell.", retryable: false });
+    },
+    subscribe() {
+      return () => void 0;
+    }
+  };
+}
+
+// src/common/upload.ts
+function createUploadBridge() {
+  return {
+    send(request) {
+      return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open(request.method ?? "POST", request.url);
+        for (const name of Object.keys(request.headers ?? {})) {
+          xhr.setRequestHeader(name, request.headers[name]);
+        }
+        if (request.timeoutMs) xhr.timeout = request.timeoutMs;
+        xhr.upload.onprogress = (event) => {
+          request.onProgress?.({
+            loaded: event.loaded,
+            total: event.lengthComputable ? event.total : void 0,
+            percent: event.lengthComputable ? event.loaded / event.total * 100 : void 0
+          });
+        };
+        xhr.onload = () => {
+          let data;
+          try {
+            const contentType = xhr.getResponseHeader("content-type") ?? "";
+            data = contentType.includes("application/json") ? JSON.parse(xhr.responseText || "null") : xhr.responseText;
+          } catch {
+            reject(new BridgeError({ code: "UNKNOWN", message: "Upload response was not valid JSON.", retryable: false }));
+            return;
+          }
+          if (xhr.status < 200 || xhr.status >= 300) {
+            reject(new BridgeError({ code: xhr.status >= 500 ? "NETWORK_ERROR" : "UNKNOWN", message: `Upload failed with HTTP ${xhr.status}.`, retryable: xhr.status >= 500 }));
+            return;
+          }
+          const headers = new Headers();
+          for (const line of xhr.getAllResponseHeaders().trim().split(/\r?\n/)) {
+            const separator = line.indexOf(":");
+            if (separator > 0) headers.append(line.slice(0, separator), line.slice(separator + 1).trim());
+          }
+          resolve({ status: xhr.status, headers, data });
+        };
+        xhr.onerror = () => reject(new BridgeError({ code: "NETWORK_ERROR", message: "Upload request failed.", retryable: true }));
+        xhr.ontimeout = () => reject(new BridgeError({ code: "NETWORK_ERROR", message: "Upload request timed out.", retryable: true }));
+        xhr.onabort = () => reject(new BridgeError({ code: "CANCELLED", message: "Upload was cancelled.", retryable: false }));
+        const abort = () => xhr.abort();
+        request.signal?.addEventListener("abort", abort, { once: true });
+        xhr.onloadend = () => request.signal?.removeEventListener("abort", abort);
+        if (request.signal?.aborted) {
+          xhr.abort();
+          return;
+        }
+        xhr.send(request.body);
+      });
+    }
+  };
+}
+
+// src/common/websocket.ts
+function assertWebSocketUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new BridgeError({ code: "INVALID_INPUT", message: "A valid WebSocket URL is required.", retryable: false });
+  }
+  if (!["ws:", "wss:"].includes(url.protocol)) {
+    throw new BridgeError({ code: "UNSUPPORTED", message: `WebSocket protocol is not allowed: ${url.protocol}`, retryable: false });
+  }
+  return url.toString();
+}
+var ReconnectingWebSocket = class {
+  constructor(options) {
+    __publicField(this, "options", options);
+    __publicField(this, "socket");
+    __publicField(this, "currentStatus", "idle");
+    __publicField(this, "retries", 0);
+    __publicField(this, "manuallyClosed", false);
+    __publicField(this, "connection");
+    __publicField(this, "rejectConnection");
+    __publicField(this, "reconnectTimer");
+    __publicField(this, "generation", 0);
+    __publicField(this, "messageListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "statusListeners", /* @__PURE__ */ new Set());
+  }
+  get status() {
+    return this.currentStatus;
+  }
+  setStatus(status2) {
+    this.currentStatus = status2;
+    for (const listener of this.statusListeners) listener(status2);
+  }
+  connect() {
+    if (this.connection) return this.connection;
+    this.manuallyClosed = false;
+    if (this.reconnectTimer) {
+      globalThis.clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+    this.setStatus("connecting");
+    const generation = ++this.generation;
+    this.connection = new Promise((resolve, reject) => {
+      this.rejectConnection = reject;
+      const socket = new WebSocket(this.options.url, this.options.protocols);
+      this.socket = socket;
+      const isCurrent = () => generation === this.generation && socket === this.socket;
+      const fail = (message) => {
+        if (isCurrent()) {
+          this.connection = void 0;
+          this.rejectConnection = void 0;
+          reject(new BridgeError({ code: "NETWORK_ERROR", message, retryable: true }));
+        }
+      };
+      socket.onopen = () => {
+        if (!isCurrent()) return;
+        this.retries = 0;
+        this.setStatus("open");
+        resolve();
+      };
+      socket.onmessage = (event) => {
+        if (!isCurrent()) return;
+        let data = event.data;
+        if (typeof event.data === "string") {
+          try {
+            data = JSON.parse(event.data);
+          } catch {
+          }
+        }
+        for (const listener of this.messageListeners) listener(data);
+      };
+      socket.onerror = () => {
+        if (this.currentStatus !== "open") fail("WebSocket connection failed.");
+      };
+      socket.onclose = () => {
+        if (!isCurrent()) return;
+        const wasConnecting = this.currentStatus === "connecting";
+        this.socket = void 0;
+        this.connection = void 0;
+        this.rejectConnection = void 0;
+        this.setStatus("closed");
+        if (wasConnecting) reject(new BridgeError({ code: "NETWORK_ERROR", message: "WebSocket closed before opening.", retryable: true }));
+        if (!this.manuallyClosed && this.options.reconnect && this.retries < (this.options.maxRetries ?? 5)) {
+          this.retries += 1;
+          this.reconnectTimer = globalThis.setTimeout(() => {
+            this.reconnectTimer = void 0;
+            void this.connect().catch(() => void 0);
+          }, this.options.retryDelayMs ?? 1e3);
+        }
+      };
+    });
+    return this.connection;
+  }
+  send(data) {
+    if (this.socket?.readyState !== WebSocket.OPEN) throw new BridgeError({ code: "UNSUPPORTED", message: "WebSocket is not open.", retryable: true });
+    this.socket.send(data);
+  }
+  close(code, reason) {
+    this.manuallyClosed = true;
+    this.generation += 1;
+    if (this.reconnectTimer) {
+      globalThis.clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+    const rejectConnection = this.rejectConnection;
+    this.connection = void 0;
+    this.rejectConnection = void 0;
+    if (this.currentStatus === "connecting") {
+      rejectConnection?.(new BridgeError({ code: "NETWORK_ERROR", message: "WebSocket connection was closed before opening.", retryable: true }));
+    }
+    this.socket?.close(code, reason);
+    this.socket = void 0;
+    this.setStatus("closed");
+  }
+  onMessage(listener) {
+    this.messageListeners.add(listener);
+    return () => this.messageListeners.delete(listener);
+  }
+  onStatus(listener) {
+    this.statusListeners.add(listener);
+    return () => this.statusListeners.delete(listener);
+  }
+};
+function createWebSocketBridge() {
+  return {
+    create: (options) => new ReconnectingWebSocket({ ...options, url: assertWebSocketUrl(options.url) })
+  };
+}
+
+// src/common/window-state.ts
+function createWebWindowStateBridge(runtime, key = "unified-desktop.window-state") {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    async get() {
+      try {
+        const raw = localStorage.getItem(key);
+        return raw ? JSON.parse(raw) : null;
+      } catch {
+        return null;
+      }
+    },
+    async set(bounds) {
+      localStorage.setItem(key, JSON.stringify(bounds));
+      for (const listener of listeners) listener(bounds);
+      window.dispatchEvent(new CustomEvent(`${runtime}:window-state`, { detail: bounds }));
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/common/store.ts
+var forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assertKey(key) {
+  if (typeof key !== "string" || key.trim() === "" || key.length > 256 || forbiddenKeys.has(key)) {
+    throw new BridgeError({ code: "INVALID_INPUT", message: "Store keys must be non-empty strings up to 256 characters.", retryable: false });
+  }
+  return key;
+}
+function assertValue(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0) throw new Error("undefined is not supported");
+    return JSON.parse(serialized);
+  } catch {
+    throw new BridgeError({ code: "INVALID_INPUT", message: "Store values must be JSON-serializable.", retryable: false });
+  }
+}
+function cloneValue(value) {
+  if (value === void 0) return value;
+  return JSON.parse(JSON.stringify(value));
+}
+function isStoreValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || ancestors.has(value)) return false;
+  ancestors.add(value);
+  const valid = Array.isArray(value) ? value.every((item) => isStoreValue(item, ancestors)) : Object.entries(value).every(([key, item]) => !forbiddenKeys.has(key) && isStoreValue(item, ancestors));
+  ancestors.delete(value);
+  return valid;
+}
+function readValues(storage, storageKey) {
+  const raw = storage.getItem(storageKey);
+  if (!raw) return /* @__PURE__ */ Object.create(null);
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !isStoreValue(parsed)) {
+      throw new Error("Store contains invalid JSON values.");
+    }
+    const values = /* @__PURE__ */ Object.create(null);
+    for (const [key, value] of Object.entries(parsed)) values[key] = value;
+    return values;
+  } catch {
+    throw new BridgeError({ code: "UNKNOWN", message: `Unable to parse store ${storageKey}.`, retryable: false });
+  }
+}
+function createMemoryStorage() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    get length() {
+      return values.size;
+    },
+    clear() {
+      values.clear();
+    },
+    getItem(key) {
+      return values.get(key) ?? null;
+    },
+    key(index) {
+      return Array.from(values.keys())[index] ?? null;
+    },
+    removeItem(key) {
+      values.delete(key);
+    },
+    setItem(key, value) {
+      values.set(key, value);
+    }
+  };
+}
+function createWebStoreBridge(storageKey = "unified-desktop-store", storage) {
+  const backingStorage = storage ?? (typeof localStorage !== "undefined" ? localStorage : createMemoryStorage());
+  let values = readValues(backingStorage, storageKey);
+  const listeners = /* @__PURE__ */ new Set();
+  const persist = () => {
+    try {
+      backingStorage.setItem(storageKey, JSON.stringify(values));
+    } catch (error) {
+      throw new BridgeError({
+        code: "UNKNOWN",
+        message: error instanceof Error ? error.message : `Unable to persist store ${storageKey}.`,
+        retryable: false
+      });
+    }
+  };
+  const notify = (change) => listeners.forEach((listener) => listener(change));
+  const onStorage = (event) => {
+    if (event.storageArea !== backingStorage || event.key !== storageKey) return;
+    const previous = values;
+    values = readValues(backingStorage, storageKey);
+    const keys = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(values)]);
+    for (const key of keys) {
+      const before = Object.hasOwn(previous, key) ? JSON.stringify(previous[key]) : void 0;
+      const after = Object.hasOwn(values, key) ? JSON.stringify(values[key]) : void 0;
+      if (before !== after) notify({ key, value: cloneValue(values[key]) });
+    }
+  };
+  if (typeof window !== "undefined") window.addEventListener("storage", onStorage);
+  return {
+    async get(key) {
+      return cloneValue(values[assertKey(key)]);
+    },
+    async set(key, value) {
+      const safeKey = assertKey(key);
+      values[safeKey] = assertValue(value);
+      persist();
+      notify({ key: safeKey, value: cloneValue(values[safeKey]) });
+    },
+    async has(key) {
+      return Object.hasOwn(values, assertKey(key));
+    },
+    async delete(key) {
+      const safeKey = assertKey(key);
+      if (!Object.hasOwn(values, safeKey)) return false;
+      delete values[safeKey];
+      persist();
+      notify({ key: safeKey, value: void 0 });
+      return true;
+    },
+    async clear() {
+      const previousKeys = Object.keys(values);
+      values = /* @__PURE__ */ Object.create(null);
+      persist();
+      previousKeys.forEach((key) => notify({ key, value: void 0 }));
+    },
+    async keys() {
+      return Object.keys(values);
+    },
+    async entries() {
+      return Object.entries(values).map(([key, value]) => [key, cloneValue(value)]);
+    },
+    async save() {
+      persist();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    dispose() {
+      if (typeof window !== "undefined") window.removeEventListener("storage", onStorage);
+      listeners.clear();
+    }
+  };
+}
+
+// src/common/secure-storage.ts
+function createStubSecureStorageBridge() {
+  const unsupported = () => new BridgeError({
+    code: "UNSUPPORTED",
+    message: "Secure storage is unavailable in this runtime.",
+    retryable: false
+  });
+  return {
+    async get() {
+      throw unsupported();
+    },
+    async set() {
+      throw unsupported();
+    },
+    async has() {
+      throw unsupported();
+    },
+    async delete() {
+      throw unsupported();
+    }
+  };
+}
+
+// src/common/permissions.ts
+function status(name, state, scope) {
+  return scope ? { name, state, scope } : { name, state };
+}
+function isEnabled(name) {
+  return getBridgeConfig().runtimePermissions?.[name]?.enabled === true;
+}
+function browserPermissionName(name) {
+  if (name === "microphone" || name === "camera") return name;
+  if (name === "notifications") return "notifications";
+  if (name === "clipboard-read" || name === "clipboard-write") return name;
+  return void 0;
+}
+async function queryBrowser(name) {
+  if (!isEnabled(name)) return status(name, "unsupported");
+  if (name === "file-download") return getBridgeConfig().runtimePermissions?.[name]?.requirePicker !== false ? status(name, "prompt", "save-dialog") : status(name, "granted", "browser-download");
+  if (name.startsWith("file-") || name.startsWith("directory-")) return status(name, "prompt", "native-dialog");
+  if (typeof navigator === "undefined") return status(name, "unsupported");
+  const permissionName = browserPermissionName(name);
+  if (!permissionName || !navigator.permissions?.query) return status(name, "prompt");
+  try {
+    const result = await navigator.permissions.query({ name: permissionName });
+    return status(name, result.state);
+  } catch {
+    return status(name, "prompt");
+  }
+}
+async function requestMedia(name) {
+  if (typeof navigator === "undefined") return status(name, "unsupported");
+  if (!navigator.mediaDevices?.getUserMedia) return status(name, "unsupported");
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia(name === "microphone" ? { audio: true } : { video: true });
+    stream.getTracks().forEach((track) => track.stop());
+    return status(name, "granted");
+  } catch (error) {
+    const normalized = toBridgeError(error, { code: "PERMISSION_DENIED", retryable: false });
+    return status(name, normalized.code === "UNSUPPORTED" ? "unsupported" : "denied");
+  }
+}
+function createWebPermissionBridge(hasPermission = () => false) {
+  return {
+    async query(name, options) {
+      if (!isEnabled(name)) return status(name, "unsupported");
+      if (options?.handleId && (name.startsWith("file-") || name.startsWith("directory-"))) {
+        return status(name, hasPermission(name, options.handleId) ? "granted" : "denied", "selected-handle");
+      }
+      return queryBrowser(name);
+    },
+    async request(name, options) {
+      if (!isEnabled(name)) return status(name, "unsupported");
+      if (options?.handleId && (name.startsWith("file-") || name.startsWith("directory-"))) {
+        return status(name, hasPermission(name, options.handleId) ? "granted" : "denied", "selected-handle");
+      }
+      if (name === "microphone" || name === "camera") return requestMedia(name);
+      if (name === "notifications") {
+        if (typeof window === "undefined" || !("Notification" in window)) return status(name, "unsupported");
+        const permission = await Notification.requestPermission();
+        return status(name, permission === "default" ? "prompt" : permission);
+      }
+      return queryBrowser(name);
+    }
+  };
+}
+
+// src/common/bridge.ts
+function mergeCapability(base, override) {
+  return { ...base, ...override };
+}
+function createCommonBridge(runtime, baseOverrides = {}, customOverrides = {}) {
+  const overrides = { ...baseOverrides, ...customOverrides };
+  for (const name of ["fileSystem", "shell", "process", "deepLink", "updater", "windowState"]) {
+    if (customOverrides[name]) Object.assign(overrides, { [name]: { ...baseOverrides[name], ...customOverrides[name] } });
+  }
+  const { hasPermission, ...webFiles } = createWebFileSystemBridge();
+  const fileSystem = mergeCapability(webFiles, overrides.fileSystem);
+  const shell = mergeCapability(createWebShellBridge(), overrides.shell);
+  const process = mergeCapability(createWebProcessBridge(runtime), overrides.process);
+  const deepLink = mergeCapability(createWebDeepLinkBridge(), overrides.deepLink);
+  const updater = mergeCapability(createStubUpdaterBridge(), overrides.updater);
+  const windowState = mergeCapability(createWebWindowStateBridge(runtime), overrides.windowState);
+  return {
+    runtime,
+    http: overrides.http ?? createHttpClient({ baseUrl: getBridgeConfig().apiBaseUrl }),
+    logger: overrides.logger ?? createLogger(runtime),
+    fileSystem,
+    deepLink,
+    clipboard: overrides.clipboard ?? createClipboardBridge(),
+    dialog: overrides.dialog ?? createDialogBridge(),
+    notification: overrides.notification ?? createNotificationBridge(),
+    process,
+    shell,
+    updater,
+    upload: overrides.upload ?? createUploadBridge(),
+    websocket: overrides.websocket ?? createWebSocketBridge(),
+    store: overrides.store ?? createWebStoreBridge(),
+    secureStorage: overrides.secureStorage ?? createStubSecureStorageBridge(),
+    permissions: overrides.permissions ?? createWebPermissionBridge(hasPermission),
+    windowState,
+    readTextFile: fileSystem.readTextFile,
+    saveTextFile: fileSystem.saveTextFile,
+    openExternal: shell.openExternal,
+    checkUpdate: updater.check
+  };
+}
+
+export {
+  configureBridge,
+  getBridgeConfig,
+  lockBridgeConfig,
+  BridgeError,
+  toBridgeError,
+  createClipboardBridge,
+  createWebDeepLinkBridge,
+  createDialogBridge,
+  createWebFileSystemBridge,
+  createHttpClient,
+  createLogger,
+  createNotificationBridge,
+  createWebProcessBridge,
+  assertSafeExternalUrl,
+  createWebShellBridge,
+  createStubUpdaterBridge,
+  createUploadBridge,
+  createWebSocketBridge,
+  createWebWindowStateBridge,
+  createWebStoreBridge,
+  createStubSecureStorageBridge,
+  createWebPermissionBridge,
+  createCommonBridge
+};