mulmoterminal 2.5.2 → 2.5.3

package/README.md

@@ -488,6 +488,7 @@ The Settings modal (⚙) persists per-user UI choices to `~/.mulmoterminal/confi
 | `worklogIntervalHours` | Worklog cadence in hours (default `6`, clamped to `1`–`168`). |
 | `terminalSubmit` | Which bytes Claude reads as **submit** vs **newline**: `"cr"` (default — Enter submits, Shift+Enter makes a newline) or `"esc-cr"` (for a Claude Code rebound the other way). Applies to the keyboard **and** the phone remote-view submit, for **Claude sessions only** (shell/codex keep plain Enter). See the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#terminal-submit). |
 | `copyOnSelect` | `true` puts a **mouse selection on the clipboard the moment it settles**, with no key pressed (the PuTTY / iTerm2 behaviour). **Off by default** — it changes the clipboard when you may only have meant to highlight something. No Settings UI: edit the file and reload the tab. Composes with the `copy` keymap action rather than replacing it. Over plain `http://` the browser gives a page no clipboard access, so a fallback asks xterm to copy instead; see the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#copy-on-select). |
+| `decisionDigest` | Keep a **Markdown digest of the decisions this project's sessions asked for**, refreshed at startup and every few hours, so an agent can read what has already been decided before asking something similar. Written to `~/.mulmoterminal/decisions/<project>.md` (never into your repository) and served to agents by the bundled `mulmoterminal-decisions` skill. **Off by default** — it is a vision-stage idea, and it writes a file that would otherwise not exist. The digest holds dated facts, never inferred rules. |
 | `issueWorkComments` | Let a cell **comment on the issue it is working on**: once when it starts, and again when its PR merges (closing the issue if GitHub has not already). The comment names the working **directory** it happened in — the folder name only, never the path — so a reader can tell which clone. **Off by default**; it writes to GitHub, often on somebody else's issue. Needs `gh` logged in. See the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#issue-work-comments). |
 | `prWorkdirFooter` | Ends a PR body with `work in <clone>` — the directory name of the clone the work happened in, so a PR says which of several side-by-side checkouts produced it. Applies to **both** paths that open PRs here: **⧉ Open PR** appends it to the PR it creates, and every Claude session is told to end the bodies it writes with the same line (the name is resolved by the server, so a session inside a managed worktree still names the main checkout). **On by default**; set `false` to opt out — read per PR and per session spawn, so no restart is needed (there is no Settings control for it). Appending is idempotent: an existing PR never gets a second copy. |
 | `fontFamily` | The **terminal font** every session renders in — a CSS font-family stack, e.g. `"'Cica', 'MS Gothic', monospace"`. No Settings UI: edit the file, then **restart** (this config is read once at startup). Unset uses the built-in stack (JetBrains Mono / Fira Code / Menlo / Consolas, then CJK faces for Japanese, Korean and Chinese). Unlike the per-browser font **size**, this is one value for the whole host — it names fonts, and which fonts exist is a property of the machine. A directory can override it. See the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#font-family). |
@@ -1145,6 +1146,7 @@ same-origin-guarded.
 | `GET /api/transcript/timeline?session=&cwd=` | Per-session activity timeline (tools run). |
 | `GET /api/transcript/last-turn?session=&cwd=&agent=` | A session's last completed exchange (`prompt`, `reply`) plus the `text` to paste into another terminal. `agent=codex` reads the codex rollout instead of the Claude transcript. |
 | `GET /api/decisions?cwd=&limit=` | The decisions a human was asked to make in this project, newest first — each question with the options it offered, their descriptions, and the answer. `answerKind` says whether the answer was one of the options, text the user wrote instead (the question was wrong), or never given. Read out of Claude's own transcripts; writes nothing. `scanned` reports how many transcripts were read (the scan is capped) and `unreadable` how many could not be, so a partial answer is visible rather than implied. A `cwd` that is not an existing directory answers an empty response rather than falling back to the default workspace. |
+| `GET /api/decisions/digest?cwd=` | The same decisions as Markdown, for an agent to read (`{ enabled, markdown }`). `enabled: false` means the `decisionDigest` setting is off — a different answer from an empty digest, so a reader can tell "switched off" from "nothing decided here". |
 
 **Git & worktrees**
 
@@ -1469,7 +1471,7 @@ server/
   mcp/            per-session MCP broker
   backends/       wiki, collections, feeds, accounting, notifier,
                   translation, whisper, remote-host, html, files
-  skills/         bundled skills (mulmoterminal-config, mulmoterminal-bug-report)
+  skills/         bundled skills (mulmoterminal-config, mulmoterminal-bug-report, mulmoterminal-decisions)
   fix-pty-perms.js              postinstall: fixes node-pty binary permissions
 src/
   App.vue                       Layout; owns the active session + single/grid view

package/common/keymap.ts

@@ -37,7 +37,21 @@ export const isKeymapAction = (value: unknown): value is KeymapAction => typeof
 //     ^C. A handler that has already swallowed the key cannot change its mind.
 export const TERMINAL_SCOPED_ACTIONS: readonly KeymapAction[] = ["copy", "paste"];
 
-export type Keymap = Partial<Record<KeymapAction, string>>;
+// A key that puts BYTES into the focused terminal instead of running an app action (#1005) —
+// Cmd+Right as Ctrl+E for end-of-line, say, or Alt+B for word-back.
+//
+// A LIST, where every action above is a single field, because the two are shaped differently:
+// an action is one behaviour that a key is pointed at, while every send binding carries its own
+// payload. `{ "send": "\u0005" }` could only ever name one key.
+//
+// `bytes` goes to the PTY verbatim. Control characters are written the way JSON writes them
+// (`"\u0005"` is Ctrl+E); nothing here interprets or re-escapes them.
+export interface SendBinding {
+  key: string;
+  bytes: string;
+}
+
+export type Keymap = Partial<Record<KeymapAction, string>> & { send?: SendBinding[] };
 
 // A parsed binding. `key` is matched against `KeyboardEvent.key` exactly as the browser
 // reports it, so it is case-sensitive for printable characters ("a" and "A" differ, the
@@ -108,6 +122,26 @@ export function actionForKey(keymap: Keymap, e: KeymapKeyEvent): KeymapAction |
   return null;
 }
 
+const isSendBinding = (value: unknown): value is SendBinding =>
+  typeof value === "object" && value !== null && typeof (value as SendBinding).key === "string" && typeof (value as SendBinding).bytes === "string";
+
+// The bytes this keydown should put into the terminal, or null when it is not a send binding.
+//
+// Only reachable for keys the GRID did not claim: its handler listens on `window` in the capture
+// phase and calls stopPropagation(), so an action and a send binding on one keystroke is not a
+// race — the action always wins and the send silently never fires. validateKeymap warns about it
+// for that reason.
+//
+// First match wins, so a keystroke listed twice uses the earlier entry.
+export function sendBytesFor(keymap: Keymap, e: KeymapKeyEvent & { type: string; isComposing?: boolean }): string | null {
+  if (e.type !== "keydown" || e.isComposing) return null;
+  for (const entry of keymap.send ?? []) {
+    const binding = parseKeyBinding(entry.key);
+    if (binding && matchesBinding(binding, e)) return entry.bytes;
+  }
+  return null;
+}
+
 // What is wrong with one `keymap` entry. `fatal` separates a typo the user clearly meant to
 // work (a binding we cannot parse — the shortcut would silently never fire) from an action
 // name we simply do not know, which is what a config written for a NEWER version looks like
@@ -127,38 +161,74 @@ export function validateKeymap(input: unknown): KeymapProblem[] {
     return [{ action: "keymap", binding: input, reason: "`keymap` must be an object of action -> key binding", fatal: true }];
   }
   const entries = Object.entries(input as Record<string, unknown>);
-  const bound = new Map<string, { action: KeymapAction; binding: string }[]>();
+  // A claim on one keystroke. `rank` is DISPATCH order, so the winner can be named: every action
+  // outranks every send binding, because the grid's handler runs in the capture phase and stops
+  // the event before the terminal — see sendBytesFor.
+  const bound = new Map<string, Claim[]>();
+  const claim = (parsed: KeyBinding, entry: Claim): void => {
+    const key = canonicalBinding(parsed); // as PARSED: "Shift+PageUp" and "shift+pageup" are one keystroke
+    bound.set(key, [...(bound.get(key) ?? []), entry]);
+  };
   const problems = entries.flatMap(([action, binding]): KeymapProblem[] => {
+    if (action === "send") return sendProblems(binding, claim);
     if (!isKeymapAction(action)) {
-      return [{ action, binding, reason: `unknown action (known: ${KEYMAP_ACTIONS.join(", ")})`, fatal: false }];
+      return [{ action, binding, reason: `unknown action (known: ${KEYMAP_ACTIONS.join(", ")}, send)`, fatal: false }];
     }
     if (typeof binding !== "string") return [{ action, binding, reason: "binding must be a string", fatal: true }];
     const parsed = parseKeyBinding(binding);
     if (parsed === null) {
       return [{ action, binding, reason: 'unparseable key binding — expected e.g. "PageDown" or "Shift+PageUp"', fatal: true }];
     }
-    // Grouped as PARSED, since "Shift+PageUp" and "shift+pageup" are one keystroke.
-    const key = canonicalBinding(parsed);
-    bound.set(key, [...(bound.get(key) ?? []), { action, binding }]);
+    claim(parsed, { label: action, binding, rank: KEYMAP_ACTIONS.indexOf(action) });
     return [];
   });
   return [...problems, ...duplicateWarnings(bound)];
 }
 
-// Two actions on one keystroke: only one can fire, so the others silently never work.
+interface Claim {
+  label: string;
+  binding: string;
+  rank: number;
+}
+
+// Everything wrong with the `send` list, claiming the keystrokes that are well-formed.
+//
+// Fatal throughout, for the reason the module header gives: a send binding is invisible until
+// the key is pressed, so a dropped one is indistinguishable from a shortcut that "doesn't work".
+// Empty `bytes` is fatal too — it would take the key away from the terminal and put nothing back.
+function sendProblems(input: unknown, claim: (parsed: KeyBinding, entry: Claim) => void): KeymapProblem[] {
+  if (!Array.isArray(input)) {
+    return [{ action: "send", binding: input, reason: "`send` must be an array of { key, bytes }", fatal: true }];
+  }
+  return input.flatMap((entry, i): KeymapProblem[] => {
+    const label = `send[${i}]`;
+    if (!isSendBinding(entry)) return [{ action: label, binding: entry, reason: "expected { key: string, bytes: string }", fatal: true }];
+    const parsed = parseKeyBinding(entry.key);
+    if (parsed === null) {
+      return [{ action: label, binding: entry.key, reason: 'unparseable key binding — expected e.g. "Cmd+ArrowRight"', fatal: true }];
+    }
+    if (entry.bytes === "") {
+      return [{ action: label, binding: entry.key, reason: "`bytes` is empty — the key would be taken from the terminal and nothing sent", fatal: true }];
+    }
+    // Ranked after every action, matching who actually wins (see the `bound` comment above).
+    claim(parsed, { label, binding: entry.key, rank: KEYMAP_ACTIONS.length + i });
+    return [];
+  });
+}
+
+// Two claims on one keystroke: only one can fire, so the others silently never work.
 //
-// The winner is decided the way `actionForKey` decides it — first in KEYMAP_ACTIONS order —
-// NOT by which came first in the config file. Reporting the config-order winner would name
-// the wrong action whenever the two orders disagree, which is worse than not naming one.
-function duplicateWarnings(bound: Map<string, { action: KeymapAction; binding: string }[]>): KeymapProblem[] {
+// The winner is the one DISPATCH picks, not the one written first in the config file. Reporting
+// the config-order winner would name the wrong entry whenever the two orders disagree, which is
+// worse than not naming one.
+function duplicateWarnings(bound: Map<string, Claim[]>): KeymapProblem[] {
   return [...bound.values()].flatMap((claims) => {
     if (claims.length < 2) return [];
-    const byDispatch = [...claims].sort((a, b) => KEYMAP_ACTIONS.indexOf(a.action) - KEYMAP_ACTIONS.indexOf(b.action));
-    const [winner, ...losers] = byDispatch;
-    return losers.map(({ action, binding }) => ({
-      action,
+    const [winner, ...losers] = [...claims].sort((a, b) => a.rank - b.rank);
+    return losers.map(({ label, binding }) => ({
+      action: label,
       binding,
-      reason: `same keystroke as \`${winner.action}\` — only \`${winner.action}\` will fire`,
+      reason: `same keystroke as \`${winner.label}\` — only \`${winner.label}\` will fire`,
       fatal: false,
     }));
   });
@@ -172,8 +242,16 @@ const canonicalBinding = (b: KeyBinding): string => `${b.shift ? "S" : ""}${b.al
 // rest of the config treats one bad entry.
 export function sanitizeKeymap(input: unknown): Keymap {
   if (typeof input !== "object" || input === null || Array.isArray(input)) return {};
-  const entries = Object.entries(input as Record<string, unknown>).filter(
+  const raw = input as Record<string, unknown>;
+  const entries = Object.entries(raw).filter(
     (entry): entry is [KeymapAction, string] => isKeymapAction(entry[0]) && typeof entry[1] === "string" && parseKeyBinding(entry[1]) !== null,
   );
-  return Object.fromEntries(entries);
+  const send = sanitizeSendBindings(raw.send);
+  return { ...Object.fromEntries(entries), ...(send.length ? { send } : {}) };
 }
+
+// An entry survives only if it names a parseable key AND carries bytes to send. An empty `send`
+// is dropped entirely rather than kept as `[]`, so an absent and an emptied list look the same
+// to everything downstream.
+const sanitizeSendBindings = (input: unknown): SendBinding[] =>
+  Array.isArray(input) ? input.filter(isSendBinding).filter((entry) => entry.bytes !== "" && parseKeyBinding(entry.key) !== null) : [];

package/common/prPhase.ts

@@ -20,9 +20,19 @@ export interface WorkItem {
   prUrl: string | null;
   issue: number | null;
   issueUrl: string | null;
+  // Titles, for the surfaces that have room for words rather than a number — the phone's session
+  // list above all, where "#987" alone says nothing about which request is running (#1014).
+  prTitle: string | null;
+  issueTitle: string | null;
 }
 
-export const EMPTY_WORK_ITEM: Readonly<WorkItem> = { phase: "none", pr: null, prUrl: null, issue: null, issueUrl: null };
+export const EMPTY_WORK_ITEM: Readonly<WorkItem> = { phase: "none", pr: null, prUrl: null, issue: null, issueUrl: null, prTitle: null, issueTitle: null };
+
+// One line for a surface with room for one: what the work is FOR beats what was done about it, so
+// the issue's title wins when there is one. Null when neither side has a title to show.
+export function workItemHeadline(item: WorkItem): string | null {
+  return item.issueTitle ?? item.prTitle ?? null;
+}
 
 // GitHub's closing keywords, as GitHub itself matches them: any of these, then optional
 // whitespace/colon, then #N. Anything else in the body is a mention, not a link — a PR that

package/common/toolGroups.ts

@@ -0,0 +1,80 @@
+// The GUI MCP is served at one URL per GROUP of tools, so a user can turn a subset on for a
+// directory with Claude Code's own per-folder MCP config (`.mcp.json` / `claude mcp add -s
+// local`) instead of a MulmoTerminal setting. `.mcp.json` only switches whole SERVERS on and
+// off — splitting the URL is what turns that into tool granularity.
+//
+// These names appear in the URL path AND in the server id users write in their own config
+// (`mulmoterminal-<group>`), so they are effectively public API: renaming one breaks every
+// config already written against it.
+
+// The groups, ordered by how much damage a call can do.
+//   render   — draws into the Canvas panel and stops there. No side effect outside it.
+//   data     — reads/writes the workspace's structured data (collections, accounting).
+//   media    — generation that is slow, costly, and lands files on disk.
+//   external — reaches a third-party account or API.
+export const TOOL_GROUPS = ["render", "data", "media", "external"] as const;
+
+export type ToolGroup = (typeof TOOL_GROUPS)[number];
+
+export const isToolGroup = (value: unknown): value is ToolGroup => TOOL_GROUPS.some((group) => group === value);
+
+// The group the Canvas pane is made of. The launcher switch registers it, the panel's
+// availability is decided by it, and the server routes on it — named here rather than written
+// as `"render"` at each of those sites, so a rename cannot leave one of them silently pointing
+// at a group that no longer exists.
+export const CANVAS_TOOL_GROUP: ToolGroup = "render";
+
+// Which group each GUI tool belongs to.
+//
+// A tool that is absent belongs to NO group and is therefore reachable only through the
+// all-tools URL (`/api/mcp/:sessionId`, the single view). That is the deliberate failure
+// mode: forgetting to classify a newly added plugin withholds it from the group URLs rather
+// than leaking it into one — the map can go stale, but only ever closed.
+//
+// `spawnBackgroundChat` is absent ON PURPOSE, not by omission: it starts another session,
+// which is neither drawing, data, media, nor an external call, and a grid cell has no
+// business doing it silently.
+// A Map, not a plain object — the same reason the plugin dispatch map is one: object index
+// access reads through the prototype chain, so `constructor` / `__proto__` / `toString` would
+// resolve to an Object.prototype member and report a truthy "group". Map.get only ever returns
+// own entries.
+const GROUP_BY_TOOL = new Map<string, ToolGroup>([
+  ["presentDocument", "render"],
+  ["presentForm", "render"],
+  ["presentChart", "render"],
+  ["presentHtml", "render"],
+
+  // presentCollection RENDERS, but it renders collection data and only makes sense next to
+  // manageCollection — a cell offered the view without the store gets a tool it cannot fill.
+  ["presentCollection", "data"],
+  ["manageCollection", "data"],
+  ["manageAccounting", "data"],
+
+  ["generateImage", "media"],
+  ["presentMulmoScript", "media"],
+
+  ["google", "external"],
+  ["readXPost", "external"],
+  ["searchX", "external"],
+]);
+
+export const groupOfTool = (toolName: string): ToolGroup | null => GROUP_BY_TOOL.get(toolName) ?? null;
+
+// The MCP server id a group is expected to be registered under. `--allowedTools` matches on
+// `mcp__<server id>__<tool>`, and the id comes from the USER's config key — so this is a
+// convention the enable-it-for-this-folder affordance has to write, and a user who registers
+// the same URL under another name simply gets permission prompts (nothing breaks).
+export const toolGroupServerId = (group: ToolGroup): string => `mulmoterminal-${group}`;
+
+// The tools MulmoTerminal pre-approves via `--allowedTools`, so they run without a permission
+// prompt. A list of TOOLS, not of groups: a group says which tools a directory can reach, and
+// that is not the same question as which may run unattended.
+//
+// `presentDocument` is the case that forces them apart, and it is deliberately ABSENT. Its
+// execute runs `fillImages` before saving, which resolves every image placeholder in the
+// markdown through the image backend — a PAID generation call. Auto-allowing it would let a
+// model spend money silently under a switch the UI presents as "let the agent draw", so it
+// keeps Claude Code's prompt (answer it once per project and the prompt stops).
+//
+// The three below save an artifact and draw it, and call nothing external.
+export const AUTO_ALLOWED_TOOLS: readonly string[] = ["presentForm", "presentChart", "presentHtml"];

package/dist/assets/{abnfDiagram-VRR7QNED-RjiYivmv-CFwKVB03.js → abnfDiagram-VRR7QNED-RjiYivmv-CkfTvNiT.js}

@@ -1 +1 @@
-import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-Brzfja-q-ch1VcTiG.js";import{_ as n,g as r}from"./mermaid-parser.core-DxEa8E3F-DvKDRZGq.js";import"./chunk-WYO6CB5R-BlzOfotS-DenoOpP3.js";import"./chunk-VAUOI2AC-CS9QJ4yz-r_1UiH65.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-DDn-QIzL.js";import{t as s}from"./chunk-JWPE2WC7-BQ3zXr2k-DSd3Ct95.js";var c=r().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{a.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new n(r);let i=r.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:o,styles:i};export{g as diagram};
+import{n as e}from"./chunk-Y2CYZVJY-Bdt8pFDJ-DsF7k-Jl.js";import{f as t}from"./src-Brzfja-q-ch1VcTiG.js";import{_ as n,g as r}from"./mermaid-parser.core-DxEa8E3F-CscC8Qqr.js";import"./chunk-WYO6CB5R-BlzOfotS-CgOwOaF2.js";import"./chunk-VAUOI2AC-CS9QJ4yz-C1PM97Ei.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-CC-mdXDP.js";import{t as s}from"./chunk-JWPE2WC7-BQ3zXr2k-DSd3Ct95.js";var c=r().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{a.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let r=c.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new n(r);let i=r.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:o,styles:i};export{g as diagram};

package/dist/assets/architecture-TIHT7OUA-0NsD2xW1-F7APysNp.js

@@ -0,0 +1 @@
+import{f as e}from"./mermaid-parser.core-DxEa8E3F-CscC8Qqr.js";export{e as createArchitectureServices};