@remnic/core 1.1.21 → 1.1.23

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.21",
+  "version": "1.1.23",
   "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 rate limits accepted chunks", 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, 429);
+    assert.equal(calls, 30);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP offline snapshot rejects invalid boolean query values", async () => {
   let calls = 0;
   const service = {

package/src/access-http.ts

@@ -9,6 +9,7 @@ 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_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,6 +670,44 @@ 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 startsUpload = offset === 0;
+      if (startsUpload) this.ensureWriteRateLimitAvailable();
+      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,
+      });
+      if (startsUpload) this.recordWriteRateLimitHit();
+      this.respondJson(res, 200, result);
+      return;
+    }
+
     if (
       req.method === "POST" &&
       (pathname === "/engram/v1/offline-sync/apply" || pathname === "/remnic/v1/offline-sync/apply")
@@ -1911,6 +1950,83 @@ export class EngramAccessHttpServer {
     return parsed as Record<string, unknown>;
   }
 
+  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): Promise<SchemaTypeFor<S>> {
     const raw = await this.readJsonBody(req);
     const result = validateRequest(schemaName, raw);

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),
+  );
+});

package/src/access-service.ts

@@ -136,10 +136,12 @@ import {
   type CapsuleListEntry,
 } from "./capsule-cli.js";
 import {
+  applyOfflineSyncFileContentChunk,
   applyOfflineSyncChangeset,
   buildOfflineSyncSnapshot,
   buildOfflineSyncSnapshotForPaths,
   readOfflineSyncFileContentChunk,
+  type OfflineSyncApplyFileContentChunkResult,
   type OfflineSyncApplyChangesetResult,
   type OfflineSyncFileContentChunk,
   type OfflineSyncSnapshot,
@@ -635,6 +637,20 @@ export interface EngramAccessOfflineSyncFileContentRequest {
   length?: number;
 }
 
+export interface EngramAccessOfflineSyncApplyFileContentRequest {
+  namespace?: string;
+  principal?: string;
+  includeTranscripts?: boolean;
+  sourceId: string;
+  path: string;
+  sha256: string;
+  bytes: number;
+  mtimeMs: number;
+  offset?: number;
+  baseSha256?: string;
+  content: Buffer;
+}
+
 export interface EngramAccessOfflineSyncApplyRequest {
   namespace?: string;
   principal?: string;
@@ -653,6 +669,10 @@ export interface EngramAccessOfflineSyncFileContentResponse extends OfflineSyncF
   namespace: string;
 }
 
+export interface EngramAccessOfflineSyncApplyFileContentResponse extends OfflineSyncApplyFileContentChunkResult {
+  namespace: string;
+}
+
 export interface EngramAccessOfflineSyncApplyResponse extends OfflineSyncApplyChangesetResult {
   namespace: string;
 }
@@ -5660,6 +5680,56 @@ export class EngramAccessService {
     }
   }
 
+  async offlineSyncApplyFileContent(
+    options: EngramAccessOfflineSyncApplyFileContentRequest,
+  ): Promise<EngramAccessOfflineSyncApplyFileContentResponse> {
+    const resolvedNamespace = this.resolveWritableNamespace(
+      options.namespace,
+      undefined,
+      options.principal,
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    try {
+      const result = await applyOfflineSyncFileContentChunk({
+        root: storage.dir,
+        sourceId: options.sourceId,
+        path: options.path,
+        sha256: options.sha256,
+        bytes: options.bytes,
+        mtimeMs: options.mtimeMs,
+        offset: options.offset,
+        baseSha256: options.baseSha256,
+        content: options.content,
+        includeTranscripts: options.includeTranscripts !== false,
+        readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+        writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
+        writeStagingFile: async ({ filePath, content }) => storage.writeOfflineSyncStagingFile(filePath, content),
+        writeFileChunks: async ({ filePath, chunks }) => storage.writeOfflineSyncFileChunks(filePath, chunks),
+      });
+      return {
+        namespace: resolvedNamespace,
+        ...result,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (
+        message.startsWith("offline sync") ||
+        message.startsWith("path:") ||
+        message.startsWith("sourceId must ") ||
+        message.startsWith("sha256 must ") ||
+        message.startsWith("baseSha256 must ") ||
+        message.startsWith("bytes must ") ||
+        message.startsWith("mtimeMs must ") ||
+        message.startsWith("offset must ") ||
+        message.startsWith("content chunk ") ||
+        message === "content must be a Buffer"
+      ) {
+        throw new EngramAccessInputError(message);
+      }
+      throw error;
+    }
+  }
+
   async offlineSyncApply(
     options: EngramAccessOfflineSyncApplyRequest,
   ): Promise<EngramAccessOfflineSyncApplyResponse> {

package/src/index.ts

@@ -683,6 +683,7 @@ export {
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
   OFFLINE_SYNC_SNAPSHOT_FORMAT,
   OFFLINE_SYNC_STATE_VERSION,
+  applyOfflineSyncFileContentChunk,
   applyOfflineSyncChangeset,
   applyOfflineSyncSnapshot,
   buildOfflineSyncChangeset,
@@ -698,6 +699,7 @@ export {
   summarizeOfflineSyncChangeset,
   summarizeOfflineSyncPendingChanges,
   writeOfflineSyncState,
+  type OfflineSyncApplyFileContentChunkResult,
   type OfflineSyncApplyChangesetResult,
   type OfflineSyncApplySnapshotResult,
   type OfflineSyncChange,