@pyxmate/memory 1.23.2 → 1.24.0

package/dist/{chunk-7YHCNO3N.mjs → chunk-L2RHO7DP.mjs}

@@ -1,6 +1,6 @@
 import {
   MemoryClient
-} from "./chunk-SGL73IY5.mjs";
+} from "./chunk-LF22PCY6.mjs";
 
 // ../dashboard/src/aggregations/consolidation-analytics.ts
 function analyzeConsolidationLog(entries) {

package/dist/{chunk-SGL73IY5.mjs → chunk-LF22PCY6.mjs}

@@ -2,7 +2,7 @@ import {
   RAGStrategy,
   assertGraphExtractionPayload,
   mergeExtractedEntities
-} from "./chunk-C46EE5BH.mjs";
+} from "./chunk-VXXRCAKS.mjs";
 
 // ../client/src/disabled-memory.ts
 var DEFAULT_PAGE_LIMIT = 20;

package/dist/{chunk-C46EE5BH.mjs → chunk-VXXRCAKS.mjs}

@@ -164,6 +164,38 @@ var DATA_PLANE_COMPILER_LIMITS = {
   graphEntities: 1e3,
   graphRelationships: 2e3
 };
+var HOSTED_FILE_INGEST_PROTOCOL = {
+  version: 1,
+  capability: "hosted-file-ingest-v1",
+  capabilityHeader: "X-Pyx-Gateway-Capabilities",
+  uploadTokenHeader: "X-Pyx-Upload-Token",
+  metaKey: "pyx.dev/hosted-file-ingest",
+  routeBase: "/api/memory/file-ingests",
+  preparationVersion: "pyx-file-prepare-v1"
+};
+var HOSTED_FILE_INGEST_LIMITS = {
+  maxFileBytes: 50 * 1024 * 1024,
+  maxFilenameBytes: 255,
+  maxExtractedUtf8Bytes: 4 * 1024 * 1024,
+  maxChunks: 4096,
+  maxChunkUtf8Bytes: 16 * 1024,
+  maxPageEntries: 50,
+  maxPageEmbeddingUtf8Bytes: 256 * 1024,
+  maxPageCanonicalBytes: 512 * 1024,
+  maxManifestCanonicalBytes: 256 * 1024,
+  uploadTokenTtlMs: 10 * 60 * 1e3,
+  prepareTimeoutMs: 60 * 1e3,
+  jobTtlMs: 24 * 60 * 60 * 1e3
+};
+var HOSTED_FILE_INGEST_JOB_STATES = [
+  "awaiting_upload",
+  "uploaded",
+  "prepared",
+  "published",
+  "failed",
+  "cancelled",
+  "expired"
+];
 var MEMORY_TYPES = ["short-term", "long-term", "working", "episodic", "summary"];
 var ENTRY_STATUSES = ["active", "superseded", "archived"];
 var SENSITIVITY_LEVELS = ["public", "internal", "secret"];
@@ -199,6 +231,10 @@ var DATA_PLANE_OPERATION_COVERAGE = {
   "rest:batch_store": {
     support: "journal_multi_step"
   },
+  "rest:file_ingest_begin": { support: "journal_multi_step" },
+  "rest:file_ingest_prepare": { support: "journal_multi_step" },
+  "rest:file_ingest_commit": { support: "journal_multi_step" },
+  "rest:file_ingest_publish": { support: "journal_multi_step" },
   "rest:get": { support: "sqlite_atomic_one_step" },
   "rest:expand": { support: "sqlite_atomic_one_step" },
   "rest:delete": {
@@ -911,6 +947,128 @@ function normalizeBatchStore(input, context) {
   }
   return { entries };
 }
+var HOSTED_FILE_INGEST_JOB_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var SHA256_HEX_RE = /^[0-9a-f]{64}$/;
+function requireHostedFileIngestJobId(value, field) {
+  const text = requireString(value, field, { maxBytes: 36 });
+  if (!HOSTED_FILE_INGEST_JOB_ID_RE.test(text)) {
+    throw new Error(`${field} must be a lowercase UUIDv4`);
+  }
+  return text;
+}
+function requireSha256Hex(value, field) {
+  const text = requireString(value, field, { maxBytes: 64 });
+  if (!SHA256_HEX_RE.test(text)) throw new Error(`${field} must be a lowercase SHA-256 hex digest`);
+  return text;
+}
+function requireHostedFileIngestFilename(value, field) {
+  const name = requireString(value, field, {
+    maxBytes: HOSTED_FILE_INGEST_LIMITS.maxFilenameBytes
+  });
+  if (name.includes("/") || name.includes("\\") || name.startsWith(".") || // biome-ignore lint/suspicious/noControlCharactersInRegex: control characters are what this rejects
+  /[\u0000-\u001f\u007f]/.test(name)) {
+    throw new Error(`${field} must be a plain filename`);
+  }
+  return name;
+}
+function normalizeFileIngestBegin(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["jobId", "filename", "byteLength", "sha256", "description"], "input");
+  const normalized = {
+    jobId: requireHostedFileIngestJobId(value.jobId, "input.jobId"),
+    filename: requireHostedFileIngestFilename(value.filename, "input.filename"),
+    byteLength: requireInteger(
+      value.byteLength,
+      "input.byteLength",
+      1,
+      HOSTED_FILE_INGEST_LIMITS.maxFileBytes
+    ),
+    sha256: requireSha256Hex(value.sha256, "input.sha256")
+  };
+  withOptional(normalized, "description", optionalString(value.description, "input.description"));
+  return normalized;
+}
+function normalizeFileIngestJob(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["jobId"], "input");
+  return { jobId: requireHostedFileIngestJobId(value.jobId, "input.jobId") };
+}
+function normalizeHostedFileIngestPageDescriptor(input, field) {
+  const value = requireObject(input, field);
+  const keys = [
+    "pageIndex",
+    "firstChunkIndex",
+    "chunkCount",
+    "pageSha256",
+    "embeddingInputSha256",
+    "embeddingUnicodeScalars",
+    "embeddingUtf8Bytes"
+  ];
+  requireExactKeys(value, keys, field);
+  const limits = HOSTED_FILE_INGEST_LIMITS;
+  const firstChunkIndex = requireInteger(
+    value.firstChunkIndex,
+    `${field}.firstChunkIndex`,
+    0,
+    limits.maxChunks - 1
+  );
+  const chunkCount = requireInteger(
+    value.chunkCount,
+    `${field}.chunkCount`,
+    1,
+    limits.maxPageEntries
+  );
+  if (firstChunkIndex + chunkCount > limits.maxChunks) {
+    throw new Error(`${field} exceeds ${limits.maxChunks} chunks`);
+  }
+  const embeddingUtf8Bytes = requireInteger(
+    value.embeddingUtf8Bytes,
+    `${field}.embeddingUtf8Bytes`,
+    1,
+    limits.maxPageEmbeddingUtf8Bytes
+  );
+  return {
+    pageIndex: requireInteger(value.pageIndex, `${field}.pageIndex`, 0, limits.maxChunks - 1),
+    firstChunkIndex,
+    chunkCount,
+    pageSha256: requireSha256Hex(value.pageSha256, `${field}.pageSha256`),
+    embeddingInputSha256: requireSha256Hex(
+      value.embeddingInputSha256,
+      `${field}.embeddingInputSha256`
+    ),
+    // Every Unicode scalar occupies at least one UTF-8 byte.
+    embeddingUnicodeScalars: requireInteger(
+      value.embeddingUnicodeScalars,
+      `${field}.embeddingUnicodeScalars`,
+      1,
+      embeddingUtf8Bytes
+    ),
+    embeddingUtf8Bytes
+  };
+}
+function normalizeFileIngestCommit(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["jobId", "manifestSha256", "page"], "input");
+  return {
+    jobId: requireHostedFileIngestJobId(value.jobId, "input.jobId"),
+    manifestSha256: requireSha256Hex(value.manifestSha256, "input.manifestSha256"),
+    page: { ...normalizeHostedFileIngestPageDescriptor(value.page, "input.page") }
+  };
+}
+function normalizeFileIngestPublish(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["jobId", "manifestSha256", "entryCount"], "input");
+  return {
+    jobId: requireHostedFileIngestJobId(value.jobId, "input.jobId"),
+    manifestSha256: requireSha256Hex(value.manifestSha256, "input.manifestSha256"),
+    entryCount: requireInteger(
+      value.entryCount,
+      "input.entryCount",
+      1,
+      HOSTED_FILE_INGEST_LIMITS.maxChunks
+    )
+  };
+}
 function normalizeSearch(input, mcp) {
   const value = requireObject(input, "input");
   const keys = [
@@ -1092,6 +1250,14 @@ function normalizeSupportedInput(operation, input, context) {
       return normalizeStore(input, context, true);
     case "rest:batch_store":
       return normalizeBatchStore(input, context);
+    case "rest:file_ingest_begin":
+      return normalizeFileIngestBegin(input);
+    case "rest:file_ingest_prepare":
+      return normalizeFileIngestJob(input);
+    case "rest:file_ingest_commit":
+      return normalizeFileIngestCommit(input);
+    case "rest:file_ingest_publish":
+      return normalizeFileIngestPublish(input);
     case "rest:search":
       return normalizeSearch(input, false);
     case "mcp:search_memories":
@@ -1177,6 +1343,9 @@ function requireExecutionScope(operation, context) {
   if (context.runtimeAttestation.tenantMode === "multi" && namespaceRequiredInMulti.has(operation) && context.scope.namespaceId === void 0) {
     throw new Error(`${operation} requires trusted context.scope.namespaceId in multi-tenant mode`);
   }
+  if (operation.startsWith("rest:file_ingest_") && (context.scope.userId !== void 0 || context.scope.teamId !== void 0)) {
+    throw new Error(`${operation} does not accept user or team scope`);
+  }
   if (operation === "mcp:get_user_profile" || operation === "mcp:upsert_user_profile") {
     if (context.scope.namespaceId === void 0) {
       throw new Error(`${operation} requires trusted context.scope.namespaceId`);
@@ -1454,6 +1623,10 @@ function compileDataPlaneRequest(request) {
       case "rest:reinforce":
       case "mcp:reinforce":
         return ["vector", "sqlite"];
+      case "rest:file_ingest_commit":
+        return ["embedding", "sqlite"];
+      case "rest:file_ingest_publish":
+        return ["vector", "sqlite"];
       default:
         return ["sqlite"];
     }
@@ -1470,7 +1643,8 @@ function compileDataPlaneRequest(request) {
     }))
   };
   const manifest = hashDataPlaneManifestV1(executionPlan);
-  const embeddingUnicodeScalars = supportedOperation === "rest:store" || supportedOperation === "mcp:store_memory" ? storeHasTarget("vector") ? Array.from(normalizedInput.content).length : 0 : supportedOperation === "rest:batch_store" ? storeEntries.reduce(
+  const filePage = supportedOperation === "rest:file_ingest_commit" ? normalizedInput.page : void 0;
+  const embeddingUnicodeScalars = filePage !== void 0 ? filePage.embeddingUnicodeScalars : supportedOperation === "rest:store" || supportedOperation === "mcp:store_memory" ? storeHasTarget("vector") ? Array.from(normalizedInput.content).length : 0 : supportedOperation === "rest:batch_store" ? storeEntries.reduce(
     (total, entry2) => total + (entry2.targets.includes("vector") ? Array.from(entry2.content).length : 0),
     0
   ) : supportedOperation === "rest:search" || supportedOperation === "mcp:search_memories" ? Array.from(normalizedInput.query).length : 0;
@@ -1487,12 +1661,240 @@ function compileDataPlaneRequest(request) {
     manifestCanonicalJson: manifest.canonicalJson,
     manifestSha256: manifest.sha256,
     quoteDimensions: {
-      databaseOperations: supportedOperation === "rest:batch_store" ? normalizedInput.entries.length : 1,
+      databaseOperations: supportedOperation === "rest:batch_store" ? normalizedInput.entries.length : filePage !== void 0 ? filePage.chunkCount : 1,
       embeddingUnicodeScalars,
       embeddingEvents: embeddingUnicodeScalars > 0 ? 1 : 0
     }
   };
 }
+function normalizeHostedFileIngestManifest(input, field) {
+  const value = requireObject(input, field);
+  requireExactKeys(
+    value,
+    [
+      "manifestSha256",
+      "preparationVersion",
+      "entryCount",
+      "pageCount",
+      "extractedUtf8Bytes",
+      "embeddingUnicodeScalars",
+      "pages"
+    ],
+    field
+  );
+  const limits = HOSTED_FILE_INGEST_LIMITS;
+  if (!Array.isArray(value.pages) || value.pages.length < 1) {
+    throw new Error(`${field}.pages must be a non-empty array`);
+  }
+  const pages = value.pages.map(
+    (page, index) => normalizeHostedFileIngestPageDescriptor(page, `${field}.pages[${index}]`)
+  );
+  let nextChunk = 0;
+  let scalars = 0;
+  for (const [index, page] of pages.entries()) {
+    if (page.pageIndex !== index || page.firstChunkIndex !== nextChunk) {
+      throw new Error(`${field}.pages[${index}] is out of sequence`);
+    }
+    nextChunk += page.chunkCount;
+    scalars += page.embeddingUnicodeScalars;
+  }
+  const manifest = {
+    manifestSha256: requireSha256Hex(value.manifestSha256, `${field}.manifestSha256`),
+    preparationVersion: requireString(value.preparationVersion, `${field}.preparationVersion`, {
+      maxBytes: 64
+    }),
+    entryCount: requireInteger(value.entryCount, `${field}.entryCount`, 1, limits.maxChunks),
+    pageCount: requireInteger(value.pageCount, `${field}.pageCount`, 1, limits.maxChunks),
+    extractedUtf8Bytes: requireInteger(
+      value.extractedUtf8Bytes,
+      `${field}.extractedUtf8Bytes`,
+      1,
+      limits.maxExtractedUtf8Bytes
+    ),
+    embeddingUnicodeScalars: requireInteger(
+      value.embeddingUnicodeScalars,
+      `${field}.embeddingUnicodeScalars`,
+      1,
+      Number.MAX_SAFE_INTEGER
+    ),
+    pages
+  };
+  if (manifest.pageCount !== pages.length || manifest.entryCount !== nextChunk || manifest.embeddingUnicodeScalars !== scalars) {
+    throw new Error(`${field} totals do not match its pages`);
+  }
+  return manifest;
+}
+function requireIsoField(value, field) {
+  return requireCanonicalIso(value, field);
+}
+function normalizeHostedFileIngestPublication(input, field) {
+  const value = requireObject(input, field);
+  requireExactKeys(value, ["entryCount", "retiredCount", "fileId"], field);
+  return {
+    entryCount: requireInteger(
+      value.entryCount,
+      `${field}.entryCount`,
+      1,
+      HOSTED_FILE_INGEST_LIMITS.maxChunks
+    ),
+    retiredCount: requireInteger(
+      value.retiredCount,
+      `${field}.retiredCount`,
+      0,
+      Number.MAX_SAFE_INTEGER
+    ),
+    fileId: requireString(value.fileId, `${field}.fileId`, { maxBytes: 64 })
+  };
+}
+function parseHostedFileIngestJobView(input) {
+  const value = requireObject(input, "job");
+  requireExactKeys(
+    value,
+    [
+      "jobId",
+      "state",
+      "filename",
+      "byteLength",
+      "sha256",
+      "expiresAt",
+      "upload",
+      "manifest",
+      "committedPages",
+      "publication",
+      "error"
+    ],
+    "job"
+  );
+  const view = {
+    jobId: requireHostedFileIngestJobId(value.jobId, "job.jobId"),
+    state: requireEnum(value.state, HOSTED_FILE_INGEST_JOB_STATES, "job.state"),
+    filename: requireHostedFileIngestFilename(value.filename, "job.filename"),
+    byteLength: requireInteger(
+      value.byteLength,
+      "job.byteLength",
+      1,
+      HOSTED_FILE_INGEST_LIMITS.maxFileBytes
+    ),
+    sha256: requireSha256Hex(value.sha256, "job.sha256"),
+    expiresAt: requireIsoField(value.expiresAt, "job.expiresAt")
+  };
+  if (value.upload !== void 0) {
+    const upload = requireObject(value.upload, "job.upload");
+    requireExactKeys(upload, ["token", "expiresAt"], "job.upload");
+    view.upload = {
+      token: requireString(upload.token, "job.upload.token", { maxBytes: 128 }),
+      expiresAt: requireIsoField(upload.expiresAt, "job.upload.expiresAt")
+    };
+  }
+  if (value.manifest !== void 0) {
+    view.manifest = normalizeHostedFileIngestManifest(value.manifest, "job.manifest");
+  }
+  if (value.committedPages !== void 0) {
+    if (!Array.isArray(value.committedPages)) {
+      throw new Error("job.committedPages must be an array");
+    }
+    view.committedPages = value.committedPages.map(
+      (page, index) => requireInteger(page, `job.committedPages[${index}]`, 0, HOSTED_FILE_INGEST_LIMITS.maxChunks)
+    );
+  }
+  if (value.publication !== void 0) {
+    view.publication = normalizeHostedFileIngestPublication(value.publication, "job.publication");
+  }
+  if (value.error !== void 0) {
+    const error = requireObject(value.error, "job.error");
+    requireExactKeys(error, ["code", "message"], "job.error");
+    view.error = {
+      code: requireString(error.code, "job.error.code", { maxBytes: 64 }),
+      message: requireString(error.message, "job.error.message", { maxBytes: 4096 })
+    };
+  }
+  return view;
+}
+function parseHostedFileIngestCommitResult(input) {
+  const value = requireObject(input, "commit");
+  requireExactKeys(value, ["jobId", "pageIndex", "state", "alreadyCommitted"], "commit");
+  return {
+    jobId: requireHostedFileIngestJobId(value.jobId, "commit.jobId"),
+    pageIndex: requireInteger(
+      value.pageIndex,
+      "commit.pageIndex",
+      0,
+      HOSTED_FILE_INGEST_LIMITS.maxChunks - 1
+    ),
+    state: requireEnum(value.state, ["committed"], "commit.state"),
+    alreadyCommitted: requireBoolean(value.alreadyCommitted, "commit.alreadyCommitted")
+  };
+}
+function parseHostedFileIngestPublishResult(input) {
+  const value = requireObject(input, "publish");
+  requireExactKeys(value, ["jobId", "state", "entryCount", "retiredCount", "fileId"], "publish");
+  return {
+    jobId: requireHostedFileIngestJobId(value.jobId, "publish.jobId"),
+    state: requireEnum(value.state, ["published"], "publish.state"),
+    ...normalizeHostedFileIngestPublication(
+      { entryCount: value.entryCount, retiredCount: value.retiredCount, fileId: value.fileId },
+      "publish"
+    )
+  };
+}
+var HOSTED_FILE_INGEST_GATEWAY_STATES = [
+  "active",
+  "limit_exceeded",
+  "quota_paused",
+  "published",
+  "failed",
+  "cancel_requested",
+  "cancelled",
+  "expired"
+];
+var HOSTED_FILE_INGEST_RETRYABLE_CODES = [
+  "prepare_in_progress",
+  "page_commit_in_progress",
+  "publish_in_progress"
+];
+function requireMicrocents(value, field) {
+  const text = requireString(value, field, { maxBytes: 20 });
+  if (!/^(0|[1-9][0-9]*)$/.test(text) || BigInt(text) > 9223372036854775807n) {
+    throw new Error(`${field} must be a non-negative BIGINT decimal string`);
+  }
+  return text;
+}
+function parseHostedFileIngestAuthorization(input) {
+  const value = requireObject(input, "authorization");
+  requireExactKeys(
+    value,
+    [
+      "jobId",
+      "state",
+      "allocated",
+      "revision",
+      "ceilingMicrocents",
+      "estimateMicrocents",
+      "settledMicrocents",
+      "outstandingMicrocents",
+      "authorized"
+    ],
+    "authorization"
+  );
+  const nullableMicrocents = (field) => value[field] === null ? null : requireMicrocents(value[field], `authorization.${field}`);
+  return {
+    jobId: requireHostedFileIngestJobId(value.jobId, "authorization.jobId"),
+    state: requireEnum(value.state, HOSTED_FILE_INGEST_GATEWAY_STATES, "authorization.state"),
+    allocated: requireBoolean(value.allocated, "authorization.allocated"),
+    revision: requireInteger(value.revision, "authorization.revision", 0, Number.MAX_SAFE_INTEGER),
+    ceilingMicrocents: nullableMicrocents("ceilingMicrocents"),
+    estimateMicrocents: nullableMicrocents("estimateMicrocents"),
+    settledMicrocents: requireMicrocents(
+      value.settledMicrocents,
+      "authorization.settledMicrocents"
+    ),
+    outstandingMicrocents: requireMicrocents(
+      value.outstandingMicrocents,
+      "authorization.outstandingMicrocents"
+    ),
+    authorized: requireBoolean(value.authorized, "authorization.authorized")
+  };
+}
 
 export {
   normalizeGraphLabel,
@@ -1516,12 +1918,23 @@ export {
   DATA_PLANE_MANIFEST_FRAME,
   DATA_PLANE_HTTP_RESPONSE_FRAME,
   DATA_PLANE_COMPILER_LIMITS,
+  HOSTED_FILE_INGEST_PROTOCOL,
+  HOSTED_FILE_INGEST_LIMITS,
+  HOSTED_FILE_INGEST_JOB_STATES,
   DATA_PLANE_OPERATION_COVERAGE,
   encodeListCursorToken,
   parseListCursorToken,
+  requireHostedFileIngestFilename,
+  normalizeHostedFileIngestPageDescriptor,
   canonicalDataPlaneJson,
   hashDataPlaneStepInputV1,
   hashDataPlaneManifestV1,
   hashDataPlaneHttpResponseV1,
-  compileDataPlaneRequest
+  compileDataPlaneRequest,
+  parseHostedFileIngestJobView,
+  parseHostedFileIngestCommitResult,
+  parseHostedFileIngestPublishResult,
+  HOSTED_FILE_INGEST_GATEWAY_STATES,
+  HOSTED_FILE_INGEST_RETRYABLE_CODES,
+  parseHostedFileIngestAuthorization
 };