@stacksjs/desktop 0.2.196 → 0.2.198

package/dist/browser.js

@@ -1,3910 +1,116 @@
 // @bun
-var __require = import.meta.require;
-
-// src/alerts.ts
-function hasNativeNotificationSupport() {
-  if (typeof Notification !== "undefined" && Notification.permission === "granted") {
-    return true;
-  }
-  return false;
-}
-function isBrowser() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-async function requestNotificationPermission() {
-  if (typeof Notification === "undefined") {
-    return false;
-  }
-  if (Notification.permission === "granted") {
-    return true;
-  }
-  if (Notification.permission === "denied") {
-    return false;
-  }
-  const permission = await Notification.requestPermission();
-  return permission === "granted";
-}
-var activeAlerts = new Map;
-function generateAlertId() {
-  return `alert-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-function getAlertIcon(type) {
-  switch (type) {
-    case "info":
-      return "ℹ";
-    case "success":
-      return "✔";
-    case "warning":
-      return "⚠";
-    case "error":
-      return "✖";
-    default:
-      return "ℹ";
-  }
-}
-function getToastContainer(position = "top-right") {
-  if (!isBrowser()) {
-    throw new Error("Toast container requires browser environment");
-  }
-  try {
-    const existingContainer = document.querySelector(`.stx-toast-container[data-position="${position}"]`);
-    if (existingContainer) {
-      return existingContainer;
-    }
-  } catch {}
-  const container = document.createElement("div");
-  container.className = `stx-toast-container ${position}`;
-  container.dataset.position = position;
-  try {
-    if (document.body) {
-      document.body.appendChild(container);
-    }
-  } catch {}
-  return container;
-}
-function createToastHTML(state) {
-  const { options } = state;
-  const icon = getAlertIcon(options.type);
-  const typeClass = options.type || "info";
-  const hasClose = options.duration !== 0;
-  return `
-    <div class="stx-toast ${typeClass}" data-alert-id="${state.id}" role="alert" aria-live="polite">
-      <div class="stx-toast-icon">${icon}</div>
-      <div class="stx-toast-content">
-        ${options.title ? `<div class="stx-toast-title">${escapeHtml(options.title)}</div>` : ""}
-        <div class="stx-toast-message">${escapeHtml(options.message)}</div>
-      </div>
-      ${hasClose ? '<button class="stx-toast-close" aria-label="Close">&times;</button>' : ""}
-    </div>
-  `;
-}
-function escapeHtml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-function dismissAlert(state) {
-  if (state.timeout) {
-    clearTimeout(state.timeout);
-  }
-  activeAlerts.delete(state.id);
-  if (state.element && isBrowser()) {
-    state.element.classList.add("dismissing");
-    setTimeout(() => {
-      state.element?.remove();
-    }, 200);
-  }
-}
-async function showAlert(options) {
-  const id = generateAlertId();
-  const hasNative = hasNativeNotificationSupport();
-  const duration = options.duration ?? 5000;
-  const state = {
-    id,
-    options
-  };
-  activeAlerts.set(id, state);
-  if (hasNative && options.type !== "error") {
-    try {
-      const notification = new Notification(options.title || "Notification", {
-        body: options.message,
-        icon: options.type === "success" ? "\u2713" : options.type === "warning" ? "\u26A0" : "\u2139",
-        tag: id
-      });
-      notification.onclick = () => {
-        if (options.onClick) {
-          options.onClick();
-        }
-        notification.close();
-      };
-      if (duration > 0) {
-        state.timeout = setTimeout(() => {
-          notification.close();
-          activeAlerts.delete(id);
-        }, duration);
-      }
-      return;
-    } catch {}
-  }
-  if (isBrowser()) {
-    try {
-      const container = getToastContainer(options.position);
-      const wrapper = document.createElement("div");
-      wrapper.innerHTML = createToastHTML(state);
-      const toast = wrapper.firstElementChild;
-      if (!toast) {
-        const typeLabel = (options.type || "info").toUpperCase();
-        console.log(`[stx-alert] ${typeLabel}: ${options.title || ""}`);
-        console.log(`[stx-alert] ${options.message}`);
-        return;
-      }
-      state.element = toast;
-      try {
-        container.appendChild(toast);
-      } catch {
-        const typeLabel = (options.type || "info").toUpperCase();
-        console.log(`[stx-alert] ${typeLabel}: ${options.title || ""}`);
-        console.log(`[stx-alert] ${options.message}`);
-        return;
-      }
-      if (typeof requestAnimationFrame === "function") {
-        requestAnimationFrame(() => {
-          try {
-            toast.classList.add("visible");
-          } catch {}
-        });
-      }
-      try {
-        toast.addEventListener("click", (e) => {
-          if (e.target.classList?.contains("stx-toast-close")) {
-            dismissAlert(state);
-            return;
-          }
-          if (options.onClick) {
-            options.onClick();
-          }
-        });
-      } catch {}
-      if (duration > 0) {
-        state.timeout = setTimeout(() => {
-          dismissAlert(state);
-        }, duration);
-      }
-    } catch {
-      const typeLabel = (options.type || "info").toUpperCase();
-      console.log(`[stx-alert] ${typeLabel}: ${options.title || ""}`);
-      console.log(`[stx-alert] ${options.message}`);
-    }
-  } else {
-    const typeLabel = (options.type || "info").toUpperCase();
-    console.log(`[stx-alert] ${typeLabel}: ${options.title || ""}`);
-    console.log(`[stx-alert] ${options.message}`);
-    if (duration > 0) {
-      state.timeout = setTimeout(() => {
-        activeAlerts.delete(id);
-      }, duration);
-    }
-  }
-}
-async function showToast(options) {
-  return showAlert({
-    ...options,
-    position: options.position || "top-right"
-  });
-}
-async function showInfoToast(message, duration = 3000) {
-  return showToast({ message, type: "info", duration });
-}
-async function showSuccessToast(message, duration = 3000) {
-  return showToast({ message, type: "success", duration });
-}
-async function showWarningToast(message, duration = 3000) {
-  return showToast({ message, type: "warning", duration });
-}
-async function showErrorToast(message, duration = 5000) {
-  return showToast({ message, type: "error", duration });
-}
-async function notify(title, message, type = "info") {
-  return showAlert({ title, message, type });
-}
-function dismissAlertById(id) {
-  const state = activeAlerts.get(id);
-  if (state) {
-    dismissAlert(state);
-  }
-}
-function dismissAllAlerts() {
-  for (const state of activeAlerts.values()) {
-    dismissAlert(state);
-  }
-}
-function getActiveAlertCount() {
-  return activeAlerts.size;
-}
-var TOAST_STYLES = `
-.stx-toast-container {
-  position: fixed;
-  z-index: 10001;
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-  max-width: 400px;
-  pointer-events: none;
-}
-
-.stx-toast-container.top-left { top: 16px; left: 16px; }
-.stx-toast-container.top-center { top: 16px; left: 50%; transform: translateX(-50%); }
-.stx-toast-container.top-right { top: 16px; right: 16px; }
-.stx-toast-container.bottom-left { bottom: 16px; left: 16px; }
-.stx-toast-container.bottom-center { bottom: 16px; left: 50%; transform: translateX(-50%); }
-.stx-toast-container.bottom-right { bottom: 16px; right: 16px; }
-
-.stx-toast {
-  display: flex;
-  align-items: flex-start;
-  gap: 12px;
-  padding: 12px 16px;
-  background: #fff;
-  border-radius: 8px;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
-  pointer-events: auto;
-  cursor: pointer;
-  opacity: 0;
-  transform: translateY(-10px);
-  transition: opacity 0.2s, transform 0.2s;
-}
-
-.stx-toast.visible {
-  opacity: 1;
-  transform: translateY(0);
-}
-
-.stx-toast.dismissing {
-  opacity: 0;
-  transform: translateX(100%);
-}
-
-@media (prefers-color-scheme: dark) {
-  .stx-toast {
-    background: #2d2d2d;
-    color: #fff;
-  }
-}
-
-.stx-toast-icon {
-  font-size: 20px;
-  flex-shrink: 0;
-  margin-top: 2px;
-}
-
-.stx-toast.info .stx-toast-icon { color: #3498db; }
-.stx-toast.success .stx-toast-icon { color: #27ae60; }
-.stx-toast.warning .stx-toast-icon { color: #f39c12; }
-.stx-toast.error .stx-toast-icon { color: #e74c3c; }
-
-.stx-toast-content {
-  flex: 1;
-  min-width: 0;
-}
-
-.stx-toast-title {
-  font-weight: 600;
-  margin-bottom: 4px;
-}
-
-.stx-toast-message {
-  color: #666;
-  font-size: 14px;
-  line-height: 1.4;
-}
-
-@media (prefers-color-scheme: dark) {
-  .stx-toast-message { color: #aaa; }
-}
-
-.stx-toast-close {
-  background: none;
-  border: none;
-  font-size: 20px;
-  cursor: pointer;
-  opacity: 0.5;
-  padding: 0;
-  line-height: 1;
-  color: inherit;
-  transition: opacity 0.15s;
-}
-
-.stx-toast-close:hover {
-  opacity: 1;
-}
-
-/* Border accent for different types */
-.stx-toast.info { border-left: 4px solid #3498db; }
-.stx-toast.success { border-left: 4px solid #27ae60; }
-.stx-toast.warning { border-left: 4px solid #f39c12; }
-.stx-toast.error { border-left: 4px solid #e74c3c; }
-`;
-// src/_bridge.ts
-function hasBridge(ns) {
-  if (typeof window === "undefined")
-    return false;
-  const c = window.craft;
-  return !!(c && c[ns]);
-}
-function requireBridge(ns) {
-  if (!hasBridge(ns)) {
-    throw new Error(`craft.${ns} is not available \u2014 this API requires a Craft native window`);
-  }
-  return window.craft[ns];
-}
-function onCraftEvent(name, cb) {
-  if (typeof window === "undefined")
-    return () => {};
-  const h = (e) => cb(e.detail ?? {});
-  window.addEventListener(name, h);
-  return () => window.removeEventListener(name, h);
-}
-
-// src/app-info.ts
-var DEFAULT_INFO = { name: "", version: "0.0.0" };
-var app = {
-  async hideDockIcon() {
-    if (hasBridge("app"))
-      await window.craft.app.hideDockIcon();
-  },
-  async showDockIcon() {
-    if (hasBridge("app"))
-      await window.craft.app.showDockIcon();
-  },
-  async quit() {
-    if (hasBridge("app"))
-      await window.craft.app.quit();
-  },
-  async getInfo() {
-    if (!hasBridge("app"))
-      return DEFAULT_INFO;
-    const r = await window.craft.app.getInfo();
-    return { ...DEFAULT_INFO, ...r || {} };
-  },
-  async notify(options) {
-    if (!options.title)
-      throw new Error("notify: title is required");
-    if (hasBridge("app"))
-      await window.craft.app.notify(options);
-  },
-  async setBadge(count) {
-    if (hasBridge("app"))
-      await window.craft.app.setBadge(count);
-  },
-  async bounce(type = "informational") {
-    if (hasBridge("app"))
-      await window.craft.app.bounce(type);
-  }
-};
-// src/apple-script.ts
-var appleScript = {
-  async execute(source) {
-    if (!source)
-      throw new Error("appleScript.execute: source is required");
-    if (!hasBridge("appleScript"))
-      return { ok: false };
-    return await window.craft.appleScript.execute(source);
-  }
-};
-// src/audio.ts
-var webAudio = null;
-var audio = {
-  async play(path, options) {
-    if (hasBridge("audio")) {
-      return await window.craft.audio.play(path, options);
-    }
-    if (typeof window === "undefined" || typeof Audio === "undefined")
-      return false;
-    if (webAudio) {
-      webAudio.pause();
-      webAudio = null;
-    }
-    webAudio = new Audio(path);
-    if (options?.volume != null)
-      webAudio.volume = options.volume;
-    if (options?.loops)
-      webAudio.loop = true;
-    try {
-      await webAudio.play();
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  async playSystemSound(name) {
-    if (hasBridge("audio"))
-      return await window.craft.audio.playSystemSound(name);
-    if (typeof window === "undefined" || typeof Audio === "undefined")
-      return false;
-    try {
-      webAudio = new Audio(`/System/Library/Sounds/${name}.aiff`);
-      await webAudio.play();
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  async stop() {
-    if (hasBridge("audio")) {
-      await window.craft.audio.stop();
-      return;
-    }
-    if (webAudio) {
-      webAudio.pause();
-      webAudio.currentTime = 0;
-      webAudio = null;
-    }
-  },
-  async isPlaying() {
-    if (hasBridge("audio"))
-      return await window.craft.audio.isPlaying();
-    return !!(webAudio && !webAudio.paused);
-  },
-  async startRecording(path, options) {
-    if (hasBridge("audio"))
-      return await window.craft.audio.startRecording(path, options);
-    return false;
-  },
-  async stopRecording() {
-    if (hasBridge("audio"))
-      await window.craft.audio.stopRecording();
-  },
-  async isRecording() {
-    if (hasBridge("audio"))
-      return await window.craft.audio.isRecording();
-    return false;
-  }
-};
-// src/battery.ts
-var battery = {
-  async isCharging() {
-    if (hasBridge("power"))
-      return await window.craft.power.isCharging();
-    const b = await getWebBatteryManager();
-    return b ? !!b.charging : false;
-  },
-  async isPluggedIn() {
-    if (hasBridge("power"))
-      return await window.craft.power.isPluggedIn();
-    const b = await getWebBatteryManager();
-    return b ? !!b.charging || b.level >= 0.999 : false;
-  },
-  async isLowPowerMode() {
-    if (hasBridge("power"))
-      return await window.craft.power.isLowPowerMode();
-    return false;
-  },
-  async level() {
-    if (hasBridge("power")) {
-      const v = await window.craft.power.batteryLevel();
-      return typeof v === "number" ? v : null;
-    }
-    const b = await getWebBatteryManager();
-    return b ? b.level : null;
-  },
-  async timeRemaining() {
-    if (hasBridge("power")) {
-      const r = await window.craft.power.timeRemaining();
-      return typeof r === "number" ? r : null;
-    }
-    const b = await getWebBatteryManager();
-    if (!b)
-      return null;
-    const sec = b.charging ? b.chargingTime : b.dischargingTime;
-    return Number.isFinite(sec) ? Math.round(sec / 60) : null;
-  },
-  async thermalState() {
-    if (hasBridge("power")) {
-      const s = await window.craft.power.thermalState();
-      return s || "unknown";
-    }
-    return "unknown";
-  },
-  async uptimeSeconds() {
-    if (hasBridge("power"))
-      return await window.craft.power.uptimeSeconds();
-    if (typeof performance !== "undefined" && typeof performance.now === "function") {
-      return Math.round(performance.now() / 1000);
-    }
-    return 0;
-  },
-  async preventSleep(reason = "app is busy") {
-    if (hasBridge("power")) {
-      await window.craft.power.preventSleep(reason);
-      return;
-    }
-    if (typeof navigator === "undefined" || !navigator.wakeLock)
-      return;
-    const w = window;
-    if (w.__craftWebWakeLock?.release) {
-      try {
-        await w.__craftWebWakeLock.release();
-      } catch {}
-      w.__craftWebWakeLock = null;
-    }
-    try {
-      const sentinel = await navigator.wakeLock.request("screen");
-      w.__craftWebWakeLock = sentinel;
-    } catch {}
-  },
-  async allowSleep() {
-    if (hasBridge("power")) {
-      await window.craft.power.allowSleep();
-      return;
-    }
-    const s = window.__craftWebWakeLock;
-    if (s && typeof s.release === "function") {
-      try {
-        await s.release();
-      } catch {}
-      window.__craftWebWakeLock = null;
-    }
-  },
-  onSleep(cb) {
-    return onCraftEvent("craft:powerSleep", cb);
-  },
-  onWake(cb) {
-    return onCraftEvent("craft:powerWake", cb);
-  }
-};
-async function getWebBatteryManager() {
-  if (typeof navigator === "undefined")
-    return null;
-  const nav = navigator;
-  if (typeof nav.getBattery !== "function")
-    return null;
-  try {
-    return await nav.getBattery();
-  } catch {
-    return null;
-  }
-}
-// src/biometric.ts
-var biometric = {
-  async isAvailable() {
-    if (!hasBridge("biometric"))
-      return false;
-    return await window.craft.biometric.isAvailable();
-  },
-  async getBiometryType() {
-    if (!hasBridge("biometric"))
-      return "none";
-    return await window.craft.biometric.getBiometryType();
-  },
-  async evaluate(reason, options) {
-    if (!reason)
-      throw new Error("biometric.evaluate: reason is required");
-    if (!hasBridge("biometric"))
-      return { success: false, errorCode: -1 };
-    return await window.craft.biometric.evaluate(reason, options);
-  }
-};
-// src/bluetooth.ts
-var HEX_RE = /^[\da-f]*$/i;
-function assertHex(label, hex) {
-  if (typeof hex !== "string" || !HEX_RE.test(hex) || hex.length % 2 !== 0) {
-    throw new Error(`${label}: must be a hex string with even length, got ${JSON.stringify(hex)}`);
-  }
-}
-var bluetooth = {
-  async isEnabled() {
-    return hasBridge("bluetooth") ? await window.craft.bluetooth.isEnabled() : false;
-  },
-  async powerState() {
-    return hasBridge("bluetooth") ? await window.craft.bluetooth.powerState() : "unknown";
-  },
-  async connectedDevices() {
-    return hasBridge("bluetooth") ? await window.craft.bluetooth.connectedDevices() : [];
-  },
-  async pairedDevices() {
-    return hasBridge("bluetooth") ? await window.craft.bluetooth.pairedDevices() : [];
-  },
-  async startDiscovery() {
-    if (hasBridge("bluetooth"))
-      await window.craft.bluetooth.startDiscovery();
-  },
-  async stopDiscovery() {
-    if (hasBridge("bluetooth"))
-      await window.craft.bluetooth.stopDiscovery();
-  },
-  async isDiscovering() {
-    return hasBridge("bluetooth") ? await window.craft.bluetooth.isDiscovering() : false;
-  },
-  async connect(id) {
-    if (hasBridge("bluetooth"))
-      await window.craft.bluetooth.connect(id);
-  },
-  async disconnect(id) {
-    if (hasBridge("bluetooth"))
-      await window.craft.bluetooth.disconnect(id);
-  },
-  async openPreferences() {
-    if (hasBridge("bluetooth"))
-      await window.craft.bluetooth.openPreferences();
-  },
-  async discoverServices(deviceId) {
-    if (!deviceId)
-      throw new Error("bluetooth.discoverServices: deviceId is required");
-    if (!hasBridge("bluetooth"))
-      return [];
-    const r = await window.craft.bluetooth.discoverServices(deviceId);
-    return Array.isArray(r) ? r : [];
-  },
-  async discoverCharacteristics(deviceId, serviceUuid) {
-    if (!deviceId || !serviceUuid)
-      throw new Error("bluetooth.discoverCharacteristics: deviceId and serviceUuid are required");
-    if (!hasBridge("bluetooth"))
-      return [];
-    const r = await window.craft.bluetooth.discoverCharacteristics(deviceId, serviceUuid);
-    return Array.isArray(r) ? r : [];
-  },
-  async readCharacteristic(deviceId, serviceUuid, characteristicUuid) {
-    if (!deviceId || !serviceUuid || !characteristicUuid) {
-      throw new Error("bluetooth.readCharacteristic: deviceId, serviceUuid, characteristicUuid are required");
-    }
-    if (!hasBridge("bluetooth"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.bluetooth.readCharacteristic(deviceId, serviceUuid, characteristicUuid);
-  },
-  async writeCharacteristic(deviceId, serviceUuid, characteristicUuid, valueHex, mode = "with-response") {
-    if (!deviceId || !serviceUuid || !characteristicUuid) {
-      throw new Error("bluetooth.writeCharacteristic: deviceId, serviceUuid, characteristicUuid are required");
-    }
-    assertHex("bluetooth.writeCharacteristic.valueHex", valueHex);
-    if (!hasBridge("bluetooth"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.bluetooth.writeCharacteristic(deviceId, serviceUuid, characteristicUuid, valueHex, mode);
-  },
-  async setCharacteristicNotify(deviceId, serviceUuid, characteristicUuid, on) {
-    if (!deviceId || !serviceUuid || !characteristicUuid) {
-      throw new Error("bluetooth.setCharacteristicNotify: deviceId, serviceUuid, characteristicUuid are required");
-    }
-    if (!hasBridge("bluetooth"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.bluetooth.setCharacteristicNotify(deviceId, serviceUuid, characteristicUuid, on);
-  },
-  onDeviceFound(cb) {
-    return onCraftEvent("craft:bluetooth:deviceFound", cb);
-  },
-  onDeviceConnected(cb) {
-    return onCraftEvent("craft:bluetooth:deviceConnected", cb);
-  },
-  onDeviceDisconnected(cb) {
-    return onCraftEvent("craft:bluetooth:deviceDisconnected", cb);
-  },
-  onCharacteristicValue(cb) {
-    return onCraftEvent("craft:bluetooth:characteristicValue", cb);
-  }
-};
-// src/bonjour.ts
-var bonjour = {
-  async browse(serviceType) {
-    if (!hasBridge("bonjour"))
-      return { started: false, reason: "bridge unavailable" };
-    return await window.craft.bonjour.browse(serviceType);
-  },
-  async stop() {
-    if (hasBridge("bonjour"))
-      await window.craft.bonjour.stop();
-  },
-  onFound(cb) {
-    return onCraftEvent("craft:bonjour:found", cb);
-  },
-  onLost(cb) {
-    return onCraftEvent("craft:bonjour:lost", cb);
-  }
-};
-// src/capabilities.ts
-var BRIDGE_INDEX = [
-  { name: "fs", support: "native" },
-  { name: "shell", support: "native" },
-  { name: "system", support: "all" },
-  { name: "clipboard", support: "all" },
-  { name: "dialog", support: "all" },
-  { name: "window", support: "native" },
-  { name: "tray", support: "native" },
-  { name: "menu", support: "native" },
-  { name: "theme", support: "all" },
-  { name: "screen", support: "all" },
-  { name: "network", support: "all" },
-  { name: "power", support: "all" },
-  { name: "battery", support: "all" },
-  { name: "notifications", support: "all" },
-  { name: "globalShortcuts", support: "native" },
-  { name: "autolaunch", support: "native" },
-  { name: "appInfo", support: "all" },
-  { name: "localServer", support: "native" },
-  { name: "bluetooth", support: "native" },
-  { name: "crashReporter", support: "all" },
-  { name: "updater", support: "native" },
-  { name: "iap", support: "macos" },
-  { name: "keychain", support: "native" },
-  { name: "log", support: "all" },
-  { name: "biometric", support: "macos" },
-  { name: "location", support: "macos" },
-  { name: "audio", support: "macos" },
-  { name: "deepLink", support: "native" },
-  { name: "handoff", support: "macos" },
-  { name: "liveActivities", support: "macos" },
-  { name: "touchbar", support: "macos" },
-  { name: "dragOut", support: "macos" },
-  { name: "appleScript", support: "macos" },
-  { name: "fileAssociations", support: "native" },
-  { name: "tags", support: "macos" },
-  { name: "pdf", support: "macos" },
-  { name: "bonjour", support: "macos" },
-  { name: "spotlight", support: "macos" },
-  { name: "speechRecognition", support: "macos" },
-  { name: "vision", support: "macos" },
-  { name: "midi", support: "macos" },
-  { name: "coreml", support: "macos" },
-  { name: "continuityCamera", support: "macos" },
-  { name: "serviceMenu", support: "macos" },
-  { name: "serial", support: "native" }
-];
-function getCapabilities() {
-  return BRIDGE_INDEX.map(({ name, support }) => ({
-    name,
-    support,
-    available: hasBridge(name)
-  }));
-}
-function getCapability(name) {
-  const entry = BRIDGE_INDEX.find((b) => b.name === name);
-  if (!entry)
-    return;
-  return { ...entry, available: hasBridge(name) };
-}
-function isAvailable(name) {
-  const cap = getCapability(name);
-  return !!cap && cap.available;
-}
-// src/clipboard.ts
-var clipboard = {
-  async writeText(text) {
-    if (hasBridge("clipboard")) {
-      await window.craft.clipboard.writeText(text);
-      return;
-    }
-    if (typeof navigator !== "undefined" && navigator.clipboard) {
-      await navigator.clipboard.writeText(text);
-    }
-  },
-  async readText() {
-    if (hasBridge("clipboard")) {
-      const v = await window.craft.clipboard.readText();
-      return typeof v === "string" ? v : "";
-    }
-    if (typeof navigator !== "undefined" && navigator.clipboard?.readText) {
-      try {
-        return await navigator.clipboard.readText();
-      } catch {
-        return "";
-      }
-    }
-    return "";
-  },
-  async writeHTML(html) {
-    if (hasBridge("clipboard")) {
-      await window.craft.clipboard.writeHTML(html);
-      return;
-    }
-    if (typeof navigator !== "undefined" && navigator.clipboard?.write) {
-      try {
-        const item = new window.ClipboardItem({
-          "text/html": new Blob([html], { type: "text/html" }),
-          "text/plain": new Blob([stripHtml(html)], { type: "text/plain" })
-        });
-        await navigator.clipboard.write([item]);
-      } catch {}
-    }
-  },
-  async readHTML() {
-    if (hasBridge("clipboard")) {
-      const v = await window.craft.clipboard.readHTML();
-      return typeof v === "string" ? v : "";
-    }
-    if (typeof navigator !== "undefined" && navigator.clipboard?.read) {
-      try {
-        const items = await navigator.clipboard.read();
-        for (const item of items) {
-          if (item.types.includes("text/html")) {
-            const blob = await item.getType("text/html");
-            return await blob.text();
-          }
-        }
-      } catch {}
-    }
-    return "";
-  },
-  async clear() {
-    if (hasBridge("clipboard")) {
-      await window.craft.clipboard.clear();
-      return;
-    }
-    if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
-      try {
-        await navigator.clipboard.writeText("");
-      } catch {}
-    }
-  },
-  async hasText() {
-    if (hasBridge("clipboard")) {
-      return await window.craft.clipboard.hasText();
-    }
-    return (await this.readText()).length > 0;
-  },
-  async hasHTML() {
-    if (hasBridge("clipboard")) {
-      return await window.craft.clipboard.hasHTML();
-    }
-    return (await this.readHTML()).length > 0;
-  },
-  async hasImage() {
-    if (hasBridge("clipboard")) {
-      return await window.craft.clipboard.hasImage();
-    }
-    return false;
-  }
-};
-function stripHtml(html) {
-  return html.replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, "").replace(/<\/?(br|p|div|li|h[1-6])\b[^>]*>/gi, `
-`).replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\n{3,}/g, `
-
-`).trim();
-}
-// src/continuity-camera.ts
-var continuityCamera = {
-  async listCameras() {
-    if (!hasBridge("continuityCamera"))
-      return [];
-    return await window.craft.continuityCamera.listCameras();
-  }
-};
-// src/coreml.ts
-var coreml = {
-  async loadModel(id, path) {
-    if (!id || !path)
-      throw new Error("coreml.loadModel: id and path are required");
-    if (!hasBridge("coreml"))
-      return false;
-    return await window.craft.coreml.loadModel(id, path);
-  },
-  async unloadModel(id) {
-    if (!hasBridge("coreml"))
-      return;
-    await window.craft.coreml.unloadModel(id);
-  },
-  async predict(id, input) {
-    if (!id)
-      throw new Error("coreml.predict: id is required");
-    if (!hasBridge("coreml"))
-      return null;
-    return await window.craft.coreml.predict(id, input);
-  }
-};
-// src/crash-reporter.ts
-var jsQueue = [];
-var jsEnabled = true;
-var jsUserId;
-var jsAppVersion;
-var crashReporter = {
-  async report(entry) {
-    if (hasBridge("crashReporter")) {
-      await window.craft.crashReporter.report(entry);
-      return;
-    }
-    if (!jsEnabled)
-      return;
-    const normalized = entry instanceof Error ? {
-      timestamp: Date.now(),
-      severity: "error",
-      message: entry.message,
-      source: "js",
-      stack: entry.stack || "",
-      userId: jsUserId,
-      appVersion: jsAppVersion
-    } : {
-      timestamp: Date.now(),
-      severity: entry.severity || "error",
-      message: entry.message || "",
-      source: entry.source || "js",
-      stack: entry.stack || "",
-      userId: jsUserId,
-      appVersion: jsAppVersion
-    };
-    if (jsQueue.length >= 64)
-      jsQueue.shift();
-    jsQueue.push(normalized);
-  },
-  async flush() {
-    if (hasBridge("crashReporter"))
-      return await window.craft.crashReporter.flush();
-    return [...jsQueue];
-  },
-  async clear() {
-    if (hasBridge("crashReporter")) {
-      await window.craft.crashReporter.clear();
-      return;
-    }
-    jsQueue.length = 0;
-  },
-  async setEnabled(on) {
-    if (hasBridge("crashReporter")) {
-      await window.craft.crashReporter.setEnabled(on);
-      return;
-    }
-    jsEnabled = on;
-  },
-  async isEnabled() {
-    if (hasBridge("crashReporter"))
-      return await window.craft.crashReporter.isEnabled();
-    return jsEnabled;
-  },
-  async setUser(id) {
-    if (hasBridge("crashReporter")) {
-      await window.craft.crashReporter.setUser(id);
-      return;
-    }
-    jsUserId = id || undefined;
-  },
-  async setAppVersion(version) {
-    if (hasBridge("crashReporter")) {
-      await window.craft.crashReporter.setAppVersion(version);
-      return;
-    }
-    jsAppVersion = version || undefined;
-  },
-  attachGlobalHandlers() {
-    if (hasBridge("crashReporter") && window.craft.crashReporter.attachGlobalHandlers) {
-      return window.craft.crashReporter.attachGlobalHandlers();
-    }
-    if (typeof window === "undefined")
-      return () => {};
-    const errorH = (e) => {
-      crashReporter.report({
-        severity: "error",
-        message: e.message,
-        source: "js",
-        stack: e.error?.stack || `${e.message}
-  at ${e.filename}:${e.lineno}:${e.colno}`
-      }).catch(() => {});
-    };
-    const rejectH = (e) => {
-      const r = e.reason;
-      crashReporter.report({
-        severity: "error",
-        message: r?.message || String(r),
-        source: "js",
-        stack: r?.stack || ""
-      }).catch(() => {});
-    };
-    window.addEventListener("error", errorH);
-    window.addEventListener("unhandledrejection", rejectH);
-    return () => {
-      window.removeEventListener("error", errorH);
-      window.removeEventListener("unhandledrejection", rejectH);
-    };
-  },
-  forwardTo(options) {
-    return startForwarder(options);
-  }
-};
-var DEFAULT_PERSIST_KEY = "craft:crashReporter:pending";
-var EMAIL_RE = /[\w.+-]+@[\w-]+\.[\w.-]+/g;
-var IPV4_RE = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
-var HOME_PATH_RE = /\/(?:Users|home)\/[^\s/'"`]+/g;
-function redactPII(entry) {
-  const scrub = (s) => s.replace(EMAIL_RE, "<email>").replace(IPV4_RE, "<ip>").replace(HOME_PATH_RE, "/<home>");
-  return {
-    ...entry,
-    message: scrub(entry.message),
-    stack: scrub(entry.stack)
-  };
-}
-async function signPayload(secret, body) {
-  const enc = new TextEncoder;
-  const key = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-  const sig = await crypto.subtle.sign("HMAC", key, enc.encode(body));
-  return [...new Uint8Array(sig)].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function loadPersisted(key) {
-  if (!key || typeof localStorage === "undefined")
-    return [];
-  try {
-    const raw = localStorage.getItem(key);
-    if (!raw)
-      return [];
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-function savePersisted(key, entries) {
-  if (!key || typeof localStorage === "undefined")
-    return;
-  try {
-    if (entries.length === 0)
-      localStorage.removeItem(key);
-    else
-      localStorage.setItem(key, JSON.stringify(entries));
-  } catch {}
-}
-function startForwarder(options) {
-  const {
-    endpoint,
-    intervalMs = 60000,
-    signingSecret,
-    redact = true,
-    headers = {},
-    maxRetries = 5,
-    persistKey
-  } = options;
-  const storageKey = persistKey === null ? null : persistKey ?? DEFAULT_PERSIST_KEY;
-  let pending = loadPersisted(storageKey);
-  let stopped = false;
-  let timer = null;
-  let inFlight = null;
-  const redactor = typeof redact === "function" ? redact : redact === false ? (e) => e : redactPII;
-  async function postBatch(batch) {
-    const body = JSON.stringify({ entries: batch });
-    const requestHeaders = {
-      "Content-Type": "application/json",
-      ...headers
-    };
-    if (signingSecret) {
-      requestHeaders["X-Craft-Signature"] = await signPayload(signingSecret, body);
-    }
-    let attempt = 0;
-    let delay = 1000;
-    while (!stopped) {
-      try {
-        const res = await fetch(endpoint, { method: "POST", headers: requestHeaders, body });
-        if (res.ok)
-          return;
-        if (res.status >= 400 && res.status < 500)
-          return;
-        throw new Error(`HTTP ${res.status}`);
-      } catch (err) {
-        attempt += 1;
-        if (attempt > maxRetries) {
-          pending = [...batch, ...pending];
-          savePersisted(storageKey, pending);
-          throw err;
-        }
-        await new Promise((r) => {
-          setTimeout(r, delay);
-        });
-        delay = Math.min(delay * 2, 60000);
-      }
-    }
-  }
-  async function drain() {
-    if (stopped || inFlight)
-      return inFlight ?? undefined;
-    const fresh = await crashReporter.flush();
-    if (fresh.length > 0)
-      await crashReporter.clear();
-    pending = [...pending, ...fresh.map((e) => redactor(e))];
-    if (pending.length === 0)
-      return;
-    const batch = pending;
-    pending = [];
-    savePersisted(storageKey, pending);
-    inFlight = postBatch(batch).catch(() => {}).finally(() => {
-      inFlight = null;
-    });
-    return inFlight;
-  }
-  if (intervalMs > 0) {
-    timer = setInterval(() => {
-      drain().catch(() => {});
-    }, intervalMs);
-  }
-  return {
-    async flushNow() {
-      await drain();
-    },
-    stop() {
-      stopped = true;
-      if (timer)
-        clearInterval(timer);
-      timer = null;
-    },
-    pending() {
-      return [...pending];
-    }
-  };
-}
-// src/deep-link.ts
-var deepLinks = {
-  onUrl(cb) {
-    if (!hasBridge("deepLink"))
-      return () => {};
-    return onCraftEvent("craft:deepLink", cb);
-  },
-  getInitialUrl() {
-    if (typeof window === "undefined")
-      return null;
-    if (hasBridge("deepLink")) {
-      try {
-        return window.craft.deepLink.getInitialUrl();
-      } catch {
-        return null;
-      }
-    }
-    return window.__craftPendingDeepLink || null;
-  },
-  consumeInitialUrl() {
-    const url = this.getInitialUrl();
-    if (typeof window !== "undefined")
-      window.__craftPendingDeepLink = undefined;
-    return url;
-  },
-  isAvailable() {
-    return hasBridge("deepLink");
-  }
-};
-// src/dialogs.ts
-function isInCraftWindow() {
-  if (typeof window !== "undefined" && window.craft?.dialog) {
-    return true;
-  }
-  return false;
-}
-async function showOpenDialog(options = {}) {
-  if (isInCraftWindow()) {
-    const craftWindow = window;
-    try {
-      return await craftWindow.craft.dialog.showOpenDialog(options);
-    } catch (error) {
-      console.warn("[stx-dialog] Failed to show native open dialog:", error);
-    }
-  }
-  return new Promise((resolve) => {
-    if (typeof document === "undefined") {
-      resolve({ canceled: true, filePaths: [] });
-      return;
-    }
-    const input = document.createElement("input");
-    input.type = "file";
-    input.multiple = options.multiSelections ?? false;
-    if (options.filters?.length) {
-      const extensions = options.filters.flatMap((f) => f.extensions.map((e) => `.${e}`));
-      input.accept = extensions.join(",");
-    }
-    if (options.canChooseDirectories && !options.canChooseFiles) {
-      input.webkitdirectory = true;
-    }
-    input.onchange = () => {
-      const files = Array.from(input.files || []);
-      if (files.length === 0) {
-        resolve({ canceled: true, filePaths: [] });
-      } else {
-        const filePaths = files.map((f) => f.name);
-        resolve({ canceled: false, filePaths });
-      }
-    };
-    input.oncancel = () => {
-      resolve({ canceled: true, filePaths: [] });
-    };
-    input.click();
-  });
-}
-async function showSaveDialog(options = {}) {
-  if (isInCraftWindow()) {
-    const craftWindow = window;
-    try {
-      return await craftWindow.craft.dialog.showSaveDialog(options);
-    } catch (error) {
-      console.warn("[stx-dialog] Failed to show native save dialog:", error);
-    }
-  }
-  if (typeof window !== "undefined" && "showSaveFilePicker" in window) {
-    try {
-      const fileTypes = options.filters?.map((f) => ({
-        description: f.name,
-        accept: {
-          "*/*": f.extensions.map((e) => `.${e}`)
-        }
-      }));
-      const handle = await window.showSaveFilePicker({
-        suggestedName: options.defaultPath,
-        types: fileTypes
-      });
-      return { canceled: false, filePath: handle.name };
-    } catch (error) {
-      return { canceled: true };
-    }
-  }
-  console.warn("[stx-dialog] Save dialog not available, using prompt fallback");
-  const filename = prompt("Enter filename:", options.defaultPath || "file.txt");
-  if (filename) {
-    return { canceled: false, filePath: filename };
-  }
-  return { canceled: true };
-}
-async function showMessageBox(options) {
-  if (isInCraftWindow()) {
-    const craftWindow = window;
-    try {
-      return await craftWindow.craft.dialog.showMessageBox(options);
-    } catch (error) {
-      console.warn("[stx-dialog] Failed to show native message box:", error);
-    }
-  }
-  const buttons = options.buttons || ["OK"];
-  if (buttons.length === 1) {
-    alert(options.message);
-    return { response: 0 };
-  }
-  if (buttons.length === 2 && options.type === "question") {
-    const confirmed2 = confirm(options.message);
-    return { response: confirmed2 ? 1 : 0 };
-  }
-  console.warn("[stx-dialog] Complex message box not fully supported in browser, using confirm");
-  const confirmed = confirm(`${options.message}
-
-${buttons.join(" / ")}`);
-  return { response: confirmed ? buttons.length - 1 : 0 };
-}
-async function showColorPicker(options = {}) {
-  if (isInCraftWindow()) {
-    const craftWindow = window;
-    try {
-      return await craftWindow.craft.dialog.showColorPicker(options);
-    } catch (error) {
-      console.warn("[stx-dialog] Failed to show native color picker:", error);
-    }
-  }
-  return new Promise((resolve) => {
-    if (typeof document === "undefined") {
-      resolve({ canceled: true });
-      return;
-    }
-    const input = document.createElement("input");
-    input.type = "color";
-    input.value = options.color || "#000000";
-    input.onchange = () => {
-      resolve({ canceled: false, color: input.value });
-    };
-    input.oncancel = () => {
-      resolve({ canceled: true });
-    };
-    input.click();
-  });
-}
-async function showAlertDialog(message, title) {
-  await showMessageBox({
-    type: "info",
-    title: title || "Alert",
-    message,
-    buttons: ["OK"]
-  });
-}
-async function showConfirmDialog(message, title) {
-  const result = await showMessageBox({
-    type: "question",
-    title: title || "Confirm",
-    message,
-    buttons: ["Cancel", "OK"],
-    defaultButton: 1,
-    cancelButton: 0
-  });
-  return result.response === 1;
-}
-async function showErrorDialog(message, title) {
-  await showMessageBox({
-    type: "error",
-    title: title || "Error",
-    message,
-    buttons: ["OK"]
-  });
-}
-async function showWarningDialog(message, title) {
-  await showMessageBox({
-    type: "warning",
-    title: title || "Warning",
-    message,
-    buttons: ["OK"]
-  });
-}
-function getDialogBridgeScript() {
-  return `
-// STX Desktop Dialog Bridge
-// Provides convenient wrappers around window.craft.dialog APIs
-window.stxDialog = {
-  // File dialogs
-  showOpenDialog: (options) => window.craft?.dialog?.showOpenDialog(options),
-  showSaveDialog: (options) => window.craft?.dialog?.showSaveDialog(options),
-
-  // Message dialogs
-  showMessageBox: (options) => window.craft?.dialog?.showMessageBox(options),
-
-  // Color picker
-  showColorPicker: (options) => window.craft?.dialog?.showColorPicker(options),
-
-  // Font picker
-  showFontPicker: (options) => window.craft?.dialog?.showFontPicker(options),
-
-  // Convenience functions
-  alert: async (message, title) => {
-    return window.craft?.dialog?.showMessageBox({
-      type: 'info',
-      title: title || 'Alert',
-      message,
-      buttons: ['OK'],
-    });
-  },
-
-  confirm: async (message, title) => {
-    const result = await window.craft?.dialog?.showMessageBox({
-      type: 'question',
-      title: title || 'Confirm',
-      message,
-      buttons: ['Cancel', 'OK'],
-    });
-    return result?.response === 1;
-  },
-
-  error: async (message, title) => {
-    return window.craft?.dialog?.showMessageBox({
-      type: 'error',
-      title: title || 'Error',
-      message,
-      buttons: ['OK'],
-    });
-  },
-
-  // Check if dialog is available
-  isAvailable: () => typeof window.craft?.dialog !== 'undefined',
-};
-`;
-}
-// src/drag-out.ts
-async function dragOut(paths, options = {}) {
-  if (!hasBridge("dragOut")) {
-    throw new Error("dragOut requires a Craft native window");
-  }
-  const arr = Array.isArray(paths) ? paths : [paths];
-  if (arr.length === 0)
-    throw new Error("dragOut: at least one path required");
-  await window.craft.dragOut.start(arr, options);
-}
-function isDragOutAvailable() {
-  return hasBridge("dragOut");
-}
-// src/file-associations.ts
-var fileAssociations = {
-  async getDefault(uti) {
-    if (!uti)
-      throw new Error("fileAssociations.getDefault: uti is required");
-    if (!hasBridge("fileAssociations"))
-      return null;
-    const v = await window.craft.fileAssociations.getDefault(uti);
-    return v ? String(v) : null;
-  },
-  async setDefault(uti, bundleId) {
-    if (!uti || !bundleId)
-      throw new Error("fileAssociations.setDefault: uti and bundleId are required");
-    if (!hasBridge("fileAssociations"))
-      return false;
-    return await window.craft.fileAssociations.setDefault(uti, bundleId);
-  }
-};
-// src/focus.ts
-var UNSUPPORTED = { supported: false, isFocused: null, authorization: "unsupported" };
-function unavailable() {
-  return { ok: false, error: "Focus control is only available in a Craft window on macOS" };
-}
-var focus = {
-  async getStatus() {
-    if (!hasBridge("focus"))
-      return { ...UNSUPPORTED };
-    return await window.craft.focus.getStatus();
-  },
-  async requestAuthorization() {
-    if (!hasBridge("focus"))
-      return "unsupported";
-    return await window.craft.focus.requestAuthorization();
-  },
-  async setEnabled(enabled, options = {}) {
-    if (!hasBridge("focus"))
-      return unavailable();
-    const name = enabled ? options.onShortcut : options.offShortcut;
-    if (!name) {
-      return {
-        ok: false,
-        error: `focus.setEnabled: no ${enabled ? "onShortcut" : "offShortcut"} configured`
-      };
-    }
-    return await window.craft.focus.setEnabled(enabled, options);
-  },
-  async runShortcut(name) {
-    if (!hasBridge("focus"))
-      return unavailable();
-    if (!name)
-      throw new Error("focus.runShortcut: name is required");
-    return await window.craft.focus.runShortcut(name);
-  },
-  async listShortcuts() {
-    if (!hasBridge("focus"))
-      return [];
-    return await window.craft.focus.listShortcuts();
-  },
-  async listShortcutsResult() {
-    if (!hasBridge("focus"))
-      return { canList: false, shortcuts: [] };
-    const r = await window.craft.focus.listShortcutsResult();
-    return { canList: Boolean(r?.canList), shortcuts: r?.shortcuts || [] };
-  }
-};
-async function hasFocusShortcuts(...names) {
-  if (names.length === 0)
-    return false;
-  const installed = new Set(await focus.listShortcuts());
-  return names.every((name) => installed.has(name));
-}
-async function focusShortcutsReady(...names) {
-  if (names.length === 0)
-    return false;
-  const { canList, shortcuts } = await focus.listShortcutsResult();
-  if (!canList)
-    return "unknown";
-  const installed = new Set(shortcuts);
-  return names.every((name) => installed.has(name));
-}
-// src/fs.ts
-var fs = {
-  async readFile(path) {
-    const r = await requireBridge("fs").readFile(path);
-    return r && r.data || "";
-  },
-  async readBuffer(path) {
-    const r = await requireBridge("fs").readFile(path);
-    const text = r && r.data || "";
-    if (r && r.base64 === true) {
-      return base64ToBytes(text);
-    }
-    return new TextEncoder().encode(text);
-  },
-  async writeFile(path, data) {
-    await requireBridge("fs").writeFile(path, data);
-  },
-  async writeBuffer(path, data) {
-    const b64 = bytesToBase64(data);
-    const bridge = requireBridge("fs");
-    if (typeof bridge.writeFileBytes === "function") {
-      await bridge.writeFileBytes(path, b64);
-    } else {
-      await bridge.writeFile(path, b64);
-    }
-  },
-  async copy(from, to) {
-    if (from === to)
-      throw new Error("fs.copy: source and destination must differ");
-    await requireBridge("fs").copy(from, to);
-  },
-  async move(from, to) {
-    if (from === to)
-      throw new Error("fs.move: source and destination must differ");
-    await requireBridge("fs").move(from, to);
-  },
-  async appendFile(path, data) {
-    await requireBridge("fs").appendFile(path, data);
-  },
-  async deleteFile(path) {
-    await requireBridge("fs").deleteFile(path);
-  },
-  async exists(path) {
-    return await requireBridge("fs").exists(path);
-  },
-  async stat(path) {
-    return normalizeStat(await requireBridge("fs").stat(path));
-  },
-  async readDir(path) {
-    const r = await requireBridge("fs").readDir(path);
-    const raw = r && r.entries || [];
-    const base = path.endsWith("/") ? path.slice(0, -1) : path;
-    return raw.map((e) => ({
-      name: e.name,
-      path: `${base}/${e.name}`,
-      isDirectory: !!e.isDirectory
-    }));
-  },
-  async mkdir(path, opts) {
-    await requireBridge("fs").mkdir(path, opts);
-  },
-  async rmdir(path, opts) {
-    await requireBridge("fs").rmdir(path, opts);
-  },
-  async watch(path, id) {
-    await requireBridge("fs").watch(path, id);
-  },
-  async unwatch(id) {
-    await requireBridge("fs").unwatch(id);
-  },
-  onChange(cb) {
-    return onCraftEvent("craft:fs:change", cb);
-  },
-  async watchTree(path, options, cb) {
-    const id = `watch-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    const bridge = requireBridge("fs");
-    await bridge.watch(path, id, { recursive: !!options.recursive });
-    const allowed = options.kinds && options.kinds.length > 0 ? new Set(options.kinds) : null;
-    const coalesceMs = Math.max(0, Math.floor(options.coalesceMs ?? 0));
-    let buffer = [];
-    let flushTimer = null;
-    let stopped = false;
-    const flush = () => {
-      flushTimer = null;
-      if (buffer.length === 0)
-        return;
-      const batch = buffer;
-      buffer = [];
-      try {
-        cb(batch);
-      } catch {}
-    };
-    const off = onCraftEvent("craft:fs:change", (e) => {
-      if (stopped)
-        return;
-      if (e.id !== id)
-        return;
-      if (allowed && e.kind && !allowed.has(e.kind))
-        return;
-      buffer.push(e);
-      if (coalesceMs === 0) {
-        flush();
-        return;
-      }
-      if (flushTimer == null) {
-        flushTimer = setTimeout(flush, coalesceMs);
-      }
-    });
-    return {
-      id,
-      async stop() {
-        if (stopped)
-          return;
-        stopped = true;
-        off();
-        if (flushTimer) {
-          clearTimeout(flushTimer);
-          flushTimer = null;
-        }
-        if (buffer.length > 0)
-          flush();
-        try {
-          await bridge.unwatch(id);
-        } catch {}
-      }
-    };
-  },
-  async homeDir() {
-    return await requireBridge("fs").homeDir();
-  },
-  async tempDir() {
-    return await requireBridge("fs").tempDir();
-  },
-  async appDataDir() {
-    return await requireBridge("fs").appDataDir();
-  }
-};
-function bytesToBase64(bytes) {
-  let s = "";
-  for (let i = 0;i < bytes.length; i++)
-    s += String.fromCharCode(bytes[i]);
-  return typeof btoa === "function" ? btoa(s) : Buffer.from(bytes).toString("base64");
-}
-function base64ToBytes(b64) {
-  const bin = typeof atob === "function" ? atob(b64) : Buffer.from(b64, "base64").toString("binary");
-  const out = new Uint8Array(bin.length);
-  for (let i = 0;i < bin.length; i++)
-    out[i] = bin.charCodeAt(i);
-  return out;
-}
-function normalizeStat(raw) {
-  return {
-    isFile: !!raw.isFile,
-    isDirectory: !!raw.isDirectory,
-    isSymlink: !!raw.isSymlink,
-    size: Number(raw.size) || 0,
-    modifiedAt: raw.modifiedAt != null ? raw.modifiedAt < 1000000000000 ? raw.modifiedAt * 1000 : raw.modifiedAt : 0
-  };
-}
-// src/global-shortcuts.ts
-var globalShortcuts = {
-  async register(id, accelerator, opts) {
-    if (!hasBridge("shortcuts"))
-      return;
-    await window.craft.shortcuts.register(id, accelerator, opts);
-  },
-  async unregister(id) {
-    if (!hasBridge("shortcuts"))
-      return;
-    await window.craft.shortcuts.unregister(id);
-  },
-  async unregisterAll() {
-    if (!hasBridge("shortcuts"))
-      return;
-    await window.craft.shortcuts.unregisterAll();
-  },
-  async enable(id) {
-    if (!hasBridge("shortcuts"))
-      return;
-    await window.craft.shortcuts.enable(id);
-  },
-  async disable(id) {
-    if (!hasBridge("shortcuts"))
-      return;
-    await window.craft.shortcuts.disable(id);
-  },
-  async isRegistered(id) {
-    if (!hasBridge("shortcuts"))
-      return false;
-    return await window.craft.shortcuts.isRegistered(id);
-  },
-  async list() {
-    if (!hasBridge("shortcuts"))
-      return [];
-    return await window.craft.shortcuts.list();
-  },
-  on(cb) {
-    return onCraftEvent("craft:shortcut", cb);
-  }
-};
-// src/handoff.ts
-var handoff = {
-  async startActivity(type, options) {
-    if (!type)
-      throw new Error("handoff.startActivity: type is required");
-    if (!hasBridge("handoff"))
-      return false;
-    const r = await window.craft.handoff.startActivity(type, options);
-    return typeof r === "boolean" ? r : !!(r && r.ok);
-  },
-  async updateActivity(options) {
-    if (!hasBridge("handoff"))
-      return false;
-    const r = await window.craft.handoff.updateActivity(options);
-    return typeof r === "boolean" ? r : !!(r && r.ok);
-  },
-  async stopActivity() {
-    if (!hasBridge("handoff"))
-      return;
-    await window.craft.handoff.stopActivity();
-  },
-  async getCurrentActivity() {
-    if (!hasBridge("handoff"))
-      return null;
-    const r = await window.craft.handoff.getCurrentActivity();
-    return r && typeof r.type === "string" ? r : null;
-  },
-  onIncoming(cb) {
-    return onCraftEvent("craft:handoff:incoming", cb);
-  }
-};
-// src/hotkeys.ts
-var registrations = new Map;
-var nextId = 0;
-var documentListenerAttached = false;
-function parseShortcut(shortcut) {
-  const parts = shortcut.split("+").map((p) => p.trim());
-  const result = {
-    key: "",
-    meta: false,
-    ctrl: false,
-    shift: false,
-    alt: false
-  };
-  for (const part of parts) {
-    const lower = part.toLowerCase();
-    switch (lower) {
-      case "cmd":
-      case "command":
-      case "meta":
-      case "\u2318":
-        result.meta = true;
-        break;
-      case "ctrl":
-      case "control":
-      case "\u2303":
-        result.ctrl = true;
-        break;
-      case "shift":
-      case "\u21E7":
-        result.shift = true;
-        break;
-      case "alt":
-      case "option":
-      case "opt":
-      case "\u2325":
-        result.alt = true;
-        break;
-      case "cmdorctrl":
-      case "commandorcontrol":
-        if (typeof process !== "undefined" && process.platform === "darwin") {
-          result.meta = true;
-        } else {
-          result.ctrl = true;
-        }
-        break;
-      default:
-        result.key = lower;
-    }
-  }
-  return result;
-}
-function formatShortcut(parsed) {
-  const parts = [];
-  if (parsed.ctrl)
-    parts.push("\u2303");
-  if (parsed.alt)
-    parts.push("\u2325");
-  if (parsed.shift)
-    parts.push("\u21E7");
-  if (parsed.meta)
-    parts.push("\u2318");
-  parts.push(parsed.key.toUpperCase());
-  return parts.join("");
-}
-function matchesEvent(event, parsed) {
-  if (parsed.meta !== event.metaKey)
-    return false;
-  if (parsed.ctrl !== event.ctrlKey)
-    return false;
-  if (parsed.shift !== event.shiftKey)
-    return false;
-  if (parsed.alt !== event.altKey)
-    return false;
-  const eventKey = event.key.toLowerCase();
-  return eventKey === parsed.key || event.code.toLowerCase() === `key${parsed.key}`;
-}
-function handleKeyDown(event) {
-  for (const [, reg] of registrations) {
-    if (matchesEvent(event, reg.parsed)) {
-      event.preventDefault();
-      event.stopPropagation();
-      try {
-        reg.handler();
-      } catch {}
-      break;
-    }
-  }
-}
-function ensureDocumentListener() {
-  if (documentListenerAttached)
-    return;
-  if (typeof document === "undefined")
-    return;
-  document.addEventListener("keydown", handleKeyDown, true);
-  documentListenerAttached = true;
-}
-function removeDocumentListener() {
-  if (!documentListenerAttached)
-    return;
-  if (typeof document === "undefined")
-    return;
-  document.removeEventListener("keydown", handleKeyDown, true);
-  documentListenerAttached = false;
-}
-async function registerWithCraft(id, shortcut) {
-  if (typeof window === "undefined")
-    return false;
-  const craft = window.craft;
-  if (!craft?.hotkeys?.register)
-    return false;
-  try {
-    await craft.hotkeys.register(id, shortcut);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function unregisterWithCraft(id) {
-  if (typeof window === "undefined")
-    return;
-  const craft = window.craft;
-  if (!craft?.hotkeys?.unregister)
-    return;
-  try {
-    await craft.hotkeys.unregister(id);
-  } catch {}
-}
-function registerHotkey(shortcut, handler) {
-  const id = `hotkey_${++nextId}_${Date.now()}`;
-  const parsed = parseShortcut(shortcut);
-  registrations.set(id, { shortcut, handler, parsed });
-  registerWithCraft(id, shortcut);
-  ensureDocumentListener();
-  const registration = {
-    shortcut,
-    id,
-    unregister() {
-      unregisterHotkey(registration);
-    }
-  };
-  return registration;
-}
-function unregisterHotkey(registration) {
-  registrations.delete(registration.id);
-  unregisterWithCraft(registration.id);
-  if (registrations.size === 0) {
-    removeDocumentListener();
-  }
-}
-function unregisterAllHotkeys() {
-  for (const [id] of registrations) {
-    unregisterWithCraft(id);
-  }
-  registrations.clear();
-  removeDocumentListener();
-}
-function getRegisteredHotkeys() {
-  return Array.from(registrations.entries()).map(([id, reg]) => ({
-    shortcut: reg.shortcut,
-    id,
-    unregister() {
-      registrations.delete(id);
-      unregisterWithCraft(id);
-      if (registrations.size === 0) {
-        removeDocumentListener();
-      }
-    }
-  }));
-}
-// src/iap.ts
-var iap = {
-  async isAvailable() {
-    if (!hasBridge("iap"))
-      return false;
-    return await window.craft.iap.isAvailable();
-  },
-  async getProducts(ids) {
-    if (!hasBridge("iap"))
-      return [];
-    const arr = Array.isArray(ids) ? ids : [String(ids)];
-    return await window.craft.iap.getProducts(arr);
-  },
-  async purchase(productId) {
-    if (!hasBridge("iap"))
-      return { queued: false, productId, reason: "IAP bridge not available" };
-    const r = await window.craft.iap.purchase(productId);
-    return { queued: !!(r && r.queued), productId: r?.productId, reason: r?.reason };
-  },
-  async restorePurchases() {
-    if (!hasBridge("iap"))
-      return { ok: false };
-    const r = await window.craft.iap.restorePurchases();
-    return { ok: !!(r && r.ok) };
-  },
-  async finishTransaction(transactionId) {
-    if (!hasBridge("iap"))
-      return;
-    await window.craft.iap.finishTransaction(transactionId);
-  },
-  async getReceiptData() {
-    if (!hasBridge("iap"))
-      return null;
-    const r = await window.craft.iap.getReceiptData();
-    return r ? String(r) : null;
-  },
-  onPurchased(cb) {
-    return onCraftEvent("craft:iap:purchased", cb);
-  },
-  onFailed(cb) {
-    return onCraftEvent("craft:iap:failed", cb);
-  },
-  onRestored(cb) {
-    return onCraftEvent("craft:iap:restored", cb);
-  },
-  onProductsLoaded(cb) {
-    return onCraftEvent("craft:iap:productsLoaded", (e) => cb(e.products || []));
-  },
-  onRefunded(cb) {
-    return onCraftEvent("craft:iap:refunded", cb);
-  },
-  onSubscriptionStatusChanged(cb) {
-    return onCraftEvent("craft:iap:subscriptionStatusChanged", cb);
-  },
-  async getActiveSubscriptions() {
-    if (!hasBridge("iap"))
-      return [];
-    const fn = window.craft.iap.getActiveSubscriptions;
-    if (typeof fn !== "function")
-      return [];
-    const r = await fn();
-    return Array.isArray(r) ? r : [];
-  },
-  async isEligibleForIntroOffer(productId) {
-    if (!hasBridge("iap"))
-      return false;
-    const fn = window.craft.iap.isEligibleForIntroOffer;
-    if (typeof fn !== "function")
-      return false;
-    return !!await fn(productId);
-  }
-};
-// src/keychain.ts
-var keychain = {
-  async set(service, account, password) {
-    if (!service)
-      throw new Error("keychain.set: service is required");
-    if (!account)
-      throw new Error("keychain.set: account is required");
-    await requireBridge("keychain").set(service, account, password);
-  },
-  async get(service, account) {
-    if (!service)
-      throw new Error("keychain.get: service is required");
-    if (!account)
-      throw new Error("keychain.get: account is required");
-    const v = await requireBridge("keychain").get(service, account);
-    return typeof v === "string" ? v : null;
-  },
-  async delete(service, account) {
-    if (!service)
-      throw new Error("keychain.delete: service is required");
-    if (!account)
-      throw new Error("keychain.delete: account is required");
-    await requireBridge("keychain").delete(service, account);
-  },
-  async has(service, account) {
-    if (!service)
-      throw new Error("keychain.has: service is required");
-    if (!account)
-      throw new Error("keychain.has: account is required");
-    return await requireBridge("keychain").has(service, account);
-  }
-};
-// src/live-activities.ts
-var liveActivities = {
-  async start(type, state) {
-    return handoff.startActivity(type, {
-      title: state?.title,
-      webpageURL: state?.webpageURL,
-      userInfo: state?.state
-    });
-  },
-  async update(state) {
-    return handoff.updateActivity({
-      title: state.title,
-      webpageURL: state.webpageURL,
-      userInfo: state.state
-    });
-  },
-  async stop() {
-    await handoff.stopActivity();
-  }
-};
-// src/local-server.ts
-var localServer = {
-  async start(port = 0, host = "127.0.0.1") {
-    if (!hasBridge("localServer"))
-      return { port: 0, started: false, reason: "bridge unavailable" };
-    return await window.craft.localServer.start(port, host);
-  },
-  async stop() {
-    if (!hasBridge("localServer"))
-      return;
-    await window.craft.localServer.stop();
-  },
-  async respond(options) {
-    if (!hasBridge("localServer"))
-      return;
-    await window.craft.localServer.respond(options || { status: 200, body: "OK" });
-  },
-  onRequest(cb) {
-    return onCraftEvent("craft:localServer:request", cb);
-  },
-  async awaitOAuthCallback(options = {}) {
-    requireBridge("localServer");
-    const { port: requestedPort = 0, host = "127.0.0.1", timeoutMs = 5 * 60 * 1000, successHTML } = options;
-    const start = await this.start(requestedPort, host);
-    if (!start.started)
-      throw new Error(`localServer: start failed${start.reason ? ` \u2014 ${start.reason}` : ""}`);
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        off();
-        this.stop().catch(() => {});
-        reject(new Error("localServer: OAuth callback timed out"));
-      }, timeoutMs);
-      const off = this.onRequest(({ url }) => {
-        clearTimeout(timer);
-        off();
-        const body = successHTML ?? `<!doctype html><meta charset="utf-8"><title>Done</title>
-<style>body{font-family:-apple-system,BlinkMacSystemFont,sans-serif;display:flex;align-items:center;justify-content:center;height:100vh;margin:0;background:#f5f5f7}</style>
-<div><h1>You can close this tab.</h1><p>Returning to the app\u2026</p></div>
-<script>setTimeout(()=>window.close(),1500)</script>`;
-        this.respond({ status: 200, body, contentType: "text/html; charset=utf-8" }).catch(() => {}).finally(() => this.stop().catch(() => {}));
-        resolve({ url, port: start.port });
-      });
-    });
-  }
-};
-// src/location.ts
-var location = {
-  async requestPermission(mode = "whenInUse") {
-    if (hasBridge("location"))
-      return await window.craft.location.requestPermission(mode);
-    if (typeof navigator !== "undefined" && navigator.geolocation) {
-      return "undetermined";
-    }
-    return "not-supported";
-  },
-  async getAuthorization() {
-    if (hasBridge("location"))
-      return await window.craft.location.getAuthorization();
-    return "unknown";
-  },
-  async getCurrentLocation() {
-    if (hasBridge("location"))
-      return await window.craft.location.getCurrentLocation();
-    if (typeof navigator !== "undefined" && navigator.geolocation) {
-      navigator.geolocation.getCurrentPosition((pos) => {
-        window.dispatchEvent(new CustomEvent("craft:location:update", {
-          detail: {
-            latitude: pos.coords.latitude,
-            longitude: pos.coords.longitude,
-            altitude: pos.coords.altitude,
-            horizontalAccuracy: pos.coords.accuracy,
-            verticalAccuracy: pos.coords.altitudeAccuracy,
-            speed: pos.coords.speed
-          }
-        }));
-      }, (err) => {
-        window.dispatchEvent(new CustomEvent("craft:location:error", {
-          detail: { message: err.message || String(err) }
-        }));
-      });
-      return { requested: true };
-    }
-    return { requested: false };
-  },
-  async startWatching(options) {
-    if (hasBridge("location"))
-      return await window.craft.location.startWatching(options);
-    if (typeof navigator !== "undefined" && navigator.geolocation) {
-      const watchId = navigator.geolocation.watchPosition((pos) => {
-        window.dispatchEvent(new CustomEvent("craft:location:update", {
-          detail: {
-            latitude: pos.coords.latitude,
-            longitude: pos.coords.longitude,
-            altitude: pos.coords.altitude,
-            horizontalAccuracy: pos.coords.accuracy,
-            verticalAccuracy: pos.coords.altitudeAccuracy,
-            speed: pos.coords.speed
-          }
-        }));
-      });
-      window.__craftWebLocationWatchId = watchId;
-      return true;
-    }
-    return false;
-  },
-  async stopWatching() {
-    if (hasBridge("location")) {
-      await window.craft.location.stopWatching();
-      return;
-    }
-    if (typeof navigator !== "undefined" && navigator.geolocation) {
-      const id = window.__craftWebLocationWatchId;
-      if (id != null) {
-        navigator.geolocation.clearWatch(id);
-        window.__craftWebLocationWatchId = null;
-      }
-    }
-  },
-  onUpdate(cb) {
-    return onCraftEvent("craft:location:update", cb);
-  },
-  onError(cb) {
-    return onCraftEvent("craft:location:error", cb);
-  },
-  onAuthChanged(cb) {
-    return onCraftEvent("craft:location:authChanged", cb);
-  }
-};
-// src/log.ts
-var log = {
-  async debug(m) {
-    if (hasBridge("log"))
-      await window.craft.log.debug(m);
-    else
-      console.debug(m);
-  },
-  async info(m) {
-    if (hasBridge("log"))
-      await window.craft.log.info(m);
-    else
-      console.info(m);
-  },
-  async warn(m) {
-    if (hasBridge("log"))
-      await window.craft.log.warn(m);
-    else
-      console.warn(m);
-  },
-  async error(m) {
-    if (hasBridge("log"))
-      await window.craft.log.error(m);
-    else
-      console.error(m);
-  }
-};
-// src/menu.ts
-var menu = {
-  async set(items) {
-    if (hasBridge("menu"))
-      await window.craft.menu.set(items);
-  },
-  async setDock(items) {
-    if (hasBridge("menu"))
-      await window.craft.menu.setDock(items);
-  },
-  async addItem(parent, item) {
-    if (hasBridge("menu"))
-      await window.craft.menu.addItem(parent, item);
-  },
-  async removeItem(id) {
-    if (hasBridge("menu"))
-      await window.craft.menu.removeItem(id);
-  },
-  async enableItem(id) {
-    if (hasBridge("menu"))
-      await window.craft.menu.enableItem(id);
-  },
-  async disableItem(id) {
-    if (hasBridge("menu"))
-      await window.craft.menu.disableItem(id);
-  },
-  async checkItem(id) {
-    if (hasBridge("menu"))
-      await window.craft.menu.checkItem(id);
-  },
-  async uncheckItem(id) {
-    if (hasBridge("menu"))
-      await window.craft.menu.uncheckItem(id);
-  },
-  async setItemLabel(id, lbl) {
-    if (hasBridge("menu"))
-      await window.craft.menu.setItemLabel(id, lbl);
-  },
-  async clearDock() {
-    if (hasBridge("menu"))
-      await window.craft.menu.clearDock();
-  },
-  onAction(cb) {
-    return onCraftEvent("craft:menu:action", cb);
-  }
-};
-// src/midi.ts
-var midi = {
-  async listSources() {
-    if (!hasBridge("midi"))
-      return [];
-    return await window.craft.midi.listSources();
-  },
-  async listDestinations() {
-    if (!hasBridge("midi"))
-      return [];
-    return await window.craft.midi.listDestinations();
-  },
-  async send(destinationIndex, data) {
-    if (!hasBridge("midi"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.midi.send(destinationIndex, data);
-  },
-  async subscribe(sourceIndex) {
-    if (!hasBridge("midi"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.midi.subscribe(sourceIndex);
-  },
-  async unsubscribe(sourceIndex) {
-    if (!hasBridge("midi"))
-      return { ok: false };
-    return await window.craft.midi.unsubscribe(sourceIndex);
-  },
-  onMessage(cb) {
-    return onCraftEvent("craft:midi:message", cb);
-  }
-};
-// src/modals.ts
-function hasNativeDialogSupport() {
-  return false;
-}
-function isBrowser2() {
-  return typeof window !== "undefined" && typeof document !== "undefined";
-}
-var activeModals = [];
-function generateModalId() {
-  return `modal-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-function getModalIcon(type) {
-  switch (type) {
-    case "info":
-      return "&#x2139;";
-    case "warning":
-      return "&#x26A0;";
-    case "error":
-      return "&#x2716;";
-    case "success":
-      return "&#x2714;";
-    case "question":
-      return "&#x2753;";
-    default:
-      return "&#x2139;";
-  }
-}
-function getDefaultButtons(type) {
-  if (type === "question") {
-    return [
-      { label: "No", style: "default" },
-      { label: "Yes", style: "primary" }
-    ];
-  }
-  return [{ label: "OK", style: "primary" }];
-}
-function createModalHTML(state) {
-  const { options } = state;
-  const icon = getModalIcon(options.type);
-  const buttons = options.buttons || getDefaultButtons(options.type);
-  const typeClass = options.type || "info";
-  let buttonsHtml = "";
-  buttons.forEach((btn, index) => {
-    const styleClass = btn.style === "destructive" ? "destructive" : btn.style === "primary" ? "primary" : "default";
-    const autoFocus = index === (options.defaultButton ?? buttons.length - 1) ? "autofocus" : "";
-    buttonsHtml += `<button class="stx-modal-btn ${styleClass}" data-index="${index}" ${autoFocus}>${btn.label}</button>`;
-  });
-  return `
-    <div class="stx-modal-overlay" data-modal-id="${state.id}">
-      <div class="stx-modal ${typeClass}" role="dialog" aria-modal="true" aria-labelledby="${state.id}-title">
-        <div class="stx-modal-icon">${icon}</div>
-        <div class="stx-modal-content">
-          ${options.title ? `<h2 id="${state.id}-title" class="stx-modal-title">${escapeHtml2(options.title)}</h2>` : ""}
-          <p class="stx-modal-message">${escapeHtml2(options.message)}</p>
-        </div>
-        <div class="stx-modal-buttons">${buttonsHtml}</div>
-      </div>
-    </div>
-  `;
-}
-function escapeHtml2(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-function closeModal(state, buttonIndex, cancelled = false) {
-  const index = activeModals.indexOf(state);
-  if (index > -1) {
-    activeModals.splice(index, 1);
-  }
-  if (state.element && isBrowser2()) {
-    state.element.remove();
-  }
-  const buttons = state.options.buttons || getDefaultButtons(state.options.type);
-  const button = buttons[buttonIndex];
-  if (button?.action) {
-    button.action();
-  }
-  state.resolve({ buttonIndex, cancelled });
-}
-async function showModal(options) {
-  const hasNative = hasNativeDialogSupport();
-  const id = generateModalId();
-  return new Promise((resolve) => {
-    const state = {
-      id,
-      options,
-      resolve
-    };
-    activeModals.push(state);
-    if (hasNative) {
-      console.log(`[stx-modal] Showing native modal: ${options.title || "Modal"}`);
-      setTimeout(() => {
-        closeModal(state, options.defaultButton ?? 0, false);
-      }, 0);
-    } else if (isBrowser2()) {
-      try {
-        const container = document.createElement("div");
-        container.innerHTML = createModalHTML(state);
-        const overlay = container.firstElementChild;
-        if (!overlay) {
-          console.log(`[stx-modal] ${options.type?.toUpperCase() || "INFO"}: ${options.title || "Modal"}`);
-          console.log(`[stx-modal] ${options.message}`);
-          setTimeout(() => {
-            closeModal(state, options.defaultButton ?? 0, false);
-          }, 0);
-          return;
-        }
-        state.element = overlay;
-        try {
-          document.body.appendChild(overlay);
-        } catch {
-          console.log(`[stx-modal] ${options.type?.toUpperCase() || "INFO"}: ${options.title || "Modal"}`);
-          console.log(`[stx-modal] ${options.message}`);
-          setTimeout(() => {
-            closeModal(state, options.defaultButton ?? 0, false);
-          }, 0);
-          return;
-        }
-        try {
-          overlay.querySelectorAll(".stx-modal-btn").forEach((btn) => {
-            btn.addEventListener("click", () => {
-              const index = Number.parseInt(btn.dataset.index || "0", 10);
-              closeModal(state, index, false);
-            });
-          });
-        } catch {}
-        try {
-          overlay.addEventListener("click", (e) => {
-            if (e.target === overlay) {
-              const cancelIndex = options.cancelButton ?? 0;
-              closeModal(state, cancelIndex, true);
-            }
-          });
-        } catch {}
-        try {
-          const handleKeydown = (e) => {
-            if (e.key === "Escape") {
-              const cancelIndex = options.cancelButton ?? 0;
-              closeModal(state, cancelIndex, true);
-              document.removeEventListener("keydown", handleKeydown);
-            } else if (e.key === "Enter") {
-              const defaultIndex = options.defaultButton ?? (options.buttons || getDefaultButtons(options.type)).length - 1;
-              closeModal(state, defaultIndex, false);
-              document.removeEventListener("keydown", handleKeydown);
-            }
-          };
-          document.addEventListener("keydown", handleKeydown);
-        } catch {}
-        try {
-          const firstButton = overlay.querySelector(".stx-modal-btn[autofocus]");
-          if (firstButton) {
-            firstButton.focus();
-          }
-        } catch {}
-        if (typeof process !== "undefined" && process.env.BUN_TEST) {
-          setTimeout(() => {
-            closeModal(state, options.defaultButton ?? 0, false);
-          }, 0);
-        }
-      } catch {
-        console.log(`[stx-modal] ${options.type?.toUpperCase() || "INFO"}: ${options.title || "Modal"}`);
-        console.log(`[stx-modal] ${options.message}`);
-        setTimeout(() => {
-          closeModal(state, options.defaultButton ?? 0, false);
-        }, 0);
-      }
-    } else {
-      console.log(`[stx-modal] ${options.type?.toUpperCase() || "INFO"}: ${options.title || "Modal"}`);
-      console.log(`[stx-modal] ${options.message}`);
-      const buttons = options.buttons || getDefaultButtons(options.type);
-      console.log(`[stx-modal] Buttons: ${buttons.map((b) => b.label).join(", ")}`);
-      setTimeout(() => {
-        closeModal(state, options.defaultButton ?? 0, false);
-      }, 0);
-    }
-  });
-}
-async function showInfoModal(title, message) {
-  return showModal({ title, message, type: "info" });
-}
-async function showWarningModal(title, message) {
-  return showModal({ title, message, type: "warning" });
-}
-async function showErrorModal(title, message) {
-  return showModal({ title, message, type: "error" });
-}
-async function showSuccessModal(title, message) {
-  return showModal({ title, message, type: "success" });
-}
-async function showQuestionModal(title, message) {
-  return showModal({
-    title,
-    message,
-    type: "question",
-    buttons: [
-      { label: "No", style: "default" },
-      { label: "Yes", style: "primary" }
-    ],
-    defaultButton: 1,
-    cancelButton: 0
-  });
-}
-async function confirm2(message, title = "Confirm") {
-  const result = await showQuestionModal(title, message);
-  return result.buttonIndex === 1;
-}
-async function alert2(message, title = "Alert") {
-  await showInfoModal(title, message);
-}
-async function prompt2(message, defaultValue = "", title = "Input") {
-  if (isBrowser2() && typeof window.prompt === "function") {
-    return window.prompt(message, defaultValue);
-  }
-  console.log(`[stx-modal] PROMPT: ${title}`);
-  console.log(`[stx-modal] ${message}`);
-  console.log(`[stx-modal] Default: ${defaultValue}`);
-  return defaultValue;
-}
-function getActiveModalCount() {
-  return activeModals.length;
-}
-function closeAllModals() {
-  while (activeModals.length > 0) {
-    const state = activeModals[activeModals.length - 1];
-    closeModal(state, 0, true);
-  }
-}
-var MODAL_STYLES = `
-.stx-modal-overlay {
-  position: fixed;
-  inset: 0;
-  background: rgba(0, 0, 0, 0.5);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  z-index: 10000;
-  animation: stx-modal-fade-in 0.15s ease-out;
-}
-
-@keyframes stx-modal-fade-in {
-  from { opacity: 0; }
-  to { opacity: 1; }
-}
-
-.stx-modal {
-  background: #fff;
-  border-radius: 12px;
-  padding: 24px;
-  max-width: 400px;
-  width: 90%;
-  box-shadow: 0 20px 40px rgba(0, 0, 0, 0.2);
-  animation: stx-modal-slide-up 0.2s ease-out;
-}
-
-@keyframes stx-modal-slide-up {
-  from { transform: translateY(20px); opacity: 0; }
-  to { transform: translateY(0); opacity: 1; }
-}
-
-@media (prefers-color-scheme: dark) {
-  .stx-modal {
-    background: #2d2d2d;
-    color: #fff;
-  }
-}
-
-.stx-modal-icon {
-  font-size: 48px;
-  text-align: center;
-  margin-bottom: 16px;
-}
-
-.stx-modal.info .stx-modal-icon { color: #3498db; }
-.stx-modal.warning .stx-modal-icon { color: #f39c12; }
-.stx-modal.error .stx-modal-icon { color: #e74c3c; }
-.stx-modal.success .stx-modal-icon { color: #27ae60; }
-.stx-modal.question .stx-modal-icon { color: #9b59b6; }
-
-.stx-modal-content {
-  text-align: center;
-  margin-bottom: 24px;
-}
-
-.stx-modal-title {
-  margin: 0 0 8px;
-  font-size: 20px;
-  font-weight: 600;
-}
-
-.stx-modal-message {
-  margin: 0;
-  color: #666;
-  line-height: 1.5;
-}
-
-@media (prefers-color-scheme: dark) {
-  .stx-modal-message { color: #aaa; }
-}
-
-.stx-modal-buttons {
-  display: flex;
-  gap: 8px;
-  justify-content: center;
-}
-
-.stx-modal-btn {
-  padding: 10px 24px;
-  border-radius: 6px;
-  font-size: 14px;
-  font-weight: 500;
-  cursor: pointer;
-  border: none;
-  transition: background 0.15s, transform 0.1s;
-}
-
-.stx-modal-btn:hover {
-  transform: translateY(-1px);
-}
-
-.stx-modal-btn:active {
-  transform: translateY(0);
-}
-
-.stx-modal-btn.default {
-  background: #e0e0e0;
-  color: #333;
-}
-
-.stx-modal-btn.default:hover {
-  background: #d0d0d0;
-}
-
-.stx-modal-btn.primary {
-  background: #3498db;
-  color: #fff;
-}
-
-.stx-modal-btn.primary:hover {
-  background: #2980b9;
-}
-
-.stx-modal-btn.destructive {
-  background: #e74c3c;
-  color: #fff;
-}
-
-.stx-modal-btn.destructive:hover {
-  background: #c0392b;
-}
-
-@media (prefers-color-scheme: dark) {
-  .stx-modal-btn.default {
-    background: #444;
-    color: #fff;
-  }
-  .stx-modal-btn.default:hover {
-    background: #555;
-  }
-}
-`;
-// src/native-autolaunch.ts
-var nativeAutoLaunch = {
-  async enable() {
-    if (!hasBridge("autoLaunch"))
-      return false;
-    return await window.craft.autoLaunch.enable();
-  },
-  async disable() {
-    if (!hasBridge("autoLaunch"))
-      return false;
-    return await window.craft.autoLaunch.disable();
-  },
-  async isEnabled() {
-    if (!hasBridge("autoLaunch"))
-      return false;
-    return await window.craft.autoLaunch.isEnabled();
-  }
-};
-// src/network.ts
-var network = {
-  async connectionType() {
-    if (hasBridge("network"))
-      return await window.craft.network.connectionType();
-    return webConnectionType();
-  },
-  async wifiSSID() {
-    if (hasBridge("network")) {
-      const v = await window.craft.network.wifiSSID();
-      return v || undefined;
-    }
-    return;
-  },
-  async wifiSignalStrength() {
-    if (hasBridge("network")) {
-      const v = await window.craft.network.wifiSignalStrength();
-      return typeof v === "number" ? v : undefined;
-    }
-    return;
-  },
-  async ipAddress() {
-    if (hasBridge("network"))
-      return await window.craft.network.ipAddress();
-    return "";
-  },
-  async macAddress() {
-    if (hasBridge("network"))
-      return await window.craft.network.macAddress();
-    return "";
-  },
-  async interfaces() {
-    if (hasBridge("network"))
-      return await window.craft.network.interfaces();
-    return [];
-  },
-  async isVPNConnected() {
-    if (hasBridge("network"))
-      return await window.craft.network.isVPNConnected();
-    return false;
-  },
-  async proxySettings() {
-    if (hasBridge("network")) {
-      const r = await window.craft.network.proxySettings();
-      return r || {};
-    }
-    return {};
-  },
-  async openPreferences() {
-    if (hasBridge("network"))
-      await window.craft.network.openPreferences();
-  },
-  onChange(cb) {
-    if (hasBridge("network")) {
-      return onCraftEvent("craft:networkChange", cb);
-    }
-    if (typeof window === "undefined")
-      return () => {};
-    const onlineH = () => cb({ type: webConnectionType(), online: true });
-    const offlineH = () => cb({ type: "none", online: false });
-    window.addEventListener("online", onlineH);
-    window.addEventListener("offline", offlineH);
-    return () => {
-      window.removeEventListener("online", onlineH);
-      window.removeEventListener("offline", offlineH);
-    };
-  }
-};
-function webConnectionType() {
-  if (typeof navigator === "undefined")
-    return "unknown";
-  if (navigator.onLine === false)
-    return "none";
-  const conn = navigator.connection;
-  if (!conn)
-    return "unknown";
-  const t = String(conn.type || conn.effectiveType || "unknown").toLowerCase();
-  if (t === "wifi" || t === "cellular" || t === "ethernet" || t === "bluetooth" || t === "none")
-    return t;
-  return "unknown";
-}
-// src/notifications.ts
-var notifications = {
-  async show(options) {
-    if (!options.title)
-      throw new Error("notification title is required");
-    if (hasBridge("notifications")) {
-      await window.craft.notifications.show(options);
-      return;
-    }
-    if (typeof window !== "undefined" && "Notification" in window) {
-      const N = window.Notification;
-      if (N.permission === "granted") {
-        new N(options.title, { body: options.body, icon: options.icon });
-      } else if (N.permission === "default") {
-        const granted = await N.requestPermission() === "granted";
-        if (granted)
-          new N(options.title, { body: options.body, icon: options.icon });
-      }
-    }
-  },
-  async schedule(options) {
-    if (hasBridge("notifications")) {
-      const o = { ...options };
-      if (o.triggerAt instanceof Date)
-        o.triggerAt = o.triggerAt.toISOString();
-      await window.craft.notifications.schedule(o);
-      return;
-    }
-    const fireAt = toEpochMs(options.triggerAt);
-    const delay = Math.max(0, fireAt - Date.now());
-    setTimeout(() => {
-      this.show(options).catch(() => {});
-    }, delay);
-  },
-  async cancel(id) {
-    if (hasBridge("notifications")) {
-      await window.craft.notifications.cancel(id);
-    }
-  },
-  async cancelAll() {
-    if (hasBridge("notifications")) {
-      await window.craft.notifications.cancelAll();
-    }
-  },
-  async setBadge(n) {
-    const safe = Math.max(0, Math.round(Number.isFinite(n) ? n : 0));
-    if (hasBridge("notifications")) {
-      await window.craft.notifications.setBadge(safe);
-      return;
-    }
-    if (typeof navigator !== "undefined" && navigator.setAppBadge) {
-      try {
-        await navigator.setAppBadge(safe);
-      } catch {}
-    }
-  },
-  async clearBadge() {
-    if (hasBridge("notifications")) {
-      await window.craft.notifications.clearBadge();
-      return;
-    }
-    if (typeof navigator !== "undefined" && navigator.clearAppBadge) {
-      try {
-        await navigator.clearAppBadge();
-      } catch {}
-    }
-  },
-  async requestPermission() {
-    if (hasBridge("notifications")) {
-      return await window.craft.notifications.requestPermission();
-    }
-    if (typeof window !== "undefined" && "Notification" in window) {
-      const N = window.Notification;
-      if (N.permission === "granted")
-        return true;
-      if (N.permission === "denied")
-        return false;
-      const result = await N.requestPermission();
-      return result === "granted";
-    }
-    return false;
-  },
-  async registerCategories(categories) {
-    if (!Array.isArray(categories) || categories.length === 0)
-      return;
-    if (hasBridge("notifications")) {
-      const fn = window.craft.notifications.registerCategories;
-      if (typeof fn === "function")
-        await fn(categories);
-    }
-  },
-  onActionClicked(cb) {
-    return onCraftEvent("craft:notification:actionClicked", cb);
-  },
-  onReply(cb) {
-    return onCraftEvent("craft:notification:reply", cb);
-  }
-};
-function toEpochMs(t) {
-  if (t == null)
-    return Date.now();
-  if (t instanceof Date)
-    return t.getTime();
-  if (typeof t === "number")
-    return t;
-  const parsed = Date.parse(t);
-  return Number.isNaN(parsed) ? Date.now() : parsed;
-}
-// src/pdf.ts
-var pdf = {
-  async countPages(path) {
-    if (!path)
-      throw new Error("pdf.countPages: path is required");
-    if (!hasBridge("pdf"))
-      return 0;
-    return await window.craft.pdf.countPages(path);
-  },
-  async extractText(path) {
-    if (!path)
-      throw new Error("pdf.extractText: path is required");
-    if (!hasBridge("pdf"))
-      return "";
-    return await window.craft.pdf.extractText(path);
-  }
-};
-// src/permissions.ts
-var permissions = {
-  async check(name) {
-    if (hasBridge("permissions"))
-      return await window.craft.permissions.check(name);
-    return await webCheck(name);
-  },
-  async request(name) {
-    if (hasBridge("permissions"))
-      return await window.craft.permissions.request(name);
-    return await webRequest(name);
-  },
-  async openSettings(name) {
-    if (hasBridge("permissions"))
-      await window.craft.permissions.openSettings(name);
-  }
-};
-async function webCheck(name) {
-  if (typeof navigator === "undefined" || !navigator.permissions?.query)
-    return "not-supported";
-  try {
-    const result = await navigator.permissions.query({ name });
-    return mapWebState(result.state);
-  } catch {
-    return "not-supported";
-  }
-}
-async function webRequest(name) {
-  if (name === "notifications" && typeof window !== "undefined" && "Notification" in window) {
-    const r = await window.Notification.requestPermission();
-    return r === "granted" ? "granted" : r === "denied" ? "denied" : "undetermined";
-  }
-  return await webCheck(name);
-}
-function mapWebState(s) {
-  if (s === "granted")
-    return "granted";
-  if (s === "denied")
-    return "denied";
-  if (s === "prompt")
-    return "undetermined";
-  return "undetermined";
-}
-// src/power.ts
-var currentProcess = null;
-var currentInstance = null;
-
-class CaffeinateInstanceImpl {
-  _process;
-  _startedAt;
-  _endsAt;
-  _options;
-  _expireHandlers = [];
-  _expireTimer = null;
-  _stopped = false;
-  constructor(process2, options) {
-    this._process = process2;
-    this._options = options;
-    this._startedAt = new Date;
-    const duration = options.duration;
-    if (duration && duration > 0) {
-      const durationMs = duration * 60 * 1000;
-      this._endsAt = new Date(this._startedAt.getTime() + durationMs);
-      this._expireTimer = setTimeout(() => {
-        this._stopped = true;
-        for (const handler of this._expireHandlers) {
-          try {
-            handler();
-          } catch {}
-        }
-      }, durationMs);
-    } else {
-      this._endsAt = null;
-    }
-  }
-  get pid() {
-    return this._process.pid;
-  }
-  get startedAt() {
-    return this._startedAt;
-  }
-  get endsAt() {
-    return this._endsAt;
-  }
-  get options() {
-    return { ...this._options };
-  }
-  get isActive() {
-    if (this._stopped)
-      return false;
-    return this._process.exitCode === null;
-  }
-  get remainingMs() {
-    if (!this._endsAt)
-      return null;
-    const remaining = this._endsAt.getTime() - Date.now();
-    return Math.max(0, remaining);
-  }
-  get elapsedMs() {
-    return Date.now() - this._startedAt.getTime();
-  }
-  stop() {
-    if (this._stopped)
-      return;
-    this._stopped = true;
-    if (this._expireTimer) {
-      clearTimeout(this._expireTimer);
-      this._expireTimer = null;
-    }
-    try {
-      this._process.kill();
-    } catch {}
-  }
-  onExpire(handler) {
-    this._expireHandlers.push(handler);
-  }
-}
-function caffeinate(options = {}) {
-  decaffeinate();
-  const {
-    duration,
-    preventDisplaySleep = true,
-    preventIdleSleep = true,
-    preventSystemSleep = true,
-    preventDiskSleep = false,
-    assertUserActivity = true
-  } = options;
-  const flags = [];
-  if (preventDisplaySleep)
-    flags.push("-d");
-  if (preventIdleSleep)
-    flags.push("-i");
-  if (preventSystemSleep)
-    flags.push("-s");
-  if (preventDiskSleep)
-    flags.push("-m");
-  if (assertUserActivity)
-    flags.push("-u");
-  const args = [...flags];
-  if (duration && duration > 0) {
-    args.push("-t", String(duration * 60));
-  }
-  const proc = Bun.spawn(["/usr/bin/caffeinate", ...args], {
-    stdio: ["ignore", "ignore", "ignore"]
-  });
-  const instance = new CaffeinateInstanceImpl(proc, options);
-  currentProcess = proc;
-  currentInstance = instance;
-  return instance;
-}
-function decaffeinate(instance) {
-  if (instance) {
-    instance.stop();
-    if (currentInstance === instance) {
-      currentProcess = null;
-      currentInstance = null;
-    }
-    return;
-  }
-  if (currentInstance) {
-    currentInstance.stop();
-  }
-  currentProcess = null;
-  currentInstance = null;
-}
-function isCaffeinated() {
-  return currentInstance !== null && currentInstance.isActive;
-}
-function getCaffeinateStatus() {
-  if (!currentInstance || !currentInstance.isActive) {
-    return {
-      active: false,
-      instance: null,
-      startedAt: null,
-      endsAt: null,
-      durationMinutes: null
-    };
-  }
-  const opts = currentInstance.options;
-  const duration = opts.duration;
-  return {
-    active: true,
-    instance: currentInstance,
-    startedAt: currentInstance.startedAt,
-    endsAt: currentInstance.endsAt,
-    durationMinutes: duration && duration > 0 ? duration : -1
-  };
-}
-function formatRemainingTime(instance) {
-  const inst = instance || currentInstance;
-  if (!inst || !inst.isActive)
-    return "0:00";
-  const remaining = inst.remainingMs;
-  if (remaining === null)
-    return "\u221E";
-  const totalSeconds = Math.ceil(remaining / 1000);
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor(totalSeconds % 3600 / 60);
-  const seconds = totalSeconds % 60;
-  if (hours > 0)
-    return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-  return `${minutes}:${String(seconds).padStart(2, "0")}`;
-}
-function formatDuration(minutes) {
-  if (minutes <= 0 || minutes === -1)
-    return "Indefinitely";
-  if (minutes < 60)
-    return `${minutes} minutes`;
-  if (minutes === 60)
-    return "1 hour";
-  if (minutes % 60 === 0)
-    return `${minutes / 60} hours`;
-  const h = Math.floor(minutes / 60);
-  const m = minutes % 60;
-  return `${h}h ${m}m`;
-}
-// src/printing.ts
-var printing = {
-  async print() {
-    if (hasBridge("printing")) {
-      await window.craft.printing.print();
-      return;
-    }
-    if (typeof window !== "undefined" && typeof window.print === "function") {
-      window.print();
-    }
-  },
-  async printToPDF(path) {
-    if (!path)
-      throw new Error("printToPDF: path is required");
-    const isPosixAbs = path.startsWith("/");
-    const isWinAbs = /^[a-zA-Z]:[\\/]/.test(path) || path.startsWith("\\\\");
-    if (!isPosixAbs && !isWinAbs) {
-      throw new Error("printToPDF: path must be absolute");
-    }
-    const r = await requireBridge("printing").printToPDF(path);
-    return { ok: !!(r && r.ok), path: r?.path };
-  }
-};
-// src/screen.ts
-var screen = {
-  async getDisplays() {
-    if (hasBridge("screen"))
-      return await window.craft.screen.getDisplays();
-    return webDisplays();
-  },
-  async getPrimary() {
-    if (hasBridge("screen")) {
-      const r = await window.craft.screen.getPrimary();
-      return r && typeof r.width === "number" ? r : null;
-    }
-    return webDisplays()[0] ?? null;
-  },
-  onChange(cb) {
-    if (hasBridge("screen"))
-      return onCraftEvent("craft:screen:change", () => cb());
-    if (typeof window === "undefined")
-      return () => {};
-    const h = () => cb();
-    window.addEventListener("resize", h);
-    return () => window.removeEventListener("resize", h);
-  }
-};
-function webDisplays() {
-  if (typeof window === "undefined" || !window.screen)
-    return [];
-  const s = window.screen;
-  return [{
-    id: 0,
-    x: s.left ?? 0,
-    y: s.top ?? 0,
-    width: s.width || 0,
-    height: s.height || 0,
-    workX: s.availLeft ?? 0,
-    workY: s.availTop ?? 0,
-    workWidth: s.availWidth ?? s.width ?? 0,
-    workHeight: s.availHeight ?? s.height ?? 0,
-    scaleFactor: window.devicePixelRatio || 1
-  }];
-}
-// src/screen-capture.ts
-var screenCapture = {
-  async captureScreen() {
-    if (!hasBridge("screenCapture"))
-      return null;
-    const r = await window.craft.screenCapture.captureScreen();
-    return r ? String(r) : null;
-  },
-  async captureWindow(id) {
-    if (!hasBridge("screenCapture"))
-      return null;
-    if (!Number.isFinite(id) || id <= 0)
-      throw new Error("captureWindow: id must be a positive number");
-    const r = await window.craft.screenCapture.captureWindow(id);
-    return r ? String(r) : null;
-  },
-  async listWindows() {
-    if (!hasBridge("screenCapture"))
-      return [];
-    return await window.craft.screenCapture.listWindows();
-  }
-};
-// src/screen-sharing.ts
-var MIN_WATCH_INTERVAL_MS = 250;
-var MAX_WATCH_INTERVAL_MS = 60000;
-var DEFAULT_WATCH_INTERVAL_MS = 2000;
-var IDLE = {
-  sharing: false,
-  signals: {
-    systemScreenShare: false,
-    remoteSession: false,
-    conferenceSharing: false,
-    screenRecording: false
-  },
-  sources: []
-};
-function idleState() {
-  return { ...IDLE, signals: { ...IDLE.signals }, sources: [] };
-}
-var screenSharing = {
-  async getState() {
-    if (!hasBridge("screenSharing"))
-      return idleState();
-    return await window.craft.screenSharing.getState();
-  },
-  async watch(intervalMs = DEFAULT_WATCH_INTERVAL_MS) {
-    const clamped = Math.min(MAX_WATCH_INTERVAL_MS, Math.max(MIN_WATCH_INTERVAL_MS, Math.round(intervalMs)));
-    if (!hasBridge("screenSharing"))
-      return clamped;
-    const r = await window.craft.screenSharing.watch(clamped);
-    return r && r.intervalMs || clamped;
-  },
-  async stop() {
-    if (!hasBridge("screenSharing"))
-      return;
-    await window.craft.screenSharing.unwatch();
-  },
-  onChange(cb) {
-    return onCraftEvent("craft:screenSharing:change", cb);
-  }
-};
-async function watchScreenSharing(cb, intervalMs = DEFAULT_WATCH_INTERVAL_MS) {
-  const off = screenSharing.onChange(cb);
-  await screenSharing.watch(intervalMs);
-  return () => {
-    off();
-    screenSharing.stop();
-  };
-}
-// src/serial.ts
-var serial = {
-  async list() {
-    if (!hasBridge("serial"))
-      return [];
-    return await window.craft.serial.list();
-  },
-  async open(path, baud = 9600) {
-    if (!path)
-      throw new Error("serial.open: path is required");
-    if (!hasBridge("serial"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.serial.open(path, baud);
-  },
-  async write(id, data) {
-    if (!id)
-      throw new Error("serial.write: id is required");
-    if (!hasBridge("serial"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.serial.write(id, data);
-  },
-  async close(id) {
-    if (!hasBridge("serial"))
-      return;
-    await window.craft.serial.close(id);
-  },
-  onData(cb) {
-    return onCraftEvent("craft:serial:data", cb);
-  }
-};
-// src/service-menu.ts
-var serviceMenu = {
-  async register(name) {
-    if (!name)
-      throw new Error("serviceMenu.register: name is required");
-    if (!hasBridge("serviceMenu"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.serviceMenu.register(name);
-  },
-  async unregister(name) {
-    if (!name)
-      throw new Error("serviceMenu.unregister: name is required");
-    if (!hasBridge("serviceMenu"))
-      return;
-    await window.craft.serviceMenu.unregister(name);
-  },
-  onInvoked(cb) {
-    return onCraftEvent("craft:serviceMenu:invoked", cb);
-  }
-};
-// src/shell.ts
-var activeSpawnIds = new Set;
-var exitListenerAttached = false;
-function ensureExitListener() {
-  if (exitListenerAttached)
-    return;
-  if (typeof window === "undefined" || typeof window.addEventListener !== "function")
-    return;
-  window.addEventListener("craft:shell:exit", (e) => {
-    const detail = e.detail;
-    if (detail?.id)
-      activeSpawnIds.delete(detail.id);
-  });
-  exitListenerAttached = true;
-}
-var BLOCKED_SCHEMES = new Set(["javascript:", "data:", "file:", "vbscript:"]);
-var shell = {
-  async openExternal(url) {
-    const lc = url.trim().toLowerCase();
-    for (const s of BLOCKED_SCHEMES) {
-      if (lc.startsWith(s)) {
-        throw new Error(`shell.openExternal: ${s} URLs are blocked for safety`);
-      }
-    }
-    if (hasBridge("shell")) {
-      await window.craft.shell.openExternal(url);
-      return;
-    }
-    if (typeof window !== "undefined" && typeof window.open === "function") {
-      window.open(url, "_blank", "noopener,noreferrer");
-    }
-  },
-  async openPath(path) {
-    await requireBridge("shell").openPath(path);
-  },
-  async showInFinder(path) {
-    await requireBridge("shell").showInFinder(path);
-  },
-  async spawn(id, command, args = [], opts = {}) {
-    ensureExitListener();
-    if (!id || typeof id !== "string")
-      throw new Error("shell.spawn: id must be a non-empty string");
-    if (!command || typeof command !== "string")
-      throw new Error("shell.spawn: command must be a non-empty string");
-    if (!Array.isArray(args))
-      throw new Error("shell.spawn: args must be an array");
-    for (const a of args) {
-      if (typeof a !== "string")
-        throw new Error("shell.spawn: args entries must be strings");
-    }
-    if (activeSpawnIds.has(id)) {
-      throw new Error(`shell.spawn: id "${id}" is already in use \u2014 call kill(id) first or pick a different id`);
-    }
-    activeSpawnIds.add(id);
-    try {
-      await requireBridge("shell").spawn(id, command, args, opts);
-    } catch (e) {
-      activeSpawnIds.delete(id);
-      throw e;
-    }
-  },
-  async kill(id) {
-    await requireBridge("shell").kill(id);
-    activeSpawnIds.delete(id);
-  },
-  async getEnv(name) {
-    if (hasBridge("shell")) {
-      const v = await window.craft.shell.getEnv(name);
-      return v == null ? undefined : String(v);
-    }
-    return;
-  },
-  async setEnv(name, value) {
-    await requireBridge("shell").setEnv(name, value);
-  },
-  onStdout(cb) {
-    return onCraftEvent("craft:shell:stdout", cb);
-  },
-  onStderr(cb) {
-    return onCraftEvent("craft:shell:stderr", cb);
-  },
-  onExit(cb) {
-    return onCraftEvent("craft:shell:exit", cb);
-  }
-};
-// src/speech.ts
-var speech = {
-  async speak(text, options) {
-    if (!text)
-      throw new Error("speech.speak: text is required");
-    if (hasBridge("speech")) {
-      await window.craft.speech.speak(text, options);
-      return;
-    }
-    if (typeof window !== "undefined" && window.speechSynthesis) {
-      const u = new window.SpeechSynthesisUtterance(text);
-      if (options) {
-        if (options.rate != null)
-          u.rate = options.rate;
-        if (options.pitch != null)
-          u.pitch = options.pitch;
-        if (options.volume != null)
-          u.volume = options.volume;
-        if (options.voice) {
-          const voices = window.speechSynthesis.getVoices();
-          const match = voices.find((v) => v.voiceURI === options.voice || v.name === options.voice || v.lang === options.voice);
-          if (match)
-            u.voice = match;
-        }
-      }
-      window.speechSynthesis.speak(u);
-    }
-  },
-  async stop() {
-    if (hasBridge("speech")) {
-      await window.craft.speech.stop();
-      return;
-    }
-    if (typeof window !== "undefined" && window.speechSynthesis) {
-      window.speechSynthesis.cancel();
-    }
-  },
-  async pause() {
-    if (hasBridge("speech")) {
-      await window.craft.speech.pause();
-      return;
-    }
-    if (typeof window !== "undefined" && window.speechSynthesis) {
-      window.speechSynthesis.pause();
-    }
-  },
-  async resume() {
-    if (hasBridge("speech")) {
-      await window.craft.speech.resume();
-      return;
-    }
-    if (typeof window !== "undefined" && window.speechSynthesis) {
-      window.speechSynthesis.resume();
-    }
-  },
-  async isSpeaking() {
-    if (hasBridge("speech"))
-      return await window.craft.speech.isSpeaking();
-    if (typeof window !== "undefined" && window.speechSynthesis) {
-      return !!window.speechSynthesis.speaking;
-    }
-    return false;
-  },
-  async getVoices() {
-    if (hasBridge("speech"))
-      return await window.craft.speech.getVoices();
-    if (typeof window !== "undefined" && window.speechSynthesis) {
-      const raw = window.speechSynthesis.getVoices();
-      return raw.map((v) => ({
-        id: v.voiceURI || v.name,
-        name: v.name,
-        language: v.lang || "",
-        quality: "default"
-      }));
-    }
-    return [];
-  }
-};
-// src/speech-recognition.ts
-var speechRecognition = {
-  async isAvailable() {
-    if (!hasBridge("speechRecognition"))
-      return false;
-    return await window.craft.speechRecognition.isAvailable();
-  },
-  async start(opts) {
-    if (!hasBridge("speechRecognition"))
-      return { started: false, reason: "bridge unavailable" };
-    return await window.craft.speechRecognition.start(opts);
-  },
-  async stop() {
-    if (hasBridge("speechRecognition"))
-      await window.craft.speechRecognition.stop();
-  },
-  onPartial(cb) {
-    return onCraftEvent("craft:speechRecognition:partial", cb);
-  },
-  onFinal(cb) {
-    return onCraftEvent("craft:speechRecognition:final", cb);
-  }
-};
-// src/spotlight.ts
-var spotlight = {
-  async index(items) {
-    if (!hasBridge("spotlight"))
-      return { ok: false, reason: "bridge unavailable" };
-    return await window.craft.spotlight.index(items);
-  },
-  async remove(ids) {
-    if (!hasBridge("spotlight"))
-      return { ok: false };
-    return await window.craft.spotlight.remove(ids);
-  },
-  async removeAll() {
-    if (!hasBridge("spotlight"))
-      return { ok: false };
-    return await window.craft.spotlight.removeAll();
-  }
-};
-// src/tags.ts
-var tags = {
-  async get(path) {
-    if (!path)
-      throw new Error("tags.get: path is required");
-    if (!hasBridge("tags"))
-      return [];
-    return await window.craft.tags.get(path);
-  },
-  async set(path, t) {
-    if (!path)
-      throw new Error("tags.set: path is required");
-    if (!hasBridge("tags"))
-      return false;
-    const arr = Array.isArray(t) ? t : [String(t)];
-    return await window.craft.tags.set(path, arr);
-  },
-  async clear(path) {
-    if (!path)
-      throw new Error("tags.clear: path is required");
-    if (!hasBridge("tags"))
-      return false;
-    return await window.craft.tags.clear(path);
-  }
-};
-// src/theme.ts
-var theme = {
-  get() {
-    if (hasBridge("theme")) {
-      try {
-        return window.craft.theme.get();
-      } catch {}
-    }
-    return { appearance: detectWebAppearance() };
-  },
-  onChange(cb) {
-    cb(this.get());
-    if (hasBridge("theme")) {
-      return onCraftEvent("craft:theme", cb);
-    }
-    if (typeof window !== "undefined" && window.matchMedia) {
-      const mq = window.matchMedia("(prefers-color-scheme: dark)");
-      const handler = () => cb({ appearance: mq.matches ? "dark" : "light" });
-      mq.addEventListener("change", handler);
-      return () => mq.removeEventListener("change", handler);
-    }
-    return () => {};
-  },
-  async current() {
-    return this.get();
-  }
-};
-function detectWebAppearance() {
-  if (typeof window === "undefined" || !window.matchMedia)
-    return "light";
-  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-}
-// src/timer.ts
-class TimerImpl {
-  _duration;
-  _tickInterval;
-  _remaining;
-  _running = false;
-  _paused = false;
-  _complete = false;
-  _intervalId = null;
-  _lastTick = 0;
-  _completionHandlers = new Set;
-  _tickHandlers = new Set;
-  constructor(options) {
-    this._duration = options.duration;
-    this._tickInterval = options.tickInterval || 1000;
-    this._remaining = options.duration;
-    if (options.onComplete)
-      this._completionHandlers.add(options.onComplete);
-    if (options.onTick)
-      this._tickHandlers.add(options.onTick);
-    if (options.autoStart)
-      this.start();
-  }
-  get isRunning() {
-    return this._running && !this._paused;
-  }
-  get isPaused() {
-    return this._paused;
-  }
-  get isComplete() {
-    return this._complete;
-  }
-  get remaining() {
-    if (this._running && !this._paused) {
-      const elapsed = Date.now() - this._lastTick;
-      return Math.max(0, this._remaining - elapsed);
-    }
-    return Math.max(0, this._remaining);
-  }
-  get elapsed() {
-    return this._duration - this.remaining;
-  }
-  get duration() {
-    return this._duration;
-  }
-  get progress() {
-    if (this._duration === 0)
-      return 1;
-    return Math.min(1, this.elapsed / this._duration);
-  }
-  start() {
-    if (this._running)
-      return;
-    this._running = true;
-    this._paused = false;
-    this._complete = false;
-    this._lastTick = Date.now();
-    this._startInterval();
-  }
-  stop() {
-    this._clearInterval();
-    this._running = false;
-    this._paused = false;
-    this._remaining = this._duration;
-  }
-  pause() {
-    if (!this._running || this._paused)
-      return;
-    const elapsed = Date.now() - this._lastTick;
-    this._remaining = Math.max(0, this._remaining - elapsed);
-    this._clearInterval();
-    this._paused = true;
-  }
-  resume() {
-    if (!this._paused)
-      return;
-    this._paused = false;
-    this._lastTick = Date.now();
-    this._startInterval();
-  }
-  reset() {
-    this._clearInterval();
-    this._running = false;
-    this._paused = false;
-    this._complete = false;
-    this._remaining = this._duration;
-  }
-  onComplete(handler) {
-    this._completionHandlers.add(handler);
-    return () => {
-      this._completionHandlers.delete(handler);
-    };
-  }
-  onTick(handler) {
-    this._tickHandlers.add(handler);
-    return () => {
-      this._tickHandlers.delete(handler);
-    };
-  }
-  _startInterval() {
-    this._clearInterval();
-    this._intervalId = setInterval(() => {
-      const now = Date.now();
-      const elapsed = now - this._lastTick;
-      this._lastTick = now;
-      this._remaining = Math.max(0, this._remaining - elapsed);
-      for (const handler of this._tickHandlers) {
-        try {
-          handler(this._remaining);
-        } catch {}
-      }
-      if (this._remaining <= 0) {
-        this._clearInterval();
-        this._running = false;
-        this._complete = true;
-        for (const handler of this._completionHandlers) {
-          try {
-            handler();
-          } catch {}
-        }
-      }
-    }, this._tickInterval);
-  }
-  _clearInterval() {
-    if (this._intervalId !== null) {
-      clearInterval(this._intervalId);
-      this._intervalId = null;
-    }
-  }
-}
-
-class IntervalImpl {
-  _interval;
-  _handler;
-  _immediate;
-  _running = false;
-  _intervalId = null;
-  constructor(options) {
-    this._interval = options.interval;
-    this._handler = options.handler;
-    this._immediate = options.immediate !== false;
-    if (this._immediate)
-      this.start();
-  }
-  get isRunning() {
-    return this._running;
-  }
-  start() {
-    if (this._running)
-      return;
-    this._running = true;
-    this._intervalId = setInterval(() => {
-      try {
-        this._handler();
-      } catch {}
-    }, this._interval);
-  }
-  stop() {
-    if (this._intervalId !== null) {
-      clearInterval(this._intervalId);
-      this._intervalId = null;
-    }
-    this._running = false;
-  }
-}
-function createTimer(options) {
-  return new TimerImpl(options);
-}
-function createInterval(options) {
-  return new IntervalImpl(options);
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function formatTime(ms) {
-  const totalSeconds = Math.ceil(ms / 1000);
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor(totalSeconds % 3600 / 60);
-  const seconds = totalSeconds % 60;
-  if (hours > 0)
-    return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-  return `${minutes}:${String(seconds).padStart(2, "0")}`;
-}
-function formatCompact(ms) {
-  const totalSeconds = Math.ceil(ms / 1000);
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor(totalSeconds % 3600 / 60);
-  const seconds = totalSeconds % 60;
-  if (hours > 0) {
-    if (minutes > 0)
-      return `${hours}h ${minutes}m`;
-    return `${hours}h`;
-  }
-  if (minutes > 0) {
-    if (seconds > 0)
-      return `${minutes}m ${seconds}s`;
-    return `${minutes}m`;
-  }
-  return `${seconds}s`;
-}
-// src/touchbar.ts
-var touchbar = {
-  async addItem(item) {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.addItem(item);
-  },
-  async removeItem(id) {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.removeItem(id);
-  },
-  async updateItem(id, props) {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.updateItem(id, props);
-  },
-  async setLabel(id, label) {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.setLabel(id, label);
-  },
-  async setIcon(id, icon) {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.setIcon(id, icon);
-  },
-  async setEnabled(id, enabled) {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.setEnabled(id, enabled);
-  },
-  async setSliderValue(id, value) {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.setSliderValue(id, value);
-  },
-  async clear() {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.clear();
-  },
-  async show() {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.show();
-  },
-  async hide() {
-    if (hasBridge("touchbar"))
-      await window.craft.touchbar.hide();
-  },
-  onAction(cb) {
-    return onCraftEvent("craft:touchbar:action", cb);
-  }
-};
-// src/updater.ts
-var updater = {
-  async checkForUpdates() {
-    if (!hasBridge("updater"))
-      return;
-    await window.craft.updater.checkForUpdates();
-  },
-  async checkInBackground() {
-    if (!hasBridge("updater"))
-      return;
-    await window.craft.updater.checkInBackground();
-  },
-  async setAutomaticChecks(on) {
-    if (!hasBridge("updater"))
-      return;
-    await window.craft.updater.setAutomaticChecks(on);
-  },
-  async setCheckInterval(seconds) {
-    if (!hasBridge("updater"))
-      return;
-    if (!Number.isFinite(seconds)) {
-      throw new Error("setCheckInterval: must be a finite number");
-    }
-    const safe = seconds <= 0 ? 0 : Math.max(60, Math.round(seconds));
-    await window.craft.updater.setCheckInterval(safe);
-  },
-  async setFeedURL(url) {
-    if (!hasBridge("updater"))
-      return;
-    await window.craft.updater.setFeedURL(url);
-  },
-  async getLastUpdateCheckDate() {
-    if (!hasBridge("updater"))
-      return null;
-    const v = await window.craft.updater.getLastUpdateCheckDate();
-    return v || null;
-  },
-  async getUpdateInfo() {
-    if (!hasBridge("updater"))
-      return null;
-    const v = await window.craft.updater.getUpdateInfo();
-    if (!v || typeof v.version !== "string" || v.version.length === 0)
-      return null;
-    return v;
-  },
-  onAvailable(cb) {
-    return onCraftEvent("craft:updateAvailable", cb);
-  },
-  onDownloaded(cb) {
-    return onCraftEvent("craft:updateDownloaded", cb);
-  },
-  async verifySignature({ payload, signatureB64, publicKeyB64 }) {
-    const data = toArrayBufferBytes(payload);
-    let publicKey;
-    try {
-      publicKey = await crypto.subtle.importKey("raw", base64ToBytes2(publicKeyB64), { name: "Ed25519" }, false, ["verify"]);
-    } catch {
-      return false;
-    }
-    try {
-      return await crypto.subtle.verify("Ed25519", publicKey, base64ToBytes2(signatureB64), data);
-    } catch {
-      return false;
-    }
-  },
-  async verifyDownload({ url, signatureB64, publicKeyB64, fetchInit }) {
-    let response;
-    try {
-      response = await fetch(url, fetchInit);
-    } catch {
-      return { ok: false, reason: "fetch-failed" };
-    }
-    if (!response.ok) {
-      return { ok: false, reason: "http-error", status: response.status };
-    }
-    const buffer = new Uint8Array(await response.arrayBuffer());
-    let publicKey;
-    try {
-      publicKey = await crypto.subtle.importKey("raw", base64ToBytes2(publicKeyB64), { name: "Ed25519" }, false, ["verify"]);
-    } catch {
-      return { ok: false, reason: "bad-key" };
-    }
-    let valid = false;
-    try {
-      valid = await crypto.subtle.verify("Ed25519", publicKey, base64ToBytes2(signatureB64), toArrayBufferBytes(buffer));
-    } catch {
-      valid = false;
-    }
-    if (!valid)
-      return { ok: false, reason: "bad-signature" };
-    return { ok: true, payload: buffer };
-  }
-};
-function toArrayBufferBytes(input) {
-  if (input instanceof ArrayBuffer)
-    return new Uint8Array(input);
-  const out = new ArrayBuffer(input.byteLength);
-  const view = new Uint8Array(out);
-  view.set(input);
-  return view;
-}
-function base64ToBytes2(b64) {
-  if (typeof atob === "function") {
-    const bin = atob(b64);
-    const buffer = new ArrayBuffer(bin.length);
-    const out = new Uint8Array(buffer);
-    for (let i = 0;i < bin.length; i++)
-      out[i] = bin.charCodeAt(i);
-    return out;
-  }
-  const node = Buffer.from(b64, "base64");
-  const buf = new ArrayBuffer(node.length);
-  new Uint8Array(buf).set(node);
-  return new Uint8Array(buf);
-}
-// src/vision.ts
-var vision = {
-  async recognizeText(path) {
-    if (!path)
-      throw new Error("vision.recognizeText: path is required");
-    if (!hasBridge("vision"))
-      return [];
-    return await window.craft.vision.recognizeText(path);
-  },
-  async detectFaces(path) {
-    if (!path)
-      throw new Error("vision.detectFaces: path is required");
-    if (!hasBridge("vision"))
-      return [];
-    return await window.craft.vision.detectFaces(path);
-  },
-  async detectBarcodes(path) {
-    if (!path)
-      throw new Error("vision.detectBarcodes: path is required");
-    if (!hasBridge("vision"))
-      return [];
-    return await window.craft.vision.detectBarcodes(path);
-  }
-};
-// src/window-events.ts
-var windowEvents = {
-  onFocus(cb) {
-    if (hasBridge("window"))
-      return onCraftEvent("craft:window:focus", () => cb());
-    return webEvent("focus", cb);
-  },
-  onBlur(cb) {
-    if (hasBridge("window"))
-      return onCraftEvent("craft:window:blur", () => cb());
-    return webEvent("blur", cb);
-  },
-  onResize(cb) {
-    if (hasBridge("window"))
-      return onCraftEvent("craft:window:resize", cb);
-    if (typeof window === "undefined")
-      return () => {};
-    const h = () => cb({ width: window.innerWidth, height: window.innerHeight });
-    window.addEventListener("resize", h);
-    return () => window.removeEventListener("resize", h);
-  },
-  onMove(cb) {
-    if (hasBridge("window"))
-      return onCraftEvent("craft:window:move", cb);
-    return () => {};
-  },
-  onClose(cb) {
-    if (hasBridge("window"))
-      return onCraftEvent("craft:window:close", () => cb());
-    return webEvent("beforeunload", cb);
-  },
-  onMinimize(cb) {
-    if (hasBridge("window"))
-      return onCraftEvent("craft:window:minimize", () => cb());
-    if (typeof document === "undefined")
-      return () => {};
-    const h = () => {
-      if (document.visibilityState === "hidden")
-        cb();
-    };
-    document.addEventListener("visibilitychange", h);
-    return () => document.removeEventListener("visibilitychange", h);
-  },
-  onRestore(cb) {
-    if (hasBridge("window"))
-      return onCraftEvent("craft:window:restore", () => cb());
-    if (typeof document === "undefined")
-      return () => {};
-    const h = () => {
-      if (document.visibilityState === "visible")
-        cb();
-    };
-    document.addEventListener("visibilitychange", h);
-    return () => document.removeEventListener("visibilitychange", h);
-  }
-};
-function webEvent(name, cb) {
-  if (typeof window === "undefined")
-    return () => {};
-  const h = () => cb();
-  window.addEventListener(name, h);
-  return () => window.removeEventListener(name, h);
-}
+import {
+  DEFAULT_WATCH_INTERVAL_MS,
+  MAX_WATCH_INTERVAL_MS,
+  MIN_WATCH_INTERVAL_MS,
+  MODAL_STYLES,
+  TOAST_STYLES,
+  alert,
+  app,
+  appleScript,
+  audio,
+  battery,
+  biometric,
+  bluetooth,
+  bonjour,
+  caffeinate,
+  clipboard,
+  closeAllModals,
+  confirm,
+  continuityCamera,
+  coreml,
+  crashReporter,
+  createInterval,
+  createTimer,
+  decaffeinate,
+  deepLinks,
+  delay,
+  dismissAlertById,
+  dismissAllAlerts,
+  dragOut,
+  fileAssociations,
+  focus,
+  focusShortcutsReady,
+  formatCompact,
+  formatDuration,
+  formatRemainingTime,
+  formatShortcut,
+  formatTime,
+  fs,
+  getActiveAlertCount,
+  getActiveModalCount,
+  getCaffeinateStatus,
+  getCapabilities,
+  getCapability,
+  getDialogBridgeScript,
+  getRegisteredHotkeys,
+  globalShortcuts,
+  handoff,
+  hasFocusShortcuts,
+  iap,
+  isAvailable,
+  isCaffeinated,
+  isDragOutAvailable,
+  keychain,
+  liveActivities,
+  localServer,
+  location,
+  log,
+  menu,
+  midi,
+  nativeAutoLaunch,
+  network,
+  notifications,
+  notify,
+  parseShortcut,
+  pdf,
+  permissions,
+  printing,
+  prompt,
+  redactPII,
+  registerHotkey,
+  requestNotificationPermission,
+  screen,
+  screenCapture,
+  screenSharing,
+  serial,
+  serviceMenu,
+  shell,
+  showAlert,
+  showAlertDialog,
+  showColorPicker,
+  showConfirmDialog,
+  showErrorDialog,
+  showErrorModal,
+  showErrorToast,
+  showInfoModal,
+  showInfoToast,
+  showMessageBox,
+  showModal,
+  showOpenDialog,
+  showQuestionModal,
+  showSaveDialog,
+  showSuccessModal,
+  showSuccessToast,
+  showToast,
+  showWarningDialog,
+  showWarningModal,
+  showWarningToast,
+  signPayload,
+  speech,
+  speechRecognition,
+  spotlight,
+  tags,
+  theme,
+  touchbar,
+  unregisterAllHotkeys,
+  unregisterHotkey,
+  updater,
+  vision,
+  watchScreenSharing,
+  windowEvents
+} from "./chunk-ys4frvmj.js";
+import"./chunk-2mx7fq49.js";
 export {
   windowEvents,
   watchScreenSharing,
@@ -3948,7 +154,7 @@ export {
   requestNotificationPermission,
   registerHotkey,
   redactPII,
-  prompt2 as prompt,
+  prompt,
   printing,
   permissions,
   pdf,
@@ -3998,7 +204,7 @@ export {
   crashReporter,
   coreml,
   continuityCamera,
-  confirm2 as confirm,
+  confirm,
   closeAllModals,
   clipboard,
   caffeinate,
@@ -4009,12 +215,10 @@ export {
   audio,
   appleScript,
   app,
-  alert2 as alert,
+  alert,
   TOAST_STYLES,
   MODAL_STYLES,
   MIN_WATCH_INTERVAL_MS,
   MAX_WATCH_INTERVAL_MS,
   DEFAULT_WATCH_INTERVAL_MS
 };
-
-//# debugId=2BBECC339E514CD564756E2164756E21