@equationalapplications/core-llm-wiki 7.12.0 → 7.13.1

package/dist/{chunk-KN4XSLLB.mjs → chunk-PCRYIUV5.mjs}

@@ -44,6 +44,8 @@ var SQLITE_RESULT_CODE_NAMES = {
   // prefix and we normalize it back to the symbolic name so callers can branch on
   // the same string the rest of the ecosystem uses.
   2067: "SQLITE_CONSTRAINT_UNIQUE",
+  // 267 = SQLITE_CORRUPT_VTAB — a corrupt FTS5 shadow table (ftsCorruptionClass).
+  267: "SQLITE_CORRUPT_VTAB",
   100: "SQLITE_ROW",
   101: "SQLITE_DONE"
 };
@@ -999,7 +1001,7 @@ var UnavailableIndexStrategy = class {
   hasIndexedEntity(_entityId) {
     return false;
   }
-  async drain() {
+  async drain(_opts) {
   }
 };
 
@@ -1045,24 +1047,31 @@ var _SearchService = class _SearchService {
   isKeywordAvailable() {
     return !(this.indexStrategy instanceof UnavailableIndexStrategy);
   }
+  /** True when the installed strategy drains a durable ledger (FTS5, or the degraded stand-in). */
+  hasLedger() {
+    return this.indexStrategy.drain !== void 0;
+  }
   /**
    * One serialized drain turn for strategies with a durable ledger. Like
    * sync(), it never rejects: the keyword index is rebuildable, and a failed
-   * drain leaves the ledger rows in place for the next turn.
+   * drain leaves the ledger rows in place for the next turn. Resolves false
+   * when the drain failed.
    */
-  drainTurn(entityId) {
+  drainTurn(entityId, opts) {
     const work = this.syncChain.then(async () => {
       try {
         try {
-          await this.indexStrategy.drain();
+          await this.indexStrategy.drain(opts);
         } finally {
           this.evictCache(entityId);
         }
+        return true;
       } catch (err) {
         console.warn(`[WikiMemory] search index drain failed for ${entityId ?? "*"}:`, err);
+        return false;
       }
     });
-    this.syncChain = work;
+    this.syncChain = work.then(() => void 0);
     return work;
   }
   /**
@@ -1072,9 +1081,18 @@ var _SearchService = class _SearchService {
    * Rebuilds are serialized per instance and never reject: the keyword index
    * is a rebuildable cache over SQLite, so degraded keyword search is the
    * correct failure mode and killing the host process is not.
+   *
+   * With a ledger strategy, `sync()` runs one full quantum bounded by
+   * `opts.deadline`; `sync(entityId)` is a write turn (ledger only).
+   * `opts.ids` are the caller's touched ids: a ledger strategy drains them
+   * first, to completion; MiniSearch ignores them and rebuilds the entity in
+   * one scan.
    */
-  async sync(entityId) {
-    if (this.indexStrategy.drain) return this.drainTurn(entityId);
+  async sync(entityId, opts) {
+    if (this.indexStrategy.drain) {
+      await this.drainTurn(entityId, entityId === void 0 ? { mode: "full", deadline: opts?.deadline, ids: opts?.ids } : { mode: "ledger", entityId, ids: opts?.ids });
+      return;
+    }
     const work = this.syncChain.then(async () => {
       try {
         try {
@@ -1115,13 +1133,17 @@ var _SearchService = class _SearchService {
    * — including on an empty `ids` list, which is a no-op only for an entity
    * the index already tracks, and even then one that waits for rebuilds
    * already queued on the chain.
+   *
+   * Resolves false only when a ledger drain failed: the caller's ids were not
+   * applied (their ledger rows remain), so a caller holding them retries.
    */
   async syncEntries(entityId, ids) {
-    if (this.indexStrategy.drain) return this.drainTurn(entityId);
+    if (this.indexStrategy.drain) return this.drainTurn(entityId, { mode: "ledger", entityId, ids: [...new Set(ids)] });
     const uniqueIds = [...new Set(ids)];
     const indexed = this.indexStrategy.hasIndexedEntity?.(entityId);
     if (uniqueIds.length === 0 && !this.staleEntities.has(entityId) && indexed === true) {
-      return this.syncChain;
+      await this.syncChain;
+      return true;
     }
     const work = this.syncChain.then(async () => {
       try {
@@ -1150,7 +1172,8 @@ var _SearchService = class _SearchService {
       }
     });
     this.syncChain = work;
-    return work;
+    await work;
+    return true;
   }
   /**
    * Forces the entity's next syncEntries to rebuild it in full. For writes core
@@ -1166,11 +1189,13 @@ var _SearchService = class _SearchService {
    * so only those entities are rebuilt. Each rebuild still takes its own turn
    * on the sync chain, and like syncEntries this never rejects. With nothing
    * stale it resolves at once, without waiting on work already on the chain.
+   * Resolves false only when a ledger drain failed (see syncEntries).
    */
-  async syncStale() {
-    if (this.indexStrategy.drain) return this.drainTurn();
+  async syncStale(opts) {
+    if (this.indexStrategy.drain) return this.drainTurn(void 0, { mode: "full", ids: opts?.ids });
     const ids = [...this.staleEntities];
     await Promise.all(ids.map((id) => this.syncEntries(id, [])));
+    return true;
   }
   /**
    * Clears the parsed vector cache. Useful for mid-loop flush guarantees
@@ -2660,7 +2685,8 @@ var IngestionService = class {
    *
    * @returns Counts: nodesWritten (validated nodes persisted), edgesWritten
    *   (manifest-valid edges persisted), superseded (prior facts soft-deleted
-   *   plus prior source-ref edges hard-deleted).
+   *   plus prior source-ref edges hard-deleted), and supersededFactIds (the
+   *   ids of those soft-deleted facts, for the caller's post-commit index sync).
    *
    * Node-ownership pre-flight (spec §3, REQ-GRAPH-01): the first statement
    * is `assertGraphNodeOwnership(entityId, params.nodes, tx)`, which runs
@@ -2788,7 +2814,8 @@ var IngestionService = class {
     return {
       nodesWritten: wikiFacts.length,
       edgesWritten: edgesInsertedCount,
-      superseded: deletedFactIds.length + deletedEdgeCount
+      superseded: deletedFactIds.length + deletedEdgeCount,
+      supersededFactIds: deletedFactIds
     };
   }
   /**
@@ -3580,6 +3607,143 @@ async function createTemporalIndexesIfColumnsExist(db, prefix) {
   }
 }
 
+// src/services/search/fts5Sql.ts
+var FTS5_STATE_KEY = "fts5_index_state";
+var FTS5_DRAIN_CHUNK = 500;
+var FTS5_SWEEP_CHUNK = 500;
+var FTS5_RETIRED_TABLES_KEY = "fts5_retired_tables";
+var FTS5_RETIRED_COUNTER_KEY = "fts5_retired_counter";
+var FTS5_RECLAIM_MERGE_PAGES = 500;
+function retiredTableName(p, n) {
+  return `${p}entries_fts_retired_${n}`;
+}
+function isRetiredTableName(p, name) {
+  return typeof name === "string" && name.startsWith(`${p}entries_fts_retired_`) && /^\d+$/.test(name.slice(`${p}entries_fts_retired_`.length));
+}
+var FTS5_REBUILD_WM_KEY = "fts5_rebuild_wm";
+var FTS5_REBUILD_SNAPSHOT_KEY = "fts5_rebuild_snapshot";
+var FTS5_SWEEP_CURSOR_KEY = "fts5_orphan_sweep_cursor";
+function fts5TriggerNames(prefix) {
+  return [`${prefix}entries_fts_ai`, `${prefix}entries_fts_au`, `${prefix}entries_fts_ad`];
+}
+function tagsExpr(col) {
+  return `CASE WHEN json_valid(${col}) THEN
+      CASE WHEN json_type(${col}) = 'array' THEN
+        (SELECT group_concat(CASE type WHEN 'true' THEN 'true' WHEN 'false' THEN 'false'
+                                       WHEN 'null' THEN '' ELSE value END, ' ')
+           FROM json_each(${col}))
+      ELSE ${col} END
+    ELSE ${col} END`;
+}
+function fts5TablesDdl(p) {
+  return `
+CREATE VIRTUAL TABLE IF NOT EXISTS ${p}entries_fts USING fts5(
+  id UNINDEXED, entity_id UNINDEXED, title, body, tags,
+  tokenize = 'porter unicode61'
+);
+CREATE TABLE IF NOT EXISTS ${p}fts_map (
+  fts_rowid INTEGER PRIMARY KEY,
+  id TEXT NOT NULL UNIQUE,
+  entity_id TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS ${p}fts_map_entity ON ${p}fts_map(entity_id);
+CREATE TABLE IF NOT EXISTS ${p}fts_pending (
+  seq INTEGER PRIMARY KEY,
+  entity_id TEXT NOT NULL,
+  id TEXT NOT NULL
+);`;
+}
+function fts5TriggersDdl(p) {
+  const [ai, au, ad] = fts5TriggerNames(p);
+  return `
+CREATE TRIGGER IF NOT EXISTS ${ai} AFTER INSERT ON ${p}entries BEGIN
+  INSERT INTO ${p}fts_pending (entity_id, id) VALUES (NEW.entity_id, NEW.id);
+END;
+CREATE TRIGGER IF NOT EXISTS ${au}
+AFTER UPDATE OF id, entity_id, title, body, tags, deleted_at ON ${p}entries BEGIN
+  INSERT INTO ${p}fts_pending (entity_id, id) VALUES (OLD.entity_id, OLD.id);
+  INSERT INTO ${p}fts_pending (entity_id, id)
+    SELECT NEW.entity_id, NEW.id WHERE NEW.id <> OLD.id OR NEW.entity_id <> OLD.entity_id;
+END;
+CREATE TRIGGER IF NOT EXISTS ${ad} AFTER DELETE ON ${p}entries BEGIN
+  INSERT INTO ${p}fts_pending (entity_id, id) VALUES (OLD.entity_id, OLD.id);
+END;`;
+}
+function drainHiSql(p) {
+  return `SELECT max(seq) AS hi FROM (SELECT seq FROM ${p}fts_pending ORDER BY seq LIMIT ${FTS5_DRAIN_CHUNK})`;
+}
+function ledgerChunkSql(p, chunkIds, ledgerWhere) {
+  return [
+    `DELETE FROM ${p}entries_fts WHERE rowid IN (SELECT m.fts_rowid FROM ${p}fts_map m WHERE m.id IN (${chunkIds}))`,
+    `DELETE FROM ${p}fts_map WHERE id IN (${chunkIds})`,
+    `INSERT INTO ${p}fts_map (id, entity_id)
+       SELECT e.id, e.entity_id FROM ${p}entries e WHERE e.id IN (${chunkIds}) AND e.deleted_at IS NULL`,
+    `INSERT INTO ${p}entries_fts (rowid, id, entity_id, title, body, tags)
+       SELECT m.fts_rowid, e.id, e.entity_id, e.title, e.body, ${tagsExpr("e.tags")}
+       FROM ${p}fts_map m JOIN ${p}entries e ON e.id = m.id
+       WHERE m.id IN (${chunkIds})`,
+    `DELETE FROM ${p}fts_pending WHERE ${ledgerWhere}`
+  ];
+}
+function drainChunkSql(p) {
+  return ledgerChunkSql(p, `SELECT id FROM ${p}fts_pending WHERE seq <= ?`, "seq <= ?");
+}
+function fts5PendingIndexesDdl(p) {
+  return `
+CREATE INDEX IF NOT EXISTS ${p}fts_pending_id ON ${p}fts_pending(id);
+CREATE INDEX IF NOT EXISTS ${p}fts_pending_entity ON ${p}fts_pending(entity_id);`;
+}
+function idDrainChunkSql(p) {
+  return ledgerChunkSql(
+    p,
+    `SELECT id FROM ${p}fts_pending WHERE id IN (SELECT value FROM json_each(?))`,
+    "id IN (SELECT value FROM json_each(?))"
+  );
+}
+function idReindexChunkSql(p) {
+  return ledgerChunkSql(p, "SELECT value FROM json_each(?)", "id IN (SELECT value FROM json_each(?))");
+}
+function entityDrainHiSql(p) {
+  return `SELECT max(seq) AS hi FROM (SELECT seq FROM ${p}fts_pending WHERE entity_id = ? ORDER BY seq LIMIT ${FTS5_DRAIN_CHUNK})`;
+}
+function entityDrainChunkSql(p) {
+  return ledgerChunkSql(p, `SELECT id FROM ${p}fts_pending WHERE entity_id = ? AND seq <= ?`, "entity_id = ? AND seq <= ?");
+}
+function fts5LedgerDropSql(p) {
+  return [
+    ...fts5TriggerNames(p).map((n) => `DROP TRIGGER IF EXISTS ${n};`),
+    `DROP TABLE IF EXISTS ${p}fts_pending;`,
+    `DROP TABLE IF EXISTS ${p}fts_map;`
+  ].join("\n");
+}
+function windowHiSql(p) {
+  return `SELECT max(rowid) AS hi FROM (SELECT rowid FROM ${p}entries WHERE rowid > ? AND rowid <= ? ORDER BY rowid LIMIT ${FTS5_DRAIN_CHUNK})`;
+}
+function windowChunkSql(p) {
+  const chunkIds = `SELECT id FROM ${p}entries WHERE rowid > ? AND rowid <= ?`;
+  return [
+    `DELETE FROM ${p}entries_fts WHERE rowid IN (SELECT m.fts_rowid FROM ${p}fts_map m WHERE m.id IN (${chunkIds}))`,
+    `DELETE FROM ${p}fts_map WHERE id IN (${chunkIds})`,
+    `INSERT INTO ${p}fts_map (id, entity_id)
+       SELECT e.id, e.entity_id FROM ${p}entries e WHERE e.rowid > ? AND e.rowid <= ? AND e.deleted_at IS NULL`,
+    `INSERT INTO ${p}entries_fts (rowid, id, entity_id, title, body, tags)
+       SELECT m.fts_rowid, e.id, e.entity_id, e.title, e.body, ${tagsExpr("e.tags")}
+       FROM ${p}entries e JOIN ${p}fts_map m ON m.id = e.id
+       WHERE e.rowid > ? AND e.rowid <= ?`
+  ];
+}
+function sweepHiSql(p) {
+  return `SELECT max(fts_rowid) AS hi FROM (SELECT fts_rowid FROM ${p}fts_map WHERE fts_rowid > ? AND fts_rowid <= ? ORDER BY fts_rowid LIMIT ${FTS5_SWEEP_CHUNK})`;
+}
+function sweepChunkSql(p) {
+  const orphans = `SELECT m.fts_rowid FROM ${p}fts_map m
+     WHERE m.fts_rowid > ? AND m.fts_rowid <= ? AND NOT EXISTS (SELECT 1 FROM ${p}entries e WHERE e.id = m.id)`;
+  return [
+    `DELETE FROM ${p}entries_fts WHERE rowid IN (${orphans})`,
+    `DELETE FROM ${p}fts_map WHERE fts_rowid IN (${orphans})`
+  ];
+}
+
 // src/db/migrations.ts
 var MIGRATIONS = [
   {
@@ -3860,6 +4024,17 @@ var MIGRATIONS = [
     run: async (db, prefix) => {
       await createLegacySourceTypeIndex(db, prefix);
     }
+  },
+  {
+    version: 15,
+    description: "fts_pending(id) and fts_pending(entity_id) indexes for the ids-first and entity-targeted drains",
+    run: async (db, prefix) => {
+      const row = await db.getFirstAsync(
+        `SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = ?`,
+        [`${prefix}fts_pending`]
+      );
+      if (row?.n) await db.execAsync(fts5PendingIndexesDdl(prefix));
+    }
   }
 ];
 async function createLegacySourceTypeIndex(db, prefix) {
@@ -3967,6 +4142,44 @@ async function runSourceRefNormalize(db, prefix, meta) {
   await runPass(db, prefix, meta, "source_ref_index", SRI_WM_KEY, true);
 }
 
+// src/services/search/fts5Progress.ts
+async function writeRebuildStart(tx, prefix, meta) {
+  const e = await tx.getFirstAsync(`SELECT coalesce(max(rowid), 0) AS hi FROM ${prefix}entries`);
+  const m = await tx.getFirstAsync(`SELECT coalesce(max(fts_rowid), 0) AS hi FROM ${prefix}fts_map`);
+  await meta.setMeta(FTS5_REBUILD_WM_KEY, JSON.stringify({ rowid: 0, id: null }), tx);
+  await meta.setMeta(FTS5_REBUILD_SNAPSHOT_KEY, JSON.stringify({ entries: e?.hi ?? 0, map: m?.hi ?? 0 }), tx);
+  await meta.setMeta(FTS5_SWEEP_CURSOR_KEY, "0", tx);
+}
+async function readRebuildProgress(meta, tx) {
+  const wm = parseJsonObject(await meta.getMeta(FTS5_REBUILD_WM_KEY, tx));
+  const snap = parseJsonObject(await meta.getMeta(FTS5_REBUILD_SNAPSHOT_KEY, tx));
+  const rawCursor = await meta.getMeta(FTS5_SWEEP_CURSOR_KEY, tx);
+  const cursor = rawCursor === null ? Number.NaN : Number(rawCursor);
+  if (typeof wm?.rowid !== "number" || !(typeof wm.id === "string" || wm.id === null)) return null;
+  if (typeof snap?.entries !== "number" || typeof snap.map !== "number" || !Number.isFinite(cursor)) return null;
+  return { wm: { rowid: wm.rowid, id: wm.id }, snapshot: { entries: snap.entries, map: snap.map }, cursor };
+}
+async function reanchorRebuildFingerprint(tx, prefix, deletedIds) {
+  if (deletedIds.length === 0) return;
+  const metaValue = async (key) => (await tx.getFirstAsync(`SELECT value FROM ${prefix}meta WHERE key = ?`, [key]))?.value ?? null;
+  if (await metaValue(FTS5_STATE_KEY) !== "rebuilding") return;
+  const wm = parseJsonObject(await metaValue(FTS5_REBUILD_WM_KEY));
+  if (typeof wm?.rowid !== "number" || typeof wm.id !== "string" || !deletedIds.includes(wm.id)) return;
+  if ((await tx.getFirstAsync(`SELECT id FROM ${prefix}entries WHERE rowid = ?`, [wm.rowid]))?.id === wm.id) return;
+  const below = await tx.getFirstAsync(
+    `SELECT rowid, id FROM ${prefix}entries WHERE rowid < ? ORDER BY rowid DESC LIMIT 1`,
+    [wm.rowid]
+  );
+  const next = below ? { rowid: below.rowid, id: below.id } : { rowid: 0, id: null };
+  await tx.runAsync(`UPDATE ${prefix}meta SET value = ? WHERE key = ?`, [JSON.stringify(next), FTS5_REBUILD_WM_KEY]);
+}
+async function restartRebuildAfterVacuum(db, prefix, meta) {
+  await db.withTransactionAsync(async (tx) => {
+    if (await meta.getMeta(FTS5_STATE_KEY, tx) !== "rebuilding") return;
+    await writeRebuildStart(tx, prefix, meta);
+  });
+}
+
 // src/services/librarian/constants.ts
 var FUZZY_THRESHOLD = 0.5;
 var MIN_TOKENS_TO_QUALIFY = 3;
@@ -4899,6 +5112,7 @@ var MaintenanceService = class {
       if (vacuum) {
         await resetNormalizeWatermarks(this.metadataRepo);
         await this.metadataRepo.vacuum();
+        await restartRebuildAfterVacuum(this.db, this.prefix, this.metadataRepo);
       }
       await this.searchService.syncEntries(entityId, syncedIds);
       return { entries: deletedEntries, tasks: deletedTasks, events: deletedEvents };
@@ -6146,7 +6360,7 @@ var ImportExportService = class {
     if (merge) {
       await this.searchService.syncEntries(entityId, [...upsertedFactIds]);
     } else {
-      await this.searchService.sync(entityId);
+      await this.searchService.sync(entityId, { ids: [.../* @__PURE__ */ new Set([...upsertedFactIds, ...softDeletedFactIds])] });
     }
     for (const fact of bundle.facts) {
       if (!fact.deleted_at && upsertedFactIds.has(fact.id) && !factsWithPreservedBlob.has(fact.id)) {
@@ -7459,6 +7673,6 @@ var WriteService = class {
   }
 };
 
-export { BaseRepository, CURRENT_SCHEMA_VERSION, DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, DEFAULT_MAX_EMBED_CHARS, DiagnosticBuffer, EMBED_CHARS_CEILING, EmbeddingService, HEAL_ANCHORS_PER_CANDIDATE, HEAL_BATCH_SIZE, HEAL_MAX_FACT_BODY_CHARS_L3, HEAL_MAX_TASKS, HEAL_RECHECK_MS, HOOK_TIMEOUT_MARKER, ImportExportService, IngestionService, JobManager, MAX_EMBED_ATTEMPTS, MIGRATIONS, MaintenanceService, MetadataRepository, ONTOLOGY_BACKFILL_BATCH_SIZE, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, ONTOLOGY_BACKFILL_RECHECK_MS, ONTOLOGY_BACKFILL_SYSTEM_PROMPT, PromptService, PrunePartialFailureError, RetrievalService, SearchService, TemporalService, UnavailableIndexStrategy, UsageMeter, WikiBusyError, WikiDraftNotFound, WikiDuplicateHashError, WikiGraphNodeOwnershipConflict, WikiIngestEmptyError, WikiInvalidReadOptions, WikiMigrationRequiredError, WikiParseError, WikiSearchUnavailableError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiSupersedeError, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, createLegacySourceTypeIndex, detectSchemaVersion, edgeTripleAllowed, emptyManifest, entitySummaryMetaKey, extractSqliteCode, factTokenCost, generateId, isLiveAt, isWikiSearchUnavailableError, liveAtSql, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, packFactsByBudget, parseEmbedding, parseJsonArray, parseJsonObject, probePendingWork, resolveEdgeDefinitions, resolveGrounding, resolveNodeType, runSourceRefNormalize, safeSlice, setupDatabase, typeSatisfies, validateInlineEdges, validateManifest, writeNormalizeStamp };
-//# sourceMappingURL=chunk-KN4XSLLB.mjs.map
-//# sourceMappingURL=chunk-KN4XSLLB.mjs.map
+export { BaseRepository, CURRENT_SCHEMA_VERSION, DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, DEFAULT_MAX_EMBED_CHARS, DiagnosticBuffer, EMBED_CHARS_CEILING, EmbeddingService, FTS5_DRAIN_CHUNK, FTS5_REBUILD_SNAPSHOT_KEY, FTS5_REBUILD_WM_KEY, FTS5_RECLAIM_MERGE_PAGES, FTS5_RETIRED_COUNTER_KEY, FTS5_RETIRED_TABLES_KEY, FTS5_STATE_KEY, FTS5_SWEEP_CURSOR_KEY, HEAL_ANCHORS_PER_CANDIDATE, HEAL_BATCH_SIZE, HEAL_MAX_FACT_BODY_CHARS_L3, HEAL_MAX_TASKS, HEAL_RECHECK_MS, HOOK_TIMEOUT_MARKER, ImportExportService, IngestionService, JobManager, MAX_EMBED_ATTEMPTS, MIGRATIONS, MaintenanceService, MetadataRepository, ONTOLOGY_BACKFILL_BATCH_SIZE, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, ONTOLOGY_BACKFILL_RECHECK_MS, ONTOLOGY_BACKFILL_SYSTEM_PROMPT, PromptService, PrunePartialFailureError, RetrievalService, SearchService, TemporalService, UnavailableIndexStrategy, UsageMeter, WikiBusyError, WikiDraftNotFound, WikiDuplicateHashError, WikiGraphNodeOwnershipConflict, WikiIngestEmptyError, WikiInvalidReadOptions, WikiMigrationRequiredError, WikiParseError, WikiSearchUnavailableError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiSupersedeError, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, createLegacySourceTypeIndex, detectSchemaVersion, drainChunkSql, drainHiSql, edgeTripleAllowed, emptyManifest, entityDrainChunkSql, entityDrainHiSql, entitySummaryMetaKey, extractSqliteCode, factTokenCost, fts5LedgerDropSql, fts5PendingIndexesDdl, fts5TablesDdl, fts5TriggerNames, fts5TriggersDdl, generateId, idDrainChunkSql, idReindexChunkSql, isLiveAt, isRetiredTableName, isWikiSearchUnavailableError, liveAtSql, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, packFactsByBudget, parseEmbedding, parseJsonArray, parseJsonObject, probePendingWork, readRebuildProgress, reanchorRebuildFingerprint, resolveEdgeDefinitions, resolveGrounding, resolveNodeType, retiredTableName, runSourceRefNormalize, safeSlice, setupDatabase, sweepChunkSql, sweepHiSql, typeSatisfies, validateInlineEdges, validateManifest, windowChunkSql, windowHiSql, writeNormalizeStamp, writeRebuildStart };
+//# sourceMappingURL=chunk-PCRYIUV5.mjs.map
+//# sourceMappingURL=chunk-PCRYIUV5.mjs.map