@remnic/core 9.45.3 → 9.45.5

package/src/storage-contract/cache-coherence.test.ts

@@ -435,3 +435,102 @@ test("citation path lookup resolves collection-prefixed QMD paths", async () =>
     await rm(dir, { recursive: true, force: true });
   }
 });
+test("memory snapshots ignore object key order", async () => {
+  const { createMemorySnapshot } = await import("../memory-snapshot.js");
+  type SnapshotInput = Parameters<typeof createMemorySnapshot>[0];
+  const first = {
+    content: "payload",
+    frontmatter: { z: 1, nested: { y: 2, x: 3 } },
+  } as unknown as SnapshotInput;
+  const second = {
+    frontmatter: { nested: { x: 3, y: 2 }, z: 1 },
+    content: "payload",
+  } as unknown as SnapshotInput;
+  assert.equal(createMemorySnapshot(first), createMemorySnapshot(second));
+});
+
+test("tier move: caller-only mutation is not persisted by moveMemoryToPath", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-caller-mut-"));
+  try {
+    resetStaticCaches();
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory("fact", "original disk content");
+    const memories = await storage.readAllMemories();
+    const memory = memories.find((m) => m.frontmatter.id === id);
+    assert.ok(memory, "memory must exist");
+
+    memory.content = "caller mutated unpersisted content";
+
+    const targetPath = storage.buildTierMemoryPath(memory, "cold");
+    await storage.moveMemoryToPath(memory, targetPath);
+
+    const onDisk = await readFile(targetPath, "utf8");
+    assert.ok(onDisk.includes("original disk content"), "Moved file on disk must retain original content");
+    assert.ok(!onDisk.includes("caller mutated unpersisted content"), "Moved file on disk must not carry caller's unpersisted content mutation");
+  } finally {
+    resetStaticCaches();
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("tier move: stale on-disk mutation fails snapshot check during move", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-stale-disk-"));
+  try {
+    resetStaticCaches();
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory("fact", "unmodified content");
+    const memories = await storage.readAllMemories();
+    const memory = memories.find((m) => m.frontmatter.id === id);
+    assert.ok(memory, "memory must exist");
+
+    const diskContent = await readFile(memory.path, "utf8");
+    await writeFile(memory.path, diskContent.replace("unmodified content", "external edit on disk"));
+
+    const targetPath = storage.buildTierMemoryPath(memory, "cold");
+    await assert.rejects(
+      async () => {
+        await storage.moveMemoryToPath(memory, targetPath);
+      },
+      (err: Error) => {
+        return err.message.includes("changed before its tier move");
+      }
+    );
+  } finally {
+    resetStaticCaches();
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("tier move: cold-to-hot move invalidates cold cache and cannot remain in readAllColdMemories", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-cold-to-hot-"));
+  try {
+    resetStaticCaches();
+    const storage = new StorageManager(dir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory("fact", "demoted to cold then promoted");
+    const memories = await storage.readAllMemories();
+    const memory = memories.find((m) => m.frontmatter.id === id);
+    assert.ok(memory, "memory must exist");
+
+    const { targetPath: coldPath } = await storage.migrateMemoryToTier(memory, "cold");
+
+    const coldMemories = await storage.readAllColdMemories();
+    const coldMem = coldMemories.find((m) => m.frontmatter.id === id);
+    assert.ok(coldMem, "memory must be present in cold tier read");
+
+    const { changed } = await storage.migrateMemoryToTier(coldMem, "hot");
+    assert.equal(changed, true, "migration from cold to hot must succeed");
+
+    const coldMemoriesAfter = await storage.readAllColdMemories();
+    const foundInCold = coldMemoriesAfter.some((m) => m.frontmatter.id === id);
+    assert.equal(foundInCold, false, "promoted memory must not remain in readAllColdMemories cache");
+  } finally {
+    resetStaticCaches();
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/storage-deletion-revisions.test.ts

@@ -0,0 +1,91 @@
+import * as assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { test } from "node:test";
+import { StorageManager } from "./storage.js";
+
+test("storage persists the actual revision time for a successful path deletion", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-deletion-revision-"));
+  try {
+    const relativePath = "facts/deleted.md";
+    const filePath = path.join(root, relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, "deleted content");
+
+    const storage = new StorageManager(root);
+    const beforeDelete = Date.now();
+    await storage.deleteOfflineSyncFile(filePath);
+    const afterDelete = Date.now();
+
+    const revisions = await new StorageManager(root).readDeletionRevisions();
+    const deletedAtMs = revisions.get(relativePath);
+    assert.ok(deletedAtMs !== undefined);
+    assert.ok(deletedAtMs >= beforeDelete && deletedAtMs <= afterDelete);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("storage does not restamp an already-absent path on a delete retry", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-deletion-retry-"));
+  try {
+    const relativePath = "facts/deleted.md";
+    const filePath = path.join(root, relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, "deleted content");
+
+    const storage = new StorageManager(root);
+    await storage.deleteOfflineSyncFile(filePath);
+    const firstRevision = (await storage.readDeletionRevisions()).get(relativePath);
+    assert.ok(firstRevision !== undefined);
+
+    await storage.deleteOfflineSyncFile(filePath);
+
+    assert.equal((await storage.readDeletionRevisions()).get(relativePath), firstRevision);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("a new path generation replaces or clears stale deletion evidence", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-deletion-generation-"));
+  try {
+    const relativePath = "facts/deleted.md";
+    const filePath = path.join(root, relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const storage = new StorageManager(root);
+
+    await writeFile(filePath, "generation one");
+    await storage.deleteOfflineSyncFile(filePath, 5000);
+    assert.equal((await storage.readDeletionRevisions()).get(relativePath), 5000);
+
+    await storage.writeOfflineSyncFile(filePath, Buffer.from("generation two"));
+    assert.equal((await storage.readDeletionRevisions()).has(relativePath), false);
+    await storage.deleteOfflineSyncFile(filePath, 3000);
+    assert.equal((await storage.readDeletionRevisions()).get(relativePath), 3000);
+
+    await storage.writeOfflineSyncFile(filePath, Buffer.from("legacy generation"));
+    assert.equal((await storage.readDeletionRevisions()).has(relativePath), false);
+    await storage.deleteOfflineSyncFile(filePath, null);
+    assert.equal((await storage.readDeletionRevisions()).has(relativePath), false);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("storage merges a known replicated deletion revision for an already-absent path", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-deletion-relay-"));
+  try {
+    const relativePath = "facts/deleted.md";
+    const storage = new StorageManager(root);
+
+    await storage.recordReplicatedDeletionRevision(path.join(root, relativePath), 2000);
+    assert.equal((await storage.readDeletionRevisions()).get(relativePath), 2000);
+
+    await storage.recordReplicatedDeletionRevision(path.join(root, relativePath), 1000);
+    assert.equal((await storage.readDeletionRevisions()).get(relativePath), 2000);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});