mindoodb-app-sdk 0.0.41 → 0.0.42

package/dist/chunk-6433L6TE.js

@@ -0,0 +1,1303 @@
+// src/client/createMindooDBAppBridge.ts
+import { parseMindooDBFormulaBooleanExpression } from "mindoodb-view-language";
+
+// src/client/portRpcClient.ts
+var PROTOCOL = "mindoodb-app-bridge";
+function normalizeRpcValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (typeof value === "function") {
+    throw new Error("Bridge RPC params cannot include functions.");
+  }
+  if (typeof value === "symbol") {
+    throw new Error("Bridge RPC params cannot include symbols.");
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof ArrayBuffer) {
+    return value.slice(0);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+  }
+  if (seen.has(value)) {
+    return seen.get(value);
+  }
+  if (Array.isArray(value)) {
+    const copy2 = [];
+    seen.set(value, copy2);
+    for (const entry of value) {
+      copy2.push(normalizeRpcValue(entry, seen));
+    }
+    return copy2;
+  }
+  const copy = {};
+  seen.set(value, copy);
+  for (const [key, entry] of Object.entries(value)) {
+    copy[key] = normalizeRpcValue(entry, seen);
+  }
+  return copy;
+}
+function toBridgeError(error) {
+  const wrapped = new Error(error.message);
+  wrapped.name = error.code || "MindooDBAppBridgeError";
+  return wrapped;
+}
+function isRpcMessage(message) {
+  if (!isProtocolMessage(message)) {
+    return false;
+  }
+  return "id" in message && typeof message.id === "string";
+}
+function isProtocolMessage(message) {
+  return Boolean(
+    message && typeof message === "object" && "protocol" in message && message.protocol === PROTOCOL
+  );
+}
+var PortRpcClient = class {
+  constructor(port) {
+    this.port = port;
+    this.handleMessage = this.handleMessage.bind(this);
+    this.port.addEventListener("message", this.handleMessage);
+    this.port.start();
+  }
+  port;
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  requestCounter = 0;
+  disposed = false;
+  /** Sends one RPC request and resolves with the typed response payload. */
+  async call(method, params) {
+    if (this.disposed) {
+      throw new Error("The bridge connection has already been closed.");
+    }
+    const normalizedParams = normalizeRpcValue(params);
+    const id = `${Date.now()}-${this.requestCounter += 1}`;
+    const message = {
+      protocol: PROTOCOL,
+      kind: "request",
+      id,
+      method,
+      params: normalizedParams
+    };
+    return await new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      try {
+        this.port.postMessage(message);
+      } catch (error) {
+        this.pending.delete(id);
+        console.error("MindooDB app bridge RPC postMessage failed.", { method, params: normalizedParams, error });
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  /** Closes the port and rejects any requests that are still waiting for a response. */
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.port.removeEventListener("message", this.handleMessage);
+    this.port.close();
+    this.pending.forEach(({ reject }) => reject(new Error("The bridge connection was closed.")));
+    this.pending.clear();
+    this.listeners.clear();
+  }
+  /** Subscribes to all protocol messages, including attachment stream traffic. */
+  addMessageListener(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Posts a raw protocol message over the port, optionally with transferables. */
+  postMessage(message, transfer = []) {
+    if (this.disposed) {
+      throw new Error("The bridge connection has already been closed.");
+    }
+    try {
+      this.port.postMessage(message, transfer);
+    } catch (error) {
+      console.error("MindooDB app bridge raw postMessage failed.", { message, transferCount: transfer.length, error });
+      throw error;
+    }
+  }
+  /** Dispatches incoming messages to listeners and resolves matching RPC requests. */
+  handleMessage(event) {
+    if (!isProtocolMessage(event.data)) {
+      return;
+    }
+    const message = event.data;
+    this.listeners.forEach((listener) => listener(message));
+    if (!isRpcMessage(message)) {
+      return;
+    }
+    if (message.kind !== "success" && message.kind !== "error") {
+      return;
+    }
+    const pending = this.pending.get(message.id);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(message.id);
+    if (message.kind === "success") {
+      pending.resolve(message.result);
+      return;
+    }
+    pending.reject(toBridgeError(message.error));
+  }
+};
+
+// src/client/createMindooDBAppBridge.ts
+var PROTOCOL2 = "mindoodb-app-bridge";
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+function isMethodNotFoundError(error) {
+  return error instanceof Error && error.name === "method-not-found";
+}
+function toTransferableArrayBuffer(chunk) {
+  return chunk.buffer.slice(
+    chunk.byteOffset,
+    chunk.byteOffset + chunk.byteLength
+  );
+}
+function isStreamChunkFor(streamId, message) {
+  return message.kind === "stream-chunk" && message.streamId === streamId;
+}
+function isStreamAckFor(streamId, message) {
+  return message.kind === "stream-ack" && message.streamId === streamId;
+}
+function isStreamErrorFor(streamId, message) {
+  return message.kind === "stream-error" && message.streamId === streamId;
+}
+function isQueryResultFor(subscriptionId, message) {
+  return message.kind === "query-result" && message.subscriptionId === subscriptionId;
+}
+function isViewChangedFor(navigatorId, message) {
+  return message.kind === "view-changed" && message.navigatorId === navigatorId;
+}
+function normalizeDocumentQuery(query) {
+  if (!query) {
+    return {};
+  }
+  const { filter, ...rest } = query;
+  return {
+    ...rest,
+    ...filter !== void 0 ? {
+      filter: typeof filter === "string" ? parseMindooDBFormulaBooleanExpression(filter) : filter
+    } : {}
+  };
+}
+function isThemeChangedMessage(message) {
+  return message.kind === "theme-changed";
+}
+function isViewportChangedMessage(message) {
+  return message.kind === "viewport-changed";
+}
+function isUiPreferencesChangedMessage(message) {
+  return message.kind === "ui-preferences-changed";
+}
+function isLocaleChangedMessage(message) {
+  return message.kind === "locale-changed";
+}
+function toStreamError(message) {
+  const error = new Error(message.error.message);
+  error.name = message.error.code || "MindooDBAppBridgeStreamError";
+  return error;
+}
+function resolveLaunchId(options) {
+  if (options?.launchId) {
+    return options.launchId;
+  }
+  if (typeof window === "undefined") {
+    throw new Error(
+      "A launchId must be provided when connecting outside the browser."
+    );
+  }
+  const search = new URLSearchParams(window.location.search);
+  const launchId = search.get("mindoodbAppLaunchId");
+  if (!launchId) {
+    throw new Error("Missing mindoodbAppLaunchId in the current URL.");
+  }
+  return launchId;
+}
+function shouldUseWindowedHostTab() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return window.parent === window && Boolean(window.opener);
+}
+function resolveTargetWindow() {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "The MindooDB app bridge is only available in the browser."
+    );
+  }
+  if (window.parent && window.parent !== window) {
+    return window.parent;
+  }
+  if (window.opener) {
+    return window.opener;
+  }
+  throw new Error("Could not find a MindooDB Haven host window.");
+}
+function waitForConnectedPort(options, launchId) {
+  const targetWindow = resolveTargetWindow();
+  const targetOrigin = options?.targetOrigin ?? "*";
+  const channel = new MessageChannel();
+  const timeoutMs = options?.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    let timeoutId = null;
+    const cleanup = () => {
+      if (timeoutId !== null) {
+        window.clearTimeout(timeoutId);
+      }
+      channel.port1.removeEventListener(
+        "message",
+        handleMessage
+      );
+    };
+    const handleMessage = (event) => {
+      const payload = event.data;
+      if (!payload || payload.protocol !== PROTOCOL2) {
+        return;
+      }
+      if (payload.type === "mindoodb-app:connected") {
+        cleanup();
+        resolve(channel.port1);
+        return;
+      }
+      if (payload.type === "mindoodb-app:error") {
+        cleanup();
+        channel.port1.close();
+        const message2 = typeof payload.error === "string" && payload.error.trim() ? payload.error : "MindooDB Haven bridge connection failed.";
+        reject(new Error(message2));
+      }
+    };
+    timeoutId = window.setTimeout(() => {
+      cleanup();
+      channel.port1.close();
+      reject(
+        new Error(
+          `Timed out while connecting to the MindooDB Haven bridge for launch ${launchId}.`
+        )
+      );
+    }, timeoutMs);
+    channel.port1.addEventListener("message", handleMessage);
+    channel.port1.start();
+    const message = {
+      protocol: PROTOCOL2,
+      type: "mindoodb-app:connect",
+      launchId
+    };
+    targetWindow.postMessage(message, targetOrigin, [channel.port2]);
+  });
+}
+var MindooDBAppViewNavigatorImpl = class {
+  constructor(rpc, navigatorId, viewCursor) {
+    this.rpc = rpc;
+    this.navigatorId = navigatorId;
+    this.viewCursor = viewCursor;
+  }
+  rpc;
+  navigatorId;
+  viewCursor;
+  /** Shorthand: call an RPC method with the navigator ID automatically injected. */
+  async call(method, params = {}) {
+    return await this.rpc.call(method, {
+      navigatorId: this.navigatorId,
+      ...params
+    });
+  }
+  async getDefinition() {
+    return await this.call("viewNavigators.getDefinition");
+  }
+  async getViewCursor() {
+    return this.viewCursor;
+  }
+  async refresh() {
+    const result = await this.call(
+      "viewNavigators.refresh"
+    );
+    this.viewCursor = result.viewCursor;
+    return this.viewCursor;
+  }
+  onDidUpdate(listener) {
+    return this.rpc.addMessageListener((message) => {
+      if (isViewChangedFor(this.navigatorId, message)) {
+        listener(message.stats);
+      }
+    });
+  }
+  async getCurrentEntry() {
+    return await this.call("viewNavigators.current.get");
+  }
+  async gotoFirst() {
+    return await this.call("viewNavigators.goto.first");
+  }
+  async gotoLast() {
+    return await this.call("viewNavigators.goto.last");
+  }
+  async gotoNext() {
+    return await this.call("viewNavigators.goto.next");
+  }
+  async gotoPrev() {
+    return await this.call("viewNavigators.goto.prev");
+  }
+  async gotoNextSibling() {
+    return await this.call("viewNavigators.goto.nextSibling");
+  }
+  async gotoPrevSibling() {
+    return await this.call("viewNavigators.goto.prevSibling");
+  }
+  async gotoParent() {
+    return await this.call("viewNavigators.goto.parent");
+  }
+  async gotoFirstChild() {
+    return await this.call("viewNavigators.goto.firstChild");
+  }
+  async gotoLastChild() {
+    return await this.call("viewNavigators.goto.lastChild");
+  }
+  async gotoPos(position) {
+    return await this.call("viewNavigators.goto.pos", { position });
+  }
+  async getPos(position) {
+    return await this.call("viewNavigators.pos.get", { position });
+  }
+  async findCategoryEntryByParts(parts) {
+    return await this.call("viewNavigators.category.findByParts", { parts });
+  }
+  async entriesForward(options) {
+    return await this.call("viewNavigators.entries.forward", {
+      options: options ?? {}
+    });
+  }
+  async entriesBackward(options) {
+    return await this.call("viewNavigators.entries.backward", {
+      options: options ?? {}
+    });
+  }
+  async gotoNextSelected() {
+    return await this.call("viewNavigators.goto.nextSelected");
+  }
+  async gotoPrevSelected() {
+    return await this.call("viewNavigators.goto.prevSelected");
+  }
+  async select(origin, docId, selectParentCategories) {
+    await this.call("viewNavigators.selection.select", {
+      origin,
+      docId,
+      selectParentCategories
+    });
+  }
+  async deselect(origin, docId) {
+    await this.call("viewNavigators.selection.deselect", { origin, docId });
+  }
+  async selectAllEntries() {
+    await this.call("viewNavigators.selection.selectAll");
+  }
+  async deselectAllEntries() {
+    await this.call("viewNavigators.selection.deselectAll");
+  }
+  async isSelected(origin, docId) {
+    return await this.call("viewNavigators.selection.isSelected", {
+      origin,
+      docId
+    });
+  }
+  async getSelectionState() {
+    return await this.call("viewNavigators.selection.get");
+  }
+  async setSelectionState(state) {
+    await this.call("viewNavigators.selection.set", { state });
+  }
+  async expand(origin, docId) {
+    await this.call("viewNavigators.expansion.expand", { origin, docId });
+  }
+  async collapse(origin, docId) {
+    await this.call("viewNavigators.expansion.collapse", { origin, docId });
+  }
+  async expandAll() {
+    await this.call("viewNavigators.expansion.expandAll");
+  }
+  async collapseAll() {
+    await this.call("viewNavigators.expansion.collapseAll");
+  }
+  async expandToLevel(level) {
+    await this.call("viewNavigators.expansion.expandToLevel", { level });
+  }
+  async isExpanded(entryKey) {
+    return await this.call("viewNavigators.expansion.isExpanded", { entryKey });
+  }
+  async getExpansionState() {
+    return await this.call("viewNavigators.expansion.get");
+  }
+  async setExpansionState(state) {
+    await this.call("viewNavigators.expansion.set", { state });
+  }
+  async childEntries(entryKey, descending) {
+    return await this.call("viewNavigators.children.entries", {
+      entryKey,
+      descending
+    });
+  }
+  async childCategories(entryKey, descending) {
+    return await this.call("viewNavigators.children.categories", {
+      entryKey,
+      descending
+    });
+  }
+  async childDocuments(entryKey, descending) {
+    return await this.call("viewNavigators.children.documents", {
+      entryKey,
+      descending
+    });
+  }
+  async childCategoriesByKey(entryKey, key, exact, descending) {
+    return await this.call("viewNavigators.children.categoriesByKey", {
+      entryKey,
+      key,
+      exact,
+      descending
+    });
+  }
+  async childDocumentsByKey(entryKey, key, exact, descending) {
+    return await this.call("viewNavigators.children.documentsByKey", {
+      entryKey,
+      key,
+      exact,
+      descending
+    });
+  }
+  async childCategoriesBetween(entryKey, range) {
+    return await this.call("viewNavigators.children.categoriesBetween", {
+      entryKey,
+      range
+    });
+  }
+  async childDocumentsBetween(entryKey, range) {
+    return await this.call("viewNavigators.children.documentsBetween", {
+      entryKey,
+      range
+    });
+  }
+  async getSortedDocIds(descending) {
+    return await this.call(
+      "viewNavigators.sortedDocIds.get",
+      { descending }
+    );
+  }
+  async getSortedDocIdsScoped(entryKey, descending) {
+    return await this.call(
+      "viewNavigators.sortedDocIds.scoped",
+      { entryKey, descending }
+    );
+  }
+  async dispose() {
+    await this.call("viewNavigators.dispose");
+  }
+};
+var MindooDBAppReadableAttachmentStreamImpl = class {
+  constructor(rpc, streamId) {
+    this.rpc = rpc;
+    this.streamId = streamId;
+    this.unsubscribe = this.rpc.addMessageListener((message) => {
+      if (isStreamChunkFor(this.streamId, message)) {
+        const pending = this.pendingRead;
+        this.pendingRead = null;
+        if (!pending) {
+          return;
+        }
+        pending.resolve(
+          message.done ? null : new Uint8Array(message.chunk ?? new ArrayBuffer(0))
+        );
+        if (message.done) {
+          this.closed = true;
+          this.unsubscribe();
+        }
+        return;
+      }
+      if (isStreamErrorFor(this.streamId, message)) {
+        const pending = this.pendingRead;
+        this.pendingRead = null;
+        pending?.reject(toStreamError(message));
+        this.closed = true;
+        this.unsubscribe();
+      }
+    });
+  }
+  rpc;
+  streamId;
+  unsubscribe;
+  closed = false;
+  pendingRead = null;
+  /** Requests and returns the next attachment chunk, or `null` when the stream ends. */
+  async read() {
+    if (this.closed) {
+      return null;
+    }
+    if (this.pendingRead) {
+      throw new Error(
+        "A read() call is already in progress for this attachment stream."
+      );
+    }
+    return await new Promise((resolve, reject) => {
+      this.pendingRead = { resolve, reject };
+      this.rpc.postMessage({
+        protocol: PROTOCOL2,
+        kind: "stream-read",
+        streamId: this.streamId
+      });
+    });
+  }
+  /** Closes the read stream and releases any pending read waiter. */
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.pendingRead?.resolve(null);
+    this.pendingRead = null;
+    this.rpc.postMessage({
+      protocol: PROTOCOL2,
+      kind: "stream-close",
+      streamId: this.streamId
+    });
+    this.unsubscribe();
+  }
+};
+var MindooDBAppWritableAttachmentStreamImpl = class {
+  constructor(rpc, streamId) {
+    this.rpc = rpc;
+    this.streamId = streamId;
+    this.unsubscribe = this.rpc.addMessageListener((message) => {
+      if (isStreamAckFor(this.streamId, message)) {
+        const inflight = this.inflight;
+        this.inflight = null;
+        inflight?.resolve();
+        return;
+      }
+      if (isStreamErrorFor(this.streamId, message)) {
+        const inflight = this.inflight;
+        this.inflight = null;
+        inflight?.reject(toStreamError(message));
+        this.closed = true;
+        this.unsubscribe();
+      }
+    });
+  }
+  rpc;
+  streamId;
+  unsubscribe;
+  closed = false;
+  inflight = null;
+  queue = Promise.resolve();
+  /** Ensures write/close/abort operations run strictly in order. */
+  enqueue(operation) {
+    const next = this.queue.then(operation);
+    this.queue = next.catch(() => void 0);
+    return next;
+  }
+  /** Sends one stream operation and waits for its ack/error response. */
+  async waitForAck(send) {
+    return await new Promise((resolve, reject) => {
+      this.inflight = { resolve, reject };
+      send();
+    });
+  }
+  /** Writes one binary chunk to the host-managed attachment stream. */
+  async write(chunk) {
+    if (this.closed) {
+      throw new Error("The attachment write stream is already closed.");
+    }
+    return await this.enqueue(async () => {
+      const buffer = toTransferableArrayBuffer(chunk);
+      await this.waitForAck(() => {
+        this.rpc.postMessage(
+          {
+            protocol: PROTOCOL2,
+            kind: "stream-write",
+            streamId: this.streamId,
+            chunk: buffer
+          },
+          [buffer]
+        );
+      });
+    });
+  }
+  /** Gracefully closes the write stream after any queued writes complete. */
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.enqueue(async () => {
+      await this.waitForAck(() => {
+        this.rpc.postMessage({
+          protocol: PROTOCOL2,
+          kind: "stream-close",
+          streamId: this.streamId
+        });
+      });
+    });
+    this.unsubscribe();
+  }
+  /** Aborts the write stream after any in-flight work has settled. */
+  async abort() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.enqueue(async () => {
+      await this.waitForAck(() => {
+        this.rpc.postMessage({
+          protocol: PROTOCOL2,
+          kind: "stream-abort",
+          streamId: this.streamId
+        });
+      });
+    });
+    this.unsubscribe();
+  }
+};
+var MindooDBAppDatabaseImpl = class {
+  constructor(rpc, databaseId) {
+    this.rpc = rpc;
+    this.databaseId = databaseId;
+    this.documents = {
+      list: async (query) => await this.rpc.call("documents.list", {
+        databaseId: this.databaseId,
+        query: query ?? {}
+      }),
+      listInaccessible: async (query) => await this.rpc.call("documents.listInaccessible", {
+        databaseId: this.databaseId,
+        query: query ?? {}
+      }),
+      query: async (query) => await this.rpc.call("documents.query", {
+        databaseId: this.databaseId,
+        query: normalizeDocumentQuery(query)
+      }),
+      liveQuery: async (query, onResult) => {
+        const { subscriptionId, result } = await this.rpc.call("documents.liveQuery.subscribe", {
+          databaseId: this.databaseId,
+          query: normalizeDocumentQuery(query)
+        });
+        let disposed = false;
+        const unsubscribe = this.rpc.addMessageListener((message) => {
+          if (!disposed && isQueryResultFor(subscriptionId, message)) {
+            onResult(message.result);
+          }
+        });
+        onResult(result);
+        const subscription = {
+          refresh: async () => {
+            if (disposed) {
+              return;
+            }
+            await this.rpc.call("documents.liveQuery.refresh", {
+              subscriptionId
+            });
+          },
+          dispose: async () => {
+            if (disposed) {
+              return;
+            }
+            disposed = true;
+            unsubscribe();
+            await this.rpc.call("documents.liveQuery.unsubscribe", {
+              subscriptionId
+            });
+          }
+        };
+        return subscription;
+      },
+      getHeadCursor: async () => await this.rpc.call("documents.getHeadCursor", {
+        databaseId: this.databaseId
+      }),
+      get: async (docId) => await this.rpc.call("documents.get", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      getRichText: async (docId, path, options) => await this.rpc.call("documents.richText.get", {
+        databaseId: this.databaseId,
+        docId,
+        path,
+        revisionId: options?.revisionId
+      }),
+      getAutomergeSnapshot: async (docId, options) => await this.rpc.call("documents.automerge.getSnapshot", {
+        databaseId: this.databaseId,
+        docId,
+        revisionId: options?.revisionId
+      }),
+      applyAutomergeChanges: async (docId, patch) => await this.rpc.call("documents.automerge.applyChanges", {
+        databaseId: this.databaseId,
+        docId,
+        patch
+      }),
+      create: async (input) => await this.rpc.call("documents.create", {
+        databaseId: this.databaseId,
+        input
+      }),
+      createMany: async (inputs) => {
+        if (inputs.length === 0) {
+          return { ids: [] };
+        }
+        try {
+          return await this.rpc.call("documents.createMany", {
+            databaseId: this.databaseId,
+            inputs
+          });
+        } catch (error) {
+          if (!isMethodNotFoundError(error)) {
+            throw error;
+          }
+          const ids = [];
+          for (const input of inputs) {
+            const document = await this.rpc.call("documents.create", {
+              databaseId: this.databaseId,
+              input
+            });
+            ids.push(document.id);
+          }
+          return { ids };
+        }
+      },
+      update: async (docId, patch) => await this.rpc.call("documents.update", {
+        databaseId: this.databaseId,
+        docId,
+        patch
+      }),
+      addRecipients: async (docId, recipients) => await this.rpc.call("documents.addRecipients", {
+        databaseId: this.databaseId,
+        docId,
+        recipients
+      }),
+      removeRecipients: async (docId, recipients) => await this.rpc.call("documents.removeRecipients", {
+        databaseId: this.databaseId,
+        docId,
+        recipients
+      }),
+      setRecipients: async (docId, recipients, options) => await this.rpc.call("documents.setRecipients", {
+        databaseId: this.databaseId,
+        docId,
+        recipients,
+        recipientOptions: options
+      }),
+      delete: async (docId) => await this.rpc.call("documents.delete", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      deleteMany: async (docIds) => {
+        if (docIds.length === 0) {
+          return { ok: true };
+        }
+        try {
+          return await this.rpc.call("documents.deleteMany", {
+            databaseId: this.databaseId,
+            docIds
+          });
+        } catch (error) {
+          if (!isMethodNotFoundError(error)) {
+            throw error;
+          }
+          for (const docId of docIds) {
+            await this.rpc.call("documents.delete", {
+              databaseId: this.databaseId,
+              docId
+            });
+          }
+          return { ok: true };
+        }
+      },
+      undelete: async (docId) => await this.rpc.call("documents.undelete", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      canCreate: async (input) => await this.rpc.call("documents.canCreate", {
+        databaseId: this.databaseId,
+        input: input ?? {}
+      }),
+      canChange: async (docId) => await this.rpc.call("documents.canChange", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      canDelete: async (docId) => await this.rpc.call("documents.canDelete", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      canUndelete: async (docId) => await this.rpc.call("documents.canUndelete", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      getDefaultCreateKeyId: async () => await this.rpc.call("documents.getDefaultCreateKeyId", {
+        databaseId: this.databaseId
+      }),
+      listCreateKeys: async () => {
+        try {
+          return await this.rpc.call("documents.listCreateKeys", {
+            databaseId: this.databaseId
+          });
+        } catch (error) {
+          if (!isMethodNotFoundError(error)) {
+            throw error;
+          }
+          const keyId = await this.rpc.call("documents.getDefaultCreateKeyId", {
+            databaseId: this.databaseId
+          });
+          return [{ keyId, isDefault: true }];
+        }
+      },
+      listHistory: async (docId) => await this.rpc.call("documents.history.list", {
+        databaseId: this.databaseId,
+        docId
+      }),
+      getAtTimestamp: async (docId, timestamp) => await this.rpc.call("documents.history.getAtTimestamp", {
+        databaseId: this.databaseId,
+        docId,
+        timestamp
+      }),
+      getAtRevision: async (docId, revisionId, options) => await this.rpc.call("documents.history.getAtRevision", {
+        databaseId: this.databaseId,
+        docId,
+        revisionId,
+        phase: options?.phase
+      }),
+      getAtHeads: async (docId, headIds) => await this.rpc.call("documents.history.getAtHeads", {
+        databaseId: this.databaseId,
+        docId,
+        headIds
+      }),
+      listVerification: async (docId, revisionIds) => await this.rpc.call("documents.history.listVerification", {
+        databaseId: this.databaseId,
+        docId,
+        revisionIds
+      })
+    };
+    this.identity = {
+      signStatement: async (input) => await this.rpc.call("identity.signStatement", {
+        databaseId: this.databaseId,
+        ...input
+      })
+    };
+    this.timestamps = {
+      rfc3161: async (input) => await this.rpc.call("timestamps.rfc3161", {
+        databaseId: this.databaseId,
+        ...input
+      }),
+      listProviders: async () => await this.rpc.call("timestamps.listProviders", {
+        databaseId: this.databaseId
+      })
+    };
+    this.directory = {
+      excerpt: async (publicKeys) => await this.rpc.call("directory.excerpt", {
+        databaseId: this.databaseId,
+        publicKeys
+      }),
+      listUsers: async () => {
+        try {
+          return await this.rpc.call("directory.listUsers", {
+            databaseId: this.databaseId
+          });
+        } catch (error) {
+          if (!isMethodNotFoundError(error)) {
+            throw error;
+          }
+          return [];
+        }
+      }
+    };
+    this.attachments = {
+      list: async (docId, options) => await this.rpc.call("attachments.list", {
+        databaseId: this.databaseId,
+        docId,
+        timestamp: options?.timestamp,
+        revisionId: options?.revisionId
+      }),
+      remove: async (docId, attachmentName) => await this.rpc.call("attachments.remove", {
+        databaseId: this.databaseId,
+        docId,
+        attachmentName
+      }),
+      openReadStream: async (docId, attachmentName, options) => {
+        const result = await this.rpc.call(
+          "attachments.openReadStream",
+          {
+            databaseId: this.databaseId,
+            docId,
+            attachmentName,
+            timestamp: options?.timestamp,
+            revisionId: options?.revisionId
+          }
+        );
+        return new MindooDBAppReadableAttachmentStreamImpl(
+          this.rpc,
+          result.streamId
+        );
+      },
+      openWriteStream: async (docId, attachmentName, contentType) => {
+        const result = await this.rpc.call(
+          "attachments.openWriteStream",
+          {
+            databaseId: this.databaseId,
+            docId,
+            attachmentName,
+            contentType
+          }
+        );
+        return new MindooDBAppWritableAttachmentStreamImpl(
+          this.rpc,
+          result.streamId
+        );
+      },
+      scan: async (docId, options) => {
+        const scannerTab = shouldUseWindowedHostTab() ? window.open("", "_blank") : null;
+        if (scannerTab) {
+          try {
+            scannerTab.document.title = "Opening document scanner...";
+            const preparedSession = await this.rpc.call("attachments.prepareScanSession", {
+              databaseId: this.databaseId,
+              docId,
+              defaultFileName: options?.defaultFileName,
+              preset: options?.preset,
+              mimeType: options?.mimeType
+            });
+            scannerTab.location.href = preparedSession.scanUrl;
+            return await this.rpc.call(
+              "attachments.awaitScanSession",
+              {
+                databaseId: this.databaseId,
+                sessionId: preparedSession.sessionId
+              }
+            );
+          } catch (error) {
+            scannerTab.close();
+            throw error;
+          }
+        }
+        return await this.rpc.call(
+          "attachments.scanAndWrite",
+          {
+            databaseId: this.databaseId,
+            docId,
+            defaultFileName: options?.defaultFileName,
+            preset: options?.preset,
+            mimeType: options?.mimeType
+          }
+        );
+      },
+      preparePreviewSession: async (docId, attachmentName, options) => await this.rpc.call("attachments.preparePreviewSession", {
+        databaseId: this.databaseId,
+        docId,
+        attachmentName,
+        timestamp: options?.timestamp,
+        revisionId: options?.revisionId
+      }),
+      openPreview: async (docId, attachmentName, options) => {
+        const previewTab = shouldUseWindowedHostTab() ? window.open("", "_blank") : null;
+        if (previewTab) {
+          try {
+            previewTab.document.title = "Opening attachment preview...";
+            const previewSession = await this.rpc.call("attachments.preparePreviewSession", {
+              databaseId: this.databaseId,
+              docId,
+              attachmentName,
+              timestamp: options?.timestamp,
+              revisionId: options?.revisionId
+            });
+            previewTab.location.href = previewSession.previewUrl;
+            return { ok: true };
+          } catch (error) {
+            previewTab.close();
+            throw error;
+          }
+        }
+        return await this.rpc.call("attachments.openPreview", {
+          databaseId: this.databaseId,
+          docId,
+          attachmentName,
+          timestamp: options?.timestamp,
+          revisionId: options?.revisionId
+        });
+      },
+      extractText: async (input) => {
+        return await this.rpc.call("attachments.extractText", {
+          databaseId: this.databaseId,
+          bytes: input.bytes,
+          mimeType: input.mimeType,
+          fileName: input.fileName,
+          format: input.format,
+          languages: input.languages
+        });
+      }
+    };
+  }
+  rpc;
+  databaseId;
+  documents;
+  attachments;
+  identity;
+  timestamps;
+  directory;
+  /** Returns database metadata for the currently opened binding. */
+  async info() {
+    return await this.rpc.call("databases.info", {
+      databaseId: this.databaseId
+    });
+  }
+  /** Reads the full-text configuration from the synced `dbsetup` document. */
+  async getFulltextSetup() {
+    const result = await this.rpc.call(
+      "database.getFulltextSetup",
+      { databaseId: this.databaseId }
+    );
+    return result.config;
+  }
+  /** Writes (or removes, with `null`) the full-text configuration. */
+  async setFulltextSetup(config) {
+    await this.rpc.call("database.setFulltextSetup", {
+      databaseId: this.databaseId,
+      config
+    });
+  }
+  /** Reads the attachment extraction configuration from the synced `dbsetup` document. */
+  async getExtractionSetup() {
+    const result = await this.rpc.call(
+      "database.getExtractionSetup",
+      { databaseId: this.databaseId }
+    );
+    return result.config;
+  }
+  /** Writes (or removes, with `null`) the attachment extraction configuration. */
+  async setExtractionSetup(config) {
+    await this.rpc.call("database.setExtractionSetup", {
+      databaseId: this.databaseId,
+      config
+    });
+  }
+};
+var MindooDBAppSessionImpl = class {
+  constructor(rpc, onDisconnect) {
+    this.rpc = rpc;
+    this.onDisconnect = onDisconnect;
+    this.menus = {
+      show: async (input) => await this.rpc.call("menus.show", input),
+      hide: async () => {
+        await this.rpc.call("menus.hide", {});
+      }
+    };
+    this.storage = {
+      snapshot: async (options) => await this.rpc.call("appStorage.snapshot", {
+        prefixes: options?.prefixes
+      }),
+      get: async (key) => await this.rpc.call("appStorage.get", { key }),
+      set: async (key, value) => {
+        await this.rpc.call("appStorage.set", { key, value });
+      },
+      remove: async (key) => {
+        await this.rpc.call("appStorage.remove", { key });
+      },
+      keys: async (options) => await this.rpc.call("appStorage.keys", { prefix: options?.prefix }),
+      clear: async (options) => {
+        await this.rpc.call("appStorage.clear", { prefix: options?.prefix });
+      }
+    };
+    this.rpc.addMessageListener((message) => {
+      if (message.kind === "before-close") {
+        void this.handleBeforeClose(message.closeId);
+      }
+    });
+  }
+  rpc;
+  onDisconnect;
+  menus;
+  storage;
+  beforeCloseListeners = /* @__PURE__ */ new Set();
+  /**
+   * Lets every listener finish, then tells the host it may proceed.
+   *
+   * The ack is sent even when a listener fails: the host is going to tear the launch down
+   * either way once its grace period elapses, and answering late only wastes that time.
+   */
+  async handleBeforeClose(closeId) {
+    try {
+      await Promise.all(
+        [...this.beforeCloseListeners].map(async (listener) => {
+          try {
+            await listener();
+          } catch (error) {
+            console.warn("[mindoodb-app-sdk] A before-close listener failed.", error);
+          }
+        })
+      );
+    } finally {
+      try {
+        this.rpc.postMessage({
+          protocol: PROTOCOL2,
+          kind: "before-close-ack",
+          closeId
+        });
+      } catch (error) {
+        console.warn("[mindoodb-app-sdk] Could not acknowledge before-close.", error);
+      }
+    }
+  }
+  /** Returns the launch context provided by the Haven host. */
+  async getLaunchContext() {
+    return await this.rpc.call("session.getLaunchContext", {});
+  }
+  /**
+   * Asks the host to open an encrypted channel to a tenant-joined service.
+   * The host owns the key exchange and the resulting session key; nothing
+   * secret crosses back into the app.
+   */
+  async openSealedChannel(input) {
+    return await this.rpc.call("sealedChannel.open", input);
+  }
+  /** Sends one request through an open channel; the host seals and opens it. */
+  async sealedChannelRequest(input) {
+    return await this.rpc.call("sealedChannel.request", input);
+  }
+  /** Discards a channel host-side. */
+  async closeSealedChannel(channelId) {
+    await this.rpc.call("sealedChannel.close", { channelId });
+  }
+  /** Returns the product names currently licensed in the Haven host. */
+  async getLicensedProducts() {
+    return await this.rpc.call("session.getLicensedProducts", {});
+  }
+  /** Lists the databases that the host has made available for this app session. */
+  async listDatabases() {
+    return await this.rpc.call("session.listDatabases", {});
+  }
+  /** Opens one database binding and returns a client facade for it. */
+  async openDatabase(databaseId) {
+    await this.rpc.call("session.openDatabase", { databaseId });
+    return new MindooDBAppDatabaseImpl(this.rpc, databaseId);
+  }
+  async listDocumentsSinceViewCursor(cursor) {
+    return await this.rpc.call("session.listDocumentsSinceViewCursor", {
+      cursor
+    });
+  }
+  /**
+   * Create a navigator from an ad-hoc view definition and one or more database bindings.
+   *
+   * The host builds a `VirtualView` from `input.definition`, optionally applying
+   * open options (root scoping, category filtering), and returns a `navigatorId`
+   * that all subsequent navigator RPCs reference.
+   */
+  async createViewNavigator(input) {
+    const result = await this.rpc.call("session.createViewNavigator", input);
+    return new MindooDBAppViewNavigatorImpl(
+      this.rpc,
+      result.navigatorId,
+      result.viewCursor
+    );
+  }
+  /**
+   * Open a navigator for a preconfigured view that the host already knows about.
+   *
+   * `viewId` must match one of the views declared in the launch context. The
+   * host resolves the full view definition and database bindings automatically.
+   */
+  async openViewNavigator(viewId, options) {
+    const result = await this.rpc.call("session.openViewNavigator", { viewId, options: options ?? {} });
+    return new MindooDBAppViewNavigatorImpl(
+      this.rpc,
+      result.navigatorId,
+      result.viewCursor
+    );
+  }
+  /** Subscribe to host-pushed theme changes (dark/light mode, color tokens). */
+  onThemeChange(listener) {
+    return this.rpc.addMessageListener((message) => {
+      if (isThemeChangedMessage(message)) {
+        listener(message.theme);
+      }
+    });
+  }
+  /** Subscribe to host-pushed viewport dimension changes (resize, orientation). */
+  onViewportChange(listener) {
+    return this.rpc.addMessageListener((message) => {
+      if (isViewportChangedMessage(message)) {
+        listener(message.viewport);
+      }
+    });
+  }
+  /** Subscribe to host-pushed embedded UI preference changes. */
+  onUiPreferencesChange(listener) {
+    return this.rpc.addMessageListener((message) => {
+      if (isUiPreferencesChangedMessage(message)) {
+        listener(message.uiPreferences);
+      }
+    });
+  }
+  /** Subscribe to host-pushed UI language changes. */
+  onLocaleChange(listener) {
+    return this.rpc.addMessageListener((message) => {
+      if (isLocaleChangedMessage(message)) {
+        listener(message.locale);
+      }
+    });
+  }
+  /** Register work to run before the host tears this launch down. */
+  onBeforeClose(listener) {
+    this.beforeCloseListeners.add(listener);
+    return () => {
+      this.beforeCloseListeners.delete(listener);
+    };
+  }
+  /** Disconnects from the host and always disposes the underlying port client. */
+  async disconnect() {
+    try {
+      await this.rpc.call("session.disconnect", {});
+    } finally {
+      this.rpc.dispose();
+      this.onDisconnect?.();
+    }
+  }
+};
+var sessionsByLaunchId = /* @__PURE__ */ new Map();
+function releaseMindooDBAppBridgeSessions(launchId) {
+  if (launchId === void 0) {
+    sessionsByLaunchId.clear();
+    return;
+  }
+  sessionsByLaunchId.delete(launchId);
+}
+function createMindooDBAppBridge() {
+  return {
+    async connect(options) {
+      const launchId = resolveLaunchId(options);
+      const existing = sessionsByLaunchId.get(launchId);
+      if (existing) {
+        return await existing;
+      }
+      const pending = (async () => {
+        const port = await waitForConnectedPort(options, launchId);
+        const rpc = new PortRpcClient(port);
+        return new MindooDBAppSessionImpl(rpc, () => {
+          if (sessionsByLaunchId.get(launchId) === pending) {
+            sessionsByLaunchId.delete(launchId);
+          }
+        });
+      })();
+      sessionsByLaunchId.set(launchId, pending);
+      try {
+        return await pending;
+      } catch (error) {
+        if (sessionsByLaunchId.get(launchId) === pending) {
+          sessionsByLaunchId.delete(launchId);
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+export {
+  releaseMindooDBAppBridgeSessions,
+  createMindooDBAppBridge
+};