@domql/utils 3.6.3 → 3.6.6

package/dist/iife/index.js

@@ -4,6 +4,9 @@ var DomqlUtils = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -18,6 +21,1510 @@ var DomqlUtils = (() => {
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // dist/esm/globals.js
+  var window3, document3;
+  var init_globals = __esm({
+    "dist/esm/globals.js"() {
+      window3 = globalThis;
+      document3 = window3.document;
+    }
+  });
+
+  // dist/esm/node.js
+  var init_node = __esm({
+    "dist/esm/node.js"() {
+    }
+  });
+
+  // dist/esm/types.js
+  var isObject2, isString2, isFunction2, isArray2;
+  var init_types = __esm({
+    "dist/esm/types.js"() {
+      isObject2 = (arg) => {
+        if (arg === null) return false;
+        return typeof arg === "object" && arg.constructor === Object;
+      };
+      isString2 = (arg) => typeof arg === "string";
+      isFunction2 = (arg) => typeof arg === "function";
+      isArray2 = (arg) => Array.isArray(arg);
+    }
+  });
+
+  // dist/esm/array.js
+  var init_array = __esm({
+    "dist/esm/array.js"() {
+    }
+  });
+
+  // dist/esm/string.js
+  var init_string = __esm({
+    "dist/esm/string.js"() {
+    }
+  });
+
+  // dist/esm/keys.js
+  var STATE_METHODS2, PROPS_METHODS2, METHODS2, METHODS_EXL2;
+  var init_keys = __esm({
+    "dist/esm/keys.js"() {
+      STATE_METHODS2 = /* @__PURE__ */ new Set([
+        "update",
+        "parse",
+        "clean",
+        "create",
+        "destroy",
+        "add",
+        "toggle",
+        "remove",
+        "apply",
+        "set",
+        "reset",
+        "replace",
+        "quietReplace",
+        "quietUpdate",
+        "applyReplace",
+        "applyFunction",
+        "keys",
+        "values",
+        "ref",
+        "rootUpdate",
+        "parentUpdate",
+        "parent",
+        "__element",
+        "__depends",
+        "__ref",
+        "__children",
+        "root",
+        "setByPath",
+        "setPathCollection",
+        "removeByPath",
+        "removePathCollection",
+        "getByPath"
+      ]);
+      PROPS_METHODS2 = /* @__PURE__ */ new Set(["update", "__element"]);
+      METHODS2 = /* @__PURE__ */ new Set([
+        "set",
+        "reset",
+        "update",
+        "remove",
+        "updateContent",
+        "removeContent",
+        "lookup",
+        "lookdown",
+        "lookdownAll",
+        "getRef",
+        "getPath",
+        "setNodeStyles",
+        "spotByPath",
+        "keys",
+        "parse",
+        "setProps",
+        "parseDeep",
+        "variables",
+        "if",
+        "log",
+        "verbose",
+        "warn",
+        "error",
+        "call",
+        "nextElement",
+        "previousElement",
+        "getRootState",
+        "getRoot",
+        "getRootData",
+        "getRootContext",
+        "getContext",
+        "getQuery",
+        "getDB",
+        "getChildren"
+      ]);
+      METHODS_EXL2 = /* @__PURE__ */ new Set([
+        "node",
+        "context",
+        "extends",
+        "__element",
+        "__ref",
+        ...METHODS2,
+        ...STATE_METHODS2,
+        ...PROPS_METHODS2
+      ]);
+    }
+  });
+
+  // dist/esm/object.js
+  var exec2;
+  var init_object = __esm({
+    "dist/esm/object.js"() {
+      init_types();
+      exec2 = (param, element, state, context) => {
+        if (isFunction2(param)) {
+          if (!element) return;
+          const result = param.call(
+            element,
+            element,
+            state || element.state,
+            context || element.context
+          );
+          if (result && typeof result.then === "function") {
+            let resolved;
+            result.then((value) => {
+              resolved = value;
+            });
+            return resolved;
+          }
+          return result;
+        }
+        return param;
+      };
+    }
+  });
+
+  // dist/esm/key.js
+  var init_key = __esm({
+    "dist/esm/key.js"() {
+    }
+  });
+
+  // dist/esm/env.js
+  var init_env = __esm({
+    "dist/esm/env.js"() {
+    }
+  });
+
+  // dist/esm/function.js
+  var init_function = __esm({
+    "dist/esm/function.js"() {
+    }
+  });
+
+  // dist/esm/if.js
+  var init_if = __esm({
+    "dist/esm/if.js"() {
+    }
+  });
+
+  // dist/esm/log.js
+  var init_log = __esm({
+    "dist/esm/log.js"() {
+    }
+  });
+
+  // dist/esm/cookie.js
+  var isMobile2;
+  var init_cookie = __esm({
+    "dist/esm/cookie.js"() {
+      isMobile2 = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
+    }
+  });
+
+  // dist/esm/tags.js
+  var init_tags = __esm({
+    "dist/esm/tags.js"() {
+    }
+  });
+
+  // dist/esm/extends.js
+  var init_extends = __esm({
+    "dist/esm/extends.js"() {
+    }
+  });
+
+  // dist/esm/component.js
+  var init_component = __esm({
+    "dist/esm/component.js"() {
+    }
+  });
+
+  // dist/esm/props.js
+  var init_props = __esm({
+    "dist/esm/props.js"() {
+    }
+  });
+
+  // dist/esm/element.js
+  var init_element = __esm({
+    "dist/esm/element.js"() {
+    }
+  });
+
+  // dist/esm/state.js
+  var init_state = __esm({
+    "dist/esm/state.js"() {
+    }
+  });
+
+  // dist/esm/scope.js
+  var init_scope = __esm({
+    "dist/esm/scope.js"() {
+    }
+  });
+
+  // dist/esm/triggerEvent.js
+  var init_triggerEvent = __esm({
+    "dist/esm/triggerEvent.js"() {
+    }
+  });
+
+  // dist/esm/cache.js
+  var init_cache = __esm({
+    "dist/esm/cache.js"() {
+    }
+  });
+
+  // dist/esm/methods.js
+  var init_methods = __esm({
+    "dist/esm/methods.js"() {
+    }
+  });
+
+  // dist/esm/update.js
+  var init_update = __esm({
+    "dist/esm/update.js"() {
+    }
+  });
+
+  // dist/esm/index.js
+  var init_esm = __esm({
+    "dist/esm/index.js"() {
+      init_key();
+      init_env();
+      init_types();
+      init_object();
+      init_function();
+      init_array();
+      init_node();
+      init_if();
+      init_log();
+      init_string();
+      init_globals();
+      init_cookie();
+      init_tags();
+      init_component();
+      init_props();
+      init_extends();
+      init_element();
+      init_state();
+      init_keys();
+      init_scope();
+      init_methods();
+      init_cache();
+      init_update();
+      init_triggerEvent();
+    }
+  });
+
+  // ../../plugins/fetch/adapters/supabase.js
+  var supabase_exports = {};
+  __export(supabase_exports, {
+    setup: () => setup,
+    supabaseAdapter: () => supabaseAdapter
+  });
+  var setup, applyFilters, applyModifiers, supabaseAdapter;
+  var init_supabase = __esm({
+    "../../plugins/fetch/adapters/supabase.js"() {
+      "use strict";
+      setup = async ({ url, key, projectId, createClient, ...options }) => {
+        const supabaseUrl = url || projectId && `https://${projectId}.supabase.co`;
+        if (!supabaseUrl || !key) {
+          throw new Error("@symbo.ls/fetch supabase: url (or projectId) and key are required");
+        }
+        if (!createClient) {
+          const pkg = "@supabase/supabase-js";
+          const mod = await import(
+            /* webpackIgnore: true */
+            pkg
+          );
+          createClient = mod.createClient;
+        }
+        return supabaseAdapter(createClient(supabaseUrl, key, options));
+      };
+      applyFilters = (query, params) => {
+        if (!params) return query;
+        for (const key in params) {
+          const val = params[key];
+          if (val === null) {
+            query = query.is(key, null);
+          } else if (Array.isArray(val)) {
+            query = query.in(key, val);
+          } else if (typeof val === "object") {
+            for (const op in val) {
+              if (op === "gt") query = query.gt(key, val[op]);
+              else if (op === "gte") query = query.gte(key, val[op]);
+              else if (op === "lt") query = query.lt(key, val[op]);
+              else if (op === "lte") query = query.lte(key, val[op]);
+              else if (op === "neq") query = query.neq(key, val[op]);
+              else if (op === "like") query = query.like(key, val[op]);
+              else if (op === "ilike") query = query.ilike(key, val[op]);
+              else if (op === "in") query = query.in(key, val[op]);
+              else if (op === "is") query = query.is(key, val[op]);
+              else if (op === "contains") query = query.contains(key, val[op]);
+              else if (op === "containedBy") query = query.containedBy(key, val[op]);
+              else if (op === "textSearch") query = query.textSearch(key, val[op]);
+            }
+          } else {
+            query = query.eq(key, val);
+          }
+        }
+        return query;
+      };
+      applyModifiers = (query, { limit, offset, order, single } = {}) => {
+        if (order) {
+          if (Array.isArray(order)) {
+            for (const o of order) {
+              const by = typeof o === "string" ? o : o.by;
+              query = query.order(by, { ascending: o.asc !== false });
+            }
+          } else {
+            const orderBy = typeof order === "string" ? order : order.by;
+            query = query.order(orderBy, { ascending: order.asc !== false });
+          }
+        }
+        if (limit) query = query.limit(limit);
+        if (offset) query = query.range(offset, offset + (limit || 20) - 1);
+        if (single) query = query.single();
+        return query;
+      };
+      supabaseAdapter = (client) => ({
+        name: "supabase",
+        client,
+        // Auth
+        getSession: async () => {
+          const { data } = await client.auth.getSession();
+          return data?.session || null;
+        },
+        getUser: async () => {
+          const { data } = await client.auth.getUser();
+          return data?.user || null;
+        },
+        signIn: (credentials) => {
+          if (credentials.provider) {
+            return client.auth.signInWithOAuth({ provider: credentials.provider });
+          }
+          if (credentials.token) {
+            return client.auth.signInWithIdToken(credentials);
+          }
+          return client.auth.signInWithPassword(credentials);
+        },
+        signUp: (credentials) => client.auth.signUp(credentials),
+        signOut: () => client.auth.signOut(),
+        onAuthStateChange: (callback) => {
+          const { data: { subscription } } = client.auth.onAuthStateChange(
+            (event, session) => callback(event, session)
+          );
+          return () => subscription.unsubscribe();
+        },
+        // CRUD
+        select: async ({ from, select, params, ...modifiers }) => {
+          let q = client.from(from).select(select || "*");
+          q = applyFilters(q, params);
+          q = applyModifiers(q, modifiers);
+          return q;
+        },
+        rpc: ({ from, params }) => client.rpc(from, params),
+        insert: ({ from, data, select }) => client.from(from).insert(data).select(select || "*"),
+        update: ({ from, data, params, select }) => {
+          let q = client.from(from).update(data);
+          q = applyFilters(q, params);
+          return q.select(select || "*");
+        },
+        upsert: ({ from, data, select }) => client.from(from).upsert(data).select(select || "*"),
+        delete: ({ from, params }) => {
+          let q = client.from(from).delete();
+          q = applyFilters(q, params);
+          return q;
+        },
+        // Realtime
+        subscribe: ({ from, params, on }, callback) => {
+          const event = on || "*";
+          const channel = client.channel(`db-${from}-${Date.now()}`).on("postgres_changes", {
+            event,
+            schema: "public",
+            table: from,
+            ...params?.id ? { filter: `id=eq.${params.id}` } : {}
+          }, (payload) => callback(payload.new, payload.old, payload)).subscribe();
+          return () => client.removeChannel(channel);
+        },
+        // Storage
+        upload: ({ bucket, path, file, options }) => client.storage.from(bucket).upload(path, file, options),
+        download: ({ bucket, path }) => client.storage.from(bucket).download(path),
+        getPublicUrl: ({ bucket, path }) => client.storage.from(bucket).getPublicUrl(path)
+      });
+    }
+  });
+
+  // ../../plugins/fetch/adapters/rest.js
+  var rest_exports = {};
+  __export(rest_exports, {
+    restAdapter: () => restAdapter,
+    setup: () => setup2
+  });
+  var buildUrl, request, setup2, restAdapter;
+  var init_rest = __esm({
+    "../../plugins/fetch/adapters/rest.js"() {
+      "use strict";
+      buildUrl = (base, from, params) => {
+        const slash = from && !from.startsWith("/") ? "/" : "";
+        const url = new URL(`${base}${slash}${from}`);
+        if (params) {
+          for (const key in params) {
+            const val = params[key];
+            if (val !== void 0 && val !== null) {
+              url.searchParams.set(key, typeof val === "object" ? JSON.stringify(val) : val);
+            }
+          }
+        }
+        return url.toString();
+      };
+      request = async (url, options) => {
+        const res = await globalThis.fetch(url, options);
+        const contentType = res.headers.get("content-type");
+        const data = contentType && contentType.includes("json") ? await res.json() : await res.text();
+        return { data, error: res.ok ? null : data?.message || data?.error || res.statusText, status: res.status };
+      };
+      setup2 = async ({ url, headers, auth, fetchOptions }) => {
+        if (!url) throw new Error("@symbo.ls/fetch rest: url is required");
+        return restAdapter(url, headers, auth, fetchOptions);
+      };
+      restAdapter = (baseUrl, defaultHeaders = {}, authConfig, defaultFetchOptions = {}) => {
+        let token = authConfig?.token || null;
+        const getHeaders = (extra) => {
+          const h = { ...defaultHeaders, ...extra };
+          if (token) h.Authorization = `Bearer ${token}`;
+          return h;
+        };
+        const getJsonHeaders = (extra) => ({ ...getHeaders(extra), "Content-Type": "application/json" });
+        const getFetchOptions = (opts) => ({ ...defaultFetchOptions, ...opts });
+        const resolveUrl = (from, base) => {
+          const b = base || baseUrl;
+          if (from && (from.startsWith("http://") || from.startsWith("https://"))) return from;
+          const slash = from && !from.startsWith("/") ? "/" : "";
+          return `${b}${slash}${from || ""}`;
+        };
+        const adapter = {
+          name: "rest",
+          // Auth
+          setToken: (t) => {
+            token = t;
+          },
+          getSession: async () => {
+            if (!authConfig?.sessionUrl) {
+              return token ? { token } : null;
+            }
+            const result = await request(
+              resolveUrl(authConfig.sessionUrl, authConfig.baseUrl),
+              getFetchOptions({ headers: getHeaders() })
+            );
+            return result.error ? null : result.data;
+          },
+          signIn: async (credentials) => {
+            if (!authConfig?.signInUrl) throw new Error("rest: auth.signInUrl not configured");
+            const result = await request(resolveUrl(authConfig.signInUrl, authConfig.baseUrl), getFetchOptions({
+              method: "POST",
+              headers: getJsonHeaders(),
+              body: JSON.stringify(credentials)
+            }));
+            if (result.data?.token) token = result.data.token;
+            return result;
+          },
+          signOut: async () => {
+            if (authConfig?.signOutUrl) {
+              await request(resolveUrl(authConfig.signOutUrl, authConfig.baseUrl), getFetchOptions({
+                method: "POST",
+                headers: getHeaders()
+              }));
+            }
+            token = null;
+            return { error: null };
+          },
+          // CRUD
+          select: ({ from, params, select, limit, offset, order, single, headers, baseUrl: fromBase }) => {
+            const allParams = { ...params };
+            if (select) allParams.select = select;
+            if (limit) allParams.limit = limit;
+            if (offset) allParams.offset = offset;
+            if (single) allParams.single = true;
+            if (order) {
+              if (typeof order === "string") {
+                allParams.order = order;
+              } else if (Array.isArray(order)) {
+                allParams.order = order.map((o) => `${o.by}:${o.asc === false ? "desc" : "asc"}`).join(",");
+              } else if (order.by) {
+                allParams.order = `${order.by}:${order.asc === false ? "desc" : "asc"}`;
+              }
+            }
+            return request(
+              buildUrl(fromBase || baseUrl, from || "", allParams),
+              getFetchOptions({ headers: getHeaders(headers) })
+            );
+          },
+          rpc: ({ from, params, headers, baseUrl: fromBase }) => request(resolveUrl(`rpc/${from}`, fromBase), getFetchOptions({
+            method: "POST",
+            headers: getJsonHeaders(headers),
+            body: JSON.stringify(params)
+          })),
+          insert: ({ from, data, headers, baseUrl: fromBase }) => request(resolveUrl(from, fromBase), getFetchOptions({
+            method: "POST",
+            headers: getJsonHeaders(headers),
+            body: JSON.stringify(data)
+          })),
+          update: ({ from, data, params, method, headers, baseUrl: fromBase }) => {
+            const id = params?.id || data?.id;
+            const path = id ? `${from}/${id}` : from;
+            return request(resolveUrl(path, fromBase), getFetchOptions({
+              method: method || "PATCH",
+              headers: getJsonHeaders(headers),
+              body: JSON.stringify(data)
+            }));
+          },
+          delete: ({ from, params, headers, baseUrl: fromBase }) => {
+            const id = params?.id;
+            const path = id ? `${from}/${id}` : from;
+            return request(resolveUrl(path, fromBase), getFetchOptions({
+              method: "DELETE",
+              headers: getHeaders(headers)
+            }));
+          }
+        };
+        return adapter;
+      };
+    }
+  });
+
+  // ../../plugins/fetch/adapters/local.js
+  var local_exports = {};
+  __export(local_exports, {
+    localAdapter: () => localAdapter,
+    setup: () => setup3
+  });
+  var matchesParams, applyModifiers2, setup3, localAdapter;
+  var init_local = __esm({
+    "../../plugins/fetch/adapters/local.js"() {
+      "use strict";
+      matchesParams = (item, params) => {
+        if (!params) return true;
+        for (const key in params) {
+          const val = params[key];
+          if (val === null) {
+            if (item[key] !== null && item[key] !== void 0) return false;
+          } else if (Array.isArray(val)) {
+            if (!val.includes(item[key])) return false;
+          } else if (typeof val === "object") {
+            for (const op in val) {
+              if (op === "gt" && !(item[key] > val[op])) return false;
+              if (op === "gte" && !(item[key] >= val[op])) return false;
+              if (op === "lt" && !(item[key] < val[op])) return false;
+              if (op === "lte" && !(item[key] <= val[op])) return false;
+              if (op === "neq" && item[key] === val[op]) return false;
+              if (op === "like" && !String(item[key]).includes(val[op])) return false;
+            }
+          } else if (item[key] !== val) {
+            return false;
+          }
+        }
+        return true;
+      };
+      applyModifiers2 = (items, { order, limit, offset, single }) => {
+        let result = [...items];
+        if (order) {
+          const by = typeof order === "string" ? order : order.by;
+          const asc = order.asc !== false;
+          result.sort((a, b) => {
+            if (a[by] < b[by]) return asc ? -1 : 1;
+            if (a[by] > b[by]) return asc ? 1 : -1;
+            return 0;
+          });
+        }
+        if (offset) result = result.slice(offset);
+        if (limit) result = result.slice(0, limit);
+        if (single) return { data: result[0] || null, error: null };
+        return { data: result, error: null };
+      };
+      setup3 = async ({ data, ...options }) => localAdapter(data, options);
+      localAdapter = (initialData = {}, options = {}) => {
+        const store = {};
+        const listeners = {};
+        const persist = options.persist !== false && typeof localStorage !== "undefined";
+        const prefix = options.prefix || "smbls_db_";
+        const getTable = (name) => {
+          if (!store[name]) {
+            if (persist) {
+              try {
+                const saved = localStorage.getItem(prefix + name);
+                store[name] = saved ? JSON.parse(saved) : initialData[name] || [];
+              } catch {
+                store[name] = initialData[name] || [];
+              }
+            } else {
+              store[name] = initialData[name] || [];
+            }
+          }
+          return store[name];
+        };
+        const save = (name) => {
+          if (persist) {
+            try {
+              localStorage.setItem(prefix + name, JSON.stringify(store[name]));
+            } catch {
+            }
+          }
+        };
+        const notify = (name, event, newItem, oldItem) => {
+          const fns = listeners[name];
+          if (!fns) return;
+          for (const fn of fns) fn(newItem, oldItem, { event, table: name });
+        };
+        let idCounter = Date.now();
+        return {
+          name: "local",
+          store,
+          select: async ({ from, params, ...modifiers }) => {
+            const table = getTable(from);
+            const filtered = table.filter((item) => matchesParams(item, params));
+            return applyModifiers2(filtered, modifiers);
+          },
+          insert: async ({ from, data }) => {
+            const table = getTable(from);
+            const items = Array.isArray(data) ? data : [data];
+            const inserted = items.map((item) => {
+              const row = { id: item.id || ++idCounter, ...item };
+              table.push(row);
+              return row;
+            });
+            save(from);
+            for (const row of inserted) notify(from, "INSERT", row, null);
+            return { data: Array.isArray(data) ? inserted : inserted[0], error: null };
+          },
+          update: async ({ from, data, params }) => {
+            const table = getTable(from);
+            const updated = [];
+            for (let i = 0; i < table.length; i++) {
+              if (matchesParams(table[i], params)) {
+                const old = { ...table[i] };
+                Object.assign(table[i], data);
+                updated.push(table[i]);
+                notify(from, "UPDATE", table[i], old);
+              }
+            }
+            save(from);
+            return { data: updated, error: null };
+          },
+          delete: async ({ from, params }) => {
+            const table = getTable(from);
+            const removed = [];
+            for (let i = table.length - 1; i >= 0; i--) {
+              if (matchesParams(table[i], params)) {
+                removed.push(table[i]);
+                table.splice(i, 1);
+                notify(from, "DELETE", null, removed[removed.length - 1]);
+              }
+            }
+            save(from);
+            return { data: removed, error: null };
+          },
+          subscribe: ({ from, on }, callback) => {
+            if (!listeners[from]) listeners[from] = [];
+            const fn = (newItem, oldItem, payload) => {
+              if (on && on !== "*" && on !== payload.event) return;
+              callback(newItem, oldItem, payload);
+            };
+            listeners[from].push(fn);
+            return () => {
+              const idx = listeners[from].indexOf(fn);
+              if (idx > -1) listeners[from].splice(idx, 1);
+            };
+          }
+        };
+      };
+    }
+  });
+
+  // ../../plugins/fetch/index.js
+  var fetch_exports = {};
+  __export(fetch_exports, {
+    createAdapter: () => createAdapter,
+    default: () => fetch_default,
+    executeFetch: () => executeFetch,
+    initAdapterAuth: () => initAdapterAuth,
+    parseDuration: () => parseDuration,
+    queryClient: () => queryClient,
+    registerAdapter: () => registerAdapter,
+    resolveDb: () => resolveDb
+  });
+  var ADAPTER_METHODS, BUILTIN_ADAPTERS, registerAdapter, createAdapter, resolveDb, parseDuration, cacheStore, querySubscribers, activeQueries, buildCacheKey, getCacheEntry, setCacheEntry, invalidateCache, removeCache, parseCacheConfig, gcTimer, startGC, DEFAULT_RETRY, DEFAULT_RETRY_DELAY, resolveRetryConfig, withRetry, globalListeners, globalListenersAttached, attachGlobalListeners, resolveFetchConfig, resolveParamsSync, resolveParams, initAdapterAuth, resolveAdapter, triggerCallback, collectFormData, updateElementState, setFetchStatus, runFetch, bindEvent, bindAutoRefetch, applyOptimisticUpdate, rollbackOptimistic, runMutation, executeFetch, queryClient, fetch_default;
+  var init_fetch = __esm({
+    "../../plugins/fetch/index.js"() {
+      "use strict";
+      init_esm();
+      ADAPTER_METHODS = ["select", "rpc", "insert", "update", "delete", "subscribe"];
+      BUILTIN_ADAPTERS = {
+        supabase: () => Promise.resolve().then(() => (init_supabase(), supabase_exports)),
+        rest: () => Promise.resolve().then(() => (init_rest(), rest_exports)),
+        local: () => Promise.resolve().then(() => (init_local(), local_exports))
+      };
+      registerAdapter = (name, loader) => {
+        BUILTIN_ADAPTERS[name] = loader;
+      };
+      createAdapter = (config) => {
+        const adapter = {};
+        for (const method of ADAPTER_METHODS) {
+          if (config[method]) adapter[method] = config[method];
+        }
+        adapter.name = config.name || "custom";
+        return adapter;
+      };
+      resolveDb = async (config) => {
+        if (!config) return null;
+        if (typeof config.select === "function") return config;
+        const { adapter, ...options } = config;
+        const name = typeof adapter === "string" ? adapter : typeof config === "string" ? config : null;
+        if (!name) return null;
+        const loader = BUILTIN_ADAPTERS[name];
+        if (!loader) throw new Error(`Unknown db adapter: "${name}". Use registerAdapter() for adapters with optional deps.`);
+        const mod = await loader();
+        return mod.setup(options);
+      };
+      parseDuration = (val) => {
+        if (!val) return 0;
+        if (typeof val === "number") return val;
+        const match = val.match(/^(\d+)(ms|s|m|h)$/);
+        if (!match) return 0;
+        const n = parseInt(match[1]);
+        const unit = match[2];
+        if (unit === "ms") return n;
+        if (unit === "s") return n * 1e3;
+        if (unit === "m") return n * 6e4;
+        if (unit === "h") return n * 36e5;
+        return 0;
+      };
+      cacheStore = /* @__PURE__ */ new Map();
+      querySubscribers = /* @__PURE__ */ new Map();
+      activeQueries = /* @__PURE__ */ new Map();
+      buildCacheKey = (config) => {
+        if (config.cache?.key) return config.cache.key;
+        const params = resolveParamsSync(config.params);
+        return `${config.from}:${config.method}:${JSON.stringify(params || "")}`;
+      };
+      getCacheEntry = (key) => cacheStore.get(key) || null;
+      setCacheEntry = (key, data, error2) => {
+        const existing = cacheStore.get(key);
+        const entry = {
+          data,
+          error: error2,
+          time: Date.now(),
+          stale: false
+        };
+        cacheStore.set(key, entry);
+        const subs = querySubscribers.get(key);
+        if (subs) {
+          for (const sub of subs) {
+            if (isFunction2(sub)) sub(entry);
+          }
+        }
+        return entry;
+      };
+      invalidateCache = (key) => {
+        if (key) {
+          const entry = cacheStore.get(key);
+          if (entry) entry.stale = true;
+          return;
+        }
+        for (const [, entry] of cacheStore) {
+          entry.stale = true;
+        }
+      };
+      removeCache = (key) => {
+        if (key) {
+          cacheStore.delete(key);
+          return;
+        }
+        cacheStore.clear();
+      };
+      parseCacheConfig = (cache2) => {
+        if (!cache2 && cache2 !== false) return { staleTime: 6e4, gcTime: 3e5 };
+        if (cache2 === false) return null;
+        if (cache2 === true) return { staleTime: 6e4, gcTime: 3e5 };
+        if (typeof cache2 === "number") return { staleTime: cache2, gcTime: Math.max(cache2 * 5, 3e5) };
+        if (isString2(cache2)) return { staleTime: parseDuration(cache2), gcTime: 3e5 };
+        return {
+          staleTime: parseDuration(cache2.stale || cache2.staleTime) || 6e4,
+          gcTime: parseDuration(cache2.gc || cache2.gcTime || cache2.expire) || 3e5,
+          key: cache2.key
+        };
+      };
+      gcTimer = null;
+      startGC = () => {
+        if (gcTimer) return;
+        gcTimer = setInterval(() => {
+          const now = Date.now();
+          for (const [key, entry] of cacheStore) {
+            const subs = querySubscribers.get(key);
+            const hasSubscribers = subs && subs.size > 0;
+            if (!hasSubscribers && now - entry.time > (entry.gcTime || 3e5)) {
+              cacheStore.delete(key);
+            }
+          }
+        }, 3e4);
+        if (gcTimer.unref) gcTimer.unref();
+      };
+      startGC();
+      DEFAULT_RETRY = 3;
+      DEFAULT_RETRY_DELAY = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4);
+      resolveRetryConfig = (config) => {
+        const retry = config.retry;
+        if (retry === false) return { count: 0 };
+        if (retry === true || retry === void 0) return { count: DEFAULT_RETRY, delay: DEFAULT_RETRY_DELAY };
+        if (typeof retry === "number") return { count: retry, delay: DEFAULT_RETRY_DELAY };
+        return {
+          count: retry.count ?? DEFAULT_RETRY,
+          delay: isFunction2(retry.delay) ? retry.delay : typeof retry.delay === "number" ? () => retry.delay : DEFAULT_RETRY_DELAY
+        };
+      };
+      withRetry = async (fn, retryConfig) => {
+        const { count, delay } = retryConfig;
+        let lastError;
+        for (let attempt = 0; attempt <= count; attempt++) {
+          try {
+            const result = await fn();
+            if (result?.error) {
+              lastError = result.error;
+              if (attempt < count) {
+                const ms = isFunction2(delay) ? delay(attempt, lastError) : delay;
+                await new Promise((r) => setTimeout(r, ms));
+                continue;
+              }
+              return result;
+            }
+            return result;
+          } catch (e) {
+            lastError = e;
+            if (attempt < count) {
+              const ms = isFunction2(delay) ? delay(attempt, e) : delay;
+              await new Promise((r) => setTimeout(r, ms));
+              continue;
+            }
+            throw e;
+          }
+        }
+        return { data: null, error: lastError };
+      };
+      globalListeners = { focus: /* @__PURE__ */ new Set(), online: /* @__PURE__ */ new Set() };
+      globalListenersAttached = false;
+      attachGlobalListeners = () => {
+        if (globalListenersAttached || typeof window === "undefined") return;
+        globalListenersAttached = true;
+        const onFocus = () => {
+          for (const fn of globalListeners.focus) fn();
+        };
+        const onOnline = () => {
+          for (const fn of globalListeners.online) fn();
+        };
+        window.addEventListener("visibilitychange", () => {
+          if (document.visibilityState === "visible") onFocus();
+        });
+        window.addEventListener("focus", onFocus);
+        window.addEventListener("online", onOnline);
+      };
+      resolveFetchConfig = (fetchProp, element) => {
+        const ref = element.__ref;
+        if (fetchProp === true) {
+          return { from: ref.__state || element.key, method: "select", query: true, on: "create" };
+        }
+        if (isString2(fetchProp)) {
+          return { from: fetchProp, method: "select", query: true, on: "create" };
+        }
+        if (isObject2(fetchProp)) {
+          const config = { ...fetchProp };
+          config.from = config.from || ref.__state || element.key;
+          config.method = config.method || "select";
+          config.on = config.on || "create";
+          if (config.query === void 0) config.query = true;
+          return config;
+        }
+        return null;
+      };
+      resolveParamsSync = (params) => {
+        if (!params || isFunction2(params)) return params;
+        return params;
+      };
+      resolveParams = (params, element) => {
+        if (!params) return void 0;
+        if (isFunction2(params)) return params(element, element.state);
+        const resolved = {};
+        for (const key in params) {
+          const val = params[key];
+          resolved[key] = isFunction2(val) ? val(element, element.state) : val;
+        }
+        return resolved;
+      };
+      initAdapterAuth = async (adapter, context) => {
+        if (adapter.__authInitialized) return;
+        adapter.__authInitialized = true;
+        if (!adapter.getSession) return;
+        const updateAuth = (user, session) => {
+          const root = context.state?.root;
+          if (root?.update) {
+            root.update({ auth: { user, session, loading: false } });
+          }
+        };
+        try {
+          const session = await adapter.getSession();
+          updateAuth(session?.user || null, session);
+        } catch (e) {
+        }
+        if (adapter.onAuthStateChange) {
+          adapter.onAuthStateChange((event, session) => {
+            updateAuth(session?.user || null, session);
+          });
+        }
+      };
+      resolveAdapter = async (db, context) => {
+        if (isFunction2(db.select)) {
+          if (db.auth !== false) await initAdapterAuth(db, context);
+          return db;
+        }
+        if (db.__resolved) {
+          if (db.auth !== false) await initAdapterAuth(db.__resolved, context);
+          return db.__resolved;
+        }
+        if (db.__resolving) return db.__resolving;
+        db.__resolving = resolveDb(db);
+        const resolved = await db.__resolving;
+        db.__resolved = resolved;
+        context.db = resolved;
+        delete db.__resolving;
+        if (db.auth !== false) await initAdapterAuth(resolved, context);
+        return resolved;
+      };
+      triggerCallback = (element, name, ...args) => {
+        const fn = isFunction2(element[name]) ? element[name] : element.props && isFunction2(element.props[name]) ? element.props[name] : null;
+        if (fn) fn.call(element, ...args, element, element.state, element.context);
+      };
+      collectFormData = (element) => {
+        const data = {};
+        const node = element.node;
+        if (!node) return data;
+        if (node.tagName === "FORM") {
+          const formData = new FormData(node);
+          for (const [key, value] of formData.entries()) {
+            data[key] = value;
+          }
+          return data;
+        }
+        const inputs = node.querySelectorAll("input, textarea, select");
+        for (let i = 0; i < inputs.length; i++) {
+          const input = inputs[i];
+          const name = input.name || input.getAttribute("name");
+          if (!name) continue;
+          if (input.type === "checkbox") {
+            data[name] = input.checked;
+          } else if (input.type === "file") {
+            data[name] = input.files;
+          } else {
+            data[name] = input.value;
+          }
+        }
+        return data;
+      };
+      updateElementState = (element, data, stateKey, options = {}) => {
+        const stateData = stateKey ? { [stateKey]: data } : data;
+        if (element.state?.update) {
+          element.state.update(stateData, { preventFetch: true, ...options });
+        }
+      };
+      setFetchStatus = (element, status) => {
+        const ref = element.__ref;
+        ref.__fetchStatus = status;
+        ref.__fetching = status.isFetching;
+        ref.__fetchError = status.error;
+      };
+      runFetch = async (config, element, context, opts = {}) => {
+        const db = context?.db;
+        if (!db) return;
+        if (config.enabled === false) return;
+        if (isFunction2(config.enabled) && !config.enabled(element, element.state)) return;
+        const adapter = await resolveAdapter(db, context);
+        if (!adapter) return;
+        const ref = element.__ref;
+        const {
+          from,
+          method,
+          query,
+          params: rawParams,
+          cache: cacheRaw,
+          transform,
+          single,
+          auth,
+          fields,
+          as: stateKey,
+          limit,
+          offset,
+          order,
+          headers,
+          baseUrl,
+          // Pagination
+          page,
+          cursor,
+          getNextPageParam,
+          getPreviousPageParam,
+          infinite,
+          // TanStack-style options
+          placeholderData,
+          initialData,
+          select: selectTransform,
+          keepPreviousData
+        } = config;
+        let select;
+        if (query && isFunction2(element.getQuery)) {
+          const q = element.getQuery(adapter.name || "paths");
+          if (q) select = q.select || q.length && q.join(",") || void 0;
+        }
+        const params = resolveParams(rawParams, element);
+        const cacheConfig = parseCacheConfig(cacheRaw);
+        const retryConfig = resolveRetryConfig(config);
+        const cacheKey = cacheConfig ? cacheRaw?.key || `${from}:${method}:${JSON.stringify(params || "")}${infinite ? ":infinite" : ""}${page ? ":p" + JSON.stringify(page) : ""}` : null;
+        if (!ref.__fetchInitialized && cacheKey) {
+          ref.__fetchInitialized = true;
+          if (initialData !== void 0) {
+            const initData = isFunction2(initialData) ? initialData() : initialData;
+            setCacheEntry(cacheKey, initData, null);
+          }
+        }
+        if ((method === "select" || method === "rpc") && cacheKey && cacheConfig) {
+          const cached = getCacheEntry(cacheKey);
+          if (cached && !cached.error) {
+            const age = Date.now() - cached.time;
+            const isStale = cached.stale || age > (cacheConfig.staleTime || 0);
+            let data = cached.data;
+            if (selectTransform) data = selectTransform(data, element, element.state);
+            if (transform) data = transform(data, element, element.state);
+            updateElementState(element, data, stateKey);
+            if (!isStale) {
+              setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: true, error: null, status: "success", fetchStatus: "idle" });
+              return;
+            }
+          } else if (placeholderData !== void 0) {
+            const phData = isFunction2(placeholderData) ? placeholderData(element, element.state) : placeholderData;
+            if (phData !== void 0) {
+              updateElementState(element, phData, stateKey);
+            }
+          }
+        }
+        if (cacheKey && activeQueries.has(cacheKey) && !opts.force) {
+          const existing = activeQueries.get(cacheKey);
+          try {
+            const result = await existing;
+            if (result?.data !== void 0) {
+              let finalData = result.data;
+              if (selectTransform) finalData = selectTransform(finalData, element, element.state);
+              if (transform) finalData = transform(finalData, element, element.state);
+              updateElementState(element, finalData, stateKey);
+              triggerCallback(element, "onFetchComplete", finalData);
+            }
+          } catch (e) {
+          }
+          return;
+        }
+        const isFirstLoad = !getCacheEntry(cacheKey)?.data;
+        setFetchStatus(element, {
+          isFetching: true,
+          isLoading: isFirstLoad,
+          isStale: false,
+          isSuccess: false,
+          error: null,
+          status: "pending",
+          fetchStatus: "fetching"
+        });
+        triggerCallback(element, "onFetchStart");
+        const doFetch = async () => {
+          if (auth !== false && adapter.getSession) {
+            const session = await adapter.getSession();
+            if (auth === true && !session) {
+              const err = { message: "Not authenticated" };
+              setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error: err, status: "error", fetchStatus: "idle" });
+              triggerCallback(element, "onFetchError", err);
+              return { data: null, error: err };
+            }
+          }
+          const fn = adapter[method];
+          if (!isFunction2(fn)) return { data: null, error: { message: `Method "${method}" not found on adapter` } };
+          const request2 = { from, select, params, single, limit, offset, order, headers, baseUrl };
+          if (page !== void 0) {
+            if (isObject2(page)) {
+              if (page.offset !== void 0) request2.offset = page.offset;
+              if (page.limit !== void 0) request2.limit = page.limit;
+              if (page.cursor !== void 0) request2.params = { ...request2.params, cursor: page.cursor };
+            } else if (typeof page === "number") {
+              const pageSize = config.pageSize || limit || 20;
+              request2.offset = (page - 1) * pageSize;
+              request2.limit = pageSize;
+            }
+          }
+          if (cursor !== void 0) {
+            request2.params = { ...request2.params, cursor };
+          }
+          if (method === "insert" || method === "update" || method === "upsert") {
+            let data;
+            if (fields === true || config.on === "submit") {
+              data = collectFormData(element);
+            } else if (isArray2(fields)) {
+              const formData = collectFormData(element);
+              data = {};
+              for (const f of fields) data[f] = formData[f];
+            } else if (element.state?.parse) {
+              data = element.state.parse();
+            } else if (isObject2(element.state)) {
+              data = { ...element.state };
+            }
+            if (transform) data = transform(data, element, element.state);
+            request2.data = data;
+          }
+          if (method === "rpc") {
+            let rpcParams = params;
+            if (config.on === "submit") {
+              const formData = collectFormData(element);
+              rpcParams = config.transformParams ? config.transformParams(formData, element, element.state) : formData;
+            }
+            request2.params = rpcParams;
+          }
+          if (method === "subscribe") {
+            const unsubscribe = adapter.subscribe(
+              { from, params, on: config.subscribeOn },
+              (newData, oldData, payload) => {
+                updateElementState(element, newData, stateKey);
+                triggerCallback(element, "onFetchComplete", newData);
+              }
+            );
+            ref.__unsubscribe = unsubscribe;
+            return { data: null, error: null, subscribed: true };
+          }
+          return fn(request2);
+        };
+        const fetchPromise = withRetry(doFetch, retryConfig);
+        if (cacheKey) activeQueries.set(cacheKey, fetchPromise);
+        try {
+          const result = await fetchPromise;
+          if (result?.subscribed) return;
+          const { data, error: error2 } = result || {};
+          if (error2) {
+            if (cacheKey) setCacheEntry(cacheKey, null, error2);
+            setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error: error2, status: "error", fetchStatus: "idle" });
+            triggerCallback(element, "onFetchError", error2);
+            return;
+          }
+          if (data !== void 0) {
+            if ((method === "select" || method === "rpc") && cacheKey) {
+              const entry = setCacheEntry(cacheKey, data, null);
+              entry.gcTime = cacheConfig?.gcTime || 3e5;
+            }
+            let finalData = data;
+            if (infinite && isArray2(data)) {
+              if (!ref.__pages) ref.__pages = [];
+              if (opts.direction === "previous") {
+                ref.__pages.unshift(data);
+              } else {
+                ref.__pages.push(data);
+              }
+              finalData = ref.__pages.flat();
+              if (getNextPageParam) {
+                ref.__nextPageParam = getNextPageParam(data, ref.__pages);
+                ref.__hasNextPage = ref.__nextPageParam != null;
+              }
+              if (getPreviousPageParam) {
+                ref.__prevPageParam = getPreviousPageParam(data, ref.__pages);
+                ref.__hasPreviousPage = ref.__prevPageParam != null;
+              }
+            }
+            if (selectTransform) finalData = selectTransform(finalData, element, element.state);
+            if (transform) finalData = transform(finalData, element, element.state);
+            if (!keepPreviousData || finalData !== void 0) {
+              updateElementState(element, finalData, stateKey);
+            }
+            setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: true, error: null, status: "success", fetchStatus: "idle" });
+            triggerCallback(element, "onFetchComplete", finalData);
+          }
+        } catch (e) {
+          setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error: e, status: "error", fetchStatus: "idle" });
+          triggerCallback(element, "onFetchError", e);
+        } finally {
+          if (cacheKey) activeQueries.delete(cacheKey);
+        }
+      };
+      bindEvent = (config, element, context) => {
+        const on = config.on;
+        const ref = element.__ref;
+        if (!ref.__fetchListeners) ref.__fetchListeners = [];
+        const runner = config.__runner || runFetch;
+        if (on === "submit") {
+          const handler = (e) => {
+            e.preventDefault();
+            runner(config, element, context);
+          };
+          const node = element.node;
+          if (node) {
+            node.addEventListener("submit", handler);
+            ref.__fetchListeners.push(() => node.removeEventListener("submit", handler));
+          }
+        } else if (on === "click") {
+          const handler = () => runner(config, element, context);
+          const node = element.node;
+          if (node) {
+            node.addEventListener("click", handler);
+            ref.__fetchListeners.push(() => node.removeEventListener("click", handler));
+          }
+        } else if (on === "stateChange") {
+          ref.__fetchOnStateChange = () => runner(config, element, context);
+        }
+      };
+      bindAutoRefetch = (config, element, context) => {
+        const ref = element.__ref;
+        if (!ref.__fetchCleanups) ref.__fetchCleanups = [];
+        attachGlobalListeners();
+        const interval = config.refetchInterval;
+        if (interval) {
+          const ms = typeof interval === "number" ? interval : parseDuration(interval);
+          if (ms > 0) {
+            const timer = setInterval(() => {
+              if (config.refetchIntervalInBackground || typeof document === "undefined" || document.visibilityState === "visible") {
+                runFetch(config, element, context, { force: true });
+              }
+            }, ms);
+            ref.__fetchCleanups.push(() => clearInterval(timer));
+          }
+        }
+        if (config.refetchOnWindowFocus !== false) {
+          const onFocus = () => {
+            const cacheKey = buildCacheKey(config);
+            const entry = getCacheEntry(cacheKey);
+            const cacheConfig = parseCacheConfig(config.cache);
+            if (!entry || entry.stale || Date.now() - entry.time > (cacheConfig?.staleTime || 0)) {
+              runFetch(config, element, context, { force: true });
+            }
+          };
+          globalListeners.focus.add(onFocus);
+          ref.__fetchCleanups.push(() => globalListeners.focus.delete(onFocus));
+        }
+        if (config.refetchOnReconnect !== false) {
+          const onOnline = () => runFetch(config, element, context, { force: true });
+          globalListeners.online.add(onOnline);
+          ref.__fetchCleanups.push(() => globalListeners.online.delete(onOnline));
+        }
+      };
+      applyOptimisticUpdate = (element, config, mutationData) => {
+        if (!config.optimistic) return null;
+        const ref = element.__ref;
+        const stateKey = config.as;
+        const snapshot2 = element.state?.parse ? element.state.parse() : isObject2(element.state) ? { ...element.state } : element.state;
+        ref.__optimisticSnapshot = snapshot2;
+        const optimisticData = isFunction2(config.optimistic) ? config.optimistic(mutationData, snapshot2, element) : config.optimistic;
+        if (optimisticData !== void 0) {
+          updateElementState(element, optimisticData, stateKey);
+        }
+        return snapshot2;
+      };
+      rollbackOptimistic = (element, config) => {
+        const ref = element.__ref;
+        const snapshot2 = ref.__optimisticSnapshot;
+        if (snapshot2 !== void 0) {
+          updateElementState(element, snapshot2, config.as);
+          delete ref.__optimisticSnapshot;
+        }
+      };
+      runMutation = async (config, element, context) => {
+        const db = context?.db;
+        if (!db) return;
+        const adapter = await resolveAdapter(db, context);
+        if (!adapter) return;
+        const ref = element.__ref;
+        const { method, from, fields, transform, as: stateKey, on: trigger, auth, headers, baseUrl, invalidates, optimistic, onMutate, onSuccess, onError, onSettled } = config;
+        let mutationData;
+        if (fields === true || trigger === "submit") {
+          mutationData = collectFormData(element);
+        } else if (isArray2(fields)) {
+          const formData = collectFormData(element);
+          mutationData = {};
+          for (const f of fields) mutationData[f] = formData[f];
+        } else if (element.state?.parse) {
+          mutationData = element.state.parse();
+        } else if (isObject2(element.state)) {
+          mutationData = { ...element.state };
+        }
+        if (transform) mutationData = transform(mutationData, element, element.state);
+        if (isFunction2(onMutate)) onMutate(mutationData, element, element.state);
+        const snapshot2 = optimistic ? applyOptimisticUpdate(element, config, mutationData) : null;
+        ref.__fetching = true;
+        setFetchStatus(element, { isFetching: true, isLoading: false, isStale: false, isSuccess: false, error: null, status: "pending", fetchStatus: "fetching" });
+        triggerCallback(element, "onFetchStart");
+        try {
+          if (auth !== false && adapter.getSession) {
+            const session = await adapter.getSession();
+            if (auth === true && !session) {
+              if (snapshot2 !== void 0) rollbackOptimistic(element, config);
+              const err = { message: "Not authenticated" };
+              triggerCallback(element, "onFetchError", err);
+              return;
+            }
+          }
+          const fn = adapter[method];
+          if (!isFunction2(fn)) return;
+          const request2 = { from, data: mutationData, headers, baseUrl };
+          if (config.params) request2.params = resolveParams(config.params, element);
+          const retryConfig = resolveRetryConfig(config);
+          const result = await withRetry(() => fn(request2), retryConfig);
+          const { data, error: error2 } = result || {};
+          if (error2) {
+            if (snapshot2 !== void 0) rollbackOptimistic(element, config);
+            setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error: error2, status: "error", fetchStatus: "idle" });
+            triggerCallback(element, "onFetchError", error2);
+            if (isFunction2(onError)) onError(error2, mutationData, element);
+            if (isFunction2(onSettled)) onSettled(null, error2, mutationData, element);
+            return;
+          }
+          delete ref.__optimisticSnapshot;
+          if (data !== void 0) {
+            const finalData = stateKey ? { [stateKey]: data } : data;
+            if (element.state?.update) element.state.update(finalData, { preventFetch: true });
+          }
+          setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: true, error: null, status: "success", fetchStatus: "idle" });
+          triggerCallback(element, "onFetchComplete", data);
+          if (isFunction2(onSuccess)) onSuccess(data, mutationData, element);
+          if (isFunction2(onSettled)) onSettled(data, null, mutationData, element);
+          if (invalidates) {
+            const keys2 = isArray2(invalidates) ? invalidates : [invalidates];
+            for (const k of keys2) {
+              if (k === true || k === "*") {
+                for (const [ck] of cacheStore) {
+                  if (ck.startsWith(from + ":")) invalidateCache(ck);
+                }
+              } else {
+                invalidateCache(k);
+              }
+            }
+          }
+        } catch (e) {
+          if (snapshot2 !== void 0) rollbackOptimistic(element, config);
+          setFetchStatus(element, { isFetching: false, isLoading: false, isStale: false, isSuccess: false, error: e, status: "error", fetchStatus: "idle" });
+          triggerCallback(element, "onFetchError", e);
+          if (isFunction2(onError)) onError(e, mutationData, element);
+          if (isFunction2(onSettled)) onSettled(null, e, mutationData, element);
+        } finally {
+          ref.__fetching = false;
+        }
+      };
+      executeFetch = (param, element, state, context) => {
+        if (!param) return;
+        const db = context?.db;
+        if (!db) return;
+        const fetchProp = exec2(param, element);
+        if (!fetchProp) return;
+        const configs = isArray2(fetchProp) ? fetchProp.map((c) => resolveFetchConfig(exec2(c, element), element)).filter(Boolean) : [resolveFetchConfig(fetchProp, element)].filter(Boolean);
+        for (const config of configs) {
+          const isMutation = config.method === "insert" || config.method === "update" || config.method === "upsert" || config.method === "delete";
+          const runner = isMutation ? runMutation : runFetch;
+          if (config.on === "create") {
+            runner(config, element, context);
+          } else {
+            Promise.resolve().then(() => {
+              bindEvent({ ...config, __runner: runner }, element, context);
+            });
+          }
+          if (!isMutation && config.on === "create") {
+            if (config.refetchInterval || config.refetchOnWindowFocus !== false || config.refetchOnReconnect !== false) {
+              bindAutoRefetch(config, element, context);
+            }
+          }
+        }
+        const ref = element.__ref;
+        ref.refetch = (opts) => {
+          for (const config of configs) {
+            runFetch(config, element, context, { force: true, ...opts });
+          }
+        };
+        ref.fetchNextPage = () => {
+          const config = configs[0];
+          if (!config || !config.infinite) return;
+          const nextParam = ref.__nextPageParam;
+          if (nextParam == null) return;
+          const nextConfig = { ...config, cursor: nextParam };
+          runFetch(nextConfig, element, context, { direction: "next", force: true });
+        };
+        ref.fetchPreviousPage = () => {
+          const config = configs[0];
+          if (!config || !config.infinite) return;
+          const prevParam = ref.__prevPageParam;
+          if (prevParam == null) return;
+          const prevConfig = { ...config, cursor: prevParam };
+          runFetch(prevConfig, element, context, { direction: "previous", force: true });
+        };
+      };
+      queryClient = {
+        invalidateQueries: (keyOrPattern) => {
+          if (!keyOrPattern) {
+            invalidateCache();
+            return;
+          }
+          if (isString2(keyOrPattern)) {
+            for (const [key] of cacheStore) {
+              if (key.startsWith(keyOrPattern) || key.includes(keyOrPattern)) {
+                invalidateCache(key);
+              }
+            }
+          } else if (isArray2(keyOrPattern)) {
+            const pattern = keyOrPattern.join(":");
+            for (const [key] of cacheStore) {
+              if (key.includes(pattern)) invalidateCache(key);
+            }
+          }
+        },
+        removeQueries: (keyOrPattern) => {
+          if (!keyOrPattern) {
+            removeCache();
+            return;
+          }
+          if (isString2(keyOrPattern)) {
+            for (const [key] of cacheStore) {
+              if (key.startsWith(keyOrPattern) || key.includes(keyOrPattern)) {
+                removeCache(key);
+              }
+            }
+          }
+        },
+        getQueryData: (key) => {
+          const entry = getCacheEntry(key);
+          return entry?.data ?? void 0;
+        },
+        setQueryData: (key, updater) => {
+          const existing = getCacheEntry(key);
+          const data = isFunction2(updater) ? updater(existing?.data) : updater;
+          setCacheEntry(key, data, null);
+        },
+        prefetchQuery: async (config, context) => {
+          const db = context?.db;
+          if (!db) return;
+          const adapter = await resolveAdapter(db, context);
+          if (!adapter) return;
+          const cacheKey = config.cache?.key || `${config.from}:${config.method || "select"}:${JSON.stringify(config.params || "")}`;
+          const fn = adapter[config.method || "select"];
+          if (!isFunction2(fn)) return;
+          const result = await fn({
+            from: config.from,
+            params: config.params,
+            limit: config.limit,
+            offset: config.offset,
+            order: config.order,
+            single: config.single
+          });
+          if (result?.data !== void 0 && !result?.error) {
+            const entry = setCacheEntry(cacheKey, result.data, null);
+            entry.gcTime = parseCacheConfig(config.cache)?.gcTime || 3e5;
+          }
+          return result;
+        },
+        getCache: () => cacheStore,
+        clear: () => removeCache()
+      };
+      fetch_default = executeFetch;
+    }
+  });
+
   // index.js
   var index_exports = {};
   __export(index_exports, {
@@ -116,6 +1623,7 @@ var DomqlUtils = (() => {
     getChildren: () => getChildren,
     getContext: () => getContext,
     getCookie: () => getCookie,
+    getDB: () => getDB,
     getExtendsInElement: () => getExtendsInElement,
     getExtendsStack: () => getExtendsStack,
     getExtendsStackRegistry: () => getExtendsStackRegistry,
@@ -126,6 +1634,7 @@ var DomqlUtils = (() => {
     getNev: () => getNev,
     getParentStateInKey: () => getParentStateInKey,
     getPath: () => getPath,
+    getQuery: () => getQuery,
     getRef: () => getRef,
     getRoot: () => getRoot,
     getRootContext: () => getRootContext,
@@ -584,6 +2093,7 @@ var DomqlUtils = (() => {
     "node",
     "variables",
     "on",
+    "fetch",
     "component",
     "context"
   ]);
@@ -682,6 +2192,8 @@ var DomqlUtils = (() => {
     "getRootData",
     "getRootContext",
     "getContext",
+    "getQuery",
+    "getDB",
     "getChildren"
   ]);
   var METHODS_EXL = /* @__PURE__ */ new Set([
@@ -709,7 +2221,9 @@ var DomqlUtils = (() => {
     "create",
     "complete",
     "frame",
-    "update"
+    "update",
+    "fetchError",
+    "fetchComplete"
   ]);
 
   // object.js
@@ -2345,10 +3859,7 @@ var DomqlUtils = (() => {
   var checkForStateTypes = (element) => {
     const { state: orig, props, __ref: ref } = element;
     const state = props?.state || orig;
-    if (isFunction(state)) {
-      ref.__state = state;
-      return exec(state, element);
-    } else if (is(state)("string", "number")) {
+    if (is(state)("string", "number")) {
       ref.__state = state;
       return { value: state };
     } else if (state === true) {
@@ -2451,7 +3962,7 @@ var DomqlUtils = (() => {
   };
   var applyDependentState = (element, state) => {
     const { __element } = state;
-    const origState = exec(__element?.state, element);
+    const origState = __element?.state;
     if (!origState) return;
     const dependentState = deepClone(origState, STATE_METHODS);
     const newDepends = { [element.key]: dependentState };
@@ -2569,6 +4080,10 @@ var DomqlUtils = (() => {
     }
   };
 
+  // cache.js
+  var cache = {};
+  var OPTIONS = {};
+
   // methods.js
   var ENV5 = process.env.NODE_ENV;
   function spotByPath(path) {
@@ -2614,8 +4129,8 @@ var DomqlUtils = (() => {
       const childElem = el[v];
       if (v === param) return childElem;
       else if (isFunction(param)) {
-        const exec2 = param(childElem, childElem.state, childElem.context);
-        if (childElem.state && exec2) {
+        const exec3 = param(childElem, childElem.state, childElem.context);
+        if (childElem.state && exec3) {
           return childElem;
         }
       }
@@ -2633,8 +4148,8 @@ var DomqlUtils = (() => {
       const childElem = el[v];
       if (v === param) results.push(childElem);
       else if (isFunction(param)) {
-        const exec2 = param(childElem, childElem.state, childElem.context);
-        if (childElem.state && exec2) results.push(childElem);
+        const exec3 = param(childElem, childElem.state, childElem.context);
+        if (childElem.state && exec3) results.push(childElem);
       }
       childElem?.lookdownAll?.(param, results);
     }
@@ -2883,14 +4398,223 @@ var DomqlUtils = (() => {
       if (context?.strictMode) throw err;
     }
   }
+  async function getDB() {
+    const element = this;
+    const db = element.context?.db;
+    if (!db) return null;
+    if (typeof db.select === "function") {
+      if (!db.__authInitialized && db.getSession) {
+        const { initAdapterAuth: initAdapterAuth2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+        await initAdapterAuth2(db, element.context);
+      }
+      return db;
+    }
+    if (db.__resolved) {
+      if (!db.__resolved.__authInitialized && db.__resolved.getSession) {
+        const { initAdapterAuth: initAdapterAuth2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+        await initAdapterAuth2(db.__resolved, element.context);
+      }
+      return db.__resolved;
+    }
+    if (db.__resolving) return db.__resolving;
+    const resolvePromise = Promise.resolve().then(() => (init_fetch(), fetch_exports)).then(({ resolveDb: resolveDb2 }) => resolveDb2(db));
+    db.__resolving = resolvePromise;
+    const resolved = await resolvePromise;
+    db.__resolved = resolved;
+    element.context.db = resolved;
+    delete db.__resolving;
+    if (resolved.getSession) {
+      const { initAdapterAuth: initAdapterAuth2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
+      await initAdapterAuth2(resolved, element.context);
+    }
+    return resolved;
+  }
+  function getQuery(format) {
+    const element = this;
+    const useStateQuery = format || OPTIONS.useStateQuery || element.context?.useStateQuery;
+    if (!useStateQuery) return null;
+    const query = {};
+    buildQueryFromElement(element, query);
+    if (useStateQuery === true) return query;
+    const formatter = QUERY_FORMATTERS[useStateQuery];
+    return formatter ? formatter(query) : query;
+  }
+  var buildQueryFromElement = (element, query) => {
+    const ref = element.__ref;
+    if (!ref) return;
+    const stateKey = ref.__state;
+    if (stateKey && typeof stateKey === "string") {
+      setQueryPath(query, stateKey);
+    }
+    const children = ref.__children;
+    if (children) {
+      for (let i = 0; i < children.length; i++) {
+        const child = element[children[i]];
+        if (child && child.__ref) {
+          buildQueryFromElement(child, query);
+        }
+      }
+    }
+    const contentKey = ref.contentElementKey || "content";
+    const content = element[contentKey];
+    if (content && content.__ref) {
+      buildQueryFromElement(content, query);
+    }
+  };
+  var setQueryPath = (query, path) => {
+    const clean = path.replaceAll("../", "").replaceAll("~/", "");
+    const parts = clean.split("/");
+    let current = query;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (i === parts.length - 1) {
+        if (!current[part]) current[part] = true;
+      } else {
+        if (current[part] === true) current[part] = {};
+        if (!current[part]) current[part] = {};
+        current = current[part];
+      }
+    }
+  };
+  var queryToGraphQL = (query, indent = 0) => {
+    const pad = "  ".repeat(indent);
+    const entries = Object.entries(query);
+    if (!entries.length) return "";
+    const fields = entries.map(([key, value]) => {
+      if (value === true) return `${pad}${key}`;
+      return `${pad}${key} {
+${queryToGraphQL(value, indent + 1)}
+${pad}}`;
+    });
+    return fields.join("\n");
+  };
+  var formatGraphQL = (query) => {
+    return `{
+${queryToGraphQL(query, 1)}
+}`;
+  };
+  var formatJsonApi = (query) => {
+    const result = { fields: {}, include: [] };
+    const walk = (obj, prefix) => {
+      const fields = [];
+      for (const key in obj) {
+        if (obj[key] === true) {
+          fields.push(key);
+        } else {
+          const nested = prefix ? `${prefix}.${key}` : key;
+          result.include.push(nested);
+          walk(obj[key], nested);
+        }
+      }
+      if (fields.length) {
+        result.fields[prefix || "_root"] = fields;
+      }
+    };
+    walk(query, "");
+    return result;
+  };
+  var formatOData = (query) => {
+    const build = (obj) => {
+      const select2 = [];
+      const expand2 = [];
+      for (const key in obj) {
+        if (obj[key] === true) {
+          select2.push(key);
+        } else {
+          const nested = build(obj[key]);
+          const parts2 = [];
+          if (nested.select) parts2.push(`$select=${nested.select}`);
+          if (nested.expand) parts2.push(`$expand=${nested.expand}`);
+          expand2.push(parts2.length ? `${key}(${parts2.join(";")})` : key);
+        }
+      }
+      return {
+        select: select2.length ? select2.join(",") : "",
+        expand: expand2.length ? expand2.join(",") : ""
+      };
+    };
+    const { select, expand } = build(query);
+    const parts = [];
+    if (select) parts.push(`$select=${select}`);
+    if (expand) parts.push(`$expand=${expand}`);
+    return parts.join("&");
+  };
+  var formatSQL = (query, options) => {
+    const columns = [];
+    const joins = [];
+    const tables = /* @__PURE__ */ new Set();
+    const walk = (obj, table, parentTable) => {
+      tables.add(table);
+      if (parentTable) {
+        joins.push(
+          `LEFT JOIN ${table} ON ${table}.${parentTable}_id = ${parentTable}.id`
+        );
+      }
+      for (const key in obj) {
+        if (obj[key] === true) {
+          columns.push(`${table}.${key}`);
+        } else {
+          walk(obj[key], key, table);
+        }
+      }
+    };
+    const roots = Object.keys(query);
+    if (roots.length === 1 && query[roots[0]] !== true) {
+      walk(query[roots[0]], roots[0], null);
+    } else {
+      walk(query, "_root", null);
+    }
+    const from = [...tables][0] || "_root";
+    const select = columns.length ? columns.join(", ") : "*";
+    const joinStr = joins.length ? "\n" + joins.join("\n") : "";
+    return `SELECT ${select}
+FROM ${from}${joinStr}`;
+  };
+  var formatPaths = (query) => {
+    const paths = [];
+    const walk = (obj, prefix) => {
+      for (const key in obj) {
+        const path = prefix ? `${prefix}/${key}` : key;
+        if (obj[key] === true) {
+          paths.push(path);
+        } else {
+          walk(obj[key], path);
+        }
+      }
+    };
+    walk(query, "");
+    return paths;
+  };
+  var formatSupabase = (query) => {
+    const build = (obj) => {
+      const parts = [];
+      for (const key in obj) {
+        if (obj[key] === true) {
+          parts.push(key);
+        } else {
+          parts.push(`${key}(${build(obj[key])})`);
+        }
+      }
+      return parts.join(", ");
+    };
+    const roots = Object.keys(query);
+    if (roots.length === 1 && query[roots[0]] !== true) {
+      return { from: roots[0], select: build(query[roots[0]]) };
+    }
+    return { from: null, select: build(query) };
+  };
+  var QUERY_FORMATTERS = {
+    graphql: formatGraphQL,
+    "json-api": formatJsonApi,
+    odata: formatOData,
+    sql: formatSQL,
+    supabase: formatSupabase,
+    paths: formatPaths
+  };
   function isMethod(param, element) {
     return Boolean(METHODS.has(param) || element?.context?.methods?.[param]);
   }
 
-  // cache.js
-  var cache = {};
-  var OPTIONS = {};
-
   // update.js
   var snapshot = {
     snapshotId: createSnapshotId