wiki-graph-core 0.3.1 → 0.4.1

package/dist/archive/query/archive-view.js

@@ -1,4540 +0,0 @@
-import {
-  WikipageResolver
-} from "../../wikipage/index.js";
-import {
-  getGraphNode,
-  listGraphNeighbors
-} from "../../facade/graph.js";
-import {
-  getChapterTree,
-  listChapters
-} from "../../facade/chapter.js";
-import {
-  createLexicalQuery,
-  listLexicalQueryCandidateTerms,
-  createMentionLexicalHits,
-  scoreLexicalText
-} from "./lexical-search.js";
-import {
-  createEntitySearchSession,
-  createSearchSession,
-  decodeBucketSearchSessionCursor,
-  decodeSearchSessionCursor,
-  encodeBucketSearchSessionCursor,
-  populateSearchSessionObjectCaches,
-  readCachedEntitySearchSessionPage,
-  readCachedSearchSessionPage,
-  readEntitySearchEvidenceMentions,
-  readEntitySearchSessionPage,
-  readSearchSessionChunkBucketPage,
-  readSearchSessionDescriptor,
-  readSearchSessionMetadataForCursor,
-  readSearchSessionObjectBucketPage,
-  readSearchSessionPage,
-  SEARCH_EVIDENCE_KIND
-} from "./search-cache.js";
-import {
-  createSearchIndexFingerprint,
-  ensureSearchIndex,
-  querySearchIndex,
-  readSearchIndexStatus,
-  SEARCH_INDEX_FTS_HIT_LIMIT,
-  SEARCH_OBJECT_PROPERTY_KIND,
-  SEARCH_OBJECT_PROPERTY_OWNER_KIND,
-  TEXT_SENTENCE_KIND
-} from "../search-index/search-index.js";
-import { WIKI_GRAPH_URI_PREFIX } from "../../common/wiki-graph-uri.js";
-const DEFAULT_SOURCE_CONTEXT = 2;
-async function getArchiveIndex(document) {
-  const [chapters, meta, nodes, edges] = await Promise.all([
-    listChapters(document),
-    document.readBookMeta(),
-    document.chunks.countAll(),
-    document.readingEdges.countAll()
-  ]);
-  return {
-    chapters,
-    edgeCount: edges,
-    meta,
-    nodeCount: nodes,
-    summaryCount: chapters.filter((chapter) => chapter.stage === "summarized").length
-  };
-}
-async function listArchiveObjects(document, kind) {
-  switch (kind) {
-    case "chapters":
-      return await Promise.all(
-        (await listChapters(document)).map(async (chapter) => {
-          const state = await createChapterState(document, chapter);
-          return {
-            id: formatChapterId(chapter.chapterId),
-            label: chapter.title ?? "[untitled]",
-            state,
-            summary: formatChapterStateSummary(state),
-            type: "chapter"
-          };
-        })
-      );
-    case "edges":
-      return (await document.readingEdges.listAll()).map((edge) => ({
-        id: formatEdgeId(edge),
-        label: `${formatNodeId(edge.fromId)} -> ${formatNodeId(edge.toId)}`,
-        summary: `weight ${formatWeight(edge.weight)}`,
-        type: "edge"
-      }));
-    case "meta": {
-      const meta = await document.readBookMeta();
-      return [
-        {
-          id: ARCHIVE_ROOT_ID,
-          label: formatMetaTitle(meta),
-          summary: formatMetaSummary(meta),
-          type: "meta"
-        }
-      ];
-    }
-    case "nodes":
-      return (await document.chunks.listAll()).map((node) => ({
-        id: formatNodeId(node.id),
-        label: node.label,
-        summary: node.content,
-        type: "node"
-      }));
-    case "summaries":
-      return (await Promise.all(
-        (await listChapters(document)).map(async (chapter) => {
-          const summary = await document.readSummary(chapter.chapterId);
-          if (summary === void 0) {
-            return void 0;
-          }
-          return {
-            id: formatSummaryId(chapter.chapterId),
-            label: chapter.title ?? `[chapter ${chapter.chapterId}]`,
-            summary: createSnippet(summary),
-            type: "summary"
-          };
-        })
-      )).filter(isDefined);
-    case "fragments":
-      return (await Promise.all(
-        (await listChapters(document)).map(async (chapter) => {
-          const title = chapter.title ?? formatChapterId(chapter.chapterId);
-          return listTextStreamSentenceCollection(
-            await createTextStreamIndex(
-              document,
-              chapter.chapterId,
-              "source"
-            ),
-            chapter.chapterId,
-            "source",
-            title,
-            chapter.documentOrder
-          ).map((hit) => ({
-            id: hit.id,
-            label: title,
-            summary: hit.snippet,
-            type: "source"
-          }));
-        })
-      )).flat();
-  }
-}
-async function listArchiveCollection(document, options = {}) {
-  const items = [];
-  const documentOrders = await document.serials.listDocumentOrders();
-  const chapterFilter = options.chapters === void 0 ? void 0 : new Set(options.chapters);
-  const types = options.types ?? [
-    "meta",
-    "chapter-title",
-    "entity",
-    "node",
-    "triple"
-  ];
-  if (types.includes("meta")) {
-    const meta = await document.readBookMeta();
-    if (meta !== void 0) {
-      items.push({
-        field: "metadata",
-        id: ARCHIVE_ROOT_ID,
-        snippet: formatMetaSummary(meta),
-        title: meta.title ?? "Archive metadata",
-        type: "meta"
-      });
-    }
-  }
-  if (types.includes("chapter") || types.includes("chapter-title")) {
-    for (const chapter of filterChapters(
-      await listChapters(document),
-      chapterFilter
-    )) {
-      const title = chapter.title ?? `[chapter ${chapter.chapterId}]`;
-      if (types.includes("chapter") || types.includes("chapter-title")) {
-        items.push({
-          chapter: chapter.chapterId,
-          field: "title",
-          id: formatChapterTitleId(chapter.chapterId),
-          position: {
-            chapter: chapter.chapterId,
-            documentOrder: chapter.documentOrder
-          },
-          snippet: title,
-          title,
-          type: "chapter-title"
-        });
-      }
-    }
-  }
-  if (types.includes("node")) {
-    for (const node of await document.chunks.listAll()) {
-      if (!isChapterAllowed(chapterFilter, node.sentenceId[0])) {
-        continue;
-      }
-      const position = createNodePosition(node.sentenceIds, documentOrders);
-      items.push({
-        chapter: node.sentenceId[0],
-        field: "content",
-        id: formatNodeId(node.id),
-        ...position === void 0 ? {} : { position },
-        snippet: createSnippet(node.content),
-        title: node.label,
-        type: "node"
-      });
-    }
-  }
-  if (types.includes("entity")) {
-    items.push(
-      ...listEntityCollection(
-        filterMentionsByChapterSet(
-          await listAllMentions(document),
-          chapterFilter
-        ),
-        documentOrders
-      )
-    );
-  }
-  if (types.includes("triple")) {
-    items.push(
-      ...await listTripleCollection(document, chapterFilter, documentOrders)
-    );
-  }
-  const result = createCollectionResult(items, options);
-  const evidenceItems = await hydrateFindHitEvidence(document, result.items, {
-    ...options.evidenceLimit === void 0 ? {} : { evidenceLimit: options.evidenceLimit },
-    order: options.order ?? "doc-asc",
-    ...options.sourceContext === void 0 ? {} : { sourceContext: options.sourceContext }
-  });
-  return {
-    ...result,
-    items: await hydrateFindHitBacklinks(document, evidenceItems, options)
-  };
-}
-function filterChapters(chapters, chapterFilter) {
-  return chapterFilter === void 0 ? chapters : chapters.filter((chapter) => chapterFilter.has(chapter.chapterId));
-}
-function isChapterAllowed(chapterFilter, chapterId) {
-  return chapterFilter === void 0 || chapterFilter.has(chapterId);
-}
-async function findArchiveObjects(document, query, options = {}) {
-  const limit = options.limit ?? DEFAULT_FIND_LIMIT;
-  const textOnlySearch = isTextOnlySearch(options);
-  if (options.cursor !== void 0 && (!textOnlySearch || !isFindCursor(options.cursor))) {
-    const bucketCursor = tryDecodeBucketSearchSessionCursor(options.cursor);
-    if (bucketCursor !== void 0) {
-      return await readBucketedSearchResultPage(document, bucketCursor, {
-        ...options,
-        limit
-      });
-    }
-    const cursor = decodeSearchSessionCursor(options.cursor);
-    const descriptor = await readSearchSessionDescriptor(
-      cursor.sessionId,
-      options.archiveKey ?? "archive"
-    );
-    assertSearchCursorTypesMatch(options.types, descriptor.types);
-    const page = isEntitySearchTypes(descriptor.types) ? await readEntitySearchSessionPage(
-      cursor.sessionId,
-      cursor.offset,
-      limit,
-      options.archiveKey ?? "archive",
-      cursor.createdAt
-    ) : await readSearchSessionPage(
-      cursor.sessionId,
-      cursor.offset,
-      limit,
-      options.archiveKey ?? "archive",
-      cursor.createdAt
-    );
-    return await hydrateFindResultBacklinks(
-      document,
-      {
-        chapters: page.chapters,
-        items: await hydrateFindHitEvidence(
-          document,
-          page.items,
-          createFindEvidenceHydrationOptions(options, cursor.sessionId)
-        ),
-        lens: parseFindLens(page.lens),
-        lensHint: page.lens === "broad" ? BROAD_FIND_LENS_HINT : null,
-        limit,
-        match: parseFindMatch(page.match),
-        nextCursor: page.nextCursor,
-        order: options.order ?? "doc-asc",
-        query: page.query,
-        terms: page.terms,
-        types: parseFindTypes(descriptor.types)
-      },
-      options
-    );
-  }
-  const requestedTypes = options.types ?? null;
-  const wantsStructuredSearch = requestedTypes === null || requestedTypes.includes("entity") || requestedTypes.includes("triple");
-  const search = createLexicalQuery(query);
-  if (search === void 0) {
-    return createFindResult(query, [], options);
-  }
-  if (textOnlySearch) {
-    return await findTextOnlyArchiveObjectsIndexed(
-      document,
-      query,
-      options,
-      search
-    );
-  }
-  const revisionScope = await createSearchRevisionScope(
-    document,
-    options.chapters
-  );
-  const cacheInput = {
-    archiveKey: options.archiveKey ?? "archive",
-    chapters: options.chapters ?? null,
-    lens: options.types === void 0 ? "broad" : "typed",
-    match: options.match ?? "any",
-    order: options.order ?? "doc-asc",
-    query,
-    revisionScope,
-    terms: search.terms,
-    types: options.types ?? null
-  };
-  const canReadSearchCache = options.triplePattern === void 0;
-  const usesBucketedSearch = options.types === void 0 && options.triplePattern === void 0;
-  if (canReadSearchCache && isEntityOnlySearch(options)) {
-    const cachedPage = await readCachedEntitySearchSessionPage(
-      cacheInput,
-      0,
-      limit
-    );
-    if (cachedPage !== void 0) {
-      return await hydrateFindResultBacklinks(
-        document,
-        {
-          chapters: cachedPage.chapters,
-          items: await hydrateFindHitEvidence(
-            document,
-            cachedPage.items,
-            createFindEvidenceHydrationOptions(options, cachedPage.sessionId)
-          ),
-          lens: parseFindLens(cachedPage.lens),
-          lensHint: cachedPage.lens === "broad" ? BROAD_FIND_LENS_HINT : null,
-          limit,
-          match: parseFindMatch(cachedPage.match),
-          nextCursor: cachedPage.nextCursor,
-          order: options.order ?? "doc-asc",
-          query: cachedPage.query,
-          terms: cachedPage.terms,
-          types: parseFindTypes(cachedPage.types)
-        },
-        options
-      );
-    }
-  } else if (canReadSearchCache && !usesBucketedSearch) {
-    const cachedPage = await readCachedSearchSessionPage(cacheInput, 0, limit);
-    if (cachedPage !== void 0) {
-      return await hydrateFindResultBacklinks(
-        document,
-        {
-          chapters: cachedPage.chapters,
-          items: await hydrateFindHitEvidence(
-            document,
-            cachedPage.items,
-            createFindEvidenceHydrationOptions(options)
-          ),
-          lens: parseFindLens(cachedPage.lens),
-          lensHint: cachedPage.lens === "broad" ? BROAD_FIND_LENS_HINT : null,
-          limit,
-          match: parseFindMatch(cachedPage.match),
-          nextCursor: cachedPage.nextCursor,
-          order: options.order ?? "doc-asc",
-          query: cachedPage.query,
-          terms: cachedPage.terms,
-          types: parseFindTypes(cachedPage.types)
-        },
-        options
-      );
-    }
-  }
-  if (usesBucketedSearch) {
-    if (!await isArchiveSearchIndexCurrent(document)) {
-      throw new Error(
-        "Wiki Graph search index is missing or outdated. Run `<archive-uri>/index enable` before searching."
-      );
-    }
-    const sessionId2 = await createSearchSession({
-      archiveKey: options.archiveKey ?? "archive",
-      chapters: options.chapters ?? null,
-      lens: "broad",
-      match: options.match ?? "any",
-      order: options.order ?? "doc-asc",
-      query,
-      revisionScope,
-      terms: search.terms,
-      types: null
-    });
-    const descriptor = await readSearchSessionDescriptor(
-      sessionId2,
-      options.archiveKey ?? "archive"
-    );
-    return await readBucketedSearchResultPage(
-      document,
-      {
-        createdAt: descriptor.createdAt,
-        cursor: { bucket: 0 },
-        sessionId: sessionId2
-      },
-      { ...options, limit }
-    );
-  }
-  const allMentions = wantsStructuredSearch ? await document.mentions.listBySurfaceTerms(
-    listLexicalQueryCandidateTerms(query)
-  ) : [];
-  const indexed = await findArchiveObjectsIndexed(document, query, options);
-  const structuredHits = wantsStructuredSearch ? [
-    ...findEntities(search, { mentions: allMentions }),
-    ...await findTriples(document, search, { mentions: allMentions })
-  ] : [];
-  const hits = [...structuredHits, ...indexed?.hits ?? []];
-  if (isEntityOnlySearch(options)) {
-    const ranked2 = createRankedFindResult(
-      query,
-      filterLexicalHitsByMatch(hits, search, options.match ?? "any"),
-      options,
-      search.terms
-    );
-    const entityCacheInput2 = createEntitySearchCacheInput(
-      ranked2.items,
-      indexed?.result
-    );
-    const sentenceCacheInput2 = await createSentenceEvidenceSearchCacheInput(
-      document,
-      indexed?.result,
-      options
-    );
-    const sessionId2 = await createEntitySearchSession({
-      archiveKey: options.archiveKey ?? "archive",
-      chapters: ranked2.chapters,
-      chunkHits: sentenceCacheInput2.chunkHits,
-      entityHits: [
-        ...entityCacheInput2.entityHits,
-        ...sentenceCacheInput2.entityHits
-      ],
-      evidenceEvents: [
-        ...entityCacheInput2.evidenceEvents,
-        ...sentenceCacheInput2.evidenceEvents
-      ],
-      lens: ranked2.lens,
-      match: ranked2.match,
-      order: ranked2.order,
-      query,
-      revisionScope,
-      terms: ranked2.terms,
-      tripleHits: sentenceCacheInput2.tripleHits,
-      types: ranked2.types
-    });
-    const firstPage2 = await readEntitySearchSessionPage(sessionId2, 0, limit);
-    return await hydrateFindResultBacklinks(
-      document,
-      {
-        ...ranked2,
-        items: await hydrateFindHitEvidence(
-          document,
-          firstPage2.items,
-          createFindEvidenceHydrationOptions(options, sessionId2)
-        ),
-        nextCursor: firstPage2.nextCursor
-      },
-      options
-    );
-  }
-  const ranked = createRankedFindResult(
-    query,
-    filterLexicalHitsByMatch(hits, search, options.match ?? "any"),
-    options,
-    search.terms
-  );
-  const entityCacheInput = createEntitySearchCacheInput(
-    ranked.items,
-    indexed?.result
-  );
-  const sentenceCacheInput = await createSentenceEvidenceSearchCacheInput(
-    document,
-    indexed?.result,
-    options
-  );
-  const sessionId = await createSearchSession({
-    archiveKey: options.archiveKey ?? "archive",
-    chapters: ranked.chapters,
-    chunkHits: sentenceCacheInput.chunkHits,
-    entityHits: [
-      ...entityCacheInput.entityHits,
-      ...sentenceCacheInput.entityHits
-    ],
-    evidenceEvents: [
-      ...entityCacheInput.evidenceEvents,
-      ...sentenceCacheInput.evidenceEvents
-    ],
-    items: ranked.items,
-    lens: ranked.lens,
-    match: ranked.match,
-    order: ranked.order,
-    query,
-    revisionScope,
-    terms: ranked.terms,
-    tripleHits: sentenceCacheInput.tripleHits,
-    types: ranked.types
-  });
-  const firstPage = await readSearchSessionPage(sessionId, 0, limit);
-  return await hydrateFindResultBacklinks(
-    document,
-    {
-      ...ranked,
-      items: await hydrateFindHitEvidence(
-        document,
-        firstPage.items,
-        createFindEvidenceHydrationOptions(options)
-      ),
-      nextCursor: firstPage.nextCursor
-    },
-    options
-  );
-}
-async function findTextOnlyArchiveObjectsIndexed(document, query, options, search) {
-  const indexed = await findArchiveObjectsIndexed(document, query, options);
-  const hits = indexed?.hits ?? [];
-  return createFindResult(
-    query,
-    filterLexicalHitsByMatch(hits, search, options.match ?? "any"),
-    options,
-    indexed?.result.terms ?? search.terms
-  );
-}
-async function createSearchRevisionScope(document, chapters) {
-  if (chapters === void 0 || chapters.length === 0) {
-    return JSON.stringify({
-      chaptersRevision: await document.serials.getChaptersRevision(),
-      scope: "all"
-    });
-  }
-  const uniqueChapters = [...new Set(chapters)].sort(compareNumbers);
-  const revisions = await document.serials.getRevisions(uniqueChapters);
-  return JSON.stringify({
-    chapters: uniqueChapters.map(
-      (chapterId) => [chapterId, revisions.get(chapterId) ?? 0]
-    ),
-    scope: "chapters"
-  });
-}
-async function readBucketedSearchResultPage(document, cursor, options) {
-  const session = await readSearchSessionMetadataForCursor(
-    cursor.sessionId,
-    options.archiveKey ?? "archive",
-    cursor.createdAt
-  );
-  assertSearchCursorTypesMatch(options.types, session.types);
-  const items = [];
-  let bucketCursor = cursor.cursor;
-  while (bucketCursor !== void 0 && items.length < options.limit) {
-    const remaining = options.limit - items.length;
-    const page = await readBucketPage(
-      document,
-      session,
-      bucketCursor,
-      remaining
-    );
-    items.push(...page.items);
-    bucketCursor = page.nextCursor;
-  }
-  return await hydrateFindResultBacklinks(
-    document,
-    {
-      chapters: session.chapters,
-      items: await hydrateFindHitEvidence(
-        document,
-        items,
-        createFindEvidenceHydrationOptions(options, cursor.sessionId)
-      ),
-      lens: parseFindLens(session.lens),
-      lensHint: session.lens === "broad" ? BROAD_FIND_LENS_HINT : null,
-      limit: options.limit,
-      match: parseFindMatch(session.match),
-      nextCursor: bucketCursor === void 0 ? null : encodeBucketSearchSessionCursor(
-        cursor.sessionId,
-        bucketCursor,
-        session.createdAt
-      ),
-      order: options.order ?? "doc-asc",
-      query: session.query,
-      terms: session.terms,
-      types: parseFindTypes(session.types)
-    },
-    options
-  );
-}
-async function readBucketPage(document, session, cursor, limit) {
-  switch (cursor.bucket) {
-    case 0:
-      return await readChapterTitleBucketPage(
-        document,
-        session,
-        cursor.key,
-        limit
-      );
-    case 1:
-      return await readObjectBucketPage(document, session, cursor.key, limit);
-    case 2:
-      return await readChunkBucketPage(document, session, cursor.key, limit);
-    case 3:
-      return await readTextBucketPage(document, session, cursor.key, limit);
-  }
-}
-async function readChapterTitleBucketPage(document, session, after, limit) {
-  const result = await querySearchIndex(document, session.query, {
-    ...session.chapters === null ? {} : { chapters: session.chapters },
-    match: parseFindMatch(session.match),
-    objectHitLimit: SEARCH_INDEX_FTS_HIT_LIMIT,
-    textHitLimit: 0,
-    types: ["chapter-title"]
-  });
-  const chapters = new Map(
-    (await listChapters(document)).map((chapter) => [
-      chapter.chapterId,
-      chapter
-    ])
-  );
-  const hits = (result?.objectHits ?? []).filter(
-    (hit) => hit.ownerKind === SEARCH_OBJECT_PROPERTY_OWNER_KIND.chapter
-  ).sort(compareChapterTitleIndexHits).filter((hit) => isAfterChapterTitleKey(hit, after));
-  const page = hits.slice(0, limit + 1);
-  const hydrated = (await Promise.all(
-    page.slice(0, limit).map(async (hit) => {
-      const item = await hydrateSearchObjectHit(document, chapters, hit);
-      return item === void 0 ? void 0 : withSearchTerms(item, session.terms);
-    })
-  )).filter(isDefined);
-  const last = page.at(limit - 1);
-  return {
-    items: hydrated,
-    nextCursor: page.length > limit && last !== void 0 ? {
-      bucket: 0,
-      key: {
-        chapterId: parseSearchPropertyIntegerOwnerId(last.ownerId),
-        score: last.score
-      }
-    } : { bucket: 1 }
-  };
-}
-async function readObjectBucketPage(document, session, after, limit) {
-  if (!session.objectCachesPopulated) {
-    await populateObjectBucketCaches(document, session);
-  }
-  const page = await readSearchSessionObjectBucketPage(
-    session.sessionId,
-    1,
-    after,
-    limit
-  );
-  const items = page.slice(0, limit);
-  const hydrated = await Promise.all(
-    items.map(async (hit) => await hydrateCachedObjectBucketHit(document, hit))
-  );
-  const last = items.at(-1);
-  return {
-    items: hydrated,
-    nextCursor: page.length > limit && last !== void 0 ? {
-      bucket: 1,
-      key: {
-        id: getObjectBucketCursorId(last),
-        kind: last.type === "triple" ? "triple" : "entity",
-        score: last.score ?? 0
-      }
-    } : { bucket: 2 }
-  };
-}
-async function populateObjectBucketCaches(document, session) {
-  const search = createLexicalQuery(session.query);
-  if (search === void 0) {
-    return;
-  }
-  const [allMentions, indexed] = await Promise.all([
-    document.mentions.listBySurfaceTerms(
-      listLexicalQueryCandidateTerms(session.query)
-    ),
-    querySearchIndex(document, session.query, {
-      ...session.chapters === null ? {} : { chapters: session.chapters },
-      match: parseFindMatch(session.match),
-      objectHitLimit: SEARCH_INDEX_FTS_HIT_LIMIT,
-      textHitLimit: 0,
-      types: null
-    })
-  ]);
-  const structuredHits = [
-    ...findEntities(search, { mentions: allMentions }),
-    ...await findTriples(document, search, { mentions: allMentions })
-  ];
-  const entityCacheInput = createEntitySearchCacheInput(
-    structuredHits,
-    indexed
-  );
-  await populateSearchSessionObjectCaches({
-    entityHits: entityCacheInput.entityHits,
-    evidenceEvents: entityCacheInput.evidenceEvents,
-    sessionId: session.sessionId
-  });
-}
-async function readChunkBucketPage(document, session, after, limit) {
-  const page = await readSearchSessionChunkBucketPage(
-    session.sessionId,
-    after,
-    limit
-  );
-  const items = page.slice(0, limit);
-  const hydrated = (await Promise.all(
-    items.map(
-      async (hit) => await hydrateCachedChunkBucketHit(document, hit)
-    )
-  )).filter(isDefined);
-  const last = items.at(-1);
-  return {
-    items: hydrated,
-    nextCursor: page.length > limit && last !== void 0 ? {
-      bucket: 2,
-      key: {
-        chunkId: parseSearchPropertyIntegerOwnerId(
-          last.id.slice("wikg://chunk/".length)
-        ),
-        score: last.score ?? 0
-      }
-    } : { bucket: 3 }
-  };
-}
-async function readTextBucketPage(document, session, after, limit) {
-  const result = await querySearchIndex(document, session.query, {
-    ...session.chapters === null ? {} : { chapters: session.chapters },
-    match: parseFindMatch(session.match),
-    objectHitLimit: 0,
-    ...after === void 0 ? {} : {
-      textAfter: {
-        chapterId: after.chapterId,
-        kind: after.kind,
-        rank: after.rank,
-        sentenceIndex: after.sentenceIndex
-      }
-    },
-    textHitLimit: createBucketQueryWindow(limit),
-    types: ["source", "summary"]
-  });
-  const chapters = new Map(
-    (await listChapters(document)).map((chapter) => [
-      chapter.chapterId,
-      chapter
-    ])
-  );
-  const hits = [...result?.textHits ?? []].sort(compareTextIndexHits).filter((hit) => isAfterTextKey(hit, after));
-  const page = hits.slice(0, limit + 1);
-  const hydrated = (await Promise.all(
-    page.slice(0, limit).map(async (hit) => {
-      const item = await hydrateSearchTextHit(document, chapters, hit);
-      return item === void 0 ? void 0 : withSearchTerms(item, session.terms);
-    })
-  )).filter(isDefined);
-  const last = page.at(limit - 1);
-  return {
-    items: hydrated,
-    nextCursor: page.length > limit && last !== void 0 ? {
-      bucket: 3,
-      key: {
-        chapterId: last.chapterId,
-        kind: last.kind,
-        rank: last.rank,
-        sentenceIndex: last.sentenceIndex
-      }
-    } : void 0
-  };
-}
-function createBucketQueryWindow(limit) {
-  return Math.max(limit + 1, limit * 3 + 1, 100);
-}
-async function hydrateCachedObjectBucketHit(document, hit) {
-  if (hit.type === "entity") {
-    const qid = parseEntityQid(hit.id);
-    if (qid === void 0) {
-      return hit;
-    }
-    const mentions = await document.mentions.listByQid(qid);
-    const [first] = [...mentions].sort(compareMentions);
-    if (first === void 0) {
-      return hit;
-    }
-    return {
-      ...hit,
-      chapter: first.chapterId,
-      position: {
-        chapter: first.chapterId,
-        sentence: first.sentenceIndex ?? 0
-      },
-      snippet: first.note ?? first.surface,
-      title: selectEntityLabel(mentions)
-    };
-  }
-  if (hit.type === "triple") {
-    return hit;
-  }
-  return hit;
-}
-async function hydrateCachedChunkBucketHit(document, hit) {
-  const chunkId = parseSearchPropertyIntegerOwnerId(
-    hit.id.slice("wikg://chunk/".length)
-  );
-  const node = await document.chunks.getById(chunkId);
-  if (node === void 0) {
-    return void 0;
-  }
-  const { position: _position, ...baseHit } = hit;
-  const position = createNodePosition(node.sentenceIds);
-  return {
-    ...baseHit,
-    chapter: node.sentenceId[0],
-    field: "title",
-    ...position === void 0 ? {} : { position },
-    snippet: createSnippet(node.content),
-    title: node.label
-  };
-}
-function compareChapterTitleIndexHits(left, right) {
-  return compareNumbers(right.score, left.score) || compareNumbers(
-    parseSearchPropertyIntegerOwnerId(left.ownerId),
-    parseSearchPropertyIntegerOwnerId(right.ownerId)
-  );
-}
-function compareTextIndexHits(left, right) {
-  return compareNumbers(left.rank, right.rank) || compareNumbers(left.chapterId, right.chapterId) || compareNumbers(left.sentenceIndex, right.sentenceIndex) || compareNumbers(left.kind, right.kind);
-}
-function isAfterChapterTitleKey(hit, key) {
-  if (key === void 0) {
-    return true;
-  }
-  return compareChapterTitleIndexHits(
-    {
-      ...hit,
-      ownerId: String(key.chapterId),
-      score: key.score
-    },
-    hit
-  ) < 0;
-}
-function isAfterTextKey(hit, key) {
-  if (key === void 0) {
-    return true;
-  }
-  return compareTextIndexHits(
-    {
-      chapterId: key.chapterId,
-      kind: key.kind,
-      rank: key.rank,
-      score: 0,
-      sentenceIndex: key.sentenceIndex,
-      wordsCount: 0
-    },
-    hit
-  ) < 0;
-}
-function getObjectBucketCursorId(hit) {
-  if (hit.type !== "triple") {
-    return hit.id.replace(/^wikg:\/\/entity\//u, "");
-  }
-  const triple = parseTripleCursorId(hit.id);
-  return triple ?? hit.id;
-}
-function parseTripleCursorId(id) {
-  const match = /^wikg:\/\/triple\/([^/]+)\/([^/]+)\/([^/]+)$/u.exec(id);
-  if (match?.[1] === void 0 || match[2] === void 0 || match[3] === void 0) {
-    return void 0;
-  }
-  return `${match[1]}${decodeURIComponent(match[2])}${match[3]}`;
-}
-function tryDecodeBucketSearchSessionCursor(cursor) {
-  try {
-    return decodeBucketSearchSessionCursor(cursor);
-  } catch {
-    return void 0;
-  }
-}
-async function rebuildArchiveSearchIndex(document, progress) {
-  const input = await createSearchIndexRecords(document, progress);
-  if (await readSearchIndexStatus(document, input) === "dirty") {
-    await document.deleteSearchIndexDatabase();
-  }
-  await ensureSearchIndex(document, input, progress);
-}
-async function isArchiveSearchIndexCurrent(document) {
-  return await readArchiveSearchIndexStatus(document) === "current";
-}
-async function readArchiveSearchIndexStatus(document) {
-  return await readSearchIndexStatus(
-    document,
-    await createSearchIndexRecords(document)
-  );
-}
-async function clearDirtyArchiveSearchIndex(document) {
-  if (await readArchiveSearchIndexStatus(document) === "dirty") {
-    await document.deleteSearchIndexDatabase();
-  }
-}
-async function createArchiveSearchIndexFingerprint(document) {
-  return createSearchIndexFingerprint(await createSearchIndexRecords(document));
-}
-async function grepArchiveObjects(document, query, options = {}) {
-  const search = createPhraseSearch(query);
-  if (search === void 0) {
-    return createFindResult(
-      query,
-      [],
-      { ...options, match: "all" },
-      [],
-      "exact"
-    );
-  }
-  const hits = [];
-  hits.push(...findMeta(await document.readBookMeta(), search));
-  hits.push(...await findChapters(document, search));
-  hits.push(...await findNodes(document, search));
-  return createFindResult(
-    query,
-    hits,
-    { ...options, match: "all" },
-    [query.trim().toLowerCase()],
-    "exact"
-  );
-}
-async function findArchiveObjectsIndexed(document, query, options) {
-  if (!await isArchiveSearchIndexCurrent(document)) {
-    throw new Error(
-      "Wiki Graph search index is missing or outdated. Run `<archive-uri>/index enable` before searching."
-    );
-  }
-  const result = await querySearchIndex(document, query, {
-    ...options.chapters === void 0 ? {} : { chapters: options.chapters },
-    ...options.match === void 0 ? {} : { match: options.match },
-    ...createSearchIndexQueryLimitOptions(options),
-    types: options.types ?? null
-  });
-  return result === void 0 ? void 0 : {
-    hits: await hydrateSearchIndexHits(
-      document,
-      result,
-      createSearchIndexHydrationOptions(options)
-    ),
-    result
-  };
-}
-async function queryRequiredSearchIndex(document, query, options) {
-  if (!await isArchiveSearchIndexCurrent(document)) {
-    throw new Error(
-      "Wiki Graph search index is missing or outdated. Run `<archive-uri>/index enable` before searching."
-    );
-  }
-  return await querySearchIndex(document, query, options);
-}
-async function hydrateSearchIndexHits(document, result, options = {}) {
-  const chapters = new Map(
-    (await listChapters(document)).map((chapter) => [
-      chapter.chapterId,
-      chapter
-    ])
-  );
-  const hits = [];
-  for (const hit of result.objectHits) {
-    const hydrated = await hydrateSearchObjectHit(document, chapters, hit);
-    if (hydrated !== void 0) {
-      hits.push(withSearchTerms(hydrated, result.terms));
-    }
-  }
-  const textHits = options.textHitLimit === void 0 ? result.textHits : result.textHits.slice(0, options.textHitLimit);
-  for (const hit of textHits) {
-    const hydrated = await hydrateSearchTextHit(document, chapters, hit);
-    if (hydrated !== void 0) {
-      hits.push(withSearchTerms(hydrated, result.terms));
-    }
-  }
-  return hits;
-}
-function createSearchIndexHydrationOptions(options) {
-  if (!isTextOnlySearch(options) || options.limit === void 0) {
-    return {};
-  }
-  return { textHitLimit: createTextOnlySearchCacheWindow(options.limit) };
-}
-function createSearchIndexQueryLimitOptions(options) {
-  if (!isTextOnlySearch(options) || options.limit === void 0) {
-    return {};
-  }
-  return { textHitLimit: createTextOnlySearchCacheWindow(options.limit) };
-}
-function createTextOnlySearchCacheWindow(limit) {
-  return Math.max(limit + 1, TEXT_ONLY_SEARCH_CACHE_WINDOW);
-}
-function isTextOnlySearch(options) {
-  return options.types !== void 0 && options.types.length > 0 && options.types.every((type) => type === "source" || type === "summary");
-}
-function withSearchTerms(hit, terms) {
-  return {
-    ...hit,
-    matchCount: terms.length,
-    matchedTerms: terms,
-    missingTerms: []
-  };
-}
-async function hydrateSearchObjectHit(document, chapters, hit) {
-  switch (hit.ownerKind) {
-    case SEARCH_OBJECT_PROPERTY_OWNER_KIND.chapter: {
-      const chapterId = parseSearchPropertyIntegerOwnerId(hit.ownerId);
-      const chapter = chapters.get(chapterId);
-      if (chapter === void 0) {
-        return void 0;
-      }
-      const title = chapter.title ?? `[chapter ${chapter.chapterId}]`;
-      return {
-        chapter: chapter.chapterId,
-        field: "title",
-        id: formatChapterTitleId(chapter.chapterId),
-        matchCount: 1,
-        position: { chapter: chapter.chapterId },
-        score: hit.score,
-        snippet: title,
-        title,
-        type: "chapter-title"
-      };
-    }
-    case SEARCH_OBJECT_PROPERTY_OWNER_KIND.chunk: {
-      const chunkId = parseSearchPropertyIntegerOwnerId(hit.ownerId);
-      const node = await document.chunks.getById(chunkId);
-      if (node === void 0) {
-        return void 0;
-      }
-      const position = createNodePosition(node.sentenceIds);
-      const isLabel = hit.propertyKind === SEARCH_OBJECT_PROPERTY_KIND.label;
-      return {
-        chapter: node.sentenceId[0],
-        field: isLabel ? "title" : "content",
-        id: formatNodeId(node.id),
-        matchCount: 1,
-        ...position === void 0 ? {} : { position },
-        score: hit.score,
-        snippet: isLabel ? node.label : createSnippet(node.content),
-        title: node.label,
-        type: "node"
-      };
-    }
-    case SEARCH_OBJECT_PROPERTY_OWNER_KIND.entity:
-      return void 0;
-  }
-}
-function parseSearchPropertyIntegerOwnerId(ownerId) {
-  const value = Number(ownerId);
-  if (!Number.isSafeInteger(value)) {
-    throw new Error(`Invalid search property owner id: ${ownerId}`);
-  }
-  return value;
-}
-async function hydrateSearchTextHit(document, chapters, hit) {
-  const stream = hit.kind === TEXT_SENTENCE_KIND.source ? "source" : "summary";
-  const chapter = chapters.get(hit.chapterId);
-  if (chapter === void 0) {
-    return void 0;
-  }
-  const range = await readTextStreamRange(
-    document,
-    hit.chapterId,
-    stream,
-    hit.sentenceIndex,
-    hit.sentenceIndex
-  );
-  return {
-    chapter: hit.chapterId,
-    field: stream,
-    id: range.id,
-    matchCount: 1,
-    position: {
-      chapter: hit.chapterId,
-      sentence: hit.sentenceIndex
-    },
-    score: hit.score,
-    snippet: createSnippet(range.text),
-    title: chapter.title ?? `[chapter ${hit.chapterId}]`,
-    type: stream
-  };
-}
-async function createSearchIndexRecords(document, progress) {
-  const objectProperties = [];
-  const textSentences = [];
-  const chapters = await listChapters(document);
-  let chapterDone = 0;
-  for (const chapter of chapters) {
-    const title = chapter.title ?? `[chapter ${chapter.chapterId}]`;
-    objectProperties.push({
-      chapterId: chapter.chapterId,
-      ownerId: String(chapter.chapterId),
-      ownerKind: SEARCH_OBJECT_PROPERTY_OWNER_KIND.chapter,
-      propertyKind: SEARCH_OBJECT_PROPERTY_KIND.title,
-      text: title
-    });
-    textSentences.push(
-      ...await createTextStreamSearchIndexRecords(
-        document,
-        chapter.chapterId,
-        "summary",
-        title
-      )
-    );
-    textSentences.push(
-      ...await createTextStreamSearchIndexRecords(
-        document,
-        chapter.chapterId,
-        "source",
-        title
-      )
-    );
-    chapterDone += 1;
-    await progress?.({
-      done: chapterDone,
-      phase: "collecting",
-      total: chapters.length,
-      unit: "chapter"
-    });
-  }
-  for (const node of await document.chunks.listAll()) {
-    objectProperties.push({
-      chapterId: node.sentenceId[0],
-      ownerId: String(node.id),
-      ownerKind: SEARCH_OBJECT_PROPERTY_OWNER_KIND.chunk,
-      propertyKind: SEARCH_OBJECT_PROPERTY_KIND.label,
-      text: node.label
-    });
-    objectProperties.push({
-      chapterId: node.sentenceId[0],
-      ownerId: String(node.id),
-      ownerKind: SEARCH_OBJECT_PROPERTY_OWNER_KIND.chunk,
-      propertyKind: SEARCH_OBJECT_PROPERTY_KIND.content,
-      text: node.content
-    });
-  }
-  for (const mention of await document.mentions.listAll()) {
-    objectProperties.push({
-      chapterId: mention.chapterId,
-      ownerId: mention.qid,
-      ownerKind: SEARCH_OBJECT_PROPERTY_OWNER_KIND.entity,
-      propertyKind: SEARCH_OBJECT_PROPERTY_KIND.surface,
-      text: mention.surface
-    });
-  }
-  return { objectProperties, textSentences };
-}
-async function createTextStreamSearchIndexRecords(document, chapterId, stream, _title) {
-  const index = await createTextStreamIndex(document, chapterId, stream);
-  return index.sentences.map((sentence) => ({
-    chapterId,
-    kind: stream === "source" ? TEXT_SENTENCE_KIND.source : TEXT_SENTENCE_KIND.summary,
-    sentenceIndex: sentence.globalIndex,
-    text: sentence.text,
-    wordsCount: sentence.wordsCount
-  }));
-}
-async function readArchiveText(document, id) {
-  const reference = parseArchiveReference(id);
-  switch (reference.type) {
-    case "chapter":
-      throw new Error(
-        `Chapter ${formatChapterId(reference.id)} is a scope URI, not a readable object.`
-      );
-    case "chapter-title": {
-      const chapter = await requireChapter(document, reference.id);
-      return chapter.title ?? `[chapter ${reference.id}]`;
-    }
-    case "fragment":
-      return (await readSourceFragment(
-        document,
-        reference.serialId,
-        reference.fragmentId
-      )).text;
-    case "summary": {
-      const summary = await readTextStreamText(
-        document,
-        reference.id,
-        "summary"
-      );
-      if (summary.trim() === "") {
-        throw new Error(`Summary ${formatSummaryId(reference.id)} is missing.`);
-      }
-      return summary;
-    }
-    case "node": {
-      const { node } = await requireNode(document, reference.id);
-      return node.content;
-    }
-    case "meta": {
-      return formatMetaText(await document.readBookMeta());
-    }
-  }
-}
-async function readArchivePage(document, id, options = {}) {
-  if (isWikiGraphObjectUri(id)) {
-    return await readWikiGraphPage(
-      document,
-      normalizeWikiGraphObjectUri(id),
-      options
-    );
-  }
-  const reference = parseArchiveReference(id);
-  switch (reference.type) {
-    case "chapter": {
-      throw new Error(
-        `Chapter ${formatChapterId(reference.id)} is a scope URI, not a readable object. Use wikg://chapter/${reference.id}/title or wikg://chapter/${reference.id}/state.`
-      );
-    }
-    case "chapter-title": {
-      const chapter = await requireChapter(document, reference.id);
-      return {
-        id: formatChapterTitleId(reference.id),
-        title: chapter.title ?? `[chapter ${reference.id}]`,
-        type: "chapter-title"
-      };
-    }
-    case "fragment": {
-      const [fragment, relatedNodes, fragmentIds] = await Promise.all([
-        readSourceFragment(document, reference.serialId, reference.fragmentId),
-        listFragmentNodes(document, reference.serialId, reference.fragmentId),
-        document.getSerialFragments(reference.serialId).listFragmentIds()
-      ]);
-      const fragmentIndex = fragmentIds.indexOf(reference.fragmentId);
-      const previousFragmentId = fragmentIndex > 0 ? fragmentIds[fragmentIndex - 1] : void 0;
-      const nextFragmentId = fragmentIndex >= 0 && fragmentIndex < fragmentIds.length - 1 ? fragmentIds[fragmentIndex + 1] : void 0;
-      return {
-        fragment,
-        id: fragment.id,
-        nextFragmentId: nextFragmentId === void 0 ? void 0 : formatFragmentId(reference.serialId, nextFragmentId),
-        nodes: relatedNodes,
-        previousFragmentId: previousFragmentId === void 0 ? void 0 : formatFragmentId(reference.serialId, previousFragmentId),
-        title: fragment.id,
-        type: "fragment"
-      };
-    }
-    case "meta":
-      return {
-        ...createMetaPage(await document.readBookMeta()),
-        id: ARCHIVE_ROOT_ID,
-        type: "meta"
-      };
-    case "node": {
-      const { chapterId, node } = await requireNode(document, reference.id);
-      const [neighbors, sourceFragments] = await Promise.all([
-        listGraphNeighbors(document, chapterId, reference.id),
-        readNodeSourceFragments(document, node)
-      ]);
-      const outgoing = neighbors.filter(
-        (neighbor) => neighbor.direction === "outgoing"
-      );
-      const incoming = neighbors.filter(
-        (neighbor) => neighbor.direction === "incoming"
-      );
-      return {
-        generatedNodeSummary: node.content,
-        id: formatNodeId(node.id),
-        incoming,
-        neighbors,
-        outgoing,
-        position: createNodePosition(node.sentenceIds),
-        sourceFragments,
-        title: node.label,
-        type: "node"
-      };
-    }
-    case "summary": {
-      const chapter = await requireChapter(document, reference.id);
-      const content = await readTextStreamText(
-        document,
-        reference.id,
-        "summary"
-      );
-      if (content.trim() === "") {
-        throw new Error(`Summary ${formatSummaryId(reference.id)} is missing.`);
-      }
-      return {
-        content,
-        id: formatSummaryId(reference.id),
-        title: chapter.title ?? `[chapter ${reference.id}]`,
-        type: "summary"
-      };
-    }
-  }
-}
-async function readWikiGraphPage(document, uri, options = {}) {
-  uri = normalizeWikiGraphObjectUri(uri);
-  const reference = parseWikiGraphReference(uri);
-  switch (reference.type) {
-    case "meta":
-      return await readArchivePage(document, ARCHIVE_ROOT_ID, options);
-    case "chapter":
-      throw new Error(
-        `wikg://chapter/${reference.chapterId} is a scope URI, not a readable object. Use wikg://chapter/${reference.chapterId}/title or wikg://chapter/${reference.chapterId}/state.`
-      );
-    case "chapter-title":
-      return await readArchivePage(
-        document,
-        formatChapterTitleId(reference.chapterId),
-        options
-      );
-    case "chapter-state": {
-      const details = await requireChapter(document, reference.chapterId);
-      const targets = await createChapterState(document, details);
-      return {
-        id: reference.target === void 0 ? `wikg://chapter/${reference.chapterId}/state` : `wikg://chapter/${reference.chapterId}/state/${reference.target}`,
-        ...reference.target === void 0 ? { state: targets } : { target: reference.target, value: targets[reference.target] },
-        type: "state"
-      };
-    }
-    case "chapter-tree":
-      return {
-        id: "chapter-tree",
-        title: "Chapter tree",
-        tree: await getChapterTree(document),
-        type: "chapter-tree"
-      };
-    case "entity": {
-      const mentions = filterMentionsByChapter(
-        await document.mentions.listByQid(reference.qid),
-        reference.chapterId
-      );
-      if (mentions.length === 0) {
-        throw new Error(`Entity ${uri} was not found in this archive.`);
-      }
-      return {
-        evidence: await createMentionEvidencePreview(
-          document,
-          mentions,
-          options.evidenceLimit,
-          createEvidenceReadContext(),
-          options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-          options.order ?? "doc-asc"
-        ),
-        id: uri,
-        label: selectEntityLabel(mentions),
-        labels: selectEntityLabels(mentions),
-        mentionCount: mentions.length,
-        qid: reference.qid,
-        type: "entity"
-      };
-    }
-    case "entity-wikipage":
-      return {
-        ...await resolveEntityWikipage(reference.qid, options),
-        id: uri,
-        type: "entity-wikipage"
-      };
-    case "triple": {
-      const links = await filterMentionLinksByChapter(
-        document,
-        await document.mentionLinks.listByTriple({
-          objectQid: reference.objectQid,
-          predicate: reference.predicate,
-          subjectQid: reference.subjectQid
-        }),
-        reference.chapterId
-      );
-      if (links.length === 0) {
-        throw new Error(`Triple ${uri} was not found in this archive.`);
-      }
-      return {
-        evidence: await createMentionLinkEvidencePreview(
-          document,
-          links,
-          options.evidenceLimit,
-          createEvidenceReadContext(),
-          options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-          options.order ?? "doc-asc"
-        ),
-        id: uri,
-        label: await createTriplePageLabel(document, reference),
-        objectQid: reference.objectQid,
-        predicate: reference.predicate,
-        subjectQid: reference.subjectQid,
-        type: "triple"
-      };
-    }
-    case "chunk": {
-      if (reference.chapterId !== void 0) {
-        const { chapterId } = await requireNode(document, reference.id);
-        if (chapterId !== reference.chapterId) {
-          throw new Error(`Chunk ${uri} was not found in this archive.`);
-        }
-      }
-      return await readArchivePage(
-        document,
-        formatNodeId(reference.id),
-        options
-      );
-    }
-    case "text-stream":
-      return {
-        ...options.backlinks === true ? { backlinks: await createTextStreamBacklinks(document, reference) } : {},
-        fragment: await createTextStreamRangeFragment(document, reference),
-        id: uri,
-        nextFragmentId: void 0,
-        nodes: [],
-        previousFragmentId: void 0,
-        title: uri,
-        type: "fragment"
-      };
-  }
-}
-async function listArchiveLinks(document, id, direction) {
-  return (await listAllArchiveLinks(document, id)).filter(
-    (neighbor) => direction === "links" ? neighbor.direction === "outgoing" : neighbor.direction === "incoming"
-  );
-}
-async function listAllArchiveLinks(document, id) {
-  if (isWikiGraphObjectUri(id)) {
-    id = normalizeWikiGraphObjectUri(id);
-    const reference2 = parseWikiGraphReference(id);
-    if (reference2.type !== "chunk") {
-      return [];
-    }
-    const { chapterId: chapterId2 } = await requireNode(document, reference2.id);
-    if (reference2.chapterId !== void 0 && reference2.chapterId !== chapterId2) {
-      throw new Error(`Chunk ${id} was not found in this archive.`);
-    }
-    return await listGraphNeighbors(document, chapterId2, reference2.id);
-  }
-  const reference = parseArchiveReference(id);
-  if (reference.type !== "node") {
-    return [];
-  }
-  const { chapterId } = await requireNode(document, reference.id);
-  return await listGraphNeighbors(document, chapterId, reference.id);
-}
-async function listRelatedArchiveObjects(document, id, options = {}) {
-  if (isWikiGraphObjectUri(id)) {
-    return await listRelatedWikiGraphObjects(
-      document,
-      normalizeWikiGraphObjectUri(id),
-      options
-    );
-  }
-  const reference = parseArchiveReference(id);
-  if (reference.type !== "node") {
-    rejectRelatedRole(options.role, id);
-    return paginateRelatedItems([], options);
-  }
-  rejectRelatedRole(options.role, id);
-  const documentOrders = await document.serials.listDocumentOrders();
-  const { chapterId } = await requireNode(document, reference.id);
-  const items = sortGraphNeighborsByListMode(
-    await listGraphNeighbors(document, chapterId, reference.id),
-    documentOrders,
-    options.order ?? "doc-asc"
-  ).map((neighbor) => ({
-    id: formatNodeId(neighbor.node.id),
-    label: neighbor.node.label,
-    summary: neighbor.node.content,
-    type: "node"
-  }));
-  return await hydrateRelatedItemsEvidence(
-    document,
-    await filterAndSortChunkRelatedItemsByQuery(document, items, options.query),
-    options
-  );
-}
-async function listRelatedWikiGraphObjects(document, uri, options) {
-  const reference = parseWikiGraphReference(uri);
-  switch (reference.type) {
-    case "chapter": {
-      throw new Error(`Related is not available for scope URI: ${uri}`);
-    }
-    case "chapter-title":
-      rejectRelatedRole(options.role, uri);
-      return paginateRelatedItems([], options);
-    case "chunk": {
-      rejectRelatedRole(options.role, uri);
-      const { chapterId } = await requireNode(document, reference.id);
-      if (reference.chapterId !== void 0 && reference.chapterId !== chapterId) {
-        throw new Error(`Chunk ${uri} was not found in this archive.`);
-      }
-      const items = sortGraphNeighborsByListMode(
-        await listGraphNeighbors(document, chapterId, reference.id),
-        await document.serials.listDocumentOrders(),
-        options.order ?? "doc-asc"
-      ).map((neighbor) => ({
-        id: formatNodeId(neighbor.node.id),
-        label: neighbor.node.label,
-        summary: neighbor.node.content,
-        type: "node"
-      }));
-      return await hydrateRelatedItemsEvidence(
-        document,
-        await filterAndSortChunkRelatedItemsByQuery(
-          document,
-          items,
-          options.query
-        ),
-        options
-      );
-    }
-    case "text-stream": {
-      rejectRelatedQuery(options.query, uri);
-      rejectRelatedRole(options.role, uri);
-      const chapter = await requireChapter(document, reference.chapterId);
-      return await hydrateRelatedItemsEvidence(
-        document,
-        [
-          {
-            id: formatChapterId(reference.chapterId),
-            label: chapter.title ?? `[chapter ${reference.chapterId}]`,
-            summary: `${chapter.stage}; ${chapter.fragmentCount} fragments`,
-            type: "chapter"
-          }
-        ],
-        options
-      );
-    }
-    case "entity":
-      return await listRelatedEntityObjects(document, reference, options);
-    case "triple":
-      throw new Error(
-        `Related is only available for chunk and entity objects: ${uri}`
-      );
-    case "chapter-tree":
-    case "entity-wikipage":
-    case "meta":
-    case "chapter-state":
-      rejectRelatedQuery(options.query, uri);
-      rejectRelatedRole(options.role, uri);
-      return paginateRelatedItems([], options);
-  }
-}
-async function resolveEntityWikipage(qid, options) {
-  const [en, zh] = await Promise.all([
-    resolveEntityWikipageLocale(qid, "en", "enwiki", options),
-    resolveEntityWikipageLocale(qid, "zh", "zhwiki", options)
-  ]);
-  return { en, zh };
-}
-async function resolveEntityWikipageLocale(qid, language, wiki, options) {
-  const resolver = await WikipageResolver.open({
-    ...options.wikipageResolverOptions,
-    language,
-    wiki
-  });
-  try {
-    const [resolution] = await resolver.resolveQids([qid]);
-    if (resolution === void 0) {
-      return null;
-    }
-    return createEntityWikipageLocale(resolution, wiki);
-  } finally {
-    await resolver.close();
-  }
-}
-function createEntityWikipageLocale(resolution, wiki) {
-  const sitelink = resolution.sitelinks?.find((item) => item.wiki === wiki) ?? (resolution.sitelink?.wiki === wiki ? resolution.sitelink : void 0);
-  if (sitelink === void 0) {
-    return null;
-  }
-  return {
-    ...resolution.description === void 0 ? {} : { description: resolution.description },
-    title: sitelink.title,
-    url: formatWikipediaPageUrl(sitelink)
-  };
-}
-function formatWikipediaPageUrl(sitelink) {
-  const language = sitelink.wiki === "zhwiki" ? "zh" : "en";
-  return `https://${language}.wikipedia.org/wiki/${encodeURIComponent(
-    sitelink.title.replace(/ /gu, "_")
-  )}`;
-}
-async function listRelatedEntityObjects(document, reference, options) {
-  const mentions = filterMentionsByChapter(
-    await document.mentions.listByQid(reference.qid),
-    reference.chapterId
-  );
-  if (mentions.length === 0) {
-    throw new Error(
-      `Entity ${formatEntityUri(reference.qid)} was not found in this archive.`
-    );
-  }
-  const chapters = [
-    ...new Set(mentions.map((mention) => mention.chapterId))
-  ].sort(compareNumbers);
-  const role = options.role ?? "any";
-  const triplesById = /* @__PURE__ */ new Map();
-  for (const chapterId of chapters) {
-    for (const link of await document.mentionLinks.listByChapter(chapterId)) {
-      const [source, target] = await Promise.all([
-        document.mentions.getById(link.sourceMentionId),
-        document.mentions.getById(link.targetMentionId)
-      ]);
-      if (source === void 0 || target === void 0) {
-        continue;
-      }
-      if (!matchesRelatedEntityRole(source.qid, target.qid, reference.qid, role)) {
-        continue;
-      }
-      const id = formatTripleUri(source.qid, link.predicate, target.qid);
-      const existing = triplesById.get(id);
-      if (existing !== void 0) {
-        triplesById.set(id, {
-          ...existing,
-          evidenceLinks: [...existing.evidenceLinks ?? [], link]
-        });
-        continue;
-      }
-      triplesById.set(id, {
-        evidenceLinks: [link],
-        id,
-        label: `${source.surface} ${link.predicate} ${target.surface}`,
-        objectLabel: target.surface,
-        objectQid: target.qid,
-        predicate: link.predicate,
-        subjectLabel: source.surface,
-        subjectQid: source.qid,
-        summary: `${source.qid} ${link.predicate} ${target.qid}`,
-        type: "triple"
-      });
-    }
-  }
-  return await hydrateRelatedItemsEvidence(
-    document,
-    await filterAndSortEntityRelatedTriplesByQuery(
-      document,
-      sortRelatedItemsByListMode(
-        [...triplesById.values()],
-        options.order ?? "doc-asc",
-        await document.serials.listDocumentOrders()
-      ),
-      reference.qid,
-      options.query
-    ),
-    options
-  );
-}
-async function filterAndSortChunkRelatedItemsByQuery(document, items, query) {
-  if (query === void 0) {
-    return items;
-  }
-  const indexResult = await queryRequiredSearchIndex(document, query, {
-    types: ["node"]
-  });
-  if (indexResult === void 0) {
-    return [];
-  }
-  const scoresByChunkId = /* @__PURE__ */ new Map();
-  const allowedChunkIds = new Set(
-    items.flatMap((item) => {
-      if (item.type !== "node") {
-        return [];
-      }
-      const reference = parseArchiveReference(item.id);
-      return reference.type === "node" ? [reference.id] : [];
-    })
-  );
-  for (const hit of indexResult.objectHits) {
-    if (hit.ownerKind !== SEARCH_OBJECT_PROPERTY_OWNER_KIND.chunk || !allowedChunkIds.has(Number(hit.ownerId))) {
-      continue;
-    }
-    const chunkId = Number(hit.ownerId);
-    const scores = scoresByChunkId.get(chunkId) ?? [];
-    scores.push(hit.score);
-    scoresByChunkId.set(chunkId, scores);
-  }
-  return items.flatMap((item) => {
-    if (item.type !== "node") {
-      return [];
-    }
-    const reference = parseArchiveReference(item.id);
-    if (reference.type !== "node") {
-      return [];
-    }
-    const scores = scoresByChunkId.get(reference.id);
-    return scores === void 0 ? [] : [{ ...item, score: aggregateEvidenceScores(scores) }];
-  }).sort(compareRelatedQueryItems);
-}
-async function filterAndSortEntityRelatedTriplesByQuery(document, items, anchorQid, query) {
-  if (query === void 0) {
-    return items;
-  }
-  const scope = await createEntityRelatedQueryScope(document, items, anchorQid);
-  const indexResult = await queryRequiredSearchIndex(document, query, {
-    chapters: [...scope.chapterIds],
-    types: ["entity", "source"]
-  });
-  if (indexResult === void 0) {
-    return [];
-  }
-  const sentenceScores = new Map(
-    indexResult.textHits.filter((hit) => hit.kind === TEXT_SENTENCE_KIND.source).map(
-      (hit) => [
-        createSentenceHitKey(hit.chapterId, hit.sentenceIndex),
-        hit.score
-      ]
-    )
-  );
-  const endpointScoresByKey = /* @__PURE__ */ new Map();
-  for (const hit of indexResult.objectHits) {
-    if (hit.ownerKind !== SEARCH_OBJECT_PROPERTY_OWNER_KIND.entity || hit.ownerId === anchorQid || hit.chapterId === void 0) {
-      continue;
-    }
-    const key = createEntityRelatedEndpointKey(hit.ownerId, hit.chapterId);
-    const scores = endpointScoresByKey.get(key) ?? [];
-    scores.push(hit.score);
-    endpointScoresByKey.set(key, scores);
-  }
-  return items.flatMap((item) => {
-    if (item.type !== "triple") {
-      return [];
-    }
-    const scores = [
-      ...[...scope.endpointKeysByTripleId.get(item.id) ?? []].flatMap(
-        (key) => endpointScoresByKey.get(key) ?? []
-      ),
-      ...(item.evidenceLinks ?? []).flatMap(
-        (link) => link.evidenceSentenceIds.flatMap(([chapterId, sentenceIndex]) => {
-          const score = sentenceScores.get(
-            createSentenceHitKey(chapterId, sentenceIndex)
-          );
-          return score === void 0 ? [] : [score];
-        })
-      )
-    ];
-    return scores.length === 0 ? [] : [{ ...item, score: aggregateEvidenceScores(scores) }];
-  }).sort(compareRelatedQueryItems);
-}
-async function createEntityRelatedQueryScope(document, items, anchorQid) {
-  const chapterIds = /* @__PURE__ */ new Set();
-  const endpointKeysByTripleId = /* @__PURE__ */ new Map();
-  const mentionCache = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    if (item.type !== "triple") {
-      continue;
-    }
-    const endpointKeys = /* @__PURE__ */ new Set();
-    for (const link of item.evidenceLinks ?? []) {
-      for (const [chapterId] of link.evidenceSentenceIds) {
-        chapterIds.add(chapterId);
-      }
-      const [source, target] = await Promise.all([
-        getCachedMention(document, mentionCache, link.sourceMentionId),
-        getCachedMention(document, mentionCache, link.targetMentionId)
-      ]);
-      for (const mention of [source, target]) {
-        if (mention === void 0 || mention.qid === anchorQid) {
-          continue;
-        }
-        chapterIds.add(mention.chapterId);
-        endpointKeys.add(
-          createEntityRelatedEndpointKey(mention.qid, mention.chapterId)
-        );
-      }
-    }
-    endpointKeysByTripleId.set(item.id, endpointKeys);
-  }
-  return { chapterIds, endpointKeysByTripleId };
-}
-async function getCachedMention(document, cache, mentionId) {
-  if (!cache.has(mentionId)) {
-    cache.set(mentionId, await document.mentions.getById(mentionId));
-  }
-  return cache.get(mentionId);
-}
-function createEntityRelatedEndpointKey(qid, chapterId) {
-  return `${qid}:${chapterId}`;
-}
-function compareRelatedQueryItems(left, right) {
-  const scoreComparison = (right.score ?? 0) - (left.score ?? 0);
-  if (scoreComparison !== 0) {
-    return scoreComparison;
-  }
-  return compareListHits(
-    createFindHitFromListItem(left),
-    createFindHitFromListItem(right),
-    "doc-asc"
-  );
-}
-function sortRelatedItemsByListMode(items, order = "doc-asc", documentOrders) {
-  return [...items].sort(
-    (left, right) => compareListHits(
-      createFindHitFromListItem(left, documentOrders),
-      createFindHitFromListItem(right, documentOrders),
-      order
-    )
-  );
-}
-function sortGraphNeighborsByListMode(neighbors, documentOrders, order) {
-  const direction = order === "doc-asc" ? 1 : -1;
-  return [...neighbors].sort(
-    (left, right) => compareSentenceIds(
-      getFirstGraphNodeSentenceId(left.node),
-      getFirstGraphNodeSentenceId(right.node),
-      documentOrders
-    ) * direction
-  );
-}
-function createFindHitFromListItem(item, documentOrders) {
-  const position = createListItemPosition(item, documentOrders);
-  const score = item.type === "triple" ? item.evidenceLinks?.length ?? 0 : void 0;
-  return {
-    field: "title",
-    id: item.id,
-    ...position === void 0 ? {} : { position },
-    ...score === void 0 ? {} : { score },
-    snippet: item.summary,
-    title: item.label,
-    type: toFindObjectType(item.type)
-  };
-}
-function toFindObjectType(type) {
-  switch (type) {
-    case "edge":
-    case "state":
-      return "meta";
-    default:
-      return type;
-  }
-}
-function createListItemPosition(item, documentOrders) {
-  if (item.type === "triple") {
-    return createFirstMentionLinkPosition(
-      item.evidenceLinks ?? [],
-      documentOrders
-    );
-  }
-  return void 0;
-}
-function createFirstMentionLinkPosition(links, documentOrders) {
-  const sentenceIds = links.flatMap((link) => link.evidenceSentenceIds);
-  const [first] = sentenceIds.sort(
-    (left, right) => compareSentenceIds(left, right, documentOrders)
-  );
-  return first === void 0 ? void 0 : createSentencePosition(first, documentOrders);
-}
-function getFirstGraphNodeSentenceId(node) {
-  return [...node.sentenceIds].sort(compareSentenceIds)[0] ?? [
-    Number.MAX_SAFE_INTEGER,
-    Number.MAX_SAFE_INTEGER
-  ];
-}
-function matchesRelatedEntityRole(subjectQid, objectQid, qid, role) {
-  const isSubject = subjectQid === qid;
-  const isObject = objectQid === qid;
-  const isSelf = isSubject && isObject;
-  switch (role) {
-    case "any":
-      return isSubject || isObject;
-    case "subject":
-      return isSubject && !isSelf;
-    case "object":
-      return isObject && !isSelf;
-    case "self":
-      return isSelf;
-  }
-}
-function rejectRelatedRole(role, id) {
-  if (role !== void 0 && role !== "any") {
-    throw new Error(`--role is only available for entity related: ${id}`);
-  }
-}
-function rejectRelatedQuery(query, id) {
-  if (query !== void 0) {
-    throw new Error(
-      `Related query is only available for chunk and entity: ${id}`
-    );
-  }
-}
-async function hydrateRelatedItemsEvidence(document, items, options) {
-  const page = paginateRelatedItems(items, options);
-  if (options.evidenceLimit === void 0) {
-    return {
-      ...page,
-      items: page.items.map((item) => {
-        if (item.type !== "triple") {
-          return item;
-        }
-        const { evidenceLinks: _evidenceLinks, ...publicItem } = item;
-        return publicItem;
-      })
-    };
-  }
-  const context = createEvidenceReadContext();
-  const evidenceLimit = options.evidenceLimit;
-  return {
-    ...page,
-    items: await Promise.all(
-      page.items.map(async (item) => {
-        if (item.evidence !== void 0) {
-          return item;
-        }
-        if (item.type === "triple") {
-          const evidence = await createMentionLinkEvidencePreview(
-            document,
-            item.evidenceLinks ?? [],
-            evidenceLimit,
-            context,
-            options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-            options.order ?? "doc-asc"
-          );
-          const { evidenceLinks: _evidenceLinks, ...publicItem } = item;
-          return { ...publicItem, evidence };
-        }
-        if (item.type === "node") {
-          const reference = parseArchiveReference(item.id);
-          if (reference.type !== "node") {
-            return item;
-          }
-          const { node } = await requireNode(document, reference.id);
-          return {
-            ...item,
-            evidence: await createSourceEvidencePreview(
-              document,
-              createNodeEvidenceRanges(node),
-              evidenceLimit,
-              context,
-              options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-              options.order ?? "doc-asc"
-            )
-          };
-        }
-        return item;
-      })
-    )
-  };
-}
-function paginateRelatedItems(items, options) {
-  const limit = options.limit ?? 20;
-  const offset = parseRelatedCursor(options.cursor);
-  const pageItems = items.slice(offset, offset + limit);
-  const nextOffset = offset + pageItems.length;
-  return {
-    items: pageItems,
-    limit,
-    nextCursor: nextOffset >= items.length ? null : String(nextOffset)
-  };
-}
-function parseRelatedCursor(cursor) {
-  if (cursor === void 0) {
-    return 0;
-  }
-  if (!/^(0|[1-9][0-9]*)$/u.test(cursor)) {
-    throw new Error(`Invalid related cursor: ${cursor}`);
-  }
-  return Number(cursor);
-}
-async function listArchiveEvidence(document, uri, options = {}) {
-  const reference = parseWikiGraphReference(uri);
-  switch (reference.type) {
-    case "chapter":
-    case "chapter-title":
-    case "chapter-state":
-    case "chapter-tree":
-    case "entity-wikipage":
-    case "meta":
-    case "text-stream":
-      throw new Error(`Evidence is not available for ${uri}.`);
-    case "chunk": {
-      const { chapterId, node } = await requireNode(document, reference.id);
-      if (reference.chapterId !== void 0 && reference.chapterId !== chapterId) {
-        throw new Error(`Chunk ${uri} was not found in this archive.`);
-      }
-      return await createSourceEvidencePage(
-        document,
-        createNodeEvidenceRanges(node),
-        options
-      );
-    }
-    case "entity":
-      return await createSourceEvidencePage(
-        document,
-        await createMentionEvidenceRanges(
-          document,
-          filterMentionsByChapter(
-            await document.mentions.listByQid(reference.qid),
-            reference.chapterId
-          )
-        ),
-        options
-      );
-    case "triple":
-      return await createSourceEvidencePage(
-        document,
-        createMentionLinkEvidenceRanges(
-          document,
-          await filterMentionLinksByChapter(
-            document,
-            await document.mentionLinks.listByTriple({
-              objectQid: reference.objectQid,
-              predicate: reference.predicate,
-              subjectQid: reference.subjectQid
-            }),
-            reference.chapterId
-          )
-        ),
-        options
-      );
-  }
-}
-async function packArchiveContext(document, id, budget) {
-  validatePackReference(id);
-  const [anchor, related] = await Promise.all([
-    readArchivePage(document, id, { evidenceLimit: 3 }),
-    listRelatedArchiveObjects(document, id, { evidenceLimit: 3 })
-  ]);
-  return {
-    anchor,
-    budget,
-    related: related.items
-  };
-}
-function validatePackReference(id) {
-  const reference = parseWikiGraphReference(id);
-  switch (reference.type) {
-    case "chunk":
-    case "entity":
-      return;
-    case "chapter":
-    case "chapter-title":
-    case "chapter-state":
-    case "chapter-tree":
-    case "entity-wikipage":
-    case "meta":
-    case "text-stream":
-      throw new Error(
-        `Pack is only available for chunk and entity objects: ${id}`
-      );
-  }
-}
-function formatChapterId(chapterId) {
-  return `chapter:${chapterId}`;
-}
-function formatChapterTitleId(chapterId) {
-  return `chapter-title:${chapterId}`;
-}
-function formatEdgeId(edge) {
-  return `edge:${edge.fromId}->${edge.toId}`;
-}
-function formatNodeId(nodeId) {
-  return `node:${nodeId}`;
-}
-function formatSummaryId(chapterId) {
-  return `summary:${chapterId}`;
-}
-function formatFragmentId(serialId, fragmentId) {
-  return `fragment:${serialId}:${fragmentId}`;
-}
-function findEntities(search, context) {
-  const candidatesByQid = /* @__PURE__ */ new Map();
-  for (const { match, mention } of createMentionLexicalHits(
-    context.mentions,
-    search
-  )) {
-    const candidates = candidatesByQid.get(mention.qid) ?? [];
-    candidates.push({
-      hit: {
-        chapter: mention.chapterId,
-        field: "title",
-        id: `wikg://entity/${mention.qid}`,
-        ...createFindMatchFields(match),
-        position: {
-          chapter: mention.chapterId,
-          sentence: mention.sentenceIndex ?? 0
-        },
-        snippet: mention.note ?? mention.surface,
-        title: mention.surface,
-        type: "entity"
-      },
-      mention
-    });
-    candidatesByQid.set(mention.qid, candidates);
-  }
-  return [...candidatesByQid.values()].map((candidates) => {
-    const rankedCandidates = [...candidates].sort((left, right) => {
-      const scoreComparison = (right.hit.score ?? 0) - (left.hit.score ?? 0);
-      if (scoreComparison !== 0) {
-        return scoreComparison;
-      }
-      if (left.hit.position === void 0) {
-        return right.hit.position === void 0 ? 0 : 1;
-      }
-      if (right.hit.position === void 0) {
-        return -1;
-      }
-      return compareArchivePositions(left.hit.position, right.hit.position);
-    });
-    const [best] = rankedCandidates;
-    if (best === void 0) {
-      throw new Error("Internal error: entity search candidate is empty.");
-    }
-    return {
-      ...best.hit,
-      score: aggregateEvidenceScores(
-        rankedCandidates.map((candidate) => candidate.hit.score ?? 0)
-      ),
-      evidenceMentions: rankedCandidates.map((candidate) => ({
-        match: {
-          matchCount: candidate.hit.matchCount ?? 0,
-          matchedTerms: candidate.hit.matchedTerms ?? [],
-          missingTerms: candidate.hit.missingTerms ?? [],
-          score: candidate.hit.score ?? 0
-        },
-        mention: candidate.mention
-      }))
-    };
-  });
-}
-async function findTriples(document, search, context) {
-  const mentionsById = new Map(
-    context.mentions.map((mention) => [mention.id, mention])
-  );
-  const hitsByTriple = /* @__PURE__ */ new Map();
-  for (const chapter of await listChapters(document)) {
-    for (const link of await document.mentionLinks.listByChapter(
-      chapter.chapterId
-    )) {
-      const [source, target] = await Promise.all([
-        getMentionForTripleSearch(document, mentionsById, link.sourceMentionId),
-        getMentionForTripleSearch(document, mentionsById, link.targetMentionId)
-      ]);
-      if (source === void 0 || target === void 0) {
-        continue;
-      }
-      const text = `${source.surface} ${link.predicate} ${target.surface}`;
-      const match = scoreLexicalText(text, search);
-      if (match === void 0) {
-        continue;
-      }
-      const id = formatTripleUri(source.qid, link.predicate, target.qid);
-      const next = {
-        chapter: source.chapterId,
-        evidenceLinks: [link],
-        field: "content",
-        id,
-        ...createFindMatchFields(match),
-        position: {
-          chapter: source.chapterId,
-          sentence: source.sentenceIndex ?? 0
-        },
-        snippet: link.note ?? text,
-        title: text,
-        triple: {
-          objectLabel: target.surface,
-          predicate: link.predicate,
-          subjectLabel: source.surface
-        },
-        type: "triple"
-      };
-      const values = hitsByTriple.get(id) ?? [];
-      values.push(next);
-      hitsByTriple.set(id, values);
-    }
-  }
-  return [...hitsByTriple.values()].map(groupTripleEvidenceHits);
-}
-async function listAllMentions(document) {
-  return await document.mentions.listAll();
-}
-function groupTripleEvidenceHits(evidenceHits) {
-  const rankedHits = [...evidenceHits].sort(compareFindEvidenceHits);
-  const [best] = rankedHits;
-  if (best === void 0) {
-    throw new Error("Internal error: triple search candidate is empty.");
-  }
-  return {
-    ...best,
-    evidenceLinks: rankedHits.flatMap((hit) => hit.evidenceLinks ?? []),
-    score: aggregateEvidenceScores(rankedHits.map((hit) => hit.score ?? 0))
-  };
-}
-function listEntityCollection(mentions, documentOrders) {
-  const mentionsByQid = /* @__PURE__ */ new Map();
-  for (const mention of mentions) {
-    const values = mentionsByQid.get(mention.qid) ?? [];
-    values.push(mention);
-    mentionsByQid.set(mention.qid, values);
-  }
-  return [...mentionsByQid.entries()].map(([qid, qidMentions]) => {
-    const [first] = qidMentions.sort(compareMentions);
-    if (first === void 0) {
-      throw new Error("Internal error: entity collection candidate is empty.");
-    }
-    return {
-      chapter: first.chapterId,
-      evidenceMentions: qidMentions.map(
-        (mention) => createUnscoredEntityEvidenceMention(mention)
-      ),
-      field: "title",
-      id: `wikg://entity/${qid}`,
-      position: {
-        chapter: first.chapterId,
-        documentOrder: documentOrders?.get(first.chapterId) ?? first.chapterId,
-        sentence: first.sentenceIndex ?? 0
-      },
-      score: qidMentions.length,
-      snippet: `${qidMentions.length} mentions`,
-      title: selectEntityLabel(qidMentions),
-      type: "entity"
-    };
-  });
-}
-function listTextStreamSentenceCollection(index, chapterId, stream, title, documentOrder) {
-  return index.sentences.map((sentence) => ({
-    chapter: chapterId,
-    field: stream,
-    id: formatTextStreamRangeUri(
-      chapterId,
-      stream,
-      sentence.globalIndex,
-      sentence.globalIndex
-    ),
-    position: {
-      chapter: chapterId,
-      documentOrder: documentOrder ?? chapterId,
-      fragment: sentence.fragmentId,
-      sentence: sentence.localIndex
-    },
-    snippet: createSnippet(sentence.text),
-    title,
-    type: stream === "source" ? "source" : "summary"
-  }));
-}
-async function listTripleCollection(document, chapterFilter, documentOrders) {
-  const hitsById = /* @__PURE__ */ new Map();
-  for (const chapter of filterChapters(
-    await listChapters(document),
-    chapterFilter
-  )) {
-    for (const link of await document.mentionLinks.listByChapter(
-      chapter.chapterId
-    )) {
-      const [source, target] = await Promise.all([
-        document.mentions.getById(link.sourceMentionId),
-        document.mentions.getById(link.targetMentionId)
-      ]);
-      if (source === void 0 || target === void 0) {
-        continue;
-      }
-      const id = formatTripleUri(source.qid, link.predicate, target.qid);
-      const existing = hitsById.get(id);
-      if (existing !== void 0) {
-        hitsById.set(id, {
-          ...existing,
-          evidenceLinks: [...existing.evidenceLinks ?? [], link],
-          score: (existing.evidenceLinks?.length ?? 0) + 1
-        });
-        continue;
-      }
-      hitsById.set(id, {
-        chapter: source.chapterId,
-        evidenceLinks: [link],
-        field: "title",
-        id,
-        position: {
-          chapter: source.chapterId,
-          documentOrder: documentOrders?.get(source.chapterId) ?? source.chapterId,
-          sentence: source.sentenceIndex ?? 0
-        },
-        score: 1,
-        snippet: `${source.surface} ${link.predicate} ${target.surface}`,
-        title: `${source.qid} ${link.predicate} ${target.qid}`,
-        triple: {
-          objectLabel: target.surface,
-          predicate: link.predicate,
-          subjectLabel: source.surface
-        },
-        type: "triple"
-      });
-    }
-  }
-  return [...hitsById.values()];
-}
-function compareMentions(left, right) {
-  return compareNumbers(left.chapterId, right.chapterId) || compareNumbers(left.sentenceIndex ?? 0, right.sentenceIndex ?? 0) || left.id.localeCompare(right.id);
-}
-async function getMentionForTripleSearch(document, cache, mentionId) {
-  const cached = cache.get(mentionId);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const mention = await document.mentions.getById(mentionId);
-  if (mention !== void 0) {
-    cache.set(mentionId, mention);
-  }
-  return mention;
-}
-async function hydrateFindHitEvidence(document, hits, options = {}) {
-  const evidenceContext = createEvidenceReadContext();
-  const hydrated = await Promise.all(
-    hits.map(async (rawHit) => {
-      const displayHit = await hydrateEntityDisplayHit(document, rawHit);
-      const hit = await hydrateTextStreamHitContext(
-        document,
-        displayHit,
-        options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-        evidenceContext
-      );
-      if (hit.evidence !== void 0 && hit.evidence.sources.length > 0) {
-        return hit;
-      }
-      if (hit.evidence !== void 0 && hit.type === "entity" && options.sessionId !== void 0) {
-        return await hydrateEntitySessionHitEvidence(
-          document,
-          hit,
-          options.sessionId,
-          options.evidenceLimit,
-          options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-          evidenceContext
-        );
-      }
-      if (hit.evidenceLinks !== void 0) {
-        if (options.evidenceLimit === void 0) {
-          const { evidenceLinks: _evidenceLinks2, ...publicHit3 } = hit;
-          return publicHit3;
-        }
-        const evidence2 = await createMentionLinkEvidencePreview(
-          document,
-          hit.evidenceLinks,
-          options.evidenceLimit,
-          evidenceContext,
-          options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-          options.order ?? "doc-asc"
-        );
-        const { evidenceLinks: _evidenceLinks, ...publicHit2 } = hit;
-        return {
-          ...publicHit2,
-          evidence: evidence2
-        };
-      }
-      if (hit.evidenceMentions === void 0) {
-        return hit;
-      }
-      if (options.evidenceLimit === void 0) {
-        const { evidenceMentions: _evidenceMentions2, ...publicHit2 } = hit;
-        return publicHit2;
-      }
-      const evidence = await createMentionEvidencePreview(
-        document,
-        hit.evidenceMentions.map((item) => item.mention),
-        options.evidenceLimit,
-        evidenceContext,
-        options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-        options.order ?? "doc-asc"
-      );
-      const { evidenceMentions: _evidenceMentions, ...publicHit } = hit;
-      return {
-        ...publicHit,
-        evidence
-      };
-    })
-  );
-  return await coalesceTextStreamFindHits(document, hydrated, evidenceContext);
-}
-async function hydrateEntityDisplayHit(document, hit) {
-  if (hit.type !== "entity") {
-    return hit;
-  }
-  const qid = parseEntityQid(hit.id);
-  if (qid === void 0) {
-    return hit;
-  }
-  if (hit.title !== qid && hit.snippet !== qid) {
-    return hit;
-  }
-  const mentions = await document.mentions.listByQid(qid);
-  const [first] = mentions.sort(compareMentions);
-  if (first === void 0) {
-    return hit;
-  }
-  return {
-    ...hit,
-    chapter: first.chapterId,
-    position: {
-      chapter: first.chapterId,
-      sentence: first.sentenceIndex ?? 0
-    },
-    snippet: hit.snippet === qid ? first.note ?? first.surface : hit.snippet,
-    title: hit.title === qid ? selectEntityLabel(mentions) : hit.title
-  };
-}
-async function hydrateTextStreamHitContext(document, hit, sourceContext, context) {
-  if (sourceContext <= 0 || hit.type !== "source" && hit.type !== "summary") {
-    return hit;
-  }
-  if (hit.matchCount === void 0 && hit.matchedTerms === void 0) {
-    return hit;
-  }
-  const reference = parseTextStreamHitReference(hit.id);
-  if (reference === void 0) {
-    return hit;
-  }
-  const range = await readTextStreamRange(
-    document,
-    reference.chapterId,
-    reference.stream,
-    reference.startSentenceIndex - sourceContext,
-    reference.endSentenceIndex + sourceContext,
-    context
-  );
-  return {
-    ...hit,
-    id: range.id,
-    snippet: range.text
-  };
-}
-function parseTextStreamHitReference(uri) {
-  if (!isWikiGraphObjectUri(uri)) {
-    return void 0;
-  }
-  try {
-    const reference = parseWikiGraphReference(normalizeWikiGraphObjectUri(uri));
-    return reference.type === "text-stream" ? reference : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function coalesceTextStreamFindHits(document, hits, context) {
-  const entries = [];
-  for (const hit of hits) {
-    const range = parseSearchTextStreamHitRange(hit);
-    if (range === void 0 || hit.backlinks !== void 0) {
-      entries.push({ hit, type: "hit" });
-      continue;
-    }
-    const overlappingIndexes = entries.map(
-      (entry, index) => entry.type === "range" && areMergeableTextStreamHitRanges(entry.range, range) ? index : -1
-    ).filter((index) => index >= 0);
-    if (overlappingIndexes.length === 0) {
-      entries.push({ range, type: "range" });
-      continue;
-    }
-    const firstIndex = overlappingIndexes[0] ?? 0;
-    const ranges = overlappingIndexes.flatMap((index) => {
-      const entry = entries[index];
-      return entry?.type === "range" ? [entry.range] : [];
-    });
-    entries[firstIndex] = {
-      range: await mergeTextStreamHitRangeGroup(
-        document,
-        [...ranges, range],
-        context
-      ),
-      type: "range"
-    };
-    for (const index of overlappingIndexes.slice(1).reverse()) {
-      entries.splice(index, 1);
-    }
-  }
-  return entries.map(
-    (entry) => entry.type === "range" ? entry.range.hit : entry.hit
-  );
-}
-function parseSearchTextStreamHitRange(hit) {
-  if (hit.type !== "source" && hit.type !== "summary") {
-    return void 0;
-  }
-  if (hit.matchCount === void 0 && hit.matchedTerms === void 0) {
-    return void 0;
-  }
-  const reference = parseTextStreamHitReference(hit.id);
-  if (reference === void 0) {
-    return void 0;
-  }
-  return {
-    chapterId: reference.chapterId,
-    endSentenceIndex: reference.endSentenceIndex,
-    hit,
-    startSentenceIndex: reference.startSentenceIndex,
-    stream: reference.stream
-  };
-}
-function areMergeableTextStreamHitRanges(left, right) {
-  return left.chapterId === right.chapterId && left.stream === right.stream && right.startSentenceIndex <= left.endSentenceIndex + 1 && left.startSentenceIndex <= right.endSentenceIndex + 1;
-}
-async function mergeTextStreamHitRangeGroup(document, ranges, context) {
-  const [representative] = ranges;
-  if (representative === void 0) {
-    throw new Error(
-      "Internal error: cannot merge empty text stream hit group."
-    );
-  }
-  const startSentenceIndex = Math.min(
-    ...ranges.map((range) => range.startSentenceIndex)
-  );
-  const endSentenceIndex = Math.max(
-    ...ranges.map((range) => range.endSentenceIndex)
-  );
-  const text = await readTextStreamRange(
-    document,
-    representative.chapterId,
-    representative.stream,
-    startSentenceIndex,
-    endSentenceIndex,
-    context
-  );
-  const hits = ranges.map((range) => range.hit);
-  const scores = hits.map((hit) => hit.score).filter((score) => score !== void 0);
-  return {
-    chapterId: representative.chapterId,
-    endSentenceIndex,
-    hit: {
-      ...representative.hit,
-      id: text.id,
-      matchCount: Math.max(...hits.map((hit) => hit.matchCount ?? 0)),
-      matchedTerms: mergeStringLists(
-        hits.flatMap((hit) => hit.matchedTerms ?? [])
-      ),
-      missingTerms: mergeStringLists(
-        hits.flatMap((hit) => hit.missingTerms ?? [])
-      ),
-      ...scores.length === 0 ? {} : { score: Math.max(...scores) },
-      snippet: text.text
-    },
-    startSentenceIndex,
-    stream: representative.stream
-  };
-}
-async function hydrateFindResultBacklinks(document, result, options) {
-  return {
-    ...result,
-    items: await hydrateFindHitBacklinks(document, result.items, options)
-  };
-}
-async function hydrateFindHitBacklinks(document, hits, options) {
-  if (options.backlinks !== true) {
-    return hits;
-  }
-  return await Promise.all(
-    hits.map(async (hit) => {
-      const reference = parseSourceBacklinkReference(hit.id);
-      if (reference === void 0) {
-        return hit;
-      }
-      return {
-        ...hit,
-        backlinks: await createTextStreamBacklinks(document, reference)
-      };
-    })
-  );
-}
-function parseSourceBacklinkReference(uri) {
-  if (!isWikiGraphObjectUri(uri)) {
-    return void 0;
-  }
-  try {
-    const reference = parseWikiGraphReference(normalizeWikiGraphObjectUri(uri));
-    return reference.type === "text-stream" && reference.stream === "source" ? reference : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function createFindEvidenceHydrationOptions(options, sessionId) {
-  return {
-    ...options.evidenceLimit === void 0 ? {} : { evidenceLimit: options.evidenceLimit },
-    order: options.order ?? "doc-asc",
-    ...sessionId === void 0 ? {} : { sessionId },
-    ...options.sourceContext === void 0 ? {} : { sourceContext: options.sourceContext }
-  };
-}
-async function createTextStreamBacklinks(document, reference) {
-  if (reference.stream !== "source") {
-    return createEmptyBacklinks();
-  }
-  const sentenceKeys = await createTextStreamRangeSentenceKeySet(
-    document,
-    reference
-  );
-  const [chunks, mentions, links] = await Promise.all([
-    createChunkBacklinkHits(document, sentenceKeys),
-    createEntityBacklinkHits(document, sentenceKeys),
-    createTripleBacklinkHits(document, reference.chapterId, sentenceKeys)
-  ]);
-  return {
-    chunks: createBacklinkBucket(chunks),
-    entities: createBacklinkBucket(mentions),
-    triples: createBacklinkBucket(links)
-  };
-}
-function createEmptyBacklinks() {
-  return {
-    chunks: createBacklinkBucket([]),
-    entities: createBacklinkBucket([]),
-    triples: createBacklinkBucket([])
-  };
-}
-function createBacklinkBucket(hits) {
-  const sorted = [...hits].sort(
-    (left, right) => compareListHits(left, right, "doc-asc")
-  );
-  return {
-    items: sorted,
-    limit: sorted.length,
-    nextCursor: null
-  };
-}
-async function createTextStreamRangeSentenceKeySet(document, reference) {
-  const index = await createTextStreamIndex(
-    document,
-    reference.chapterId,
-    reference.stream
-  );
-  const lastSentenceIndex = Math.max(0, index.sentences.length - 1);
-  const start = clampInteger(
-    reference.startSentenceIndex,
-    0,
-    lastSentenceIndex
-  );
-  const end = clampInteger(
-    reference.endSentenceIndex,
-    start,
-    lastSentenceIndex
-  );
-  const keys = /* @__PURE__ */ new Set();
-  for (const sentence of index.sentences.slice(start, end + 1)) {
-    keys.add(formatSentenceKey(reference.chapterId, sentence.globalIndex));
-  }
-  return keys;
-}
-async function createChunkBacklinkHits(document, sentenceKeys) {
-  return (await document.chunks.listAll()).filter(
-    (chunk) => chunk.sentenceIds.some(
-      (sentenceId) => sentenceKeys.has(formatSentenceIdKey(sentenceId))
-    )
-  ).map((chunk) => {
-    const position = createNodePosition(chunk.sentenceIds);
-    return {
-      chapter: chunk.sentenceId[0],
-      field: "content",
-      id: formatNodeId(chunk.id),
-      ...position === void 0 ? {} : { position },
-      snippet: createSnippet(chunk.content),
-      title: chunk.label,
-      type: "node"
-    };
-  });
-}
-async function createEntityBacklinkHits(document, sentenceKeys) {
-  return listEntityCollection(
-    (await listAllMentions(document)).filter(
-      (mention) => sentenceKeys.has(
-        formatSentenceKey(mention.chapterId, mention.sentenceIndex ?? 0)
-      )
-    )
-  );
-}
-async function createTripleBacklinkHits(document, chapterId, sentenceKeys) {
-  const hitsById = /* @__PURE__ */ new Map();
-  for (const link of await document.mentionLinks.listByChapter(chapterId)) {
-    const evidenceSentenceIds = link.evidenceSentenceIds.filter(
-      (sentenceId) => sentenceKeys.has(formatSentenceIdKey(sentenceId))
-    );
-    if (evidenceSentenceIds.length === 0) {
-      continue;
-    }
-    const [source, target] = await Promise.all([
-      document.mentions.getById(link.sourceMentionId),
-      document.mentions.getById(link.targetMentionId)
-    ]);
-    if (source === void 0 || target === void 0) {
-      continue;
-    }
-    const id = formatTripleUri(source.qid, link.predicate, target.qid);
-    const existing = hitsById.get(id);
-    const evidenceLink = { ...link, evidenceSentenceIds };
-    if (existing !== void 0) {
-      hitsById.set(id, {
-        ...existing,
-        evidenceLinks: [...existing.evidenceLinks ?? [], evidenceLink],
-        score: (existing.evidenceLinks?.length ?? 0) + 1
-      });
-      continue;
-    }
-    hitsById.set(id, {
-      chapter: source.chapterId,
-      evidenceLinks: [evidenceLink],
-      field: "title",
-      id,
-      position: createSentencePosition(
-        [...evidenceSentenceIds].sort(compareSentenceIds)[0] ?? [
-          source.chapterId,
-          source.sentenceIndex ?? 0
-        ]
-      ),
-      score: 1,
-      snippet: `${source.surface} ${link.predicate} ${target.surface}`,
-      title: `${source.qid} ${link.predicate} ${target.qid}`,
-      triple: {
-        objectLabel: target.surface,
-        predicate: link.predicate,
-        subjectLabel: source.surface
-      },
-      type: "triple"
-    });
-  }
-  return [...hitsById.values()];
-}
-function formatSentenceIdKey(sentenceId) {
-  return formatSentenceKey(sentenceId[0], sentenceId[1]);
-}
-function formatSentenceKey(chapterId, sentenceIndex) {
-  return `${chapterId}:${sentenceIndex}`;
-}
-function createUnscoredEntityEvidenceMention(mention) {
-  return {
-    match: {
-      matchCount: 0,
-      matchedTerms: [],
-      missingTerms: [],
-      score: 0
-    },
-    mention
-  };
-}
-async function hydrateEntitySessionHitEvidence(document, hit, sessionId, evidenceLimit, sourceContext, context = createEvidenceReadContext()) {
-  if (evidenceLimit === void 0) {
-    const { evidence: _evidence, ...publicHit } = hit;
-    return publicHit;
-  }
-  const qid = parseEntityQid(hit.id);
-  if (qid === void 0) {
-    return hit;
-  }
-  const mentionsByQid = await document.mentions.listByQid(qid);
-  const mentionsById = new Map(
-    mentionsByQid.map((mention) => [mention.id, mention])
-  );
-  const allMentions = (await readEntitySearchEvidenceMentions(
-    sessionId,
-    mentionsByQid.map((mention) => mention.id),
-    1e4
-  )).flatMap((hit2) => {
-    const mention = mentionsById.get(hit2.mentionId);
-    return mention === void 0 ? [] : [mention];
-  });
-  const ranges = await createMentionEvidenceRanges(document, allMentions);
-  const mergedRanges = await createExpandedSourceEvidenceRanges(
-    document,
-    ranges,
-    sourceContext,
-    context
-  );
-  const sources = await Promise.all(
-    mergedRanges.slice(0, evidenceLimit).map(
-      async (range) => await createSourceEvidenceItem(
-        document,
-        range.chapterId,
-        range.startSentenceIndex,
-        range.endSentenceIndex,
-        context
-      )
-    )
-  );
-  return {
-    ...hit,
-    ...allMentions[0] === void 0 ? {} : {
-      chapter: allMentions[0].chapterId,
-      position: {
-        chapter: allMentions[0].chapterId,
-        sentence: allMentions[0].sentenceIndex ?? 0
-      },
-      snippet: allMentions[0].note ?? allMentions[0].surface,
-      title: allMentions[0].surface
-    },
-    evidence: {
-      nextCursor: sources.length < mergedRanges.length ? encodeFindCursor(sources.length) : null,
-      shown: sources.length,
-      sources,
-      total: mergedRanges.length
-    }
-  };
-}
-function formatTripleUri(subjectQid, predicate, objectQid) {
-  return `wikg://triple/${subjectQid}/${encodeURIComponent(predicate)}/${objectQid}`;
-}
-function formatEntityUri(qid) {
-  return `wikg://entity/${qid}`;
-}
-function isEntityOnlySearch(options) {
-  return isEntitySearchTypes(options.types ?? null);
-}
-function isEntitySearchTypes(types) {
-  return types !== null && types.length === 1 && types[0] === "entity";
-}
-function assertSearchCursorTypesMatch(requestedTypes, sessionTypes) {
-  if (requestedTypes === void 0) {
-    return;
-  }
-  if (requestedTypes.length !== (sessionTypes?.length ?? 0)) {
-    throw new Error("Search cursor does not match the requested result types.");
-  }
-  const sessionTypeSet = new Set(sessionTypes ?? []);
-  if (requestedTypes.some((type) => !sessionTypeSet.has(type))) {
-    throw new Error("Search cursor does not match the requested result types.");
-  }
-}
-function createEntitySearchCacheInput(hits, indexResult) {
-  const evidenceEvents = [];
-  const evidenceScoresByQid = /* @__PURE__ */ new Map();
-  const propertyScoresByQid = /* @__PURE__ */ new Map();
-  for (const hit of indexResult?.objectHits ?? []) {
-    if (hit.ownerKind !== SEARCH_OBJECT_PROPERTY_OWNER_KIND.entity) {
-      continue;
-    }
-    const scores = propertyScoresByQid.get(hit.ownerId) ?? [];
-    scores.push(hit.score);
-    propertyScoresByQid.set(hit.ownerId, scores);
-  }
-  for (const hit of hits) {
-    if (hit.type !== "entity" || hit.evidenceMentions === void 0) {
-      continue;
-    }
-    const qid = parseEntityQid(hit.id);
-    if (qid === void 0) {
-      continue;
-    }
-    const scores = evidenceScoresByQid.get(qid) ?? [];
-    for (const evidenceMention of hit.evidenceMentions) {
-      const sentenceIndex = evidenceMention.mention.sentenceIndex;
-      if (sentenceIndex === void 0) {
-        continue;
-      }
-      const score = evidenceMention.match.score ?? hit.score ?? 0;
-      evidenceEvents.push({
-        chapterId: evidenceMention.mention.chapterId,
-        evidenceId: evidenceMention.mention.id,
-        evidenceKind: SEARCH_EVIDENCE_KIND.mention,
-        score,
-        sentenceIndex
-      });
-      scores.push(score);
-    }
-    evidenceScoresByQid.set(qid, scores);
-  }
-  const qids = /* @__PURE__ */ new Set([
-    ...evidenceScoresByQid.keys(),
-    ...propertyScoresByQid.keys()
-  ]);
-  return {
-    entityHits: [...qids].map((qid) => ({
-      evidenceTopScores: evidenceScoresByQid.get(qid) ?? [],
-      propertyTopScores: propertyScoresByQid.get(qid) ?? [],
-      qid
-    })),
-    evidenceEvents
-  };
-}
-async function createSentenceEvidenceSearchCacheInput(document, indexResult, options) {
-  if (indexResult === void 0 || isTextOnlySearch(options)) {
-    return {
-      chunkHits: [],
-      entityHits: [],
-      evidenceEvents: [],
-      tripleHits: []
-    };
-  }
-  const sourceHits = indexResult.textHits.filter(
-    (hit) => hit.kind === TEXT_SENTENCE_KIND.source
-  );
-  if (sourceHits.length === 0) {
-    return {
-      chunkHits: [],
-      entityHits: [],
-      evidenceEvents: [],
-      tripleHits: []
-    };
-  }
-  const sourceHitScores = /* @__PURE__ */ new Map();
-  const chapterIds = /* @__PURE__ */ new Set();
-  for (const hit of sourceHits) {
-    sourceHitScores.set(
-      createSentenceHitKey(hit.chapterId, hit.sentenceIndex),
-      hit.score
-    );
-    chapterIds.add(hit.chapterId);
-  }
-  const evidenceEvents = [];
-  const entityEvidenceScoresByQid = /* @__PURE__ */ new Map();
-  const chunkEvidenceScoresById = /* @__PURE__ */ new Map();
-  const tripleEvidenceScoresByKey = /* @__PURE__ */ new Map();
-  for (const chapterId of chapterIds) {
-    for (const mention of await document.mentions.listByChapter(chapterId)) {
-      if (mention.sentenceIndex === void 0) {
-        continue;
-      }
-      const score = sourceHitScores.get(
-        createSentenceHitKey(chapterId, mention.sentenceIndex)
-      );
-      if (score === void 0) {
-        continue;
-      }
-      evidenceEvents.push({
-        chapterId,
-        evidenceId: mention.id,
-        evidenceKind: SEARCH_EVIDENCE_KIND.mention,
-        score,
-        sentenceIndex: mention.sentenceIndex
-      });
-      const scores = entityEvidenceScoresByQid.get(mention.qid) ?? [];
-      scores.push(score);
-      entityEvidenceScoresByQid.set(mention.qid, scores);
-    }
-    for (const chunk of await document.chunks.listBySerial(chapterId)) {
-      for (const [, sentenceIndex] of chunk.sentenceIds) {
-        const score = sourceHitScores.get(
-          createSentenceHitKey(chapterId, sentenceIndex)
-        );
-        if (score === void 0) {
-          continue;
-        }
-        evidenceEvents.push({
-          chapterId,
-          evidenceId: String(chunk.id),
-          evidenceKind: SEARCH_EVIDENCE_KIND.chunk,
-          score,
-          sentenceIndex
-        });
-        const scores = chunkEvidenceScoresById.get(chunk.id) ?? [];
-        scores.push(score);
-        chunkEvidenceScoresById.set(chunk.id, scores);
-      }
-    }
-    const mentionCache = /* @__PURE__ */ new Map();
-    for (const link of await document.mentionLinks.listByChapter(chapterId)) {
-      const [source, target] = await Promise.all([
-        getMentionForTripleSearch(document, mentionCache, link.sourceMentionId),
-        getMentionForTripleSearch(document, mentionCache, link.targetMentionId)
-      ]);
-      if (source === void 0 || target === void 0) {
-        continue;
-      }
-      for (const [
-        evidenceChapterId,
-        sentenceIndex
-      ] of link.evidenceSentenceIds) {
-        const score = sourceHitScores.get(
-          createSentenceHitKey(evidenceChapterId, sentenceIndex)
-        );
-        if (score === void 0) {
-          continue;
-        }
-        evidenceEvents.push({
-          chapterId: evidenceChapterId,
-          evidenceId: link.id,
-          evidenceKind: SEARCH_EVIDENCE_KIND.mentionLink,
-          score,
-          sentenceIndex
-        });
-        const key = formatTripleUri(source.qid, link.predicate, target.qid);
-        const current = tripleEvidenceScoresByKey.get(key) ?? {
-          objectQid: target.qid,
-          predicate: link.predicate,
-          scores: [],
-          subjectQid: source.qid
-        };
-        current.scores.push(score);
-        tripleEvidenceScoresByKey.set(key, current);
-      }
-    }
-  }
-  return {
-    chunkHits: [...chunkEvidenceScoresById.entries()].map(
-      ([chunkId, scores]) => ({
-        chunkId,
-        evidenceTopScores: scores
-      })
-    ),
-    entityHits: [...entityEvidenceScoresByQid.entries()].map(
-      ([qid, scores]) => ({
-        evidenceTopScores: scores,
-        qid
-      })
-    ),
-    evidenceEvents,
-    tripleHits: [...tripleEvidenceScoresByKey.values()].map((hit) => ({
-      evidenceTopScores: hit.scores,
-      objectQid: hit.objectQid,
-      predicate: hit.predicate,
-      subjectQid: hit.subjectQid
-    }))
-  };
-}
-function createSentenceHitKey(chapterId, sentenceIndex) {
-  return `${chapterId}:${sentenceIndex}`;
-}
-function parseEntityQid(id) {
-  const normalized = normalizeWikiGraphObjectUri(id);
-  const prefix = `${WIKI_GRAPH_URI_PREFIX}entity/`;
-  return normalized.startsWith(prefix) ? normalized.slice(prefix.length) : void 0;
-}
-function filterLexicalHitsByMatch(hits, search, match) {
-  if (match === "any") {
-    return hits;
-  }
-  const requiredTerms = [...search.phrases];
-  if (requiredTerms.length === 0) {
-    return hits;
-  }
-  return hits.filter(
-    (hit) => requiredTerms.every((term) => hit.matchedTerms?.includes(term) === true)
-  );
-}
-async function findChapters(document, search) {
-  const hits = [];
-  for (const chapter of await listChapters(document)) {
-    const title = chapter.title ?? `[chapter ${chapter.chapterId}]`;
-    const titleMatch = matchText(title, search);
-    if (titleMatch !== void 0) {
-      hits.push({
-        chapter: chapter.chapterId,
-        field: "title",
-        id: formatChapterTitleId(chapter.chapterId),
-        ...createFindMatchFields(titleMatch),
-        position: {
-          chapter: chapter.chapterId
-        },
-        snippet: title,
-        title,
-        type: "chapter-title"
-      });
-    }
-    hits.push(
-      ...await findTextStreamSentences(
-        document,
-        chapter.chapterId,
-        "summary",
-        title,
-        search
-      )
-    );
-    hits.push(
-      ...await findTextStreamSentences(
-        document,
-        chapter.chapterId,
-        "source",
-        title,
-        search
-      )
-    );
-  }
-  return hits;
-}
-async function findTextStreamSentences(document, chapterId, stream, title, search) {
-  const index = await createTextStreamIndex(document, chapterId, stream);
-  return index.sentences.flatMap((sentence) => {
-    const match = matchText(sentence.text, search);
-    if (match === void 0) {
-      return [];
-    }
-    return [
-      {
-        chapter: chapterId,
-        field: stream,
-        id: formatTextStreamRangeUri(
-          chapterId,
-          stream,
-          sentence.globalIndex,
-          sentence.globalIndex
-        ),
-        ...createFindMatchFields(match),
-        position: {
-          chapter: chapterId,
-          fragment: sentence.fragmentId,
-          sentence: sentence.localIndex
-        },
-        snippet: createSnippet(sentence.text, getSnippetNeedle(match)),
-        title,
-        type: stream === "source" ? "source" : "summary"
-      }
-    ];
-  });
-}
-async function readSourceFragment(document, serialId, fragmentId) {
-  const fragment = await document.getSerialFragments(serialId).getFragment(fragmentId);
-  const text = fragment.sentences.map((sentence) => sentence.text).join("\n");
-  return {
-    fragmentId,
-    id: formatFragmentId(serialId, fragmentId),
-    preview: createSnippet(text),
-    sentenceCount: fragment.sentences.length,
-    text,
-    wordsCount: fragment.sentences.reduce(
-      (total, sentence) => total + sentence.wordsCount,
-      0
-    )
-  };
-}
-async function createTextStreamRangeFragment(document, reference) {
-  const range = await readTextStreamRange(
-    document,
-    reference.chapterId,
-    reference.stream,
-    reference.startSentenceIndex,
-    reference.endSentenceIndex
-  );
-  return {
-    fragmentId: range.startSentenceIndex,
-    id: range.id,
-    preview: createSnippet(range.text),
-    sentenceCount: range.endSentenceIndex - range.startSentenceIndex + 1,
-    text: range.text,
-    wordsCount: countWords(range.text)
-  };
-}
-async function readTextStreamRange(document, chapterId, stream, startSentenceIndex, endSentenceIndex, context = createEvidenceReadContext()) {
-  const index = await getTextStreamIndex(document, chapterId, stream, context);
-  if (index.sentences.length === 0) {
-    throw new Error(
-      `Chapter ${formatChapterId(chapterId)} has no ${stream} text.`
-    );
-  }
-  const lastSentenceIndex = index.sentences.length - 1;
-  if (startSentenceIndex > lastSentenceIndex) {
-    throw new Error(
-      `${stream} range ${formatTextStreamRangeUri(chapterId, stream, startSentenceIndex, endSentenceIndex)} is out of bounds. Last sentence number is ${lastSentenceIndex + 1}.`
-    );
-  }
-  const start = clampInteger(startSentenceIndex, 0, lastSentenceIndex);
-  const end = clampInteger(endSentenceIndex, start, lastSentenceIndex);
-  const sentences = index.sentences.slice(start, end + 1);
-  const text = normalizeRenderedTextStreamRange(
-    await readTextStreamRawRange(document, chapterId, stream, start, end)
-  ) ?? joinTextStreamSentences(sentences);
-  return {
-    endSentenceIndex: end,
-    id: formatTextStreamRangeUri(chapterId, stream, start, end),
-    startSentenceIndex: start,
-    text
-  };
-}
-async function readTextStreamText(document, chapterId, stream) {
-  const serial = getTextStreamSerial(document, chapterId, stream);
-  const text = await serial.readText?.();
-  if (text !== void 0) {
-    return text;
-  }
-  const index = await createTextStreamIndex(document, chapterId, stream);
-  return joinTextStreamSentences(index.sentences);
-}
-async function readTextStreamRawRange(document, chapterId, stream, startSentenceIndex, endSentenceIndex) {
-  const serial = getTextStreamSerial(document, chapterId, stream);
-  return await serial.readTextInRange?.(startSentenceIndex, endSentenceIndex);
-}
-function getTextStreamSerial(document, chapterId, stream) {
-  return stream === "summary" ? document.getSummaryFragments(chapterId) : document.getSerialFragments(chapterId);
-}
-function joinTextStreamSentences(sentences) {
-  return sentences.map((sentence) => sentence.text).join("");
-}
-function normalizeRenderedTextStreamRange(text) {
-  return text?.replace(/^(?:[^\S\r\n]*(?:\r\n|\n|\r))+/u, "").replace(/(?:(?:\r\n|\n|\r)[^\S\r\n]*)+$/u, "");
-}
-async function getTextStreamIndex(document, chapterId, stream, context = createEvidenceReadContext()) {
-  const key = `${chapterId}:${stream}`;
-  let index = context.streamIndexes.get(key);
-  if (index === void 0) {
-    index = createTextStreamIndex(document, chapterId, stream);
-    context.streamIndexes.set(key, index);
-  }
-  return await index;
-}
-async function createTextStreamIndex(document, chapterId, stream) {
-  if (stream === "summary") {
-    const fragments2 = document.getSummaryFragments(chapterId);
-    const sentences2 = [];
-    for (const fragmentId of await fragments2.listFragmentIds()) {
-      const fragment = await fragments2.getFragment(fragmentId);
-      for (let index = 0; index < fragment.sentences.length; index += 1) {
-        const sentence = fragment.sentences[index];
-        if (sentence === void 0) {
-          continue;
-        }
-        sentences2.push({
-          fragmentId,
-          globalIndex: sentences2.length,
-          localIndex: index,
-          text: sentence.text,
-          wordsCount: sentence.wordsCount
-        });
-      }
-    }
-    return { sentences: sentences2 };
-  }
-  const fragments = document.getSerialFragments(chapterId);
-  const sentences = [];
-  for (const fragmentId of await fragments.listFragmentIds()) {
-    const fragment = await fragments.getFragment(fragmentId);
-    for (let index = 0; index < fragment.sentences.length; index += 1) {
-      const sentence = fragment.sentences[index];
-      if (sentence === void 0) {
-        continue;
-      }
-      sentences.push({
-        fragmentId,
-        globalIndex: sentences.length,
-        localIndex: index,
-        text: sentence.text,
-        wordsCount: sentence.wordsCount
-      });
-    }
-  }
-  return { sentences };
-}
-function selectEntityLabel(mentions) {
-  return selectEntityLabels(mentions)[0] ?? mentions[0]?.qid ?? "[entity]";
-}
-function selectEntityLabels(mentions) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const mention of mentions) {
-    counts.set(mention.surface, (counts.get(mention.surface) ?? 0) + 1);
-  }
-  return [...counts.entries()].sort((left, right) => {
-    const countComparison = right[1] - left[1];
-    return countComparison === 0 ? left[0].localeCompare(right[0]) : countComparison;
-  }).map(([label]) => label);
-}
-async function createTriplePageLabel(document, reference) {
-  const [subjectMentions, objectMentions] = await Promise.all([
-    document.mentions.listByQid(reference.subjectQid),
-    document.mentions.listByQid(reference.objectQid)
-  ]);
-  const scopedSubjectMentions = filterMentionsByChapter(
-    subjectMentions,
-    reference.chapterId
-  );
-  const scopedObjectMentions = filterMentionsByChapter(
-    objectMentions,
-    reference.chapterId
-  );
-  const subjectLabel = scopedSubjectMentions.length === 0 ? reference.subjectQid : selectEntityLabel(scopedSubjectMentions);
-  const objectLabel = scopedObjectMentions.length === 0 ? reference.objectQid : selectEntityLabel(scopedObjectMentions);
-  return `${subjectLabel}(${reference.subjectQid}) ${reference.predicate} ${objectLabel}(${reference.objectQid})`;
-}
-function countWords(text) {
-  const trimmed = text.trim();
-  return trimmed === "" ? 0 : trimmed.split(/\s+/u).length;
-}
-async function listFragmentNodes(document, chapterId, fragmentId) {
-  return (await document.chunks.listBySentenceStartIndexes(chapterId, [fragmentId])).map(createPositionedNodeLabel).sort(comparePositionedNodeLabels).map(({ label }) => label);
-}
-function createNodeLabel(node) {
-  return {
-    id: formatNodeId(node.id),
-    title: node.label
-  };
-}
-function createPositionedNodeLabel(node) {
-  return {
-    label: createNodeLabel(node),
-    position: createNodePosition(node.sentenceIds)
-  };
-}
-function comparePositionedNodeLabels(left, right) {
-  if (left.position !== void 0 && right.position !== void 0) {
-    return compareArchivePositions(left.position, right.position);
-  }
-  if (left.position !== void 0) {
-    return -1;
-  }
-  if (right.position !== void 0) {
-    return 1;
-  }
-  return left.label.id.localeCompare(right.label.id);
-}
-function findMeta(meta, search) {
-  if (meta === void 0) {
-    return [];
-  }
-  const fields = [
-    meta.title,
-    ...meta.authors,
-    meta.description,
-    meta.publisher
-  ].filter(isDefined);
-  const content = fields.join("\n");
-  const contentMatch = matchText(content, search);
-  if (contentMatch === void 0) {
-    return [];
-  }
-  return [
-    {
-      field: "metadata",
-      id: ARCHIVE_ROOT_ID,
-      ...createFindMatchFields(contentMatch),
-      snippet: createSnippet(content, getSnippetNeedle(contentMatch)),
-      title: meta.title ?? "Archive metadata",
-      type: "meta"
-    }
-  ];
-}
-async function findNodes(document, search) {
-  const hits = [];
-  for (const node of await document.chunks.listAll()) {
-    const position = createNodePosition(node.sentenceIds);
-    const labelMatch = matchText(node.label, search);
-    if (labelMatch !== void 0) {
-      hits.push({
-        chapter: node.sentenceId[0],
-        field: "title",
-        id: formatNodeId(node.id),
-        ...createFindMatchFields(labelMatch),
-        ...position === void 0 ? {} : { position },
-        snippet: node.label,
-        title: node.label,
-        type: "node"
-      });
-    }
-    const contentMatch = matchText(node.content, search);
-    if (contentMatch !== void 0) {
-      hits.push({
-        chapter: node.sentenceId[0],
-        field: "content",
-        id: formatNodeId(node.id),
-        ...createFindMatchFields(contentMatch),
-        ...position === void 0 ? {} : { position },
-        snippet: createSnippet(node.content, getSnippetNeedle(contentMatch)),
-        title: node.label,
-        type: "node"
-      });
-    }
-  }
-  return hits;
-}
-async function requireChapter(document, chapterId) {
-  const chapter = (await listChapters(document)).find(
-    (entry) => entry.chapterId === chapterId
-  );
-  if (chapter === void 0) {
-    throw new Error(`Chapter ${formatChapterId(chapterId)} does not exist.`);
-  }
-  return chapter;
-}
-async function createChapterState(document, chapter) {
-  const serial = await document.serials.getById(chapter.chapterId);
-  return {
-    source: chapter.stage === "planned" ? "missing" : "ready",
-    "reading-graph": chapter.stage === "graphed" || chapter.stage === "summarized" ? "ready" : "missing",
-    "reading-summary": chapter.stage === "summarized" ? "ready" : "missing",
-    "knowledge-graph": serial?.knowledgeGraphReady === true ? "ready" : "missing"
-  };
-}
-function formatChapterStateSummary(state) {
-  return [
-    `source:${state.source}`,
-    `reading-graph:${state["reading-graph"]}`,
-    `reading-summary:${state["reading-summary"]}`,
-    `knowledge-graph:${state["knowledge-graph"]}`
-  ].join(" ");
-}
-async function requireNode(document, nodeId) {
-  const chunk = await document.chunks.getById(nodeId);
-  if (chunk === void 0) {
-    throw new Error(`Node ${formatNodeId(nodeId)} does not exist.`);
-  }
-  const chapterId = chunk.sentenceId[0];
-  return {
-    chapterId,
-    node: await getGraphNode(document, chapterId, nodeId)
-  };
-}
-async function readNodeSourceFragments(document, node) {
-  const fragmentIds = await collectNodeSourceFragmentIds(document, node);
-  return await Promise.all(
-    fragmentIds.map(async ([chapterId, fragmentId]) => {
-      const fragment = await readSourceFragment(
-        document,
-        chapterId,
-        fragmentId
-      );
-      const index = await createTextStreamIndex(document, chapterId, "source");
-      const fragmentSentences = index.sentences.filter(
-        (sentence) => sentence.fragmentId === fragmentId
-      );
-      const firstSentence = fragmentSentences[0];
-      const lastSentence = fragmentSentences[fragmentSentences.length - 1];
-      const text = truncateSourceExcerpt(fragment.text);
-      return {
-        id: firstSentence === void 0 || lastSentence === void 0 ? fragment.id : formatTextStreamRangeUri(
-          chapterId,
-          "source",
-          firstSentence.globalIndex,
-          lastSentence.globalIndex
-        ),
-        text,
-        truncated: text.length < fragment.text.length
-      };
-    })
-  );
-}
-async function collectNodeSourceFragmentIds(document, node) {
-  const seen = /* @__PURE__ */ new Set();
-  const fragmentIds = [];
-  const indexes = /* @__PURE__ */ new Map();
-  for (const [chapterId, sentenceIndex] of node.sentenceIds) {
-    let index = indexes.get(chapterId);
-    if (index === void 0) {
-      index = createTextStreamIndex(document, chapterId, "source");
-      indexes.set(chapterId, index);
-    }
-    const sentence = (await index).sentences[sentenceIndex];
-    if (sentence === void 0) {
-      continue;
-    }
-    const fragmentId = sentence.fragmentId;
-    const key = `${chapterId}:${fragmentId}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      fragmentIds.push([chapterId, fragmentId]);
-    }
-  }
-  return fragmentIds;
-}
-function truncateSourceExcerpt(text) {
-  return text.length <= 1200 ? text : `${text.slice(0, 1200)}...`;
-}
-function createNodeEvidenceRanges(node) {
-  const ranges = /* @__PURE__ */ new Map();
-  for (const [chapterId, sentenceIndex] of node.sentenceIds) {
-    const key = `${chapterId}`;
-    const current = ranges.get(key);
-    if (current === void 0) {
-      ranges.set(key, [sentenceIndex, sentenceIndex]);
-    } else {
-      ranges.set(key, [
-        Math.min(current[0], sentenceIndex),
-        Math.max(current[1], sentenceIndex)
-      ]);
-    }
-  }
-  return [...ranges.entries()].map(([key, [start, end]]) => {
-    const chapterId = Number(key);
-    return {
-      chapterId,
-      endSentenceIndex: end,
-      startSentenceIndex: start
-    };
-  });
-}
-async function createMentionEvidencePreview(document, mentions, limit = 3, context = createEvidenceReadContext(), sourceContext = DEFAULT_SOURCE_CONTEXT, order = "doc-asc") {
-  return await createSourceEvidencePreview(
-    document,
-    await createMentionEvidenceRanges(document, mentions),
-    limit,
-    context,
-    sourceContext,
-    order
-  );
-}
-async function createMentionEvidenceRanges(document, mentions) {
-  return await Promise.all(
-    mentions.map(async (mention) => {
-      const startSentenceIndex = mention.sentenceIndex ?? await findSentenceIndexAtOffset(
-        document,
-        mention.chapterId,
-        mention.rangeStart
-      );
-      const endSentenceIndex = mention.sentenceIndex ?? await findSentenceIndexAtOffset(
-        document,
-        mention.chapterId,
-        Math.max(0, mention.rangeEnd - 1)
-      );
-      return {
-        chapterId: mention.chapterId,
-        endSentenceIndex,
-        startSentenceIndex
-      };
-    })
-  );
-}
-async function createMentionLinkEvidencePreview(document, links, limit = 3, context = createEvidenceReadContext(), sourceContext = DEFAULT_SOURCE_CONTEXT, order = "doc-asc") {
-  return await createSourceEvidencePreview(
-    document,
-    createMentionLinkEvidenceRanges(document, links),
-    limit,
-    context,
-    sourceContext,
-    order
-  );
-}
-function createMentionLinkEvidenceRanges(_document, links) {
-  return links.flatMap(
-    (link) => link.evidenceSentenceIds.map(([chapterId, sentenceIndex]) => ({
-      chapterId,
-      endSentenceIndex: sentenceIndex,
-      startSentenceIndex: sentenceIndex
-    }))
-  );
-}
-function filterMentionsByChapter(mentions, chapterId) {
-  return chapterId === void 0 ? mentions : mentions.filter((mention) => mention.chapterId === chapterId);
-}
-function filterMentionsByChapterSet(mentions, chapterFilter) {
-  return chapterFilter === void 0 ? mentions : mentions.filter((mention) => chapterFilter.has(mention.chapterId));
-}
-async function filterMentionLinksByChapter(document, links, chapterId) {
-  if (chapterId === void 0) {
-    return links;
-  }
-  const filtered = [];
-  for (const link of links) {
-    const source = await document.mentions.getById(link.sourceMentionId);
-    if (source?.chapterId === chapterId) {
-      filtered.push(link);
-    }
-  }
-  return filtered;
-}
-async function createSourceEvidencePage(document, ranges, options) {
-  const context = createEvidenceReadContext();
-  const limit = options.limit ?? DEFAULT_FIND_LIMIT;
-  const start = decodeFindCursor(options.cursor);
-  const evidenceRanges = await filterAndSortSourceEvidenceRangesByFtsQuery(
-    document,
-    ranges,
-    options.query,
-    options.order ?? "doc-asc"
-  );
-  const displayRanges = await createExpandedSourceEvidenceRanges(
-    document,
-    evidenceRanges,
-    options.sourceContext ?? DEFAULT_SOURCE_CONTEXT,
-    context
-  );
-  const pageRanges = displayRanges.slice(start, start + limit);
-  const nextOffset = start + pageRanges.length;
-  const items = await Promise.all(
-    pageRanges.map(
-      async (range) => await createSourceEvidenceItem(
-        document,
-        range.chapterId,
-        range.startSentenceIndex,
-        range.endSentenceIndex,
-        context,
-        range.score
-      )
-    )
-  );
-  return {
-    items,
-    limit,
-    nextCursor: nextOffset < displayRanges.length ? encodeFindCursor(nextOffset) : null
-  };
-}
-async function filterAndSortSourceEvidenceRangesByFtsQuery(document, ranges, queryText, order) {
-  const documentOrders = await document.serials.listDocumentOrders();
-  if (queryText === void 0) {
-    return mergeSourceEvidenceRanges(ranges).sort(
-      (left, right) => compareSourceEvidenceRanges(left, right, documentOrders, order)
-    );
-  }
-  const indexResult = await queryRequiredSearchIndex(document, queryText, {
-    chapters: [...new Set(ranges.map((range) => range.chapterId))],
-    types: ["source"]
-  });
-  if (indexResult === void 0) {
-    return [];
-  }
-  const matchedRanges = /* @__PURE__ */ new Map();
-  const rangesByChapterId = /* @__PURE__ */ new Map();
-  for (const range of ranges) {
-    const chapterRanges = rangesByChapterId.get(range.chapterId) ?? [];
-    chapterRanges.push(range);
-    rangesByChapterId.set(range.chapterId, chapterRanges);
-  }
-  for (const hit of indexResult.textHits) {
-    if (hit.kind !== TEXT_SENTENCE_KIND.source) {
-      continue;
-    }
-    for (const range of rangesByChapterId.get(hit.chapterId) ?? []) {
-      if (hit.sentenceIndex < range.startSentenceIndex || hit.sentenceIndex > range.endSentenceIndex) {
-        continue;
-      }
-      const key = formatSourceEvidenceRangeKey(range);
-      const current = matchedRanges.get(key);
-      matchedRanges.set(key, {
-        ...range,
-        score: Math.max(current?.score ?? 0, hit.score)
-      });
-    }
-  }
-  return [...matchedRanges.values()].sort((left, right) => {
-    const scoreComparison = (right.score ?? 0) - (left.score ?? 0);
-    if (scoreComparison !== 0) {
-      return scoreComparison;
-    }
-    return compareSourceEvidenceRanges(left, right, documentOrders, "doc-asc");
-  });
-}
-function formatSourceEvidenceRangeKey(range) {
-  return `${range.chapterId}:${range.startSentenceIndex}:${range.endSentenceIndex}`;
-}
-function compareSourceEvidenceRanges(left, right, documentOrders, order) {
-  const direction = order === "doc-asc" ? 1 : -1;
-  return (compareNumbers(
-    documentOrders.get(left.chapterId) ?? left.chapterId,
-    documentOrders.get(right.chapterId) ?? right.chapterId
-  ) || compareNumbers(left.chapterId, right.chapterId) || compareNumbers(left.startSentenceIndex, right.startSentenceIndex) || compareNumbers(left.endSentenceIndex, right.endSentenceIndex)) * direction;
-}
-async function createSourceEvidencePreview(document, ranges, limit, context = createEvidenceReadContext(), sourceContext = DEFAULT_SOURCE_CONTEXT, order = "doc-asc") {
-  const documentOrders = await document.serials.listDocumentOrders();
-  const mergedRanges = mergeSourceEvidenceRanges(ranges).sort(
-    (left, right) => compareSourceEvidenceRanges(left, right, documentOrders, order)
-  );
-  const displayRanges = await createExpandedSourceEvidenceRanges(
-    document,
-    mergedRanges.slice(0, limit),
-    sourceContext,
-    context
-  );
-  const sources = await Promise.all(
-    displayRanges.map(
-      async (range) => await createSourceEvidenceItem(
-        document,
-        range.chapterId,
-        range.startSentenceIndex,
-        range.endSentenceIndex,
-        context
-      )
-    )
-  );
-  return {
-    nextCursor: Math.min(limit, mergedRanges.length) < mergedRanges.length ? encodeFindCursor(Math.min(limit, mergedRanges.length)) : null,
-    shown: sources.length,
-    sources,
-    total: mergedRanges.length
-  };
-}
-function mergeSourceEvidenceRanges(ranges) {
-  const rangesBySource = /* @__PURE__ */ new Map();
-  for (const range of ranges) {
-    const key = `${range.chapterId}`;
-    const sourceRanges = rangesBySource.get(key) ?? [];
-    sourceRanges.push({
-      end: range.endSentenceIndex,
-      ...range.score === void 0 ? {} : { score: range.score },
-      start: range.startSentenceIndex
-    });
-    rangesBySource.set(key, sourceRanges);
-  }
-  return [...rangesBySource.entries()].flatMap(([key, ranges2]) => {
-    const chapterId = Number(key);
-    return mergeEvidenceRanges(ranges2).map(
-      ({ end, score, start }) => ({
-        chapterId,
-        endSentenceIndex: end,
-        ...score === void 0 ? {} : { score },
-        startSentenceIndex: start
-      })
-    );
-  });
-}
-function mergeSourceEvidenceRangesInInputOrder(ranges) {
-  const merged = [];
-  for (const range of ranges) {
-    const overlappingIndexes = merged.map(
-      (existing, index) => areMergeableSourceEvidenceRanges(existing, range) ? index : -1
-    ).filter((index) => index >= 0);
-    if (overlappingIndexes.length === 0) {
-      merged.push(range);
-      continue;
-    }
-    const firstIndex = overlappingIndexes[0] ?? 0;
-    const overlapping = overlappingIndexes.flatMap((index) => {
-      const existing = merged[index];
-      return existing === void 0 ? [] : [existing];
-    });
-    const mergedRange = mergeSourceEvidenceRangeGroup([...overlapping, range]);
-    merged[firstIndex] = mergedRange;
-    for (const index of overlappingIndexes.slice(1).reverse()) {
-      merged.splice(index, 1);
-    }
-  }
-  return merged;
-}
-function areMergeableSourceEvidenceRanges(left, right) {
-  return left.chapterId === right.chapterId && right.startSentenceIndex <= left.endSentenceIndex + 1 && left.startSentenceIndex <= right.endSentenceIndex + 1;
-}
-function mergeSourceEvidenceRangeGroup(ranges) {
-  const [first] = ranges;
-  if (first === void 0) {
-    throw new Error("Internal error: cannot merge empty evidence range group.");
-  }
-  const scores = ranges.map((range) => range.score).filter((score) => score !== void 0);
-  return {
-    chapterId: first.chapterId,
-    endSentenceIndex: Math.max(
-      ...ranges.map((range) => range.endSentenceIndex)
-    ),
-    ...scores.length === 0 ? {} : { score: Math.max(...scores) },
-    startSentenceIndex: Math.min(
-      ...ranges.map((range) => range.startSentenceIndex)
-    )
-  };
-}
-async function createExpandedSourceEvidenceRanges(document, ranges, sourceContext, context) {
-  const expanded = await Promise.all(
-    ranges.map(async (range) => {
-      if (sourceContext <= 0) {
-        return range;
-      }
-      const sourceIndex = await getTextStreamIndex(
-        document,
-        range.chapterId,
-        "source",
-        context
-      );
-      const lastSentenceIndex = Math.max(0, sourceIndex.sentences.length - 1);
-      return {
-        ...range,
-        endSentenceIndex: clampInteger(
-          range.endSentenceIndex + sourceContext,
-          range.startSentenceIndex,
-          lastSentenceIndex
-        ),
-        startSentenceIndex: clampInteger(
-          range.startSentenceIndex - sourceContext,
-          0,
-          lastSentenceIndex
-        )
-      };
-    })
-  );
-  return mergeSourceEvidenceRangesInInputOrder(expanded);
-}
-async function createSourceEvidenceItem(document, chapterId, startSentenceIndex, endSentenceIndex, context = createEvidenceReadContext(), score) {
-  const chapter = await getEvidenceChapter(document, chapterId, context);
-  const range = await readTextStreamRange(
-    document,
-    chapterId,
-    "source",
-    startSentenceIndex,
-    endSentenceIndex,
-    context
-  );
-  return {
-    chapterId,
-    endSentenceIndex: range.endSentenceIndex,
-    fragmentId: range.startSentenceIndex,
-    id: formatTextStreamRangeUri(
-      chapterId,
-      "source",
-      range.startSentenceIndex,
-      range.endSentenceIndex
-    ),
-    ...score === void 0 ? {} : { score },
-    source: range.text,
-    startSentenceIndex: range.startSentenceIndex,
-    title: chapter.title ?? `[chapter ${chapterId}]`,
-    type: "source"
-  };
-}
-function createEvidenceReadContext() {
-  return {
-    chapters: /* @__PURE__ */ new Map(),
-    streamIndexes: /* @__PURE__ */ new Map()
-  };
-}
-async function getEvidenceChapter(document, chapterId, context) {
-  let chapter = context.chapters.get(chapterId);
-  if (chapter === void 0) {
-    chapter = requireChapter(document, chapterId);
-    context.chapters.set(chapterId, chapter);
-  }
-  return await chapter;
-}
-async function findSentenceIndexAtOffset(document, chapterId, offset) {
-  const serial = document.getSerialFragments(chapterId);
-  const sentences = serial.listSentences === void 0 ? [] : await serial.listSentences();
-  if (sentences.length === 0) {
-    return 0;
-  }
-  let cursor = 0;
-  for (let index = 0; index < sentences.length; index += 1) {
-    const sentence = sentences[index];
-    if (sentence === void 0) {
-      continue;
-    }
-    const nextCursor = cursor + sentence.text.length;
-    if (offset <= nextCursor) {
-      return index;
-    }
-    cursor = nextCursor + 1;
-  }
-  return Math.max(0, sentences.length - 1);
-}
-function formatTextStreamRangeUri(chapterId, stream, startSentenceIndex, endSentenceIndex) {
-  const startSentenceNumber = startSentenceIndex + 1;
-  const endSentenceNumber = endSentenceIndex + 1;
-  const hash = startSentenceIndex === endSentenceIndex ? String(startSentenceNumber) : `${startSentenceNumber}..${endSentenceNumber}`;
-  return `wikg://chapter/${chapterId}/${stream}#${hash}`;
-}
-function mergeEvidenceRanges(ranges) {
-  const sortedRanges = [...ranges].map((range) => ({
-    ...range.score === void 0 ? {} : { score: range.score },
-    end: Math.max(range.start, range.end),
-    start: Math.min(range.start, range.end)
-  })).sort(
-    (left, right) => left.start === right.start ? left.end - right.end : left.start - right.start
-  );
-  const mergedRanges = [];
-  for (const { end, score, start } of sortedRanges) {
-    const last = mergedRanges.at(-1);
-    if (last === void 0 || start > last.end + 1) {
-      mergedRanges.push({
-        end,
-        ...score === void 0 ? {} : { score },
-        start
-      });
-    } else {
-      last.end = Math.max(last.end, end);
-      if (score !== void 0) {
-        last.score = Math.max(last.score ?? score, score);
-      }
-    }
-  }
-  return mergedRanges;
-}
-function clampInteger(value, min, max) {
-  return Math.max(min, Math.min(max, Math.floor(value)));
-}
-function parseWikiGraphReference(uri) {
-  uri = normalizeWikiGraphObjectUri(uri);
-  if (!isWikiGraphObjectUri(uri)) {
-    const archiveReference = parseArchiveReference(uri);
-    switch (archiveReference.type) {
-      case "node":
-        return { id: archiveReference.id, type: "chunk" };
-      case "chapter":
-        return { chapterId: archiveReference.id, type: "chapter" };
-      case "chapter-title":
-        return { chapterId: archiveReference.id, type: "chapter-title" };
-      case "summary":
-        return {
-          chapterId: archiveReference.id,
-          endSentenceIndex: Number.POSITIVE_INFINITY,
-          stream: "summary",
-          startSentenceIndex: 0,
-          type: "text-stream"
-        };
-      case "fragment":
-      case "meta":
-        throw new Error(`Evidence is not available for ${uri}.`);
-    }
-  }
-  if (uri === WIKI_GRAPH_URI_PREFIX) {
-    return { type: "meta" };
-  }
-  const [rawPath = "", hash = ""] = uri.slice(WIKI_GRAPH_URI_PREFIX.length).split("#", 2);
-  const pathParts = rawPath.split("/").filter((part) => part !== "");
-  if (pathParts.length === 0) {
-    return { type: "meta" };
-  }
-  if (pathParts[0] === "chapter-tree" && pathParts.length === 1) {
-    return { type: "chapter-tree" };
-  }
-  switch (pathParts[0]) {
-    case "chapter":
-      if (pathParts.length === 2) {
-        return {
-          chapterId: parsePositiveInteger(pathParts[1], uri),
-          type: "chapter"
-        };
-      }
-      if (pathParts[1] !== void 0) {
-        const chapterId = parsePositiveInteger(pathParts[1], uri);
-        switch (pathParts[2]) {
-          case "state":
-            if (pathParts.length === 3) {
-              return { chapterId, type: "chapter-state" };
-            }
-            if (pathParts.length === 4) {
-              return {
-                chapterId,
-                target: parseChapterStateTarget(pathParts[3], uri),
-                type: "chapter-state"
-              };
-            }
-            break;
-          case "title":
-            if (pathParts.length === 3) {
-              return { chapterId, type: "chapter-title" };
-            }
-            break;
-          case "chunk":
-            if (pathParts.length === 4) {
-              return {
-                chapterId,
-                id: parsePositiveInteger(pathParts[3], uri),
-                type: "chunk"
-              };
-            }
-            break;
-          case "entity":
-            if (pathParts.length === 4) {
-              return {
-                chapterId,
-                qid: parseQid(pathParts[3], uri),
-                type: "entity"
-              };
-            }
-            break;
-          case "source":
-            if (pathParts.length === 3) {
-              const [start, end] = parseSentenceRange(hash);
-              return {
-                chapterId,
-                endSentenceIndex: end,
-                stream: "source",
-                startSentenceIndex: start,
-                type: "text-stream"
-              };
-            }
-            break;
-          case "summary":
-            if (pathParts.length === 3) {
-              const [start, end] = parseSentenceRange(hash);
-              return {
-                chapterId,
-                endSentenceIndex: end,
-                stream: "summary",
-                startSentenceIndex: start,
-                type: "text-stream"
-              };
-            }
-            break;
-          case "tree":
-            if (pathParts.length === 3) {
-              return { chapterId, type: "chapter" };
-            }
-            break;
-          case "triple":
-            if (pathParts.length === 6) {
-              return {
-                chapterId,
-                objectQid: parseQid(pathParts[5], uri),
-                predicate: decodeURIComponent(pathParts[4] ?? ""),
-                subjectQid: parseQid(pathParts[3], uri),
-                type: "triple"
-              };
-            }
-            break;
-        }
-      }
-      break;
-    case "chunk":
-      if (pathParts.length === 2) {
-        return {
-          id: parsePositiveInteger(pathParts[1], uri),
-          type: "chunk"
-        };
-      }
-      break;
-    case "entity":
-      if (pathParts.length === 2) {
-        return {
-          qid: parseQid(pathParts[1], uri),
-          type: "entity"
-        };
-      }
-      if (pathParts.length === 3 && pathParts[2] === "wikipage") {
-        return {
-          qid: parseQid(pathParts[1], uri),
-          type: "entity-wikipage"
-        };
-      }
-      break;
-    case "triple":
-      if (pathParts.length === 4) {
-        return {
-          objectQid: parseQid(pathParts[3], uri),
-          predicate: decodeURIComponent(pathParts[2] ?? ""),
-          subjectQid: parseQid(pathParts[1], uri),
-          type: "triple"
-        };
-      }
-      break;
-  }
-  throw new Error(`Invalid Wiki Graph URI: ${uri}`);
-}
-function parseQid(value, uri) {
-  if (value !== void 0 && /^Q[1-9][0-9]*$/u.test(value)) {
-    return value;
-  }
-  throw new Error(`Invalid Wiki Graph URI: ${uri}`);
-}
-function parseChapterStateTarget(value, uri) {
-  if (value === "source" || value === "reading-graph" || value === "reading-summary" || value === "knowledge-graph") {
-    return value;
-  }
-  throw new Error(`Invalid Wiki Graph URI: ${uri}`);
-}
-function parseSentenceRange(hash) {
-  if (hash === "") {
-    return [0, Number.POSITIVE_INFINITY];
-  }
-  const match = /^([1-9][0-9]*)(?:\.\.([1-9][0-9]*))?$/u.exec(hash);
-  if (match?.[1] === void 0) {
-    throw new Error(`Invalid source sentence range: ${hash}`);
-  }
-  const parsedStart = Number(match[1]) - 1;
-  const parsedEnd = Number(match[2] ?? match[1]) - 1;
-  if (Number.isInteger(parsedStart) && parsedStart >= 0 && Number.isInteger(parsedEnd) && parsedEnd >= parsedStart) {
-    return [parsedStart, parsedEnd];
-  }
-  throw new Error(`Invalid source sentence range: ${hash}`);
-}
-function parseArchiveReference(id) {
-  const normalized = id.trim();
-  const [type, value] = normalized.split(":", 2);
-  if (type === "meta" && (value === "book" || value === "root")) {
-    return { type: "meta" };
-  }
-  if (type === "chapter" || type === "chapter-title" || type === "summary") {
-    const parsedId = parsePositiveInteger(value, normalized);
-    return { id: parsedId, type };
-  }
-  if (type === "node") {
-    const parsedId = parsePositiveInteger(value, normalized);
-    return {
-      id: parsedId,
-      type: "node"
-    };
-  }
-  if (type === "fragment") {
-    const parts = normalized.slice("fragment:".length).split(":");
-    if (parts.length !== 2) {
-      throw new Error(`Invalid archive object id: ${id}`);
-    }
-    return {
-      fragmentId: parseNonNegativeInteger(parts[1], normalized),
-      serialId: parsePositiveInteger(parts[0], normalized),
-      type: "fragment"
-    };
-  }
-  throw new Error(`Invalid archive object id: ${id}`);
-}
-function parsePositiveInteger(value, id) {
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new Error(`Invalid archive object id: ${id}`);
-  }
-  return parsed;
-}
-function parseNonNegativeInteger(value, id) {
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed < 0) {
-    throw new Error(`Invalid archive object id: ${id}`);
-  }
-  return parsed;
-}
-const DEFAULT_FIND_LIMIT = 20;
-const GROUP_SCORE_EVIDENCE_LIMIT = 10;
-const TEXT_ONLY_SEARCH_CACHE_WINDOW = 100;
-const GROUP_SCORE_MAX_EQUAL_EVIDENCE_BONUS = 0.3;
-const ARCHIVE_ROOT_ID = "meta:root";
-function isWikiGraphObjectUri(uri) {
-  return uri.startsWith(WIKI_GRAPH_URI_PREFIX);
-}
-function normalizeWikiGraphObjectUri(uri) {
-  return uri;
-}
-const BROAD_FIND_LENS_HINT = {
-  lenses: {
-    chapter: "book outline and chapter titles",
-    chunk: "source text ranges",
-    entity: "indexed entities",
-    node: "topology / LLM Wiki structure",
-    triple: "knowledge graph statements"
-  },
-  message: "Choose scope URI lenses such as /chapter, /chunk, /entity, or /triple for broad search."
-};
-function createPhraseSearch(query) {
-  const needle = query.trim().toLowerCase();
-  if (needle === "") {
-    return void 0;
-  }
-  return {
-    match: "all",
-    terms: [needle]
-  };
-}
-function matchText(value, search) {
-  const lower = value.toLowerCase();
-  const matchedTerms = search.terms.filter((term) => lower.includes(term));
-  const missingTerms = search.terms.filter((term) => !lower.includes(term));
-  if (search.match === "all" && missingTerms.length > 0) {
-    return void 0;
-  }
-  if (search.match === "any" && matchedTerms.length === 0) {
-    return void 0;
-  }
-  const [snippetNeedle] = matchedTerms;
-  if (snippetNeedle === void 0) {
-    return void 0;
-  }
-  return {
-    matchCount: matchedTerms.length,
-    matchedTerms,
-    missingTerms,
-    score: matchedTerms.length / search.terms.length
-  };
-}
-function createFindMatchFields(match) {
-  return {
-    matchCount: match.matchCount,
-    matchedTerms: match.matchedTerms,
-    missingTerms: match.missingTerms,
-    score: match.score
-  };
-}
-function aggregateEvidenceScores(scores) {
-  const rankedScores = [...scores].filter((score) => score > 0).sort((left, right) => right - left).slice(0, GROUP_SCORE_EVIDENCE_LIMIT);
-  const [bestScore] = rankedScores;
-  if (bestScore === void 0) {
-    return 0;
-  }
-  const evidenceDecayFactor = GROUP_SCORE_MAX_EQUAL_EVIDENCE_BONUS / calculateEvidenceDecayBase();
-  return rankedScores.reduce(
-    (total, score, index) => total + score * (index === 0 ? 1 : evidenceDecayFactor / Math.log2(index + 2)),
-    0
-  );
-}
-function calculateEvidenceDecayBase() {
-  let total = 0;
-  for (let rank = 2; rank <= GROUP_SCORE_EVIDENCE_LIMIT; rank += 1) {
-    total += 1 / Math.log2(rank + 1);
-  }
-  return total;
-}
-function compareFindEvidenceHits(left, right) {
-  const scoreComparison = (right.score ?? 0) - (left.score ?? 0);
-  if (scoreComparison !== 0) {
-    return scoreComparison;
-  }
-  if (left.position === void 0) {
-    return right.position === void 0 ? 0 : 1;
-  }
-  if (right.position === void 0) {
-    return -1;
-  }
-  return compareArchivePositions(left.position, right.position);
-}
-function getSnippetNeedle(match) {
-  const [needle] = match.matchedTerms;
-  if (needle === void 0) {
-    throw new Error("Internal error: missing matched search term.");
-  }
-  return needle;
-}
-function createFindResult(query, hits, options, terms = createSearchTerms(query), lens = options.types === void 0 ? "broad" : "typed") {
-  const ranked = createRankedFindResult(query, hits, options, terms, lens);
-  const start = decodeFindCursor(options.cursor);
-  const items = ranked.items.slice(start, start + ranked.limit);
-  const nextOffset = start + items.length;
-  return {
-    ...ranked,
-    items,
-    nextCursor: nextOffset < ranked.items.length ? encodeFindCursor(nextOffset) : null
-  };
-}
-function createRankedFindResult(query, hits, options, terms = createSearchTerms(query), lens = options.types === void 0 ? "broad" : "typed") {
-  const order = options.order ?? "doc-asc";
-  const limit = options.limit ?? DEFAULT_FIND_LIMIT;
-  const chapters = options.chapters ?? null;
-  const match = options.match ?? "any";
-  const types = options.types ?? null;
-  const ids = options.ids ?? null;
-  const filtered = groupFindHitsByObject(hits).filter((hit) => matchesFindId(hit, ids)).filter((hit) => matchesFindChapter(hit, chapters)).filter((hit) => matchesFindType(hit, types)).filter((hit) => matchesTriplePattern(hit, options.triplePattern)).sort((left, right) => compareSearchHits(left, right, order));
-  return {
-    chapters,
-    items: filtered,
-    lens,
-    lensHint: lens === "broad" ? BROAD_FIND_LENS_HINT : null,
-    limit,
-    match,
-    nextCursor: null,
-    order,
-    query,
-    terms,
-    types
-  };
-}
-function groupFindHitsByObject(hits) {
-  const hitsById = /* @__PURE__ */ new Map();
-  for (const hit of hits) {
-    const values = hitsById.get(hit.id) ?? [];
-    values.push(hit);
-    hitsById.set(hit.id, values);
-  }
-  return [...hitsById.values()].map(groupObjectEvidenceHits);
-}
-function groupObjectEvidenceHits(evidenceHits) {
-  const rankedHits = [...evidenceHits].sort(compareFindEvidenceHits);
-  const [best] = rankedHits;
-  if (best === void 0) {
-    throw new Error("Internal error: search result candidate is empty.");
-  }
-  if (rankedHits.length === 1) {
-    return best;
-  }
-  return {
-    ...best,
-    matchCount: Math.max(...rankedHits.map((hit) => hit.matchCount ?? 0)),
-    matchedTerms: mergeStringLists(
-      rankedHits.flatMap((hit) => hit.matchedTerms ?? [])
-    ),
-    missingTerms: mergeStringLists(
-      rankedHits.flatMap((hit) => hit.missingTerms ?? [])
-    ),
-    score: aggregateEvidenceScores(rankedHits.map((hit) => hit.score ?? 0))
-  };
-}
-function mergeStringLists(values) {
-  return [...new Set(values)];
-}
-function createCollectionResult(hits, options) {
-  const order = options.order ?? "doc-asc";
-  const limit = options.limit ?? DEFAULT_FIND_LIMIT;
-  const chapters = options.chapters ?? null;
-  const ids = options.ids ?? null;
-  const types = options.types ?? null;
-  const start = decodeFindCursor(options.cursor);
-  const filtered = hits.filter((hit) => matchesFindId(hit, ids)).filter((hit) => matchesFindChapter(hit, chapters)).filter((hit) => matchesCollectionType(hit, types)).filter((hit) => matchesTriplePattern(hit, options.triplePattern)).sort((left, right) => compareListHits(left, right, order));
-  const items = filtered.slice(start, start + limit);
-  const nextOffset = start + items.length;
-  return {
-    chapters,
-    ids,
-    items,
-    limit,
-    nextCursor: nextOffset < filtered.length ? encodeFindCursor(nextOffset) : null,
-    order,
-    types
-  };
-}
-function matchesFindId(hit, ids) {
-  return ids === null || ids.includes(hit.id);
-}
-function matchesFindChapter(hit, chapters) {
-  if (chapters === null) {
-    return true;
-  }
-  return hit.chapter !== void 0 && chapters.includes(hit.chapter);
-}
-function matchesFindType(hit, types) {
-  if (types === null) {
-    return true;
-  }
-  if (hit.type === "chapter-title" && types.includes("chapter")) {
-    return true;
-  }
-  return isFindFilterType(hit.type) && types.includes(hit.type);
-}
-function matchesCollectionType(hit, types) {
-  return types === null || isCollectionType(hit.type) && types.includes(hit.type);
-}
-function matchesTriplePattern(hit, pattern) {
-  if (pattern === void 0 || hit.type !== "triple") {
-    return true;
-  }
-  const triple = parseTripleHitUri(hit.id);
-  if (triple === void 0) {
-    return false;
-  }
-  return (pattern.subjectQid === void 0 || pattern.subjectQid === triple.subjectQid) && (pattern.predicate === void 0 || pattern.predicate === triple.predicate) && (pattern.objectQid === void 0 || pattern.objectQid === triple.objectQid);
-}
-function parseTripleHitUri(uri) {
-  const match = /^wikg:\/\/triple\/(Q[1-9][0-9]*)\/([^/]+)\/(Q[1-9][0-9]*)$/u.exec(uri);
-  if (match?.[1] === void 0 || match[2] === void 0 || match[3] === void 0) {
-    return void 0;
-  }
-  return {
-    objectQid: match[3],
-    predicate: decodeURIComponent(match[2]),
-    subjectQid: match[1]
-  };
-}
-function compareSearchHits(left, right, order) {
-  const direction = order === "doc-asc" ? 1 : -1;
-  const relevance = compareNumbers(getSearchBucket(left.type), getSearchBucket(right.type)) || compareNumbers(right.score ?? 0, left.score ?? 0) || compareNumbers(right.matchCount ?? 0, left.matchCount ?? 0);
-  const position = compareNumbers(
-    getPositionDocumentOrder(left),
-    getPositionDocumentOrder(right)
-  ) || compareNumbers(getPositionChapter(left), getPositionChapter(right)) || compareNumbers(getPositionFragment(left), getPositionFragment(right)) || compareNumbers(getPositionSentence(left), getPositionSentence(right)) || compareNumbers(getTypeOrder(left.type), getTypeOrder(right.type)) || left.id.localeCompare(right.id);
-  return relevance || position * direction;
-}
-function compareListHits(left, right, order) {
-  const direction = order === "doc-asc" ? 1 : -1;
-  const bucketComparison = compareNumbers(getListBucket(left.type), getListBucket(right.type)) || compareListBucketItems(left, right);
-  if (bucketComparison !== 0) {
-    return bucketComparison;
-  }
-  return compareListPosition(left, right) * direction;
-}
-function compareListBucketItems(left, right) {
-  const leftBucket = getListBucket(left.type);
-  if (leftBucket !== getListBucket(right.type)) {
-    return 0;
-  }
-  if (leftBucket === 0) {
-    return compareNumbers(right.score ?? 0, left.score ?? 0);
-  }
-  return 0;
-}
-function compareListPosition(left, right) {
-  return compareNumbers(
-    getPositionDocumentOrder(left),
-    getPositionDocumentOrder(right)
-  ) || compareNumbers(getPositionChapter(left), getPositionChapter(right)) || compareNumbers(getPositionFragment(left), getPositionFragment(right)) || compareNumbers(getPositionSentence(left), getPositionSentence(right)) || compareNumbers(getTypeOrder(left.type), getTypeOrder(right.type)) || left.id.localeCompare(right.id);
-}
-function getListBucket(type) {
-  switch (type) {
-    case "entity":
-    case "triple":
-      return 0;
-    case "node":
-      return 1;
-    case "summary":
-      return 2;
-    case "source":
-    case "fragment":
-      return 3;
-    case "chapter-title":
-    case "chapter":
-    case "chapter-tree":
-    case "meta":
-      return 4;
-  }
-}
-function getSearchBucket(type) {
-  switch (type) {
-    case "chapter-title":
-      return 0;
-    case "entity":
-    case "triple":
-      return 1;
-    case "node":
-      return 2;
-    case "source":
-    case "summary":
-      return 3;
-    case "chapter":
-    case "chapter-tree":
-    case "meta":
-    case "fragment":
-      throw new Error(`Unsupported search result bucket type: ${type}`);
-  }
-}
-function createSearchTerms(query) {
-  return query.trim().toLowerCase().split(/\s+/u).filter((term) => term !== "");
-}
-function getPositionChapter(hit) {
-  return hit.position?.chapter ?? Number.MAX_SAFE_INTEGER;
-}
-function getPositionDocumentOrder(hit) {
-  return hit.position?.documentOrder ?? hit.position?.chapter ?? Number.MAX_SAFE_INTEGER;
-}
-function getPositionFragment(hit) {
-  return hit.position?.fragment ?? 0;
-}
-function getPositionSentence(hit) {
-  return hit.position?.sentence ?? 0;
-}
-function getTypeOrder(type) {
-  switch (type) {
-    case "chapter-title":
-    case "chapter":
-      return 0;
-    case "chapter-tree":
-      return 1;
-    case "entity":
-      return 2;
-    case "triple":
-      return 3;
-    case "summary":
-      return 4;
-    case "node":
-      return 5;
-    case "source":
-      return 6;
-    case "fragment":
-      return 6;
-    case "meta":
-      return 7;
-  }
-}
-function createNodePosition(sentenceIds, documentOrders) {
-  const [first] = [...sentenceIds].sort(compareSentenceIds);
-  return first === void 0 ? void 0 : createSentencePosition(first, documentOrders);
-}
-function createSentencePosition(sentenceId, documentOrders) {
-  return {
-    chapter: sentenceId[0],
-    documentOrder: documentOrders?.get(sentenceId[0]) ?? sentenceId[0],
-    fragment: sentenceId[1],
-    sentence: sentenceId[1]
-  };
-}
-function compareSentenceIds(left, right, documentOrders) {
-  return compareNumbers(
-    documentOrders?.get(left[0]) ?? left[0],
-    documentOrders?.get(right[0]) ?? right[0]
-  ) || compareNumbers(left[0], right[0]) || compareNumbers(left[1], right[1]);
-}
-function compareArchivePositions(left, right) {
-  return compareNumbers(
-    left.documentOrder ?? left.chapter,
-    right.documentOrder ?? right.chapter
-  ) || compareNumbers(left.chapter, right.chapter) || compareNumbers(left.fragment ?? 0, right.fragment ?? 0) || compareNumbers(left.sentence ?? 0, right.sentence ?? 0);
-}
-function compareNumbers(left, right) {
-  return left === right ? 0 : left < right ? -1 : 1;
-}
-function isFindFilterType(type) {
-  return type === "chapter" || type === "chapter-title" || type === "entity" || type === "fragment" || type === "meta" || type === "node" || type === "source" || type === "summary" || type === "triple";
-}
-function isCollectionType(type) {
-  return type === "chapter" || type === "chapter-title" || type === "entity" || type === "fragment" || type === "meta" || type === "node" || type === "source" || type === "summary" || type === "triple";
-}
-function parseFindLens(value) {
-  if (value === "broad" || value === "exact" || value === "typed") {
-    return value;
-  }
-  throw new Error("Invalid cached search session.");
-}
-function parseFindMatch(value) {
-  if (value === "all" || value === "any") {
-    return value;
-  }
-  throw new Error("Invalid cached search session.");
-}
-function parseFindTypes(values) {
-  if (values === null) {
-    return null;
-  }
-  return values.map((value) => {
-    if (value === "entity" || value === "fragment" || value === "meta" || value === "node" || value === "source" || value === "summary" || value === "chapter" || value === "chapter-title" || value === "triple") {
-      return value;
-    }
-    throw new Error("Invalid cached search session.");
-  });
-}
-function encodeFindCursor(offset) {
-  return Buffer.from(JSON.stringify({ offset, v: 1 })).toString("base64url");
-}
-function decodeFindCursor(cursor) {
-  if (cursor === void 0) {
-    return 0;
-  }
-  try {
-    const parsed = JSON.parse(
-      Buffer.from(cursor, "base64url").toString("utf8")
-    );
-    if (typeof parsed === "object" && parsed !== null && "v" in parsed && "offset" in parsed && parsed.v === 1 && Number.isInteger(parsed.offset) && typeof parsed.offset === "number" && parsed.offset >= 0) {
-      return parsed.offset;
-    }
-  } catch {
-    throw new Error("Invalid search cursor.");
-  }
-  throw new Error("Invalid search cursor.");
-}
-function isFindCursor(cursor) {
-  try {
-    decodeFindCursor(cursor);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function createSnippet(value, needle) {
-  const collapsed = value.replace(/\s+/g, " ").trim();
-  if (needle === void 0) {
-    return collapsed.length > 180 ? `${collapsed.slice(0, 177)}...` : collapsed;
-  }
-  const index = collapsed.toLowerCase().indexOf(needle);
-  if (index < 0) {
-    return collapsed.length > 180 ? `${collapsed.slice(0, 177)}...` : collapsed;
-  }
-  const start = Math.max(0, index - 60);
-  const end = Math.min(collapsed.length, index + needle.length + 120);
-  const prefix = start === 0 ? "" : "...";
-  const suffix = end === collapsed.length ? "" : "...";
-  return `${prefix}${collapsed.slice(start, end)}${suffix}`;
-}
-function formatMetaSummary(meta) {
-  if (meta === void 0) {
-    return "[missing]";
-  }
-  return [meta.title, meta.authors.join(", "), meta.publisher].filter((value) => value !== null && value !== "").join(" / ");
-}
-function formatMetaTitle(meta) {
-  return meta?.title ?? "Archive metadata";
-}
-function createMetaPage(meta) {
-  return {
-    ...meta?.authors === void 0 || meta.authors.length === 0 ? {} : { authors: meta.authors },
-    ...meta?.description === void 0 || meta.description === null ? {} : { description: meta.description },
-    ...meta?.publisher === void 0 || meta.publisher === null ? {} : { publisher: meta.publisher },
-    title: formatMetaTitle(meta)
-  };
-}
-function formatMetaText(meta) {
-  const page = createMetaPage(meta);
-  return [
-    `title: ${page.title}`,
-    page.authors === void 0 ? void 0 : `authors: ${page.authors.join(", ")}`,
-    page.publisher === void 0 ? void 0 : `publisher: ${page.publisher}`,
-    page.description === void 0 ? void 0 : `description: ${page.description}`
-  ].filter(isDefined).join("\n");
-}
-function formatWeight(weight) {
-  return Number.isInteger(weight) ? String(weight) : weight.toFixed(3);
-}
-function isDefined(value) {
-  return value !== void 0 && value !== null;
-}
-export {
-  clearDirtyArchiveSearchIndex,
-  createArchiveSearchIndexFingerprint,
-  findArchiveObjects,
-  formatChapterId,
-  formatChapterTitleId,
-  formatEdgeId,
-  formatFragmentId,
-  formatNodeId,
-  formatSummaryId,
-  getArchiveIndex,
-  grepArchiveObjects,
-  isArchiveSearchIndexCurrent,
-  listAllArchiveLinks,
-  listArchiveCollection,
-  listArchiveEvidence,
-  listArchiveLinks,
-  listArchiveObjects,
-  listRelatedArchiveObjects,
-  packArchiveContext,
-  readArchivePage,
-  readArchiveSearchIndexStatus,
-  readArchiveText,
-  rebuildArchiveSearchIndex
-};
-//# sourceMappingURL=archive-view.js.map