@equationalapplications/core-llm-wiki 5.5.1 → 6.0.0

package/README.md

@@ -10,34 +10,6 @@ Platform-agnostic TypeScript engine for hybrid LLM memory. Features episodic fac
 
 > Inspired by [Andrej Karpathy's LLM Wiki memory spec](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f).
 
-## Recent changes
-
-### 5.4.1 — Ingest parse resilience (issue #92)
-
-- `parseJsonResponse` now tolerates bare `"` characters in LLM output via a
-  container-aware repair pass. The function's signature is unchanged
-  (`parseJsonResponse<T>(text: string): T`); the runtime contract widens —
-  the new `WikiParseError` type carries `{ tier, position, slice }` instead
-  of an opaque `Error`, and `tier: 'repair'` is now reachable for balanced
-  invalid payloads (e.g. `{"facts":}`) where the walker found a candidate
-  span that `JSON.parse` ultimately rejected.
-- `IngestionService.ingestDocument` no longer rejects the whole call when one
-  chunk fails. Sibling chunks commit; the result's `parseFailures[]` records
-  per-chunk failures. A new typed error `WikiIngestEmptyError` is thrown when
-  every chunk failed. New typed error `WikiParseError` carries `{tier,
-  position, slice}`. New result fields: `ingestedChunks`, `failedChunks`,
-  `parseFailures?`.
-- Partial-commit semantics: when some chunks fail, the document's
-  `(entity, sourceHash) → sourceRef` ownership is **not** recorded and the
-  partial rows are stored with `source_hash = NULL`. Subsequent runs with
-  the same hash see `hasChanged` return `true` and the failed chunks retry
-  on the next pass; the retry's `appendPartialFacts` dedupes against the
-  prior partial's surviving rows so titles are never duplicated. On full
-  success the next run supersedes everything atomically.
-- `INGEST_SYSTEM_PROMPT` and `ONTOLOGY_BACKFILL_SYSTEM_PROMPT` were tightened
-  to call out JSON-escape discipline explicitly.
-
-**Hosts must update (host-facing migration)**: a host that today treats `ingestDocument` throwing as the only failure signal will, after 5.4.1, see a successful return with `parseFailures[]` set when a subset of chunks failed. Inspect `result.failedChunks` and surface `result.parseFailures[]` for observability — do not rely on the throw for partial failures. Only `WikiIngestEmptyError` (every chunk failed) still throws. Catch `WikiParseError` explicitly if you previously caught `Error` to log parse failures — the new `tier` field replaces the opaque `message`.
 
 ## Features
 
@@ -49,7 +21,7 @@ Platform-agnostic TypeScript engine for hybrid LLM memory. Features episodic fac
 - **Immutable vs mutable facts** — Use `WikiFact.source_type` to distinguish document-sourced facts (`immutable_document`) from derived or user-provided facts (`librarian_inferred`, `user_stated`, `user_confirmed`). Immutable document facts are not rewritten by `runLibrarian()` or `runHeal()` and can only be removed by `forget()` or re-ingesting.
 - **Full-featured memory** — Facts, tasks, events, maintenance jobs (librarian, heal, reembed, prune)
 - **Type-safe** — Built with TypeScript, full type exports
-- **Interoperability:** Supports [Open Knowledge Format (OKF) v0.1](https://github.com/GoogleCloudPlatform/knowledge-catalog/tree/main/okf) import and export via the [llm-wiki OKF profile (llm-wiki/1)](https://github.com/equationalapplications/expo-llm-wiki/blob/main/docs/okf-profile.md).
+- **Interoperability:** Supports [Open Knowledge Format (OKF)](https://github.com/GoogleCloudPlatform/knowledge-catalog/tree/main/okf) v0.1 + v0.2 import and export via the [llm-wiki OKF profiles](https://github.com/equationalapplications/expo-llm-wiki/blob/main/docs/okf-profile.md) (default `llm-wiki/2`, back-compat `llm-wiki/1`).
 - **Per-entity seeded ontology** — Optional Strict, Emergent, or Off modes govern LLM graph extraction; seed taxonomies per entity and persist typed facts with inline edges.
 
 ## GraphRAG & Multi-Modal Retrieval
@@ -649,7 +621,7 @@ const result = await wiki.runOntologyBackfill(entityId);
 
 ## OKF Import/Export
 
-The core package integrates with `@equationalapplications/core-okf` to seamlessly adapt wiki data dumps to and from Open Knowledge Format (OKF) v0.1 bundles.
+The core package integrates with `@equationalapplications/core-okf` to seamlessly adapt wiki data dumps to and from Open Knowledge Format (OKF) bundles (v0.1 and v0.2; `formatOkfBundle` defaults to the v0.2 / `llm-wiki/2` profile).
 
 ### Exporting an OKF Bundle
 
@@ -1157,7 +1129,7 @@ The flowchart shows:
 | [@equationalapplications/react-llm-wiki](https://github.com/equationalapplications/expo-llm-wiki/blob/main/packages/react/README.md) | Persistent episodic memory for Web |
 | [@equationalapplications/prisma-outbox](https://github.com/equationalapplications/expo-llm-wiki/blob/main/packages/prisma-outbox/README.md) | Sync SQLite outbox events to Prisma |
 | [@equationalapplications/core-llm-tools](https://github.com/equationalapplications/expo-llm-wiki/blob/main/packages/core-llm-tools/README.md) | Gemini tool schemas and capability injector |
-| [@equationalapplications/core-okf](https://github.com/equationalapplications/expo-llm-wiki/blob/main/packages/okf/README.md) | Zero-dependency Open Knowledge Format (OKF) v0.1 primitives — parse and produce interoperable knowledge bundles. |
+| [@equationalapplications/core-okf](https://github.com/equationalapplications/expo-llm-wiki/blob/main/packages/okf/README.md) | Zero-dependency Open Knowledge Format (OKF) v0.1 + v0.2 primitives — parse and produce interoperable knowledge bundles. |
 | [@equationalapplications/schema-org-llm-wiki](https://github.com/equationalapplications/expo-llm-wiki/blob/main/packages/schema-org/README.md) | Curated schema.org warm-agent ontology manifest |
 
 ## OKF v0.2 conformance (llm-wiki/2)

package/dist/{chunk-JQRA6BYQ.mjs → chunk-HREQ6F6Z.mjs}

@@ -1481,6 +1481,12 @@ Return ONLY a valid JSON object matching this schema:
 If no manifest type fits a fact, omit that fact from "classifications" entirely \u2014 do not guess.
 When echoing an existing fact's title verbatim into "target_title", preserve every JSON escape sequence (\\", \\n, \\\\, \\/) exactly as it appeared in the input body \u2014 do not strip backslashes, do not add unescaped quotes. Do not return markdown, just raw JSON.`;
 
+// src/utils/healConstants.ts
+var HEAL_MAX_ANCHORS = 50;
+var HEAL_ANCHORS_PER_CANDIDATE = 4;
+var HEAL_MAX_FACT_BODY_CHARS_L3 = 4e3;
+var HEAL_MAX_TASKS = 50;
+
 // src/services/PromptService.ts
 var PromptService = class {
   constructor(globalOverrides) {
@@ -1548,25 +1554,67 @@ Current Facts:
 ${JSON.stringify(currentFacts, null, 2)}`
     };
   }
-  buildHealPrompt(healCandidates, documentAnchors, allTasks, recentEvents, runtimeOverride) {
+  /**
+   * Heal-prompt level interpretation for the `attemptLevel` ladder.
+   *
+   * Caller contract: `documentAnchors` may be a slice sized for `batch.length`
+   * or a larger set (e.g. a cache hit from `_selectHealAnchors`). This function
+   * applies the prompt-side anchor cap `min(HEAL_MAX_ANCHORS=50, batch.length
+   * * HEAL_ANCHORS_PER_CANDIDATE=4)` so the rendered prompt is bounded
+   * regardless of caller input. `HEAL_MAX_ANCHORS` and
+   * `HEAL_ANCHORS_PER_CANDIDATE` live here too — keeping the formula
+   * co-located with its application avoids a "MaintenanceService policy"
+   * import cycle (`PromptService` is constructed before `MaintenanceService`
+   * exists) and makes the cap testable without a `MaintenanceService`
+   * instance. Task 3 exports the same two constants from `MaintenanceService`
+   * for caller-side overfetch sizing; the values must match.
+   *
+   * Level semantics:
+   * - L0: allTasks + recentEvents + full candidate bodies; anchors re-capped
+   * - L1: drop allTasks; recentEvents present; candidate bodies full
+   * - L2: drop allTasks and recentEvents; candidate bodies full
+   * - L3: drop allTasks and recentEvents; truncate each candidate body to
+   *   `bodyTruncationChars` and emit a `degraded` record per truncated fact
+   */
+  buildHealPrompt(healCandidates, documentAnchors, allTasks, recentEvents, runtimeOverride, attemptLevel, bodyTruncationChars = HEAL_MAX_FACT_BODY_CHARS_L3) {
+    const effectiveTasks = attemptLevel >= 1 ? [] : allTasks;
+    const effectiveEvents = attemptLevel >= 2 ? [] : recentEvents;
+    const maxAnchors = Math.max(1, Math.min(HEAL_MAX_ANCHORS, healCandidates.length * HEAL_ANCHORS_PER_CANDIDATE));
+    const effectiveAnchors = documentAnchors.slice(0, maxAnchors);
+    const { shapedCandidates, degraded } = applyBodyTruncation(
+      healCandidates,
+      attemptLevel,
+      bodyTruncationChars
+    );
     const template = runtimeOverride ?? this.globalOverrides?.healSystemPrompt ?? HEAL_SYSTEM_PROMPT;
     if (/\{\{\s*healCandidates\s*\}\}/.test(template) || /\{\{\s*documentAnchors\s*\}\}/.test(template) || /\{\{\s*allTasks\s*\}\}/.test(template) || /\{\{\s*recentEvents\s*\}\}/.test(template)) {
       return {
-        systemPrompt: this.hydrate(template, { healCandidates, documentAnchors, allTasks, recentEvents }),
-        userPrompt: "Please heal the memory graph."
+        prompts: {
+          systemPrompt: this.hydrate(template, {
+            healCandidates: shapedCandidates,
+            documentAnchors: effectiveAnchors,
+            allTasks: effectiveTasks,
+            recentEvents: effectiveEvents
+          }),
+          userPrompt: "Please heal the memory graph."
+        },
+        degraded
       };
     }
     return {
-      systemPrompt: template,
-      userPrompt: `Heal Candidates:
-${JSON.stringify(healCandidates, null, 2)}
+      prompts: {
+        systemPrompt: template,
+        userPrompt: `Heal Candidates:
+${JSON.stringify(shapedCandidates, null, 2)}
 Document Anchors (DO NOT MODIFY OR DELETE):
-${JSON.stringify(documentAnchors, null, 2)}
+${JSON.stringify(effectiveAnchors, null, 2)}
 All Tasks:
-${JSON.stringify(allTasks, null, 2)}
+${JSON.stringify(effectiveTasks, null, 2)}
 Recent Events:
-${JSON.stringify(recentEvents, null, 2)}
+${JSON.stringify(effectiveEvents, null, 2)}
 The following document anchors are provided for contradiction detection only. Do not include them in \`downgraded\`, \`deleted\`, or \`newFacts\`.`
+      },
+      degraded
     };
   }
   buildOntologyBackfillPrompt(facts, runtimeOverride, ontologyContext) {
@@ -1586,6 +1634,36 @@ ${JSON.stringify(facts, null, 2)}`
     };
   }
 };
+function applyBodyTruncation(candidates, attemptLevel, bodyTruncationChars) {
+  if (attemptLevel < 3) {
+    return { shapedCandidates: candidates, degraded: [] };
+  }
+  const shapedCandidates = [];
+  const degraded = [];
+  for (const c of candidates) {
+    if (typeof c !== "object" || c === null) {
+      shapedCandidates.push(c);
+      continue;
+    }
+    const fact = c;
+    const body = typeof fact.body === "string" ? fact.body : "";
+    if (body.length <= bodyTruncationChars) {
+      shapedCandidates.push(c);
+      continue;
+    }
+    if (typeof fact.id !== "string") {
+      shapedCandidates.push(c);
+      continue;
+    }
+    const originalBodyChars = body.length;
+    const prefix = safeSlice(body, 0, bodyTruncationChars);
+    const truncatedBodyChars = prefix.length;
+    const truncated = `${prefix}\u2026[truncated at ${truncatedBodyChars} chars, original was ${originalBodyChars}]`;
+    shapedCandidates.push({ ...fact, body: truncated });
+    degraded.push({ id: fact.id, originalBodyChars, truncatedBodyChars });
+  }
+  return { shapedCandidates, degraded };
+}
 
 // src/utils/chunkingDefaults.ts
 var DEFAULT_MAX_CHUNK_LENGTH = 12e3;
@@ -2240,16 +2318,24 @@ var TRUNCATION_PATTERNS = [
   /finish[_ ]?reason/i
 ];
 var EXCEEDS_LIMIT_PATTERN = /exceed[a-z]*[^.]{0,40}\b(model|context)?[ _-]?limit/i;
-function isTruncationError(err) {
-  let message;
+function getErrorMessage(err) {
   try {
-    message = err instanceof Error ? err.message : String(err ?? "");
+    return err instanceof Error ? err.message : String(err ?? "");
   } catch {
-    return false;
+    return void 0;
   }
+}
+function isTruncationError(err) {
+  const message = getErrorMessage(err);
+  if (message === void 0) return false;
   if (EXCEEDS_LIMIT_PATTERN.test(message)) return false;
   return TRUNCATION_PATTERNS.some((pattern) => pattern.test(message));
 }
+function isConfigError(err) {
+  const message = getErrorMessage(err);
+  if (message === void 0) return false;
+  return EXCEEDS_LIMIT_PATTERN.test(message);
+}
 function initialBatchSize(maxOutputTokens) {
   if (!maxOutputTokens || !Number.isFinite(maxOutputTokens) || maxOutputTokens <= 0) {
     return DEFAULT_BATCH_SIZE;
@@ -2291,14 +2377,18 @@ async function runBatched(args) {
     const single = candidate.slice(0, 1);
     return { batch: single, prompts: await buildPrompt(single) };
   };
-  const onFailure = async (batch, err) => {
-    if (batch.length <= 1) {
-      if (batch.length === 1) {
-        skipped.push(batch[0]);
+  const onFailure = async (batch, err, attemptLevel, fromCall) => {
+    if (batch.length === 1) {
+      if (fromCall && isTruncationError(err) && attemptLevel < 3) {
+        await attempt(batch, void 0, attemptLevel + 1);
+      } else {
+        const reason = fromCall && !isTruncationError(err) && !isConfigError(err) ? "call_error" : "non_convergent";
+        skipped.push({ item: batch[0], reason });
         onSkip?.(batch[0], err);
       }
       return;
     }
+    if (fromCall && !isTruncationError(err)) throw err;
     const mid = Math.ceil(batch.length / 2);
     if (mid < batchSize) batchSize = mid;
     let i = 0;
@@ -2309,23 +2399,22 @@ async function runBatched(args) {
       i += trimmed.batch.length;
     }
   };
-  const attempt = async (batch, prebuilt) => {
+  const attempt = async (batch, prebuilt, attemptLevel = 0) => {
     if (batch.length === 0) return;
-    const prompts = prebuilt ?? await buildPrompt(batch);
+    const prompts = prebuilt && attemptLevel === 0 ? prebuilt : await buildPrompt(batch, attemptLevel);
     batches++;
     let responseText;
     try {
       responseText = await call(prompts);
     } catch (err) {
-      if (!isTruncationError(err)) throw err;
-      await onFailure(batch, err);
+      await onFailure(batch, err, attemptLevel, true);
       return;
     }
     let result;
     try {
       result = parse(responseText, batch);
     } catch (err) {
-      await onFailure(batch, err);
+      await onFailure(batch, err, attemptLevel, false);
       return;
     }
     results.push(result);
@@ -2334,7 +2423,7 @@ async function runBatched(args) {
   while (index < items.length) {
     const { batch, prompts } = await trim(items.slice(index, index + batchSize));
     index += batch.length;
-    await attempt(batch, prompts);
+    await attempt(batch, prompts, 0);
   }
   return { results, skipped, batches };
 }
@@ -2345,7 +2434,6 @@ var MIN_TOKENS_TO_QUALIFY = 3;
 var ONTOLOGY_BACKFILL_BATCH_SIZE = 25;
 var ONTOLOGY_BACKFILL_MAX_PROMPT_CHARS = 4e4;
 var ONTOLOGY_BACKFILL_RECHECK_MS = 7 * 24 * 60 * 60 * 1e3;
-var HEAL_MAX_ANCHORS = 50;
 var HEAL_ANCHOR_SEARCH_OVERFETCH = 4;
 var HEAL_MAX_PROMPT_CHARS = 4e4;
 var HEAL_BATCH_SIZE = 25;
@@ -2776,6 +2864,10 @@ var MaintenanceService = class {
     if (!Number.isInteger(batchSize) || batchSize < 1) {
       throw new Error("Invalid batchSize: must be an integer >= 1");
     }
+    const bodyTruncationChars = options?.bodyTruncationChars ?? HEAL_MAX_FACT_BODY_CHARS_L3;
+    if (!Number.isInteger(bodyTruncationChars) || bodyTruncationChars < 1) {
+      throw new Error("Invalid bodyTruncationChars: must be an integer >= 1");
+    }
     const now = Date.now();
     const recheckCutoff = now - HEAL_RECHECK_MS;
     const orphanAfterDays = this.options.config?.orphanAfterDays !== void 0 ? this.options.config?.orphanAfterDays : 30;
@@ -2816,29 +2908,44 @@ var MaintenanceService = class {
         downgraded: staleDowngradedIds.length,
         deleted: orphanedIds.length,
         newFactsCreated: 0,
-        skipped: 0,
+        skipped: [],
+        degraded: [],
         remaining: counts2.eligible,
         deferred: counts2.deferred
       };
     }
-    const allTasks = await this.taskRepo.findAllPending([entityId]);
+    const allTasks = await this.taskRepo.findAllPending([entityId], HEAL_MAX_TASKS);
     const recentEvents = await this.eventRepo.getRecent(entityId, 20);
     const toPromptShape = (f) => {
       const { embedding: _embedding, embedding_blob: _blob, ...rest } = f;
       return { ...rest, tags: typeof rest.tags === "string" ? JSON.parse(rest.tags) : rest.tags };
     };
     const anchorCache = /* @__PURE__ */ new Map();
+    const degraded = [];
     const outcome = await runBatched({
       items: healCandidates,
-      buildPrompt: async (batch) => {
-        const documentAnchors = await this._selectHealAnchors(entityId, batch, anchorCache);
-        return this.promptService.buildHealPrompt(
+      buildPrompt: async (batch, attemptLevel = 0) => {
+        const documentAnchors = await this._selectHealAnchors(
+          entityId,
+          batch,
+          // Per-batch anchor cap: `batch.length * HEAL_ANCHORS_PER_CANDIDATE` (capped at
+          // HEAL_MAX_ANCHORS) right-sizes the anchor lookup so a 1-fact batch does
+          // not overfetch the same 200 keyword hits a 25-fact batch once did.
+          // buildHealPrompt applies the matching cap on its side — values must match.
+          Math.min(HEAL_MAX_ANCHORS, batch.length * HEAL_ANCHORS_PER_CANDIDATE),
+          anchorCache
+        );
+        const { prompts, degraded: batchDegraded } = await this.promptService.buildHealPrompt(
           batch.map(toPromptShape),
           documentAnchors,
           allTasks,
           recentEvents,
-          promptOverride
+          promptOverride,
+          attemptLevel,
+          bodyTruncationChars
         );
+        degraded.push(...batchDegraded);
+        return prompts;
       },
       call: (prompts) => this.options.llmProvider.generateText(prompts),
       parse: (responseText, batch) => {
@@ -2912,8 +3019,14 @@ var MaintenanceService = class {
         insertedFacts.push({ id, entity_id: entityId, title: fact.title, body: fact.body, tags: JSON.stringify(fact.tags) });
         healFactsForDedupe.push({ id, title: fact.title });
       }
+      const callErrorIds = new Set(
+        outcome.skipped.filter((s) => s.reason === "call_error").map((s) => s.item.id)
+      );
       await this.entryRepo.markHealChecked(
-        [...healCandidates.map((f) => f.id), ...insertedFacts.map((f) => f.id)],
+        [
+          ...healCandidates.map((f) => f.id).filter((id) => !callErrorIds.has(id)),
+          ...insertedFacts.map((f) => f.id)
+        ],
         entityId,
         now,
         tx
@@ -2931,6 +3044,13 @@ var MaintenanceService = class {
       await this.embeddingService.embedFact(fact);
     }
     this.searchService.evictCache(entityId);
+    const skippedIds = new Set(outcome.skipped.map(({ item }) => item.id));
+    const healedDegraded = degraded.filter((d) => !skippedIds.has(d.id));
+    for (const d of healedDegraded) {
+      console.warn(
+        `[WikiMemory] heal healed under degraded context ${entityId}/${d.id}: body truncated from ${d.originalBodyChars} to ${d.truncatedBodyChars} chars`
+      );
+    }
     let scanned = outcome.skipped.length;
     for (const batchResult of outcome.results) scanned += batchResult.batch.length;
     const allDowngraded = /* @__PURE__ */ new Set([...staleDowngradedIds, ...safeDowngraded]);
@@ -2941,7 +3061,8 @@ var MaintenanceService = class {
       downgraded: allDowngraded.size,
       deleted: allDeleted.size,
       newFactsCreated: insertedFacts.length,
-      skipped: outcome.skipped.length,
+      skipped: outcome.skipped.map(({ item, reason }) => ({ id: item.id, reason })),
+      degraded: healedDegraded,
       remaining: counts.eligible,
       deferred: counts.deferred
     };
@@ -3025,7 +3146,15 @@ var MaintenanceService = class {
       };
     }
     if (outcome.skipped.length > 0) {
-      await this.entryRepo.markOntologyChecked(outcome.skipped.map((f) => f.id), entityId, now, this.db);
+      const callErrorIds = new Set(
+        outcome.skipped.filter((s) => s.reason === "call_error").map((s) => s.item.id)
+      );
+      await this.entryRepo.markOntologyChecked(
+        outcome.skipped.filter(({ item }) => !callErrorIds.has(item.id)).map(({ item }) => item.id),
+        entityId,
+        now,
+        this.db
+      );
     }
     this.searchService.evictCache(entityId);
     const counts = await this.entryRepo.countUntypedByEntityId(entityId, recheckCutoff);
@@ -3141,7 +3270,7 @@ var MaintenanceService = class {
    * batches that reduce to the same query share one lookup. Caller-owned and
    * per-pass — see the call site in doRunHeal.
    */
-  async _selectHealAnchors(entityId, batch, cache) {
+  async _selectHealAnchors(entityId, batch, cap = HEAL_MAX_ANCHORS, cache) {
     const query = batch.map((f) => f.title).join(" ").trim();
     if (!query) return [];
     const cached = cache?.get(query);
@@ -3149,7 +3278,7 @@ var MaintenanceService = class {
     const hits = this.searchService.searchKeyword(
       query,
       [entityId],
-      HEAL_MAX_ANCHORS * HEAL_ANCHOR_SEARCH_OVERFETCH
+      cap * HEAL_ANCHOR_SEARCH_OVERFETCH
     );
     const hitIds = hits.map((h) => h.id);
     const anchors = [];
@@ -3160,7 +3289,7 @@ var MaintenanceService = class {
         const row = byId.get(id);
         if (!row) continue;
         anchors.push(row);
-        if (anchors.length >= HEAL_MAX_ANCHORS) break;
+        if (anchors.length >= cap) break;
       }
     }
     cache?.set(query, anchors);
@@ -4437,6 +4566,6 @@ var WriteService = class {
   }
 };
 
-export { BaseRepository, DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, EmbeddingService, HEAL_BATCH_SIZE, 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, WikiDuplicateHashError, WikiIngestEmptyError, WikiParseError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, emptyManifest, entitySummaryMetaKey, extractSqliteCode, generateId, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, parseEmbedding, resolveEdgeDefinitions, resolveNodeType, safeSlice, validateInlineEdges, validateManifest };
-//# sourceMappingURL=chunk-JQRA6BYQ.mjs.map
-//# sourceMappingURL=chunk-JQRA6BYQ.mjs.map
+export { BaseRepository, DEFAULT_CHUNK_OVERLAP, DEFAULT_MAX_CHUNK_LENGTH, 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, WikiDuplicateHashError, WikiIngestEmptyError, WikiParseError, WikiSourceRefHashCollision, WikiStrictOntologyViolation, WikiTransactionError, WriteService, __privateAdd, __privateGet, __privateSet, chunkText, configureRandomSource, emptyManifest, entitySummaryMetaKey, extractSqliteCode, generateId, normalizeSourceHash, normalizeSourceRef, normalizeTitleKey, parseEmbedding, resolveEdgeDefinitions, resolveNodeType, safeSlice, validateInlineEdges, validateManifest };
+//# sourceMappingURL=chunk-HREQ6F6Z.mjs.map
+//# sourceMappingURL=chunk-HREQ6F6Z.mjs.map