@1agh/maude 0.60.3 → 0.60.5

package/apps/studio/test/sync-fresh-link-parity.test.ts

@@ -0,0 +1,267 @@
+// THE ACCEPTANCE GATE — feature-sync-file-plane.
+//
+// The RCA's shape, made a test: a fresh link delivered 79/79 canvases and
+// lost 103 files, because sync's unit was a canvas and everything else had no
+// lane. The user-visible contract this feature ships is "what's in the folder
+// syncs": a fresh, EMPTY design root linked to a project ends up
+// FILE-FOR-FILE equal to the source — minus exactly `config.json` (the trust
+// anchors) and Maude runtime state, which must never travel.
+//
+// The hub half is REAL: the actual `handleFilesRoute` / `handleProjectFileRoute`
+// handlers (apps/hub/src/file-manifest.mjs) mounted on a real `node:http`
+// server over a real source tree. Token VERIFICATION is injected (the same
+// `verify` seam the documents-route harness uses — the sqlite token store is
+// a native module bun cannot open); the real store is exercised by the hub's
+// own node suite. The peer half is the real `pullFiles`. What is SIMULATED is
+// plane A: the canvas body and its named sidecars are pre-written on the peer
+// the way the Yjs canvas lanes deliver them — that transport has its own
+// suite (sync-runtime, two-client-sync); this test's subject is everything
+// plane A does NOT carry, and the disjointness between the two.
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+
+import {
+  type Dirent,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { createServer, type Server } from 'node:http';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { handleFilesRoute, handleProjectFileRoute } from '../../hub/src/file-manifest.mjs';
+// `matchesScope` is pure; the token STORE itself is native sqlite the bun
+// runtime cannot open, so verification is injected below (the same `verify`
+// seam the documents-route harness uses).
+import { matchesScope } from '../../hub/src/tokens.mjs';
+import { isRuntimeStateRel } from '../sync/file-membership.ts';
+import { pullFiles } from '../sync/file-pull.ts';
+
+const TOKEN = 'parity-peer-token';
+const verify = (t: string) => (t === TOKEN ? { scope: '*', label: 'peer' } : null);
+
+const CANVAS_GROUPS = [{ path: 'ui' }, { path: 'system' }];
+
+/** The RCA fixture: one canvas plus every file class the fresh link lost. */
+function seedSource(root: string): void {
+  mkdirSync(path.join(root, 'ui'), { recursive: true });
+  mkdirSync(path.join(root, 'system/ds/preview'), { recursive: true });
+  mkdirSync(path.join(root, 'system/ds/assets/logos'), { recursive: true });
+  mkdirSync(path.join(root, 'assets'), { recursive: true });
+  mkdirSync(path.join(root, '_history/junk'), { recursive: true });
+  writeFileSync(
+    path.join(root, 'config.json'),
+    JSON.stringify({ canvasGroups: CANVAS_GROUPS, linkedHub: { url: 'http://x', syncFiles: true } })
+  );
+  // Plane A's cargo — the canvas and its named sidecars.
+  writeFileSync(path.join(root, 'ui/welcome.tsx'), 'export default () => null');
+  writeFileSync(path.join(root, 'ui/welcome.meta.json'), '{"title":"Welcome"}');
+  writeFileSync(path.join(root, 'system/ds/preview/specimen.tsx'), 'export default 1');
+  writeFileSync(path.join(root, 'system/ds/preview/specimen.css'), '.spec{}');
+  // Plane B's cargo — the 103-file gap's representatives.
+  writeFileSync(path.join(root, 'system/ds/brand.css'), ':root { --bg-0: #fff }');
+  writeFileSync(path.join(root, 'system/ds/README.md'), '# the design system');
+  writeFileSync(path.join(root, 'system/ds/preview/_layout.css'), '.layout{}');
+  writeFileSync(path.join(root, 'system/ds/preview/_brand-css.ts'), 'import "./x.css"');
+  writeFileSync(path.join(root, 'system/ds/assets/logos/logo.svg'), '<svg/>');
+  writeFileSync(path.join(root, 'assets/c0fa9c7f.png'), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+  // What must NEVER travel.
+  writeFileSync(path.join(root, '_history/junk/old.tsx'), 'stale');
+  writeFileSync(path.join(root, '_server.json'), '{"pid":1}');
+}
+
+/** Plane A's delivery, simulated: what the canvas CRDT lanes put on a fresh
+ *  peer (body + named sidecars), byte-identical to the source. */
+function deliverPlaneA(source: string, peer: string): void {
+  for (const rel of [
+    'ui/welcome.tsx',
+    'ui/welcome.meta.json',
+    'system/ds/preview/specimen.tsx',
+    'system/ds/preview/specimen.css',
+  ]) {
+    mkdirSync(path.dirname(path.join(peer, rel)), { recursive: true });
+    writeFileSync(path.join(peer, rel), readFileSync(path.join(source, rel)));
+  }
+}
+
+/** Every file in a tree, designRoot-relative, sorted. */
+function walkTree(root: string): string[] {
+  const out: string[] = [];
+  const walk = (dir: string, rel: string): void => {
+    let entries: Dirent[];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) walk(path.join(dir, entry.name), childRel);
+      else if (entry.isFile()) out.push(childRel);
+    }
+  };
+  walk(root, '');
+  return out.sort();
+}
+
+/** The parity domain: everything except the trust anchors + runtime state. */
+function syncableSet(root: string): string[] {
+  return walkTree(root).filter((rel) => rel !== 'config.json' && !isRuntimeStateRel(rel));
+}
+
+let sourceRoot: string;
+let server: Server;
+let hubUrl: string;
+
+beforeAll(async () => {
+  sourceRoot = mkdtempSync(path.join(tmpdir(), 'maude-parity-src-'));
+  seedSource(sourceRoot);
+
+  // The REAL hub handlers on a real socket — encoding, headers and streaming
+  // all take the same path production takes.
+  server = createServer((req, res) => {
+    const pathname = (req.url ?? '').split('?')[0] ?? '';
+    const bearer = (req.headers.authorization ?? '').replace(/^Bearer\s+/i, '').trim() || null;
+    if (pathname === '/api/files') {
+      handleFilesRoute({
+        path: pathname,
+        method: req.method ?? 'GET',
+        bearer,
+        verify,
+        matchesScope,
+        designRoot: sourceRoot,
+        respondJson: (status: number, payload: unknown) => {
+          const body = JSON.stringify(payload);
+          res.writeHead(status, { 'Content-Type': 'application/json' }).end(body);
+        },
+      });
+      return;
+    }
+    void handleProjectFileRoute({
+      request: req,
+      response: res,
+      pathname,
+      method: req.method ?? 'GET',
+      dataDir: '/nonexistent', // unused — `verify` is injected
+      secret: '',
+      verify,
+      designRoot: sourceRoot,
+      matchesScope,
+    }).then((handled: boolean) => {
+      if (!handled) res.writeHead(404).end('not found');
+    });
+  });
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const addr = server.address();
+  hubUrl = `http://127.0.0.1:${typeof addr === 'object' && addr ? addr.port : 0}`;
+});
+
+afterAll(async () => {
+  await new Promise((resolve) => server.close(resolve));
+  rmSync(sourceRoot, { recursive: true, force: true });
+});
+
+const silent = { log: () => {}, warn: () => {} };
+
+describe('fresh-link parity — the whole project arrives', () => {
+  test('an empty peer converges to file-for-file equality minus config + runtime state', async () => {
+    const peerRoot = mkdtempSync(path.join(tmpdir(), 'maude-parity-peer-'));
+    try {
+      deliverPlaneA(sourceRoot, peerRoot);
+      const result = await pullFiles({
+        designRoot: peerRoot,
+        hubUrl,
+        token: () => TOKEN,
+        canvasGroups: CANVAS_GROUPS,
+        allowCodeModules: true, // an owner's fresh link
+        log: silent,
+      });
+      expect(result.failed).toEqual([]);
+      expect(result.dropped).toEqual([]);
+
+      // THE acceptance assertion: the RCA's `diff -rq`, as a set + bytes.
+      const want = syncableSet(sourceRoot);
+      expect(syncableSet(peerRoot)).toEqual(want);
+      for (const rel of want) {
+        expect(readFileSync(path.join(peerRoot, rel))).toEqual(
+          readFileSync(path.join(sourceRoot, rel))
+        );
+      }
+
+      // …and the excluded set is EXCLUDED, not merely equal.
+      const arrived = walkTree(peerRoot);
+      expect(arrived.includes('config.json')).toBe(false);
+      expect(arrived.some((rel) => rel.startsWith('_history/'))).toBe(false);
+      expect(arrived.includes('_server.json')).toBe(false);
+
+      // A second pass is the steady state: everything skips, nothing moves.
+      const again = await pullFiles({
+        designRoot: peerRoot,
+        hubUrl,
+        token: () => TOKEN,
+        canvasGroups: CANVAS_GROUPS,
+        allowCodeModules: true,
+        log: silent,
+      });
+      expect(again.pulled).toEqual([]);
+      expect(again.skipped).toBe(result.pulled.length);
+      expect(again.conflicts).toEqual([]);
+    } finally {
+      rmSync(peerRoot, { recursive: true, force: true });
+    }
+  });
+
+  test('without the owner gate the same link arrives minus code modules only', async () => {
+    const peerRoot = mkdtempSync(path.join(tmpdir(), 'maude-parity-member-'));
+    try {
+      deliverPlaneA(sourceRoot, peerRoot);
+      const result = await pullFiles({
+        designRoot: peerRoot,
+        hubUrl,
+        token: () => TOKEN,
+        canvasGroups: CANVAS_GROUPS,
+        allowCodeModules: false, // a member's fresh link
+        log: silent,
+      });
+      const want = syncableSet(sourceRoot).filter(
+        (rel) => rel !== 'system/ds/preview/_brand-css.ts'
+      );
+      expect(syncableSet(peerRoot)).toEqual(want);
+      expect(result.dropped.map((d) => d.rel)).toEqual(['system/ds/preview/_brand-css.ts']);
+    } finally {
+      rmSync(peerRoot, { recursive: true, force: true });
+    }
+  });
+
+  test('the wire itself never offers a canvas body — disjointness holds end-to-end', async () => {
+    const res = await fetch(`${hubUrl}/api/files`, {
+      headers: { authorization: `Bearer ${TOKEN}` },
+    });
+    const body = (await res.json()) as { files: { path: string; class: string }[] };
+    const offered = body.files.map((f) => f.path);
+    for (const owned of [
+      'ui/welcome.tsx',
+      'ui/welcome.meta.json',
+      'system/ds/preview/specimen.tsx',
+      'system/ds/preview/specimen.css',
+    ]) {
+      expect(offered.includes(owned)).toBe(false);
+    }
+    for (const never of ['config.json', '_server.json', '_history/junk/old.tsx']) {
+      expect(offered.includes(never)).toBe(false);
+    }
+    // …and refusing to SERVE them outright, even when asked by name.
+    for (const refused of ['config.json', 'ui/welcome.tsx', '_server.json']) {
+      const read = await fetch(`${hubUrl}/_project-file/${encodeURIComponent(refused)}`, {
+        headers: { authorization: `Bearer ${TOKEN}` },
+      });
+      expect(read.status).toBe(404);
+    }
+  });
+});

package/apps/studio/test/sync-remote-docs.test.ts

@@ -10,9 +10,11 @@ import { canvasSlugFromRel } from '../canvas-slug.ts';
 import {
   describeRemoteDiff,
   diffRemoteDocs,
-  fetchRemoteDocs,
+  fetchRemoteListing,
   pullTargets,
   slugFromDocName,
+  stateDocumentGone,
+  tombstonedSlugs,
 } from '../sync/remote-docs.ts';
 
 const okFetch = (documents: unknown) =>
@@ -22,14 +24,14 @@ const okFetch = (documents: unknown) =>
       headers: { 'content-type': 'application/json' },
     })) as unknown as typeof fetch;
 
-describe('fetchRemoteDocs', () => {
+describe('fetchRemoteListing', () => {
   test('reads the hub listing', async () => {
-    const docs = await fetchRemoteDocs(
+    const listing = await fetchRemoteListing(
       'https://hub.example',
       't',
       okFetch([{ name: 'ui-welcome', bytes: 2931 }])
     );
-    expect(docs).toEqual([{ name: 'ui-welcome', bytes: 2931 }]);
+    expect(listing?.documents).toEqual([{ name: 'ui-welcome', bytes: 2931 }]);
   });
 
   test('carries the token as a bearer, and strips a trailing slash', async () => {
@@ -40,7 +42,7 @@ describe('fetchRemoteDocs', () => {
       seenAuth = String((init.headers as Record<string, string>).authorization);
       return new Response(JSON.stringify({ documents: [] }), { status: 200 });
     }) as unknown as typeof fetch;
-    await fetchRemoteDocs('https://hub.example/', 'tok123', spy);
+    await fetchRemoteListing('https://hub.example/', 'tok123', spy);
     expect(seenUrl).toBe('https://hub.example/api/documents');
     expect(seenAuth).toBe('Bearer tok123');
   });
@@ -51,16 +53,124 @@ describe('fetchRemoteDocs', () => {
     const boom = (async () => {
       throw new Error('offline');
     }) as unknown as typeof fetch;
-    expect(await fetchRemoteDocs('https://h', 't', boom)).toBeNull();
+    expect(await fetchRemoteListing('https://h', 't', boom)).toBeNull();
 
     const notFound = (async () => new Response('nope', { status: 404 })) as unknown as typeof fetch;
-    expect(await fetchRemoteDocs('https://h', 't', notFound)).toBeNull();
+    expect(await fetchRemoteListing('https://h', 't', notFound)).toBeNull();
 
     const junk = (async () =>
       new Response(JSON.stringify({ documents: 'not-an-array' }), {
         status: 200,
       })) as unknown as typeof fetch;
-    expect(await fetchRemoteDocs('https://h', 't', junk)).toBeNull();
+    expect(await fetchRemoteListing('https://h', 't', junk)).toBeNull();
+  });
+
+  test('reads the tombstones a peer needs to stop resurrecting a delete', async () => {
+    const withStones = (async () =>
+      new Response(
+        JSON.stringify({ documents: [], tombstones: [{ name: 'ui-gone', deletedAt: 42 }] }),
+        { status: 200 }
+      )) as unknown as typeof fetch;
+    const listing = await fetchRemoteListing('https://h', 't', withStones);
+    expect(listing?.tombstones).toEqual([{ name: 'ui-gone', deletedAt: 42 }]);
+  });
+
+  test('a hub with no tombstone route reports no deletions, not a failure', async () => {
+    // "This hub cannot say" and "nothing was deleted" must behave identically:
+    // change nothing on disk. Anything else would make an old hub delete work.
+    const listing = await fetchRemoteListing(
+      'https://h',
+      't',
+      okFetch([{ name: 'ui-welcome', bytes: 1 }])
+    );
+    expect(listing?.tombstones).toEqual([]);
+    expect(listing?.documents).toHaveLength(1);
+  });
+
+  test('a junk tombstone field is read as no deletions', async () => {
+    const hostile = (async () =>
+      new Response(JSON.stringify({ documents: [], tombstones: 'everything' }), {
+        status: 200,
+      })) as unknown as typeof fetch;
+    expect((await fetchRemoteListing('https://h', 't', hostile))?.tombstones).toEqual([]);
+  });
+});
+
+describe('tombstonedSlugs', () => {
+  test('names only the slugs this peer actually holds', () => {
+    const slugs = tombstonedSlugs(
+      [
+        { name: 'ui-gone', deletedAt: 1 },
+        { name: 'ui-never-had-it', deletedAt: 2 },
+      ],
+      ['ui-gone', 'ui-welcome']
+    );
+    expect(slugs).toEqual(['ui-gone']);
+  });
+
+  test('refuses a name that could place a file outside the design root', () => {
+    // The one hub-supplied signal whose effect is to REMOVE work, so it runs
+    // through the same gate a pull does.
+    expect(
+      tombstonedSlugs(
+        [
+          { name: '../../etc/passwd', deletedAt: 1 },
+          { name: 'ui/../../x', deletedAt: 1 },
+          { name: 'ui-real.tsx', deletedAt: 1 },
+        ],
+        ['passwd', 'x', 'ui-real', 'ui-real.tsx']
+      )
+    ).toEqual([]);
+  });
+
+  test('deduplicates a hub naming the same canvas flat and namespaced', () => {
+    expect(
+      tombstonedSlugs(
+        [
+          { name: 'ui-gone', deletedAt: 1 },
+          { name: 'ws/acme/main/ui-gone', deletedAt: 2 },
+        ],
+        ['ui-gone']
+      )
+    ).toEqual(['ui-gone']);
+  });
+});
+
+describe('stateDocumentGone', () => {
+  test('DELETEs the document, percent-encoding the name', async () => {
+    let seenUrl = '';
+    let seenMethod = '';
+    const spy = (async (url: string, init: RequestInit) => {
+      seenUrl = String(url);
+      seenMethod = String(init.method);
+      return new Response('{}', { status: 200 });
+    }) as unknown as typeof fetch;
+    const ok = await stateDocumentGone('https://hub.example/', 't', 'ws/acme/main/ui-x', {
+      fetchImpl: spy,
+    });
+    expect(ok).toBe(true);
+    expect(seenMethod).toBe('DELETE');
+    expect(seenUrl).toBe('https://hub.example/api/documents/ws%2Facme%2Fmain%2Fui-x');
+  });
+
+  test('POSTs to revive, so a re-created name is not eaten by its gravestone', async () => {
+    let seenMethod = '';
+    const spy = (async (_url: string, init: RequestInit) => {
+      seenMethod = String(init.method);
+      return new Response('{}', { status: 200 });
+    }) as unknown as typeof fetch;
+    await stateDocumentGone('https://h', 't', 'ui-x', { revive: true, fetchImpl: spy });
+    expect(seenMethod).toBe('POST');
+  });
+
+  test('an old or unreachable hub is false, never a throw', async () => {
+    // The local delete already happened; a failed call costs the propagation.
+    const boom = (async () => {
+      throw new Error('offline');
+    }) as unknown as typeof fetch;
+    expect(await stateDocumentGone('https://h', 't', 'ui-x', { fetchImpl: boom })).toBe(false);
+    const gone = (async () => new Response('nope', { status: 404 })) as unknown as typeof fetch;
+    expect(await stateDocumentGone('https://h', 't', 'ui-x', { fetchImpl: gone })).toBe(false);
   });
 });
 

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

@@ -171,4 +171,22 @@ describe('sync status store — asset lane (feature-sync-progress-modal)', () =>
     store.update(snap());
     expect('assets' in store.get()).toBe(false);
   });
+
+  test('updateFiles() merges the file plane into the payload + flushes', () => {
+    // feature-sync-file-plane — same slice discipline as assets: a lane, not
+    // a connection, surviving later monitor updates untouched.
+    const { store, writes, broadcasts } = makeStore();
+    const files = { synced: 103, pulled: 103, conflicts: 1 };
+    store.updateFiles(files);
+    expect(writes[writes.length - 1].files).toEqual(files);
+    expect(broadcasts[broadcasts.length - 1].files).toEqual(files);
+    store.update(snap({ state: 'online' }));
+    expect(store.get().files).toEqual(files);
+  });
+
+  test('payloads before the first file-plane emit carry no files field', () => {
+    const { store } = makeStore();
+    store.update(snap());
+    expect('files' in store.get()).toBe(false);
+  });
 });

package/apps/studio/test/sync-tombstone-apply.test.ts

@@ -0,0 +1,111 @@
+// Acting on a deletion the project stated — see sync/tombstone-apply.ts.
+//
+// The rule under test is the one that makes it acceptable for a hub signal to
+// remove local files at all: QUARANTINE, NEVER DELETE.
+
+import { describe, expect, test } from 'bun:test';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { quarantineCanvas } from '../sync/tombstone-apply.ts';
+
+function project(lanes: string[]): string {
+  const root = mkdtempSync(path.join(tmpdir(), 'maude-tombstone-'));
+  mkdirSync(path.join(root, 'ui'), { recursive: true });
+  for (const lane of lanes) {
+    const abs = path.join(root, lane);
+    mkdirSync(path.dirname(abs), { recursive: true });
+    writeFileSync(abs, `contents of ${lane}`);
+  }
+  return root;
+}
+
+function lanesFor(root: string) {
+  return {
+    html: path.join(root, 'ui/card.tsx'),
+    meta: path.join(root, 'ui/card.meta.json'),
+    css: path.join(root, 'ui/card.css'),
+    annotations: path.join(root, 'ui-card.annotations.svg'),
+  };
+}
+
+describe('quarantineCanvas', () => {
+  test('moves the canvas out of the tree and into _trash, never deleting it', () => {
+    const root = project([
+      'ui/card.tsx',
+      'ui/card.meta.json',
+      'ui/card.css',
+      'ui-card.annotations.svg',
+    ]);
+    const move = quarantineCanvas({
+      designRoot: root,
+      slug: 'ui-card',
+      lanes: lanesFor(root),
+      now: 1234,
+      log: () => {},
+    });
+
+    expect(move?.trashedTo).toBe('_trash/ui-card-deleted-1234');
+    // Gone from the tree...
+    expect(existsSync(path.join(root, 'ui/card.tsx'))).toBe(false);
+    // ...and recoverable, which is the whole point.
+    const trashed = readdirSync(path.join(root, '_trash/ui-card-deleted-1234')).sort();
+    expect(trashed).toEqual(['card.css', 'card.meta.json', 'card.tsx', 'ui-card.annotations.svg']);
+  });
+
+  test('the annotations sidecar travels with the body', () => {
+    // A body stripped of its annotations is not a restorable canvas — the
+    // sidecar lives at the design root under the flat slug, so it is the one
+    // lane a naive "move the folder" would leave behind.
+    const root = project(['ui/card.tsx', 'ui-card.annotations.svg']);
+    quarantineCanvas({
+      designRoot: root,
+      slug: 'ui-card',
+      lanes: lanesFor(root),
+      now: 1,
+      log: () => {},
+    });
+    expect(existsSync(path.join(root, 'ui-card.annotations.svg'))).toBe(false);
+    expect(existsSync(path.join(root, '_trash/ui-card-deleted-1/ui-card.annotations.svg'))).toBe(
+      true
+    );
+  });
+
+  test('a canvas already gone is a no-op, not an error', () => {
+    // The steady state once both peers have converged: every later poll repeats
+    // the same tombstone and must find nothing to do.
+    const root = project([]);
+    expect(
+      quarantineCanvas({ designRoot: root, slug: 'ui-card', lanes: lanesFor(root), log: () => {} })
+    ).toBeNull();
+    expect(existsSync(path.join(root, '_trash'))).toBe(false);
+  });
+
+  test('moves what it can when a lane is missing', () => {
+    const root = project(['ui/card.tsx']);
+    const move = quarantineCanvas({
+      designRoot: root,
+      slug: 'ui-card',
+      lanes: lanesFor(root),
+      now: 7,
+      log: () => {},
+    });
+    expect(move?.moved).toEqual(['ui/card.tsx']);
+  });
+
+  test('leaves per-machine runtime state alone', () => {
+    // `_history/`, `_comments/` and `_canvas-state/` are per-machine runtime
+    // state (DDR-115). Sweeping them would make a recoverable delete lossy.
+    const root = project(['ui/card.tsx', '_history/ui-card/1.tsx', '_comments/ui-card.json']);
+    quarantineCanvas({
+      designRoot: root,
+      slug: 'ui-card',
+      lanes: lanesFor(root),
+      now: 2,
+      log: () => {},
+    });
+    expect(existsSync(path.join(root, '_history/ui-card/1.tsx'))).toBe(true);
+    expect(existsSync(path.join(root, '_comments/ui-card.json'))).toBe(true);
+  });
+});

package/apps/studio/whats-new.json

@@ -1,6 +1,24 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "annotations-survive-cold-start",
+      "version": "0.60.5",
+      "date": "2026-08-14",
+      "kind": "fix",
+      "title": "Your drawings survive a cloud restart",
+      "summary": "Stickers, drawings and dropped images on the canvas no longer vanish after the cloud restarts, and a freshly added image now reaches your other machines instead of showing a broken frame. Annotations keep their own edit time now, and an empty record can never silently replace real strokes.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "self-contained-asset-sweep",
+      "version": "0.60.5",
+      "date": "2026-08-14",
+      "kind": "fix",
+      "title": "Asset upload works on a clean machine",
+      "summary": "The desktop app uploads your project images with its own bundled runtime, so the upload no longer fails with an executable-not-found error on machines without developer tools installed.",
+      "surface": "design-ui"
+    },
     {
       "id": "continuous-sync-discovery",
       "version": "0.60.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "0.60.3",
+  "version": "0.60.5",
   "description": "Marketplace of Claude Code plugins by Michal Dovrtěl: `design` (canvas-first design iteration) + `flow` (generic agentic workflow loop with .ai second brain). Ships the `maude` CLI (with `mdcc` legacy alias) to scaffold workspace, run the design dev server, and manage configs.",
   "type": "module",
   "engines": {
@@ -54,13 +54,13 @@
     "test:e2e:desktop:parity:cloud": "pnpm --filter @maude/desktop-e2e e2e:parity:cloud"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "0.60.3",
-    "@1agh/maude-darwin-x64": "0.60.3",
-    "@1agh/maude-linux-arm64": "0.60.3",
-    "@1agh/maude-linux-arm64-musl": "0.60.3",
-    "@1agh/maude-linux-x64": "0.60.3",
-    "@1agh/maude-linux-x64-musl": "0.60.3",
-    "@1agh/maude-win32-x64": "0.60.3"
+    "@1agh/maude-darwin-arm64": "0.60.5",
+    "@1agh/maude-darwin-x64": "0.60.5",
+    "@1agh/maude-linux-arm64": "0.60.5",
+    "@1agh/maude-linux-arm64-musl": "0.60.5",
+    "@1agh/maude-linux-x64": "0.60.5",
+    "@1agh/maude-linux-x64-musl": "0.60.5",
+    "@1agh/maude-win32-x64": "0.60.5"
   },
   "files": [
     "cli",