@surelle-ha/dead-fuse 1.0.4

package/dist/index.d.mts

@@ -0,0 +1,56 @@
+type ProjectState = "ACTIVE" | "WARNING" | "READONLY" | "LIMITED" | "LOCKED" | "EXPIRED" | "SLEEP" | "SELF_DESTRUCT";
+interface DeadFuseConfig {
+    /** Unique project identifier (project_key from dashboard) */
+    projectId: string;
+    /**
+     * URL of the DeadFuse dashboard server.
+     * e.g. "https://your-dashboard.vercel.app"
+     * The SDK fetches configuration from `<master>/api/config` automatically.
+     * Optional: provide this OR both (supabaseUrl + supabaseAnonKey).
+     */
+    master?: string;
+    /**
+     * Public project token (public_token from dashboard).
+     * Used to authenticate the initial state fetch via PostgREST.
+     */
+    token: string;
+    /**
+     * Override the Supabase project URL.
+     * Optional — if omitted the SDK fetches this from `<master>/api/config`.
+     * Useful if you self-host Supabase or want zero extra round-trips.
+     */
+    supabaseUrl?: string;
+    /**
+     * Override the Supabase anon/public key.
+     * Optional — pair with supabaseUrl to bypass the /api/config fetch entirely.
+     */
+    supabaseAnonKey?: string;
+    /** State to apply immediately when the Realtime channel cannot connect */
+    fallbackMode?: ProjectState;
+    /** Grace period in days (informational — enforced by dashboard) */
+    gracePeriod?: number;
+    onActive?: () => void;
+    onWarning?: (message: string) => void;
+    onReadonly?: () => void;
+    onLimited?: () => void;
+    onLocked?: (message: string) => void;
+    onExpired?: () => void;
+    onSleep?: () => void;
+    onSelfDestruct?: () => void;
+    onDisconnect?: () => void;
+    onReconnect?: () => void;
+}
+interface StateMessage {
+    state: ProjectState;
+    message?: string;
+}
+interface DeadFuseInstance {
+    activate: (config: DeadFuseConfig) => void;
+    deactivate: () => void;
+    getState: () => ProjectState | null;
+    getConfig: () => DeadFuseConfig | null;
+}
+
+declare const DeadFuse: DeadFuseInstance;
+
+export { DeadFuse, type DeadFuseConfig, type DeadFuseInstance, type ProjectState, type StateMessage, DeadFuse as default };

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+type ProjectState = "ACTIVE" | "WARNING" | "READONLY" | "LIMITED" | "LOCKED" | "EXPIRED" | "SLEEP" | "SELF_DESTRUCT";
+interface DeadFuseConfig {
+    /** Unique project identifier (project_key from dashboard) */
+    projectId: string;
+    /**
+     * URL of the DeadFuse dashboard server.
+     * e.g. "https://your-dashboard.vercel.app"
+     * The SDK fetches configuration from `<master>/api/config` automatically.
+     * Optional: provide this OR both (supabaseUrl + supabaseAnonKey).
+     */
+    master?: string;
+    /**
+     * Public project token (public_token from dashboard).
+     * Used to authenticate the initial state fetch via PostgREST.
+     */
+    token: string;
+    /**
+     * Override the Supabase project URL.
+     * Optional — if omitted the SDK fetches this from `<master>/api/config`.
+     * Useful if you self-host Supabase or want zero extra round-trips.
+     */
+    supabaseUrl?: string;
+    /**
+     * Override the Supabase anon/public key.
+     * Optional — pair with supabaseUrl to bypass the /api/config fetch entirely.
+     */
+    supabaseAnonKey?: string;
+    /** State to apply immediately when the Realtime channel cannot connect */
+    fallbackMode?: ProjectState;
+    /** Grace period in days (informational — enforced by dashboard) */
+    gracePeriod?: number;
+    onActive?: () => void;
+    onWarning?: (message: string) => void;
+    onReadonly?: () => void;
+    onLimited?: () => void;
+    onLocked?: (message: string) => void;
+    onExpired?: () => void;
+    onSleep?: () => void;
+    onSelfDestruct?: () => void;
+    onDisconnect?: () => void;
+    onReconnect?: () => void;
+}
+interface StateMessage {
+    state: ProjectState;
+    message?: string;
+}
+interface DeadFuseInstance {
+    activate: (config: DeadFuseConfig) => void;
+    deactivate: () => void;
+    getState: () => ProjectState | null;
+    getConfig: () => DeadFuseConfig | null;
+}
+
+declare const DeadFuse: DeadFuseInstance;
+
+export { DeadFuse, type DeadFuseConfig, type DeadFuseInstance, type ProjectState, type StateMessage, DeadFuse as default };

package/dist/index.js

@@ -0,0 +1,406 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DeadFuse: () => DeadFuse_default,
+  default: () => DeadFuse_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/connection.ts
+var import_supabase_js = require("@supabase/supabase-js");
+
+// src/stateManager.ts
+var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var currentState = null;
+var interceptorsInstalled = false;
+var originalFetch = null;
+var originalXHROpen = null;
+function getCurrentState() {
+  return currentState;
+}
+function setCurrentState(state) {
+  currentState = state;
+  applyStateEffects(state);
+}
+function isMutationBlocked() {
+  return currentState === "READONLY" || currentState === "LOCKED" || currentState === "EXPIRED" || currentState === "SLEEP" || currentState === "SELF_DESTRUCT";
+}
+function applyStateEffects(state) {
+  if (state === "READONLY" || state === "LOCKED" || state === "EXPIRED" || state === "SLEEP" || state === "SELF_DESTRUCT") {
+    installInterceptors();
+  } else {
+    if (interceptorsInstalled) {
+      removeInterceptors();
+    }
+  }
+}
+function installInterceptors() {
+  if (interceptorsInstalled) return;
+  interceptorsInstalled = true;
+  if (typeof window !== "undefined" && typeof window.fetch === "function") {
+    originalFetch = window.fetch.bind(window);
+    window.fetch = async function(input, init) {
+      const method = (init?.method || "GET").toUpperCase();
+      if (isMutationBlocked() && MUTATION_METHODS.has(method)) {
+        console.warn(
+          `[DeadFuse] Blocked ${method} request \u2014 project is in ${currentState} mode.`
+        );
+        return new Response(
+          JSON.stringify({
+            error: "Service unavailable",
+            reason: `Project is in ${currentState} mode`,
+            deadfuse: true
+          }),
+          {
+            status: 503,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      }
+      return originalFetch(input, init);
+    };
+  }
+  if (typeof XMLHttpRequest !== "undefined") {
+    originalXHROpen = XMLHttpRequest.prototype.open;
+    XMLHttpRequest.prototype.open = function(method, url, async = true, username, password) {
+      this._deadfuseMethod = method.toUpperCase();
+      originalXHROpen.call(this, method, url, async, username, password);
+    };
+    const originalSend = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.send = function(body) {
+      const method = this._deadfuseMethod || "GET";
+      if (isMutationBlocked() && MUTATION_METHODS.has(method)) {
+        console.warn(
+          `[DeadFuse] Blocked XHR ${method} \u2014 project is in ${currentState} mode.`
+        );
+        Object.defineProperty(this, "status", { get: () => 503 });
+        Object.defineProperty(this, "readyState", { get: () => 4 });
+        Object.defineProperty(this, "responseText", {
+          get: () => JSON.stringify({
+            error: "Service unavailable",
+            reason: `Project is in ${currentState} mode`,
+            deadfuse: true
+          })
+        });
+        this.dispatchEvent(new Event("readystatechange"));
+        this.dispatchEvent(new Event("load"));
+        return;
+      }
+      originalSend.call(this, body);
+    };
+  }
+  if (typeof window !== "undefined" && window.axios) {
+    const axios = window.axios;
+    if (axios.interceptors) {
+      axios.interceptors.request.use((config) => {
+        const method = (config.method || "get").toUpperCase();
+        if (isMutationBlocked() && MUTATION_METHODS.has(method)) {
+          console.warn(
+            `[DeadFuse] Blocked axios ${method} \u2014 project is in ${currentState} mode.`
+          );
+          return Promise.reject({
+            response: {
+              status: 503,
+              data: {
+                error: "Service unavailable",
+                reason: `Project is in ${currentState} mode`,
+                deadfuse: true
+              }
+            }
+          });
+        }
+        return config;
+      });
+    }
+  }
+}
+function removeInterceptors() {
+  if (!interceptorsInstalled) return;
+  interceptorsInstalled = false;
+  if (originalFetch && typeof window !== "undefined") {
+    window.fetch = originalFetch;
+    originalFetch = null;
+  }
+  if (originalXHROpen) {
+    XMLHttpRequest.prototype.open = originalXHROpen;
+    originalXHROpen = null;
+  }
+}
+function cleanupState() {
+  currentState = null;
+  removeInterceptors();
+}
+
+// src/events.ts
+function dispatchStateEvent(state, message, config) {
+  switch (state) {
+    case "ACTIVE":
+      config.onActive?.();
+      break;
+    case "WARNING":
+      config.onWarning?.(message);
+      break;
+    case "READONLY":
+      config.onReadonly?.();
+      break;
+    case "LIMITED":
+      config.onLimited?.();
+      break;
+    case "LOCKED":
+      config.onLocked?.(message);
+      break;
+    case "EXPIRED":
+      config.onExpired?.();
+      break;
+    case "SLEEP":
+      config.onSleep?.();
+      break;
+    case "SELF_DESTRUCT":
+      config.onSelfDestruct?.();
+      break;
+  }
+}
+
+// src/connection.ts
+var MAX_RECONNECT_ATTEMPTS = 10;
+var BASE_RECONNECT_DELAY = 1e3;
+var DeadFuseConnection = class {
+  constructor(config) {
+    this.supabase = null;
+    this.channel = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.destroyed = false;
+    this.config = config;
+  }
+  connect() {
+    if (this.destroyed) return;
+    this._init();
+  }
+  // ── Bootstrap ──────────────────────────────────────────────────────────────
+  /**
+   * Resolve credentials then kick off the subscription + initial state fetch.
+   * If explicit supabaseUrl/Key are provided they are used immediately (no
+   * network round-trip). Otherwise we fetch them from the dashboard.
+   */
+  async _init() {
+    if (this.destroyed) return;
+    let supabaseUrl = this.config.supabaseUrl;
+    let supabaseAnonKey = this.config.supabaseAnonKey;
+    if (!supabaseUrl || !supabaseAnonKey) {
+      const masterUrl = this.config.master ?? (typeof window !== "undefined" ? window.location.origin : void 0);
+      if (!masterUrl) {
+        console.error(
+          "[DeadFuse] Provide either `master` (dashboard URL) or both `supabaseUrl` + `supabaseAnonKey`."
+        );
+        this._applyFallback();
+        return;
+      }
+      try {
+        const res = await fetch(`${masterUrl.replace(/\/$/, "")}/api/config`);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const json = await res.json();
+        supabaseUrl = json.supabaseUrl;
+        supabaseAnonKey = json.supabaseAnonKey;
+      } catch (err) {
+        console.warn("[DeadFuse] Could not fetch config from dashboard:", err);
+        this._applyFallback();
+        this._scheduleReconnect();
+        return;
+      }
+    }
+    if (this.destroyed) return;
+    this.supabase = (0, import_supabase_js.createClient)(supabaseUrl, supabaseAnonKey, {
+      realtime: { params: { eventsPerSecond: 2 } }
+    });
+    this._subscribe();
+    this._fetchInitialState();
+  }
+  // ── Realtime subscription ──────────────────────────────────────────────────
+  _subscribe() {
+    if (!this.supabase) return;
+    const channelName = `project:${this.config.projectId}`;
+    this.channel = this.supabase.channel(channelName, { config: { broadcast: { self: false } } }).on("broadcast", { event: "state" }, (payload) => {
+      const data = payload.payload;
+      if (data?.state) {
+        setCurrentState(data.state);
+        dispatchStateEvent(data.state, data.message ?? "", this.config);
+      }
+    }).subscribe((status) => {
+      if (status === "SUBSCRIBED") {
+        console.info(`[DeadFuse] Realtime channel connected: ${channelName}`);
+        if (this.reconnectAttempts > 0) this.config.onReconnect?.();
+        this.reconnectAttempts = 0;
+        this.channel?.track({ projectId: this.config.projectId, ts: Date.now() });
+      }
+      if (status === "CHANNEL_ERROR" || status === "TIMED_OUT") {
+        console.warn(`[DeadFuse] Realtime channel error: ${status}`);
+        this.config.onDisconnect?.();
+        this._applyFallback();
+        this._scheduleReconnect();
+      }
+      if (status === "CLOSED" && !this.destroyed) {
+        this.config.onDisconnect?.();
+        this._applyFallback();
+        this._scheduleReconnect();
+      }
+    });
+  }
+  // ── Initial state fetch ────────────────────────────────────────────────────
+  async _fetchInitialState() {
+    if (!this.supabase) return;
+    const tryDashboardFallback = async () => {
+      const masterUrl = this.config.master ?? (typeof window !== "undefined" ? window.location.origin : void 0);
+      if (!masterUrl) return null;
+      try {
+        const res = await fetch(
+          `${masterUrl.replace(/\/$/, "")}/api/projects/${this.config.projectId}/initial-state?token=${encodeURIComponent(
+            this.config.token
+          )}`
+        );
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        return await res.json();
+      } catch (err) {
+        console.warn("[DeadFuse] Dashboard initial-state fallback failed:", err);
+        return null;
+      }
+    };
+    try {
+      const { data, error } = await this.supabase.from("projects").select("state, message").eq("project_key", this.config.projectId).eq("public_token", this.config.token).single();
+      if (error || !data) {
+        console.warn("[DeadFuse] Could not fetch initial state via Supabase:", error?.message);
+        const fallback = await tryDashboardFallback();
+        if (fallback) {
+          setCurrentState(fallback.state);
+          dispatchStateEvent(fallback.state, fallback.message ?? "", this.config);
+          return;
+        }
+        this._applyFallback();
+        return;
+      }
+      setCurrentState(data.state);
+      dispatchStateEvent(data.state, data.message ?? "", this.config);
+    } catch (err) {
+      console.warn("[DeadFuse] Initial state fetch failed:", err);
+      const fallback = await tryDashboardFallback();
+      if (fallback) {
+        setCurrentState(fallback.state);
+        dispatchStateEvent(fallback.state, fallback.message ?? "", this.config);
+        return;
+      }
+      this._applyFallback();
+    }
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────────
+  _applyFallback() {
+    const fallback = this.config.fallbackMode;
+    if (fallback) {
+      setCurrentState(fallback);
+      dispatchStateEvent(fallback, "", this.config);
+    }
+  }
+  _scheduleReconnect() {
+    if (this.destroyed || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        console.warn("[DeadFuse] Max reconnect attempts reached.");
+      }
+      return;
+    }
+    const delay = Math.min(BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts), 3e4);
+    this.reconnectAttempts++;
+    console.info(`[DeadFuse] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})\u2026`);
+    this.reconnectTimer = setTimeout(() => {
+      if (this.destroyed) return;
+      if (this.channel && this.supabase) {
+        this.supabase.removeChannel(this.channel);
+        this.channel = null;
+      }
+      this._init();
+    }, delay);
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.channel && this.supabase) {
+      this.supabase.removeChannel(this.channel);
+      this.channel = null;
+    }
+  }
+};
+
+// src/DeadFuse.ts
+var activeConnection = null;
+var activeConfig = null;
+var DeadFuse = {
+  activate(config) {
+    if (activeConnection) {
+      console.warn(
+        "[DeadFuse] Already activated. Call deactivate() first to reinitialize."
+      );
+      return;
+    }
+    if (!config.projectId) throw new Error("[DeadFuse] projectId is required.");
+    if (!config.token) throw new Error("[DeadFuse] token is required.");
+    const hasExplicitSupabase = Boolean(config.supabaseUrl && config.supabaseAnonKey);
+    const resolvedConfig = { ...config };
+    if (!resolvedConfig.master && !hasExplicitSupabase) {
+      if (typeof window !== "undefined") {
+        resolvedConfig.master = window.location.origin;
+      }
+    }
+    if (!resolvedConfig.master && !hasExplicitSupabase) {
+      throw new Error(
+        "[DeadFuse] Provide either a dashboard URL via `master` or both `supabaseUrl` + `supabaseAnonKey`."
+      );
+    }
+    activeConfig = resolvedConfig;
+    activeConnection = new DeadFuseConnection(resolvedConfig);
+    activeConnection.connect();
+    const connectMsg = resolvedConfig.master ? `dashboard at ${resolvedConfig.master}` : "explicit Supabase credentials";
+    console.info(
+      `[DeadFuse] Activated for project "${resolvedConfig.projectId}". Connecting via ${connectMsg}...`
+    );
+  },
+  deactivate() {
+    if (activeConnection) {
+      activeConnection.destroy();
+      activeConnection = null;
+    }
+    activeConfig = null;
+    cleanupState();
+    console.info("[DeadFuse] Deactivated.");
+  },
+  getState() {
+    return getCurrentState();
+  },
+  getConfig() {
+    return activeConfig;
+  }
+};
+var DeadFuse_default = DeadFuse;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeadFuse
+});

package/dist/index.mjs

@@ -0,0 +1,379 @@
+// src/connection.ts
+import { createClient } from "@supabase/supabase-js";
+
+// src/stateManager.ts
+var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var currentState = null;
+var interceptorsInstalled = false;
+var originalFetch = null;
+var originalXHROpen = null;
+function getCurrentState() {
+  return currentState;
+}
+function setCurrentState(state) {
+  currentState = state;
+  applyStateEffects(state);
+}
+function isMutationBlocked() {
+  return currentState === "READONLY" || currentState === "LOCKED" || currentState === "EXPIRED" || currentState === "SLEEP" || currentState === "SELF_DESTRUCT";
+}
+function applyStateEffects(state) {
+  if (state === "READONLY" || state === "LOCKED" || state === "EXPIRED" || state === "SLEEP" || state === "SELF_DESTRUCT") {
+    installInterceptors();
+  } else {
+    if (interceptorsInstalled) {
+      removeInterceptors();
+    }
+  }
+}
+function installInterceptors() {
+  if (interceptorsInstalled) return;
+  interceptorsInstalled = true;
+  if (typeof window !== "undefined" && typeof window.fetch === "function") {
+    originalFetch = window.fetch.bind(window);
+    window.fetch = async function(input, init) {
+      const method = (init?.method || "GET").toUpperCase();
+      if (isMutationBlocked() && MUTATION_METHODS.has(method)) {
+        console.warn(
+          `[DeadFuse] Blocked ${method} request \u2014 project is in ${currentState} mode.`
+        );
+        return new Response(
+          JSON.stringify({
+            error: "Service unavailable",
+            reason: `Project is in ${currentState} mode`,
+            deadfuse: true
+          }),
+          {
+            status: 503,
+            headers: { "Content-Type": "application/json" }
+          }
+        );
+      }
+      return originalFetch(input, init);
+    };
+  }
+  if (typeof XMLHttpRequest !== "undefined") {
+    originalXHROpen = XMLHttpRequest.prototype.open;
+    XMLHttpRequest.prototype.open = function(method, url, async = true, username, password) {
+      this._deadfuseMethod = method.toUpperCase();
+      originalXHROpen.call(this, method, url, async, username, password);
+    };
+    const originalSend = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.send = function(body) {
+      const method = this._deadfuseMethod || "GET";
+      if (isMutationBlocked() && MUTATION_METHODS.has(method)) {
+        console.warn(
+          `[DeadFuse] Blocked XHR ${method} \u2014 project is in ${currentState} mode.`
+        );
+        Object.defineProperty(this, "status", { get: () => 503 });
+        Object.defineProperty(this, "readyState", { get: () => 4 });
+        Object.defineProperty(this, "responseText", {
+          get: () => JSON.stringify({
+            error: "Service unavailable",
+            reason: `Project is in ${currentState} mode`,
+            deadfuse: true
+          })
+        });
+        this.dispatchEvent(new Event("readystatechange"));
+        this.dispatchEvent(new Event("load"));
+        return;
+      }
+      originalSend.call(this, body);
+    };
+  }
+  if (typeof window !== "undefined" && window.axios) {
+    const axios = window.axios;
+    if (axios.interceptors) {
+      axios.interceptors.request.use((config) => {
+        const method = (config.method || "get").toUpperCase();
+        if (isMutationBlocked() && MUTATION_METHODS.has(method)) {
+          console.warn(
+            `[DeadFuse] Blocked axios ${method} \u2014 project is in ${currentState} mode.`
+          );
+          return Promise.reject({
+            response: {
+              status: 503,
+              data: {
+                error: "Service unavailable",
+                reason: `Project is in ${currentState} mode`,
+                deadfuse: true
+              }
+            }
+          });
+        }
+        return config;
+      });
+    }
+  }
+}
+function removeInterceptors() {
+  if (!interceptorsInstalled) return;
+  interceptorsInstalled = false;
+  if (originalFetch && typeof window !== "undefined") {
+    window.fetch = originalFetch;
+    originalFetch = null;
+  }
+  if (originalXHROpen) {
+    XMLHttpRequest.prototype.open = originalXHROpen;
+    originalXHROpen = null;
+  }
+}
+function cleanupState() {
+  currentState = null;
+  removeInterceptors();
+}
+
+// src/events.ts
+function dispatchStateEvent(state, message, config) {
+  switch (state) {
+    case "ACTIVE":
+      config.onActive?.();
+      break;
+    case "WARNING":
+      config.onWarning?.(message);
+      break;
+    case "READONLY":
+      config.onReadonly?.();
+      break;
+    case "LIMITED":
+      config.onLimited?.();
+      break;
+    case "LOCKED":
+      config.onLocked?.(message);
+      break;
+    case "EXPIRED":
+      config.onExpired?.();
+      break;
+    case "SLEEP":
+      config.onSleep?.();
+      break;
+    case "SELF_DESTRUCT":
+      config.onSelfDestruct?.();
+      break;
+  }
+}
+
+// src/connection.ts
+var MAX_RECONNECT_ATTEMPTS = 10;
+var BASE_RECONNECT_DELAY = 1e3;
+var DeadFuseConnection = class {
+  constructor(config) {
+    this.supabase = null;
+    this.channel = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.destroyed = false;
+    this.config = config;
+  }
+  connect() {
+    if (this.destroyed) return;
+    this._init();
+  }
+  // ── Bootstrap ──────────────────────────────────────────────────────────────
+  /**
+   * Resolve credentials then kick off the subscription + initial state fetch.
+   * If explicit supabaseUrl/Key are provided they are used immediately (no
+   * network round-trip). Otherwise we fetch them from the dashboard.
+   */
+  async _init() {
+    if (this.destroyed) return;
+    let supabaseUrl = this.config.supabaseUrl;
+    let supabaseAnonKey = this.config.supabaseAnonKey;
+    if (!supabaseUrl || !supabaseAnonKey) {
+      const masterUrl = this.config.master ?? (typeof window !== "undefined" ? window.location.origin : void 0);
+      if (!masterUrl) {
+        console.error(
+          "[DeadFuse] Provide either `master` (dashboard URL) or both `supabaseUrl` + `supabaseAnonKey`."
+        );
+        this._applyFallback();
+        return;
+      }
+      try {
+        const res = await fetch(`${masterUrl.replace(/\/$/, "")}/api/config`);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const json = await res.json();
+        supabaseUrl = json.supabaseUrl;
+        supabaseAnonKey = json.supabaseAnonKey;
+      } catch (err) {
+        console.warn("[DeadFuse] Could not fetch config from dashboard:", err);
+        this._applyFallback();
+        this._scheduleReconnect();
+        return;
+      }
+    }
+    if (this.destroyed) return;
+    this.supabase = createClient(supabaseUrl, supabaseAnonKey, {
+      realtime: { params: { eventsPerSecond: 2 } }
+    });
+    this._subscribe();
+    this._fetchInitialState();
+  }
+  // ── Realtime subscription ──────────────────────────────────────────────────
+  _subscribe() {
+    if (!this.supabase) return;
+    const channelName = `project:${this.config.projectId}`;
+    this.channel = this.supabase.channel(channelName, { config: { broadcast: { self: false } } }).on("broadcast", { event: "state" }, (payload) => {
+      const data = payload.payload;
+      if (data?.state) {
+        setCurrentState(data.state);
+        dispatchStateEvent(data.state, data.message ?? "", this.config);
+      }
+    }).subscribe((status) => {
+      if (status === "SUBSCRIBED") {
+        console.info(`[DeadFuse] Realtime channel connected: ${channelName}`);
+        if (this.reconnectAttempts > 0) this.config.onReconnect?.();
+        this.reconnectAttempts = 0;
+        this.channel?.track({ projectId: this.config.projectId, ts: Date.now() });
+      }
+      if (status === "CHANNEL_ERROR" || status === "TIMED_OUT") {
+        console.warn(`[DeadFuse] Realtime channel error: ${status}`);
+        this.config.onDisconnect?.();
+        this._applyFallback();
+        this._scheduleReconnect();
+      }
+      if (status === "CLOSED" && !this.destroyed) {
+        this.config.onDisconnect?.();
+        this._applyFallback();
+        this._scheduleReconnect();
+      }
+    });
+  }
+  // ── Initial state fetch ────────────────────────────────────────────────────
+  async _fetchInitialState() {
+    if (!this.supabase) return;
+    const tryDashboardFallback = async () => {
+      const masterUrl = this.config.master ?? (typeof window !== "undefined" ? window.location.origin : void 0);
+      if (!masterUrl) return null;
+      try {
+        const res = await fetch(
+          `${masterUrl.replace(/\/$/, "")}/api/projects/${this.config.projectId}/initial-state?token=${encodeURIComponent(
+            this.config.token
+          )}`
+        );
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        return await res.json();
+      } catch (err) {
+        console.warn("[DeadFuse] Dashboard initial-state fallback failed:", err);
+        return null;
+      }
+    };
+    try {
+      const { data, error } = await this.supabase.from("projects").select("state, message").eq("project_key", this.config.projectId).eq("public_token", this.config.token).single();
+      if (error || !data) {
+        console.warn("[DeadFuse] Could not fetch initial state via Supabase:", error?.message);
+        const fallback = await tryDashboardFallback();
+        if (fallback) {
+          setCurrentState(fallback.state);
+          dispatchStateEvent(fallback.state, fallback.message ?? "", this.config);
+          return;
+        }
+        this._applyFallback();
+        return;
+      }
+      setCurrentState(data.state);
+      dispatchStateEvent(data.state, data.message ?? "", this.config);
+    } catch (err) {
+      console.warn("[DeadFuse] Initial state fetch failed:", err);
+      const fallback = await tryDashboardFallback();
+      if (fallback) {
+        setCurrentState(fallback.state);
+        dispatchStateEvent(fallback.state, fallback.message ?? "", this.config);
+        return;
+      }
+      this._applyFallback();
+    }
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────────
+  _applyFallback() {
+    const fallback = this.config.fallbackMode;
+    if (fallback) {
+      setCurrentState(fallback);
+      dispatchStateEvent(fallback, "", this.config);
+    }
+  }
+  _scheduleReconnect() {
+    if (this.destroyed || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        console.warn("[DeadFuse] Max reconnect attempts reached.");
+      }
+      return;
+    }
+    const delay = Math.min(BASE_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts), 3e4);
+    this.reconnectAttempts++;
+    console.info(`[DeadFuse] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})\u2026`);
+    this.reconnectTimer = setTimeout(() => {
+      if (this.destroyed) return;
+      if (this.channel && this.supabase) {
+        this.supabase.removeChannel(this.channel);
+        this.channel = null;
+      }
+      this._init();
+    }, delay);
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.channel && this.supabase) {
+      this.supabase.removeChannel(this.channel);
+      this.channel = null;
+    }
+  }
+};
+
+// src/DeadFuse.ts
+var activeConnection = null;
+var activeConfig = null;
+var DeadFuse = {
+  activate(config) {
+    if (activeConnection) {
+      console.warn(
+        "[DeadFuse] Already activated. Call deactivate() first to reinitialize."
+      );
+      return;
+    }
+    if (!config.projectId) throw new Error("[DeadFuse] projectId is required.");
+    if (!config.token) throw new Error("[DeadFuse] token is required.");
+    const hasExplicitSupabase = Boolean(config.supabaseUrl && config.supabaseAnonKey);
+    const resolvedConfig = { ...config };
+    if (!resolvedConfig.master && !hasExplicitSupabase) {
+      if (typeof window !== "undefined") {
+        resolvedConfig.master = window.location.origin;
+      }
+    }
+    if (!resolvedConfig.master && !hasExplicitSupabase) {
+      throw new Error(
+        "[DeadFuse] Provide either a dashboard URL via `master` or both `supabaseUrl` + `supabaseAnonKey`."
+      );
+    }
+    activeConfig = resolvedConfig;
+    activeConnection = new DeadFuseConnection(resolvedConfig);
+    activeConnection.connect();
+    const connectMsg = resolvedConfig.master ? `dashboard at ${resolvedConfig.master}` : "explicit Supabase credentials";
+    console.info(
+      `[DeadFuse] Activated for project "${resolvedConfig.projectId}". Connecting via ${connectMsg}...`
+    );
+  },
+  deactivate() {
+    if (activeConnection) {
+      activeConnection.destroy();
+      activeConnection = null;
+    }
+    activeConfig = null;
+    cleanupState();
+    console.info("[DeadFuse] Deactivated.");
+  },
+  getState() {
+    return getCurrentState();
+  },
+  getConfig() {
+    return activeConfig;
+  }
+};
+var DeadFuse_default = DeadFuse;
+export {
+  DeadFuse_default as DeadFuse,
+  DeadFuse_default as default
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@surelle-ha/dead-fuse",
+  "version": "1.0.4",
+  "description": "Lightweight license enforcement and remote control layer for deployed web applications",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5"
+  },
+  "keywords": [
+    "license",
+    "enforcement",
+    "remote-control",
+    "websocket",
+    "freelance"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@supabase/supabase-js": "^2.102.1"
+  }
+}