@1agh/maude 1.4.5 → 1.4.6

package/apps/studio/sync/comment-ledger.ts

@@ -0,0 +1,229 @@
+// Per-machine comment ledger — issue #133.
+//
+// Records, per canvas slug, the comment identities (`commentKey`) that were on
+// this machine's `_comments/<slug>.json` AND in the shared document at the last
+// point the two agreed. It answers the one question neither side can answer
+// alone after a restart: an id that is on disk but not in the document — is it
+// a comment still on its way TO the document (keep it), or one the document
+// DROPPED while this machine was away (a remote delete — let it go)?
+//
+//   - in the ledger → it was synced before, the document no longer has it: a
+//     delete. The projection may write the file without it, and a cold-start
+//     union must not put it back.
+//   - not in the ledger → never synced from here: still in flight (a mutation
+//     whose import has not landed, an external edit — how /design:edit resolves
+//     comments). Keep it; defer, exactly as before.
+//
+// Before this, the "ever carried" knowledge lived only in memory
+// (collab/persistence.ts), so it started empty on every launch. A desktop that
+// was closed while a comment was deleted on the web then read that id as "in
+// flight" forever and never wrote its comments file again (accepted mode: the
+// file froze), and the legacy cold-start union re-added it for everyone.
+//
+// Per hub, like the sync journal (DDR-102): the file carries the hub URL it was
+// recorded against, and relinking to a different hub wipes it — "synced
+// before" against one hub says nothing about another. Best-effort and never
+// throws: a missing or corrupt ledger reads as empty, which degrades to the old
+// behaviour (defer), the safe direction. Lives under `_state/`, which is
+// already per-machine runtime state (DDR-115 taxonomy), so no new path.
+
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { atomicWrite } from './atomic-write.ts';
+import { commentKey } from './comment-identity.ts';
+
+const LEDGER_FILE = 'comment-ledger.json';
+/**
+ * Written immediately, not debounced: a record follows a comments-file write
+ * (rare), and a peer quit right after syncing must not lose it — a debounced
+ * ledger lost exactly that record in the E2E relaunch run and left the file
+ * frozen. Order is file first, ledger second, so a crash between the two
+ * leaves ids the ledger does not know: deferred, the safe direction.
+ */
+const FLUSH_MS = 0;
+/** Same ceiling as collab/persistence.ts MAX_SEEN_COMMENT_IDS (DDR-054 §2d). */
+const MAX_IDS_PER_SLUG = 10_000;
+
+interface LedgerFileShape {
+  hubUrl: string | null;
+  updatedAt: number;
+  slugs: Record<string, string[]>;
+}
+
+/** A read-only view of the identities recorded for one canvas. */
+export interface SyncedSet {
+  readonly size: number;
+  /** Takes a raw `commentKey`; the ledger stores only its hash. */
+  has(key: string): boolean;
+}
+
+/**
+ * The stored form of a comment key. Hashed (security review F3): an id-less
+ * comment's key is its whole JSON body, which a peer controls — the ledger must
+ * not grow with comment bodies, only with how many there are.
+ */
+export function ledgerKey(key: string): string {
+  return createHash('sha256').update(key).digest('base64url').slice(0, 22);
+}
+
+export interface CommentLedger {
+  /** Identities last known synced for `slug` (empty when never recorded). */
+  get(slug: string): SyncedSet;
+  /** Has `slug` ever been recorded (under the current hub)? Distinguishes
+   *  "synced, and had no comments" from "no knowledge" (first launch after
+   *  upgrading, a fresh link) — only the first may act on a difference. */
+  known(slug: string): boolean;
+  /** Replace `slug`'s record with the identities of a list both sides now agree on. */
+  record(slug: string, keys: Iterable<string>): void;
+  /**
+   * Linked to a (different) hub → drop every record. The identity must name
+   * the document namespace, not just the URL: one hub serves several
+   * workspaces (and branches), and "synced before" in one says nothing about
+   * another (security review F1c). `null` = no hub.
+   */
+  invalidateIfHubChanged(identity: string | null): void;
+  /** Persist now. Best-effort. */
+  flush(): void;
+}
+
+export function commentLedgerPath(designRoot: string): string {
+  return path.join(designRoot, '_state', LEDGER_FILE);
+}
+
+export interface LoadCommentLedgerOptions {
+  /** Tests use 0 to persist synchronously. */
+  flushMs?: number;
+  writer?: (file: string, bytes: string) => void;
+}
+
+export function loadCommentLedger(
+  designRoot: string,
+  opts: LoadCommentLedgerOptions = {}
+): CommentLedger {
+  const file = commentLedgerPath(designRoot);
+  const flushMs = opts.flushMs ?? FLUSH_MS;
+  const writer = opts.writer ?? ((p: string, bytes: string) => void atomicWrite(p, bytes));
+
+  let hubUrl: string | null = null;
+  const slugs = new Map<string, Set<string>>();
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let dirty = false;
+
+  try {
+    if (existsSync(file)) {
+      const parsed = JSON.parse(readFileSync(file, 'utf8')) as Partial<LedgerFileShape>;
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        hubUrl = typeof parsed.hubUrl === 'string' ? parsed.hubUrl : null;
+        const raw = parsed.slugs;
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+          for (const [slug, ids] of Object.entries(raw)) {
+            if (!Array.isArray(ids)) continue;
+            const keys = ids.filter((k): k is string => typeof k === 'string');
+            slugs.set(slug, new Set(keys.slice(-MAX_IDS_PER_SLUG)));
+          }
+        }
+      }
+    }
+  } catch {
+    /* corrupt → empty; every id then reads as "in flight", the old behaviour */
+  }
+
+  function persist(): void {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!dirty) return;
+    dirty = false;
+    const payload: LedgerFileShape = {
+      hubUrl,
+      updatedAt: Date.now(),
+      slugs: Object.fromEntries([...slugs].map(([s, ids]) => [s, [...ids]])),
+    };
+    try {
+      writer(file, `${JSON.stringify(payload)}\n`);
+    } catch (err) {
+      console.warn(
+        '[sync/comment-ledger] persist failed:',
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+
+  function schedule(): void {
+    dirty = true;
+    if (flushMs === 0) {
+      persist();
+      return;
+    }
+    if (!timer) timer = setTimeout(persist, flushMs);
+  }
+
+  return {
+    get(slug) {
+      const set = slugs.get(slug);
+      return {
+        size: set?.size ?? 0,
+        has: (key: string) => !!set && set.has(ledgerKey(key)),
+      };
+    },
+    known(slug) {
+      return slugs.has(slug);
+    },
+    record(slug, keys) {
+      const next = new Set<string>();
+      for (const k of keys) {
+        next.add(ledgerKey(k));
+        if (next.size >= MAX_IDS_PER_SLUG) break;
+      }
+      const prev = slugs.get(slug);
+      if (prev && prev.size === next.size && [...next].every((k) => prev.has(k))) return;
+      slugs.set(slug, next);
+      schedule();
+    },
+    invalidateIfHubChanged(url) {
+      if (url === hubUrl) return;
+      hubUrl = url;
+      slugs.clear();
+      schedule();
+    },
+    flush: persist,
+  };
+}
+
+/**
+ * The local half of a cold-start comments union, minus the comments a peer
+ * deleted while this machine was away: those the ledger knows were synced from
+ * here and the document no longer holds. Everything else — comments never
+ * synced from here — still unions up, exactly as before. Shared by both
+ * cold-start paths (sync/agent.ts reconcile, sync/migrate-seed.ts), which must
+ * agree or one would resurrect what the other let go.
+ */
+export function withoutRemotelyDeleted(
+  local: unknown[],
+  docList: unknown[],
+  syncedBefore: Pick<SyncedSet, 'size' | 'has'> | undefined
+): unknown[] {
+  if (!syncedBefore || syncedBefore.size === 0) return local;
+  const inDoc = new Set(docList.map(commentKey));
+  return local.filter((c) => {
+    const k = commentKey(c);
+    return inDoc.has(k) || !syncedBefore.has(k);
+  });
+}
+
+// One ledger per design root per process: the room projection (collab/) and the
+// sync agent (sync/) must share it, or two writers would overwrite each other's
+// file and each would only know half of what was synced.
+const shared = new Map<string, CommentLedger>();
+
+export function commentLedgerFor(designRoot: string): CommentLedger {
+  let l = shared.get(designRoot);
+  if (!l) {
+    l = loadCommentLedger(designRoot);
+    shared.set(designRoot, l);
+  }
+  return l;
+}

package/apps/studio/sync/file-plane.ts

@@ -640,6 +640,21 @@ export function createFilePlane(opts: FilePlaneOptions): FilePlane {
   let reanchorsInARow = 0;
   let reanchorHeldSince = 0;
 
+  /**
+   * A conflict row is waiting on a remote only a FULL read can tell it.
+   *
+   * A push answered `conflict` defers to "the next pass, against what the hub
+   * holds now" — but for a path the hub then leaves alone, a cursor read says
+   * nothing, the remembered remote stays unknown, and the row sat in
+   * `conflict` for good: Resync restarted the plane and read the same silence
+   * (rca issue-file-ledger-orphaned-rows). So a conflict owes one full read.
+   * Seeded from the ledger, which is what makes Resync (a restart) pay it.
+   * Capped at one per `REANCHOR_HOLD_RECOVERY_MS`, like the re-anchor storm,
+   * so a hub answering `conflict` to every push cannot farm full reads.
+   */
+  let fullReadOwed = Object.values(ledger.rows()).some((r) => r.state === 'conflict');
+  let lastOwedFullReadAt = Number.NEGATIVE_INFINITY;
+
   /**
    * When the plane may talk to the hub again. Issue #109.
    *
@@ -1497,7 +1512,14 @@ export function createFilePlane(opts: FilePlaneOptions): FilePlane {
     requestsThisPass = 0;
 
     // ── 1. The hub's side ────────────────────────────────────────────────
-    const startedFrom = ledger.cursor();
+    const payOwedRead = fullReadOwed && now() - lastOwedFullReadAt >= REANCHOR_HOLD_RECOVERY_MS;
+    if (payOwedRead) {
+      fullReadOwed = false;
+      lastOwedFullReadAt = now();
+    }
+    // An owed read is a compaction read in the SAME epoch: the ancestors still
+    // describe this log, so nothing is degraded — it only refreshes remotes.
+    const startedFrom = payOwedRead ? 0 : ledger.cursor();
     let fullRead = startedFrom === 0;
     let page = await fetchJournal({
       hubUrl: opts.hubUrl,
@@ -1648,6 +1670,45 @@ export function createFilePlane(opts: FilePlaneOptions): FilePlane {
         ledger.forget(rel);
         continue;
       }
+      // NOT OURS ON EITHER SIDE ANY MORE — forget it, do not keep refusing it.
+      //
+      // A path can leave the file plane while the ledger still tracks it: a
+      // `.css` written before its `.tsx` becomes the canvas's sidecar, or the
+      // canvas groups change. The local scan stops offering it, the hub stops
+      // listing it, and the row stayed behind forever — re-stamped `stuck` by
+      // the admission drop against a remembered remote, or frozen in
+      // `conflict` with nothing left to decide — counted as "waiting" in the
+      // panel (rca issue-file-ledger-orphaned-rows). Only when this page did
+      // not offer it: a path the hub is actively naming still goes through
+      // admission, which reports the refusal.
+      if (!here && !row && kept) {
+        const cls = classifyProjectFile(rel, {
+          canvasGroups: opts.canvasGroups,
+          hasFile: (r) => local.has(r) || existsSync(path.join(designRoot, r)),
+        });
+        if (!isFilePlaneClass(cls)) {
+          ledger.forget(rel);
+          continue;
+        }
+      }
+      // A DELETE IS A TRANSFER TOO. The code-module gate below only sees a
+      // non-null remote, so a tombstone walked past it: an ancestor this peer
+      // recorded (by push, or by agreement) was all `tombstone-agreed` needed
+      // to quarantine a code module on the word of a hub that may not move
+      // one. Refuse it here, reported, with the file and its row untouched.
+      if (row?.deleted && here && !opts.allowCodeModules) {
+        const cls = classifyProjectFile(rel, {
+          canvasGroups: opts.canvasGroups,
+          hasFile: (r) => local.has(r) || existsSync(path.join(designRoot, r)),
+        });
+        if (cls === 'code-module') {
+          out.dropped.push({
+            rel,
+            reason: 'code modules are removed only by an owner-vouched or loopback hub',
+          });
+          continue;
+        }
+      }
       // What the hub holds: this page when it spoke about the path, otherwise
       // what we last learned. `undefined` (never learned) reads as null only
       // after a full read has had the chance to say so.
@@ -1673,6 +1734,20 @@ export function createFilePlane(opts: FilePlaneOptions): FilePlane {
           continue;
         }
         if (cls === 'code-module' && !opts.allowCodeModules) {
+          // AGREEMENT IS NOT A TRANSFER. The gate refuses to move a code
+          // module from an unvouched hub (DDR-054); identical bytes on both
+          // sides move nothing, and reporting them as refused left a
+          // converged file permanently "stuck".
+          if (here && here.hash === remoteHash) {
+            void ledger.adoptAfter(rel, here.hash, () => {}, {
+              ...(row ? { remoteSeq: row.seq } : {}),
+              size: here.size,
+              mtimeMs: here.mtimeMs,
+              state: 'on-hub',
+            });
+            out.synced += 1;
+            continue;
+          }
           drop(
             out,
             rel,
@@ -2082,6 +2157,7 @@ export function createFilePlane(opts: FilePlaneOptions): FilePlane {
           ledger.setState(rel, 'conflict', {
             reason: 'the hub changed this file while the upload was in flight',
           });
+          fullReadOwed = true;
           out.conflicts.push({ rel, copy: null });
           return true;
         }

package/apps/studio/sync/index.ts

@@ -53,6 +53,7 @@ import {
   stampCanvasPath,
   stampMovedTo,
 } from './codec.ts';
+import { commentLedgerFor } from './comment-ledger.ts';
 import {
   type ConnectionMonitor,
   createConnectionMonitor,
@@ -520,6 +521,14 @@ export interface SyncRuntime {
   ): Promise<{ status: 'accepted' | 'rejected'; code?: string; queued?: boolean }> | null;
   /** True while the linked project is in accepted-revisions mode. */
   acceptedMode?(): boolean;
+  /**
+   * Issue #133 — may the comment ledger record `slug`'s current comments as
+   * synced? Only when the hub is known to hold them: accepted mode (the doc IS
+   * the accepted replica), or a synced provider with nothing unacknowledged. A
+   * comment added offline and not yet delivered must never read as "synced",
+   * or the next cold start would take it for a remote delete.
+   */
+  commentsConfirmedOnHub?(slug: string): boolean;
   /** Tripwire count: local writes that reached an accepted replica. */
   acceptedWriteViolations?(): number;
   /** Accepted revisions: the project's logical history (T27). Null when legacy. */
@@ -2722,6 +2731,11 @@ export function createSyncRuntime(
     // in `_history/<slug>/` via history.ts so /design:rollback recovers them.
     journal = loadJournal(ctx.paths.designRoot);
     journal.invalidateIfHubChanged(linkedHub.url);
+    // Issue #133 — same per-hub rule for the comment ledger: "synced before"
+    // against one hub says nothing about another.
+    commentLedgerFor(ctx.paths.designRoot).invalidateIfHubChanged(
+      `${linkedHub.url} ${docNameFor('_')}`
+    );
     const history = createHistory(ctx);
 
     // ---- DDR-102 helpers: auth aggregation, re-probe, settle bookkeeping ----
@@ -3123,6 +3137,7 @@ export function createSyncRuntime(
           projection,
           historyDir: path.join(ctx.paths.historyDir, canvas.slug),
           journal: journal ?? undefined,
+          commentLedger: commentLedgerFor(ctx.paths.designRoot),
           ownAccepted,
           wasAccepted: (content) => acceptedLink.client.holdsValue(content),
           createDoc: (lanes) => acceptedLink.createDoc(canvas.slug, rel, lanes),
@@ -3142,6 +3157,7 @@ export function createSyncRuntime(
           paths: canvasPaths,
           historyDir: path.join(ctx.paths.historyDir, canvas.slug),
           journal: journal ?? undefined,
+          commentLedger: commentLedgerFor(ctx.paths.designRoot),
           snapshot: async (content, reason) => {
             try {
               const snap = await history.writeSnapshot(relBody, content, reason);
@@ -3755,6 +3771,14 @@ export function createSyncRuntime(
                 echoGuard,
                 adopt: adoptOnce,
                 journal: journal ?? undefined,
+                commentLedger: commentLedgerFor(ctx.paths.designRoot),
+                commentsConfirmed: () => {
+                  const p = provider as unknown as {
+                    synced?: boolean;
+                    hasUnsyncedChanges?: boolean;
+                  };
+                  return p.synced === true && p.hasUnsyncedChanges === false;
+                },
                 snapshot: async (content, reason) => {
                   try {
                     const snap = await history.writeSnapshot(relBody, content, reason);
@@ -4936,6 +4960,19 @@ export function createSyncRuntime(
     },
     proposeFolder,
     acceptedMode: acceptedOn,
+    commentsConfirmedOnHub: (slug) => {
+      // The canvas must be live on the hub right now: a provider that has
+      // synced. In accepted mode its doc is the accepted replica (local writes
+      // are refused), but only once THIS canvas's projection exists — before
+      // that, a comment falls back to the local room and is not on the hub
+      // (security review F1b). In legacy mode nothing may be unacknowledged.
+      const p = providers.get(slug) as unknown as
+        | { synced?: boolean; hasUnsyncedChanges?: boolean }
+        | undefined;
+      if (!p || p.synced !== true) return false;
+      if (acceptedOn()) return projections.has(slug);
+      return p.hasUnsyncedChanges === false;
+    },
     acceptedWriteViolations: () => acceptedWriteViolations,
     acceptedHistory: async (q) => {
       if (!acceptedOn() || !acceptedLink) return null;

package/apps/studio/sync/migrate-seed.ts

@@ -58,6 +58,7 @@ import {
   unionCommentsById,
 } from './cold-start.ts';
 import { applyColdStart, type ColdStartSnapshotReason } from './cold-start-apply.ts';
+import { type CommentLedger, withoutRemotelyDeleted } from './comment-ledger.ts';
 import { hashBytes } from './echo-guard.ts';
 import type { SyncJournal } from './journal.ts';
 import { ORIGINS } from './origins.ts';
@@ -85,6 +86,8 @@ export interface MigrateSeedOptions {
   historyDir?: string;
   /** DDR-102 — per-machine journal; gates fast-forward vs conflict. */
   journal?: SyncJournal;
+  /** Issue #133 — comment ids synced from here before (sync/comment-ledger.ts). */
+  commentLedger?: CommentLedger;
   /** DDR-102 — body snapshot writer (history.ts), same contract as the agent's. */
   snapshot?: (content: string, reason: ColdStartSnapshotReason) => Promise<string | null>;
   /**
@@ -414,9 +417,13 @@ export async function migrateSeed(opts: MigrateSeedOptions): Promise<MigrateSeed
   // delete-then-insert codec — same-id entries keep the doc's version, so the
   // duplication trap stays closed; local-only comments survive.
   if (localComments) {
-    const parsed = tryParseJsonArray(localComments);
+    const docList = doc.getArray(Y_TYPES.comments).toArray();
+    const read = tryParseJsonArray(localComments);
+    // Issue #133 — never union back a comment a peer deleted while we were away.
+    const parsed = read
+      ? withoutRemotelyDeleted(read, docList, opts.commentLedger?.get(slug))
+      : null;
     if (parsed && parsed.length > 0) {
-      const docList = doc.getArray(Y_TYPES.comments).toArray();
       const merged = unionCommentsById(docList, parsed);
       if (merged.length !== docList.length) {
         doc.transact(() => {

package/apps/studio/use-collab.tsx

@@ -323,6 +323,27 @@ export function useCollab(): CollabValue | null {
 // ─────────────────────────────────────────────────────────────────────────────
 // Hook: foreign awareness peers (the cursor overlay subscribes to this).
 
+export interface AwarenessChanges {
+  added: number[];
+  updated: number[];
+  removed: number[];
+}
+
+/**
+ * Could this awareness `change` alter the foreign peers we show? False only
+ * when every touched client is the local one (our own cursor publish — #131).
+ * Unknown shape → true, the safe direction.
+ */
+export function touchesForeignClient(changes: AwarenessChanges | undefined, myId: number): boolean {
+  if (!changes) return true;
+  const touched = [
+    ...(changes.added ?? []),
+    ...(changes.updated ?? []),
+    ...(changes.removed ?? []),
+  ];
+  return touched.length === 0 || touched.some((id) => id !== myId);
+}
+
 /**
  * Returns the current set of foreign peers (excludes the local client). The
  * returned array is stable-reference between awareness updates — useful for
@@ -351,7 +372,13 @@ export function useForeignAwareness(): ForeignAwareness[] {
       return out;
     }
     setPeers(compute());
-    const onChange = () => setPeers(compute());
+    // Issue #131 — `change` fires for OUR OWN publishes too (the 30 Hz cursor),
+    // and each one rebuilt every peer object and re-rendered every consumer.
+    // Only a change that touches another client can change what we show.
+    const onChange = (changes?: AwarenessChanges) => {
+      if (!touchesForeignClient(changes, awareness.clientID)) return;
+      setPeers(compute());
+    };
     awareness.on('change', onChange);
     return () => {
       awareness.off('change', onChange);

package/apps/studio/use-selection-set.tsx

@@ -67,6 +67,10 @@ export interface Selection {
   worldW?: number;
   worldH?: number;
   html?: string;
+  /** Comment drops only — the annotation the click landed on, and the click's
+   *  world point (comment-anchor.ts). */
+  annotationId?: string;
+  world?: { x: number; y: number };
   /** Phase 12.2 — authored inline-style values (knob pre-fill) + resolved computed (placeholder hint). */
   authored?: Record<string, string>;
   computed?: Record<string, string>;

package/apps/studio/whats-new.json

@@ -1,6 +1,42 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "comments-stay-where-you-put-them",
+      "version": "1.4.6",
+      "date": "2026-09-30",
+      "kind": "fix",
+      "title": "Comments stay where you put them",
+      "summary": "A comment on a sticky, a drawing or empty canvas no longer disappears a few seconds after you save it. A comment on a sticky moves with it, and if the thing it points at is deleted the comment stays, marked as detached, until you remove it.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "comments-reach-every-peer",
+      "version": "1.4.6",
+      "date": "2026-09-30",
+      "kind": "fix",
+      "title": "Web comments reach the desktop app",
+      "summary": "Comments added on the web while your desktop app was closed now show up when you reopen it, and a comment deleted elsewhere no longer comes back.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "large-boards-pan-smoothly",
+      "version": "1.4.6",
+      "date": "2026-09-30",
+      "kind": "improvement",
+      "title": "Large boards pan smoothly again",
+      "summary": "Panning a board with many artboards stays smooth while something is selected or a teammate is on the canvas — on the desktop app it could drop to a frame a second.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "sync-no-phantom-waiting-files",
+      "version": "1.4.6",
+      "date": "2026-09-30",
+      "kind": "fix",
+      "title": "Sync stops counting files that are done",
+      "summary": "The Sync panel no longer shows files as waiting or stuck when there is nothing left to deliver, and Resync now brings down a file the project changed while you were uploading it.",
+      "surface": "design-ui"
+    },
     {
       "id": "team-projects-hold-up",
       "version": "1.4.5",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "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": {
@@ -58,13 +58,13 @@
     "test:e2e:desktop:parity:cloud": "pnpm --filter @maude/desktop-e2e e2e:parity:cloud"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "1.4.5",
-    "@1agh/maude-darwin-x64": "1.4.5",
-    "@1agh/maude-linux-arm64": "1.4.5",
-    "@1agh/maude-linux-arm64-musl": "1.4.5",
-    "@1agh/maude-linux-x64": "1.4.5",
-    "@1agh/maude-linux-x64-musl": "1.4.5",
-    "@1agh/maude-win32-x64": "1.4.5"
+    "@1agh/maude-darwin-arm64": "1.4.6",
+    "@1agh/maude-darwin-x64": "1.4.6",
+    "@1agh/maude-linux-arm64": "1.4.6",
+    "@1agh/maude-linux-arm64-musl": "1.4.6",
+    "@1agh/maude-linux-x64": "1.4.6",
+    "@1agh/maude-linux-x64-musl": "1.4.6",
+    "@1agh/maude-win32-x64": "1.4.6"
   },
   "files": [
     "cli",