@1agh/maude 1.0.11 → 1.3.0

package/apps/studio/bin/_import-figma.mjs

@@ -29,12 +29,14 @@
 
 import { createHash } from 'node:crypto';
 import {
+  copyFileSync,
   existsSync,
   mkdirSync,
   mkdtempSync,
   readFileSync,
   renameSync,
   rmSync,
+  unlinkSync,
   writeFileSync,
 } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
@@ -143,6 +145,50 @@ function makeStagingDir() {
   return mkdtempSync(join(tmpdir(), 'maude-figma-'));
 }
 
+/**
+ * Promote one staged file into the project tree.
+ *
+ * A bare `renameSync` is atomic — and SAME-FILESYSTEM ONLY. Staging lives under
+ * the OS temp root (or `~/.cache/maude/figma-staging` for the codegen lane)
+ * while the project can be anywhere: a second partition, an external drive, a
+ * container volume, a tmpfs `/tmp`. Those are different devices, so the rename
+ * threw `EXDEV: cross-device link not permitted` and the whole import died at
+ * the final step, after every byte of work was already done. It reproduces on
+ * any Linux box where `/tmp` is a tmpfs, which is most of them, and it is why
+ * the figma-explode suite was red.
+ *
+ * The atomicity is not negotiable — nothing may land half-written in the
+ * versioned tree — so this does NOT fall back to a plain copy. It copies into a
+ * sibling temp file IN THE DESTINATION DIRECTORY and renames within that
+ * directory: same filesystem by construction, so the step that publishes the
+ * file is still a single atomic rename.
+ */
+function promoteFile(src, dest) {
+  try {
+    renameSync(src, dest);
+    return;
+  } catch (err) {
+    if (err?.code !== 'EXDEV') throw err;
+  }
+  const tmp = `${dest}.${process.pid}.promote-tmp`;
+  copyFileSync(src, tmp);
+  try {
+    renameSync(tmp, dest);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+      /* best effort — the staged original is still intact */
+    }
+    throw err;
+  }
+  try {
+    unlinkSync(src);
+  } catch {
+    /* staging is reaped wholesale by its own finally */
+  }
+}
+
 /**
  * DDR-219 D8 — a staging directory outside the synced tree, under a STABLE
  * parent.
@@ -548,9 +594,9 @@ export async function importBoard({
     mkdirSync(join(root, designRootRel, 'ui'), { recursive: true });
     // Promote by rename — atomic, and nothing lands in the versioned tree
     // until the whole translation has succeeded.
-    renameSync(stagedTsx, finalTsx);
-    renameSync(stagedMeta, finalMeta);
-    renameSync(stagedSvg, finalPath);
+    promoteFile(stagedTsx, finalTsx);
+    promoteFile(stagedMeta, finalMeta);
+    promoteFile(stagedSvg, finalPath);
     return {
       slug: annSlug,
       canvas: canvasRel,
@@ -977,8 +1023,8 @@ export async function importPages({
         mkdirSync(outDir, { recursive: true });
         const finalTsx = assertContained(root, designRootRel, join(outDir, `${title}.tsx`));
         const finalMeta = assertContained(root, designRootRel, join(outDir, `${title}.meta.json`));
-        renameSync(stagedTsx, finalTsx);
-        renameSync(stagedMeta, finalMeta);
+        promoteFile(stagedTsx, finalTsx);
+        promoteFile(stagedMeta, finalMeta);
 
         // The page's annotation layer has TWO sources, and the second one is the
         // reason a tree-walking import felt half-migrated:
@@ -1060,7 +1106,7 @@ export async function importPages({
             designRootRel,
             join(root, designRootRel, `${annSlug}.annotations.svg`)
           );
-          renameSync(stagedAnn, finalAnn);
+          promoteFile(stagedAnn, finalAnn);
         }
         written.push({
           title,
@@ -1240,8 +1286,8 @@ export async function importFrames({
       mkdirSync(uiDir, { recursive: true });
       const finalTsx = assertContained(root, designRootRel, join(uiDir, `${base}.tsx`));
       const finalMeta = assertContained(root, designRootRel, join(uiDir, `${base}.meta.json`));
-      renameSync(stagedTsx, finalTsx);
-      renameSync(stagedMeta, finalMeta);
+      promoteFile(stagedTsx, finalTsx);
+      promoteFile(stagedMeta, finalMeta);
       written.push({
         slug: base,
         path: finalTsx,
@@ -1559,8 +1605,8 @@ export async function explodeArtboard({
     const stagedMeta = join(staging, 'canvas.meta.json');
     writeFileSync(stagedTsx, tsxOut, 'utf8');
     writeFileSync(stagedMeta, `${JSON.stringify(nextMeta, null, 2)}\n`, 'utf8');
-    renameSync(stagedTsx, tsxPath);
-    renameSync(stagedMeta, metaPath);
+    promoteFile(stagedTsx, tsxPath);
+    promoteFile(stagedMeta, metaPath);
 
     return {
       canvas: rel,
@@ -1624,7 +1670,7 @@ export async function importTokens({ url, root, designRootRel = '.design', dryRu
       designRootRel,
       join(outDir, `figma-tokens-${target.fileKey.slice(0, 8).toLowerCase()}.json`)
     );
-    renameSync(staged, finalPath);
+    promoteFile(staged, finalPath);
     return { ...result, path: finalPath };
   } finally {
     rmSync(staging, { recursive: true, force: true });

package/apps/studio/bin/_seed-fixture.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+// Generate a synthetic `.design/` with the SHAPE of a large real project.
+//
+// WHY THIS EXISTS. Every defect in feature-large-project-seed only appears at
+// scale: the request ceiling needs >200 paths to bite, the hourly write quota
+// needs >2 GiB, the doručenka's unbounded map needs thousands of rows before
+// its cost shows, and the door's 95 MB ceiling needs a file that exceeds it.
+// The only project that reproduced all of them is 8.8 GB and 47 751 files, so
+// "run it against alligators" was the entire test plan — which meant the
+// regression surface was one person's laptop.
+//
+// SPARSE BY DEFAULT. The bytes are allocated, not written: a 3 GB fixture
+// costs a few hundred milliseconds and almost no disk on APFS/ext4, because
+// nothing here needs the content to be anything in particular. Pass
+// `--real-bytes` when a test genuinely needs them materialised (hashing
+// throughput, compression), and expect it to be slow.
+//
+// Deliberately NOT a `maude design` verb: it is a test fixture generator, and
+// putting it on the user-facing surface would invite someone to run it at a
+// real project. Internal, like `_screenshot-playwright.mjs`.
+//
+// Usage:
+//   node apps/studio/bin/_seed-fixture.mjs --out /tmp/big --files 3000 --bytes 2GB
+//   node apps/studio/bin/_seed-fixture.mjs --out /tmp/big --files 50 --bytes 10MB --real-bytes
+
+import {
+  closeSync,
+  ftruncateSync,
+  mkdirSync,
+  openSync,
+  rmSync,
+  writeFileSync,
+  writeSync,
+} from 'node:fs';
+import { join } from 'node:path';
+
+function parseBytes(raw) {
+  const m = String(raw ?? '')
+    .trim()
+    .match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)?$/i);
+  if (!m) return null;
+  const mult = { b: 1, kb: 1024, mb: 1024 ** 2, gb: 1024 ** 3 }[(m[2] ?? 'B').toLowerCase()];
+  return Math.round(Number(m[1]) * mult);
+}
+
+function parseArgs(argv) {
+  const out = { files: 3000, bytes: 2 * 1024 ** 3, out: null, realBytes: false, force: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--files') out.files = Number(argv[++i]);
+    else if (a === '--bytes') out.bytes = parseBytes(argv[++i]);
+    else if (a === '--out') out.out = argv[++i];
+    else if (a === '--real-bytes') out.realBytes = true;
+    else if (a === '--force') out.force = true;
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.out || !Number.isFinite(args.files) || args.files < 1 || !Number.isFinite(args.bytes)) {
+  process.stderr.write(
+    'usage: _seed-fixture.mjs --out <dir> [--files N] [--bytes 2GB] [--real-bytes] [--force]\n'
+  );
+  process.exit(2);
+}
+
+// REFUSE TO WRITE INTO SOMETHING THAT LOOKS REAL. This generator creates and
+// deletes a `.design/` tree; pointing it at a project by accident would be
+// unrecoverable, and `--force` is the only way past.
+const root = args.out;
+const designRoot = join(root, '.design');
+if (!args.force && !/(^\/tmp\/|^\/private\/tmp\/|fixture|scratch)/.test(root)) {
+  process.stderr.write(
+    `refusing to generate into ${root} — it does not look like a scratch path.\n` +
+      'Use a path under /tmp, or one containing "fixture"/"scratch", or pass --force.\n'
+  );
+  process.exit(2);
+}
+rmSync(designRoot, { recursive: true, force: true });
+
+/** Allocate a file of `size` without writing `size` bytes. */
+function makeFile(abs, size, real) {
+  if (real) {
+    // A repeating pattern rather than zeros, so a compression-sensitive test
+    // is not accidentally measuring a best case.
+    const chunk = Buffer.alloc(Math.min(size, 1 << 20), 0);
+    for (let i = 0; i < chunk.length; i++) chunk[i] = (i * 31) & 0xff;
+    const fd = openSync(abs, 'w');
+    let left = size;
+    while (left > 0) {
+      const n = Math.min(left, chunk.length);
+      writeSync(fd, chunk, 0, n);
+      left -= n;
+    }
+    closeSync(fd);
+    return;
+  }
+  const fd = openSync(abs, 'w');
+  ftruncateSync(fd, size); // sparse — allocated, not written
+  closeSync(fd);
+}
+
+const dirs = [
+  'system/fixture-ds/assets/photos',
+  'system/fixture-ds/assets/photos-cut',
+  'system/fixture-ds/assets/video',
+  'system/fixture-ds/assets/graphics',
+  'system/fixture-ds/preview',
+  'ui',
+];
+for (const d of dirs) mkdirSync(join(designRoot, d), { recursive: true });
+
+writeFileSync(
+  join(designRoot, 'config.json'),
+  `${JSON.stringify({ designSystems: ['fixture-ds'], canvasGroups: [{ path: 'ui' }] }, null, 2)}\n`
+);
+
+// The canvas layer — small, numerous, and the part a real project actually
+// edits. Kept to ~2 % of the file count, matching the observed ratio
+// (149 .tsx against 4 237 .jpg).
+const canvasCount = Math.max(1, Math.round(args.files * 0.02));
+for (let i = 0; i < canvasCount; i++) {
+  writeFileSync(
+    join(designRoot, 'ui', `screen-${i}.tsx`),
+    `export default function Screen${i}() {\n  return null;\n}\n`
+  );
+  writeFileSync(
+    join(designRoot, 'ui', `screen-${i}.meta.json`),
+    `${JSON.stringify({ title: `Screen ${i}`, status: 'draft' })}\n`
+  );
+}
+
+// The asset bulk. Sizes are drawn deterministically around the observed
+// distribution (0.5–3 MB stills), so a run is reproducible.
+const assetCount = Math.max(0, args.files - canvasCount * 2);
+let remaining = args.bytes;
+let made = 0;
+const folders = ['photos', 'photos-cut', 'graphics'];
+for (let i = 0; i < assetCount && remaining > 0; i++) {
+  const folder = folders[i % folders.length];
+  const share = Math.max(1024, Math.round(remaining / (assetCount - i)));
+  const size = Math.min(remaining, share);
+  makeFile(join(designRoot, 'system/fixture-ds/assets', folder, `a${i}.jpg`), size, args.realBytes);
+  remaining -= size;
+  made += 1;
+}
+
+// TWO FILES OVER THE DOOR'S 95 MB CEILING, because that is the case with no
+// backoff answer — the real project has exactly two (164.9 MB, 465.8 MB) and
+// they are what proved the client and the door disagreed about the limit.
+const over = [
+  ['system/fixture-ds/assets/video/over-cap-1.mp4', 165 * 1024 ** 2],
+  ['system/fixture-ds/assets/video/over-cap-2.mp4', 466 * 1024 ** 2],
+];
+for (const [rel, size] of over) makeFile(join(designRoot, rel), size, args.realBytes);
+
+const totalFiles = canvasCount * 2 + made + over.length;
+process.stdout.write(
+  `${designRoot}\n` +
+    `  ${totalFiles} files · ${(args.bytes / 1024 ** 3).toFixed(2)} GB nominal` +
+    `${args.realBytes ? ' (materialised)' : ' (sparse)'}\n` +
+    `  ${canvasCount} canvases · ${made} assets · ${over.length} over the 95 MB door ceiling\n`
+);

package/apps/studio/bin/annotate.mjs

@@ -1242,7 +1242,9 @@ async function main() {
         const res = await fetch(`${base}/_api/annotations`, {
           method: 'PUT',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ file: `${designRel}/${relPath}`, svg: merged }),
+          // `base` — the SVG this edit was merged onto, so a peer's strokes
+          // that landed meanwhile are merged, not replaced (DDR-241).
+          body: JSON.stringify({ file: `${designRel}/${relPath}`, svg: merged, base: svg }),
           signal: AbortSignal.timeout(3000),
         });
         if (res.ok) via = 'server';

package/apps/studio/bin/server-up.sh

@@ -145,9 +145,24 @@ NEEDS_START=1
 if [ -f "$STATE" ]; then
   PID=$(read_pid)
   PORT=$(read_port)
+  # Sandboxed agents may reach Studio while kill -0 returns EPERM. Verify the
+  # server's identity over HTTP instead of mistaking denied signalling for death.
+  HEALTH=""
+  if [ -n "$PORT" ]; then
+    HEALTH=$(curl -fs --max-time 2 "http://localhost:$PORT/_health" 2>/dev/null || true)
+  fi
   if [ -n "$PID" ] && [ -n "$PORT" ] \
-     && kill -0 "$PID" 2>/dev/null \
-     && curl -fs "http://localhost:$PORT/_health" >/dev/null 2>&1; then
+     && printf '%s' "$HEALTH" | node -e '
+       try {
+         const fs = require("node:fs");
+         const h = JSON.parse(fs.readFileSync(0, "utf8"));
+         const root = fs.realpathSync(process.argv[2]);
+         const id = require("node:crypto").createHash("sha256").update(root).digest("hex").slice(0, 12);
+         process.exit(h.ok === true && h.app === "design" &&
+           Number(h.pid) === Number(process.argv[1]) &&
+           (h.rootId === undefined || h.rootId === id) ? 0 : 1);
+       } catch { process.exit(1); }
+     ' "$PID" "$REPO"; then
     echo "✓ server alive pid=$PID port=$PORT" >&2
     echo "$PORT"
     exit 0