mulmoterminal 4.1.1 → 4.3.0

package/README.md

@@ -8,6 +8,10 @@ coding with a single agent needs nothing but a shell — this is for when you ru
 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.
 
+**Every cell is a real pty.** `htop`, `lazygit`, a dev server and Claude Code are the same kind
+of object here — which is why the one-session-per-worktree limit applies to **agents only**, and
+a shell or a `yarn dev` launcher can sit in the same worktree an agent is working in.
+
 ### 📖 Documentation — **[receptron.github.io/mulmoterminal](https://receptron.github.io/mulmoterminal/)**
 
 - **User guide:** [English](https://receptron.github.io/mulmoterminal/guide/en/) — the grid
@@ -39,7 +43,7 @@ npx mulmoterminal@latest        # starts on http://localhost:34567 and opens you
 
 ![MulmoTerminal's grid view — four live Claude sessions running side by side, each in its own color-coded project](https://raw.githubusercontent.com/receptron/mulmoterminal/main/docs/guide/images/grid-2x2-live.png)
 
-*The grid is a **cockpit for parallel agents** — here, four live Claude sessions, each in its own color-coded project. Every cell's header carries what you need to triage at a glance: **model · context %**, **token counts** (`⇡in ⇣out`), the **git branch / changes** chip, and an AI summary of what the agent is doing. A cell's **border color signals state** — working / done (blue), needs-you (amber — e.g. waiting on a permission), idle — with an attention chime so a stuck cell off-screen still pulls you back. Supervise many; only step in where you're called.*
+*The grid is a **cockpit for parallel agents** — here, four live Claude sessions, each in its own color-coded project. Every cell's header carries what you need to triage at a glance: **model · context %**, **token counts** (`⇡in ⇣out`), the **git branch / changes** chip, and an AI summary of what the agent is doing. A cell's **border color signals state** — working (blue), done (green), needs-you (amber — e.g. waiting on a permission), idle — with an attention chime so a stuck cell off-screen still pulls you back. Supervise many; only step in where you're called.*
 
 ## Why you'll want it
 
@@ -214,7 +218,7 @@ Needs **Node ≥ 22.9**, plus these CLIs on your `PATH`:
 | **Required** | [`claude`](https://claude.com/claude-code) | every Claude session — this app is a cockpit for it | `npm i -g @anthropic-ai/claude-code`, then run `claude` once to log in |
 | **Required** | `git` | [worktree isolation](#git-worktrees--pull-requests), each cell's branch / unsaved-dot / diff readout, the PR footer | `brew install git` · `sudo apt install git` · `sudo dnf install git` · Windows: [git-scm.com](https://git-scm.com/download/win) |
 | **Required** | `gh` | the cross-repo **PRs & Issues** view and one-click PR creation — it uses your `gh` login, so no token is stored | [cli.github.com](https://cli.github.com), then `gh auth login` |
-| Optional | `glab` | the same for **gitlab.com** projects (#981). Same arrangement: the CLI holds the credentials, this app stores no token | `brew install glab`, then `glab auth login` |
+| Optional | `glab` | the same for **GitLab** projects (#981) — gitlab.com, and a self-hosted instance you declare in `gitlabHosts` (#1332). Same arrangement: the CLI holds the credentials, this app stores no token | `brew install glab`, then `glab auth login` (self-hosted: `glab auth login --hostname gitlab.example.com`) |
 | Recommended | `tmux` | [session persistence](#session-persistence-tmux) — terminals survive a server restart | `brew install tmux` · `sudo apt install tmux` · `sudo dnf install tmux` · no native Windows build (falls back to plain PTYs) |
 | Optional | `codex` | [Codex sessions](#agents-claude--codex) in a cell, alongside Claude | `npm i -g @openai/codex` |
 | Optional | `ffmpeg` | video rendering from the [mulmo-script panel](#wiki-collections--the-gui-panel) (its plugin ships enabled) | `brew install ffmpeg` · `sudo apt install ffmpeg` · `sudo dnf install ffmpeg` |
@@ -386,9 +390,10 @@ today — **Claude Code** (the default), **Codex**, and **Antigravity** (`agy`).
 
 - **Claude** — spawned as `claude` (override with `CLAUDE_BIN`). The server passes
   `--session-id <uuid>`, so it knows the live session's id even before its transcript
-  file exists, and injects activity hooks + the GUI MCP per spawn (see
+  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.
 - **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
@@ -543,10 +548,11 @@ The Settings modal (⚙) persists per-user UI choices to `~/.mulmoterminal/confi
 | `soundKinds` | Which moments beep — see [Notification sounds](#notification-sounds). Defaults to `["finished","waiting"]`; the other kinds are opt-in. |
 | `sounds`     | Per-kind sound: `{ "waiting": "preset:coin" }`. A `preset:<id>` reference or an absolute path; a kind with no entry falls back to `soundFile`. |
 | `prRepos`    | `owner/repo` entries whose open PRs/issues the cross-repo **PRs & Issues** view aggregates, using whichever CLI the host needs — your own `gh` or `glab` login, so no token is stored here. An entry may name its host — `gitlab.com/group/project` is read with `glab`, and work can be started on it, commented on and turned into a merge request. A host that is neither shows a row saying so. |
+| `gitlabHosts` | Hosts that run a **self-hosted GitLab**, e.g. `["gitlab.example.com"]`. Nothing in a URL says which forge a host runs, so declaring it is what lets `prRepos` entries on that host be read with `glab` — everything gitlab.com can do, it can do. Needs `glab auth login --hostname <host>`. config.json only (no Settings control), so a hand edit takes effect on the next server start. |
 | `repoDirs`   | `{ "owner/repo": "/abs/path" }` — which local clone work on a repo starts in, when you keep several side by side. Only the *choice* is stored; which clones exist is re-derived from `cwdPresets` on every read, and an entry that no longer names a clone of that repo is ignored. |
 | `launchers`  | `{ label, command }` entries offered in a grid cell's launcher besides the agents — any interactive command. A plain shell needs no entry: the launch form's **Shell** toggle opens `$SHELL` unconfigured. |
 | `quickCommands` | `{ label, text, agents? }` phrases the **phone** offers as chips on a session's terminal view. Tapping one puts `text` in the input box; it is not sent until you press send. `agents` (`"claude"` / `"codex"` / `"shell"`) scopes a chip to session kinds — omit it to offer the chip everywhere. Empty by default. |
-| `userMcpServers` | `{ id, url }` HTTP MCP servers merged into the `--mcp-config` of the Claude sessions that carry the full GUI MCP — a cell whose working directory is the **workspace**, and any session the server starts itself (the phone, a scheduled task). A cell in a project directory loads its own MCP config instead. Takes effect on the next session. |
+| `userMcpServers` | `{ id, url }` HTTP MCP servers merged into the `--mcp-config` of the Claude sessions that carry the full GUI MCP — a cell whose working directory is the **workspace**, and a session the server starts itself (the phone, a scheduled task) unless it asks for a grid cell's shape, as an issue's seed session does (`issueSpawnOptions`). A cell in a project directory loads its own MCP config instead. Takes effect on the next session. |
 | `buttons`    | Header action buttons — see [Header buttons](#header-buttons). Omit to keep the defaults; set to replace them. |
 | `chips`      | Header info chips (`dir` / `git` / `work` / `diff` / `ctx` / `usage` / `status` / `tools`, or custom text). Omit to keep the default set; `[]` hides all built-ins. `work` shows which PR / issue the cell is on (`#977 → #966`) and clears itself when the PR merges — see the [Configuration guide](https://receptron.github.io/mulmoterminal/guide/en/config.html#work-chip). |
 | `pushEnabled` | `true` to send a **Web Push** to your registered devices. Off by default; only sends while the **RemoteHost** channel is connected (see below). The master switch — `pushKinds` picks which moments. |
@@ -706,7 +712,7 @@ malformed file is ignored.
 | `theme`      | xterm palette for terminals in this directory (one of the built-in theme ids). |
 | `colors`     | Per-key xterm palette overrides applied on top of `theme` (or the app theme when `theme` is unset). Keys are xterm `ITheme` names (`background`, `foreground`, `cursor`, `selectionBackground`, the 16 ANSI colors, …); values are hex (`#rgb` / `#rrggbb` / `#rrggbbaa`). Unknown keys / bad values are dropped. |
 | `fontSize`   | Terminal font size in px for this directory (8–32), overriding the Settings value. A size outside the range is clamped; a non-number is ignored. Changing it re-fits the terminal, so the PTY learns the new width — unlike browser zoom, which leaves the two disagreeing. |
-| `orderPriority` | This directory's rank in the grid's **priority** ordering — the third mode on the toolbar's ordering button, next to auto (attention-first) and manual (the move buttons). Any integer, **lowest first**; negatives are allowed. Directories that set nothing sort last, keeping their existing order, so adding the key to one project doesn't shuffle the rest. The grid reads it in **priority** mode only; the launcher's directory chips always sort by it, so a project sits in the same place on both. |
+| `orderPriority` | This directory's rank in the grid's **priority** ordering — the third mode on the toolbar's ordering button, next to auto (attention-first) and manual (the move buttons). Any integer, **lowest first**; negatives are allowed. Directories that set nothing sort last, keeping their existing order, so adding the key to one project doesn't shuffle the rest. The grid reads it in **priority** mode only; the launcher's directory chips sort by it, so a project sits in the same place on both. The one exception is the **workspace** chip, which always leads the launcher's row regardless of any rank — it is not one of the directories being ranked against each other, and it is the one place every GUI tool is reachable (see [MCP server ids](#mcp-server-ids-why-a-workspace-cell-and-a-project-cell-disagree)). |
 | `fontFamily` | CSS font-family stack for this directory's terminals, overriding the global `fontFamily`. Use the names as your OS lists them (`"'Cica', 'MS Gothic', monospace"`). An unusable stack is ignored whole rather than half-applied; `monospace` is appended if you name no generic family. Prefer fonts whose fullwidth glyphs are exactly twice the Latin width, or box-drawing frames tear. |
 | `sound`      | Attention sound for this directory's sessions, a path **relative to the directory** (served at `GET /api/dir-sound`). The fallback for every kind. |
 | `sounds`     | Per-kind override of `sound`: `{ "command-failed": "preset:gong" }`. Each value is a `preset:<id>` or a directory-relative path, under the same confinement. |
@@ -740,22 +746,21 @@ yarn dev                # backend (:34567) + Vite UI (:6856), concurrently — o
 yarn dev:server         # backend only  (node --import tsx --env-file-if-exists=.env server/index.ts)
 yarn dev:client         # Vite dev server only
 
-yarn build              # type-check (vue-tsc) + vite build -> dist/
-yarn typecheck:server   # type-check the server (tsconfig.server.json)
-yarn typecheck:test     # type-check the specs (tsconfig.test*.json)
+yarn typecheck          # type-check everything (vue-tsc -b)
+yarn build              # type-check + vite build -> dist/
 yarn server             # run backend; serves dist/ + the APIs on :34567
 yarn test               # vitest run
 ```
 
-The backend is TypeScript run directly via `tsx` (no build step); `server/` is
-type-checked separately through `tsconfig.server.json` (`strict`), kept out of
-the main `build` so the two type-check independently.
-
-Specs sit outside both of those projects, and vitest strips types rather than
-checking them — so `yarn typecheck:test` is what keeps them honest. It mirrors
-the same split: `tsconfig.test.json` (client specs, DOM + `.vue`) and
-`tsconfig.test-server.json` (server specs, node). CI runs it alongside the
-other two.
+`yarn typecheck` covers the whole repo. The root `tsconfig.json` is a solution
+file that references all five projects, so one `vue-tsc -b` builds them:
+`tsconfig.app.json` (client), `tsconfig.node.json` (vite config),
+`tsconfig.server.json` (backend, run directly via `tsx` with no build step),
+plus `tsconfig.test.json` and `tsconfig.test-server.json` for the specs — which
+need checking of their own because vitest strips types rather than checking
+them. They exist as separate projects because each has its own compiler options
+(the client ones DOM + `.vue`, the server ones node, the specs with
+`noUncheckedIndexedAccess` off).
 
 In dev, open the Vite URL; its proxy forwards `/ws`, `/ws/pubsub`, and `/api` to
 `:34567`. In production, run `yarn build` then `yarn server` and open
@@ -766,7 +771,22 @@ In dev, open the Vite URL; its proxy forwards `/ws`, `/ws/pubsub`, and `/api` to
 ## Scripts (Run menu)
 
 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). It also offers a
+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 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**
+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
+back the moment you point the field at a project directory.
+
+It also offers a
 **run a script** row
 that launches project scripts (a dev server, tests, a build, …) **in that cell, in
 the directory the cell is pointed at** — so a whole workflow lives in one window
@@ -920,6 +940,17 @@ separate working tree that shares the repo's `.git`, so several agents can work
 repo without colliding. Worktrees live under `~/.mulmoterminal/worktrees/` (override with
 `MULMOTERMINAL_HOME`), and existing ones are listed below the field.
 
+**A worktree inherits the project's settings.** `.mulmoterminal.json` is normally gitignored,
+so a fresh worktree used to have none — no colours, no name, no model, no grid rank. It is now
+given its own copy derived from the project's: `name` / `theme` / `colors` / `fontSize` /
+`fontFamily` / `provider` / `model` as written, the seven chrome colours **rotated 12 degrees
+further around the hue wheel per worktree** (so a project's trees read as a gradient; a grey like
+`#ffffff` has no hue to move and stays put), and `orderPriority` at the project's rank **+ 1**, so
+the worktree sorts directly after it. `sound` / `sounds` / `addDirs` are not carried — they name
+paths inside the project directory. Written only where git would **ignore** it: an untracked file
+in a worktree's `git status` would make it count as dirty, and a dirty worktree is one
+MulmoTerminal refuses to remove. An existing config in the worktree is never overwritten.
+
 **One worktree, one session.** A worktree is tied to a branch, so it is never started
 twice: a listed row **resumes** that worktree's session when it has one, and **starts** one
 only when it has none. A row whose session is open in another terminal reads `in use` and
@@ -968,7 +999,7 @@ Closing a worktree cell asks whether to **keep** the worktree or **discard & rem
 
 **PRs & Issues (cross-repo).** The toolbar's **Pull requests** button opens a full-screen
 view that aggregates open PRs **and** issues across the repos listed in Settings →
-**Pull request repos** (`prRepos`, `owner/repo` entries, or `gitlab.com/group/project`) via your server-side `gh` / `glab` login.
+**Pull request repos** (`prRepos`, `owner/repo` entries, or `gitlab.com/group/project` — plus any host declared in `gitlabHosts`) via your server-side `gh` / `glab` login.
 PRs show a CI-rollup / review-decision / draft badge; each repo lists its latest open
 issues. Rows are real links, per-repo errors don't sink the view, and the two lists load
 independently. Backed by `GET /api/prs` and `GET /api/issues`.
@@ -1035,11 +1066,61 @@ GUI-protocol tools the agent calls — documents (`presentDocument`), forms (`pr
 generated images, charts, HTML, and collection cards. Each result is drawn by its plugin's
 own Vue view inside a Shadow-DOM `PluginFrame` (so a plugin's bundled CSS can't leak),
 mirrors the active session, and replays history on re-select. Plugins reach the agent over
-an **in-process MCP server** served per session at `POST /api/mcp/:sessionId` (server name
-`mulmoterminal-gui`). Which plugins load is gated by `plugins/plugins.json`; the shipped
-set includes markdown, form, image generation (needs `GEMINI_API_KEY`), chart, HTML,
-collection, and mulmoscript (MulmoCast video/slides/PDF playback) views. You can also merge
-your **own HTTP MCP servers** into a workspace session via Settings → `userMcpServers`.
+an **in-process MCP server** served per session at `POST /api/mcp/:sessionId`. Which plugins
+load is gated by `plugins/plugins.json`; the shipped set includes markdown, form, image
+generation (needs `GEMINI_API_KEY`), chart, HTML, collection, and mulmoscript (MulmoCast
+video/slides/PDF playback) views. You can also merge your **own HTTP MCP servers** into a
+workspace session via Settings → `userMcpServers`.
+
+### MCP server ids: why a workspace cell and a project cell disagree
+
+A tool is never called by its own name. Every MCP client prefixes it with the id of the server
+it came from — `mcp__<id>__presentChart` in Claude Code, `mcp-<id>-presentChart` in Codex (which
+also rewrites `-` in the id to `_`). So the id you register under is repeated on every tool, in
+every listing, for the life of the session.
+
+MulmoTerminal delivers the GUI MCP by **two different routes**, and they do not share an id:
+
+| | Workspace cell / single view | Project-directory grid cell |
+|---|---|---|
+| How it arrives | generated per spawn into `--mcp-config` (Claude) or `-c mcp_servers.<id>.url=` (Codex) | the user's OWN per-folder config — `.mcp.json`, `claude mcp add -s local` |
+| Server id | **`mt`** | **`mulmoterminal-render`**, `-data`, `-media`, `-external` — one per tool group |
+| Tools carried | all of them, on one URL | only the groups that directory registered |
+| Tool name looks like | `mcp__mt__presentChart` | `mcp__mulmoterminal-render__presentChart` |
+
+Which route a session takes is decided by `carriesFullGuiMcp()` in
+`server/session/mcp-config.ts` — the single view, a cell-less chat, or anything whose cwd **is**
+the workspace take the first; anything in a project directory takes the second.
+
+**The workspace is agent-agnostic, and so is the way you start a terminal there.** All three
+agents and the launcher chips ask the same predicate, so two terminals in the workspace reach
+the same tools no matter how they were started:
+
+| Started as | In the workspace | In a project directory |
+|---|---|---|
+| claude cell (including `?gui=0`) | `mt`, every tool | the directory's registered groups |
+| codex cell | `mt`, every tool | the directory's registered groups |
+| launcher chip running `claude` | `mt`, every tool — flags inserted into the command line | nothing injected; its own `.mcp.json` loads |
+| launcher chip running `codex` | `mt`, every tool — `-c` overrides inserted | the directory's registered groups |
+| launcher chip running anything else | untouched | untouched |
+
+A chip is a command line the user wrote, so the injection is a **rewrite of their text** and is
+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.
+
+**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
+group ids are the opposite — they are keys in config files **users wrote**, they are what the
+launcher's per-group switch reads back, and they are documented in the setup guide. Renaming
+them breaks working setups silently, and would need a migration that rewrites existing
+per-folder configs. Both live in [`common/toolGroups.ts`](common/toolGroups.ts), where the
+constants carry the same warning.
 
 **Wiki.** The toolbar **Wiki** button opens a read-only browser over `<workspace>/data/wiki/`
 — an **index** (tag-filterable page catalog), rendered **pages** with `[[wiki links]]` and
@@ -1309,7 +1390,7 @@ same-origin-guarded.
 | `POST /api/git-remote` | The dir's GitHub repo URL (for the header GitHub menu). |
 | `GET /api/worktrees?cwd=` · `GET /api/worktrees/diff?cwd=` | List managed worktrees / diff one vs its base. |
 | `POST /api/worktrees/create` · `/remove` · `/push` · `/pr` | Create on `agent/<slug>` — or, with `issue: <N>`, on `issue/<N>-<slug>` forked from a freshly fetched `origin/<base>`; remove (managed root only), push, open a PR (`gh`, else compare URL). |
-| `GET /api/prs` · `GET /api/issues` | Open PRs / issues across the configured `prRepos` — `gh` for github.com entries, `glab` for `gitlab.com/...` ones. |
+| `GET /api/prs` · `GET /api/issues` | Open PRs / issues across the configured `prRepos` — `gh` for github.com entries, `glab` for gitlab.com and any host declared in `gitlabHosts`. |
 | `GET /api/repo-dirs` | Which saved directories clone which GitHub repo, ordered, with the recorded choice per repo. |
 | `POST /api/issues/start` | Cut an issue's worktree in one of that repo's known clones and spawn a session there, seeded with the issue as a draft. |
 | `GET /api/github/star` · `POST /api/github/star` | Whether you have starred MulmoTerminal, and star it (via `gh`). `starred: null` means `gh` could not answer, and hides the button. |
@@ -1719,6 +1800,19 @@ 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.
+
+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.
+
+- **Updates** are announced in Japanese on X: [@SingularitySoci](https://x.com/SingularitySoci)
+- **Sister project:** [MulmoClaude](https://github.com/receptron/mulmoclaude)
+
 ## Contributing
 
 **Please open an issue rather than a pull request.** Bug reports and feature requests are very

package/common/byCodeUnit.ts

@@ -0,0 +1,11 @@
+// Sort filenames and directory names deterministically.
+//
+// `.sort()` with no comparator is flagged (sonarjs/no-alphabetical-sort) because the default is
+// implementation-defined for non-ASCII. The rule suggests `localeCompare`, which would be WRONG
+// here: these are filenames — zero-padded date directories and ISO-stamped rollout files — and
+// ordering them by the user's locale makes the answer depend on who is running the app. Code-unit
+// order is what the callers actually mean, and it is the same everywhere.
+export function byCodeUnit(a: string, b: string): number {
+  if (a < b) return -1;
+  return a > b ? 1 : 0;
+}

package/common/codeBlocks.ts

@@ -59,8 +59,12 @@ export function fencedBlocks(markdown: string): FencedBlock[] {
   const lines = markdown.split("\n");
   const blocks: FencedBlock[] = [];
   let i = 0;
+  // Each line is read into a const before use: with noUncheckedIndexedAccess, `lines[i]` is
+  // `string | undefined` even inside `i < lines.length`, and the loop condition is what actually
+  // rules the undefined out.
   while (i < lines.length) {
-    const open = fenceOf(lines[i]);
+    const line = lines[i];
+    const open = line === undefined ? null : fenceOf(line);
     if (!open) {
       i++;
       continue;
@@ -69,12 +73,12 @@ export function fencedBlocks(markdown: string): FencedBlock[] {
     const info = open.info.trim();
     const body: string[] = [];
     i++;
-    while (i < lines.length && !closes(lines[i], fence)) {
-      body.push(lines[i]);
+    for (let next = lines[i]; next !== undefined && !closes(next, fence); next = lines[i]) {
+      body.push(next);
       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") });
+    blocks.push({ lang: info ? (info.split(/\s+/)[0]?.toLowerCase() ?? null) : null, body: body.join("\n") });
   }
   return blocks;
 }
@@ -84,5 +88,5 @@ export function fencedBlocks(markdown: string): FencedBlock[] {
  *  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;
+  return withBody[withBody.length - 1] ?? null;
 }

package/common/gitlabHosts.ts

@@ -0,0 +1,60 @@
+// Which hosts are a GitLab this app can talk to (#1332). `gitlab.com` is known from its name; a
+// self-hosted instance at `gitlab.hogefuga.com` is indistinguishable from any other host, so the
+// user DECLARES it in `gitlabHosts` — the config mechanism #981 said this would need.
+//
+// In `common/` because both sides decide from it: the server picks a CLI from it, and the browser
+// says why a control is off. Two copies would drift, and disagreeing is the failure the forge
+// abstraction exists to undo.
+import { GITHUB_HOST, GITLAB_HOST } from "./repoEntry.js";
+
+// A hostname, lower case, with at least one dot. The dot is not cosmetic: `parseRepoEntry` reads a
+// leading segment as a host ONLY when it contains one, so a dotless declaration could never match
+// an entry and would sit in the config doing nothing.
+const HOSTNAME_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/;
+
+const SCHEME_RE = /^https?:\/\//;
+
+const GITLAB_HOSTS_MAX = 20;
+
+/** One declared host, or null when the string does not name one.
+ *
+ *  A pasted `https://gitlab.example.com/` is accepted and reduced to its hostname: this value is
+ *  hand-typed into config.json with no UI to validate it, and the browser's address bar is where
+ *  the user is copying from. Anything else with a slash is rejected rather than truncated — a
+ *  project path here is a different mistake, and silently keeping its host would hide it.
+ */
+export function normalizeGitlabHost(input: unknown): string | null {
+  if (typeof input !== "string") return null;
+  const host = input.trim().toLowerCase().replace(SCHEME_RE, "").replace(/\/$/, "");
+  return HOSTNAME_RE.test(host) ? host : null;
+}
+
+/** The declared hosts, de-duplicated and capped. Anything unusable is dropped rather than failing
+ *  the whole config — one typo must not cost the user the hosts they spelled correctly. */
+export function sanitizeGitlabHosts(input: unknown): string[] {
+  if (!Array.isArray(input)) return [];
+  const hosts = new Set<string>();
+  for (const value of input) {
+    const host = normalizeGitlabHost(value);
+    if (host) hosts.add(host);
+    if (hosts.size >= GITLAB_HOSTS_MAX) break;
+  }
+  return [...hosts];
+}
+
+/** Whether `host` is a GitLab: gitlab.com, or one the user declared.
+ *
+ *  `github.com` is refused whatever the config says. A declaration is a hand-typed line with no UI
+ *  behind it, and the one that would do real damage — every GitHub repo suddenly addressed with
+ *  `glab` — is also the easiest to write by accident.
+ */
+export const isGitlabHost = (host: string, declared: readonly string[]): boolean => host === GITLAB_HOST || (host !== GITHUB_HOST && declared.includes(host));
+
+/** Why a host is not handled, and what to do about it.
+ *
+ *  ONE sentence, shared by the PRs/Issues row and the start-work refusal: #1332 was filed by a user
+ *  who read "is not supported yet" and could not tell whether their setup was wrong, whether the
+ *  feature was coming, or what to try — so the reason has to carry the fix.
+ */
+export const unknownForgeReason = (host: string): string =>
+  `${host} is not supported yet — MulmoTerminal reads github.com and gitlab.com; if ${host} is a self-hosted GitLab, add it to "gitlabHosts" in ~/.mulmoterminal/config.json and restart`;

package/common/isRecord.ts

@@ -11,3 +11,9 @@ import { isObject } from "graphai";
 // graphai's own `isPlainObject` is exactly this (it also rejects Map/Date/class instances), but
 // it is not exported from the package root, so the array check stays here.
 export const isRecord = (value: unknown): value is Record<string, unknown> => isObject(value) && !Array.isArray(value);
+
+// "Absent, or of this type" — what an OPTIONAL field on a wire shape has to satisfy. A guard that
+// skips these asserts a type it has not seen: absent is meaningful (an older server never said the
+// field), but a present one of the wrong type is a lie the rest of the code then reads.
+export const optionalString = (value: unknown): boolean => value === undefined || typeof value === "string";
+export const optionalBoolean = (value: unknown): boolean => value === undefined || typeof value === "boolean";

package/common/isUnknownArray.ts

@@ -0,0 +1,8 @@
+// The array counterpart to isRecord, and it exists for a reason that is easy to miss:
+// `Array.isArray(value)` on an `unknown` narrows it to **`any[]`**, not `unknown[]`. So the
+// obvious `Array.isArray(x) ? x : []` hands back an array whose elements are outside the type
+// checker entirely, and every read off them type-checks against anything.
+//
+// Declaring the guard's result as `unknown[]` keeps the elements unverified-but-visible, which is
+// what the callers want: they check each element before using it.
+export const isUnknownArray = (value: unknown): value is unknown[] => Array.isArray(value);

package/common/issueStartPlan.ts

@@ -8,15 +8,17 @@
 // docs/remote-host-protocol.md), so it refuses `choose` where the desktop opens it.
 import type { RepoDirs } from "./repoDirs";
 import { GITHUB_HOST, GITLAB_HOST, parseRepoEntry } from "./repoEntry";
+import { isGitlabHost, unknownForgeReason } from "./gitlabHosts";
 
 // Where work can be STARTED — the issue is read and a worktree cut. A host that is merely listable
-// still refuses, and says which host it is rather than blaming a missing clone (#981).
-const STARTABLE_HOSTS: ReadonlySet<string> = new Set([GITHUB_HOST, GITLAB_HOST]);
+// still refuses, and says which host it is rather than blaming a missing clone (#981). A host the
+// user declared as self-hosted GitLab starts work like gitlab.com does (#1332).
+const isStartableHost = (host: string, gitlabHosts: readonly string[]): boolean => host === GITHUB_HOST || isGitlabHost(host, gitlabHosts);
 
-/** The hosts named in a refusal, read off the set rather than written out beside it — a hardcoded
- *  "github.com only" survived GitLab becoming startable and told users the opposite of the truth
- *  (Codex review). Exported so the phone's refusal says the same thing. */
-export const startableHosts = (): string => [...STARTABLE_HOSTS].join(" and ");
+/** The hosts named in a refusal, built from the same rule rather than written out beside it — a
+ *  hardcoded "github.com only" survived GitLab becoming startable and told users the opposite of
+ *  the truth (Codex review). Exported so the phone's refusal says the same thing. */
+export const startableHosts = (gitlabHosts: readonly string[]): string => [...new Set([GITHUB_HOST, GITLAB_HOST, ...gitlabHosts])].join(" and ");
 
 export type IssueStartPlan =
   /** No clone of this repo on this machine, so there is nowhere for the work to happen. */
@@ -35,24 +37,29 @@ export type BlockedIssueStartPlan = Exclude<IssueStartPlan, { kind: "ready" }>;
 
 // `repo` is REQUIRED, not optional, even though only one branch reads it: a caller that omitted it
 // would get `no-clone` for a GitLab repo, which is the exact wrong answer this parameter was added
-// to fix. Making the compiler ask for it is what stops that coming back.
-export function issueStartPlan(entry: RepoDirs | undefined, repo: string): IssueStartPlan {
+// to fix. Making the compiler ask for it is what stops that coming back. `gitlabHosts` is required
+// for the same reason — defaulted to empty, a caller that forgot it would refuse the user's own
+// self-hosted GitLab and blame the host (#1332).
+export function issueStartPlan(entry: RepoDirs | undefined, repo: string, gitlabHosts: readonly string[]): IssueStartPlan {
   // Checked before the clone list, because a GitLab repo has no entry there and would otherwise
   // read as "no clone" — a reason that is not true and points at the wrong fix.
   const parsed = parseRepoEntry(repo);
-  if (parsed && !STARTABLE_HOSTS.has(parsed.host)) return { kind: "unsupported-forge", host: parsed.host };
+  if (parsed && !isStartableHost(parsed.host, gitlabHosts)) return { kind: "unsupported-forge", host: parsed.host };
   const dirs = entry?.dirs ?? [];
   if (dirs.length === 0) return { kind: "no-clone" };
   // A recording wins even when the repo has one clone: it is still the same answer, and treating
   // the two cases the same keeps "recorded" from being a state the UI has to distinguish.
   const recorded = entry?.primary;
   if (recorded) return { kind: "ready", dir: recorded };
-  if (dirs.length === 1) return { kind: "ready", dir: dirs[0].path };
+  const only = dirs.length === 1 ? dirs[0] : undefined;
+  if (only) return { kind: "ready", dir: only.path };
   return { kind: "choose", dirs };
 }
 
 /** Why the control is disabled, for the row's title text. Null when it is not disabled. */
 export function issueStartBlockedReason(plan: IssueStartPlan, repo: string): string | null {
-  if (plan.kind === "unsupported-forge") return `Starting work supports ${startableHosts()} — ${plan.host} issues are listed here, not started from`;
+  // The same sentence the row's own error carries: the host is not one this app knows, and the fix
+  // is a config line rather than anything about this issue or this clone (#1332).
+  if (plan.kind === "unsupported-forge") return unknownForgeReason(plan.host);
   return plan.kind === "no-clone" ? `No local clone of ${repo} — add one to your directory presets to start work here` : null;
 }

package/common/keymap.ts

@@ -87,6 +87,7 @@ export function parseKeyBinding(input: string): KeyBinding | null {
   const parts = input.split("+").map((part) => part.trim());
   if (parts.length === 0 || parts.some((part) => part === "")) return null;
   const key = parts[parts.length - 1];
+  if (key === undefined) return null; // unreachable: parts.length was checked above
   const binding: KeyBinding = { key, shift: false, alt: false, ctrl: false, meta: false };
   for (const part of parts.slice(0, -1)) {
     const flag = MODIFIERS[part.toLowerCase()];
@@ -226,6 +227,7 @@ function duplicateWarnings(bound: Map<string, Claim[]>): KeymapProblem[] {
   return [...bound.values()].flatMap((claims) => {
     if (claims.length < 2) return [];
     const [winner, ...losers] = [...claims].sort((a, b) => a.rank - b.rank);
+    if (!winner) return []; // unreachable: claims.length >= 2 was checked above
     return losers.map(({ label, binding }) => ({
       action: label,
       binding,

package/common/median.ts

@@ -8,6 +8,11 @@ export const median = (values: number[]): number | null => {
   if (values.length === 0) return null;
   const sorted = [...values].sort((a, b) => a - b);
   const mid = Math.floor(sorted.length / 2);
-  if (sorted.length % 2 === 1) return sorted[mid];
-  return (sorted[mid - 1] + sorted[mid]) / 2;
+  // Read once each: `sorted[mid]` is `number | undefined` under noUncheckedIndexedAccess, and the
+  // length checks above are what actually rule that out.
+  const middle = sorted[mid];
+  if (middle === undefined) return null;
+  if (sorted.length % 2 === 1) return middle;
+  const below = sorted[mid - 1];
+  return below === undefined ? middle : (below + middle) / 2;
 };

package/common/prPhase.ts

@@ -83,7 +83,7 @@ function toIssueNumber(digits: string): number | null {
 // shown next to this cell's PR has to belong to the same repo to be clickable and true.
 export function issueRefFromPrBody(body: string | null | undefined): number | null {
   const found = typeof body === "string" ? CLOSING_KEYWORD.exec(body) : null;
-  return found ? toIssueNumber(found[1]) : null;
+  return found?.[1] === undefined ? null : toIssueNumber(found[1]);
 }
 
 // Whether the body ALREADY states what merging it closes, in either form GitHub honours. Broader
@@ -105,7 +105,7 @@ const BRANCH_ISSUE = /^[a-z][a-z-]*\/([1-9]\d*)-/;
 // somebody else's issue. Named for the doubt so a call site can't forget it.
 export function issueCandidateFromBranch(branch: string | null | undefined): number | null {
   const found = typeof branch === "string" ? BRANCH_ISSUE.exec(branch) : null;
-  return found ? toIssueNumber(found[1]) : null;
+  return found?.[1] === undefined ? null : toIssueNumber(found[1]);
 }
 
 // The prefix this app gives a branch it creates FOR an issue (#1171). Shared because the two
@@ -121,5 +121,5 @@ const ANCHORED_ISSUE = new RegExp(`^${ISSUE_BRANCH_PREFIX}([1-9]\\d*)-`);
 // else's issue the moment the PR merges, which no amount of confirming afterwards undoes.
 export function issueFromAnchoredBranch(branch: string | null | undefined): number | null {
   const found = typeof branch === "string" ? ANCHORED_ISSUE.exec(branch) : null;
-  return found ? toIssueNumber(found[1]) : null;
+  return found?.[1] === undefined ? null : toIssueNumber(found[1]);
 }

package/common/readString.ts

@@ -0,0 +1,28 @@
+// Reading a string out of untrusted JSON — a phone's command params, a transcript line, a `gh`
+// response — without `String()`.
+//
+// `String(value)` answers for ANY input, and that is the problem: an object becomes the literal
+// text "[object Object]" and an array becomes "1,2". Nothing throws, so the bad value travels —
+// as a collection slug that matches nothing, or as a session title on screen. The rule that
+// catches this is @typescript-eslint/no-base-to-string.
+//
+// Reading returns "" (or null) instead, which the callers already handle: they were written
+// against `String(x ?? "")`, so an absent field was always the empty string.
+
+/** The value when it is a string, else `""`. For a field the caller then validates or defaults. */
+export const readString = (value: unknown): string => (typeof value === "string" ? value : "");
+
+/**
+ * A value rendered for a HUMAN — an error message naming what was rejected.
+ *
+ * Here the input is bad by definition, so there is something to say about any of it; `String()` is
+ * wrong only because "[object Object]" tells the reader nothing. JSON keeps the shape visible.
+ */
+export const describeValue = (value: unknown): string => {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return "[unserializable]"; // a circular structure, which JSON.stringify throws on
+  }
+};

package/common/repoEntry.ts

@@ -30,8 +30,9 @@ export interface RepoEntry {
 export function parseRepoEntry(entry: string): RepoEntry | null {
   const segments = entry.trim().split("/");
   if (segments.some((segment) => segment === "")) return null;
-  const declared = segments.length > 1 && HOST_SEGMENT.test(segments[0]);
-  return declared ? { host: segments[0].toLowerCase(), path: segments.slice(1), declared } : { host: GITHUB_HOST, path: segments, declared };
+  const first = segments[0];
+  const host = segments.length > 1 && first !== undefined && HOST_SEGMENT.test(first) ? first : null;
+  return host === null ? { host: GITHUB_HOST, path: segments, declared: false } : { host: host.toLowerCase(), path: segments.slice(1), declared: true };
 }
 
 /** The identity a repository is known by ON ITS OWN HOST — `owner/repo` for GitHub, the group path

package/common/toolGroups.ts

@@ -96,8 +96,45 @@ export const toolsInGroup = (group: ToolGroup): string[] => [...GROUP_BY_TOOL].f
 // `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).
+//
+// DELIBERATELY long, and deliberately NOT the same id as GUI_SERVER_ID below. The two are
+// reached by different routes (see that constant), so the same tool is named
+// `mcp__mulmoterminal-render__presentChart` in a project cell and `mcp__mt__presentChart` in a
+// workspace one. That is not drift to be tidied up: shortening these would break every
+// `.mcp.json` and `claude mcp add -s local` entry users have already written against them,
+// which the launcher's per-group switch also reads back and the setup guide documents. It needs
+// a migration over existing per-folder configs, not a rename. README's "MCP server ids" section
+// is the long version.
 export const toolGroupServerId = (group: ToolGroup): string => `mulmoterminal-${group}`;
 
+// The MCP server id the SINGLE VIEW registers — every tool on one URL, rather than the per-group
+// ids above. Unlike those, a user never writes this one: it is generated per spawn into
+// `--mcp-config` (claude) or `-c mcp_servers.<id>.url=` (codex), so it is ours to name.
+//
+// Which of the two ids a session gets is decided by `carriesFullGuiMcp` in
+// server/session/spawn-claude.ts: the single view, a cell-less chat, and a cell whose cwd IS the
+// workspace carry this one; a cell in a project directory is handed no --mcp-config at all and
+// reaches the group ids through the user's own per-folder config. Both are live, on purpose.
+//
+// It is SHORT because the id is not what the agent sees — the client prefixes every tool with it.
+// claude turns `presentChart` into `mcp__<id>__presentChart` and codex into `mcp-<id>-presentChart`
+// (with `-` in the id normalised to `_`), so a long id is paid on every tool name in every listing.
+// `mulmoterminal-gui` cost 17 characters per tool to say what the surrounding config already says.
+//
+// It had been spelled out at four sites (this server's registration, the advertised server name,
+// the allowedTools prefix and the reserved-id list). It lives here now because both the server and
+// the UI-facing config validation decide from it — see the `common/` rule in CLAUDE.md.
+export const GUI_SERVER_ID = "mt";
+
+// Ids this project has shipped for the SAME single-view server before. Not live: kept so the place
+// that must recognise our own past output still does — the Antigravity config merge, which deletes
+// our entries by id and would otherwise leave a stale `mulmoterminal-gui` behind forever.
+//
+// Only where we WROTE them, though. A legacy id is not reserved against the user's own
+// `userMcpServers`: nothing writes it any more, so a server someone names `mulmoterminal-gui`
+// today is reachable and works, and treating it as ours would be claiming a name we abandoned.
+export const LEGACY_GUI_SERVER_IDS: readonly string[] = ["mulmoterminal-gui"];
+
 // 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.

package/dist/assets/{abnfDiagram-VRR7QNED-RjiYivmv-CuUAI5MR.js → abnfDiagram-VRR7QNED-RjiYivmv-Bdog-CiH.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-akMN_vOP.js";import"./chunk-WYO6CB5R-BlzOfotS-CeZxJxL0.js";import"./chunk-VAUOI2AC-CS9QJ4yz-BZe0Q9XX.js";import{n as i,r as a,t as o}from"./chunk-MOJQB5TN-CMZRaeqt-DcPt_trW.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-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};

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

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