@1agh/maude 0.29.0 → 0.31.0

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

@@ -11,6 +11,7 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
+  readdirSync,
   readFileSync,
   rmSync,
   writeFileSync,
@@ -50,7 +51,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 (cfgPathEnv === undefined) delete process.env.HUBS_CONFIG_PATH;
   else process.env.HUBS_CONFIG_PATH = cfgPathEnv;
   rmSync(dir, { recursive: true, force: true });
@@ -424,14 +424,15 @@ describe('createSyncRuntime', () => {
     await runtime?.stop();
   });
 
-  test('Task 8: hub-wins reconcile over divergent local content records a conflict', async () => {
+  test('DDR-102: reconcile over divergent local content records a diverged conflict + snapshots both sides', async () => {
     const url = 'https://hub.example.com';
     writeHubsConfig(url, 'mau_test');
     const ctx = makeCtx({ url, linkedAt: 1 });
-    // Local disk has divergent, non-empty content.
+    // Local disk has divergent, non-empty content (and no journal — divergence).
     writeFileSync(join(ctx.paths.designRoot, 'ui', 'screen.html'), '<button>LOCAL EDIT</button>');
 
-    // Provider whose doc already carries different hub state.
+    // Provider whose doc already carries different hub state. No syncMeta
+    // stamp (older peer) → newest-wins falls back to hub.
     const factory = () => {
       const document = new Y.Doc();
       document.getText('html').insert(0, '<button>HUB STATE</button>');
@@ -451,7 +452,25 @@ describe('createSyncRuntime', () => {
 
     const status = runtime?.status();
     expect(status?.conflicts.length).toBeGreaterThanOrEqual(1);
-    expect(status?.conflicts[0].kind).toBe('cold-start-hub-wins');
+    const conflict = status?.conflicts[0];
+    expect(conflict?.kind).toBe('cold-start-diverged');
+    expect(conflict?.winner).toBe('hub');
+    // Both pre-resolution versions were snapshotted to _history/<slug>/.
+    expect(conflict?.snapshots?.local).toBeDefined();
+    expect(conflict?.snapshots?.hub).toBeDefined();
+    const historyDir = join(ctx.paths.historyDir, 'ui-screen');
+    const blobs = readdirSync(historyDir).filter((f) => f.endsWith('.html'));
+    expect(blobs.length).toBe(2);
+    // The loser (local) is recoverable byte-identical from its snapshot.
+    const metas = readdirSync(historyDir).filter((f) => f.endsWith('.json'));
+    const snapshotContents = blobs.map((f) => readFileSync(join(historyDir, f), 'utf8'));
+    expect(snapshotContents).toContain('<button>LOCAL EDIT</button>');
+    expect(snapshotContents).toContain('<button>HUB STATE</button>');
+    expect(metas.length).toBe(2);
+    // Hub won → disk now carries hub state.
+    expect(readFileSync(join(ctx.paths.designRoot, 'ui', 'screen.html'), 'utf8')).toBe(
+      '<button>HUB STATE</button>'
+    );
     await runtime?.stop();
   });
 });
@@ -885,3 +904,339 @@ describe('toWsUrl', () => {
     expect(toWsUrl('ws://localhost:1234')).toBe('ws://localhost:1234');
   });
 });
+
+// DDR-102 — WS multiplexing: the default factory shares ONE
+// HocuspocusProviderWebsocket per hub URL across all providers.
+describe('createDefaultProviderFactory — shared socket multiplexing', () => {
+  class FakeEmitter {
+    handlers = new Map<string, Set<(arg?: unknown) => void>>();
+    on(evt: string, cb: (arg?: unknown) => void) {
+      if (!this.handlers.has(evt)) this.handlers.set(evt, new Set());
+      this.handlers.get(evt)?.add(cb);
+    }
+    off(evt: string, cb: (arg?: unknown) => void) {
+      this.handlers.get(evt)?.delete(cb);
+    }
+    emit(evt: string, arg?: unknown) {
+      for (const cb of this.handlers.get(evt) ?? []) cb(arg);
+    }
+  }
+
+  function makeFakeModule() {
+    const sockets: Array<{ url: string; destroyed: boolean }> = [];
+    const providers: Array<{
+      name: string;
+      attached: boolean;
+      destroyed: boolean;
+      socket: unknown;
+    }> = [];
+
+    class HocuspocusProviderWebsocket extends FakeEmitter {
+      url: string;
+      status = 'connecting';
+      destroyed = false;
+      constructor(cfg: { url: string }) {
+        super();
+        this.url = cfg.url;
+        sockets.push(this);
+      }
+      destroy() {
+        this.destroyed = true;
+      }
+    }
+
+    class HocuspocusProvider extends FakeEmitter {
+      configuration: { name: string; websocketProvider: unknown; document: unknown };
+      awareness = undefined;
+      synced = false;
+      attached = false;
+      destroyed = false;
+      name: string;
+      socket: unknown;
+      constructor(cfg: { name: string; websocketProvider: unknown; document: unknown }) {
+        super();
+        this.configuration = cfg;
+        this.name = cfg.name;
+        this.socket = cfg.websocketProvider;
+        providers.push(this);
+      }
+      attach() {
+        this.attached = true;
+      }
+      destroy() {
+        this.destroyed = true;
+      }
+    }
+
+    return { mod: { HocuspocusProviderWebsocket, HocuspocusProvider }, sockets, providers };
+  }
+
+  test('N providers for one hub URL share ONE socket, each explicitly attached', async () => {
+    const { mod, sockets, providers } = makeFakeModule();
+    const { createDefaultProviderFactory } = await import('../sync/index.ts');
+    const factory = createDefaultProviderFactory(async () => mod);
+
+    await factory({ url: 'https://hub.example.com', token: 't', documentName: 'ui-a' });
+    await factory({ url: 'https://hub.example.com', token: 't', documentName: 'ui-b' });
+    await factory({ url: 'https://hub.example.com', token: 't', documentName: 'ui-c' });
+
+    expect(sockets).toHaveLength(1);
+    expect(sockets[0].url).toBe('wss://hub.example.com');
+    expect(providers).toHaveLength(3);
+    for (const p of providers) {
+      expect(p.attached).toBe(true);
+      expect(p.socket).toBe(sockets[0]);
+    }
+  });
+
+  test('provider destroy() detaches only; dispose() destroys the shared socket', async () => {
+    const { mod, sockets, providers } = makeFakeModule();
+    const { createDefaultProviderFactory } = await import('../sync/index.ts');
+    const factory = createDefaultProviderFactory(async () => mod);
+
+    const p1 = await factory({ url: 'https://h.example.com', token: 't', documentName: 'ui-a' });
+    p1.destroy();
+    expect(providers[0].destroyed).toBe(true);
+    expect(sockets[0].destroyed).toBe(false); // socket survives provider death
+
+    factory.dispose();
+    expect(sockets[0].destroyed).toBe(true);
+  });
+
+  test('onStatus seeds from the SOCKET status and forwards provider status events', async () => {
+    const { mod, sockets, providers } = makeFakeModule();
+    const { createDefaultProviderFactory } = await import('../sync/index.ts');
+    const factory = createDefaultProviderFactory(async () => mod);
+
+    const wrapped = await factory({
+      url: 'https://h.example.com',
+      token: 't',
+      documentName: 'ui-a',
+    });
+    const seen: string[] = [];
+    const unsub = wrapped.onStatus?.((s) => seen.push(s));
+    // Seeded from socket.status ('connecting') immediately.
+    expect(seen).toEqual(['connecting']);
+    // Provider-level forwarded events keep flowing.
+    (providers[0] as unknown as FakeEmitter).emit('status', { status: 'connected' });
+    expect(seen).toEqual(['connecting', 'connected']);
+    unsub?.();
+    (providers[0] as unknown as FakeEmitter).emit('status', { status: 'disconnected' });
+    expect(seen).toEqual(['connecting', 'connected']); // unsubscribed
+    expect(sockets).toHaveLength(1);
+  });
+});
+
+// DDR-102 — auth-failure intelligence (classification, aggregation,
+// destroy-on-permanent + re-probe) and the honest settled boot summary.
+describe('DDR-102 — auth-failure intelligence + boot summary', () => {
+  function fakeTimerQueue() {
+    let nextId = 1;
+    const timers = new Map<number, { cb: () => void; ms: number }>();
+    return {
+      setTimer: (cb: () => void, ms: number) => {
+        const id = nextId++;
+        timers.set(id, { cb, ms });
+        return id as unknown as ReturnType<typeof setTimeout>;
+      },
+      clearTimer: (h: ReturnType<typeof setTimeout>) => {
+        timers.delete(h as unknown as number);
+      },
+      /** Fire every pending timer with ms <= maxMs (one sweep). */
+      fire(maxMs: number) {
+        for (const [id, t] of [...timers.entries()]) {
+          if (t.ms <= maxMs) {
+            timers.delete(id);
+            t.cb();
+          }
+        }
+      },
+      pending: () => timers.size,
+    };
+  }
+
+  /** Stub factory whose providers expose onAuthFailed + track destroys. */
+  function authStubFactory() {
+    const made: Array<{
+      documentName: string;
+      destroyed: boolean;
+      emitAuthFailure: (reason: string) => void;
+      document: Y.Doc;
+    }> = [];
+    const factory = (args: { documentName: string; document?: Y.Doc }) => {
+      const document = args.document ?? new Y.Doc();
+      const cbs = new Set<(info: { reason: string }) => void>();
+      const entry = {
+        documentName: args.documentName,
+        destroyed: false,
+        emitAuthFailure: (reason: string) => {
+          for (const cb of cbs) cb({ reason });
+        },
+        document,
+      };
+      made.push(entry);
+      return {
+        document,
+        onAuthFailed(cb: (info: { reason: string }) => void) {
+          cbs.add(cb);
+          return () => cbs.delete(cb);
+        },
+        onceSynced() {
+          return new Promise<void>(() => {}); // never settles (rejected docs)
+        },
+        destroy() {
+          entry.destroyed = true;
+        },
+      };
+    };
+    return { factory, made };
+  }
+
+  test('classification + ONE aggregated warn + destroy-on-permanent + re-probe', async () => {
+    const url = 'https://hub.example.com';
+    writeHubsConfig(url, 'mau_test');
+    const ctx = makeCtx({ url, linkedAt: 1 });
+    writeFileSync(join(ctx.paths.designRoot, 'ui', 'a.html'), '<a/>');
+    writeFileSync(join(ctx.paths.designRoot, 'ui', 'b.html'), '<b/>');
+    writeFileSync(join(ctx.paths.designRoot, 'ui', 'c.html'), '<c/>');
+
+    const timers = fakeTimerQueue();
+    const { factory, made } = authStubFactory();
+    const warns: string[] = [];
+    const origWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warns.push(args.map(String).join(' '));
+    };
+
+    try {
+      const runtime = createSyncRuntime(ctx, {
+        providerFactory: factory,
+        auth: {
+          warnDebounceMs: 2_000,
+          reprobeMs: 300_000,
+          settleTimeoutMs: 15_000,
+          setTimer: timers.setTimer,
+          clearTimer: timers.clearTimer,
+        },
+      });
+      await runtime?.start();
+      expect(made).toHaveLength(3);
+      // readdir order is not deterministic — address providers by slug.
+      const bySlug = (slug: string) => {
+        const m = made.find((p) => p.documentName === slug);
+        if (!m) throw new Error(`no provider for ${slug}`);
+        return m;
+      };
+
+      // Hub rejects: a + b permanently (scope), c transiently (rate limit).
+      bySlug('ui-a').emitAuthFailure('token not authorized for this documentName');
+      bySlug('ui-b').emitAuthFailure('token not authorized for this documentName');
+      bySlug('ui-c').emitAuthFailure('rate limit exceeded for this token');
+
+      // Per-slug statuses are honest immediately.
+      const status = runtime?.status();
+      expect(status?.docs?.rejected).toBe(3);
+      expect(status?.rejectedSlugs?.sort()).toEqual(['ui-a', 'ui-b', 'ui-c']);
+
+      // Permanent classes destroyed (retry storm stopped); transient keeps its
+      // provider (built-in backoff).
+      expect(bySlug('ui-a').destroyed).toBe(true);
+      expect(bySlug('ui-b').destroyed).toBe(true);
+      expect(bySlug('ui-c').destroyed).toBe(false);
+
+      // No warn yet (debounced); ONE aggregated warn after the window.
+      const authWarnsBefore = warns.filter((w) => w.includes('auth rejections')).length;
+      expect(authWarnsBefore).toBe(0);
+      timers.fire(2_000);
+      const authWarns = warns.filter((w) => w.includes('auth rejections'));
+      expect(authWarns).toHaveLength(1);
+      // Reason-specific hints, both classes in the one warn.
+      expect(authWarns[0]).toContain('not-authorized');
+      expect(authWarns[0]).toContain('rate-limit');
+      expect(authWarns[0]).toContain('mint a hub-wide token');
+      expect(authWarns[0]).toContain('HUB_CONN_RATE_LIMIT');
+
+      // Re-probe (5 min): the two permanently-rejected docs reconnect with the
+      // SAME doc instance (agent wiring survives the provider swap).
+      const docA = bySlug('ui-a').document;
+      timers.fire(300_000);
+      await new Promise((res) => setTimeout(res, 10));
+      const reprobed = made.slice(3);
+      expect(reprobed.map((m) => m.documentName).sort()).toEqual(['ui-a', 'ui-b']);
+      expect(reprobed.find((m) => m.documentName === 'ui-a')?.document).toBe(docA);
+
+      await runtime?.stop();
+    } finally {
+      console.warn = origWarn;
+    }
+  });
+
+  test('boot summary prints AFTER settle with honest counts (not the premature N/N)', async () => {
+    const url = 'https://hub.example.com';
+    writeHubsConfig(url, 'mau_test');
+    const ctx = makeCtx({ url, linkedAt: 1 });
+    writeFileSync(join(ctx.paths.designRoot, 'ui', 'good.html'), '<g/>');
+    writeFileSync(join(ctx.paths.designRoot, 'ui', 'bad.html'), '<b/>');
+
+    const timers = fakeTimerQueue();
+    const logs: string[] = [];
+    const origLog = console.log;
+    const origWarn = console.warn;
+    console.log = (...args: unknown[]) => {
+      logs.push(args.map(String).join(' '));
+    };
+    console.warn = () => {};
+
+    // 'good' syncs immediately; 'bad' is auth-rejected and never settles.
+    const { factory, made } = authStubFactory();
+    const mixedFactory = (args: { documentName: string; document?: Y.Doc }) => {
+      if (args.documentName === 'ui-good') {
+        const document = args.document ?? new Y.Doc();
+        return {
+          document,
+          async onceSynced() {},
+          destroy() {},
+        };
+      }
+      return factory(args);
+    };
+
+    try {
+      const runtime = createSyncRuntime(ctx, {
+        providerFactory: mixedFactory,
+        auth: {
+          settleTimeoutMs: 15_000,
+          warnDebounceMs: 2_000,
+          setTimer: timers.setTimer,
+          clearTimer: timers.clearTimer,
+        },
+      });
+      await runtime?.start();
+      made.find((m) => m.documentName === 'ui-bad')?.emitAuthFailure('invalid token');
+      // Boot prints the linking line immediately, NOT a premature N/N.
+      expect(logs.some((l) => l.includes('linking to'))).toBe(true);
+      expect(logs.some((l) => l.includes('synced'))).toBe(false);
+
+      // Let the good handshake's microtask chain run, then hit the ceiling.
+      await new Promise((res) => setTimeout(res, 10));
+      timers.fire(15_000);
+      await new Promise((res) => setTimeout(res, 10));
+
+      const summary = logs.find((l) => l.includes('synced'));
+      expect(summary).toBeDefined();
+      expect(summary).toContain('1/2 synced');
+      expect(summary).toContain('1 auth-rejected');
+      expect(summary).toContain('ui-bad');
+      expect(summary).toContain('invalid-token');
+
+      // lastSyncAt reflects the real reconcile activity of the good canvas.
+      expect(runtime?.status()?.lastSyncAt).not.toBeNull();
+      expect(runtime?.status()?.docs?.synced).toBe(1);
+
+      await runtime?.stop();
+    } finally {
+      console.log = origLog;
+      console.warn = origWarn;
+    }
+  });
+});

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

@@ -78,3 +78,69 @@ describe('sync status store', () => {
     expect(() => store.update(snap({ state: 'offline' }))).not.toThrow();
   });
 });
+
+// DDR-102 — the payload carries the per-doc rollup + rich conflicts additively.
+describe('sync status store — DDR-102 additive fields', () => {
+  test('docs + rejectedSlugs flow through update() into the payload', () => {
+    const writes: SyncStatusPayload[] = [];
+    const store = createSyncStatusStore({
+      url: 'https://h.example.com',
+      canvases: 3,
+      write: (p) => writes.push(p),
+    });
+    store.update({
+      state: 'online',
+      queuedOps: 0,
+      lastSyncAt: 123,
+      offlineSince: null,
+      flash: null,
+      updatedAt: 456,
+      docs: { synced: 1, pending: 0, rejected: 2 },
+      rejectedSlugs: ['ui-x', 'ui-y'],
+    });
+    const p = store.get();
+    expect(p.docs).toEqual({ synced: 1, pending: 0, rejected: 2 });
+    expect(p.rejectedSlugs).toEqual(['ui-x', 'ui-y']);
+    expect(p.lastSyncAt).toBe(123);
+  });
+
+  test('addConflict carries winner + snapshots (cold-start-diverged)', () => {
+    const store = createSyncStatusStore({
+      url: 'https://h.example.com',
+      canvases: 1,
+      write: () => {},
+      now: () => 999,
+    });
+    store.addConflict({
+      slug: 'ui-maskot',
+      kind: 'cold-start-diverged',
+      winner: 'local',
+      snapshots: { local: '2026-06-11T10:00:00.000Z', hub: '2026-06-11T10:00:00.001Z' },
+    });
+    const c = store.get().conflicts[0];
+    expect(c.kind).toBe('cold-start-diverged');
+    expect(c.winner).toBe('local');
+    expect(c.snapshots?.local).toBe('2026-06-11T10:00:00.000Z');
+    expect(c.at).toBe(999);
+  });
+
+  test('old-shape payload readers: a snapshot WITHOUT docs/rejectedSlugs still works', () => {
+    const store = createSyncStatusStore({
+      url: 'https://h.example.com',
+      canvases: 1,
+      write: () => {},
+    });
+    store.update({
+      state: 'online',
+      queuedOps: 0,
+      lastSyncAt: null,
+      offlineSince: null,
+      flash: null,
+      updatedAt: 1,
+    });
+    const p = store.get();
+    expect(p.docs).toBeUndefined();
+    expect(p.rejectedSlugs).toBeUndefined();
+    expect(p.state).toBe('online');
+  });
+});

package/apps/studio/test/tour-overlay.test.tsx

@@ -43,6 +43,24 @@ describe('TourOverlay', () => {
     expect(html).not.toContain('mdcc-tour__back'); // i === 0
   });
 
+  test('a step with a render graphic widens the card and draws the graphic (Phase 29 / E4)', () => {
+    function Graphic() {
+      return <div className="cm-info">TWO-LAYER-DIAGRAM</div>;
+    }
+    const html = renderToStaticMarkup(
+      <TourOverlay
+        open
+        steps={[{ render: Graphic, title: 'Working together', body: 'Two layers.' }]}
+        onClose={() => {}}
+        onComplete={() => {}}
+      />
+    );
+    expect(html).toContain('mdcc-tour__card--graphic');
+    expect(html).toContain('mdcc-tour__graphic');
+    expect(html).toContain('TWO-LAYER-DIAGRAM');
+    expect(html).toContain('Working together');
+  });
+
   test('closed or empty renders nothing', () => {
     expect(
       renderToStaticMarkup(

package/apps/studio/test/use-annotation-resize.test.ts

@@ -241,3 +241,162 @@ describe('resizeStroke / pen — point scaling', () => {
     expect(out.points[2]).toEqual([150, 150]);
   });
 });
+
+describe('resizeStroke / rotation — Wave G corner rotate zones', () => {
+  // rect center = (50, 25). Angles below are measured around it.
+  test('relative rotation: grab angle is the zero reference (no jump)', () => {
+    // Grab at angle 0° (due east of center), drag to 45° → rotation 45.
+    const rotRef = { angle0: 0, rot0: 0 };
+    const out = resizeStroke(
+      rect,
+      'rot-se',
+      50 + 70,
+      25 + 70,
+      { shift: false, alt: false },
+      rotRef
+    );
+    expect(out).toEqual({ rotation: 45 });
+  });
+
+  test('starting rotation accumulates with the drag delta', () => {
+    const rotated: RectStroke = { ...rect, rotation: 30 };
+    const rotRef = { angle0: 0, rot0: 30 };
+    const out = resizeStroke(
+      rotated,
+      'rot-ne',
+      50 + 70,
+      25 + 70,
+      { shift: false, alt: false },
+      rotRef
+    );
+    expect(out).toEqual({ rotation: 75 });
+  });
+
+  test('magnetic cardinals: within 2° of 0 lock on and serialize as undefined', () => {
+    const rotated: RectStroke = { ...rect, rotation: 44 };
+    // Drag back by 42.5° → raw −1.5° + rot0 44 = ... use angle0 50, current 7.5 → deg = 44 − 42.5 = 1.5 → locks to 0.
+    const cur = (Math.PI / 180) * 7.5;
+    const out = resizeStroke(
+      rotated,
+      'rot-nw',
+      50 + 70 * Math.cos(cur),
+      25 + 70 * Math.sin(cur),
+      { shift: false, alt: false },
+      { angle0: 50, rot0: 44 }
+    );
+    expect(out).toEqual({ rotation: undefined });
+  });
+
+  test('Shift snaps to 15° steps', () => {
+    // delta = 40° → snaps to 45.
+    const cur = (Math.PI / 180) * 40;
+    const out = resizeStroke(
+      rect,
+      'rot-sw',
+      50 + 70 * Math.cos(cur),
+      25 + 70 * Math.sin(cur),
+      { shift: true, alt: false },
+      { angle0: 0, rot0: 0 }
+    );
+    expect(out).toEqual({ rotation: 45 });
+  });
+
+  test('non-rotatable strokes refuse the rotate corners', () => {
+    const arrow: ArrowStroke = {
+      id: 'a1',
+      tool: 'arrow',
+      color: '#000',
+      width: 2,
+      x1: 0,
+      y1: 0,
+      x2: 100,
+      y2: 0,
+    };
+    expect(
+      resizeStroke(arrow, 'rot-se', 50, 50, { shift: false, alt: false }, { angle0: 0, rot0: 0 })
+    ).toBeNull();
+  });
+
+  test('polygon rotates (diamond/triangle are rotatable hosts)', () => {
+    const poly: PolygonStroke = {
+      id: 'p1',
+      tool: 'polygon',
+      shape: 'diamond',
+      color: '#000',
+      width: 2,
+      x: 0,
+      y: 0,
+      w: 100,
+      h: 50,
+    };
+    const out = resizeStroke(
+      poly,
+      'rot-se',
+      50 + 70,
+      25 + 70,
+      { shift: false, alt: false },
+      { angle0: 0, rot0: 0 }
+    );
+    expect(out).toEqual({ rotation: 45 });
+  });
+});
+
+describe('resizeStroke / rotated strokes — Wave H anchor compensation', () => {
+  // rect 100×50 at origin, rotated 90° around its center (50, 25).
+  const rotated: RectStroke = { ...rect, rotation: 90 };
+  const rotP = (px: number, py: number, cx: number, cy: number, deg: number): [number, number] => {
+    const r = (deg * Math.PI) / 180;
+    const dx = px - cx;
+    const dy = py - cy;
+    return [cx + dx * Math.cos(r) - dy * Math.sin(r), cy + dx * Math.sin(r) + dy * Math.cos(r)];
+  };
+
+  test('se-corner drag keeps the nw corner fixed in WORLD space', () => {
+    // Cursor in the LOCAL frame (applyResize inverse-rotates before calling).
+    const out = resizeStroke(rotated, 'se', 140, 90) as RectStroke;
+    expect(out.w).toBeCloseTo(140, 6);
+    expect(out.h).toBeCloseTo(90, 6);
+    const before = rotP(0, 0, 50, 25, 90);
+    const after = rotP(out.x, out.y, out.x + out.w / 2, out.y + out.h / 2, 90);
+    expect(after[0]).toBeCloseTo(before[0], 6);
+    expect(after[1]).toBeCloseTo(before[1], 6);
+  });
+
+  test('e-edge drag keeps the west edge midpoint fixed in WORLD space', () => {
+    const out = resizeStroke(rotated, 'e', 130, 25) as RectStroke;
+    expect(out.w).toBeCloseTo(130, 6);
+    const before = rotP(0, 25, 50, 25, 90);
+    const after = rotP(out.x, out.y + out.h / 2, out.x + out.w / 2, out.y + out.h / 2, 90);
+    expect(after[0]).toBeCloseTo(before[0], 6);
+    expect(after[1]).toBeCloseTo(before[1], 6);
+  });
+
+  test('Alt resize keeps the center (no compensation path)', () => {
+    const out = resizeStroke(rotated, 'se', 130, 80, { shift: false, alt: true }) as RectStroke;
+    expect(out.x + out.w / 2).toBeCloseTo(50, 6);
+    expect(out.y + out.h / 2).toBeCloseTo(25, 6);
+  });
+
+  test('unrotated strokes are byte-stable (no shift applied)', () => {
+    expect(resizeStroke(rect, 'se', 120, 80)).toEqual({ x: 0, y: 0, w: 120, h: 80 });
+  });
+
+  test('rotated ellipse: se drag keeps the nw bbox corner fixed in WORLD space', () => {
+    const ell: EllipseStroke = {
+      id: 'e1',
+      tool: 'ellipse',
+      color: '#000',
+      width: 2,
+      cx: 50,
+      cy: 25,
+      rx: 50,
+      ry: 25,
+      rotation: 45,
+    };
+    const out = resizeStroke(ell, 'se', 140, 90) as EllipseStroke;
+    const before = rotP(0, 0, 50, 25, 45);
+    const after = rotP(out.cx - out.rx, out.cy - out.ry, out.cx, out.cy, 45);
+    expect(after[0]).toBeCloseTo(before[0], 6);
+    expect(after[1]).toBeCloseTo(before[1], 6);
+  });
+});

package/apps/studio/test/use-artboard-drag.test.ts

@@ -15,7 +15,6 @@ import {
   DEFAULT_SNAP_TOLERANCE,
   DRAG_THRESHOLD_PX,
   type DragEvent,
-  type DragState,
   dragReducer,
   selectionsToArtboardIds,
 } from '../use-artboard-drag.tsx';