@equationalapplications/core-llm-wiki 7.7.4 → 7.7.6

package/dist/{chunk-JV2OQ5CM.mjs → chunk-PBUZLSOM.mjs}

@@ -432,7 +432,31 @@ var _SearchService = class _SearchService {
      * auto-vacuum debt behind the TypeError in #64.
      */
     this.syncChain = Promise.resolve();
-    this.miniSearch = new MiniSearch({
+    /**
+     * Entities whose index may have drifted from SQLite: an incremental update
+     * failed part-way, or core wrote rows it could not index (upsertGraph runs in
+     * the host's transaction). Their next syncEntries rebuilds the entity in full.
+     * See spec 2026-09-28 §5.
+     */
+    this.staleEntities = /* @__PURE__ */ new Set();
+    /**
+     * Per-entity count of markStale() calls. A rebuild clears an entity's stale
+     * flag only when the count it snapshotted before its read still holds
+     * afterwards: markStale() runs inside the host's still-open transaction, so
+     * a call landing mid-read belongs to rows the read cannot have seen, and
+     * its flag must outlive the turn (#233 review).
+     */
+    this.staleEpochs = /* @__PURE__ */ new Map();
+    this.miniSearch = this.createMiniSearch();
+  }
+  /**
+   * A fresh index with the production options. clearAll() swaps one in because
+   * MiniSearch.removeAll() empties the index but leaves dirtCount (and its
+   * vacuum bookkeeping) at its old value, which would trip syncEntries'
+   * conditional vacuum early after a clear.
+   */
+  createMiniSearch() {
+    return new MiniSearch({
       fields: ["title", "body", "tags"],
       storeFields: ["entity_id"],
       // Vacuuming is driven explicitly at the end of each serialized rebuild
@@ -459,7 +483,19 @@ var _SearchService = class _SearchService {
     const work = this.syncChain.then(async () => {
       try {
         try {
+          const epochsBefore = new Map(this.staleEpochs);
           await this.rebuildIndex(entityId);
+          if (entityId) {
+            if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
+              this.staleEntities.delete(entityId);
+            }
+          } else {
+            for (const id of [...this.staleEntities]) {
+              if ((this.staleEpochs.get(id) ?? 0) === (epochsBefore.get(id) ?? 0)) {
+                this.staleEntities.delete(id);
+              }
+            }
+          }
           await this.miniSearch.vacuum();
         } finally {
           this.evictCache(entityId);
@@ -471,6 +507,68 @@ var _SearchService = class _SearchService {
     this.syncChain = work;
     return work;
   }
+  /**
+   * Re-indexes only `ids` for `entityId`: drops each from the index, then
+   * re-adds the ones still live in SQLite, so soft-deleted or missing ids end
+   * up absent. Costs O(ids), where sync(entityId) costs O(entity) — callers that
+   * know what a write touched use this so chunked imports stay linear (#232).
+   *
+   * Serialized with sync() on the same chain and, like it, never rejects. An
+   * entity that is stale or has never been indexed gets a full rebuild instead
+   * — 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.
+   */
+  async syncEntries(entityId, ids) {
+    const uniqueIds = [...new Set(ids)];
+    if (uniqueIds.length === 0 && !this.staleEntities.has(entityId) && this.miniSearchEntryIdsByEntity.has(entityId)) {
+      return this.syncChain;
+    }
+    const work = this.syncChain.then(async () => {
+      try {
+        try {
+          const epochsBefore = new Map(this.staleEpochs);
+          const needsRebuild = () => this.staleEntities.has(entityId) || !this.miniSearchEntryIdsByEntity.has(entityId);
+          if (!needsRebuild()) {
+            const rows = await this.entryRepo.findMiniSearchRowsByIds(entityId, uniqueIds);
+            const tracked = this.miniSearchEntryIdsByEntity.get(entityId);
+            if (tracked && !this.staleEntities.has(entityId)) {
+              for (const id of uniqueIds) {
+                if (tracked.delete(id) && this.miniSearch.has(id)) this.miniSearch.discard(id);
+              }
+              const documents = rows.map((row) => this.normalizeMiniSearchRow(row));
+              if (documents.length > 0) this.miniSearch.addAll(documents);
+              for (const document of documents) tracked.add(document.id);
+              if (this.miniSearch.dirtCount > 0) {
+                await this.miniSearch.vacuum();
+              }
+              return;
+            }
+          }
+          await this.rebuildIndex(entityId);
+          if ((this.staleEpochs.get(entityId) ?? 0) === (epochsBefore.get(entityId) ?? 0)) {
+            this.staleEntities.delete(entityId);
+          }
+          await this.miniSearch.vacuum();
+        } finally {
+          this.evictCache(entityId);
+        }
+      } catch (err) {
+        this.staleEntities.add(entityId);
+        console.warn(`[WikiMemory] search index incremental sync failed for ${entityId}:`, err);
+      }
+    });
+    this.syncChain = work;
+    return work;
+  }
+  /**
+   * Forces the entity's next syncEntries to rebuild it in full. For writes core
+   * cannot index itself, such as upsertGraph inside a host transaction.
+   */
+  markStale(entityId) {
+    this.staleEntities.add(entityId);
+    this.staleEpochs.set(entityId, (this.staleEpochs.get(entityId) ?? 0) + 1);
+  }
   /**
    * Clears the parsed vector cache. Useful for mid-loop flush guarantees
    * or memory pressure evictions.
@@ -487,8 +585,10 @@ var _SearchService = class _SearchService {
    */
   clearAll() {
     this.vectorCache.clear();
-    this.miniSearch.removeAll();
+    this.miniSearch = this.createMiniSearch();
     this.miniSearchEntryIdsByEntity.clear();
+    this.staleEntities.clear();
+    this.staleEpochs.clear();
   }
   /**
    * Executes a keyword search against the active MiniSearch index.
@@ -499,7 +599,7 @@ var _SearchService = class _SearchService {
       filter: (r) => entityIdSet.has(r.entity_id),
       combineWith: "OR"
     });
-    return results.slice(0, limit);
+    return results.sort((a, b) => this._compareSearchResults(a, b)).slice(0, limit);
   }
   /**
    * Pre-fetches MiniSearch scores for candidate hydration, used during hybrid weighting.
@@ -509,7 +609,7 @@ var _SearchService = class _SearchService {
     let results = this.miniSearch.search(query, {
       filter: (r) => entityIdSet.has(r.entity_id),
       combineWith: "OR"
-    });
+    }).sort((a, b) => this._compareSearchResults(a, b));
     if (preFilterLimit !== void 0) {
       results = results.slice(0, preFilterLimit);
     }
@@ -637,6 +737,18 @@ var _SearchService = class _SearchService {
     if (updatedAtDiff !== 0) return updatedAtDiff;
     return a.id.localeCompare(b.id);
   }
+  /**
+   * MiniSearch breaks equal-score ties by internal insertion order, which
+   * syncEntries changes: a discarded-and-re-added id moves to the end. Every
+   * caller truncates these results to a limit, so which ids survive a tie at
+   * the boundary must not depend on write history. Re-sort exact score ties
+   * by id — the same final tie-break _compareScoredRows applies.
+   */
+  _compareSearchResults(a, b) {
+    const scoreDiff = b.score - a.score;
+    if (!Number.isNaN(scoreDiff) && scoreDiff !== 0) return scoreDiff;
+    return a.id.localeCompare(b.id);
+  }
 };
 /**
  * Maximum number of entities whose parsed embedding vectors are held in
@@ -2290,7 +2402,10 @@ var IngestionService = class {
         return zeroChunkResult(canonical);
       }
       diagBuffer.flush(this.options);
-      await this.searchService.sync(entityId);
+      await this.searchService.syncEntries(
+        entityId,
+        [...deletedSourceFactIds, ...insertedFacts.map((fact) => fact.id)]
+      );
       if (failedChunks === 0) {
         const uniqueDeletedSourceFactIds = Array.from(new Set(deletedSourceFactIds));
         for (const factId of uniqueDeletedSourceFactIds) {
@@ -4479,7 +4594,11 @@ var ImportExportService = class {
         );
       }
     });
-    await this.searchService.sync(entityId);
+    if (merge) {
+      await this.searchService.syncEntries(entityId, [...upsertedFactIds]);
+    } else {
+      await this.searchService.sync(entityId);
+    }
     for (const fact of bundle.facts) {
       if (!fact.deleted_at && upsertedFactIds.has(fact.id) && !factsWithPreservedBlob.has(fact.id)) {
         const clipped = clippedTextByFactId.get(fact.id);
@@ -5663,5 +5782,5 @@ var WriteService = class {
 };
 
 export { BaseRepository, 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, MaintenanceService, MetadataRepository, ONTOLOGY_BACKFILL_BATCH_SIZE, ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS, ONTOLOGY_BACKFILL_RECHECK_MS, ONTOLOGY_BACKFILL_SYSTEM_PROMPT, PromptService, PrunePartialFailureError, RetrievalService, SearchService, WikiBusyError, WikiDraftNotFound, WikiDuplicateHashError, WikiGraphNodeOwnershipConflict, WikiIngestEmptyError, WikiInvalidReadOptions, WikiParseError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, edgeTripleAllowed, emptyManifest, entitySummaryMetaKey, extractSqliteCode, generateId, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, parseEmbedding, resolveEdgeDefinitions, resolveGrounding, resolveNodeType, safeSlice, typeSatisfies, validateInlineEdges, validateManifest };
-//# sourceMappingURL=chunk-JV2OQ5CM.mjs.map
-//# sourceMappingURL=chunk-JV2OQ5CM.mjs.map
+//# sourceMappingURL=chunk-PBUZLSOM.mjs.map
+//# sourceMappingURL=chunk-PBUZLSOM.mjs.map