amalgm 0.1.209 → 0.1.211

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.209",
+  "version": "0.1.211",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/tests/workspace-wall.test.js

@@ -146,10 +146,25 @@ test('only a value different from both the materialized baseline and the rail is
     baseline,
     null,
     {
+      positionVersion: 10,
       head: { branch: 'main', oid: oidB, detached: false },
-      branches: [{ name: 'main', oid: oidB }],
+      branches: [{ name: 'main', oid: oidB, version: 10 }],
     },
   ), false);
+  assert.equal(hasLocalContribution(
+    {
+      head: { branch: 'main', oid: oidB, detached: false },
+      refs: [{ name: 'main', oid: oidB }],
+    },
+    remoteAdvance,
+    baseline,
+    null,
+    {
+      positionVersion: null,
+      head: { branch: 'main', oid: oidB, detached: false },
+      branches: [{ name: 'main', oid: oidB, version: null }],
+    },
+  ), true);
   assert.equal(hasLocalContribution(
     local,
     plan,
@@ -161,8 +176,8 @@ test('only a value different from both the materialized baseline and the rail is
     {
       head: { branch: 'main', oid: oidA, detached: false },
       branches: [
-        { name: 'main', oid: oidA },
-        { name: 'feature', oid: oidB },
+        { name: 'main', oid: oidA, version: 10 },
+        { name: 'feature', oid: oidB, version: 10 },
       ],
     },
   ), true);
@@ -285,6 +300,13 @@ test('a repo project appends immutable machine records', async () => {
   assert.equal(entries[0].cards[0].positionMutationId, first.mutationId);
   assert.equal(entries[0].cards[0].positionVersion, null);
   assert.equal(publishedCardFor(refreshed.cards[0]), null);
+  const awaitingNumber = publishWall(repoKey);
+  assert.equal(awaitingNumber.published, false);
+  assert.equal(awaitingNumber.reason, 'unchanged');
+  assert.equal(
+    require('../workspace/reducer').localCardMayMaterialize(null, awaitingNumber),
+    false,
+  );
 
   acknowledgeCloudMutation(project.resourceId, first.mutationId, {
     version: 1,
@@ -663,3 +685,27 @@ test('a restarted wall publishes once even when the project is already attached'
       > before.publishes + before.publishSkips,
   );
 });
+
+test('the periodic project check retries an unsent wall', async () => {
+  const originalSetInterval = global.setInterval;
+  let periodicCheck = null;
+  global.setInterval = (callback) => {
+    periodicCheck = callback;
+    return { unref() {} };
+  };
+  try {
+    startWallService();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const before = wallStats();
+    periodicCheck();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const after = wallStats();
+    assert.ok(
+      after.publishes + after.publishSkips
+        > before.publishes + before.publishSkips,
+    );
+  } finally {
+    stopWallService();
+    global.setInterval = originalSetInterval;
+  }
+});

package/runtime/scripts/amalgm-mcp/workspace/wall.js

@@ -144,6 +144,27 @@ function parseWallLine(line) {
   }
 }
 
+function sealCardVersions(project, card) {
+  return {
+    ...card,
+    positionVersion: validVersion(card.positionVersion)
+      ? card.positionVersion
+      : officialVersion(project.resourceId, card.positionMutationId),
+    branches: (card.branches || []).map((ref) => ({
+      ...ref,
+      version: validVersion(ref.version)
+        ? ref.version
+        : officialVersion(project.resourceId, ref.mutationId),
+    })),
+    checkpoints: (card.checkpoints || []).map((checkpoint) => ({
+      ...checkpoint,
+      version: validVersion(checkpoint.version)
+        ? checkpoint.version
+        : officialVersion(project.resourceId, checkpoint.mutationId),
+    })),
+  };
+}
+
 function readProjectWall(project) {
   if (!fs.existsSync(project.file)) return [];
   const entries = new Map();
@@ -154,24 +175,7 @@ function readProjectWall(project) {
     entries.set(entry.machine, {
       ...entry,
       resourceId: project.resourceId,
-      cards: entry.cards.map((card) => ({
-        ...card,
-        positionVersion: validVersion(card.positionVersion)
-          ? card.positionVersion
-          : officialVersion(project.resourceId, card.positionMutationId),
-        branches: (card.branches || []).map((ref) => ({
-          ...ref,
-          version: validVersion(ref.version)
-            ? ref.version
-            : officialVersion(project.resourceId, ref.mutationId),
-        })),
-        checkpoints: (card.checkpoints || []).map((checkpoint) => ({
-          ...checkpoint,
-          version: validVersion(checkpoint.version)
-            ? checkpoint.version
-            : officialVersion(project.resourceId, checkpoint.mutationId),
-        })),
-      })),
+      cards: entry.cards.map((card) => sealCardVersions(project, card)),
     });
   }
   return [...entries.values()];
@@ -231,8 +235,10 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
   const atBaseline = baseline
     && card.head?.branch === baseline.branch
     && card.head?.oid === baseline.baseOid;
-  const alreadyPublished = previousCard && samePosition(card, previousCard);
+  const alreadyPublished = validVersion(previousCard?.positionVersion)
+    && samePosition(card, previousCard);
   const reversesPublishedSharedPosition = previousCard
+    && validVersion(previousCard.positionVersion)
     && samePosition(previousCard, plan.card)
     && !alreadyPublished;
   if ((!onRail && !atBaseline && !alreadyPublished) || reversesPublishedSharedPosition) return true;
@@ -240,7 +246,9 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
   const currentRefs = oidMap(card.refs);
   const railRefs = oidMap(plan.branches);
   const baselineRefs = oidMap(baseline?.branches);
-  const previousRefs = oidMap(previousCard?.branches || previousCard?.refs);
+  const previousRefs = new Map(
+    (previousCard?.branches || previousCard?.refs || []).map((ref) => [ref.name, ref]),
+  );
   for (const name of new Set([
     ...currentRefs.keys(),
     ...baselineRefs.keys(),
@@ -249,10 +257,11 @@ function hasLocalContribution(card, plan, baseline, checkpoint = null, previousC
     const current = currentRefs.get(name) ?? null;
     const shared = railRefs.get(name) ?? null;
     const previous = baselineRefs.get(name) ?? null;
-    const published = previousRefs.get(name) ?? null;
+    const publishedRef = previousRefs.get(name);
+    const published = publishedRef?.oid ?? null;
     const matchesBaseline = baselineRefs.has(name) && current === previous;
-    const matchesPublished = previousRefs.has(name) && current === published;
-    const reversesPublishedSharedValue = previousRefs.has(name)
+    const matchesPublished = validVersion(publishedRef?.version) && current === published;
+    const reversesPublishedSharedValue = validVersion(publishedRef?.version)
       && published === shared
       && current !== published;
     if (
@@ -519,12 +528,13 @@ function publishProject(project, rawCards) {
   const reducer = require('./reducer');
   const sharedPlan = reducer.reduceWall(readProjectWall(project)).get(project.repoKey);
   const baseline = reducer.readRepoState(project.repoKey);
-  const previousReplicas = new Set((previousEntry?.cards || []).map((card) => card.replica));
+  const previousCards = (previousEntry?.cards || []).map((card) => sealCardVersions(project, card));
+  const previousReplicas = new Set(previousCards.map((card) => card.replica));
   const currentReplicas = new Set(rawCards.map((card) => card.replica));
   const removed = [...previousReplicas].some((replica) => !currentReplicas.has(replica));
   const contributes = rawCards.some((card) => {
     const checkpoint = readCheckpoint(machineId(), project.repoKey);
-    const previousCard = previousEntry?.cards?.find((entry) => entry.replica === card.replica);
+    const previousCard = previousCards.find((entry) => entry.replica === card.replica);
     return hasLocalContribution(card, sharedPlan, baseline, checkpoint, previousCard)
       || hasObjectUpgrade(card, sharedPlan);
   });
@@ -535,7 +545,7 @@ function publishProject(project, rawCards) {
   const mutationId = `mut_project_${crypto.randomBytes(16).toString('base64url')}`;
   const cards = stampCards(
     rawCards,
-    previousEntry?.cards,
+    previousCards,
     sharedPlan,
     baseline,
     mutationId,
@@ -704,7 +714,10 @@ function startWallService() {
       schedulePublish();
     }
   });
-  service.ensureInterval = setInterval(() => ensureProjects().catch(() => {}), ENSURE_INTERVAL_MS);
+  service.ensureInterval = setInterval(() => {
+    ensureProjects().catch(() => {});
+    schedulePublish();
+  }, ENSURE_INTERVAL_MS);
   service.ensureInterval.unref?.();
   ensureProjects().catch(() => {});
   schedulePublish();