mulmoterminal 4.3.0 → 4.4.0

package/README.md

@@ -1,4 +1,4 @@
-# mulmoterminal
+# MulmoTerminal
 
 **Run multiple Claude Code and Codex sessions in parallel — and see which one needs you.**
 
@@ -34,6 +34,10 @@ ping to your phone when a task finishes. One `npx` command, no Electron, no conf
 npx mulmoterminal@latest        # starts on http://localhost:34567 and opens your browser
 ```
 
+Built by **[receptron](https://github.com/receptron)** — **[Satoshi Nakajima](https://x.com/snakajima)**,
+software architect for **Windows 95** at Microsoft, and **[Isamu Arimoto](https://github.com/isamu)**;
+the same two behind **[GraphAI](https://github.com/receptron/graphai)**. [More ↓](#who-builds-this)
+
 > **Something looks wrong?** Type `/mulmoterminal-bug-report` in any MulmoTerminal session. The
 > bundled skill hears the symptom out, checks your **real** config, schema and version to see
 > whether the behaviour is configuration or by design, searches the existing issues — and only
@@ -393,7 +397,7 @@ today — **Claude Code** (the default), **Codex**, and **Antigravity** (`agy`).
   file exists, and injects activity hooks per spawn (see
   [Claude hook injection](#claude-hook-injection)) plus the
   [closing summary](#closing-summary) instruction.
-  The **whole** GUI MCP (`--mcp-config` + `--strict-mcp-config`) goes only to a session that is not a grid cell, or to a grid cell whose cwd IS the workspace — `carriesFullGuiMcp` in `server/session/spawn-claude.ts`, which is what gives a workspace cell the tools the single view had before 4.0.0 removed it. That equivalence is about what the session *carries*: a workspace cell is still a grid cell in every other respect. A cell in a project directory attaches neither flag, so Claude Code loads MCP servers the ordinary way — the directory's own local scope, any `.mcp.json` up the tree, and your global ones — including whichever [Canvas switches](#wiki-collections--the-gui-panel) are registered for it.
+  The **whole** GUI MCP (`--mcp-config`, on one all-tools URL) goes only to a session that is not a grid cell, or to a grid cell whose cwd IS the workspace — `claimFullGuiMcp` in `server/session/registry.ts`, which is what gives a workspace cell the tools the single view had before 4.0.0 removed it. That equivalence is about what the session *carries*: a workspace cell is still a grid cell in every other respect. A cell in a project directory attaches none of ours, so its GUI tools come from whichever [Canvas switches](#wiki-collections--the-gui-panel) are registered for it. **Either way, Claude Code loads your own MCP servers normally** — the directory's local scope, any `.mcp.json` up the tree, your global ones and your claude.ai connectors. It did not always: `--strict-mcp-config` used to ride along with `--mcp-config`, which hid all of that from the very sessions meant to be the most capable ([#1338](https://github.com/receptron/mulmoterminal/issues/1338), [#1385](https://github.com/receptron/mulmoterminal/issues/1385)).
 - **Codex** — spawned as `codex` (override with `CODEX_BIN`; `CODEX_MODEL` sets
   `--model`). Codex runs on its own WebSocket (`/ws/codex`) and its sessions appear in the
   cockpit roster next to Claude's. Because Codex only mints its rollout id **after** the first
@@ -562,7 +566,7 @@ The Settings modal (⚙) persists per-user UI choices to `~/.mulmoterminal/confi
 | `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). |
+| `issueWorkComments` | Let a cell **comment on the issue it is working on**: **one comment**, posted when the work starts and then **edited** as the PR opens and merges (closing the issue if GitHub has not already), each milestone stamped in UTC. The comment names the working **directory** it happened in — the folder name only, never the path — so a reader can tell which clone, and two terminals do not start the same issue twice. It says it came from MulmoTerminal. CI is deliberately not reported: it is on the PR already, and it flaps. When it **cannot** write — no `gh`, not logged in, or a login without write access — the cell says so next to the work chip rather than doing nothing silently; the work is unaffected either way. **Off by default**; it writes to GitHub, often on somebody else's issue. Needs `gh` logged in **with write access**. 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. |
 | `appendSystemPrompt` | Whether a spawned Claude session is asked to end a reply with a **closing summary** — what was asked, what was achieved, what was not (see [Closing summary](#closing-summary)). **On by default**; set `false` to opt out, and a directory's `.mulmoterminal.json` outranks this. Read per spawn, so no restart is needed (there is no Settings control for it), though a session already running keeps what it was launched with. `true` / `false` only. |
 | `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). |
@@ -772,15 +776,17 @@ In dev, open the Vite URL; its proxy forwards `/ws`, `/ws/pubsub`, and `/api` to
 
 An empty grid cell's launcher sets the **Working directory** by typing, by a preset
 chip, or with the **📁 folder button** (a native OS folder dialog). The preset chips are
-the directories you have launched in; the **workspace** leads them always, marked with an
-icon, whether or not you have ever launched there — it is the one directory where a
-session reaches every GUI tool, so it is never a click you can lose. It has no remove
-button for the same reason.
+the directories you have launched in; the **workspace** leads them always, labelled
+**WORKSPACE** and marked with an icon, whether or not you have ever launched there — it is
+the one directory where a session reaches every GUI tool, so it is never a click you can
+lose. It has no remove button for the same reason. It is named for its role rather than its
+folder, because the folder name (`~/mulmoclaude` by default, or wherever `CLAUDE_CWD`
+points) says the least interesting true thing about it; the real path is on its hover.
 
 **The launcher is shorter in the workspace**, because two of its choices do not apply
 there. The per-directory **Canvas switches** are replaced by a line saying every GUI tool
-is already available — a session there is handed the whole GUI MCP at spawn, so switches
-would write a registration that `--strict-mcp-config` then ignores. And the **worktree**
+is already available — a session there is handed the whole GUI MCP at spawn, so a switch
+would register a group URL that then has nothing left to serve. And the **worktree**
 section is hidden: a worktree isolates work on one codebase onto a branch, while the
 workspace is what a session works *from* (the shared wiki, collections and accounting
 live there), which is precisely what a detached branch would cut it off from. Both come
@@ -970,6 +976,14 @@ and refused, where before it could be confirmed away — which detached whoever
 `mulmoterminal` process on this machine: the server answers from its own PTY table plus
 tmux, not from what one page can see.
 
+**Change the directory and those lists empty immediately**, replaced by a single
+`Loading this directory's sessions, worktrees and scripts…` row until the new ones arrive.
+Everything the launch form offers below the field — **OR RESUME HERE**, the worktrees and
+**OR RUN A SCRIPT** — belongs to the directory it was read for, and reading it costs a
+debounce plus a round trip. Rows left standing through that wait would be the previous
+directory's, listed under the new directory's name, and clicking one resumes exactly the
+session it offers.
+
 A worktree started **from an issue** gets an `issue/<N>-<slug>` branch instead. The number
 in the name is what later tells the app which issue the work belongs to: the ⧉ Open PR
 button puts `Fixes #<N>` in the PR body, and the branch chip, the issue work comment and
@@ -1108,11 +1122,11 @@ A chip is a command line the user wrote, so the injection is a **rewrite of thei
 deliberately narrow: only a bare `claude` or `codex` is recognised, and anything else — a wrapper
 script, `FOO=1 claude` — is passed through unchanged.
 
-A `claude` chip in the workspace is given `--strict-mcp-config`, same as the cell. That makes the
-generated config the only source — but it already contains your Settings `userMcpServers`, so
-**those still load and are still pre-approved**. What stops contributing is a project directory's
-per-folder `.mcp.json`, which in the workspace is the intent: that file is where the per-group URLs
-live, and the chip is being handed the all-tools URL instead.
+A `claude` chip in the workspace is handed the all-tools URL, same as the cell, and like the cell it
+**does not** isolate the session: your own MCP servers and claude.ai connectors load as usual. Where
+a directory also registered per-group URLs in its `.mcp.json`, those groups stand down for that
+session rather than serving a second copy of the same tools — the session already reaches all of
+them under `mt`.
 
 **The asymmetry is deliberate.** `mt` is ours to name: nothing on disk holds it, it is
 regenerated on every spawn, so it was shortened to stop paying 17 characters per tool name. The
@@ -1802,10 +1816,23 @@ and `fetch` are mocked so the tests run without a server.
 
 ## Who builds this
 
-MulmoTerminal is built by the **[Singularity Society](https://singularitysociety.org)** team,
-including **[Satoshi Nakajima](https://x.com/snakajima)** — software architect for **Windows 95**,
-**Windows 98** and **Internet Explorer 3.0 / 4.0** at Microsoft, later founder of UIEvolution /
-Xevo, and still building from Seattle.
+MulmoTerminal is built by **[receptron](https://github.com/receptron)** —
+**[Satoshi Nakajima](https://x.com/snakajima)** and **[Isamu Arimoto](https://github.com/isamu)**.
+
+Satoshi was the software architect for **Windows 95**, **Windows 98** and **Internet Explorer
+3.0 / 4.0** at Microsoft, later founded UIEvolution / Xevo, and still builds from Seattle.
+
+The two have shipped open source together since 2015, and the core of each venture has been
+public every time:
+
+| | |
+|---|---|
+| **[VideoShader](https://github.com/snakajima/videoshader)** (2015) | GPU video processing for iOS, built at Veemob |
+| **[Swipe](https://github.com/swipe-org/swipe)** (2015) | an animation runtime that made manga move on phones |
+| **[OwnPlate](https://github.com/Nakajima-Foundation/ownplate)** (2020) | takeout ordering for restaurants during COVID, run at the Singularity Society and launched with ITOCHU |
+| **[SlashGPT](https://github.com/receptron/SlashGPT)** (2023) · **[GraphAI](https://github.com/receptron/graphai)** (2024) · **[MulmoCast](https://github.com/receptron/mulmocast-cli)** (2025) | LLM agents, declarative dataflow, AI video |
+
+MulmoTerminal is the seventh.
 
 It exists because we run several coding agents every day and kept losing track of which one was
 waiting on us. Everything here was built for that, then kept because it worked. MIT licensed.

package/common/workComment.ts

@@ -1,9 +1,29 @@
-// 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.
+// The comment MulmoTerminal leaves on an issue: ONE per (issue, clone), edited as the work moves
+// (#979, #1369). Pure, and shared, because the comment is its own storage — the server renders the
+// body, reads it back on the next milestone, and appends to what it parsed. A mismatch between the
+// two halves would either lose the earlier milestones or post a second comment on every poll.
+import { GITHUB_REPO } from "./githubRepo.js";
 
-export type WorkCommentKind = "start" | "merged";
+// A milestone worth telling the issue about. NOT every state the cell passes through: CI is on the
+// pull request already, and it flaps, so it is deliberately absent.
+export type WorkCommentKind = "start" | "pr" | "merged";
+
+const WORK_COMMENT_KINDS: readonly WorkCommentKind[] = ["start", "pr", "merged"];
+
+export const isWorkCommentKind = (v: unknown): v is WorkCommentKind => WORK_COMMENT_KINDS.some((kind) => kind === v);
+
+/** One milestone. `pr` is the pull request the milestone is about, null when there is none. */
+export interface WorkEvent {
+  kind: WorkCommentKind;
+  /** `YYYY-MM-DD HH:MM UTC`, from the SERVER's clock — see formatWorkTime. */
+  at: string;
+  pr: number | null;
+}
+
+// Only the two kinds that were ever written as a marker: `start` identifies the comment (see
+// workAnchorMarker) and `merged` is the second comment older builds left, which is read back so an
+// issue upgraded mid-flight does not get told about the same merge twice.
+type WorkMarkerKind = "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
@@ -14,10 +34,15 @@ export type WorkCommentKind = "start" | "merged";
 // 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 {
+export function workCommentMarker(kind: WorkMarkerKind, dir: string): string {
   return `<!-- mulmoterminal:work:${kind} dir=${encodeURIComponent(dir)} -->`;
 }
 
+/** The marker that IDENTIFIES this clone's comment, so later milestones can find it and edit it.
+ *  Still spelled `:start` — that is what builds before #1369 wrote, and reusing it is what lets an
+ *  already-posted comment be adopted instead of duplicated. */
+export const workAnchorMarker = (dir: string): string => workCommentMarker("start", 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 {
@@ -27,18 +52,120 @@ export function workCommentDirLabel(cwd: string): string {
   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}`;
+// Minutes, UTC, spelled out. A reader of the issue is asking "is this claim still alive" — the
+// answer needs a date more than it needs seconds, and a fixed zone means two clones in two
+// timezones write comparable lines.
+export const formatWorkTime = (at: Date): string => `${at.toISOString().slice(0, 16).replace("T", " ")} UTC`;
+
+const TIME = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2} UTC$/;
+
+// Says who wrote it, in the rendered comment rather than only in the marker: this lands on other
+// people's issues, and a reader should not have to guess which tool is claiming their issue.
+const SIGNATURE = `<sub>posted by [MulmoTerminal](https://github.com/${GITHUB_REPO})</sub>`;
+
+// A directory name may legally contain newlines and control characters, and the name is written
+// into the headline as-is. The marker below is percent-encoded, but a newline here would put a
+// line of the user's choosing into the body — including one that reads back as a milestone.
+const displayDir = (dir: string): string =>
+  dir
+    .replace(/[\p{Cc}\p{Cf}]/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+
+// The widest number a milestone line can carry. Render and parse have to agree on it: a line this
+// side wrote and the parser could not read would vanish from the comment on the NEXT edit, taking
+// its milestone with it (Codex review). Ten digits is far more than any forge issues, and the
+// pattern below reads exactly that back.
+const MAX_LINE_PR = 9_999_999_999;
+
+const writablePr = (pr: number | null): pr is number => pr !== null && Number.isSafeInteger(pr) && pr > 0 && pr <= MAX_LINE_PR;
+
+// The wording of the two states, unchanged from the build that wrote one comment per state: an
+// issue that already carries "Working on this in `x`." must not read differently after an edit.
+function headline(dir: string, events: readonly WorkEvent[]): string {
+  const shown = displayDir(dir);
+  const merged = events.find((event) => event.kind === "merged");
+  if (!merged) return `Working on this in \`${shown}\`.`;
+  // The same bound as the line: the headline is not parsed, but naming a number the line beneath
+  // it had to drop would make the comment contradict itself.
+  const where = writablePr(merged.pr) ? `Merged in #${merged.pr}.` : "Merged.";
+  return `${where} Work done in \`${shown}\`.`;
+}
+
+// Null for an event that cannot be written as a line the parser would read back — a PR milestone
+// with no number says nothing anyway.
+function eventLine(event: WorkEvent): string | null {
+  if (event.kind === "start") return `- started — ${event.at}`;
+  if (event.kind === "pr") return writablePr(event.pr) ? `- PR #${event.pr} — ${event.at}` : null;
+  return writablePr(event.pr) ? `- merged in #${event.pr} — ${event.at}` : `- merged — ${event.at}`;
+}
+
+const isLine = (line: string | null): line is string => line !== null;
+
+/** The whole comment body for a clone's milestones so far. Rendered from scratch every time, so
+ *  the body is a function of the events and nothing else. */
+export function renderWorkComment(dir: string, events: readonly WorkEvent[]): string {
+  const lines = events.map(eventLine).filter(isLine);
+  return [headline(dir, events), "", ...lines, "", SIGNATURE, "", workAnchorMarker(dir)].join("\n");
+}
+
+// MAX_LINE_PR, spelled as digits — the parse half of the same bound. It stops a run of digits out
+// of an edited body from reaching the parser as something that would print as `1e+20`, and it
+// keeps `\d*` from sitting inside an optional group, which `security/detect-unsafe-regex` reads as
+// a backtracking risk (measured as linear here, but a bound is a better answer than an exception).
+const PR_DIGITS = "[1-9]\\d{0,9}";
+const START_LINE = /^- started — (.+)$/;
+const PR_LINE = new RegExp(`^- PR #(${PR_DIGITS}) — (.+)$`);
+const MERGED_LINE = new RegExp(`^- merged(?: in #(${PR_DIGITS}))? — (.+)$`);
+
+// Strict about the timestamp on purpose. The body is editable by anyone reading the issue, and
+// whatever this returns is written straight back into the next edit — so a line that is not
+// exactly what render wrote is dropped rather than echoed.
+const timed = (kind: WorkCommentKind, pr: number | null, at: string | undefined): WorkEvent | null =>
+  at !== undefined && TIME.test(at) ? { kind, at, pr } : null;
+
+// `Number` is exact for anything the patterns above admit, so there is no second check here: a
+// line whose number is longer than that does not match at all, and is dropped like every other
+// line that is not exactly what render wrote.
+const prNumber = (digits: string | undefined): number | null => (digits === undefined ? null : Number(digits));
+
+function parseEventLine(line: string): WorkEvent | null {
+  const started = START_LINE.exec(line);
+  if (started) return timed("start", null, started[1]);
+  const pr = PR_LINE.exec(line);
+  if (pr) return timed("pr", prNumber(pr[1]), pr[2]);
+  const merged = MERGED_LINE.exec(line);
+  // A merge with no number is a line render writes and reads back, so null is an answer here
+  // rather than a failure.
+  return merged ? timed("merged", prNumber(merged[1]), merged[2]) : null;
+}
+
+/** The milestones a comment body records, in the order it lists them. Empty for a comment written
+ *  before #1369 — those carry the marker and the headline but no lines, and the caller supplies
+ *  the start from the comment's own creation time. */
+export const parseWorkEvents = (body: string): WorkEvent[] =>
+  body
+    .split("\n")
+    // trimEnd, not trim: a body round-tripped through the forge can come back CRLF, and `\r` at the
+    // end of the timestamp would fail the strict check above.
+    .map((line) => parseEventLine(line.trimEnd()))
+    .filter((event): event is WorkEvent => event !== null);
+
+/** `events` with `event` added, or null when the comment already records it — which is the normal
+ *  answer, because the caller asks on every poll of every open tab. */
+export function withWorkEvent(events: readonly WorkEvent[], event: WorkEvent): WorkEvent[] | null {
+  // A PR milestone is its number, and a number the line cannot carry is not a milestone this
+  // comment can record — refused here rather than added and then silently dropped by render.
+  if (event.kind === "pr" && !writablePr(event.pr)) return null;
+  // Matched on the PR number too: a second pull request for the same issue from the same clone —
+  // the first one closed unmerged, say — is a new milestone, not a repeat of the old one.
+  if (events.some((known) => known.kind === event.kind && known.pr === event.pr)) return null;
+  return [...events, event];
 }
 
 // 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 {
+export function alreadyCommented(bodies: readonly string[], kind: WorkMarkerKind, dir: string): boolean {
   const marker = workCommentMarker(kind, dir);
   return bodies.some((body) => typeof body === "string" && body.includes(marker));
 }

package/common/workCommentFailure.ts

@@ -0,0 +1,16 @@
+// Why MulmoTerminal could not write its work comment (#1369). Shared, because the server decides
+// it from `gh`'s exit and the UI turns it into a sentence — a second copy of the list on the client
+// would drift into wording a server can never send.
+//
+// Not commenting stays a normal outcome: the work carries on either way. What this adds is the
+// REASON, which used to exist nowhere — a read-only `gh` login made the feature do nothing at all,
+// with the same silence as having it switched off.
+
+/** `permission` is the one this exists for: logged in, but not allowed to write on that repo. */
+export type WorkCommentFailure = "cli-missing" | "auth" | "permission" | "unknown";
+
+const FAILURES: readonly WorkCommentFailure[] = ["cli-missing", "auth", "permission", "unknown"];
+
+// The value arrives over the wire, so a build skew (an older server naming a cause this one has
+// never heard of) has to read as "no cause" rather than reach the UI's wording switch.
+export const isWorkCommentFailure = (v: unknown): v is WorkCommentFailure => FAILURES.some((failure) => failure === v);

package/dist/assets/{abnfDiagram-VRR7QNED-RjiYivmv-Bdog-CiH.js → abnfDiagram-VRR7QNED-RjiYivmv-C43gBAG2.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-D6oVwac4.js";import"./chunk-WYO6CB5R-BlzOfotS-DMj-dLn7.js";import"./chunk-VAUOI2AC-CS9QJ4yz-DDJgABqC.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-ePkETRCM.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-CTOK7EeF.js";import"./chunk-WYO6CB5R-BlzOfotS-B-BAzlIB.js";import"./chunk-VAUOI2AC-CS9QJ4yz-DhyLweXm.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-gTPiZssc.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-DRANrMDe.js

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