amalgm 0.1.158 → 0.1.159

package/package.json

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

package/runtime/scripts/amalgm-mcp/fs/rest.js

@@ -12,7 +12,7 @@ const { appendStateEvent } = require('../state/events');
 const { createFsSearchHandler } = require('./search');
 
 const TEXT_EXTENSIONS = new Set([
-  'txt', 'md', 'json', 'js', 'ts', 'tsx', 'jsx', 'py', 'html', 'css',
+  'txt', 'md', 'json', 'jsonl', 'js', 'ts', 'tsx', 'jsx', 'py', 'html', 'css',
   'xml', 'yaml', 'yml', 'sh', 'bash', 'env', 'gitignore', 'dockerfile',
   'svg', 'csv', 'sql', 'toml', 'rs', 'go', 'rb', 'java', 'kt', 'swift',
   'c', 'cpp', 'cs', 'php', 'scss', 'log', 'ini', 'cfg', 'conf',

package/runtime/scripts/amalgm-mcp/index.js

@@ -127,6 +127,8 @@ async function boot() {
   startAppRouteSyncLoop();
   startHealthMonitor();
   require('./state/ports').startPortsBridge();
+  require('./workspace/cards').startRepoCardService();
+  require('./workspace/wall').startWallService();
 }
 
 boot().catch((err) => {

package/runtime/scripts/amalgm-mcp/server/routes/state.js

@@ -59,6 +59,10 @@ async function handleStateRoutes(ctx) {
       await stateRest.handleResourceEmit(await ctx.readJsonBody(), ctx.sendJson);
       return true;
     }
+    if (ctx.pathname === '/state/presence') {
+      await stateRest.handlePresenceUpdate(await ctx.readJsonBody(), ctx.sendJson);
+      return true;
+    }
     if (ctx.pathname === '/state/docs/open') {
       await stateRest.handleDocOpen(await ctx.readJsonBody(), ctx.sendJson);
       return true;

package/runtime/scripts/amalgm-mcp/server/routes/workspace.js

@@ -51,6 +51,22 @@ async function handleWorkspaceRoutes(ctx) {
     workspaceRest.handleWorktreeDelete(await ctx.readJsonBody(), ctx.sendJson);
     return true;
   }
+  if (ctx.pathname === '/workspace/repos' && ctx.method === 'GET') {
+    workspaceRest.handleRepoCards(ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/workspace/repos/refresh' && ctx.method === 'POST') {
+    await workspaceRest.handleRepoCardsRefresh(ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/workspace/sync/stats' && ctx.method === 'GET') {
+    workspaceRest.handleWorkspaceSyncStats(ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/workspace/machines' && ctx.method === 'GET') {
+    workspaceRest.handleWorkspaceMachines(ctx.sendJson);
+    return true;
+  }
   return false;
 }
 

package/runtime/scripts/amalgm-mcp/state/attachments.js

@@ -231,11 +231,54 @@ function getAttachment(attachmentId, options = {}) {
   );
 }
 
+/** The one durable attachment request for a resource, if any. */
+function getAttachmentByResource(resourceId, options = {}) {
+  const database = options.database || openLocalDb();
+  return normalizeRow(
+    cachedStatement(database, 'SELECT * FROM shared_resource_attachments WHERE resource_id = ?')
+      .get(resourceId),
+  );
+}
+
+/**
+ * Cycle a refused (or stuck) attachment request back to pending — for a
+ * binding whose cloud answer may have changed since the refusal, e.g. a
+ * derived-id resource that lost its creation race and exists now. Unlike
+ * requestRehydration this needs no replica: it retries the first binding.
+ */
+function retryAttachment(resourceIdInput, options = {}) {
+  const resourceId = requiredText(resourceIdInput, 'resourceId', 132);
+  if (!SHARED_RESOURCE_ID.test(resourceId)) throw invalid('resourceId has an invalid format');
+  const database = options.database || openLocalDb();
+  const now = new Date().toISOString();
+  const result = cachedStatement(database, `
+    UPDATE shared_resource_attachments
+    SET attachment_state = 'pending',
+        next_attempt_at = NULL,
+        last_error = NULL,
+        updated_at = ?
+    WHERE resource_id = ? AND attachment_state != 'attached'
+  `).run(now, resourceId);
+  if (!result.changes) throw invalid(`no retryable attachment for ${resourceId}`, 404);
+  const attachment = getAttachmentByResource(resourceId, { database });
+  appendStateEvent({
+    resource: 'shared:attachments',
+    op: 'update',
+    id: attachment.attachmentId,
+    sharedResourceId: resourceId,
+    value: { state: 'pending' },
+    source: 'shared:attachment-retry',
+  });
+  return attachment;
+}
+
 module.exports = {
   acknowledgeAttachment,
   claimAttachments,
   enqueueAttachment,
   failAttachment,
   getAttachment,
+  getAttachmentByResource,
   requestRehydration,
+  retryAttachment,
 };

package/runtime/scripts/amalgm-mcp/state/db.js

@@ -58,6 +58,7 @@ function openLocalDb() {
 }
 
 function migrate(database = openLocalDb()) {
+  dropLegacyRepoCards(database);
   database.exec(`
     CREATE TABLE IF NOT EXISTS event_log (
       seq INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -531,6 +532,29 @@ function migrate(database = openLocalDb()) {
     CREATE INDEX IF NOT EXISTS workspaces_location_type_idx
       ON workspaces(location_type);
 
+    CREATE TABLE IF NOT EXISTS repo_replicas (
+      git_dir TEXT PRIMARY KEY,
+      replica_id TEXT NOT NULL UNIQUE,
+      root_commit TEXT,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS repo_cards (
+      replica_id TEXT PRIMARY KEY,
+      path TEXT NOT NULL,
+      git_dir TEXT NOT NULL,
+      root TEXT NOT NULL,
+      health TEXT NOT NULL,
+      fingerprint TEXT NOT NULL,
+      generation INTEGER NOT NULL,
+      first_seen_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      card_json TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS repo_cards_path_idx
+      ON repo_cards(path);
+
     CREATE TABLE IF NOT EXISTS browser_profiles (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,
@@ -621,6 +645,17 @@ function ensureColumn(database, tableName, columnName, declaration) {
   database.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${declaration}`);
 }
 
+// repo-card identity moved from the path to minted replica ids
+// (repo-card@2). Cards are derived observations, so the v1 table is
+// dropped rather than migrated — the next refresh rebuilds every card
+// straight from git.
+function dropLegacyRepoCards(database) {
+  const columns = database.prepare('PRAGMA table_info(repo_cards)').all();
+  if (columns.length > 0 && !columns.some((column) => column.name === 'replica_id')) {
+    database.exec('DROP TABLE repo_cards');
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Lazily created tables. The DDL lives here so this file owns every schema
 // statement, but these tables are only created when their feature is first

package/runtime/scripts/amalgm-mcp/state/presence.js

@@ -0,0 +1,175 @@
+'use strict';
+
+/**
+ * The ephemeral presence lane (realtime-sdk.md §6, "Ephemeral").
+ *
+ * Presence is the channel connection made visible: per resource, the set of
+ * live bindings (sessions) and the small opaque position blob each one last
+ * published. Everything here is the inverse of the durable lane in events.js:
+ * never written to the event log, never in snapshots or replay, expired by
+ * TTL instead of retained — a caret that outlives its author is a lie, where
+ * a doc byte must outlive everything.
+ *
+ * Ownership rules the wire shape enforces:
+ *  - Identity is stamped HERE from the enrolled account (workspace/identity),
+ *    never accepted from the publisher. A blob cannot impersonate.
+ *  - The blob is opaque. Only the surface bound to the same resource on the
+ *    other end knows its coordinate system (text caret, canvas x,y, nothing).
+ *  - Absence is the default presence must re-earn: entries live TTL_MS from
+ *    their last publish, and a session's death (stream teardown or expiry)
+ *    removes it everywhere without its cooperation.
+ *
+ * Broadcast shape: the full peer list per resource, re-sent on every change.
+ * Removal is implicit (absent from the list), so there is no ordering, no
+ * seq, and nothing to replay — receivers replace, never merge.
+ */
+
+const { EventEmitter } = require('events');
+
+const emitter = new EventEmitter();
+emitter.setMaxListeners(200);
+
+/** A peer whose publisher has gone silent this long is gone, no exceptions. */
+const PRESENCE_TTL_MS = 30_000;
+const SWEEP_INTERVAL_MS = 10_000;
+/** Positions are small facts; anything bigger is data smuggling on the lane. */
+const MAX_BLOB_JSON_BYTES = 8 * 1024;
+
+/** resource -> (session -> { session, user, blob, at, activeAt }) */
+const channels = new Map();
+let sweepTimer = null;
+
+function requireString(value, field) {
+  if (typeof value !== 'string' || !value.trim()) {
+    const error = new Error(`presence requires a non-empty "${field}" string`);
+    error.statusCode = 400;
+    throw error;
+  }
+  return value.trim();
+}
+
+function stampedUser() {
+  // Lazy require: identity reads config/db at load, and presence must stay
+  // importable in tests that stub neither.
+  try {
+    return require('../workspace/identity').userId() || null;
+  } catch {
+    return null;
+  }
+}
+
+function peersOf(resource) {
+  const peers = channels.get(resource);
+  return peers ? Array.from(peers.values()) : [];
+}
+
+function broadcast(resource) {
+  emitter.emit('presence', { resource, peers: peersOf(resource) });
+}
+
+function ensureSweeper() {
+  if (sweepTimer) return;
+  sweepTimer = setInterval(() => {
+    const cutoff = Date.now() - PRESENCE_TTL_MS;
+    for (const [resource, peers] of channels) {
+      let changed = false;
+      for (const [session, entry] of peers) {
+        if (entry.at < cutoff) {
+          peers.delete(session);
+          changed = true;
+        }
+      }
+      if (peers.size === 0) channels.delete(resource);
+      if (changed) broadcast(resource);
+    }
+    // An empty lane must not tick: the timer exists only while peers do.
+    if (channels.size === 0) {
+      clearInterval(sweepTimer);
+      sweepTimer = null;
+    }
+  }, SWEEP_INTERVAL_MS);
+  if (typeof sweepTimer.unref === 'function') sweepTimer.unref();
+}
+
+/**
+ * Publish one binding's presence on a resource. `blob` is the surface's
+ * opaque position state (may be null — present without a position);
+ * `active` marks input activity, so chrome can render idle separately from
+ * gone. Re-publishing is the heartbeat: it is the only way to stay present.
+ */
+function updatePresence(input) {
+  const resource = requireString(input?.resource, 'resource');
+  const session = requireString(input?.session, 'session');
+  const blob = input?.blob === undefined ? null : input.blob;
+  if (blob !== null && JSON.stringify(blob).length > MAX_BLOB_JSON_BYTES) {
+    const error = new Error('presence blob exceeds the ephemeral lane size limit');
+    error.statusCode = 413;
+    throw error;
+  }
+
+  const now = Date.now();
+  let peers = channels.get(resource);
+  if (!peers) {
+    peers = new Map();
+    channels.set(resource, peers);
+  }
+  const previous = peers.get(session);
+  peers.set(session, {
+    session,
+    user: stampedUser(),
+    blob,
+    at: now,
+    activeAt: input?.active ? now : (previous?.activeAt ?? now),
+  });
+  ensureSweeper();
+  broadcast(resource);
+  return { resource, session, peers: peers.size };
+}
+
+/** Explicit goodbye for one binding on one resource. */
+function leavePresence(input) {
+  const resource = requireString(input?.resource, 'resource');
+  const session = requireString(input?.session, 'session');
+  const peers = channels.get(resource);
+  if (!peers || !peers.delete(session)) return { resource, session, peers: peers?.size ?? 0 };
+  if (peers.size === 0) channels.delete(resource);
+  broadcast(resource);
+  return { resource, session, peers: peers?.size ?? 0 };
+}
+
+/**
+ * A session's connection died: remove it from every resource it was present
+ * on. The stream teardown calls this — the "dead connection" layer between
+ * the clean goodbye and TTL expiry.
+ */
+function evictSession(session) {
+  if (typeof session !== 'string' || !session) return;
+  for (const [resource, peers] of Array.from(channels)) {
+    if (!peers.delete(session)) continue;
+    if (peers.size === 0) channels.delete(resource);
+    broadcast(resource);
+  }
+}
+
+/**
+ * Current state as broadcast frames — sent to a stream on connect so a late
+ * joiner sees existing peers immediately instead of waiting out their next
+ * heartbeat. Empty resources produce nothing.
+ */
+function snapshotFrames() {
+  return Array.from(channels.keys(), (resource) => ({ resource, peers: peersOf(resource) }));
+}
+
+function subscribePresence(callback) {
+  emitter.on('presence', callback);
+  return () => emitter.off('presence', callback);
+}
+
+module.exports = {
+  PRESENCE_TTL_MS,
+  evictSession,
+  leavePresence,
+  snapshotFrames,
+  subscribePresence,
+  updatePresence,
+};

package/runtime/scripts/amalgm-mcp/state/promotions.js

@@ -314,10 +314,20 @@ function getPromotion(promotionId, options = {}) {
   );
 }
 
+/** The one durable promotion request for a resource, if any. */
+function getPromotionByResource(resourceId, options = {}) {
+  const database = options.database || openLocalDb();
+  return normalizeRow(
+    cachedStatement(database, 'SELECT * FROM shared_resource_promotions WHERE resource_id = ?')
+      .get(resourceId),
+  );
+}
+
 module.exports = {
   acknowledgePromotion,
   claimPromotions,
   enqueuePromotion,
   failPromotion,
   getPromotion,
+  getPromotionByResource,
 };

package/runtime/scripts/amalgm-mcp/state/rest.js

@@ -7,6 +7,7 @@ const {
   subscribeStateEvents,
 } = require('./events');
 const appResources = require('./app-resources');
+const presence = require('./presence');
 
 function sendHandlerError(error, sendJson) {
   const statusCode = Number(error?.statusCode) || 500;
@@ -128,6 +129,21 @@ async function handleDocWrite(body, sendJson) {
   }
 }
 
+// The ephemeral lane's one REST door: publish (the heartbeat) or leave.
+// Identity is stamped server-side in state/presence — the body never
+// carries who you are, only where you are (the opaque surface blob).
+async function handlePresenceUpdate(body, sendJson) {
+  try {
+    if (body?.leave) {
+      sendJson(200, presence.leavePresence(body));
+      return;
+    }
+    sendJson(200, presence.updatePresence(body));
+  } catch (error) {
+    sendHandlerError(error, sendJson);
+  }
+}
+
 async function handleResourceList(sendJson) {
   try {
     sendJson(200, { resources: appResources.listAppResources() });
@@ -158,6 +174,13 @@ function handleStream(req, res, query) {
   // ignored — the snapshot IS the resume point.
   const bootstrap = String(query.bootstrap || '').trim() === '1';
   const after = bootstrap ? 0 : parsePositiveInt(query.after, 0);
+  // The client's binding session, when it has one: ties this connection to
+  // the presence the same session publishes over POST /state/presence, so a
+  // dead stream takes its presence down with it (the layer between the clean
+  // goodbye and TTL expiry). Optional — presence-less clients pass nothing.
+  const presenceSession = typeof query.session === 'string' && query.session.trim()
+    ? query.session.trim()
+    : null;
 
   res.writeHead(200, {
     'Content-Type': 'text/event-stream; charset=utf-8',
@@ -195,12 +218,17 @@ function handleStream(req, res, query) {
   // on a 'close' that never fires is how dead streams pile up.
   let heartbeat = null;
   let unsubscribe = null;
+  let unsubscribePresence = null;
   let tornDown = false;
   const teardown = () => {
     if (tornDown) return;
     tornDown = true;
     if (heartbeat) clearInterval(heartbeat);
     if (unsubscribe) unsubscribe();
+    if (unsubscribePresence) unsubscribePresence();
+    // The connection was the presence: its death removes this session's
+    // entries everywhere, and the broadcast tells every other stream.
+    if (presenceSession) presence.evictSession(presenceSession);
     try {
       res.end();
     } catch {
@@ -265,6 +293,18 @@ function handleStream(req, res, query) {
     }
   }
 
+  // Presence rides the same stream as its own frame type — never through the
+  // event log, never with a seq, invisible to replay/backlog. Current state
+  // goes out first (a late joiner must not wait out other peers' heartbeats),
+  // after the snapshot/backlog so ordered-bootstrap clients have their
+  // snapshot before any presence frame arrives.
+  for (const frame of presence.snapshotFrames()) {
+    writeSafe(() => sendSseControl(res, 'presence', frame));
+  }
+  unsubscribePresence = presence.subscribePresence((frame) => {
+    writeSafe(() => sendSseControl(res, 'presence', frame));
+  });
+
   // A named event (not an SSE comment) so EventSource clients can observe it
   // and detect a silently dead stream, e.g. tunnel frame drops. It doubles as
   // the server-side liveness probe: writing to a dead socket tears down.
@@ -288,6 +328,7 @@ module.exports = {
   handleDocUpdate,
   handleDocWrite,
   handleEvents,
+  handlePresenceUpdate,
   handleResourceEmit,
   handleResourceList,
   handleResourceRegister,

package/runtime/scripts/amalgm-mcp/state/shared-rest.js

@@ -12,7 +12,9 @@ const fs = require('fs');
 
 function sendHandlerError(error, sendJson) {
   const statusCode = Number(error?.statusCode) || 500;
-  sendJson(statusCode, { error: error?.message || 'internal error' });
+  const payload = { error: error?.message || 'internal error' };
+  if (typeof error?.code === 'string' && error.code) payload.code = error.code;
+  sendJson(statusCode, payload);
 }
 
 function parsePositiveInt(value, fallback) {
@@ -71,6 +73,23 @@ async function handleReplicaRehydrate(body, sendJson) {
 
 async function handlePromotionStart(body, sendJson) {
   try {
+    // One owner per file (workspace-sync.md §1). A file tracked by a
+    // repository is git-owned: it syncs through commits on the workspace
+    // rail, and it may join the doc rail only via a future explicit
+    // ownership handoff — never by ambient promotion.
+    if (typeof body?.path === 'string' && body.path) {
+      const owner = await require('../workspace/git').gitOwnerOf(body.path);
+      if (owner) {
+        throw Object.assign(
+          new Error(
+            `${body.path} is git-owned: tracked by the repository at ${owner.toplevel}. `
+            + 'Repository files sync through git (commits are the sync points), not the doc rail. '
+            + 'If this file truly belongs on the rail, untrack it first (git rm --cached <file>).',
+          ),
+          { statusCode: 409, code: 'file_git_owned' },
+        );
+      }
+    }
     const opened = require('./docs').openDoc(body?.path);
     const result = require('./promotions').enqueuePromotion({
       promotionId: body?.promotionId || `prm_${crypto.randomBytes(16).toString('base64url')}`,

package/runtime/scripts/amalgm-mcp/tests/state-presence.test.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { EventEmitter } = require('events');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-presence-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+
+const { closeLocalDb } = require('../state/db');
+const { listEventsAfter } = require('../state/events');
+const presence = require('../state/presence');
+const rest = require('../state/rest');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+function fakeRequest() {
+  return new EventEmitter();
+}
+
+function fakeResponse() {
+  const res = new EventEmitter();
+  res.writes = [];
+  res.destroyed = false;
+  res.writableEnded = false;
+  res.writeHead = () => res;
+  res.write = (chunk) => {
+    res.writes.push(String(chunk));
+    return true;
+  };
+  res.end = () => {
+    res.writableEnded = true;
+  };
+  return res;
+}
+
+function presenceFrames(res) {
+  return res.writes
+    .map((write, index) => (write === 'event: presence\n' ? JSON.parse(res.writes[index + 1].replace(/^data: /, '')) : null))
+    .filter(Boolean);
+}
+
+test('publish → broadcast; leave → removal broadcast; frames replace wholesale', () => {
+  const frames = [];
+  const unsubscribe = presence.subscribePresence((frame) => frames.push(frame));
+
+  presence.updatePresence({ resource: 'doc:t1', session: 'ps_a', blob: { kind: 'text-caret@1', anchor: 1, head: 4 } });
+  presence.updatePresence({ resource: 'doc:t1', session: 'ps_b', blob: null });
+  assert.equal(frames.length, 2);
+  assert.equal(frames[1].peers.length, 2, 'second frame carries the full list');
+
+  presence.leavePresence({ resource: 'doc:t1', session: 'ps_a' });
+  const last = frames[frames.length - 1];
+  assert.deepEqual(last.peers.map((peer) => peer.session), ['ps_b'], 'leave broadcasts the survivor list');
+
+  presence.leavePresence({ resource: 'doc:t1', session: 'ps_b' });
+  assert.equal(frames[frames.length - 1].peers.length, 0, 'last leave broadcasts an empty list');
+  unsubscribe();
+});
+
+test('the lane never touches the durable event log', () => {
+  const before = listEventsAfter(0).length;
+  presence.updatePresence({ resource: 'doc:t2', session: 'ps_x', blob: { p: 1 } });
+  presence.leavePresence({ resource: 'doc:t2', session: 'ps_x' });
+  assert.equal(listEventsAfter(0).length, before, 'presence must not journal');
+});
+
+test('identity cannot ride in the payload: user is stamped server-side', () => {
+  const frames = [];
+  const unsubscribe = presence.subscribePresence((frame) => frames.push(frame));
+  presence.updatePresence({ resource: 'doc:t3', session: 'ps_i', user: 'liar', blob: null });
+  const peer = frames[0].peers[0];
+  assert.notEqual(peer.user, 'liar', 'client-supplied user must be ignored');
+  presence.leavePresence({ resource: 'doc:t3', session: 'ps_i' });
+  unsubscribe();
+});
+
+test('oversized blobs are refused — the lane carries positions, not data', () => {
+  assert.throws(
+    () => presence.updatePresence({ resource: 'doc:t4', session: 'ps_big', blob: { pad: 'x'.repeat(9000) } }),
+    /size limit/,
+  );
+});
+
+test('a stream gets current presence on connect, live frames after, and evicts its session on close', () => {
+  presence.updatePresence({ resource: 'doc:t5', session: 'ps_existing', blob: { at: 1 } });
+
+  const req = fakeRequest();
+  const res = fakeResponse();
+  rest.handleStream(req, res, { session: 'ps_stream' });
+
+  const catchUp = presenceFrames(res);
+  assert.ok(
+    catchUp.some((frame) => frame.resource === 'doc:t5'),
+    'connect must deliver existing presence without waiting for a heartbeat',
+  );
+
+  presence.updatePresence({ resource: 'doc:t5', session: 'ps_stream', blob: { at: 2 } });
+  const live = presenceFrames(res);
+  assert.equal(live[live.length - 1].peers.length, 2, 'live broadcasts reach the open stream');
+
+  // The connection dies → its session's presence goes with it, and the
+  // other streams hear about it (our own subscriber here is torn down).
+  const frames = [];
+  const unsubscribe = presence.subscribePresence((frame) => frames.push(frame));
+  req.emit('close');
+  const after = frames.find((frame) => frame.resource === 'doc:t5');
+  assert.ok(after, 'teardown broadcasts the eviction');
+  assert.deepEqual(after.peers.map((peer) => peer.session), ['ps_existing'], 'only the dead session is evicted');
+
+  presence.leavePresence({ resource: 'doc:t5', session: 'ps_existing' });
+  unsubscribe();
+});
+
+test('presence frames are absent from replay surfaces', () => {
+  presence.updatePresence({ resource: 'doc:t6', session: 'ps_r', blob: null });
+  const req = fakeRequest();
+  const res = fakeResponse();
+  rest.handleStream(req, res, {});
+  const stateFrames = res.writes.filter((write) => write.startsWith('event: state\n'));
+  assert.equal(stateFrames.length, 0, 'no presence rides the durable frame type');
+  req.emit('close');
+  presence.leavePresence({ resource: 'doc:t6', session: 'ps_r' });
+});