@hasna/mementos 0.14.80 → 0.14.81

package/dist/server/index.js

@@ -57624,8 +57624,8 @@ function normalizeProjectUpdateInput(input) {
   }
   return normalized;
 }
-function assertProjectUpdateIdentity(identity) {
-  if (identity.authority_id !== PROJECT_UPDATE_AUTHORITY.authority_id || identity.tenant_id !== PROJECT_UPDATE_AUTHORITY.tenant_id || identity.corpus_id !== PROJECT_UPDATE_AUTHORITY.corpus_id) {
+function assertProjectUpdateIdentity(identity, expectedIdentity = PROJECT_UPDATE_AUTHORITY) {
+  if (identity.authority_id !== expectedIdentity.authority_id || identity.tenant_id !== expectedIdentity.tenant_id || identity.corpus_id !== expectedIdentity.corpus_id) {
     throw new ProjectGuardedUpdateError("PROJECT_UPDATE_AUTHORITY_MISMATCH", "guarded project update does not match this authority, tenant, and corpus");
   }
 }
@@ -57634,8 +57634,8 @@ function assertBoundedIdentifier2(value, field) {
     throw new ProjectGuardedUpdateError("PROJECT_UPDATE_INVALID_INPUT", `${field} must be an 8-128 character bounded identifier`);
   }
 }
-function assertProjectUpdateRequest(request) {
-  assertProjectUpdateIdentity(request);
+function assertProjectUpdateRequest(request, expectedIdentity = PROJECT_UPDATE_AUTHORITY) {
+  assertProjectUpdateIdentity(request, expectedIdentity);
   assertBoundedIdentifier2(request.operation_id, "operation_id");
   assertBoundedIdentifier2(request.step_id, "step_id");
   assertBoundedIdentifier2(request.idempotency_key, "idempotency_key");
@@ -57748,7 +57748,7 @@ function makeProjectUpdateReceipt(input) {
     target_id: input.target_id,
     expected_revision: input.request.expected_revision,
     result_revision: input.after_project.updated_at,
-    result_digest: digestProjectUpdateValue(input.after_project),
+    result_digest: input.result_digest ?? digestProjectUpdateValue(input.after_project),
     accepted_receipt_id: input.accepted_receipt_id ?? null,
     before_project: input.before_project,
     after_project: input.after_project,
@@ -57812,8 +57812,8 @@ function listProjects(db) {
   const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
   return rows.map(parseProjectRow2);
 }
-function previewProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function previewProjectUpdate(id, request, db, expectedIdentity = PROJECT_UPDATE_AUTHORITY) {
+  assertProjectUpdateRequest(request, expectedIdentity);
   const normalized = normalizeProjectUpdateInput(request.updates);
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-update`, { ...request, updates: normalized, dry_run: true });
@@ -57835,8 +57835,8 @@ function previewProjectUpdate(id, request, db) {
     receipt: null
   };
 }
-function applyProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function applyProjectUpdate(id, request, db, expectedIdentity = PROJECT_UPDATE_AUTHORITY, resultDigestForProject) {
+  assertProjectUpdateRequest(request, expectedIdentity);
   const normalized = normalizeProjectUpdateInput(request.updates);
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-update`, { ...request, updates: normalized, dry_run: false });
@@ -57897,14 +57897,15 @@ function applyProjectUpdate(id, request, db) {
       request_digest: requestDigest,
       target_id: id,
       before_project: before,
-      after_project: readback
+      after_project: readback,
+      result_digest: resultDigestForProject?.(readback)
     });
     insertProjectUpdateReceipt(d, receipt);
     return { dry_run: false, applied: true, project: readback, receipt };
   });
 }
-function rollbackProjectUpdate(id, request, db) {
-  assertProjectUpdateRequest(request);
+function rollbackProjectUpdate(id, request, db, expectedIdentity = PROJECT_UPDATE_AUTHORITY, resultDigestForProject) {
+  assertProjectUpdateRequest(request, expectedIdentity);
   assertBoundedIdentifier2(request.accepted_receipt_id, "accepted_receipt_id");
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/guarded-rollback`, request);
@@ -57970,14 +57971,15 @@ function rollbackProjectUpdate(id, request, db) {
       target_id: id,
       before_project: current,
       after_project: readback,
+      result_digest: resultDigestForProject?.(readback),
       accepted_receipt_id: accepted.receipt_id
     });
     insertProjectUpdateReceipt(d, receipt);
     return { dry_run: false, applied: true, project: readback, receipt };
   });
 }
-function getProjectUpdateReceipt(id, receiptId, identity = PROJECT_UPDATE_AUTHORITY, db) {
-  assertProjectUpdateIdentity(identity);
+function getProjectUpdateReceipt(id, receiptId, identity = PROJECT_UPDATE_AUTHORITY, db, expectedIdentity = PROJECT_UPDATE_AUTHORITY) {
+  assertProjectUpdateIdentity(identity, expectedIdentity);
   if (!db && isApiMode()) {
     const { data } = apiJson("POST", `/projects/${encodeURIComponent(id)}/update-receipts/lookup`, { ...identity, receipt_id: receiptId });
     return data;
@@ -58205,9 +58207,9 @@ function assertWithinBounds(value, bounds, startedAt) {
   }
   return { response_bytes: bytes, elapsed_ms: elapsed };
 }
-function withResponseControl(receipt, bounds, startedAt) {
+function withBoundedResponseControl(payload, bounds, startedAt) {
   const result = {
-    receipt,
+    ...payload,
     response_control: {
       response_byte_limit: bounds.response_byte_limit,
       time_budget_ms: bounds.time_budget_ms,
@@ -58230,6 +58232,9 @@ function withResponseControl(receipt, bounds, startedAt) {
   result.response_control.elapsed_ms = measured.elapsed_ms;
   return result;
 }
+function withResponseControl(receipt, bounds, startedAt) {
+  return withBoundedResponseControl({ receipt }, bounds, startedAt);
+}
 function requireString(value, field, options = {}) {
   const min = options.min ?? 1;
   const max = options.max ?? 512;
@@ -58256,6 +58261,80 @@ function ownedPath(target) {
   }
   return path;
 }
+function guardedAuthorityIdentity(capability) {
+  return {
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id
+  };
+}
+function assertGuardedAuthorityRequest(targetId, request, capability) {
+  assertBounds(request);
+  requireString(targetId, "target_id", { min: 8, max: 128, pattern: OPERATION_PATTERN });
+  if (request.authority !== "mementos" || request.authority_route !== MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE || request.package_version !== capability.package_version || request.authority_id !== capability.authority_id || request.tenant_id !== capability.tenant_id || request.corpus_id !== capability.corpus_id) {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH", "guarded project request does not match this authority capability identity");
+  }
+  return guardedAuthorityIdentity(capability);
+}
+function assertGuardedOperationFields(request) {
+  requireString(request.operation_id, "operation_id", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.step_id, "step_id", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.idempotency_key, "idempotency_key", {
+    min: 8,
+    max: 128,
+    pattern: OPERATION_PATTERN
+  });
+  requireString(request.expected_revision, "expected_revision", { max: 128 });
+}
+function assertGuardedUpdateRequest(targetId, request, capability) {
+  const identity = assertGuardedAuthorityRequest(targetId, request, capability);
+  assertGuardedOperationFields(request);
+  if (!request.updates || typeof request.updates !== "object") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "guarded project updates must contain exactly one private path handle");
+  }
+  exactKeys(request.updates, ["path"], "updates");
+  return { identity, path: ownedPath(request.updates.path) };
+}
+function publicGuardedUpdateReceipt(receipt, capability) {
+  return {
+    receipt_id: receipt.receipt_id,
+    authority: "mementos",
+    route: MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
+    package_version: capability.package_version,
+    authority_id: capability.authority_id,
+    tenant_id: capability.tenant_id,
+    corpus_id: capability.corpus_id,
+    operation_id: receipt.operation_id,
+    step_id: receipt.step_id,
+    direction: receipt.direction,
+    idempotency_key: receipt.idempotency_key,
+    request_digest: receipt.request_digest,
+    outcome: "accepted",
+    target_id: receipt.target_id,
+    expected_revision: receipt.expected_revision,
+    result_revision: receipt.result_revision,
+    result_digest: receipt.result_digest,
+    accepted_receipt_id: receipt.accepted_receipt_id,
+    created_at: receipt.created_at
+  };
+}
+function guardedProjectError(cause) {
+  if (cause instanceof MementosProjectRegistrationError)
+    throw cause;
+  if (cause instanceof ProjectGuardedUpdateError) {
+    const code = cause.code === "PROJECT_UPDATE_INVALID_INPUT" ? "MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT" : cause.code === "PROJECT_UPDATE_AUTHORITY_MISMATCH" ? "MEMENTOS_PROJECT_REGISTRATION_CAPABILITY_MISMATCH" : cause.code === "PROJECT_UPDATE_NOT_FOUND" ? "MEMENTOS_PROJECT_REGISTRATION_RECORD_NOT_FOUND" : cause.code === "PROJECT_UPDATE_RECEIPT_NOT_FOUND" ? "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND" : "MEMENTOS_PROJECT_REGISTRATION_CONFLICT";
+    throw new MementosProjectRegistrationError(code, "guarded project operation was rejected without exposing private project data", { project_update_code: cause.code });
+  }
+  throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project operation failed before a bounded public result was available");
+}
 function normalizedCallDigest(request) {
   return digestMementosProjectRegistrationValue({
     authority_route: request.authority_route,
@@ -58642,6 +58721,7 @@ class PackageOwnedMementosProjectRegistrationAuthority {
       conditional_inverse: true,
       ambiguous_outcome_reconciliation: true,
       guarded_update: true,
+      guarded_update_route: MEMENTOS_PROJECT_GUARDED_UPDATE_ROUTE,
       no_write_dry_run: true,
       expected_revision_compare_and_swap: true,
       caller_idempotency: true,
@@ -58703,6 +58783,90 @@ class PackageOwnedMementosProjectRegistrationAuthority {
       supported_resources: ["project"]
     };
   }
+  boundedGuardedUpdateResult(targetId2, project, receipt, bounds, startedAt) {
+    if (!receipt || project.id !== targetId2 || receipt.target_id !== targetId2) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project operation did not return its exact immutable receipt");
+    }
+    if (project.updated_at !== receipt.result_revision) {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_ATOMICITY_UNAVAILABLE", "guarded project result revision did not match its immutable receipt");
+    }
+    const record = {
+      target_id: targetId2,
+      revision: receipt.result_revision,
+      digest: receipt.result_digest
+    };
+    return withBoundedResponseControl({
+      dry_run: false,
+      applied: true,
+      record,
+      receipt: publicGuardedUpdateReceipt(receipt, this.capabilityValue)
+    }, bounds, startedAt);
+  }
+  async guardedUpdateProject(targetId2, request) {
+    const startedAt = Date.now();
+    const { identity, path } = assertGuardedUpdateRequest(targetId2, request, this.capabilityValue);
+    try {
+      const result = applyProjectUpdate(targetId2, {
+        ...identity,
+        operation_id: request.operation_id,
+        step_id: request.step_id,
+        idempotency_key: request.idempotency_key,
+        expected_revision: request.expected_revision,
+        updates: { path }
+      }, this.db, identity, (project) => projectRecord(this.db, project).digest);
+      return this.boundedGuardedUpdateResult(targetId2, result.project, result.receipt, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
+  async getGuardedProjectUpdateReceipt(targetId2, receiptId2, request) {
+    const startedAt = Date.now();
+    const identity = assertGuardedAuthorityRequest(targetId2, request, this.capabilityValue);
+    requireString(receiptId2, "receipt_id", {
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
+    });
+    try {
+      const receipt = getProjectUpdateReceipt(targetId2, receiptId2, identity, this.db, identity);
+      return withBoundedResponseControl({
+        receipt: publicGuardedUpdateReceipt(receipt, this.capabilityValue)
+      }, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
+  async rollbackGuardedProjectUpdate(targetId2, request) {
+    const startedAt = Date.now();
+    const identity = assertGuardedAuthorityRequest(targetId2, request, this.capabilityValue);
+    assertGuardedOperationFields(request);
+    if (!request.accepted_receipt || typeof request.accepted_receipt !== "object") {
+      throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional rollback requires the exact sanitized accepted receipt");
+    }
+    requireString(request.accepted_receipt.receipt_id, "accepted_receipt.receipt_id", {
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
+    });
+    try {
+      const internalAccepted = getProjectUpdateReceipt(targetId2, request.accepted_receipt.receipt_id, identity, this.db, identity);
+      const accepted = publicGuardedUpdateReceipt(internalAccepted, this.capabilityValue);
+      if (accepted.direction !== "forward" || accepted.target_id !== targetId2 || request.expected_revision !== accepted.result_revision || canonicalMementosProjectRegistrationJson(request.accepted_receipt) !== canonicalMementosProjectRegistrationJson(accepted)) {
+        throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "conditional rollback receipt does not exactly match the accepted forward update");
+      }
+      const result = rollbackProjectUpdate(targetId2, {
+        ...identity,
+        operation_id: request.operation_id,
+        step_id: request.step_id,
+        idempotency_key: request.idempotency_key,
+        expected_revision: request.expected_revision,
+        accepted_receipt_id: accepted.receipt_id
+      }, this.db, identity, (project) => projectRecord(this.db, project).digest);
+      return this.boundedGuardedUpdateResult(targetId2, result.project, result.receipt, request, startedAt);
+    } catch (cause) {
+      return guardedProjectError(cause);
+    }
+  }
   async create(request) {
     const startedAt = Date.now();
     const path = assertForwardRequest2(request, this.capabilityValue);
@@ -58799,9 +58963,9 @@ class PackageOwnedMementosProjectRegistrationAuthority {
       throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "resource_kind must be project");
     }
     requireString(request.target_id, "target_id", {
-      min: 51,
-      max: 51,
-      pattern: PROJECT_ID_PATTERN
+      min: 8,
+      max: 128,
+      pattern: OPERATION_PATTERN
     });
     const path = ownedPath(request.target);
     const project = getProjectByExactId3(this.db, request.target_id);
@@ -59059,6 +59223,31 @@ function fromWireReadRequest(body) {
     target: new WirePathHandle(canonicalPath)
   };
 }
+function fromWireGuardedUpdateRequest(body) {
+  const { target_id: targetId2, updates, ...request } = body;
+  if (typeof targetId2 !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "target_id is required on the private guarded-update transport");
+  }
+  if (!updates || typeof updates !== "object" || Array.isArray(updates) || typeof updates["path"] !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", "updates.path is required on the private guarded-update transport");
+  }
+  return {
+    targetId: targetId2,
+    request: {
+      ...request,
+      updates: {
+        path: new WirePathHandle(String(updates["path"]))
+      }
+    }
+  };
+}
+function exactWireIdentifier(body, field) {
+  const value = body[field];
+  if (typeof value !== "string") {
+    throw new MementosProjectRegistrationError("MEMENTOS_PROJECT_REGISTRATION_INVALID_INPUT", `${field} is required on the guarded-update transport`);
+  }
+  return value;
+}
 async function handleMementosProjectRegistrationHttpRequest(request, url, authority, basePath = "/v1/project-registration") {
   const path = url.pathname;
   if (path !== basePath && !path.startsWith(`${basePath}/`))
@@ -59093,6 +59282,21 @@ async function handleMementosProjectRegistrationHttpRequest(request, url, author
     if (action === "verify-inverse") {
       return json2({ verification: await authority.verifyInverse(fromWireRequest(body)) });
     }
+    if (action === "projects/guarded-update") {
+      const guarded = fromWireGuardedUpdateRequest(body);
+      return json2(await authority.guardedUpdateProject(guarded.targetId, guarded.request));
+    }
+    if (action === "projects/update-receipts/lookup") {
+      const targetId2 = exactWireIdentifier(body, "target_id");
+      const receiptId2 = exactWireIdentifier(body, "receipt_id");
+      const { target_id: _targetId, receipt_id: _receiptId, ...lookup } = body;
+      return json2(await authority.getGuardedProjectUpdateReceipt(targetId2, receiptId2, lookup));
+    }
+    if (action === "projects/guarded-rollback") {
+      const targetId2 = exactWireIdentifier(body, "target_id");
+      const { target_id: _targetId, ...rollback } = body;
+      return json2(await authority.rollbackGuardedProjectUpdate(targetId2, rollback));
+    }
     return json2({
       error: "unknown Mementos project-registration route",
       code: "MEMENTOS_PROJECT_REGISTRATION_RECEIPT_NOT_FOUND"
@@ -59129,6 +59333,9 @@ addRoute("POST", "/api/project-registration/receipts/lookup", handle);
 addRoute("POST", "/api/project-registration/read-exact", handle);
 addRoute("POST", "/api/project-registration/compensate", handle);
 addRoute("POST", "/api/project-registration/verify-inverse", handle);
+addRoute("POST", "/api/project-registration/projects/guarded-update", handle);
+addRoute("POST", "/api/project-registration/projects/update-receipts/lookup", handle);
+addRoute("POST", "/api/project-registration/projects/guarded-rollback", handle);
 
 // src/server/routes/entities.ts
 init_entities();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/mementos",
-  "version": "0.14.80",
+  "version": "0.14.81",
   "description": "Universal memory system for AI agents - CLI + MCP server + library API",
   "type": "module",
   "main": "dist/index.js",
@@ -108,5 +108,5 @@
     "sigstore": "5.0.0",
     "typescript": "^5.7.3"
   },
-  "gitHead": "a45d90c4a854aae12d57168ca31897213dbfca58"
+  "gitHead": "cb2c4c46e64f71e28018307fe00b7083e2e0a8aa"
 }