@remnic/core 9.7.15 → 9.9.0

package/src/orchestrator-flush.test.ts

@@ -8,12 +8,14 @@ import {
   Orchestrator,
 } from "./orchestrator.js";
 import { ExtractionQueueCoordinator } from "./orchestration/extraction-queue-coordinator.js";
+import { SmartBuffer } from "./buffer.js";
 import { parseConfig } from "./config.js";
 import { stableHash } from "./coding/git-context.js";
-import type { BufferTurn } from "./types.js";
+import type { BufferState, BufferTurn } from "./types.js";
 import type { ImportTurn } from "./bulk-import/types.js";
 import { namespaceIdentityToken } from "./namespaces/identity.js";
 import { readNamespaceMaintenanceStatuses } from "./maintenance/namespace-planner.js";
+import { stubPersistExtraction } from "./testing/orchestrator-lite.js";
 
 function makeTurn(sessionKey: string, content: string): BufferTurn {
   return {
@@ -144,6 +146,140 @@ test("flushSession waits for queued extraction task completion", async () => {
   assert.equal(flushSettled, true);
 });
 
+test("flushSession flushes the pending debounced buffer save before extraction, so keep_buffering turns survive a failed/timed-out extraction (issue #1909, PR #2016)", async () => {
+  // Regression: in steady-state debounced buffering a `keep_buffering` turn only
+  // SCHEDULES a trailing-edge save, so the newest turns live only in memory
+  // behind an unref'd timer. The lifecycle force-drain (before_reset /
+  // session_end) queues extraction with clearBufferAfterExtraction; if that
+  // extraction fails or times out and the host then exits, the debounce timer
+  // never fires and those turns are lost. flushSession must force the pending
+  // save durable BEFORE reading/clearing turns.
+  let saved: BufferState | null = null;
+  const storage = {
+    async loadBuffer(): Promise<BufferState> {
+      return saved
+        ? structuredClone(saved)
+        : { turns: [], lastExtractionAt: null, extractionCount: 0 };
+    },
+    async saveBuffer(state: BufferState): Promise<void> {
+      saved = structuredClone(state);
+    },
+  };
+  const buffer = new SmartBuffer(
+    parseConfig({ bufferSaveDebounceMs: 10_000, triggerMode: "smart", bufferMaxTurns: 100 }),
+    storage as unknown as ConstructorParameters<typeof SmartBuffer>[1],
+  );
+
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "remember alpha"));
+  // Debounced keep_buffering: buffered in memory but NOT yet durable.
+  assert.equal(saved, null, "debounced keep_buffering turn is not yet on disk");
+  assert.equal(buffer.getTurns("thread-a").length, 1);
+
+  interface FlushFake {
+    buffer: SmartBuffer;
+    queueBufferedExtraction: (
+      turns: BufferTurn[],
+      reason: string,
+      options?: Record<string, unknown>,
+    ) => Promise<void>;
+    flushSession(sessionKey: string, options: { reason: string }): Promise<void>;
+  }
+  const orchestrator = Object.create(Orchestrator.prototype) as unknown as FlushFake;
+  orchestrator.buffer = buffer;
+  let extractionAttempted = false;
+  orchestrator.queueBufferedExtraction = async (
+    _turns: BufferTurn[],
+    _reason: string,
+    options?: Record<string, unknown>,
+  ) => {
+    extractionAttempted = true;
+    // Extraction fails/times out: the buffer is NOT cleared.
+    (options?.onTaskSettled as ((error?: unknown) => void) | undefined)?.(
+      new Error("simulated extraction timeout"),
+    );
+  };
+
+  await assert.rejects(
+    orchestrator.flushSession("thread-a", { reason: "before_reset" }),
+    /simulated extraction timeout/,
+  );
+
+  assert.equal(extractionAttempted, true);
+  // The pending debounced save was forced durable BEFORE the failing
+  // extraction, so the keep_buffering turn is on disk for re-extraction even
+  // though extraction failed and (in production) the host would now exit.
+  assert.ok(saved, "pending debounced save was flushed before extraction");
+  const persisted = saved as BufferState;
+  const entryTurns = persisted.entries?.["thread-a"]?.turns ?? [];
+  assert.equal(entryTurns.length, 1, "keep_buffering turn is durable after failed flush");
+  assert.equal(entryTurns[0]?.content, "remember alpha");
+});
+
+test("flushSession rejects and skips extraction when the durable buffer save fails, leaving turns and pending state intact (issue #1909, PR #2016)", async () => {
+  // Fail-closed regression: if the pending debounced save cannot land durably,
+  // flushSession must STOP before queuing extraction with
+  // clearBufferAfterExtraction. Otherwise the drain would clear turns that never
+  // reached disk; a subsequent extraction failure + host exit loses the turn.
+  let saved: BufferState | null = null;
+  let failSave = true;
+  const storage = {
+    async loadBuffer(): Promise<BufferState> {
+      return saved
+        ? structuredClone(saved)
+        : { turns: [], lastExtractionAt: null, extractionCount: 0 };
+    },
+    async saveBuffer(state: BufferState): Promise<void> {
+      if (failSave) throw new Error("simulated durable save failure");
+      saved = structuredClone(state);
+    },
+  };
+  const buffer = new SmartBuffer(
+    parseConfig({ bufferSaveDebounceMs: 10_000, triggerMode: "smart", bufferMaxTurns: 100 }),
+    storage as unknown as ConstructorParameters<typeof SmartBuffer>[1],
+  );
+
+  await buffer.addTurn("thread-a", makeTurn("thread-a", "remember alpha"));
+  // Debounced keep_buffering: buffered in memory but NOT yet durable.
+  assert.equal(saved, null, "debounced keep_buffering turn is not yet on disk");
+  assert.equal(buffer.getTurns("thread-a").length, 1);
+
+  interface FlushFake {
+    buffer: SmartBuffer;
+    queueBufferedExtraction: (
+      turns: BufferTurn[],
+      reason: string,
+      options?: Record<string, unknown>,
+    ) => Promise<void>;
+    flushSession(sessionKey: string, options: { reason: string }): Promise<void>;
+  }
+  const orchestrator = Object.create(Orchestrator.prototype) as unknown as FlushFake;
+  orchestrator.buffer = buffer;
+  let extractionAttempted = false;
+  orchestrator.queueBufferedExtraction = async () => {
+    extractionAttempted = true;
+  };
+
+  await assert.rejects(
+    orchestrator.flushSession("thread-a", { reason: "before_reset" }),
+    /simulated durable save failure/,
+  );
+
+  // The failed save short-circuits the drain: extraction never runs.
+  assert.equal(extractionAttempted, false, "extraction is skipped after a failed durable save");
+  assert.equal(saved, null, "nothing was written durably");
+  // In-memory turns survive: the buffer was never read/cleared.
+  assert.equal(buffer.getTurns("thread-a").length, 1, "buffered turn is retained after a failed flush");
+
+  // Pending state was retained (not cleared): once the durable write recovers,
+  // the still-pending save lands the turn on disk.
+  failSave = false;
+  await buffer.flushPendingSave();
+  assert.ok(saved, "pending save was retained and lands durably once the write recovers");
+  const entryTurns = (saved as BufferState).entries?.["thread-a"]?.turns ?? [];
+  assert.equal(entryTurns.length, 1, "retained pending save persists the keep_buffering turn");
+  assert.equal(entryTurns[0]?.content, "remember alpha");
+});
+
 test("ingestBulkImportBatch rejects when the extraction deadline expires in the queue", async () => {
   const orchestrator = Object.create(Orchestrator.prototype) as any;
   orchestrator.config = parseConfig({});
@@ -860,7 +996,6 @@ test("runExtraction fails closed on invalid extraction results when required", a
     config.extractionMinUserTurns = 1;
 
     let clearCalls = 0;
-    let persistCalls = 0;
     const orchestrator = Object.create(Orchestrator.prototype) as any;
     orchestrator.config = config;
     orchestrator.buffer = {
@@ -885,10 +1020,7 @@ test("runExtraction fails closed on invalid extraction results when required", a
     orchestrator.extraction = {
       extract: async () => extractionResult,
     };
-    orchestrator.persistExtraction = async () => {
-      persistCalls += 1;
-      return ["fact-1"];
-    };
+    const persistCalls = stubPersistExtraction(orchestrator, () => ["fact-1"]);
 
     await assert.rejects(
       orchestrator.runExtraction([makeTurn("session-invalid", "remember bad output")], {
@@ -899,7 +1031,7 @@ test("runExtraction fails closed on invalid extraction results when required", a
     );
 
     assert.equal(clearCalls, 0);
-    assert.equal(persistCalls, 0);
+    assert.equal(persistCalls.length, 0);
   }
 });
 
@@ -909,7 +1041,6 @@ test("runExtraction persists processed fingerprints for empty extraction results
   config.extractionMinUserTurns = 1;
 
   let clearCalls = 0;
-  let persistCalls = 0;
   let saveMetaCalls = 0;
   let savedMeta:
     | {
@@ -961,10 +1092,7 @@ test("runExtraction persists processed fingerprints for empty extraction results
       profileUpdates: [],
     }),
   };
-  orchestrator.persistExtraction = async () => {
-    persistCalls += 1;
-    return [];
-  };
+  const persistCalls = stubPersistExtraction(orchestrator);
 
   const turns = [
     {
@@ -981,7 +1109,7 @@ test("runExtraction persists processed fingerprints for empty extraction results
 
   assert.equal(result.status, "skipped");
   assert.equal(result.reason, "empty_extraction_result");
-  assert.equal(persistCalls, 0);
+  assert.equal(persistCalls.length, 0);
   assert.equal(saveMetaCalls, 1);
   assert.equal(clearCalls, 1);
   assert.equal(savedMeta?.extractionCount, 1);
@@ -1000,7 +1128,6 @@ test("runExtraction does not persist processed fingerprints for failed empty ext
   config.extractionMinUserTurns = 1;
 
   let clearCalls = 0;
-  let persistCalls = 0;
   let saveMetaCalls = 0;
 
   const meta = {
@@ -1040,10 +1167,7 @@ test("runExtraction does not persist processed fingerprints for failed empty ext
       extractionFailure: "gateway_unavailable",
     }),
   };
-  orchestrator.persistExtraction = async () => {
-    persistCalls += 1;
-    return [];
-  };
+  const persistCalls = stubPersistExtraction(orchestrator);
 
   const turns = [
     {
@@ -1059,7 +1183,7 @@ test("runExtraction does not persist processed fingerprints for failed empty ext
 
   assert.equal(result.status, "skipped");
   assert.equal(result.reason, "empty_extraction_result");
-  assert.equal(persistCalls, 0);
+  assert.equal(persistCalls.length, 0);
   // #1908: a failed extraction now persists per-fingerprint retry-state to meta (one
   // saveMeta call), but MUST NOT record a processed fingerprint — the invariant
   // below (processedExtractionFingerprints stays []) is the real contract.
@@ -1091,7 +1215,7 @@ test("runExtraction clears the buffer on a failed extraction when extractionRetr
   orchestrator.extraction = {
     extract: async () => ({ facts: [], entities: [], questions: [], profileUpdates: [], extractionFailure: "gateway_unavailable" }),
   };
-  orchestrator.persistExtraction = async () => [];
+  stubPersistExtraction(orchestrator);
   const turns = [{ ...makeTurn("session-retry-off", "failed gateway"), logicalSessionKey: "logical-thread:retry-off", turnFingerprint: "fp-retry-off", persistProcessedFingerprint: true }];
   const result = await orchestrator.runExtraction(turns, { bufferKey: "logical-thread:retry-off" });
   assert.equal(result.status, "skipped");
@@ -1244,7 +1368,6 @@ test("runExtraction still clears the buffer when fingerprint persistence fails a
   config.extractionMinChars = 0;
   config.extractionMinUserTurns = 1;
   let clearCalls = 0;
-  let persistCalls = 0;
   let fingerprintWrites = 0;
   const orchestrator = Object.create(Orchestrator.prototype) as any;
   orchestrator.config = config;
@@ -1282,10 +1405,7 @@ test("runExtraction still clears the buffer when fingerprint persistence fails a
       profileUpdates: [],
     }),
   };
-  orchestrator.persistExtraction = async () => {
-    persistCalls += 1;
-    return ["fact-1"];
-  };
+  const persistCalls = stubPersistExtraction(orchestrator, () => ["fact-1"]);
   orchestrator.recordProcessedExtractionFingerprint = async () => {
     fingerprintWrites += 1;
     throw new Error("saveMeta failed");
@@ -1307,7 +1427,7 @@ test("runExtraction still clears the buffer when fingerprint persistence fails a
     },
   );
 
-  assert.equal(persistCalls, 1);
+  assert.equal(persistCalls.length, 1);
   assert.equal(fingerprintWrites, 1);
   assert.equal(clearCalls, 1);
 });
@@ -1380,7 +1500,7 @@ test("runExtraction persists fingerprint and extraction counters through one coh
       profileUpdates: [],
     }),
   };
-  orchestrator.persistExtraction = async () => ["fact-1"];
+  stubPersistExtraction(orchestrator, () => ["fact-1"]);
   orchestrator.requestQmdMaintenance = () => undefined;
   orchestrator.runTierMigrationCycle = async () => undefined;
 
@@ -1488,7 +1608,7 @@ test("runExtraction loads meta before updating extraction counters when fingerpr
       profileUpdates: [],
     }),
   };
-  orchestrator.persistExtraction = async () => ["fact-1"];
+  stubPersistExtraction(orchestrator, () => ["fact-1"]);
   orchestrator.requestQmdMaintenance = () => undefined;
   orchestrator.runTierMigrationCycle = async () => undefined;
 
@@ -1569,7 +1689,7 @@ test("runExtraction completes after late threading failures and saves the proces
       profileUpdates: [],
     }),
   };
-  orchestrator.persistExtraction = async () => ["fact-1"];
+  stubPersistExtraction(orchestrator, () => ["fact-1"]);
   orchestrator.threading = {
     processTurn: async () => "thread-15",
     appendEpisodeIds: async () => undefined,
@@ -1671,7 +1791,7 @@ test("runExtraction completes and clears the buffer when the post-persist meta s
       profileUpdates: [],
     }),
   };
-  orchestrator.persistExtraction = async () => ["fact-1"];
+  stubPersistExtraction(orchestrator, () => ["fact-1"]);
   orchestrator.requestQmdMaintenance = () => undefined;
   orchestrator.runTierMigrationCycle = async () => undefined;
 
@@ -1754,7 +1874,7 @@ test("runExtraction still runs follow-on extraction helpers when the post-persis
       profileUpdates: [],
     }),
   };
-  orchestrator.persistExtraction = async () => ["fact-1"];
+  stubPersistExtraction(orchestrator, () => ["fact-1"]);
   orchestrator.threading = {
     processTurn: async () => "thread-17",
     appendEpisodeIds: async () => {
@@ -1813,7 +1933,6 @@ test("runExtraction aborts before late buffer clearing when the caller cancels",
   config.extractionMinUserTurns = 1;
 
   let clearCalls = 0;
-  let persistCalls = 0;
   let resolveExtract!: (value: {
     facts: [];
     entities: [];
@@ -1851,10 +1970,7 @@ test("runExtraction aborts before late buffer clearing when the caller cancels",
   orchestrator.extraction = {
     extract: async () => extractPromise,
   };
-  orchestrator.persistExtraction = async () => {
-    persistCalls += 1;
-    return [];
-  };
+  const persistCalls = stubPersistExtraction(orchestrator);
 
   const abortController = new AbortController();
   const runPromise = orchestrator.runExtraction(
@@ -1877,7 +1993,7 @@ test("runExtraction aborts before late buffer clearing when the caller cancels",
   await new Promise((resolve) => setTimeout(resolve, 0));
 
   assert.equal(clearCalls, 0);
-  assert.equal(persistCalls, 0);
+  assert.equal(persistCalls.length, 0);
 });
 
 test("runExtraction still clears the session buffer after persistence even if reset abort fires late", async () => {
@@ -1922,10 +2038,10 @@ test("runExtraction still clears the session buffer after persistence even if re
       profileUpdates: [],
     }),
   };
-  orchestrator.persistExtraction = async () => {
+  stubPersistExtraction(orchestrator, () => {
     abortController.abort();
     return ["fact-1"];
-  };
+  });
   orchestrator.maybeScheduleConsolidation = () => undefined;
   orchestrator.requestQmdMaintenance = () => undefined;
   orchestrator.nonZeroExtractionsSinceConsolidation = 0;

package/src/orchestrator-nonchunked-hash-durability.test.ts

@@ -0,0 +1,121 @@
+/**
+ * PR #2016 regression: non-chunked parent fact-hash durability.
+ *
+ * Sibling to orchestrator-chunked-hash-durability.test.ts. When fact dedup is
+ * enabled, the NON-chunked extraction path writes the fact memory with its
+ * fact-content-hash flush DEFERRED to the end-of-method batch
+ * saveContentHashIndexes() (issue #1909 batching). The fallible post-write work
+ * that follows — applyDeferredContradictionResolve(), embedding index, shared
+ * promotion, verbatim artifact write — can throw AFTER writeSealedMemory() has
+ * made the `.md` durable but BEFORE that batch save runs. Left unguarded, the
+ * durable fact would be missing from fact-hashes.txt until the next corpus
+ * rebuild, so a peer with an already-built in-memory index could re-extract it
+ * as a duplicate.
+ *
+ * Fix (extraction-persist.ts): the non-chunked path guards the post-write work
+ * and flushes the deferred parent hash before propagating any failure, while
+ * keeping #1909 batching on the success path. This test drives persistExtraction
+ * through the real Orchestrator, forces the verbatim-artifact write to throw,
+ * and asserts the fact's hash is already durable in the on-disk fact-hashes.txt
+ * (loaded directly, NOT via a corpus rebuild that would reconstruct it anyway).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+
+import { parseConfig } from "./config.js";
+import { Orchestrator } from "./orchestrator.js";
+import { ContentHashIndex, StorageManager } from "./storage.js";
+import { sanitizeMemoryContent } from "./sanitize.js";
+import type { ExtractionResult, MemoryFile } from "./types.js";
+
+/** persistExtraction is private; reach it through an unknown-cast surface. */
+interface OrchestratorTestSurface {
+  persistExtraction: (
+    result: ExtractionResult,
+    storage: StorageManager,
+    threadId: string | null,
+    sourceContext?: { sourceConnector?: string; validAt?: string },
+  ) => Promise<string[]>;
+  getStorage: (namespace: string) => Promise<StorageManager>;
+}
+
+/** A short single-sentence fact that does NOT chunk (non-chunked write path). */
+const FACT_BODY = "The staging deploy pinned build 8421 as the rollback anchor.";
+
+function factResult(content: string): ExtractionResult {
+  return {
+    facts: [{ content, category: "fact", confidence: 0.9, tags: [] }],
+    entities: [],
+    relationships: [],
+    questions: [],
+    profileUpdates: [],
+  } as ExtractionResult;
+}
+
+test("#2016: a non-chunked fact's hash is durable on disk before fallible post-write work", async () => {
+  const memoryDir = await mkdtemp(
+    path.join(os.tmpdir(), "remnic-nonchunk-hash-durability-"),
+  );
+  try {
+    const config = parseConfig({
+      openaiApiKey: "sk-test",
+      memoryDir,
+      workspaceDir: path.join(memoryDir, "workspace"),
+      qmdEnabled: false,
+      embeddingFallbackEnabled: false,
+      // Force the non-chunked write path.
+      chunkingEnabled: false,
+      multiGraphMemoryEnabled: false,
+      factDeduplicationEnabled: true,
+      // Make the fallible post-write verbatim-artifact write reachable for a
+      // fact so the injected throw fires AFTER the durable .md write.
+      verbatimArtifactsEnabled: true,
+      verbatimArtifactCategories: ["fact"],
+      verbatimArtifactsMinConfidence: 0.5,
+    });
+    const orchestrator = new Orchestrator(
+      config,
+    ) as unknown as OrchestratorTestSurface;
+    const storage = await orchestrator.getStorage("default");
+    await storage.ensureDirectories();
+
+    // Deterministic failure: the verbatim-artifact write throws — after the
+    // fact .md is durable and before the end-of-method saveContentHashIndexes().
+    storage.writeArtifact = async (): Promise<string> => {
+      throw new Error("simulated writeArtifact failure");
+    };
+
+    await assert.rejects(
+      orchestrator.persistExtraction(factResult(FACT_BODY), storage, null, {
+        sourceConnector: "chatgpt",
+      }),
+      /simulated writeArtifact failure/,
+      "the artifact write failure must propagate — post-write work is not swallowed",
+    );
+
+    // The fact .md is durable.
+    const all = await storage.readAllMemories();
+    const facts = all.filter(
+      (m: MemoryFile) => m.frontmatter.category === "fact" && m.content.includes("rollback anchor"),
+    );
+    assert.equal(facts.length, 1, "the fact .md must be durable");
+
+    // Its content hash was flushed to fact-hashes.txt BEFORE the throw. Load
+    // ONLY the on-disk index (no corpus rebuild) so this asserts the durable
+    // file itself, not a restart-time reconstruction.
+    const stateDir = path.join(memoryDir, "state");
+    const onDisk = new ContentHashIndex(stateDir);
+    await onDisk.load();
+    assert.equal(
+      onDisk.has(sanitizeMemoryContent(FACT_BODY).text),
+      true,
+      "the fact hash must be durable on disk before fallible post-write work (PR #2016)",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/orchestrator-source-attribution.test.ts

@@ -71,7 +71,7 @@ test("persistExtraction is a no-op by default — no inline citation is injected
     profileUpdates: [],
   } as ExtractionResult;
 
-  const persistedIds = await orchestrator.persistExtraction(
+  const { persistedIds } = await orchestrator.persistExtraction(
     result,
     storage,
     null,
@@ -512,7 +512,7 @@ test("persistExtraction injects the inline citation when the flag is enabled", a
     profileUpdates: [],
   } as ExtractionResult;
 
-  const persistedIds = await orchestrator.persistExtraction(
+  const { persistedIds } = await orchestrator.persistExtraction(
     result,
     storage,
     null,
@@ -555,7 +555,7 @@ test("persistExtraction honors a custom inline citation format template", async
     profileUpdates: [],
   } as ExtractionResult;
 
-  const persistedIds = await orchestrator.persistExtraction(
+  const { persistedIds } = await orchestrator.persistExtraction(
     result,
     storage,
     null,
@@ -597,7 +597,7 @@ test("persistExtraction does not double-inject a citation on facts that already
     profileUpdates: [],
   } as ExtractionResult;
 
-  const persistedIds = await orchestrator.persistExtraction(
+  const { persistedIds } = await orchestrator.persistExtraction(
     result,
     storage,
     null,
@@ -650,7 +650,7 @@ test("dedup: pre-tagged fact is not re-persisted when canonical body is already
     profileUpdates: [],
   } as ExtractionResult;
 
-  const firstIds = await orchestrator.persistExtraction(
+  const { persistedIds: firstIds } = await orchestrator.persistExtraction(
     firstResult,
     storage,
     null,
@@ -674,7 +674,7 @@ test("dedup: pre-tagged fact is not re-persisted when canonical body is already
     profileUpdates: [],
   } as ExtractionResult;
 
-  const secondIds = await orchestrator.persistExtraction(
+  const { persistedIds: secondIds } = await orchestrator.persistExtraction(
     secondResult,
     storage,
     null,
@@ -719,7 +719,7 @@ test("dedup: exact matches are scoped to the target namespace storage", async ()
   await tenantStorage.ensureDirectories();
 
   const rawBody = "The Helios tenant keeps staging feature flags isolated.";
-  const firstIds = await orchestrator.persistExtraction(
+  const { persistedIds: firstIds } = await orchestrator.persistExtraction(
     {
       facts: [makeFact(rawBody)],
       entities: [],
@@ -733,7 +733,7 @@ test("dedup: exact matches are scoped to the target namespace storage", async ()
   );
   assert.equal(firstIds.length, 1, "default namespace write must succeed");
 
-  const tenantIds = await orchestrator.persistExtraction(
+  const { persistedIds: tenantIds } = await orchestrator.persistExtraction(
     {
       facts: [makeFact(rawBody)],
       entities: [],
@@ -751,7 +751,7 @@ test("dedup: exact matches are scoped to the target namespace storage", async ()
     "a duplicate in another namespace must not be suppressed by the default hash index",
   );
 
-  const tenantDuplicateIds = await orchestrator.persistExtraction(
+  const { persistedIds: tenantDuplicateIds } = await orchestrator.persistExtraction(
     {
       facts: [makeFact(rawBody)],
       entities: [],