mulmoterminal 2.5.0 → 2.5.2

package/README.md

@@ -2,6 +2,12 @@
 
 **Run a whole team of coding agents from your browser — and actually keep up with them.**
 
+A **browser terminal** for **parallel AI coding agents**: several **Claude Code** and **Codex**
+sessions side by side, each in its own cell, with the one that needs you marked in colour. Vibe
+coding with a single agent needs nothing but a shell — this is for when you run several and lose
+track of which is waiting. Sessions survive a reload (tmux), work isolates in **git worktrees**,
+and a **phone push** reaches you when a turn finishes.
+
 ### 📖 Documentation — **[receptron.github.io/mulmoterminal](https://receptron.github.io/mulmoterminal/)**
 
 - **User guide:** [English](https://receptron.github.io/mulmoterminal/guide/en/) — the grid
@@ -482,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). |
+| `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). |
 
@@ -876,7 +883,9 @@ Each grid cell's header shows two badges for its session, refreshed when a turn
   current-gen Opus / Sonnet / Fable / Mythos, **200k** otherwise). A session running on a
   [provider model](#agents-claude--codex) shows that model's name and its published window
   (`Kimi K2.7 Code · ctx 12%`); a model in neither list keeps the label and hides the %,
-  since the window is never guessed.
+  since the window is never guessed. A reading **past 100%** shows `ctx ?` instead of the
+  number: the window is a hard cap, so an impossible percentage means the built-in window
+  table is out of date for that model rather than that the session is over-full.
 - **Token badge** — `⇡<in> ⇣<out>`: cumulative input (fresh + cache-read + cache-creation)
   and output tokens for the session, k/M-formatted, with a full breakdown in the tooltip.
 
@@ -1135,6 +1144,7 @@ same-origin-guarded.
 | `GET /api/cost?cwd=&session=` | Estimated $ cost — session / today / month. |
 | `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. |
 
 **Git & worktrees**
 

package/common/codeBlocks.ts

@@ -0,0 +1,88 @@
+// Fenced code blocks in a markdown string (#865).
+//
+// The point is to hand another app EXACTLY what the agent wrote. Selecting the same text off
+// the terminal picks up the leading padding xterm draws with it, which is what breaks a paste
+// into Discord or Slack — so the source here is the agent's own transcript markdown, never the
+// screen.
+//
+// Deliberately not a markdown parser. It answers one question — where do the fences sit — and
+// the cases below are the ones a real reply produces:
+//
+//   - ``` and ~~~ are both fences, and a run of 3+ of the same character opens one
+//   - a fence closes only on the SAME character, at least as long as the opener. That is what
+//     lets a shell snippet contain ``` inside a ~~~~ block without cutting it short
+//   - an info string (```ts, ```bash) names the language; the rest of that line is dropped
+//   - a fence may be indented up to 3 spaces, per CommonMark
+//   - an UNCLOSED fence still yields a block, running to the end of the text. An agent whose
+//     output was cut off mid-block is exactly when someone reaches for this, and refusing to
+//     return anything would read as "there is no code here"
+
+export interface FencedBlock {
+  /** The info string's first word, lower-cased — `ts`, `bash` — or null when absent. */
+  lang: string | null;
+  /** The block's contents, verbatim apart from the trailing newline. */
+  body: string;
+}
+
+interface Fence {
+  /** The run itself, so its LENGTH can gate what is allowed to close it. */
+  run: string;
+  /** Everything after the run — the info string on an opener, empty on a closer. */
+  info: string;
+}
+
+// Scanned by hand rather than with a pattern: the obvious regex (` {0,3}(`{3,}|~{3,})(.*)`)
+// nests two quantifiers under an alternation, which the linter flags for super-linear
+// backtracking. This walk is plainly one pass, and reads closer to the rule it implements.
+// Up to three leading spaces are allowed (CommonMark); a fourth makes it an indented code
+// block, not a fence.
+function fenceOf(line: string): Fence | null {
+  let i = 0;
+  while (i < 3 && line[i] === " ") i++;
+  const char = line[i];
+  if (char !== "`" && char !== "~") return null;
+  let length = 0;
+  while (line[i + length] === char) length++;
+  if (length < 3) return null;
+  return { run: line.slice(i, i + length), info: line.slice(i + length) };
+}
+
+// A closing fence is the same character, at least as long, with nothing after it. Compared
+// after `.trim()` because trailing whitespace is invisible and would otherwise leave the block
+// silently unclosed.
+const closes = (line: string, opener: string): boolean => {
+  const fence = fenceOf(line);
+  return !!fence && fence.run[0] === opener[0] && fence.run.length >= opener.length && fence.info.trim() === "";
+};
+
+export function fencedBlocks(markdown: string): FencedBlock[] {
+  const lines = markdown.split("\n");
+  const blocks: FencedBlock[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    const open = fenceOf(lines[i]);
+    if (!open) {
+      i++;
+      continue;
+    }
+    const fence = open.run;
+    const info = open.info.trim();
+    const body: string[] = [];
+    i++;
+    while (i < lines.length && !closes(lines[i], fence)) {
+      body.push(lines[i]);
+      i++;
+    }
+    i++; // step over the closing fence (or past the end, for an unclosed block)
+    blocks.push({ lang: info ? (info.split(/\s+/)[0].toLowerCase() ?? null) : null, body: body.join("\n") });
+  }
+  return blocks;
+}
+
+/** The block a reader means by "the code you just gave me": the last one. Null when the reply
+ *  has no fenced block, or when the only ones are empty — an empty clipboard would look
+ *  exactly like a copy that silently failed. */
+export function lastFencedBlock(markdown: string): FencedBlock | null {
+  const withBody = fencedBlocks(markdown).filter((b) => b.body.trim() !== "");
+  return withBody.length ? withBody[withBody.length - 1] : null;
+}

package/common/decisionLog.ts

@@ -0,0 +1,49 @@
+// A decision a human was asked to make, as it was actually asked and answered.
+//
+// The record is not something this app writes: Claude Code already stores every
+// `AskUserQuestion` in its transcript, options and chosen answer included. These types are the
+// shape we read it back in, shared because both the API and the UI decide from them (#997).
+
+/** One option the user was offered, with the reasoning shown alongside it — this is where the
+ *  consequence of the branch NOT taken is recorded. */
+export interface DecisionOption {
+  label: string;
+  description: string;
+}
+
+/** Where the answer came from. `free-text` means the user declined every option and wrote their
+ *  own answer, which is evidence about the QUESTION (wrong options, or a premise the asker and
+ *  the user did not share) rather than about the choice. `unanswered` is a question that was
+ *  asked and never resolved — the session was interrupted or abandoned. */
+export type DecisionAnswerKind = "option" | "free-text" | "unanswered";
+
+export interface DecisionQuestion {
+  question: string;
+  /** The short chip the UI showed above the question ("進め方", "Auth method"). */
+  header: string;
+  multiSelect: boolean;
+  options: DecisionOption[];
+  /** Verbatim, exactly as it came back. Null when nothing came back. */
+  answer: string | null;
+  answerKind: DecisionAnswerKind;
+}
+
+/** One `AskUserQuestion` call: the questions it asked together, and what each got back. */
+export interface DecisionRecord {
+  sessionId: string;
+  cwd: string | null;
+  /** ISO timestamp of the turn that asked. */
+  ts: string;
+  toolUseId: string;
+  questions: DecisionQuestion[];
+}
+
+export interface DecisionsResponse {
+  decisions: DecisionRecord[];
+  /** How many transcripts were read successfully. Bounded, so a caller can tell a quiet project
+   *  from a truncated scan. */
+  scanned: number;
+  /** How many could not be read at all. Reported rather than folded into `scanned`, because a
+   *  read that failed is missing decisions — not a session that had none. */
+  unreadable: number;
+}

package/common/themeVars.ts

@@ -0,0 +1,134 @@
+// A custom theme's colours, and the rules that turn a user's `themes` entry into something the
+// app can paint with. Shared across the build boundary for the same reason THEME_COLOR_KEYS is
+// (see themeColors.ts): the server VALIDATES a config against these keys and the client APPLIES
+// it, so a key known to one side and not the other would be accepted and then silently ignored.
+
+import { THEME_IDS, type ThemeId } from "./themeIds.js";
+
+// The CSS custom properties one theme sets, mirroring the `:root[data-theme=...]` blocks in
+// src/style.css. A theme with no `extends` has to supply every one of them — a half-painted
+// theme is worse than none, because the missing half falls back to whatever the previous theme
+// left on the element.
+export const THEME_VAR_KEYS = [
+  "--bg-base",
+  "--bg-deep",
+  "--bg-panel",
+  "--bg-subtle",
+  "--bg-elevated",
+  "--bg-input",
+  "--bg-hover",
+  "--bg-selected",
+  "--bg-selected-hover",
+  "--border",
+  "--accent",
+  "--accent-bg",
+  "--accent-bg-hover",
+  "--on-accent",
+  "--text",
+  "--text-secondary",
+  "--text-muted",
+  "--text-dim",
+  "--term-fg",
+  "--term-selection",
+] as const;
+
+export type ThemeVarKey = (typeof THEME_VAR_KEYS)[number];
+export type ThemeVars = Record<ThemeVarKey, string>;
+
+/** An id a user may give a custom theme: lowercase, digits and dashes, so it is safe both as a
+ *  `data-theme` attribute value and as something to type into a `.mulmoterminal.json`. */
+export const CUSTOM_THEME_ID_RE = /^[a-z][a-z0-9-]{0,31}$/;
+
+/** Whether a value could name a theme — built-in OR user-defined.
+ *
+ *  The result is `string`, deliberately NOT `ThemeId`: that is the CLOSED set of four built-ins,
+ *  and a guard claiming it while custom ids flow through would let downstream code treat a
+ *  four-way switch as exhaustive (Codex review on #996). Membership is not checked here — the
+ *  server drops an id that resolves to nothing, and termThemeFor() resolves what survives. */
+export function isThemeIdLike(value: unknown): value is string {
+  return typeof value === "string" && CUSTOM_THEME_ID_RE.test(value);
+}
+
+export function isBuiltinThemeId(id: string): id is ThemeId {
+  return (THEME_IDS as readonly string[]).includes(id);
+}
+
+/** Whether an id may be used for a CUSTOM theme. Built-in ids are refused rather than merged
+ *  into: someone reading the guide's description of Midnight has to get Midnight. */
+export function isUsableCustomThemeId(id: unknown): id is string {
+  return typeof id === "string" && CUSTOM_THEME_ID_RE.test(id) && !isBuiltinThemeId(id);
+}
+
+export interface CustomThemeInput {
+  id: string;
+  label: string;
+  /** A built-in theme to start from. Omitted means `colors` must be complete. */
+  extends?: ThemeId;
+  colors: Partial<ThemeVars>;
+}
+
+/** The full variable set for a theme: the base it extends, with its own colours on top.
+ *  `builtins` supplies the base sets so this stays pure — the client reads them from the
+ *  stylesheet's source of truth, the specs from a fixture. */
+export function resolveThemeVars(theme: CustomThemeInput, builtins: Record<ThemeId, ThemeVars>): ThemeVars | null {
+  const base = theme.extends ? builtins[theme.extends] : null;
+  const merged = { ...(base ?? {}), ...theme.colors } as Partial<ThemeVars>;
+  const missing = THEME_VAR_KEYS.filter((key) => !merged[key]);
+  // No base and an incomplete list is the one case we cannot paint: report it rather than
+  // leaving the gaps to whatever the previously applied theme put on the element.
+  return missing.length ? null : (merged as ThemeVars);
+}
+
+function channel(hex: string, at: number): number {
+  const value = parseInt(hex.slice(at, at + 2), 16) / 255;
+  return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+}
+
+/** `#rgb` / `#rgba` / `#rrggbb` / `#rrggbbaa` as `#rrggbb`, or null. The config schema accepts
+ *  every one of those forms, so anything reading a colour has to expand the short ones — a
+ *  luminance check that understood only the six-digit form would read `#fff` as unmeasurable and
+ *  call a white theme dark (Codex review on #996).
+ *
+ *  Alpha is dropped rather than composited: what a translucent `--bg-base` ends up looking like
+ *  depends on what is behind it, which nothing here can know. The opaque colour is the closest
+ *  honest answer, and `--bg-base` is the one variable where translucency makes least sense. */
+export function normalizeHexColor(color: string): string | null {
+  const hex = color.trim().toLowerCase();
+  if (!/^#[0-9a-f]{3,8}$/.test(hex)) return null;
+  const digits = hex.slice(1);
+  if (digits.length === 3 || digits.length === 4) {
+    return `#${[...digits.slice(0, 3)].map((d) => d + d).join("")}`;
+  }
+  if (digits.length === 6 || digits.length === 8) return `#${digits.slice(0, 6)}`;
+  return null;
+}
+
+/** Relative luminance (WCAG) of any hex colour the config accepts. Null for anything else. */
+export function relativeLuminance(color: string): number | null {
+  const hex = normalizeHexColor(color);
+  if (!hex) return null;
+  return 0.2126 * channel(hex, 1) + 0.7152 * channel(hex, 3) + 0.0722 * channel(hex, 5);
+}
+
+// Above this, the chrome is treated as a light theme. The status pills (ok / warn / err) come in
+// a dark-background set and a light-background set, and picking the wrong one leaves them
+// unreadable — which is why this is derived rather than declared: a theme author who never
+// thinks about it still gets legible pills.
+const LIGHT_LUMINANCE_THRESHOLD = 0.4;
+
+export function isLightTheme(vars: ThemeVars): boolean {
+  const luminance = relativeLuminance(vars["--bg-base"]);
+  return luminance !== null && luminance > LIGHT_LUMINANCE_THRESHOLD;
+}
+
+/** The xterm palette a theme's variables imply. xterm draws on a canvas and cannot read CSS
+ *  variables, so the same colours have to reach it as values — derived here rather than asked
+ *  for twice, since two copies of one colour is two chances to change only one. The 16 ANSI
+ *  colours are NOT derived: they come from the base theme, which is what `extends` is for. */
+export function termThemeFromVars(vars: ThemeVars): { background: string; foreground: string; selectionBackground: string } {
+  return {
+    background: vars["--bg-base"],
+    foreground: vars["--term-fg"],
+    selectionBackground: vars["--term-selection"],
+  };
+}

package/common/workComment.ts

@@ -0,0 +1,44 @@
+// The comments MulmoTerminal leaves on an issue: "a cell is on this" and "it was merged" (#979).
+// Pure, and shared, because the marker is the whole idempotency story — the server writes it and
+// the server reads it back, and a mismatch between the two would post the same comment on every
+// poll of every tab.
+
+export type WorkCommentKind = "start" | "merged";
+
+// An HTML comment, so it is invisible in the rendered issue but survives a round-trip through the
+// GitHub API. Keyed by kind AND directory: the same issue worked on from a second clone is a
+// second, honest line in the thread, not a duplicate to suppress.
+//
+// The directory is percent-encoded, not interpolated raw: a folder may legally be called
+// `foo-->bar`, and that string ends the HTML comment early — the rest spills into the rendered
+// issue as text (Codex review). Encoding also keeps a newline or a backtick in a path from
+// reshaping the comment. Ordinary names encode to themselves, so markers already posted still
+// match.
+export function workCommentMarker(kind: WorkCommentKind, dir: string): string {
+  return `<!-- mulmoterminal:work:${kind} dir=${encodeURIComponent(dir)} -->`;
+}
+
+// The directory a comment names. The BASENAME only: the point is "which of my clones", and a full
+// path on a public issue leaks the machine's layout (and, on a work machine, project names).
+export function workCommentDirLabel(cwd: string): string {
+  // Split-and-take-last rather than trimming a trailing separator with a regex: an anchored
+  // `[/\\]+$` backtracks super-linearly, and a path is user input.
+  const parts = cwd.split(/[/\\]/).filter((part) => part !== "");
+  return parts[parts.length - 1] ?? cwd;
+}
+
+// `pr` is the number the merge came in as, when there is one — a reader of the issue should not
+// have to go looking for which PR closed it.
+export function workCommentBody(kind: WorkCommentKind, dir: string, pr: number | null): string {
+  const marker = workCommentMarker(kind, dir);
+  if (kind === "start") return `Working on this in \`${dir}\`.\n\n${marker}`;
+  const where = pr === null ? "Merged." : `Merged in #${pr}.`;
+  return `${where} Work done in \`${dir}\`.\n\n${marker}`;
+}
+
+// Has this exact comment already been left? Matching on the marker rather than the prose means an
+// edited comment, or a change to the wording above, still counts as "already said".
+export function alreadyCommented(bodies: readonly string[], kind: WorkCommentKind, dir: string): boolean {
+  const marker = workCommentMarker(kind, dir);
+  return bodies.some((body) => typeof body === "string" && body.includes(marker));
+}

package/dist/assets/{abnfDiagram-VRR7QNED-RjiYivmv-ZKZeabOo.js → abnfDiagram-VRR7QNED-RjiYivmv-CFwKVB03.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-BAMiAMZz.js";import"./chunk-WYO6CB5R-BlzOfotS-CoeWhGPT.js";import"./chunk-VAUOI2AC-CS9QJ4yz-DYmUgyge.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-B6_lajzj.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-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};

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

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