@remnic/core 1.1.16 → 1.1.18

package/dist/semantic-rule-verifier.js

@@ -1,12 +1,10 @@
 import {
   searchVerifiedSemanticRules
-} from "./chunk-QLKBF3TI.js";
-import "./chunk-IOAY54RF.js";
+} from "./chunk-QOHBYVZG.js";
+import "./chunk-7Q2P774N.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-SH5S7XYD.js";
 import "./chunk-NN2DKE4T.js";
 import "./chunk-Q7P4WJDP.js";
-import "./chunk-P7FMDTKL.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-3KW65B36.js";
 import "./chunk-3HPAPHUK.js";
@@ -20,7 +18,9 @@ import "./chunk-FAAFWE4G.js";
 import "./chunk-DT5TVLJE.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-2ODBA7MQ.js";
+import "./chunk-SH5S7XYD.js";
 import "./chunk-A6XUJE5D.js";
+import "./chunk-P7FMDTKL.js";
 import "./chunk-PZ5AY32C.js";
 export {
   searchVerifiedSemanticRules

package/dist/storage.js

@@ -8,12 +8,10 @@ import {
   normalizeEntityName,
   parseEntityFile,
   serializeEntityFile
-} from "./chunk-IOAY54RF.js";
+} from "./chunk-7Q2P774N.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-SH5S7XYD.js";
 import "./chunk-NN2DKE4T.js";
 import "./chunk-Q7P4WJDP.js";
-import "./chunk-P7FMDTKL.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-3KW65B36.js";
 import "./chunk-3HPAPHUK.js";
@@ -26,7 +24,9 @@ import "./chunk-G7D6GZ5J.js";
 import "./chunk-FAAFWE4G.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-2ODBA7MQ.js";
+import "./chunk-SH5S7XYD.js";
 import "./chunk-A6XUJE5D.js";
+import "./chunk-P7FMDTKL.js";
 import "./chunk-PZ5AY32C.js";
 export {
   ContentHashIndex,

package/dist/transfer/types.d.ts

@@ -313,13 +313,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
+    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -334,13 +334,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
+    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -464,13 +464,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -485,13 +485,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -518,13 +518,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -551,13 +551,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -683,13 +683,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -704,13 +704,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -737,13 +737,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -770,13 +770,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -815,13 +815,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -854,13 +854,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;

package/dist/verified-recall.js

@@ -1,13 +1,11 @@
 import {
   searchVerifiedEpisodes
-} from "./chunk-MS3ULOZF.js";
+} from "./chunk-5IQC4OG6.js";
 import "./chunk-NZL6GGQE.js";
-import "./chunk-IOAY54RF.js";
+import "./chunk-7Q2P774N.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-SH5S7XYD.js";
 import "./chunk-NN2DKE4T.js";
 import "./chunk-Q7P4WJDP.js";
-import "./chunk-P7FMDTKL.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-3KW65B36.js";
 import "./chunk-3HPAPHUK.js";
@@ -21,7 +19,9 @@ import "./chunk-FAAFWE4G.js";
 import "./chunk-DT5TVLJE.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-2ODBA7MQ.js";
+import "./chunk-SH5S7XYD.js";
 import "./chunk-A6XUJE5D.js";
+import "./chunk-P7FMDTKL.js";
 import "./chunk-PZ5AY32C.js";
 export {
   searchVerifiedEpisodes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",

package/src/access-http.test.ts

@@ -359,6 +359,96 @@ test("HTTP offline files forwards namespace and requested paths", async () => {
   }
 });
 
+test("HTTP offline file-content forwards range options and returns binary metadata", async () => {
+  const calls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+    includeTranscripts: boolean | undefined;
+    path: string;
+    offset: number | undefined;
+    length: number | undefined;
+  }> = [];
+  const service = {
+    offlineSyncFileContent: async (options: {
+      namespace?: string;
+      principal?: string;
+      includeTranscripts?: boolean;
+      path: string;
+      offset?: number;
+      length?: number;
+    }) => {
+      calls.push({
+        namespace: options.namespace,
+        principal: options.principal,
+        includeTranscripts: options.includeTranscripts,
+        path: options.path,
+        offset: options.offset,
+        length: options.length,
+      });
+      return {
+        namespace: options.namespace ?? "default",
+        path: options.path,
+        sha256: "a".repeat(64),
+        bytes: 12,
+        mtimeMs: 1234,
+        offset: options.offset ?? 0,
+        chunkBytes: 5,
+        content: Buffer.from("hello"),
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    principal: "reader",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(
+      `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/file-content`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          namespace: "team",
+          includeTranscripts: false,
+          path: "state/memory-lifecycle-ledger.jsonl",
+          offset: 8,
+          length: 5,
+        }),
+      },
+    );
+    const body = Buffer.from(await response.arrayBuffer());
+
+    assert.equal(response.status, 200);
+    assert.equal(body.toString("utf-8"), "hello");
+    assert.equal(response.headers.get("content-type"), "application/octet-stream");
+    assert.equal(response.headers.get("x-remnic-namespace"), "team");
+    assert.equal(response.headers.get("x-remnic-file-path"), "state%2Fmemory-lifecycle-ledger.jsonl");
+    assert.equal(response.headers.get("x-remnic-file-sha256"), "a".repeat(64));
+    assert.equal(response.headers.get("x-remnic-file-bytes"), "12");
+    assert.equal(response.headers.get("x-remnic-file-mtime-ms"), "1234");
+    assert.equal(response.headers.get("x-remnic-chunk-offset"), "8");
+    assert.equal(response.headers.get("x-remnic-chunk-bytes"), "5");
+    assert.deepEqual(calls, [{
+      namespace: "team",
+      principal: "reader",
+      includeTranscripts: false,
+      path: "state/memory-lifecycle-ledger.jsonl",
+      offset: 8,
+      length: 5,
+    }]);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP offline snapshot rejects invalid boolean query values", async () => {
   let calls = 0;
   const service = {

package/src/access-http.ts

@@ -641,6 +641,34 @@ export class EngramAccessHttpServer {
       return;
     }
 
+    if (
+      req.method === "POST" &&
+      (
+        pathname === "/engram/v1/offline-sync/file-content" ||
+        pathname === "/remnic/v1/offline-sync/file-content"
+      )
+    ) {
+      const body = await this.readValidatedBody(req, "offlineSyncFileContent");
+      const result = await this.service.offlineSyncFileContent({
+        namespace: this.resolveNamespace(req, body.namespace),
+        principal: this.resolveRequestPrincipal(req),
+        includeTranscripts: body.includeTranscripts,
+        path: body.path,
+        offset: body.offset,
+        length: body.length,
+      });
+      this.respondBinary(res, 200, result.content, {
+        "x-remnic-namespace": encodeURIComponent(result.namespace),
+        "x-remnic-file-path": encodeURIComponent(result.path),
+        "x-remnic-file-bytes": String(result.bytes),
+        "x-remnic-file-mtime-ms": String(result.mtimeMs),
+        "x-remnic-chunk-offset": String(result.offset),
+        "x-remnic-chunk-bytes": String(result.chunkBytes),
+        ...(result.sha256 ? { "x-remnic-file-sha256": result.sha256 } : {}),
+      });
+      return;
+    }
+
     if (
       req.method === "POST" &&
       (pathname === "/engram/v1/offline-sync/apply" || pathname === "/remnic/v1/offline-sync/apply")
@@ -1803,6 +1831,25 @@ export class EngramAccessHttpServer {
     res.end(body);
   }
 
+  private respondBinary(
+    res: ServerResponse,
+    status: number,
+    body: Buffer,
+    headers: Record<string, string> = {},
+  ): void {
+    res.statusCode = status;
+    res.setHeader("content-type", "application/octet-stream");
+    res.setHeader("content-length", String(body.length));
+    for (const [key, value] of Object.entries(headers)) {
+      res.setHeader(key, value);
+    }
+    const cid = correlationIdStore.getStore();
+    if (cid) {
+      res.setHeader("x-request-id", cid);
+    }
+    res.end(body);
+  }
+
   private async handleAdminConsole(
     req: IncomingMessage,
     res: ServerResponse,

package/src/access-schema.ts

@@ -10,6 +10,7 @@ import {
 } from "./action-confidence.js";
 import { isValidCapsuleSince } from "./transfer/capsule-export.js";
 import { CAPSULE_ID_PATTERN } from "./transfer/types.js";
+import { OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES } from "./offline-sync.js";
 
 // ---------------------------------------------------------------------------
 // Error formatting
@@ -386,6 +387,14 @@ export const offlineSyncFilesRequestSchema = z.object({
     .max(5000, "paths must contain 5000 or fewer entries"),
 });
 
+export const offlineSyncFileContentRequestSchema = z.object({
+  namespace: namespaceSchema,
+  includeTranscripts: z.boolean().optional(),
+  path: z.string().trim().min(1, "path must be non-empty").max(4096),
+  offset: z.number().int().min(0).optional(),
+  length: z.number().int().min(1).max(OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES).optional(),
+});
+
 // ---------------------------------------------------------------------------
 // Action confidence
 // ---------------------------------------------------------------------------
@@ -453,6 +462,7 @@ export type CapsuleImportRequest = z.infer<typeof capsuleImportRequestSchema>;
 export type CapsuleListRequest = z.infer<typeof capsuleListRequestSchema>;
 export type OfflineSyncApplyRequest = z.infer<typeof offlineSyncApplyRequestSchema>;
 export type OfflineSyncFilesRequest = z.infer<typeof offlineSyncFilesRequestSchema>;
+export type OfflineSyncFileContentRequest = z.infer<typeof offlineSyncFileContentRequestSchema>;
 export type ActionConfidenceRequest = z.infer<typeof actionConfidenceRequestSchema>;
 
 // ---------------------------------------------------------------------------
@@ -477,6 +487,7 @@ export type SchemaName =
   | "capsuleImport"
   | "capsuleList"
   | "offlineSyncFiles"
+  | "offlineSyncFileContent"
   | "offlineSyncApply"
   | "actionConfidence";
 
@@ -498,6 +509,7 @@ export type SchemaTypeFor<N extends SchemaName> =
   : N extends "capsuleImport" ? CapsuleImportRequest
   : N extends "capsuleList" ? CapsuleListRequest
   : N extends "offlineSyncFiles" ? OfflineSyncFilesRequest
+  : N extends "offlineSyncFileContent" ? OfflineSyncFileContentRequest
   : N extends "offlineSyncApply" ? OfflineSyncApplyRequest
   : N extends "actionConfidence" ? ActionConfidenceRequest
   : never;
@@ -520,6 +532,7 @@ const schemas: Record<SchemaName, z.ZodTypeAny> = {
   capsuleImport: capsuleImportRequestSchema,
   capsuleList: capsuleListRequestSchema,
   offlineSyncFiles: offlineSyncFilesRequestSchema,
+  offlineSyncFileContent: offlineSyncFileContentRequestSchema,
   offlineSyncApply: offlineSyncApplyRequestSchema,
   actionConfidence: actionConfidenceRequestSchema,
 };

package/src/access-service.ts

@@ -139,7 +139,9 @@ import {
   applyOfflineSyncChangeset,
   buildOfflineSyncSnapshot,
   buildOfflineSyncSnapshotForPaths,
+  readOfflineSyncFileContentChunk,
   type OfflineSyncApplyChangesetResult,
+  type OfflineSyncFileContentChunk,
   type OfflineSyncSnapshot,
 } from "./offline-sync.js";
 import {
@@ -624,6 +626,15 @@ export interface EngramAccessOfflineSyncFilesRequest {
   paths: string[];
 }
 
+export interface EngramAccessOfflineSyncFileContentRequest {
+  namespace?: string;
+  principal?: string;
+  includeTranscripts?: boolean;
+  path: string;
+  offset?: number;
+  length?: number;
+}
+
 export interface EngramAccessOfflineSyncApplyRequest {
   namespace?: string;
   principal?: string;
@@ -638,6 +649,10 @@ export interface EngramAccessOfflineSyncFilesResponse extends OfflineSyncSnapsho
   namespace: string;
 }
 
+export interface EngramAccessOfflineSyncFileContentResponse extends OfflineSyncFileContentChunk {
+  namespace: string;
+}
+
 export interface EngramAccessOfflineSyncApplyResponse extends OfflineSyncApplyChangesetResult {
   namespace: string;
 }
@@ -5612,6 +5627,39 @@ export class EngramAccessService {
     }
   }
 
+  async offlineSyncFileContent(
+    options: EngramAccessOfflineSyncFileContentRequest,
+  ): Promise<EngramAccessOfflineSyncFileContentResponse> {
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    try {
+      const chunk = await readOfflineSyncFileContentChunk({
+        root: storage.dir,
+        path: options.path,
+        offset: options.offset,
+        length: options.length,
+        includeTranscripts: options.includeTranscripts !== false,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+      });
+      return {
+        namespace: resolvedNamespace,
+        ...chunk,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (
+        message.startsWith("path:") ||
+        message.startsWith("offset ") ||
+        message.startsWith("offset must ") ||
+        message.startsWith("length ") ||
+        message.startsWith("offline sync file content ")
+      ) {
+        throw new EngramAccessInputError(message);
+      }
+      throw error;
+    }
+  }
+
   async offlineSyncApply(
     options: EngramAccessOfflineSyncApplyRequest,
   ): Promise<EngramAccessOfflineSyncApplyResponse> {

package/src/index.ts

@@ -680,6 +680,7 @@ export {
 
 export {
   OFFLINE_SYNC_CHANGESET_FORMAT,
+  OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
   OFFLINE_SYNC_SNAPSHOT_FORMAT,
   OFFLINE_SYNC_STATE_VERSION,
   applyOfflineSyncChangeset,
@@ -692,6 +693,7 @@ export {
   normalizeOfflineSyncChangeset,
   normalizeOfflineSyncSnapshot,
   offlineSyncStateFromSnapshot,
+  readOfflineSyncFileContentChunk,
   readOfflineSyncState,
   summarizeOfflineSyncChangeset,
   writeOfflineSyncState,
@@ -701,6 +703,7 @@ export {
   type OfflineSyncChangeset,
   type OfflineSyncConflict,
   type OfflineSyncFileRecord,
+  type OfflineSyncFileContentChunk,
   type OfflineSyncFileState,
   type OfflineSyncFileTarget,
   type OfflineSyncFileWriteTarget,

package/src/offline-sync.test.ts

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -10,6 +11,7 @@ import {
   buildOfflineSyncChangeset,
   buildOfflineSyncSnapshot,
   buildOfflineSyncSnapshotForPaths,
+  readOfflineSyncFileContentChunk,
 } from "./offline-sync.js";
 import { isEncryptedFile } from "./secure-store/secure-fs.js";
 import { StorageManager } from "./storage.js";
@@ -39,6 +41,9 @@ test("offline snapshot captures source-of-truth files and excludes private/inter
     await write(root, ".offline-sync/state/local.json", "state");
     await write(root, "state/fact-hashes.txt", "derived");
     await write(root, "state/fact-hashes.ready", "v1");
+    await write(root, "state/lcm.sqlite", "live db");
+    await write(root, "state/lcm.sqlite-shm", "live shm");
+    await write(root, "state/lcm.sqlite-wal", "live wal");
 
     const snapshot = await buildOfflineSyncSnapshot({
       root,
@@ -68,6 +73,82 @@ test("offline snapshot captures source-of-truth files and excludes private/inter
   }
 });
 
+test("offline sync excludes live LCM sqlite artifacts without deleting existing local copies", async () => {
+  const root = await tempDir("remnic-offline-lcm-sqlite");
+  try {
+    await write(root, "facts/a.md", "alpha");
+    await write(root, "state/lcm.sqlite", "live db");
+    await write(root, "state/lcm.sqlite-shm", "live shm");
+    await write(root, "state/lcm.sqlite-wal", "live wal");
+
+    const snapshot = await buildOfflineSyncSnapshot({
+      root,
+      sourceId: "remote",
+      includeContent: true,
+    });
+
+    assert.deepEqual(snapshot.files.map((file) => file.path), ["facts/a.md"]);
+    await assert.rejects(
+      () =>
+        buildOfflineSyncSnapshotForPaths({
+          root,
+          sourceId: "remote",
+          paths: ["state/lcm.sqlite"],
+          includeContent: true,
+        }),
+      /offline sync snapshot path is excluded: state\/lcm\.sqlite/,
+    );
+
+    const oldDb = Buffer.from("old live db");
+    const pull = await applyOfflineSyncSnapshot({
+      root,
+      snapshot,
+      baseFiles: [{
+        path: "state/lcm.sqlite",
+        sha256: createHash("sha256").update(oldDb).digest("hex"),
+        bytes: oldDb.byteLength,
+        mtimeMs: 0,
+      }],
+    });
+
+    assert.equal(pull.deleted, 0);
+    assert.equal(await readUtf8(root, "state/lcm.sqlite"), "live db");
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("offline sync reads bounded file content chunks with metadata", async () => {
+  const root = await tempDir("remnic-offline-file-content");
+  try {
+    await write(root, "state/memory-lifecycle-ledger.jsonl", "alpha\nbeta\ngamma\n");
+
+    const chunk = await readOfflineSyncFileContentChunk({
+      root,
+      path: "state/memory-lifecycle-ledger.jsonl",
+      offset: 6,
+      length: 5,
+    });
+
+    assert.equal(chunk.path, "state/memory-lifecycle-ledger.jsonl");
+    assert.equal(chunk.offset, 6);
+    assert.equal(chunk.chunkBytes, 5);
+    assert.equal(chunk.content.toString("utf-8"), "beta\n");
+    assert.equal(chunk.bytes, Buffer.byteLength("alpha\nbeta\ngamma\n"));
+
+    await assert.rejects(
+      () =>
+        readOfflineSyncFileContentChunk({
+          root,
+          path: "state/lcm.sqlite",
+        }),
+      /offline sync file content path is excluded: state\/lcm\.sqlite/,
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("offline changeset pushes local edits when the remote is still at the shared base", async () => {
   const remote = await tempDir("remnic-offline-remote");
   const local = await tempDir("remnic-offline-local");