mulmoterminal 1.7.1 → 1.8.0

package/README.md

@@ -410,13 +410,16 @@ The Settings modal (⚙) persists per-user UI choices to `~/.mulmoterminal/confi
 | `pushEnabled` | `true` to send a **Web Push** to your registered devices when a background task finishes. Off by default; only sends while the **RemoteHost** channel is connected (see below). |
 | `worklogEnabled` | `true` to run the built-in **dev worklog** batch (see below). Off by default (each run spawns an LLM session, so it costs tokens). |
 | `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). |
 
 #### Header buttons
 
 Each terminal header shows configurable **action buttons**. Omitting `buttons` (globally or per-dir)
-keeps the built-in defaults — a **file-path picker** (📎) and an **OS file-manager reveal** (📂).
-Setting `buttons` (at either level) **replaces** the defaults with your list, so you can drop, reorder,
-or swap them — e.g. add the in-app **📁 file explorer** with `"open": { "files": "${dir}" }`.
+keeps the built-in **starter set**: a file-path picker (📎), an OS file-manager reveal (📂), an in-app
+file explorer (📁), a new terminal here (🖥), this branch's PR (🔗, git repos, only when a PR exists),
+and open-on-GitHub (🌐, git repos). Setting `buttons` (at either level) **replaces the whole default
+set** with your list (it is not merged on top), so listing your own — even a **shorter** one — is how
+you drop, reorder, or swap them.
 A button has an `id`, `label`, and a `run` of `"shell"` (run a command), `"input"` (send text to the
 agent), or `"open"`. An `open` button targets one of `url` / `reveal` (OS file manager) / `files`
 (in-app explorer) / `view` (a built-in overlay) / `terminal` (a dir → a new cell running `$SHELL`,
@@ -793,7 +796,9 @@ Favorited collections get their own toolbar buttons.
 - **Themes** — four terminal palettes (midnight / nord / daylight / solarized), your pick
   remembered; a project's `.mulmoterminal.json` can override per directory.
 - **Editing niceties** — **Shift+Enter** inserts a newline in the prompt, and on macOS
-  **Option** is treated as Meta so Claude's Alt-key bindings work.
+  **Option** is treated as Meta so Claude's Alt-key bindings work. If your Claude Code is
+  rebound so Enter and Shift+Enter behave backwards, flip them with
+  [`terminalSubmit`](https://receptron.github.io/mulmoterminal/guide/en/config.html#terminal-submit).
 
 ---
 

package/bin/mulmoterminal.js

@@ -7,13 +7,14 @@
 
 import { execSync, spawn } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
-import { get as httpGet } from "node:http";
 import { createRequire } from "node:module";
 import { createServer } from "node:net";
 import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { computeUpdateNotice, isUpdateCheckDisabled } from "./update-check.js";
+import { detectNpxCacheDir, npxCacheHintLines } from "./npx-cache-hint.js";
+import { waitUntilReady } from "./wait-ready.js";
 import {
   chooseCwd,
   parsePortArg,
@@ -30,10 +31,12 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_DIR = join(__dirname, "..");
 const SERVER_ENTRY = join(PKG_DIR, "server", "index.ts");
 const DEFAULT_PORT = 34567;
-const READY_TIMEOUT_MS = 15_000;
 // Server exit code meaning "port taken at bind time" — keep in sync with
 // server/index.ts (PORT_IN_USE_EXIT_CODE).
 const PORT_IN_USE_EXIT_CODE = 75;
+// Only the end of stderr matters for the crash diagnosis; a long-lived server can log
+// arbitrarily much before dying, so the tail is bounded.
+const STDERR_TAIL_MAX_BYTES = 64 * 1024;
 
 // Single source of truth: read the version from the shipped package.json so
 // `--version` never drifts from the published version.
@@ -170,36 +173,6 @@ function isPortFree(port) {
   });
 }
 
-// Poll the server until it answers, then call onReady; give up after the timeout
-// so the launcher never hangs on a crash loop. Returns a cancel function — a
-// raced/abandoned attempt stops polling so it can't fire a stale banner.
-function waitUntilReady(port, onReady) {
-  const startedAt = Date.now();
-  let timer = null;
-  let cancelled = false;
-  const attempt = () => {
-    if (cancelled) return;
-    const req = httpGet({ host: "127.0.0.1", port, path: "/", timeout: 1000 }, (res) => {
-      res.resume();
-      if (!cancelled) onReady();
-    });
-    req.on("error", retry);
-    req.on("timeout", () => {
-      req.destroy();
-      retry();
-    });
-  };
-  const retry = () => {
-    if (cancelled || Date.now() - startedAt > READY_TIMEOUT_MS) return;
-    timer = setTimeout(attempt, 300);
-  };
-  attempt();
-  return () => {
-    cancelled = true;
-    if (timer) clearTimeout(timer);
-  };
-}
-
 function printReadyBanner(url) {
   const bar = "\x1b[32m" + "─".repeat(48) + "\x1b[0m";
   console.log(`\n${bar}`);
@@ -272,10 +245,18 @@ async function choosePort(requested, explicit) {
 function runServer(port, noOpen, cwd, onChild) {
   return new Promise((resolveExit) => {
     log(`Starting MulmoTerminal on port ${port}...`);
+    // stderr is piped (and passed through) so a fatal boot error can be inspected once the
+    // child closes — a half-unpacked npx cache entry crashes here with ERR_MODULE_NOT_FOUND,
+    // and without reading stderr the launcher cannot tell that from a real bug.
     const server = spawn(process.execPath, ["--import", "tsx", SERVER_ENTRY], {
       cwd: PKG_DIR,
       env: { ...process.env, NODE_ENV: "production", PORT: String(port), CLAUDE_CWD: cwd },
-      stdio: "inherit",
+      stdio: ["inherit", "inherit", "pipe"],
+    });
+    let stderrTail = "";
+    server.stderr.on("data", (chunk) => {
+      process.stderr.write(chunk);
+      stderrTail = (stderrTail + chunk.toString()).slice(-STDERR_TAIL_MAX_BYTES);
     });
     onChild(server);
 
@@ -292,7 +273,10 @@ function runServer(port, noOpen, cwd, onChild) {
       }
     });
 
-    server.on("exit", (code) => {
+    // `close`, not `exit`: it fires only once the piped stderr has fully drained, so the
+    // whole crash output — including a trailing `_npx/<hash>` line that can arrive after
+    // `exit` — is in `stderrTail` before we inspect it.
+    server.on("close", (code) => {
       cancelReady();
       // Exit code 75 means this child failed to bind (EADDRINUSE) and never
       // served — always retriable, regardless of what a probe to the port saw
@@ -301,6 +285,10 @@ function runServer(port, noOpen, cwd, onChild) {
         resolveExit();
         return;
       }
+      if (code !== 0) {
+        const cacheDir = detectNpxCacheDir(stderrTail);
+        if (cacheDir) npxCacheHintLines(cacheDir, process.platform).forEach((line) => error(line));
+      }
       process.exit(code ?? 1);
     });
   });

package/bin/npx-cache-hint.d.ts

@@ -0,0 +1,2 @@
+export declare function detectNpxCacheDir(stderrText: string): string | null;
+export declare function npxCacheHintLines(cacheDir: string, platform: NodeJS.Platform): string[];

package/bin/npx-cache-hint.js

@@ -0,0 +1,69 @@
+// Turning a confusing crash into a one-line fix. When an `npx mulmoterminal` install is
+// aborted mid-unpack (npm's npx lock race — `ECOMPROMISED: Lock compromised`), the next run
+// reuses the half-unpacked `~/.npm/_npx/<hash>/node_modules` and dies at boot with
+// ERR_MODULE_NOT_FOUND for some transitive dependency. That reads as a broken package, but
+// the published tarball is fine — the local npx cache entry is corrupted, and removing it
+// is the whole fix. Nothing here reads the filesystem; the caller feeds it stderr text.
+
+const MISSING_MODULE = /ERR_MODULE_NOT_FOUND|Cannot find (?:package|module)/;
+
+// The cache entry itself: `<sep>_npx<sep><hash>` followed by another separator. Anchored on
+// the literal `_npx` rather than on a leading `[^\s'"]*` wildcard — that prefix can also match
+// separators, which makes the match ambiguous and the regex backtrack super-linearly on a long
+// stack trace. The directory part before it is recovered by scanning, not by matching.
+const NPX_ENTRY = /[/\\]_npx[/\\][0-9a-f]+(?=[/\\])/;
+
+// What ends the path token a stack trace embeds: whitespace, or the quotes Node wraps
+// specifiers in.
+const PATH_BOUNDARIES = [" ", "\t", "\n", "\r", "'", '"'];
+
+// Where the path token containing the entry begins: just past the last boundary before it.
+const pathStartIndex = (textBefore) => Math.max(-1, ...PATH_BOUNDARIES.map((ch) => textBefore.lastIndexOf(ch))) + 1;
+
+/**
+ * The corrupted npx cache entry a failed boot points at, or null.
+ * Fires only when BOTH signals are present — a module-resolution error and a path inside
+ * an `_npx/<hash>` cache entry — so an ordinary crash, or a resolution error in a normal
+ * install, never triggers the hint.
+ */
+export function detectNpxCacheDir(stderrText) {
+  if (typeof stderrText !== "string" || !MISSING_MODULE.test(stderrText)) return null;
+  const match = NPX_ENTRY.exec(stderrText);
+  if (!match) return null;
+  return stderrText.slice(pathStartIndex(stderrText.slice(0, match.index)), match.index + match[0].length);
+}
+
+// Shell-quote the cache dir so a path containing quote characters (a home dir with an
+// apostrophe on POSIX is the realistic case) produces a command that is still valid — and
+// safe — to copy-paste, rather than one that breaks or runs something unintended.
+
+// POSIX single-quoting: wrap in '…' and turn every embedded ' into '\'' (close, escaped
+// quote, reopen). Nothing inside single quotes is special, so this is injection-proof.
+const posixQuote = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+
+// PowerShell single-quoting: '…' with each ' doubled. Single quotes suppress $-interpolation
+// (a double-quoted path containing $ would otherwise expand a variable), so this is safe.
+const powershellQuote = (s) => `'${s.replace(/'/g, "''")}'`;
+
+// cmd has no way to escape a " inside "…", but " is an illegal character in a Windows path,
+// so double-quoting a real cache dir is safe; it protects the spaces that do occur.
+const cmdQuote = (s) => `"${s}"`;
+
+// The delete command differs per platform, and a wrong one is worse than none: `rm -rf` is not
+// a command on Windows, and cmd's `rmdir /s /q` is a syntax error in PowerShell (where `rmdir`
+// aliases Remove-Item), so Windows gets both of its shells spelled out.
+const removalCommands = (cacheDir, platform) =>
+  platform === "win32"
+    ? [`  cmd:        rmdir /s /q ${cmdQuote(cacheDir)}`, `  PowerShell: Remove-Item -Recurse -Force ${powershellQuote(cacheDir)}`]
+    : [`  rm -rf ${posixQuote(cacheDir)}`];
+
+/** The recovery instructions shown under the crash, one string per line. */
+export function npxCacheHintLines(cacheDir, platform) {
+  return [
+    "This looks like a corrupted npx cache, not a MulmoTerminal bug.",
+    'An interrupted `npx` install (npm\'s "Lock compromised" race) can leave this entry half-unpacked:',
+    `  ${cacheDir}`,
+    "Remove it and run the same command again:",
+    ...removalCommands(cacheDir, platform),
+  ];
+}

package/bin/wait-ready.d.ts

@@ -0,0 +1,26 @@
+// Only the surface probeOnce actually touches — narrower than http.ClientRequest /
+// IncomingMessage on purpose, so a test fake and the real node:http both satisfy it.
+export interface ProbeRequest {
+  on(event: "error" | "timeout", listener: (...args: unknown[]) => void): unknown;
+  destroy(): void;
+}
+
+export interface ProbeResponse {
+  resume(): void;
+}
+
+export type ProbeGet = (opts: { host: string; port: number; path: string; timeout: number }, cb: (res: ProbeResponse) => void) => ProbeRequest;
+
+export declare function probeOnce(get: ProbeGet, port: number, timeoutMs?: number): Promise<"ready" | "retry">;
+
+export declare function waitUntilReady(
+  port: number,
+  onReady: () => void,
+  deps?: {
+    get?: ProbeGet;
+    now?: () => number;
+    timeoutMs?: number;
+    intervalMs?: number;
+    readyTimeoutMs?: number;
+  },
+): () => void;

package/bin/wait-ready.js

@@ -0,0 +1,61 @@
+// Polling the launched server until it answers `/`, then firing onReady exactly once.
+// Split out of mulmoterminal.js so the retry state machine is testable without a socket.
+
+import { get as httpGet } from "node:http";
+
+const PROBE_TIMEOUT_MS = 1000;
+const RETRY_INTERVAL_MS = 300;
+const DEFAULT_READY_TIMEOUT_MS = 15_000;
+
+// One probe of the server: resolves "ready" if it answers, else "retry". It NEVER
+// rejects, and yields exactly ONE outcome per call — the crucial guarantee. Destroying a
+// timed-out request itself emits an 'error', so a single timeout would otherwise trigger
+// both the timeout handler AND the error handler; each schedules a retry, the poll loop
+// forks in two, and every fork fires onReady when the server finally answers — printing
+// the banner and opening the browser several times. The `settled` latch collapses each
+// request to one outcome.
+export function probeOnce(get, port, timeoutMs = PROBE_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (outcome) => {
+      if (settled) return;
+      settled = true;
+      resolve(outcome);
+    };
+    const req = get({ host: "127.0.0.1", port, path: "/", timeout: timeoutMs }, (res) => {
+      res.resume();
+      done("ready");
+    });
+    req.on("error", () => done("retry"));
+    req.on("timeout", () => {
+      req.destroy();
+      done("retry");
+    });
+  });
+}
+
+// Poll until the server answers, then call onReady once; give up after readyTimeoutMs so
+// the launcher never hangs on a crash loop. Returns a cancel function — a raced/abandoned
+// attempt stops polling so it can't fire a stale banner. `deps` is injectable for tests.
+export function waitUntilReady(port, onReady, deps = {}) {
+  const { get = httpGet, now = Date.now, timeoutMs = PROBE_TIMEOUT_MS, intervalMs = RETRY_INTERVAL_MS, readyTimeoutMs = DEFAULT_READY_TIMEOUT_MS } = deps;
+  const startedAt = now();
+  let cancelled = false;
+  let timer = null;
+  const loop = async () => {
+    if (cancelled) return;
+    const outcome = await probeOnce(get, port, timeoutMs);
+    if (cancelled) return;
+    if (outcome === "ready") {
+      onReady();
+      return;
+    }
+    if (now() - startedAt > readyTimeoutMs) return;
+    timer = setTimeout(loop, intervalMs);
+  };
+  loop();
+  return () => {
+    cancelled = true;
+    if (timer) clearTimeout(timer);
+  };
+}

package/common/modelPresets.ts

@@ -197,7 +197,7 @@ export const MODEL_PRESETS: readonly ModelPreset[] = [
     provider: "openrouter",
     id: "nvidia/nemotron-3-ultra-550b-a55b",
     label: "Nemotron 3 Ultra 550B",
-    contextLength: 512_288,
+    contextLength: 524_288, // 512 KiB = 512 * 1024; was 512_288 (a typo)
     pricePerMTok: { input: 0.6, output: 3.6 },
     trials: measured(3, 3, 13),
   },
@@ -300,14 +300,19 @@ export const MODEL_PRESETS: readonly ModelPreset[] = [
 
 // Presets for one provider, plus whatever the user added to that provider's `models`.
 // A user entry with the same id as a preset keeps the preset's measured numbers rather
-// than appearing twice.
+// than appearing twice — and two user entries for the same id (even differing only in
+// case) collapse to one, so a dropdown never shows the same model twice.
 export function presetsForProvider(providerId: string, userModels: readonly string[] = []): ModelPreset[] {
   const presets = MODEL_PRESETS.filter((preset) => preset.provider === providerId);
   // Match `presetFor` (modelOption.ts), which compares ids case-insensitively: a user
   // entry that only differs from a preset in case is the same model, not a new one.
-  const known = new Set(presets.map((preset) => preset.id.toLowerCase()));
-  const added: ModelPreset[] = userModels
-    .filter((id) => !known.has(id.toLowerCase()))
-    .map((id) => ({ provider: providerId, id, label: id, contextLength: 0, pricePerMTok: { input: 0, output: 0 }, trials: { status: "unmeasured" } }));
+  const seen = new Set(presets.map((preset) => preset.id.toLowerCase()));
+  const added: ModelPreset[] = [];
+  for (const id of userModels) {
+    const key = id.toLowerCase();
+    if (seen.has(key)) continue; // already a preset OR an earlier user entry
+    seen.add(key);
+    added.push({ provider: providerId, id, label: id, contextLength: 0, pricePerMTok: { input: 0, output: 0 }, trials: { status: "unmeasured" } });
+  }
   return [...presets, ...added];
 }

package/common/terminalSubmit.ts

@@ -0,0 +1,70 @@
+// How the host's Claude Code / TUI maps received bytes to "submit this prompt" vs
+// "insert a newline". The TUI decides from the bytes, and that mapping is environment-
+// dependent (Claude Code lets a user rebind it), so the SAME fact has to reach two
+// unrelated places: the browser's xterm key handler and the phone remote-view's submit.
+// One value, consumed by both, keeps them from drifting apart.
+//
+//   "cr"      — the standard binding: CR (\r) submits, ESC+CR (\x1b\r, = Alt/Meta+Enter)
+//               makes a newline. This is MulmoTerminal's default and unchanged behaviour.
+//   "esc-cr"  — the reversed binding some users configure: ESC+CR submits, CR makes a
+//               newline.
+export const TERMINAL_SUBMIT_MODES = ["cr", "esc-cr"] as const;
+export type TerminalSubmitMode = (typeof TERMINAL_SUBMIT_MODES)[number];
+export const DEFAULT_TERMINAL_SUBMIT_MODE: TerminalSubmitMode = "cr";
+
+export const isTerminalSubmitMode = (value: unknown): value is TerminalSubmitMode =>
+  typeof value === "string" && (TERMINAL_SUBMIT_MODES as readonly string[]).includes(value);
+
+// CR on its own. ESC+CR is what a terminal emits for Alt/Meta+Enter.
+const CR = "\r";
+const ESC_CR = "\x1b\r";
+
+// The byte(s) the host reads as "submit this prompt" in the given mode.
+export const submitSequence = (mode: TerminalSubmitMode): string => (mode === "esc-cr" ? ESC_CR : CR);
+// The byte(s) it reads as "insert a newline" — the other one.
+export const newlineSequence = (mode: TerminalSubmitMode): string => (mode === "esc-cr" ? CR : ESC_CR);
+
+// The submit byte(s) for a specific session. `terminalSubmit` describes the user's CLAUDE
+// binding, so it applies ONLY to Claude sessions; every other agent (shell, codex, a
+// one-shot command) keeps plain CR — a reversed setting must never rewrite a shell's Enter,
+// where ESC+CR is Alt+Enter, not submit.
+export const submitSequenceForAgent = (agent: string | undefined, mode: TerminalSubmitMode): string => (agent === "claude" ? submitSequence(mode) : CR);
+
+// The structural shape of a keydown the override needs. A real DOM KeyboardEvent satisfies
+// it, and so does a plain test object — no DOM dependency, so this stays testable and shared.
+export interface EnterKeyEvent {
+  type: string;
+  key: string;
+  shiftKey: boolean;
+  altKey: boolean;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  isComposing?: boolean;
+}
+
+// The bytes to emit for an Enter-family keydown (the caller then suppresses xterm's own
+// \r and sends these instead), or null to let xterm handle the key natively.
+//
+// The SEMANTICS are the same in both modes — a bare Enter SUBMITS, Shift/Alt(Option)+Enter
+// make a NEWLINE — only which bytes carry each meaning differs, because that is the
+// environment fact `mode` encodes.
+//
+// In "cr" mode only Shift+Enter is overridden, exactly as before the setting existed: a
+// bare Enter falls through to xterm's native \r (submit) and Option+Enter to
+// macOptionIsMeta's ESC+CR (newline). Leaving the bare-Enter path native keeps IME
+// candidate-confirm and the hottest key untouched in the default configuration.
+export const enterKeyOverride = (mode: TerminalSubmitMode, e: EnterKeyEvent): string | null => {
+  if (e.type !== "keydown" || e.key !== "Enter") return null;
+  // IME composition (Japanese and other CJK input): this Enter confirms a candidate — it
+  // is never the user's submit/newline, so never intercept it.
+  if (e.isComposing) return null;
+  const bare = !e.shiftKey && !e.altKey && !e.ctrlKey && !e.metaKey;
+  const shiftOnly = e.shiftKey && !e.altKey && !e.ctrlKey && !e.metaKey;
+  const altHeld = e.altKey && !e.ctrlKey && !e.metaKey; // Option/Alt (with or without Shift)
+  if (mode === "cr") return shiftOnly ? newlineSequence(mode) : null;
+  // "esc-cr": a bare Enter must emit the ESC+CR that submits here; Shift/Alt+Enter must
+  // emit the CR that makes a newline (the Alt case also overrides macOptionIsMeta's ESC+CR).
+  if (bare) return submitSequence(mode);
+  if (shiftOnly || altHeld) return newlineSequence(mode);
+  return null;
+};

package/dist/assets/{abnfDiagram-VRR7QNED-RjiYivmv-0ZB3Q7Mv.js → abnfDiagram-VRR7QNED-RjiYivmv-Dv9Yctvh.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-bFNCoAMV.js";import"./chunk-WYO6CB5R-BlzOfotS-Dm5-lJPj.js";import"./chunk-VAUOI2AC-CS9QJ4yz-BkjFKKFo.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-DynKnij8.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-DjFZ0x4N.js";import"./chunk-WYO6CB5R-BlzOfotS-BuYOtRW-.js";import"./chunk-VAUOI2AC-CS9QJ4yz-C8yjyNAb.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-Dv_IeGiN.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-D3TA8fTd.js

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