mindoodb-app-sdk 0.0.40 → 0.0.42

package/dist/index.js

@@ -1,3 +1,18 @@
+import {
+  createMindooDBAppBridge,
+  releaseMindooDBAppBridgeSessions
+} from "./chunk-6433L6TE.js";
+import {
+  MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME,
+  MINDOODB_APP_BUNDLE_MANIFEST_FILE_NAME,
+  MINDOODB_APP_BUNDLE_MANIFEST_FORMAT,
+  MINDOODB_APP_BUNDLE_MANIFEST_VERSION,
+  buildMindooDBAppBundleContentHashInput,
+  isMindooDBAppBundleHash,
+  normalizeMindooDBAppBundlePath,
+  validateMindooDBAppBundleManifest
+} from "./chunk-LT4FK6LU.js";
+
 // src/types.ts
 var MINDOODB_APP_SEAL_SIGNING_DOMAIN = "mindoodb-seal/v1";
 
@@ -85,1212 +100,294 @@ function expandAbbreviatedName(value) {
   }).join("/");
 }
 
-// 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());
+// src/client/hosting.ts
+var MINDOODB_APP_HOSTING_QUERY_PARAM = "mindoodbAppHosting";
+function readMindooDBAppHostingMode(search) {
+  const raw = search ?? (typeof window === "undefined" ? "" : window.location.search);
+  if (!raw) {
+    return "external";
   }
-  if (value instanceof ArrayBuffer) {
-    return value.slice(0);
+  try {
+    return new URLSearchParams(raw).get(MINDOODB_APP_HOSTING_QUERY_PARAM) === "hosted" ? "hosted" : "external";
+  } catch {
+    return "external";
   }
-  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 isHostedBundleRuntime(search) {
+  return readMindooDBAppHostingMode(search) === "hosted";
 }
-function isProtocolMessage(message) {
-  return Boolean(
-    message && typeof message === "object" && "protocol" in message && message.protocol === PROTOCOL
-  );
+
+// src/client/havenStorageShim.ts
+var DEFAULT_QUOTA_BYTES = 256 * 1024;
+var DEFAULT_MAX_VALUE_BYTES = 64 * 1024;
+var DEFAULT_COALESCE_MS = 200;
+var DEFAULT_TIMEOUT_MS = 2e3;
+var MAX_COALESCE_MULTIPLIER = 5;
+var textEncoder = typeof TextEncoder === "undefined" ? null : new TextEncoder();
+function byteLength(value) {
+  return textEncoder ? textEncoder.encode(value).byteLength : value.length;
+}
+function createQuotaExceededError(message) {
+  if (typeof DOMException === "function") {
+    return new DOMException(message, "QuotaExceededError");
+  }
+  const error = new Error(message);
+  error.name = "QuotaExceededError";
+  return error;
 }
-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)));
+var STORAGE_MEMBERS = ["length", "key", "getItem", "setItem", "removeItem", "clear"];
+function createStorageBackend(options) {
+  const entries = /* @__PURE__ */ new Map();
+  let persistedBytes = 0;
+  function entrySize(key, value) {
+    return byteLength(key) + byteLength(value);
+  }
+  function write(key, value, { fromHost }) {
+    const persisted = options.isPersisted(key);
+    if (persisted && !fromHost) {
+      if (byteLength(value) > options.maxValueBytes) {
+        throw createQuotaExceededError(
+          `Value for "${key}" exceeds the ${options.maxValueBytes} byte per-value limit.`
+        );
       }
-    });
-  }
-  /** Closes the port and rejects any requests that are still waiting for a response. */
-  dispose() {
-    if (this.disposed) {
-      return;
+      const previous = entries.get(key);
+      const delta = entrySize(key, value) - (previous === void 0 ? 0 : entrySize(key, previous));
+      if (persistedBytes + delta > options.quotaBytes) {
+        throw createQuotaExceededError(
+          `Storing "${key}" would exceed the ${options.quotaBytes} byte storage quota.`
+        );
+      }
+      persistedBytes += delta;
+    } else if (persisted) {
+      const previous = entries.get(key);
+      persistedBytes += entrySize(key, value) - (previous === void 0 ? 0 : entrySize(key, previous));
     }
-    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;
+    entries.set(key, value);
+    if (persisted && !fromHost) {
+      options.onPersistedChange(key, value);
     }
   }
-  /** Dispatches incoming messages to listeners and resolves matching RPC requests. */
-  handleMessage(event) {
-    if (!isProtocolMessage(event.data)) {
+  function remove(key, { fromHost }) {
+    const previous = entries.get(key);
+    if (previous === void 0) {
       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;
+    entries.delete(key);
+    if (options.isPersisted(key)) {
+      persistedBytes -= entrySize(key, previous);
+      if (!fromHost) {
+        options.onPersistedChange(key, null);
+      }
     }
-    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
-    } : {}
+  const target = {
+    get length() {
+      return entries.size;
+    },
+    key(index) {
+      return [...entries.keys()][index] ?? null;
+    },
+    getItem(key) {
+      const value = entries.get(String(key));
+      return value === void 0 ? null : value;
+    },
+    setItem(key, value) {
+      write(String(key), String(value), { fromHost: false });
+    },
+    removeItem(key) {
+      remove(String(key), { fromHost: false });
+    },
+    clear() {
+      [...entries.keys()].forEach((key) => remove(key, { fromHost: false }));
+    }
   };
-}
-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);
+  const memberNames = new Set(STORAGE_MEMBERS);
+  const storage = new Proxy(target, {
+    get(proxyTarget, property, receiver) {
+      if (typeof property === "symbol" || memberNames.has(property)) {
+        return Reflect.get(proxyTarget, property, receiver);
       }
-      channel.port1.removeEventListener(
-        "message",
-        handleMessage
-      );
-    };
-    const handleMessage = (event) => {
-      const payload = event.data;
-      if (!payload || payload.protocol !== PROTOCOL2) {
-        return;
+      return entries.get(property);
+    },
+    set(proxyTarget, property, value, receiver) {
+      if (typeof property === "symbol" || memberNames.has(property)) {
+        return Reflect.set(proxyTarget, property, value, receiver);
       }
-      if (payload.type === "mindoodb-app:connected") {
-        cleanup();
-        resolve(channel.port1);
-        return;
+      write(property, String(value), { fromHost: false });
+      return true;
+    },
+    has(proxyTarget, property) {
+      if (typeof property === "symbol" || memberNames.has(property)) {
+        return Reflect.has(proxyTarget, property);
       }
-      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));
+      return entries.has(property);
+    },
+    deleteProperty(proxyTarget, property) {
+      if (typeof property === "symbol" || memberNames.has(property)) {
+        return Reflect.deleteProperty(proxyTarget, property);
       }
-    };
-    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);
+      remove(property, { fromHost: false });
+      return true;
+    },
+    ownKeys() {
+      return [...entries.keys()];
+    },
+    getOwnPropertyDescriptor(proxyTarget, property) {
+      if (typeof property === "symbol" || memberNames.has(property)) {
+        return Reflect.getOwnPropertyDescriptor(proxyTarget, property);
       }
-    });
-  }
-  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();
+      const value = entries.get(property);
+      if (value === void 0) {
+        return void 0;
       }
-    });
-  }
-  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 { value, writable: true, enumerable: true, configurable: true };
     }
-    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]
-        );
+  });
+  return {
+    storage,
+    /** Seeds values from the host without counting them as app-initiated writes. */
+    hydrate(values) {
+      Object.entries(values).forEach(([key, value]) => {
+        write(key, value, { fromHost: true });
       });
-    });
-  }
-  /** 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;
+  };
+}
+function replaceGlobal(name, value) {
+  const previous = Object.getOwnPropertyDescriptor(window, name);
+  Object.defineProperty(window, name, { value, configurable: true, writable: false });
+  return () => {
+    if (previous) {
+      Object.defineProperty(window, name, previous);
+    } else {
+      Reflect.deleteProperty(window, name);
     }
-    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
-        });
+  };
+}
+async function installHavenStorageShim(options = {}) {
+  const hosting = options.hosting ?? readMindooDBAppHostingMode();
+  if (hosting !== "hosted" || typeof window === "undefined") {
+    return {
+      installed: false,
+      connected: false,
+      flush: async () => {
       },
-      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) {
-    this.rpc = rpc;
-    this.menus = {
-      show: async (input) => await this.rpc.call("menus.show", input),
-      hide: async () => {
-        await this.rpc.call("menus.hide", {});
+      uninstall: async () => {
       }
     };
   }
-  rpc;
-  menus;
-  /** 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);
+  const persistPrefixes = options.persistPrefixes ?? [];
+  const coalesceMs = options.coalesceMs ?? DEFAULT_COALESCE_MS;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  let session = null;
+  const pending = /* @__PURE__ */ new Map();
+  let flushTimer = null;
+  let deadline = 0;
+  let flushChain = Promise.resolve();
+  function isPersisted(key) {
+    return persistPrefixes.some((prefix) => key.startsWith(prefix));
+  }
+  function runFlush() {
+    if (flushTimer !== null) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+    deadline = 0;
+    const batch = [...pending.entries()];
+    pending.clear();
+    if (!batch.length || !session) {
+      return flushChain;
+    }
+    const active = session;
+    flushChain = flushChain.then(async () => {
+      for (const [key, value] of batch) {
+        if (value === null) {
+          await active.storage.remove(key);
+        } else {
+          await active.storage.set(key, value);
+        }
       }
+    }).catch((error) => {
+      console.warn("[mindoodb-app-sdk] Failed to persist app storage to the host.", error);
     });
+    return flushChain;
   }
-  /** Subscribe to host-pushed viewport dimension changes (resize, orientation). */
-  onViewportChange(listener) {
-    return this.rpc.addMessageListener((message) => {
-      if (isViewportChangedMessage(message)) {
-        listener(message.viewport);
-      }
-    });
+  function scheduleFlush() {
+    if (!session) {
+      return;
+    }
+    const now = Date.now();
+    if (deadline === 0) {
+      deadline = now + coalesceMs * MAX_COALESCE_MULTIPLIER;
+    }
+    if (flushTimer !== null) {
+      clearTimeout(flushTimer);
+    }
+    flushTimer = setTimeout(() => void runFlush(), Math.max(0, Math.min(coalesceMs, deadline - now)));
   }
-  /** Subscribe to host-pushed embedded UI preference changes. */
-  onUiPreferencesChange(listener) {
-    return this.rpc.addMessageListener((message) => {
-      if (isUiPreferencesChangedMessage(message)) {
-        listener(message.uiPreferences);
-      }
-    });
+  async function flushAll() {
+    for (let pass = 0; pass < 3 && pending.size; pass += 1) {
+      await runFlush();
+    }
+    await flushChain;
   }
-  /** Subscribe to host-pushed UI language changes. */
-  onLocaleChange(listener) {
-    return this.rpc.addMessageListener((message) => {
-      if (isLocaleChangedMessage(message)) {
-        listener(message.locale);
+  const backend = createStorageBackend({
+    quotaBytes: options.quotaBytes ?? DEFAULT_QUOTA_BYTES,
+    maxValueBytes: options.maxValueBytes ?? DEFAULT_MAX_VALUE_BYTES,
+    isPersisted,
+    onPersistedChange(key, value) {
+      pending.set(key, value);
+      scheduleFlush();
+    }
+  });
+  const restoreLocal = replaceGlobal("localStorage", backend.storage);
+  const restoreSession = options.shimSessionStorage === false ? null : replaceGlobal(
+    "sessionStorage",
+    createStorageBackend({
+      quotaBytes: Number.POSITIVE_INFINITY,
+      maxValueBytes: Number.POSITIVE_INFINITY,
+      isPersisted: () => false,
+      onPersistedChange: () => {
       }
-    });
-  }
-  /** Disconnects from the host and always disposes the underlying port client. */
-  async disconnect() {
+    }).storage
+  );
+  let connected = false;
+  if (persistPrefixes.length) {
+    const bridge = options.bridge ?? createMindooDBAppBridge();
+    let timeoutHandle = null;
     try {
-      await this.rpc.call("session.disconnect", {});
+      const connectedSession = await Promise.race([
+        bridge.connect(options.launchId ? { launchId: options.launchId } : void 0),
+        new Promise((_resolve, reject) => {
+          timeoutHandle = setTimeout(
+            () => reject(new Error(`Host did not answer within ${timeoutMs} ms.`)),
+            timeoutMs
+          );
+        })
+      ]);
+      backend.hydrate(await connectedSession.storage.snapshot({ prefixes: persistPrefixes }));
+      session = connectedSession;
+      connected = true;
+      connectedSession.onBeforeClose(() => flushAll());
+    } catch (error) {
+      console.warn(
+        "[mindoodb-app-sdk] App storage is not connected to the host; running in-memory only.",
+        error
+      );
     } finally {
-      this.rpc.dispose();
+      if (timeoutHandle !== null) {
+        clearTimeout(timeoutHandle);
+      }
     }
   }
-};
-function createMindooDBAppBridge() {
   return {
-    async connect(options) {
-      const launchId = resolveLaunchId(options);
-      const port = await waitForConnectedPort(options, launchId);
-      const rpc = new PortRpcClient(port);
-      return new MindooDBAppSessionImpl(rpc);
+    installed: true,
+    connected,
+    flush: flushAll,
+    async uninstall() {
+      await flushAll();
+      restoreLocal();
+      restoreSession?.();
     }
   };
 }
@@ -1635,7 +732,7 @@ function computeSingleSplice2(previous, next) {
 }
 
 // src/viewLanguage.ts
-import { parseMindooDBFormulaBooleanExpression as parseMindooDBFormulaBooleanExpression2 } from "mindoodb-view-language";
+import { parseMindooDBFormulaBooleanExpression } from "mindoodb-view-language";
 import {
   createViewLanguage,
   getMindooDBViewLanguageHelper,
@@ -1646,19 +743,32 @@ async function queryDocuments(db, filter, sortBy, options) {
   if (!db.query) {
     throw new Error("This MindooDB instance does not support ad-hoc queries.");
   }
-  const expression = typeof filter === "string" ? parseMindooDBFormulaBooleanExpression2(filter) : filter;
+  const expression = typeof filter === "string" ? parseMindooDBFormulaBooleanExpression(filter) : filter;
   return db.query({ filter: expression, sortBy }, options);
 }
 export {
+  MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME,
+  MINDOODB_APP_BUNDLE_MANIFEST_FILE_NAME,
+  MINDOODB_APP_BUNDLE_MANIFEST_FORMAT,
+  MINDOODB_APP_BUNDLE_MANIFEST_VERSION,
+  MINDOODB_APP_HOSTING_QUERY_PARAM,
   MINDOODB_APP_SEAL_SIGNING_DOMAIN,
   MindooDBRichTextHandle,
   MindooDBTextBuffer,
   abbreviateCanonicalName,
+  buildMindooDBAppBundleContentHashInput,
   canPreviewAttachment,
   createMindooDBAppBridge,
   createMindooDBRichTextHandle,
   createMindooDBTextBuffer,
   createViewLanguage,
   expandAbbreviatedName,
-  queryDocuments
+  installHavenStorageShim,
+  isHostedBundleRuntime,
+  isMindooDBAppBundleHash,
+  normalizeMindooDBAppBundlePath,
+  queryDocuments,
+  readMindooDBAppHostingMode,
+  releaseMindooDBAppBridgeSessions,
+  validateMindooDBAppBundleManifest
 };