@haex-space/vault-sdk 1.0.0

package/dist/vue.js

@@ -0,0 +1,1388 @@
+'use strict';
+
+var vue = require('vue');
+var sqliteProxy = require('drizzle-orm/sqlite-proxy');
+
+// src/vue.ts
+
+// src/polyfills/localStorage.ts
+function installLocalStoragePolyfill() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  console.log("[HaexHub] Storage Polyfill loading immediately");
+  let localStorageWorks = false;
+  try {
+    const testKey = "__ls_test__";
+    localStorage.setItem(testKey, testKey);
+    localStorage.removeItem(testKey);
+    localStorageWorks = true;
+  } catch (e) {
+    console.warn("[HaexHub] localStorage blocked \u2013 using in-memory fallback");
+  }
+  if (!localStorageWorks) {
+    const lsStorage = /* @__PURE__ */ new Map();
+    const localStoragePoly = {
+      getItem(key) {
+        return lsStorage.get(key) || null;
+      },
+      setItem(key, value) {
+        lsStorage.set(key, String(value));
+      },
+      removeItem(key) {
+        lsStorage.delete(key);
+      },
+      clear() {
+        lsStorage.clear();
+      },
+      get length() {
+        return lsStorage.size;
+      },
+      key(index) {
+        return Array.from(lsStorage.keys())[index] || null;
+      }
+    };
+    try {
+      Object.defineProperty(window, "localStorage", {
+        value: localStoragePoly,
+        writable: true,
+        configurable: true
+      });
+    } catch (e) {
+      window.localStorage = localStoragePoly;
+    }
+    console.log("[HaexHub] localStorage replaced with in-memory polyfill");
+  }
+}
+function installSessionStoragePolyfill() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    const sessionStoragePoly = {
+      getItem() {
+        return null;
+      },
+      setItem() {
+      },
+      removeItem() {
+      },
+      clear() {
+      },
+      get length() {
+        return 0;
+      },
+      key() {
+        return null;
+      }
+    };
+    Object.defineProperty(window, "sessionStorage", {
+      value: sessionStoragePoly,
+      writable: true,
+      configurable: true
+    });
+  } catch (e) {
+    window.sessionStorage = {
+      getItem: () => null,
+      setItem: () => {
+      },
+      removeItem: () => {
+      },
+      clear: () => {
+      },
+      get length() {
+        return 0;
+      },
+      key: () => null
+    };
+  }
+  console.log("[HaexHub] sessionStorage polyfill installed");
+}
+
+// src/polyfills/cookies.ts
+function installCookiePolyfill() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return;
+  }
+  let cookiesWork = false;
+  try {
+    document.cookie = "__cookie_test__=1";
+    cookiesWork = document.cookie.indexOf("__cookie_test__") !== -1;
+  } catch (e) {
+    console.warn("[HaexHub] Cookies blocked \u2013 using in-memory fallback");
+  }
+  if (!cookiesWork) {
+    const cookieStore = /* @__PURE__ */ new Map();
+    Object.defineProperty(document, "cookie", {
+      get() {
+        const cookies = [];
+        cookieStore.forEach((value, key) => {
+          cookies.push(`${key}=${value}`);
+        });
+        return cookies.join("; ");
+      },
+      set(cookieString) {
+        const parts = cookieString.split(";").map((p) => p.trim());
+        const [keyValue] = parts;
+        if (!keyValue) return;
+        const [key, value] = keyValue.split("=");
+        if (!key) return;
+        const options = {};
+        for (let i = 1; i < parts.length; i++) {
+          const part = parts[i];
+          if (!part) continue;
+          const parts_split = part.split("=");
+          const optKey = parts_split[0];
+          const optValue = parts_split[1];
+          if (optKey) {
+            options[optKey.toLowerCase()] = optValue || true;
+          }
+        }
+        const expiresValue = options.expires;
+        if (expiresValue && typeof expiresValue === "string") {
+          const expiresDate = new Date(expiresValue);
+          if (expiresDate < /* @__PURE__ */ new Date()) {
+            cookieStore.delete(key);
+            return;
+          }
+        }
+        const maxAgeValue = options["max-age"];
+        if (typeof maxAgeValue === "string" && maxAgeValue === "0") {
+          cookieStore.delete(key);
+          return;
+        }
+        cookieStore.set(key, value || "");
+      },
+      configurable: true
+    });
+    console.log("[HaexHub] Cookie polyfill installed");
+  }
+}
+
+// src/polyfills/history.ts
+function installHistoryPolyfill() {
+  if (typeof window === "undefined" || typeof history === "undefined") {
+    return;
+  }
+  const install = () => {
+    console.log("[HaexHub] History Patch loading");
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    let skipNextPush = false;
+    let skipNextReplace = false;
+    history.pushState = function(state, title, url) {
+      console.log("[HaexHub] pushState called:", url, "skip:", skipNextPush);
+      if (skipNextPush) {
+        skipNextPush = false;
+        console.log("[HaexHub] pushState skipped");
+        return;
+      }
+      try {
+        return originalPushState.call(this, state, title, url);
+      } catch (e) {
+        if (e.name === "SecurityError" && url) {
+          const urlString = url.toString();
+          let hashUrl = urlString.replace(/^\/#/, "");
+          hashUrl = hashUrl.startsWith("#") ? hashUrl : "#" + hashUrl;
+          console.log("[HaexHub] SecurityError - setting hash to:", hashUrl);
+          skipNextPush = true;
+          window.location.hash = hashUrl.replace(/^#/, "");
+          return;
+        }
+        throw e;
+      }
+    };
+    history.replaceState = function(state, title, url) {
+      console.log("[HaexHub] replaceState called:", url, "skip:", skipNextReplace);
+      if (skipNextReplace) {
+        skipNextReplace = false;
+        console.log("[HaexHub] replaceState skipped");
+        return;
+      }
+      try {
+        return originalReplaceState.call(this, state, title, url);
+      } catch (e) {
+        if (e.name === "SecurityError" && url) {
+          const urlString = url.toString();
+          let hashUrl = urlString.replace(/^\/#/, "");
+          hashUrl = hashUrl.startsWith("#") ? hashUrl : "#" + hashUrl;
+          console.log("[HaexHub] SecurityError - setting hash to:", hashUrl);
+          skipNextReplace = true;
+          window.location.hash = hashUrl.replace(/^#/, "");
+          return;
+        }
+        throw e;
+      }
+    };
+    console.log("[HaexHub] History API patched");
+  };
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", install, { once: true });
+  } else {
+    install();
+  }
+}
+
+// src/polyfills/debug.ts
+function installDebugDiagnostics() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const hasParent = window.parent && window.parent !== window;
+  console.log("[HaexHub] hasParent:", hasParent);
+  if (hasParent) {
+    console.log("[HaexHub] Attempting to send debug message to parent...");
+    window.parent.postMessage({
+      type: "haexhub:debug",
+      data: `[Polyfills] window.parent test: exists=${!!window.parent}, different=${hasParent}, selfIsTop=${window.self === window.top}`
+    }, "*");
+    console.log("[HaexHub] Debug message sent!");
+  } else {
+    console.log("[HaexHub] No parent window or parent === window");
+  }
+}
+
+// src/polyfills/consoleForwarding.ts
+var originalConsole = {
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error,
+  debug: console.debug
+};
+function serializeArgs(args) {
+  return args.map((arg) => {
+    if (arg === null) return "null";
+    if (arg === void 0) return "undefined";
+    if (typeof arg === "object") {
+      try {
+        return JSON.stringify(arg, null, 2);
+      } catch {
+        return String(arg);
+      }
+    }
+    return String(arg);
+  }).join(" ");
+}
+function interceptConsole(level) {
+  console[level] = function(...args) {
+    originalConsole[level].apply(console, args);
+    if (window.self !== window.top && window.parent) {
+      try {
+        const message = serializeArgs(args);
+        const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        window.parent.postMessage(
+          {
+            type: "console.forward",
+            data: {
+              timestamp,
+              level,
+              message
+            },
+            timestamp: Date.now()
+          },
+          "*"
+        );
+      } catch (error) {
+        originalConsole.error("[HaexHub] Failed to forward console message:", error);
+      }
+    }
+  };
+}
+function installConsoleForwarding(debug = false) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (window.self === window.top) {
+    return;
+  }
+  if (!debug) {
+    console.log("[HaexHub] Console forwarding disabled (not in debug mode)");
+    return;
+  }
+  interceptConsole("log");
+  interceptConsole("info");
+  interceptConsole("warn");
+  interceptConsole("error");
+  interceptConsole("debug");
+  console.log("[HaexHub] Console forwarding installed");
+}
+
+// src/polyfills/index.ts
+function installPolyfills() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  installLocalStoragePolyfill();
+  installSessionStoragePolyfill();
+  installCookiePolyfill();
+  installHistoryPolyfill();
+  console.log("[HaexHub] All polyfills loaded successfully");
+  installDebugDiagnostics();
+}
+if (typeof window !== "undefined") {
+  installPolyfills();
+}
+
+// src/events.ts
+var HAEXTENSION_EVENTS = {
+  /** Context (theme, locale, platform) has changed */
+  CONTEXT_CHANGED: "haextension:context:changed",
+  /** Search request from HaexHub */
+  SEARCH_REQUEST: "haextension:search:request"
+};
+
+// src/methods.ts
+var HAEXTENSION_METHODS = {
+  context: {
+    get: "haextension:context:get"
+  },
+  database: {
+    query: "haextension:database:query",
+    execute: "haextension:database:execute",
+    transaction: "haextension:database:transaction",
+    registerMigrations: "haextension:database:register-migrations"
+  },
+  filesystem: {
+    saveFile: "haextension:filesystem:save-file",
+    openFile: "haextension:filesystem:open-file",
+    showImage: "haextension:filesystem:show-image"
+  },
+  storage: {
+    getItem: "haextension:storage:get-item",
+    setItem: "haextension:storage:set-item",
+    removeItem: "haextension:storage:remove-item",
+    clear: "haextension:storage:clear",
+    keys: "haextension:storage:keys"
+  },
+  web: {
+    fetch: "haextension:web:fetch"
+  },
+  application: {
+    open: "haextension:application:open"
+  }
+};
+
+// src/types.ts
+var DEFAULT_TIMEOUT = 3e4;
+var TABLE_SEPARATOR = "__";
+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) {
+    this.client = client;
+  }
+  async getItem(key) {
+    return this.client.request(HAEXTENSION_METHODS.storage.getItem, { key });
+  }
+  async setItem(key, value) {
+    await this.client.request(HAEXTENSION_METHODS.storage.setItem, { key, value });
+  }
+  async removeItem(key) {
+    await this.client.request(HAEXTENSION_METHODS.storage.removeItem, { key });
+  }
+  async clear() {
+    await this.client.request(HAEXTENSION_METHODS.storage.clear);
+  }
+  async keys() {
+    return this.client.request(HAEXTENSION_METHODS.storage.keys);
+  }
+};
+
+// src/api/database.ts
+var DatabaseAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async query(query, params) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.database.query,
+      {
+        query,
+        params: params || []
+      }
+    );
+    return result.rows;
+  }
+  async queryOne(query, params) {
+    const rows = await this.query(query, params);
+    return rows.length > 0 ? rows[0] ?? null : null;
+  }
+  async execute(query, params) {
+    return this.client.request(HAEXTENSION_METHODS.database.execute, {
+      query,
+      params: params || []
+    });
+  }
+  async transaction(statements) {
+    await this.client.request(HAEXTENSION_METHODS.database.transaction, {
+      statements
+    });
+  }
+  async createTable(tableName, columns) {
+    const query = `CREATE TABLE IF NOT EXISTS ${tableName} (${columns})`;
+    await this.execute(query);
+  }
+  async dropTable(tableName) {
+    const query = `DROP TABLE IF EXISTS ${tableName}`;
+    await this.execute(query);
+  }
+  /**
+   * Registers extension migrations with HaexVault for CRDT synchronization
+   * HaexVault will validate and execute these migrations, ensuring only
+   * tables with the correct prefix are manipulated
+   * @param extensionVersion - The version of the extension
+   * @param migrations - Array of migration objects with name and SQL content
+   * @returns Promise that resolves when migrations are registered
+   */
+  async registerMigrationsAsync(extensionVersion, migrations) {
+    await this.client.request(HAEXTENSION_METHODS.database.registerMigrations, {
+      extensionVersion,
+      migrations
+    });
+  }
+  async insert(tableName, data) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = keys.map(() => "?").join(", ");
+    const query = `INSERT INTO ${tableName} (${keys.join(
+      ", "
+    )}) VALUES (${placeholders})`;
+    const result = await this.execute(query, values);
+    return result.lastInsertId ?? -1;
+  }
+  async update(tableName, data, where, whereParams) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const setClause = keys.map((key) => `${key} = ?`).join(", ");
+    const query = `UPDATE ${tableName} SET ${setClause} WHERE ${where}`;
+    const result = await this.execute(query, [
+      ...values,
+      ...whereParams || []
+    ]);
+    return result.rowsAffected;
+  }
+  async delete(tableName, where, whereParams) {
+    const query = `DELETE FROM ${tableName} WHERE ${where}`;
+    const result = await this.execute(query, whereParams);
+    return result.rowsAffected;
+  }
+  async count(tableName, where, whereParams) {
+    const query = where ? `SELECT COUNT(*) as count FROM ${tableName} WHERE ${where}` : `SELECT COUNT(*) as count FROM ${tableName}`;
+    const result = await this.queryOne(query, whereParams);
+    return result?.count ?? 0;
+  }
+};
+
+// src/api/filesystem.ts
+var FilesystemAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Opens a save file dialog and saves the provided data to the selected location
+   * @param data The file data as Uint8Array
+   * @param options Options for the save dialog
+   * @returns The path where the file was saved, or null if cancelled
+   */
+  async saveFileAsync(data, options = {}) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.saveFile,
+      {
+        data: Array.from(data),
+        // Convert Uint8Array to regular array for postMessage
+        defaultPath: options.defaultPath,
+        title: options.title,
+        filters: options.filters
+      }
+    );
+    return result;
+  }
+  /**
+   * Opens a file with the system's default viewer
+   * @param data The file data as Uint8Array
+   * @param options Options for opening the file
+   * @returns The result of the operation
+   */
+  async openFileAsync(data, options) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.openFile,
+      {
+        data: Array.from(data),
+        // Convert Uint8Array to regular array for postMessage
+        fileName: options.fileName,
+        mimeType: options.mimeType
+      }
+    );
+    return result;
+  }
+  /**
+   * Shows an image using a data URL (safe, read-only viewing)
+   * This is safe to use without special permissions as it only displays images
+   * and doesn't execute any code or open files with external applications
+   * @param options Options containing the data URL
+   * @returns The result of the operation
+   */
+  async showImageAsync(options) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.showImage,
+      {
+        dataUrl: options.dataUrl
+      }
+    );
+    return result;
+  }
+};
+
+// src/api/web.ts
+var WebAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Performs a web request through the HaexHub host application
+   * @param url The URL to fetch
+   * @param options Request options (method, headers, body, timeout)
+   * @returns Promise resolving to the web response
+   */
+  async fetchAsync(url, options = {}) {
+    let bodyParam;
+    if (options.body) {
+      if (options.body instanceof ArrayBuffer) {
+        bodyParam = this.arrayBufferToBase64(options.body);
+      } else if (options.body instanceof Blob) {
+        bodyParam = await this.blobToBase64(options.body);
+      } else {
+        bodyParam = options.body;
+      }
+    }
+    const response = await this.client.request(HAEXTENSION_METHODS.web.fetch, {
+      url,
+      method: options.method || "GET",
+      headers: options.headers,
+      body: bodyParam,
+      timeout: options.timeout
+    });
+    const bodyBuffer = this.base64ToArrayBuffer(response.body);
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      body: bodyBuffer,
+      url: response.url
+    };
+  }
+  /**
+   * Convenience method for JSON requests
+   */
+  async fetchJsonAsync(url, options = {}) {
+    const response = await this.fetchAsync(url, options);
+    const text = new TextDecoder().decode(response.body);
+    return JSON.parse(text);
+  }
+  /**
+   * Convenience method for text requests
+   */
+  async fetchTextAsync(url, options = {}) {
+    const response = await this.fetchAsync(url, options);
+    return new TextDecoder().decode(response.body);
+  }
+  /**
+   * Convenience method for blob requests
+   */
+  async fetchBlobAsync(url, options = {}) {
+    const response = await this.fetchAsync(url, options);
+    return new Blob([response.body]);
+  }
+  /**
+   * Opens a URL in the user's default browser
+   * @param url The URL to open
+   */
+  async openAsync(url) {
+    await this.client.request(HAEXTENSION_METHODS.application.open, {
+      application: "browser",
+      url
+    });
+  }
+  arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+      const byte = bytes[i];
+      if (byte === void 0) {
+        throw new Error("Invalid byte at index " + i);
+      }
+      binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+  }
+  async blobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        const result = reader.result;
+        if (typeof result !== "string") {
+          reject(new Error("Failed to read blob as data URL"));
+          return;
+        }
+        const parts = result.split(",");
+        const base64 = parts[1];
+        if (!base64) {
+          reject(new Error("Failed to extract base64 from data URL"));
+          return;
+        }
+        resolve(base64);
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+  base64ToArrayBuffer(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+};
+
+// src/api/permissions.ts
+var PermissionsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Checks if the extension has permission for a database operation
+   * @param resource The database resource (table name or "*" for all tables)
+   * @param operation The operation type ("read" or "write")
+   * @returns Promise<boolean> indicating if permission is granted
+   */
+  async checkDatabaseAsync(resource, operation) {
+    const response = await this.client.request(
+      "permissions.database.check",
+      {
+        resource,
+        operation
+      }
+    );
+    return response.status === "granted";
+  }
+  /**
+   * Checks if the extension has permission for a web request
+   * @param url The URL to check (e.g., "https://example.com/path")
+   * @returns Promise<boolean> indicating if permission is granted
+   * @note Method/operation is not checked - permissions apply to all HTTP methods
+   */
+  async checkWebAsync(url) {
+    const response = await this.client.request(
+      "permissions.web.check",
+      {
+        url
+      }
+    );
+    return response.status === "granted";
+  }
+  /**
+   * Checks if the extension has permission for a filesystem operation
+   * @param path The file or directory path
+   * @param operation The operation type ("read" or "write")
+   * @returns Promise<boolean> indicating if permission is granted
+   */
+  async checkFilesystemAsync(path, operation) {
+    const response = await this.client.request(
+      "permissions.filesystem.check",
+      {
+        path,
+        operation
+      }
+    );
+    return response.status === "granted";
+  }
+};
+var HaexVaultClient = class {
+  constructor(config = {}) {
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.eventListeners = /* @__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();
+  }
+  /**
+   * Gibt ein Promise zurück, das aufgelöst wird, sobald der Client
+   * initialisiert ist und Extension-Infos empfangen hat.
+   */
+  async ready() {
+    return this.readyPromise;
+  }
+  /**
+   * Gibt zurück, ob das Setup bereits abgeschlossen wurde.
+   */
+  get setupCompleted() {
+    return this._setupCompleted;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  async runSetupAsync() {
+    if (!this.setupHook) return;
+    try {
+      this.log("[HaexHub] Running setup hook...");
+      await this.setupHook();
+      this._setupCompleted = true;
+      this.log("[HaexHub] Setup completed successfully");
+      this.notifySubscribers();
+    } catch (error) {
+      this.log("[HaexHub] Setup failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * 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 = sqliteProxy.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
+      }
+    );
+    this.orm = dbInstance;
+    return dbInstance;
+  }
+  get extensionInfo() {
+    return this._extensionInfo;
+  }
+  get context() {
+    return this._context;
+  }
+  subscribe(callback) {
+    this.reactiveSubscribers.add(callback);
+    return () => {
+      this.reactiveSubscribers.delete(callback);
+    };
+  }
+  notifySubscribers() {
+    this.reactiveSubscribers.forEach((callback) => callback());
+  }
+  async getDependencies() {
+    return this.request("extensions.getDependencies");
+  }
+  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;
+    const extensionName = name;
+    return `"${publicKey}${TABLE_SEPARATOR}${extensionName}${TABLE_SEPARATOR}${tableName}"`;
+  }
+  getDependencyTableName(publicKey, extensionName, tableName) {
+    this.validatePublicKey(publicKey);
+    this.validateExtensionName(extensionName);
+    this.validateTableName(tableName);
+    return `"${publicKey}${TABLE_SEPARATOR}${extensionName}${TABLE_SEPARATOR}${tableName}"`;
+  }
+  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
+    };
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Alias for query() - more intuitive for SELECT statements
+   */
+  async select(sql, params = []) {
+    return this.query(sql, params);
+  }
+  /**
+   * 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 extension migrations with HaexVault for CRDT synchronization
+   * HaexVault will validate and execute these migrations
+   * @param extensionVersion - The version of the extension
+   * @param migrations - Array of migration objects with name and SQL content
+   * @returns Promise that resolves when migrations are registered
+   */
+  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
+    });
+  }
+  async request(method, params = {}) {
+    if (this.isNativeWindow && typeof window.__TAURI__ !== "undefined") {
+      return this.invoke(method, params);
+    }
+    return this.postMessage(method, params);
+  }
+  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
+        });
+      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");
+  }
+  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("[HaexHub SDK] Setting up Tauri event listener for:", HAEXTENSION_EVENTS.CONTEXT_CHANGED);
+          try {
+            await listen(HAEXTENSION_EVENTS.CONTEXT_CHANGED, (event) => {
+              console.log("[HaexHub 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("[HaexHub SDK] Updated context to:", this._context);
+                this.handleEvent({
+                  type: HAEXTENSION_EVENTS.CONTEXT_CHANGED,
+                  data: { context: this._context },
+                  timestamp: Date.now()
+                });
+              } else {
+                console.warn("[HaexHub SDK] Event received but no context in payload:", event);
+              }
+            });
+            console.log("[HaexHub SDK] Context change listener registered successfully");
+          } catch (error) {
+            console.error("[HaexHub SDK] Failed to setup context change listener:", error);
+            this.log("Failed to setup context change 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("HaexHub 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: "haexhub: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;
+    }
+  }
+  handleMessage(event) {
+    if (this.config.debug) {
+      console.log("[SDK Debug] ========== Message Received ==========");
+      console.log("[SDK Debug] Event origin:", event.origin);
+      console.log(
+        "[SDK Debug] Event source:",
+        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] Pending requests count:",
+        this.pendingRequests.size
+      );
+    }
+    if (event.source !== window.parent) {
+      if (this.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) {
+        console.log("[SDK Debug] \u2705 Found pending request for ID:", data.id);
+      }
+      const pending = this.pendingRequests.get(data.id);
+      clearTimeout(pending.timeout);
+      this.pendingRequests.delete(data.id);
+      if (data.error) {
+        if (this.config.debug) {
+          console.error("[SDK Debug] \u274C Request failed:", data.error);
+        }
+        pending.reject(data.error);
+      } else {
+        if (this.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) {
+        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())
+        );
+      }
+    }
+    if ("type" in data && data.type) {
+      if (this.config.debug) {
+        console.log("[SDK Debug] Event received:", data.type);
+      }
+      this.handleEvent(data);
+    }
+    if (this.config.debug) {
+      console.log("[SDK Debug] ========== End Message ==========");
+    }
+  }
+  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();
+    }
+    this.emitEvent(event);
+  }
+  emitEvent(event) {
+    this.log("Event received:", event);
+    const listeners = this.eventListeners.get(event.type);
+    if (listeners) {
+      listeners.forEach((callback) => callback(event));
+    }
+  }
+  generateRequestId() {
+    return `req_${++this.requestCounter}`;
+  }
+  validatePublicKey(publicKey) {
+    if (!publicKey || typeof publicKey !== "string" || publicKey.trim() === "") {
+      throw new HaexHubError(
+        "INVALID_PUBLIC_KEY" /* INVALID_PUBLIC_KEY */,
+        "errors.invalid_public_key",
+        { publicKey }
+      );
+    }
+  }
+  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 }
+      );
+    }
+  }
+  validateTableName(tableName) {
+    if (!tableName || typeof tableName !== "string") {
+      throw new HaexHubError(
+        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+        "errors.table_name_empty"
+      );
+    }
+    if (tableName.includes(TABLE_SEPARATOR)) {
+      throw new HaexHubError(
+        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+        "errors.table_name_contains_separator",
+        { tableName, separator: TABLE_SEPARATOR }
+      );
+    }
+    if (!/^[a-z][a-z0-9-_]*$/i.test(tableName)) {
+      throw new HaexHubError(
+        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+        "errors.table_name_format",
+        { tableName }
+      );
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[HaexHub SDK]", ...args);
+    }
+  }
+};
+
+// src/index.ts
+function createHaexVaultClient(config = {}) {
+  return new HaexVaultClient(config);
+}
+
+// src/vue.ts
+var clientInstance = null;
+var extensionInfo = null;
+var context = null;
+var isSetupComplete = null;
+function useHaexHub(config = {}) {
+  if (!clientInstance) {
+    clientInstance = createHaexVaultClient(config);
+    extensionInfo = vue.ref(clientInstance.extensionInfo);
+    context = vue.ref(clientInstance.context);
+    isSetupComplete = vue.ref(false);
+    clientInstance.subscribe(() => {
+      if (extensionInfo) {
+        extensionInfo.value = clientInstance.extensionInfo;
+      }
+      if (context) {
+        context.value = clientInstance.context;
+      }
+      if (isSetupComplete) {
+        isSetupComplete.value = clientInstance.setupCompleted;
+      }
+    });
+  }
+  return {
+    client: clientInstance,
+    extensionInfo: vue.readonly(extensionInfo),
+    context: vue.readonly(context),
+    isSetupComplete: vue.readonly(isSetupComplete),
+    db: clientInstance.orm,
+    storage: clientInstance.storage,
+    getTableName: clientInstance.getTableName.bind(clientInstance)
+  };
+}
+function getHaexVaultClient() {
+  return clientInstance;
+}
+
+exports.getHaexVaultClient = getHaexVaultClient;
+exports.useHaexHub = useHaexHub;
+//# sourceMappingURL=vue.js.map
+//# sourceMappingURL=vue.js.map