amalgm 0.1.198 → 0.1.200

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.198",
+  "version": "0.1.200",
   "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

@@ -31,6 +31,7 @@ const { refreshRepoCards } = require('../workspace/cards');
 const { checkpointFile, repoKeyOfCard } = require('../workspace/checkpoint');
 const {
   bindProject,
+  compactWallText,
   hasLocalContribution,
   isCommittedCard,
   projectForRepo,
@@ -352,6 +353,7 @@ test('peer records and earlier local history survive later publishes', async ()
     wall: 'code-project@3',
     project: repoKey,
     machine: 'machine-b',
+    mutationId: 'mut_project_peer',
     publishedAt: '2026-07-19T00:00:00.000Z',
     cards: [{ card: 'repo-card@2', machine: 'machine-b', replica: 'rpl_peer', path: '/work/app', head: { branch: 'preview' } }],
   });
@@ -401,6 +403,103 @@ test('three concurrent append records stay whole under Yjs ordering', () => {
   );
 });
 
+test('wall compaction deletes only records superseded for every machine', () => {
+  const line = (machine, value) => JSON.stringify({
+    wall: 'code-project@3',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}_${value}`,
+    cards: [{ value }],
+  });
+  const oldA = line('machine-a', 'old-a');
+  const oldB = line('machine-b', 'old-b');
+  const latestA = line('machine-a', 'latest-a');
+  const torn = '{"wall":"code-project@3","machine":"torn"';
+  const latestB = line('machine-b', 'latest-b');
+  const current = `${oldA}\n${oldB}\n${latestA}\n${torn}\n${latestB}\n`;
+  const compacted = compactWallText(current, repoKey);
+
+  assert.equal(compacted, `${latestA}\n${torn}\n${latestB}\n`);
+  assert.equal(compacted.includes(oldA), false);
+  assert.equal(compacted.includes(oldB), false);
+});
+
+test('an unordered legacy record cannot pin wall compaction', () => {
+  const unordered = JSON.stringify({
+    wall: 'code-project@3',
+    project: repoKey,
+    machine: '16.612Z',
+    cards: [{ value: 'corrupted-legacy-record' }],
+  });
+  const ordered = (machine) => JSON.stringify({
+    wall: 'code-project@3',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}`,
+    cards: [{ value: machine }],
+  });
+  const latestA = ordered('machine-a');
+  const latestB = ordered('machine-b');
+
+  assert.equal(
+    compactWallText(`${unordered}\n${latestA}\n${latestB}\n`, repoKey),
+    `${latestA}\n${latestB}\n`,
+  );
+});
+
+test('a concurrent deletion-only compaction and append commute in Yjs', () => {
+  const Y = require('yjs');
+  const line = (machine, value) => JSON.stringify({
+    wall: 'code-project@3',
+    project: repoKey,
+    machine,
+    mutationId: `mut_project_${machine}_${value}`,
+    cards: [{ value }],
+  });
+  const oldA = line('machine-a', 'old-a');
+  const oldB = line('machine-b', 'old-b');
+  const latestA = line('machine-a', 'latest-a');
+  const latestB = line('machine-b', 'latest-b');
+  const baseText = `${oldA}\n${oldB}\n${latestA}\n${latestB}\n`;
+  const compacted = compactWallText(baseText, repoKey);
+  const base = new Y.Doc();
+  base.getText('content').insert(0, baseText);
+  const baseUpdate = Y.encodeStateAsUpdate(base);
+
+  const writerUpdate = (change) => {
+    const writer = new Y.Doc();
+    Y.applyUpdate(writer, baseUpdate);
+    let update = null;
+    writer.on('update', (value) => {
+      update = value;
+    });
+    change(writer.getText('content'));
+    return update;
+  };
+  const compactUpdate = writerUpdate((text) => {
+    text.delete(0, baseText.length - compacted.length);
+  });
+  const appendLine = `${line('machine-c', 'latest-c')}\n`;
+  const appendUpdate = writerUpdate((text) => {
+    text.insert(text.length, appendLine);
+  });
+
+  const replicas = [
+    [compactUpdate, appendUpdate],
+    [appendUpdate, compactUpdate],
+  ].map((order) => {
+    const replica = new Y.Doc();
+    Y.applyUpdate(replica, baseUpdate);
+    for (const update of order) Y.applyUpdate(replica, update);
+    return replica.getText('content').toString();
+  });
+  assert.equal(replicas[0], replicas[1]);
+  assert.deepEqual(
+    replicas[0].trim().split('\n').map((entry) => JSON.parse(entry).cards[0].value),
+    ['latest-a', 'latest-b', 'latest-c'],
+  );
+});
+
 test('a torn line is ignored by readers, never fatal', () => {
   writeDocText(
     project.file,
@@ -409,6 +508,23 @@ test('a torn line is ignored by readers, never fatal', () => {
   assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
 });
 
+test('publishing compacts an oversized history before appending the new record', async () => {
+  const before = getDocText(project.file);
+  writeDocText(project.file, `${'obsolete\n'.repeat(132_000)}${before}`);
+  assert.ok(Buffer.byteLength(getDocText(project.file), 'utf8') > 1024 * 1024);
+
+  const repo = path.join(tempRoot, 'projects/app');
+  fs.writeFileSync(path.join(repo, 'after-compaction.txt'), 'bounded\n');
+  await run(repo, 'add', '.');
+  await run(repo, 'commit', '-m', 'publish after compaction');
+  await refreshRepoCards();
+  const result = publishWall(repoKey);
+
+  assert.equal(result.published, true);
+  assert.ok(Buffer.byteLength(getDocText(project.file), 'utf8') < 1024 * 1024);
+  assert.deepEqual(readWall(repoKey).map((entry) => entry.machine).sort(), ['machine-a', 'machine-b']);
+});
+
 test('project stats name every project resource, binding, and publish counter', () => {
   const stats = wallStats();
   const row = stats.projects.find((entry) => entry.repoKey === repoKey);

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

@@ -23,6 +23,7 @@ const WALL_CONTRACT = 'code-project@3';
 const PROJECT_DIR = path.join(AMALGM_DIR, 'state', 'code-projects');
 const REGISTRY_FILE = path.join(PROJECT_DIR, 'projects.json');
 const PUBLISH_QUIET_MS = 25;
+const COMPACT_AT_BYTES = 1024 * 1024;
 const ENSURE_STEP_TIMEOUT_MS = 20_000;
 const ENSURE_INTERVAL_MS = 15_000;
 const ATTACH_REJECTED = /shared_resource_read_forbidden/;
@@ -134,6 +135,7 @@ function parseWallLine(line) {
       entry?.wall !== WALL_CONTRACT
       || !entry.project
       || !entry.machine
+      || !entry.mutationId
       || !Array.isArray(entry.cards)
     ) return null;
     return entry;
@@ -442,6 +444,29 @@ function withoutPublishedAt(line) {
   return JSON.stringify(rest);
 }
 
+/**
+ * Keep the newest complete record for every machine, plus anything after
+ * the earliest of those records. Everything before that point is obsolete:
+ * every machine represented there has a newer complete value later.
+ *
+ * Compaction is deletion-only. Concurrent deletions and appends commute in
+ * Yjs, so this bounds the wall without bringing back whole-document races.
+ */
+function compactWallText(current, repoKey) {
+  const latest = new Map();
+  const lines = current.split('\n');
+  let offset = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const entry = line ? parseWallLine(line) : null;
+    if (entry?.project === repoKey) latest.set(entry.machine, offset);
+    offset += line.length + (index < lines.length - 1 ? 1 : 0);
+  }
+  if (latest.size === 0) return current;
+  const cutoff = Math.min(...latest.values());
+  return cutoff > 0 ? current.slice(cutoff) : current;
+}
+
 function publishProject(project, rawCards) {
   const replica = wallReplica(project);
   if (!replica) {
@@ -449,7 +474,7 @@ function publishProject(project, rawCards) {
     return { published: false, reason: 'project-not-bound', repoKey: project.repoKey };
   }
   const docs = require('../state/docs');
-  const current = docs.getDocText(project.file);
+  let current = docs.getDocText(project.file);
   let previous = null;
   let previousEntry = null;
   for (const line of current.split('\n')) {
@@ -501,9 +526,20 @@ function publishProject(project, rawCards) {
   }
 
   const separator = current && !current.endsWith('\n') ? '\n' : '';
+  if (Buffer.byteLength(`${current}${separator}${mine}\n`, 'utf8') > COMPACT_AT_BYTES) {
+    const compacted = compactWallText(current, project.repoKey);
+    if (compacted !== current) {
+      docs.writeDocText(project.file, compacted, {
+        baseHash: sha256(current),
+        mutationId: `mut_project_compact_${crypto.randomBytes(16).toString('base64url')}`,
+      });
+      current = docs.getDocText(project.file);
+    }
+  }
+  const nextSeparator = current && !current.endsWith('\n') ? '\n' : '';
   const result = docs.writeDocText(
     project.file,
-    `${current}${separator}${mine}\n`,
+    `${current}${nextSeparator}${mine}\n`,
     { baseHash: sha256(current), mutationId },
   );
   service.counters.publishes += 1;
@@ -686,6 +722,7 @@ function wallStats() {
 module.exports = {
   WALL_CONTRACT,
   bindProject,
+  compactWallText,
   hasLocalContribution,
   isCommittedCard,
   projectFile,