mindoodb-app-sdk 0.0.34 → 0.0.37

package/dist/testing/index.js

@@ -1,9 +1,470 @@
 // src/testing/index.ts
 import * as Automerge from "@automerge/automerge";
 import {
-  evaluateExpression,
+  evaluateExpression as evaluateExpression2,
   parseMindooDBFormulaBooleanExpression
 } from "mindoodb-view-language";
+
+// src/testing/evaluatingViewNavigator.ts
+import { evaluateExpression, getFieldValue } from "mindoodb-view-language";
+var mindoodbModulePromise = null;
+async function loadMindoodbForTesting() {
+  if (!mindoodbModulePromise) {
+    mindoodbModulePromise = import("mindoodb").then((mod) => mod).catch(() => null);
+  }
+  return mindoodbModulePromise;
+}
+function toFormulaBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized !== "" && normalized !== "false" && normalized !== "0" && normalized !== "no";
+  }
+  return Boolean(value);
+}
+function matchesFilter(mindoodb, definition, doc, origin, createdAt, lastModifiedAt, witnessed, awaitingWitness) {
+  void mindoodb;
+  if (!definition.filter) return true;
+  return toFormulaBoolean(
+    evaluateExpression(definition.filter.expression, {
+      doc,
+      values: doc,
+      origin,
+      createdAt,
+      lastModifiedAt,
+      witnessed,
+      awaitingWitness,
+      variables: {}
+    })
+  );
+}
+function computeColumnValues(definition, doc, origin, createdAt, lastModifiedAt, witnessed, awaitingWitness) {
+  const values = {};
+  for (const [key, value] of Object.entries(doc)) {
+    if (!key.startsWith("_")) values[key] = value;
+  }
+  for (const column of definition.columns) {
+    const expression = column.expression;
+    const value = expression.kind === "field" ? getFieldValue(doc, expression.path) ?? getFieldValue(values, expression.path) : evaluateExpression(expression, {
+      doc,
+      values,
+      origin,
+      createdAt,
+      lastModifiedAt,
+      witnessed,
+      awaitingWitness,
+      variables: {}
+    });
+    values[column.name] = value;
+  }
+  return values;
+}
+function mapSorting(mindoodb, direction) {
+  switch (direction) {
+    case "ascending":
+      return mindoodb.ColumnSorting.ASCENDING;
+    case "descending":
+      return mindoodb.ColumnSorting.DESCENDING;
+    default:
+      return mindoodb.ColumnSorting.NONE;
+  }
+}
+function mapTotalMode(mindoodb, mode) {
+  switch (mode) {
+    case "sum":
+      return mindoodb.TotalMode.SUM;
+    case "average":
+      return mindoodb.TotalMode.AVERAGE;
+    default:
+      return mindoodb.TotalMode.NONE;
+  }
+}
+function getCategoryPath(entry) {
+  const path = [];
+  let current = entry.isCategory() ? entry : entry.getParent();
+  while (current && !current.isRoot()) {
+    if (current.isCategory()) path.unshift(current.getCategoryValue());
+    current = current.getParent();
+  }
+  return path;
+}
+function serializeEntry(navigator, entry) {
+  const parent = entry.getParent();
+  return {
+    key: entry.getPositionStr(),
+    kind: entry.isCategory() ? "category" : "document",
+    origin: entry.origin,
+    docId: entry.docId,
+    level: entry.getLevel(),
+    parentKey: parent && !parent.isRoot() ? parent.getPositionStr() : null,
+    categoryPath: getCategoryPath(entry),
+    categoryValue: entry.isCategory() ? entry.getCategoryValue() : null,
+    columnValues: entry.getColumnValues(),
+    childCount: entry.getChildCount(),
+    descendantDocumentCount: entry.getDescendantDocumentCount(),
+    descendantCount: entry.getDescendantCount(),
+    descendantCategoryCount: entry.getDescendantCategoryCount(),
+    siblingCount: entry.getSiblingCount(),
+    childCategoryCount: entry.getChildCategoryCount(),
+    childDocumentCount: entry.getChildDocumentCount(),
+    position: entry.getPositionStr(),
+    expanded: entry.isCategory() ? navigator.isExpanded(entry) : false,
+    selected: navigator.isSelected(entry.origin, entry.docId),
+    isVisible: true
+  };
+}
+async function buildVirtualView(mindoodb, definition, documents, categorizationStyle) {
+  const builder = mindoodb.VirtualViewFactory.createView().withCategorizationStyle(
+    categorizationStyle === "category_then_document" ? mindoodb.CategorizationStyle.CATEGORY_THEN_DOCUMENT : mindoodb.CategorizationStyle.DOCUMENT_THEN_CATEGORY
+  );
+  for (const column of definition.columns) {
+    const commonOptions = {
+      title: column.title,
+      isHidden: column.hidden,
+      expression: column.expression
+    };
+    switch (column.role) {
+      case "category":
+        builder.addCategoryColumn(column.name, {
+          ...commonOptions,
+          sorting: mapSorting(
+            mindoodb,
+            column.sorting === "none" ? "ascending" : column.sorting
+          )
+        });
+        break;
+      case "sort":
+        builder.addSortedColumn(
+          column.name,
+          mapSorting(
+            mindoodb,
+            !column.sorting || column.sorting === "none" ? "ascending" : column.sorting
+          ),
+          commonOptions
+        );
+        break;
+      case "display":
+        if (column.sorting && column.sorting !== "none") {
+          builder.addSortedColumn(column.name, mapSorting(mindoodb, column.sorting), commonOptions);
+        } else {
+          builder.addDisplayColumn(column.name, commonOptions);
+        }
+        break;
+      case "total":
+        builder.addTotalColumn(
+          column.name,
+          mapTotalMode(mindoodb, column.totalMode === "none" ? "sum" : column.totalMode),
+          commonOptions
+        );
+        break;
+    }
+  }
+  const view = await builder.build();
+  const changes = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    if (!matchesFilter(
+      mindoodb,
+      definition,
+      document.data,
+      document.origin,
+      document.createdAt,
+      document.lastModifiedAt,
+      document.witnessed,
+      document.awaitingWitness
+    )) {
+      continue;
+    }
+    const change = changes.get(document.origin) ?? new mindoodb.VirtualViewDataChange(document.origin);
+    change.addEntry(
+      document.docId,
+      computeColumnValues(
+        definition,
+        document.data,
+        document.origin,
+        document.createdAt,
+        document.lastModifiedAt,
+        document.witnessed,
+        document.awaitingWitness
+      )
+    );
+    changes.set(document.origin, change);
+  }
+  for (const change of changes.values()) {
+    if (change.hasChanges()) view.applyChanges(change);
+  }
+  view.getRoot();
+  return view;
+}
+function createCoreNavigator(mindoodb, view, options) {
+  const builder = mindoodb.VirtualViewFactory.createNavigator(view);
+  const includeCategories = options?.includeCategories ?? true;
+  const includeDocuments = options?.includeDocuments ?? true;
+  if (!includeCategories && includeDocuments) builder.documentsOnly();
+  else if (includeCategories && !includeDocuments) builder.categoriesOnly();
+  if (options?.hideEmptyCategories) builder.hideEmptyCategories();
+  if (Array.isArray(options?.rootCategoryPath) && options.rootCategoryPath.length > 0) {
+    builder.fromCategory(options.rootCategoryPath.map((part) => String(part)).join("\\"));
+  } else if (options?.rootEntryKey) {
+    const temp = mindoodb.VirtualViewFactory.createSimpleNavigator(view);
+    const rootEntry = temp.getPos(options.rootEntryKey);
+    if (rootEntry) builder.fromEntry(rootEntry);
+  }
+  return builder.build();
+}
+function normalizePageLimit(limit) {
+  return Math.max(1, Math.min(1e3, Math.trunc(limit ?? 100)));
+}
+function pageEntries(navigator, direction, options = {}) {
+  const entries = [];
+  const startOk = options.startPosition ? navigator.gotoPos(options.startPosition) : direction === "forward" ? navigator.gotoFirst() : navigator.gotoLast();
+  if (!startOk) {
+    return { entries, nextPosition: null, hasMore: false };
+  }
+  const moveNext = () => {
+    if (direction === "forward") {
+      return options.selectedOnly ? navigator.gotoNextSelected() : navigator.gotoNext();
+    }
+    return options.selectedOnly ? navigator.gotoPrevSelected() : navigator.gotoPrev();
+  };
+  if (options.selectedOnly) {
+    const current = navigator.getCurrentEntry();
+    if (!current || !navigator.isSelected(current.origin, current.docId)) {
+      if (!moveNext()) return { entries, nextPosition: null, hasMore: false };
+    }
+  }
+  const limit = normalizePageLimit(options.limit);
+  let nextPosition = null;
+  let hasMore = false;
+  while (true) {
+    const current = navigator.getCurrentEntry();
+    if (!current) break;
+    entries.push(serializeEntry(navigator, current));
+    if (entries.length >= limit) {
+      hasMore = moveNext();
+      nextPosition = hasMore ? navigator.getCurrentEntry()?.getPositionStr() ?? null : null;
+      break;
+    }
+    if (!moveNext()) break;
+  }
+  return { entries, nextPosition, hasMore };
+}
+function resolveEntry(navigator, entryKey) {
+  const entry = navigator.getPos(entryKey);
+  if (!entry) {
+    throw new Error(`Unknown view entry: ${entryKey}`);
+  }
+  return entry;
+}
+function wrapNavigator(definition, navigator) {
+  const updateListeners = /* @__PURE__ */ new Set();
+  let viewCursor = null;
+  return {
+    async getDefinition() {
+      return definition;
+    },
+    async getViewCursor() {
+      return viewCursor;
+    },
+    async refresh() {
+      return viewCursor;
+    },
+    onDidUpdate(listener) {
+      updateListeners.add(listener);
+      return () => updateListeners.delete(listener);
+    },
+    async getCurrentEntry() {
+      const entry = navigator.getCurrentEntry();
+      return entry ? serializeEntry(navigator, entry) : null;
+    },
+    async gotoFirst() {
+      return navigator.gotoFirst();
+    },
+    async gotoLast() {
+      return navigator.gotoLast();
+    },
+    async gotoNext() {
+      return navigator.gotoNext();
+    },
+    async gotoPrev() {
+      return navigator.gotoPrev();
+    },
+    async gotoNextSibling() {
+      return navigator.gotoNextSibling();
+    },
+    async gotoPrevSibling() {
+      return navigator.gotoPrevSibling();
+    },
+    async gotoParent() {
+      return navigator.gotoParent();
+    },
+    async gotoFirstChild() {
+      return navigator.gotoFirstChild();
+    },
+    async gotoLastChild() {
+      return navigator.gotoLastChild();
+    },
+    async gotoPos(position) {
+      return navigator.gotoPos(position);
+    },
+    async getPos(position) {
+      const entry = navigator.getPos(position);
+      return entry ? serializeEntry(navigator, entry) : null;
+    },
+    async findCategoryEntryByParts(parts) {
+      const entry = navigator.findCategoryEntryByParts(parts);
+      return entry ? serializeEntry(navigator, entry) : null;
+    },
+    async entriesForward(options) {
+      return pageEntries(navigator, "forward", options);
+    },
+    async entriesBackward(options) {
+      return pageEntries(navigator, "backward", options);
+    },
+    async gotoNextSelected() {
+      return navigator.gotoNextSelected();
+    },
+    async gotoPrevSelected() {
+      return navigator.gotoPrevSelected();
+    },
+    async select(origin, docId, selectParentCategories = false) {
+      navigator.select(origin, docId, selectParentCategories);
+    },
+    async deselect(origin, docId) {
+      navigator.deselect(origin, docId);
+    },
+    async selectAllEntries() {
+      navigator.selectAllEntries();
+    },
+    async deselectAllEntries() {
+      navigator.deselectAllEntries();
+    },
+    async isSelected(origin, docId) {
+      return navigator.isSelected(origin, docId);
+    },
+    async getSelectionState() {
+      return {
+        selectAllByDefault: navigator.isSelectAllByDefault(),
+        entryKeys: Array.from(navigator.getSelectedOrDeselectedEntries())
+      };
+    },
+    async setSelectionState(state) {
+      if (state.selectAllByDefault) navigator.selectAllEntries();
+      else navigator.deselectAllEntries();
+      navigator.setSelectedOrDeselectedEntries(new Set(state.entryKeys));
+    },
+    async expand(origin, docId) {
+      navigator.expand(origin, docId);
+    },
+    async collapse(origin, docId) {
+      navigator.collapse(origin, docId);
+    },
+    async expandAll() {
+      navigator.expandAll();
+    },
+    async collapseAll() {
+      navigator.collapseAll();
+    },
+    async expandToLevel(level) {
+      navigator.expandToLevel(level);
+    },
+    async isExpanded(entryKey) {
+      const entry = navigator.getPos(entryKey);
+      return entry ? navigator.isExpanded(entry) : false;
+    },
+    async getExpansionState() {
+      return {
+        expandAllByDefault: navigator.isExpandAllByDefault(),
+        expandLevel: navigator.getExpandLevel(),
+        entryKeys: Array.from(navigator.getExpandedOrCollapsedEntries())
+      };
+    },
+    async setExpansionState(state) {
+      if (state.expandAllByDefault) navigator.expandAll();
+      else navigator.collapseAll();
+      navigator.expandToLevel(state.expandLevel);
+      navigator.setExpandedOrCollapsedEntries(new Set(state.entryKeys));
+    },
+    async childEntries(entryKey, descending) {
+      return navigator.childEntries(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childCategories(entryKey, descending) {
+      return navigator.childCategories(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childDocuments(entryKey, descending) {
+      return navigator.childDocuments(resolveEntry(navigator, entryKey), descending).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childCategoriesByKey(entryKey, key, exact, descending) {
+      return navigator.childCategoriesByKey(
+        resolveEntry(navigator, entryKey),
+        String(key ?? ""),
+        Boolean(exact),
+        descending
+      ).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childDocumentsByKey(entryKey, key, exact, descending) {
+      return navigator.childDocumentsByKey(
+        resolveEntry(navigator, entryKey),
+        String(key ?? ""),
+        Boolean(exact),
+        descending
+      ).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childCategoriesBetween(entryKey, range) {
+      return navigator.childCategoriesBetween(
+        resolveEntry(navigator, entryKey),
+        range.startKey,
+        range.endKey,
+        range.descending
+      ).map((entry) => serializeEntry(navigator, entry));
+    },
+    async childDocumentsBetween(entryKey, range) {
+      return navigator.childDocumentsBetween(
+        resolveEntry(navigator, entryKey),
+        range.startKey,
+        range.endKey,
+        range.descending
+      ).map((entry) => serializeEntry(navigator, entry));
+    },
+    async getSortedDocIds(descending) {
+      const page = pageEntries(navigator, descending ? "backward" : "forward", { limit: 1e3 });
+      return collectSortedDocIds(page.entries);
+    },
+    async getSortedDocIdsScoped(entryKey, descending) {
+      const docs = navigator.childDocuments(resolveEntry(navigator, entryKey), descending);
+      return docs.map((entry) => ({ origin: entry.origin, docId: entry.docId }));
+    },
+    async dispose() {
+      updateListeners.clear();
+    }
+  };
+}
+function collectSortedDocIds(entries) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.kind !== "document" || !entry.docId) continue;
+    const key = `${entry.origin}:${entry.docId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({ origin: entry.origin, docId: entry.docId });
+  }
+  return results;
+}
+async function createEvaluatingViewNavigator(input, documents) {
+  const mindoodb = await loadMindoodbForTesting();
+  if (!mindoodb) return null;
+  const view = await buildVirtualView(
+    mindoodb,
+    input.definition,
+    documents,
+    input.categorizationStyle
+  );
+  const navigator = createCoreNavigator(mindoodb, view, input.options);
+  return wrapNavigator(input.definition, navigator);
+}
+
+// src/testing/index.ts
 var PROTOCOL = "mindoodb-app-bridge";
 var MOCK_SIGNING_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAmockmockmockmockmockmockmockmockmockmockmoc=\n-----END PUBLIC KEY-----\n";
 function createBridgeErrorPayload(error, fallbackCode = "bridge-error") {
@@ -378,7 +839,7 @@ function persistMockAutomergeDocument(document, automergeDoc) {
   document.data = structuredClone(automergeDoc);
   document.heads = Automerge.getHeads(automergeDoc);
 }
-function getFieldValue(source, field) {
+function getFieldValue2(source, field) {
   return field.split(".").reduce((current, part) => {
     if (current && typeof current === "object" && part in current) {
       return current[part];
@@ -391,7 +852,7 @@ function matchesDocumentFilter(document, filter) {
     return true;
   }
   return Object.entries(filter).every(
-    ([field, expected]) => getFieldValue(document.data, field) === expected
+    ([field, expected]) => getFieldValue2(document.data, field) === expected
   );
 }
 function matchesMockIdPrefix(docId, idPrefix) {
@@ -454,7 +915,7 @@ function computeMockTextScore(document, clause) {
   if (terms.length === 0) {
     return void 0;
   }
-  const haystack = clause.fields ? clause.fields.map((field) => collectMockText(getFieldValue(document.data, field))).join(" ") : collectMockText(
+  const haystack = clause.fields ? clause.fields.map((field) => collectMockText(getFieldValue2(document.data, field))).join(" ") : collectMockText(
     Object.fromEntries(
       Object.entries(document.data).filter(([key]) => !key.startsWith("_"))
     )
@@ -497,14 +958,14 @@ function runMockDocumentQuery(storedDocuments, databaseId, query) {
       origin: databaseId,
       variables: {}
     };
-    if (filter && !mockExpressionToBoolean(evaluateExpression(filter, context))) {
+    if (filter && !mockExpressionToBoolean(evaluateExpression2(filter, context))) {
       continue;
     }
     const sortValues = sortBy.map((key) => {
       if (key.special === "textScore") {
         return textScore ?? 0;
       }
-      return key.expression ? evaluateExpression(key.expression, context) : getFieldValue(document.data, key.field ?? "");
+      return key.expression ? evaluateExpression2(key.expression, context) : getFieldValue2(document.data, key.field ?? "");
     });
     matches.push({ document, sortValues, textScore });
   }
@@ -531,7 +992,7 @@ function runMockDocumentQuery(storedDocuments, databaseId, query) {
     fields: query?.fields ? Object.fromEntries(
       query.fields.map((field) => [
         field,
-        getFieldValue(document.data, field)
+        getFieldValue2(document.data, field)
       ])
     ) : structuredClone(document.data),
     lastModified: document.updatedAt ? Date.parse(document.updatedAt) || 0 : 0,
@@ -760,6 +1221,16 @@ function createDatabaseHandle(definition) {
   let changeCounter = 0;
   const defaultViewFactory = async () => createDefaultViewNavigator();
   const storedDocuments = /* @__PURE__ */ new Map();
+  for (const seed of definition.documents ?? []) {
+    storedDocuments.set(seed.id, {
+      id: seed.id,
+      data: structuredClone(seed.data),
+      heads: seed.heads ? [...seed.heads] : void 0,
+      attachments: seed.attachments ? structuredClone(seed.attachments) : [],
+      updatedAt: seed.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      isDeleted: seed.isDeleted ?? false
+    });
+  }
   const liveQuerySubscriptions = /* @__PURE__ */ new Set();
   const notifyLiveQueries = () => {
     for (const subscription of liveQuerySubscriptions) {
@@ -775,6 +1246,43 @@ function createDatabaseHandle(definition) {
       }
     }
   };
+  function mockEncryptForMap(names) {
+    const encryptFor = {};
+    for (const name of names) {
+      const trimmed = name.trim();
+      if (trimmed) {
+        encryptFor[trimmed] = { kind: "user" };
+      }
+    }
+    return encryptFor;
+  }
+  function persistEncryptFor(docId, nextEncryptFor) {
+    const existing = storedDocuments.get(docId);
+    if (!existing || existing.isDeleted) {
+      throw new Error(`Recipient mutators require an existing document (${docId})`);
+    }
+    const raw = existing.data._encryptFor;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      throw new Error("Recipient mutators require a document created with `recipients`");
+    }
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      id: docId,
+      data: { ...existing.data, _encryptFor: nextEncryptFor },
+      heads: [`mock-head-${++changeCounter}`],
+      attachments: existing.attachments ? structuredClone(existing.attachments) : [],
+      updatedAt
+    };
+    storedDocuments.set(docId, {
+      ...updated,
+      data: structuredClone(updated.data),
+      attachments: updated.attachments ? structuredClone(updated.attachments) : [],
+      isDeleted: false,
+      automergeBinary: void 0
+    });
+    notifyLiveQueries();
+    return updated;
+  }
   const defaultDocuments = {
     async query(query) {
       return runMockDocumentQuery(storedDocuments, definition.info.id, query);
@@ -832,7 +1340,7 @@ function createDatabaseHandle(definition) {
         const projectedData = query?.fields ? Object.fromEntries(
           query.fields.map((field) => [
             field,
-            getFieldValue(document.data, field)
+            getFieldValue2(document.data, field)
           ])
         ) : document.data;
         return {
@@ -962,9 +1470,17 @@ function createDatabaseHandle(definition) {
         id = `doc-${createCounter}`;
       }
       const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (Array.isArray(input.recipients) && input.recipientOptions?.includeSelf === false && input.recipients.every((name) => name.trim().length === 0)) {
+        throw new Error(
+          "recipients: [] with includeSelf: false would produce a document nobody can read"
+        );
+      }
       const created = {
         id,
-        data: { ...input.set },
+        data: {
+          ...input.set,
+          ...Array.isArray(input.recipients) ? { _encryptFor: mockEncryptForMap(input.recipients) } : {}
+        },
         heads: [`mock-head-${++changeCounter}`],
         attachments: [],
         updatedAt: createdAt
@@ -1008,6 +1524,49 @@ function createDatabaseHandle(definition) {
       notifyLiveQueries();
       return updated;
     },
+    async addRecipients(docId, recipients) {
+      const existing = storedDocuments.get(docId);
+      const current = existing?.data._encryptFor && typeof existing.data._encryptFor === "object" && !Array.isArray(existing.data._encryptFor) ? { ...existing.data._encryptFor } : null;
+      if (!current) {
+        throw new Error("Recipient mutators require a document created with `recipients`");
+      }
+      for (const name of recipients) {
+        const trimmed = name.trim();
+        if (!trimmed) {
+          continue;
+        }
+        const key = Object.keys(current).find(
+          (entry) => entry.trim().toLowerCase() === trimmed.toLowerCase()
+        );
+        if (key) {
+          delete current[key].removedAt;
+        } else {
+          current[trimmed] = { kind: "user" };
+        }
+      }
+      return persistEncryptFor(docId, current);
+    },
+    async removeRecipients(docId, recipients) {
+      const existing = storedDocuments.get(docId);
+      const current = existing?.data._encryptFor && typeof existing.data._encryptFor === "object" && !Array.isArray(existing.data._encryptFor) ? { ...existing.data._encryptFor } : {};
+      const drop = new Set(
+        recipients.map((name) => name.trim().toLowerCase()).filter(Boolean)
+      );
+      for (const key of Object.keys(current)) {
+        if (drop.has(key.trim().toLowerCase())) {
+          delete current[key];
+        }
+      }
+      return persistEncryptFor(docId, current);
+    },
+    async setRecipients(docId, recipients, options) {
+      if (options?.includeSelf === false && recipients.every((name) => name.trim().length === 0)) {
+        throw new Error(
+          "recipients: [] with includeSelf: false would produce a document nobody can read"
+        );
+      }
+      return persistEncryptFor(docId, mockEncryptForMap(recipients));
+    },
     async delete(_docId) {
       const existing = storedDocuments.get(_docId);
       if (existing) {
@@ -1054,6 +1613,9 @@ function createDatabaseHandle(definition) {
     async getDefaultCreateKeyId() {
       return "default";
     },
+    async listCreateKeys() {
+      return [{ keyId: "default", isDefault: true }];
+    },
     async listHistory(_docId) {
       return [];
     },
@@ -1139,6 +1701,9 @@ function createDatabaseHandle(definition) {
         fingerprint: "0".repeat(64),
         status: "unknown"
       }));
+    },
+    async listUsers() {
+      return [];
     }
   };
   const defaultViews = {
@@ -1181,12 +1746,22 @@ function createDatabaseHandle(definition) {
     },
     async openPreview(_docId, _attachmentName, _options) {
       return { ok: true };
+    },
+    async extractText(input) {
+      const format = input.format ?? "markdown";
+      const text = new TextDecoder("utf-8", { fatal: false }).decode(input.bytes);
+      return {
+        text,
+        handled: true,
+        format,
+        engine: "mock-utf-8"
+      };
     }
   };
   const methods = definition.methods ?? {};
   let fulltextSetup = definition.fulltextSetup ?? null;
   let extractionSetup = definition.extractionSetup ?? null;
-  return {
+  const databaseHandle = {
     async info() {
       return {
         ...definition.info,
@@ -1226,6 +1801,15 @@ function createDatabaseHandle(definition) {
       extractionSetup = config === null ? null : { ...config };
     }
   };
+  return {
+    handle: databaseHandle,
+    listViewDocuments: () => Array.from(storedDocuments.values()).filter((document) => !document.isDeleted).map((document) => ({
+      origin: definition.info.id,
+      docId: document.id,
+      data: structuredClone(document.data),
+      createdAt: document.updatedAt ?? null
+    }))
+  };
 }
 function createMockSessionState(options = {}) {
   let launchContext = createDefaultLaunchContext(options.launchContext);
@@ -1234,6 +1818,7 @@ function createMockSessionState(options = {}) {
   const uiPreferencesListeners = /* @__PURE__ */ new Set();
   const localeListeners = /* @__PURE__ */ new Set();
   const databaseHandles = /* @__PURE__ */ new Map();
+  const databaseViewDocumentLists = /* @__PURE__ */ new Map();
   const databaseViewApis = /* @__PURE__ */ new Map();
   const sessionViews = /* @__PURE__ */ new Map();
   let activeMenuResolve = null;
@@ -1260,15 +1845,27 @@ function createMockSessionState(options = {}) {
   };
   const setDatabases = (definitions) => {
     databaseHandles.clear();
+    databaseViewDocumentLists.clear();
     databaseViewApis.clear();
     databaseInfos = definitions.map((definition) => ({
       ...definition.info,
       capabilities: [...definition.info.capabilities]
     }));
     for (const definition of definitions) {
-      databaseHandles.set(definition.info.id, createDatabaseHandle(definition));
+      const created = createDatabaseHandle(definition);
+      databaseHandles.set(definition.info.id, created.handle);
+      databaseViewDocumentLists.set(definition.info.id, created.listViewDocuments);
       databaseViewApis.set(definition.info.id, {
-        async create(_input) {
+        async create(input) {
+          const documents = input.databaseIds.flatMap((databaseId) => {
+            const list = databaseViewDocumentLists.get(databaseId);
+            return list ? list() : [];
+          });
+          const evaluating = await createEvaluatingViewNavigator(input, documents);
+          if (evaluating) return evaluating;
+          console.warn(
+            "[mindoodb-app-sdk/testing] mindoodb peer not available; using empty view navigator. Install mindoodb as a devDependency for evaluating VirtualViews."
+          );
           return await createDefaultViewNavigator();
         },
         async open(_viewId) {
@@ -1734,6 +2331,22 @@ function createFakeBridgeHost(options = {}) {
           String(params.docId),
           params.patch
         );
+      case "documents.addRecipients":
+        return await state.getDatabase(String(params.databaseId)).documents.addRecipients(
+          String(params.docId),
+          Array.isArray(params.recipients) ? params.recipients.map(String) : []
+        );
+      case "documents.removeRecipients":
+        return await state.getDatabase(String(params.databaseId)).documents.removeRecipients(
+          String(params.docId),
+          Array.isArray(params.recipients) ? params.recipients.map(String) : []
+        );
+      case "documents.setRecipients":
+        return await state.getDatabase(String(params.databaseId)).documents.setRecipients(
+          String(params.docId),
+          Array.isArray(params.recipients) ? params.recipients.map(String) : [],
+          params.recipientOptions && typeof params.recipientOptions === "object" && !Array.isArray(params.recipientOptions) ? params.recipientOptions : void 0
+        );
       case "documents.delete":
         return await state.getDatabase(String(params.databaseId)).documents.delete(String(params.docId));
       case "documents.undelete":
@@ -1750,6 +2363,8 @@ function createFakeBridgeHost(options = {}) {
         return await state.getDatabase(String(params.databaseId)).documents.canUndelete(String(params.docId));
       case "documents.getDefaultCreateKeyId":
         return await state.getDatabase(String(params.databaseId)).documents.getDefaultCreateKeyId();
+      case "documents.listCreateKeys":
+        return await state.getDatabase(String(params.databaseId)).documents.listCreateKeys();
       case "documents.history.list":
         return await state.getDatabase(String(params.databaseId)).documents.listHistory(String(params.docId));
       case "documents.history.getAtTimestamp":
@@ -1789,6 +2404,8 @@ function createFakeBridgeHost(options = {}) {
         return await state.getDatabase(String(params.databaseId)).directory.excerpt(
           Array.isArray(params.publicKeys) ? params.publicKeys.map(String) : []
         );
+      case "directory.listUsers":
+        return await state.getDatabase(String(params.databaseId)).directory.listUsers();
       case "attachments.list":
         return await state.getDatabase(String(params.databaseId)).attachments.list(
           String(params.docId),
@@ -1831,6 +2448,16 @@ function createFakeBridgeHost(options = {}) {
           String(params.attachmentName),
           typeof params.revisionId === "string" ? { revisionId: params.revisionId } : typeof params.timestamp === "number" ? { timestamp: params.timestamp } : void 0
         );
+      case "attachments.extractText":
+        return await state.getDatabase(String(params.databaseId)).attachments.extractText({
+          bytes: params.bytes instanceof Uint8Array ? params.bytes : new Uint8Array(
+            params.bytes instanceof ArrayBuffer ? params.bytes : Array.isArray(params.bytes) ? params.bytes : []
+          ),
+          mimeType: typeof params.mimeType === "string" ? params.mimeType : "",
+          fileName: typeof params.fileName === "string" ? params.fileName : void 0,
+          format: params.format === "plainText" || params.format === "markdown" ? params.format : void 0,
+          languages: Array.isArray(params.languages) ? params.languages.filter((entry) => typeof entry === "string") : void 0
+        });
       case "attachments.preparePreviewSession":
         return await state.getDatabase(String(params.databaseId)).attachments.preparePreviewSession(
           String(params.docId),
@@ -2180,7 +2807,9 @@ function createFakeBridgeHost(options = {}) {
   return controller;
 }
 export {
+  createEvaluatingViewNavigator,
   createFakeBridgeHost,
   createMockMindooDBAppBridge,
-  createMockMindooDBAppSession
+  createMockMindooDBAppSession,
+  loadMindoodbForTesting
 };