@remnic/core 1.1.13 → 1.1.15

package/dist/secure-store/index.js

@@ -13,7 +13,7 @@ import {
   runSecureStoreMigrate,
   runSecureStoreStatus,
   runSecureStoreUnlock
-} from "../chunk-CK5NTM2S.js";
+} from "../chunk-OGROP7ZN.js";
 import {
   FILE_FORMAT_FLAGS,
   FILE_FORMAT_VERSION,
@@ -29,7 +29,7 @@ import {
   migrateMemoryDirToEncrypted,
   readMaybeEncryptedFile,
   writeMaybeEncryptedFile
-} from "../chunk-YNJHCGDT.js";
+} from "../chunk-SH5S7XYD.js";
 import {
   HEADER_FILENAME,
   HEADER_FORMAT,

package/dist/semantic-consolidation.js

@@ -7,20 +7,20 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-I5V2VDIW.js";
-import "./chunk-ME6ESPZU.js";
+} from "./chunk-YCVWX2NF.js";
+import "./chunk-IG5VGHYB.js";
 import "./chunk-RHY3HH7P.js";
 import {
   resolveExtensionsRoot
 } from "./chunk-EJI5XIBB.js";
 import "./chunk-3UXOZBHV.js";
 import "./chunk-U3PN77QT.js";
-import "./chunk-7AAT6G4Q.js";
+import "./chunk-IOAY54RF.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-YNJHCGDT.js";
-import "./chunk-P7FMDTKL.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";

package/dist/semantic-rule-promotion.js

@@ -1,12 +1,12 @@
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-XVZ7B3HG.js";
-import "./chunk-7AAT6G4Q.js";
+} from "./chunk-JFEH2LZM.js";
+import "./chunk-IOAY54RF.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-YNJHCGDT.js";
-import "./chunk-P7FMDTKL.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";

package/dist/semantic-rule-verifier.js

@@ -1,12 +1,12 @@
 import {
   searchVerifiedSemanticRules
-} from "./chunk-MC26UJIM.js";
-import "./chunk-7AAT6G4Q.js";
+} from "./chunk-QLKBF3TI.js";
+import "./chunk-IOAY54RF.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-YNJHCGDT.js";
-import "./chunk-P7FMDTKL.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";

package/dist/storage.d.ts

@@ -50,6 +50,8 @@ declare class ContentHashIndex {
     /** Add content hash to the index. */
     add(content: string): void;
     get size(): number;
+    /** Clear all loaded hashes so the next save rewrites the index from scratch. */
+    clear(): void;
     /** Persist index to disk if changed. */
     save(): Promise<void>;
     /** Remove a hash from the index (used when archiving/deleting). */
@@ -230,6 +232,11 @@ declare class StorageManager {
     private get entitiesDir();
     private readStorageSecureFile;
     private writeStorageSecureFile;
+    private assertManagedStoragePath;
+    readOfflineSyncFile(filePath: string): Promise<Buffer>;
+    writeOfflineSyncFile(filePath: string, content: Buffer): Promise<void>;
+    deleteOfflineSyncFile(filePath: string): Promise<void>;
+    private invalidateAfterOfflineSyncMutation;
     createContentHashIndex(): ContentHashIndex;
     private appendStorageSecureFile;
     private appendStorageSecureFileUnlocked;

package/dist/storage.js

@@ -8,12 +8,12 @@ import {
   normalizeEntityName,
   parseEntityFile,
   serializeEntityFile
-} from "./chunk-7AAT6G4Q.js";
+} from "./chunk-IOAY54RF.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-YNJHCGDT.js";
-import "./chunk-P7FMDTKL.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";

package/dist/transfer/backup.js

@@ -4,11 +4,11 @@ import {
 import "../chunk-6H2TESSP.js";
 import "../chunk-KNKUID7G.js";
 import "../chunk-J4EB7DNW.js";
-import "../chunk-I6K5FBRQ.js";
-import "../chunk-AGZQD76C.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";
 import "../chunk-FP2373TW.js";
+import "../chunk-I6K5FBRQ.js";
+import "../chunk-AGZQD76C.js";
 import "../chunk-A6XUJE5D.js";
 import "../chunk-PZ5AY32C.js";
 export {

package/dist/transfer/capsule-export.js

@@ -1,15 +1,15 @@
 import {
   exportCapsule,
   isValidCapsuleSince
-} from "../chunk-2F2W355T.js";
-import "../chunk-KNKUID7G.js";
+} from "../chunk-QA2ZAPBU.js";
 import "../chunk-WEHSQBFR.js";
+import "../chunk-KNKUID7G.js";
 import "../chunk-J4EB7DNW.js";
-import "../chunk-I6K5FBRQ.js";
-import "../chunk-AGZQD76C.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";
 import "../chunk-FP2373TW.js";
+import "../chunk-I6K5FBRQ.js";
+import "../chunk-AGZQD76C.js";
 import "../chunk-A6XUJE5D.js";
 import "../chunk-PZ5AY32C.js";
 export {

package/dist/transfer/capsule-import.js

@@ -1,13 +1,13 @@
 import {
   importCapsule
-} from "../chunk-GGKRUQOO.js";
+} from "../chunk-ZYVPLJ4T.js";
 import "../chunk-FAAFWE4G.js";
-import "../chunk-KNKUID7G.js";
 import "../chunk-WEHSQBFR.js";
-import "../chunk-AGZQD76C.js";
+import "../chunk-KNKUID7G.js";
 import "../chunk-BJMBJZ2Y.js";
 import "../chunk-UKJAGEXH.js";
 import "../chunk-FP2373TW.js";
+import "../chunk-AGZQD76C.js";
 import "../chunk-A6XUJE5D.js";
 import "../chunk-PZ5AY32C.js";
 export {

package/dist/transfer/import-sqlite.js

@@ -1,8 +1,8 @@
 import {
   importSqlite
-} from "../chunk-TFO23QT4.js";
-import "../chunk-Z734BLO3.js";
+} from "../chunk-XKLD5OK4.js";
 import "../chunk-3JXBXXM2.js";
+import "../chunk-Z734BLO3.js";
 import "../chunk-3HPAPHUK.js";
 import "../chunk-AGZQD76C.js";
 import "../chunk-PZ5AY32C.js";

package/dist/verified-recall.js

@@ -1,13 +1,13 @@
 import {
   searchVerifiedEpisodes
-} from "./chunk-P4NEIHUT.js";
+} from "./chunk-MS3ULOZF.js";
 import "./chunk-NZL6GGQE.js";
-import "./chunk-7AAT6G4Q.js";
+import "./chunk-IOAY54RF.js";
 import "./chunk-5UZXUTVO.js";
-import "./chunk-YNJHCGDT.js";
-import "./chunk-P7FMDTKL.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";

package/package.json

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

package/src/access-http.test.ts

@@ -223,3 +223,219 @@ test("HTTP review show hides namespace denial as pair_not_found", async () => {
     await rm(dir, { recursive: true, force: true });
   }
 });
+
+test("HTTP offline snapshot forwards namespace and transfer options", async () => {
+  const calls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+    includeTranscripts: boolean | undefined;
+    includeContent: boolean | undefined;
+  }> = [];
+  const service = {
+    offlineSyncSnapshot: async (options: {
+      namespace?: string;
+      principal?: string;
+      includeTranscripts?: boolean;
+      includeContent?: boolean;
+    }) => {
+      calls.push({
+        namespace: options.namespace,
+        principal: options.principal,
+        includeTranscripts: options.includeTranscripts,
+        includeContent: options.includeContent,
+      });
+      return {
+        namespace: options.namespace ?? "default",
+        format: "remnic.offline-sync.snapshot.v1",
+        schemaVersion: 1,
+        createdAt: new Date("2026-05-21T00:00:00Z").toISOString(),
+        sourceId: "remote:test",
+        includeTranscripts: options.includeTranscripts !== false,
+        files: [],
+      };
+    },
+  } 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/snapshot?namespace=team&include_transcripts=false&content=false`,
+      { headers: { authorization: "Bearer test-token" } },
+    );
+    const body = await response.json() as { namespace?: string; includeTranscripts?: boolean; files?: unknown[] };
+
+    assert.equal(response.status, 200);
+    assert.equal(body.namespace, "team");
+    assert.equal(body.includeTranscripts, false);
+    assert.deepEqual(body.files, []);
+    assert.deepEqual(calls, [{
+      namespace: "team",
+      principal: "reader",
+      includeTranscripts: false,
+      includeContent: false,
+    }]);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP offline snapshot rejects invalid boolean query values", async () => {
+  let calls = 0;
+  const service = {
+    offlineSyncSnapshot: async () => {
+      calls += 1;
+      return {};
+    },
+  } 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}/engram/v1/offline-sync/snapshot?include_transcripts=maybe`,
+      { headers: { authorization: "Bearer test-token" } },
+    );
+    const body = await response.json() as { error?: string; code?: string };
+
+    assert.equal(response.status, 400);
+    assert.match(body.error ?? "", /include_transcripts must be one of: true, false/);
+    assert.equal(body.code, "input_error");
+    assert.equal(calls, 0);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP offline apply validates and forwards changesets", async () => {
+  const calls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+    changeset: unknown;
+  }> = [];
+  const changeset = {
+    format: "remnic.offline-sync.changeset.v1",
+    schemaVersion: 1,
+    createdAt: new Date("2026-05-21T00:00:00Z").toISOString(),
+    sourceId: "laptop:test",
+    includeTranscripts: true,
+    changes: [],
+  };
+  const service = {
+    offlineSyncApply: async (options: {
+      namespace?: string;
+      principal?: string;
+      changeset: unknown;
+    }) => {
+      calls.push({
+        namespace: options.namespace,
+        principal: options.principal,
+        changeset: options.changeset,
+      });
+      return {
+        namespace: options.namespace ?? "default",
+        appliedUpserts: 0,
+        appliedDeletes: 0,
+        skipped: 0,
+        conflicts: [],
+        currentFiles: [],
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    principal: "writer",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/remnic/v1/offline-sync/apply`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ namespace: "team", changeset }),
+    });
+    const body = await response.json() as { namespace?: string; appliedUpserts?: number };
+
+    assert.equal(response.status, 200);
+    assert.equal(body.namespace, "team");
+    assert.equal(body.appliedUpserts, 0);
+    assert.deepEqual(calls, [{
+      namespace: "team",
+      principal: "writer",
+      changeset,
+    }]);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP offline apply requires a changeset", async () => {
+  let calls = 0;
+  const service = {
+    offlineSyncApply: async () => {
+      calls += 1;
+      return {};
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    principal: "writer",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/offline-sync/apply`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ namespace: "team" }),
+    });
+    const body = await response.json() as { code?: string; details?: Array<{ field?: string; message?: string }> };
+
+    assert.equal(response.status, 400);
+    assert.equal(body.code, "validation_error");
+    assert.equal(body.details?.[0]?.field, "changeset");
+    assert.equal(calls, 0);
+
+    const nullResponse = await fetch(`http://127.0.0.1:${status.port}/engram/v1/offline-sync/apply`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ namespace: "team", changeset: null }),
+    });
+    const nullBody = await nullResponse.json() as { code?: string; details?: Array<{ field?: string; message?: string }> };
+
+    assert.equal(nullResponse.status, 400);
+    assert.equal(nullBody.code, "validation_error");
+    assert.equal(nullBody.details?.[0]?.field, "changeset");
+    assert.equal(nullBody.details?.[0]?.message, "changeset is required");
+    assert.equal(calls, 0);
+  } finally {
+    await server.stop();
+  }
+});

package/src/access-http.ts

@@ -588,6 +588,60 @@ export class EngramAccessHttpServer {
       return;
     }
 
+    if (
+      req.method === "GET" &&
+      (pathname === "/engram/v1/offline-sync/snapshot" || pathname === "/remnic/v1/offline-sync/snapshot")
+    ) {
+      const includeTranscriptsRaw = parsed.searchParams.get("include_transcripts");
+      const includeContentRaw = parsed.searchParams.get("content");
+      if (
+        includeTranscriptsRaw !== null &&
+        includeTranscriptsRaw !== "true" &&
+        includeTranscriptsRaw !== "false"
+      ) {
+        throw new EngramAccessInputError(
+          `include_transcripts must be one of: true, false (got: ${includeTranscriptsRaw})`,
+        );
+      }
+      if (
+        includeContentRaw !== null &&
+        includeContentRaw !== "true" &&
+        includeContentRaw !== "false"
+      ) {
+        throw new EngramAccessInputError(
+          `content must be one of: true, false (got: ${includeContentRaw})`,
+        );
+      }
+      const namespaceParam = parsed.searchParams.get("namespace");
+      const result = await this.service.offlineSyncSnapshot({
+        namespace: this.resolveNamespace(
+          req,
+          namespaceParam && namespaceParam.length > 0 ? namespaceParam : undefined,
+        ),
+        principal: this.resolveRequestPrincipal(req),
+        includeTranscripts: includeTranscriptsRaw !== "false",
+        includeContent: includeContentRaw !== "false",
+      });
+      this.respondJson(res, 200, result);
+      return;
+    }
+
+    if (
+      req.method === "POST" &&
+      (pathname === "/engram/v1/offline-sync/apply" || pathname === "/remnic/v1/offline-sync/apply")
+    ) {
+      const body = await this.readValidatedBody(req, "offlineSyncApply");
+      this.ensureWriteRateLimitAvailable();
+      const result = await this.service.offlineSyncApply({
+        namespace: this.resolveNamespace(req, body.namespace),
+        principal: this.resolveRequestPrincipal(req),
+        changeset: body.changeset,
+      });
+      this.recordWriteRateLimitHit();
+      this.respondJson(res, 200, result);
+      return;
+    }
+
     if (req.method === "POST" && pathname === "/engram/v1/recall/explain") {
       const body = await this.readValidatedBody(req, "recallExplain");
       const response = await this.service.recallExplain({

package/src/access-schema.ts

@@ -364,6 +364,20 @@ export const capsuleListRequestSchema = z
     namespace: namespaceSchema,
   });
 
+// ---------------------------------------------------------------------------
+// Offline sync
+// ---------------------------------------------------------------------------
+
+export const offlineSyncApplyRequestSchema = z
+  .object({
+    namespace: namespaceSchema,
+    changeset: z.unknown(),
+  })
+  .refine((value) => value.changeset !== undefined && value.changeset !== null, {
+    message: "changeset is required",
+    path: ["changeset"],
+  });
+
 // ---------------------------------------------------------------------------
 // Action confidence
 // ---------------------------------------------------------------------------
@@ -429,6 +443,7 @@ export type DaySummaryRequest = z.infer<typeof daySummaryRequestSchema>;
 export type CapsuleExportRequest = z.infer<typeof capsuleExportRequestSchema>;
 export type CapsuleImportRequest = z.infer<typeof capsuleImportRequestSchema>;
 export type CapsuleListRequest = z.infer<typeof capsuleListRequestSchema>;
+export type OfflineSyncApplyRequest = z.infer<typeof offlineSyncApplyRequestSchema>;
 export type ActionConfidenceRequest = z.infer<typeof actionConfidenceRequestSchema>;
 
 // ---------------------------------------------------------------------------
@@ -452,6 +467,7 @@ export type SchemaName =
   | "capsuleExport"
   | "capsuleImport"
   | "capsuleList"
+  | "offlineSyncApply"
   | "actionConfidence";
 
 export type SchemaTypeFor<N extends SchemaName> =
@@ -471,6 +487,7 @@ export type SchemaTypeFor<N extends SchemaName> =
   : N extends "capsuleExport" ? CapsuleExportRequest
   : N extends "capsuleImport" ? CapsuleImportRequest
   : N extends "capsuleList" ? CapsuleListRequest
+  : N extends "offlineSyncApply" ? OfflineSyncApplyRequest
   : N extends "actionConfidence" ? ActionConfidenceRequest
   : never;
 
@@ -491,6 +508,7 @@ const schemas: Record<SchemaName, z.ZodTypeAny> = {
   capsuleExport: capsuleExportRequestSchema,
   capsuleImport: capsuleImportRequestSchema,
   capsuleList: capsuleListRequestSchema,
+  offlineSyncApply: offlineSyncApplyRequestSchema,
   actionConfidence: actionConfidenceRequestSchema,
 };
 

package/src/access-service.ts

@@ -135,6 +135,12 @@ import {
   defaultCapsulesDir,
   type CapsuleListEntry,
 } from "./capsule-cli.js";
+import {
+  applyOfflineSyncChangeset,
+  buildOfflineSyncSnapshot,
+  type OfflineSyncApplyChangesetResult,
+  type OfflineSyncSnapshot,
+} from "./offline-sync.js";
 import {
   evaluateActionConfidence,
   type ActionConfidenceInput,
@@ -603,6 +609,27 @@ export interface EngramAccessCapsuleListResponse {
   capsules: CapsuleListEntry[];
 }
 
+export interface EngramAccessOfflineSyncSnapshotRequest {
+  namespace?: string;
+  principal?: string;
+  includeTranscripts?: boolean;
+  includeContent?: boolean;
+}
+
+export interface EngramAccessOfflineSyncApplyRequest {
+  namespace?: string;
+  principal?: string;
+  changeset: unknown;
+}
+
+export interface EngramAccessOfflineSyncSnapshotResponse extends OfflineSyncSnapshot {
+  namespace: string;
+}
+
+export interface EngramAccessOfflineSyncApplyResponse extends OfflineSyncApplyChangesetResult {
+  namespace: string;
+}
+
 export type EngramAccessActionConfidenceRequest = ActionConfidenceInput;
 export type EngramAccessActionConfidenceResponse = ActionConfidenceResult;
 
@@ -5522,6 +5549,55 @@ export class EngramAccessService {
     return { namespace: resolvedNamespace, capsulesDir, capsules };
   }
 
+  async offlineSyncSnapshot(
+    options: EngramAccessOfflineSyncSnapshotRequest = {},
+  ): Promise<EngramAccessOfflineSyncSnapshotResponse> {
+    const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const storageHash = createHash("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    const snapshot = await buildOfflineSyncSnapshot({
+      root: storage.dir,
+      sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
+      includeContent: options.includeContent !== false,
+      includeTranscripts: options.includeTranscripts !== false,
+      readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+    });
+    return {
+      namespace: resolvedNamespace,
+      ...snapshot,
+    };
+  }
+
+  async offlineSyncApply(
+    options: EngramAccessOfflineSyncApplyRequest,
+  ): Promise<EngramAccessOfflineSyncApplyResponse> {
+    const resolvedNamespace = this.resolveWritableNamespace(
+      options.namespace,
+      undefined,
+      options.principal,
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    try {
+      const result = await applyOfflineSyncChangeset({
+        root: storage.dir,
+        changeset: options.changeset,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
+        deleteFile: async ({ filePath }) => storage.deleteOfflineSyncFile(filePath),
+      });
+      return {
+        namespace: resolvedNamespace,
+        ...result,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.startsWith("offline sync")) {
+        throw new EngramAccessInputError(message);
+      }
+      throw error;
+    }
+  }
+
   // ── Dreams pipeline telemetry surfaces (issue #678 PR 3+4) ──────────────
 
   /**

package/src/index.ts

@@ -674,6 +674,39 @@ export {
   type SyncState,
 } from "./sync/index.js";
 
+// ---------------------------------------------------------------------------
+// Offline Sync
+// ---------------------------------------------------------------------------
+
+export {
+  OFFLINE_SYNC_CHANGESET_FORMAT,
+  OFFLINE_SYNC_SNAPSHOT_FORMAT,
+  OFFLINE_SYNC_STATE_VERSION,
+  applyOfflineSyncChangeset,
+  applyOfflineSyncSnapshot,
+  buildOfflineSyncChangeset,
+  buildOfflineSyncSnapshot,
+  defaultOfflineSyncStatePath,
+  fileStatesFromSnapshot,
+  normalizeOfflineSyncChangeset,
+  normalizeOfflineSyncSnapshot,
+  offlineSyncStateFromSnapshot,
+  readOfflineSyncState,
+  summarizeOfflineSyncChangeset,
+  writeOfflineSyncState,
+  type OfflineSyncApplyChangesetResult,
+  type OfflineSyncApplySnapshotResult,
+  type OfflineSyncChange,
+  type OfflineSyncChangeset,
+  type OfflineSyncConflict,
+  type OfflineSyncFileRecord,
+  type OfflineSyncFileState,
+  type OfflineSyncFileTarget,
+  type OfflineSyncFileWriteTarget,
+  type OfflineSyncSnapshot,
+  type OfflineSyncState,
+} from "./offline-sync.js";
+
 // ---------------------------------------------------------------------------
 // Memory Extension Host (#382)
 // ---------------------------------------------------------------------------