@vincenthanxiaodu/pi-web 1.202608.1

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

@@ -0,0 +1,222 @@
+// Generated from pi-web-plugins/info/infoInternals.ts. Do not edit directly.
+// Implementation details of the bundled Info plugin.
+//
+// This file is NOT part of the plugin skeleton. If you copied the Info plugin
+// as a starting point for your own plugin, replace everything here with your
+// own content — the plugin contract (metadata and contribution definitions)
+// lives in pi-web-plugin.ts.
+export function componentHealth(component) {
+    if (!component.available)
+        return "unavailable";
+    if (component.stale)
+        return "restart needed";
+    return "current";
+}
+export function formatVersion(version) {
+    return version === undefined || version === "" ? "unknown" : version;
+}
+export function installationLabel(installation) {
+    if (installation === undefined)
+        return "installation unknown";
+    if (installation.kind === "pi-package") {
+        const scope = installation.scope === undefined ? "" : ` · ${installation.scope}`;
+        const source = installation.source ?? "Pi package";
+        return `${source}${scope}`;
+    }
+    if (installation.kind === "npm-global")
+        return "global npm package";
+    if (installation.kind === "local")
+        return "local checkout";
+    if (installation.kind === "docker")
+        return installation.dockerMode === "dev" ? "Docker development runtime" : "Docker runtime";
+    return "installation unknown";
+}
+export function machineKindLabel(kind) {
+    return kind === "local" ? "local machine" : "remote machine";
+}
+export function releaseSummary(release) {
+    if (release.updateAvailable) {
+        return release.latestVersion === undefined || release.latestVersion === ""
+            ? "Update available"
+            : `Update available: ${release.latestVersion}`;
+    }
+    if (release.error !== undefined && release.error !== "")
+        return `Update check failed: ${release.error}`;
+    if (release.skipped === true)
+        return "Update check skipped";
+    return "Up to date";
+}
+/** One-line component summary used by the panel rows and the clipboard diagnostics. */
+export function componentDetails(component) {
+    const parts = [
+        `running ${formatVersion(component.runtimeVersion)}`,
+        `installed ${formatVersion(component.installedVersion)}`,
+        `pi ${formatVersion(component.piVersion)}`,
+        componentHealth(component),
+        installationLabel(component.installation),
+    ];
+    if (component.installation?.path !== undefined && component.installation.path !== "")
+        parts.push(component.installation.path);
+    if (component.error !== undefined && component.error !== "")
+        parts.push(`error: ${component.error}`);
+    return parts.join(" · ");
+}
+/** Note shown when the session daemon runs a different Pi version than the web process. */
+export function piVersionDriftNote(web, sessiond) {
+    if (!sessiond.available)
+        return undefined;
+    if (web.piVersion === undefined || sessiond.piVersion === undefined)
+        return undefined;
+    return web.piVersion === sessiond.piVersion ? undefined : `session daemon running ${formatVersion(sessiond.piVersion)}`;
+}
+export function workspaceFlags(workspace) {
+    return [
+        workspace.provider === undefined ? "folder workspace" : `provider: ${workspace.provider.pluginId}`,
+        workspace.isMain ? "main workspace" : undefined,
+    ].filter((flag) => flag !== undefined);
+}
+/** Plain-text status block suitable for pasting into a bug report. */
+export function diagnosticsSummary({ status, machine, workspace }) {
+    const lines = ["PI WEB diagnostics"];
+    if (status === undefined) {
+        lines.push("Status: unavailable");
+    }
+    else {
+        lines.push(`Package: ${status.packageName}`);
+        lines.push(`${status.components.web.label}: ${componentDetails(status.components.web)}`);
+        lines.push(`${status.components.sessiond.label}: ${componentDetails(status.components.sessiond)}`);
+        const checked = status.release.checkedAt === undefined || status.release.skipped === true ? "" : ` (checked ${status.release.checkedAt})`;
+        lines.push(`Release: ${releaseSummary(status.release)}${checked}`);
+        lines.push(`Status generated: ${status.generatedAt}`);
+    }
+    if (machine !== undefined)
+        lines.push(`Machine: ${machine.name} (${machineKindLabel(machine.kind)})`);
+    if (workspace === undefined) {
+        lines.push("Workspace: none selected");
+    }
+    else {
+        lines.push(`Workspace: ${workspace.label} — ${workspace.path} (${workspaceFlags(workspace).join(", ")})`);
+    }
+    return lines.join("\n");
+}
+/** Action body: copy the diagnostics summary for the current runtime context. */
+export async function copyDiagnostics(context) {
+    const summary = diagnosticsSummary({
+        status: context.state.piWebStatus,
+        machine: context.state.selectedMachine,
+        workspace: context.state.selectedWorkspace,
+    });
+    await navigator.clipboard.writeText(summary);
+}
+function renderComponent(html, component) {
+    const health = componentHealth(component);
+    return html `
+    <div class="info-component">
+      <strong>${component.label}</strong>
+      <span class=${health === "current" ? "info-health-ok" : "info-health-attention"}>${health}</span>
+      <small>${componentDetails(component)}</small>
+    </div>
+  `;
+}
+function renderStatusSection(html, status) {
+    if (status === undefined) {
+        return html `
+      <section>
+        <strong>PI WEB</strong>
+        <p class="muted">PI WEB status is not available yet. It refreshes automatically in the background.</p>
+      </section>
+    `;
+    }
+    const web = status.components.web;
+    const driftNote = piVersionDriftNote(web, status.components.sessiond);
+    const messageCount = status.messages.length;
+    return html `
+    <section>
+      <strong>PI WEB</strong>
+      <div class="info-row">
+        <span>Version</span>
+        <span>${formatVersion(web.runtimeVersion)}</span>
+        ${web.installedVersion === undefined || web.installedVersion === web.runtimeVersion ? null : html `<small>installed ${formatVersion(web.installedVersion)}</small>`}
+      </div>
+      <div class="info-row">
+        <span>Pi</span>
+        <span>${formatVersion(web.piVersion)}</span>
+        ${driftNote === undefined ? null : html `<small>${driftNote}</small>`}
+      </div>
+      <div class="info-row">
+        <span>Package</span>
+        <span>${status.packageName}</span>
+      </div>
+      <div class="info-row">
+        <span>Installation</span>
+        <span>${installationLabel(web.installation)}</span>
+        ${web.installation?.path === undefined || web.installation.path === "" ? null : html `<small>${web.installation.path}</small>`}
+      </div>
+      <div class="info-row">
+        <span>Release</span>
+        <span>${releaseSummary(status.release)}</span>
+        ${status.release.checkedAt === undefined || status.release.skipped === true ? null : html `<small>checked ${status.release.checkedAt}</small>`}
+      </div>
+      ${messageCount === 0 ? null : html `<p class="muted">${String(messageCount)} status ${messageCount === 1 ? "message" : "messages"} — open the Updates tab for details.</p>`}
+      <p class="muted">Status generated ${status.generatedAt}</p>
+    </section>
+    <section>
+      <strong>Services</strong>
+      ${renderComponent(html, status.components.web)}
+      ${renderComponent(html, status.components.sessiond)}
+    </section>
+  `;
+}
+function renderMachineSection(html, machine) {
+    return html `
+    <section>
+      <strong>Machine</strong>
+      <div class="info-row">
+        <span>Name</span>
+        <span>${machine.name}</span>
+      </div>
+      <div class="info-row">
+        <span>Type</span>
+        <span>${machineKindLabel(machine.kind)}</span>
+      </div>
+    </section>
+  `;
+}
+function renderWorkspaceSection(html, workspace) {
+    return html `
+    <section>
+      <strong>Workspace</strong>
+      <div class="info-row">
+        <span>Name</span>
+        <span>${workspace.label}</span>
+      </div>
+      <div class="info-row">
+        <span>Path</span>
+        <span class="info-path">${workspace.path}</span>
+        ${workspaceFlags(workspace).length === 0 ? null : html `<small>${workspaceFlags(workspace).join(" · ")}</small>`}
+      </div>
+    </section>
+  `;
+}
+/** Panel body: render the Info tab for the current workspace panel context. */
+export function renderInfoPanel(html, context) {
+    return html `
+    <style>
+      .viewer.info-status { flex: 1 1 auto; min-height: 0; box-sizing: border-box; display: flex; flex-direction: column; gap: 14px; padding: 12px; overflow-y: auto; overflow-x: hidden; }
+      .viewer.info-status section { flex: 0 0 auto; min-width: 0; display: grid; gap: 8px; align-content: start; }
+      .viewer.info-status p { margin: 0; }
+      .info-row { display: grid; grid-template-columns: minmax(90px, auto) minmax(0, 1fr); gap: 3px 10px; border-bottom: 1px solid var(--pi-border-muted); padding: 6px 0; overflow-wrap: anywhere; }
+      .info-row small { grid-column: 1 / -1; color: var(--pi-muted); }
+      .info-component { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 3px 10px; border-bottom: 1px solid var(--pi-border-muted); padding: 6px 0; }
+      .info-component small { grid-column: 1 / -1; color: var(--pi-muted); overflow-wrap: anywhere; }
+      .info-health-ok { color: var(--pi-success); }
+      .info-health-attention { color: var(--pi-warning); }
+    </style>
+    <section class="toolbar"><strong>Info</strong></section>
+    <section class="viewer info-status">
+      ${renderStatusSection(html, context.state?.piWebStatus)}
+      ${renderMachineSection(html, context.machine)}
+      ${renderWorkspaceSection(html, context.workspace)}
+    </section>
+  `;
+}

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

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

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

@@ -0,0 +1,48 @@
+// 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: 2,
+    name: "Info Plugin",
+    activate: ({ html, svg }) => ({
+        contributions: {
+            actions: [
+                {
+                    id: "copy-diagnostics",
+                    title: "Copy PI WEB Diagnostics",
+                    description: "Copy version, installation, and status details for this machine, ready to paste into a bug report",
+                    group: "Info",
+                    run: (context) => copyDiagnostics(context),
+                },
+            ],
+            workspaceLabels: [
+                {
+                    id: "workspace.kind-label",
+                    order: 100,
+                    items: (context) => [{ type: "text", text: context.workspace.provider?.pluginId ?? "folder", title: context.workspace.path }],
+                },
+            ],
+            workspacePanels: [
+                {
+                    id: "workspace.info",
+                    title: "Info",
+                    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) => renderInfoPanel(html, context),
+                },
+            ],
+        },
+    }),
+};
+export default plugin;

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", "Table");
+        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", "browserRoot": ".", "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: 2,
+    name: "Relays",
+    activate: ({ runtimePluginId, html, svg }) => {
+        defineRelaysPanelElement();
+        return {
+            contributions: {
+                actions: [
+                    {
+                        id: "workspace.open-relays",
+                        title: "Open Workspace Relays",
+                        description: `Open the workspace Relays tab. Relays live in ${RELAYS_ROOT}.`,
+                        group: "Workspace",
+                        enabled: (context) => context.state.selectedWorkspace !== undefined,
+                        run: (context) => {
+                            if (context.state.selectedWorkspace === undefined)
+                                return;
+                            context.selectWorkspaceTool(`${runtimePluginId}:workspace.relays`);
+                        },
+                    },
+                ],
+                workspacePanels: [
+                    {
+                        id: "workspace.relays",
+                        title: "Relays",
+                        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,228 @@
+// 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"];
+/**
+ * Deepest node depth listed below the relay root; direct children of the relay
+ * root are depth 0. Children of a directory at this depth are skipped and the
+ * listing is flagged partial instead of walking arbitrarily deep trees.
+ */
+export const MAX_RELAY_TREE_DEPTH = 5;
+/** Most documents listed across one relay; extras are skipped and the listing is flagged partial. */
+export const MAX_RELAY_DOCUMENTS = 200;
+/** Most directories walked in one relay; extras stay listed but unexplored and the listing is flagged partial. */
+export const MAX_RELAY_DIRECTORIES = 50;
+// 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 document tree. At the relay root the anchor documents come
+ * first (status.md, charter.md, log.md); at every level files sort
+ * alphabetically before directories. Symlinks are never followed. Never
+ * rejects.
+ */
+export async function listRelayDocumentTree(files, relayPath) {
+    let rootListing;
+    try {
+        rootListing = await files.listFiles(relayPath);
+    }
+    catch (error) {
+        return fileAccessFailure(error);
+    }
+    const state = { documentCount: 0, directoryCount: 0, partial: rootListing.truncated };
+    const tree = await walkListing(files, rootListing, relayPath, 0, state);
+    return { kind: "loaded", tree, documentCount: state.documentCount, partial: state.partial };
+}
+/** 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);
+}
+/** The document a relay opens on: the depth-first first file (root anchors sort first, so status.md wins when present). */
+export function defaultRelayDocument(tree) {
+    for (const node of tree) {
+        if (node.kind === "file")
+            return node;
+        const nested = defaultRelayDocument(node.children);
+        if (nested !== undefined)
+            return nested;
+    }
+    return undefined;
+}
+/** All file nodes in tree order, depth-first. */
+export function flattenRelayTree(tree) {
+    const files = [];
+    const visit = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind === "file")
+                files.push(node);
+            else
+                visit(node.children);
+        }
+    };
+    visit(tree);
+    return files;
+}
+/** Directory paths of every directory in the tree; used to prune stale expansion state. */
+export function collectDirectoryPaths(tree) {
+    const paths = new Set();
+    const visit = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind !== "directory")
+                continue;
+            paths.add(node.path);
+            visit(node.children);
+        }
+    };
+    visit(tree);
+    return paths;
+}
+/** Directory paths containing the given file, from the relay root down; empty when the file is not in the tree. */
+export function ancestorDirectoryPaths(tree, filePath) {
+    const chain = [];
+    const visit = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind === "file") {
+                if (node.path === filePath)
+                    return true;
+                continue;
+            }
+            chain.push(node.path);
+            if (visit(node.children))
+                return true;
+            chain.pop();
+        }
+        return false;
+    };
+    return visit(tree) ? chain : [];
+}
+/**
+ * Build the ordered children of one already-fetched directory listing.
+ * Subdirectories are walked in parallel; a subdirectory whose own listing
+ * fails contributes an empty node and flags the tree partial rather than
+ * failing the whole relay.
+ */
+async function walkListing(files, listing, relayPath, depth, state) {
+    // Symlink entries are intentionally never followed.
+    const fileEntries = listing.entries.filter((entry) => entry.type === "file");
+    const directoryEntries = listing.entries.filter((entry) => entry.type === "directory");
+    let fileNodes = orderFileEntries(fileEntries, depth === 0).map((entry) => toFileNode(entry, relayPath, depth));
+    const remaining = MAX_RELAY_DOCUMENTS - state.documentCount;
+    if (fileNodes.length > remaining) {
+        fileNodes = fileNodes.slice(0, Math.max(0, remaining));
+        state.partial = true;
+    }
+    state.documentCount += fileNodes.length;
+    const directories = await Promise.all([...directoryEntries].sort(compareByName).map(async (entry) => {
+        const node = {
+            kind: "directory",
+            name: entry.name,
+            path: entry.path,
+            relativePath: relativePathOf(entry.path, relayPath),
+            depth,
+            children: [],
+        };
+        if (depth >= MAX_RELAY_TREE_DEPTH) {
+            state.partial = true;
+            return node;
+        }
+        // The count is bumped synchronously before any await, so the parallel
+        // walk below stays deterministic in sorted order.
+        if (state.directoryCount >= MAX_RELAY_DIRECTORIES) {
+            state.partial = true;
+            return node;
+        }
+        state.directoryCount += 1;
+        try {
+            const subListing = await files.listFiles(entry.path);
+            if (subListing.truncated)
+                state.partial = true;
+            node.children = await walkListing(files, subListing, relayPath, depth + 1, state);
+        }
+        catch {
+            state.partial = true;
+        }
+        return node;
+    }));
+    return [...fileNodes, ...directories];
+}
+/** At the relay root the anchor documents lead; deeper levels are simply alphabetical. */
+function orderFileEntries(entries, isRelayRoot) {
+    return [...entries].sort(isRelayRoot ? compareRootFiles : compareByName);
+}
+function compareRootFiles(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 compareByName(left, right) {
+    return left.name.localeCompare(right.name);
+}
+function toRelaySummary(entry) {
+    return { name: entry.name, path: entry.path, modifiedAt: entry.modifiedAt };
+}
+function toFileNode(entry, relayPath, depth) {
+    return {
+        kind: "file",
+        name: entry.name,
+        path: entry.path,
+        relativePath: relativePathOf(entry.path, relayPath),
+        depth,
+        modifiedAt: entry.modifiedAt,
+    };
+}
+/** Entry paths from the file API should sit under the relay root; fall back to the file name if not. */
+function relativePathOf(path, relayPath) {
+    const prefix = `${relayPath}/`;
+    return path.startsWith(prefix) ? path.slice(prefix.length) : path.slice(path.lastIndexOf("/") + 1);
+}
+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 fileAccessFailure(error) {
+    if (error instanceof Error && missingListingErrorMessages.has(error.message))
+        return { kind: "missing" };
+    return { kind: "unavailable", detail: error instanceof Error ? error.message : String(error) };
+}