@pol-studios/db 1.0.31 → 1.0.34

package/dist/chunk-O7SETNGD.js

@@ -1,3391 +0,0 @@
-import {
-  normalizeFilter
-} from "./chunk-H3LNH2NT.js";
-import {
-  OperationLog
-} from "./chunk-7SCJNYTE.js";
-import {
-  useDbQuery
-} from "./chunk-WX4ABYIF.js";
-import {
-  useDbUpsert
-} from "./chunk-VGEMLNNM.js";
-import {
-  getSupabaseUrl
-} from "./chunk-GC3TBUWE.js";
-import {
-  PostgrestParser
-} from "./chunk-TKWR5AAY.js";
-import {
-  chunkArray,
-  diff,
-  getObjectChanges,
-  isNullOrWhitespace,
-  isUsable,
-  newUuid,
-  omit,
-  require_moment
-} from "./chunk-OQ7U6EQ3.js";
-import {
-  buildNormalizedQuery,
-  encode,
-  normalizeResponse,
-  useDeleteItem,
-  useDeleteManyMutation,
-  useQueriesForTableLoader,
-  useQuery,
-  useUpsertItem
-} from "./chunk-H6365JPC.js";
-import {
-  UserSessionId,
-  useSupabase
-} from "./chunk-5EFDS7SR.js";
-import {
-  __require,
-  __toESM
-} from "./chunk-P4UZ7IXC.js";
-
-// src/useMutationSuccess.ts
-import { c as _c } from "react/compiler-runtime";
-import { useEffect, useRef } from "react";
-function useMutationSuccess(mutation, t0) {
-  const $ = _c(10);
-  let t1;
-  if ($[0] !== t0) {
-    t1 = t0 === void 0 ? {} : t0;
-    $[0] = t0;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const options = t1;
-  const {
-    successMessage,
-    entityName,
-    enabled: t2,
-    onSuccess
-  } = options;
-  const enabled = t2 === void 0 ? true : t2;
-  const previousSuccessRef = useRef(false);
-  const previousDataRef = useRef(void 0);
-  let t3;
-  let t4;
-  if ($[2] !== enabled || $[3] !== entityName || $[4] !== mutation.data || $[5] !== mutation.isSuccess || $[6] !== onSuccess || $[7] !== successMessage) {
-    t3 = () => {
-      if (!enabled) {
-        return;
-      }
-      const isSuccess = mutation.isSuccess;
-      const hasNewData = mutation.data !== previousDataRef.current;
-      if (isSuccess && hasNewData && !previousSuccessRef.current) {
-        const message = successMessage || getDefaultSuccessMessage(entityName);
-        if (typeof window !== "undefined") {
-          try {
-            const {
-              toast
-            } = __require("@pol-studios/hooks");
-            toast.toast({
-              title: "Success",
-              description: message
-            });
-          } catch {
-          }
-        } else {
-          try {
-            const {
-              Toast
-            } = __require("toastify-react-native");
-            Toast.success(message);
-          } catch {
-          }
-        }
-        onSuccess?.();
-      }
-      previousSuccessRef.current = isSuccess;
-      previousDataRef.current = mutation.data;
-    };
-    t4 = [mutation.isSuccess, mutation.data, enabled, successMessage, entityName, onSuccess];
-    $[2] = enabled;
-    $[3] = entityName;
-    $[4] = mutation.data;
-    $[5] = mutation.isSuccess;
-    $[6] = onSuccess;
-    $[7] = successMessage;
-    $[8] = t3;
-    $[9] = t4;
-  } else {
-    t3 = $[8];
-    t4 = $[9];
-  }
-  useEffect(t3, t4);
-  return mutation;
-}
-function getDefaultSuccessMessage(entityName) {
-  if (!entityName) {
-    return "Saved successfully";
-  }
-  return `${entityName} saved successfully`;
-}
-function useMutationSuccessRN(mutation, t0) {
-  const $ = _c(2);
-  let t1;
-  if ($[0] !== t0) {
-    t1 = t0 === void 0 ? {} : t0;
-    $[0] = t0;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const options = t1;
-  return useMutationSuccess(mutation, options);
-}
-
-// src/adapters/types.ts
-var ADAPTER_STRATEGIES = {
-  POWERSYNC: "powersync",
-  SUPABASE: "supabase",
-  CACHED: "cached",
-  HYBRID: "hybrid",
-  AUTO: "auto"
-};
-
-// src/adapters/auto-detector.ts
-var BackendStatus = /* @__PURE__ */ ((BackendStatus2) => {
-  BackendStatus2["AVAILABLE"] = "available";
-  BackendStatus2["INITIALIZING"] = "initializing";
-  BackendStatus2["UNAVAILABLE"] = "unavailable";
-  return BackendStatus2;
-})(BackendStatus || {});
-var AdapterAutoDetector = class {
-  constructor(powerSyncDb, supabase, options = {}) {
-    this.powerSyncDb = powerSyncDb;
-    this.supabase = supabase;
-    this.options = {
-      preferPowerSync: options.preferPowerSync ?? true,
-      statusCheckTimeout: options.statusCheckTimeout ?? 1e3,
-      useOnlineUntilSynced: options.useOnlineUntilSynced ?? true
-    };
-  }
-  options;
-  listeners = /* @__PURE__ */ new Set();
-  lastResult = null;
-  syncStatus = null;
-  /**
-   * Update the sync status from PowerSync.
-   * Called when sync status changes to re-evaluate backend recommendation.
-   *
-   * @param status - Current sync status or null if not available
-   */
-  updateSyncStatus(status) {
-    const hadSynced = this.syncStatus?.hasSynced;
-    const hasSyncedNow = status?.hasSynced;
-    const changed = hadSynced !== hasSyncedNow;
-    this.syncStatus = status;
-    if (changed) {
-      this.detect();
-    }
-  }
-  /**
-   * Get current sync status.
-   * @returns Current sync status or null
-   */
-  getSyncStatus() {
-    return this.syncStatus;
-  }
-  // ===========================================================================
-  // Main Detection Methods
-  // ===========================================================================
-  /**
-   * Detect backend availability and recommend best option.
-   *
-   * The detection logic follows this priority:
-   * 1. If preferPowerSync is true and PowerSync is available, use PowerSync
-   * 2. If PowerSync is initializing and online with Supabase available, use Supabase temporarily
-   * 3. If online with Supabase available, use Supabase
-   * 4. If offline but PowerSync available, use PowerSync (offline mode)
-   * 5. If offline and PowerSync exists (even if initializing), use PowerSync local data
-   * 6. Default to Supabase as fallback
-   *
-   * @returns Detection result with recommendation and reasoning
-   */
-  detect() {
-    const powerSyncStatus = this.detectPowerSyncStatus();
-    const supabaseStatus = this.detectSupabaseStatus();
-    const isOnline = this.checkOnlineStatus();
-    let recommendedBackend;
-    let reason;
-    if (this.options.preferPowerSync && powerSyncStatus === "available" /* AVAILABLE */) {
-      recommendedBackend = "powersync";
-      reason = "PowerSync is available and preferred for offline-first experience";
-    } else if (powerSyncStatus === "initializing" /* INITIALIZING */ && isOnline && supabaseStatus === "available" /* AVAILABLE */) {
-      recommendedBackend = "supabase";
-      reason = "PowerSync initial sync in progress; using Supabase for fresh data";
-    } else if (supabaseStatus === "available" /* AVAILABLE */ && isOnline) {
-      recommendedBackend = "supabase";
-      reason = "Using Supabase direct connection";
-    } else if (powerSyncStatus === "available" /* AVAILABLE */) {
-      recommendedBackend = "powersync";
-      reason = "Offline mode using PowerSync local data";
-    } else if (!isOnline && this.powerSyncDb) {
-      recommendedBackend = "powersync";
-      reason = "Offline mode - using PowerSync local data (initial sync may be incomplete)";
-    } else {
-      recommendedBackend = "supabase";
-      reason = "No confirmed available backend; defaulting to Supabase";
-    }
-    const result = {
-      powerSyncStatus,
-      supabaseStatus,
-      recommendedBackend,
-      isOnline,
-      reason
-    };
-    if (this.hasResultChanged(result)) {
-      this.lastResult = result;
-      this.notifyListeners(result);
-    }
-    return result;
-  }
-  /**
-   * Check if PowerSync is available.
-   *
-   * PowerSync status depends on:
-   * 1. Database instance exists
-   * 2. If useOnlineUntilSynced is true, also checks if initial sync completed
-   *
-   * @returns PowerSync backend status
-   */
-  detectPowerSyncStatus() {
-    if (!this.powerSyncDb) {
-      return "unavailable" /* UNAVAILABLE */;
-    }
-    try {
-      if (typeof this.powerSyncDb.getAll !== "function") {
-        return "initializing" /* INITIALIZING */;
-      }
-      if (this.options.useOnlineUntilSynced && this.syncStatus) {
-        if (!this.syncStatus.hasSynced) {
-          return "initializing" /* INITIALIZING */;
-        }
-      }
-      return "available" /* AVAILABLE */;
-    } catch {
-      return "initializing" /* INITIALIZING */;
-    }
-  }
-  /**
-   * Check if Supabase is available.
-   *
-   * Supabase is considered available if we have a client instance.
-   * The actual network connectivity is checked separately via checkOnlineStatus().
-   *
-   * @returns Supabase backend status
-   */
-  detectSupabaseStatus() {
-    if (!this.supabase) {
-      return "unavailable" /* UNAVAILABLE */;
-    }
-    try {
-      if (typeof this.supabase.from === "function") {
-        return "available" /* AVAILABLE */;
-      }
-      return "unavailable" /* UNAVAILABLE */;
-    } catch {
-      return "unavailable" /* UNAVAILABLE */;
-    }
-  }
-  /**
-   * Check if device is online.
-   *
-   * Prefers the sync status's isOnline property if available (from React Native NetInfo).
-   * Falls back to navigator.onLine in browser environments.
-   * Returns true by default for other environments.
-   *
-   * @returns Whether the device has network connectivity
-   */
-  checkOnlineStatus() {
-    if (this.syncStatus?.isOnline !== void 0) {
-      return this.syncStatus.isOnline;
-    }
-    if (typeof window !== "undefined" && typeof navigator !== "undefined") {
-      return navigator.onLine;
-    }
-    return true;
-  }
-  // ===========================================================================
-  // Instance Management Methods
-  // ===========================================================================
-  /**
-   * Update PowerSync instance (e.g., when it becomes available).
-   *
-   * @param db - New PowerSync database instance or null
-   */
-  setPowerSync(db) {
-    this.powerSyncDb = db;
-  }
-  /**
-   * Update Supabase instance.
-   *
-   * @param supabase - New Supabase client instance or null
-   */
-  setSupabase(supabase) {
-    this.supabase = supabase;
-  }
-  /**
-   * Get current PowerSync instance.
-   *
-   * @returns Current PowerSync database instance or null
-   */
-  getPowerSync() {
-    return this.powerSyncDb;
-  }
-  /**
-   * Get current Supabase instance.
-   *
-   * @returns Current Supabase client instance or null
-   */
-  getSupabase() {
-    return this.supabase;
-  }
-  // ===========================================================================
-  // Options Management
-  // ===========================================================================
-  /**
-   * Update detector options.
-   *
-   * @param options - New options to merge with existing
-   */
-  setOptions(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    };
-  }
-  /**
-   * Get current detector options.
-   *
-   * @returns Current detector options
-   */
-  getOptions() {
-    return {
-      ...this.options
-    };
-  }
-  // ===========================================================================
-  // Listener Management
-  // ===========================================================================
-  /**
-   * Add a listener for backend change events.
-   *
-   * @param listener - Callback to invoke when detection result changes
-   * @returns Function to remove the listener
-   */
-  addListener(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  /**
-   * Remove a listener for backend change events.
-   *
-   * @param listener - Listener to remove
-   */
-  removeListener(listener) {
-    this.listeners.delete(listener);
-  }
-  /**
-   * Get the last detection result.
-   *
-   * @returns Last detection result or null if never detected
-   */
-  getLastResult() {
-    return this.lastResult;
-  }
-  // ===========================================================================
-  // Private Helper Methods
-  // ===========================================================================
-  /**
-   * Check if the detection result has changed from the last result.
-   */
-  hasResultChanged(result) {
-    if (!this.lastResult) {
-      return true;
-    }
-    return this.lastResult.powerSyncStatus !== result.powerSyncStatus || this.lastResult.supabaseStatus !== result.supabaseStatus || this.lastResult.recommendedBackend !== result.recommendedBackend || this.lastResult.isOnline !== result.isOnline;
-  }
-  /**
-   * Notify all listeners of a detection result change.
-   */
-  notifyListeners(result) {
-    const isDev = typeof __DEV__ !== "undefined" ? __DEV__ : process.env.NODE_ENV !== "production";
-    if (isDev) {
-      const prevBackend = this.lastResult?.recommendedBackend;
-      if (prevBackend && prevBackend !== result.recommendedBackend) {
-        console.log(`[DataLayer] Backend switched: ${prevBackend} \u2192 ${result.recommendedBackend}`, `| Reason: ${result.reason}`);
-      }
-      if (result.recommendedBackend === "supabase" && this.options.preferPowerSync) {
-        console.log(`[DataLayer] Using online fallback (Supabase)`, `| PowerSync: ${result.powerSyncStatus}`, `| Online: ${result.isOnline}`, `| Reason: ${result.reason}`);
-      }
-    }
-    Array.from(this.listeners).forEach((listener) => {
-      try {
-        listener(result);
-      } catch (error) {
-        console.error("Error in backend change listener:", error);
-      }
-    });
-  }
-};
-function createAdapterAutoDetector(powerSyncDb, supabase, options) {
-  return new AdapterAutoDetector(powerSyncDb, supabase, options);
-}
-
-// src/adapters/registry.ts
-function stripSchemaPrefix(tableName) {
-  if (!tableName.includes(".")) {
-    return tableName;
-  }
-  return tableName.split(".")[1];
-}
-function getPowerSyncAlias(tableName, strategy) {
-  if (strategy && (strategy.strategy === "powersync" || strategy.strategy === "hybrid")) {
-    const typedStrategy = strategy;
-    if (typedStrategy.alias) {
-      return typedStrategy.alias;
-    }
-  }
-  return stripSchemaPrefix(tableName);
-}
-var AdapterRegistry = class {
-  /**
-   * Create a new adapter registry
-   *
-   * @param config - Data layer configuration with table strategies
-   */
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Cache of created adapters by table name
-   */
-  adapters = /* @__PURE__ */ new Map();
-  /**
-   * PowerSync adapter instance (set during initialization)
-   */
-  powerSyncAdapter = null;
-  /**
-   * Supabase adapter instance (set during initialization)
-   */
-  supabaseAdapter = null;
-  /**
-   * Cached adapter instance (wraps Supabase with TanStack Query)
-   */
-  cachedAdapter = null;
-  /**
-   * Dependencies for creating adapters
-   */
-  deps = null;
-  /**
-   * Whether the registry has been initialized with adapters
-   */
-  _isInitialized = false;
-  /**
-   * Auto-detector instance for automatic backend selection
-   */
-  autoDetector = null;
-  /**
-   * Listeners for backend change events
-   */
-  backendChangeListeners = /* @__PURE__ */ new Set();
-  /**
-   * Last auto-detection result for debugging and status
-   */
-  lastDetectionResult = null;
-  // ===========================================================================
-  // Initialization
-  // ===========================================================================
-  /**
-   * Check if the registry has been initialized
-   */
-  get isInitialized() {
-    return this._isInitialized;
-  }
-  /**
-   * Initialize the registry with dependencies.
-   * Called by DataLayerProvider when PowerSync and Supabase are ready.
-   *
-   * @param deps - Dependencies needed to create adapters
-   */
-  initialize(deps) {
-    this.deps = deps;
-    this._isInitialized = true;
-  }
-  /**
-   * Set the PowerSync adapter instance
-   *
-   * @param adapter - PowerSync adapter implementation
-   */
-  setPowerSyncAdapter(adapter) {
-    this.powerSyncAdapter = adapter;
-  }
-  /**
-   * Set the Supabase adapter instance
-   *
-   * @param adapter - Supabase adapter implementation
-   */
-  setSupabaseAdapter(adapter) {
-    this.supabaseAdapter = adapter;
-  }
-  /**
-   * Set the Cached adapter instance
-   *
-   * @param adapter - Cached adapter implementation
-   */
-  setCachedAdapter(adapter) {
-    this.cachedAdapter = adapter;
-  }
-  /**
-   * Initialize auto-detection with a detector instance
-   *
-   * @param detector - The auto-detector to use
-   */
-  initializeAutoDetection(detector) {
-    this.autoDetector = detector;
-    detector.addListener((result) => {
-      this.lastDetectionResult = result;
-      this.notifyBackendChange(result.recommendedBackend);
-    });
-  }
-  // ===========================================================================
-  // Adapter Access
-  // ===========================================================================
-  /**
-   * Get the appropriate adapter for a table based on configuration.
-   *
-   * The adapter is selected based on the table's strategy in config.tables:
-   * - "powersync": Returns PowerSyncAdapter
-   * - "supabase": Returns SupabaseAdapter
-   * - "cached": Returns CachedAdapter (wrapping Supabase)
-   * - "hybrid": Returns HybridAdapter (combining PowerSync + Cached)
-   * - "auto": Uses auto-detection to select the best backend
-   *
-   * For tables not in config, defaults to auto-detection if available,
-   * otherwise falls back to SupabaseAdapter.
-   *
-   * Supports schema-qualified table names:
-   * - "core.Profile" looks up config["core.Profile"] first, then config["Profile"]
-   * - Auto-generates PowerSync alias as "CoreProfile" if not explicitly set
-   *
-   * @param table - The table name (may be schema-qualified like "core.Profile")
-   * @returns The appropriate adapter for the table
-   * @throws Error if adapters are not initialized
-   */
-  getAdapter(table) {
-    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
-    const strategy = this.config.tables[table] ?? this.config.tables[tableWithoutSchema];
-    if (!strategy || strategy.strategy === "auto") {
-      if (this.powerSyncAdapter) {
-        const powerSyncTableKeys = this.getPowerSyncTableKeys();
-        const isConfigured = powerSyncTableKeys.some((key) => key === table || key === tableWithoutSchema || key.includes(".") && key.split(".")[1] === tableWithoutSchema);
-        if (!isConfigured) {
-          if (this.supabaseAdapter) {
-            return this.supabaseAdapter;
-          }
-          throw new Error(`Table "${table}" is not configured for PowerSync sync and Supabase adapter is not available. Either add this table to the PowerSync schema or initialize the Supabase adapter.`);
-        }
-      }
-      return this.getAutoAdapter(strategy);
-    }
-    if (strategy.strategy === "powersync" && this.autoDetector && this.supabaseAdapter) {
-      const detection = this.autoDetector.detect();
-      if (detection.powerSyncStatus === "initializing" /* INITIALIZING */ && detection.isOnline) {
-        return this.supabaseAdapter;
-      }
-    }
-    const existing = this.adapters.get(table);
-    if (existing) {
-      return existing;
-    }
-    const adapter = this.createAdapter(strategy);
-    this.adapters.set(table, adapter);
-    return adapter;
-  }
-  /**
-   * Get the PowerSync adapter directly
-   *
-   * @returns PowerSync adapter or null if not initialized
-   */
-  getPowerSyncAdapter() {
-    return this.powerSyncAdapter;
-  }
-  /**
-   * Get the Supabase adapter directly
-   *
-   * @returns Supabase adapter or null if not initialized
-   */
-  getSupabaseAdapter() {
-    return this.supabaseAdapter;
-  }
-  /**
-   * Get the Cached adapter directly
-   *
-   * @returns Cached adapter or null if not initialized
-   */
-  getCachedAdapter() {
-    return this.cachedAdapter;
-  }
-  /**
-   * Get all configured table names
-   *
-   * @returns Array of table names with explicit strategy configuration
-   */
-  getConfiguredTables() {
-    return Object.keys(this.config.tables);
-  }
-  /**
-   * Get the strategy for a specific table
-   *
-   * @param table - The table name (may include schema prefix like "core.Profile")
-   * @returns The table strategy or undefined if not configured
-   */
-  getTableStrategy(table) {
-    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
-    return this.config.tables[table] ?? this.config.tables[tableWithoutSchema];
-  }
-  /**
-   * Check if a table uses PowerSync strategy
-   *
-   * @param table - The table name (may include schema prefix like "core.Profile")
-   * @returns True if table uses PowerSync or Hybrid strategy
-   */
-  usesPowerSync(table) {
-    const strategy = this.getTableStrategy(table);
-    return strategy?.strategy === "powersync" || strategy?.strategy === "hybrid";
-  }
-  /**
-   * Get all table config keys that use PowerSync (may be schema-qualified)
-   *
-   * @returns Array of config keys using PowerSync or Hybrid strategy
-   */
-  getPowerSyncTableKeys() {
-    return Object.entries(this.config.tables).filter(([_, strategy]) => strategy.strategy === "powersync" || strategy.strategy === "hybrid").map(([key]) => key);
-  }
-  /**
-   * Get all tables that use PowerSync (returns aliases for PowerSync schema)
-   *
-   * @returns Array of PowerSync table aliases
-   */
-  getPowerSyncTables() {
-    return Object.entries(this.config.tables).filter(([_, strategy]) => strategy.strategy === "powersync" || strategy.strategy === "hybrid").map(([key, strategy]) => getPowerSyncAlias(key, strategy));
-  }
-  /**
-   * Get the PowerSync alias for a table.
-   * Uses explicit alias from config if set, otherwise auto-generates.
-   *
-   * @param table - Table name (may be schema-qualified)
-   * @returns The alias to use in PowerSync schema
-   */
-  getTableAlias(table) {
-    const strategy = this.getTableStrategy(table);
-    const tableWithoutSchema = table.includes(".") ? table.split(".")[1] : table;
-    const configKey = this.config.tables[table] ? table : tableWithoutSchema;
-    return getPowerSyncAlias(configKey, strategy);
-  }
-  // ===========================================================================
-  // Auto-Detection Methods
-  // ===========================================================================
-  /**
-   * Get adapter using auto-detection
-   *
-   * @param strategy - Optional auto strategy configuration
-   * @returns The automatically selected adapter
-   */
-  getAutoAdapter(_strategy) {
-    if (!this.autoDetector) {
-      if (!this.supabaseAdapter) {
-        throw new Error("No auto-detector configured and Supabase adapter not available. Either initialize auto-detection or set adapters explicitly.");
-      }
-      return this.supabaseAdapter;
-    }
-    const detection = this.autoDetector.detect();
-    this.lastDetectionResult = detection;
-    if (detection.recommendedBackend === "powersync") {
-      if (!this.powerSyncAdapter) {
-        if (!this.supabaseAdapter) {
-          throw new Error("Neither PowerSync nor Supabase adapters are available.");
-        }
-        return this.supabaseAdapter;
-      }
-      return this.powerSyncAdapter;
-    }
-    if (!this.supabaseAdapter) {
-      throw new Error("Supabase adapter not available and PowerSync not recommended.");
-    }
-    return this.supabaseAdapter;
-  }
-  /**
-   * Subscribe to backend changes
-   *
-   * @param callback - Function called when recommended backend changes
-   * @returns Unsubscribe function
-   */
-  onBackendChange(callback) {
-    this.backendChangeListeners.add(callback);
-    return () => {
-      this.backendChangeListeners.delete(callback);
-    };
-  }
-  /**
-   * Notify listeners of backend change
-   *
-   * @param backend - The new recommended backend
-   */
-  notifyBackendChange(backend) {
-    this.backendChangeListeners.forEach((callback) => {
-      try {
-        callback(backend);
-      } catch (error) {
-        console.error("Error in backend change listener:", error);
-      }
-    });
-  }
-  /**
-   * Get the last auto-detection result
-   *
-   * @returns Last detection result or null if never detected
-   */
-  getLastDetectionResult() {
-    return this.lastDetectionResult;
-  }
-  /**
-   * Get the auto-detector instance
-   *
-   * @returns Auto-detector instance or null if not initialized
-   */
-  getAutoDetector() {
-    return this.autoDetector;
-  }
-  // ===========================================================================
-  // Private Methods
-  // ===========================================================================
-  /**
-   * Create an adapter based on the strategy type
-   *
-   * @param strategy - The table strategy configuration
-   * @returns The created adapter
-   * @throws Error if the required base adapter is not initialized
-   */
-  createAdapter(strategy) {
-    switch (strategy.strategy) {
-      case "powersync":
-        if (!this.powerSyncAdapter) {
-          throw new Error("PowerSync adapter not initialized. Ensure PowerSyncAdapter is set before accessing PowerSync tables.");
-        }
-        return this.powerSyncAdapter;
-      case "supabase":
-        if (!this.supabaseAdapter) {
-          throw new Error("Supabase adapter not initialized. Ensure SupabaseAdapter is set before accessing Supabase tables.");
-        }
-        return this.supabaseAdapter;
-      case "cached":
-        if (this.cachedAdapter) {
-          return this.cachedAdapter;
-        }
-        throw new Error("CachedAdapter not yet implemented. This feature will be available in Wave 2. For now, use 'supabase' strategy as a fallback.");
-      case "hybrid":
-        throw new Error("HybridAdapter not yet implemented. This feature will be available in Wave 2. For now, use 'powersync' or 'supabase' strategy as a fallback.");
-      default:
-        if (!this.supabaseAdapter) {
-          throw new Error("Supabase adapter not initialized. Ensure SupabaseAdapter is set before accessing tables.");
-        }
-        return this.supabaseAdapter;
-    }
-  }
-  // ===========================================================================
-  // Utility Methods
-  // ===========================================================================
-  /**
-   * Clear all cached adapters.
-   * Useful when configuration changes and adapters need to be recreated.
-   */
-  clearCache() {
-    this.adapters.clear();
-  }
-  /**
-   * Reset the registry to uninitialized state.
-   * Used during cleanup or testing.
-   */
-  reset() {
-    this.adapters.clear();
-    this.powerSyncAdapter = null;
-    this.supabaseAdapter = null;
-    this.cachedAdapter = null;
-    this.deps = null;
-    this._isInitialized = false;
-    this.autoDetector = null;
-    this.backendChangeListeners.clear();
-    this.lastDetectionResult = null;
-  }
-  /**
-   * Dispose all adapters and clean up resources.
-   * Called when the DataLayerProvider unmounts.
-   */
-  dispose() {
-    this.reset();
-  }
-  /**
-   * Get debug information about the registry state
-   */
-  getDebugInfo() {
-    return {
-      isInitialized: this._isInitialized,
-      hasPowerSync: this.powerSyncAdapter !== null,
-      hasSupabase: this.supabaseAdapter !== null,
-      hasCached: this.cachedAdapter !== null,
-      cachedAdapterCount: this.adapters.size,
-      configuredTableCount: Object.keys(this.config.tables).length,
-      powerSyncTables: this.getPowerSyncTables(),
-      hasAutoDetector: this.autoDetector !== null,
-      lastDetectionResult: this.lastDetectionResult
-    };
-  }
-};
-function createAdapterRegistry(config) {
-  return new AdapterRegistry(config);
-}
-
-// src/adapters/supabase-adapter.ts
-var SupabaseAdapter = class {
-  constructor(supabase, schema) {
-    this.supabase = supabase;
-    this.schema = schema;
-  }
-  name = "supabase";
-  capabilities = {
-    supportsSubscribe: true,
-    supportsOffline: false,
-    supportsCache: false,
-    supportsSync: false
-  };
-  // ===========================================================================
-  // Private Helper - Table Name Parsing
-  // ===========================================================================
-  /**
-   * Parse a table identifier to extract schema and table name.
-   * Handles schema-qualified names like "core.Profile" -> { schema: "core", tableName: "Profile" }
-   *
-   * @param table - The table name, optionally schema-qualified (e.g., "users" or "core.Profile")
-   * @returns Object with schema (defaults to "public") and tableName
-   */
-  parseTableIdentifier(table) {
-    if (table.includes(".")) {
-      const [schema, ...rest] = table.split(".");
-      return {
-        schema,
-        tableName: rest.join(".")
-      };
-    }
-    return {
-      schema: "public",
-      tableName: table
-    };
-  }
-  // ===========================================================================
-  // Query Operations
-  // ===========================================================================
-  /**
-   * Execute a query and return results with optional count
-   *
-   * @param table - The table name to query
-   * @param options - Query options (select, where, orderBy, limit, offset)
-   * @returns Promise resolving to query results with optional count
-   */
-  async query(table, options) {
-    const {
-      select = "*",
-      where,
-      orderBy,
-      limit,
-      offset
-    } = options;
-    const {
-      schema,
-      tableName
-    } = this.parseTableIdentifier(table);
-    let query = this.supabase.schema(schema).from(tableName).select(select, {
-      count: "exact"
-    });
-    if (where) {
-      query = this.applyWhereClause(query, where);
-    }
-    if (orderBy && orderBy.length > 0) {
-      for (const order of orderBy) {
-        query = query.order(order.field, {
-          ascending: order.direction === "asc"
-        });
-      }
-    }
-    if (limit !== void 0 && offset !== void 0) {
-      query = query.range(offset, offset + limit - 1);
-    } else if (limit !== void 0) {
-      query = query.limit(limit);
-    }
-    const {
-      data,
-      error,
-      count
-    } = await query;
-    if (error) {
-      throw new Error(`Supabase query error on ${table}: ${error.message}`);
-    }
-    return {
-      data: data ?? [],
-      count: count ?? void 0
-    };
-  }
-  /**
-   * Query a single record by ID
-   *
-   * @param table - The table name to query
-   * @param id - The record ID
-   * @param options - Optional query options (mainly for select)
-   * @returns Promise resolving to the record or null if not found
-   */
-  async queryById(table, id, options) {
-    const select = options?.select ?? "*";
-    const {
-      schema,
-      tableName
-    } = this.parseTableIdentifier(table);
-    const {
-      data,
-      error
-    } = await this.supabase.schema(schema).from(tableName).select(select).eq("id", id).single();
-    if (error) {
-      if (error.code === "PGRST116") {
-        return null;
-      }
-      throw new Error(`Supabase queryById error on ${table}: ${error.message}`);
-    }
-    return data;
-  }
-  // ===========================================================================
-  // Mutation Operations
-  // ===========================================================================
-  /**
-   * Insert a new record
-   *
-   * @param table - The table name
-   * @param data - The data to insert
-   * @returns Promise resolving to the inserted record
-   */
-  async insert(table, data) {
-    const {
-      schema,
-      tableName
-    } = this.parseTableIdentifier(table);
-    const {
-      data: insertedData,
-      error
-    } = await this.supabase.schema(schema).from(tableName).insert(data).select().single();
-    if (error) {
-      throw new Error(`Supabase insert error on ${table}: ${error.message}`);
-    }
-    return insertedData;
-  }
-  /**
-   * Update an existing record by ID
-   *
-   * @param table - The table name
-   * @param id - The record ID to update
-   * @param data - The data to update
-   * @returns Promise resolving to the updated record
-   */
-  async update(table, id, data) {
-    const {
-      schema,
-      tableName
-    } = this.parseTableIdentifier(table);
-    const {
-      data: updatedData,
-      error
-    } = await this.supabase.schema(schema).from(tableName).update(data).eq("id", id).select().single();
-    if (error) {
-      throw new Error(`Supabase update error on ${table}: ${error.message}`);
-    }
-    return updatedData;
-  }
-  /**
-   * Upsert (insert or update) a record
-   *
-   * @param table - The table name
-   * @param data - The data to upsert
-   * @returns Promise resolving to the upserted record
-   */
-  async upsert(table, data) {
-    const {
-      schema,
-      tableName
-    } = this.parseTableIdentifier(table);
-    const {
-      data: upsertedData,
-      error
-    } = await this.supabase.schema(schema).from(tableName).upsert(data, {
-      onConflict: "id"
-    }).select().single();
-    if (error) {
-      throw new Error(`Supabase upsert error on ${table}: ${error.message}`);
-    }
-    return upsertedData;
-  }
-  /**
-   * Delete a record by ID
-   *
-   * @param table - The table name
-   * @param id - The record ID to delete
-   * @returns Promise that resolves when deletion is complete
-   */
-  async delete(table, id) {
-    const {
-      schema,
-      tableName
-    } = this.parseTableIdentifier(table);
-    const {
-      error
-    } = await this.supabase.schema(schema).from(tableName).delete().eq("id", id);
-    if (error) {
-      throw new Error(`Supabase delete error on ${table}: ${error.message}`);
-    }
-  }
-  // ===========================================================================
-  // Subscription (Real-time)
-  // ===========================================================================
-  /**
-   * Subscribe to real-time changes on a query
-   *
-   * @param table - The table name to watch
-   * @param options - Query options to filter what to watch
-   * @param callback - Function called with updated data
-   * @returns Unsubscribe function
-   */
-  subscribe(table, options, callback) {
-    const {
-      schema,
-      tableName
-    } = this.parseTableIdentifier(table);
-    const channelName = `v3:${table}:${Date.now()}`;
-    const channel = this.supabase.channel(channelName).on("postgres_changes", {
-      event: "*",
-      schema,
-      table: tableName
-    }, async () => {
-      try {
-        const {
-          data
-        } = await this.query(table, options);
-        callback(data);
-      } catch (error) {
-        console.error(`Supabase subscription refetch error on ${table}:`, error);
-      }
-    }).subscribe();
-    return () => {
-      this.supabase.removeChannel(channel);
-    };
-  }
-  // ===========================================================================
-  // Private Helper Methods
-  // ===========================================================================
-  /**
-   * Apply where clause filters to a Supabase query
-   *
-   * Converts WhereClause to Supabase filter methods:
-   * - Direct value: .eq(field, value)
-   * - { in: [...] }: .in(field, values)
-   * - { gt: n }: .gt(field, n)
-   * - { gte: n }: .gte(field, n)
-   * - { lt: n }: .lt(field, n)
-   * - { lte: n }: .lte(field, n)
-   * - { like: s }: .ilike(field, s)
-   * - { is: null }: .is(field, null)
-   * - { neq: v }: .neq(field, v) or .not(field, "is", null)
-   * - { notIn: [...] }: .not().in(field, values)
-   *
-   * @param query - The Supabase query builder
-   * @param where - The where clause to apply
-   * @returns The query with filters applied
-   */
-  applyWhereClause(query, where) {
-    for (const [field, condition] of Object.entries(where)) {
-      if (condition === null) {
-        query = query.is(field, null);
-      } else if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean") {
-        query = query.eq(field, condition);
-      } else if (typeof condition === "object") {
-        const operators = condition;
-        if (operators.in !== void 0) {
-          query = query.in(field, operators.in);
-        }
-        if (operators.gt !== void 0) {
-          query = query.gt(field, operators.gt);
-        }
-        if (operators.gte !== void 0) {
-          query = query.gte(field, operators.gte);
-        }
-        if (operators.lt !== void 0) {
-          query = query.lt(field, operators.lt);
-        }
-        if (operators.lte !== void 0) {
-          query = query.lte(field, operators.lte);
-        }
-        if (operators.like !== void 0) {
-          query = query.ilike(field, operators.like);
-        }
-        if (operators.is !== void 0) {
-          query = query.is(field, null);
-        }
-        if (operators.neq !== void 0) {
-          if (operators.neq === null) {
-            query = query.not(field, "is", null);
-          } else {
-            query = query.neq(field, operators.neq);
-          }
-        }
-        if (operators.notIn !== void 0) {
-          query = query.not(field, "in", `(${operators.notIn.join(",")})`);
-        }
-      }
-    }
-    return query;
-  }
-};
-function createSupabaseAdapter(supabase, schema) {
-  return new SupabaseAdapter(supabase, schema);
-}
-
-// src/supabase-functions.tsx
-async function getErrorBody(response) {
-  const stream = response.error.context.body;
-  const reader = stream.getReader();
-  const {
-    value
-  } = await reader.read();
-  const text = new TextDecoder().decode(value);
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    parsed = text;
-  }
-  return parsed;
-}
-
-// src/useAI.ts
-import { c as _c2 } from "react/compiler-runtime";
-function useAI() {
-  const $ = _c2(2);
-  const supabase = useSupabase();
-  let t0;
-  if ($[0] !== supabase) {
-    const generate = async (prompt, context, options) => {
-      const response = await supabase.functions.invoke("ai", {
-        body: {
-          prompt,
-          context,
-          options
-        }
-      });
-      if (response.error) {
-        throw new Error(`Failed to invoke AI function: ${response.error.message}`);
-      }
-      if (response.data?.error) {
-        throw new Error(response.data.error);
-      }
-      if (!response.data?.success) {
-        throw new Error(response.data?.error || "Unknown error occurred");
-      }
-      if (!response.data?.data?.response) {
-        throw new Error("No response from AI");
-      }
-      return response.data.data.response;
-    };
-    t0 = {
-      generate
-    };
-    $[0] = supabase;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  return t0;
-}
-
-// src/useServerAvailability.ts
-import { useState, useEffect as useEffect2, useCallback } from "react";
-var CHECK_TIMEOUT = 1e4;
-var CHECK_INTERVAL = 3e4;
-function useServerAvailability(options) {
-  const {
-    enabled = true,
-    checkInterval = CHECK_INTERVAL,
-    timeout = CHECK_TIMEOUT
-  } = options || {};
-  const [isAvailable, setIsAvailable] = useState(null);
-  const [isChecking, setIsChecking] = useState(false);
-  const [lastChecked, setLastChecked] = useState(null);
-  const [error, setError] = useState(null);
-  const checkAvailability = useCallback(async () => {
-    if (!enabled) return;
-    setIsChecking(true);
-    setError(null);
-    try {
-      const supabaseUrl = getSupabaseUrl();
-      const supabaseAnonKey = process.env.SUPABASE_ANON_KEY || process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY;
-      if (!supabaseUrl) {
-        throw new Error("Supabase URL is not configured");
-      }
-      if (!supabaseAnonKey) {
-        throw new Error("Supabase anon key is not configured");
-      }
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeout);
-      const healthCheckPromise = fetch(`${supabaseUrl}/rest/v1/`, {
-        method: "HEAD",
-        headers: {
-          apikey: supabaseAnonKey
-        },
-        signal: controller.signal
-      }).then((response) => {
-        clearTimeout(timeoutId);
-        return response.status < 500;
-      }).catch((err_0) => {
-        clearTimeout(timeoutId);
-        if (err_0.name === "AbortError") {
-          return false;
-        }
-        return false;
-      });
-      const available = await healthCheckPromise;
-      setIsAvailable(available);
-      setLastChecked(/* @__PURE__ */ new Date());
-      setError(null);
-    } catch (err) {
-      const error_0 = err instanceof Error ? err : new Error("Unknown error checking server availability");
-      setIsAvailable(false);
-      setError(error_0);
-      setLastChecked(/* @__PURE__ */ new Date());
-    } finally {
-      setIsChecking(false);
-    }
-  }, [enabled, timeout]);
-  useEffect2(() => {
-    if (enabled) {
-      checkAvailability();
-    }
-  }, [enabled, checkAvailability]);
-  useEffect2(() => {
-    if (!enabled || isAvailable !== false) return;
-    const intervalId = setInterval(() => {
-      checkAvailability();
-    }, checkInterval);
-    return () => clearInterval(intervalId);
-  }, [enabled, isAvailable, checkInterval, checkAvailability]);
-  return {
-    isAvailable,
-    isChecking,
-    lastChecked,
-    error,
-    checkAvailability
-  };
-}
-
-// src/useSearchQuery.ts
-import { useMemo } from "react";
-import React from "react";
-function useSearchQuery(baseQuery, searchText, columns, options = {
-  isOptional: true,
-  additionCondition: []
-}) {
-  const original = React.useRef(null);
-  if (original.current?.lastQuery !== baseQuery) {
-    const b = baseQuery;
-    const urlValue = b.url;
-    const url = urlValue ? typeof urlValue === "string" ? new URL(urlValue) : new URL(urlValue.toString()) : new URL("http://localhost");
-    const method = b.method ?? "GET";
-    const headers = b.headers ?? {};
-    const body = method !== "GET" && method !== "HEAD" ? b.body ?? null : null;
-    const signal = b.signal ?? null;
-    original.current = {
-      lastQuery: baseQuery,
-      original: {
-        url,
-        method,
-        headers,
-        body,
-        signal
-      }
-    };
-  }
-  return useMemo(() => {
-    const qb = baseQuery;
-    const {
-      url: url_0,
-      method: method_0,
-      body: body_0,
-      signal: signal_0
-    } = original.current.original;
-    qb.url = new URL(url_0.toString());
-    qb.method = method_0;
-    if (method_0 !== "GET" && method_0 !== "HEAD") {
-      qb.body = body_0;
-    } else {
-      delete qb.body;
-    }
-    qb.signal = signal_0;
-    const term = searchText.trim();
-    if (term) {
-      const clauses = columns.map((col) => {
-        const [tbl, colName] = col.split(".");
-        return `${colName ?? tbl}.ilike.%${escapeLikePattern(term)}%`;
-      });
-      clauses.push(...options.additionCondition.filter(Boolean));
-      qb.or(clauses.join(","), {
-        referencedTable: columns.find((c) => c.includes("."))?.split(".")[0]
-      });
-    } else if (!options.isOptional) {
-      const conds = options.additionCondition.filter(Boolean);
-      conds?.length ? qb.or(conds.join(",")) : qb.limit(0);
-    }
-    return qb;
-  }, [baseQuery, searchText, columns.join(","), options.isOptional, options.additionCondition.join(",")]);
-}
-function escapeLikePattern(text) {
-  return text?.replace(/[%_]/g, "\\$&");
-}
-
-// src/useLiveChangeTracking.ts
-import { c as _c3 } from "react/compiler-runtime";
-import { useEffect as useEffect3, useState as useState2 } from "react";
-var import_moment = __toESM(require_moment(), 1);
-function useLiveChangeTracking(tableName, item, action) {
-  const $ = _c3(12);
-  const [changeLog, setChangeLog] = useState2(null);
-  const [oldItem, setOldItem] = useState2(null);
-  const supabase = useSupabase();
-  let t0;
-  if ($[0] !== item || $[1] !== oldItem || $[2] !== supabase || $[3] !== tableName) {
-    t0 = () => {
-      setChangeLog(null);
-      if (isUsable(item) === false) {
-        return;
-      }
-      if (isUsable(oldItem) === false) {
-        setOldItem(item);
-        return;
-      }
-      const itemId = item.id;
-      if (isUsable(itemId) === false) {
-        return;
-      }
-      const changes = getObjectChanges(oldItem, item);
-      if (Object.keys(changes).length === 0) {
-        return;
-      }
-      supabase.schema("core").from("OperationLog").select().filter("tableName", "eq", tableName).filter("recordId", "eq", itemId).order("changeAt", {
-        ascending: false
-      }).limit(1).single().then((x) => {
-        if (isUsable(x.data) === false) {
-          return;
-        }
-        const data = x.data;
-        if (data.sessionId === UserSessionId) {
-          return;
-        }
-        const changeLog_0 = {
-          modifiedByUserId: data.changeBy,
-          changedOn: import_moment.default.utc(data.changeAt),
-          changes
-        };
-        setChangeLog(changeLog_0);
-      });
-      setOldItem(item);
-    };
-    $[0] = item;
-    $[1] = oldItem;
-    $[2] = supabase;
-    $[3] = tableName;
-    $[4] = t0;
-  } else {
-    t0 = $[4];
-  }
-  let t1;
-  if ($[5] !== item) {
-    t1 = [item];
-    $[5] = item;
-    $[6] = t1;
-  } else {
-    t1 = $[6];
-  }
-  useEffect3(t0, t1);
-  let t2;
-  if ($[7] !== action || $[8] !== changeLog) {
-    t2 = () => {
-      if (isUsable(changeLog) && action) {
-        action(changeLog.changes, changeLog);
-      }
-    };
-    $[7] = action;
-    $[8] = changeLog;
-    $[9] = t2;
-  } else {
-    t2 = $[9];
-  }
-  let t3;
-  if ($[10] !== changeLog) {
-    t3 = [changeLog];
-    $[10] = changeLog;
-    $[11] = t3;
-  } else {
-    t3 = $[11];
-  }
-  useEffect3(t2, t3);
-  return changeLog;
-}
-
-// src/useLatestOperationLog.ts
-import { c as _c4 } from "react/compiler-runtime";
-function useLatestOperationLog(tableName, recordId) {
-  const $ = _c4(8);
-  const supabase = useSupabase();
-  const t0 = supabase;
-  let t1;
-  if ($[0] !== recordId || $[1] !== t0 || $[2] !== tableName) {
-    t1 = t0.schema("core").from("OperationLog").select(OperationLog.defaultQuery).eq("recordId", String(recordId)).eq("tableName", tableName).order("changeAt", {
-      ascending: false
-    }).limit(1).maybeSingle();
-    $[0] = recordId;
-    $[1] = t0;
-    $[2] = tableName;
-    $[3] = t1;
-  } else {
-    t1 = $[3];
-  }
-  let t2;
-  if ($[4] !== recordId) {
-    t2 = isUsable(recordId);
-    $[4] = recordId;
-    $[5] = t2;
-  } else {
-    t2 = $[5];
-  }
-  let t3;
-  if ($[6] !== t2) {
-    t3 = {
-      refetchOnMount: true,
-      refetchOnWindowFocus: true,
-      staleTime: 0,
-      enabled: t2
-    };
-    $[6] = t2;
-    $[7] = t3;
-  } else {
-    t3 = $[7];
-  }
-  return useDbQuery(t1, t3);
-}
-
-// src/useAutosaveState.ts
-import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo2, useRef as useRef3, useState as useState3 } from "react";
-function newTimeActivity(date) {
-  return {
-    activityDate: date.clone().startOf("day").toISOString(true),
-    description: "",
-    hasRequestBillableChange: false,
-    hasRequestVerification: false,
-    hours: 0,
-    userNotes: "",
-    adminNotes: "",
-    userId: null,
-    clientId: null,
-    projectId: null,
-    workingPhaseId: null,
-    roleId: null,
-    taskId: null,
-    subtaskId: null,
-    weeklyTimesheetId: null,
-    id: null,
-    BillingDetails: {
-      status: "Unknown",
-      id: null,
-      orderHint: "",
-      chargeTableId: null,
-      cosmosId: null,
-      amount: 0,
-      rate: 0,
-      type: "TimeActivity"
-    }
-  };
-}
-function getNewValue(action, prevState) {
-  return typeof action === "function" ? action(prevState) : action;
-}
-function useAutosaveState(relation, defaultValue, options) {
-  const [value, setValue] = useState3(() => defaultValue);
-  const [baseValue, setBaseValue] = useState3(() => defaultValue);
-  const baseValueRef = useRef3(defaultValue);
-  const pendingChangesRef = useRef3(/* @__PURE__ */ new Map());
-  const currentId = useRef3(null);
-  const newOptions = useMemo2(() => options ? {
-    ...options,
-    primaryKeys: options.primaryKeys ?? ["id"]
-  } : {
-    delay: 200,
-    primaryKeys: ["id"]
-  }, [options]);
-  const upsertMutation = useDbUpsert(relation, {
-    invalidateTables: [relation]
-  });
-  const saveEntityChanges = useCallback2(async (entityId) => {
-    if (__DEV__) {
-      console.log("[Autosave] saveEntityChanges called:", {
-        entityId,
-        relation,
-        hasPendingEntry: pendingChangesRef.current.has(entityId)
-      });
-    }
-    const pending = pendingChangesRef.current.get(entityId);
-    if (!pending) {
-      if (__DEV__) {
-        console.log("[Autosave] No pending changes found for entity:", entityId);
-      }
-      return;
-    }
-    const changes = diff(pending.baseValue, pending.currentValue);
-    if (__DEV__) {
-      console.log("[Autosave] Computed diff:", {
-        entityId,
-        relation,
-        changeKeys: Object.keys(changes),
-        changes,
-        baseValue: pending.baseValue,
-        currentValue: pending.currentValue
-      });
-    }
-    if (Object.keys(changes).length === 0) {
-      if (__DEV__) {
-        console.log("[Autosave] No changes detected, skipping save for:", entityId);
-      }
-      pendingChangesRef.current.delete(entityId);
-      return;
-    }
-    const patch = {
-      ...changes,
-      id: entityId
-    };
-    const finalPatch = newOptions.transformBeforeMutation ? newOptions.transformBeforeMutation(patch) : patch;
-    if (__DEV__) {
-      console.log("[Autosave] Calling mutateAsync:", {
-        entityId,
-        relation,
-        patch,
-        finalPatch,
-        hasTransform: !!newOptions.transformBeforeMutation
-      });
-    }
-    try {
-      const result = await upsertMutation.mutateAsync(finalPatch);
-      if (__DEV__) {
-        console.log("[Autosave] mutateAsync SUCCESS:", {
-          entityId,
-          relation,
-          finalPatch,
-          result
-        });
-      }
-      pendingChangesRef.current.delete(entityId);
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[Autosave] mutateAsync FAILED:", {
-          entityId,
-          relation,
-          finalPatch,
-          error,
-          errorMessage: error instanceof Error ? error.message : String(error),
-          errorStack: error instanceof Error ? error.stack : void 0
-        });
-      }
-      throw error;
-    }
-  }, [relation, upsertMutation, newOptions.transformBeforeMutation]);
-  const updateValue = useCallback2((update) => {
-    setValue((prev) => {
-      const newValue = getNewValue(update, prev);
-      const entityId_0 = newValue.id;
-      if (!entityId_0) return newValue;
-      let pending_0 = pendingChangesRef.current.get(entityId_0);
-      if (!pending_0) {
-        pending_0 = {
-          baseValue: baseValueRef.current,
-          currentValue: newValue,
-          timeoutId: null
-        };
-        pendingChangesRef.current.set(entityId_0, pending_0);
-        if (__DEV__) {
-          console.log("[Autosave] Created new pending entry using baseValueRef:", {
-            entityId: entityId_0,
-            baseValueId: baseValueRef.current?.id
-          });
-        }
-      } else {
-        pending_0.currentValue = newValue;
-      }
-      if (pending_0.timeoutId) {
-        clearTimeout(pending_0.timeoutId);
-      }
-      pending_0.timeoutId = setTimeout(() => {
-        saveEntityChanges(entityId_0);
-      }, newOptions.delay);
-      return newValue;
-    });
-  }, [saveEntityChanges, newOptions.delay]);
-  const setNewEntity = useCallback2((newEntity) => {
-    baseValueRef.current = newEntity;
-    if (__DEV__) {
-      console.log("[Autosave] setNewEntity - baseValueRef updated synchronously:", {
-        entityId: newEntity.id,
-        relation
-      });
-    }
-    setValue(newEntity);
-    setBaseValue(newEntity);
-    currentId.current = newEntity.id;
-  }, [relation]);
-  useEffect4(() => {
-    return () => {
-      pendingChangesRef.current.forEach((pending_1) => {
-        if (pending_1.timeoutId) clearTimeout(pending_1.timeoutId);
-      });
-    };
-  }, []);
-  const saveCurrentValue = useCallback2(async () => {
-    if (currentId.current) {
-      await saveEntityChanges(currentId.current);
-    }
-  }, [saveEntityChanges]);
-  return [value, updateValue, upsertMutation, setValue, setNewEntity, saveCurrentValue];
-}
-
-// src/useToastError.ts
-import { c as _c5 } from "react/compiler-runtime";
-import { useEffect as useEffect5 } from "react";
-import { useToast } from "@pol-studios/hooks/toast";
-function useToastError(mutation) {
-  const $ = _c5(5);
-  const toast = useToast();
-  let t0;
-  if ($[0] !== mutation.error || $[1] !== toast) {
-    t0 = () => {
-      if (isUsable(mutation.error) === false) {
-        return;
-      }
-      toast.toast({
-        title: "Error",
-        description: mutation.error.message
-      });
-    };
-    $[0] = mutation.error;
-    $[1] = toast;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  let t1;
-  if ($[3] !== mutation.error) {
-    t1 = [mutation.error];
-    $[3] = mutation.error;
-    $[4] = t1;
-  } else {
-    t1 = $[4];
-  }
-  useEffect5(t0, t1);
-  return mutation;
-}
-
-// src/advance-query.tsx
-async function executeAdvanceQuery(supabase, query, filterLayer) {
-  const parser = new PostgrestParser(query);
-  const filterGroup = {
-    id: filterLayer.id,
-    op: filterLayer.op,
-    not: filterLayer.not,
-    filters: filterLayer.filters.map(normalizeFilter).filter((f) => f !== null)
-  };
-  const pagination = {
-    offset: void 0,
-    limit: void 0
-  };
-  const sort = [...filterLayer.sort || []];
-  const searchParams = Array.from(parser.searchParams.entries());
-  searchParams.forEach(([k, v]) => {
-    if (k.includes("offset")) {
-      pagination.offset = Number(v);
-      return;
-    }
-    if (k.includes("limit")) {
-      pagination.limit = Number(v);
-      return;
-    }
-    if (k.includes("order")) {
-      const orderColumns = v.split(",");
-      orderColumns.forEach((x) => {
-        const values2 = x.split(".");
-        sort.push({
-          field: values2[0],
-          direction: values2[1] === "asc" ? "asc" : "desc"
-        });
-      });
-      return;
-    }
-    if (v.includes(".") === false) return;
-    const values = v.split(".");
-    const column = k;
-    const rawCondition = values[0];
-    let condition = "";
-    const value = values[1];
-    if (column == "select") return;
-    switch (rawCondition) {
-      case "eq":
-        condition = "=";
-        break;
-      case "in":
-        condition = "in";
-        break;
-      case "lt":
-        condition = "<";
-        break;
-      case "gt":
-        condition = ">";
-        break;
-      case "lte":
-        condition = "<=";
-        break;
-      case "gte":
-        condition = ">=";
-        break;
-      case "is":
-        condition = "is";
-        break;
-      case "ilike":
-        condition = "ilike";
-        break;
-      case "neq":
-        condition = "=";
-        break;
-      case "like":
-        condition = "contains";
-        break;
-    }
-    filterGroup.filters.push({
-      id: `filter_${column}_${Date.now()}`,
-      field: column,
-      op: condition,
-      value,
-      display: `${column} ${condition} ${value}`
-    });
-  });
-  const stripUIProperties = (obj) => {
-    return JSON.parse(JSON.stringify(obj, (key, value) => {
-      if (key === "display" || key === "info" || key === "options") {
-        return void 0;
-      }
-      return value;
-    }));
-  };
-  const cleanedBody = stripUIProperties({
-    table: parser.table,
-    schema: parser.schema,
-    select: parser.select,
-    filters: filterGroup,
-    pagination,
-    sort,
-    count: "exact"
-  });
-  const response = await supabase.functions.invoke("query", {
-    body: cleanedBody,
-    method: "POST"
-  });
-  if (response.error) {
-    return {
-      data: null,
-      count: null,
-      error: response.error
-    };
-  }
-  return {
-    data: response.data?.data ?? null,
-    count: response.data?.count ?? null,
-    error: null
-  };
-}
-
-// src/storage/useStorageUrl.ts
-var import_moment2 = __toESM(require_moment(), 1);
-import { useRef as useRef4 } from "react";
-import { useIndexedDB } from "@pol-studios/hooks/storage";
-var cacheVersions = /* @__PURE__ */ new Map();
-var cacheVersionListeners = /* @__PURE__ */ new Map();
-var retryAttempts = /* @__PURE__ */ new Map();
-function useStorageUrl() {
-  const db = useIndexedDB({
-    dbName: "polstudios",
-    storeName: "cached-urls"
-  });
-  const storedUrls = useRef4(/* @__PURE__ */ new Map());
-  const supabase = useSupabase();
-  function getCacheVersion(entity) {
-    const key = `${entity.bucketId}${entity.path}`;
-    return cacheVersions.get(key) || 0;
-  }
-  function subscribeToCacheVersion(entity_0, callback) {
-    const key_0 = `${entity_0.bucketId}${entity_0.path}`;
-    if (!cacheVersionListeners.has(key_0)) {
-      cacheVersionListeners.set(key_0, /* @__PURE__ */ new Set());
-    }
-    cacheVersionListeners.get(key_0).add(callback);
-    return () => {
-      cacheVersionListeners.get(key_0)?.delete(callback);
-    };
-  }
-  async function expireCache(entity_1) {
-    const key_1 = `${entity_1.bucketId}${entity_1.path}`;
-    const dbKeys = await db.getAllKeys();
-    const keysToDelete = Array.from(new Set([...Array.from(storedUrls.current.keys()), ...dbKeys].filter((value) => value.startsWith(key_1))));
-    await Promise.all(keysToDelete.map(async (x) => {
-      storedUrls.current.delete(x);
-      await db.removeItem(x);
-    }));
-    const currentVersion = cacheVersions.get(key_1) || 0;
-    cacheVersions.set(key_1, currentVersion + 1);
-    const listeners = cacheVersionListeners.get(key_1);
-    if (listeners) {
-      listeners.forEach((callback_0) => {
-        callback_0();
-      });
-    }
-  }
-  async function baseFetchUrl(entity_2, options, isPublic = false) {
-    if (isUsable(entity_2) === false) return;
-    const optionsString = JSON.stringify(options);
-    if (isUsable(entity_2.bucketId) === false) {
-      return;
-    }
-    if (isUsable(entity_2.path) === false) {
-      return;
-    }
-    const key_2 = `${entity_2.bucketId}${entity_2.path}${optionsString ?? ""}-cached-url`;
-    const inMemoryItem = storedUrls.current.get(key_2);
-    let item = inMemoryItem;
-    if (isUsable(inMemoryItem) === false) {
-      item = await db.getItem(key_2) ?? void 0;
-      if (isUsable(item)) {
-      }
-    } else {
-    }
-    if (isUsable(item) && (0, import_moment2.default)(item.expiresOn).isAfter((0, import_moment2.default)().add(-1 * 60, "seconds"))) {
-      return item.url;
-    }
-    const base = supabase.storage.from(entity_2.bucketId);
-    let download = options?.download;
-    if (typeof options?.download === "string") {
-      const ext = entity_2.path.split(".").pop() ?? "";
-      download = options?.download.endsWith(ext) ? options?.download : options?.download + "." + ext;
-    }
-    const newOptions = options ? {
-      ...options,
-      download
-    } : void 0;
-    const retryKey = `${entity_2.bucketId}/${entity_2.path}`;
-    const currentRetries = retryAttempts.get(retryKey) || 0;
-    let url;
-    if (isPublic) {
-      url = base.getPublicUrl(entity_2.path, newOptions).data.publicUrl;
-    } else {
-      try {
-        console.log("Creating signed URL for", entity_2.path);
-        const result = await base.createSignedUrl(entity_2.path, 60 * 100, newOptions);
-        url = result.data?.signedUrl;
-        if (isUsable(url)) {
-          retryAttempts.delete(retryKey);
-        } else if (currentRetries < 3) {
-          retryAttempts.set(retryKey, currentRetries + 1);
-          throw new Error("Failed to get signed URL");
-        }
-      } catch (error) {
-        if (currentRetries < 3) {
-          retryAttempts.set(retryKey, currentRetries + 1);
-          const delay = Math.min(1e3 * Math.pow(2, currentRetries), 5e3);
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          return baseFetchUrl(entity_2, options, isPublic);
-        }
-        retryAttempts.delete(retryKey);
-        return void 0;
-      }
-    }
-    if (isUsable(url) === false) return url;
-    const cachedUrl = {
-      key: key_2,
-      url,
-      expiresOn: (0, import_moment2.default)().add(60 * 100, "seconds").toISOString(true)
-    };
-    storedUrls.current.set(key_2, cachedUrl);
-    db.setItem(key_2, cachedUrl);
-    return url;
-  }
-  async function fetchUrl(entity_3, options_0) {
-    return baseFetchUrl(entity_3, options_0, false);
-  }
-  async function fetchPublicUrl(entity_4, options_1) {
-    return baseFetchUrl(entity_4, options_1, true);
-  }
-  async function prefetchImage(entity_5, options_2) {
-    const url_0 = await fetchUrl(entity_5, options_2);
-    if (url_0) {
-      new Image().src = url_0;
-    }
-  }
-  async function fetchUrls(entities, options_3) {
-    const results = /* @__PURE__ */ new Map();
-    if (entities.length === 0) return results;
-    const optionsString_0 = JSON.stringify(options_3);
-    const expirySeconds = 60 * 100;
-    const byBucket = /* @__PURE__ */ new Map();
-    for (const entity_6 of entities) {
-      if (!isUsable(entity_6.bucketId) || !isUsable(entity_6.path)) continue;
-      const list = byBucket.get(entity_6.bucketId) ?? [];
-      list.push(entity_6);
-      byBucket.set(entity_6.bucketId, list);
-    }
-    for (const [bucketId, bucketEntities] of byBucket) {
-      const uncached = [];
-      for (const entity_7 of bucketEntities) {
-        const key_3 = `${entity_7.bucketId}${entity_7.path}${optionsString_0 ?? ""}-cached-url`;
-        const entityKey = `${entity_7.bucketId}/${entity_7.path}`;
-        let item_0 = storedUrls.current.get(key_3);
-        if (!isUsable(item_0)) {
-          item_0 = await db.getItem(key_3) ?? void 0;
-        }
-        if (isUsable(item_0) && (0, import_moment2.default)(item_0.expiresOn).isAfter((0, import_moment2.default)().add(-1 * 60, "seconds"))) {
-          results.set(entityKey, item_0.url);
-        } else {
-          uncached.push(entity_7);
-        }
-      }
-      if (uncached.length > 0) {
-        const paths = uncached.map((e) => e.path);
-        const base_0 = supabase.storage.from(bucketId);
-        try {
-          console.log("Signed URLs created");
-          const {
-            data,
-            error: error_0
-          } = await base_0.createSignedUrls(paths, expirySeconds);
-          if (!error_0 && data) {
-            const expiresOn = (0, import_moment2.default)().add(expirySeconds, "seconds").toISOString(true);
-            for (let i = 0; i < uncached.length; i++) {
-              const entity_9 = uncached[i];
-              const urlData = data[i];
-              const entityKey_1 = `${entity_9.bucketId}/${entity_9.path}`;
-              const cacheKey = `${entity_9.bucketId}${entity_9.path}${optionsString_0 ?? ""}-cached-url`;
-              if (urlData?.signedUrl) {
-                results.set(entityKey_1, urlData.signedUrl);
-                const cachedUrl_0 = {
-                  key: cacheKey,
-                  url: urlData.signedUrl,
-                  expiresOn
-                };
-                storedUrls.current.set(cacheKey, cachedUrl_0);
-                db.setItem(cacheKey, cachedUrl_0);
-              } else {
-                results.set(entityKey_1, void 0);
-              }
-            }
-          } else {
-            for (const entity_10 of uncached) {
-              const entityKey_2 = `${entity_10.bucketId}/${entity_10.path}`;
-              const url_2 = await fetchUrl(entity_10, options_3);
-              results.set(entityKey_2, url_2);
-            }
-          }
-        } catch {
-          for (const entity_8 of uncached) {
-            const entityKey_0 = `${entity_8.bucketId}/${entity_8.path}`;
-            const url_1 = await fetchUrl(entity_8, options_3);
-            results.set(entityKey_0, url_1);
-          }
-        }
-      }
-    }
-    return results;
-  }
-  return {
-    fetchUrl,
-    fetchUrls,
-    prefetchImage,
-    fetchPublicUrl,
-    expireCache,
-    getCacheVersion,
-    subscribeToCacheVersion
-  };
-}
-
-// src/storage/useStoragePath.ts
-import { c as _c6 } from "react/compiler-runtime";
-import { useEffect as useEffect6, useState as useState4 } from "react";
-function getContentType(metadata, path) {
-  if (metadata?.contentType) {
-    return metadata.contentType;
-  }
-  const ext = path.split(".").pop()?.toUpperCase();
-  return ext || "Unknown";
-}
-function useStoragePath(storagePath, bucketId, t0) {
-  const $ = _c6(40);
-  let t1;
-  if ($[0] !== t0) {
-    t1 = t0 === void 0 ? {} : t0;
-    $[0] = t0;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const options = t1;
-  const {
-    fetchMetadata: t2,
-    transform,
-    download
-  } = options;
-  const fetchMetadata = t2 === void 0 ? true : t2;
-  const [url, setUrl] = useState4(null);
-  const [error, setError] = useState4(null);
-  const {
-    fetchUrl
-  } = useStorageUrl();
-  const supabase = useSupabase();
-  let t3;
-  if ($[2] !== bucketId || $[3] !== download || $[4] !== fetchUrl || $[5] !== storagePath || $[6] !== transform) {
-    t3 = () => {
-      if (!isUsable(storagePath) || !isUsable(bucketId)) {
-        setUrl(null);
-        return;
-      }
-      let cancelled = false;
-      fetchUrl({
-        bucketId,
-        path: storagePath
-      }, {
-        transform,
-        download
-      }).then((signedUrl) => {
-        if (!cancelled) {
-          setUrl(signedUrl ?? null);
-          setError(null);
-        }
-      }).catch((err) => {
-        if (!cancelled) {
-          setError(err instanceof Error ? err : new Error(String(err)));
-          setUrl(null);
-        }
-      });
-      return () => {
-        cancelled = true;
-      };
-    };
-    $[2] = bucketId;
-    $[3] = download;
-    $[4] = fetchUrl;
-    $[5] = storagePath;
-    $[6] = transform;
-    $[7] = t3;
-  } else {
-    t3 = $[7];
-  }
-  let t4;
-  if ($[8] !== transform) {
-    t4 = JSON.stringify(transform);
-    $[8] = transform;
-    $[9] = t4;
-  } else {
-    t4 = $[9];
-  }
-  let t5;
-  if ($[10] !== bucketId || $[11] !== download || $[12] !== storagePath || $[13] !== t4) {
-    t5 = [storagePath, bucketId, t4, download];
-    $[10] = bucketId;
-    $[11] = download;
-    $[12] = storagePath;
-    $[13] = t4;
-    $[14] = t5;
-  } else {
-    t5 = $[14];
-  }
-  useEffect6(t3, t5);
-  let t6;
-  if ($[15] !== bucketId || $[16] !== storagePath || $[17] !== supabase) {
-    t6 = supabase.schema("storage").from("objects").select("metadata").eq("bucket_id", bucketId).eq("name", storagePath ?? "").maybeSingle();
-    $[15] = bucketId;
-    $[16] = storagePath;
-    $[17] = supabase;
-    $[18] = t6;
-  } else {
-    t6 = $[18];
-  }
-  const storageQuery = t6;
-  let t7;
-  if ($[19] !== bucketId || $[20] !== fetchMetadata || $[21] !== storagePath) {
-    t7 = fetchMetadata && isUsable(storagePath) && isUsable(bucketId);
-    $[19] = bucketId;
-    $[20] = fetchMetadata;
-    $[21] = storagePath;
-    $[22] = t7;
-  } else {
-    t7 = $[22];
-  }
-  let t8;
-  if ($[23] !== t7) {
-    t8 = {
-      enabled: t7
-    };
-    $[23] = t7;
-    $[24] = t8;
-  } else {
-    t8 = $[24];
-  }
-  const metadataRequest = useDbQuery(storageQuery, t8);
-  const metadata = metadataRequest.data?.metadata ?? null;
-  const t9 = storagePath ?? "";
-  let t10;
-  if ($[25] !== metadata || $[26] !== t9) {
-    t10 = getContentType(metadata, t9);
-    $[25] = metadata;
-    $[26] = t9;
-    $[27] = t10;
-  } else {
-    t10 = $[27];
-  }
-  const contentType = t10;
-  let t11;
-  if ($[28] !== error || $[29] !== fetchMetadata || $[30] !== metadataRequest.isFetching || $[31] !== storagePath || $[32] !== url) {
-    t11 = isUsable(storagePath) && url === null && error === null || fetchMetadata && metadataRequest.isFetching;
-    $[28] = error;
-    $[29] = fetchMetadata;
-    $[30] = metadataRequest.isFetching;
-    $[31] = storagePath;
-    $[32] = url;
-    $[33] = t11;
-  } else {
-    t11 = $[33];
-  }
-  const isLoading = t11;
-  let t12;
-  if ($[34] !== contentType || $[35] !== error || $[36] !== isLoading || $[37] !== metadata || $[38] !== url) {
-    t12 = {
-      url,
-      metadata,
-      contentType,
-      isLoading,
-      error
-    };
-    $[34] = contentType;
-    $[35] = error;
-    $[36] = isLoading;
-    $[37] = metadata;
-    $[38] = url;
-    $[39] = t12;
-  } else {
-    t12 = $[39];
-  }
-  return t12;
-}
-
-// src/storage/bucketConfig.ts
-var BUCKETS = {
-  AVATARS: "avatars",
-  FIXTURE_CATALOG_COVER: "fixture-catalog-cover",
-  FIXTURE_ATTACHMENTS: "fixture-attachments",
-  UNIT_DOCUMENTATION: "unit-documentation-attachments",
-  DATASHEETS: "datasheets",
-  PATTERNS: "patterns",
-  LOGOS: "logos",
-  RECEIPTS: "receipts",
-  TICKET_ATTACHMENTS: "ticket-attachment",
-  PROCESS_RESULTS: "process-results",
-  DATA_EXCHANGE_IMPORTS: "data-exchange-imports",
-  EMAIL_TEMPLATES: "email-templates",
-  EMAIL_TEMPLATES_ASSETS: "email-templates-assets"
-};
-
-// src/utilities/query-utils.ts
-function createInCondition(column, values) {
-  let condition = "";
-  if (values.length > 2e3) {
-    throw new Error("Too many values to create in condition");
-  }
-  chunkArray(values, 99).forEach((x, index) => {
-    if (index == 0) {
-      condition = `${column}.in.(${x.join(",")})`;
-      return;
-    }
-    condition += `,${column}.in.(${x.join(",")})`;
-  });
-  return condition;
-}
-
-// src/useDbDelete.ts
-import { c as _c7 } from "react/compiler-runtime";
-import { useMutation } from "@tanstack/react-query";
-function useDbDelete(relation, t0) {
-  const $ = _c7(14);
-  let t1;
-  if ($[0] !== t0) {
-    t1 = t0 === void 0 ? ["id"] : t0;
-    $[0] = t0;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const primaryKeys = t1;
-  const tableName = typeof relation === "object" ? relation.table : relation;
-  const schemaName = typeof relation === "object" ? relation.schema : "public";
-  const supabase = useSupabase();
-  let t2;
-  if ($[2] !== primaryKeys) {
-    t2 = primaryKeys.map(_temp);
-    $[2] = primaryKeys;
-    $[3] = t2;
-  } else {
-    t2 = $[3];
-  }
-  const t3 = t2;
-  let t4;
-  if ($[4] !== schemaName || $[5] !== t3 || $[6] !== tableName) {
-    t4 = {
-      primaryKeys: t3,
-      table: tableName,
-      schema: schemaName
-    };
-    $[4] = schemaName;
-    $[5] = t3;
-    $[6] = tableName;
-    $[7] = t4;
-  } else {
-    t4 = $[7];
-  }
-  const deleteItem = useDeleteItem(t4);
-  let t5;
-  if ($[8] !== deleteItem || $[9] !== primaryKeys || $[10] !== schemaName || $[11] !== supabase || $[12] !== tableName) {
-    t5 = {
-      mutationFn: async (item) => {
-        if (Array.isArray(item)) {
-          throw new Error("Item cannot be an array.");
-        }
-        const deleteQuery = supabase.schema(schemaName).from(tableName).delete();
-        primaryKeys.forEach((key) => {
-          const keyStr = String(key);
-          const value = item[keyStr];
-          if (isUsable(value)) {
-            deleteQuery.eq(keyStr, value);
-          }
-        });
-        const response = await deleteQuery.select().single();
-        if (response.error) {
-          throw response.error;
-        }
-        if (response.data) {
-          deleteItem(response.data);
-        } else {
-          deleteItem(item);
-        }
-        return response.data;
-      }
-    };
-    $[8] = deleteItem;
-    $[9] = primaryKeys;
-    $[10] = schemaName;
-    $[11] = supabase;
-    $[12] = tableName;
-    $[13] = t5;
-  } else {
-    t5 = $[13];
-  }
-  const deleteMutation = useMutation(t5);
-  return deleteMutation;
-}
-function _temp(k) {
-  return String(k);
-}
-
-// src/useDbMultiUpsert.ts
-import { c as _c8 } from "react/compiler-runtime";
-import { useMutation as useMutation2 } from "@tanstack/react-query";
-function useDbMultiUpsert(relation, t0, t1) {
-  const $ = _c8(17);
-  let t2;
-  if ($[0] !== t0) {
-    t2 = t0 === void 0 ? ["id"] : t0;
-    $[0] = t0;
-    $[1] = t2;
-  } else {
-    t2 = $[1];
-  }
-  const primaryKeys = t2;
-  const query = t1 === void 0 ? "*" : t1;
-  const supabase = useSupabase();
-  const tableName = typeof relation === "object" ? relation.table : relation;
-  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
-  const t3 = relation;
-  let t4;
-  if ($[2] !== primaryKeys || $[3] !== t3) {
-    t4 = {
-      primaryKeys,
-      table: t3,
-      schema: "public"
-    };
-    $[2] = primaryKeys;
-    $[3] = t3;
-    $[4] = t4;
-  } else {
-    t4 = $[4];
-  }
-  const upsertItem = useUpsertItem(t4);
-  let t5;
-  if ($[5] !== primaryKeys) {
-    t5 = primaryKeys.map(_temp3);
-    $[5] = primaryKeys;
-    $[6] = t5;
-  } else {
-    t5 = $[6];
-  }
-  const primaryKeysAsStrings = t5;
-  let t6;
-  if ($[7] !== primaryKeys || $[8] !== primaryKeysAsStrings || $[9] !== query || $[10] !== schemaName || $[11] !== supabase || $[12] !== tableName) {
-    t6 = async function upsertItemAction2(item) {
-      let task;
-      if (Object.keys(item).length !== primaryKeys.length && primaryKeys.every((key_0) => key_0 in item && isUsable(item[key_0]))) {
-        const updateObject = omit(item, primaryKeysAsStrings);
-        task = supabase.schema(schemaName).from(tableName).update(updateObject);
-        primaryKeys.forEach((key) => {
-          task = task.eq(String(key), item[key]);
-        });
-      } else {
-        task = supabase.schema(schemaName).from(tableName).insert(omit(item, primaryKeysAsStrings));
-      }
-      const response = await task.select(query);
-      if (response.error) {
-        throw response.error;
-      }
-      return response.data[0];
-    };
-    $[7] = primaryKeys;
-    $[8] = primaryKeysAsStrings;
-    $[9] = query;
-    $[10] = schemaName;
-    $[11] = supabase;
-    $[12] = tableName;
-    $[13] = t6;
-  } else {
-    t6 = $[13];
-  }
-  const upsertItemAction = t6;
-  let t7;
-  if ($[14] !== upsertItem || $[15] !== upsertItemAction) {
-    t7 = {
-      mutationFn: async (item_0) => {
-        if (Array.isArray(item_0)) {
-          const data = await Promise.all(item_0.map((x) => upsertItemAction(x)));
-          data.filter(_temp2).forEach((x_1) => upsertItem(x_1));
-          return data;
-        }
-        throw new Error("Item must be an array.");
-      }
-    };
-    $[14] = upsertItem;
-    $[15] = upsertItemAction;
-    $[16] = t7;
-  } else {
-    t7 = $[16];
-  }
-  const updateMutation = useMutation2(t7);
-  return updateMutation;
-}
-function _temp2(x_0) {
-  return isUsable(x_0);
-}
-function _temp3(k) {
-  return String(k);
-}
-
-// src/useDbMultiDelete.ts
-import { c as _c9 } from "react/compiler-runtime";
-import { useMutation as useMutation3 } from "@tanstack/react-query";
-function useDbMultiDelete(relation, t0) {
-  const $ = _c9(10);
-  let t1;
-  if ($[0] !== t0) {
-    t1 = t0 === void 0 ? ["id"] : t0;
-    $[0] = t0;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const primaryKeys = t1;
-  const tableName = typeof relation === "object" ? relation.table : relation;
-  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
-  const supabase = useSupabase();
-  let t2;
-  if ($[2] !== primaryKeys) {
-    t2 = primaryKeys.map(_temp4);
-    $[2] = primaryKeys;
-    $[3] = t2;
-  } else {
-    t2 = $[3];
-  }
-  const primaryKeysAsStrings = t2;
-  const t3 = supabase;
-  let t4;
-  if ($[4] !== schemaName || $[5] !== t3 || $[6] !== tableName) {
-    t4 = t3.schema(schemaName).from(tableName);
-    $[4] = schemaName;
-    $[5] = t3;
-    $[6] = tableName;
-    $[7] = t4;
-  } else {
-    t4 = $[7];
-  }
-  const deleteManyMutation = useDeleteManyMutation(t4, primaryKeysAsStrings);
-  let t5;
-  if ($[8] !== deleteManyMutation) {
-    t5 = {
-      mutationFn: async (item) => {
-        if (Array.isArray(item)) {
-          const response = await deleteManyMutation.mutateAsync(item);
-          return response;
-        } else {
-          throw new Error("Item must be an array.");
-        }
-      }
-    };
-    $[8] = deleteManyMutation;
-    $[9] = t5;
-  } else {
-    t5 = $[9];
-  }
-  const deleteMutation = useMutation3(t5);
-  return deleteMutation;
-}
-function _temp4(k) {
-  return String(k);
-}
-
-// src/changelog/useChangelogMutations.ts
-import { c as _c10 } from "react/compiler-runtime";
-var useUpsertChangelog = () => {
-  const $ = _c10(1);
-  let t0;
-  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
-    t0 = {
-      invalidateTables: ["Changelog", "ChangelogEntry", "ChangelogMedia"]
-    };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  return useDbUpsert("Changelog", t0);
-};
-var useDeleteChangelog = () => {
-  return useDbDelete("Changelog");
-};
-var useUpsertChangelogEntry = () => {
-  const $ = _c10(1);
-  let t0;
-  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
-    t0 = {
-      invalidateTables: ["ChangelogEntry", "ChangelogMedia"]
-    };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  return useDbUpsert("ChangelogEntry", t0);
-};
-var useMultiUpsertChangelogEntries = () => {
-  const $ = _c10(1);
-  let t0;
-  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
-    t0 = ["id"];
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  return useDbMultiUpsert("ChangelogEntry", t0, "*, ChangelogMedia (*)");
-};
-var useDeleteChangelogEntry = () => {
-  return useDbDelete("ChangelogEntry");
-};
-var useMultiDeleteChangelogEntries = () => {
-  return useDbMultiDelete("ChangelogEntry");
-};
-var useUpsertChangelogMedia = () => {
-  const $ = _c10(1);
-  let t0;
-  if ($[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
-    t0 = {
-      invalidateTables: ["ChangelogMedia"]
-    };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  return useDbUpsert("ChangelogMedia", t0);
-};
-var useDeleteChangelogMedia = () => {
-  return useDbDelete("ChangelogMedia");
-};
-var useUploadChangelogMedia = () => {
-  return {
-    mutateAsync: async () => ({
-      path: "",
-      publicUrl: ""
-    })
-  };
-};
-
-// src/useDbRealtime.ts
-import { c as _c11 } from "react/compiler-runtime";
-import { useEffect as useEffect7, useState as useState5, useRef as useRef5 } from "react";
-import { REALTIME_POSTGRES_CHANGES_LISTEN_EVENT } from "@supabase/supabase-js";
-import { useDelayedValue } from "@pol-studios/hooks/state";
-function useDbRealtime(key, query, table, primaryKeys, options) {
-  const $ = _c11(37);
-  const supabase = useSupabase();
-  const tableNameValue = typeof table === "string" ? table : table.table;
-  const schemaValue = typeof table === "string" ? "public" : table.schema;
-  const queriesForTable = useQueriesForTableLoader(tableNameValue);
-  let t0;
-  if ($[0] !== primaryKeys || $[1] !== schemaValue || $[2] !== tableNameValue) {
-    t0 = {
-      primaryKeys,
-      table: tableNameValue,
-      schema: schemaValue
-    };
-    $[0] = primaryKeys;
-    $[1] = schemaValue;
-    $[2] = tableNameValue;
-    $[3] = t0;
-  } else {
-    t0 = $[3];
-  }
-  const deleteItem = useDeleteItem(t0);
-  let t1;
-  if ($[4] !== primaryKeys || $[5] !== schemaValue || $[6] !== tableNameValue) {
-    t1 = {
-      primaryKeys,
-      table: tableNameValue,
-      schema: schemaValue
-    };
-    $[4] = primaryKeys;
-    $[5] = schemaValue;
-    $[6] = tableNameValue;
-    $[7] = t1;
-  } else {
-    t1 = $[7];
-  }
-  const upsertItem = useUpsertItem(t1);
-  const [realtimeState, setRealtimeState] = useState5("CLOSED");
-  const [retryTick, setRetryTick] = useState5(0);
-  const channelRef = useRef5(null);
-  const lastRetryTimeRef = useRef5(0);
-  const retryCountRef = useRef5(0);
-  const enabled = options?.enabled ?? true;
-  const filter = options?.filter;
-  const onChange = options?.onChange;
-  const debouncedKey = useDelayedValue(key, 50);
-  let t2;
-  if ($[8] !== deleteItem || $[9] !== enabled || $[10] !== filter || $[11] !== onChange || $[12] !== primaryKeys || $[13] !== queriesForTable || $[14] !== query || $[15] !== retryTick || $[16] !== schemaValue || $[17] !== supabase || $[18] !== tableNameValue || $[19] !== upsertItem) {
-    t2 = () => {
-      if (!enabled) {
-        if (channelRef.current) {
-          channelRef.current.unsubscribe();
-          supabase.removeChannel(channelRef.current);
-          channelRef.current = null;
-        }
-        setRealtimeState("CLOSED");
-        return;
-      }
-      const now = Date.now();
-      const timeSinceLastRetry = now - lastRetryTimeRef.current;
-      if (timeSinceLastRetry < 2e3 && retryTick > 0) {
-        return;
-      }
-      if (channelRef.current) {
-        channelRef.current.unsubscribe();
-        supabase.removeChannel(channelRef.current);
-        channelRef.current = null;
-      }
-      lastRetryTimeRef.current = now;
-      retryCountRef.current = retryCountRef.current + 1;
-      const channel = supabase.channel(newUuid()).on("postgres_changes", {
-        event: "*",
-        schema: schemaValue,
-        table: tableNameValue,
-        filter
-      }, async (payload) => {
-        let data = payload.new ?? payload.old;
-        if (payload.new && Object.keys(payload.new).length > 0) {
-          const selectQuery = buildNormalizedQuery({
-            queriesForTable,
-            query
-          });
-          if (payload.eventType !== REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE && selectQuery) {
-            if (selectQuery.groupedUserQueryPaths?.every((x) => x.path in data) === false) {
-              const qb = supabase.schema(payload.schema).from(payload.table).select(selectQuery.selectQuery);
-              for (const pk of primaryKeys) {
-                qb.eq(pk.toString(), data[pk]);
-              }
-              const res = await qb.single();
-              if (res.data) {
-                data = normalizeResponse(selectQuery.groupedPaths, res.data);
-              }
-            }
-          }
-          if ("changedBySessionId" in data) {
-            const sessionId = data.changedBySessionId;
-            if (sessionId !== UserSessionId) {
-              await upsertItem(data);
-            }
-          } else {
-            await upsertItem(data);
-          }
-        }
-        if (payload.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE) {
-          await deleteItem(payload.old);
-        }
-        if (payload.errors?.length > 0) {
-          setRealtimeState("CHANNEL_ERROR");
-        }
-        if (onChange) {
-          onChange(payload);
-        }
-      }).on("postgres_changes", {
-        event: "DELETE",
-        schema: schemaValue,
-        table: tableNameValue
-      }, async (payload_0) => {
-        if (payload_0.eventType === REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.DELETE) {
-          await deleteItem(payload_0.old);
-        }
-      }).subscribe((status) => {
-        setRealtimeState(status);
-        if (status === "SUBSCRIBED") {
-          retryCountRef.current = 0;
-        }
-      });
-      channelRef.current = channel;
-      return () => {
-        if (channelRef.current) {
-          channelRef.current.unsubscribe();
-          supabase.removeChannel(channelRef.current);
-          channelRef.current = null;
-        }
-      };
-    };
-    $[8] = deleteItem;
-    $[9] = enabled;
-    $[10] = filter;
-    $[11] = onChange;
-    $[12] = primaryKeys;
-    $[13] = queriesForTable;
-    $[14] = query;
-    $[15] = retryTick;
-    $[16] = schemaValue;
-    $[17] = supabase;
-    $[18] = tableNameValue;
-    $[19] = upsertItem;
-    $[20] = t2;
-  } else {
-    t2 = $[20];
-  }
-  let t3;
-  if ($[21] !== primaryKeys) {
-    t3 = primaryKeys.join(",");
-    $[21] = primaryKeys;
-    $[22] = t3;
-  } else {
-    t3 = $[22];
-  }
-  let t4;
-  if ($[23] !== debouncedKey || $[24] !== enabled || $[25] !== filter || $[26] !== query || $[27] !== retryTick || $[28] !== schemaValue || $[29] !== supabase || $[30] !== t3 || $[31] !== tableNameValue) {
-    t4 = [supabase, tableNameValue, schemaValue, enabled, filter, query, t3, retryTick, debouncedKey];
-    $[23] = debouncedKey;
-    $[24] = enabled;
-    $[25] = filter;
-    $[26] = query;
-    $[27] = retryTick;
-    $[28] = schemaValue;
-    $[29] = supabase;
-    $[30] = t3;
-    $[31] = tableNameValue;
-    $[32] = t4;
-  } else {
-    t4 = $[32];
-  }
-  useEffect7(t2, t4);
-  let t5;
-  let t6;
-  if ($[33] !== enabled || $[34] !== realtimeState) {
-    t5 = () => {
-      if (!enabled || realtimeState === "SUBSCRIBED") {
-        retryCountRef.current = 0;
-        return;
-      }
-      const delay = Math.min(5e3 * Math.pow(2, retryCountRef.current), 6e4);
-      const id = setTimeout(() => {
-        setRetryTick(_temp5);
-      }, delay);
-      return () => clearTimeout(id);
-    };
-    t6 = [realtimeState, enabled];
-    $[33] = enabled;
-    $[34] = realtimeState;
-    $[35] = t5;
-    $[36] = t6;
-  } else {
-    t5 = $[35];
-    t6 = $[36];
-  }
-  useEffect7(t5, t6);
-  return realtimeState;
-}
-function _temp5(t) {
-  return t + 1;
-}
-
-// src/useDbRealtimeQuery.tsx
-import { c as _c12 } from "react/compiler-runtime";
-function convertFilterToRealtimeQuery(filters) {
-  function convert(filter) {
-    if (!filter) return "";
-    if ("path" in filter) {
-      if (filter.path.includes(".")) return "";
-      let valueString = filter.value?.toString() ?? "null";
-      if (filter.operator === "in") {
-        valueString = '("' + valueString.slice(2, valueString.length - 2).split(",").join('","') + '")';
-      }
-      return `${filter.path}=${filter.negate ? "not." : ""}${filter.operator}.${valueString}`;
-    } else {
-      if (filter.or) {
-        return `(${filter.or.map((f) => convert(f)).join("|")})`;
-      } else if (filter.and) {
-        return `(${filter.and.map((f) => convert(f)).join("&")})`;
-      }
-    }
-    return "";
-  }
-  return convert(filters[0]);
-}
-function useDbRealtimeQuery(query, config, t0) {
-  const $ = _c12(27);
-  let t1;
-  if ($[0] !== t0) {
-    t1 = t0 === void 0 ? ["id"] : t0;
-    $[0] = t0;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const primaryKeys = t1;
-  const t2 = query;
-  let t3;
-  if ($[2] !== t2) {
-    t3 = new PostgrestParser(t2);
-    $[2] = t2;
-    $[3] = t3;
-  } else {
-    t3 = $[3];
-  }
-  const parser = t3;
-  const request = useQuery(query, config);
-  let filter;
-  let selectStatement;
-  let t4;
-  let t5;
-  if ($[4] !== parser.filters || $[5] !== parser.select || $[6] !== query || $[7] !== request.data) {
-    const queryKey = encode(query, false);
-    let t62;
-    if ($[12] !== parser.filters || $[13] !== request.data) {
-      const filterString = convertFilterToRealtimeQuery(parser.filters);
-      filter = request.data && typeof request.data === "object" && "id" in request.data ? "id=eq." + request.data.id : filterString;
-      if (filter.includes('in.(\\"\\")')) {
-        filter = void 0;
-      }
-      t62 = isNullOrWhitespace(filter);
-      $[12] = parser.filters;
-      $[13] = request.data;
-      $[14] = filter;
-      $[15] = t62;
-    } else {
-      filter = $[14];
-      t62 = $[15];
-    }
-    if (t62) {
-      filter = void 0;
-    }
-    selectStatement = parser.select;
-    t4 = useDbRealtime;
-    t5 = queryKey.join("-");
-    $[4] = parser.filters;
-    $[5] = parser.select;
-    $[6] = query;
-    $[7] = request.data;
-    $[8] = filter;
-    $[9] = selectStatement;
-    $[10] = t4;
-    $[11] = t5;
-  } else {
-    filter = $[8];
-    selectStatement = $[9];
-    t4 = $[10];
-    t5 = $[11];
-  }
-  let t6;
-  if ($[16] !== parser.schema || $[17] !== parser.table) {
-    t6 = {
-      schema: parser.schema,
-      table: parser.table
-    };
-    $[16] = parser.schema;
-    $[17] = parser.table;
-    $[18] = t6;
-  } else {
-    t6 = $[18];
-  }
-  const t7 = typeof config?.enabled === "boolean" ? config.enabled : true;
-  let t8;
-  if ($[19] !== filter || $[20] !== t7) {
-    t8 = {
-      filter,
-      enabled: t7
-    };
-    $[19] = filter;
-    $[20] = t7;
-    $[21] = t8;
-  } else {
-    t8 = $[21];
-  }
-  const realtimeStatus = t4(t5, selectStatement, t6, primaryKeys, t8);
-  const outputRealtimeStatus = request.isFetching ? "Loading..." : realtimeStatus;
-  const t9 = request.data;
-  const t10 = realtimeStatus == "SUBSCRIBED";
-  let t11;
-  if ($[22] !== outputRealtimeStatus || $[23] !== request || $[24] !== t10 || $[25] !== t9) {
-    t11 = {
-      ...request,
-      data: t9,
-      realtimeStatus: outputRealtimeStatus,
-      isRealtimeConnected: t10,
-      isRealtimeLoading: request.isFetching
-    };
-    $[22] = outputRealtimeStatus;
-    $[23] = request;
-    $[24] = t10;
-    $[25] = t9;
-    $[26] = t11;
-  } else {
-    t11 = $[26];
-  }
-  return t11;
-}
-
-// src/changelog/useChangelogQuery.ts
-import { c as _c13 } from "react/compiler-runtime";
-var useChangelogs = (options) => {
-  const supabase = useSupabase();
-  const query = supabase.from("Changelog").select(`
-      *,
-      ChangelogEntry (
-        *,
-        ChangelogMedia (*)
-      )
-    `).order("releaseDate", {
-    ascending: false
-  }).order("order", {
-    foreignTable: "ChangelogEntry",
-    ascending: true
-  }).order("order", {
-    foreignTable: "ChangelogEntry.ChangelogMedia",
-    ascending: true
-  });
-  if (options?.realtime) {
-    return useDbRealtimeQuery(query, {
-      crossOrganization: true
-    });
-  }
-  return useDbQuery(query, {
-    crossOrganization: true
-  });
-};
-var usePublishedChangelogs = (options) => {
-  const supabase = useSupabase();
-  const query = supabase.from("Changelog").select(`
-      *,
-      ChangelogEntry (
-        *,
-        ChangelogMedia (*)
-      )
-    `).eq("isPublished", true).order("releaseDate", {
-    ascending: false
-  }).order("order", {
-    foreignTable: "ChangelogEntry",
-    ascending: true
-  }).order("order", {
-    foreignTable: "ChangelogEntry.ChangelogMedia",
-    ascending: true
-  });
-  if (options?.realtime) {
-    return useDbRealtimeQuery(query, {
-      crossOrganization: true
-    });
-  }
-  return useDbQuery(query, {
-    crossOrganization: true
-  });
-};
-var useChangelogById = (id) => {
-  const $ = _c13(5);
-  const supabase = useSupabase();
-  let t0;
-  if ($[0] !== id || $[1] !== supabase) {
-    t0 = supabase.from("Changelog").select("\n        *,\n        ChangelogEntry (\n          *,\n          ChangelogMedia (*)\n        )\n      ").eq("id", id).order("order", {
-      foreignTable: "ChangelogEntry",
-      ascending: true
-    }).order("order", {
-      foreignTable: "ChangelogEntry.ChangelogMedia",
-      ascending: true
-    }).single();
-    $[0] = id;
-    $[1] = supabase;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  const t1 = !!id;
-  let t2;
-  if ($[3] !== t1) {
-    t2 = {
-      enabled: t1,
-      crossOrganization: true
-    };
-    $[3] = t1;
-    $[4] = t2;
-  } else {
-    t2 = $[4];
-  }
-  return useDbQuery(t0, t2);
-};
-var useChangelogBySlug = (slug) => {
-  const $ = _c13(5);
-  const supabase = useSupabase();
-  let t0;
-  if ($[0] !== slug || $[1] !== supabase) {
-    t0 = supabase.from("Changelog").select("\n        *,\n        ChangelogEntry (\n          *,\n          ChangelogMedia (*)\n        )\n      ").eq("slug", slug).order("order", {
-      foreignTable: "ChangelogEntry",
-      ascending: true
-    }).order("order", {
-      foreignTable: "ChangelogEntry.ChangelogMedia",
-      ascending: true
-    }).single();
-    $[0] = slug;
-    $[1] = supabase;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  const t1 = !!slug;
-  let t2;
-  if ($[3] !== t1) {
-    t2 = {
-      enabled: t1,
-      crossOrganization: true
-    };
-    $[3] = t1;
-    $[4] = t2;
-  } else {
-    t2 = $[4];
-  }
-  return useDbQuery(t0, t2);
-};
-var useChangelogEntries = (changelogId) => {
-  const $ = _c13(5);
-  const supabase = useSupabase();
-  let t0;
-  if ($[0] !== changelogId || $[1] !== supabase) {
-    t0 = supabase.from("ChangelogEntry").select("*, ChangelogMedia (*)").eq("changelogId", changelogId).order("order", {
-      ascending: true
-    }).order("order", {
-      foreignTable: "ChangelogMedia",
-      ascending: true
-    });
-    $[0] = changelogId;
-    $[1] = supabase;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  const t1 = !!changelogId;
-  let t2;
-  if ($[3] !== t1) {
-    t2 = {
-      enabled: t1,
-      crossOrganization: true
-    };
-    $[3] = t1;
-    $[4] = t2;
-  } else {
-    t2 = $[4];
-  }
-  return useDbQuery(t0, t2);
-};
-var useChangelogMedia = (entryId) => {
-  const $ = _c13(5);
-  const supabase = useSupabase();
-  let t0;
-  if ($[0] !== entryId || $[1] !== supabase) {
-    t0 = supabase.from("ChangelogMedia").select("*").eq("changelogEntryId", entryId).order("order", {
-      ascending: true
-    });
-    $[0] = entryId;
-    $[1] = supabase;
-    $[2] = t0;
-  } else {
-    t0 = $[2];
-  }
-  const t1 = !!entryId;
-  let t2;
-  if ($[3] !== t1) {
-    t2 = {
-      enabled: t1,
-      crossOrganization: true
-    };
-    $[3] = t1;
-    $[4] = t2;
-  } else {
-    t2 = $[4];
-  }
-  return useDbQuery(t0, t2);
-};
-
-// src/nl-training/useFeedbackList.ts
-import { c as _c14 } from "react/compiler-runtime";
-import { useQuery as useQuery2 } from "@tanstack/react-query";
-function useFeedbackList(t0) {
-  const $ = _c14(10);
-  let t1;
-  if ($[0] !== t0) {
-    t1 = t0 === void 0 ? {} : t0;
-    $[0] = t0;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const params = t1;
-  const supabase = useSupabase();
-  let t2;
-  if ($[2] !== params) {
-    t2 = ["feedback-list", params];
-    $[2] = params;
-    $[3] = t2;
-  } else {
-    t2 = $[3];
-  }
-  let t3;
-  if ($[4] !== params || $[5] !== supabase) {
-    t3 = async () => {
-      const searchParams = new URLSearchParams();
-      if (params.resolved !== void 0) {
-        searchParams.append("resolved", String(params.resolved));
-      }
-      if (params.status) {
-        searchParams.append("status", params.status);
-      }
-      if (params.limit) {
-        searchParams.append("limit", String(params.limit));
-      }
-      if (params.offset) {
-        searchParams.append("offset", String(params.offset));
-      }
-      if (params.userId) {
-        searchParams.append("userId", params.userId);
-      }
-      if (params.startDate) {
-        searchParams.append("startDate", params.startDate);
-      }
-      if (params.endDate) {
-        searchParams.append("endDate", params.endDate);
-      }
-      const {
-        data,
-        error
-      } = await supabase.functions.invoke("query", {
-        body: {},
-        method: "GET",
-        headers: {
-          "X-Path": `/query/feedback?${searchParams.toString()}`
-        }
-      });
-      if (error) {
-        throw error;
-      }
-      return data;
-    };
-    $[4] = params;
-    $[5] = supabase;
-    $[6] = t3;
-  } else {
-    t3 = $[6];
-  }
-  let t4;
-  if ($[7] !== t2 || $[8] !== t3) {
-    t4 = {
-      queryKey: t2,
-      queryFn: t3
-    };
-    $[7] = t2;
-    $[8] = t3;
-    $[9] = t4;
-  } else {
-    t4 = $[9];
-  }
-  return useQuery2(t4);
-}
-
-// src/nl-training/useSubmitFeedback.ts
-import { c as _c15 } from "react/compiler-runtime";
-import { useMutation as useMutation4, useQueryClient } from "@tanstack/react-query";
-function useSubmitFeedback() {
-  const $ = _c15(7);
-  const supabase = useSupabase();
-  const queryClient = useQueryClient();
-  let t0;
-  if ($[0] !== supabase) {
-    t0 = async (params) => {
-      const {
-        data,
-        error
-      } = await supabase.functions.invoke("query", {
-        body: params,
-        method: "POST",
-        headers: {
-          "X-Path": "/query/feedback"
-        }
-      });
-      if (error) {
-        throw error;
-      }
-      return data;
-    };
-    $[0] = supabase;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  let t1;
-  if ($[2] !== queryClient) {
-    t1 = () => {
-      queryClient.invalidateQueries({
-        queryKey: ["feedback-list"]
-      });
-    };
-    $[2] = queryClient;
-    $[3] = t1;
-  } else {
-    t1 = $[3];
-  }
-  let t2;
-  if ($[4] !== t0 || $[5] !== t1) {
-    t2 = {
-      mutationFn: t0,
-      onSuccess: t1
-    };
-    $[4] = t0;
-    $[5] = t1;
-    $[6] = t2;
-  } else {
-    t2 = $[6];
-  }
-  return useMutation4(t2);
-}
-
-// src/nl-training/useApplyFeedback.ts
-import { c as _c16 } from "react/compiler-runtime";
-import { useMutation as useMutation5, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
-function useApplyFeedback() {
-  const $ = _c16(7);
-  const supabase = useSupabase();
-  const queryClient = useQueryClient2();
-  let t0;
-  if ($[0] !== supabase) {
-    t0 = async (memoryId) => {
-      const {
-        data,
-        error
-      } = await supabase.functions.invoke("query", {
-        body: {},
-        method: "POST",
-        headers: {
-          "X-Path": `/query/feedback/${memoryId}/apply`
-        }
-      });
-      if (error) {
-        throw error;
-      }
-      return data;
-    };
-    $[0] = supabase;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  let t1;
-  if ($[2] !== queryClient) {
-    t1 = () => {
-      queryClient.invalidateQueries({
-        queryKey: ["feedback-list"]
-      });
-    };
-    $[2] = queryClient;
-    $[3] = t1;
-  } else {
-    t1 = $[3];
-  }
-  let t2;
-  if ($[4] !== t0 || $[5] !== t1) {
-    t2 = {
-      mutationFn: t0,
-      onSuccess: t1
-    };
-    $[4] = t0;
-    $[5] = t1;
-    $[6] = t2;
-  } else {
-    t2 = $[6];
-  }
-  return useMutation5(t2);
-}
-
-// src/nl-training/useResolveFeedback.ts
-import { c as _c17 } from "react/compiler-runtime";
-import { useMutation as useMutation6, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
-function useResolveFeedback() {
-  const $ = _c17(7);
-  const supabase = useSupabase();
-  const queryClient = useQueryClient3();
-  let t0;
-  if ($[0] !== supabase) {
-    t0 = async (memoryId) => {
-      const {
-        data,
-        error
-      } = await supabase.functions.invoke("query", {
-        body: {},
-        method: "POST",
-        headers: {
-          "X-Path": `/query/feedback/${memoryId}/resolve`
-        }
-      });
-      if (error) {
-        throw error;
-      }
-      return data;
-    };
-    $[0] = supabase;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  let t1;
-  if ($[2] !== queryClient) {
-    t1 = () => {
-      queryClient.invalidateQueries({
-        queryKey: ["feedback-list"]
-      });
-    };
-    $[2] = queryClient;
-    $[3] = t1;
-  } else {
-    t1 = $[3];
-  }
-  let t2;
-  if ($[4] !== t0 || $[5] !== t1) {
-    t2 = {
-      mutationFn: t0,
-      onSuccess: t1
-    };
-    $[4] = t0;
-    $[5] = t1;
-    $[6] = t2;
-  } else {
-    t2 = $[6];
-  }
-  return useMutation6(t2);
-}
-
-export {
-  useMutationSuccess,
-  useMutationSuccessRN,
-  ADAPTER_STRATEGIES,
-  BackendStatus,
-  AdapterAutoDetector,
-  createAdapterAutoDetector,
-  stripSchemaPrefix,
-  AdapterRegistry,
-  createAdapterRegistry,
-  SupabaseAdapter,
-  createSupabaseAdapter,
-  getErrorBody,
-  useAI,
-  useServerAvailability,
-  useSearchQuery,
-  useLiveChangeTracking,
-  useLatestOperationLog,
-  newTimeActivity,
-  useAutosaveState,
-  useToastError,
-  executeAdvanceQuery,
-  useStorageUrl,
-  useStoragePath,
-  BUCKETS,
-  createInCondition,
-  useDbDelete,
-  useDbMultiUpsert,
-  useDbMultiDelete,
-  useUpsertChangelog,
-  useDeleteChangelog,
-  useUpsertChangelogEntry,
-  useMultiUpsertChangelogEntries,
-  useDeleteChangelogEntry,
-  useMultiDeleteChangelogEntries,
-  useUpsertChangelogMedia,
-  useDeleteChangelogMedia,
-  useUploadChangelogMedia,
-  useDbRealtime,
-  convertFilterToRealtimeQuery,
-  useDbRealtimeQuery,
-  useChangelogs,
-  usePublishedChangelogs,
-  useChangelogById,
-  useChangelogBySlug,
-  useChangelogEntries,
-  useChangelogMedia,
-  useFeedbackList,
-  useSubmitFeedback,
-  useApplyFeedback,
-  useResolveFeedback
-};
-//# sourceMappingURL=chunk-O7SETNGD.js.map