wiki-graph-core 0.3.1

package/dist/archive/query/search-cache.js

@@ -0,0 +1,1248 @@
+import { createHash } from "crypto";
+import { stat } from "fs/promises";
+import { join } from "path";
+import { resolveWikiGraphCacheDirectoryPath } from "../../common/wiki-graph-dir.js";
+import { getNumber, getString } from "../../document/database.js";
+import { openSharedStateDatabase } from "../../document/index.js";
+import { isNodeError } from "../../utils/node-error.js";
+const SEARCH_EVIDENCE_KIND = {
+  mention: 1,
+  mentionLink: 2,
+  chunk: 3
+};
+const SEARCH_SESSION_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS search_sessions (
+  session_id TEXT PRIMARY KEY,
+  archive_key TEXT NOT NULL,
+  query TEXT NOT NULL,
+  options_json TEXT NOT NULL,
+  terms_json TEXT NOT NULL,
+  lens TEXT NOT NULL,
+  match TEXT NOT NULL,
+  object_caches_populated INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL,
+  expires_at INTEGER NOT NULL,
+  accessed_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS search_results (
+  session_id TEXT NOT NULL,
+  rank INTEGER NOT NULL,
+  item_json TEXT NOT NULL,
+  PRIMARY KEY (session_id, rank)
+);
+
+CREATE TABLE IF NOT EXISTS predicate_dictionary (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  value TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE IF NOT EXISTS search_evidence_hit_events (
+  session_id TEXT NOT NULL,
+  evidence_kind INTEGER NOT NULL,
+  evidence_id TEXT NOT NULL,
+  chapter_id INTEGER NOT NULL,
+  sentence_index INTEGER NOT NULL,
+  score REAL NOT NULL,
+  PRIMARY KEY (
+    session_id,
+    evidence_kind,
+    evidence_id,
+    chapter_id,
+    sentence_index
+  )
+);
+
+CREATE INDEX IF NOT EXISTS idx_search_evidence_hit_events_evidence_rank
+ON search_evidence_hit_events(session_id, evidence_kind, evidence_id, score DESC, chapter_id, sentence_index);
+
+CREATE INDEX IF NOT EXISTS idx_search_evidence_hit_events_sentence
+ON search_evidence_hit_events(session_id, chapter_id, sentence_index, evidence_kind, evidence_id);
+
+CREATE TABLE IF NOT EXISTS search_entity_hits (
+  session_id TEXT NOT NULL,
+  qid TEXT NOT NULL,
+  property_top_scores_json TEXT NOT NULL DEFAULT '[]',
+  evidence_top_scores_json TEXT NOT NULL DEFAULT '[]',
+  property_score REAL NOT NULL DEFAULT 0,
+  evidence_score REAL NOT NULL DEFAULT 0,
+  result_score REAL NOT NULL DEFAULT 0,
+  PRIMARY KEY (session_id, qid)
+);
+
+CREATE INDEX IF NOT EXISTS idx_search_entity_hits_rank
+ON search_entity_hits(session_id, result_score DESC, qid);
+
+CREATE TABLE IF NOT EXISTS search_triple_hits (
+  session_id TEXT NOT NULL,
+  subject_qid TEXT NOT NULL,
+  predicate_id INTEGER NOT NULL,
+  object_qid TEXT NOT NULL,
+  evidence_top_scores_json TEXT NOT NULL DEFAULT '[]',
+  result_score REAL NOT NULL DEFAULT 0,
+  PRIMARY KEY (session_id, subject_qid, predicate_id, object_qid),
+  FOREIGN KEY (predicate_id) REFERENCES predicate_dictionary(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_search_triple_hits_rank
+ON search_triple_hits(session_id, result_score DESC, subject_qid, predicate_id, object_qid);
+
+CREATE TABLE IF NOT EXISTS search_chunk_hits (
+  session_id TEXT NOT NULL,
+  chunk_id INTEGER NOT NULL,
+  property_top_scores_json TEXT NOT NULL DEFAULT '[]',
+  evidence_top_scores_json TEXT NOT NULL DEFAULT '[]',
+  property_score REAL NOT NULL DEFAULT 0,
+  evidence_score REAL NOT NULL DEFAULT 0,
+  result_score REAL NOT NULL DEFAULT 0,
+  PRIMARY KEY (session_id, chunk_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_search_chunk_hits_rank
+ON search_chunk_hits(session_id, result_score DESC, chunk_id);
+
+CREATE INDEX IF NOT EXISTS idx_search_sessions_archive
+ON search_sessions(archive_key, session_id);
+
+CREATE INDEX IF NOT EXISTS idx_search_sessions_expires
+ON search_sessions(expires_at);
+
+CREATE INDEX IF NOT EXISTS idx_search_sessions_prune
+ON search_sessions(accessed_at DESC, created_at DESC, session_id);
+`;
+const SEARCH_RANKING_VERSION = 6;
+const SEARCH_SESSION_MAX_COUNT = 500;
+const SEARCH_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+const SEARCH_TOP_SCORE_COUNT = 10;
+async function readCachedSearchSessionPage(input, offset, limit) {
+  const sessionId = createSearchSessionId(input);
+  if (!await hasSearchSession(sessionId, input.archiveKey)) {
+    return void 0;
+  }
+  return await readSearchSessionPage(
+    sessionId,
+    offset,
+    limit,
+    input.archiveKey
+  );
+}
+async function readCachedEntitySearchSessionPage(input, offset, limit) {
+  const sessionId = createEntitySearchSessionId(input);
+  if (!await hasSearchSession(sessionId, input.archiveKey)) {
+    return void 0;
+  }
+  return await readEntitySearchSessionPage(
+    sessionId,
+    offset,
+    limit,
+    input.archiveKey
+  );
+}
+async function createSearchSession(input) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const now = Date.now();
+    const sessionId = createSearchSessionId(input);
+    const optionsJSON = JSON.stringify({
+      chapters: input.chapters,
+      order: input.order,
+      types: input.types
+    });
+    await database.transaction(async () => {
+      await deleteSearchSession(database, sessionId);
+      await database.run(
+        `
+          INSERT INTO search_sessions (
+            session_id, archive_key, query, options_json, terms_json, lens,
+            match, created_at, expires_at, accessed_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+        [
+          sessionId,
+          input.archiveKey,
+          input.query,
+          optionsJSON,
+          JSON.stringify(input.terms),
+          input.lens,
+          input.match,
+          now,
+          now + SEARCH_SESSION_TTL_MS,
+          now
+        ]
+      );
+      for (const [index, item] of (input.items ?? []).entries()) {
+        await database.run(
+          `
+            INSERT INTO search_results (session_id, rank, item_json)
+            VALUES (?, ?, ?)
+          `,
+          [sessionId, index, JSON.stringify(item)]
+        );
+      }
+      for (const event of input.evidenceEvents ?? []) {
+        await insertSearchEvidenceHitEvent(database, sessionId, event);
+      }
+      for (const hit of input.entityHits ?? []) {
+        await upsertSearchEntityHit(database, sessionId, hit);
+      }
+      for (const hit of input.tripleHits ?? []) {
+        await upsertSearchTripleHit(database, sessionId, hit);
+      }
+      for (const hit of input.chunkHits ?? []) {
+        await upsertSearchChunkHit(database, sessionId, hit);
+      }
+    });
+    return sessionId;
+  } finally {
+    await database.close();
+  }
+}
+async function readSearchSessionObjectBucketPage(sessionId, bucket, after, limit) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const entityRows = await readSearchSessionEntityBucketRows(
+      database,
+      sessionId,
+      after,
+      limit + 1
+    );
+    const tripleRows = await readSearchSessionTripleBucketRows(
+      database,
+      sessionId,
+      after,
+      limit + 1
+    );
+    return [...entityRows, ...tripleRows].sort(compareObjectBucketHits).slice(0, limit + 1);
+  } finally {
+    await database.close();
+  }
+}
+async function readSearchSessionChunkBucketPage(sessionId, after, limit) {
+  const database = await openSearchSessionDatabase();
+  try {
+    return await database.queryAll(
+      `
+        SELECT
+          chunk_id,
+          result_score
+        FROM search_chunk_hits
+        WHERE session_id = ?
+          ${after === void 0 ? "" : `
+                AND (
+                  result_score < ?
+                  OR (result_score = ? AND chunk_id > ?)
+                )
+              `}
+        ORDER BY result_score DESC, chunk_id
+        LIMIT ?
+      `,
+      [
+        sessionId,
+        ...after === void 0 ? [] : [after.score, after.score, after.chunkId],
+        limit + 1
+      ],
+      (row) => {
+        const chunkId = getNumber(row, "chunk_id");
+        return {
+          field: "title",
+          id: `wikg://chunk/${chunkId}`,
+          score: getNumber(row, "result_score"),
+          snippet: `chunk ${chunkId}`,
+          title: `chunk ${chunkId}`,
+          type: "node"
+        };
+      }
+    );
+  } finally {
+    await database.close();
+  }
+}
+async function createEntitySearchSession(input) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const now = Date.now();
+    const sessionId = createEntitySearchSessionId(input);
+    const optionsJSON = JSON.stringify({
+      chapters: input.chapters,
+      order: input.order,
+      types: input.types
+    });
+    await database.transaction(async () => {
+      await deleteSearchSession(database, sessionId);
+      await database.run(
+        `
+          INSERT INTO search_sessions (
+            session_id, archive_key, query, options_json, terms_json, lens,
+            match, created_at, expires_at, accessed_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `,
+        [
+          sessionId,
+          input.archiveKey,
+          input.query,
+          optionsJSON,
+          JSON.stringify(input.terms),
+          input.lens,
+          input.match,
+          now,
+          now + SEARCH_SESSION_TTL_MS,
+          now
+        ]
+      );
+      for (const event of input.evidenceEvents ?? []) {
+        await insertSearchEvidenceHitEvent(database, sessionId, event);
+      }
+      for (const hit of input.entityHits ?? []) {
+        await upsertSearchEntityHit(database, sessionId, hit);
+      }
+      for (const hit of input.tripleHits ?? []) {
+        await upsertSearchTripleHit(database, sessionId, hit);
+      }
+      for (const hit of input.chunkHits ?? []) {
+        await upsertSearchChunkHit(database, sessionId, hit);
+      }
+    });
+    return sessionId;
+  } finally {
+    await database.close();
+  }
+}
+async function populateSearchSessionObjectCaches(input) {
+  const database = await openSearchSessionDatabase();
+  try {
+    await database.transaction(async () => {
+      for (const event of input.evidenceEvents ?? []) {
+        await insertSearchEvidenceHitEvent(database, input.sessionId, event);
+      }
+      for (const hit of input.entityHits ?? []) {
+        await upsertSearchEntityHit(database, input.sessionId, hit);
+      }
+      for (const hit of input.tripleHits ?? []) {
+        await upsertSearchTripleHit(database, input.sessionId, hit);
+      }
+      for (const hit of input.chunkHits ?? []) {
+        await upsertSearchChunkHit(database, input.sessionId, hit);
+      }
+      await database.run(
+        `
+          UPDATE search_sessions
+          SET object_caches_populated = 1
+          WHERE session_id = ?
+        `,
+        [input.sessionId]
+      );
+    });
+  } finally {
+    await database.close();
+  }
+}
+async function deleteArchiveSearchSessions(archiveKey) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const sessionIds = await database.queryAll(
+      `
+        SELECT session_id
+        FROM search_sessions
+        WHERE archive_key = ?
+      `,
+      [archiveKey],
+      (row) => getString(row, "session_id")
+    );
+    await database.transaction(async () => {
+      for (const sessionId of sessionIds) {
+        await deleteSearchSession(database, sessionId);
+      }
+      await deleteUnusedPredicates(database);
+    });
+  } finally {
+    await database.close();
+  }
+}
+async function runSearchCacheGc(context) {
+  const databasePath = getSearchSessionDatabasePath();
+  const beforeBytes = await readFileSize(databasePath);
+  const database = await openSearchSessionDatabase();
+  try {
+    const scanned = await database.queryOne(
+      "SELECT COUNT(*) AS count FROM search_sessions",
+      void 0,
+      (row) => getNumber(row, "count")
+    );
+    const expiredSessionIds = context.force ? await listAllSearchSessionIds(database) : await listExpiredSearchSessionIds(database, context.now);
+    const prunedSessionIds = context.force ? [] : await listPrunedSearchSessionIds(database);
+    const sessionIds = [
+      .../* @__PURE__ */ new Set([...expiredSessionIds, ...prunedSessionIds])
+    ].sort();
+    if (!context.dryRun && sessionIds.length > 0) {
+      await database.transaction(async () => {
+        for (const sessionId of sessionIds) {
+          await deleteSearchSession(database, sessionId);
+        }
+        await deleteUnusedPredicates(database);
+      });
+      await database.run("VACUUM");
+    }
+    const afterBytes = await readFileSize(databasePath);
+    return {
+      freedBytes: Math.max(0, beforeBytes - afterBytes),
+      removed: sessionIds.length,
+      scanned: scanned ?? 0
+    };
+  } finally {
+    await database.close();
+  }
+}
+async function readSearchSessionPage(sessionId, offset, limit, expectedArchiveKey, expectedCreatedAt) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const session = await readSearchSessionMetadata(
+      database,
+      sessionId,
+      expectedArchiveKey,
+      expectedCreatedAt
+    );
+    await touchSearchSession(database, sessionId);
+    const rows = await database.queryAll(
+      `
+        SELECT rank, item_json
+        FROM search_results
+        WHERE session_id = ? AND rank >= ?
+        ORDER BY rank
+        LIMIT ?
+      `,
+      [sessionId, offset, limit + 1],
+      (row) => ({
+        item: parseSearchResultItem(getString(row, "item_json")),
+        rank: getNumber(row, "rank")
+      })
+    );
+    const items = rows.slice(0, limit).map((row) => row.item);
+    const last = rows.at(limit - 1);
+    return {
+      chapters: session.options.chapters,
+      items,
+      lens: session.lens,
+      match: session.match,
+      nextCursor: rows.length > limit && last !== void 0 ? encodeSearchSessionCursor(
+        sessionId,
+        last.rank + 1,
+        session.createdAt
+      ) : null,
+      query: session.query,
+      sessionId,
+      terms: session.terms,
+      types: session.options.types
+    };
+  } finally {
+    await database.close();
+  }
+}
+async function readEntitySearchSessionPage(sessionId, offset, limit, expectedArchiveKey, expectedCreatedAt) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const session = await readSearchSessionMetadata(
+      database,
+      sessionId,
+      expectedArchiveKey,
+      expectedCreatedAt
+    );
+    await touchSearchSession(database, sessionId);
+    const rows = await database.queryAll(
+      `
+        SELECT
+          qid,
+          result_score
+        FROM search_entity_hits
+        WHERE session_id = ?
+        ORDER BY result_score DESC, qid
+        LIMIT ? OFFSET ?
+      `,
+      [sessionId, limit + 1, offset],
+      mapEntitySearchObjectRow
+    );
+    const items = rows.slice(0, limit);
+    const nextOffset = offset + items.length;
+    return {
+      chapters: session.options.chapters,
+      items,
+      lens: session.lens,
+      match: session.match,
+      nextCursor: rows.length > limit ? encodeSearchSessionCursor(sessionId, nextOffset, session.createdAt) : null,
+      query: session.query,
+      sessionId,
+      terms: session.terms,
+      types: session.options.types
+    };
+  } finally {
+    await database.close();
+  }
+}
+async function readSearchSessionDescriptor(sessionId, expectedArchiveKey) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const session = await readSearchSessionMetadata(
+      database,
+      sessionId,
+      expectedArchiveKey
+    );
+    await touchSearchSession(database, sessionId);
+    return {
+      chapters: session.options.chapters,
+      createdAt: session.createdAt,
+      lens: session.lens,
+      match: session.match,
+      objectCachesPopulated: session.objectCachesPopulated,
+      query: session.query,
+      sessionId,
+      terms: session.terms,
+      types: session.options.types
+    };
+  } finally {
+    await database.close();
+  }
+}
+async function readSearchSessionMetadataForCursor(sessionId, expectedArchiveKey, expectedCreatedAt) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const session = await readSearchSessionMetadata(
+      database,
+      sessionId,
+      expectedArchiveKey,
+      expectedCreatedAt
+    );
+    await touchSearchSession(database, sessionId);
+    return {
+      chapters: session.options.chapters,
+      createdAt: session.createdAt,
+      lens: session.lens,
+      match: session.match,
+      objectCachesPopulated: session.objectCachesPopulated,
+      query: session.query,
+      sessionId,
+      terms: session.terms,
+      types: session.options.types
+    };
+  } finally {
+    await database.close();
+  }
+}
+async function readEntitySearchEvidenceMentions(sessionId, mentionIds, limit) {
+  if (mentionIds.length === 0) {
+    return [];
+  }
+  const database = await openSearchSessionDatabase();
+  try {
+    const placeholders = mentionIds.map(() => "?").join(", ");
+    return await database.queryAll(
+      `
+        SELECT
+          event.evidence_id AS mention_id,
+          event.score AS score
+        FROM search_evidence_hit_events AS event
+        WHERE event.session_id = ?
+          AND event.evidence_kind = ?
+          AND event.evidence_id IN (${placeholders})
+        ORDER BY event.score DESC, event.chapter_id, event.sentence_index,
+          event.evidence_id
+        LIMIT ?
+      `,
+      [sessionId, SEARCH_EVIDENCE_KIND.mention, ...mentionIds, limit],
+      (row) => ({
+        mentionId: getString(row, "mention_id"),
+        score: getNumber(row, "score")
+      })
+    );
+  } finally {
+    await database.close();
+  }
+}
+function encodeSearchSessionCursor(sessionId, offset, createdAt) {
+  return Buffer.from(
+    JSON.stringify({ createdAt, offset, sessionId, v: 3 })
+  ).toString("base64url");
+}
+function encodeBucketSearchSessionCursor(sessionId, cursor, createdAt) {
+  return Buffer.from(
+    JSON.stringify({ createdAt, cursor, sessionId, v: 4 })
+  ).toString("base64url");
+}
+function decodeBucketSearchSessionCursor(cursor) {
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(cursor, "base64url").toString("utf8")
+    );
+    if (typeof parsed === "object" && parsed !== null && "createdAt" in parsed && "cursor" in parsed && "sessionId" in parsed && "v" in parsed && parsed.v === 4 && typeof parsed.createdAt === "number" && Number.isInteger(parsed.createdAt) && parsed.createdAt >= 0 && typeof parsed.sessionId === "string" && parsed.sessionId !== "" && isBucketSearchCursor(parsed.cursor)) {
+      return {
+        createdAt: parsed.createdAt,
+        cursor: parsed.cursor,
+        sessionId: parsed.sessionId
+      };
+    }
+  } catch {
+    throw new Error("Invalid search cursor.");
+  }
+  throw new Error("Invalid search cursor.");
+}
+function decodeSearchSessionCursor(cursor) {
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(cursor, "base64url").toString("utf8")
+    );
+    if (typeof parsed === "object" && parsed !== null && "offset" in parsed && "sessionId" in parsed && "createdAt" in parsed && "v" in parsed && parsed.v === 3 && typeof parsed.sessionId === "string" && parsed.sessionId !== "" && typeof parsed.createdAt === "number" && Number.isInteger(parsed.createdAt) && parsed.createdAt >= 0 && typeof parsed.offset === "number" && Number.isInteger(parsed.offset) && parsed.offset >= 0) {
+      return {
+        createdAt: parsed.createdAt,
+        offset: parsed.offset,
+        sessionId: parsed.sessionId
+      };
+    }
+    if (typeof parsed === "object" && parsed !== null && "offset" in parsed && "sessionId" in parsed && "v" in parsed && parsed.v === 2 && typeof parsed.sessionId === "string" && parsed.sessionId !== "" && typeof parsed.offset === "number" && Number.isInteger(parsed.offset) && parsed.offset >= 0) {
+      return { offset: parsed.offset, sessionId: parsed.sessionId };
+    }
+  } catch {
+    throw new Error("Invalid search cursor.");
+  }
+  throw new Error("Invalid search cursor.");
+}
+async function openSearchSessionDatabase() {
+  return await openSharedStateDatabase(
+    getSearchSessionDatabasePath(),
+    SEARCH_SESSION_SCHEMA_SQL
+  );
+}
+function getSearchSessionDatabasePath() {
+  return join(getSearchSessionStateDirectoryPath(), "search-sessions.sqlite");
+}
+function getSearchSessionStateDirectoryPath() {
+  return resolveWikiGraphCacheDirectoryPath();
+}
+async function listExpiredSearchSessionIds(database, now) {
+  return await database.queryAll(
+    `
+      SELECT session_id
+      FROM search_sessions
+      WHERE expires_at < ?
+    `,
+    [now],
+    (row) => getString(row, "session_id")
+  );
+}
+async function listAllSearchSessionIds(database) {
+  return await database.queryAll(
+    "SELECT session_id FROM search_sessions",
+    void 0,
+    (row) => getString(row, "session_id")
+  );
+}
+async function hasSearchSession(sessionId, archiveKey) {
+  const database = await openSearchSessionDatabase();
+  try {
+    const row = await database.queryOne(
+      `
+        SELECT session_id
+        FROM search_sessions
+        WHERE session_id = ? AND archive_key = ?
+          AND expires_at >= ?
+      `,
+      [sessionId, archiveKey, Date.now()],
+      () => true
+    );
+    return row === true;
+  } finally {
+    await database.close();
+  }
+}
+async function deleteSearchSession(database, sessionId) {
+  await database.run("DELETE FROM search_results WHERE session_id = ?", [
+    sessionId
+  ]);
+  await database.run(
+    "DELETE FROM search_evidence_hit_events WHERE session_id = ?",
+    [sessionId]
+  );
+  await database.run("DELETE FROM search_entity_hits WHERE session_id = ?", [
+    sessionId
+  ]);
+  await database.run("DELETE FROM search_triple_hits WHERE session_id = ?", [
+    sessionId
+  ]);
+  await database.run("DELETE FROM search_chunk_hits WHERE session_id = ?", [
+    sessionId
+  ]);
+  await database.run("DELETE FROM search_sessions WHERE session_id = ?", [
+    sessionId
+  ]);
+}
+async function deleteUnusedPredicates(database) {
+  await database.run(`
+    DELETE FROM predicate_dictionary
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM search_triple_hits
+      WHERE search_triple_hits.predicate_id = predicate_dictionary.id
+    )
+  `);
+}
+async function insertSearchEvidenceHitEvent(database, sessionId, event) {
+  await database.run(
+    `
+      INSERT OR REPLACE INTO search_evidence_hit_events (
+        session_id,
+        evidence_kind,
+        evidence_id,
+        chapter_id,
+        sentence_index,
+        score
+      )
+      VALUES (?, ?, ?, ?, ?, ?)
+    `,
+    [
+      sessionId,
+      event.evidenceKind,
+      event.evidenceId,
+      event.chapterId,
+      event.sentenceIndex,
+      event.score
+    ]
+  );
+}
+async function upsertSearchEntityHit(database, sessionId, hit) {
+  const current = await database.queryOne(
+    `
+      SELECT property_top_scores_json, evidence_top_scores_json
+      FROM search_entity_hits
+      WHERE session_id = ? AND qid = ?
+    `,
+    [sessionId, hit.qid],
+    (row) => ({
+      evidenceTopScores: parseNumberArray(
+        getString(row, "evidence_top_scores_json")
+      ),
+      propertyTopScores: parseNumberArray(
+        getString(row, "property_top_scores_json")
+      )
+    })
+  );
+  const propertyTopScores = mergeTopScores(
+    current?.propertyTopScores ?? [],
+    hit.propertyTopScores ?? []
+  );
+  const evidenceTopScores = mergeTopScores(
+    current?.evidenceTopScores ?? [],
+    hit.evidenceTopScores ?? []
+  );
+  const propertyScore = aggregateCachedScores(propertyTopScores);
+  const evidenceScore = aggregateCachedScores(evidenceTopScores);
+  const resultScore = propertyScore + evidenceScore;
+  await database.run(
+    `
+      INSERT INTO search_entity_hits (
+        session_id,
+        qid,
+        property_top_scores_json,
+        evidence_top_scores_json,
+        property_score,
+        evidence_score,
+        result_score
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id, qid) DO UPDATE SET
+        property_top_scores_json = excluded.property_top_scores_json,
+        evidence_top_scores_json = excluded.evidence_top_scores_json,
+        property_score = excluded.property_score,
+        evidence_score = excluded.evidence_score,
+        result_score = excluded.result_score
+    `,
+    [
+      sessionId,
+      hit.qid,
+      JSON.stringify(propertyTopScores),
+      JSON.stringify(evidenceTopScores),
+      propertyScore,
+      evidenceScore,
+      resultScore
+    ]
+  );
+}
+async function upsertSearchTripleHit(database, sessionId, hit) {
+  const predicateId = await getOrCreatePredicateId(database, hit.predicate);
+  const current = await database.queryOne(
+    `
+      SELECT evidence_top_scores_json
+      FROM search_triple_hits
+      WHERE session_id = ?
+        AND subject_qid = ?
+        AND predicate_id = ?
+        AND object_qid = ?
+    `,
+    [sessionId, hit.subjectQid, predicateId, hit.objectQid],
+    (row) => ({
+      evidenceTopScores: parseNumberArray(
+        getString(row, "evidence_top_scores_json")
+      )
+    })
+  );
+  const evidenceTopScores = mergeTopScores(
+    current?.evidenceTopScores ?? [],
+    hit.evidenceTopScores
+  );
+  const resultScore = aggregateCachedScores(evidenceTopScores);
+  await database.run(
+    `
+      INSERT INTO search_triple_hits (
+        session_id,
+        subject_qid,
+        predicate_id,
+        object_qid,
+        evidence_top_scores_json,
+        result_score
+      )
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id, subject_qid, predicate_id, object_qid)
+      DO UPDATE SET
+        evidence_top_scores_json = excluded.evidence_top_scores_json,
+        result_score = excluded.result_score
+    `,
+    [
+      sessionId,
+      hit.subjectQid,
+      predicateId,
+      hit.objectQid,
+      JSON.stringify(evidenceTopScores),
+      resultScore
+    ]
+  );
+}
+async function upsertSearchChunkHit(database, sessionId, hit) {
+  const current = await database.queryOne(
+    `
+      SELECT property_top_scores_json, evidence_top_scores_json
+      FROM search_chunk_hits
+      WHERE session_id = ? AND chunk_id = ?
+    `,
+    [sessionId, hit.chunkId],
+    (row) => ({
+      evidenceTopScores: parseNumberArray(
+        getString(row, "evidence_top_scores_json")
+      ),
+      propertyTopScores: parseNumberArray(
+        getString(row, "property_top_scores_json")
+      )
+    })
+  );
+  const propertyTopScores = mergeTopScores(
+    current?.propertyTopScores ?? [],
+    hit.propertyTopScores ?? []
+  );
+  const evidenceTopScores = mergeTopScores(
+    current?.evidenceTopScores ?? [],
+    hit.evidenceTopScores ?? []
+  );
+  const propertyScore = aggregateCachedScores(propertyTopScores);
+  const evidenceScore = aggregateCachedScores(evidenceTopScores);
+  const resultScore = propertyScore + evidenceScore;
+  await database.run(
+    `
+      INSERT INTO search_chunk_hits (
+        session_id,
+        chunk_id,
+        property_top_scores_json,
+        evidence_top_scores_json,
+        property_score,
+        evidence_score,
+        result_score
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id, chunk_id) DO UPDATE SET
+        property_top_scores_json = excluded.property_top_scores_json,
+        evidence_top_scores_json = excluded.evidence_top_scores_json,
+        property_score = excluded.property_score,
+        evidence_score = excluded.evidence_score,
+        result_score = excluded.result_score
+    `,
+    [
+      sessionId,
+      hit.chunkId,
+      JSON.stringify(propertyTopScores),
+      JSON.stringify(evidenceTopScores),
+      propertyScore,
+      evidenceScore,
+      resultScore
+    ]
+  );
+}
+async function getOrCreatePredicateId(database, predicate) {
+  await database.run(
+    `
+      INSERT OR IGNORE INTO predicate_dictionary(value)
+      VALUES (?)
+    `,
+    [predicate]
+  );
+  const id = await database.queryOne(
+    `
+      SELECT id
+      FROM predicate_dictionary
+      WHERE value = ?
+    `,
+    [predicate],
+    (row) => getNumber(row, "id")
+  );
+  if (id === void 0) {
+    throw new Error("Failed to create predicate dictionary entry.");
+  }
+  return id;
+}
+async function listPrunedSearchSessionIds(database) {
+  return await database.queryAll(
+    `
+      SELECT session_id
+      FROM search_sessions
+      ORDER BY accessed_at DESC, created_at DESC, session_id
+      LIMIT -1 OFFSET ?
+    `,
+    [SEARCH_SESSION_MAX_COUNT],
+    (row) => getString(row, "session_id")
+  );
+}
+async function readFileSize(path) {
+  try {
+    return (await stat(path)).size;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return 0;
+    }
+    throw error;
+  }
+}
+async function readSearchSessionMetadata(database, sessionId, expectedArchiveKey, expectedCreatedAt) {
+  const session = await database.queryOne(
+    `
+      SELECT
+        session_id,
+        query,
+        options_json,
+        terms_json,
+        lens,
+        match,
+        object_caches_populated,
+        created_at,
+        expires_at
+      FROM search_sessions
+      WHERE session_id = ?
+        ${expectedArchiveKey === void 0 ? "" : "AND archive_key = ?"}
+        ${expectedCreatedAt === void 0 ? "" : "AND created_at = ?"}
+    `,
+    [
+      sessionId,
+      ...expectedArchiveKey === void 0 ? [] : [expectedArchiveKey],
+      ...expectedCreatedAt === void 0 ? [] : [expectedCreatedAt]
+    ],
+    (row) => ({
+      createdAt: getNumber(row, "created_at"),
+      expiresAt: getNumber(row, "expires_at"),
+      lens: getString(row, "lens"),
+      match: getString(row, "match"),
+      objectCachesPopulated: getNumber(row, "object_caches_populated") !== 0,
+      options: parseSessionOptions(getString(row, "options_json")),
+      query: getString(row, "query"),
+      sessionId: getString(row, "session_id"),
+      terms: parseStringArray(getString(row, "terms_json"))
+    })
+  );
+  if (session === void 0 || session.expiresAt < Date.now()) {
+    throw new Error("Search cursor expired. Run the search again.");
+  }
+  return session;
+}
+async function touchSearchSession(database, sessionId) {
+  await database.run(
+    `
+      UPDATE search_sessions
+      SET accessed_at = ?, expires_at = ?
+      WHERE session_id = ?
+    `,
+    [Date.now(), Date.now() + SEARCH_SESSION_TTL_MS, sessionId]
+  );
+}
+function createEntitySearchSessionId(input) {
+  return createHash("sha256").update(
+    JSON.stringify({
+      archiveKey: input.archiveKey,
+      entity: true,
+      lens: input.lens,
+      match: input.match,
+      order: input.order,
+      rankingVersion: SEARCH_RANKING_VERSION,
+      revisionScope: input.revisionScope,
+      scope: normalizeSearchSessionScope(input.chapters),
+      terms: input.terms,
+      types: normalizeSearchSessionTypes(input.types)
+    })
+  ).digest("hex");
+}
+function mapEntitySearchObjectRow(row) {
+  const qid = getString(row, "qid");
+  return {
+    evidence: {
+      nextCursor: null,
+      shown: 0,
+      sources: [],
+      total: 0
+    },
+    field: "title",
+    id: `wikg://entity/${qid}`,
+    score: getNumber(row, "result_score"),
+    snippet: qid,
+    title: qid,
+    type: "entity"
+  };
+}
+async function readSearchSessionEntityBucketRows(database, sessionId, after, limit) {
+  return await database.queryAll(
+    `
+      SELECT
+        qid,
+        result_score
+      FROM search_entity_hits
+      WHERE session_id = ?
+        ${after === void 0 ? "" : `
+              AND (
+                result_score < ?
+                OR (
+                  result_score = ?
+                  AND (
+                    ? < ?
+                    OR (? = ? AND qid > ?)
+                  )
+                )
+              )
+            `}
+      ORDER BY result_score DESC, qid
+      LIMIT ?
+    `,
+    [
+      sessionId,
+      ...after === void 0 ? [] : [
+        after.score,
+        after.score,
+        getObjectBucketKindOrder(after.kind),
+        SEARCH_OBJECT_BUCKET_KIND.entity,
+        getObjectBucketKindOrder(after.kind),
+        SEARCH_OBJECT_BUCKET_KIND.entity,
+        after.id
+      ],
+      limit
+    ],
+    mapEntitySearchObjectRow
+  );
+}
+async function readSearchSessionTripleBucketRows(database, sessionId, after, limit) {
+  return await database.queryAll(
+    `
+      SELECT
+        search_triple_hits.subject_qid AS subject_qid,
+        predicate_dictionary.value AS predicate,
+        search_triple_hits.object_qid AS object_qid,
+        search_triple_hits.result_score AS result_score
+      FROM search_triple_hits
+      JOIN predicate_dictionary
+        ON predicate_dictionary.id = search_triple_hits.predicate_id
+      WHERE search_triple_hits.session_id = ?
+        ${after === void 0 ? "" : `
+              AND (
+                search_triple_hits.result_score < ?
+                OR (
+                  search_triple_hits.result_score = ?
+                  AND (
+                    ? < ?
+                    OR (
+                      ? = ?
+                      AND (
+                        search_triple_hits.subject_qid || char(31) ||
+                        predicate_dictionary.value || char(31) ||
+                        search_triple_hits.object_qid
+                      ) > ?
+                    )
+                  )
+                )
+              )
+            `}
+      ORDER BY search_triple_hits.result_score DESC,
+        search_triple_hits.subject_qid,
+        predicate_dictionary.value,
+        search_triple_hits.object_qid
+      LIMIT ?
+    `,
+    [
+      sessionId,
+      ...after === void 0 ? [] : [
+        after.score,
+        after.score,
+        getObjectBucketKindOrder(after.kind),
+        SEARCH_OBJECT_BUCKET_KIND.triple,
+        getObjectBucketKindOrder(after.kind),
+        SEARCH_OBJECT_BUCKET_KIND.triple,
+        after.id
+      ],
+      limit
+    ],
+    (row) => {
+      const subjectQid = getString(row, "subject_qid");
+      const predicate = getString(row, "predicate");
+      const objectQid = getString(row, "object_qid");
+      const title = `${subjectQid} ${predicate} ${objectQid}`;
+      return {
+        field: "content",
+        id: `wikg://triple/${subjectQid}/${encodeURIComponent(predicate)}/${objectQid}`,
+        score: getNumber(row, "result_score"),
+        snippet: title,
+        title,
+        triple: {
+          objectLabel: objectQid,
+          predicate,
+          subjectLabel: subjectQid
+        },
+        type: "triple"
+      };
+    }
+  );
+}
+function compareObjectBucketHits(left, right) {
+  return (right.score ?? 0) - (left.score ?? 0) || getObjectBucketKindOrder(getObjectBucketHitKind(left)) - getObjectBucketKindOrder(getObjectBucketHitKind(right)) || getObjectBucketHitKey(left).localeCompare(getObjectBucketHitKey(right));
+}
+const SEARCH_OBJECT_BUCKET_KIND = {
+  entity: 1,
+  triple: 2
+};
+function getObjectBucketHitKind(hit) {
+  return hit.type === "triple" ? "triple" : "entity";
+}
+function getObjectBucketHitKey(hit) {
+  if (hit.type !== "triple") {
+    return hit.id.slice("wikg://entity/".length);
+  }
+  return [
+    hit.triple?.subjectLabel ?? "",
+    hit.triple?.predicate ?? "",
+    hit.triple?.objectLabel ?? ""
+  ].join("");
+}
+function getObjectBucketKindOrder(kind) {
+  return SEARCH_OBJECT_BUCKET_KIND[kind];
+}
+function isBucketSearchCursor(value) {
+  if (typeof value !== "object" || value === null || !("bucket" in value)) {
+    return false;
+  }
+  const cursor = value;
+  switch (cursor.bucket) {
+    case 0:
+      return cursor.key === void 0 || isChapterTitleCursorKey(cursor.key);
+    case 1:
+      return cursor.key === void 0 || isObjectCursorKey(cursor.key);
+    case 2:
+      return cursor.key === void 0 || isChunkCursorKey(cursor.key);
+    case 3:
+      return cursor.key === void 0 || isTextCursorKey(cursor.key);
+    default:
+      return false;
+  }
+}
+function isChapterTitleCursorKey(value) {
+  return typeof value === "object" && value !== null && typeof value.chapterId === "number" && typeof value.score === "number";
+}
+function isObjectCursorKey(value) {
+  return typeof value === "object" && value !== null && typeof value.id === "string" && (value.kind === "entity" || value.kind === "triple") && typeof value.score === "number";
+}
+function isChunkCursorKey(value) {
+  return typeof value === "object" && value !== null && typeof value.chunkId === "number" && typeof value.score === "number";
+}
+function isTextCursorKey(value) {
+  return typeof value === "object" && value !== null && typeof value.chapterId === "number" && typeof value.kind === "number" && typeof value.rank === "number" && typeof value.sentenceIndex === "number";
+}
+function createSearchSessionId(input) {
+  return createHash("sha256").update(
+    JSON.stringify({
+      archiveKey: input.archiveKey,
+      entity: false,
+      lens: input.lens,
+      match: input.match,
+      order: input.order,
+      rankingVersion: SEARCH_RANKING_VERSION,
+      revisionScope: input.revisionScope,
+      scope: normalizeSearchSessionScope(input.chapters),
+      terms: input.terms,
+      types: normalizeSearchSessionTypes(input.types)
+    })
+  ).digest("hex");
+}
+function normalizeSearchSessionScope(chapters) {
+  return chapters === null ? null : [...new Set(chapters)].sort(compareNumbers);
+}
+function normalizeSearchSessionTypes(types) {
+  return types === null ? null : [...new Set(types)].sort();
+}
+function compareNumbers(left, right) {
+  return left - right;
+}
+function parseSearchResultItem(value) {
+  const parsed = JSON.parse(value);
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("Invalid cached search result.");
+  }
+  return parsed;
+}
+function parseSessionOptions(value) {
+  const parsed = JSON.parse(value);
+  if (typeof parsed === "object" && parsed !== null && "chapters" in parsed && "types" in parsed && (parsed.chapters === null || Array.isArray(parsed.chapters) && parsed.chapters.every((chapter) => typeof chapter === "number")) && (parsed.types === null || Array.isArray(parsed.types) && parsed.types.every((type) => typeof type === "string"))) {
+    return {
+      chapters: parsed.chapters,
+      types: parsed.types
+    };
+  }
+  throw new Error("Invalid cached search session.");
+}
+function parseStringArray(value) {
+  const parsed = JSON.parse(value);
+  if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+    return parsed;
+  }
+  throw new Error("Invalid cached search session.");
+}
+function parseNumberArray(value) {
+  const parsed = JSON.parse(value);
+  if (Array.isArray(parsed) && parsed.every((item) => typeof item === "number" && Number.isFinite(item))) {
+    return parsed.map((item) => Number(item));
+  }
+  return [];
+}
+function mergeTopScores(current, incoming) {
+  return [...current, ...incoming].filter((score) => Number.isFinite(score)).sort((left, right) => right - left).slice(0, SEARCH_TOP_SCORE_COUNT);
+}
+function aggregateCachedScores(scores) {
+  return scores.slice(0, SEARCH_TOP_SCORE_COUNT).reduce((total, score, index) => total + score / Math.log2(index + 2), 0);
+}
+export {
+  SEARCH_EVIDENCE_KIND,
+  createEntitySearchSession,
+  createSearchSession,
+  decodeBucketSearchSessionCursor,
+  decodeSearchSessionCursor,
+  deleteArchiveSearchSessions,
+  encodeBucketSearchSessionCursor,
+  encodeSearchSessionCursor,
+  populateSearchSessionObjectCaches,
+  readCachedEntitySearchSessionPage,
+  readCachedSearchSessionPage,
+  readEntitySearchEvidenceMentions,
+  readEntitySearchSessionPage,
+  readSearchSessionChunkBucketPage,
+  readSearchSessionDescriptor,
+  readSearchSessionMetadataForCursor,
+  readSearchSessionObjectBucketPage,
+  readSearchSessionPage,
+  runSearchCacheGc
+};
+//# sourceMappingURL=search-cache.js.map