@1agh/maude 0.36.0 → 0.37.0

package/apps/studio/github/endpoints.ts

@@ -107,6 +107,7 @@ export interface GitHubEndpoints {
   repos(): Promise<GitHubEndpointResult>;
   createRepo(body: unknown): Promise<GitHubEndpointResult>;
   createProject(body: unknown): Promise<GitHubEndpointResult>;
+  createLocalProject(body: unknown): Promise<GitHubEndpointResult>;
   invite(body: unknown): Promise<GitHubEndpointResult>;
   clone(body: unknown): Promise<GitHubEndpointResult>;
   initDesign(body: unknown): Promise<GitHubEndpointResult>;
@@ -346,6 +347,46 @@ export function createGitHubEndpoints(ctx: Context): GitHubEndpoints {
     });
   }
 
+  // "Just a local git repo, no GitHub remote" — same as createProject minus the
+  // network: mkdir + git init (defaultBranch main) + .design scaffold, NO token, NO
+  // createRepo, NO setRemote. The user can publish it later. Reuses the same slug +
+  // parent-dir validation as createProject, and the route is main-origin/loopback
+  // gated (http.ts) + absent from CANVAS_SAFE_API (dual-allowlist) like its sibling.
+  async function createLocalProject(body: unknown): Promise<GitHubEndpointResult> {
+    const b = (body ?? {}) as { name?: unknown; parentDir?: unknown };
+    const slug = slugifyRepoName(b.name);
+    if (!slug) return bad('Enter a project name (letters, numbers, hyphens).');
+    if (!validParentDir(b.parentDir))
+      return bad('Pick a folder on your computer to save the project in.');
+    const target = join(b.parentDir, slug);
+    if (existsSync(target)) {
+      return {
+        status: 409,
+        json: { ok: false, error: `A folder named “${slug}” already exists there.` },
+      };
+    }
+    const humanName = typeof b.name === 'string' ? b.name.trim() : slug;
+    try {
+      mkdirSync(target, { recursive: true });
+      await git.init({ fs, dir: target, defaultBranch: 'main' });
+      const s = scaffoldDesign(target, humanName);
+      if (!s.ok)
+        return {
+          status: 500,
+          json: { ok: false, error: s.error ?? 'Could not set up the project.' },
+        };
+    } catch (e) {
+      return {
+        status: 500,
+        json: {
+          ok: false,
+          error: e instanceof Error ? e.message : 'Could not set up the project.',
+        },
+      };
+    }
+    return { status: 200, json: { ok: true, path: target } };
+  }
+
   // Fallback for "open a folder/repo that isn't a Maude project yet" — scaffold a
   // bootable .design/ into an existing folder so it can open (no GitHub, no token).
   async function initDesign(body: unknown): Promise<GitHubEndpointResult> {
@@ -368,6 +409,7 @@ export function createGitHubEndpoints(ctx: Context): GitHubEndpoints {
     repos,
     createRepo: createRepoHandler,
     createProject,
+    createLocalProject,
     invite,
     clone,
     initDesign,

package/apps/studio/http.ts

@@ -1050,6 +1050,21 @@ export function createHttp(ctx: Context, api: Api, inspect: Inspect, ai: AiActiv
       return gitJson(await githubApi.createProject(body));
     },
 
+    // Create a NEW *local-only* project: mkdir + git init + .design scaffold, NO
+    // GitHub / no token (the "just local git, no remote" path). Same main-origin +
+    // loopback + POST CSRF gate as create-project, and MAIN-ORIGIN ONLY — absent
+    // from CANVAS_SAFE_API + startCanvasServer routes (dual-allowlist), so the
+    // untrusted canvas iframe can't drive disk writes.
+    '/_api/project/create-local': async (req: Request) => {
+      if (req.method !== 'POST') return new Response('Method not allowed', { status: 405 });
+      if (!sameOriginWrite(req))
+        return new Response('cross-origin write rejected', { status: 403 });
+      if (!isLoopbackHost(req.headers.get('host')))
+        return new Response('local request required', { status: 403 });
+      const body = await readJson<unknown>(req, 8 * 1024);
+      return gitJson(await githubApi.createLocalProject(body));
+    },
+
     // Scaffold a bootable .design/ into an existing folder (the "open a non-Maude
     // repo → set it up?" fallback). No token / no GitHub — local FS only, but still
     // main-origin + loopback gated (it writes to disk).

package/apps/studio/scaffold-design.ts

@@ -13,6 +13,93 @@ import { basename, join } from 'node:path';
 const CONFIG_SCHEMA =
   'https://raw.githubusercontent.com/1aGh/maude/main/apps/studio/config.schema.json';
 
+// A neutral, token-free starter canvas seeded into `ui/` so a freshly-created project
+// opens to a real artboard instead of an empty studio (the "empty-studio after Start a
+// new project" onboarding gap). It depends ONLY on @maude/canvas-lib + inline styles —
+// no design-system tokens — so it renders before /design:setup-ds exists. The button
+// vocabulary mirrors the shipped GitPanel (Save version · Publish · Get latest).
+const STARTER_CANVAS_TSX = `/**
+ * @canvas   welcome · Your first canvas — seeded when a new Maude project is created.
+ * @platform desktop
+ * @stack    React 19 · TSX · Bun.build
+ *
+ * Neutral + token-free so it renders the moment the project is created — before
+ * /design:setup-ds builds a design system. Edit it, replace it, or delete it once you
+ * have your own canvases.
+ */
+import { DCArtboard, DCSection, DesignCanvas } from "@maude/canvas-lib";
+
+export default function Welcome() {
+  return (
+    <DesignCanvas>
+      <DCSection id="welcome" title="Welcome to Maude" subtitle="START HERE">
+        <DCArtboard id="welcome" label="WELCOME/01" width={680} height={440}>
+          <div
+            data-testid="welcome-artboard-content"
+            style={{
+              height: "100%",
+              boxSizing: "border-box",
+              padding: 48,
+              display: "flex",
+              flexDirection: "column",
+              gap: 24,
+              fontFamily: "system-ui, -apple-system, sans-serif",
+              color: "#16181d",
+              background: "#fbfbfc",
+            }}
+          >
+            <div style={{ display: "flex", flexDirection: "column", gap: 8 }}>
+              <span style={{ fontSize: 12, letterSpacing: "0.12em", textTransform: "uppercase", color: "#8a8f98" }}>
+                Your first canvas
+              </span>
+              <h1 style={{ margin: 0, fontSize: 30, lineHeight: 1.1, fontWeight: 650 }}>
+                You're in. This is a canvas.
+              </h1>
+              <p style={{ margin: 0, fontSize: 15, lineHeight: 1.5, color: "#4a4f57", maxWidth: 460 }}>
+                Everything you design lives on canvases like this one. Edit it, or start fresh —
+                your work saves on its own, and you can version and share it without ever opening a terminal.
+              </p>
+            </div>
+            <div style={{ display: "flex", gap: 12 }}>
+              {[
+                ["Save version", "keep a checkpoint, just for you"],
+                ["Publish", "share it with your team"],
+                ["Get latest", "pull in everyone else's work"],
+              ].map(([title, desc]) => (
+                <div key={title} style={{ flex: 1, padding: 16, border: "1px solid #e6e7ea", borderRadius: 10, background: "#fff" }}>
+                  <div style={{ fontSize: 14, fontWeight: 600, marginBottom: 4 }}>{title}</div>
+                  <div style={{ fontSize: 12.5, lineHeight: 1.4, color: "#6b7078" }}>{desc}</div>
+                </div>
+              ))}
+            </div>
+            <p style={{ margin: 0, fontSize: 13, lineHeight: 1.5, color: "#8a8f98" }}>
+              Next: build a design system, or just start editing this canvas.
+            </p>
+          </div>
+        </DCArtboard>
+      </DCSection>
+    </DesignCanvas>
+  );
+}
+`;
+
+const STARTER_CANVAS_META = {
+  title: 'Welcome',
+  subtitle: 'Your first canvas — seeded on project creation',
+  brief:
+    'Neutral, token-free welcome canvas written by scaffoldDesign() so a new project opens to a real artboard instead of an empty studio. Safe to edit or delete.',
+  platform: 'desktop',
+  sections: [
+    {
+      id: 'welcome',
+      title: 'Welcome to Maude · START HERE',
+      artboards: [{ id: 'welcome', label: 'WELCOME/01', width: 680, height: 440 }],
+    },
+  ],
+  css_mode: 'inline',
+  layout: { artboards: [{ id: 'welcome', x: 0, y: 0 }] },
+};
+
 /** Whether `dir` is already a Maude project (has `.design/config.json`). */
 export function hasDesign(dir: string): boolean {
   return existsSync(join(dir, '.design', 'config.json'));
@@ -47,8 +134,14 @@ export function scaffoldDesign(dir: string, name?: string): ScaffoldResult {
       completenessProfile: 'standard',
     };
     writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
-    // Keep the empty group dirs in git so a fresh clone still has the structure.
-    writeFileSync(join(designDir, 'ui', '.gitkeep'), '', 'utf8');
+    // Seed a starter canvas so the studio opens to a real artboard, not an empty list.
+    writeFileSync(join(designDir, 'ui', 'Welcome.tsx'), STARTER_CANVAS_TSX, 'utf8');
+    writeFileSync(
+      join(designDir, 'ui', 'Welcome.meta.json'),
+      `${JSON.stringify(STARTER_CANVAS_META, null, 2)}\n`,
+      'utf8'
+    );
+    // `system/` is genuinely empty until /design:setup-ds — keep it in git.
     writeFileSync(join(designDir, 'system', '.gitkeep'), '', 'utf8');
     return { ok: true };
   } catch (e) {

package/apps/studio/test/canvas-origin-gate.test.ts

@@ -99,6 +99,9 @@ describe('canvas-origin gate — A1/A2 traversal + privilege containment', () =>
         '/_api/github/invite',
         '/_api/github/clone',
         '/_api/github/create-project',
+        // Local-only project create (mkdir + git init + scaffold) — writes to disk,
+        // no token; MAIN-ORIGIN ONLY, so the canvas origin must 403 at the gate.
+        '/_api/project/create-local',
         '/_api/design/init',
         // Phase 29 (E4) Door C — the hub-link credential write is MAIN-ORIGIN ONLY;
         // the untrusted canvas origin must never reach it (it writes the global

package/apps/studio/test/edit-source-command.test.ts

@@ -0,0 +1,119 @@
+import { beforeAll, describe, expect, mock, test } from 'bun:test';
+
+import {
+  buildEditSourceRecord,
+  createEditSourceCommand,
+  EDIT_SOURCE_KIND,
+  type EditSourceApplyFn,
+  type EditSourcePayload,
+} from '../commands/edit-source-command.ts';
+import { type CommandSinks, rebuildCommand, registerCommand } from '../undo-stack.ts';
+
+const cssEdit: EditSourcePayload = {
+  op: 'css',
+  canvas: '.design/ui/Foo.tsx',
+  id: 'cd-1',
+  key: 'color',
+  before: 'red',
+  after: 'blue',
+};
+
+describe('createEditSourceCommand', () => {
+  test('do() applies the AFTER value', async () => {
+    const applyFn = mock(() => {});
+    const cmd = createEditSourceCommand({ payload: cssEdit, applyFn });
+    await cmd.do();
+    expect(applyFn).toHaveBeenCalledTimes(1);
+    expect(applyFn.mock.calls[0]?.[0]).toEqual({
+      op: 'css',
+      canvas: '.design/ui/Foo.tsx',
+      id: 'cd-1',
+      key: 'color',
+      value: 'blue',
+    });
+  });
+
+  test('undo() applies the BEFORE value', async () => {
+    const applyFn = mock(() => {});
+    const cmd = createEditSourceCommand({ payload: cssEdit, applyFn });
+    await cmd.undo();
+    expect(applyFn.mock.calls[0]?.[0]?.value).toBe('red');
+  });
+
+  test('undo() of a NEW prop (before:null) applies null = reset', async () => {
+    const applyFn = mock(() => {});
+    const cmd = createEditSourceCommand({
+      payload: { ...cssEdit, before: null, after: 'blue' },
+      applyFn,
+    });
+    await cmd.undo();
+    expect(applyFn.mock.calls[0]?.[0]?.value).toBeNull();
+  });
+
+  test('do() of a RESET (after:null) applies null = remove the prop', async () => {
+    const applyFn = mock(() => {});
+    const cmd = createEditSourceCommand({
+      payload: { ...cssEdit, before: 'red', after: null },
+      applyFn,
+    });
+    await cmd.do();
+    expect(applyFn.mock.calls[0]?.[0]?.value).toBeNull();
+  });
+
+  test('label reflects op + key', () => {
+    expect(createEditSourceCommand({ payload: cssEdit, applyFn: () => {} }).label).toBe(
+      'edit color'
+    );
+    expect(
+      createEditSourceCommand({ payload: { ...cssEdit, after: null }, applyFn: () => {} }).label
+    ).toBe('reset color');
+    expect(
+      createEditSourceCommand({
+        payload: { op: 'attr', canvas: 'x', id: 'y', key: 'data-x', before: null, after: '1' },
+        applyFn: () => {},
+      }).label
+    ).toBe('edit @data-x');
+    expect(
+      createEditSourceCommand({
+        payload: { op: 'text', canvas: 'x', id: 'y', key: '', before: 'a', after: 'b' },
+        applyFn: () => {},
+      }).label
+    ).toBe('edit text');
+  });
+});
+
+describe('buildEditSourceRecord', () => {
+  test('produces a serializable record under the edit-source kind', () => {
+    const rec = buildEditSourceRecord(cssEdit);
+    expect(rec.kind).toBe(EDIT_SOURCE_KIND);
+    expect(rec.payload).toEqual(cssEdit);
+    expect(JSON.parse(JSON.stringify(rec))).toEqual(rec); // round-trips
+  });
+});
+
+describe('edit-source registry', () => {
+  // The module self-registers on import, but sibling test files wipe the shared
+  // builder registry in their beforeEach — re-register here so this block is
+  // order-independent. Mirrors the real registration in edit-source-command.ts.
+  beforeAll(() => {
+    registerCommand<EditSourcePayload>(EDIT_SOURCE_KIND, (record, sinks) => {
+      const applyFn = sinks.editSourceApplyFn as EditSourceApplyFn | undefined;
+      if (!applyFn) return null;
+      return createEditSourceCommand({ payload: record.payload, applyFn, label: record.label });
+    });
+  });
+
+  test('rebuildCommand returns null when the editSourceApplyFn sink is unbound', () => {
+    expect(rebuildCommand(buildEditSourceRecord(cssEdit), {} as CommandSinks)).toBeNull();
+  });
+
+  test('rebuildCommand wires the bound sink into a runnable command', async () => {
+    const applyFn = mock(() => {});
+    const cmd = rebuildCommand(buildEditSourceRecord(cssEdit), {
+      editSourceApplyFn: applyFn,
+    } as CommandSinks);
+    expect(cmd).not.toBeNull();
+    await cmd?.do();
+    expect(applyFn.mock.calls[0]?.[0]?.value).toBe('blue');
+  });
+});

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

@@ -190,14 +190,21 @@ describe('CanvasSyncAgent — cold start reconciliation', () => {
     agent = makeAgent({ adopt: true });
     await agent.reconcile();
 
-    // Hub changes the value.
+    // Hub changes the value — stamp it explicitly newer than the disk so the
+    // newest-wins reconcile is deterministic. An un-pinned `applyHtmlToDoc` stamp
+    // is `Date.now()` (ms-truncated) while the disk mtime is sub-ms `statSync`:
+    // in isolation they land in the same ms → tie → hub; under parallel-suite
+    // load they straddle a ms boundary → disk looks newer → local, flaking this
+    // assertion. Sibling tests pin timestamps for exactly this reason.
     applyHtmlToDoc(docA, '<button>hub-v2</button>');
+    docA.getMap('syncMeta').set('bodyEditAt', Date.now() + 60_000);
 
     // Disk reverts to a stale local-only state.
     writeFileSync(paths().html, '<button>local-v3</button>');
     await agent.reconcile();
 
-    // Hub state won this time.
+    // Hub state won this time — adopt was consumed, so the second reconcile runs
+    // normal newest-wins, and the (explicitly newer) hub body wins.
     expect(htmlFromDoc(docB)).toBe('<button>hub-v2</button>');
   });
 

package/apps/studio/test/use-undo-stack.test.tsx

@@ -155,6 +155,36 @@ describe('use-undo-stack / runner side-effects', () => {
   });
 });
 
+describe('use-undo-stack / record (already-applied edits)', () => {
+  test('record() appends WITHOUT running do()', async () => {
+    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
+    v.record(rec('inline-edit', 'X'));
+    // undo() is enqueued after record(), so awaiting it flushes record first.
+    await v.undo();
+    expect(doSpy).toHaveBeenCalledTimes(0); // record never runs do()
+    expect(undoSpy).toHaveBeenCalledTimes(1);
+    expect(undoSpy.mock.calls[0]?.[0]).toBe('X');
+  });
+
+  test('record() then redo() (after undo) re-runs do()', async () => {
+    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
+    v.record(rec('e', 'Y'));
+    await v.undo();
+    await v.redo();
+    expect(doSpy).toHaveBeenCalledTimes(1); // only redo's do(), not the record
+    expect(doSpy.mock.calls[0]?.[0]).toBe('Y');
+  });
+
+  test('record() clears the redo future', async () => {
+    const v = captureProvider(undefined, { layoutPatchFn: () => {} });
+    await v.push(rec('a', 'A')); // doSpy: 1
+    await v.undo(); // future = [a]
+    v.record(rec('b', 'B')); // clears future
+    await v.redo(); // future empty → no-op, no extra do()
+    expect(doSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe('use-undo-stack / cross-canvas persistence', () => {
   test('history under a canvasFile survives a fresh provider mount with the same canvasFile', async () => {
     // First mount: push 2 records.

package/apps/studio/undo-stack.ts

@@ -71,6 +71,16 @@ export interface CommandSinks {
   layoutPatchFn?: unknown;
   /** Wired by `AnnotationsLayer`. */
   strokesPutFn?: unknown;
+  /**
+   * Wired by `CanvasShell` (canvas-shell.tsx). Applies a single inline source
+   * edit (CSS / text / attr) by posting `dgn:'apply-edit'` to the parent shell,
+   * which owns the main-origin-only `/_api/edit-*` write (DDR-054 — the canvas
+   * iframe can't call those routes directly). Drives undo/redo of inspector
+   * CSS edits, inline text rewrites, and custom-attribute edits, which write
+   * the canvas `.tsx` source and were previously unrecoverable (no command, no
+   * snapshot). See `commands/edit-source-command.ts`.
+   */
+  editSourceApplyFn?: unknown;
 }
 
 export type CommandBuilder<P = unknown> = (

package/apps/studio/use-undo-stack.tsx

@@ -51,6 +51,14 @@ export interface UndoStackValue {
    * Awaiting the returned promise is optional.
    */
   push: (record: CommandRecord) => Promise<void>;
+  /**
+   * Record an ALREADY-APPLIED command — appends to `past` + clears `future`
+   * WITHOUT running `do()`. Use when the side-effect happened outside the
+   * stack (e.g. an inspector CSS commit / inline text edit that already POSTed
+   * `/_api/edit-*`), so re-running `do()` would double-apply. `undo()` / `redo()`
+   * still drive the command's `undo()` / `do()` normally afterwards.
+   */
+  record: (record: CommandRecord) => void;
   /** Undo the top of `past`. No-op when empty. */
   undo: () => Promise<void>;
   /** Redo the top of `future`. No-op when empty. */
@@ -69,6 +77,7 @@ const UndoStackContext = createContext<UndoStackValue | null>(null);
 
 const NOOP_VALUE: UndoStackValue = {
   push: () => Promise.resolve(),
+  record: () => {},
   undo: () => Promise.resolve(),
   redo: () => Promise.resolve(),
   clear: () => {},
@@ -213,6 +222,16 @@ export function UndoStackProvider({
     [enqueue, build, reportError, bumpLabel, writeState]
   );
 
+  const record = useCallback(
+    (rec: CommandRecord): void => {
+      void enqueue(async () => {
+        writeState(undoReducer(stateRef.current, { type: 'push', record: rec }));
+        bumpLabel(rec.label);
+      });
+    },
+    [enqueue, writeState, bumpLabel]
+  );
+
   const undo = useCallback(
     (): Promise<void> =>
       enqueue(async () => {
@@ -306,6 +325,7 @@ export function UndoStackProvider({
   const value = useMemo<UndoStackValue>(
     () => ({
       push,
+      record,
       undo,
       redo,
       clear,
@@ -318,7 +338,7 @@ export function UndoStackProvider({
     // `lastTick` (bumped by every push/undo/redo/clear) as the proxy so the
     // memoized canUndo/canRedo readouts re-evaluate on each transition.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [push, undo, redo, clear, lastLabel, lastTick]
+    [push, record, undo, redo, clear, lastLabel, lastTick]
   );
 
   return (

package/apps/studio/whats-new.json

@@ -1,6 +1,24 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "new-project-menu-and-local",
+      "version": "0.37.0",
+      "date": "2026-07-01",
+      "kind": "feature",
+      "title": "Start a project from the menu — or fully local",
+      "summary": "New Project… is now in the File menu (⌘N), not just onboarding. And you can create a project on This computer only — a plain local git repo with no GitHub and no remote, that you can publish later. It works even when you're signed out.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "desktop-onboarding-fixes",
+      "version": "0.36.2",
+      "date": "2026-06-30",
+      "kind": "fix",
+      "title": "A smoother first run",
+      "summary": "Onboarding got a polish. If you're already signed in, the GitHub step now says Continue instead of asking you to sign in again, and your signed-in status shows reliably. Cancelling the sign-in code screen frees the button right away, “Merge this branch → main” shows progress while it runs, and a brand-new project opens to a starter canvas instead of an empty workspace.",
+      "surface": "design-ui"
+    },
     {
       "id": "git-native-switcher",
       "version": "0.36.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "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": {
@@ -21,6 +21,7 @@
     "dev": "bun run apps/studio/server.ts --port 4555",
     "dev:site": "pnpm --filter @maude/site dev --port 4398",
     "dev:desktop": "PATH=\"$HOME/.cargo/bin:$PATH\" pnpm --filter @maude/desktop tauri dev",
+    "dev:desktop:onboarding": "PATH=\"$HOME/.cargo/bin:$PATH\" MAUDE_FORCE_ONBOARDING=1 pnpm --filter @maude/desktop tauri dev",
     "build:desktop": "PATH=\"$HOME/.cargo/bin:$PATH\" pnpm --filter @maude/desktop tauri build",
     "test:e2e:desktop:build": "PATH=\"$HOME/.cargo/bin:$PATH\" pnpm --filter @maude/desktop tauri build --debug --config src-tauri/tauri.e2e.conf.json",
     "test:e2e:desktop": "pnpm --filter @maude/desktop-e2e e2e",
@@ -45,16 +46,17 @@
     "postinstall": "node cli/install.cjs",
     "prepublishOnly": "bash scripts/check-version-parity.sh && bash apps/studio/bin/check-runtime-bundles.sh",
     "test:e2e:desktop:lifecycle": "pnpm --filter @maude/desktop-e2e e2e:lifecycle",
-    "test:e2e:desktop:switchrepos": "pnpm --filter @maude/desktop-e2e e2e:switchrepos"
+    "test:e2e:desktop:switchrepos": "pnpm --filter @maude/desktop-e2e e2e:switchrepos",
+    "test:e2e:desktop:onboarding": "pnpm --filter @maude/desktop-e2e e2e:onboarding"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "0.36.0",
-    "@1agh/maude-darwin-x64": "0.36.0",
-    "@1agh/maude-linux-arm64": "0.36.0",
-    "@1agh/maude-linux-arm64-musl": "0.36.0",
-    "@1agh/maude-linux-x64": "0.36.0",
-    "@1agh/maude-linux-x64-musl": "0.36.0",
-    "@1agh/maude-win32-x64": "0.36.0"
+    "@1agh/maude-darwin-arm64": "0.37.0",
+    "@1agh/maude-darwin-x64": "0.37.0",
+    "@1agh/maude-linux-arm64": "0.37.0",
+    "@1agh/maude-linux-arm64-musl": "0.37.0",
+    "@1agh/maude-linux-x64": "0.37.0",
+    "@1agh/maude-linux-x64-musl": "0.37.0",
+    "@1agh/maude-win32-x64": "0.37.0"
   },
   "files": [
     "cli",