@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/test/edit-suppress.test.ts

@@ -1,170 +0,0 @@
-// RC1 + RC2 (rca/issue-canvas-hmr-optimistic-update-consistency) — inline edits
-// (inspector CSS knobs / inline text / attr panel) are USER-originated and must
-// not light the "agent works here" rim: every edit op arms `activity:suppress`
-// before its write (disarming on no-op/throw), and the activity tracker swallows
-// EVERY fs:any inside the suppression window (not just the first — the old
-// one-shot let the 2nd event of a same-file write burst through).
-
-import { describe, expect, test } from 'bun:test';
-import { join } from 'node:path';
-
-import { createActivity } from '../activity.ts';
-import { createApi } from '../api.ts';
-import { transpileCanvasSource } from '../canvas-pipeline.ts';
-import { type Context, createBus } from '../context.ts';
-import { makeSandbox } from './_helpers.ts';
-
-function mkCtx(root: string, designRoot: string): Context {
-  return {
-    cfg: {} as Context['cfg'],
-    projectLabel: 'test',
-    bus: createBus(),
-    paths: {
-      repoRoot: root,
-      designRel: '.design',
-      designRoot,
-      serverInfoFile: join(designRoot, '_server.json'),
-      activeFile: join(designRoot, '_active.json'),
-      commentsDir: join(designRoot, '_comments'),
-      canvasStateDir: join(designRoot, '_canvas-state'),
-      historyDir: join(designRoot, '_history'),
-      tokensUrlRel: '',
-      systemDirRel: 'system',
-    },
-  };
-}
-
-const SRC = `export default function Knob() {
-  return (
-    <section>
-      <div id="a">Alpha</div>
-      <div id="b">Beta</div>
-    </section>
-  );
-}`;
-
-/** Map author `id="X"` → the data-cd-id the pipeline injects (reorder-test trick). */
-function cdIds(abs: string, source: string): Record<string, string> {
-  const { withIds } = transpileCanvasSource(abs, source);
-  const out: Record<string, string> = {};
-  for (const m of withIds.matchAll(/data-cd-id="([0-9a-f]{8})"[^>]*?\bid="([^"]+)"/g)) {
-    out[m[2] as string] = m[1] as string;
-  }
-  return out;
-}
-
-interface Rig {
-  ctx: Context;
-  api: ReturnType<typeof createApi>;
-  ids: Record<string, string>;
-  suppressed: string[];
-  unsuppressed: string[];
-}
-
-async function mkRig(): Promise<Rig> {
-  const { root, designRoot } = makeSandbox();
-  const abs = join(designRoot, 'ui', 'Knob.tsx');
-  await Bun.write(abs, SRC);
-  const ctx = mkCtx(root, designRoot);
-  const api = createApi(ctx, { onCommentsChanged: () => {} });
-  const suppressed: string[] = [];
-  const unsuppressed: string[] = [];
-  ctx.bus.on('activity:suppress', (rel: string) => suppressed.push(rel));
-  ctx.bus.on('activity:unsuppress', (rel: string) => unsuppressed.push(rel));
-  return { ctx, api, ids: cdIds(abs, SRC), suppressed, unsuppressed };
-}
-
-describe('inline edits arm activity:suppress (RC1)', () => {
-  test('editCss arms suppress before the write and does not disarm on success', async () => {
-    const rig = await mkRig();
-    const res = await rig.api.editCss({
-      canvas: 'ui/Knob',
-      id: rig.ids.a,
-      property: 'color',
-      value: 'red',
-    });
-    expect(res.ok).toBe(true);
-    if (res.ok) expect(res.delta).toBeGreaterThan(0);
-    expect(rig.suppressed).toEqual(['ui/Knob.tsx']);
-    expect(rig.unsuppressed).toEqual([]);
-  });
-
-  test('editText and editAttr arm suppress too', async () => {
-    const rig = await mkRig();
-    const t = await rig.api.editText({ canvas: 'ui/Knob', id: rig.ids.a, text: 'Gamma' });
-    expect(t.ok).toBe(true);
-    const a = await rig.api.editAttr({
-      canvas: 'ui/Knob',
-      id: rig.ids.b,
-      attr: 'data-x',
-      value: 'on',
-    });
-    expect(a.ok).toBe(true);
-    expect(rig.suppressed).toEqual(['ui/Knob.tsx', 'ui/Knob.tsx']);
-    expect(rig.unsuppressed).toEqual([]);
-  });
-
-  test('a no-op edit disarms (no write happened — the next agent edit must rim)', async () => {
-    const rig = await mkRig();
-    // Removing an inline style that was never set is delta-0 by contract.
-    const res = await rig.api.editCss({
-      canvas: 'ui/Knob',
-      id: rig.ids.a,
-      property: 'color',
-      reset: true,
-    });
-    expect(res.ok).toBe(true);
-    if (res.ok) expect(res.delta).toBe(0);
-    expect(rig.suppressed).toEqual(['ui/Knob.tsx']);
-    expect(rig.unsuppressed).toEqual(['ui/Knob.tsx']);
-  });
-
-  test('a failed edit disarms', async () => {
-    const rig = await mkRig();
-    // Valid id shape, but no such element — canvas-edit throws, op returns 422.
-    const res = await rig.api.editCss({
-      canvas: 'ui/Knob',
-      id: '00000000',
-      property: 'color',
-      value: 'red',
-    });
-    expect(res.ok).toBe(false);
-    expect(rig.unsuppressed).toEqual(['ui/Knob.tsx']);
-  });
-});
-
-describe('suppression window swallows the whole burst (RC2)', () => {
-  test('every fs:any inside the TTL is swallowed; post-TTL marks active again', async () => {
-    const rig = await mkRig();
-    const activity = createActivity(rig.ctx, { idleMs: 20, diff: false, suppressTtlMs: 150 });
-    const changes: Array<{ status: string }> = [];
-    rig.ctx.bus.on('activity:change', (c: { status: string }) => changes.push(c));
-
-    await rig.api.editCss({ canvas: 'ui/Knob', id: rig.ids.a, property: 'color', value: 'red' });
-    // Simulate the watcher: an editor save often lands as several debounced
-    // events — the old one-shot suppress let the 2nd one light the rim.
-    rig.ctx.bus.emit('fs:any', 'ui/Knob.tsx');
-    rig.ctx.bus.emit('fs:any', 'ui/Knob.tsx');
-    rig.ctx.bus.emit('fs:any', 'ui/Knob.tsx');
-    expect(changes).toHaveLength(0);
-
-    // After the TTL expires the same file must rim again (agent edit case).
-    await new Promise((r) => setTimeout(r, 180));
-    rig.ctx.bus.emit('fs:any', 'ui/Knob.tsx');
-    expect(changes).toHaveLength(1);
-    expect(changes[0]?.status).toBe('active');
-    activity.stop();
-  });
-
-  test('unsuppress (failed edit) restores the rim immediately', async () => {
-    const rig = await mkRig();
-    const activity = createActivity(rig.ctx, { idleMs: 20, diff: false, suppressTtlMs: 5000 });
-    const changes: Array<{ status: string }> = [];
-    rig.ctx.bus.on('activity:change', (c: { status: string }) => changes.push(c));
-
-    await rig.api.editCss({ canvas: 'ui/Knob', id: '00000000', property: 'color', value: 'red' });
-    rig.ctx.bus.emit('fs:any', 'ui/Knob.tsx');
-    expect(changes).toHaveLength(1); // not muted — the arm was rolled back
-    activity.stop();
-  });
-});

package/apps/studio/test/editing-presence.test.ts

@@ -1,103 +0,0 @@
-// Unit: soft editing-presence (Phase 30) — the `editing` awareness field at the
-// hub trust boundary. Locking is deliberately NOT built (no lease/takeover); the
-// `editing` field is a soft heads-up. Every foreign value is attacker-influenceable
-// through the semi-trusted hub (DDR-054), so it MUST be validated for VALUE — a
-// future / NaN / non-positive `since` is rejected so a hostile peer can't pin a
-// permanent badge or poison a `Date.now() - since` age computation.
-
-import { describe, expect, test } from 'bun:test';
-
-import { createRoom, type RoomCallbacks } from '../collab/room.ts';
-import { sanitizeForeignState } from '../use-collab.tsx';
-
-const noopCallbacks: RoomCallbacks = {
-  seed() {},
-  persistJson() {},
-  persistBinary() {},
-};
-
-describe('sanitizeForeignState — editing field (Phase 30)', () => {
-  test('keeps a valid current `editing.since`', () => {
-    const now = Date.now();
-    const peer = sanitizeForeignState(3, { name: 'Anna', editing: { since: now } });
-    expect(peer?.editing).toEqual({ since: now });
-  });
-
-  test('absent editing → null (peer is not editing)', () => {
-    const peer = sanitizeForeignState(3, { name: 'Anna' });
-    expect(peer?.editing).toBeNull();
-  });
-
-  test('rejects a FUTURE since beyond the ±5s skew window (no permanent-badge pin)', () => {
-    const future = Date.now() + 60_000;
-    const peer = sanitizeForeignState(3, { name: 'Anna', editing: { since: future } });
-    expect(peer?.editing).toBeNull();
-  });
-
-  test('allows a near-future since inside the 5s skew window', () => {
-    const skew = Date.now() + 3_000;
-    const peer = sanitizeForeignState(3, { name: 'Anna', editing: { since: skew } });
-    expect(peer?.editing).toEqual({ since: skew });
-  });
-
-  test('rejects NaN / Infinity / non-positive since (no Date-math poison)', () => {
-    for (const bad of [Number.NaN, Number.POSITIVE_INFINITY, 0, -1]) {
-      const peer = sanitizeForeignState(3, { name: 'Anna', editing: { since: bad } });
-      expect(peer?.editing).toBeNull();
-    }
-  });
-
-  test('rejects a non-object / malformed editing payload', () => {
-    expect(sanitizeForeignState(3, { name: 'Anna', editing: 'now' })?.editing).toBeNull();
-    expect(sanitizeForeignState(3, { name: 'Anna', editing: 12345 })?.editing).toBeNull();
-    expect(sanitizeForeignState(3, { name: 'Anna', editing: {} })?.editing).toBeNull();
-    expect(sanitizeForeignState(3, { name: 'Anna', editing: { since: '5' } })?.editing).toBeNull();
-  });
-
-  test('editing presence does not disturb the other sanitized fields', () => {
-    const peer = sanitizeForeignState(9, {
-      name: 'Anna',
-      cursor: { x: 1, y: 2 },
-      editing: { since: Date.now() },
-    });
-    expect(peer?.name).toBe('Anna');
-    expect(peer?.cursor).toEqual({ x: 1, y: 2 });
-    expect(peer?.editing).not.toBeNull();
-  });
-});
-
-describe('room.setAgentEditing — agent presence projected onto awareness (Phase 30)', () => {
-  test('projects an editing state that a remote peer can sanitize, then clears it', async () => {
-    const room = createRoom('agent-editing-slug', noopCallbacks);
-    const since = Date.now();
-
-    room.setAgentEditing({ name: 'Anna', since });
-    const states = Array.from(room.awareness.getStates().values());
-    expect(states.length).toBe(1);
-    // The projected state survives the client trust-boundary sanitizer with the
-    // editing field intact (name → re-derived color; since preserved).
-    const sanitized = sanitizeForeignState(1, states[0]);
-    expect(sanitized?.name).toBe('Anna');
-    expect(sanitized?.editing).toEqual({ since });
-
-    room.setAgentEditing(null);
-    expect(room.awareness.getStates().size).toBe(0);
-
-    await room.destroy();
-  });
-
-  test('re-setting the same {name, since} is a no-op (heartbeat re-emit guard)', async () => {
-    const room = createRoom('agent-editing-idempotent', noopCallbacks);
-    const since = Date.now();
-    let updates = 0;
-    room.awareness.on('update', () => {
-      updates += 1;
-    });
-
-    room.setAgentEditing({ name: 'Anna', since });
-    room.setAgentEditing({ name: 'Anna', since }); // identical → no second update
-    expect(updates).toBe(1);
-
-    await room.destroy();
-  });
-});

package/apps/studio/test/element-resize.test.ts

@@ -1,136 +0,0 @@
-// element-resize — feature-element-editing-robustness Stage D (Task D1 + G2).
-// Pure resize math: `computeElementResize(corner, start, dxW, dyW, mods, flags)`.
-// World-unit deltas → target box, deriving left/top only when the moved edge
-// permits it (out-of-flow element with an inline value), holding the opposite
-// edge fixed (Figma grammar).
-
-import { describe, expect, test } from 'bun:test';
-import {
-  computeElementResize,
-  type ElResizeStart,
-  pointerAngleRad,
-  rotateDeltaDeg,
-  rotatePointDeg,
-  rotationDegFromMatrix,
-  scaleFromMatrix,
-} from '../use-element-resize.tsx';
-
-const NO_MODS = { aspect: false, center: false };
-const NO_MOVE = { canMoveLeft: false, canMoveTop: false };
-const CAN_MOVE = { canMoveLeft: true, canMoveTop: true };
-
-// A 200×100 box at left:50 top:30 (out-of-flow when CAN_MOVE).
-const START: ElResizeStart = { w: 200, h: 100, left: 50, top: 30 };
-
-describe('computeElementResize — plain drags', () => {
-  test('SE corner grows width + height, never moves origin', () => {
-    const r = computeElementResize('se', START, 40, 20, NO_MODS, CAN_MOVE);
-    expect(r.width).toBe(240);
-    expect(r.height).toBe(120);
-    expect(r.left).toBeUndefined();
-    expect(r.top).toBeUndefined();
-  });
-
-  test('E edge changes width only', () => {
-    const r = computeElementResize('e', START, 30, 999, NO_MODS, CAN_MOVE);
-    expect(r.width).toBe(230);
-    expect(r.height).toBe(100);
-  });
-
-  test('S edge changes height only', () => {
-    const r = computeElementResize('s', START, 999, -25, NO_MODS, CAN_MOVE);
-    expect(r.width).toBe(200);
-    expect(r.height).toBe(75);
-  });
-
-  test('NW corner (out-of-flow) moves left+top, SE corner stays fixed', () => {
-    // Drag NW by (+10, +10): width 190, height 90; left 60, top 40.
-    const r = computeElementResize('nw', START, 10, 10, NO_MODS, CAN_MOVE);
-    expect(r.width).toBe(190);
-    expect(r.height).toBe(90);
-    expect(r.left).toBe(60); // start.left + start.w - width = 50 + 200 - 190
-    expect(r.top).toBe(40); // start.top + start.h - height = 30 + 100 - 90
-    // Opposite (SE) corner is invariant: left+width and top+height unchanged.
-    expect((r.left as number) + r.width).toBe(START.left + START.w);
-    expect((r.top as number) + r.height).toBe(START.top + START.h);
-  });
-
-  test('NW corner IN-FLOW resizes width/height but never writes left/top', () => {
-    const r = computeElementResize('nw', START, 10, 10, NO_MODS, NO_MOVE);
-    expect(r.width).toBe(190);
-    expect(r.height).toBe(90);
-    expect(r.left).toBeUndefined();
-    expect(r.top).toBeUndefined();
-  });
-
-  test('W edge (out-of-flow) moves left, keeps the east edge fixed', () => {
-    const r = computeElementResize('w', START, -20, 0, NO_MODS, CAN_MOVE);
-    expect(r.width).toBe(220); // start.w - dxW = 200 - (-20)
-    expect(r.left).toBe(30); // 50 + 200 - 220
-    expect(r.top).toBeUndefined();
-  });
-});
-
-describe('computeElementResize — modifiers', () => {
-  test('Shift on SE corner locks the start aspect ratio (2:1)', () => {
-    // Bigger horizontal change → height driven by width to keep 2:1.
-    const r = computeElementResize('se', START, 100, 5, { aspect: true, center: false }, CAN_MOVE);
-    expect(r.width).toBe(300);
-    expect(r.height).toBe(150); // 300 / (200/100)
-    expect(r.width / r.height).toBe(START.w / START.h);
-  });
-
-  test('Alt on E edge (out-of-flow) resizes from center: 2× delta, left shifts', () => {
-    const r = computeElementResize('e', START, 20, 0, { aspect: false, center: true }, CAN_MOVE);
-    expect(r.width).toBe(240); // 200 + 2*20
-    expect(r.left).toBe(30); // center-preserving: 50 + (200-240)/2
-    // Center is invariant: left + width/2 unchanged.
-    expect((r.left as number) + r.width / 2).toBe(START.left + START.w / 2);
-  });
-
-  test('shrinking past zero clamps to the 1px minimum', () => {
-    const r = computeElementResize('se', START, -500, -500, NO_MODS, CAN_MOVE);
-    expect(r.width).toBe(1);
-    expect(r.height).toBe(1);
-  });
-});
-
-describe('rotate math (Task L8)', () => {
-  test('rotationDegFromMatrix reads the angle', () => {
-    expect(rotationDegFromMatrix('none')).toBe(0);
-    expect(rotationDegFromMatrix(null)).toBe(0);
-    expect(rotationDegFromMatrix('matrix(1, 0, 0, 1, 0, 0)')).toBe(0);
-    expect(rotationDegFromMatrix('matrix(0, 1, -1, 0, 0, 0)')).toBe(90); // CW 90°
-    expect(Math.round(rotationDegFromMatrix('matrix(0.7071, 0.7071, -0.7071, 0.7071, 0, 0)'))).toBe(
-      45
-    );
-  });
-
-  test('scaleFromMatrix reads the .dc-world zoom', () => {
-    expect(scaleFromMatrix('none')).toBe(1);
-    expect(scaleFromMatrix('matrix(2, 0, 0, 2, 100, 50)')).toBe(2);
-    // Scale survives a combined rotate+scale (magnitude of the first column).
-    expect(scaleFromMatrix('matrix(0, 1.5, -1.5, 0, 0, 0)')).toBe(1.5);
-  });
-
-  test('rotatePointDeg rotates a local offset (screen y-down, CW positive)', () => {
-    const [x0, y0] = rotatePointDeg(10, 0, 0);
-    expect(x0).toBeCloseTo(10);
-    expect(y0).toBeCloseTo(0);
-    const [x90, y90] = rotatePointDeg(10, 0, 90);
-    expect(x90).toBeCloseTo(0);
-    expect(y90).toBeCloseTo(10);
-  });
-
-  test('rotateDeltaDeg turns by the change in center→pointer angle; Shift snaps 15°', () => {
-    const start = pointerAngleRad(100, 100, 200, 100); // pointer right → 0 rad
-    const down = pointerAngleRad(100, 100, 100, 200); // pointer down → +π/2
-    // From 0°, dragging the pointer from right to down = +90°.
-    expect(rotateDeltaDeg(0, start, down, false)).toBe(90);
-    // No pointer change → angle unchanged (relative model).
-    expect(rotateDeltaDeg(30, start, start, false)).toBe(30);
-    // Shift snaps to a 15° multiple.
-    expect(rotateDeltaDeg(0, start, down, true) % 15).toBe(0);
-    expect(rotateDeltaDeg(0, start, down, true)).toBe(90);
-  });
-});