brane 0.3.2 → 0.3.3

package/CHANGELOG.md

@@ -6,6 +6,27 @@ page, which is also what triggers its publish (see
 [docs/releasing.md](docs/releasing.md)). This file is the summary that
 travels in the npm tarball.
 
+## 0.3.3 - 2026-10-14
+
+- A fresh `npm install brane` audits clean. The math syntax extension
+  is now vendored (`src/math-syntax.ts`) instead of depending on
+  `micromark-extension-math`, which pinned a second, older katex into
+  every install (GHSA-238p-pmpm-9mq7) and led `npm audit fix --force` to
+  propose brane@0.1.1 ([#608](https://github.com/benjamn/brane/pull/608)).
+- In the web app, "All narratives" opens the list in a new tab, and a
+  link opened in a new tab lands on the daemon it came from rather than
+  the browser's default one ([#607](https://github.com/benjamn/brane/pull/607)).
+- The 膜 glyph carries a caption — a quip or a tip about brane — that
+  changes on each tap and nothing else; the empty state's words move
+  above it, and it no longer says "No narratives yet" when they are all
+  archived ([#606](https://github.com/benjamn/brane/pull/606)).
+- The README, which is also the npm page, opens with a new
+  introduction: what brane is for, the LIVE loop, and terminal
+  mirroring ([#610](https://github.com/benjamn/brane/pull/610)).
+
+Published while the repository is private, so like 0.3.0–0.3.2 it
+carries no npm provenance attestation.
+
 ## 0.3.2 - 2026-10-13
 
 - Archive is offered only once a narrative has ended, and the daemon

package/README.md

@@ -1,6 +1,12 @@
 # brane
 
-A TypeScript CLI and userspace daemon for managing narrative agent sessions.
+Brane provides a [web-based remote management interface](https://brane.organelle.dev/) for running long-lived Terminal UI (TUI) applications on any remote machine, securely and directly, without a central server, supporting not only full shells like `zsh` and `fish` and utilities like `lazygit` or `htop`, but also most of the popular _agentic_ TUI commands: `claude`, `codex`, `gemini`, `crush`, `copilot`, `goose`, and so on.
+
+The "intelligent" TUI applications demonstrate their intelligence by using brane's local MCP tools: `whoami`, `narrate`, `listen` and the rest, to implement a protocol for ongoing, purposeful conversation (the "LIVE loop") recorded automatically to a permanent, fully agent-searchable record that remains completely private to the host machine.
+
+Unlike a lot of other remote-coding tools, which let you chat with your agents and accept/deny permissions prompts, brane also _mirrors the terminal of the running agent_, so you can effortlessly observe your agents working from any mobile device, with the full power of a software keyboard and touch inputs for interacting with the terminal from afar, whenever you need that level of control.
+
+## Etymology and economics
 
 "Brane" is short for **membrane**, evoking a [_eukaryotic_](https://en.wikipedia.org/wiki/Eukaryote) metaphor for agent management, inherited from [organelle](https://github.com/benjamn/organelle): the daemon is the nucleus (which has a membrane), agents are organelles (which in turn have their own membranes), and narrative event logs trace everything each organelle has encountered and done (biologically implausible, but very useful).
 
@@ -12,24 +18,6 @@ If you find brane useful, perhaps because your tastes align with mine and I have
 
 [![Sponsor](https://img.shields.io/badge/Sponsor-%E2%9D%A4-ea4aaa?logo=githubsponsors)](https://github.com/sponsors/benjamn)
 
-## What it does
-
-Brane runs long-lived coding agents (Claude Code, Codex, Gemini, Goose and
-others, or any command) in tmux on your own machine, keeps everything they
-say and hear in one SQLite database, and lets you read, steer and search
-them from a phone or any browser on your tailnet.
-
-Four ideas cover most of it:
-
-- **Fold**: a directory you've registered as a place agents may be spawned.
-- **Narrative**: one agent session's append-only log of everything it said
-  and everything said to it. Every message has a stable address
-  (`claude-4c7289d1:42`) you can link to from anywhere.
-- **The LIVE loop**: the protocol agents follow to talk to you through an
-  MCP server brane injects into each session: listen, interpret, vocalize,
-  execute.
-- **Meld**: a QR code that signs a phone or browser into your daemon.
-
 ## Quick start
 
 0. **Install [Tailscale](https://tailscale.com/download)** and join your

package/dist/export.js

@@ -4,7 +4,7 @@ import { micromark } from "micromark";
 import { gfmTable, gfmTableHtml } from "micromark-extension-gfm-table";
 import { gfmAutolinkLiteral, gfmAutolinkLiteralHtml } from "micromark-extension-gfm-autolink-literal";
 import { gfmTaskListItem, gfmTaskListItemHtml } from "micromark-extension-gfm-task-list-item";
-import { math } from "micromark-extension-math";
+import { math } from "./math-syntax.js";
 import { NID_PATTERN, NID_REF_PATTERN } from "./shared/markdown-nids.js";
 import { isInlinePayload, INLINE_PAYLOAD_MIME } from "./shared/payload-inline.js";
 import { readEvents, readEventsBySeqs } from "./db/events.js";

package/dist/markdown-diagnostics.js

@@ -32,7 +32,7 @@ import { micromark } from "micromark";
 import { gfmTable, gfmTableHtml } from "micromark-extension-gfm-table";
 import { gfmAutolinkLiteral, gfmAutolinkLiteralHtml } from "micromark-extension-gfm-autolink-literal";
 import { gfmTaskListItem, gfmTaskListItemHtml } from "micromark-extension-gfm-task-list-item";
-import { math } from "micromark-extension-math";
+import { math } from "./math-syntax.js";
 import { mathHtmlExtension } from "./math.js";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { inspectDiagram } from "./diagram/index.js";

package/dist/math-syntax.js

@@ -0,0 +1,354 @@
+/** micromark syntax extension for math: `$…$` (text) and `$$` fences (flow).
+ *
+ *  Vendored from `micromark-extension-math` 3.1.0 (`dev/lib/syntax.js`,
+ *  `math-flow.js`, `math-text.js`), the syntax half only, so the published
+ *  package no longer depends on it. That package's index also loads its
+ *  `mathHtml()`, which imports `katex` at the range it pins (`^0.16.0`). Our
+ *  root `overrides` dedupe that onto our own katex in this checkout, but npm
+ *  ignores a dependency's `overrides`, so every `npm install brane` got a
+ *  second, older katex: loaded, never called (`src/math.ts` is our `mathHtml`),
+ *  and flagged by `npm audit` (GHSA-238p-pmpm-9mq7). The tokenizers are
+ *  unchanged apart from TypeScript annotations and dropping the `devlop`
+ *  assertions, which upstream's production build drops too. The web app still
+ *  imports the package itself: it ships prebuilt, under `expo/`'s overrides.
+ *
+ *  Upstream: https://github.com/micromark/micromark-extension-math
+ *
+ *  (The MIT License)
+ *
+ *  Copyright (c) 2020 Titus Wormer <tituswormer@gmail.com>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  'Software'), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ *  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ *  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ *  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { factorySpace } from "micromark-factory-space";
+import { markdownLineEnding } from "micromark-util-character";
+import { codes, constants, types } from "micromark-util-symbol";
+/** Create an extension for `micromark` to enable math syntax. */
+export function math(options) {
+    return {
+        flow: { [codes.dollarSign]: mathFlow },
+        text: { [codes.dollarSign]: mathText(options) },
+    };
+}
+// --- math (flow) ------------------------------------------------------------
+const mathFlow = {
+    tokenize: tokenizeMathFenced,
+    concrete: true,
+    name: "mathFlow",
+};
+const nonLazyContinuation = {
+    tokenize: tokenizeNonLazyContinuation,
+    partial: true,
+};
+function tokenizeMathFenced(effects, ok, nok) {
+    const self = this;
+    const tail = self.events[self.events.length - 1];
+    const initialSize = tail && tail[1].type === types.linePrefix
+        ? tail[2].sliceSerialize(tail[1], true).length
+        : 0;
+    let sizeOpen = 0;
+    return start;
+    /** Start of math: `$$`, at the first `$`. */
+    function start(code) {
+        effects.enter("mathFlow");
+        effects.enter("mathFlowFence");
+        effects.enter("mathFlowFenceSequence");
+        return sequenceOpen(code);
+    }
+    /** In opening fence sequence. */
+    function sequenceOpen(code) {
+        if (code === codes.dollarSign) {
+            effects.consume(code);
+            sizeOpen++;
+            return sequenceOpen;
+        }
+        if (sizeOpen < 2) {
+            return nok(code);
+        }
+        effects.exit("mathFlowFenceSequence");
+        return factorySpace(effects, metaBefore, types.whitespace)(code);
+    }
+    /** In opening fence, before meta: `$$asciimath`, at `a`. */
+    function metaBefore(code) {
+        if (code === codes.eof || markdownLineEnding(code)) {
+            return metaAfter(code);
+        }
+        effects.enter("mathFlowFenceMeta");
+        effects.enter(types.chunkString, { contentType: constants.contentTypeString });
+        return meta(code);
+    }
+    /** In meta. */
+    function meta(code) {
+        if (code === codes.eof || markdownLineEnding(code)) {
+            effects.exit(types.chunkString);
+            effects.exit("mathFlowFenceMeta");
+            return metaAfter(code);
+        }
+        if (code === codes.dollarSign) {
+            return nok(code);
+        }
+        effects.consume(code);
+        return meta;
+    }
+    /** After meta. */
+    function metaAfter(code) {
+        // Guaranteed to be eol/eof.
+        effects.exit("mathFlowFence");
+        if (self.interrupt) {
+            return ok(code);
+        }
+        return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+    }
+    /** After eol/eof in math, at a non-lazy closing fence or content. */
+    function beforeNonLazyContinuation(code) {
+        return effects.attempt({ tokenize: tokenizeClosingFence, partial: true }, after, contentStart)(code);
+    }
+    /** Before math content, definitely not before a closing fence. */
+    function contentStart(code) {
+        return (initialSize
+            ? factorySpace(effects, beforeContentChunk, types.linePrefix, initialSize + 1)
+            : beforeContentChunk)(code);
+    }
+    /** Before math content, after optional prefix. */
+    function beforeContentChunk(code) {
+        if (code === codes.eof) {
+            return after(code);
+        }
+        if (markdownLineEnding(code)) {
+            return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+        }
+        effects.enter("mathFlowValue");
+        return contentChunk(code);
+    }
+    /** In math content. */
+    function contentChunk(code) {
+        if (code === codes.eof || markdownLineEnding(code)) {
+            effects.exit("mathFlowValue");
+            return beforeContentChunk(code);
+        }
+        effects.consume(code);
+        return contentChunk;
+    }
+    /** After math (ha!). */
+    function after(code) {
+        effects.exit("mathFlow");
+        return ok(code);
+    }
+    function tokenizeClosingFence(effects, ok, nok) {
+        let size = 0;
+        // Before closing fence, at optional whitespace.
+        return factorySpace(effects, beforeSequenceClose, types.linePrefix, self.parser.constructs.disable.null.includes("codeIndented")
+            ? undefined
+            : constants.tabSize);
+        /** In closing fence, after optional whitespace, at sequence. */
+        function beforeSequenceClose(code) {
+            effects.enter("mathFlowFence");
+            effects.enter("mathFlowFenceSequence");
+            return sequenceClose(code);
+        }
+        /** In closing fence sequence. */
+        function sequenceClose(code) {
+            if (code === codes.dollarSign) {
+                size++;
+                effects.consume(code);
+                return sequenceClose;
+            }
+            if (size < sizeOpen) {
+                return nok(code);
+            }
+            effects.exit("mathFlowFenceSequence");
+            return factorySpace(effects, afterSequenceClose, types.whitespace)(code);
+        }
+        /** After closing fence sequence, after optional whitespace. */
+        function afterSequenceClose(code) {
+            if (code === codes.eof || markdownLineEnding(code)) {
+                effects.exit("mathFlowFence");
+                return ok(code);
+            }
+            return nok(code);
+        }
+    }
+}
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+    const self = this;
+    return start;
+    function start(code) {
+        if (code === null) {
+            return ok(code);
+        }
+        effects.enter(types.lineEnding);
+        effects.consume(code);
+        effects.exit(types.lineEnding);
+        return lineStart;
+    }
+    function lineStart(code) {
+        return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+    }
+}
+// --- math (text) ------------------------------------------------------------
+// To do (upstream): next major: clean spaces in HTML compiler.
+// This has to be coordinated together with `mdast-util-math`.
+function mathText(options) {
+    const options_ = options || {};
+    let single = options_.singleDollarTextMath;
+    if (single === null || single === undefined) {
+        single = true;
+    }
+    return {
+        tokenize: tokenizeMathText,
+        resolve: resolveMathText,
+        previous,
+        name: "mathText",
+    };
+    function tokenizeMathText(effects, ok, nok) {
+        let sizeOpen = 0;
+        let size;
+        let token;
+        return start;
+        /** Start of math (text): `$a$` at the first `$`, or `\$a$` at the second. */
+        function start(code) {
+            effects.enter("mathText");
+            effects.enter("mathTextSequence");
+            return sequenceOpen(code);
+        }
+        /** In opening sequence. */
+        function sequenceOpen(code) {
+            if (code === codes.dollarSign) {
+                effects.consume(code);
+                sizeOpen++;
+                return sequenceOpen;
+            }
+            // Not enough markers in the sequence.
+            if (sizeOpen < 2 && !single) {
+                return nok(code);
+            }
+            effects.exit("mathTextSequence");
+            return between(code);
+        }
+        /** Between something and something else. */
+        function between(code) {
+            if (code === codes.eof) {
+                return nok(code);
+            }
+            if (code === codes.dollarSign) {
+                token = effects.enter("mathTextSequence");
+                size = 0;
+                return sequenceClose(code);
+            }
+            // Tabs don’t work, and virtual spaces don’t make sense.
+            if (code === codes.space) {
+                effects.enter("space");
+                effects.consume(code);
+                effects.exit("space");
+                return between;
+            }
+            if (markdownLineEnding(code)) {
+                effects.enter(types.lineEnding);
+                effects.consume(code);
+                effects.exit(types.lineEnding);
+                return between;
+            }
+            // Data.
+            effects.enter("mathTextData");
+            return data(code);
+        }
+        /** In data. */
+        function data(code) {
+            if (code === codes.eof ||
+                code === codes.space ||
+                code === codes.dollarSign ||
+                markdownLineEnding(code)) {
+                effects.exit("mathTextData");
+                return between(code);
+            }
+            effects.consume(code);
+            return data;
+        }
+        /** In closing sequence. */
+        function sequenceClose(code) {
+            // More.
+            if (code === codes.dollarSign) {
+                effects.consume(code);
+                size++;
+                return sequenceClose;
+            }
+            // Done!
+            if (size === sizeOpen) {
+                effects.exit("mathTextSequence");
+                effects.exit("mathText");
+                return ok(code);
+            }
+            // More or less accents: mark as data.
+            token.type = "mathTextData";
+            return data(code);
+        }
+    }
+}
+const resolveMathText = function (events) {
+    let tailExitIndex = events.length - 4;
+    let headEnterIndex = 3;
+    let index;
+    let enter;
+    // If we start and end with an EOL or a space.
+    if ((events[headEnterIndex][1].type === types.lineEnding ||
+        events[headEnterIndex][1].type === "space") &&
+        (events[tailExitIndex][1].type === types.lineEnding ||
+            events[tailExitIndex][1].type === "space")) {
+        index = headEnterIndex;
+        // And we have data.
+        while (++index < tailExitIndex) {
+            if (events[index][1].type === "mathTextData") {
+                // Then we have padding.
+                events[tailExitIndex][1].type = "mathTextPadding";
+                events[headEnterIndex][1].type = "mathTextPadding";
+                headEnterIndex += 2;
+                tailExitIndex -= 2;
+                break;
+            }
+        }
+    }
+    // Merge adjacent spaces and data.
+    index = headEnterIndex - 1;
+    tailExitIndex++;
+    while (++index <= tailExitIndex) {
+        if (enter === undefined) {
+            if (index !== tailExitIndex && events[index][1].type !== types.lineEnding) {
+                enter = index;
+            }
+        }
+        else if (index === tailExitIndex || events[index][1].type === types.lineEnding) {
+            events[enter][1].type = "mathTextData";
+            if (index !== enter + 2) {
+                events[enter][1].end = events[index - 1][1].end;
+                events.splice(enter + 2, index - enter - 2);
+                tailExitIndex -= index - enter - 2;
+                index = enter + 2;
+            }
+            enter = undefined;
+        }
+    }
+    return events;
+};
+const previous = function (code) {
+    // If there is a previous code, there will always be a tail.
+    return (code !== codes.dollarSign ||
+        this.events[this.events.length - 1][1].type === types.characterEscape);
+};
+//# sourceMappingURL=math-syntax.js.map

package/dist/shared/membrane-quips.js

@@ -0,0 +1,77 @@
+/**
+ * What the 膜 says, in the caption under it.
+ *
+ * `expo/components/MembraneEmpty.web.tsx` shows one of these under the glyph
+ * whenever the glyph is shown — under an empty list and under a full one —
+ * and a tap on the glyph swaps it for another. Nothing else changes it, so
+ * it can be read at leisure, links and all. Each line is markdown, rendered
+ * by the app's own renderer. Two kinds, mixed and worn alike: a quip is a
+ * joke at the glyph's own expense (it is, after all, a fragment shader
+ * running full-time under an empty list), and a tip is the loading-screen
+ * filler of a video game — one true thing about brane the operator may not
+ * have found yet. Every tip states something the app or CLI actually does;
+ * a tip that stops being true should be removed rather than left to
+ * mislead. Brevity is the operator's rule: aim
+ * for one sentence, with no terminal period (claude-nusb6rnr:7).
+ *
+ * The order is one shuffle per page load, then a fixed loop through it
+ * (`QuipLoop`): every line once before any line twice, and the same order
+ * every time round. Randomness is passed in so a test can pin it.
+ */
+export const MEMBRANE_QUIPS = [
+    // ── quips ──────────────────────────────────────────────────────────────
+    "I noticed you were not using your GPU",
+    "I am the opposite of load-bearing",
+    "膜 is pronounced mó",
+    "My Kolmogorov complexity is actually quite low",
+    "Covert side-channel? Takes one to know one",
+    "Abstract impressionism? Here's my abstract impression of _you_",
+    "Drag me around a little",
+    "Do you know where your children are running shader programs?",
+    "No human art was digested in the making of whatever this is",
+    "Too many taps and the paradigm could shift",
+    "Bet you wish your phosphenes were lit like me",
+    "If this be a prisoner's cinema, then who be the prisoners?",
+    "Do not fall in love with any particular color scheme",
+    "All these colors will be lost in time, like tears in rain",
+    // ── tips ───────────────────────────────────────────────────────────────
+    "Agent stop working? Feed it something from the 🥫 menu",
+    "What was that terminal shortcut? Maybe it's in the 🦾 menu",
+    "Agents glow whenever they are awaiting chat input",
+    "@-mention any agent by NID (narrative ID) to summon them",
+    "Ask your agent about rendering mermaid diagrams",
+    "Go ahead and install [Tailscale](https://tailscale.com/) (it's free)",
+    "Command your own daemon: `npm install -g brane`",
+    "Wonder what this does? `brane absorb survey`",
+    "Have YOU read the /LIVE_loop protocol?",
+    "Your daemon from any device: `brane meld` and prosper 🖖",
+    "Fork tangential narratives with 🧬 Twin in the 🦠 menu",
+];
+/** A uniformly random permutation of `list` (Fisher–Yates); `list` is left alone. */
+export function shuffled(list, rand = Math.random) {
+    const out = [...list];
+    for (let i = out.length - 1; i > 0; i--) {
+        const j = Math.min(i, Math.floor(rand() * (i + 1)));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}
+/** One shuffle of the lines, walked in a loop: `current` is the line showing,
+ *  `next` steps to the one after it, back to the first after the last. */
+export class QuipLoop {
+    order;
+    at = 0;
+    constructor(list = MEMBRANE_QUIPS, rand = Math.random) {
+        if (list.length === 0)
+            throw new Error("no quips");
+        this.order = shuffled(list, rand);
+    }
+    current() {
+        return this.order[this.at];
+    }
+    next() {
+        this.at = (this.at + 1) % this.order.length;
+        return this.current();
+    }
+}
+//# sourceMappingURL=membrane-quips.js.map

package/dist/shared/mo-glyph.js

@@ -17,6 +17,10 @@
  */
 /** Side of the square the path is laid out in, in path units. */
 export const MO_GLYPH_BOX = 1000;
+/** The empty band between the ink and the box's top or bottom edge, in path
+ *  units: the glyph is centered, so it is the same above and below. Whatever
+ *  sits under the glyph is that much farther from the ink than from the box. */
+export const MO_GLYPH_MARGIN = 92.79;
 /** SVG path data for 膜, y down, inside `[0, MO_GLYPH_BOX]²`. */
 export const MO_GLYPH_PATH = "M493.98 449.69L493.98 425.61L791.54 425.61L791.54 449.69L493.98 449.69ZM493.98 557.19L493.98 533.11" +
     "L791.54 533.11L791.54 557.19L493.98 557.19ZM431.20 606.21L431.20 319.83L431.20 275.11L431.20 275.11" +

package/dist/shared/view-url.js

@@ -91,10 +91,72 @@ export function parseLineSpec(s) {
     const end = m[2] ? Number(m[2]) : undefined;
     return end !== undefined && end >= line ? { line, lineEnd: end } : { line };
 }
+/** Which melded daemon a same-origin link means, named by its home `brane_id`
+ *  (the registry's dedup key, and no secret), in the link's **fragment**:
+ *  `#daemon=brane-f66d2b`.
+ *
+ *  A tab's active daemon lives in its own `sessionStorage`, and a link opened in
+ *  a new tab (⌘-click, middle-click, `target="_blank"`) starts with none: it
+ *  falls back to this browser's *default* daemon, which on a shared app with
+ *  several melded need not be the one the link was written from. So in-app
+ *  hrefs carry this param, and an arriving tab whose slot is still empty
+ *  adopts it as its active daemon before anything connects (`expo/lib/api.ts`,
+ *  `adoptDaemonByBraneId`). A tab that already has one ignores it, which is
+ *  what keeps a reload from undoing a later switch. Plain clicks navigate
+ *  within the tab and never put it in the URL.
+ *
+ *  It says which daemon, not what you are looking at, so it rides where the
+ *  connection does (`connectionFragment`): a fragment reaches no server, and
+ *  the shared host's edge, a daemon's request log and a link unfurler never
+ *  see it. It is not `brane`, because a daemon hosts several branes and the
+ *  list already filters by one; this names the daemon. A brane_id this browser
+ *  has not melded is ignored, and the default applies as before. */
+export const DAEMON_PARAM = "daemon";
 /** The params that describe *which daemon*, as opposed to what you are looking
  *  at. They are origin-scoped: meaningful to the page that received them, never
- *  to be carried onward. */
-export const CONNECTION_PARAMS = ["host", "token"];
+ *  to be carried onward. `daemon` is one of them: cleaned on arrival like the
+ *  token, and dropped by Isolate and Meld, whose token already says. */
+export const CONNECTION_PARAMS = ["host", "token", DAEMON_PARAM];
+/** An in-app href (path, optional query, optional fragment) with `daemon` set
+ *  to `braneId` in its fragment, replacing any already there and leaving the
+ *  query, which is the view, untouched. Without a `braneId` the href comes
+ *  back unchanged, so a caller that does not know its daemon yet still gets a
+ *  working link. */
+export function withDaemonFragment(href, braneId) {
+    if (!braneId)
+        return href;
+    const hashAt = href.indexOf("#");
+    const beforeHash = hashAt === -1 ? href : href.slice(0, hashAt);
+    const params = new URLSearchParams(hashAt === -1 ? "" : href.slice(hashAt + 1));
+    params.set(DAEMON_PARAM, braneId);
+    return `${beforeHash}#${params.toString()}`;
+}
+/** The `daemon` param from a location hash (with or without its `#`), or null
+ *  when absent or empty. */
+export function daemonFromHash(hash) {
+    return new URLSearchParams(hash.startsWith("#") ? hash.slice(1) : hash).get(DAEMON_PARAM) || null;
+}
+/** The brane_id an in-app link should name: the tab's active entry's, falling
+ *  back to the first entry when `activeId` is missing or stale, which is what
+ *  the root layout connects to in that case. Null with nothing melded. */
+export function activeDaemonBraneId(daemons, activeId) {
+    return (daemons.find((d) => d.id === activeId) ?? daemons[0])?.brane_id ?? null;
+}
+/** Which registry entry a page arriving with `#daemon=<braneId>` should make
+ *  this tab's active one, or null to leave things as they are.
+ *
+ *  Only an **empty** slot is filled (`tabActiveId` is the tab's own
+ *  sessionStorage value, not the cross-tab default it falls back to). A new
+ *  tab has none; a reloaded, restored or duplicated tab has one and keeps it.
+ *  That matters because the router puts the initial fragment back on its
+ *  first URL write, so `#daemon=` can outlive a daemon switched later in the
+ *  same tab, and a reload must not switch it back. A brane_id this browser
+ *  has not melded is no instruction at all. */
+export function daemonToAdopt(daemons, tabActiveId, braneId) {
+    if (tabActiveId !== null)
+        return null;
+    return daemons.find((d) => d.brane_id === braneId)?.id ?? null;
+}
 /** A search string with the connection params removed and everything else left
  *  alone, ready to hand to `history.replaceState`.
  *

package/dist/test/markdown-math.test.js

@@ -1,7 +1,7 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { micromark } from "micromark";
-import { math } from "micromark-extension-math";
+import { math } from "../math-syntax.js";
 import { MATH_BLOCK_CSS, prepareMathMarkdown, isMathContent, renderMathHtml } from "../shared/markdown-math.js";
 import { mathHtmlExtension, katexStyleFor } from "../math.js";
 import { readFileSync } from "node:fs";