@1agh/maude 1.0.9 → 1.2.0

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

@@ -1,262 +0,0 @@
-// The one rule both sync surfaces read — see sync/presentation.ts.
-//
-// Pins the two SURFACE defects that the monitor-level falsifier
-// (`sync-connect-honesty.test.ts`) deliberately leaves alone:
-//   - a link with refusals reading green, because the old status bar keyed off
-//     `state` and never looked at `docs` at all;
-//   - the status bar and the connect note being able to disagree, because they
-//     were two rules over one payload.
-//
-// Every row of the plan's states/copy table gets a case, and each asserts the
-// state names a NEXT ACTION where one exists — the user's explicit ask.
-
-import { describe, expect, test } from 'bun:test';
-
-import { type SyncStatusLike, syncPresentation } from '../sync/presentation.ts';
-
-const base: SyncStatusLike = {
-  state: 'online',
-  queuedOps: 0,
-  lastSyncAt: null,
-  offlineSince: null,
-  flash: null,
-  updatedAt: 0,
-};
-
-const at = (over: SyncStatusLike) =>
-  syncPresentation({ ...base, ...over }, { project: 'alligators' });
-
-describe('nothing to say', () => {
-  test('an unlinked project has no hub status', () => {
-    expect(syncPresentation({ linked: false })).toBeNull();
-    expect(syncPresentation(null)).toBeNull();
-  });
-});
-
-describe('the states a person passes through', () => {
-  test('connecting — no document has settled yet', () => {
-    const p = at({ state: 'connecting', docs: { synced: 0, pending: 3, rejected: 0 } });
-    expect(p?.phase).toBe('connecting');
-    expect(p?.online).toBe(false);
-    expect(p?.title).toContain('Connecting to alligators');
-  });
-
-  test('syncing — visible progress, with a real count', () => {
-    const p = at({ docs: { synced: 40, pending: 35, rejected: 0 } });
-    expect(p?.phase).toBe('syncing');
-    expect(p?.online).toBe(false);
-    expect(p?.label).toBe('40/75');
-    expect(p?.title).toContain('40 of 75');
-  });
-
-  test('synced — and names what arrived, without telling you to open it', () => {
-    const p = at({
-      docs: { synced: 75, pending: 0, rejected: 0 },
-      pulled: { names: ['ui-welcome', 'ui-how-to'], count: 2 },
-    });
-    expect(p?.phase).toBe('synced');
-    expect(p?.online).toBe(true);
-    expect(p?.title).toContain('2 came down');
-    // Names the fact; the decision to open hub-authored TSX stays the person's.
-    expect(p?.next).toContain('new to this machine');
-    expect(p?.next).not.toContain('Open one');
-    expect(p?.names).toEqual(['ui-welcome', 'ui-how-to']);
-  });
-
-  test('synced with nothing pulled has no next action — because there is none', () => {
-    const p = at({ docs: { synced: 5, pending: 0, rejected: 0 } });
-    expect(p?.phase).toBe('synced');
-    expect(p?.next).toBeNull();
-  });
-});
-
-describe('the states that used to read green', () => {
-  test('a hub that refuses everything is not synced', () => {
-    // THE surface defect: `state` is 'online' (a socket exists, the hub is
-    // reachable) while every document's edits go nowhere. The old status bar
-    // showed a green dot and the word "synced" here.
-    const p = at({ state: 'online', docs: { synced: 0, pending: 0, rejected: 75 } });
-    expect(p?.phase).toBe('refused');
-    expect(p?.online).toBe(false);
-    expect(p?.label).toBe('75 refused');
-    expect(p?.next).toContain('Reconnect');
-  });
-
-  test('a partial refusal is reported, not averaged away', () => {
-    const p = at({ state: 'online', docs: { synced: 72, pending: 0, rejected: 3 } });
-    expect(p?.phase).toBe('refused');
-    expect(p?.title).toContain('3 of 75');
-  });
-
-  test('an unreachable hub outranks a stale count', () => {
-    const p = at({ state: 'offline', queuedOps: 4, docs: { synced: 75, pending: 0, rejected: 0 } });
-    expect(p?.phase).toBe('offline');
-    expect(p?.online).toBe(false);
-    expect(p?.label).toBe('offline · 4 ↑');
-    expect(p?.next).toContain('resumes by itself');
-  });
-});
-
-describe('payloads that predate the counts', () => {
-  test('an old payload falls back to state without inventing document facts', () => {
-    const p = at({ state: 'online', docs: undefined });
-    expect(p?.phase).toBe('synced');
-    expect(p?.title).not.toContain('canvas');
-  });
-
-  test('a linked project with zero known documents reads as connecting, not synced', () => {
-    const p = at({ state: 'online', docs: { synced: 0, pending: 0, rejected: 0 } });
-    expect(p?.phase).toBe('connecting');
-    expect(p?.online).toBe(false);
-  });
-
-  test('nothing syncable keeps its own honest copy and names the move', () => {
-    const p = syncPresentation({ notSyncable: true, tsxCount: 4, reason: 'No canvases yet.' });
-    expect(p?.phase).toBe('nothing-syncable');
-    expect(p?.label).toBe('0 syncable · 4 tsx');
-    expect(p?.next).toContain('Create a canvas');
-  });
-});
-
-describe('a payload it cannot read is not a payload that says everything is fine', () => {
-  // `/_sync-status` returns JSON.parse of `_sync.json` with NO schema, so the
-  // input here is whatever is on disk — a partial write, an older producer, a
-  // newer one. `synced` used to be the fall-through, which made the reassuring
-  // answer the only reachable one for every shape not recognised.
-  test('an empty docs object does not render as "all NaN canvases", green', () => {
-    const p = at({ state: 'online', docs: {} as never });
-    expect(p?.phase).not.toBe('synced');
-    expect(p?.online).toBe(false);
-    expect(p?.title).not.toContain('NaN');
-  });
-
-  test('negative, fractional and non-numeric counts all fail closed', () => {
-    for (const docs of [
-      { synced: 5, pending: -5, rejected: 0 },
-      { synced: 1, pending: null, rejected: 0 },
-      { synced: 1.5, pending: 0, rejected: 0 },
-      { synced: '75', pending: 0, rejected: 0 },
-    ] as never[]) {
-      const p = at({ state: 'online', docs });
-      expect(p?.online).toBe(false);
-      expect(p?.phase).not.toBe('synced');
-    }
-  });
-
-  test('an absent docs field is still the old-payload path, not "unreadable"', () => {
-    // Absent and malformed are different facts and must not collapse.
-    const p = at({ state: 'online', docs: undefined });
-    expect(p?.phase).toBe('synced');
-  });
-
-  test('a wild pulled count cannot reach the sentence', () => {
-    const p = at({
-      docs: { synced: 1, pending: 0, rejected: 0 },
-      pulled: { names: [], count: 1e9 } as never,
-    });
-    expect(p?.title).not.toContain('1000000000');
-  });
-});
-
-describe('hub-supplied text is untrusted (DDR-054)', () => {
-  test('counts come first and names are capped in number', () => {
-    const p = at({
-      state: 'online',
-      docs: { synced: 0, pending: 0, rejected: 9 },
-      rejectedSlugs: ['a', 'b', 'c', 'd', 'e'],
-    });
-    expect(p?.names).toHaveLength(3);
-    // The label a hostile name could otherwise dominate carries no name at all.
-    expect(p?.label).toBe('9 refused');
-  });
-
-  test('a long project name cannot run away with the sentence', () => {
-    const p = syncPresentation(
-      { ...base, docs: { synced: 1, pending: 0, rejected: 0 } },
-      { project: 'x'.repeat(500) }
-    );
-    expect(p?.title.length).toBeLessThan(200);
-  });
-
-  test('names survive being absent or empty', () => {
-    const p = at({ state: 'online', docs: { synced: 0, pending: 0, rejected: 2 } });
-    expect(p?.names).toEqual([]);
-  });
-});
-
-describe('zero progress has a deadline — the stalled phase', () => {
-  const NOW = 10 * 60_000; // 10 minutes after the epoch-zero base
-
-  test('connecting past the ceiling with nothing synced becomes stalled, with the move named', () => {
-    const p = syncPresentation(
-      { ...base, state: 'connecting', startedAt: 1, docs: { synced: 0, pending: 73, rejected: 0 } },
-      { project: 'alligators', now: NOW }
-    );
-    expect(p?.phase).toBe('stalled');
-    expect(p?.online).toBe(false);
-    expect(p?.title).toContain('Nothing has synced');
-    expect(p?.next).toContain('Reconnect');
-  });
-
-  test('a fresh connect is NOT stalled — the handshake gets its moment', () => {
-    const p = syncPresentation(
-      { ...base, state: 'connecting', startedAt: 1, docs: { synced: 0, pending: 73, rejected: 0 } },
-      { project: 'alligators', now: 30_000 }
-    );
-    expect(p?.phase).toBe('connecting');
-  });
-
-  test('any progress at all cancels the stall — syncing is not stalling', () => {
-    const p = syncPresentation(
-      { ...base, startedAt: 1, docs: { synced: 1, pending: 72, rejected: 0 } },
-      { project: 'alligators', now: NOW }
-    );
-    expect(p?.phase).toBe('syncing');
-  });
-
-  test('zero known documents past the ceiling also stalls', () => {
-    const p = syncPresentation(
-      { ...base, state: 'connecting', startedAt: 1, docs: { synced: 0, pending: 0, rejected: 0 } },
-      { project: 'alligators', now: NOW }
-    );
-    expect(p?.phase).toBe('stalled');
-  });
-
-  test('an old payload without startedAt can never stall (fail open to connecting)', () => {
-    const p = syncPresentation(
-      { ...base, state: 'connecting' },
-      { project: 'alligators', now: NOW }
-    );
-    expect(p?.phase).toBe('connecting');
-  });
-
-  test('a refusal still outranks a stall — the more specific cause wins', () => {
-    const p = syncPresentation(
-      { ...base, startedAt: 1, docs: { synced: 0, pending: 0, rejected: 73 } },
-      { project: 'alligators', now: NOW }
-    );
-    expect(p?.phase).toBe('refused');
-  });
-
-  test('an unreachable hub still outranks a stall — offline explains itself', () => {
-    const p = syncPresentation(
-      { ...base, state: 'offline', startedAt: 1, docs: { synced: 0, pending: 3, rejected: 0 } },
-      { project: 'alligators', now: NOW }
-    );
-    expect(p?.phase).toBe('offline');
-  });
-
-  test('a garbage startedAt fails open, never into a false alarm', () => {
-    const p = syncPresentation(
-      // biome-ignore lint/suspicious/noExplicitAny: hostile-payload shape test
-      {
-        ...base,
-        state: 'connecting',
-        startedAt: 'yes' as any,
-        docs: { synced: 0, pending: 1, rejected: 0 },
-      },
-      { project: 'alligators', now: NOW }
-    );
-    expect(p?.phase).toBe('connecting');
-  });
-});

package/apps/studio/test/sync-pull-budget.test.ts

@@ -1,169 +0,0 @@
-// F6 — the aggregate per-pass byte budget on the downward lanes (Sync v2
-// Increment 0, DDR-226 §9).
-//
-// The gap the Plane-B flip gate named: every lane capped ONE file and the COUNT
-// of files, nothing capped the product. 200 × 512 MB = 100 GB, and the hub
-// chooses both factors. These tests pin that a pass stops on bytes, that it
-// stops LOUDLY, and — the part that matters for an untrusted hub — that a
-// manifest UNDERSTATING a file's size buys no extra transfer.
-
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { pullFiles } from '../sync/file-pull.ts';
-import { createPullBudget, MAX_PULL_BYTES_PER_PASS } from '../sync/pull-budget.ts';
-
-const silent = { log: () => {}, warn: () => {} };
-
-describe('createPullBudget', () => {
-  test('commits what fits and refuses what does not', () => {
-    const b = createPullBudget({ maxBytes: 100, label: 't', log: silent });
-    expect(b.take(60)).toBe(true);
-    expect(b.spent()).toBe(60);
-    expect(b.remaining()).toBe(40);
-    expect(b.take(50)).toBe(false);
-    expect(b.spent()).toBe(60); // a refused charge is not committed
-    expect(b.exhausted()).toBe(true);
-  });
-
-  test('an exact fit is allowed', () => {
-    const b = createPullBudget({ maxBytes: 100, label: 't', log: silent });
-    expect(b.take(100)).toBe(true);
-    expect(b.exhausted()).toBe(false);
-    expect(b.remaining()).toBe(0);
-    expect(b.take(1)).toBe(false);
-  });
-
-  test('a negative or NaN size can never refund budget', () => {
-    const b = createPullBudget({ maxBytes: 100, label: 't', log: silent });
-    expect(b.take(-1_000_000)).toBe(true);
-    expect(b.take(Number.NaN)).toBe(true);
-    expect(b.spent()).toBe(0);
-    expect(b.take(101)).toBe(false);
-  });
-
-  test('the wall is named exactly once, and loudly', () => {
-    const warns: string[] = [];
-    const b = createPullBudget({
-      maxBytes: 10,
-      label: 'sync/files',
-      log: { warn: (m: string) => warns.push(m) },
-    });
-    b.take(20);
-    b.take(20);
-    expect(warns).toHaveLength(1);
-    expect(warns[0]).toContain('[sync/files]');
-    expect(warns[0]).toContain('byte budget');
-    expect(warns[0]).toContain('next pass');
-  });
-
-  test('the default ceiling is the documented 2 GiB', () => {
-    expect(MAX_PULL_BYTES_PER_PASS).toBe(2 * 1024 * 1024 * 1024);
-    const b = createPullBudget({ label: 't', log: silent });
-    expect(b.remaining()).toBe(MAX_PULL_BYTES_PER_PASS);
-  });
-});
-
-describe('file-pull honours the pass budget', () => {
-  const manifest = (files: { path: string; size: number; sha256: string }[]) =>
-    ({
-      files: files.map((f) => ({
-        path: f.path,
-        sha256: f.sha256,
-        size: f.size,
-        mtimeMs: Date.now(),
-        class: 'inert-media',
-      })),
-    }) as const;
-
-  const sha = async (bytes: Uint8Array) =>
-    Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', bytes)))
-      .map((b) => b.toString(16).padStart(2, '0'))
-      .join('');
-
-  test('charges from the manifest BEFORE the request — an over-budget batch costs no transfer', async () => {
-    const dir = mkdtempSync(join(tmpdir(), 'pull-budget-files-'));
-    try {
-      mkdirSync(join(dir, 'assets'), { recursive: true });
-      const bytes = new Uint8Array(400);
-      const hash = await sha(bytes);
-      const fetched: string[] = [];
-      const fetchImpl = (async (url: string) => {
-        const u = String(url);
-        if (u.endsWith('/api/files')) {
-          return new Response(
-            JSON.stringify(
-              manifest([
-                { path: 'assets/a.png', size: 400, sha256: hash },
-                { path: 'assets/b.png', size: 400, sha256: hash },
-                { path: 'assets/c.png', size: 400, sha256: hash },
-              ])
-            ),
-            { status: 200 }
-          );
-        }
-        fetched.push(u);
-        return new Response(bytes, { status: 200 });
-      }) as unknown as typeof fetch;
-
-      const out = await pullFiles({
-        designRoot: dir,
-        hubUrl: 'https://hub.example',
-        token: () => 't',
-        allowCodeModules: false,
-        fetchImpl,
-        log: silent,
-        maxPassBytes: 900,
-      });
-
-      expect(out.pulled).toHaveLength(2);
-      expect(out.budgetExhausted).toBe(true);
-      // The third file was never even requested — the manifest priced it.
-      expect(fetched).toHaveLength(2);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test('a manifest that UNDERSTATES a size buys no extra transfer', async () => {
-    const dir = mkdtempSync(join(tmpdir(), 'pull-budget-files-lie-'));
-    try {
-      mkdirSync(join(dir, 'assets'), { recursive: true });
-      const big = new Uint8Array(5_000);
-      const hash = await sha(big);
-      const fetchImpl = (async (url: string) => {
-        const u = String(url);
-        if (u.endsWith('/api/files')) {
-          return new Response(
-            JSON.stringify(
-              // Declares 1 byte; sends 5,000.
-              manifest([{ path: 'assets/lie.png', size: 1, sha256: hash }])
-            ),
-            { status: 200 }
-          );
-        }
-        return new Response(big, { status: 200 });
-      }) as unknown as typeof fetch;
-
-      const out = await pullFiles({
-        designRoot: dir,
-        hubUrl: 'https://hub.example',
-        token: () => 't',
-        allowCodeModules: false,
-        fetchImpl,
-        log: silent,
-        maxPassBytes: 1_000,
-      });
-
-      expect(out.pulled).toEqual([]);
-      expect(out.budgetExhausted).toBe(true);
-      expect(out.failed[0]?.reason).toContain('declared 1 B, sent 5000 B');
-      // And crucially: nothing landed on disk.
-      expect(readdirSync(join(dir, 'assets'))).toEqual([]);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});