@chromahq/core 1.0.43 → 1.0.45

package/dist/{boot-DKPBDDrp.js → boot-PbJQqgzX.js}

@@ -497,85 +497,189 @@ function bootstrap$1(options) {
   return runtime;
 }
 
-class AlarmAdapter {
+const _AlarmAdapter = class _AlarmAdapter {
   constructor() {
     this.callbacks = /* @__PURE__ */ new Map();
+    this.listenerRegistered = false;
+    /**
+     * Initialize the Chrome Alarms listener (once)
+     */
+    this.initializeAlarmListener = () => {
+      if (this.listenerRegistered) return;
+      if (this.isChromeAlarmsAvailable()) {
+        this.clearStaleAlarms();
+        chrome.alarms.onAlarm.addListener(this.handleAlarm);
+        this.listenerRegistered = true;
+        console.log("[AlarmAdapter] \u2705 Chrome Alarms API available and listener registered");
+      } else {
+        console.log(
+          "[AlarmAdapter] \u26A0\uFE0F Chrome Alarms API not available - will use setTimeout fallback"
+        );
+      }
+    };
+    /**
+     * Clear any stale chroma alarms from previous SW instances
+     */
+    this.clearStaleAlarms = () => {
+      if (!this.isChromeAlarmsAvailable()) return;
+      chrome.alarms.getAll((alarms) => {
+        const staleAlarms = alarms.filter((a) => a.name.startsWith(_AlarmAdapter.ALARM_PREFIX));
+        if (staleAlarms.length > 0) {
+          console.log(
+            `[AlarmAdapter] \u{1F9F9} Clearing ${staleAlarms.length} stale alarms from previous session`
+          );
+          staleAlarms.forEach((alarm) => {
+            chrome.alarms.clear(alarm.name);
+          });
+        }
+      });
+    };
+    /**
+     * Check if Chrome Alarms API is available
+     */
+    this.isChromeAlarmsAvailable = () => {
+      return !!(typeof chrome !== "undefined" && chrome.alarms && typeof chrome.alarms.create === "function" && typeof chrome.alarms.clear === "function" && chrome.alarms.onAlarm?.addListener);
+    };
+    /**
+     * Handle alarm trigger from Chrome
+     */
+    this.handleAlarm = (alarm) => {
+      if (!alarm.name.startsWith(_AlarmAdapter.ALARM_PREFIX)) {
+        return;
+      }
+      const jobId = alarm.name.slice(_AlarmAdapter.ALARM_PREFIX.length);
+      console.log(`[AlarmAdapter] \u{1F514} Chrome Alarm fired: ${jobId}`);
+      this.callbacks.delete(jobId);
+      this.triggerCallback?.(jobId);
+    };
+    this.onTrigger = (callback) => {
+      this.triggerCallback = callback;
+    };
+    this.schedule = (id, when) => {
+      this.cancel(id);
+      const delay = Math.max(0, when - Date.now());
+      const delayInMinutes = delay / 6e4;
+      if (this.isChromeAlarmsAvailable() && delayInMinutes >= 0.5) {
+        const alarmName = `${_AlarmAdapter.ALARM_PREFIX}${id}`;
+        chrome.alarms.create(alarmName, {
+          when
+        });
+        console.log(
+          `[AlarmAdapter] \u23F0 Chrome Alarm scheduled: ${id} in ${Math.round(delay / 1e3)}s`
+        );
+        this.callbacks.set(id, () => {
+          chrome.alarms.clear(alarmName);
+        });
+        return null;
+      }
+      console.log(
+        `[AlarmAdapter] \u23F1\uFE0F setTimeout fallback: ${id} in ${Math.round(delay / 1e3)}s (Chrome Alarms: ${this.isChromeAlarmsAvailable() ? "available but delay too short" : "unavailable"})`
+      );
+      const timeoutId = setTimeout(() => {
+        this.callbacks.delete(id);
+        this.triggerCallback?.(id);
+      }, delay);
+      this.callbacks.set(id, () => clearTimeout(timeoutId));
+      return timeoutId;
+    };
+    this.cancel = (id) => {
+      const callback = this.callbacks.get(id);
+      if (callback) {
+        callback();
+        this.callbacks.delete(id);
+      }
+      if (this.isChromeAlarmsAvailable()) {
+        const alarmName = `${_AlarmAdapter.ALARM_PREFIX}${id}`;
+        chrome.alarms.clear(alarmName);
+      }
+    };
+    /**
+     * Get the number of active alarms (for debugging/monitoring)
+     */
+    this.size = () => {
+      return this.callbacks.size;
+    };
+    /**
+     * Clear all alarms (for shutdown)
+     */
+    this.clear = () => {
+      for (const [id, callback] of this.callbacks.entries()) {
+        callback();
+      }
+      this.callbacks.clear();
+      if (this.isChromeAlarmsAvailable()) {
+        chrome.alarms.getAll((alarms) => {
+          for (const alarm of alarms) {
+            if (alarm.name.startsWith(_AlarmAdapter.ALARM_PREFIX)) {
+              chrome.alarms.clear(alarm.name);
+            }
+          }
+        });
+      }
+    };
+    /**
+     * Get diagnostic info about active alarms
+     */
+    this.getDiagnostics = async () => {
+      const chromeAlarms = [];
+      if (this.isChromeAlarmsAvailable()) {
+        await new Promise((resolve) => {
+          chrome.alarms.getAll((alarms) => {
+            chromeAlarms.push(...alarms.filter((a) => a.name.startsWith(_AlarmAdapter.ALARM_PREFIX)));
+            resolve();
+          });
+        });
+      }
+      return {
+        trackedAlarms: this.callbacks.size,
+        chromeAlarms,
+        usingChromeApi: this.isChromeAlarmsAvailable()
+      };
+    };
+    this.initializeAlarmListener();
   }
-  onTrigger(callback) {
-    this.triggerCallback = callback;
-  }
-  schedule(id, when) {
-    this.cancel(id);
-    const delay = Math.max(0, when - Date.now());
-    const timeoutId = setTimeout(() => {
-      this.callbacks.delete(id);
-      this.triggerCallback?.(id);
-    }, delay);
-    this.callbacks.set(id, () => clearTimeout(timeoutId));
-    return timeoutId;
-  }
-  cancel(id) {
-    const callback = this.callbacks.get(id);
-    if (callback) {
-      callback();
-      this.callbacks.delete(id);
-    }
-  }
-  /**
-   * Get the number of active alarms (for debugging/monitoring)
-   */
-  size() {
-    return this.callbacks.size;
-  }
-  /**
-   * Clear all alarms (for shutdown)
-   */
-  clear() {
-    for (const callback of this.callbacks.values()) {
-      callback();
-    }
-    this.callbacks.clear();
-  }
-}
+};
+_AlarmAdapter.ALARM_PREFIX = "chroma_job_";
+let AlarmAdapter = _AlarmAdapter;
 
 class TimeoutAdapter {
   constructor() {
     this.callbacks = /* @__PURE__ */ new Map();
-  }
-  onTrigger(callback) {
-    this.triggerCallback = callback;
-  }
-  schedule(id, when) {
-    this.cancel(id);
-    const delay = Math.max(0, when - Date.now());
-    const timeoutId = setTimeout(() => {
-      this.callbacks.delete(id);
-      this.triggerCallback?.(id);
-    }, delay);
-    this.callbacks.set(id, () => clearTimeout(timeoutId));
-    return timeoutId;
-  }
-  cancel(id) {
-    const callback = this.callbacks.get(id);
-    if (callback) {
-      callback();
-      this.callbacks.delete(id);
-    }
-  }
-  /**
-   * Get the number of active timers (for debugging/monitoring)
-   */
-  size() {
-    return this.callbacks.size;
-  }
-  /**
-   * Clear all timers (for shutdown)
-   */
-  clear() {
-    for (const callback of this.callbacks.values()) {
-      callback();
-    }
-    this.callbacks.clear();
+    this.onTrigger = (callback) => {
+      this.triggerCallback = callback;
+    };
+    this.schedule = (id, when) => {
+      this.cancel(id);
+      const delay = Math.max(0, when - Date.now());
+      const timeoutId = setTimeout(() => {
+        this.callbacks.delete(id);
+        this.triggerCallback?.(id);
+      }, delay);
+      this.callbacks.set(id, () => clearTimeout(timeoutId));
+      return timeoutId;
+    };
+    this.cancel = (id) => {
+      const callback = this.callbacks.get(id);
+      if (callback) {
+        callback();
+        this.callbacks.delete(id);
+      }
+    };
+    /**
+     * Get the number of active timers (for debugging/monitoring)
+     */
+    this.size = () => {
+      return this.callbacks.size;
+    };
+    /**
+     * Clear all timers (for shutdown)
+     */
+    this.clear = () => {
+      for (const callback of this.callbacks.values()) {
+        callback();
+      }
+      this.callbacks.clear();
+    };
   }
 }
 
@@ -1347,13 +1451,14 @@ class Scheduler {
     this.alarm.cancel(id);
     this.timeout.cancel(id);
     this.registry.clearTimers(id);
-    const adapter = when - now < 6e4 ? this.timeout : this.alarm;
+    const delayMs = when - now;
+    const adapter = delayMs < 3e4 ? this.timeout : this.alarm;
     const timerId = adapter.schedule(id, when);
-    if (adapter === this.timeout) {
+    if (adapter === this.timeout && timerId) {
       this.registry.setTimeoutId(id, timerId);
     }
-    this.logger.debug(
-      `Job ${id} scheduled for ${new Date(when).toISOString()} (in ${Math.round((when - now) / 1e3)}s)`
+    this.logger.info(
+      `[Scheduler] Job "${id}" scheduled for ${new Date(when).toISOString()} (in ${Math.round(delayMs / 1e3)}s) \u2192 ${adapter === this.alarm ? "\u23F0 AlarmAdapter" : "\u23F1\uFE0F TimeoutAdapter"}`
     );
   }
   pause(id) {
@@ -1965,4 +2070,4 @@ class BootstrapBuilder {
 }
 
 export { JobState as J, create as a, bootstrap as b, container as c };
-//# sourceMappingURL=boot-DKPBDDrp.js.map
+//# sourceMappingURL=boot-PbJQqgzX.js.map