amalgm 0.1.239 → 0.1.240

package/runtime/scripts/amalgm-mcp/state/mutation-contracts.js

@@ -10,7 +10,9 @@
 
 const { decryptJson, encryptJson } = require('../browser/auth-vault');
 
+const CODE_PROJECT_CONTRACT = 'code-project-stream@2';
 const COOKIE_CONTRACT = 'browser-cookie-jar@1';
+const WORKSPACE_TREE_CONTRACT = 'workspace-tree@1';
 const PROTECTED_KIND = 'amalgm.encrypted-json@1';
 
 function isSensitiveContract(contract) {
@@ -47,10 +49,107 @@ function diagnosticOperation(contract, operation) {
   };
 }
 
+/**
+ * A numbered code publication may leave the generic journal only after the
+ * canonical code-project snapshot carries at least that contiguous number.
+ */
+function codeProjectOrderIsDurable(row, options = {}) {
+  const database = options.database;
+  const version = Number(row.official_cloud_version);
+  if (
+    !database
+    || !row.shared_resource_id
+    || !Number.isSafeInteger(version)
+    || version < 1
+  ) return false;
+
+  const cache = options.snapshotCache;
+  let snapshot = cache?.get(row.shared_resource_id);
+  if (snapshot === undefined) {
+    const replica = database.prepare(`
+      SELECT local_path, applied_version
+      FROM shared_resource_replicas
+      WHERE resource_id = ?
+    `).get(row.shared_resource_id);
+    try {
+      snapshot = (
+        replica?.local_path
+        && Number.isSafeInteger(Number(replica.applied_version))
+      ) ? require('../workspace/project-stream').readSnapshot(
+        replica.local_path,
+        row.shared_resource_id,
+      ) : null;
+      if (snapshot && snapshot.version !== Number(replica.applied_version)) {
+        snapshot = null;
+      }
+    } catch {
+      snapshot = null;
+    }
+    cache?.set(row.shared_resource_id, snapshot);
+  }
+
+  if (
+    !snapshot
+    || snapshot.version < version
+  ) return false;
+  return true;
+}
+
+/**
+ * A local code outbox row may leave only after another durable local fact can
+ * finish recovery: either the folded intent still names it, or the verified
+ * physical repo has already advanced through it.
+ */
+function codeProjectLocalRecoveryIsDurable(row) {
+  if (row.mutation_origin !== 'local') return true;
+  const project = require('../workspace/wall').projectForResource(row.shared_resource_id);
+  if (!project) return false;
+  const intent = require('../workspace/intent').readIntent(project);
+  if (
+    intent?.publication?.mutationId === row.mutation_id
+    && intent.publication.numberedVersion === Number(row.official_cloud_version)
+    && typeof intent.publication.foldedAt === 'string'
+  ) return true;
+  const state = require('../workspace/reducer').readRepoState(
+    project.repoKey,
+    project.resourceId,
+  );
+  return state?.materialized === true
+    && Number.isSafeInteger(state.appliedThrough)
+    && state.appliedThrough >= Number(row.official_cloud_version);
+}
+
+function mutationMayPrune(row, options = {}) {
+  if (row.contract !== CODE_PROJECT_CONTRACT) return true;
+  return codeProjectOrderIsDurable(row, options)
+    && codeProjectLocalRecoveryIsDurable(row);
+}
+
+function mutationNeedsOfficialMaterialization(contract) {
+  return contract === CODE_PROJECT_CONTRACT;
+}
+
+/**
+ * Some locally materialized contracts still need their own numbered echo to
+ * move the official floor. They may not let generic acknowledgement logic
+ * mark the row projected or advance the cursor merely because local bytes
+ * already resemble the event.
+ */
+function mutationNeedsOrderedEcho(contract) {
+  return contract === CODE_PROJECT_CONTRACT || contract === WORKSPACE_TREE_CONTRACT;
+}
+
 module.exports = {
+  CODE_PROJECT_CONTRACT,
   COOKIE_CONTRACT,
+  WORKSPACE_TREE_CONTRACT,
+  codeProjectLocalRecoveryIsDurable,
+  codeProjectOrderIsDurable,
   diagnosticOperation,
   isSensitiveContract,
+  mutationMayPrune,
+  mutationNeedsOfficialMaterialization,
+  mutationNeedsOrderedEcho,
   protectOperation,
   revealOperation,
 };