@remnic/core 1.1.22 → 1.1.24

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,8 +1,8 @@
 import {
   searchVerifiedEpisodes
-} from "./chunk-5IQC4OG6.js";
+} from "./chunk-4H6DURG6.js";
 import "./chunk-NZL6GGQE.js";
-import "./chunk-7Q2P774N.js";
+import "./chunk-F33CJ5CH.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-NN2DKE4T.js";
 import "./chunk-Q7P4WJDP.js";
@@ -19,7 +19,7 @@ import "./chunk-FAAFWE4G.js";
 import "./chunk-DT5TVLJE.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-2ODBA7MQ.js";
-import "./chunk-SH5S7XYD.js";
+import "./chunk-MXFBBHJU.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-PZ5AY32C.js";

package/package.json

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

package/src/access-http.test.ts

@@ -449,6 +449,182 @@ test("HTTP offline file-content forwards range options and returns binary metada
   }
 });
 
+test("HTTP offline apply-file-content forwards binary chunks and metadata", async () => {
+  const calls: Array<{
+    namespace: string | undefined;
+    principal: string | undefined;
+    includeTranscripts: boolean | undefined;
+    sourceId: string;
+    path: string;
+    sha256: string;
+    bytes: number;
+    mtimeMs: number;
+    offset: number | undefined;
+    baseSha256: string | undefined;
+    content: string;
+  }> = [];
+  const service = {
+    offlineSyncApplyFileContent: async (options: {
+      namespace?: string;
+      principal?: string;
+      includeTranscripts?: boolean;
+      sourceId: string;
+      path: string;
+      sha256: string;
+      bytes: number;
+      mtimeMs: number;
+      offset?: number;
+      baseSha256?: string;
+      content: Buffer;
+    }) => {
+      calls.push({
+        namespace: options.namespace,
+        principal: options.principal,
+        includeTranscripts: options.includeTranscripts,
+        sourceId: options.sourceId,
+        path: options.path,
+        sha256: options.sha256,
+        bytes: options.bytes,
+        mtimeMs: options.mtimeMs,
+        offset: options.offset,
+        baseSha256: options.baseSha256,
+        content: options.content.toString("utf-8"),
+      });
+      return {
+        namespace: options.namespace ?? "default",
+        path: options.path,
+        sha256: options.sha256,
+        bytes: options.bytes,
+        mtimeMs: options.mtimeMs,
+        offset: options.offset ?? 0,
+        chunkBytes: options.content.length,
+        done: true,
+        applied: true,
+        skipped: false,
+      };
+    },
+  } 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-file-content?namespace=team`,
+      {
+        method: "POST",
+        headers: {
+          authorization: "Bearer test-token",
+          "content-type": "application/octet-stream",
+          "x-remnic-include-transcripts": "false",
+          "x-remnic-source-id": encodeURIComponent("laptop:test"),
+          "x-remnic-file-path": encodeURIComponent("state/lcm.sqlite"),
+          "x-remnic-file-sha256": "b".repeat(64),
+          "x-remnic-file-bytes": "5",
+          "x-remnic-file-mtime-ms": "1234",
+          "x-remnic-chunk-offset": "8",
+          "x-remnic-base-sha256": "a".repeat(64),
+        },
+        body: Buffer.from("hello"),
+      },
+    );
+    const body = await response.json() as { namespace?: string; applied?: boolean; chunkBytes?: number };
+
+    assert.equal(response.status, 200);
+    assert.equal(body.namespace, "team");
+    assert.equal(body.applied, true);
+    assert.equal(body.chunkBytes, 5);
+    assert.deepEqual(calls, [{
+      namespace: "team",
+      principal: "writer",
+      includeTranscripts: false,
+      sourceId: "laptop:test",
+      path: "state/lcm.sqlite",
+      sha256: "b".repeat(64),
+      bytes: 5,
+      mtimeMs: 1234,
+      offset: 8,
+      baseSha256: "a".repeat(64),
+      content: "hello",
+    }]);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP offline apply-file-content allows bulk sync chunks outside the generic write throttle", async () => {
+  let calls = 0;
+  const service = {
+    offlineSyncApplyFileContent: async (options: {
+      namespace?: string;
+      path: string;
+      sha256: string;
+      bytes: number;
+      mtimeMs: number;
+      offset?: number;
+      content: Buffer;
+    }) => {
+      calls += 1;
+      return {
+        namespace: options.namespace ?? "default",
+        path: options.path,
+        sha256: options.sha256,
+        bytes: options.bytes,
+        mtimeMs: options.mtimeMs,
+        offset: options.offset ?? 0,
+        chunkBytes: options.content.length,
+        done: true,
+        applied: true,
+        skipped: false,
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    principal: "writer",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    let lastStatus = 0;
+    for (let i = 0; i < 31; i += 1) {
+      const response = await fetch(
+        `http://127.0.0.1:${status.port}/remnic/v1/offline-sync/apply-file-content?namespace=team`,
+        {
+          method: "POST",
+          headers: {
+            authorization: "Bearer test-token",
+            "content-type": "application/octet-stream",
+            "x-remnic-source-id": encodeURIComponent("laptop:test"),
+            "x-remnic-file-path": encodeURIComponent(`state/file-${i}.bin`),
+            "x-remnic-file-sha256": "b".repeat(64),
+            "x-remnic-file-bytes": "5",
+            "x-remnic-file-mtime-ms": "1234",
+            "x-remnic-chunk-offset": "0",
+          },
+          body: new Blob([new Uint8Array(Buffer.from("hello"))]),
+        },
+      );
+      lastStatus = response.status;
+      if (!response.ok) break;
+      await response.arrayBuffer();
+    }
+
+    assert.equal(lastStatus, 200);
+    assert.equal(calls, 31);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP offline snapshot rejects invalid boolean query values", async () => {
   let calls = 0;
   const service = {
@@ -550,6 +726,69 @@ test("HTTP offline apply validates and forwards changesets", async () => {
   }
 });
 
+test("HTTP offline apply accepts bulk changesets above the generic JSON body limit", async () => {
+  let calls = 0;
+  const largeContent = Buffer.alloc(256 * 1024, 7).toString("base64");
+  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: [{
+      type: "upsert",
+      path: "facts/large.md",
+      file: {
+        path: "facts/large.md",
+        sha256: "b".repeat(64),
+        bytes: 256 * 1024,
+        mtimeMs: 1,
+        contentBase64: largeContent,
+      },
+    }],
+  };
+  const service = {
+    offlineSyncApply: async () => {
+      calls += 1;
+      return {
+        namespace: "team",
+        appliedUpserts: 1,
+        appliedDeletes: 0,
+        skipped: 0,
+        conflicts: [],
+        currentFiles: [],
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    principal: "writer",
+    maxBodyBytes: 1024,
+    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 { appliedUpserts?: number };
+
+    assert.equal(response.status, 200);
+    assert.equal(body.appliedUpserts, 1);
+    assert.equal(calls, 1);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP offline apply requires a changeset", async () => {
   let calls = 0;
   const service = {

package/src/access-http.ts

@@ -9,6 +9,10 @@ import { log } from "./logger.js";
 import { EngramAccessInputError, type EngramAccessService } from "./access-service.js";
 import { EngramMcpServer } from "./access-mcp.js";
 import { validateRequest, type SchemaName, type SchemaTypeFor } from "./access-schema.js";
+import {
+  OFFLINE_SYNC_APPLY_MAX_BODY_BYTES,
+  OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
+} from "./offline-sync.js";
 import type { RecallDisclosure, RecallPlanMode } from "./types.js";
 import { isRecallDisclosure } from "./types.js";
 import { isTrustZoneName, type TrustZoneName, type TrustZoneRecordKind, type TrustZoneSourceClass } from "./trust-zones.js";
@@ -669,18 +673,51 @@ export class EngramAccessHttpServer {
       return;
     }
 
+    if (
+      req.method === "POST" &&
+      (
+        pathname === "/engram/v1/offline-sync/apply-file-content" ||
+        pathname === "/remnic/v1/offline-sync/apply-file-content"
+      )
+    ) {
+      const namespaceParam = parsed.searchParams.get("namespace");
+      const bytes = this.readRequiredIntegerHeader(req, "x-remnic-file-bytes");
+      const offset = this.readOptionalIntegerHeader(req, "x-remnic-chunk-offset") ?? 0;
+      const content = await this.readBinaryBody(req, OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES);
+      const result = await this.service.offlineSyncApplyFileContent({
+        namespace: this.resolveNamespace(
+          req,
+          namespaceParam && namespaceParam.length > 0 ? namespaceParam : undefined,
+        ),
+        principal: this.resolveRequestPrincipal(req),
+        includeTranscripts: this.parseOptionalBooleanHeader(
+          req,
+          "x-remnic-include-transcripts",
+          true,
+        ),
+        sourceId: this.readRequiredDecodedHeader(req, "x-remnic-source-id"),
+        path: this.readRequiredDecodedHeader(req, "x-remnic-file-path"),
+        sha256: this.readRequiredHeader(req, "x-remnic-file-sha256"),
+        bytes,
+        mtimeMs: this.readRequiredNumberHeader(req, "x-remnic-file-mtime-ms"),
+        offset,
+        baseSha256: this.readOptionalHeader(req, "x-remnic-base-sha256"),
+        content,
+      });
+      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 body = await this.readValidatedBody(req, "offlineSyncApply", OFFLINE_SYNC_APPLY_MAX_BODY_BYTES);
       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;
     }
@@ -1885,13 +1922,16 @@ export class EngramAccessHttpServer {
     }
   }
 
-  private async readJsonBody(req: IncomingMessage): Promise<Record<string, unknown>> {
+  private async readJsonBody(
+    req: IncomingMessage,
+    maxBodyBytes = this.maxBodyBytes,
+  ): Promise<Record<string, unknown>> {
     const chunks: Buffer[] = [];
     let total = 0;
     for await (const chunk of req) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
       total += buffer.length;
-      if (total > this.maxBodyBytes) {
+      if (total > maxBodyBytes) {
         throw new HttpError(413, "request_body_too_large", "request_body_too_large");
       }
       chunks.push(buffer);
@@ -1911,8 +1951,89 @@ export class EngramAccessHttpServer {
     return parsed as Record<string, unknown>;
   }
 
-  private async readValidatedBody<S extends SchemaName>(req: IncomingMessage, schemaName: S): Promise<SchemaTypeFor<S>> {
-    const raw = await this.readJsonBody(req);
+  private async readBinaryBody(req: IncomingMessage, maxBytes: number): Promise<Buffer> {
+    const chunks: Buffer[] = [];
+    let total = 0;
+    for await (const chunk of req) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      total += buffer.length;
+      if (total > maxBytes) {
+        throw new HttpError(413, "request_body_too_large", "request_body_too_large");
+      }
+      chunks.push(buffer);
+    }
+    return Buffer.concat(chunks, total);
+  }
+
+  private readRequiredHeader(req: IncomingMessage, name: string): string {
+    const value = this.readOptionalHeader(req, name);
+    if (value === undefined || value.length === 0) {
+      throw new EngramAccessInputError(`${name} header is required`);
+    }
+    return value;
+  }
+
+  private readOptionalHeader(req: IncomingMessage, name: string): string | undefined {
+    const raw = req.headers[name.toLowerCase()];
+    if (Array.isArray(raw)) return raw[0]?.trim() || undefined;
+    return raw?.trim() || undefined;
+  }
+
+  private readRequiredDecodedHeader(req: IncomingMessage, name: string): string {
+    const raw = this.readRequiredHeader(req, name);
+    try {
+      return decodeURIComponent(raw);
+    } catch {
+      throw new EngramAccessInputError(`${name} header is not valid percent-encoded input`);
+    }
+  }
+
+  private readRequiredIntegerHeader(req: IncomingMessage, name: string): number {
+    const raw = this.readRequiredHeader(req, name);
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+      throw new EngramAccessInputError(`${name} header must be a non-negative integer`);
+    }
+    return parsed;
+  }
+
+  private readOptionalIntegerHeader(req: IncomingMessage, name: string): number | undefined {
+    const raw = this.readOptionalHeader(req, name);
+    if (raw === undefined) return undefined;
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+      throw new EngramAccessInputError(`${name} header must be a non-negative integer`);
+    }
+    return parsed;
+  }
+
+  private readRequiredNumberHeader(req: IncomingMessage, name: string): number {
+    const raw = this.readRequiredHeader(req, name);
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      throw new EngramAccessInputError(`${name} header must be a non-negative finite number`);
+    }
+    return parsed;
+  }
+
+  private parseOptionalBooleanHeader(
+    req: IncomingMessage,
+    name: string,
+    defaultValue: boolean,
+  ): boolean {
+    const raw = this.readOptionalHeader(req, name);
+    if (raw === undefined) return defaultValue;
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+    throw new EngramAccessInputError(`${name} header must be one of: true, false`);
+  }
+
+  private async readValidatedBody<S extends SchemaName>(
+    req: IncomingMessage,
+    schemaName: S,
+    maxBodyBytes?: number,
+  ): Promise<SchemaTypeFor<S>> {
+    const raw = await this.readJsonBody(req, maxBodyBytes);
     const result = validateRequest(schemaName, raw);
     if (!result.success) {
       throw new HttpError(400, result.error.error, "validation_error", result.error.details);

package/src/access-service-offline-file-content.test.ts

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { EngramAccessInputError, EngramAccessService } from "./access-service.js";
+
+function createOfflineService(): EngramAccessService {
+  return new EngramAccessService({
+    config: {
+      memoryDir: "/tmp/remnic-access-service-offline-file-content-test",
+      namespacesEnabled: false,
+      defaultNamespace: "global",
+      sharedNamespace: "shared",
+    },
+    getStorage: async () => ({
+      dir: "/tmp/remnic-access-service-offline-file-content-test",
+    }),
+  } as any);
+}
+
+test("offline apply-file-content reports invalid metadata as input errors", async () => {
+  const service = createOfflineService();
+  await assert.rejects(
+    () => service.offlineSyncApplyFileContent({
+      includeTranscripts: true,
+      sourceId: "laptop",
+      path: "state/lcm.sqlite",
+      sha256: "not-a-sha",
+      bytes: 0,
+      mtimeMs: 0,
+      offset: 0,
+      content: Buffer.alloc(0),
+    }),
+    (error) =>
+      error instanceof EngramAccessInputError &&
+      /sha256 must be a 64-character sha256/.test(error.message),
+  );
+});