dolphin-client 1.0.0

package/dist/dolphin-client.js

@@ -0,0 +1,2042 @@
+var DolphinModule = (() => {
+  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, {
+    DolphinClient: () => DolphinClient
+  });
+
+  // src/api.ts
+  var APIHandler = class {
+    client;
+    /** @param {DolphinClient} client */
+    constructor(client) {
+      this.client = client;
+      return this._createProxy([]);
+    }
+    /** @private */
+    _createProxy(pathParts) {
+      const joined = pathParts.join("/");
+      const target = (options) => this.request("GET", joined, null, options);
+      target.get = (pathOrOptions, options) => typeof pathOrOptions === "string" ? this.request("GET", pathOrOptions, null, options) : this.request("GET", joined, null, pathOrOptions);
+      target.post = (pathOrBody, bodyOrOptions, options) => typeof pathOrBody === "string" ? this.request("POST", pathOrBody, bodyOrOptions, options) : this.request("POST", joined, pathOrBody, bodyOrOptions);
+      target.put = (pathOrBody, bodyOrOptions, options) => typeof pathOrBody === "string" ? this.request("PUT", pathOrBody, bodyOrOptions, options) : this.request("PUT", joined, pathOrBody, bodyOrOptions);
+      target.patch = (pathOrBody, bodyOrOptions, options) => typeof pathOrBody === "string" ? this.request("PATCH", pathOrBody, bodyOrOptions, options) : this.request("PATCH", joined, pathOrBody, bodyOrOptions);
+      target.del = (pathOrOptions, options) => typeof pathOrOptions === "string" ? this.request("DELETE", pathOrOptions, null, options) : this.request("DELETE", joined, null, pathOrOptions);
+      target.request = (method, subPath, body, options) => {
+        const finalPath = subPath ? `${joined}/${subPath.startsWith("/") ? subPath.slice(1) : subPath}` : joined;
+        return this.request(method, finalPath, body, options);
+      };
+      target.requestDirect = (method, path, body, options) => {
+        return this.requestDirect(method, path, body, options);
+      };
+      const methods = ["get", "post", "put", "patch", "del", "request", "requestDirect"];
+      return new Proxy(target, {
+        get: (t, prop) => {
+          if (typeof prop === "string" && !methods.includes(prop)) {
+            return this._createProxy([...pathParts, prop]);
+          }
+          return t[prop];
+        }
+      });
+    }
+    /**
+     * Intercept request for offline-first caching and queuing.
+     */
+    async request(method, path, body = null, options = {}) {
+      if (this.client.offline) {
+        const isOnline = this.client.offline.isOnline;
+        const cacheKey = `${method.toUpperCase()}:${path}`;
+        if (method.toUpperCase() === "GET") {
+          if (isOnline) {
+            try {
+              const result = await this.requestDirect(method, path, body, options);
+              await this.client.offline.setCache(cacheKey, result);
+              return result;
+            } catch (err) {
+              const cached = await this.client.offline.getCache(cacheKey);
+              if (cached !== void 0 && cached !== null) {
+                return cached;
+              }
+              throw err;
+            }
+          } else {
+            const cached = await this.client.offline.getCache(cacheKey);
+            if (cached !== void 0 && cached !== null) {
+              return cached;
+            }
+            throw { status: 503, data: { error: "Offline, no cache available" } };
+          }
+        } else {
+          if (isOnline) {
+            return this.requestDirect(method, path, body, options);
+          } else {
+            await this.client.offline.queueMutation(method, path, body);
+            this.client._dispatch("offline:queued", { method, path, body });
+            return { success: true, offline: true, message: "Mutation queued offline" };
+          }
+        }
+      }
+      return this.requestDirect(method, path, body, options);
+    }
+    /**
+     * Make an HTTP request with timeout + auto token refresh.
+     * @param {string}      method
+     * @param {string}      path
+     * @param {any}         [body]
+     * @param {RequestInit} [options]
+     * @param {boolean}     [_isRetry=false]   — internal: prevent infinite refresh loop
+     * @returns {Promise<any>}
+     */
+    async requestDirect(method, path, body = null, options = {}) {
+      const _isRetry = options._isRetry === true;
+      const url = `${this.client.httpUrl}${path.startsWith("/") ? path : "/" + path}`;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        this.client.options.timeout
+      );
+      const headers = {
+        "Content-Type": "application/json",
+        ...options.headers || {}
+      };
+      if (this.client.accessToken) {
+        headers["Authorization"] = `Bearer ${this.client.accessToken}`;
+      }
+      const fetchOptions = { ...options };
+      delete fetchOptions._isRetry;
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          signal: controller.signal,
+          ...body ? { body: JSON.stringify(body) } : {},
+          ...fetchOptions
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 401 && !_isRetry && this.client.options.autoRefreshToken) {
+          const refreshed = await this.client.auth._silentRefresh();
+          if (refreshed) {
+            return this.request(method, path, body, { ...options, _isRetry: true });
+          }
+        }
+        const contentType = response.headers.get("content-type") || "";
+        const data = contentType.includes("application/json") ? await response.json() : await response.text();
+        if (!response.ok) throw { status: response.status, data };
+        if (data && typeof data === "object") {
+          if (data.accessToken) {
+            this.client.setToken(data.accessToken);
+            if (data.user) this.client.auth.user = data.user;
+          }
+        }
+        if (this.client.options.autoBroadcast && ["POST", "PUT", "PATCH", "DELETE"].includes(method.toUpperCase())) {
+          const cleanPath = path.startsWith("/") ? path.substring(1) : path;
+          this.client.publish(cleanPath, { method: method.toUpperCase(), payload: body, result: data });
+        }
+        return data;
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err.name === "AbortError") {
+          throw { status: 408, data: { error: "Request timed out" } };
+        }
+        throw err;
+      }
+    }
+  };
+
+  // src/auth.ts
+  var AuthHandler = class {
+    client;
+    user;
+    _refreshing;
+    /** @param {DolphinClient} client */
+    constructor(client) {
+      this.client = client;
+      this.user = null;
+      this._refreshing = false;
+    }
+    /**
+     * Login with email + password.
+     * @param {string} email
+     * @param {string} password
+     */
+    async login(email, password) {
+      const res = await this.client.api.post("/api/auth/login", { email, password });
+      if (res.accessToken) {
+        this.client.setToken(res.accessToken);
+        this.user = res.user || null;
+      }
+      return res;
+    }
+    /**
+     * Register a new account.
+     * @param {{ email: string, password: string, [key: string]: any }} data
+     */
+    async register(data) {
+      return this.client.api.post("/api/auth/register", data);
+    }
+    /** Get current user profile. */
+    async me() {
+      const res = await this.client.api.get("/api/auth/me");
+      if (res.success) this.user = res.data;
+      return res;
+    }
+    /** Logout and clear token. */
+    async logout() {
+      try {
+        await this.client.api.post("/api/auth/logout");
+      } catch {
+      }
+      this.client.setToken(null);
+      this.user = null;
+    }
+    /**
+     * Manually refresh the access token using the httpOnly refresh-token cookie.
+     * Called automatically on 401 if autoRefreshToken is enabled.
+     * @returns {Promise<boolean>} — true if refresh succeeded
+     */
+    async refresh() {
+      return this._silentRefresh();
+    }
+    /** @private */
+    async _silentRefresh() {
+      if (this._refreshing) return false;
+      this._refreshing = true;
+      try {
+        const res = await this.client.api.post("/api/auth/refresh", null, { _isRetry: true });
+        if (res.accessToken) {
+          this.client.setToken(res.accessToken);
+          return true;
+        }
+        return false;
+      } catch {
+        this.client.setToken(null);
+        return false;
+      } finally {
+        this._refreshing = false;
+      }
+    }
+    /**
+     * Verify a 2FA TOTP code after login.
+     * @param {string} code     — 6-digit TOTP code
+     * @param {string} [email]  — email (if not already in user)
+     */
+    async verify2FA(code, email) {
+      const payload = {
+        code,
+        email: email || this.user?.email
+      };
+      const res = await this.client.api.post("/api/auth/2fa/verify", payload);
+      if (res.accessToken) {
+        this.client.setToken(res.accessToken);
+        if (res.user) this.user = res.user;
+      }
+      return res;
+    }
+    /**
+     * Enable 2FA — returns QR code URL and secret.
+     */
+    async enable2FA() {
+      return this.client.api.post("/api/auth/2fa/enable");
+    }
+    /**
+     * Disable 2FA.
+     * @param {string} code — current TOTP code to confirm
+     */
+    async disable2FA(code) {
+      return this.client.api.post("/api/auth/2fa/disable", { code });
+    }
+    /**
+     * Request a password reset email.
+     * @param {string} email
+     */
+    async forgotPassword(email) {
+      return this.client.api.post("/api/auth/forgot-password", { email });
+    }
+    /**
+     * Reset password using the token from email.
+     * @param {string} token
+     * @param {string} newPassword
+     */
+    async resetPassword(token, newPassword) {
+      return this.client.api.post("/api/auth/reset-password", { token, newPassword });
+    }
+  };
+
+  // src/store.ts
+  var DolphinStore = class {
+    client;
+    data;
+    listeners;
+    subscribed;
+    /** @param {DolphinClient} client */
+    constructor(client) {
+      this.client = client;
+      this.data = /* @__PURE__ */ new Map();
+      this.listeners = /* @__PURE__ */ new Set();
+      this.subscribed = /* @__PURE__ */ new Set();
+      return new Proxy(this, {
+        get: (target, prop) => {
+          if (prop in target) return target[prop];
+          if (typeof prop === "string") return this._getCollection(prop);
+        }
+      });
+    }
+    /** @private */
+    _getCollection(name) {
+      if (!this.data.has(name)) {
+        const collection = {
+          _rawItems: [],
+          items: [],
+          loading: true,
+          error: null,
+          success: false,
+          _filter: null,
+          _sort: null,
+          where: (fn) => {
+            collection._filter = fn;
+            this._applyTransform(collection);
+            return collection;
+          },
+          orderBy: (key, direction = "asc") => {
+            collection._sort = { key, direction };
+            this._applyTransform(collection);
+            return collection;
+          },
+          reset: () => {
+            collection._filter = null;
+            collection._sort = null;
+            this._applyTransform(collection);
+            return collection;
+          }
+        };
+        this.data.set(name, collection);
+        this._fetchAndSync(name);
+      }
+      return this.data.get(name);
+    }
+    /** @private */
+    async _fetchAndSync(name) {
+      const state = this.data.get(name);
+      try {
+        const res = await this.client.api.get(`/${name.toLowerCase()}`);
+        state._rawItems = Array.isArray(res) ? res : res.data || [];
+        state.loading = false;
+        state.success = true;
+        state.error = null;
+        this._applyTransform(state);
+        if (!this.subscribed.has(name)) {
+          this.client.subscribe(`db:sync/${name.toLowerCase()}`, (update) => {
+            this._handleRemoteUpdate(name, update);
+          });
+          this.subscribed.add(name);
+        }
+      } catch (e) {
+        state.loading = false;
+        state.success = false;
+        state.error = e.data?.error || e.message || "Fetch failed";
+        this._notify();
+      }
+    }
+    /** @private */
+    _applyTransform(state) {
+      let result = [...state._rawItems];
+      if (state._filter) result = result.filter(state._filter);
+      if (state._sort) {
+        const { key, direction } = state._sort;
+        result.sort((a, b) => {
+          if (a[key] === b[key]) return 0;
+          return (a[key] > b[key] ? 1 : -1) * (direction === "asc" ? 1 : -1);
+        });
+      }
+      state.items = result;
+      this._notify();
+    }
+    /** @private */
+    _handleRemoteUpdate(collection, update) {
+      const state = this.data.get(collection);
+      if (!state) return;
+      const { type, data } = update;
+      let items = state._rawItems;
+      if (type === "create") {
+        items = [...items, data];
+      } else if (type === "update") {
+        items = items.map((i) => i.id === data.id || i._id === data._id ? { ...i, ...data } : i);
+      } else if (type === "delete") {
+        items = items.filter((i) => {
+          if (data.id != null && i.id === data.id) return false;
+          if (data._id != null && i._id === data._id) return false;
+          return true;
+        });
+      }
+      state._rawItems = items;
+      this._applyTransform(state);
+    }
+    /** Subscribe for React useSyncExternalStore */
+    subscribe(listener) {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    }
+    /** @param {string} collection */
+    getSnapshot(collection) {
+      return this.data.get(collection) || { items: [], loading: false, error: null, success: false };
+    }
+    /** @private */
+    _notify() {
+      this.listeners.forEach((l) => l());
+    }
+  };
+
+  // src/core.ts
+  var DolphinClient = class {
+    host;
+    httpUrl;
+    deviceId;
+    options;
+    socket;
+    storage;
+    accessToken;
+    api;
+    auth;
+    store;
+    handlers;
+    signalHandlers;
+    fileHandlers;
+    _offlineQueue;
+    reconnectAttempts;
+    _attachedListeners;
+    constructor(url = "", deviceId = "", options = {}) {
+      if (!url && typeof window !== "undefined") url = window.location.host;
+      let protocol = "http:";
+      if (url.startsWith("https://")) protocol = "https:";
+      else if (url.startsWith("http://")) protocol = "http:";
+      else if (typeof window !== "undefined") protocol = window.location.protocol;
+      this.host = (url || "localhost").replace(/\/$/, "").replace(/^https?:\/\//, "");
+      this.httpUrl = `${protocol}//${this.host}`;
+      this.deviceId = deviceId || "web_" + Math.random().toString(36).substr(2, 8);
+      this.options = {
+        timeout: 15e3,
+        chunkSize: 65536,
+        // 64 KB
+        maxReconnect: 5,
+        autoRefreshToken: true,
+        ...options
+      };
+      this.socket = null;
+      this.storage = typeof localStorage !== "undefined" ? localStorage : {
+        getItem: () => null,
+        setItem: () => {
+        },
+        removeItem: () => {
+        }
+      };
+      this.accessToken = this.storage.getItem("dolphin_token");
+      this.api = new APIHandler(this);
+      this.auth = new AuthHandler(this);
+      this.store = new DolphinStore(this);
+      this.handlers = /* @__PURE__ */ new Map();
+      this.signalHandlers = /* @__PURE__ */ new Set();
+      this.fileHandlers = /* @__PURE__ */ new Set();
+      this._offlineQueue = [];
+      this.reconnectAttempts = 0;
+      this._attachedListeners = [];
+      if (typeof window !== "undefined" && typeof this._initDOMBinding === "function") {
+        this._initDOMBinding();
+      }
+      if (typeof this._initOffline === "function") {
+        this._initOffline();
+      }
+      if (typeof this._initA11y === "function") {
+        this._initA11y();
+      }
+      if (typeof this._initI18n === "function") {
+        this._initI18n();
+      }
+      if (typeof this._initDragDrop === "function") {
+        this._initDragDrop();
+      }
+      if (typeof this._initCollab === "function") {
+        this._initCollab();
+      }
+    }
+    /** Save or clear the access token */
+    setToken(token) {
+      this.accessToken = token;
+      token ? this.storage.setItem("dolphin_token", token) : this.storage.removeItem("dolphin_token");
+    }
+    // ── WebSocket ─────────────────────────────────────────────────────────────
+    /** Connect to the Dolphin realtime server */
+    async connect() {
+      return new Promise((resolve, reject) => {
+        const protocol = this.httpUrl.startsWith("https") ? "wss:" : "ws:";
+        const wsUrl = `${protocol}//${this.host}/realtime?deviceId=${this.deviceId}`;
+        console.log(`[Dolphin] Connecting to ${wsUrl}...`);
+        this.socket = new WebSocket(wsUrl);
+        this.socket.onopen = () => {
+          console.log(`[Dolphin] Connected as "${this.deviceId}" \u{1F42C}`);
+          this.reconnectAttempts = 0;
+          this._flushOfflineQueue();
+          resolve();
+        };
+        this.socket.onmessage = (ev) => this._handleMessage(ev.data);
+        this.socket.onclose = () => {
+          console.warn("[Dolphin] Connection closed");
+          this._maybeReconnect();
+        };
+        this.socket.onerror = (err) => {
+          console.error("[Dolphin] WebSocket error:", err);
+          reject(err);
+        };
+      });
+    }
+    /** Disconnect cleanly */
+    disconnect() {
+      if (this.socket) {
+        this.socket.onclose = null;
+        this.socket.close();
+        this.socket = null;
+      }
+      this.cleanupDomListeners();
+    }
+    /** @private */
+    _handleMessage(data) {
+      try {
+        const msg = JSON.parse(data);
+        if (msg.type && msg.from && (msg.to === this.deviceId || msg.to === "all")) {
+          if (msg.msgId && msg.type !== "ACK") this._sendAck(msg.from, msg.msgId);
+          this.signalHandlers.forEach((h) => h(msg));
+        }
+        if (msg.type === "FILE_AVAILABLE") {
+          this.fileHandlers.forEach((h) => h(msg));
+        }
+        if (msg.type === "FILE_CHUNK") {
+          this.saveFileProgress(msg.fileId, msg.chunkIndex);
+          this._dispatch("file:chunk", msg);
+          this._dispatch(`file:chunk/${msg.fileId}`, msg);
+        }
+        if (msg.type === "FILE_UPLOAD_ACK") {
+          this._dispatch(`file:upload:ack/${msg.fileId}`, msg);
+        }
+        if (msg.type === "PULL_RESPONSE") {
+          this._dispatch("pull:response", msg.payload, msg.topic);
+          this._dispatch(`pull:response/${msg.topic}`, msg.payload, msg.topic);
+        }
+        if (msg.topic && msg.payload !== void 0) {
+          this.handlers.forEach((cbs, pattern) => {
+            if (this._matchTopic(pattern, msg.topic)) {
+              cbs.forEach((cb) => cb(msg.payload, msg.topic));
+            }
+          });
+        }
+      } catch {
+        this._dispatch("raw", data);
+      }
+    }
+    /** @private */
+    _dispatch(pattern, payload, topic) {
+      const cbs = this.handlers.get(pattern);
+      if (cbs) cbs.forEach((cb) => cb(payload, topic || pattern));
+    }
+    /** @private */
+    _sendRaw(msg) {
+      const str = typeof msg === "string" ? msg : JSON.stringify(msg);
+      if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+        this.socket.send(str);
+      } else {
+        if (this._offlineQueue.length < 100) this._offlineQueue.push(str);
+      }
+    }
+    /** Flush buffered messages after reconnect @private */
+    _flushOfflineQueue() {
+      while (this._offlineQueue.length > 0) {
+        const msg = this._offlineQueue.shift();
+        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+          this.socket.send(msg);
+        }
+      }
+    }
+    /** @private */
+    _sendAck(to, msgId) {
+      this._sendRaw({ type: "ACK", from: this.deviceId, to, data: { ackId: msgId }, timestamp: Date.now() });
+    }
+    /** MQTT wildcard topic matching @private */
+    _matchTopic(pattern, topic) {
+      if (pattern === topic || pattern === "#") return true;
+      const pp = pattern.split("/");
+      const tp = topic.split("/");
+      if (pp.length !== tp.length && !pattern.includes("#")) return false;
+      for (let i = 0; i < pp.length; i++) {
+        if (pp[i] === "#") return true;
+        if (pp[i] !== "+" && pp[i] !== tp[i]) return false;
+      }
+      return pp.length === tp.length;
+    }
+    /** @private */
+    _maybeReconnect() {
+      if (this.reconnectAttempts < this.options.maxReconnect) {
+        this.reconnectAttempts++;
+        const delay = Math.pow(2, this.reconnectAttempts) * 1e3;
+        console.log(`[Dolphin] Reconnecting in ${delay / 1e3}s (attempt ${this.reconnectAttempts})...`);
+        setTimeout(() => this.connect().catch(() => {
+        }), delay);
+      } else {
+        console.error("[Dolphin] Max reconnect attempts reached.");
+      }
+    }
+    // ── Pub/Sub ───────────────────────────────────────────────────────────────
+    /**
+     * Subscribe to a topic (MQTT wildcards supported: + and #).
+     * @param {string}        topic
+     * @param {TopicCallback} callback
+     */
+    subscribe(topic, callback) {
+      if (!this.handlers.has(topic)) {
+        this.handlers.set(topic, /* @__PURE__ */ new Set());
+        this._sendRaw({ type: "sub", topic });
+      }
+      this.handlers.get(topic).add(callback);
+    }
+    /**
+     * Unsubscribe from a topic.
+     * @param {string}        topic
+     * @param {TopicCallback} callback
+     */
+    unsubscribe(topic, callback) {
+      if (this.handlers.has(topic)) {
+        const cbs = this.handlers.get(topic);
+        cbs.delete(callback);
+        if (cbs.size === 0) {
+          this.handlers.delete(topic);
+          this._sendRaw({ type: "unsub", topic });
+        }
+      }
+    }
+    /**
+     * Publish a message to a topic. Queued if offline.
+     * @param {string} topic
+     * @param {any}    payload
+     */
+    publish(topic, payload) {
+      this._sendRaw({ topic, payload });
+    }
+    /**
+     * High-frequency data push (IoT sensors).
+     * @param {string} topic
+     * @param {any}    payload
+     */
+    pubPush(topic, payload) {
+      this._sendRaw({ type: "pub", topic, payload });
+    }
+    /**
+     * Request historical data from a topic.
+     * @param {string} topic
+     * @param {number} [count=10]
+     */
+    subPull(topic, count = 10) {
+      this._sendRaw({ type: "PULL_REQUEST", topic, count });
+    }
+    // ── File Transfer ─────────────────────────────────────────────────────────
+    /**
+     * Upload a file to the server in chunks.
+     * @param {string}   fileId
+     * @param {Blob|ArrayBuffer|Uint8Array} fileData
+     * @param {string}   [filename]
+     * @param {function(number): void} [onProgress]  — progress callback (0-100)
+     * @returns {Promise<void>}
+     */
+    async pubFile(fileId, fileData, filename = "", onProgress) {
+      let buffer;
+      if (fileData instanceof Blob) {
+        buffer = await fileData.arrayBuffer();
+      } else if (fileData instanceof ArrayBuffer) {
+        buffer = fileData;
+      } else {
+        buffer = fileData.buffer || fileData;
+      }
+      const bytes = new Uint8Array(buffer);
+      const chunkSize = this.options.chunkSize;
+      const totalChunks = Math.ceil(bytes.length / chunkSize);
+      this._sendRaw({
+        type: "FILE_UPLOAD_START",
+        fileId,
+        name: filename,
+        size: bytes.length,
+        totalChunks,
+        chunkSize
+      });
+      for (let i = 0; i < totalChunks; i++) {
+        const chunk = bytes.slice(i * chunkSize, (i + 1) * chunkSize);
+        const b64 = this._uint8ToBase64(chunk);
+        this._sendRaw({
+          type: "FILE_UPLOAD_CHUNK",
+          fileId,
+          chunkIndex: i,
+          totalChunks,
+          data: b64
+        });
+        if (onProgress) onProgress(Math.round((i + 1) / totalChunks * 100));
+        if (i % 10 === 0) await new Promise((r) => setTimeout(r, 0));
+      }
+      this._sendRaw({ type: "FILE_UPLOAD_DONE", fileId });
+    }
+    /** @private */
+    _uint8ToBase64(uint8) {
+      let binary = "";
+      for (let i = 0; i < uint8.length; i++) binary += String.fromCharCode(uint8[i]);
+      if (typeof btoa !== "undefined") return btoa(binary);
+      return Buffer.from(binary, "binary").toString("base64");
+    }
+    /**
+     * Download a file from the server by chunks.
+     * @param {string} fileId
+     * @param {number} [startChunk=0]
+     */
+    subFile(fileId, startChunk = 0) {
+      this._sendRaw({ type: "FILE_REQUEST", fileId, startChunk });
+    }
+    /**
+     * Resume a file download from saved progress.
+     * @param {string} fileId
+     */
+    resumeFile(fileId) {
+      const last = parseInt(this.storage.getItem(`dolphin_file_${fileId}`) || "-1");
+      this.subFile(fileId, last + 1);
+    }
+    /**
+     * Save download chunk progress.
+     * @param {string} fileId
+     * @param {number} chunkIndex
+     */
+    saveFileProgress(fileId, chunkIndex) {
+      this.storage.setItem(`dolphin_file_${fileId}`, chunkIndex.toString());
+    }
+    // ── Signaling ─────────────────────────────────────────────────────────────
+    /**
+     * @param {function(SignalMessage): void} handler
+     */
+    onSignal(handler) {
+      this.signalHandlers.add(handler);
+    }
+    /**
+     * @param {function(SignalMessage): void} handler
+     */
+    offSignal(handler) {
+      this.signalHandlers.delete(handler);
+    }
+    /**
+     * @param {function(FileMetadata): void} handler
+     */
+    onFileAvailable(handler) {
+      this.fileHandlers.add(handler);
+    }
+    /**
+     * @param {function(FileMetadata): void} handler
+     */
+    offFileAvailable(handler) {
+      this.fileHandlers.delete(handler);
+    }
+    addDomListener(target, event, cb) {
+      if (!target) return;
+      target.addEventListener(event, cb);
+      this._attachedListeners = this._attachedListeners || [];
+      this._attachedListeners.push({ target, event, cb });
+    }
+    cleanupDomListeners() {
+      if (this._attachedListeners) {
+        this._attachedListeners.forEach(({ target, event, cb }) => {
+          try {
+            target.removeEventListener(event, cb);
+          } catch {
+          }
+        });
+        this._attachedListeners = [];
+      }
+    }
+  };
+
+  // src/dom.ts
+  function attachDOMBinding(clientProto) {
+    function escapeRegExp(str) {
+      return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function resolveTemplate(el) {
+      const template = el.getAttribute("data-rt-template");
+      if (!template) return null;
+      if (typeof document !== "undefined" && !template.includes("<")) {
+        try {
+          const tempEl = document.querySelector(template);
+          if (tempEl) return tempEl.innerHTML;
+        } catch {
+        }
+      }
+      return template;
+    }
+    function sanitizeHTML(html) {
+      if (typeof document === "undefined") return html;
+      try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(html, "text/html");
+        const body = doc.body;
+        const sanitizeNode = (el) => {
+          const tag = el.tagName.toLowerCase();
+          if (["script", "iframe", "object", "embed", "link", "style", "meta", "applet", "svg"].includes(tag)) {
+            el.parentNode?.removeChild(el);
+            return;
+          }
+          const attrs = el.attributes;
+          for (let i = attrs.length - 1; i >= 0; i--) {
+            const attrName = attrs[i].name.toLowerCase();
+            const attrVal = attrs[i].value.toLowerCase();
+            if (attrName.startsWith("on")) {
+              el.removeAttribute(attrs[i].name);
+            } else if (["src", "href", "data"].includes(attrName) && (attrVal.includes("javascript:") || attrVal.includes("data:text/html"))) {
+              el.removeAttribute(attrs[i].name);
+            }
+          }
+          Array.from(el.children).forEach(sanitizeNode);
+        };
+        Array.from(body.children).forEach(sanitizeNode);
+        return body.innerHTML;
+      } catch {
+        return html;
+      }
+    }
+    function diffDOM(existingNode, newNode) {
+      if (existingNode.nodeType !== newNode.nodeType) {
+        existingNode.parentNode?.replaceChild(newNode.cloneNode(true), existingNode);
+        return;
+      }
+      if (existingNode.nodeType === Node.TEXT_NODE) {
+        if (existingNode.textContent !== newNode.textContent) {
+          existingNode.textContent = newNode.textContent;
+        }
+        return;
+      }
+      if (existingNode.nodeType === Node.ELEMENT_NODE) {
+        const el1 = existingNode;
+        const el2 = newNode;
+        if (el1.tagName !== el2.tagName) {
+          el1.parentNode?.replaceChild(el2.cloneNode(true), el1);
+          return;
+        }
+        const attr1 = el1.attributes;
+        const attr2 = el2.attributes;
+        for (let i = attr1.length - 1; i >= 0; i--) {
+          const name = attr1[i].name;
+          if (!el2.hasAttribute(name)) el1.removeAttribute(name);
+        }
+        for (let i = 0; i < attr2.length; i++) {
+          const name = attr2[i].name;
+          const val = attr2[i].value;
+          if (el1.getAttribute(name) !== val) el1.setAttribute(name, val);
+        }
+        if (el1.tagName === "INPUT" || el1.tagName === "TEXTAREA") {
+          if (el1.value !== el2.value) el1.value = el2.value;
+          if (el1.checked !== el2.checked) el1.checked = el2.checked;
+        } else if (el1.tagName === "SELECT") {
+          if (el1.value !== el2.value) el1.value = el2.value;
+        }
+        const childs1 = Array.from(el1.childNodes);
+        const childs2 = Array.from(el2.childNodes);
+        const len1 = childs1.length;
+        const len2 = childs2.length;
+        const maxLen = Math.max(len1, len2);
+        for (let i = 0; i < maxLen; i++) {
+          if (i >= len1) {
+            el1.appendChild(childs2[i].cloneNode(true));
+          } else if (i >= len2) {
+            el1.removeChild(childs1[i]);
+          } else {
+            diffDOM(childs1[i], childs2[i]);
+          }
+        }
+      }
+    }
+    function patchDOM(parentElement, newHTML) {
+      if (typeof document === "undefined") return;
+      const temp = document.createElement(parentElement.tagName);
+      temp.innerHTML = newHTML;
+      const childs1 = Array.from(parentElement.childNodes);
+      const childs2 = Array.from(temp.childNodes);
+      const len1 = childs1.length;
+      const len2 = childs2.length;
+      const maxLen = Math.max(len1, len2);
+      for (let i = 0; i < maxLen; i++) {
+        if (i >= len1) {
+          parentElement.appendChild(childs2[i].cloneNode(true));
+        } else if (i >= len2) {
+          parentElement.removeChild(childs1[i]);
+        } else {
+          diffDOM(childs1[i], childs2[i]);
+        }
+      }
+    }
+    const pendingUpdates = /* @__PURE__ */ new Map();
+    let rafScheduled = false;
+    function scheduleDOMUpdate(element, newHTML) {
+      pendingUpdates.set(element, newHTML);
+      if (!rafScheduled) {
+        rafScheduled = true;
+        const scheduleFn = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : (cb) => setTimeout(cb, 0);
+        scheduleFn(() => {
+          pendingUpdates.forEach((html, el) => {
+            patchDOM(el, html);
+          });
+          pendingUpdates.clear();
+          rafScheduled = false;
+        });
+      }
+    }
+    clientProto.setStoreState = function(storeName, key, val) {
+      this.uiStores = this.uiStores || /* @__PURE__ */ new Map();
+      if (!this.uiStores.has(storeName)) {
+        this.uiStores.set(storeName, {});
+      }
+      const store = this.uiStores.get(storeName);
+      store[key] = val;
+      if (typeof document !== "undefined") {
+        const readElements = document.querySelectorAll(`[data-store-read="${storeName}.${key}"]`);
+        readElements.forEach((el) => {
+          if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
+            if (el.type === "checkbox") {
+              el.checked = !!val;
+            } else {
+              el.value = val !== void 0 && val !== null ? val : "";
+            }
+          } else {
+            el.textContent = val !== void 0 && val !== null ? val : "";
+          }
+        });
+      }
+      this.publish(`store/${storeName}`, store);
+    };
+    clientProto.getStoreState = function(storeName, key) {
+      this.uiStores = this.uiStores || /* @__PURE__ */ new Map();
+      const store = this.uiStores.get(storeName);
+      return store ? store[key] : void 0;
+    };
+    clientProto._scanStoreBinds = function() {
+      if (typeof document === "undefined") return;
+      const writeEls = document.querySelectorAll("[data-store-write]");
+      writeEls.forEach((el) => {
+        const writeBind = el.getAttribute("data-store-write");
+        if (writeBind) {
+          const parts = writeBind.split(".");
+          if (parts.length === 2) {
+            const storeName = parts[0];
+            const key = parts[1];
+            const val = el.type === "checkbox" ? el.checked : el.value;
+            this.uiStores = this.uiStores || /* @__PURE__ */ new Map();
+            if (!this.uiStores.has(storeName)) {
+              this.uiStores.set(storeName, {});
+            }
+            const store = this.uiStores.get(storeName);
+            if (store[key] === void 0) {
+              store[key] = val;
+            }
+          }
+        }
+      });
+      const readEls = document.querySelectorAll("[data-store-read]");
+      readEls.forEach((el) => {
+        const readBind = el.getAttribute("data-store-read");
+        if (readBind) {
+          const parts = readBind.split(".");
+          if (parts.length === 2) {
+            const storeName = parts[0];
+            const key = parts[1];
+            const val = this.getStoreState(storeName, key);
+            if (val !== void 0 && val !== null) {
+              if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
+                if (el.type === "checkbox") {
+                  el.checked = !!val;
+                } else {
+                  el.value = val;
+                }
+              } else {
+                el.textContent = val;
+              }
+            }
+          }
+        }
+      });
+    };
+    clientProto.getClosestContext = function(element, key) {
+      let current = element;
+      while (current) {
+        if (current._rtContext) {
+          const ctx = current._rtContext;
+          if (key) return ctx[key];
+          return ctx;
+        }
+        current = current.parentElement;
+      }
+      return null;
+    };
+    clientProto._initDOMBinding = function() {
+      if (this._domInitialized) return;
+      this._domInitialized = true;
+      const PUSH_EVENTS = ["input", "change", "keyup", "paste", "blur"];
+      const debounceTimers = /* @__PURE__ */ new Map();
+      PUSH_EVENTS.forEach((evtName) => {
+        this.addDomListener(document, evtName, (e) => {
+          if (!e.target || !e.target.getAttribute) return;
+          const writeBind = e.target.getAttribute("data-store-write");
+          if (writeBind) {
+            const parts = writeBind.split(".");
+            if (parts.length === 2) {
+              const storeName = parts[0];
+              const key = parts[1];
+              const val = e.target.type === "checkbox" ? e.target.checked : e.target.value;
+              this.setStoreState(storeName, key, val);
+            }
+          }
+          const rules = e.target.getAttribute("data-rt-validate");
+          const name = e.target.name;
+          if (rules && name && typeof this.validateField === "function") {
+            const form = e.target.closest("form");
+            const formValues = form ? Object.fromEntries(new FormData(form).entries()) : {};
+            const errorMsg = this.validateField(e.target.value, rules, formValues);
+            if (errorMsg) {
+              e.target.classList.add("invalid");
+              this.publish(`errors/${name}`, errorMsg);
+            } else {
+              e.target.classList.remove("invalid");
+              this.publish(`errors/${name}`, "");
+            }
+          }
+          const topic = e.target.getAttribute("data-rt-push");
+          if (topic) {
+            const debounceVal = e.target.getAttribute("data-rt-debounce");
+            const waitMs = debounceVal ? parseInt(debounceVal, 10) : 0;
+            const triggerPush = () => {
+              const payload = { name: e.target.name, value: e.target.value };
+              this.pubPush(topic, payload);
+            };
+            if (waitMs > 0) {
+              if (debounceTimers.has(e.target)) {
+                clearTimeout(debounceTimers.get(e.target));
+              }
+              const timer = setTimeout(triggerPush, waitMs);
+              debounceTimers.set(e.target, timer);
+            } else {
+              triggerPush();
+            }
+          }
+        });
+      });
+      this.addDomListener(document, "submit", async (e) => {
+        if (!e.target || !e.target.getAttribute) return;
+        const rtTopic = e.target.getAttribute("data-rt-submit");
+        const apiTarget = e.target.getAttribute("data-api-submit");
+        if (rtTopic || apiTarget) {
+          const validatedInputs = e.target.querySelectorAll("[data-rt-validate]");
+          let formIsValid = true;
+          if (validatedInputs.length > 0 && typeof this.validateField === "function") {
+            const formValues = Object.fromEntries(new FormData(e.target).entries());
+            validatedInputs.forEach((inputEl) => {
+              const rules = inputEl.getAttribute("data-rt-validate");
+              const name = inputEl.name;
+              if (rules && name) {
+                const errorMsg = this.validateField(inputEl.value, rules, formValues);
+                if (errorMsg) {
+                  formIsValid = false;
+                  inputEl.classList.add("invalid");
+                  this.publish(`errors/${name}`, errorMsg);
+                } else {
+                  inputEl.classList.remove("invalid");
+                  this.publish(`errors/${name}`, "");
+                }
+              }
+            });
+          }
+          if (!formIsValid) {
+            e.preventDefault();
+            e.stopPropagation();
+            return;
+          }
+          e.preventDefault();
+          const parentCtx = this.getClosestContext(e.target) || {};
+          const formData = new FormData(e.target);
+          const data = Object.fromEntries(formData.entries());
+          if (rtTopic) {
+            let resolvedTopic = rtTopic;
+            for (const k in parentCtx) {
+              const escapedK = escapeRegExp(k);
+              resolvedTopic = resolvedTopic.replace(new RegExp(`\\{\\{${escapedK}\\}\\}`, "g"), parentCtx[k] !== void 0 && parentCtx[k] !== null ? parentCtx[k] : "");
+            }
+            this.publish(resolvedTopic, data);
+          } else if (apiTarget) {
+            let resolvedTarget = apiTarget;
+            for (const k in parentCtx) {
+              const escapedK = escapeRegExp(k);
+              resolvedTarget = resolvedTarget.replace(new RegExp(`\\{\\{${escapedK}\\}\\}`, "g"), parentCtx[k] !== void 0 && parentCtx[k] !== null ? parentCtx[k] : "");
+            }
+            const parts = resolvedTarget.trim().split(" ");
+            const method = parts.length > 1 ? parts[0].toUpperCase() : "POST";
+            const path = parts.length > 1 ? parts[1] : parts[0];
+            try {
+              const result = await this.api.request(method, path, data);
+              const resultBind = e.target.getAttribute("data-api-result");
+              if (resultBind) this._updateDOM(resultBind, result);
+              const redirect = e.target.getAttribute("data-api-redirect");
+              if (redirect) window.location.href = redirect;
+              if (e.target.hasAttribute("data-api-reload")) window.location.reload();
+            } catch (err) {
+              console.error("[Dolphin] API Submit Error:", err);
+            }
+          }
+        }
+      });
+      const INTERACTION_EVENTS = ["click", "change", "submit", "input", "keydown", "keyup", "dblclick", "focus", "blur", "mouseenter", "mouseleave"];
+      INTERACTION_EVENTS.forEach((evtName) => {
+        this.addDomListener(document, evtName, async (e) => {
+          if (!e.target || !e.target.closest) return;
+          const rtBtn = e.target.closest(`[data-rt-${evtName}]`);
+          const apiBtn = e.target.closest(`[data-api-${evtName}]`);
+          if (rtBtn) {
+            if (evtName === "submit") e.preventDefault();
+            const topic = rtBtn.getAttribute(`data-rt-${evtName}`);
+            const actionData = rtBtn.getAttribute("data-rt-payload");
+            const parentCtx = this.getClosestContext(rtBtn) || {};
+            let payload = {};
+            if (actionData) {
+              let resolvedDataStr = actionData;
+              for (const k in parentCtx) {
+                const escapedK = escapeRegExp(k);
+                resolvedDataStr = resolvedDataStr.replace(new RegExp(`\\{\\{${escapedK}\\}\\}`, "g"), parentCtx[k] !== void 0 && parentCtx[k] !== null ? parentCtx[k] : "");
+              }
+              try {
+                payload = JSON.parse(resolvedDataStr);
+              } catch {
+                payload = {};
+              }
+            }
+            this.publish(topic, payload);
+          }
+          if (apiBtn) {
+            if (evtName === "submit") e.preventDefault();
+            const apiTarget = apiBtn.getAttribute(`data-api-${evtName}`);
+            const actionData = apiBtn.getAttribute("data-api-payload");
+            const parentCtx = this.getClosestContext(apiBtn) || {};
+            const parts = apiTarget.trim().split(" ");
+            const method = parts.length > 1 ? parts[0].toUpperCase() : "POST";
+            const path = parts.length > 1 ? parts[1] : parts[0];
+            let payload = null;
+            if (actionData) {
+              let resolvedDataStr = actionData;
+              for (const k in parentCtx) {
+                const escapedK = escapeRegExp(k);
+                resolvedDataStr = resolvedDataStr.replace(new RegExp(`\\{\\{${escapedK}\\}\\}`, "g"), parentCtx[k] !== void 0 && parentCtx[k] !== null ? parentCtx[k] : "");
+              }
+              try {
+                payload = JSON.parse(resolvedDataStr);
+              } catch {
+                payload = null;
+              }
+            }
+            try {
+              const result = await this.api.request(method, path, payload);
+              const resultBind = apiBtn.getAttribute("data-api-result");
+              if (resultBind) this._updateDOM(resultBind, result);
+              const redirect = apiBtn.getAttribute("data-api-redirect");
+              if (redirect) window.location.href = redirect;
+              if (apiBtn.hasAttribute("data-api-reload")) window.location.reload();
+            } catch (err) {
+              console.error(`[Dolphin] API ${evtName} Error:`, err);
+            }
+          }
+        });
+      });
+      this.subscribe("#", (payload, topic) => {
+        this._updateDOM(topic, payload);
+      });
+      this._scanAndFetchAPIBinds();
+      this._scanStoreBinds();
+    };
+    clientProto._scanAndFetchAPIBinds = async function() {
+      if (typeof document === "undefined") return;
+      const elements = document.querySelectorAll("[data-api-get]");
+      for (const el of Array.from(elements)) {
+        const path = el.getAttribute("data-api-get");
+        if (!path) continue;
+        try {
+          const result = await this.api.get(path);
+          const rtBind = el.getAttribute("data-rt-bind");
+          if (rtBind) {
+            this._updateDOM(rtBind, result);
+          } else {
+            const template = resolveTemplate(el);
+            if (template && typeof result === "object" && result !== null) {
+              if (Array.isArray(result)) {
+                let combinedHTML = "";
+                for (const item of result) {
+                  let finalItemHTML = template;
+                  for (let key in item) {
+                    const escapedKey = escapeRegExp(key);
+                    finalItemHTML = finalItemHTML.replace(new RegExp(`\\{\\{${escapedKey}\\}\\}`, "g"), item[key] !== void 0 && item[key] !== null ? item[key] : "");
+                  }
+                  combinedHTML += finalItemHTML;
+                }
+                scheduleDOMUpdate(el, combinedHTML);
+              } else {
+                let finalHTML = template;
+                for (let key in result) {
+                  const escapedKey = escapeRegExp(key);
+                  finalHTML = finalHTML.replace(new RegExp(`\\{\\{${escapedKey}\\}\\}`, "g"), result[key] !== void 0 && result[key] !== null ? result[key] : "");
+                }
+                scheduleDOMUpdate(el, finalHTML);
+              }
+            } else {
+              if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
+                el.value = typeof result === "object" ? result.value !== void 0 ? result.value : "" : result;
+              } else {
+                el.innerHTML = typeof result === "object" ? result.html || result.text || JSON.stringify(result) : result;
+              }
+            }
+          }
+        } catch (e) {
+          console.error("[Dolphin] API Get Error:", e);
+        }
+      }
+    };
+    clientProto._updateDOM = function(topic, payload) {
+      if (typeof document === "undefined") return;
+      const elements = document.querySelectorAll(`[data-rt-bind="${topic}"]`);
+      elements.forEach((el) => {
+        if (el.getAttribute("data-rt-type") === "context" && typeof payload === "object" && payload !== null) {
+          el._rtContext = payload;
+          const processNode = (node) => {
+            if (node.hasAttribute("data-rt-text")) {
+              const key = node.getAttribute("data-rt-text");
+              if (key && payload[key] !== void 0 && payload[key] !== null) node.textContent = payload[key];
+            }
+            if (node.hasAttribute("data-rt-html")) {
+              const key = node.getAttribute("data-rt-html");
+              if (key && payload[key] !== void 0 && payload[key] !== null) {
+                node.innerHTML = sanitizeHTML(payload[key]);
+              }
+            }
+            if (node.hasAttribute("data-rt-attr")) {
+              const attrStr = node.getAttribute("data-rt-attr");
+              if (attrStr) {
+                attrStr.split(",").forEach((b) => {
+                  const parts = b.split(":");
+                  if (parts.length === 2) {
+                    const attrName = parts[0].trim();
+                    const key = parts[1].trim();
+                    if (attrName && key && payload[key] !== void 0 && payload[key] !== null) {
+                      node.setAttribute(attrName, payload[key]);
+                    }
+                  }
+                });
+              }
+            }
+            if (node.hasAttribute("data-rt-class")) {
+              const classStr = node.getAttribute("data-rt-class");
+              if (classStr) {
+                classStr.split(",").forEach((b) => {
+                  const parts = b.split(":");
+                  if (parts.length === 2) {
+                    const className = parts[0].trim();
+                    const key = parts[1].trim();
+                    if (payload[key]) {
+                      node.classList.add(className);
+                    } else {
+                      node.classList.remove(className);
+                    }
+                  }
+                });
+              }
+            }
+            if (node.hasAttribute("data-rt-if")) {
+              const key = node.getAttribute("data-rt-if");
+              if (key) {
+                if (payload[key]) {
+                  node.style.display = "";
+                } else {
+                  node.style.display = "none";
+                }
+              }
+            }
+            if (node.hasAttribute("data-rt-hide")) {
+              const key = node.getAttribute("data-rt-hide");
+              if (key) {
+                if (payload[key]) {
+                  node.style.display = "none";
+                } else {
+                  node.style.display = "";
+                }
+              }
+            }
+          };
+          processNode(el);
+          el.querySelectorAll("[data-rt-text], [data-rt-html], [data-rt-attr], [data-rt-class], [data-rt-if], [data-rt-hide]").forEach(processNode);
+          return;
+        }
+        const template = resolveTemplate(el);
+        if (template && typeof payload === "object" && payload !== null) {
+          if (Array.isArray(payload)) {
+            let combinedHTML = "";
+            for (const item of payload) {
+              let finalItemHTML = template;
+              for (let key in item) {
+                const escapedKey = escapeRegExp(key);
+                finalItemHTML = finalItemHTML.replace(new RegExp(`\\{\\{${escapedKey}\\}\\}`, "g"), item[key] !== void 0 && item[key] !== null ? item[key] : "");
+              }
+              combinedHTML += finalItemHTML;
+            }
+            scheduleDOMUpdate(el, combinedHTML);
+          } else {
+            let finalHTML = template;
+            for (let key in payload) {
+              const escapedKey = escapeRegExp(key);
+              finalHTML = finalHTML.replace(new RegExp(`\\{\\{${escapedKey}\\}\\}`, "g"), payload[key] !== void 0 && payload[key] !== null ? payload[key] : "");
+            }
+            scheduleDOMUpdate(el, finalHTML);
+          }
+          return;
+        }
+        if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
+          el.value = typeof payload === "object" ? payload.value !== void 0 ? payload.value : "" : payload;
+        } else {
+          el.innerHTML = typeof payload === "object" ? payload.html || payload.text || JSON.stringify(payload) : payload;
+        }
+      });
+    };
+  }
+
+  // src/offline.ts
+  var DolphinOffline = class {
+    client;
+    db;
+    isOnline;
+    memoryCache = /* @__PURE__ */ new Map();
+    memoryMutations = [];
+    constructor(client) {
+      this.client = client;
+      this.isOnline = typeof window !== "undefined" && typeof navigator !== "undefined" ? navigator.onLine : true;
+      this.initDB();
+      this.setupNetworkListeners();
+    }
+    initDB() {
+      if (typeof indexedDB === "undefined") return;
+      try {
+        const request = indexedDB.open("dolphin_offline", 1);
+        request.onupgradeneeded = (e) => {
+          const db = e.target.result;
+          if (!db.objectStoreNames.contains("cache")) {
+            db.createObjectStore("cache");
+          }
+          if (!db.objectStoreNames.contains("mutations")) {
+            db.createObjectStore("mutations", { keyPath: "id", autoIncrement: true });
+          }
+        };
+        request.onsuccess = (e) => {
+          this.db = e.target.result;
+          if (this.isOnline) {
+            this.syncMutations();
+          }
+        };
+      } catch (err) {
+        console.warn("[Dolphin Offline] Failed to initialize IndexedDB:", err);
+      }
+    }
+    setupNetworkListeners() {
+      if (typeof window === "undefined") return;
+      this.client.addDomListener(window, "online", () => {
+        this.isOnline = true;
+        this.client._dispatch("network:status", { online: true });
+        this.syncMutations();
+      });
+      this.client.addDomListener(window, "offline", () => {
+        this.isOnline = false;
+        this.client._dispatch("network:status", { online: false });
+      });
+    }
+    async getCache(key) {
+      if (!this.db) {
+        return this.memoryCache.get(key);
+      }
+      return new Promise((resolve) => {
+        try {
+          const transaction = this.db.transaction("cache", "readonly");
+          const store = transaction.objectStore("cache");
+          const req = store.get(key);
+          req.onsuccess = () => resolve(req.result ? req.result.data : null);
+          req.onerror = () => resolve(null);
+        } catch {
+          resolve(null);
+        }
+      });
+    }
+    async setCache(key, data) {
+      if (!this.db) {
+        this.memoryCache.set(key, data);
+        return;
+      }
+      return new Promise((resolve) => {
+        try {
+          const transaction = this.db.transaction("cache", "readwrite");
+          const store = transaction.objectStore("cache");
+          store.put({ data, timestamp: Date.now() }, key);
+          transaction.oncomplete = () => resolve();
+        } catch {
+          resolve();
+        }
+      });
+    }
+    async queueMutation(method, path, payload) {
+      const mutation = {
+        method,
+        path,
+        payload,
+        timestamp: Date.now()
+      };
+      if (!this.db) {
+        this.memoryMutations.push(mutation);
+        return;
+      }
+      return new Promise((resolve) => {
+        try {
+          const transaction = this.db.transaction("mutations", "readwrite");
+          const store = transaction.objectStore("mutations");
+          store.add(mutation);
+          transaction.oncomplete = () => resolve();
+        } catch {
+          resolve();
+        }
+      });
+    }
+    async getMutations() {
+      if (!this.db) {
+        return [...this.memoryMutations];
+      }
+      return new Promise((resolve) => {
+        try {
+          const transaction = this.db.transaction("mutations", "readonly");
+          const store = transaction.objectStore("mutations");
+          const req = store.getAll();
+          req.onsuccess = () => resolve(req.result || []);
+          req.onerror = () => resolve([]);
+        } catch {
+          resolve([]);
+        }
+      });
+    }
+    async removeMutation(id) {
+      if (!this.db) {
+        this.memoryMutations = this.memoryMutations.filter((m) => m.id !== id);
+        return;
+      }
+      return new Promise((resolve) => {
+        try {
+          const transaction = this.db.transaction("mutations", "readwrite");
+          const store = transaction.objectStore("mutations");
+          store.delete(id);
+          transaction.oncomplete = () => resolve();
+        } catch {
+          resolve();
+        }
+      });
+    }
+    async syncMutations() {
+      const mutations = await this.getMutations();
+      if (mutations.length === 0) return;
+      console.log(`[Dolphin Offline] Syncing ${mutations.length} queued mutations...`);
+      for (const mutation of mutations) {
+        try {
+          await this.client.api.requestDirect(mutation.method, mutation.path, mutation.payload);
+          if (mutation.id !== void 0) {
+            await this.removeMutation(mutation.id);
+          } else {
+            this.memoryMutations.shift();
+          }
+        } catch (err) {
+          console.error(`[Dolphin Offline] Sync failed for mutation ${mutation.method} ${mutation.path}:`, err);
+          if (err && err.status && err.status >= 400 && err.status < 500) {
+            console.warn("[Dolphin Offline] Discarding invalid mutation.");
+            if (mutation.id !== void 0) {
+              await this.removeMutation(mutation.id);
+            } else {
+              this.memoryMutations.shift();
+            }
+          } else {
+            break;
+          }
+        }
+      }
+    }
+  };
+  function attachOffline(clientProto) {
+    clientProto._initOffline = function() {
+      this.offline = new DolphinOffline(this);
+    };
+  }
+
+  // src/validation.ts
+  function validateField(value, rulesStr, allValues) {
+    const rules = rulesStr.split(",");
+    for (const rule of rules) {
+      const parts = rule.trim().split(":");
+      const ruleName = parts[0];
+      const ruleArg = parts[1];
+      if (ruleName === "required") {
+        if (!value || value.trim() === "") {
+          return "This field is required";
+        }
+      } else if (ruleName === "email") {
+        if (value && value.trim() !== "") {
+          const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+          if (!emailRegex.test(value)) {
+            return "Please enter a valid email address";
+          }
+        }
+      } else if (ruleName === "min") {
+        const minLen = parseInt(ruleArg, 10);
+        if (!value || value.length < minLen) {
+          return `Must be at least ${minLen} characters`;
+        }
+      } else if (ruleName === "match") {
+        if (allValues && value !== allValues[ruleArg]) {
+          return `Must match ${ruleArg}`;
+        }
+      }
+    }
+    return null;
+  }
+  function attachValidation(clientProto) {
+    clientProto.validateField = validateField;
+  }
+
+  // src/animation.ts
+  function attachAnimations(clientProto) {
+    clientProto.animateElement = function(el, animationClass, durationMs = 300) {
+      if (typeof el.animate !== "function") {
+        el.classList.add(animationClass);
+        setTimeout(() => el.classList.remove(animationClass), durationMs);
+        return;
+      }
+      if (animationClass === "fade-in") {
+        el.animate([
+          { opacity: 0, transform: "translateY(10px)" },
+          { opacity: 1, transform: "translateY(0)" }
+        ], { duration: durationMs, easing: "ease-out" });
+      } else if (animationClass === "fade-out") {
+        el.animate([
+          { opacity: 1, transform: "translateY(0)" },
+          { opacity: 0, transform: "translateY(10px)" }
+        ], { duration: durationMs, easing: "ease-in" });
+      }
+    };
+    clientProto.staggerListItems = function(container, itemSelector, delayMs = 50) {
+      if (typeof document === "undefined") return;
+      const items = container.querySelectorAll(itemSelector);
+      items.forEach((item, idx) => {
+        item.style.animationDelay = `${idx * delayMs}ms`;
+        item.classList.add("staggered-item");
+      });
+    };
+  }
+
+  // src/a11y.ts
+  function attachA11y(clientProto) {
+    clientProto._initA11y = function() {
+      if (typeof document === "undefined") return;
+      this.addDomListener(document, "keydown", (e) => {
+        if (e.key !== "Tab") return;
+        const trappedContainers = document.querySelectorAll("[data-rt-a11y-focus-trap]");
+        trappedContainers.forEach((container) => {
+          if (container.style.display === "none" || container.hasAttribute("aria-hidden") && container.getAttribute("aria-hidden") === "true") {
+            return;
+          }
+          const focusableSelectors = 'a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable]';
+          const focusableElements = Array.from(container.querySelectorAll(focusableSelectors));
+          if (focusableElements.length === 0) return;
+          const firstEl = focusableElements[0];
+          const lastEl = focusableElements[focusableElements.length - 1];
+          if (e.shiftKey) {
+            if (document.activeElement === firstEl) {
+              lastEl.focus();
+              e.preventDefault();
+            }
+          } else {
+            if (document.activeElement === lastEl) {
+              firstEl.focus();
+              e.preventDefault();
+            }
+          }
+        });
+      });
+      this.addDomListener(document, "keydown", (e) => {
+        if (!["ArrowUp", "ArrowDown", "Enter"].includes(e.key)) return;
+        const keyNavLists = document.querySelectorAll("[data-rt-keynav]");
+        keyNavLists.forEach((list) => {
+          const items = Array.from(list.children);
+          if (items.length === 0) return;
+          let activeIdx = items.findIndex((el) => el.classList.contains("active") || document.activeElement === el);
+          if (e.key === "ArrowDown") {
+            activeIdx = (activeIdx + 1) % items.length;
+            items[activeIdx].focus();
+            items.forEach((item, idx) => {
+              if (idx === activeIdx) item.classList.add("active");
+              else item.classList.remove("active");
+            });
+            e.preventDefault();
+          } else if (e.key === "ArrowUp") {
+            activeIdx = (activeIdx - 1 + items.length) % items.length;
+            items[activeIdx].focus();
+            items.forEach((item, idx) => {
+              if (idx === activeIdx) item.classList.add("active");
+              else item.classList.remove("active");
+            });
+            e.preventDefault();
+          } else if (e.key === "Enter" && activeIdx !== -1) {
+            items[activeIdx].click();
+            e.preventDefault();
+          }
+        });
+      });
+    };
+    clientProto.autoAriaModal = function(modalEl, isOpen) {
+      if (isOpen) {
+        modalEl.setAttribute("role", "dialog");
+        modalEl.setAttribute("aria-modal", "true");
+        modalEl.setAttribute("aria-hidden", "false");
+        modalEl.focus();
+      } else {
+        modalEl.setAttribute("aria-hidden", "true");
+      }
+    };
+  }
+
+  // src/i18n.ts
+  function attachI18n(clientProto) {
+    clientProto._initI18n = function() {
+      this.i18n = this.i18n || {
+        locale: "en",
+        dicts: {}
+      };
+      if (typeof document === "undefined") return;
+      const dictEls = document.querySelectorAll("[data-i18n-dict]");
+      dictEls.forEach((el) => {
+        const locale = el.getAttribute("data-i18n-dict");
+        if (locale) {
+          try {
+            const dictData = JSON.parse(el.textContent || "{}");
+            this.i18n.dicts[locale] = {
+              ...this.i18n.dicts[locale] || {},
+              ...dictData
+            };
+          } catch (e) {
+            console.warn("[Dolphin i18n] Failed to parse dictionary for locale:", locale, e);
+          }
+        }
+      });
+      if (!this.i18n.locale && typeof navigator !== "undefined") {
+        const browserLang = navigator.language.split("-")[0];
+        if (this.i18n.dicts[browserLang]) {
+          this.i18n.locale = browserLang;
+        }
+      }
+      this.addDomListener(document, "click", (e) => {
+        const switcher = e.target.closest("[data-i18n-switch]");
+        if (switcher) {
+          const newLocale = switcher.getAttribute("data-i18n-switch");
+          if (newLocale) {
+            this.setLocale(newLocale);
+          }
+        }
+      });
+      this.translateDOM();
+    };
+    clientProto.setLocale = function(locale) {
+      this.i18n = this.i18n || { locale: "en", dicts: {} };
+      this.i18n.locale = locale;
+      this.translateDOM();
+      this.publish("i18n/locale", locale);
+    };
+    clientProto.translateDOM = function() {
+      if (typeof document === "undefined") return;
+      this.i18n = this.i18n || { locale: "en", dicts: {} };
+      const currentLocale = this.i18n.locale || "en";
+      const dict = this.i18n.dicts[currentLocale] || {};
+      const translateEls = document.querySelectorAll("[data-i18n-key]");
+      translateEls.forEach((el) => {
+        const key = el.getAttribute("data-i18n-key");
+        if (!key) return;
+        let translation = key.split(".").reduce((o, i) => o ? o[i] : null, dict);
+        if (translation === void 0 || translation === null) {
+          translation = key;
+        }
+        const paramsAttr = el.getAttribute("data-i18n-params");
+        if (paramsAttr) {
+          try {
+            const params = JSON.parse(paramsAttr);
+            const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            for (const k in params) {
+              const escapedK = escapeRegExp(k);
+              translation = translation.replace(new RegExp(`\\{\\{${escapedK}\\}\\}`, "g"), params[k]);
+            }
+          } catch {
+          }
+        }
+        if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") {
+          el.placeholder = translation;
+        } else {
+          el.textContent = translation;
+        }
+      });
+    };
+  }
+
+  // src/dragdrop.ts
+  function attachDragDrop(clientProto) {
+    clientProto._initDragDrop = function() {
+      if (typeof document === "undefined") return;
+      this.addDomListener(document, "dragstart", (e) => {
+        const dragEl = e.target.closest("[data-drag]");
+        if (!dragEl) return;
+        const payloadStr = dragEl.getAttribute("data-drag");
+        if (payloadStr) {
+          e.dataTransfer.setData("text/plain", payloadStr);
+          e.dataTransfer.effectAllowed = "move";
+          dragEl.classList.add("dragging");
+        }
+      });
+      this.addDomListener(document, "dragend", (e) => {
+        const dragEl = e.target.closest("[data-drag]");
+        if (dragEl) {
+          dragEl.classList.remove("dragging");
+        }
+      });
+      this.addDomListener(document, "dragover", (e) => {
+        const dropZone = e.target.closest("[data-drop]");
+        if (dropZone) {
+          e.preventDefault();
+          dropZone.classList.add("drag-over");
+        }
+      });
+      this.addDomListener(document, "dragleave", (e) => {
+        const dropZone = e.target.closest("[data-drop]");
+        if (dropZone) {
+          dropZone.classList.remove("drag-over");
+        }
+      });
+      this.addDomListener(document, "drop", (e) => {
+        const dropZone = e.target.closest("[data-drop]");
+        if (!dropZone) return;
+        e.preventDefault();
+        dropZone.classList.remove("drag-over");
+        const topic = dropZone.getAttribute("data-drop");
+        const dataStr = e.dataTransfer.getData("text/plain");
+        if (topic && dataStr) {
+          try {
+            const payload = JSON.parse(dataStr);
+            this.publish(topic, payload);
+          } catch {
+            this.publish(topic, { value: dataStr });
+          }
+        }
+      });
+      this.addDomListener(document, "dragover", (e) => {
+        const sortableContainer = e.target.closest("[data-sortable]");
+        if (!sortableContainer) return;
+        e.preventDefault();
+        const draggingEl = sortableContainer.querySelector(".dragging");
+        if (!draggingEl) return;
+        const siblings = Array.from(sortableContainer.querySelectorAll("[data-drag]:not(.dragging)"));
+        const nextSibling = siblings.find((sibling) => {
+          const box = sibling.getBoundingClientRect();
+          const offset = e.clientY - box.top - box.height / 2;
+          return offset < 0;
+        });
+        if (nextSibling) {
+          sortableContainer.insertBefore(draggingEl, nextSibling);
+        } else {
+          sortableContainer.appendChild(draggingEl);
+        }
+      });
+      this.addDomListener(document, "drop", (e) => {
+        const sortableContainer = e.target.closest("[data-sortable]");
+        if (!sortableContainer) return;
+        const topic = sortableContainer.getAttribute("data-sortable");
+        if (!topic) return;
+        const elements = Array.from(sortableContainer.querySelectorAll("[data-drag]"));
+        const newOrder = elements.map((el, index) => {
+          const payloadStr = el.getAttribute("data-drag");
+          try {
+            return { index, payload: JSON.parse(payloadStr || "{}") };
+          } catch {
+            return { index, payload: payloadStr };
+          }
+        });
+        this.publish(topic, newOrder);
+      });
+    };
+  }
+
+  // src/collab.ts
+  function attachCollab(clientProto) {
+    clientProto._initCollab = function() {
+      if (typeof document === "undefined") return;
+      this.addDomListener(document, "mousemove", (e) => {
+        const shareContainers = document.querySelectorAll("[data-rt-cursor-share]");
+        shareContainers.forEach((container) => {
+          const room = container.getAttribute("data-rt-cursor-share");
+          if (!room) return;
+          const box = container.getBoundingClientRect();
+          const xRatio = (e.clientX - box.left) / box.width;
+          const yRatio = (e.clientY - box.top) / box.height;
+          const now = Date.now();
+          if (!container._lastSent || now - container._lastSent > 50) {
+            container._lastSent = now;
+            this.pubPush(`collab/${room}/cursor/${this.deviceId}`, {
+              deviceId: this.deviceId,
+              x: xRatio,
+              y: yRatio
+            });
+          }
+        });
+      });
+      this.addDomListener(document, "input", (e) => {
+        const typingBind = e.target.getAttribute("data-rt-typing");
+        if (!typingBind) return;
+        const room = typingBind;
+        const publishTyping = (isTyping) => {
+          this.pubPush(`collab/${room}/typing/${this.deviceId}`, {
+            deviceId: this.deviceId,
+            typing: isTyping
+          });
+        };
+        if (!e.target._isTyping) {
+          e.target._isTyping = true;
+          publishTyping(true);
+        }
+        if (e.target._typingTimer) clearTimeout(e.target._typingTimer);
+        e.target._typingTimer = setTimeout(() => {
+          e.target._isTyping = false;
+          publishTyping(false);
+        }, 2e3);
+      });
+      this.addDomListener(document, "input", (e) => {
+        const crdtBind = e.target.getAttribute("data-rt-crdt");
+        if (!crdtBind) return;
+        const docName = crdtBind;
+        const value = e.target.value;
+        const now = Date.now();
+        this.publish(`collab/${docName}/crdt`, {
+          deviceId: this.deviceId,
+          value,
+          timestamp: now,
+          cursorPos: e.target.selectionStart
+        });
+      });
+      this.subscribe("collab/+/cursor/+", (payload, topic) => {
+        const parts = topic.split("/");
+        const room = parts[1];
+        const remoteDeviceId = parts[3];
+        if (remoteDeviceId === this.deviceId) return;
+        const container = document.querySelector(`[data-rt-cursor-share="${room}"]`);
+        if (!container) return;
+        let cursorEl = container.querySelector(`.rt-cursor-${remoteDeviceId}`);
+        if (!cursorEl) {
+          cursorEl = document.createElement("div");
+          cursorEl.className = `rt-cursor rt-cursor-${remoteDeviceId}`;
+          cursorEl.style.position = "absolute";
+          cursorEl.style.width = "10px";
+          cursorEl.style.height = "10px";
+          cursorEl.style.borderRadius = "50%";
+          cursorEl.style.backgroundColor = "#" + Math.floor(Math.random() * 16777215).toString(16);
+          cursorEl.style.pointerEvents = "none";
+          container.appendChild(cursorEl);
+        }
+        const box = container.getBoundingClientRect();
+        cursorEl.style.left = payload.x * box.width + "px";
+        cursorEl.style.top = payload.y * box.height + "px";
+      });
+      this.subscribe("collab/+/crdt", (payload, topic) => {
+        if (payload.deviceId === this.deviceId) return;
+        const parts = topic.split("/");
+        const docName = parts[1];
+        const crdtInputs = document.querySelectorAll(`[data-rt-crdt="${docName}"]`);
+        crdtInputs.forEach((input) => {
+          if (!input._lastUpdate || payload.timestamp > input._lastUpdate) {
+            input._lastUpdate = payload.timestamp;
+            const originalPos = input.selectionStart;
+            input.value = payload.value;
+            if (document.activeElement === input) {
+              input.setSelectionRange(originalPos, originalPos);
+            }
+          }
+        });
+      });
+    };
+  }
+
+  // src/pwa.ts
+  function attachPwa(clientProto) {
+    clientProto.registerServiceWorker = async function(swPath = "/sw.js") {
+      if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
+        console.warn("[Dolphin PWA] Service Workers are not supported in this browser.");
+        return null;
+      }
+      try {
+        const registration = await navigator.serviceWorker.register(swPath);
+        console.log("[Dolphin PWA] Service Worker registered successfully with scope:", registration.scope);
+        return registration;
+      } catch (e) {
+        console.error("[Dolphin PWA] Service Worker registration failed:", e);
+        return null;
+      }
+    };
+    clientProto.subscribePushNotifications = async function(vapidPublicKey) {
+      if (typeof window === "undefined" || !("serviceWorker" in navigator) || !("PushManager" in window)) {
+        console.warn("[Dolphin PWA] Push notifications are not supported in this browser.");
+        return null;
+      }
+      try {
+        const registration = await navigator.serviceWorker.ready;
+        let subscription = await registration.pushManager.getSubscription();
+        if (!subscription) {
+          const padding = "=".repeat((4 - vapidPublicKey.length % 4) % 4);
+          const base64 = (vapidPublicKey + padding).replace(/\-/g, "+").replace(/_/g, "/");
+          const rawData = window.atob(base64);
+          const outputArray = new Uint8Array(rawData.length);
+          for (let i = 0; i < rawData.length; ++i) {
+            outputArray[i] = rawData.charCodeAt(i);
+          }
+          subscription = await registration.pushManager.subscribe({
+            userVisibleOnly: true,
+            applicationServerKey: outputArray
+          });
+        }
+        console.log("[Dolphin PWA] Subscribed to push notifications:", subscription);
+        return subscription;
+      } catch (e) {
+        console.error("[Dolphin PWA] Push notification subscription failed:", e);
+        return null;
+      }
+    };
+  }
+
+  // src/testing.ts
+  var DolphinTestUtils = class {
+    static render(html) {
+      if (typeof document === "undefined") {
+        throw new Error("DolphinTestUtils.render requires a DOM document environment to execute.");
+      }
+      const container = document.createElement("div");
+      container.innerHTML = html;
+      document.body.appendChild(container);
+      return {
+        container,
+        find: (sel) => container.querySelector(sel),
+        fireEvent: (el, eventType) => {
+          const evt = document.createEvent("Event");
+          evt.initEvent(eventType, true, true);
+          el.dispatchEvent(evt);
+        }
+      };
+    }
+    static mockWebSocket() {
+      const sentMessages = [];
+      const mockWS = {
+        readyState: 1,
+        // OPEN
+        send: (data) => {
+          sentMessages.push(data);
+        },
+        close: jest.fn(),
+        onopen: jest.fn(),
+        onmessage: jest.fn(),
+        onclose: jest.fn(),
+        onerror: jest.fn(),
+        sentMessages
+      };
+      global.WebSocket = class {
+        static OPEN = 1;
+        readyState = mockWS.readyState;
+        send = mockWS.send;
+        close = mockWS.close;
+        set onopen(v) {
+          mockWS.onopen = v;
+        }
+        get onopen() {
+          return mockWS.onopen;
+        }
+        set onmessage(v) {
+          mockWS.onmessage = v;
+        }
+        get onmessage() {
+          return mockWS.onmessage;
+        }
+        set onclose(v) {
+          mockWS.onclose = v;
+        }
+        get getonclose() {
+          return mockWS.onclose;
+        }
+        constructor() {
+          setTimeout(() => mockWS.onopen && mockWS.onopen(), 0);
+        }
+      };
+      return mockWS;
+    }
+    static simulateClick(el) {
+      const clickEvt = {
+        target: el,
+        preventDefault: jest.fn(),
+        stopPropagation: jest.fn()
+      };
+      const clickListeners = global.document._listeners?.["click"] || [];
+      clickListeners.forEach((listener) => listener(clickEvt));
+    }
+    static simulateChange(el, value) {
+      el.value = value;
+      const changeEvt = {
+        target: el,
+        preventDefault: jest.fn(),
+        stopPropagation: jest.fn()
+      };
+      const changeListeners = global.document._listeners?.["change"] || [];
+      changeListeners.forEach((listener) => listener(changeEvt));
+    }
+  };
+  function attachTesting(clientProto) {
+    clientProto.testing = DolphinTestUtils;
+  }
+
+  // src/index.ts
+  attachDOMBinding(DolphinClient.prototype);
+  attachOffline(DolphinClient.prototype);
+  attachValidation(DolphinClient.prototype);
+  attachAnimations(DolphinClient.prototype);
+  attachA11y(DolphinClient.prototype);
+  attachI18n(DolphinClient.prototype);
+  attachDragDrop(DolphinClient.prototype);
+  attachCollab(DolphinClient.prototype);
+  attachPwa(DolphinClient.prototype);
+  attachTesting(DolphinClient.prototype);
+  if (typeof window !== "undefined") {
+    window.DolphinClient = DolphinClient;
+  }
+  return __toCommonJS(index_exports);
+})();