@chainingintention/pi-web-cn 1.202607.10 → 1.202608.2

package/dist/pi-web-plugins/info/pi-web-plugin.js

@@ -1,4 +1,11 @@
 // Generated from pi-web-plugins/info/pi-web-plugin.ts. Do not edit directly.
+// Skeleton of a PI WEB plugin: metadata plus contribution definitions.
+//
+// Everything the bundled Info panel and action actually render lives in
+// infoInternals.ts. That file is replaceable implementation detail — when
+// copying this plugin as a starting point, keep this file's shape and swap
+// the internals for your own.
+import { copyDiagnostics, renderInfoPanel } from "./infoInternals.js";
 const plugin = {
     apiVersion: 1,
     name: "信息插件",
@@ -6,43 +13,33 @@ const plugin = {
         contributions: {
             actions: [
                 {
-                    id: "workspace.show-path",
-                    title: "显示当前工作区路径",
+                    id: "copy-diagnostics",
+                    title: "复制 PI WEB 诊断信息",
+                    description: "复制此机器的版本、安装和状态详情，以便粘贴到错误报告中",
                     group: "信息",
-                    enabled: (context) => context.state.selectedWorkspace !== undefined,
-                    run: (context) => {
-                        const path = context.state.selectedWorkspace?.path ?? "未选择工作区";
-                        window.alert(path);
-                    },
+                    run: (context) => copyDiagnostics(context),
                 },
             ],
             workspaceLabels: [
                 {
                     id: "workspace.kind-label",
                     order: 100,
-                    items: (context) => [{ type: "text", text: context.workspace.isGitRepo ? "git" : "文件夹", title: context.workspace.path }],
+                    items: (context) => [{ type: "text", text: context.workspace.isGitRepo ? "Git" : "文件夹", title: context.workspace.path }],
                 },
             ],
             workspacePanels: [
                 {
                     id: "workspace.info",
                     title: "信息",
-                    icon: svg `
-            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-              <circle cx="12" cy="12" r="9"></circle>
-              <path d="M12 11v5"></path>
-              <path d="M12 8h.01"></path>
-            </svg>
+                    icon: svg `
+            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+              <circle cx="12" cy="12" r="9"></circle>
+              <path d="M12 11v5"></path>
+              <path d="M12 8h.01"></path>
+            </svg>
           `,
                     order: 1000,
-                    render: (context) => html `
-            <section class="toolbar"><strong>信息</strong></section>
-            <section class="viewer">
-              <p><strong>工作区</strong></p>
-              <p class="muted">${context.workspace.label}</p>
-              <p class="muted">${context.workspace.path}</p>
-            </section>
-          `,
+                    render: (context) => renderInfoPanel(html, context),
                 },
             ],
         },

package/dist/pi-web-plugins/relays/markdownDocument.js

@@ -0,0 +1,81 @@
+// Generated from pi-web-plugins/relays/markdownDocument.ts. Do not edit directly.
+import { marked } from "./vendor/marked.esm.js";
+// Raw HTML inside relay documents is escaped before sanitizing, so the
+// sanitizer only ever sees marked-generated markup. This mirrors the safety
+// rules of the app's renderer in src/client/src/formatting/markdown.ts; the
+// plugin cannot import that module, so the rules are duplicated here.
+const renderer = new marked.Renderer();
+renderer.html = ({ text }) => escapeHtml(text);
+const MAX_MARKDOWN_CACHE_ENTRIES = 300;
+const markdownHtmlCache = new Map();
+/** Relay documents ending in .md render as markdown; everything else stays preformatted text. */
+export function isMarkdownDocumentPath(path) {
+    return path.toLowerCase().endsWith(".md");
+}
+/** Render one relay markdown document into sanitized HTML safe to interpolate into innerHTML. */
+export function renderRelayDocumentHtml(source) {
+    const cached = markdownHtmlCache.get(source);
+    if (cached !== undefined)
+        return cached;
+    const html = marked.parse(source, { async: false, breaks: true, gfm: true, renderer });
+    const safeHtml = sanitizeHtml(html);
+    markdownHtmlCache.set(source, safeHtml);
+    if (markdownHtmlCache.size > MAX_MARKDOWN_CACHE_ENTRIES) {
+        const oldest = markdownHtmlCache.keys().next().value;
+        if (oldest !== undefined)
+            markdownHtmlCache.delete(oldest);
+    }
+    return safeHtml;
+}
+function escapeHtml(text) {
+    return text
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+const TABLE_SCROLL_CLASS = "table-scroll";
+function sanitizeHtml(html) {
+    const template = document.createElement("template");
+    template.innerHTML = html;
+    template.content.querySelectorAll("script, style, iframe, object, embed").forEach((node) => { node.remove(); });
+    template.content.querySelectorAll("*").forEach((element) => {
+        for (const attribute of [...element.attributes]) {
+            const name = attribute.name.toLowerCase();
+            if (name.startsWith("on"))
+                element.removeAttribute(attribute.name);
+            if ((name === "href" || name === "src") && !isSafeUrl(attribute.value))
+                element.removeAttribute(attribute.name);
+        }
+        if (element.tagName === "A") {
+            element.setAttribute("target", "_blank");
+            element.setAttribute("rel", "noreferrer noopener");
+        }
+    });
+    wrapTablesInScrollRegions(template.content);
+    return template.innerHTML;
+}
+// Tables keep their natural width and scroll horizontally instead of being
+// squeezed into the panel, which is unreadable on narrow screens.
+function wrapTablesInScrollRegions(root) {
+    root.querySelectorAll("table").forEach((table) => {
+        if (table.parentElement?.classList.contains(TABLE_SCROLL_CLASS) === true)
+            return;
+        const wrapper = document.createElement("div");
+        wrapper.className = TABLE_SCROLL_CLASS;
+        wrapper.setAttribute("role", "region");
+        wrapper.setAttribute("aria-label", "表格");
+        wrapper.setAttribute("tabindex", "0");
+        table.before(wrapper);
+        wrapper.append(table);
+    });
+}
+function isSafeUrl(url) {
+    if (url.startsWith("#") || url.startsWith("/"))
+        return true;
+    try {
+        return ["http:", "https:", "mailto:"].includes(new URL(url).protocol);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/pi-web-plugins/relays/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@pi-web/relays-plugin",
+  "private": true,
+  "piWeb": {
+    "plugins": [
+      { "id": "relays", "module": "pi-web-plugin.js" }
+    ]
+  }
+}

package/dist/pi-web-plugins/relays/pi-web-plugin.js

@@ -0,0 +1,44 @@
+// Generated from pi-web-plugins/relays/pi-web-plugin.ts. Do not edit directly.
+import { RELAYS_ROOT } from "./relayDiscovery.js";
+import { defineRelaysPanelElement } from "./relaysPanelElement.js";
+const plugin = {
+    apiVersion: 1,
+    name: "中继",
+    activate: ({ pluginId, html, svg }) => {
+        defineRelaysPanelElement();
+        return {
+            contributions: {
+                actions: [
+                    {
+                        id: "workspace.open-relays",
+                        title: "打开工作区中继",
+                        description: `打开工作区的中继标签页。中继存放在 ${RELAYS_ROOT}。`,
+                        group: "工作区",
+                        enabled: (context) => context.state.selectedWorkspace !== undefined,
+                        run: (context) => {
+                            if (context.state.selectedWorkspace === undefined)
+                                return;
+                            context.selectWorkspaceTool(`${pluginId}:workspace.relays`);
+                        },
+                    },
+                ],
+                workspacePanels: [
+                    {
+                        id: "workspace.relays",
+                        title: "中继",
+                        icon: svg `
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                <path d="M9 17H7A5 5 0 0 1 7 7h2"></path>
+                <path d="M15 7h2a5 5 0 1 1 0 10h-2"></path>
+                <line x1="8" y1="12" x2="16" y2="12"></line>
+              </svg>
+            `,
+                        order: 50,
+                        render: (context) => html `<pi-web-relays-panel .context=${context}></pi-web-relays-panel>`,
+                    },
+                ],
+            },
+        };
+    },
+};
+export default plugin;

package/dist/pi-web-plugins/relays/relayDiscovery.js

@@ -0,0 +1,96 @@
+// Generated from pi-web-plugins/relays/relayDiscovery.ts. Do not edit directly.
+export const RELAYS_ROOT = ".pi-web/relays";
+/** Documents that anchor a relay packet, in display order. Any other files follow alphabetically. */
+export const RELAY_ANCHOR_DOCUMENTS = ["status.md", "charter.md", "log.md"];
+// The workspace file API rejects with these messages when a path is absent or
+// is not a directory. For the relays root both mean "zero relays", not a failure.
+const missingListingErrorMessages = new Set(["Path does not exist", "Path is not a directory"]);
+/** List the workspace's relays, most recently modified first. Never rejects. */
+export async function listWorkspaceRelays(files) {
+    let listing;
+    try {
+        listing = await files.listFiles(RELAYS_ROOT);
+    }
+    catch (error) {
+        return fileAccessFailure(error);
+    }
+    const relays = sortRelaysByRecency(listing.entries
+        .filter((entry) => entry.type === "directory")
+        .map((entry) => toRelaySummary(entry)));
+    return { kind: "loaded", relays };
+}
+/** List one relay's documents: status.md, charter.md, log.md first, then alphabetical. Never rejects. */
+export async function listRelayDocuments(files, relayPath) {
+    let listing;
+    try {
+        listing = await files.listFiles(relayPath);
+    }
+    catch (error) {
+        return fileAccessFailure(error);
+    }
+    const documents = orderRelayDocuments(listing.entries
+        .filter((entry) => entry.type === "file")
+        .map((entry) => toRelayDocumentEntry(entry)));
+    return { kind: "loaded", documents };
+}
+/** Read one relay document. Never rejects. */
+export async function readRelayDocument(files, documentPath) {
+    try {
+        const file = await files.readFile(documentPath);
+        return { kind: "loaded", content: file.content, truncated: file.truncated, binary: file.binary };
+    }
+    catch (error) {
+        return fileAccessFailure(error);
+    }
+}
+/** Newest first; relays without a usable modifiedAt sort last, alphabetically. */
+export function sortRelaysByRecency(relays) {
+    return [...relays].sort(compareRelaysByRecency);
+}
+/** Anchor documents first in fixed order, then everything else alphabetically. */
+export function orderRelayDocuments(documents) {
+    return [...documents].sort(compareRelayDocuments);
+}
+/** The document a relay opens on: status.md when present, otherwise the first ordered document. */
+export function defaultRelayDocument(documents) {
+    // Anchor ordering guarantees status.md is first whenever it exists.
+    return orderRelayDocuments(documents)[0];
+}
+function toRelaySummary(entry) {
+    return { name: entry.name, path: entry.path, modifiedAt: entry.modifiedAt };
+}
+function toRelayDocumentEntry(entry) {
+    return { name: entry.name, path: entry.path, modifiedAt: entry.modifiedAt };
+}
+function compareRelaysByRecency(left, right) {
+    const leftTime = timestampOf(left.modifiedAt);
+    const rightTime = timestampOf(right.modifiedAt);
+    if (leftTime !== undefined && rightTime !== undefined && leftTime !== rightTime)
+        return rightTime - leftTime;
+    if (leftTime !== undefined)
+        return -1;
+    if (rightTime !== undefined)
+        return 1;
+    return left.name.localeCompare(right.name);
+}
+function timestampOf(modifiedAt) {
+    if (modifiedAt === undefined)
+        return undefined;
+    const time = Date.parse(modifiedAt);
+    return Number.isNaN(time) ? undefined : time;
+}
+function compareRelayDocuments(left, right) {
+    const anchorOrder = anchorIndexOf(left.name) - anchorIndexOf(right.name);
+    if (anchorOrder !== 0)
+        return anchorOrder;
+    return left.name.localeCompare(right.name);
+}
+function anchorIndexOf(name) {
+    const index = RELAY_ANCHOR_DOCUMENTS.indexOf(name);
+    return index === -1 ? RELAY_ANCHOR_DOCUMENTS.length : index;
+}
+function fileAccessFailure(error) {
+    if (error instanceof Error && missingListingErrorMessages.has(error.message))
+        return { kind: "missing" };
+    return { kind: "unavailable", detail: error instanceof Error ? error.message : String(error) };
+}

package/dist/pi-web-plugins/relays/relaysPanelElement.js

@@ -0,0 +1,327 @@
+// Generated from pi-web-plugins/relays/relaysPanelElement.ts. Do not edit directly.
+import { isMarkdownDocumentPath, renderRelayDocumentHtml } from "./markdownDocument.js";
+import { defaultRelayDocument, listRelayDocuments, listWorkspaceRelays, readRelayDocument, RELAYS_ROOT, } from "./relayDiscovery.js";
+export const relaysPanelTagName = "pi-web-relays-panel";
+export function defineRelaysPanelElement() {
+    if (!customElements.get(relaysPanelTagName))
+        customElements.define(relaysPanelTagName, PiWebRelaysPanel);
+}
+/**
+ * Read-only relay browser: relay picker (auto-opens a single relay), one tab
+ * per relay document, and a document viewer rendering markdown documents as
+ * sanitized HTML and everything else as preformatted text. All async loads
+ * flow through scanToken so stale responses for a previous workspace or
+ * selection never overwrite newer state.
+ */
+class PiWebRelaysPanel extends HTMLElement {
+    contextValue;
+    listing;
+    selectedRelayPath;
+    documents;
+    selectedDocumentPath;
+    documentContent;
+    scanToken = 0;
+    root;
+    constructor() {
+        super();
+        this.root = this.attachShadow({ mode: "open" });
+    }
+    set context(value) {
+        const previousKey = this.contextValue === undefined ? undefined : contextKey(this.contextValue);
+        const nextKey = value === undefined ? undefined : contextKey(value);
+        this.contextValue = value;
+        // Parent app updates should not rescan or rebuild this shadow DOM for the
+        // same workspace (mirrors the workspace-tasks panel).
+        if (previousKey === nextKey)
+            return;
+        if (value === undefined) {
+            this.resetScanState();
+            this.render();
+            return;
+        }
+        void this.scan(value, {});
+    }
+    connectedCallback() {
+        this.render();
+    }
+    /** Rescan relays, then reload the selected relay's documents and the open document. */
+    async scan(context, selection) {
+        const token = ++this.scanToken;
+        this.resetScanState();
+        this.render();
+        const listing = await listWorkspaceRelays(context.files);
+        if (!this.isCurrentScan(context, token))
+            return;
+        this.listing = listing;
+        // listWorkspaceRelays returns most recently modified first, so the first
+        // relay is the default pre-selection.
+        const relay = listing.kind === "loaded"
+            ? listing.relays.find((candidate) => candidate.path === selection.relayPath) ?? listing.relays[0]
+            : undefined;
+        this.selectedRelayPath = relay?.path;
+        if (relay === undefined) {
+            this.render();
+            return;
+        }
+        await this.loadDocuments(context, token, relay.path, selection.documentPath);
+    }
+    async openRelay(context, relayPath) {
+        const token = ++this.scanToken;
+        this.selectedRelayPath = relayPath;
+        await this.loadDocuments(context, token, relayPath, undefined);
+    }
+    async openDocument(context, documentPath) {
+        const token = ++this.scanToken;
+        this.selectedDocumentPath = documentPath;
+        await this.loadDocumentContent(context, token, documentPath);
+    }
+    async loadDocuments(context, token, relayPath, preferredDocumentPath) {
+        this.documents = undefined;
+        this.selectedDocumentPath = undefined;
+        this.documentContent = undefined;
+        this.render();
+        const documents = await listRelayDocuments(context.files, relayPath);
+        if (!this.isCurrentScan(context, token))
+            return;
+        this.documents = documents;
+        const document = documents.kind === "loaded"
+            ? documents.documents.find((candidate) => candidate.path === preferredDocumentPath) ?? defaultRelayDocument(documents.documents)
+            : undefined;
+        this.selectedDocumentPath = document?.path;
+        if (document === undefined) {
+            this.render();
+            return;
+        }
+        await this.loadDocumentContent(context, token, document.path);
+    }
+    async loadDocumentContent(context, token, documentPath) {
+        this.documentContent = undefined;
+        this.render();
+        const content = await readRelayDocument(context.files, documentPath);
+        if (!this.isCurrentScan(context, token))
+            return;
+        this.documentContent = content;
+        this.render();
+    }
+    refresh() {
+        const context = this.contextValue;
+        if (context === undefined)
+            return;
+        void this.scan(context, { relayPath: this.selectedRelayPath, documentPath: this.selectedDocumentPath });
+    }
+    resetScanState() {
+        this.listing = undefined;
+        this.selectedRelayPath = undefined;
+        this.documents = undefined;
+        this.selectedDocumentPath = undefined;
+        this.documentContent = undefined;
+    }
+    isCurrentScan(context, token) {
+        return token === this.scanToken && this.contextValue !== undefined && contextKey(this.contextValue) === contextKey(context);
+    }
+    render() {
+        const context = this.contextValue;
+        if (context === undefined) {
+            this.root.innerHTML = `${relaysStyles()}<section class="empty">请选择工作区。</section>`;
+            return;
+        }
+        this.root.innerHTML = `
+      ${relaysStyles()}
+      <section class="toolbar">
+        <strong>中继</strong>
+        <span class="toolbar-actions">
+          ${this.renderRelayPicker()}
+          <button class="icon-button" data-refresh aria-label="刷新" title="刷新">${refreshIconSvg()}</button>
+        </span>
+      </section>
+      ${this.renderDocumentTabs()}
+      <section class="viewer">${this.renderViewer()}</section>
+    `;
+        this.root.querySelector("button[data-refresh]")?.addEventListener("click", () => {
+            this.refresh();
+        });
+        this.root.querySelector("select[data-relay-picker]")?.addEventListener("change", (event) => {
+            const picker = event.target;
+            if (picker instanceof HTMLSelectElement)
+                void this.openRelay(context, picker.value);
+        });
+        for (const tab of this.root.querySelectorAll("button[data-document-path]")) {
+            tab.addEventListener("click", () => {
+                const documentPath = tab.getAttribute("data-document-path");
+                if (documentPath !== null)
+                    void this.openDocument(context, documentPath);
+            });
+        }
+    }
+    renderRelayPicker() {
+        const listing = this.listing;
+        if (listing?.kind !== "loaded" || listing.relays.length === 0)
+            return "";
+        // A single relay opens immediately; a one-option picker would be noise.
+        if (listing.relays.length === 1) {
+            const relay = listing.relays[0];
+            return relay === undefined ? "" : `<span class="relay-name" title="${escapeAttr(relay.path)}">${escapeHtml(relay.name)}</span>`;
+        }
+        const options = listing.relays.map((relay) => {
+            const selected = relay.path === this.selectedRelayPath ? " selected" : "";
+            return `<option value="${escapeAttr(relay.path)}"${selected}>${escapeHtml(relay.name)}</option>`;
+        }).join("");
+        return `<select data-relay-picker aria-label="中继">${options}</select>`;
+    }
+    renderDocumentTabs() {
+        const documents = this.documents;
+        if (documents?.kind !== "loaded" || documents.documents.length === 0)
+            return "";
+        const tabs = documents.documents.map((document) => {
+            const active = document.path === this.selectedDocumentPath;
+            return `<button class="document-tab${active ? " active" : ""}" data-document-path="${escapeAttr(document.path)}"${active ? ' aria-current="true"' : ""}>${escapeHtml(document.name)}</button>`;
+        }).join("");
+        return `<nav class="document-tabs" aria-label="中继文档">${tabs}</nav>`;
+    }
+    renderViewer() {
+        const listing = this.listing;
+        if (listing === undefined)
+            return `<p class="muted">正在扫描 ${escapeHtml(RELAYS_ROOT)}…</p>`;
+        if (listing.kind === "unavailable")
+            return renderErrorState("无法扫描工作区中继。", listing.detail);
+        if (listing.kind === "missing" || listing.relays.length === 0)
+            return renderEmptyState();
+        return this.renderSelectedRelay();
+    }
+    renderSelectedRelay() {
+        const documents = this.documents;
+        if (documents === undefined)
+            return `<p class="muted">正在加载中继文档…</p>`;
+        if (documents.kind === "unavailable")
+            return renderErrorState("无法列出此中继的文档。", documents.detail);
+        if (documents.kind === "missing") {
+            return `<div class="empty-state"><strong>此中继已不存在。</strong><p>点击“刷新”重新扫描 ${escapeHtml(RELAYS_ROOT)}。</p></div>`;
+        }
+        if (documents.documents.length === 0) {
+            return `
+        <div class="empty-state">
+          <strong>此中继还没有文档。</strong>
+          <p>中继包通常包含 <code>status.md</code>、<code>charter.md</code> 和 <code>log.md</code>。</p>
+        </div>
+      `;
+        }
+        return this.renderSelectedDocument();
+    }
+    renderSelectedDocument() {
+        const documentPath = this.selectedDocumentPath;
+        const content = this.documentContent;
+        if (documentPath === undefined)
+            return `<p class="muted">请选择文档。</p>`;
+        if (content === undefined)
+            return `<p class="muted">正在加载 ${escapeHtml(documentName(documentPath))}…</p>`;
+        if (content.kind === "unavailable")
+            return renderErrorState("无法读取此文档。", content.detail);
+        if (content.kind === "missing") {
+            return `<div class="empty-state"><strong>此文档已不存在。</strong><p>点击“刷新”重新扫描中继。</p></div>`;
+        }
+        if (content.binary) {
+            return `<div class="empty-state"><strong>二进制文件：${escapeHtml(documentName(documentPath))}</strong><p>二进制文档无法提供文本预览。</p></div>`;
+        }
+        const truncation = content.truncated
+            ? `<div class="status info">此文档已截断，仅显示开头内容。</div>`
+            : "";
+        if (isMarkdownDocumentPath(documentPath)) {
+            return `${truncation}<div class="document markdown">${renderRelayDocumentHtml(content.content)}</div>`;
+        }
+        return `${truncation}<pre class="document">${escapeHtml(content.content)}</pre>`;
+    }
+}
+/** Reload glyph matching the app's own refresh control (AppRefreshControl). */
+function refreshIconSvg() {
+    return `
+    <svg viewBox="0 0 24 24" aria-hidden="true" focusable="false">
+      <path d="M20 6v5h-5"></path>
+      <path d="M4 18v-5h5"></path>
+      <path d="M18.2 9A7 7 0 0 0 6.1 6.8L4 9"></path>
+      <path d="M5.8 15a7 7 0 0 0 12.1 2.2L20 15"></path>
+    </svg>
+  `;
+}
+function contextKey(context) {
+    return `${context.machine.id}:${context.workspace.projectId}:${context.workspace.id}`;
+}
+function documentName(path) {
+    return path.slice(path.lastIndexOf("/") + 1);
+}
+function renderEmptyState() {
+    return `
+    <div class="empty-state">
+      <strong>此工作区中没有中继。</strong>
+      <p>中继包存放在 <code>${escapeHtml(RELAYS_ROOT)}/&lt;name&gt;/</code>，此工作区目前还没有中继包。</p>
+    </div>
+  `;
+}
+function renderErrorState(message, detail) {
+    return `<div class="status error"><strong>${escapeHtml(message)}</strong><pre>${escapeHtml(detail)}</pre></div>`;
+}
+function relaysStyles() {
+    return `
+    <style>
+      :host { display: contents; }
+      /* Toolbar and tab strip are panel chrome: they must never flex-shrink
+         (the app container is a fixed-height flex column; with shrink enabled
+         the viewer's huge content basis starves them down to a sliver once a
+         tall document renders). The viewer absorbs all shrinking instead. */
+      .toolbar { flex: 0 0 auto; display: flex; align-items: center; justify-content: space-between; gap: 8px; padding: 10px 12px; border-bottom: 1px solid var(--pi-border-muted); }
+      .toolbar-actions { display: inline-flex; align-items: center; flex-wrap: nowrap; justify-content: flex-end; gap: 8px; min-width: 0; }
+      .relay-name { min-width: 0; color: var(--pi-text-secondary); overflow-wrap: anywhere; }
+      /* Bottom padding (not viewer margin) so the gap below the tabs persists
+         when the viewer's content scrolls up against its top edge. */
+      .document-tabs { flex: 0 0 auto; display: flex; flex-wrap: nowrap; gap: 6px; padding: 8px 12px; overflow-x: auto; overflow-y: hidden; overscroll-behavior-x: contain; scrollbar-width: thin; }
+      .viewer { flex: 1 1 auto; box-sizing: border-box; display: grid; align-content: start; gap: 12px; min-height: 0; overflow: auto; padding: 12px; }
+      /* Grid children default to min-width: auto; without these caps a wide code
+         block or table would silently stretch the whole viewer track. */
+      .viewer > * { box-sizing: border-box; min-width: 0; max-width: 100%; }
+      button, select { border: 1px solid var(--pi-border); border-radius: 7px; background: var(--pi-surface); color: var(--pi-text); font: inherit; }
+      button { cursor: pointer; padding: 6px 10px; }
+      button.icon-button { flex: 0 0 auto; display: inline-grid; place-items: center; width: 30px; height: 30px; padding: 0; }
+      button.icon-button svg { width: 16px; height: 16px; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; pointer-events: none; }
+      select { min-width: 0; max-width: 240px; padding: 5px 6px; }
+      .document-tab { flex: 0 0 auto; white-space: nowrap; font-size: 12px; padding: 4px 10px; }
+      .document-tab.active { border-color: var(--pi-accent-border); background: var(--pi-accent); color: var(--pi-bg); }
+      code, pre { border: 1px solid var(--pi-border-muted); border-radius: 6px; background: var(--pi-bg); color: var(--pi-text-secondary); font: 12px ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+      code { padding: 2px 5px; }
+      pre { margin: 0; overflow: auto; padding: 8px; white-space: pre-wrap; overflow-wrap: anywhere; }
+      .document.markdown { line-height: 1.5; overflow-wrap: anywhere; }
+      .document.markdown p, .document.markdown ul, .document.markdown ol, .document.markdown pre, .document.markdown blockquote, .document.markdown .table-scroll { margin: 0 0 10px; }
+      .document.markdown > :last-child { margin-bottom: 0; }
+      .document.markdown h1, .document.markdown h2, .document.markdown h3, .document.markdown h4 { line-height: 1.25; margin: 14px 0 8px; }
+      .document.markdown h1:first-child, .document.markdown h2:first-child, .document.markdown h3:first-child, .document.markdown h4:first-child { margin-top: 0; }
+      .document.markdown h1 { font-size: 18px; }
+      .document.markdown h2 { font-size: 16px; }
+      .document.markdown h3 { font-size: 14px; }
+      .document.markdown h4 { font-size: 13px; }
+      .document.markdown ul, .document.markdown ol { padding-left: 22px; }
+      .document.markdown li + li { margin-top: 3px; }
+      .document.markdown pre { white-space: pre; overflow-wrap: normal; }
+      .document.markdown pre code { border: 0; background: transparent; padding: 0; }
+      .document.markdown img { box-sizing: border-box; max-width: 100%; }
+      .document.markdown blockquote { border-left: 3px solid var(--pi-border-muted); color: var(--pi-muted); padding-left: 10px; }
+      .document.markdown a { color: var(--pi-accent); }
+      .document.markdown .table-scroll { max-width: 100%; overflow-x: auto; }
+      /* Cells wrap at word boundaries only: a wide table keeps its natural width
+         and scrolls inside .table-scroll instead of being squeezed unreadably. */
+      .document.markdown table { border-collapse: collapse; overflow-wrap: normal; }
+      .document.markdown th, .document.markdown td { border: 1px solid var(--pi-border-muted); padding: 4px 8px; }
+      .status pre { margin-top: 8px; }
+      .muted { color: var(--pi-muted); }
+      .empty-state { border: 1px dashed var(--pi-border-muted); border-radius: 8px; color: var(--pi-muted); padding: 12px; }
+      .empty-state p { margin: 6px 0 0; }
+      .status { border: 1px solid var(--pi-border); border-radius: 8px; padding: 10px; }
+      .status.info { border-color: var(--pi-accent-border); background: var(--pi-bg-overlay-soft); }
+      .status.error { border-color: var(--pi-danger); color: var(--pi-danger); }
+      .empty { padding: 16px; color: var(--pi-muted); }
+    </style>
+  `;
+}
+function escapeHtml(value) {
+    return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeAttr(value) {
+    return escapeHtml(value).replaceAll('"', "&quot;");
+}

package/dist/pi-web-plugins/relays/vendor/README.md

@@ -0,0 +1,24 @@
+# Vendored dependencies
+
+## marked (`marked.esm.js`)
+
+- **Source:** `node_modules/marked/lib/marked.esm.js` — marked v18.0.6, the
+  version the repo pins (`"marked": "^18.0.6"` in the root `package.json`).
+- **License:** MIT — copyright (c) 2018-2026 MarkedJS, (c) 2011-2018
+  Christopher Jeffrey. The attribution header at the top of `marked.esm.js` is
+  preserved; see also `node_modules/marked/LICENSE.md`.
+- **Why vendored:** bundled plugins load in the browser as standalone ES
+  modules and cannot resolve bare package specifiers. The plugin therefore
+  ships the exact marked build the repo already depends on, rather than
+  hand-rolling a markdown subset or adding a markdown helper to the plugin API.
+- **Local modification:** the trailing `//# sourceMappingURL=marked.esm.js.map`
+  comment was removed because the (much larger) source map is not vendored.
+  Everything else is byte-identical to the published file.
+- **`marked.esm.d.ts`** is a hand-written minimal declaration covering only the
+  surface `markdownDocument.ts` uses. The plugin build
+  (`scripts/build-plugins.mjs`) skips `.d.ts` files and copies `.js` assets
+  verbatim, so the vendored module ships as-is.
+
+**Updating:** after a `marked` upgrade in the root `package.json`, copy the new
+`node_modules/marked/lib/marked.esm.js` here, re-apply the sourceMappingURL
+removal, and update this note.