@stacksjs/desktop 0.2.20 → 0.2.24

package/dist/index.js

@@ -2772,14 +2772,19 @@ async function createWindow(url, options = {}) {
 }
 async function openDevWindow(port, options = {}) {
   const url = `http://localhost:${port}/`;
+  const isTestEnv = process3.env.NODE_ENV === "test" || process3.env.BUN_TEST;
+  if (isTestEnv) {
+    console.warn("\u26A0  Skipping native window in test environment");
+    console.log("(Skipping browser fallback in test environment)");
+    return false;
+  }
   try {
     const { createApp } = await import("ts-craft");
-    console.log("\u26A1 Opening native window...");
-    const craftPath = getCraftBinaryPath();
+    console.log("\u26A1 Opening native window via ts-craft\u2026");
     const useSystemTray = !options.nativeSidebar;
     const app = createApp({
       url,
-      craftPath,
+      craftPath: getCraftBinaryPath(),
       window: {
         title: options.title || "stx Development",
         width: options.width || 1400,
@@ -2798,30 +2803,51 @@ async function openDevWindow(port, options = {}) {
     activeWindows.set(id, { app, url, options });
     await app.show();
     console.log(`\u2713 Native window opened at ${url}`);
-    console.log(`\uD83D\uDCCC Look for the "stx Development" icon in your menubar`);
     return true;
-  } catch (error) {
-    console.warn("\u26A0  Could not open native window:", error.message);
+  } catch (tsCraftErr) {
+    const craftPath = getCraftBinaryPath();
+    if (craftPath) {
+      try {
+        console.log(`\u26A1 Opening native window via craft binary (${craftPath})\u2026`);
+        const { spawn } = await import("child_process");
+        const args = [
+          "--url",
+          url,
+          "--title",
+          options.title || "stx Development",
+          "--width",
+          String(options.width || 1400),
+          "--height",
+          String(options.height || 900)
+        ];
+        if (options.darkMode)
+          args.push("--dark");
+        if (options.hotReload ?? true)
+          args.push("--hot-reload");
+        const child = spawn(craftPath, args, { stdio: "inherit" });
+        child.on("exit", () => process3.exit(0));
+        child.on("error", (err) => console.warn("craft child error:", err.message));
+        const id = `dev-window-${port}`;
+        activeWindows.set(id, { app: { close: () => child.kill() }, url, options });
+        console.log(`\u2713 Native window opened at ${url}`);
+        return true;
+      } catch (binaryErr) {
+        console.warn("\u26A0  Could not spawn craft binary:", binaryErr.message);
+      }
+    } else {
+      console.warn("\u26A0  ts-craft not installed and no craft binary found");
+      console.warn(`    (ts-craft error: ${tsCraftErr.message})`);
+    }
     if (process3.env.NODE_ENV === "test" || process3.env.BUN_TEST) {
       console.log("(Skipping browser fallback in test environment)");
       return false;
     }
-    console.log("\uD83D\uDCF1 Opening in browser instead...");
+    console.log("\uD83D\uDCF1 Opening in browser instead\u2026");
     try {
       const { spawn } = await import("child_process");
       const platform = process3.platform;
-      let command;
-      let args;
-      if (platform === "darwin") {
-        command = "open";
-        args = [url];
-      } else if (platform === "win32") {
-        command = "cmd";
-        args = ["/c", "start", url];
-      } else {
-        command = "xdg-open";
-        args = [url];
-      }
+      const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+      const args = platform === "win32" ? ["/c", "start", url] : [url];
       spawn(command, args, { detached: true, stdio: "ignore" }).unref();
       console.log(`\u2713 Browser opened at ${url}`);
       return true;
@@ -3760,10 +3786,2428 @@ function formatCompact(ms) {
   }
   return `${seconds}s`;
 }
+// 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/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/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 delay2 = Math.max(0, fireAt - Date.now());
+    setTimeout(() => {
+      this.show(options).catch(() => {});
+    }, delay2);
+  },
+  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/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/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/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/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/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/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/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/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/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/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);
+}
+// 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/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/system.ts
+var system = {
+  accentColor: () => bridgeOr("system", "accentColor", () => ""),
+  highlightColor: () => bridgeOr("system", "highlightColor", () => ""),
+  language: () => bridgeOr("system", "language", () => {
+    if (typeof navigator === "undefined")
+      return "";
+    return navigator.language?.split("-")[0] || "";
+  }),
+  locale: () => bridgeOr("system", "locale", () => {
+    if (typeof navigator === "undefined")
+      return "";
+    return navigator.language || "";
+  }),
+  timezone: () => bridgeOr("system", "timezone", () => {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().timeZone || "";
+    } catch {
+      return "";
+    }
+  }),
+  is24HourTime: () => bridgeOr("system", "is24HourTime", () => {
+    try {
+      const opts = new Intl.DateTimeFormat([], { hour: "numeric" }).resolvedOptions();
+      return opts.hourCycle === "h23" || opts.hourCycle === "h24";
+    } catch {
+      return false;
+    }
+  }),
+  reduceMotion: () => bridgeOr("system", "reduceMotion", () => mediaMatches("(prefers-reduced-motion: reduce)")),
+  reduceTransparency: () => bridgeOr("system", "reduceTransparency", () => mediaMatches("(prefers-reduced-transparency: reduce)")),
+  increaseContrast: () => bridgeOr("system", "increaseContrast", () => mediaMatches("(prefers-contrast: more)")),
+  systemVersion: () => bridgeOr("system", "systemVersion", () => ""),
+  hostname: () => bridgeOr("system", "hostname", () => ""),
+  username: () => bridgeOr("system", "username", () => ""),
+  async openPreferences() {
+    if (hasBridge("system"))
+      await window.craft.system.openPreferences();
+  }
+};
+async function bridgeOr(ns, method, fallback) {
+  if (hasBridge(ns))
+    return await window.craft[ns][method]();
+  return await fallback();
+}
+function mediaMatches(query) {
+  if (typeof window === "undefined" || !window.matchMedia)
+    return false;
+  return window.matchMedia(query).matches;
+}
+// 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/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/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/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/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/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/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/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/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 delay2 = 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, delay2);
+        });
+        delay2 = Math.min(delay2 * 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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/continuity-camera.ts
+var continuityCamera = {
+  async listCameras() {
+    if (!hasBridge("continuityCamera"))
+      return [];
+    return await window.craft.continuityCamera.listCameras();
+  }
+};
+// 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/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/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;
+}
 export {
+  windowEvents,
+  vision,
+  updater,
   unregisterHotkey,
   unregisterAllHotkeys,
   triggerTrayAction,
+  touchbar,
+  theme,
+  tags,
+  system,
+  spotlight,
+  speechRecognition,
+  speech,
+  signPayload,
   showWarningToast,
   showWarningModal,
   showWarningDialog,
@@ -3784,18 +6228,42 @@ export {
   showColorPicker,
   showAlertDialog,
   showAlert,
+  shell,
   setDesktopConfig,
   setAutoLaunch,
+  serviceMenu,
+  serial,
+  screenCapture,
+  screen,
   resetDesktopConfig,
   requestNotificationPermission,
   registerHotkey,
+  redactPII,
   prompt2 as prompt,
+  printing,
+  permissions,
+  pdf,
   parseShortcut,
   openDevWindow,
   notify,
+  notifications,
+  network,
+  nativeAutoLaunch,
+  midi,
+  menu,
+  log,
+  location,
+  localServer,
+  liveActivities,
+  keychain,
   isWebviewAvailable,
+  isDragOutAvailable,
   isCaffeinated,
+  isAvailable,
   isAutoLaunchEnabled,
+  iap,
+  handoff,
+  globalShortcuts,
   getWindowBridgeScript,
   getWindow,
   getTrayInstance,
@@ -3804,19 +6272,25 @@ export {
   getRegisteredHotkeys,
   getDialogBridgeScript,
   getDesktopConfig,
+  getCapability,
+  getCapabilities,
   getCaffeinateStatus,
   getActiveWindowIds,
   getActiveTrayInstances,
   getActiveModalCount,
   getActiveAlertCount,
+  fs,
   formatTime,
   formatShortcut,
   formatRemainingTime,
   formatDuration,
   formatCompact,
+  fileAssociations,
+  dragOut,
   dismissAllAlerts,
   dismissAlertById,
   delay,
+  deepLinks,
   decaffeinate,
   createWindowWithHTML,
   createWindow,
@@ -3859,10 +6333,21 @@ export {
   createAvatar,
   createAutocomplete,
   createAccordion,
+  crashReporter,
+  coreml,
+  continuityCamera,
   confirm2 as confirm,
   closeAllWindows,
   closeAllModals,
+  clipboard,
   caffeinate,
+  bonjour,
+  bluetooth,
+  biometric,
+  battery,
+  audio,
+  appleScript,
+  app as appInfo,
   alert2 as alert,
   TRAY_MENU_STYLES,
   TOAST_STYLES,
@@ -3871,4 +6356,4 @@ export {
   AVAILABLE_COMPONENTS
 };
 
-//# debugId=20FC12EC72514C4464756E2164756E21
+//# debugId=EABDD0C2E7CA346F64756E2164756E21