@1agh/maude 0.60.3 → 0.60.5

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

@@ -0,0 +1,302 @@
+// Per-lane annotations cold start — the 2026-08-14 annotations eraser.
+//
+// The eraser: annotations used to follow the BODY winner at cold start, and
+// the emptiness guard was `!== ''` — so a hub doc holding the bare 72-byte
+// wrapper (`<svg …></svg>`, a non-empty STRING carrying zero strokes)
+// overwrote a peer's real strokes whenever the hub won the body, taking the
+// `assets/<sha8>` references the asset pull scans with them. Confirmed on
+// alligators: a sidecar committed with two `<image>` strokes at 12:45 was the
+// empty wrapper on every peer two minutes after the next fleet roll.
+//
+// The fix has three parts, each pinned here:
+//   1. `isEmptyAnnotationsSvg` — the wrapper counts as empty.
+//   2. `decideAnnotationsColdStart` — per-lane table; unstamped emptiness
+//      never beats content, stamped delete-all is honored by time.
+//   3. `stampAnnotationsEdit` riding every local→doc annotations apply
+//      (applyFromFs, cold-start seed, adopt) in the same transaction.
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, readFileSync, rmSync, utimesSync, 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 {
+  annotationsEditAtFromDoc,
+  annotationsFromDoc,
+  applyHtmlToDoc,
+  isEmptyAnnotationsSvg,
+  stampAnnotationsEdit,
+} from '../sync/codec.ts';
+import { type AnnotationsColdStartInput, decideAnnotationsColdStart } from '../sync/cold-start.ts';
+import { createEchoGuard, hashBytes } from '../sync/echo-guard.ts';
+import { migrateSeed } from '../sync/migrate-seed.ts';
+
+/** The exact serialization `strokesToSvg([])` emits — the eraser's payload. */
+const EMPTY_WRAPPER = '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"></svg>';
+const STROKES =
+  '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"><image data-id="s_1" data-tool="image" x="0" y="0" width="160" height="160" href="assets/0327a8e5.png"/></svg>';
+const STROKES_B =
+  '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"><rect data-id="s_2" x="1" y="1" width="10" height="10"/></svg>';
+
+/* ------------------------------------------------- isEmptyAnnotationsSvg */
+
+describe('isEmptyAnnotationsSvg', () => {
+  test('null / empty / whitespace are empty', () => {
+    expect(isEmptyAnnotationsSvg(null)).toBe(true);
+    expect(isEmptyAnnotationsSvg('')).toBe(true);
+    expect(isEmptyAnnotationsSvg('  \n\t ')).toBe(true);
+  });
+
+  test('the bare wrapper is empty — the eraser regression pin', () => {
+    expect(isEmptyAnnotationsSvg(EMPTY_WRAPPER)).toBe(true);
+  });
+
+  test('wrapper with surrounding whitespace is empty', () => {
+    expect(isEmptyAnnotationsSvg(`  ${EMPTY_WRAPPER}\n`)).toBe(true);
+  });
+
+  test('a single stroke is NOT empty', () => {
+    expect(isEmptyAnnotationsSvg(STROKES)).toBe(false);
+  });
+});
+
+/* ------------------------------------------- decideAnnotationsColdStart */
+
+function input(over: Partial<AnnotationsColdStartInput>): AnnotationsColdStartInput {
+  return {
+    local: null,
+    doc: '',
+    isEmpty: isEmptyAnnotationsSvg,
+    localMtimeMs: null,
+    docEditAtMs: null,
+    bodyWinner: 'hub',
+    ...over,
+  };
+}
+
+describe('decideAnnotationsColdStart — emptiness vs content', () => {
+  test('both empty → none', () => {
+    expect(decideAnnotationsColdStart(input({})).winner).toBe('none');
+    expect(
+      decideAnnotationsColdStart(input({ local: EMPTY_WRAPPER, doc: EMPTY_WRAPPER })).winner
+    ).toBe('none');
+  });
+
+  test('THE ERASER: unstamped hub wrapper + local strokes + hub body winner → local', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: EMPTY_WRAPPER, localMtimeMs: 1000, bodyWinner: 'hub' })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('unset hub lane + local strokes → local (seed up), even with hub body winner', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: '', localMtimeMs: 1000, bodyWinner: 'hub' })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('STAMPED hub delete-all newer than local strokes → hub (deletes are honored)', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: EMPTY_WRAPPER, localMtimeMs: 1000, docEditAtMs: 2000 })
+    );
+    expect(d.winner).toBe('hub');
+  });
+
+  test('stamped hub delete-all OLDER than local strokes → local', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: EMPTY_WRAPPER, localMtimeMs: 2000, docEditAtMs: 1000 })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('local absent + hub strokes → hub (clean first sync materializes)', () => {
+    const d = decideAnnotationsColdStart(input({ doc: STROKES }));
+    expect(d.winner).toBe('hub');
+  });
+
+  test('local delete-all (wrapper on disk) newer than hub stamp → local', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: EMPTY_WRAPPER, doc: STROKES, localMtimeMs: 2000, docEditAtMs: 1000 })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('local wrapper with no doc stamp → hub (unstamped local emptiness loses too)', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: EMPTY_WRAPPER, doc: STROKES, localMtimeMs: 2000 })
+    );
+    expect(d.winner).toBe('hub');
+  });
+});
+
+describe('decideAnnotationsColdStart — both non-empty', () => {
+  test('equal content → none', () => {
+    const d = decideAnnotationsColdStart(input({ local: STROKES, doc: STROKES }));
+    expect(d.winner).toBe('none');
+  });
+
+  test('newest wins by per-lane stamp: local newer → local', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: STROKES_B, localMtimeMs: 2000, docEditAtMs: 1000 })
+    );
+    expect(d.winner).toBe('local');
+  });
+
+  test('newest wins by per-lane stamp: doc newer → hub', () => {
+    const d = decideAnnotationsColdStart(
+      input({ local: STROKES, doc: STROKES_B, localMtimeMs: 1000, docEditAtMs: 2000 })
+    );
+    expect(d.winner).toBe('hub');
+  });
+
+  test('no per-lane stamp → follows the body winner (legacy coupling)', () => {
+    expect(
+      decideAnnotationsColdStart(
+        input({ local: STROKES, doc: STROKES_B, localMtimeMs: 1000, bodyWinner: 'local' })
+      ).winner
+    ).toBe('local');
+    expect(
+      decideAnnotationsColdStart(
+        input({ local: STROKES, doc: STROKES_B, localMtimeMs: 1000, bodyWinner: 'hub' })
+      ).winner
+    ).toBe('hub');
+  });
+});
+
+/* ------------------------------------------------------- codec round-trip */
+
+describe('stampAnnotationsEdit / annotationsEditAtFromDoc', () => {
+  test('round-trips; absent stamp reads null', () => {
+    const doc = new Y.Doc();
+    expect(annotationsEditAtFromDoc(doc)).toBe(null);
+    stampAnnotationsEdit(doc, undefined, 12345);
+    expect(annotationsEditAtFromDoc(doc)).toBe(12345);
+  });
+});
+
+/* ------------------------------------------------------ agent integration */
+
+let dir: string;
+let agent: CanvasSyncAgent;
+let docA: Y.Doc;
+let docB: Y.Doc;
+
+function paths() {
+  return {
+    html: join(dir, 'screen.html'),
+    comments: join(dir, '_comments', 'screen.json'),
+    annotations: join(dir, 'screen.annotations.svg'),
+  };
+}
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'sync-ann-cold-'));
+  docA = new Y.Doc();
+  docB = new Y.Doc();
+  const TRANSPORT = Symbol('transport');
+  docA.on('update', (update: Uint8Array, origin: unknown) => {
+    if (origin === TRANSPORT) return;
+    Y.applyUpdate(docB, update, TRANSPORT);
+  });
+  docB.on('update', (update: Uint8Array, origin: unknown) => {
+    if (origin === TRANSPORT) return;
+    Y.applyUpdate(docA, update, TRANSPORT);
+  });
+});
+
+afterEach(() => {
+  agent?.stop();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function makeAgent(): CanvasSyncAgent {
+  const a = createCanvasSyncAgent({
+    slug: 'screen',
+    doc: docB,
+    paths: paths(),
+    echoGuard: createEchoGuard(),
+    flushMs: 0,
+  });
+  a.start();
+  return a;
+}
+
+describe('cold start — the eraser scenario end to end', () => {
+  test('unstamped hub wrapper does NOT erase local strokes; local seeds up + stamps', async () => {
+    // Hub holds the stale empty wrapper (what the eraser propagated) with no
+    // per-lane stamp — the exact pre-fix state of every wiped canvas.
+    docA.getMap('annotations').set('svg', EMPTY_WRAPPER);
+    // Local disk holds real strokes with an image reference.
+    writeFileSync(paths().annotations, STROKES);
+
+    agent = makeAgent();
+    await agent.reconcile();
+
+    // Disk keeps the strokes; the doc now carries them, stamped.
+    expect(readFileSync(paths().annotations, 'utf8')).toBe(STROKES);
+    expect(annotationsFromDoc(docB)).toBe(STROKES);
+    expect(annotationsFromDoc(docA)).toBe(STROKES); // propagated to the hub side
+    expect(annotationsEditAtFromDoc(docB)).not.toBe(null);
+  });
+
+  test('stamped hub delete-all newer than local strokes IS honored on disk', async () => {
+    writeFileSync(paths().annotations, STROKES);
+    // Backdate the local file so the hub's delete-all stamp is provably newer.
+    const past = new Date(Date.now() - 60_000);
+    utimesSync(paths().annotations, past, past);
+    docA.transact(() => {
+      docA.getMap('annotations').set('svg', EMPTY_WRAPPER);
+    });
+    stampAnnotationsEdit(docA, undefined, Date.now());
+
+    agent = makeAgent();
+    await agent.reconcile();
+
+    expect(readFileSync(paths().annotations, 'utf8')).toBe(EMPTY_WRAPPER);
+  });
+
+  test('clean first sync still materializes hub strokes to disk', async () => {
+    docA.getMap('annotations').set('svg', STROKES);
+
+    agent = makeAgent();
+    await agent.reconcile();
+
+    expect(readFileSync(paths().annotations, 'utf8')).toBe(STROKES);
+  });
+
+  test('SHARED-DOC eraser: migrateSeed rescues local strokes from an unstamped hub wrapper', async () => {
+    // The cell-side copy of the eraser: hub doc has a newer body (so the body
+    // resolution keeps the hub) and a stale unstamped wrapper in the
+    // annotations lane; local disk has real strokes.
+    const doc = new Y.Doc();
+    applyHtmlToDoc(doc, '<main>hub body</main>');
+    doc.getMap('annotations').set('svg', EMPTY_WRAPPER);
+    writeFileSync(paths().html, '<main>hub body</main>'); // body identical → noop path
+    writeFileSync(paths().annotations, STROKES);
+
+    await migrateSeed({ slug: 'screen', doc, paths: paths() });
+
+    // The doc now carries the local strokes, stamped — so the collab room's
+    // persistJson materializes strokes, not the wrapper.
+    expect(annotationsFromDoc(doc)).toBe(STROKES);
+    expect(annotationsEditAtFromDoc(doc)).not.toBe(null);
+  });
+
+  test('applyFromFs stamps annotationsEditAt in the same update', () => {
+    agent = makeAgent();
+    const bytes = new TextEncoder().encode(STROKES);
+    const changed = agent.applyFromFs({
+      path: paths().annotations,
+      bytes,
+      hash: hashBytes(STROKES),
+    });
+    expect(changed).toBe(true);
+    expect(annotationsFromDoc(docB)).toBe(STROKES);
+    expect(annotationsEditAtFromDoc(docB)).not.toBe(null);
+    // The stamp crossed to the other peer with the same update.
+    expect(annotationsEditAtFromDoc(docA)).not.toBe(null);
+  });
+});

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

@@ -0,0 +1,161 @@
+// The downward asset lane — see sync/asset-pull.ts.
+//
+// Regression cover for the reported "obrázky v annotations se nevykreslí":
+// `<slug>.annotations.svg` synced, its `assets/<sha8>.png` did not, and the
+// canvas rendered a broken-image glyph on every peer but the one that made it.
+
+import { describe, expect, test } from 'bun:test';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { pullAssets, referencedAssets } from '../sync/asset-pull.ts';
+
+function project(files: Record<string, string>): string {
+  const root = mkdtempSync(path.join(tmpdir(), 'maude-asset-pull-'));
+  for (const [rel, body] of Object.entries(files)) {
+    const abs = path.join(root, rel);
+    mkdirSync(path.dirname(abs), { recursive: true });
+    writeFileSync(abs, body);
+  }
+  return root;
+}
+
+const annotation = (name: string) =>
+  `<svg xmlns="http://www.w3.org/2000/svg"><image data-tool="image" href="assets/${name}"/></svg>`;
+
+/** A hub that serves every asset as three bytes. */
+const servingFetch = (seen: string[] = []) =>
+  (async (url: string) => {
+    seen.push(String(url));
+    return new Response(new Uint8Array([1, 2, 3]), { status: 200 });
+  }) as unknown as typeof fetch;
+
+describe('referencedAssets', () => {
+  test('finds the image an annotation references', () => {
+    const root = project({ 'ui-board.annotations.svg': annotation('c0fa9c7f.png') });
+    expect(referencedAssets(root)).toEqual(['c0fa9c7f.png']);
+  });
+
+  test('reads canvas bodies and sidecars too, deduplicating', () => {
+    const root = project({
+      'ui-board.annotations.svg': annotation('a.png'),
+      'ui/card.tsx': `<img src="assets/b.jpg" /><img src="assets/a.png" />`,
+      'ui/card.css': `.x { background: url(assets/c.webp) }`,
+    });
+    expect(referencedAssets(root)).toEqual(['a.png', 'b.jpg', 'c.webp']);
+  });
+
+  test('refuses a reference that could place a file outside assets/', () => {
+    // An annotation can itself have arrived from the hub, so a name found in
+    // one is untrusted input.
+    const root = project({
+      'ui-board.annotations.svg': [
+        '<svg>',
+        '<image href="assets/../../etc/passwd"/>',
+        '<image href="assets/ok.png"/>',
+        '</svg>',
+      ].join(''),
+    });
+    expect(referencedAssets(root)).toEqual(['ok.png']);
+  });
+
+  test('refuses an extension outside the asset allowlist', () => {
+    const root = project({
+      'ui/card.tsx': `"assets/payload.sh" "assets/x.tsx" "assets/real.png"`,
+    });
+    expect(referencedAssets(root)).toEqual(['real.png']);
+  });
+
+  test('ignores runtime directories — a trashed canvas wants nothing', () => {
+    const root = project({
+      '_trash/old-deleted-1/old.annotations.svg': annotation('ghost.png'),
+      '_history/ui-board/1.tsx': `"assets/older.png"`,
+      'ui-board.annotations.svg': annotation('live.png'),
+    });
+    expect(referencedAssets(root)).toEqual(['live.png']);
+  });
+});
+
+describe('pullAssets', () => {
+  const opts = (root: string, fetchImpl: typeof fetch) => ({
+    designRoot: root,
+    hubUrl: 'https://hub.example/',
+    token: () => 'tok',
+    fetchImpl,
+    log: { log: () => {}, warn: () => {} },
+  });
+
+  test('fetches a referenced asset this machine does not have', async () => {
+    const root = project({ 'ui-board.annotations.svg': annotation('c0fa9c7f.png') });
+    const seen: string[] = [];
+    const res = await pullAssets(opts(root, servingFetch(seen)));
+
+    expect(res.pulled).toEqual(['c0fa9c7f.png']);
+    expect(seen).toEqual(['https://hub.example/assets/c0fa9c7f.png']);
+    expect(readFileSync(path.join(root, 'assets/c0fa9c7f.png'))).toEqual(Buffer.from([1, 2, 3]));
+  });
+
+  test('asks for nothing when every reference is already on disk', async () => {
+    const root = project({
+      'ui-board.annotations.svg': annotation('have.png'),
+      'assets/have.png': 'bytes',
+    });
+    let called = 0;
+    const counting = (async () => {
+      called += 1;
+      return new Response('x', { status: 200 });
+    }) as unknown as typeof fetch;
+
+    const res = await pullAssets(opts(root, counting));
+    expect(called).toBe(0);
+    expect(res.present).toBe(1);
+    expect(res.pulled).toEqual([]);
+  });
+
+  test('is idempotent — a second pass costs no requests', async () => {
+    const root = project({ 'ui-board.annotations.svg': annotation('x.png') });
+    await pullAssets(opts(root, servingFetch()));
+    const seen: string[] = [];
+    const second = await pullAssets(opts(root, servingFetch(seen)));
+    expect(seen).toEqual([]);
+    expect(second.pulled).toEqual([]);
+  });
+
+  test('a 404 is recorded and retried, never fatal', async () => {
+    // Ordinary: the peer that owns the bytes has not pushed them yet.
+    const root = project({ 'ui-board.annotations.svg': annotation('later.png') });
+    const missing = (async () => new Response('nope', { status: 404 })) as unknown as typeof fetch;
+    const res = await pullAssets(opts(root, missing));
+    expect(res.pulled).toEqual([]);
+    expect(res.failed).toEqual([{ name: 'later.png', reason: 'HTTP 404' }]);
+    expect(existsSync(path.join(root, 'assets/later.png'))).toBe(false);
+  });
+
+  test('a throwing hub is not fatal either', async () => {
+    const root = project({ 'ui-board.annotations.svg': annotation('x.png') });
+    const boom = (async () => {
+      throw new Error('offline');
+    }) as unknown as typeof fetch;
+    const res = await pullAssets(opts(root, boom));
+    expect(res.pulled).toEqual([]);
+    expect(res.failed[0]?.reason).toBe('offline');
+  });
+
+  test('refuses an empty body rather than writing a zero-byte image', async () => {
+    const root = project({ 'ui-board.annotations.svg': annotation('x.png') });
+    const empty = (async () =>
+      new Response(new Uint8Array([]), { status: 200 })) as unknown as typeof fetch;
+    const res = await pullAssets(opts(root, empty));
+    expect(res.pulled).toEqual([]);
+    expect(existsSync(path.join(root, 'assets/x.png'))).toBe(false);
+  });
+
+  test('leaves no .part file behind on success', async () => {
+    // The write is temp-then-rename so the dev server serving this very path
+    // never reads a half-written image.
+    const root = project({ 'ui-board.annotations.svg': annotation('x.png') });
+    await pullAssets(opts(root, servingFetch()));
+    expect(existsSync(path.join(root, 'assets/x.png.part'))).toBe(false);
+  });
+});

package/apps/studio/test/sync-asset-push.test.ts

@@ -21,7 +21,7 @@ function scratchDesignRoot(): string {
   return mkdtempSync(join(tmpdir(), 'asset-push-'));
 }
 
-describe('listPushableAssets — every assets/ dir, asset extensions only', () => {
+describe('listPushableAssets — classifier membership over the whole design root', () => {
   test('finds top-level content-addressed AND nested DS/brand assets', () => {
     const designRoot = scratchDesignRoot();
     // Class 1 — top-level content-addressed uploads (+ a .photo.json sidecar).
@@ -67,6 +67,51 @@ describe('listPushableAssets — every assets/ dir, asset extensions only', () =
     writeFileSync(join(designRoot, 'assets/a/b/c/d/e/f/g/x.png'), 'x');
     expect(listPushableAssets(designRoot)).toEqual([]);
   });
+
+  test('the file-plane widening: the RCA miss-list goes up, canvas lanes stay home', () => {
+    // feature-sync-file-plane — the sweep now carries what the fresh-link RCA
+    // named laneless: token stylesheets, docs, shared modules, underscore
+    // FILES. A canvas body and its named sidecars stay the CRDT lanes'.
+    const designRoot = scratchDesignRoot();
+    mkdirSync(join(designRoot, 'system/ds/preview'), { recursive: true });
+    writeFileSync(join(designRoot, 'config.json'), '{}');
+    writeFileSync(join(designRoot, 'system/ds/brand.css'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/README.md'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/preview/_brand-css.ts'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/preview/_layout.css'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/preview/specimen.tsx'), 'x');
+    writeFileSync(join(designRoot, 'system/ds/preview/specimen.css'), 'x'); // sibling css lane
+    writeFileSync(join(designRoot, 'system/ds/preview/specimen.meta.json'), '{}');
+    expect(listPushableAssets(designRoot, { syncFiles: true })).toEqual([
+      'system/ds/README.md',
+      'system/ds/brand.css',
+      'system/ds/preview/_brand-css.ts',
+      'system/ds/preview/_layout.css',
+    ]);
+    // Flag OFF ⇒ today's reach, byte-for-byte: none of these are binary
+    // media under an assets/ dir, so none of them move.
+    expect(listPushableAssets(designRoot)).toEqual([]);
+  });
+
+  test('declared canvasGroups decide what a canvas body IS', () => {
+    const designRoot = scratchDesignRoot();
+    mkdirSync(join(designRoot, 'mocks'), { recursive: true });
+    mkdirSync(join(designRoot, 'lib'), { recursive: true });
+    writeFileSync(join(designRoot, 'mocks/screen.tsx'), 'x');
+    writeFileSync(join(designRoot, 'lib/helpers.tsx'), 'x');
+    const groups = [{ path: 'mocks' }];
+    // `mocks/screen.tsx` is a canvas here; `lib/helpers.tsx` a shared module.
+    expect(listPushableAssets(designRoot, { canvasGroups: groups, syncFiles: true })).toEqual([
+      'lib/helpers.tsx',
+    ]);
+    // …and both the groups and the flag reach the walk through config.json —
+    // the out-of-process worker's path.
+    writeFileSync(
+      join(designRoot, 'config.json'),
+      JSON.stringify({ canvasGroups: groups, linkedHub: { url: 'http://h', syncFiles: true } })
+    );
+    expect(listPushableAssets(designRoot)).toEqual(['lib/helpers.tsx']);
+  });
 });
 
 describe('pushAssets — routes each class to the right hub endpoint', () => {
@@ -790,7 +835,12 @@ describe('the runtime sweeps on change, not only at boot', () => {
   const SYNC = readFileSync(join(import.meta.dir, '..', 'sync', 'index.ts'), 'utf8');
 
   test('the fs watcher decides with isPushableAssetRel and schedules a sweep', () => {
-    expect(SYNC).toContain('if (isPushableAssetRel(rel)) scheduleAssetSweep(');
+    // The predicate gets the project's OWN canvas groups — with the default
+    // set a custom-group project's shared module would answer canvas-owned
+    // and silently never schedule the sweep that uploads it.
+    expect(SYNC).toContain(
+      'if (isPushableAssetRel(rel, ctx.cfg.canvasGroups)) scheduleAssetSweep('
+    );
   });
 
   test('bursts coalesce, and a change DURING a sweep is not lost', () => {