@silverprotocol/richtext 0.3.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Loqu, Inc.
+
+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.

package/README.md

@@ -0,0 +1,68 @@
+# @silverprotocol/richtext
+
+The headless rich-text block model for AgJSON `text` content. Agents emit
+markdown in chat (`**bold**`, lists, headings); this package turns that text
+into a **typed AST** and owns the **safety policy** — once, for every host —
+while rendering stays entirely yours.
+
+- **Headless.** No components, no styling, no dependencies. You map the AST
+  onto your own renderers and design tokens (React, React Native, DOM,
+  terminal — anything).
+- **Safe by construction.** Raw HTML is never interpreted: no HTML node type
+  exists, so `<script>` in model output can only ever be literal text. Link
+  `href` is populated only for `http:` / `https:` / `mailto:` targets —
+  everything else (`javascript:`, `data:`, relative paths) parses as a link
+  with `href: undefined`.
+- **Streaming-tolerant.** Feed a growing buffer on every `text.delta` and
+  re-parse: mid-stream input with unclosed markers (`**bol`, a dangling code
+  fence, half a link) parses to a stable AST with `closed: false` on the open
+  construct. Completed constructs never change shape.
+
+## Install
+
+```sh
+npm install @silverprotocol/richtext
+```
+
+## Usage
+
+```ts
+import { parseRichText } from "@silverprotocol/richtext";
+
+const blocks = parseRichText("- **12:00–2:00 PM** — Finish the pitch deck");
+// [{ type: "list", ordered: false, items: [{ children: [
+//    { type: "strong", children: [{ type: "text", text: "12:00–2:00 PM" }], closed: true },
+//    { type: "text", text: " — Finish the pitch deck" },
+// ] }] }]
+```
+
+Walk the `RichTextBlock[]` and map each node to your renderer. The one
+rendering rule: every string in the AST (`text`, `code`) is **literal
+content** — render it as text content (React children / RN `<Text>` /
+`textContent`), never as markup.
+
+### The subset
+
+Blocks: paragraphs (single newlines become explicit `break` nodes — chat prose
+is line-broken), headings (`#`–`######`), fenced code (with language tag),
+flat ordered/unordered lists. Inline: `**strong**`, `*em*` / `_em_`,
+`` `code` ``, `[links](https://…)`, backslash escapes.
+
+Deliberately out of v1 (parses as plain text): images, tables, blockquotes,
+strikethrough, autolinked bare URLs, nested lists, raw HTML (permanently).
+
+### Streaming
+
+```ts
+parseRichText("**bol");
+// [{ type: "paragraph", children: [
+//    { type: "strong", children: [{ type: "text", text: "bol" }], closed: false },
+// ] }]
+```
+
+`closed: false` is the signal — style it optimistically or plainly, your call;
+when the closing marker arrives, the same node completes in place.
+
+Spec: [silverprotocol.io/AgJSON](https://silverprotocol.io/AgJSON) — proposed
+in [workspace#8]; the AST is protocol-adjacent (it defines what a `text`
+block's content means to a renderer), presentation is host business.

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+/**
+ * `@silverprotocol/richtext` — the headless rich-text block model for AgJSON
+ * `text` content (workspace#8).
+ *
+ * Agents emit markdown in chat text (`**bold**`, lists, headings); every host
+ * that renders an AgJSON stream needs the SAME answer to "what does this text
+ * MEAN to a renderer". This package owns exactly that seam and nothing more:
+ *
+ *  - `parseRichText(text)` → a typed block/inline AST for the CONVERSATIONAL
+ *    markdown subset: bold / italic / inline code / fenced code / lists /
+ *    headings / links (plus explicit line breaks — chat prose is line-broken
+ *    and a renderer that joins lines destroys it).
+ *  - The SAFETY POLICY lives here, once. Raw HTML is NEVER interpreted — no
+ *    HTML node type exists in the AST, so `<script>` in model output can only
+ *    ever be literal text. Link `href` is populated ONLY for http/https/mailto
+ *    targets; everything else (javascript:, data:, vbscript:, relative paths)
+ *    parses as a link whose `href` is `undefined` — hosts get the styled text
+ *    but nothing navigable. Rich HTML has its own channel (tool-result UI
+ *    resources); chat text is untrusted model output.
+ *  - STREAMING-TOLERANT by design: mid-stream input with unclosed markers
+ *    (`**bol`, a dangling fence, half a link) parses to a stable AST that
+ *    fails SOFT — the construct exists with `closed: false` and its partial
+ *    content, never a throw, never a reshuffle of earlier siblings. Feed a
+ *    growing buffer on every `text.delta` and re-parse: completed constructs
+ *    never change shape; only the trailing OPEN construct extends (or
+ *    disambiguates) as input arrives.
+ *
+ * NO components, NO styling, NO dependencies — hosts map the AST onto their
+ * own renderers and design systems. Rendering rule for hosts: every string in
+ * this AST (`text`, `code`) is literal content — render it as text content
+ * (React children / RN <Text> / textContent), NEVER as markup.
+ *
+ * Deliberately OUT of the v1 subset (parse as plain text; future spec-process
+ * additions, not silent behavior): images, tables, blockquotes, strikethrough,
+ * autolinked bare URLs, nested lists (indented bullets FLATTEN into the open
+ * list), block content inside list items, and `setext` headings.
+ */
+/** Inline content. `closed: false` marks a construct still open mid-stream. */
+export type RichTextInline = {
+    type: "text";
+    text: string;
+}
+/** Explicit line break — a single newline inside a paragraph/heading/item.
+ *  Chat prose is line-broken; hosts map this to <br/> / "\n", never a space. */
+ | {
+    type: "break";
+} | {
+    type: "strong";
+    children: RichTextInline[];
+    closed: boolean;
+} | {
+    type: "em";
+    children: RichTextInline[];
+    closed: boolean;
+} | {
+    type: "code";
+    code: string;
+    closed: boolean;
+} | {
+    type: "link";
+    children: RichTextInline[];
+    /**
+     * The navigable target — populated ONLY when the written target passed
+     * the scheme allowlist (http:, https:, mailto:). `undefined` means
+     * "style as a link if you like, but there is nothing safe to open".
+     */
+    href: string | undefined;
+    /**
+     * The target VERBATIM as written (lossless — may be a partial mid-stream
+     * fragment or a rejected scheme). NEVER navigate to this; it exists for
+     * audit/debug display only. `href` is the only navigable field.
+     */
+    rawHref: string;
+    closed: boolean;
+};
+export type RichTextListItem = {
+    children: RichTextInline[];
+};
+/** Block content. Order is the render order. */
+export type RichTextBlock = {
+    type: "paragraph";
+    children: RichTextInline[];
+} | {
+    type: "heading";
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: RichTextInline[];
+} | {
+    type: "code-fence";
+    code: string;
+    /** The info string's first word (```ts → "ts"), if any. */
+    lang: string | undefined;
+    closed: boolean;
+} | {
+    type: "list";
+    ordered: boolean;
+    /** First item's number for an ordered list (1. / 3. …), else undefined. */
+    start: number | undefined;
+    items: RichTextListItem[];
+};
+/**
+ * Parse a single run of inline content (no block structure). Useful when a
+ * host renders one-line strings (labels, list items it assembled itself).
+ */
+export declare function parseInlineRichText(text: string): RichTextInline[];
+/**
+ * Parse a chat text block into the rich-text AST. Pure and total: any string
+ * (including any prefix of a longer one) parses without throwing.
+ */
+export declare function parseRichText(text: string): RichTextBlock[];
+export default parseRichText;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAIH,+EAA+E;AAC/E,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAChC;gFACgF;GAC9E;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,cAAc,EAAE,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,cAAc,EAAE,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC/C;IACE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B;;;;OAIG;IACH,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEN,MAAM,MAAM,gBAAgB,GAAG;IAAE,QAAQ,EAAE,cAAc,EAAE,CAAA;CAAE,CAAC;AAE9D,gDAAgD;AAChD,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,cAAc,EAAE,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAAC,QAAQ,EAAE,cAAc,EAAE,CAAA;CAAE,GAC7E;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;CACjB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,2EAA2E;IAC3E,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,KAAK,EAAE,gBAAgB,EAAE,CAAC;CAC3B,CAAC;AA6QN;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,CAElE;AAaD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CA4F3D;AAED,eAAe,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,381 @@
+/**
+ * `@silverprotocol/richtext` — the headless rich-text block model for AgJSON
+ * `text` content (workspace#8).
+ *
+ * Agents emit markdown in chat text (`**bold**`, lists, headings); every host
+ * that renders an AgJSON stream needs the SAME answer to "what does this text
+ * MEAN to a renderer". This package owns exactly that seam and nothing more:
+ *
+ *  - `parseRichText(text)` → a typed block/inline AST for the CONVERSATIONAL
+ *    markdown subset: bold / italic / inline code / fenced code / lists /
+ *    headings / links (plus explicit line breaks — chat prose is line-broken
+ *    and a renderer that joins lines destroys it).
+ *  - The SAFETY POLICY lives here, once. Raw HTML is NEVER interpreted — no
+ *    HTML node type exists in the AST, so `<script>` in model output can only
+ *    ever be literal text. Link `href` is populated ONLY for http/https/mailto
+ *    targets; everything else (javascript:, data:, vbscript:, relative paths)
+ *    parses as a link whose `href` is `undefined` — hosts get the styled text
+ *    but nothing navigable. Rich HTML has its own channel (tool-result UI
+ *    resources); chat text is untrusted model output.
+ *  - STREAMING-TOLERANT by design: mid-stream input with unclosed markers
+ *    (`**bol`, a dangling fence, half a link) parses to a stable AST that
+ *    fails SOFT — the construct exists with `closed: false` and its partial
+ *    content, never a throw, never a reshuffle of earlier siblings. Feed a
+ *    growing buffer on every `text.delta` and re-parse: completed constructs
+ *    never change shape; only the trailing OPEN construct extends (or
+ *    disambiguates) as input arrives.
+ *
+ * NO components, NO styling, NO dependencies — hosts map the AST onto their
+ * own renderers and design systems. Rendering rule for hosts: every string in
+ * this AST (`text`, `code`) is literal content — render it as text content
+ * (React children / RN <Text> / textContent), NEVER as markup.
+ *
+ * Deliberately OUT of the v1 subset (parse as plain text; future spec-process
+ * additions, not silent behavior): images, tables, blockquotes, strikethrough,
+ * autolinked bare URLs, nested lists (indented bullets FLATTEN into the open
+ * list), block content inside list items, and `setext` headings.
+ */
+// ─── safety policy: link scheme allowlist ─────────────────────────────────────
+// http/https/mailto ONLY. Case-insensitive; whitespace and control characters
+// in the written target disqualify rather than get cleaned (a target that
+// needs cleaning is not a target the model wrote cleanly).
+const SAFE_HREF = /^(?:https?:\/\/|mailto:)[^\s\x00-\x1f]+$/i;
+/** The one place the navigable-target decision is made (workspace#8 policy). */
+function safeHref(raw) {
+    return SAFE_HREF.test(raw) ? raw : undefined;
+}
+/** Shift a closer-index set down one stack level (drop this frame's own slot). */
+function shiftIdxs(idxs) {
+    const out = new Set();
+    for (const i of idxs)
+        if (i > 0)
+            out.add(i - 1);
+    return out;
+}
+function isWs(ch) {
+    return ch === undefined || ch === " " || ch === "\t" || ch === "\n";
+}
+function isWordChar(ch) {
+    return ch !== undefined && /[A-Za-z0-9]/.test(ch);
+}
+// Flanking rules — the pragmatic subset of CommonMark's:
+//  *  opens when followed by non-space; closes when preceded by non-space.
+//  _  additionally must sit at a word BOUNDARY on its outer side, so
+//     snake_case_identifiers in prose never italicize (the reason CommonMark
+//     has the rule; agents emit identifiers constantly).
+function canOpen(marker, prev, next) {
+    if (isWs(next))
+        return false;
+    if (marker === "_" || marker === "__")
+        return !isWordChar(prev);
+    return true;
+}
+function canClose(marker, prev, next) {
+    if (isWs(prev))
+        return false;
+    if (marker === "_" || marker === "__")
+        return !isWordChar(next);
+    return true;
+}
+// Backslash escapes: exactly ASCII punctuation (CommonMark's set) — `\*` is a
+// literal asterisk; `\n` (the letter n) is just "\" + "n".
+const ESCAPABLE = new Set("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~");
+function parseInlineFrom(src, start, closers) {
+    const children = [];
+    let buf = "";
+    const flush = () => {
+        if (buf.length > 0) {
+            children.push({ type: "text", text: buf });
+            buf = "";
+        }
+    };
+    let pos = start;
+    while (pos < src.length) {
+        const ch = src[pos];
+        if (ch === undefined)
+            break;
+        // Backslash escape.
+        if (ch === "\\") {
+            const next = src[pos + 1];
+            if (next !== undefined && ESCAPABLE.has(next)) {
+                buf += next;
+                pos += 2;
+                continue;
+            }
+            buf += ch;
+            pos += 1;
+            continue;
+        }
+        // Explicit line break (paragraph lines are joined with "\n" upstream).
+        if (ch === "\n") {
+            flush();
+            children.push({ type: "break" });
+            pos += 1;
+            continue;
+        }
+        // Inline code span — verbatim until the closing backtick (newlines
+        // included: a span the stream hasn't closed yet swallows softly, and a
+        // genuine multi-line span renders fine under code styling). No nested
+        // markdown inside.
+        if (ch === "`") {
+            flush();
+            const end = src.indexOf("`", pos + 1);
+            if (end === -1) {
+                children.push({ type: "code", code: src.slice(pos + 1), closed: false });
+                pos = src.length;
+                continue;
+            }
+            children.push({ type: "code", code: src.slice(pos + 1, end), closed: true });
+            pos = end + 1;
+            continue;
+        }
+        // Emphasis delimiters. Closing is checked BEFORE opening so `**bold**`'s
+        // second ** seals rather than re-opens.
+        if (ch === "*" || ch === "_") {
+            const two = src.slice(pos, pos + 2);
+            const double = two === "**" || two === "__" ? two : undefined;
+            const single = ch;
+            const prev = pos > 0 ? src[pos - 1] : undefined;
+            // Measure the whole delimiter run, then walk the open frames OUTERMOST-
+            // first (link brackets bound the walk — emphasis never closes across a
+            // `[`), spending the run's characters on every closeable frame: a **
+            // run seals the strong (its inner em dangles soft — `**a *b** c`), a
+            // *** run seals the em AND the strong. The closure SET rides the unwind
+            // so every level marks its own `closed` flag accurately.
+            let runLen = 1;
+            while (src[pos + runLen] === ch)
+                runLen++;
+            const nextAfterRun = src[pos + runLen];
+            const bracket = closers.indexOf("]");
+            const bound = bracket === -1 ? closers.length - 1 : bracket - 1;
+            const closedIdxs = new Set();
+            let budget = runLen;
+            for (let ci = bound; ci >= 0; ci--) {
+                const m = closers[ci];
+                if (m === undefined || m[0] !== ch)
+                    continue;
+                if (m.length > budget)
+                    continue;
+                if (!canClose(m, prev, nextAfterRun))
+                    continue;
+                closedIdxs.add(ci);
+                budget -= m.length;
+                if (budget === 0)
+                    break;
+            }
+            if (closedIdxs.size > 0) {
+                flush();
+                return {
+                    children,
+                    closedBy: Math.max(...closedIdxs),
+                    closedIdxs,
+                    runConsumed: runLen - budget,
+                    pos,
+                };
+            }
+            // Opening reads the longest marker (** before *); a double that cannot
+            // open stays a literal double, never a half-open single.
+            const marker = double ?? single;
+            const next = src[pos + marker.length];
+            if (canOpen(marker, prev, next)) {
+                flush();
+                const inner = parseInlineFrom(src, pos + marker.length, [marker, ...closers]);
+                const node = marker === "**" || marker === "__"
+                    ? { type: "strong", children: inner.children, closed: inner.closedIdxs.has(0) }
+                    : { type: "em", children: inner.children, closed: inner.closedIdxs.has(0) };
+                children.push(node);
+                if (inner.closedBy === 0) {
+                    // This frame is the OUTERMOST one the run closed — consume the
+                    // run's whole closed span here.
+                    pos = inner.pos + inner.runConsumed;
+                    continue;
+                }
+                if (inner.closedBy === -1) {
+                    // End of input — everything is flushed; this frame ends open too.
+                    pos = inner.pos;
+                    continue;
+                }
+                // The run reached an OUTER frame: keep unwinding (shift the set past
+                // this frame's own stack slot).
+                return {
+                    children,
+                    closedBy: inner.closedBy - 1,
+                    closedIdxs: shiftIdxs(inner.closedIdxs),
+                    runConsumed: inner.runConsumed,
+                    pos: inner.pos,
+                };
+            }
+            buf += marker;
+            pos += marker.length;
+            continue;
+        }
+        // Link: [children](target). `[text]` followed by anything but "(" is the
+        // literal bracket text it always was; `[text]` at END of input stays an
+        // open link — the "(url)" may still be in flight (fail-soft, documented).
+        if (ch === "[") {
+            const inner = parseInlineFrom(src, pos + 1, ["]", ...closers]);
+            if (inner.closedBy > 0) {
+                // An outer delimiter fired inside the bracket — the bracket is literal.
+                buf += "[";
+                pos += 1;
+                continue;
+            }
+            if (inner.closedBy === -1) {
+                // Input ended inside [ … — an open link with no target yet.
+                flush();
+                children.push({ type: "link", children: inner.children, href: undefined, rawHref: "", closed: false });
+                pos = inner.pos;
+                continue;
+            }
+            const afterBracket = inner.pos + 1;
+            const paren = src[afterBracket];
+            if (paren === "(") {
+                const close = src.indexOf(")", afterBracket + 1);
+                if (close === -1) {
+                    // Target still streaming — style the text, expose NO href yet.
+                    const partial = src.slice(afterBracket + 1);
+                    flush();
+                    children.push({ type: "link", children: inner.children, href: undefined, rawHref: partial, closed: false });
+                    pos = src.length;
+                    continue;
+                }
+                // `(url "title")` tolerance: the target is the first whitespace-run-
+                // delimited word; anything after it inside the parens is ignored.
+                const rawHref = (src.slice(afterBracket + 1, close).trim().split(/\s+/)[0] ?? "");
+                flush();
+                children.push({ type: "link", children: inner.children, href: safeHref(rawHref), rawHref, closed: true });
+                pos = close + 1;
+                continue;
+            }
+            if (paren === undefined) {
+                // Input ended exactly at `[text]` — the "(" may still arrive.
+                flush();
+                children.push({ type: "link", children: inner.children, href: undefined, rawHref: "", closed: false });
+                pos = afterBracket;
+                continue;
+            }
+            // `[text]` followed by something else — literal brackets.
+            buf += "[";
+            pos += 1;
+            continue;
+        }
+        // "]" only matters when a link frame is open.
+        if (ch === "]" && closers.includes("]")) {
+            const closerIdx = closers.indexOf("]");
+            flush();
+            return { children, closedBy: closerIdx, closedIdxs: new Set([closerIdx]), runConsumed: 1, pos };
+        }
+        buf += ch;
+        pos += 1;
+    }
+    flush();
+    return { children, closedBy: -1, closedIdxs: new Set(), runConsumed: 0, pos };
+}
+/**
+ * Parse a single run of inline content (no block structure). Useful when a
+ * host renders one-line strings (labels, list items it assembled itself).
+ */
+export function parseInlineRichText(text) {
+    return parseInlineFrom(text, 0, []).children;
+}
+// ─── block parser ─────────────────────────────────────────────────────────────
+const FENCE_OPEN = /^```+\s*(\S*)\s*$/;
+const FENCE_CLOSE = /^```+\s*$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+// Leading indent is ACCEPTED and flattened (nested lists are a documented
+// future addition, not silent structure loss — the items are all kept, in
+// order, in the one open list).
+const BULLET = /^\s*[-*+]\s+(.*)$/;
+const ORDERED = /^\s*(\d{1,9})[.)]\s+(.*)$/;
+/**
+ * Parse a chat text block into the rich-text AST. Pure and total: any string
+ * (including any prefix of a longer one) parses without throwing.
+ */
+export function parseRichText(text) {
+    const blocks = [];
+    const lines = text.split("\n");
+    // Accumulators for the (single) open block.
+    let para = [];
+    let list;
+    const flushPara = () => {
+        if (para.length > 0) {
+            blocks.push({ type: "paragraph", children: parseInlineFrom(para.join("\n"), 0, []).children });
+            para = [];
+        }
+    };
+    const flushList = () => {
+        if (list !== undefined) {
+            blocks.push({ type: "list", ordered: list.ordered, start: list.start, items: list.items });
+            list = undefined;
+        }
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        // Fenced code — verbatim until the closing fence (or end of input:
+        // closed:false, content-so-far intact).
+        const fence = line.match(FENCE_OPEN);
+        if (fence !== null) {
+            flushPara();
+            flushList();
+            const lang = fence[1] !== undefined && fence[1].length > 0 ? fence[1] : undefined;
+            const body = [];
+            let closed = false;
+            let j = i + 1;
+            for (; j < lines.length; j++) {
+                const l = lines[j];
+                if (l !== undefined && FENCE_CLOSE.test(l)) {
+                    closed = true;
+                    break;
+                }
+                body.push(l ?? "");
+            }
+            blocks.push({ type: "code-fence", code: body.join("\n"), lang, closed });
+            i = j;
+            continue;
+        }
+        if (line.trim().length === 0) {
+            flushPara();
+            flushList();
+            continue;
+        }
+        const heading = line.match(HEADING);
+        if (heading !== null && heading[1] !== undefined) {
+            flushPara();
+            flushList();
+            const level = heading[1].length;
+            blocks.push({ type: "heading", level, children: parseInlineFrom(heading[2] ?? "", 0, []).children });
+            continue;
+        }
+        const ordered = line.match(ORDERED);
+        const bullet = ordered === null ? line.match(BULLET) : null;
+        if (ordered !== null || bullet !== null) {
+            flushPara();
+            const isOrdered = ordered !== null;
+            const content = (isOrdered ? ordered[2] : bullet?.[1]) ?? "";
+            // A same-orderedness item continues the open list; a switch (1. → -)
+            // closes it and opens the other kind.
+            if (list !== undefined && list.ordered !== isOrdered)
+                flushList();
+            if (list === undefined) {
+                list = {
+                    ordered: isOrdered,
+                    start: isOrdered && ordered[1] !== undefined ? parseInt(ordered[1], 10) : undefined,
+                    items: [],
+                };
+            }
+            list.items.push({ children: parseInlineFrom(content, 0, []).children });
+            continue;
+        }
+        // Plain prose. A non-bullet line after a list ENDS the list (predictable
+        // for chat; lazy continuation is not part of the v1 subset).
+        flushList();
+        para.push(line);
+    }
+    flushPara();
+    flushList();
+    return blocks;
+}
+export default parseRichText;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@silverprotocol/richtext",
+  "version": "0.3.11",
+  "description": "Headless rich-text block model for AgJSON text content — a typed markdown-subset AST + the safety policy, no rendering.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/silverprotocol/typescript-sdk.git",
+    "directory": "packages/richtext"
+  },
+  "homepage": "https://silverprotocol.io/AgJSON",
+  "bugs": {
+    "url": "https://github.com/silverprotocol/typescript-sdk/issues"
+  },
+  "keywords": [
+    "agjson",
+    "agent",
+    "agents",
+    "ai",
+    "llm",
+    "markdown",
+    "ast",
+    "streaming",
+    "chat",
+    "headless"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!dist/**/*.test.*"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "prepack": "rm -rf dist && tsc -b --force",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,473 @@
+/**
+ * `@silverprotocol/richtext` — the headless rich-text block model for AgJSON
+ * `text` content (workspace#8).
+ *
+ * Agents emit markdown in chat text (`**bold**`, lists, headings); every host
+ * that renders an AgJSON stream needs the SAME answer to "what does this text
+ * MEAN to a renderer". This package owns exactly that seam and nothing more:
+ *
+ *  - `parseRichText(text)` → a typed block/inline AST for the CONVERSATIONAL
+ *    markdown subset: bold / italic / inline code / fenced code / lists /
+ *    headings / links (plus explicit line breaks — chat prose is line-broken
+ *    and a renderer that joins lines destroys it).
+ *  - The SAFETY POLICY lives here, once. Raw HTML is NEVER interpreted — no
+ *    HTML node type exists in the AST, so `<script>` in model output can only
+ *    ever be literal text. Link `href` is populated ONLY for http/https/mailto
+ *    targets; everything else (javascript:, data:, vbscript:, relative paths)
+ *    parses as a link whose `href` is `undefined` — hosts get the styled text
+ *    but nothing navigable. Rich HTML has its own channel (tool-result UI
+ *    resources); chat text is untrusted model output.
+ *  - STREAMING-TOLERANT by design: mid-stream input with unclosed markers
+ *    (`**bol`, a dangling fence, half a link) parses to a stable AST that
+ *    fails SOFT — the construct exists with `closed: false` and its partial
+ *    content, never a throw, never a reshuffle of earlier siblings. Feed a
+ *    growing buffer on every `text.delta` and re-parse: completed constructs
+ *    never change shape; only the trailing OPEN construct extends (or
+ *    disambiguates) as input arrives.
+ *
+ * NO components, NO styling, NO dependencies — hosts map the AST onto their
+ * own renderers and design systems. Rendering rule for hosts: every string in
+ * this AST (`text`, `code`) is literal content — render it as text content
+ * (React children / RN <Text> / textContent), NEVER as markup.
+ *
+ * Deliberately OUT of the v1 subset (parse as plain text; future spec-process
+ * additions, not silent behavior): images, tables, blockquotes, strikethrough,
+ * autolinked bare URLs, nested lists (indented bullets FLATTEN into the open
+ * list), block content inside list items, and `setext` headings.
+ */
+
+// ─── AST types ────────────────────────────────────────────────────────────────
+
+/** Inline content. `closed: false` marks a construct still open mid-stream. */
+export type RichTextInline =
+  | { type: "text"; text: string }
+  /** Explicit line break — a single newline inside a paragraph/heading/item.
+   *  Chat prose is line-broken; hosts map this to <br/> / "\n", never a space. */
+  | { type: "break" }
+  | { type: "strong"; children: RichTextInline[]; closed: boolean }
+  | { type: "em"; children: RichTextInline[]; closed: boolean }
+  | { type: "code"; code: string; closed: boolean }
+  | {
+      type: "link";
+      children: RichTextInline[];
+      /**
+       * The navigable target — populated ONLY when the written target passed
+       * the scheme allowlist (http:, https:, mailto:). `undefined` means
+       * "style as a link if you like, but there is nothing safe to open".
+       */
+      href: string | undefined;
+      /**
+       * The target VERBATIM as written (lossless — may be a partial mid-stream
+       * fragment or a rejected scheme). NEVER navigate to this; it exists for
+       * audit/debug display only. `href` is the only navigable field.
+       */
+      rawHref: string;
+      closed: boolean;
+    };
+
+export type RichTextListItem = { children: RichTextInline[] };
+
+/** Block content. Order is the render order. */
+export type RichTextBlock =
+  | { type: "paragraph"; children: RichTextInline[] }
+  | { type: "heading"; level: 1 | 2 | 3 | 4 | 5 | 6; children: RichTextInline[] }
+  | {
+      type: "code-fence";
+      code: string;
+      /** The info string's first word (```ts → "ts"), if any. */
+      lang: string | undefined;
+      closed: boolean;
+    }
+  | {
+      type: "list";
+      ordered: boolean;
+      /** First item's number for an ordered list (1. / 3. …), else undefined. */
+      start: number | undefined;
+      items: RichTextListItem[];
+    };
+
+// ─── safety policy: link scheme allowlist ─────────────────────────────────────
+
+// http/https/mailto ONLY. Case-insensitive; whitespace and control characters
+// in the written target disqualify rather than get cleaned (a target that
+// needs cleaning is not a target the model wrote cleanly).
+const SAFE_HREF = /^(?:https?:\/\/|mailto:)[^\s\x00-\x1f]+$/i;
+
+/** The one place the navigable-target decision is made (workspace#8 policy). */
+function safeHref(raw: string): string | undefined {
+  return SAFE_HREF.test(raw) ? raw : undefined;
+}
+
+// ─── inline parser ────────────────────────────────────────────────────────────
+// Recursive descent with an explicit closer stack. `closers` is innermost-
+// first; a delimiter that matches ANY active closer unwinds to that frame —
+// the frames it skips over close as `closed: false` (fail-soft: `**a *b** c`
+// closes the strong; the dangling em inside it stays open-but-stable).
+
+type Closer = "**" | "__" | "*" | "_" | "]";
+
+interface InlineResult {
+  children: RichTextInline[];
+  /** Index into `closers` of the OUTERMOST frame the ending delimiter run closed, or -1 for end-of-input. */
+  closedBy: number;
+  /**
+   * Every `closers` index the run closed (a *** run can close an em AND its
+   * strong at once) — each unwind level reads its own frame's flag from here.
+   */
+  closedIdxs: ReadonlySet<number>;
+  /** Run characters consumed by those closes — the outermost consumer advances past them. */
+  runConsumed: number;
+  pos: number;
+}
+
+/** Shift a closer-index set down one stack level (drop this frame's own slot). */
+function shiftIdxs(idxs: ReadonlySet<number>): Set<number> {
+  const out = new Set<number>();
+  for (const i of idxs) if (i > 0) out.add(i - 1);
+  return out;
+}
+
+function isWs(ch: string | undefined): boolean {
+  return ch === undefined || ch === " " || ch === "\t" || ch === "\n";
+}
+
+function isWordChar(ch: string | undefined): boolean {
+  return ch !== undefined && /[A-Za-z0-9]/.test(ch);
+}
+
+// Flanking rules — the pragmatic subset of CommonMark's:
+//  *  opens when followed by non-space; closes when preceded by non-space.
+//  _  additionally must sit at a word BOUNDARY on its outer side, so
+//     snake_case_identifiers in prose never italicize (the reason CommonMark
+//     has the rule; agents emit identifiers constantly).
+function canOpen(marker: Closer, prev: string | undefined, next: string | undefined): boolean {
+  if (isWs(next)) return false;
+  if (marker === "_" || marker === "__") return !isWordChar(prev);
+  return true;
+}
+function canClose(marker: Closer, prev: string | undefined, next: string | undefined): boolean {
+  if (isWs(prev)) return false;
+  if (marker === "_" || marker === "__") return !isWordChar(next);
+  return true;
+}
+
+// Backslash escapes: exactly ASCII punctuation (CommonMark's set) — `\*` is a
+// literal asterisk; `\n` (the letter n) is just "\" + "n".
+const ESCAPABLE = new Set("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~");
+
+function parseInlineFrom(src: string, start: number, closers: Closer[]): InlineResult {
+  const children: RichTextInline[] = [];
+  let buf = "";
+  const flush = (): void => {
+    if (buf.length > 0) {
+      children.push({ type: "text", text: buf });
+      buf = "";
+    }
+  };
+
+  let pos = start;
+  while (pos < src.length) {
+    const ch = src[pos];
+    if (ch === undefined) break;
+
+    // Backslash escape.
+    if (ch === "\\") {
+      const next = src[pos + 1];
+      if (next !== undefined && ESCAPABLE.has(next)) {
+        buf += next;
+        pos += 2;
+        continue;
+      }
+      buf += ch;
+      pos += 1;
+      continue;
+    }
+
+    // Explicit line break (paragraph lines are joined with "\n" upstream).
+    if (ch === "\n") {
+      flush();
+      children.push({ type: "break" });
+      pos += 1;
+      continue;
+    }
+
+    // Inline code span — verbatim until the closing backtick (newlines
+    // included: a span the stream hasn't closed yet swallows softly, and a
+    // genuine multi-line span renders fine under code styling). No nested
+    // markdown inside.
+    if (ch === "`") {
+      flush();
+      const end = src.indexOf("`", pos + 1);
+      if (end === -1) {
+        children.push({ type: "code", code: src.slice(pos + 1), closed: false });
+        pos = src.length;
+        continue;
+      }
+      children.push({ type: "code", code: src.slice(pos + 1, end), closed: true });
+      pos = end + 1;
+      continue;
+    }
+
+    // Emphasis delimiters. Closing is checked BEFORE opening so `**bold**`'s
+    // second ** seals rather than re-opens.
+    if (ch === "*" || ch === "_") {
+      const two = src.slice(pos, pos + 2);
+      const double: Closer | undefined = two === "**" || two === "__" ? (two as Closer) : undefined;
+      const single = ch as Closer;
+      const prev = pos > 0 ? src[pos - 1] : undefined;
+
+      // Measure the whole delimiter run, then walk the open frames OUTERMOST-
+      // first (link brackets bound the walk — emphasis never closes across a
+      // `[`), spending the run's characters on every closeable frame: a **
+      // run seals the strong (its inner em dangles soft — `**a *b** c`), a
+      // *** run seals the em AND the strong. The closure SET rides the unwind
+      // so every level marks its own `closed` flag accurately.
+      let runLen = 1;
+      while (src[pos + runLen] === ch) runLen++;
+      const nextAfterRun = src[pos + runLen];
+      const bracket = closers.indexOf("]");
+      const bound = bracket === -1 ? closers.length - 1 : bracket - 1;
+      const closedIdxs = new Set<number>();
+      let budget = runLen;
+      for (let ci = bound; ci >= 0; ci--) {
+        const m = closers[ci];
+        if (m === undefined || m[0] !== ch) continue;
+        if (m.length > budget) continue;
+        if (!canClose(m, prev, nextAfterRun)) continue;
+        closedIdxs.add(ci);
+        budget -= m.length;
+        if (budget === 0) break;
+      }
+      if (closedIdxs.size > 0) {
+        flush();
+        return {
+          children,
+          closedBy: Math.max(...closedIdxs),
+          closedIdxs,
+          runConsumed: runLen - budget,
+          pos,
+        };
+      }
+
+      // Opening reads the longest marker (** before *); a double that cannot
+      // open stays a literal double, never a half-open single.
+      const marker: Closer = double ?? single;
+      const next = src[pos + marker.length];
+      if (canOpen(marker, prev, next)) {
+        flush();
+        const inner = parseInlineFrom(src, pos + marker.length, [marker, ...closers]);
+        const node: RichTextInline =
+          marker === "**" || marker === "__"
+            ? { type: "strong", children: inner.children, closed: inner.closedIdxs.has(0) }
+            : { type: "em", children: inner.children, closed: inner.closedIdxs.has(0) };
+        children.push(node);
+        if (inner.closedBy === 0) {
+          // This frame is the OUTERMOST one the run closed — consume the
+          // run's whole closed span here.
+          pos = inner.pos + inner.runConsumed;
+          continue;
+        }
+        if (inner.closedBy === -1) {
+          // End of input — everything is flushed; this frame ends open too.
+          pos = inner.pos;
+          continue;
+        }
+        // The run reached an OUTER frame: keep unwinding (shift the set past
+        // this frame's own stack slot).
+        return {
+          children,
+          closedBy: inner.closedBy - 1,
+          closedIdxs: shiftIdxs(inner.closedIdxs),
+          runConsumed: inner.runConsumed,
+          pos: inner.pos,
+        };
+      }
+      buf += marker;
+      pos += marker.length;
+      continue;
+    }
+
+    // Link: [children](target). `[text]` followed by anything but "(" is the
+    // literal bracket text it always was; `[text]` at END of input stays an
+    // open link — the "(url)" may still be in flight (fail-soft, documented).
+    if (ch === "[") {
+      const inner = parseInlineFrom(src, pos + 1, ["]", ...closers]);
+      if (inner.closedBy > 0) {
+        // An outer delimiter fired inside the bracket — the bracket is literal.
+        buf += "[";
+        pos += 1;
+        continue;
+      }
+      if (inner.closedBy === -1) {
+        // Input ended inside [ … — an open link with no target yet.
+        flush();
+        children.push({ type: "link", children: inner.children, href: undefined, rawHref: "", closed: false });
+        pos = inner.pos;
+        continue;
+      }
+      const afterBracket = inner.pos + 1;
+      const paren = src[afterBracket];
+      if (paren === "(") {
+        const close = src.indexOf(")", afterBracket + 1);
+        if (close === -1) {
+          // Target still streaming — style the text, expose NO href yet.
+          const partial = src.slice(afterBracket + 1);
+          flush();
+          children.push({ type: "link", children: inner.children, href: undefined, rawHref: partial, closed: false });
+          pos = src.length;
+          continue;
+        }
+        // `(url "title")` tolerance: the target is the first whitespace-run-
+        // delimited word; anything after it inside the parens is ignored.
+        const rawHref = (src.slice(afterBracket + 1, close).trim().split(/\s+/)[0] ?? "");
+        flush();
+        children.push({ type: "link", children: inner.children, href: safeHref(rawHref), rawHref, closed: true });
+        pos = close + 1;
+        continue;
+      }
+      if (paren === undefined) {
+        // Input ended exactly at `[text]` — the "(" may still arrive.
+        flush();
+        children.push({ type: "link", children: inner.children, href: undefined, rawHref: "", closed: false });
+        pos = afterBracket;
+        continue;
+      }
+      // `[text]` followed by something else — literal brackets.
+      buf += "[";
+      pos += 1;
+      continue;
+    }
+
+    // "]" only matters when a link frame is open.
+    if (ch === "]" && closers.includes("]")) {
+      const closerIdx = closers.indexOf("]");
+      flush();
+      return { children, closedBy: closerIdx, closedIdxs: new Set([closerIdx]), runConsumed: 1, pos };
+    }
+
+    buf += ch;
+    pos += 1;
+  }
+
+  flush();
+  return { children, closedBy: -1, closedIdxs: new Set(), runConsumed: 0, pos };
+}
+
+/**
+ * Parse a single run of inline content (no block structure). Useful when a
+ * host renders one-line strings (labels, list items it assembled itself).
+ */
+export function parseInlineRichText(text: string): RichTextInline[] {
+  return parseInlineFrom(text, 0, []).children;
+}
+
+// ─── block parser ─────────────────────────────────────────────────────────────
+
+const FENCE_OPEN = /^```+\s*(\S*)\s*$/;
+const FENCE_CLOSE = /^```+\s*$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+// Leading indent is ACCEPTED and flattened (nested lists are a documented
+// future addition, not silent structure loss — the items are all kept, in
+// order, in the one open list).
+const BULLET = /^\s*[-*+]\s+(.*)$/;
+const ORDERED = /^\s*(\d{1,9})[.)]\s+(.*)$/;
+
+/**
+ * Parse a chat text block into the rich-text AST. Pure and total: any string
+ * (including any prefix of a longer one) parses without throwing.
+ */
+export function parseRichText(text: string): RichTextBlock[] {
+  const blocks: RichTextBlock[] = [];
+  const lines = text.split("\n");
+
+  // Accumulators for the (single) open block.
+  let para: string[] = [];
+  let list: { ordered: boolean; start: number | undefined; items: RichTextListItem[] } | undefined;
+
+  const flushPara = (): void => {
+    if (para.length > 0) {
+      blocks.push({ type: "paragraph", children: parseInlineFrom(para.join("\n"), 0, []).children });
+      para = [];
+    }
+  };
+  const flushList = (): void => {
+    if (list !== undefined) {
+      blocks.push({ type: "list", ordered: list.ordered, start: list.start, items: list.items });
+      list = undefined;
+    }
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined) continue;
+
+    // Fenced code — verbatim until the closing fence (or end of input:
+    // closed:false, content-so-far intact).
+    const fence = line.match(FENCE_OPEN);
+    if (fence !== null) {
+      flushPara();
+      flushList();
+      const lang = fence[1] !== undefined && fence[1].length > 0 ? fence[1] : undefined;
+      const body: string[] = [];
+      let closed = false;
+      let j = i + 1;
+      for (; j < lines.length; j++) {
+        const l = lines[j];
+        if (l !== undefined && FENCE_CLOSE.test(l)) {
+          closed = true;
+          break;
+        }
+        body.push(l ?? "");
+      }
+      blocks.push({ type: "code-fence", code: body.join("\n"), lang, closed });
+      i = j;
+      continue;
+    }
+
+    if (line.trim().length === 0) {
+      flushPara();
+      flushList();
+      continue;
+    }
+
+    const heading = line.match(HEADING);
+    if (heading !== null && heading[1] !== undefined) {
+      flushPara();
+      flushList();
+      const level = heading[1].length as 1 | 2 | 3 | 4 | 5 | 6;
+      blocks.push({ type: "heading", level, children: parseInlineFrom(heading[2] ?? "", 0, []).children });
+      continue;
+    }
+
+    const ordered = line.match(ORDERED);
+    const bullet = ordered === null ? line.match(BULLET) : null;
+    if (ordered !== null || bullet !== null) {
+      flushPara();
+      const isOrdered = ordered !== null;
+      const content = (isOrdered ? ordered[2] : bullet?.[1]) ?? "";
+      // A same-orderedness item continues the open list; a switch (1. → -)
+      // closes it and opens the other kind.
+      if (list !== undefined && list.ordered !== isOrdered) flushList();
+      if (list === undefined) {
+        list = {
+          ordered: isOrdered,
+          start: isOrdered && ordered[1] !== undefined ? parseInt(ordered[1], 10) : undefined,
+          items: [],
+        };
+      }
+      list.items.push({ children: parseInlineFrom(content, 0, []).children });
+      continue;
+    }
+
+    // Plain prose. A non-bullet line after a list ENDS the list (predictable
+    // for chat; lazy continuation is not part of the v1 subset).
+    flushList();
+    para.push(line);
+  }
+
+  flushPara();
+  flushList();
+  return blocks;
+}
+
+export default parseRichText;