@pyxmate/memory 1.17.16 → 1.17.17

package/dist/chunk-3OLH3HYR.mjs

@@ -0,0 +1,1404 @@
+// ../shared/src/graph/extraction.ts
+function normalizeGraphLabel(value, fallback) {
+  const normalized = value.trim().toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized.length > 0 ? normalized : fallback;
+}
+function normalizeNameKey(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function requireGraphRecord(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${field} must be an object`);
+  }
+  return value;
+}
+function requireNonemptyGraphString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+function assertGraphExtractionPayload(value, field = "graph extraction payload") {
+  const record = requireGraphRecord(value, field);
+  if (!Array.isArray(record.entities)) throw new Error(`${field}.entities must be an array`);
+  if (!Array.isArray(record.relationships)) {
+    throw new Error(`${field}.relationships must be an array`);
+  }
+  const entities = record.entities.map((item, index) => {
+    const entity = requireGraphRecord(item, `${field}.entities[${index}]`);
+    requireNonemptyGraphString(entity.name, `${field}.entities[${index}].name`);
+    requireNonemptyGraphString(entity.type, `${field}.entities[${index}].type`);
+    if (entity.properties !== void 0 && (!entity.properties || typeof entity.properties !== "object" || Array.isArray(entity.properties))) {
+      throw new Error(`${field}.entities[${index}].properties must be an object`);
+    }
+    return item;
+  });
+  const entityNames = new Set(entities.map((entity) => normalizeNameKey(entity.name)));
+  const relationships = record.relationships.map((item, index) => {
+    const relationship = requireGraphRecord(item, `${field}.relationships[${index}]`);
+    const source = requireNonemptyGraphString(
+      relationship.source,
+      `${field}.relationships[${index}].source`
+    );
+    const target = requireNonemptyGraphString(
+      relationship.target,
+      `${field}.relationships[${index}].target`
+    );
+    requireNonemptyGraphString(relationship.type, `${field}.relationships[${index}].type`);
+    if (!entityNames.has(normalizeNameKey(source)) || !entityNames.has(normalizeNameKey(target))) {
+      throw new Error(
+        `${field}.relationships[${index}] endpoints must reference declared entity names`
+      );
+    }
+    if (relationship.properties !== void 0 && (!relationship.properties || typeof relationship.properties !== "object" || Array.isArray(relationship.properties))) {
+      throw new Error(`${field}.relationships[${index}].properties must be an object`);
+    }
+    return item;
+  });
+  return { entities, relationships };
+}
+function relationshipKey(relationship) {
+  return [
+    relationship.source.trim().toLowerCase(),
+    relationship.target.trim().toLowerCase(),
+    normalizeGraphLabel(relationship.type, "RELATED_TO")
+  ].join("\0");
+}
+function mergeExtractedEntities(callerEntities, callerRelationships, extracted) {
+  const entities = [...callerEntities ?? []];
+  const relationships = [...callerRelationships ?? []];
+  const nameByLowercase = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    const key = entity.name.toLowerCase();
+    if (!nameByLowercase.has(key)) nameByLowercase.set(key, entity.name);
+  }
+  for (const entity of extracted.entities) {
+    const key = entity.name.toLowerCase();
+    if (nameByLowercase.has(key)) continue;
+    entities.push({ ...entity, type: normalizeGraphLabel(entity.type, "CONCEPT") });
+    nameByLowercase.set(key, entity.name);
+  }
+  for (const relationship of extracted.relations) {
+    const source = nameByLowercase.get(relationship.source.toLowerCase());
+    const target = nameByLowercase.get(relationship.target.toLowerCase());
+    if (source && target) {
+      relationships.push({
+        ...relationship,
+        source,
+        target,
+        type: normalizeGraphLabel(relationship.type, "RELATED_TO")
+      });
+    }
+  }
+  const seenRelationships = /* @__PURE__ */ new Set();
+  const dedupedRelationships = [];
+  for (const relationship of relationships) {
+    const key = relationshipKey(relationship);
+    if (seenRelationships.has(key)) continue;
+    seenRelationships.add(key);
+    dedupedRelationships.push(relationship);
+  }
+  return { entities, relationships: dedupedRelationships };
+}
+
+// ../shared/src/data-plane-contract.ts
+import { createHash } from "crypto";
+var DATA_PLANE_CONTRACT_VERSION = "pyx-data-plane-contract-v1";
+var DATA_PLANE_CATALOG_VERSION = "maas-request-v1";
+var DATA_PLANE_MANIFEST_VERSION = "pyx-data-plane-manifest-v1";
+var DATA_PLANE_SEARCH_EMBEDDING_CONTRACT = "single_precomputed_query_v1";
+var DATA_PLANE_STEP_INPUT_FRAME = "pyx-data-plane-step-input-v1\0";
+var DATA_PLANE_MANIFEST_FRAME = "pyx-data-plane-manifest-v1\0";
+var DATA_PLANE_HTTP_RESPONSE_FRAME = "pyx-data-plane-http-response-v1\0";
+var DATA_PLANE_COMPILER_LIMITS = {
+  operationIdBytes: 64,
+  identityBytes: 256,
+  semanticTextBytes: 128e3,
+  canonicalInputBytes: 1048576,
+  profileContentBytes: 8192,
+  graphEntities: 1e3,
+  graphRelationships: 2e3
+};
+var MEMORY_TYPES = ["short-term", "long-term", "working", "episodic", "summary"];
+var ENTRY_STATUSES = ["active", "superseded", "archived"];
+var SENSITIVITY_LEVELS = ["public", "internal", "secret"];
+var PRINCIPAL_KINDS = ["api_key", "user"];
+var TENANT_MODES = ["single", "multi"];
+var ENTITY_TYPES = ["PERSON", "ORGANIZATION", "CONCEPT", "TOOL", "LOCATION", "EVENT"];
+var DATA_PLANE_OPERATION_COVERAGE = {
+  "rest:store": {
+    support: "journal_multi_step"
+  },
+  "rest:search": {
+    support: "journal_multi_step"
+  },
+  "rest:query_as_of": { support: "sqlite_atomic_one_step" },
+  "rest:query_by_event_time": { support: "sqlite_atomic_one_step" },
+  "rest:log": { support: "sqlite_atomic_one_step" },
+  "rest:lineage": {
+    support: "journal_multi_step"
+  },
+  "rest:reinforce": {
+    support: "journal_multi_step"
+  },
+  "rest:record_correction": { support: "sqlite_atomic_one_step" },
+  "rest:fetch_corrections": { support: "sqlite_atomic_one_step" },
+  "rest:synthesis_entity_refresh": {
+    support: "not_execution_ready",
+    reasonCode: "external_io_execution_not_ready",
+    reason: "entity synthesis refresh invokes an external LLM with data-dependent output and is not execution-ready in data-plane contract v1"
+  },
+  "rest:get_synthesis_entity": { support: "sqlite_atomic_one_step" },
+  "rest:list": { support: "sqlite_atomic_one_step" },
+  "rest:batch_store": {
+    support: "journal_multi_step"
+  },
+  "rest:get": { support: "sqlite_atomic_one_step" },
+  "rest:delete": {
+    support: "journal_multi_step"
+  },
+  "rest:graph_nodes": {
+    support: "journal_multi_step"
+  },
+  "rest:graph_relationships": {
+    support: "journal_multi_step"
+  },
+  "rest:graph_subgraph": {
+    support: "journal_multi_step"
+  },
+  "rest:embedding_map": {
+    support: "not_execution_ready",
+    reasonCode: "corpus_dependent_execution_not_ready",
+    reason: "embedding map reads cache state and may compute PCA over a data-dependent corpus, so it is not execution-ready in data-plane contract v1"
+  },
+  "mcp:search_memories": {
+    support: "journal_multi_step"
+  },
+  "mcp:store_memory": {
+    support: "journal_multi_step"
+  },
+  "mcp:get_memory": { support: "sqlite_atomic_one_step" },
+  "mcp:lineage": {
+    support: "journal_multi_step"
+  },
+  "mcp:reinforce": {
+    support: "journal_multi_step"
+  },
+  "mcp:list_memories": { support: "sqlite_atomic_one_step" },
+  "mcp:delete_memory": {
+    support: "journal_multi_step"
+  },
+  "mcp:ingest_memory_file": {
+    support: "not_execution_ready",
+    reasonCode: "external_io_execution_not_ready",
+    reason: "ingest_memory_file reads caller-local files and is not execution-ready in data-plane contract v1"
+  },
+  "mcp:summarize_memory_entity": { support: "sqlite_atomic_one_step" },
+  "mcp:get_taxonomy_state": {
+    support: "journal_multi_step"
+  },
+  "mcp:name_cluster": {
+    support: "journal_multi_step"
+  },
+  "mcp:status": {
+    support: "not_execution_ready",
+    reasonCode: "nonchargeable_operation",
+    reason: "status is nonchargeable and must bypass data-plane reservation"
+  },
+  "mcp:get_user_profile": { support: "sqlite_atomic_one_step" },
+  "mcp:upsert_user_profile": { support: "sqlite_atomic_one_step" },
+  "mcp:record_correction": { support: "sqlite_atomic_one_step" },
+  "mcp:fetch_applicable_corrections": { support: "sqlite_atomic_one_step" },
+  "mcp:fetch_due_facts": { support: "sqlite_atomic_one_step" }
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function requireObject(value, field) {
+  if (!isPlainObject(value)) throw new Error(`${field} must be a plain object`);
+  return value;
+}
+function requireExactKeys(value, allowed, field) {
+  const allowedKeys = new Set(allowed);
+  for (const key of Object.keys(value)) {
+    requireWellFormedUnicode(key, `${field} key`);
+    if (!allowedKeys.has(key)) throw new Error(`${field} contains unknown field: ${key}`);
+  }
+}
+function requireWellFormedUnicode(value, field) {
+  if (!value.isWellFormed()) throw new Error(`${field} contains an unpaired UTF-16 surrogate`);
+}
+function requireString(value, field, options = {}) {
+  if (typeof value !== "string") throw new Error(`${field} must be a string`);
+  requireWellFormedUnicode(value, field);
+  if (options.nonempty !== false && value.length === 0)
+    throw new Error(`${field} must not be empty`);
+  const maxBytes = options.maxBytes ?? DATA_PLANE_COMPILER_LIMITS.semanticTextBytes;
+  if (Buffer.byteLength(value, "utf8") > maxBytes)
+    throw new Error(`${field} exceeds ${maxBytes} UTF-8 bytes`);
+  return value;
+}
+function optionalString(value, field) {
+  return value === void 0 ? void 0 : requireString(value, field);
+}
+function optionalNonemptyString(value, field) {
+  if (value === void 0) return void 0;
+  const text = requireString(value, field, { nonempty: false });
+  return text.length === 0 ? void 0 : text;
+}
+function requireEnum(value, values, field) {
+  if (typeof value !== "string" || !values.includes(value)) throw new Error(`${field} is invalid`);
+  return value;
+}
+function optionalEnum(value, values, field) {
+  return value === void 0 ? void 0 : requireEnum(value, values, field);
+}
+function optionalEnumOrEmpty(value, values, field) {
+  return value === "" ? void 0 : optionalEnum(value, values, field);
+}
+function normalizeAgentId(value, field, defaultAgentId, emptyMeansNoFilter) {
+  if (value === void 0) return defaultAgentId ?? void 0;
+  const agentId = requireString(value, field, { nonempty: false });
+  if (agentId.length > 0) return agentId;
+  return emptyMeansNoFilter ? null : defaultAgentId ?? void 0;
+}
+function requireInteger(value, field, minimum, maximum) {
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new Error(`${field} must be a safe integer between ${minimum} and ${maximum}`);
+  }
+  return Object.is(value, -0) ? 0 : value;
+}
+function optionalInteger(value, field, minimum, maximum) {
+  return value === void 0 ? void 0 : requireInteger(value, field, minimum, maximum);
+}
+function optionalClampedPositiveInteger(value, field, maximum) {
+  if (value === void 0) return void 0;
+  return Math.min(requireInteger(value, field, 1, Number.MAX_SAFE_INTEGER), maximum);
+}
+function requireFiniteNumber(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${field} must be a finite number`);
+  }
+  return Object.is(value, -0) ? 0 : value;
+}
+function normalizeRestLimit(value, field, originMaximum) {
+  const requested = value === void 0 ? 50 : requireFiniteNumber(value, field);
+  const gatewayLimit = Math.min(Math.max(requested || 50, 1), 200);
+  const originLimit = Number.parseInt(String(gatewayLimit), 10);
+  return Math.min(originMaximum, Math.max(1, originLimit));
+}
+function normalizeRestPagination(limitValue, offsetValue) {
+  const requestedLimit = limitValue === void 0 ? 50 : requireFiniteNumber(limitValue, "input.limit");
+  const requestedOffset = offsetValue === void 0 ? 0 : requireFiniteNumber(offsetValue, "input.offset");
+  const gatewayLimit = Math.min(requestedLimit || 50, 200);
+  const gatewayOffset = Math.max(requestedOffset || 0, 0);
+  const mappedPage = Math.floor(gatewayOffset / gatewayLimit) + 1;
+  const originPage = Number.parseInt(String(mappedPage), 10);
+  const originLimit = Number.parseInt(String(gatewayLimit), 10);
+  if (!Number.isSafeInteger(originPage) || !Number.isSafeInteger(originLimit)) {
+    throw new Error("REST pagination cannot be represented as safe origin integers");
+  }
+  return {
+    page: Math.max(1, originPage),
+    limit: Math.min(100, Math.max(1, originLimit))
+  };
+}
+function requireBoolean(value, field) {
+  if (typeof value !== "boolean") throw new Error(`${field} must be a boolean`);
+  return value;
+}
+function requireCanonicalIso(value, field) {
+  const text = requireString(value, field, { maxBytes: 32 });
+  const parsed = Date.parse(text);
+  if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== text) {
+    throw new Error(`${field} must be a canonical absolute ISO-8601 timestamp`);
+  }
+  return text;
+}
+function normalizeIso(value, field) {
+  const text = requireString(value, field, { maxBytes: 64 });
+  const parsed = Date.parse(text);
+  if (!Number.isFinite(parsed)) throw new Error(`${field} must be a valid ISO-8601 timestamp`);
+  return new Date(parsed).toISOString();
+}
+function withOptional(target, key, value) {
+  if (value !== void 0) target[key] = value;
+}
+function normalizeTemporalFilters(value, prefix, defaultAgentId) {
+  const normalized = {
+    limit: normalizeRestLimit(value.limit, `${prefix}.limit`, 100)
+  };
+  withOptional(
+    normalized,
+    "agentId",
+    normalizeAgentId(value.agentId, `${prefix}.agentId`, defaultAgentId, false)
+  );
+  withOptional(normalized, "type", optionalEnumOrEmpty(value.type, MEMORY_TYPES, `${prefix}.type`));
+  return normalized;
+}
+function normalizeQueryAsOf(input, defaultAgentId) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["asOf", "limit", "type", "agentId"], "input");
+  return {
+    asOf: normalizeIso(value.asOf, "input.asOf"),
+    ...normalizeTemporalFilters(value, "input", defaultAgentId)
+  };
+}
+function normalizeQueryByEventTime(input, defaultAgentId) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["startTime", "endTime", "limit", "type", "agentId"], "input");
+  const startTime = normalizeIso(value.startTime, "input.startTime");
+  const endTime = normalizeIso(value.endTime, "input.endTime");
+  if (endTime < startTime) throw new Error("input.endTime must not be before input.startTime");
+  return { startTime, endTime, ...normalizeTemporalFilters(value, "input", defaultAgentId) };
+}
+function normalizeLog(input, defaultAgentId) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["since", "limit", "type", "agentId"], "input");
+  const normalized = {
+    ...normalizeTemporalFilters(value, "input", defaultAgentId)
+  };
+  withOptional(
+    normalized,
+    "since",
+    value.since === void 0 ? void 0 : normalizeIso(value.since, "input.since")
+  );
+  return normalized;
+}
+function normalizeCorrectionRecord(input, defaultAgentId) {
+  const value = requireObject(input, "input");
+  const keys = ["whatWasWrong", "whatToDoInstead", "appliesWhen", "project", "taskShape"];
+  requireExactKeys(value, keys, "input");
+  const normalized = {
+    whatWasWrong: requireString(value.whatWasWrong, "input.whatWasWrong"),
+    whatToDoInstead: requireString(value.whatToDoInstead, "input.whatToDoInstead"),
+    appliesWhen: requireString(value.appliesWhen, "input.appliesWhen")
+  };
+  withOptional(normalized, "agentId", defaultAgentId ?? void 0);
+  withOptional(normalized, "project", optionalNonemptyString(value.project, "input.project"));
+  withOptional(normalized, "taskShape", optionalNonemptyString(value.taskShape, "input.taskShape"));
+  return normalized;
+}
+function normalizeCorrectionFetch(input, rest) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["taskShape", "project", "limit"], "input");
+  const normalized = {
+    taskShape: requireString(value.taskShape, "input.taskShape"),
+    limit: rest ? normalizeRestLimit(value.limit, "input.limit", 5) : optionalClampedPositiveInteger(value.limit, "input.limit", 5) ?? 5
+  };
+  withOptional(normalized, "project", optionalNonemptyString(value.project, "input.project"));
+  return normalized;
+}
+function normalizeEntitySynthesisGet(input, mcp) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, mcp ? ["entityName", "entityType", "refresh"] : ["name"], "input");
+  const nameField = mcp ? "input.entityName" : "input.name";
+  const name = requireString(mcp ? value.entityName : value.name, nameField).trim().toLowerCase();
+  if (name.length === 0) throw new Error(`${nameField} must not be blank`);
+  if (!mcp) return { name };
+  const refresh = value.refresh === void 0 ? false : requireBoolean(value.refresh, "input.refresh");
+  if (refresh) throw new Error("mcp:summarize_memory_entity refresh=true is not execution-ready");
+  if (value.entityType !== void 0)
+    requireEnum(value.entityType, ENTITY_TYPES, "input.entityType");
+  return { name };
+}
+var LIST_CURSOR_MAX_TOKEN_CHARS = 4096;
+var BASE64URL_TOKEN_RE = /^[A-Za-z0-9_-]+$/;
+var ISO_DATE_TIME_PREFIX_RE = /^\d{4}-\d{2}-\d{2}T/;
+function encodeListCursorToken(entry) {
+  const token = Buffer.from(JSON.stringify({ c: entry.createdAt, i: entry.id }), "utf8").toString(
+    "base64url"
+  );
+  if (token.length > LIST_CURSOR_MAX_TOKEN_CHARS) {
+    throw new Error("entry key is too large to encode as a cursor");
+  }
+  parseListCursorToken(token);
+  return token;
+}
+function parseListCursorToken(token) {
+  if (token.length === 0 || token.length > LIST_CURSOR_MAX_TOKEN_CHARS) {
+    throw new Error("cursor token is empty or exceeds the size bound");
+  }
+  if (!BASE64URL_TOKEN_RE.test(token)) {
+    throw new Error("cursor token contains non-base64url characters");
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+  } catch {
+    throw new Error("cursor token is not base64url-encoded JSON");
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) {
+    throw new Error("cursor token payload must be an object");
+  }
+  const { c, i } = decoded;
+  if (typeof c !== "string" || !ISO_DATE_TIME_PREFIX_RE.test(c) || Number.isNaN(Date.parse(c))) {
+    throw new Error("cursor token field `c` must be an ISO-8601 timestamp");
+  }
+  if (typeof i !== "string" || i.length === 0) {
+    throw new Error("cursor token field `i` must be a non-empty entry id");
+  }
+  return { createdAt: c, id: i };
+}
+function normalizeRestList(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["limit", "offset", "type"], "input");
+  const normalized = normalizeRestPagination(
+    value.limit,
+    value.offset
+  );
+  withOptional(normalized, "type", optionalEnumOrEmpty(value.type, MEMORY_TYPES, "input.type"));
+  return normalized;
+}
+function normalizeGet(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["id"], "input");
+  return {
+    id: requireString(value.id, "input.id", { maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes })
+  };
+}
+var CALLER_ENTRY_ID_RESERVED_PREFIXES = ["synthesis:", "user-profile:", "correction:"];
+function optionalCallerEntryId(value, field) {
+  if (value === void 0) return void 0;
+  const id = requireString(value, field, { maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes });
+  if (/\p{Cc}/u.test(id)) throw new Error(`${field} must not contain control characters`);
+  for (const prefix of CALLER_ENTRY_ID_RESERVED_PREFIXES) {
+    if (id.startsWith(prefix)) {
+      throw new Error(`${field} must not use the platform-reserved '${prefix}' id prefix`);
+    }
+  }
+  return id;
+}
+function normalizeMcpDelete(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["id", "reason"], "input");
+  return {
+    id: requireString(value.id, "input.id", {
+      maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes
+    }),
+    reason: requireString(value.reason, "input.reason")
+  };
+}
+function normalizeMcpListEntries(value, normalized) {
+  if (value.since !== void 0) requireString(value.since, "input.since", { nonempty: false });
+  withOptional(normalized, "status", optionalEnum(value.status, ENTRY_STATUSES, "input.status"));
+  if (value.cursor !== void 0) {
+    if (value.page !== void 0) {
+      throw new Error("input.cursor and input.page are mutually exclusive");
+    }
+    if (typeof value.cursor !== "string") throw new Error("input.cursor must be a string");
+    parseListCursorToken(value.cursor);
+    normalized.cursor = value.cursor;
+  } else {
+    normalized.page = optionalInteger(value.page, "input.page", 1, Number.MAX_SAFE_INTEGER) ?? 1;
+  }
+  normalized.limit = optionalClampedPositiveInteger(value.limit, "input.limit", 100) ?? 20;
+  withOptional(
+    normalized,
+    "agentId",
+    normalizeAgentId(value.agentId, "input.agentId", null, false)
+  );
+}
+function normalizeMcpList(input, defaultAgentId) {
+  const value = requireObject(input, "input");
+  requireExactKeys(
+    value,
+    ["mode", "page", "limit", "cursor", "status", "type", "agentId", "since"],
+    "input"
+  );
+  const mode = value.mode === void 0 ? "entries" : requireEnum(value.mode, ["entries", "log"], "input.mode");
+  if (mode === "log") {
+    if (value.cursor !== void 0) throw new Error("input.cursor is only valid in entries mode");
+    if (value.status !== void 0) throw new Error("input.status is only valid in entries mode");
+  }
+  const normalized = { mode };
+  withOptional(normalized, "type", optionalEnum(value.type, MEMORY_TYPES, "input.type"));
+  if (mode === "entries") {
+    normalizeMcpListEntries(value, normalized);
+  } else {
+    if (value.page !== void 0)
+      requireInteger(value.page, "input.page", 1, Number.MAX_SAFE_INTEGER);
+    withOptional(
+      normalized,
+      "agentId",
+      normalizeAgentId(value.agentId, "input.agentId", defaultAgentId, true)
+    );
+    withOptional(
+      normalized,
+      "limit",
+      optionalClampedPositiveInteger(value.limit, "input.limit", 100)
+    );
+    withOptional(
+      normalized,
+      "since",
+      value.since === void 0 ? void 0 : normalizeIso(value.since, "input.since")
+    );
+  }
+  return normalized;
+}
+function normalizeProfile(input, write, defaultAgentId) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, write ? ["content"] : [], "input");
+  const normalized = {};
+  if (write) {
+    normalized.content = requireString(value.content, "input.content", {
+      maxBytes: DATA_PLANE_COMPILER_LIMITS.profileContentBytes
+    });
+    withOptional(normalized, "agentId", defaultAgentId ?? void 0);
+  }
+  return normalized;
+}
+function normalizeDue(input, context) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["windowDays", "from", "limit"], "input");
+  const windowDays = requireInteger(value.windowDays, "input.windowDays", 1, 370);
+  const from = value.from === void 0 ? context.resolvedAt : normalizeIso(value.from, "input.from");
+  const to = new Date(Date.parse(from) + windowDays * 864e5).toISOString();
+  const normalized = {
+    from,
+    to,
+    limit: optionalClampedPositiveInteger(value.limit, "input.limit", 100) ?? 20
+  };
+  return normalized;
+}
+function canonicalValue(value, field) {
+  try {
+    return JSON.parse(canonicalDataPlaneJson(value));
+  } catch (error) {
+    throw new Error(`${field} is not canonical JSON data`, { cause: error });
+  }
+}
+function normalizeStoreTargets(value) {
+  const order = ["sqlite", "vector", "graph"];
+  if (value === void 0) return [...order];
+  if (!Array.isArray(value) || value.length < 1 || value.length > 3) {
+    throw new Error("input.targets must contain 1-3 storage targets");
+  }
+  const targets = value.map((target) => requireEnum(target, order, "input.targets item"));
+  if (new Set(targets).size !== targets.length) throw new Error("input.targets must be unique");
+  return order.filter((target) => targets.includes(target));
+}
+function normalizeGraphEntities(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length > DATA_PLANE_COMPILER_LIMITS.graphEntities) {
+    throw new Error(
+      `input.entities must be an array of at most ${DATA_PLANE_COMPILER_LIMITS.graphEntities} items`
+    );
+  }
+  return value.map((item, index) => {
+    const entity = requireObject(item, `input.entities[${index}]`);
+    requireExactKeys(entity, ["name", "type", "properties"], `input.entities[${index}]`);
+    const normalized = {
+      name: requireString(entity.name, `input.entities[${index}].name`),
+      type: normalizeGraphLabel(
+        requireString(entity.type, `input.entities[${index}].type`, { maxBytes: 100 }),
+        "CONCEPT"
+      )
+    };
+    if (entity.properties !== void 0) {
+      normalized.properties = canonicalValue(
+        requireObject(entity.properties, `input.entities[${index}].properties`),
+        `input.entities[${index}].properties`
+      );
+    }
+    return normalized;
+  });
+}
+function normalizeGraphRelationships(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length > DATA_PLANE_COMPILER_LIMITS.graphRelationships) {
+    throw new Error(
+      `input.relationships must be an array of at most ${DATA_PLANE_COMPILER_LIMITS.graphRelationships} items`
+    );
+  }
+  return value.map((item, index) => {
+    const relationship = requireObject(item, `input.relationships[${index}]`);
+    requireExactKeys(
+      relationship,
+      ["source", "target", "type", "properties"],
+      `input.relationships[${index}]`
+    );
+    const normalized = {
+      source: requireString(relationship.source, `input.relationships[${index}].source`),
+      target: requireString(relationship.target, `input.relationships[${index}].target`),
+      type: requireString(relationship.type, `input.relationships[${index}].type`)
+    };
+    if (relationship.properties !== void 0) {
+      normalized.properties = canonicalValue(
+        requireObject(relationship.properties, `input.relationships[${index}].properties`),
+        `input.relationships[${index}].properties`
+      );
+    }
+    return normalized;
+  });
+}
+var MCP_SERVER_OWNED_METADATA_KEYS = ["source", "topic", "project", "_kind"];
+function normalizeMcpStoreMetadata(value) {
+  const serverOwned = {
+    source: "agent",
+    topic: requireString(value.topic, "input.topic"),
+    project: requireString(value.project, "input.project")
+  };
+  if (value.metadata === void 0) return serverOwned;
+  const caller = canonicalValue(
+    requireObject(value.metadata, "input.metadata"),
+    "input.metadata"
+  );
+  for (const key of MCP_SERVER_OWNED_METADATA_KEYS) {
+    if (key in caller) {
+      throw new Error(`input.metadata.${key} is server-owned and cannot be caller-supplied`);
+    }
+  }
+  return { ...caller, ...serverOwned };
+}
+function mergeCanonicalGraphInput(entities, relationships, triples) {
+  const uniqueEntities = /* @__PURE__ */ new Map();
+  const addEntity = (entity) => {
+    const key = `${normalizeNameKey(entity.name)}\0${normalizeGraphLabel(entity.type, "CONCEPT")}`;
+    if (!uniqueEntities.has(key)) uniqueEntities.set(key, entity);
+  };
+  const uniqueRelationships = /* @__PURE__ */ new Map();
+  const addRelationship = (relationship) => {
+    const key = [
+      normalizeNameKey(relationship.source),
+      normalizeNameKey(relationship.target),
+      normalizeGraphLabel(relationship.type, "RELATED_TO")
+    ].join("\0");
+    if (!uniqueRelationships.has(key)) uniqueRelationships.set(key, relationship);
+  };
+  for (const entity of entities) addEntity(entity);
+  for (const relationship of relationships) addRelationship(relationship);
+  for (const triple of triples) {
+    addEntity(triple.subject);
+    addEntity(triple.object);
+    addRelationship({
+      source: triple.subject.name,
+      target: triple.object.name,
+      type: normalizeGraphLabel(triple.relation, "RELATED_TO")
+    });
+  }
+  return {
+    entities: [...uniqueEntities.values()],
+    relationships: [...uniqueRelationships.values()]
+  };
+}
+function canonicalizeStorePayload(input, resolvedAt, mcp, compileAdmission) {
+  const value = requireObject(input, "input");
+  const common = [
+    "id",
+    "content",
+    "type",
+    "targets",
+    "source",
+    "importance",
+    "eventTime",
+    "agentId",
+    "namespaceId",
+    "sessionId",
+    "parentId",
+    "entities",
+    "relationships",
+    "extractEntities"
+  ];
+  requireExactKeys(
+    value,
+    mcp ? [...common, "topic", "project", "metadata", "triples", "entitiesOnly"] : [...common, "metadata"],
+    "input"
+  );
+  compileAdmission?.(value);
+  const normalized = {
+    content: requireString(value.content, "input.content"),
+    type: optionalEnum(value.type, MEMORY_TYPES, "input.type") ?? "long-term",
+    targets: normalizeStoreTargets(value.targets),
+    metadata: mcp ? normalizeMcpStoreMetadata(value) : canonicalValue(value.metadata ?? {}, "input.metadata"),
+    createdAt: resolvedAt,
+    ingestTime: resolvedAt,
+    extractEntities: false
+  };
+  withOptional(normalized, "id", optionalCallerEntryId(value.id, "input.id"));
+  withOptional(normalized, "source", optionalNonemptyString(value.source, "input.source"));
+  withOptional(normalized, "agentId", optionalNonemptyString(value.agentId, "input.agentId"));
+  withOptional(normalized, "sessionId", optionalNonemptyString(value.sessionId, "input.sessionId"));
+  withOptional(normalized, "parentId", optionalNonemptyString(value.parentId, "input.parentId"));
+  withOptional(
+    normalized,
+    "eventTime",
+    value.eventTime === void 0 ? void 0 : normalizeIso(value.eventTime, "input.eventTime")
+  );
+  if (value.importance !== void 0) {
+    const importance = requireFiniteNumber(value.importance, "input.importance");
+    if (importance < 0 || importance > 10) throw new Error("input.importance must be 0-10");
+    normalized.importance = importance;
+  }
+  const entities = normalizeGraphEntities(value.entities) ?? [];
+  const relationships = normalizeGraphRelationships(value.relationships) ?? [];
+  const triples = [];
+  if (mcp && value.triples !== void 0) {
+    if (!Array.isArray(value.triples) || value.triples.length > 256) {
+      throw new Error("input.triples must be an array of at most 256 items");
+    }
+    for (const [index, item] of value.triples.entries()) {
+      const triple = requireObject(item, `input.triples[${index}]`);
+      requireExactKeys(triple, ["subject", "relation", "object"], `input.triples[${index}]`);
+      const tripleEntities = normalizeGraphEntities([triple.subject, triple.object]);
+      const subject = tripleEntities?.[0];
+      const object = tripleEntities?.[1];
+      if (!subject || !object) throw new Error(`input.triples[${index}] has invalid endpoints`);
+      triples.push({
+        subject,
+        relation: requireString(triple.relation, `input.triples[${index}].relation`),
+        object
+      });
+    }
+  }
+  const merged = mergeCanonicalGraphInput(entities, relationships, triples);
+  const graphTargeted = normalized.targets.includes(
+    "graph"
+  );
+  const entityNames = new Set(merged.entities.map((entity) => normalizeNameKey(entity.name)));
+  const hasResolvableRelationship = merged.relationships.some((relationship) => {
+    const source = normalizeNameKey(relationship.source);
+    const target = normalizeNameKey(relationship.target);
+    return source !== target && entityNames.has(source) && entityNames.has(target);
+  });
+  const entitiesOnly = mcp && value.entitiesOnly !== void 0 ? requireBoolean(value.entitiesOnly, "input.entitiesOnly") : false;
+  if (mcp && graphTargeted && merged.entities.length >= 2 && !hasResolvableRelationship && !entitiesOnly) {
+    throw new Error(
+      "GRAPH_RELATIONSHIPS_REQUIRED: graph stores with two or more entities require a relationship that connects declared entity names, or entitiesOnly=true"
+    );
+  }
+  if (merged.entities.length > 0) normalized.entities = merged.entities;
+  if (merged.relationships.length > 0) normalized.relationships = merged.relationships;
+  return normalized;
+}
+function normalizeStore(input, context, mcp) {
+  return canonicalizeStorePayload(input, context.resolvedAt, mcp, (value) => {
+    if (value.namespaceId !== void 0 && value.namespaceId !== context.scope.namespaceId) {
+      throw new Error("input.namespaceId does not match trusted context.scope.namespaceId");
+    }
+    if (value.extractEntities === true) {
+      throw new Error(
+        "input.extractEntities=true requires external I/O and is not execution-ready"
+      );
+    }
+  });
+}
+function normalizeBatchStore(input, context) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["entries"], "input");
+  if (!Array.isArray(value.entries) || value.entries.length < 1 || value.entries.length > 100) {
+    throw new Error("input.entries must contain 1-100 entries");
+  }
+  const entries = value.entries.map((entry, batchIndex) => ({
+    ...normalizeStore(entry, context, false),
+    batchIndex
+  }));
+  const callerIds = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (typeof entry.id !== "string") continue;
+    if (callerIds.has(entry.id)) {
+      throw new Error(`input.entries contains duplicate entry id: ${entry.id}`);
+    }
+    callerIds.add(entry.id);
+  }
+  return { entries };
+}
+function normalizeSearch(input, mcp) {
+  const value = requireObject(input, "input");
+  const keys = [
+    "query",
+    "limit",
+    "strategy",
+    "effort",
+    "type",
+    "agentId",
+    "abstentionThreshold",
+    "eventTimeStart",
+    "eventTimeEnd",
+    "asOf",
+    "anchorTime",
+    "enumerationConcept",
+    "enableRerank"
+  ];
+  requireExactKeys(value, keys, "input");
+  if (value.enumerationConcept !== void 0) {
+    throw new Error(
+      "input.enumerationConcept requires additional embeddings and is not execution-ready"
+    );
+  }
+  const normalized = {
+    query: requireString(value.query, "input.query"),
+    limit: mcp ? optionalClampedPositiveInteger(value.limit, "input.limit", 100) ?? 10 : normalizeRestLimit(value.limit, "input.limit", 100),
+    strategy: optionalEnum(value.strategy, ["naive", "graph", "hybrid"], "input.strategy") ?? "hybrid"
+  };
+  withOptional(
+    normalized,
+    "effort",
+    optionalEnum(value.effort, ["quick", "medium", "deep"], "input.effort")
+  );
+  withOptional(normalized, "type", optionalEnum(value.type, MEMORY_TYPES, "input.type"));
+  withOptional(normalized, "agentId", optionalNonemptyString(value.agentId, "input.agentId"));
+  for (const field of ["asOf", "anchorTime"]) {
+    if (value[field] !== void 0)
+      normalized[field] = normalizeIso(value[field], `input.${field}`);
+  }
+  if (value.eventTimeStart === void 0 !== (value.eventTimeEnd === void 0)) {
+    throw new Error("input.eventTimeStart and input.eventTimeEnd must be paired");
+  }
+  if (value.eventTimeStart !== void 0 && value.eventTimeEnd !== void 0) {
+    normalized.eventTimeRange = [
+      normalizeIso(value.eventTimeStart, "input.eventTimeStart"),
+      normalizeIso(value.eventTimeEnd, "input.eventTimeEnd")
+    ];
+  }
+  if (value.abstentionThreshold !== void 0) {
+    const threshold = requireFiniteNumber(value.abstentionThreshold, "input.abstentionThreshold");
+    if (threshold < 0 || threshold > 1) throw new Error("input.abstentionThreshold must be 0-1");
+    normalized.abstentionThreshold = threshold;
+  }
+  if (value.enableRerank !== void 0) {
+    normalized.enableRerank = requireBoolean(value.enableRerank, "input.enableRerank");
+  }
+  return normalized;
+}
+function normalizeLineage(input, mcp) {
+  const value = requireObject(input, "input");
+  requireExactKeys(
+    value,
+    [
+      "subject",
+      "relation",
+      "entryId",
+      "asOf",
+      "beforeValue",
+      "eventTimeStart",
+      "eventTimeEnd",
+      "limit"
+    ],
+    "input"
+  );
+  if (value.subject === void 0 && value.entryId === void 0) {
+    throw new Error("input.subject or input.entryId is required");
+  }
+  const normalized = {};
+  for (const field of ["subject", "relation", "entryId", "beforeValue"]) {
+    withOptional(normalized, field, optionalNonemptyString(value[field], `input.${field}`));
+  }
+  if (value.asOf !== void 0) normalized.asOf = normalizeIso(value.asOf, "input.asOf");
+  if (value.eventTimeStart === void 0 !== (value.eventTimeEnd === void 0)) {
+    throw new Error("input.eventTimeStart and input.eventTimeEnd must be paired");
+  }
+  if (value.eventTimeStart !== void 0 && value.eventTimeEnd !== void 0) {
+    normalized.eventTimeRange = [
+      normalizeIso(value.eventTimeStart, "input.eventTimeStart"),
+      normalizeIso(value.eventTimeEnd, "input.eventTimeEnd")
+    ];
+  }
+  normalized.limit = mcp ? optionalInteger(value.limit, "input.limit", 1, 200) ?? 50 : normalizeRestLimit(value.limit, "input.limit", 200);
+  return normalized;
+}
+function normalizeReinforce(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["entryIds", "signal", "at"], "input");
+  if (!Array.isArray(value.entryIds) || value.entryIds.length < 1 || value.entryIds.length > 100) {
+    throw new Error("input.entryIds must contain 1-100 ids");
+  }
+  const normalized = {
+    entryIds: value.entryIds.map(
+      (id, index) => requireString(id, `input.entryIds[${index}]`, {
+        maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes
+      })
+    ),
+    signal: requireEnum(
+      value.signal,
+      ["context_included", "cited", "explicit_positive"],
+      "input.signal"
+    )
+  };
+  if (value.at !== void 0) {
+    normalized.at = typeof value.at === "number" ? requireInteger(value.at, "input.at", 0, Number.MAX_SAFE_INTEGER) : normalizeIso(value.at, "input.at");
+  }
+  return normalized;
+}
+function normalizeGraphRead(input, operation) {
+  const value = requireObject(input, "input");
+  if (operation === "rest:graph_nodes") {
+    requireExactKeys(value, ["name", "type", "limit"], "input");
+    const normalized = {
+      limit: optionalClampedPositiveInteger(value.limit, "input.limit", 1e3) ?? 100
+    };
+    withOptional(normalized, "name", optionalNonemptyString(value.name, "input.name"));
+    withOptional(normalized, "type", optionalNonemptyString(value.type, "input.type"));
+    return normalized;
+  }
+  const field = operation === "rest:graph_subgraph" ? "edges" : "limit";
+  requireExactKeys(
+    value,
+    operation === "rest:graph_subgraph" ? ["edges", "nodes"] : [field],
+    "input"
+  );
+  if (operation === "rest:graph_subgraph") {
+    const normalized = {
+      edges: optionalClampedPositiveInteger(value.edges, "input.edges", 1e4) ?? 2e3
+    };
+    withOptional(
+      normalized,
+      "nodes",
+      optionalClampedPositiveInteger(value.nodes, "input.nodes", 1e4)
+    );
+    return normalized;
+  }
+  return {
+    [field]: optionalClampedPositiveInteger(value[field], `input.${field}`, 1e3) ?? 200
+  };
+}
+function normalizeNameCluster(input) {
+  const value = requireObject(input, "input");
+  requireExactKeys(value, ["name", "memberNames", "previousName"], "input");
+  const name = requireString(value.name, "input.name").trim();
+  if (name.length < 1 || name.length > 40) {
+    throw new Error("input.name must contain 1-40 characters after trimming");
+  }
+  if (!Array.isArray(value.memberNames) || value.memberNames.length > 30) {
+    throw new Error("input.memberNames must be an array of at most 30 names");
+  }
+  const normalized = {
+    name,
+    memberNames: value.memberNames.map(
+      (memberName, index) => requireString(memberName, `input.memberNames[${index}]`)
+    )
+  };
+  withOptional(
+    normalized,
+    "previousName",
+    optionalString(value.previousName, "input.previousName")
+  );
+  return normalized;
+}
+function normalizeSupportedInput(operation, input, context) {
+  const defaultAgentId = context.runtimeAttestation.defaultAgentId;
+  switch (operation) {
+    case "rest:store":
+      return normalizeStore(input, context, false);
+    case "mcp:store_memory":
+      return normalizeStore(input, context, true);
+    case "rest:batch_store":
+      return normalizeBatchStore(input, context);
+    case "rest:search":
+      return normalizeSearch(input, false);
+    case "mcp:search_memories":
+      return normalizeSearch(input, true);
+    case "rest:lineage":
+      return normalizeLineage(input, false);
+    case "mcp:lineage":
+      return normalizeLineage(input, true);
+    case "rest:reinforce":
+    case "mcp:reinforce":
+      return normalizeReinforce(input);
+    case "rest:delete":
+      return normalizeGet(input);
+    case "mcp:delete_memory":
+      return normalizeMcpDelete(input);
+    case "rest:graph_nodes":
+    case "rest:graph_relationships":
+    case "rest:graph_subgraph":
+      return normalizeGraphRead(input, operation);
+    case "mcp:get_taxonomy_state": {
+      const value = requireObject(input, "input");
+      requireExactKeys(value, [], "input");
+      return {};
+    }
+    case "mcp:name_cluster":
+      return normalizeNameCluster(input);
+    case "rest:query_as_of":
+      return normalizeQueryAsOf(input, defaultAgentId);
+    case "rest:query_by_event_time":
+      return normalizeQueryByEventTime(input, defaultAgentId);
+    case "rest:log":
+      return normalizeLog(input, defaultAgentId);
+    case "rest:record_correction":
+      return normalizeCorrectionRecord(input, defaultAgentId);
+    case "rest:fetch_corrections":
+      return normalizeCorrectionFetch(input, true);
+    case "rest:get_synthesis_entity":
+      return normalizeEntitySynthesisGet(input, false);
+    case "rest:list":
+      return normalizeRestList(input);
+    case "rest:get":
+      return normalizeGet(input);
+    case "mcp:get_memory":
+      return normalizeGet(input);
+    case "mcp:list_memories":
+      return normalizeMcpList(input, defaultAgentId);
+    case "mcp:get_user_profile":
+      return normalizeProfile(input, false, defaultAgentId);
+    case "mcp:upsert_user_profile":
+      return normalizeProfile(input, true, defaultAgentId);
+    case "mcp:record_correction":
+      return normalizeCorrectionRecord(input, defaultAgentId);
+    case "mcp:fetch_applicable_corrections":
+      return normalizeCorrectionFetch(input, false);
+    case "mcp:fetch_due_facts":
+      return normalizeDue(input, context);
+    case "mcp:summarize_memory_entity":
+      return normalizeEntitySynthesisGet(input, true);
+  }
+}
+function requireExecutionScope(operation, context) {
+  const sharedFallbackSafe = /* @__PURE__ */ new Set([
+    "rest:query_as_of",
+    "rest:query_by_event_time",
+    "rest:log",
+    "rest:get"
+  ]);
+  if (context.runtimeAttestation.sharedFallback && !sharedFallbackSafe.has(operation)) {
+    throw new Error(`${operation} is not execution-ready on the shared fallback runtime`);
+  }
+  const namespaceRequiredInMulti = /* @__PURE__ */ new Set([
+    "rest:record_correction",
+    "rest:fetch_corrections",
+    "mcp:record_correction",
+    "mcp:fetch_applicable_corrections",
+    "mcp:fetch_due_facts"
+  ]);
+  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 === "mcp:get_user_profile" || operation === "mcp:upsert_user_profile") {
+    if (context.scope.namespaceId === void 0) {
+      throw new Error(`${operation} requires trusted context.scope.namespaceId`);
+    }
+    if (context.scope.userId === void 0) {
+      throw new Error(`${operation} requires trusted context.scope.userId`);
+    }
+  }
+}
+function stripAndVerifyRawScope(input, context) {
+  if (!isPlainObject(input)) return input;
+  const value = { ...input };
+  const bindings = {
+    tenantId: context.scope.tenantId,
+    namespaceId: context.scope.namespaceId,
+    userId: context.scope.userId,
+    teamId: context.scope.teamId,
+    callerAccessLevel: context.scope.callerAccessLevel
+  };
+  for (const [field, trusted] of Object.entries(bindings)) {
+    if (value[field] !== void 0 && value[field] !== trusted) {
+      throw new Error(`input.${field} does not match trusted context.scope.${field}`);
+    }
+    delete value[field];
+  }
+  return value;
+}
+function normalizeContext(input) {
+  const value = requireObject(input, "context");
+  requireExactKeys(
+    value,
+    [
+      "organizationId",
+      "projectId",
+      "instanceId",
+      "operationId",
+      "principal",
+      "scope",
+      "resolvedAt",
+      "runtimeAttestation"
+    ],
+    "context"
+  );
+  const principal = requireObject(value.principal, "context.principal");
+  requireExactKeys(principal, ["kind", "id"], "context.principal");
+  const scope = requireObject(value.scope, "context.scope");
+  requireExactKeys(
+    scope,
+    ["tenantId", "namespaceId", "userId", "teamId", "callerAccessLevel"],
+    "context.scope"
+  );
+  const runtime = requireObject(value.runtimeAttestation, "context.runtimeAttestation");
+  requireExactKeys(
+    runtime,
+    [
+      "contractVersion",
+      "tenantMode",
+      "defaultAgentId",
+      "effectiveSource",
+      "sharedFallback",
+      "sqliteAtomicOneStep"
+    ],
+    "context.runtimeAttestation"
+  );
+  if (runtime.contractVersion !== DATA_PLANE_CONTRACT_VERSION)
+    throw new Error("context.runtimeAttestation.contractVersion is invalid");
+  if (runtime.sqliteAtomicOneStep !== true)
+    throw new Error("context.runtimeAttestation.sqliteAtomicOneStep must be true");
+  const normalizedScope = {
+    tenantId: requireString(scope.tenantId, "context.scope.tenantId", {
+      maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes
+    })
+  };
+  const namespaceId = optionalString(scope.namespaceId, "context.scope.namespaceId");
+  const userId = optionalString(scope.userId, "context.scope.userId");
+  const teamId = optionalString(scope.teamId, "context.scope.teamId");
+  const callerAccessLevel = optionalEnum(
+    scope.callerAccessLevel,
+    SENSITIVITY_LEVELS,
+    "context.scope.callerAccessLevel"
+  );
+  if (namespaceId !== void 0) normalizedScope.namespaceId = namespaceId;
+  if (userId !== void 0) normalizedScope.userId = userId;
+  if (teamId !== void 0) normalizedScope.teamId = teamId;
+  if (callerAccessLevel !== void 0) normalizedScope.callerAccessLevel = callerAccessLevel;
+  const organizationId = requireString(value.organizationId, "context.organizationId", {
+    maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes
+  });
+  const projectId = requireString(value.projectId, "context.projectId", {
+    maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes
+  });
+  const effectiveSource = requireString(
+    runtime.effectiveSource,
+    "context.runtimeAttestation.effectiveSource"
+  );
+  if (effectiveSource !== `tenant:${organizationId}:${projectId}`) {
+    throw new Error(
+      "context.runtimeAttestation.effectiveSource must match the trusted organization/project source"
+    );
+  }
+  return {
+    organizationId,
+    projectId,
+    instanceId: requireString(value.instanceId, "context.instanceId", {
+      maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes
+    }),
+    operationId: requireString(value.operationId, "context.operationId", {
+      maxBytes: DATA_PLANE_COMPILER_LIMITS.operationIdBytes
+    }),
+    principal: {
+      kind: requireEnum(principal.kind, PRINCIPAL_KINDS, "context.principal.kind"),
+      id: requireString(principal.id, "context.principal.id", {
+        maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes
+      })
+    },
+    scope: normalizedScope,
+    resolvedAt: requireCanonicalIso(value.resolvedAt, "context.resolvedAt"),
+    runtimeAttestation: {
+      contractVersion: DATA_PLANE_CONTRACT_VERSION,
+      tenantMode: requireEnum(
+        runtime.tenantMode,
+        TENANT_MODES,
+        "context.runtimeAttestation.tenantMode"
+      ),
+      defaultAgentId: runtime.defaultAgentId === null ? null : requireString(runtime.defaultAgentId, "context.runtimeAttestation.defaultAgentId", {
+        maxBytes: DATA_PLANE_COMPILER_LIMITS.identityBytes
+      }),
+      effectiveSource,
+      sharedFallback: requireBoolean(
+        runtime.sharedFallback,
+        "context.runtimeAttestation.sharedFallback"
+      ),
+      sqliteAtomicOneStep: true
+    }
+  };
+}
+function normalizeCanonicalValue(value, path) {
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    requireWellFormedUnicode(value, path);
+    return value;
+  }
+  if (typeof value === "bigint") return value.toString(10);
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) throw new Error(`${path} must be a safe integer`);
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (Array.isArray(value)) {
+    return Array.from({ length: value.length }, (_, index) => {
+      if (!Object.hasOwn(value, index))
+        throw new Error(`${path}[${index}] must not be a sparse hole`);
+      return normalizeCanonicalValue(value[index], `${path}[${index}]`);
+    });
+  }
+  const record = requireObject(value, path);
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(record).sort()) {
+    requireWellFormedUnicode(key, `${path} key`);
+    if (record[key] === void 0) throw new Error(`${path}.${key} must not be undefined`);
+    normalized[key] = normalizeCanonicalValue(record[key], `${path}.${key}`);
+  }
+  return normalized;
+}
+function canonicalDataPlaneJson(value) {
+  return JSON.stringify(normalizeCanonicalValue(value, "$"));
+}
+function framedSha256(frame, canonicalJson, maxBytes) {
+  const payload = Buffer.from(canonicalJson, "utf8");
+  if (payload.byteLength > maxBytes)
+    throw new Error(`canonical payload exceeds ${maxBytes} UTF-8 bytes`);
+  if (payload.byteLength > 4294967295)
+    throw new Error("canonical payload exceeds U32 framing capacity");
+  const length = Buffer.allocUnsafe(4);
+  length.writeUInt32BE(payload.byteLength, 0);
+  return createHash("sha256").update(frame, "utf8").update(length).update(payload).digest("hex");
+}
+function hashDataPlaneStepInputV1(value) {
+  const canonicalJson = canonicalDataPlaneJson(value);
+  return {
+    canonicalJson,
+    sha256: framedSha256(
+      DATA_PLANE_STEP_INPUT_FRAME,
+      canonicalJson,
+      DATA_PLANE_COMPILER_LIMITS.canonicalInputBytes
+    )
+  };
+}
+function hashDataPlaneManifestV1(value) {
+  const canonicalJson = canonicalDataPlaneJson(value);
+  return { canonicalJson, sha256: framedSha256(DATA_PLANE_MANIFEST_FRAME, canonicalJson, 32768) };
+}
+function hashDataPlaneHttpResponseV1(statusCode, contentType, body) {
+  if (!Number.isSafeInteger(statusCode) || statusCode < 100 || statusCode > 599) {
+    throw new Error("statusCode must be an integer from 100 through 599");
+  }
+  if (typeof contentType !== "string" || contentType.length === 0 || Buffer.byteLength(contentType, "utf8") > 256 || !/^[\x20-\x7e]+$/.test(contentType) || /[\r\n]/.test(contentType)) {
+    throw new Error("contentType must be 1-256 visible ASCII bytes without CR or LF");
+  }
+  if (!(body instanceof Uint8Array)) throw new Error("body must be a Uint8Array");
+  const status = Buffer.from(String(statusCode), "ascii");
+  const contentTypeBytes = Buffer.from(contentType, "ascii");
+  const statusLength = Buffer.allocUnsafe(4);
+  statusLength.writeUInt32BE(status.byteLength);
+  const contentTypeLength = Buffer.allocUnsafe(4);
+  contentTypeLength.writeUInt32BE(contentTypeBytes.byteLength);
+  const bodyLength = Buffer.allocUnsafe(8);
+  bodyLength.writeBigUInt64BE(BigInt(body.byteLength));
+  return createHash("sha256").update(DATA_PLANE_HTTP_RESPONSE_FRAME, "utf8").update(statusLength).update(status).update(contentTypeLength).update(contentTypeBytes).update(bodyLength).update(body).digest("hex");
+}
+function compileDataPlaneRequest(request) {
+  const outer = requireObject(request, "request");
+  requireExactKeys(outer, ["catalogVersion", "operation", "context", "input"], "request");
+  if (outer.catalogVersion !== DATA_PLANE_CATALOG_VERSION)
+    throw new Error(`unknown data-plane catalog version: ${String(outer.catalogVersion)}`);
+  if (typeof outer.operation !== "string" || !Object.hasOwn(DATA_PLANE_OPERATION_COVERAGE, outer.operation)) {
+    throw new Error(`unknown data-plane catalog operation: ${String(outer.operation)}`);
+  }
+  const operation = outer.operation;
+  const entry = DATA_PLANE_OPERATION_COVERAGE[operation];
+  if (entry.support === "not_execution_ready") {
+    return {
+      kind: "unsupported",
+      catalogVersion: DATA_PLANE_CATALOG_VERSION,
+      operation,
+      reasonCode: entry.reasonCode,
+      reason: entry.reason
+    };
+  }
+  const supportedOperation = operation;
+  const context = normalizeContext(outer.context);
+  requireExecutionScope(supportedOperation, context);
+  const normalizedInput = normalizeSupportedInput(
+    supportedOperation,
+    stripAndVerifyRawScope(outer.input, context),
+    context
+  );
+  const stepInput = {
+    contractVersion: DATA_PLANE_CONTRACT_VERSION,
+    catalogVersion: DATA_PLANE_CATALOG_VERSION,
+    operation: supportedOperation,
+    context,
+    input: normalizedInput
+  };
+  const step = hashDataPlaneStepInputV1(stepInput);
+  const storeEntries = supportedOperation === "rest:batch_store" ? normalizedInput.entries : supportedOperation === "rest:store" || supportedOperation === "mcp:store_memory" ? [normalizedInput] : [];
+  const storeHasTarget = (target) => storeEntries.some(
+    (entry2) => entry2.targets.includes(target)
+  );
+  const multiStepKinds = (() => {
+    switch (supportedOperation) {
+      case "rest:store":
+      case "mcp:store_memory":
+      case "rest:batch_store": {
+        const kinds = [];
+        if (storeHasTarget("vector")) kinds.push("embedding", "vector");
+        if (storeHasTarget("graph")) kinds.push("graph");
+        kinds.push("sqlite");
+        return kinds;
+      }
+      case "rest:search":
+      case "mcp:search_memories":
+        return ["embedding", "sqlite"];
+      case "rest:delete":
+      case "mcp:delete_memory":
+        return ["vector", "graph", "sqlite"];
+      case "rest:lineage":
+      case "mcp:lineage":
+      case "rest:graph_nodes":
+      case "rest:graph_relationships":
+      case "rest:graph_subgraph":
+      case "mcp:get_taxonomy_state":
+      case "mcp:name_cluster":
+        return ["graph", "sqlite"];
+      case "rest:reinforce":
+      case "mcp:reinforce":
+        return ["vector", "sqlite"];
+      default:
+        return ["sqlite"];
+    }
+  })();
+  const executionPlan = {
+    mode: "journal",
+    version: DATA_PLANE_MANIFEST_VERSION,
+    steps: multiStepKinds.map((kind, sequence) => ({
+      sequence,
+      stepKey: multiStepKinds.length === 1 ? supportedOperation : `${supportedOperation}:${kind}`,
+      kind,
+      execution: kind === "sqlite" ? "sqlite_atomic" : "idempotent_adapter",
+      inputSha256: multiStepKinds.length === 1 ? step.sha256 : hashDataPlaneStepInputV1({ ...stepInput, step: { kind, sequence } }).sha256
+    }))
+  };
+  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(
+    (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;
+  return {
+    kind: "compiled",
+    contractVersion: DATA_PLANE_CONTRACT_VERSION,
+    catalogVersion: DATA_PLANE_CATALOG_VERSION,
+    operation: supportedOperation,
+    context,
+    normalizedInput,
+    stepInputCanonicalJson: step.canonicalJson,
+    stepInputSha256: step.sha256,
+    executionPlan,
+    manifestCanonicalJson: manifest.canonicalJson,
+    manifestSha256: manifest.sha256,
+    quoteDimensions: {
+      databaseOperations: supportedOperation === "rest:batch_store" ? normalizedInput.entries.length : 1,
+      embeddingUnicodeScalars,
+      embeddingEvents: embeddingUnicodeScalars > 0 ? 1 : 0
+    }
+  };
+}
+
+export {
+  normalizeGraphLabel,
+  normalizeNameKey,
+  assertGraphExtractionPayload,
+  mergeExtractedEntities,
+  DATA_PLANE_CONTRACT_VERSION,
+  DATA_PLANE_CATALOG_VERSION,
+  DATA_PLANE_MANIFEST_VERSION,
+  DATA_PLANE_SEARCH_EMBEDDING_CONTRACT,
+  DATA_PLANE_STEP_INPUT_FRAME,
+  DATA_PLANE_MANIFEST_FRAME,
+  DATA_PLANE_HTTP_RESPONSE_FRAME,
+  DATA_PLANE_COMPILER_LIMITS,
+  DATA_PLANE_OPERATION_COVERAGE,
+  encodeListCursorToken,
+  parseListCursorToken,
+  canonicalDataPlaneJson,
+  hashDataPlaneStepInputV1,
+  hashDataPlaneManifestV1,
+  hashDataPlaneHttpResponseV1,
+  compileDataPlaneRequest
+};