@haex-space/vault-sdk 2.3.16 → 2.5.0

package/dist/svelte.mjs

@@ -335,9 +335,47 @@ var HAEXTENSION_EVENTS = {
   /** Context (theme, locale, platform) has changed */
   CONTEXT_CHANGED: "haextension:context:changed",
   /** Search request from HaexHub */
-  SEARCH_REQUEST: "haextension:search:request",
-  /** External request from authorized client (browser extension, CLI, server, etc.) */
-  EXTERNAL_REQUEST: "haextension:external:request"
+  SEARCH_REQUEST: "haextension:search:request"
+};
+
+// src/types.ts
+var DEFAULT_TIMEOUT = 3e4;
+var TABLE_SEPARATOR = "__";
+function getTableName(publicKey, extensionName, tableName) {
+  return `${publicKey}${TABLE_SEPARATOR}${extensionName}${TABLE_SEPARATOR}${tableName}`;
+}
+var HaexVaultSdkError = class extends Error {
+  constructor(code, messageKey, details) {
+    super(messageKey);
+    this.code = code;
+    this.messageKey = messageKey;
+    this.details = details;
+    this.name = "HaexVaultSdkError";
+  }
+  /**
+   * Get localized error message
+   * @param locale - Locale code (e.g., 'en', 'de')
+   * @param translations - Translation object
+   */
+  getLocalizedMessage(locale = "en", translations) {
+    if (!translations || !translations[locale]) {
+      return this.messageKey;
+    }
+    let message = translations[locale][this.messageKey] || this.messageKey;
+    if (this.details) {
+      Object.entries(this.details).forEach(([key, value]) => {
+        message = message.replace(`{${key}}`, String(value));
+      });
+    }
+    return message;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.messageKey,
+      details: this.details
+    };
+  }
 };
 
 // src/methods.ts
@@ -401,46 +439,6 @@ var HAEXTENSION_METHODS = {
   }
 };
 
-// src/types.ts
-var DEFAULT_TIMEOUT = 3e4;
-var TABLE_SEPARATOR = "__";
-function getTableName(publicKey, extensionName, tableName) {
-  return `${publicKey}${TABLE_SEPARATOR}${extensionName}${TABLE_SEPARATOR}${tableName}`;
-}
-var HaexHubError = class extends Error {
-  constructor(code, messageKey, details) {
-    super(messageKey);
-    this.code = code;
-    this.messageKey = messageKey;
-    this.details = details;
-    this.name = "HaexHubError";
-  }
-  /**
-   * Get localized error message
-   * @param locale - Locale code (e.g., 'en', 'de')
-   * @param translations - Translation object
-   */
-  getLocalizedMessage(locale = "en", translations) {
-    if (!translations || !translations[locale]) {
-      return this.messageKey;
-    }
-    let message = translations[locale][this.messageKey] || this.messageKey;
-    if (this.details) {
-      Object.entries(this.details).forEach(([key, value]) => {
-        message = message.replace(`{${key}}`, String(value));
-      });
-    }
-    return message;
-  }
-  toJSON() {
-    return {
-      code: this.code,
-      message: this.messageKey,
-      details: this.details
-    };
-  }
-};
-
 // src/api/storage.ts
 var StorageAPI = class {
   constructor(client) {
@@ -983,548 +981,543 @@ var PermissionsAPI = class {
     return response.status === "granted";
   }
 };
-var HaexVaultClient = class {
-  constructor(config = {}) {
-    this.pendingRequests = /* @__PURE__ */ new Map();
-    this.eventListeners = /* @__PURE__ */ new Map();
-    this.externalRequestHandlers = /* @__PURE__ */ new Map();
-    this.messageHandler = null;
-    this.initialized = false;
-    this.requestCounter = 0;
-    this._extensionInfo = null;
-    this._context = null;
-    this.reactiveSubscribers = /* @__PURE__ */ new Set();
-    this.isNativeWindow = false;
-    // Wird im Konstruktor initialisiert
-    this.setupPromise = null;
-    this.setupHook = null;
-    this._setupCompleted = false;
-    this.orm = null;
-    this.config = {
-      debug: config.debug ?? false,
-      timeout: config.timeout ?? DEFAULT_TIMEOUT,
-      manifest: config.manifest
-    };
-    this.storage = new StorageAPI(this);
-    this.database = new DatabaseAPI(this);
-    this.filesystem = new FilesystemAPI(this);
-    this.web = new WebAPI(this);
-    this.permissions = new PermissionsAPI(this);
-    installConsoleForwarding(this.config.debug);
-    this.readyPromise = new Promise((resolve) => {
-      this.resolveReady = resolve;
-    });
-    this.init();
+
+// src/client/tableName.ts
+function validatePublicKey(publicKey) {
+  if (!publicKey || typeof publicKey !== "string" || publicKey.trim() === "") {
+    throw new HaexVaultSdkError(
+      "INVALID_PUBLIC_KEY" /* INVALID_PUBLIC_KEY */,
+      "errors.invalid_public_key",
+      { publicKey }
+    );
   }
-  /**
-   * Gibt ein Promise zurück, das aufgelöst wird, sobald der Client
-   * initialisiert ist und Extension-Infos empfangen hat.
-   */
-  async ready() {
-    return this.readyPromise;
+}
+function validateExtensionName(extensionName) {
+  if (!extensionName || !/^[a-z][a-z0-9-]*$/i.test(extensionName)) {
+    throw new HaexVaultSdkError(
+      "INVALID_EXTENSION_NAME" /* INVALID_EXTENSION_NAME */,
+      "errors.invalid_extension_name",
+      { extensionName }
+    );
   }
-  /**
-   * Gibt zurück, ob das Setup bereits abgeschlossen wurde.
-   */
-  get setupCompleted() {
-    return this._setupCompleted;
+  if (extensionName.includes(TABLE_SEPARATOR)) {
+    throw new HaexVaultSdkError(
+      "INVALID_EXTENSION_NAME" /* INVALID_EXTENSION_NAME */,
+      "errors.extension_name_contains_separator",
+      { extensionName, separator: TABLE_SEPARATOR }
+    );
   }
-  /**
-   * Registriert eine Setup-Funktion, die nach der Initialisierung ausgeführt wird.
-   * Diese Funktion sollte für Aufgaben wie Tabellenerstellung, Migrationen, etc. verwendet werden.
-   * @param setupFn Die Setup-Funktion, die ausgeführt werden soll
-   */
-  onSetup(setupFn) {
-    if (this.setupHook) {
-      throw new Error("Setup hook already registered");
-    }
-    this.setupHook = setupFn;
+}
+function validateTableName(tableName) {
+  if (!tableName || typeof tableName !== "string") {
+    throw new HaexVaultSdkError(
+      "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+      "errors.table_name_empty"
+    );
   }
-  /**
-   * Gibt ein Promise zurück, das aufgelöst wird, sobald der Client vollständig eingerichtet ist.
-   * Dies umfasst die Initialisierung UND das Setup (z.B. Tabellenerstellung).
-   * Falls kein Setup-Hook registriert wurde, entspricht dies ready().
-   */
-  async setupComplete() {
-    await this.readyPromise;
-    if (!this.setupHook || this.setupCompleted) {
-      return;
-    }
-    if (!this.setupPromise) {
-      this.setupPromise = this.runSetupAsync();
-    }
-    return this.setupPromise;
+  if (tableName.includes(TABLE_SEPARATOR)) {
+    throw new HaexVaultSdkError(
+      "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+      "errors.table_name_contains_separator",
+      { tableName, separator: TABLE_SEPARATOR }
+    );
   }
-  async runSetupAsync() {
-    if (!this.setupHook) return;
-    try {
-      this.log("[HaexSpace] Running setup hook...");
-      await this.setupHook();
-      this._setupCompleted = true;
-      this.log("[HaexSpace] Setup completed successfully");
-      this.notifySubscribers();
-    } catch (error) {
-      this.log("[HaexSpace] Setup failed:", error);
-      throw error;
-    }
+  if (!/^[a-z][a-z0-9-_]*$/i.test(tableName)) {
+    throw new HaexVaultSdkError(
+      "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+      "errors.table_name_format",
+      { tableName }
+    );
   }
-  /**
-   * Initialisiert die Drizzle-Datenbankinstanz.
-   * Muss nach der Definition des Schemas aufgerufen werden.
-   * @param schema Das Drizzle-Schemaobjekt (mit bereits geprefixten Tabellennamen).
-   * @returns Die typsichere Drizzle-Datenbankinstanz.
-   */
-  initializeDatabase(schema) {
-    if (!this._extensionInfo) {
-      throw new HaexHubError(
-        "EXTENSION_INFO_UNAVAILABLE" /* EXTENSION_INFO_UNAVAILABLE */,
-        "errors.client_not_ready"
-      );
-    }
-    const dbInstance = drizzle(
-      async (sql, params, method) => {
-        try {
-          if (method === "run" || method === "all") {
-            const result2 = await this.request(
-              HAEXTENSION_METHODS.database.execute,
-              {
-                query: sql,
-                params
-              }
-            );
-            if (method === "all") {
-              return { rows: result2.rows || [] };
-            }
-            if (result2.rows && Array.isArray(result2.rows) && result2.rows.length > 0) {
-              return { rows: result2.rows };
-            }
-            return result2;
-          }
-          const result = await this.request(HAEXTENSION_METHODS.database.query, {
-            query: sql,
-            params
-          });
-          const rows = result.rows;
-          if (method === "get") {
-            return { rows: rows.length > 0 ? rows.at(0) : void 0 };
-          }
-          return { rows };
-        } catch (error) {
-          this.log("Database operation failed:", error);
-          throw error;
-        }
-      },
-      {
-        schema,
-        logger: false
-      }
+}
+function getExtensionTableName(extensionInfo2, tableName) {
+  if (!extensionInfo2) {
+    throw new HaexVaultSdkError(
+      "EXTENSION_INFO_UNAVAILABLE" /* EXTENSION_INFO_UNAVAILABLE */,
+      "errors.extension_info_unavailable"
     );
-    this.orm = dbInstance;
-    return dbInstance;
   }
-  get extensionInfo() {
-    return this._extensionInfo;
+  validateTableName(tableName);
+  const { publicKey, name } = extensionInfo2;
+  return `"${getTableName(publicKey, name, tableName)}"`;
+}
+function getDependencyTableName(publicKey, extensionName, tableName) {
+  validatePublicKey(publicKey);
+  validateExtensionName(extensionName);
+  validateTableName(tableName);
+  return `"${getTableName(publicKey, extensionName, tableName)}"`;
+}
+function parseTableName(fullTableName) {
+  let cleanTableName = fullTableName;
+  if (cleanTableName.startsWith('"') && cleanTableName.endsWith('"')) {
+    cleanTableName = cleanTableName.slice(1, -1);
+  }
+  const parts = cleanTableName.split(TABLE_SEPARATOR);
+  if (parts.length !== 3) {
+    return null;
+  }
+  const [publicKey, extensionName, tableName] = parts;
+  if (!publicKey || !extensionName || !tableName) {
+    return null;
+  }
+  return {
+    publicKey,
+    extensionName,
+    tableName
+  };
+}
+
+// src/client/init.ts
+function isInIframe() {
+  return window.self !== window.top;
+}
+function hasTauri() {
+  return typeof window.__TAURI__ !== "undefined";
+}
+function getTauriCore() {
+  return window.__TAURI__.core;
+}
+function getTauriEvent() {
+  return window.__TAURI__.event;
+}
+async function initNativeMode(ctx, log, onEvent, onContextChange) {
+  const { invoke } = getTauriCore();
+  const extensionInfo2 = await invoke("webview_extension_get_info");
+  const context2 = await invoke("webview_extension_context_get");
+  ctx.state.isNativeWindow = true;
+  ctx.state.initialized = true;
+  ctx.state.extensionInfo = extensionInfo2;
+  ctx.state.context = context2;
+  log("HaexVault SDK initialized in native WebViewWindow mode");
+  log("Extension info:", extensionInfo2);
+  log("Application context:", context2);
+  await setupTauriEventListeners(ctx, log, onEvent, onContextChange);
+  return { extensionInfo: extensionInfo2, context: context2 };
+}
+async function setupTauriEventListeners(ctx, log, onEvent, onContextChange) {
+  const { listen } = getTauriEvent();
+  console.log("[HaexVault SDK] Setting up Tauri event listener for:", HAEXTENSION_EVENTS.CONTEXT_CHANGED);
+  try {
+    await listen(HAEXTENSION_EVENTS.CONTEXT_CHANGED, (event) => {
+      console.log("[HaexVault SDK] Received Tauri event:", HAEXTENSION_EVENTS.CONTEXT_CHANGED, event);
+      log("Received context change event:", event);
+      const payload = event.payload;
+      if (payload?.context) {
+        ctx.state.context = payload.context;
+        console.log("[HaexVault SDK] Updated context to:", ctx.state.context);
+        onContextChange(payload.context);
+        onEvent({
+          type: HAEXTENSION_EVENTS.CONTEXT_CHANGED,
+          data: { context: ctx.state.context },
+          timestamp: Date.now()
+        });
+      } else {
+        console.warn("[HaexVault SDK] Event received but no context in payload:", event);
+      }
+    });
+    console.log("[HaexVault SDK] Context change listener registered successfully");
+  } catch (error) {
+    console.error("[HaexVault SDK] Failed to setup context change listener:", error);
+    log("Failed to setup context change listener:", error);
   }
-  get context() {
-    return this._context;
+  try {
+    await listen(HAEXTENSION_EVENTS.EXTERNAL_REQUEST, (event) => {
+      log("Received external request event:", event);
+      if (event.payload) {
+        onEvent({
+          type: HAEXTENSION_EVENTS.EXTERNAL_REQUEST,
+          data: event.payload,
+          timestamp: Date.now()
+        });
+      }
+    });
+    console.log("[HaexVault SDK] External request listener registered successfully");
+  } catch (error) {
+    console.error("[HaexVault SDK] Failed to setup external request listener:", error);
+    log("Failed to setup external request listener:", error);
   }
-  subscribe(callback) {
-    this.reactiveSubscribers.add(callback);
-    return () => {
-      this.reactiveSubscribers.delete(callback);
+}
+async function initIframeMode(ctx, log, messageHandler, request) {
+  if (!isInIframe()) {
+    throw new HaexVaultSdkError("NOT_IN_IFRAME" /* NOT_IN_IFRAME */, "errors.not_in_iframe");
+  }
+  ctx.handlers.messageHandler = messageHandler;
+  window.addEventListener("message", messageHandler);
+  ctx.state.isNativeWindow = false;
+  ctx.state.initialized = true;
+  log("HaexVault SDK initialized in iframe mode");
+  if (ctx.config.manifest) {
+    ctx.state.extensionInfo = {
+      publicKey: ctx.config.manifest.publicKey,
+      name: ctx.config.manifest.name,
+      version: ctx.config.manifest.version,
+      displayName: ctx.config.manifest.name
     };
+    log("Extension info loaded from manifest:", ctx.state.extensionInfo);
   }
-  notifySubscribers() {
-    this.reactiveSubscribers.forEach((callback) => callback());
+  sendDebugInfo(ctx.config);
+  const context2 = await request(HAEXTENSION_METHODS.context.get);
+  ctx.state.context = context2;
+  log("Application context received:", context2);
+  return { context: context2 };
+}
+function sendDebugInfo(config) {
+  if (!config.debug) return;
+  if (typeof window === "undefined" || !window.parent) return;
+  const debugInfo = `SDK Debug:
+window.parent exists: ${!!window.parent}
+window.parent === window: ${window.parent === window}
+window.self === window.top: ${window.self === window.top}`;
+  try {
+    window.parent.postMessage({
+      type: HAEXSPACE_MESSAGE_TYPES.DEBUG,
+      data: debugInfo
+    }, "*");
+  } catch (e) {
+    alert(debugInfo + `
+postMessage error: ${e}`);
   }
-  async getDependencies() {
-    return this.request("extensions.getDependencies");
+}
+
+// src/commands.ts
+var TAURI_COMMANDS = {
+  database: {
+    query: "webview_extension_db_query",
+    execute: "webview_extension_db_execute",
+    registerMigrations: "webview_extension_db_register_migrations"
+  },
+  permissions: {
+    checkWeb: "webview_extension_check_web_permission",
+    checkDatabase: "webview_extension_check_database_permission",
+    checkFilesystem: "webview_extension_check_filesystem_permission"
+  },
+  web: {
+    open: "webview_extension_web_open",
+    fetch: "webview_extension_web_request"
+  },
+  filesystem: {
+    saveFile: "webview_extension_fs_save_file",
+    openFile: "webview_extension_fs_open_file",
+    showImage: "webview_extension_fs_show_image"
+  },
+  external: {
+    // Response handling (called by extensions)
+    respond: "external_respond"},
+  filesync: {
+    // Spaces
+    listSpaces: "filesync_list_spaces",
+    createSpace: "filesync_create_space",
+    deleteSpace: "filesync_delete_space",
+    // Files
+    listFiles: "filesync_list_files",
+    getFile: "filesync_get_file",
+    uploadFile: "filesync_upload_file",
+    downloadFile: "filesync_download_file",
+    deleteFile: "filesync_delete_file",
+    // Backends
+    listBackends: "filesync_list_backends",
+    addBackend: "filesync_add_backend",
+    removeBackend: "filesync_remove_backend",
+    testBackend: "filesync_test_backend",
+    // Sync Rules
+    listSyncRules: "filesync_list_sync_rules",
+    addSyncRule: "filesync_add_sync_rule",
+    removeSyncRule: "filesync_remove_sync_rule",
+    // Sync Operations
+    getSyncStatus: "filesync_get_sync_status",
+    triggerSync: "filesync_trigger_sync",
+    pauseSync: "filesync_pause_sync",
+    resumeSync: "filesync_resume_sync",
+    // Conflict Resolution
+    resolveConflict: "filesync_resolve_conflict",
+    // UI Helpers
+    selectFolder: "filesync_select_folder"
   }
-  getTableName(tableName) {
-    if (!this._extensionInfo) {
-      throw new HaexHubError(
-        "EXTENSION_INFO_UNAVAILABLE" /* EXTENSION_INFO_UNAVAILABLE */,
-        "errors.extension_info_unavailable"
-      );
-    }
-    this.validateTableName(tableName);
-    const { publicKey, name } = this._extensionInfo;
-    return `"${getTableName(publicKey, name, tableName)}"`;
+};
+
+// src/transport/handlers/database.ts
+var databaseHandlers = {
+  [HAEXTENSION_METHODS.database.query]: {
+    command: TAURI_COMMANDS.database.query,
+    args: (p) => ({
+      query: p.query,
+      params: p.params || []
+    })
+  },
+  [HAEXTENSION_METHODS.database.execute]: {
+    command: TAURI_COMMANDS.database.execute,
+    args: (p) => ({
+      query: p.query,
+      params: p.params || []
+    })
+  },
+  [HAEXTENSION_METHODS.database.registerMigrations]: {
+    command: TAURI_COMMANDS.database.registerMigrations,
+    args: (p) => ({
+      extensionVersion: p.extensionVersion,
+      migrations: p.migrations
+    })
   }
-  getDependencyTableName(publicKey, extensionName, tableName) {
-    this.validatePublicKey(publicKey);
-    this.validateExtensionName(extensionName);
-    this.validateTableName(tableName);
-    return `"${getTableName(publicKey, extensionName, tableName)}"`;
+};
+
+// src/transport/handlers/permissions.ts
+var permissionsHandlers = {
+  "permissions.web.check": {
+    command: TAURI_COMMANDS.permissions.checkWeb,
+    args: (p) => ({
+      url: p.url
+    })
+  },
+  "permissions.database.check": {
+    command: TAURI_COMMANDS.permissions.checkDatabase,
+    args: (p) => ({
+      resource: p.resource,
+      operation: p.operation
+    })
+  },
+  "permissions.filesystem.check": {
+    command: TAURI_COMMANDS.permissions.checkFilesystem,
+    args: (p) => ({
+      path: p.path,
+      actionStr: p.action
+    })
   }
-  parseTableName(fullTableName) {
-    let cleanTableName = fullTableName;
-    if (cleanTableName.startsWith('"') && cleanTableName.endsWith('"')) {
-      cleanTableName = cleanTableName.slice(1, -1);
-    }
-    const parts = cleanTableName.split(TABLE_SEPARATOR);
-    if (parts.length !== 3) {
-      return null;
-    }
-    const [publicKey, extensionName, tableName] = parts;
-    if (!publicKey || !extensionName || !tableName) {
-      return null;
-    }
-    return {
-      publicKey,
-      extensionName,
-      tableName
-    };
+};
+
+// src/transport/handlers/web.ts
+var webHandlers = {
+  [HAEXTENSION_METHODS.application.open]: {
+    command: TAURI_COMMANDS.web.open,
+    args: (p) => ({
+      url: p.url
+    })
+  },
+  [HAEXTENSION_METHODS.web.fetch]: {
+    command: TAURI_COMMANDS.web.fetch,
+    args: (p) => ({
+      url: p.url,
+      method: p.method,
+      headers: p.headers,
+      body: p.body
+    })
   }
-  /**
-   * Execute a raw SQL query (SELECT)
-   * Returns rows as an array of objects
-   */
-  async query(sql, params = []) {
-    const result = await this.request(
-      HAEXTENSION_METHODS.database.query,
-      { query: sql, params }
-    );
-    if (this.config.debug) {
-      console.log("[SDK query()] Raw result:", JSON.stringify(result, null, 2));
-    }
-    return result.rows;
+};
+
+// src/transport/handlers/filesystem.ts
+var filesystemHandlers = {
+  [HAEXTENSION_METHODS.filesystem.saveFile]: {
+    command: TAURI_COMMANDS.filesystem.saveFile,
+    args: (p) => ({
+      data: p.data,
+      defaultPath: p.defaultPath,
+      title: p.title,
+      filters: p.filters
+    })
+  },
+  [HAEXTENSION_METHODS.filesystem.openFile]: {
+    command: TAURI_COMMANDS.filesystem.openFile,
+    args: (p) => ({
+      data: p.data,
+      fileName: p.fileName
+    })
+  },
+  [HAEXTENSION_METHODS.filesystem.showImage]: {
+    command: TAURI_COMMANDS.filesystem.showImage,
+    args: (p) => ({
+      dataUrl: p.dataUrl
+    })
   }
-  /**
-   * Alias for query() - more intuitive for SELECT statements
-   */
-  async select(sql, params = []) {
-    return this.query(sql, params);
+};
+
+// src/transport/handlers/external.ts
+var externalHandlers = {
+  "external.respond": {
+    command: TAURI_COMMANDS.external.respond,
+    args: (p) => ({
+      requestId: p.requestId,
+      success: p.success,
+      data: p.data,
+      error: p.error
+    })
   }
-  /**
-   * Execute a raw SQL statement (INSERT, UPDATE, DELETE, CREATE, etc.)
-   * Returns rowsAffected and lastInsertId
-   */
-  async execute(sql, params = []) {
-    const result = await this.request(
-      HAEXTENSION_METHODS.database.execute,
-      { query: sql, params }
-    );
-    return {
-      rowsAffected: result.rowsAffected,
-      lastInsertId: result.lastInsertId
-    };
-  }
-  /**
-   * Registers and applies extension migrations with HaexVault
-   *
-   * HaexVault will:
-   * 1. Validate all SQL statements (ensure only extension's own tables are accessed)
-   * 2. Store migrations with applied_at = NULL
-   * 3. Query pending migrations sorted by name
-   * 4. Apply pending migrations and set up CRDT triggers
-   * 5. Mark successful migrations with applied_at timestamp
-   *
-   * @param extensionVersion - The version of the extension
-   * @param migrations - Array of migration objects with name and SQL content
-   * @returns Promise with migration result (applied count, already applied count, applied migration names)
-   */
-  async registerMigrationsAsync(extensionVersion, migrations) {
-    return this.database.registerMigrationsAsync(extensionVersion, migrations);
-  }
-  async requestDatabasePermission(request) {
-    return this.request("permissions.database.request", {
-      resource: request.resource,
-      operation: request.operation,
-      reason: request.reason
-    });
-  }
-  async checkDatabasePermission(resource, operation) {
-    const response = await this.request(
-      "permissions.database.check",
-      {
-        resource,
-        operation
-      }
-    );
-    return response.status === "granted";
-  }
-  async respondToSearch(requestId, results) {
-    await this.request("search.respond", {
-      requestId,
-      results
-    });
-  }
-  /**
-   * Register a handler for external requests (from browser extensions, CLI, servers, etc.)
-   *
-   * @param action - The action/method name to handle (e.g., "get-logins", "get-totp")
-   * @param handler - Function that processes the request and returns a response
-   * @returns Unsubscribe function to remove the handler
-   *
-   * @example
-   * ```typescript
-   * client.onExternalRequest("get-logins", async (request) => {
-   *   const entries = await getMatchingEntries(request.payload.url);
-   *   return {
-   *     requestId: request.requestId,
-   *     success: true,
-   *     data: { entries }
-   *   };
-   * });
-   * ```
-   */
-  onExternalRequest(action, handler) {
-    this.externalRequestHandlers.set(action, handler);
-    this.log(`[ExternalRequest] Registered handler for action: ${action}`);
-    return () => {
-      this.externalRequestHandlers.delete(action);
-      this.log(`[ExternalRequest] Unregistered handler for action: ${action}`);
-    };
-  }
-  /**
-   * Send a response to an external request back to haex-vault
-   * This is called internally after a handler processes a request
-   */
-  async respondToExternalRequest(response) {
-    await this.request("external.respond", response);
-  }
-  async request(method, params) {
-    const resolvedParams = params ?? {};
-    if (this.isNativeWindow && typeof window.__TAURI__ !== "undefined") {
-      return this.invoke(method, resolvedParams);
-    }
-    return this.postMessage(method, resolvedParams);
-  }
-  async postMessage(method, params) {
-    const requestId = this.generateRequestId();
-    const request = {
-      method,
-      params,
-      timestamp: Date.now()
-    };
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingRequests.delete(requestId);
-        reject(
-          new HaexHubError("TIMEOUT" /* TIMEOUT */, "errors.timeout", {
-            timeout: this.config.timeout
-          })
-        );
-      }, this.config.timeout);
-      this.pendingRequests.set(requestId, { resolve, reject, timeout });
-      const targetOrigin = "*";
-      if (this.config.debug) {
-        console.log("[SDK Debug] ========== Sending Request ==========");
-        console.log("[SDK Debug] Request ID:", requestId);
-        console.log("[SDK Debug] Method:", request.method);
-        console.log("[SDK Debug] Params:", request.params);
-        console.log("[SDK Debug] Target origin:", targetOrigin);
-        console.log("[SDK Debug] Extension info:", this._extensionInfo);
-        console.log("[SDK Debug] ========================================");
-      }
-      window.parent.postMessage({ id: requestId, ...request }, targetOrigin);
-    });
-  }
-  async invoke(method, params) {
-    const { invoke } = window.__TAURI__.core;
-    if (this.config.debug) {
-      console.log("[SDK Debug] ========== Invoke Request ==========");
-      console.log("[SDK Debug] Method:", method);
-      console.log("[SDK Debug] Params:", params);
-      console.log("[SDK Debug] =======================================");
-    }
-    switch (method) {
-      case HAEXTENSION_METHODS.database.query:
-        return invoke("webview_extension_db_query", {
-          query: params.query,
-          params: params.params || []
-        });
-      case HAEXTENSION_METHODS.database.execute:
-        return invoke("webview_extension_db_execute", {
-          query: params.query,
-          params: params.params || []
-        });
-      case "permissions.web.check":
-        return invoke("webview_extension_check_web_permission", {
-          url: params.url
-        });
-      case "permissions.database.check":
-        return invoke("webview_extension_check_database_permission", {
-          resource: params.resource,
-          operation: params.operation
-        });
-      case "permissions.filesystem.check":
-        return invoke("webview_extension_check_filesystem_permission", {
-          path: params.path,
-          actionStr: params.action
-        });
-      case HAEXTENSION_METHODS.application.open:
-        return invoke("webview_extension_web_open", {
-          url: params.url
-        });
-      case HAEXTENSION_METHODS.web.fetch:
-        return invoke("webview_extension_web_request", {
-          url: params.url,
-          method: params.method,
-          headers: params.headers,
-          body: params.body
-        });
-      case HAEXTENSION_METHODS.filesystem.saveFile:
-        return invoke("webview_extension_fs_save_file", {
-          data: params.data,
-          defaultPath: params.defaultPath,
-          title: params.title,
-          filters: params.filters
-        });
-      case HAEXTENSION_METHODS.filesystem.openFile:
-        return invoke("webview_extension_fs_open_file", {
-          data: params.data,
-          fileName: params.fileName
-        });
-      case HAEXTENSION_METHODS.database.registerMigrations:
-        return invoke("webview_extension_db_register_migrations", {
-          extensionVersion: params.extensionVersion,
-          migrations: params.migrations
-        });
-      case "external.respond":
-        return invoke("webview_extension_external_respond", {
-          requestId: params.requestId,
-          success: params.success,
-          data: params.data,
-          error: params.error
-        });
-      default:
-        throw new HaexHubError(
-          "METHOD_NOT_FOUND" /* METHOD_NOT_FOUND */,
-          "errors.method_not_found",
-          { method }
-        );
-    }
-  }
-  on(eventType, callback) {
-    if (!this.eventListeners.has(eventType)) {
-      this.eventListeners.set(eventType, /* @__PURE__ */ new Set());
-    }
-    this.eventListeners.get(eventType).add(callback);
-  }
-  off(eventType, callback) {
-    const listeners = this.eventListeners.get(eventType);
-    if (listeners) {
-      listeners.delete(callback);
-    }
-  }
-  destroy() {
-    if (this.messageHandler) {
-      window.removeEventListener("message", this.messageHandler);
-    }
-    this.pendingRequests.forEach(({ timeout }) => clearTimeout(timeout));
-    this.pendingRequests.clear();
-    this.eventListeners.clear();
-    this.initialized = false;
-    this.log("HaexHub SDK destroyed");
+};
+
+// src/transport/handlers/filesync.ts
+var filesyncHandlers = {
+  // ==========================================================================
+  // Spaces
+  // ==========================================================================
+  [HAEXTENSION_METHODS.filesystem.sync.listSpaces]: {
+    command: TAURI_COMMANDS.filesync.listSpaces,
+    args: () => ({})
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.createSpace]: {
+    command: TAURI_COMMANDS.filesync.createSpace,
+    args: (p) => ({ request: p })
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.deleteSpace]: {
+    command: TAURI_COMMANDS.filesync.deleteSpace,
+    args: (p) => ({ spaceId: p.spaceId })
+  },
+  // ==========================================================================
+  // Files
+  // ==========================================================================
+  [HAEXTENSION_METHODS.filesystem.sync.listFiles]: {
+    command: TAURI_COMMANDS.filesync.listFiles,
+    args: (p) => ({ request: p })
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.getFile]: {
+    command: TAURI_COMMANDS.filesync.getFile,
+    args: (p) => ({ fileId: p.fileId })
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.uploadFile]: {
+    command: TAURI_COMMANDS.filesync.uploadFile,
+    args: (p) => ({ request: p })
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.downloadFile]: {
+    command: TAURI_COMMANDS.filesync.downloadFile,
+    args: (p) => ({ request: p })
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.deleteFile]: {
+    command: TAURI_COMMANDS.filesync.deleteFile,
+    args: (p) => ({ fileId: p.fileId })
+  },
+  // ==========================================================================
+  // Backends
+  // ==========================================================================
+  [HAEXTENSION_METHODS.filesystem.sync.listBackends]: {
+    command: TAURI_COMMANDS.filesync.listBackends,
+    args: () => ({})
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.addBackend]: {
+    command: TAURI_COMMANDS.filesync.addBackend,
+    args: (p) => ({ request: p })
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.removeBackend]: {
+    command: TAURI_COMMANDS.filesync.removeBackend,
+    args: (p) => ({ backendId: p.backendId })
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.testBackend]: {
+    command: TAURI_COMMANDS.filesync.testBackend,
+    args: (p) => ({ backendId: p.backendId })
+  },
+  // ==========================================================================
+  // Sync Rules
+  // ==========================================================================
+  [HAEXTENSION_METHODS.filesystem.sync.listSyncRules]: {
+    command: TAURI_COMMANDS.filesync.listSyncRules,
+    args: () => ({})
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.addSyncRule]: {
+    command: TAURI_COMMANDS.filesync.addSyncRule,
+    args: (p) => ({ request: p })
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.removeSyncRule]: {
+    command: TAURI_COMMANDS.filesync.removeSyncRule,
+    args: (p) => ({ ruleId: p.ruleId })
+  },
+  // ==========================================================================
+  // Sync Operations
+  // ==========================================================================
+  [HAEXTENSION_METHODS.filesystem.sync.getSyncStatus]: {
+    command: TAURI_COMMANDS.filesync.getSyncStatus,
+    args: () => ({})
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.triggerSync]: {
+    command: TAURI_COMMANDS.filesync.triggerSync,
+    args: () => ({})
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.pauseSync]: {
+    command: TAURI_COMMANDS.filesync.pauseSync,
+    args: () => ({})
+  },
+  [HAEXTENSION_METHODS.filesystem.sync.resumeSync]: {
+    command: TAURI_COMMANDS.filesync.resumeSync,
+    args: () => ({})
+  },
+  // ==========================================================================
+  // Conflict Resolution
+  // ==========================================================================
+  [HAEXTENSION_METHODS.filesystem.sync.resolveConflict]: {
+    command: TAURI_COMMANDS.filesync.resolveConflict,
+    args: (p) => ({ request: p })
+  },
+  // ==========================================================================
+  // UI Helpers
+  // ==========================================================================
+  [HAEXTENSION_METHODS.filesystem.sync.selectFolder]: {
+    command: TAURI_COMMANDS.filesync.selectFolder,
+    args: () => ({})
   }
-  async init() {
-    if (this.initialized) return;
-    const isInIframe = window.self !== window.top;
-    if (!isInIframe) {
-      try {
-        if (typeof window.__TAURI__ !== "undefined") {
-          const { invoke } = window.__TAURI__.core;
-          this._extensionInfo = await invoke("webview_extension_get_info");
-          this._context = await invoke("webview_extension_context_get");
-          this.isNativeWindow = true;
-          this.initialized = true;
-          this.log("HaexHub SDK initialized in native WebViewWindow mode");
-          this.log("Extension info:", this._extensionInfo);
-          this.log("Application context:", this._context);
-          this.notifySubscribers();
-          const { listen } = window.__TAURI__.event;
-          console.log("[HaexSpace SDK] Setting up Tauri event listener for:", HAEXTENSION_EVENTS.CONTEXT_CHANGED);
-          try {
-            await listen(HAEXTENSION_EVENTS.CONTEXT_CHANGED, (event) => {
-              console.log("[HaexSpace SDK] Received Tauri event:", HAEXTENSION_EVENTS.CONTEXT_CHANGED, event);
-              this.log("Received context change event:", event);
-              if (event.payload?.context) {
-                this._context = event.payload.context;
-                console.log("[HaexSpace SDK] Updated context to:", this._context);
-                this.handleEvent({
-                  type: HAEXTENSION_EVENTS.CONTEXT_CHANGED,
-                  data: { context: this._context },
-                  timestamp: Date.now()
-                });
-              } else {
-                console.warn("[HaexSpace SDK] Event received but no context in payload:", event);
-              }
-            });
-            console.log("[HaexSpace SDK] Context change listener registered successfully");
-          } catch (error) {
-            console.error("[HaexSpace SDK] Failed to setup context change listener:", error);
-            this.log("Failed to setup context change listener:", error);
-          }
-          try {
-            await listen(HAEXTENSION_EVENTS.EXTERNAL_REQUEST, (event) => {
-              this.log("Received external request event:", event);
-              if (event.payload) {
-                this.handleEvent({
-                  type: HAEXTENSION_EVENTS.EXTERNAL_REQUEST,
-                  data: event.payload,
-                  timestamp: Date.now()
-                });
-              }
-            });
-            console.log("[HaexSpace SDK] External request listener registered successfully");
-          } catch (error) {
-            console.error("[HaexSpace SDK] Failed to setup external request listener:", error);
-            this.log("Failed to setup external request listener:", error);
-          }
-          this.resolveReady();
-          return;
-        }
-      } catch (error) {
-        this.log("Tauri commands failed, falling back to iframe mode", error);
-      }
-    }
-    if (window.self === window.top) {
-      throw new HaexHubError("NOT_IN_IFRAME" /* NOT_IN_IFRAME */, "errors.not_in_iframe");
-    }
-    this.messageHandler = this.handleMessage.bind(this);
-    window.addEventListener("message", this.messageHandler);
-    this.isNativeWindow = false;
-    this.initialized = true;
-    this.log("HaexSpace SDK initialized in iframe mode");
-    try {
-      if (this.config.manifest) {
-        this._extensionInfo = {
-          publicKey: this.config.manifest.publicKey,
-          name: this.config.manifest.name,
-          version: this.config.manifest.version,
-          displayName: this.config.manifest.name
-        };
-        this.log("Extension info loaded from manifest:", this._extensionInfo);
-        this.notifySubscribers();
-      }
-      if (typeof window !== "undefined" && window.parent) {
-        const debugInfo = `SDK Debug:
-window.parent exists: ${!!window.parent}
-window.parent === window: ${window.parent === window}
-window.self === window.top: ${window.self === window.top}`;
-        try {
-          window.parent.postMessage({
-            type: HAEXSPACE_MESSAGE_TYPES.DEBUG,
-            data: debugInfo
-          }, "*");
-        } catch (e) {
-          alert(debugInfo + `
-postMessage error: ${e}`);
-        }
-      }
-      this._context = await this.request(HAEXTENSION_METHODS.context.get);
-      this.log("Application context received:", this._context);
-      this.notifySubscribers();
-      this.resolveReady();
-    } catch (error) {
-      this.log("Failed to load extension info or context:", error);
-      throw error;
+};
+
+// src/transport/handlers/index.ts
+var allHandlers = {
+  ...databaseHandlers,
+  ...permissionsHandlers,
+  ...webHandlers,
+  ...filesystemHandlers,
+  ...externalHandlers,
+  ...filesyncHandlers
+};
+
+// src/client/transport.ts
+function generateRequestId(counter) {
+  return `req_${counter}`;
+}
+function sendPostMessage(method, params, requestId, config, extensionInfo2, pendingRequests) {
+  const request = {
+    method,
+    params,
+    timestamp: Date.now()
+  };
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      pendingRequests.delete(requestId);
+      reject(
+        new HaexVaultSdkError("TIMEOUT" /* TIMEOUT */, "errors.timeout", {
+          timeout: config.timeout
+        })
+      );
+    }, config.timeout);
+    pendingRequests.set(requestId, { resolve, reject, timeout });
+    const targetOrigin = "*";
+    if (config.debug) {
+      console.log("[SDK Debug] ========== Sending Request ==========");
+      console.log("[SDK Debug] Request ID:", requestId);
+      console.log("[SDK Debug] Method:", request.method);
+      console.log("[SDK Debug] Params:", request.params);
+      console.log("[SDK Debug] Target origin:", targetOrigin);
+      console.log("[SDK Debug] Extension info:", extensionInfo2);
+      console.log("[SDK Debug] ========================================");
     }
-  }
-  handleMessage(event) {
-    if (this.config.debug) {
+    window.parent.postMessage({ id: requestId, ...request }, targetOrigin);
+  });
+}
+async function sendInvoke(method, params, config, log) {
+  const { invoke } = window.__TAURI__.core;
+  if (config.debug) {
+    console.log("[SDK Debug] ========== Invoke Request ==========");
+    console.log("[SDK Debug] Method:", method);
+    console.log("[SDK Debug] Params:", params);
+    console.log("[SDK Debug] =======================================");
+  }
+  const handler = allHandlers[method];
+  if (handler) {
+    const args = handler.args(params);
+    return invoke(handler.command, args);
+  }
+  throw new HaexVaultSdkError(
+    "METHOD_NOT_FOUND" /* METHOD_NOT_FOUND */,
+    "errors.method_not_found",
+    { method }
+  );
+}
+
+// src/client/events.ts
+function createMessageHandler(config, pendingRequests, extensionInfo2, onEvent) {
+  return (event) => {
+    if (config.debug) {
       console.log("[SDK Debug] ========== Message Received ==========");
       console.log("[SDK Debug] Event origin:", event.origin);
       console.log(
@@ -1532,160 +1525,534 @@ postMessage error: ${e}`);
         event.source === window.parent ? "parent window" : "unknown"
       );
       console.log("[SDK Debug] Event data:", event.data);
-      console.log("[SDK Debug] Extension info loaded:", !!this._extensionInfo);
+      console.log("[SDK Debug] Extension info loaded:", !!extensionInfo2());
       console.log(
         "[SDK Debug] Pending requests count:",
-        this.pendingRequests.size
+        pendingRequests.size
       );
     }
     if (event.source !== window.parent) {
-      if (this.config.debug) {
+      if (config.debug) {
         console.error("[SDK Debug] \u274C REJECTED: Message not from parent window!");
       }
       return;
     }
     const data = event.data;
-    if ("id" in data && this.pendingRequests.has(data.id)) {
-      if (this.config.debug) {
+    if ("id" in data && pendingRequests.has(data.id)) {
+      if (config.debug) {
         console.log("[SDK Debug] \u2705 Found pending request for ID:", data.id);
       }
-      const pending = this.pendingRequests.get(data.id);
+      const pending = pendingRequests.get(data.id);
       clearTimeout(pending.timeout);
-      this.pendingRequests.delete(data.id);
+      pendingRequests.delete(data.id);
       if (data.error) {
-        if (this.config.debug) {
+        if (config.debug) {
           console.error("[SDK Debug] \u274C Request failed:", data.error);
         }
         pending.reject(data.error);
       } else {
-        if (this.config.debug) {
+        if (config.debug) {
           console.log("[SDK Debug] \u2705 Request succeeded:", data.result);
         }
         pending.resolve(data.result);
       }
       return;
     }
-    if ("id" in data && !this.pendingRequests.has(data.id)) {
-      if (this.config.debug) {
+    if ("id" in data && !pendingRequests.has(data.id)) {
+      if (config.debug) {
         console.warn(
           "[SDK Debug] \u26A0\uFE0F Received response for unknown request ID:",
           data.id
         );
         console.warn(
           "[SDK Debug] Known IDs:",
-          Array.from(this.pendingRequests.keys())
+          Array.from(pendingRequests.keys())
         );
       }
     }
     if ("type" in data && data.type) {
-      if (this.config.debug) {
+      if (config.debug) {
         console.log("[SDK Debug] Event received:", data.type);
       }
-      this.handleEvent(data);
+      onEvent(data);
     }
-    if (this.config.debug) {
+    if (config.debug) {
       console.log("[SDK Debug] ========== End Message ==========");
     }
+  };
+}
+function processEvent(event, log, eventListeners, onContextChanged, onExternalRequest) {
+  if (event.type === HAEXTENSION_EVENTS.CONTEXT_CHANGED) {
+    const contextEvent = event;
+    onContextChanged(contextEvent.data.context);
+    log("Context updated:", contextEvent.data.context);
+  }
+  if (event.type === HAEXTENSION_EVENTS.EXTERNAL_REQUEST) {
+    const externalEvent = event;
+    onExternalRequest(externalEvent);
+    return;
   }
-  handleEvent(event) {
-    if (event.type === HAEXTENSION_EVENTS.CONTEXT_CHANGED) {
-      const contextEvent = event;
-      this._context = contextEvent.data.context;
-      this.log("Context updated:", this._context);
-      this.notifySubscribers();
+  emitEvent(event, log, eventListeners);
+}
+function emitEvent(event, log, eventListeners) {
+  log("Event received:", event);
+  const listeners = eventListeners.get(event.type);
+  if (listeners) {
+    listeners.forEach((callback) => callback(event));
+  }
+}
+function addEventListener(eventType, callback, eventListeners) {
+  if (!eventListeners.has(eventType)) {
+    eventListeners.set(eventType, /* @__PURE__ */ new Set());
+  }
+  eventListeners.get(eventType).add(callback);
+}
+function removeEventListener(eventType, callback, eventListeners) {
+  const listeners = eventListeners.get(eventType);
+  if (listeners) {
+    listeners.delete(callback);
+  }
+}
+function notifySubscribers(subscribers) {
+  subscribers.forEach((callback) => callback());
+}
+function createDrizzleInstance(schema, extensionInfo2, request, log) {
+  if (!extensionInfo2) {
+    throw new HaexVaultSdkError(
+      "EXTENSION_INFO_UNAVAILABLE" /* EXTENSION_INFO_UNAVAILABLE */,
+      "errors.client_not_ready"
+    );
+  }
+  return drizzle(
+    async (sql, params, method) => {
+      try {
+        if (method === "run" || method === "all") {
+          const result2 = await request(
+            HAEXTENSION_METHODS.database.execute,
+            {
+              query: sql,
+              params
+            }
+          );
+          if (method === "all") {
+            return { rows: result2.rows || [] };
+          }
+          if (result2.rows && Array.isArray(result2.rows) && result2.rows.length > 0) {
+            return { rows: result2.rows };
+          }
+          return result2;
+        }
+        const result = await request(HAEXTENSION_METHODS.database.query, {
+          query: sql,
+          params
+        });
+        const rows = result.rows;
+        if (method === "get") {
+          return { rows: rows.length > 0 ? rows.at(0) : void 0 };
+        }
+        return { rows };
+      } catch (error) {
+        log("Database operation failed:", error);
+        throw error;
+      }
+    },
+    {
+      schema,
+      logger: false
     }
-    if (event.type === HAEXTENSION_EVENTS.EXTERNAL_REQUEST) {
-      const externalEvent = event;
-      this.handleExternalRequest(externalEvent.data);
-      return;
+  );
+}
+async function queryRaw(sql, params, request, debug) {
+  const result = await request(
+    HAEXTENSION_METHODS.database.query,
+    { query: sql, params }
+  );
+  if (debug) {
+    console.log("[SDK query()] Raw result:", JSON.stringify(result, null, 2));
+  }
+  return result.rows;
+}
+async function executeRaw(sql, params, request) {
+  const result = await request(
+    HAEXTENSION_METHODS.database.execute,
+    { query: sql, params }
+  );
+  return {
+    rowsAffected: result.rowsAffected,
+    lastInsertId: result.lastInsertId
+  };
+}
+
+// src/client/external.ts
+function registerExternalHandler(action, handler, handlers, log) {
+  handlers.set(action, handler);
+  log(`[ExternalRequest] Registered handler for action: ${action}`);
+  return () => {
+    handlers.delete(action);
+    log(`[ExternalRequest] Unregistered handler for action: ${action}`);
+  };
+}
+async function handleExternalRequest(request, handlers, respond, log) {
+  log(`[ExternalRequest] Received request: ${request.action} from ${request.publicKey.substring(0, 20)}...`);
+  const handler = handlers.get(request.action);
+  if (!handler) {
+    log(`[ExternalRequest] No handler for action: ${request.action}`);
+    await respond({
+      requestId: request.requestId,
+      success: false,
+      error: `No handler registered for action: ${request.action}`
+    });
+    return;
+  }
+  try {
+    const response = await handler(request);
+    await respond(response);
+    log(`[ExternalRequest] Response sent for: ${request.action}`);
+  } catch (error) {
+    log(`[ExternalRequest] Handler error:`, error);
+    await respond({
+      requestId: request.requestId,
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function respondToExternalRequest(response, request) {
+  await request("external.respond", response);
+}
+
+// src/client.ts
+var HaexVaultClient = class {
+  constructor(config = {}) {
+    // State
+    this.initialized = false;
+    this.isNativeWindow = false;
+    this.requestCounter = 0;
+    this._extensionInfo = null;
+    this._context = null;
+    this._setupCompleted = false;
+    // Collections
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.externalRequestHandlers = /* @__PURE__ */ new Map();
+    this.reactiveSubscribers = /* @__PURE__ */ new Set();
+    // Handlers
+    this.messageHandler = null;
+    this.setupPromise = null;
+    this.setupHook = null;
+    // Public APIs
+    this.orm = null;
+    this.config = {
+      debug: config.debug ?? false,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      manifest: config.manifest
+    };
+    this.storage = new StorageAPI(this);
+    this.database = new DatabaseAPI(this);
+    this.filesystem = new FilesystemAPI(this);
+    this.web = new WebAPI(this);
+    this.permissions = new PermissionsAPI(this);
+    installConsoleForwarding(this.config.debug);
+    this.readyPromise = new Promise((resolve) => {
+      this.resolveReady = resolve;
+    });
+    this.init();
+  }
+  // ==========================================================================
+  // Lifecycle
+  // ==========================================================================
+  async ready() {
+    return this.readyPromise;
+  }
+  get setupCompleted() {
+    return this._setupCompleted;
+  }
+  onSetup(setupFn) {
+    if (this.setupHook) {
+      throw new Error("Setup hook already registered");
     }
-    this.emitEvent(event);
-  }
-  async handleExternalRequest(request) {
-    this.log(`[ExternalRequest] Received request: ${request.action} from ${request.publicKey.substring(0, 20)}...`);
-    const handler = this.externalRequestHandlers.get(request.action);
-    if (!handler) {
-      this.log(`[ExternalRequest] No handler for action: ${request.action}`);
-      await this.respondToExternalRequest({
-        requestId: request.requestId,
-        success: false,
-        error: `No handler registered for action: ${request.action}`
-      });
+    this.setupHook = setupFn;
+  }
+  async setupComplete() {
+    await this.readyPromise;
+    if (!this.setupHook || this.setupCompleted) {
       return;
     }
-    try {
-      const response = await handler(request);
-      await this.respondToExternalRequest(response);
-      this.log(`[ExternalRequest] Response sent for: ${request.action}`);
-    } catch (error) {
-      this.log(`[ExternalRequest] Handler error:`, error);
-      await this.respondToExternalRequest({
-        requestId: request.requestId,
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      });
+    if (!this.setupPromise) {
+      this.setupPromise = this.runSetupAsync();
     }
+    return this.setupPromise;
   }
-  emitEvent(event) {
-    this.log("Event received:", event);
-    const listeners = this.eventListeners.get(event.type);
-    if (listeners) {
-      listeners.forEach((callback) => callback(event));
+  destroy() {
+    if (this.messageHandler) {
+      window.removeEventListener("message", this.messageHandler);
     }
+    this.pendingRequests.forEach(({ timeout }) => clearTimeout(timeout));
+    this.pendingRequests.clear();
+    this.eventListeners.clear();
+    this.initialized = false;
+    this.log("HaexVault SDK destroyed");
   }
-  generateRequestId() {
-    return `req_${++this.requestCounter}`;
+  // ==========================================================================
+  // Properties
+  // ==========================================================================
+  get extensionInfo() {
+    return this._extensionInfo;
   }
-  validatePublicKey(publicKey) {
-    if (!publicKey || typeof publicKey !== "string" || publicKey.trim() === "") {
-      throw new HaexHubError(
-        "INVALID_PUBLIC_KEY" /* INVALID_PUBLIC_KEY */,
-        "errors.invalid_public_key",
-        { publicKey }
-      );
-    }
+  get context() {
+    return this._context;
   }
-  validateExtensionName(extensionName) {
-    if (!extensionName || !/^[a-z][a-z0-9-]*$/i.test(extensionName)) {
-      throw new HaexHubError(
-        "INVALID_EXTENSION_NAME" /* INVALID_EXTENSION_NAME */,
-        "errors.invalid_extension_name",
-        { extensionName }
-      );
-    }
-    if (extensionName.includes(TABLE_SEPARATOR)) {
-      throw new HaexHubError(
-        "INVALID_EXTENSION_NAME" /* INVALID_EXTENSION_NAME */,
-        "errors.extension_name_contains_separator",
-        { extensionName, separator: TABLE_SEPARATOR }
-      );
+  // ==========================================================================
+  // Subscriptions
+  // ==========================================================================
+  subscribe(callback) {
+    this.reactiveSubscribers.add(callback);
+    return () => {
+      this.reactiveSubscribers.delete(callback);
+    };
+  }
+  // ==========================================================================
+  // Table Name Utilities
+  // ==========================================================================
+  getTableName(tableName) {
+    return getExtensionTableName(this._extensionInfo, tableName);
+  }
+  getDependencyTableName(publicKey, extensionName, tableName) {
+    return getDependencyTableName(publicKey, extensionName, tableName);
+  }
+  parseTableName(fullTableName) {
+    return parseTableName(fullTableName);
+  }
+  // ==========================================================================
+  // Database
+  // ==========================================================================
+  initializeDatabase(schema) {
+    const db = createDrizzleInstance(schema, this._extensionInfo, this.request.bind(this), this.log.bind(this));
+    this.orm = db;
+    return db;
+  }
+  async query(sql, params = []) {
+    return queryRaw(sql, params, this.request.bind(this), this.config.debug);
+  }
+  async select(sql, params = []) {
+    return this.query(sql, params);
+  }
+  async execute(sql, params = []) {
+    return executeRaw(sql, params, this.request.bind(this));
+  }
+  async registerMigrationsAsync(extensionVersion, migrations) {
+    return this.database.registerMigrationsAsync(extensionVersion, migrations);
+  }
+  // ==========================================================================
+  // Dependencies
+  // ==========================================================================
+  async getDependencies() {
+    return this.request("extensions.getDependencies");
+  }
+  // ==========================================================================
+  // Permissions
+  // ==========================================================================
+  async requestDatabasePermission(request) {
+    return this.request("permissions.database.request", {
+      resource: request.resource,
+      operation: request.operation,
+      reason: request.reason
+    });
+  }
+  async checkDatabasePermission(resource, operation) {
+    const response = await this.request("permissions.database.check", { resource, operation });
+    return response.status === "granted";
+  }
+  // ==========================================================================
+  // Search
+  // ==========================================================================
+  async respondToSearch(requestId, results) {
+    await this.request("search.respond", { requestId, results });
+  }
+  // ==========================================================================
+  // External Requests
+  // ==========================================================================
+  onExternalRequest(action, handler) {
+    return registerExternalHandler(action, handler, this.externalRequestHandlers, this.log.bind(this));
+  }
+  async respondToExternalRequest(response) {
+    await respondToExternalRequest(response, this.request.bind(this));
+  }
+  // ==========================================================================
+  // Events
+  // ==========================================================================
+  on(eventType, callback) {
+    addEventListener(eventType, callback, this.eventListeners);
+  }
+  off(eventType, callback) {
+    removeEventListener(eventType, callback, this.eventListeners);
+  }
+  // ==========================================================================
+  // Communication
+  // ==========================================================================
+  async request(method, params) {
+    const resolvedParams = params ?? {};
+    if (this.isNativeWindow && hasTauri()) {
+      return sendInvoke(method, resolvedParams, this.config, this.log.bind(this));
     }
+    const requestId = generateRequestId(++this.requestCounter);
+    return sendPostMessage(method, resolvedParams, requestId, this.config, this._extensionInfo, this.pendingRequests);
   }
-  validateTableName(tableName) {
-    if (!tableName || typeof tableName !== "string") {
-      throw new HaexHubError(
-        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
-        "errors.table_name_empty"
-      );
+  // ==========================================================================
+  // Private: Initialization
+  // ==========================================================================
+  async init() {
+    if (this.initialized) return;
+    if (!isInIframe() && hasTauri()) {
+      try {
+        await this.initNative();
+        return;
+      } catch (error) {
+        this.log("Tauri commands failed, falling back to iframe mode", error);
+      }
     }
-    if (tableName.includes(TABLE_SEPARATOR)) {
-      throw new HaexHubError(
-        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
-        "errors.table_name_contains_separator",
-        { tableName, separator: TABLE_SEPARATOR }
-      );
+    await this.initIframe();
+  }
+  async initNative() {
+    const { extensionInfo: extensionInfo2, context: context2 } = await initNativeMode(
+      {
+        config: this.config,
+        state: {
+          initialized: this.initialized,
+          isNativeWindow: this.isNativeWindow,
+          requestCounter: this.requestCounter,
+          setupCompleted: this._setupCompleted,
+          extensionInfo: this._extensionInfo,
+          context: this._context,
+          orm: this.orm
+        },
+        collections: {
+          pendingRequests: this.pendingRequests,
+          eventListeners: this.eventListeners,
+          externalRequestHandlers: this.externalRequestHandlers,
+          reactiveSubscribers: this.reactiveSubscribers
+        },
+        promises: {
+          readyPromise: this.readyPromise,
+          resolveReady: this.resolveReady,
+          setupPromise: this.setupPromise,
+          setupHook: this.setupHook
+        },
+        handlers: {
+          messageHandler: this.messageHandler
+        }
+      },
+      this.log.bind(this),
+      this.handleEvent.bind(this),
+      (ctx) => {
+        this._context = ctx;
+        this.notifySubscribersInternal();
+      }
+    );
+    this._extensionInfo = extensionInfo2;
+    this._context = context2;
+    this.isNativeWindow = true;
+    this.initialized = true;
+    this.notifySubscribersInternal();
+    this.resolveReady();
+  }
+  async initIframe() {
+    this.messageHandler = createMessageHandler(
+      this.config,
+      this.pendingRequests,
+      () => this._extensionInfo,
+      this.handleEvent.bind(this)
+    );
+    const { context: context2 } = await initIframeMode(
+      {
+        config: this.config,
+        state: {
+          initialized: this.initialized,
+          isNativeWindow: this.isNativeWindow,
+          requestCounter: this.requestCounter,
+          setupCompleted: this._setupCompleted,
+          extensionInfo: this._extensionInfo,
+          context: this._context,
+          orm: this.orm
+        },
+        collections: {
+          pendingRequests: this.pendingRequests,
+          eventListeners: this.eventListeners,
+          externalRequestHandlers: this.externalRequestHandlers,
+          reactiveSubscribers: this.reactiveSubscribers
+        },
+        promises: {
+          readyPromise: this.readyPromise,
+          resolveReady: this.resolveReady,
+          setupPromise: this.setupPromise,
+          setupHook: this.setupHook
+        },
+        handlers: {
+          messageHandler: this.messageHandler
+        }
+      },
+      this.log.bind(this),
+      this.messageHandler,
+      this.request.bind(this)
+    );
+    if (this.config.manifest) {
+      this._extensionInfo = {
+        publicKey: this.config.manifest.publicKey,
+        name: this.config.manifest.name,
+        version: this.config.manifest.version,
+        displayName: this.config.manifest.name
+      };
+      this.notifySubscribersInternal();
     }
-    if (!/^[a-z][a-z0-9-_]*$/i.test(tableName)) {
-      throw new HaexHubError(
-        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
-        "errors.table_name_format",
-        { tableName }
-      );
+    this._context = context2;
+    this.isNativeWindow = false;
+    this.initialized = true;
+    this.notifySubscribersInternal();
+    this.resolveReady();
+  }
+  // ==========================================================================
+  // Private: Event Handling
+  // ==========================================================================
+  handleEvent(event) {
+    processEvent(
+      event,
+      this.log.bind(this),
+      this.eventListeners,
+      (ctx) => {
+        this._context = ctx;
+        this.notifySubscribersInternal();
+      },
+      (extEvent) => this.handleExternalRequestInternal(extEvent.data)
+    );
+  }
+  async handleExternalRequestInternal(request) {
+    await handleExternalRequest(request, this.externalRequestHandlers, this.respondToExternalRequest.bind(this), this.log.bind(this));
+  }
+  // ==========================================================================
+  // Private: Setup
+  // ==========================================================================
+  async runSetupAsync() {
+    if (!this.setupHook) return;
+    try {
+      this.log("[HaexVault] Running setup hook...");
+      await this.setupHook();
+      this._setupCompleted = true;
+      this.log("[HaexVault] Setup completed successfully");
+      this.notifySubscribersInternal();
+    } catch (error) {
+      this.log("[HaexVault] Setup failed:", error);
+      throw error;
     }
   }
+  // ==========================================================================
+  // Private: Utilities
+  // ==========================================================================
+  notifySubscribersInternal() {
+    notifySubscribers(this.reactiveSubscribers);
+  }
   log(...args) {
     if (this.config.debug) {
-      console.log("[HaexSpace SDK]", ...args);
+      console.log("[HaexVault SDK]", ...args);
     }
   }
 };