@1agh/maude 0.15.0

package/plugins/design/dev-server/canvas-header.ts

@@ -0,0 +1,165 @@
+// canvas-header.ts — Phase 3.6 Task 12a. JSDoc header generator for canvas
+// TSX files. Projects `<Slug>.meta.json` → the leading block comment, so a
+// future Claude (or human) cold-reading the canvas sees DS / opt-out / brief /
+// artboards / handoff command without opening the sidecar.
+//
+// Header is *generated*. `.meta.json` stays the source of truth; this module
+// is a projection. /design:edit step 1 (or scripts/migrate-canvases.ts) calls
+// `applyHeader(canvasPath)` to keep the projection in sync.
+//
+// Idempotency:
+//   - First non-empty token is `/**` ending in `*/`  → overwrite that block.
+//   - Otherwise                                       → prepend a new block.
+//
+// JSX / imports are never touched. The module-level `import` order survives.
+
+import path from 'node:path';
+
+export interface MetaSidecar {
+  title?: string;
+  subtitle?: string;
+  brief?: string;
+  platform?: string;
+  designSystem?: string;
+  opt_out_scope?: string;
+  css_mode?: 'inline' | 'tailwind' | 'modules';
+  sections?: Array<{ id: string; artboards?: Array<{ id: string }> }>;
+  ai_context?: {
+    pinned_decisions?: string[];
+    known_quirks?: string[];
+    why_this_exists?: string;
+  };
+  [k: string]: unknown;
+}
+
+export interface HeaderOpts {
+  /** Bare canvas name (file stem, no extension). Used for @canvas + @handoff. */
+  name: string;
+  meta: MetaSidecar;
+  /** Override the DS slug. Defaults to meta.designSystem ?? 'project'. */
+  dsName?: string;
+}
+
+/**
+ * Build the JSDoc header string (no trailing newline padding — caller picks).
+ * Pure function — no fs.
+ */
+export function buildHeader(opts: HeaderOpts): string {
+  const m = opts.meta;
+  const artboardIds =
+    (m.sections ?? [])
+      .flatMap((s) => s.artboards ?? [])
+      .map((a) => a.id)
+      .join(' | ') || '—';
+  const opt = m.opt_out_scope ?? 'palette';
+  const platform = m.platform ?? 'desktop';
+  const ds = m.designSystem ?? opts.dsName ?? 'project';
+  const cssMode = m.css_mode ?? 'inline';
+  const brief = (m.brief ?? '').replace(/\s+/g, ' ').trim() || '—';
+  const subtitle = (m.subtitle ?? '').replace(/\s+/g, ' ').trim();
+  const slug = kebabSlug(opts.name);
+
+  const lines = [
+    '/**',
+    ` * @canvas      ${opts.name}${subtitle ? ` — ${subtitle}` : ''}`,
+    ` * @ds          ${ds}`,
+    ` * @platform    ${platform}`,
+    ` * @opt_out     ${opt}`,
+    ` * @artboards   ${artboardIds}`,
+    ` * @brief       ${brief}`,
+    ` * @stack       React 19 · TSX · Bun.build · css_mode=${cssMode}`,
+    ` * @history     .design/_history/${slug}/`,
+    ` * @handoff     bunx shadcn add file://./${opts.name}.registry.json`,
+  ];
+
+  const ai = m.ai_context;
+  if (ai && (ai.why_this_exists || (ai.pinned_decisions?.length ?? 0) > 0)) {
+    lines.push(' *');
+    if (ai.why_this_exists) {
+      lines.push(` * @notes       ${ai.why_this_exists.replace(/\s+/g, ' ').trim()}`);
+    }
+    for (const dec of ai.pinned_decisions ?? []) {
+      lines.push(` * @decision    ${dec.replace(/\s+/g, ' ').trim()}`);
+    }
+    for (const q of ai.known_quirks ?? []) {
+      lines.push(` * @quirk       ${q.replace(/\s+/g, ' ').trim()}`);
+    }
+  }
+  lines.push(' */');
+  return lines.join('\n');
+}
+
+/**
+ * Pure helper: replace or insert the header in a TSX source string. Returns
+ * the new source. If the source already starts with a block comment, that
+ * comment is replaced; otherwise a fresh header is prepended.
+ */
+export function applyHeaderToSource(source: string, header: string): string {
+  const trimmed = source.trimStart();
+  const leading = source.length - trimmed.length;
+  if (trimmed.startsWith('/**')) {
+    const end = trimmed.indexOf('*/');
+    if (end > 0) {
+      const before = source.slice(0, leading);
+      const after = trimmed.slice(end + 2);
+      return `${before}${header}${after}`;
+    }
+  }
+  return `${header}\n\n${source}`;
+}
+
+/**
+ * Read a canvas file + sibling .meta.json, regenerate the JSDoc header, write
+ * the canvas back atomically. No-op when content is identical.
+ */
+export async function applyHeader(canvasAbsPath: string): Promise<{ changed: boolean }> {
+  const ext = path.extname(canvasAbsPath);
+  const stem = path.basename(canvasAbsPath, ext);
+  const metaPath = path.join(path.dirname(canvasAbsPath), `${stem}.meta.json`);
+  const metaFile = Bun.file(metaPath);
+  const meta: MetaSidecar = (await metaFile.exists())
+    ? ((await metaFile.json()) as MetaSidecar)
+    : {};
+  const source = await Bun.file(canvasAbsPath).text();
+  const header = buildHeader({ name: stem, meta });
+  const next = applyHeaderToSource(source, header);
+  if (next === source) return { changed: false };
+  const tmp = `${canvasAbsPath}.tmp.${Math.random().toString(36).slice(2, 10)}`;
+  await Bun.write(tmp, next);
+  const { rename } = await import('node:fs/promises');
+  await rename(tmp, canvasAbsPath);
+  return { changed: true };
+}
+
+function kebabSlug(s: string): string {
+  return s
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .toLowerCase()
+    .replace(/[\s_]+/g, '-')
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry — invoked by /design:edit's pre-flight when canvas-meta has
+// changed since the header was last projected.
+
+if (import.meta.main) {
+  const argv = process.argv.slice(2);
+  if (argv[0] === '--invoke' && argv.length === 2) {
+    const canvas = argv[1] as string;
+    try {
+      const { changed } = await applyHeader(canvas);
+      console.log(JSON.stringify({ canvas, changed }));
+      process.exit(0);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`canvas-header: ${msg}`);
+      process.exit(2);
+    }
+  } else {
+    console.error('Usage: bun run canvas-header.ts --invoke <canvas-abs-path>');
+    process.exit(2);
+  }
+}

package/plugins/design/dev-server/canvas-icons.tsx

@@ -0,0 +1,131 @@
+/**
+ * @file       canvas-icons.tsx — Phase 5.1 inline-SVG icon set
+ * @scope      plugins/design/dev-server/canvas-icons.tsx
+ * @purpose    Tiny dependency-free Lucide-style icon set for the canvas
+ *             chrome (tool palette, context toolbar). Each icon is a single
+ *             `<svg>` with `currentColor` stroke so it inherits the button
+ *             foreground. Sized 16 px by default; the parent button is
+ *             32 × 32, leaving 8 px of optical padding on every side.
+ */
+
+import type { SVGProps } from 'react';
+
+type IconProps = SVGProps<SVGSVGElement> & { size?: number };
+
+function Svg({ size = 16, children, ...rest }: IconProps) {
+  return (
+    <svg
+      width={size}
+      height={size}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={1.75}
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden="true"
+      focusable="false"
+      {...rest}
+    >
+      {children}
+    </svg>
+  );
+}
+
+export function IconMove(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <path d="M4 4l16 6-7 2-2 7z" />
+    </Svg>
+  );
+}
+
+export function IconHand(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <path d="M8 13V5a1.5 1.5 0 013 0v6" />
+      <path d="M11 11V4a1.5 1.5 0 013 0v7" />
+      <path d="M14 11V5.5a1.5 1.5 0 013 0V13" />
+      <path d="M17 9a1.5 1.5 0 013 0v6a6 6 0 01-6 6h-2a6 6 0 01-5-2.5L4 14a1.5 1.5 0 012-2l2 2" />
+    </Svg>
+  );
+}
+
+export function IconComment(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <path d="M21 12a8 8 0 11-3.3-6.5L21 4l-1 4.3A8 8 0 0121 12z" />
+    </Svg>
+  );
+}
+
+export function IconPen(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <path d="M14.5 4.5l5 5L8 21H3v-5z" />
+      <path d="M13 6l5 5" />
+    </Svg>
+  );
+}
+
+export function IconRect(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <rect x="4" y="5" width="16" height="14" rx="1.5" />
+    </Svg>
+  );
+}
+
+export function IconEllipse(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <ellipse cx="12" cy="12" rx="8" ry="6" />
+    </Svg>
+  );
+}
+
+export function IconArrow(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <path d="M4 12h14" />
+      <path d="M13 6l6 6-6 6" />
+    </Svg>
+  );
+}
+
+export function IconEraser(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <path d="M16 3l5 5-11 11H4v-6z" />
+      <path d="M8 14l5 5" />
+    </Svg>
+  );
+}
+
+export function IconPresentation(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <rect x="3" y="4" width="18" height="12" rx="1.5" />
+      <path d="M9 21l3-5 3 5" />
+    </Svg>
+  );
+}
+
+export function IconChevronDown(props: IconProps) {
+  return (
+    <Svg {...props}>
+      <path d="M6 9l6 6 6-6" />
+    </Svg>
+  );
+}
+
+export const TOOL_ICONS: Record<string, (p: IconProps) => JSX.Element> = {
+  move: IconMove,
+  hand: IconHand,
+  comment: IconComment,
+  pen: IconPen,
+  rect: IconRect,
+  ellipse: IconEllipse,
+  arrow: IconArrow,
+  eraser: IconEraser,
+};

package/plugins/design/dev-server/canvas-lib-inline.ts

@@ -0,0 +1,260 @@
+// canvas-lib inlining for /design:handoff (Phase 3.6.1 Task 9; per DDR-025 the
+// lib source now ships with the dev-server install).
+//
+// `/design:handoff` emits a self-contained shadcn registry-item.json. Canvases
+// import their envelope + helpers from `@maude/canvas-lib`, which the dev-server
+// resolves to its bundled `plugins/design/dev-server/canvas-lib.tsx`. The
+// handoff drop must inline every used export so the consumer never sees the
+// `@maude/canvas-lib` specifier — it's a dev-time virtual module, not a real
+// npm dep.
+//
+// Strategy:
+//   1. Parse the dev-server-bundled canvas-lib.tsx via oxc-parser. Walk top-level declarations
+//      to build a Map<name, { source, deps }>:
+//        - source: byte range of the declaration (including JSDoc immediately
+//                  above, when present).
+//        - deps: other top-level identifiers referenced inside the body.
+//   2. Scan the canvas TSX for `import { ... } from "@maude/canvas-lib"`.
+//      Collect the named imports.
+//   3. Transitively resolve deps: each import drags in helpers it calls,
+//      which drag in helpers THEY call, etc.
+//   4. Strip the import line.
+//   5. Append the resolved function/const bodies AFTER the canvas's default
+//      export. (Placing them after default avoids "use before declare" issues
+//      in dev-mode tooling — JSX inside the component reads the outer scope.)
+//
+// Pure module — caller persists. Tested.
+
+import { parseSync } from 'oxc-parser';
+
+// biome-ignore lint/suspicious/noExplicitAny: oxc AST nodes are heterogeneous.
+type AnyNode = any;
+
+export interface LibExport {
+  name: string;
+  /** Full declaration source, including leading JSDoc block. */
+  source: string;
+  /** Other top-level identifiers this declaration references. */
+  deps: string[];
+}
+
+export type LibMap = Map<string, LibExport>;
+
+/**
+ * Parse a canvas-lib TSX source into a Map keyed by named-export identifier.
+ * For each entry, `source` is the verbatim declaration text (with JSDoc
+ * comment if it precedes the declaration), and `deps` is the set of other
+ * top-level names the declaration body references.
+ */
+export function buildLibMap(libPath: string, libSource: string): LibMap {
+  const parsed = parseSync(libPath, libSource, { sourceType: 'module' });
+  if (parsed.errors && parsed.errors.length > 0) {
+    const first = parsed.errors[0];
+    throw new Error(
+      `oxc-parser failed on ${libPath} (${parsed.errors.length} errors). First: ${first?.message ?? 'unknown'}`
+    );
+  }
+
+  // First pass — collect every top-level binding name (exports + internals).
+  const topLevelNames = new Set<string>();
+  for (const node of parsed.program.body as AnyNode[]) {
+    for (const n of namesFromTopLevel(node)) topLevelNames.add(n);
+  }
+
+  // Second pass — record exported declarations with their source range +
+  // identifier references inside the body.
+  const map: LibMap = new Map();
+  // Also keep internal (non-exported) declarations indexed for transitive
+  // resolution — when an exported helper calls an internal helper, that
+  // internal must travel along.
+  const internals = new Map<string, LibExport>();
+
+  for (const node of parsed.program.body as AnyNode[]) {
+    if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+      for (const name of namesFromDecl(node.declaration)) {
+        const range = nodeRangeWithComment(libSource, node);
+        const source = libSource.slice(range.start, range.end);
+        // Strip the leading `export` token from the captured source — inlined
+        // bodies must NOT re-export.
+        const stripped = source.replace(/^export\s+/m, '');
+        const deps = collectIdentifierRefs(node.declaration, topLevelNames, name);
+        map.set(name, { name, source: stripped, deps: [...deps] });
+      }
+    } else if (
+      node.type === 'FunctionDeclaration' ||
+      node.type === 'VariableDeclaration' ||
+      node.type === 'ClassDeclaration'
+    ) {
+      for (const name of namesFromDecl(node)) {
+        const range = nodeRangeWithComment(libSource, node);
+        const source = libSource.slice(range.start, range.end);
+        const deps = collectIdentifierRefs(node, topLevelNames, name);
+        internals.set(name, { name, source, deps: [...deps] });
+      }
+    }
+  }
+
+  // Merge internals into the map under their own names — they're resolvable
+  // by the inliner when an export depends on them. Internals are never
+  // surfaced as user-requested imports but are reachable transitively.
+  for (const [name, info] of internals) {
+    if (!map.has(name)) map.set(name, info);
+  }
+
+  return map;
+}
+
+function namesFromTopLevel(node: AnyNode): string[] {
+  if (!node || typeof node !== 'object') return [];
+  if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+    return namesFromDecl(node.declaration);
+  }
+  if (
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'ClassDeclaration' ||
+    node.type === 'VariableDeclaration'
+  ) {
+    return namesFromDecl(node);
+  }
+  return [];
+}
+
+function namesFromDecl(decl: AnyNode): string[] {
+  if (!decl) return [];
+  if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
+    return decl.id?.name ? [decl.id.name as string] : [];
+  }
+  if (decl.type === 'VariableDeclaration') {
+    const out: string[] = [];
+    for (const d of decl.declarations ?? []) {
+      if (d.id?.type === 'Identifier' && d.id.name) out.push(d.id.name as string);
+    }
+    return out;
+  }
+  return [];
+}
+
+/**
+ * Walk an AST subtree collecting Identifier names that match the top-level
+ * registry, excluding `selfName` (no self-reference).
+ */
+function collectIdentifierRefs(
+  decl: AnyNode,
+  registry: Set<string>,
+  selfName: string
+): Set<string> {
+  const found = new Set<string>();
+  function visit(node: AnyNode): void {
+    if (!node || typeof node !== 'object') return;
+    if (Array.isArray(node)) {
+      for (const c of node) visit(c);
+      return;
+    }
+    if (typeof node.type !== 'string') return;
+    if (node.type === 'Identifier' && typeof node.name === 'string') {
+      if (node.name !== selfName && registry.has(node.name)) found.add(node.name);
+    }
+    // JSXIdentifier looks the same shape — treat like Identifier.
+    if (node.type === 'JSXIdentifier' && typeof node.name === 'string') {
+      if (node.name !== selfName && registry.has(node.name)) found.add(node.name);
+    }
+    for (const k of Object.keys(node)) {
+      if (k === 'loc' || k === 'range' || k === 'start' || k === 'end' || k === 'type') continue;
+      visit(node[k]);
+    }
+  }
+  visit(decl);
+  return found;
+}
+
+/**
+ * Find the source-range start of a node, extended backwards over any
+ * immediately-preceding block-comment (JSDoc) so the inlined declaration
+ * keeps its docs.
+ */
+function nodeRangeWithComment(source: string, node: AnyNode): { start: number; end: number } {
+  const end = node.end as number;
+  let start = node.start as number;
+  // Walk back over whitespace; if we hit `*/` we extend through the matching
+  // `/*`.
+  let i = start - 1;
+  while (i >= 0 && /\s/.test(source[i] ?? '')) i--;
+  if (i >= 1 && source[i - 1] === '*' && source[i] === '/') {
+    // We're at the `*/` — find matching `/*`.
+    const open = source.lastIndexOf('/*', i);
+    if (open >= 0) start = open;
+  }
+  return { start, end };
+}
+
+export interface InlineResult {
+  /** Canvas source with the import stripped + helpers appended. */
+  content: string;
+  /** True when an `@maude/canvas-lib` import was found + removed. */
+  droppedImport: boolean;
+  /** Sorted list of helper names inlined (including transitive). */
+  inlined: string[];
+}
+
+/**
+ * Replace `import { ... } from "@maude/canvas-lib"` with the resolved bodies
+ * of every named import (+ their transitive dependencies). Returns the
+ * rewritten source.
+ */
+export function inlineUsedExports(canvasSource: string, libMap: LibMap): InlineResult {
+  // 1. Locate the import line. We tolerate single OR double quotes, type-only
+  //    imports (rare), trailing commas, multi-line shapes.
+  const importRe = /\bimport\s+(?:type\s+)?\{([^}]+)\}\s*from\s*["']@maude\/canvas-lib["']\s*;?/m;
+  const m = importRe.exec(canvasSource);
+  if (!m) {
+    return { content: canvasSource, droppedImport: false, inlined: [] };
+  }
+  const importList = (m[1] ?? '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+    // Drop `type` prefix on individual names + handle `X as Y` aliases (rare).
+    .map((s) => s.replace(/^type\s+/, '').split(/\s+as\s+/)[0])
+    .filter((s): s is string => Boolean(s));
+
+  // 2. Resolve transitive deps. BFS over the libMap.
+  const wanted = new Set<string>();
+  const queue = [...importList];
+  while (queue.length > 0) {
+    const name = queue.shift() as string;
+    if (wanted.has(name)) continue;
+    const info = libMap.get(name);
+    if (!info) {
+      throw new Error(
+        `[canvas-lib-inline] Canvas imports '${name}' from @maude/canvas-lib but the lib has no such export.`
+      );
+    }
+    wanted.add(name);
+    for (const dep of info.deps) {
+      if (!wanted.has(dep)) queue.push(dep);
+    }
+  }
+
+  // 3. Strip the import line.
+  let out = canvasSource.slice(0, m.index) + canvasSource.slice(m.index + m[0].length);
+  // Cleanup: collapse runs of blank lines we just opened up.
+  out = out.replace(/\n{3,}/g, '\n\n');
+
+  // 4. Append the resolved declarations at the file's tail. The plan calls
+  //    for "before export default", but a trailing block works in modern JS
+  //    (function declarations hoist, top-level consts referenced inside the
+  //    default export are evaluated at module init). Place after a clear
+  //    separator + section comment so cold readers grok what's happening.
+  const ordered = [...wanted].sort();
+  const banner =
+    '\n\n// ─────────────────────────────────────────────────────────────────────────────\n' +
+    '// Canvas-lib helpers (inlined by /design:handoff). Self-contained drop —\n' +
+    '// no dev-time specifier is referenced from this file.\n\n';
+  const bodies = ordered.map((n) => (libMap.get(n)?.source ?? '').trimEnd()).join('\n\n');
+
+  return {
+    content: `${out.trimEnd()}${banner}${bodies}\n`,
+    droppedImport: true,
+    inlined: ordered,
+  };
+}

package/plugins/design/dev-server/canvas-lib-resolver.ts

@@ -0,0 +1,85 @@
+// Virtual-module resolver for `@maude/canvas-lib` (Phase 3.6.1; relocated 4.0.5).
+//
+// Canvases import the shared canvas library via the specifier `@maude/canvas-lib`.
+// At build time we redirect that to the dev-server-bundled source at
+// `plugins/design/dev-server/canvas-lib.tsx` so:
+//
+//   - the lib ships with the dev-server install (single source of truth — see
+//     DDR-025; reverses DDR-022's "project-owned source under <designRoot>/_lib/"),
+//   - Bun.build bundles the actually-used exports into the canvas module via
+//     normal tree-shaking,
+//   - `/design:handoff` can strip the import + inline the same exports for the
+//     emitted registry-item (see canvas-lib-inline.ts).
+//
+// Two surfaces:
+//
+//   - `canvasLibResolver()` — Bun.build plugin. Registered alongside
+//     `exact-externals` in canvas-build.ts. Must run FIRST so the bare specifier
+//     gets claimed before any other resolver.
+//   - `readCanvasLibSource()` — small async helper used by handoff.ts
+//     to read the lib source once for inlining.
+//
+// Failure mode: if the dev-server's bundled canvas-lib is missing, the install
+// is corrupt; canvas-build.ts surfaces a re-install hint.
+
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+import type { BunPlugin } from 'bun';
+
+export const CANVAS_LIB_SPECIFIER = '@maude/canvas-lib';
+
+/**
+ * Returns the dev-server-internal canvas-lib path. The `_designRoot` parameter
+ * is retained for one minor (back-compat with callers we don't control) but
+ * ignored — canvas-lib now ships with the dev-server install (DDR-025).
+ */
+export function canvasLibPath(_designRoot?: string): string {
+  return path.join(import.meta.dir, 'canvas-lib.tsx');
+}
+
+export interface CanvasLibResolverOptions {
+  /** Throw at resolve-time when the lib file is missing. Defaults to true. */
+  failLoud?: boolean;
+}
+
+/**
+ * Bun.build plugin factory. Maps `@maude/canvas-lib` → the dev-server-bundled
+ * `canvas-lib.tsx`. No-op for any other specifier.
+ */
+export function canvasLibResolver(
+  _designRoot?: string,
+  opts: CanvasLibResolverOptions = {}
+): BunPlugin {
+  const target = canvasLibPath();
+  const failLoud = opts.failLoud !== false;
+  return {
+    name: 'maude-canvas-lib',
+    setup(builder) {
+      builder.onResolve({ filter: /^@maude\/canvas-lib$/ }, () => {
+        if (failLoud && !existsSync(target)) {
+          throw new Error(
+            `[@maude/canvas-lib] canvas library missing at ${target} — dev-server install is corrupt; re-install @1agh/maude.`
+          );
+        }
+        return { path: target };
+      });
+    },
+  };
+}
+
+/**
+ * Read the on-disk canvas-lib source. Returns the raw TSX. Throws if the file
+ * is missing. Used by handoff.ts to build the export-name → source map for
+ * inlining used helpers into the emitted registry-item.
+ */
+export async function readCanvasLibSource(_designRoot?: string): Promise<string> {
+  const p = canvasLibPath();
+  const f = Bun.file(p);
+  if (!(await f.exists())) {
+    throw new Error(
+      `[@maude/canvas-lib] canvas library missing at ${p} — dev-server install is corrupt; re-install @1agh/maude.`
+    );
+  }
+  return f.text();
+}