@1agh/maude 0.29.0 → 0.31.0

package/apps/studio/test/sync-cold-seed-dedup.test.ts

@@ -0,0 +1,187 @@
+// Concurrent cold-seed de-duplication — F1 regression.
+//
+// RCA: `.ai/logs/rca/issue-collab-cold-seed-tsx-duplication.md`. When TWO
+// dev-servers seed the SAME canvas slug into an EMPTY hub at the SAME instant,
+// each reads `docBody === empty` before the other's `seed-local-up` write has
+// propagated, so both apply their (identical) body. Two `applyHtmlToDoc`
+// insertions from two Yjs clientIDs into one Y.Text are NOT content-deduped by
+// the CRDT — the body doubled (two `export default`), failing the canvas build.
+//
+// The fix elects a single writer (`syncMeta.seededBy` — Y.Map LWW converges it
+// to ONE clientID on every peer) which, inside a bounded post-seed window,
+// re-applies the canonical body so `applyHtmlToDoc`'s diff deletes the trailing
+// duplicate. These tests pin: (1) simultaneous seed → one copy, (2) a fresh peer
+// booting against an already-doubled hub recovers, (3) the sequential control
+// stays clean (no over-eager collapse of legitimately-adopted state).
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import * as Y from 'yjs';
+
+import { type CanvasSyncAgent, createCanvasSyncAgent } from '../sync/agent.ts';
+import { htmlFromDoc } from '../sync/codec.ts';
+import { createEchoGuard } from '../sync/echo-guard.ts';
+
+// A realistic canvas body — the un-buildable failure is `export default` × 2.
+const BODY = [
+  'import { DesignCanvas } from "@maude/canvas-lib";',
+  'export default function Screen() {',
+  '  return <DesignCanvas><h1>Shared draft</h1></DesignCanvas>;',
+  '}',
+  '',
+].join('\n');
+
+const TRANSPORT = Symbol('transport');
+
+let dirA: string;
+let dirB: string;
+let docA: Y.Doc;
+let docB: Y.Doc;
+let agentA: CanvasSyncAgent | undefined;
+let agentB: CanvasSyncAgent | undefined;
+
+function pathsFor(dir: string) {
+  return {
+    html: join(dir, 'screen.tsx'),
+    comments: join(dir, '_comments', 'screen.json'),
+    annotations: join(dir, 'screen.annotations.svg'),
+  };
+}
+
+function writeLocalBody(dir: string, body: string): void {
+  // Seed disk before the agent reconciles (the local side of the cold start).
+  writeFileSync(pathsFor(dir).html, body);
+}
+
+function makeAgent(doc: Y.Doc, dir: string): CanvasSyncAgent {
+  const a = createCanvasSyncAgent({
+    slug: 'screen',
+    doc,
+    paths: pathsFor(dir),
+    echoGuard: createEchoGuard(),
+    flushMs: 0, // synchronous flush via queueMicrotask
+  });
+  a.start();
+  return a;
+}
+
+/** Bidirectional full-state exchange, looped until the de-dup repair (which
+ *  fires synchronously inside applyUpdate) has propagated + settled. */
+function syncDocs(d1: Y.Doc, d2: Y.Doc, rounds = 6): void {
+  for (let i = 0; i < rounds; i++) {
+    Y.applyUpdate(d2, Y.encodeStateAsUpdate(d1), TRANSPORT);
+    Y.applyUpdate(d1, Y.encodeStateAsUpdate(d2), TRANSPORT);
+  }
+}
+
+beforeEach(() => {
+  dirA = mkdtempSync(join(tmpdir(), 'cold-seed-a-'));
+  dirB = mkdtempSync(join(tmpdir(), 'cold-seed-b-'));
+  docA = new Y.Doc();
+  docB = new Y.Doc();
+});
+
+afterEach(() => {
+  agentA?.stop();
+  agentB?.stop();
+  agentA = undefined;
+  agentB = undefined;
+  rmSync(dirA, { recursive: true, force: true });
+  rmSync(dirB, { recursive: true, force: true });
+});
+
+describe('concurrent cold-seed → single body', () => {
+  test('two peers seed identical bodies into an empty hub at once → ONE copy', async () => {
+    writeLocalBody(dirA, BODY);
+    writeLocalBody(dirB, BODY);
+    agentA = makeAgent(docA, dirA);
+    agentB = makeAgent(docB, dirB);
+
+    // The race: BOTH reconcile against an empty doc before either propagates.
+    await agentA.reconcile();
+    await agentB.reconcile();
+
+    // Hub merges both seeds — the moment the duplication would surface.
+    syncDocs(docA, docB);
+
+    // Both docs converge to exactly ONE copy (no doubled `export default`).
+    expect(htmlFromDoc(docA)).toBe(BODY);
+    expect(htmlFromDoc(docB)).toBe(BODY);
+    // And the count of `export default` is 1 — the build-breaking signature gone.
+    expect(htmlFromDoc(docA).match(/export default/g)?.length).toBe(1);
+
+    // Disk on both peers mirrors the single copy.
+    await agentA.flush();
+    await agentB.flush();
+    expect(readFileSync(pathsFor(dirA).html, 'utf8')).toBe(BODY);
+    expect(readFileSync(pathsFor(dirB).html, 'utf8')).toBe(BODY);
+  });
+
+  test('adopt-mode concurrent seed also self-heals to one copy', async () => {
+    writeLocalBody(dirA, BODY);
+    writeLocalBody(dirB, BODY);
+    agentA = createCanvasSyncAgent({
+      slug: 'screen',
+      doc: docA,
+      paths: pathsFor(dirA),
+      echoGuard: createEchoGuard(),
+      flushMs: 0,
+      adopt: true,
+    });
+    agentB = createCanvasSyncAgent({
+      slug: 'screen',
+      doc: docB,
+      paths: pathsFor(dirB),
+      echoGuard: createEchoGuard(),
+      flushMs: 0,
+      adopt: true,
+    });
+    agentA.start();
+    agentB.start();
+
+    await agentA.reconcile();
+    await agentB.reconcile();
+    syncDocs(docA, docB);
+
+    expect(htmlFromDoc(docA)).toBe(BODY);
+    expect(htmlFromDoc(docB)).toBe(BODY);
+  });
+});
+
+describe('recovery of an already-duplicated hub (requirement #3)', () => {
+  test('a peer booting against a doubled doc collapses it on reconcile', async () => {
+    writeLocalBody(dirA, BODY);
+    // Simulate a hub that already concatenated two identical seeds.
+    const t = docA.getText('html');
+    t.insert(0, BODY);
+    t.insert(BODY.length, BODY);
+    expect(htmlFromDoc(docA)).toBe(BODY + BODY);
+
+    agentA = makeAgent(docA, dirA);
+    await agentA.reconcile();
+
+    expect(htmlFromDoc(docA)).toBe(BODY);
+    expect(htmlFromDoc(docA).match(/export default/g)?.length).toBe(1);
+  });
+});
+
+describe('sequential control — no over-eager collapse', () => {
+  test('B joining after A seeded adopts the single copy (no duplication)', async () => {
+    writeLocalBody(dirA, BODY);
+    writeLocalBody(dirB, BODY);
+    agentA = makeAgent(docA, dirA);
+    agentB = makeAgent(docB, dirB);
+
+    // A seeds first and FULLY propagates before B reconciles.
+    await agentA.reconcile();
+    syncDocs(docA, docB);
+    // B now sees the hub already holds the body → noop (adopt), no second seed.
+    await agentB.reconcile();
+    syncDocs(docA, docB);
+
+    expect(htmlFromDoc(docA)).toBe(BODY);
+    expect(htmlFromDoc(docB)).toBe(BODY);
+  });
+});

package/apps/studio/test/sync-cold-start.test.ts

@@ -0,0 +1,304 @@
+// Cold-start decision matrix — hub-sync cold-start safety (DDR-102).
+//
+// Exhaustive table over (local: absent/empty/clean/diverged) × (doc:
+// empty/same/different) × (journal: absent/match/stale), plus both winner
+// directions and the null-timestamp fallbacks. Mirrors the table style of
+// sync-codec.test.ts: every case is a row with explicit inputs + expected
+// action.
+
+import { describe, expect, test } from 'bun:test';
+
+import { type ColdStartInput, decideColdStart, isExactRepeat } from '../sync/cold-start.ts';
+import { hashBytes } from '../sync/echo-guard.ts';
+
+const BODY_LOCAL = '<div>local work — a day of mascot edits</div>';
+const BODY_HUB = '<div>hub state</div>';
+
+/** Convenience: build an input with safe defaults, override per case. */
+function input(over: Partial<ColdStartInput>): ColdStartInput {
+  return {
+    localBody: null,
+    docBody: '',
+    journalHash: null,
+    localMtimeMs: null,
+    docBodyEditAtMs: null,
+    ...over,
+  };
+}
+
+describe('decideColdStart — empty/absent sides', () => {
+  test('local absent + doc empty → noop', () => {
+    expect(decideColdStart(input({})).action).toBe('noop');
+  });
+
+  test('local empty-string + doc empty → noop', () => {
+    expect(decideColdStart(input({ localBody: '' })).action).toBe('noop');
+  });
+
+  test('whitespace-only local counts as empty (mirrors the trim guard)', () => {
+    const d = decideColdStart(input({ localBody: '  \n\t ', docBody: BODY_HUB }));
+    expect(d.action).toBe('materialize-hub');
+  });
+
+  test('local absent + doc non-empty → materialize-hub (clean first sync)', () => {
+    const d = decideColdStart(input({ docBody: BODY_HUB }));
+    expect(d.action).toBe('materialize-hub');
+  });
+
+  test('local empty + doc non-empty → materialize-hub', () => {
+    const d = decideColdStart(input({ localBody: '', docBody: BODY_HUB }));
+    expect(d.action).toBe('materialize-hub');
+  });
+
+  test('local non-empty + doc empty → seed-local-up (DDR-064 guard as a named case)', () => {
+    const d = decideColdStart(input({ localBody: BODY_LOCAL, docBody: '' }));
+    expect(d.action).toBe('seed-local-up');
+  });
+
+  test('local non-empty + whitespace-only doc → seed-local-up', () => {
+    const d = decideColdStart(input({ localBody: BODY_LOCAL, docBody: ' \n ' }));
+    expect(d.action).toBe('seed-local-up');
+  });
+
+  test('seed-local-up holds regardless of journal state (stale journal must not block it)', () => {
+    const d = decideColdStart(
+      input({ localBody: BODY_LOCAL, docBody: '', journalHash: 'stale-hash' })
+    );
+    expect(d.action).toBe('seed-local-up');
+  });
+});
+
+describe('decideColdStart — identical sides', () => {
+  test('local == doc → noop (caller records journal)', () => {
+    const d = decideColdStart(input({ localBody: BODY_HUB, docBody: BODY_HUB }));
+    expect(d.action).toBe('noop');
+  });
+
+  test('local == doc with a stale journal is still a noop (content equality wins)', () => {
+    const d = decideColdStart(
+      input({ localBody: BODY_HUB, docBody: BODY_HUB, journalHash: 'stale' })
+    );
+    expect(d.action).toBe('noop');
+  });
+});
+
+describe('decideColdStart — concurrent cold-seed duplication (F1)', () => {
+  const BODY = '<div>export default fn — one copy</div>';
+
+  test('doc == local repeated twice → recover-seed-dup (collapse, not conflict)', () => {
+    const d = decideColdStart(input({ localBody: BODY, docBody: BODY + BODY }));
+    expect(d.action).toBe('recover-seed-dup');
+  });
+
+  test('doc == local repeated three times (3-way seed) → recover-seed-dup', () => {
+    const d = decideColdStart(input({ localBody: BODY, docBody: BODY.repeat(3) }));
+    expect(d.action).toBe('recover-seed-dup');
+  });
+
+  test('duplication recovery beats the conflict path even with divergent timestamps', () => {
+    // A doubled body is NOT new content — newest-wins must not get to pick it.
+    const d = decideColdStart(
+      input({
+        localBody: BODY,
+        docBody: BODY + BODY,
+        localMtimeMs: 1_000,
+        docBodyEditAtMs: 9_999,
+      })
+    );
+    expect(d.action).toBe('recover-seed-dup');
+  });
+
+  test('duplication recovery fires even with a stale journal', () => {
+    const d = decideColdStart(
+      input({ localBody: BODY, docBody: BODY + BODY, journalHash: 'stale' })
+    );
+    expect(d.action).toBe('recover-seed-dup');
+  });
+
+  test('doc = local + genuinely different bytes is NOT a repeat → conflict (snapshots both)', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY,
+        docBody: `${BODY}<div>a real concurrent edit</div>`,
+        localMtimeMs: 2_000,
+        docBodyEditAtMs: 1_000,
+      })
+    );
+    expect(d.action).toBe('conflict');
+  });
+
+  test('exact equality (×1) stays a noop, never recover-seed-dup', () => {
+    expect(decideColdStart(input({ localBody: BODY, docBody: BODY })).action).toBe('noop');
+  });
+
+  test('isExactRepeat — exact multiples only', () => {
+    expect(isExactRepeat(BODY + BODY, BODY)).toBe(true);
+    expect(isExactRepeat(BODY.repeat(4), BODY)).toBe(true);
+    expect(isExactRepeat(BODY, BODY)).toBe(false); // ×1 is equality, not duplication
+    expect(isExactRepeat(`${BODY}x`, BODY)).toBe(false); // not a clean multiple
+    expect(isExactRepeat(`${BODY}${BODY}x`, BODY)).toBe(false);
+    expect(isExactRepeat('', BODY)).toBe(false);
+    expect(isExactRepeat(BODY, '')).toBe(false);
+  });
+});
+
+describe('decideColdStart — journal-gated fast-forward', () => {
+  test('local ≠ doc, journal matches hash(local) → fast-forward-hub (no conflict)', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        journalHash: hashBytes(BODY_LOCAL),
+      })
+    );
+    expect(d.action).toBe('fast-forward-hub');
+    expect(d.winner).toBeUndefined();
+  });
+
+  test('journal match overrides timestamps — even a NEWER local mtime fast-forwards', () => {
+    // mtime newer than the doc stamp, but the bytes are exactly what we last
+    // synced (e.g. touch / checkout changed mtime only) → not a conflict.
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        journalHash: hashBytes(BODY_LOCAL),
+        localMtimeMs: 2_000,
+        docBodyEditAtMs: 1_000,
+      })
+    );
+    expect(d.action).toBe('fast-forward-hub');
+  });
+});
+
+describe('decideColdStart — divergence (conflict + newest-wins)', () => {
+  test('journal ABSENT, local newer → conflict, winner=local (the incident shape)', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        localMtimeMs: 2_000,
+        docBodyEditAtMs: 1_000,
+      })
+    );
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('local');
+  });
+
+  test('journal ABSENT, doc newer → conflict, winner=hub', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        localMtimeMs: 1_000,
+        docBodyEditAtMs: 2_000,
+      })
+    );
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('hub');
+  });
+
+  test('journal STALE (≠ hash(local)), local newer → conflict, winner=local', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        journalHash: hashBytes('<div>some older synced state</div>'),
+        localMtimeMs: 5_000,
+        docBodyEditAtMs: 4_000,
+      })
+    );
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('local');
+  });
+
+  test('journal STALE, doc newer → conflict, winner=hub', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        journalHash: hashBytes('<div>some older synced state</div>'),
+        localMtimeMs: 4_000,
+        docBodyEditAtMs: 5_000,
+      })
+    );
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('hub');
+  });
+
+  test('journal matching hash(DOC) — not local — is still divergence', () => {
+    // The journal proves we once synced what the HUB now holds reverted to;
+    // local moved past it → local is unreconciled work, must conflict.
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        journalHash: hashBytes(BODY_HUB),
+        localMtimeMs: 2_000,
+        docBodyEditAtMs: 1_000,
+      })
+    );
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('local');
+  });
+
+  test('doc stamp NULL (older peer never stamped) → hub-wins fallback', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        localMtimeMs: 2_000,
+        docBodyEditAtMs: null,
+      })
+    );
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('hub');
+  });
+
+  test('local mtime NULL → hub-wins fallback', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        localMtimeMs: null,
+        docBodyEditAtMs: 2_000,
+      })
+    );
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('hub');
+  });
+
+  test('both timestamps NULL → hub-wins fallback', () => {
+    const d = decideColdStart(input({ localBody: BODY_LOCAL, docBody: BODY_HUB }));
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('hub');
+  });
+
+  test('timestamps TIED → hub-wins fallback', () => {
+    const d = decideColdStart(
+      input({
+        localBody: BODY_LOCAL,
+        docBody: BODY_HUB,
+        localMtimeMs: 1_000,
+        docBodyEditAtMs: 1_000,
+      })
+    );
+    expect(d.action).toBe('conflict');
+    expect(d.winner).toBe('hub');
+  });
+
+  test('every decision carries a human-readable reason', () => {
+    const cases: ColdStartInput[] = [
+      input({}),
+      input({ docBody: BODY_HUB }),
+      input({ localBody: BODY_LOCAL }),
+      input({ localBody: BODY_HUB, docBody: BODY_HUB }),
+      input({ localBody: BODY_LOCAL, docBody: BODY_HUB, journalHash: hashBytes(BODY_LOCAL) }),
+      input({ localBody: BODY_LOCAL, docBody: BODY_HUB }),
+    ];
+    for (const c of cases) {
+      const d = decideColdStart(c);
+      expect(d.reason.length).toBeGreaterThan(0);
+    }
+  });
+});

package/apps/studio/test/sync-connection-state.test.ts

@@ -144,3 +144,71 @@ describe('connection monitor', () => {
     expect(changes.length).toBe(before); // no offline transition fired
   });
 });
+
+// DDR-102 — per-doc states + real lastSyncAt.
+describe('connection monitor — per-doc states (DDR-102)', () => {
+  test('noteDocState rolls up into docs counts + rejectedSlugs', () => {
+    const { monitor } = makeMonitor();
+    monitor.noteDocState('ui-a', 'pending');
+    monitor.noteDocState('ui-b', 'connected');
+    monitor.noteDocState('ui-c', 'auth-rejected');
+    monitor.noteDocState('ui-d', 'auth-rejected');
+
+    const snap = monitor.snapshot();
+    expect(snap.docs).toEqual({ synced: 1, pending: 1, rejected: 2 });
+    expect(snap.rejectedSlugs?.sort()).toEqual(['ui-c', 'ui-d']);
+  });
+
+  test('doc state transitions update the rollup (rejected → connected after re-link)', () => {
+    const { monitor, changes } = makeMonitor();
+    monitor.noteDocState('ui-a', 'auth-rejected');
+    expect(monitor.snapshot().docs?.rejected).toBe(1);
+    monitor.noteDocState('ui-a', 'connected');
+    const snap = monitor.snapshot();
+    expect(snap.docs).toEqual({ synced: 1, pending: 0, rejected: 0 });
+    expect(snap.rejectedSlugs).toEqual([]);
+    // Each transition emitted (no-op repeats don't).
+    const emitted = changes.length;
+    monitor.noteDocState('ui-a', 'connected');
+    expect(changes.length).toBe(emitted);
+  });
+
+  test('rejectedSlugs caps at 20 while docs.rejected carries the true count', () => {
+    const { monitor } = makeMonitor();
+    for (let i = 0; i < 25; i++) monitor.noteDocState(`ui-${i}`, 'auth-rejected');
+    const snap = monitor.snapshot();
+    expect(snap.docs?.rejected).toBe(25);
+    expect(snap.rejectedSlugs).toHaveLength(20);
+  });
+
+  test('noteSyncActivity sets lastSyncAt to now and promotes a pending doc', () => {
+    const { clock, monitor } = makeMonitor();
+    monitor.noteDocState('ui-a', 'pending');
+    expect(monitor.snapshot().lastSyncAt).toBeNull();
+
+    clock.advance(5_000);
+    monitor.noteSyncActivity('ui-a');
+    const snap = monitor.snapshot();
+    expect(snap.lastSyncAt).toBe(clock.now());
+    expect(snap.docs?.synced).toBe(1);
+    expect(snap.docs?.pending).toBe(0);
+  });
+
+  test('noteSyncActivity does NOT resurrect an auth-rejected doc', () => {
+    const { monitor } = makeMonitor();
+    monitor.noteDocState('ui-a', 'auth-rejected');
+    monitor.noteSyncActivity('ui-a');
+    expect(monitor.snapshot().docs?.rejected).toBe(1);
+    expect(monitor.snapshot().lastSyncAt).not.toBeNull();
+  });
+
+  test('lastSyncAt advances on repeated activity (real activity, not just transitions)', () => {
+    const { clock, monitor } = makeMonitor();
+    monitor.noteDocState('ui-a', 'connected');
+    monitor.noteSyncActivity('ui-a');
+    const first = monitor.snapshot().lastSyncAt;
+    clock.advance(10_000);
+    monitor.noteSyncActivity('ui-a');
+    expect(monitor.snapshot().lastSyncAt).toBe((first as number) + 10_000);
+  });
+});

package/apps/studio/test/sync-hardening.test.ts

@@ -54,25 +54,19 @@ describe('DDR-054 §2a — CI environment gate', () => {
     savedCi = process.env.CI;
     savedGha = process.env.GITHUB_ACTIONS;
     savedOverride = process.env.MAUDE_SYNC_IN_CI;
-    // biome-ignore lint/performance/noDelete: process.env semantics
     delete process.env.CI;
-    // biome-ignore lint/performance/noDelete: process.env semantics
     delete process.env.GITHUB_ACTIONS;
-    // biome-ignore lint/performance/noDelete: process.env semantics
     delete process.env.MAUDE_SYNC_IN_CI;
   });
 
   afterEach(() => {
     if (savedCi === undefined) {
-      // biome-ignore lint/performance/noDelete: process.env semantics
       delete process.env.CI;
     } else process.env.CI = savedCi;
     if (savedGha === undefined) {
-      // biome-ignore lint/performance/noDelete: process.env semantics
       delete process.env.GITHUB_ACTIONS;
     } else process.env.GITHUB_ACTIONS = savedGha;
     if (savedOverride === undefined) {
-      // biome-ignore lint/performance/noDelete: process.env semantics
       delete process.env.MAUDE_SYNC_IN_CI;
     } else process.env.MAUDE_SYNC_IN_CI = savedOverride;
   });
@@ -443,7 +437,6 @@ describe('DDR-054 §2i — auto-clear adopt after first success', () => {
     const savedHubsEnv = process.env.HUBS_CONFIG_PATH;
     process.env.HUBS_CONFIG_PATH = hubsPath;
     const savedCi = process.env.CI;
-    // biome-ignore lint/performance/noDelete: process.env semantics
     delete process.env.CI;
 
     try {
@@ -504,7 +497,6 @@ describe('DDR-054 §2i — auto-clear adopt after first success', () => {
       expect(typeof after.linkedHub.lastAdoptedAt).toBe('number');
     } finally {
       if (savedHubsEnv === undefined) {
-        // biome-ignore lint/performance/noDelete: process.env semantics
         delete process.env.HUBS_CONFIG_PATH;
       } else process.env.HUBS_CONFIG_PATH = savedHubsEnv;
       if (savedCi !== undefined) process.env.CI = savedCi;

package/apps/studio/test/sync-hubs-config.test.ts

@@ -21,7 +21,6 @@ beforeEach(() => {
 afterEach(() => {
   // Node's process.env stringifies on assignment; assigning undefined yields
   // the literal string "undefined". delete is the correct restoration.
-  // biome-ignore lint/performance/noDelete: process.env semantics.
   if (savedEnv === undefined) delete process.env.HUBS_CONFIG_PATH;
   else process.env.HUBS_CONFIG_PATH = savedEnv;
   rmSync(dir, { recursive: true, force: true });