@stacksjs/desktop 0.2.5 → 0.2.8

package/dist/index.js

@@ -2070,10 +2070,10 @@ var MODAL_STYLES = `
 }
 `;
 // src/system-tray.ts
-import process from "process";
+import process2 from "process";
 function getPlatform() {
-  if (process.platform) {
-    return process.platform;
+  if (process2.platform) {
+    return process2.platform;
   }
   return "unknown";
 }
@@ -2628,7 +2628,7 @@ window.stxDialog = {
 // src/window.ts
 import { existsSync } from "fs";
 import { join } from "path";
-import process2 from "process";
+import process3 from "process";
 var currentConfig = {};
 function setDesktopConfig(config) {
   currentConfig = { ...currentConfig, ...config };
@@ -2640,19 +2640,19 @@ function resetDesktopConfig() {
   currentConfig = {};
 }
 var DEFAULT_SEARCH_PATHS = [
-  join(process2.env.HOME || "", ".bun/bin/craft"),
-  join(process2.env.HOME || "", "Code/Tools/craft/packages/zig/zig-out/bin/craft"),
-  join(process2.env.HOME || "", "Code/craft/packages/zig/zig-out/bin/craft"),
-  join(process2.cwd(), "../../craft/packages/zig/zig-out/bin/craft"),
-  join(process2.cwd(), "../../craft/packages/zig/zig-out/bin/craft-minimal"),
-  join(process2.cwd(), "../../../craft/packages/zig/zig-out/bin/craft"),
-  join(process2.cwd(), "../../../craft/packages/zig/zig-out/bin/craft-minimal"),
-  join(process2.cwd(), "../craft/packages/zig/zig-out/bin/craft"),
-  join(process2.cwd(), "../craft/packages/zig/zig-out/bin/craft-minimal"),
-  join(process2.cwd(), "node_modules/.bin/craft")
+  join(process3.env.HOME || "", ".bun/bin/craft"),
+  join(process3.env.HOME || "", "Code/Tools/craft/packages/zig/zig-out/bin/craft"),
+  join(process3.env.HOME || "", "Code/craft/packages/zig/zig-out/bin/craft"),
+  join(process3.cwd(), "../../craft/packages/zig/zig-out/bin/craft"),
+  join(process3.cwd(), "../../craft/packages/zig/zig-out/bin/craft-minimal"),
+  join(process3.cwd(), "../../../craft/packages/zig/zig-out/bin/craft"),
+  join(process3.cwd(), "../../../craft/packages/zig/zig-out/bin/craft-minimal"),
+  join(process3.cwd(), "../craft/packages/zig/zig-out/bin/craft"),
+  join(process3.cwd(), "../craft/packages/zig/zig-out/bin/craft-minimal"),
+  join(process3.cwd(), "node_modules/.bin/craft")
 ];
 function getCraftBinaryPath() {
-  const envPath = process2.env.CRAFT_BINARY_PATH;
+  const envPath = process3.env.CRAFT_BINARY_PATH;
   if (envPath && existsSync(envPath)) {
     return envPath;
   }
@@ -2802,14 +2802,14 @@ async function openDevWindow(port, options = {}) {
     return true;
   } catch (error) {
     console.warn("\u26A0  Could not open native window:", error.message);
-    if (process2.env.NODE_ENV === "test" || process2.env.BUN_TEST) {
+    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...");
     try {
       const { spawn } = await import("child_process");
-      const platform = process2.platform;
+      const platform = process3.platform;
       let command;
       let args;
       if (platform === "darwin") {
@@ -2921,7 +2921,848 @@ window.stxWindow = {
 window.desktop = window.stxWindow;
 `;
 }
+// src/power.ts
+var currentProcess = null;
+var currentInstance = null;
+
+class CaffeinateInstanceImpl {
+  _process;
+  _startedAt;
+  _endsAt;
+  _options;
+  _expireHandlers = [];
+  _expireTimer = null;
+  _stopped = false;
+  constructor(process4, options) {
+    this._process = process4;
+    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/preferences.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, watch } from "fs";
+import { dirname, join as join2 } from "path";
+import { homedir, platform } from "os";
+function getDefaultPrefsDir(appName) {
+  const os = platform();
+  const home = homedir();
+  switch (os) {
+    case "darwin":
+      return join2(home, "Library", "Application Support", appName);
+    case "win32":
+      return join2(process.env.APPDATA || join2(home, "AppData", "Roaming"), appName);
+    default:
+      return join2(home, ".config", appName);
+  }
+}
+
+class PreferencesImpl {
+  _defaults;
+  _data;
+  _path;
+  _changeHandlers = new Map;
+  _anyChangeHandlers = new Set;
+  _watcher = null;
+  _writeTimer = null;
+  _writing = false;
+  constructor(options) {
+    this._defaults = { ...options.defaults };
+    const dir = options.path ? dirname(options.path) : getDefaultPrefsDir(options.name);
+    this._path = options.path || join2(dir, "preferences.json");
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this._data = this._load();
+    if (options.watch !== false) {
+      this._setupWatcher();
+    }
+  }
+  get path() {
+    return this._path;
+  }
+  get(key) {
+    if (key in this._data) {
+      return this._data[key];
+    }
+    return this._defaults[key];
+  }
+  set(key, value) {
+    const oldValue = this.get(key);
+    if (JSON.stringify(oldValue) === JSON.stringify(value))
+      return;
+    this._data[key] = value;
+    this._scheduleSave();
+    this._notifyChange(key, value, oldValue);
+  }
+  getAll() {
+    return { ...this._defaults, ...this._data };
+  }
+  has(key) {
+    return key in this._data;
+  }
+  delete(key) {
+    if (!(key in this._data))
+      return;
+    const oldValue = this._data[key];
+    delete this._data[key];
+    this._scheduleSave();
+    this._notifyChange(key, this._defaults[key], oldValue);
+  }
+  reset() {
+    const oldData = { ...this._data };
+    this._data = {};
+    this._save();
+    for (const key of Object.keys(oldData)) {
+      const defaultVal = this._defaults[key];
+      this._notifyChange(key, defaultVal, oldData[key]);
+    }
+  }
+  onChange(key, handler) {
+    const keyStr = key;
+    if (!this._changeHandlers.has(keyStr)) {
+      this._changeHandlers.set(keyStr, new Set);
+    }
+    this._changeHandlers.get(keyStr).add(handler);
+    return () => {
+      this._changeHandlers.get(keyStr)?.delete(handler);
+    };
+  }
+  onAnyChange(handler) {
+    this._anyChangeHandlers.add(handler);
+    return () => {
+      this._anyChangeHandlers.delete(handler);
+    };
+  }
+  close() {
+    if (this._watcher) {
+      this._watcher.close();
+      this._watcher = null;
+    }
+    if (this._writeTimer) {
+      clearTimeout(this._writeTimer);
+      this._writeTimer = null;
+      this._save();
+    }
+  }
+  _load() {
+    try {
+      if (existsSync2(this._path)) {
+        const content = readFileSync(this._path, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {}
+    return {};
+  }
+  _save() {
+    this._writing = true;
+    try {
+      const json = JSON.stringify({ ...this._defaults, ...this._data }, null, 2);
+      writeFileSync(this._path, json, "utf-8");
+    } catch (err) {
+      console.error(`Failed to save preferences to ${this._path}:`, err);
+    } finally {
+      setTimeout(() => {
+        this._writing = false;
+      }, 100);
+    }
+  }
+  _scheduleSave() {
+    if (this._writeTimer) {
+      clearTimeout(this._writeTimer);
+    }
+    this._writeTimer = setTimeout(() => {
+      this._writeTimer = null;
+      this._save();
+    }, 50);
+  }
+  _setupWatcher() {
+    try {
+      if (!existsSync2(this._path)) {
+        this._save();
+      }
+      this._watcher = watch(this._path, () => {
+        if (this._writing)
+          return;
+        const newData = this._load();
+        const oldData = { ...this._data };
+        this._data = newData;
+        const allKeys = new Set([...Object.keys(oldData), ...Object.keys(newData)]);
+        for (const key of allKeys) {
+          const oldVal = key in oldData ? oldData[key] : this._defaults[key];
+          const newVal = key in newData ? newData[key] : this._defaults[key];
+          if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+            this._notifyChange(key, newVal, oldVal);
+          }
+        }
+      });
+    } catch {}
+  }
+  _notifyChange(key, value, oldValue) {
+    const handlers = this._changeHandlers.get(key);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(value, oldValue);
+        } catch {}
+      }
+    }
+    for (const handler of this._anyChangeHandlers) {
+      try {
+        handler(key, value, oldValue);
+      } catch {}
+    }
+  }
+}
+function createPreferences(options) {
+  return new PreferencesImpl(options);
+}
+// src/autolaunch.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2, platform as platform2 } from "os";
+function getLaunchAgentPath(appName) {
+  const identifier = appName.toLowerCase().replace(/[^a-z0-9]/g, "-");
+  return join3(homedir2(), "Library", "LaunchAgents", `com.${identifier}.plist`);
+}
+function getLinuxAutostartPath(appName) {
+  const configDir = process.env.XDG_CONFIG_HOME || join3(homedir2(), ".config");
+  return join3(configDir, "autostart", `${appName.toLowerCase()}.desktop`);
+}
+async function setAutoLaunchMacOS(enabled, options) {
+  const appName = options.appName || "StxApp";
+  const plistPath = getLaunchAgentPath(appName);
+  const launchAgentsDir = join3(homedir2(), "Library", "LaunchAgents");
+  if (enabled) {
+    const appPath = options.appPath || process.execPath;
+    const args = options.args || [];
+    const programArgs = [appPath, ...args];
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.${appName.toLowerCase().replace(/[^a-z0-9]/g, "-")}</string>
+    <key>ProgramArguments</key>
+    <array>
+${programArgs.map((arg) => `        <string>${escapeXml(arg)}</string>`).join(`
+`)}
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <false/>
+${options.isHidden ? `    <key>ProcessType</key>
+    <string>Background</string>` : ""}
+</dict>
+</plist>`;
+    if (!existsSync3(launchAgentsDir)) {
+      mkdirSync2(launchAgentsDir, { recursive: true });
+    }
+    writeFileSync2(plistPath, plist, "utf-8");
+  } else {
+    if (existsSync3(plistPath)) {
+      unlinkSync(plistPath);
+    }
+  }
+}
+async function setAutoLaunchLinux(enabled, options) {
+  const appName = options.appName || "StxApp";
+  const desktopPath = getLinuxAutostartPath(appName);
+  const autostartDir = join3(process.env.XDG_CONFIG_HOME || join3(homedir2(), ".config"), "autostart");
+  if (enabled) {
+    const appPath = options.appPath || process.execPath;
+    const args = options.args || [];
+    const exec = [appPath, ...args].join(" ");
+    const desktopEntry = `[Desktop Entry]
+Type=Application
+Name=${appName}
+Exec=${exec}
+Terminal=false
+StartupNotify=false
+${options.isHidden ? `X-GNOME-Autostart-enabled=true
+NoDisplay=true` : ""}
+`;
+    if (!existsSync3(autostartDir)) {
+      mkdirSync2(autostartDir, { recursive: true });
+    }
+    writeFileSync2(desktopPath, desktopEntry, "utf-8");
+  } else {
+    if (existsSync3(desktopPath)) {
+      unlinkSync(desktopPath);
+    }
+  }
+}
+async function isAutoLaunchEnabledMacOS(appName) {
+  return existsSync3(getLaunchAgentPath(appName));
+}
+async function isAutoLaunchEnabledLinux(appName) {
+  const path = getLinuxAutostartPath(appName);
+  if (!existsSync3(path))
+    return false;
+  try {
+    const content = readFileSync2(path, "utf-8");
+    if (content.includes("X-GNOME-Autostart-enabled=false"))
+      return false;
+    if (content.includes("Hidden=true"))
+      return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+async function setAutoLaunch(enabled, options = {}) {
+  const os = platform2();
+  switch (os) {
+    case "darwin":
+      return setAutoLaunchMacOS(enabled, options);
+    case "linux":
+      return setAutoLaunchLinux(enabled, options);
+    default:
+      throw new Error(`Auto-launch is not yet supported on ${os}`);
+  }
+}
+async function isAutoLaunchEnabled(appName) {
+  const name = appName || "StxApp";
+  const os = platform2();
+  switch (os) {
+    case "darwin":
+      return isAutoLaunchEnabledMacOS(name);
+    case "linux":
+      return isAutoLaunchEnabledLinux(name);
+    default:
+      return false;
+  }
+}
+// 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/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`;
+}
 export {
+  unregisterHotkey,
+  unregisterAllHotkeys,
   triggerTrayAction,
   showWarningToast,
   showWarningModal,
@@ -2944,30 +3785,45 @@ export {
   showAlertDialog,
   showAlert,
   setDesktopConfig,
+  setAutoLaunch,
   resetDesktopConfig,
   requestNotificationPermission,
+  registerHotkey,
   prompt2 as prompt,
+  parseShortcut,
   openDevWindow,
   notify,
   isWebviewAvailable,
+  isCaffeinated,
+  isAutoLaunchEnabled,
   getWindowBridgeScript,
   getWindow,
   getTrayInstance,
   getTrayBridgeScript,
   getSimulatedTrayHTML,
+  getRegisteredHotkeys,
   getDialogBridgeScript,
   getDesktopConfig,
+  getCaffeinateStatus,
   getActiveWindowIds,
   getActiveTrayInstances,
   getActiveModalCount,
   getActiveAlertCount,
+  formatTime,
+  formatShortcut,
+  formatRemainingTime,
+  formatDuration,
+  formatCompact,
   dismissAllAlerts,
   dismissAlertById,
+  delay,
+  decaffeinate,
   createWindowWithHTML,
   createWindow,
   createWebView,
   createTreeView,
   createTooltip,
+  createTimer,
   createTimePicker,
   createTextInput,
   createTabs,
@@ -2980,11 +3836,13 @@ export {
   createRating,
   createRadioButton,
   createProgressBar,
+  createPreferences,
   createModalComponent,
   createMenubar,
   createMediaPlayer,
   createListView,
   createLabel,
+  createInterval,
   createImageView,
   createFileExplorer,
   createDropdown,
@@ -3004,6 +3862,7 @@ export {
   confirm2 as confirm,
   closeAllWindows,
   closeAllModals,
+  caffeinate,
   alert2 as alert,
   TRAY_MENU_STYLES,
   TOAST_STYLES,
@@ -3012,4 +3871,4 @@ export {
   AVAILABLE_COMPONENTS
 };
 
-//# debugId=574CB389B0B4B44F64756E2164756E21
+//# debugId=20FC12EC72514C4464756E2164756E21