ccdesk 0.2.2 → 0.2.3

package/dist/ui/index.html

@@ -6,7 +6,7 @@
     <meta name="color-scheme" content="light dark" />
     <title>ccdesk</title>
     <link rel="icon" href="/logo.png" type="image/png" />
-    <script type="module" crossorigin src="/assets/index-Dg9dxngR.js"></script>
+    <script type="module" crossorigin src="/assets/index-CH1HoC38.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D5XqP5c_.css">
   </head>
   <body>

package/dist/view/diff.d.ts

@@ -0,0 +1,16 @@
+type DiffLine = {
+    kind: "same" | "add" | "remove";
+    text: string;
+};
+/**
+ * Line diff: lines shared at the start and end are matched directly, and the changed middle by
+ * longest common subsequence, unless it is too large for that.
+ */
+export declare function diffLines(before: string, after: string): DiffLine[];
+type DiffRow = DiffLine | {
+    kind: "skip";
+    count: number;
+};
+/** Keeps `context` unchanged lines around each change and folds longer unchanged runs. */
+export declare function withContext(lines: DiffLine[], context?: number): DiffRow[];
+export {};

package/dist/view/diff.js

@@ -0,0 +1,85 @@
+function splitLines(text) {
+    return text === "" ? [] : text.replace(/\n$/, "").split("\n");
+}
+/** Above this many line pairs the changed middle is shown as removed, then added. */
+const MAX_CELLS = 4_000_000;
+/**
+ * Line diff: lines shared at the start and end are matched directly, and the changed middle by
+ * longest common subsequence, unless it is too large for that.
+ */
+export function diffLines(before, after) {
+    const a = splitLines(before);
+    const b = splitLines(after);
+    let start = 0;
+    while (start < a.length && start < b.length && a[start] === b[start])
+        start++;
+    let end = 0;
+    while (end < a.length - start &&
+        end < b.length - start &&
+        a[a.length - 1 - end] === b[b.length - 1 - end])
+        end++;
+    const same = (text) => ({ kind: "same", text });
+    return [
+        ...a.slice(0, start).map(same),
+        ...middle(a.slice(start, a.length - end), b.slice(start, b.length - end)),
+        ...a.slice(a.length - end).map(same),
+    ];
+}
+function middle(a, b) {
+    if ((a.length + 1) * (b.length + 1) > MAX_CELLS)
+        return [
+            ...a.map((text) => ({ kind: "remove", text })),
+            ...b.map((text) => ({ kind: "add", text })),
+        ];
+    const width = b.length + 1;
+    // lcs[i * width + j] is the common length of a[i..] and b[j..].
+    const lcs = new Int32Array((a.length + 1) * width);
+    const at = (row, col) => lcs[row * width + col] ?? 0;
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            lcs[i * width + j] =
+                a[i] === b[j] ? at(i + 1, j + 1) + 1 : Math.max(at(i + 1, j), at(i, j + 1));
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            out.push({ kind: "same", text: a[i] ?? "" });
+            i++;
+            j++;
+        }
+        else if (j < b.length && (i === a.length || at(i, j + 1) > at(i + 1, j))) {
+            out.push({ kind: "add", text: b[j] ?? "" });
+            j++;
+        }
+        else {
+            out.push({ kind: "remove", text: a[i] ?? "" });
+            i++;
+        }
+    }
+    return out;
+}
+/** Keeps `context` unchanged lines around each change and folds longer unchanged runs. */
+export function withContext(lines, context = 3) {
+    // Distance to the nearest change, in lines, looking both ways.
+    const distance = lines.map((l) => (l.kind === "same" ? Number.POSITIVE_INFINITY : 0));
+    for (let i = 1; i < lines.length; i++)
+        distance[i] = Math.min(distance[i] ?? 0, (distance[i - 1] ?? 0) + 1);
+    for (let i = lines.length - 2; i >= 0; i--)
+        distance[i] = Math.min(distance[i] ?? 0, (distance[i + 1] ?? 0) + 1);
+    const out = [];
+    lines.forEach((line, i) => {
+        if ((distance[i] ?? 0) <= context) {
+            out.push(line);
+            return;
+        }
+        const last = out[out.length - 1];
+        if (last?.kind === "skip")
+            last.count++;
+        else
+            out.push({ kind: "skip", count: 1 });
+    });
+    return out;
+}

package/dist/view/format.d.ts

@@ -0,0 +1,17 @@
+/** Paths shown the way you read them: under your home folder as `~`. */
+export interface Formatter {
+    /** `/home/me/projects/app` → `~/projects/app`. */
+    tilde(path: string): string;
+    /** Path relative to `base` when inside it, otherwise the tilde form. */
+    relativeTo(path: string, base: string): string;
+    /** Every home path inside free text (a hook command, an MCP target) in its tilde form. */
+    tildeAll(text: string): string;
+    /** True for a file reached through a symlink into ~/.agents, which other coding agents read too. */
+    sharedWithAgents(realPath: string | undefined): boolean;
+}
+/** A formatter for `home`; with an empty home, paths are shown in full. */
+export declare function formatter(home: string): Formatter;
+export declare function ago(iso: string | null): string;
+/** A one-line value for a table cell: JSON, minus the quotes on plain keys, with spaces to read by. */
+export declare function preview(value: unknown): string;
+export declare function plural(n: number, word: string, many?: string): string;

package/dist/view/format.js

@@ -0,0 +1,47 @@
+/** True when `path` is `base` or inside it, with / or Windows \\ separators. */
+function under(path, base) {
+    return path.startsWith(`${base}/`) || path.startsWith(`${base}\\`);
+}
+/** A formatter for `home`; with an empty home, paths are shown in full. */
+export function formatter(home) {
+    const tilde = (path) => home && (path === home || under(path, home)) ? `~${path.slice(home.length)}` : path;
+    return {
+        tilde,
+        relativeTo: (path, base) => (under(path, base) ? path.slice(base.length + 1) : tilde(path)),
+        tildeAll: (text) => home ? text.replaceAll(`${home}/`, "~/").replaceAll(`${home}\\`, "~\\") : text,
+        sharedWithAgents: (realPath) => realPath !== undefined && /^~[/\\]\.agents[/\\]/.test(tilde(realPath)),
+    };
+}
+export function ago(iso) {
+    if (!iso)
+        return "never";
+    const seconds = (Date.now() - new Date(iso).getTime()) / 1000;
+    if (seconds < 90)
+        return "just now";
+    if (seconds < 3600)
+        return `${Math.round(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.round(seconds / 3600)}h ago`;
+    if (seconds < 86400 * 60)
+        return `${Math.round(seconds / 86400)}d ago`;
+    return new Date(iso).toLocaleDateString();
+}
+const PLAIN_KEY = /^[A-Za-z_$][\w$@.-]*$/;
+/** A one-line value for a table cell: JSON, minus the quotes on plain keys, with spaces to read by. */
+export function preview(value) {
+    if (typeof value === "string")
+        return value;
+    return compact(value);
+}
+function compact(value) {
+    if (Array.isArray(value))
+        return `[${value.map(compact).join(", ")}]`;
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value).map(([k, v]) => `${PLAIN_KEY.test(k) ? k : JSON.stringify(k)}: ${compact(v)}`);
+        return entries.length ? `{ ${entries.join(", ")} }` : "{}";
+    }
+    return JSON.stringify(value) ?? String(value);
+}
+export function plural(n, word, many = `${word}s`) {
+    return `${n} ${n === 1 ? word : many}`;
+}

package/dist/view/index.d.ts

@@ -0,0 +1,11 @@
+export { diffLines, withContext } from "./diff.ts";
+export { ago, type Formatter, formatter, plural, preview } from "./format.ts";
+export { LINES, type Line, lineName } from "./lines.ts";
+export { valueHere } from "./sections/catalog.ts";
+export { MATCH_KIND } from "./path-test.ts";
+export { buildRows, SECTIONS } from "./sections/index.ts";
+export { isSuggested, unused } from "./sections/permissions.ts";
+export { callsOf, outcome } from "./sections/tools.ts";
+export type { Column, EntryKind, Facet, Row, RowOf, SectionId, ViewContext, ViewSection, } from "./sections/types.ts";
+export { type FieldKind, fieldKind, valuesIn } from "./settings.ts";
+export { sessionsHere, suggestedRules } from "./usage.ts";

package/dist/view/index.js

@@ -0,0 +1,13 @@
+// What a front end shows from a DirectoryView, without React or the browser: each section's rows,
+// columns, filter text and labels, and the formatting they use. The page in src/ui adds the cells
+// and the inspector; a terminal UI can draw the same rows. See ARCHITECTURE.md.
+export { diffLines, withContext } from "./diff.js";
+export { ago, formatter, plural, preview } from "./format.js";
+export { LINES, lineName } from "./lines.js";
+export { valueHere } from "./sections/catalog.js";
+export { MATCH_KIND } from "./path-test.js";
+export { buildRows, SECTIONS } from "./sections/index.js";
+export { isSuggested, unused } from "./sections/permissions.js";
+export { callsOf, outcome } from "./sections/tools.js";
+export { fieldKind, valuesIn } from "./settings.js";
+export { sessionsHere, suggestedRules } from "./usage.js";

package/dist/view/lines.d.ts

@@ -0,0 +1,9 @@
+import { type Scope } from "../shared/types.ts";
+/** A scope on the route strip. Auto memory and plugins get their own lines. */
+export type Line = Scope | "memory" | "plugin";
+export declare const LINES: Array<{
+    line: Line;
+    letter: string;
+    name: string;
+}>;
+export declare function lineName(line: Line): string;

package/dist/view/lines.js

@@ -0,0 +1,12 @@
+import {} from "../shared/types.js";
+export const LINES = [
+    { line: "managed", letter: "M", name: "Managed" },
+    { line: "user", letter: "U", name: "User" },
+    { line: "project", letter: "P", name: "Project" },
+    { line: "local", letter: "L", name: "Local" },
+    { line: "memory", letter: "A", name: "Auto memory" },
+    { line: "plugin", letter: "X", name: "Plugin" },
+];
+export function lineName(line) {
+    return LINES.find((l) => l.line === line)?.name ?? line;
+}

package/dist/view/path-test.d.ts

@@ -0,0 +1,3 @@
+import { type PathMatch } from "../shared/types.ts";
+/** What each kind of path-test match is called, on the page and by `ccdesk explain`. */
+export declare const MATCH_KIND: Record<PathMatch["kind"], string>;

package/dist/view/path-test.js

@@ -0,0 +1,7 @@
+import {} from "../shared/types.js";
+/** What each kind of path-test match is called, on the page and by `ccdesk explain`. */
+export const MATCH_KIND = {
+    rule: "path rule",
+    skill: "skill",
+    nested: "folder instructions",
+};

package/dist/view/sections/catalog.d.ts

@@ -0,0 +1,9 @@
+import { type DirectoryView, type EffectiveSetting } from "../../shared/types.ts";
+/** The value a key has here: a top-level setting, or a field inside one such as sandbox.network.allowedDomains. */
+export declare function valueHere(view: DirectoryView, key: string): {
+    set?: EffectiveSetting;
+    value?: unknown;
+};
+/** Docs Markdown kept to one line of plain text, for a table cell. */
+export declare function plain(text: string): string;
+export declare const catalog: import("./types.ts").ViewSection<import("./types.ts").Row>;

package/dist/view/sections/catalog.js

@@ -0,0 +1,47 @@
+import {} from "../../shared/types.js";
+import {} from "../lines.js";
+import { defineSection } from "./types.js";
+/** The value a key has here: a top-level setting, or a field inside one such as sandbox.network.allowedDomains. */
+export function valueHere(view, key) {
+    const [top = "", ...path] = key.split(".");
+    const set = view.effective.find((s) => s.key === top && s.from.length > 0);
+    if (!set)
+        return {};
+    let value = set.value;
+    for (const field of path)
+        value =
+            typeof value === "object" && value !== null
+                ? value[field]
+                : undefined;
+    return value === undefined ? {} : { set, value };
+}
+/** Docs Markdown kept to one line of plain text, for a table cell. */
+export function plain(text) {
+    return text.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/[`*]/g, "");
+}
+export const catalog = defineSection({
+    id: "catalog",
+    title: "All settings",
+    rows: (view, { reference }) => reference.catalog.map((item) => {
+        const { set } = valueHere(view, item.key);
+        const line = set?.from.at(-1) ?? null;
+        return { id: `cat:${item.key}`, section: "catalog", line, item, ...(set ? { set } : {}) };
+    }),
+    columns: [
+        { label: "", sort: (r) => (r.set ? 0 : 1) },
+        { label: "Setting", sort: (r) => r.item.key },
+        { label: "What it does" },
+        { label: "Files", sort: (r) => -r.item.scopes.length },
+        { label: "Here", sort: (r) => (r.set ? 0 : 1) },
+    ],
+    empty: () => "ccdesk has no list of Claude Code's settings.",
+    text: (row) => `${row.item.key} ${plain(row.item.summary)} ${row.item.category}`,
+    label: (row) => `setting ${row.item.key} (all settings)`,
+    heading: (row) => row.item.key,
+    facet: {
+        label: "Filter settings by area",
+        of: (row) => row.item.category,
+        // Categories in the order the settings reference lists them.
+        order: ({ reference }) => [...new Set(reference.catalog.map((s) => s.category))],
+    },
+});

package/dist/view/sections/extensions.d.ts

@@ -0,0 +1 @@
+export declare const extensions: import("./types.ts").ViewSection<import("./types.ts").Row>;

package/dist/view/sections/extensions.js

@@ -0,0 +1,48 @@
+import { defineSection } from "./types.js";
+const KINDS = ["agent", "skill", "command", "output style", "plugin"];
+export const extensions = defineSection({
+    id: "extensions",
+    title: "Agents, skills & plugins",
+    short: "Extensions",
+    rows: (view) => {
+        const inv = view.inventory;
+        const entries = [
+            ["agent", inv.agents],
+            ["skill", inv.skills],
+            ["command", inv.commands],
+            ["output style", inv.outputStyles],
+        ];
+        return [
+            ...entries.flatMap(([kind, list]) => list.map((item) => ({
+                id: `ent:${kind}:${item.path}`,
+                section: "extensions",
+                line: item.scope,
+                item,
+                kind,
+            }))),
+            ...inv.plugins.map((item) => ({
+                id: `plug:${item.id}`,
+                section: "extensions",
+                line: "plugin",
+                item,
+                kind: "plugin",
+            })),
+        ];
+    },
+    columns: [
+        { label: "", sort: (r) => r.line },
+        { label: "Kind", sort: (r) => KINDS.indexOf(r.kind) },
+        { label: "Name", sort: (r) => (r.kind === "plugin" ? r.item.id : (r.item.id ?? r.item.name)) },
+        { label: "Description" },
+    ],
+    empty: () => "No subagents, skills, commands or plugins.",
+    dimmed: (row) => row.kind === "plugin"
+        ? !row.item.enabled
+        : Boolean(row.item.shadowedBy || row.item.skipped) || row.item.override === "off",
+    text: (row) => row.kind === "plugin"
+        ? `plugin ${row.item.id}`
+        : `${row.kind} ${row.item.id ?? row.item.name} ${row.item.description}`,
+    label: (row) => row.kind === "plugin" ? `plugin ${row.item.id}` : `${row.kind} ${row.item.id ?? row.item.name}`,
+    heading: (row) => (row.kind === "plugin" ? row.item.id : (row.item.id ?? row.item.name)),
+    facet: { label: "Filter by kind", of: (row) => row.kind, order: () => KINDS },
+});

package/dist/view/sections/hooks.d.ts

@@ -0,0 +1 @@
+export declare const hooks: import("./types.ts").ViewSection<import("./types.ts").Row>;

package/dist/view/sections/hooks.js

@@ -0,0 +1,32 @@
+import { defineSection } from "./types.js";
+export const hooks = defineSection({
+    id: "hooks",
+    title: "Hooks",
+    rows: (view) => {
+        // Named by what the hook is, so a selection survives hooks added above it.
+        const seen = new Map();
+        return view.inventory.hooks.map((item) => {
+            const key = `hook:${item.sourcePath}:${item.event}:${item.matcher ?? ""}:${item.command}`;
+            const count = seen.get(key) ?? 0;
+            seen.set(key, count + 1);
+            return {
+                id: count === 0 ? key : `${key}:${count}`,
+                section: "hooks",
+                line: item.source,
+                item,
+            };
+        });
+    },
+    columns: [
+        { label: "", sort: (r) => r.item.source },
+        { label: "Event", sort: (r) => r.item.event },
+        { label: "Matcher", sort: (r) => r.item.matcher ?? "" },
+        { label: "Runs" },
+    ],
+    empty: () => "No hooks run here.",
+    dimmed: (row) => !row.item.active,
+    text: (row) => `${row.item.event} ${row.item.matcher ?? ""} ${row.item.command}`,
+    label: (row) => `${row.item.event} hook: ${row.item.command}`,
+    heading: (row) => `${row.item.event} hook`,
+    facet: { label: "Filter hooks by event", of: (row) => row.item.event },
+});

package/dist/view/sections/index.d.ts

@@ -0,0 +1,6 @@
+import { type DirectoryView } from "../../shared/types.ts";
+import { type Row, type ViewContext, type ViewSection } from "./types.ts";
+/** The sections of a directory page, in page order. */
+export declare const SECTIONS: ViewSection<Row>[];
+/** Every section's rows for one directory, in page order. */
+export declare function buildRows(view: DirectoryView, context: ViewContext): Row[];

package/dist/view/sections/index.js

@@ -0,0 +1,27 @@
+import {} from "../../shared/types.js";
+import { catalog } from "./catalog.js";
+import { extensions } from "./extensions.js";
+import { hooks } from "./hooks.js";
+import { instructions } from "./instructions.js";
+import { mcp } from "./mcp.js";
+import { memory } from "./memory.js";
+import { permissions } from "./permissions.js";
+import { settings } from "./settings.js";
+import { tools } from "./tools.js";
+import {} from "./types.js";
+/** The sections of a directory page, in page order. */
+export const SECTIONS = [
+    instructions,
+    settings,
+    permissions,
+    tools,
+    memory,
+    hooks,
+    mcp,
+    extensions,
+    catalog,
+];
+/** Every section's rows for one directory, in page order. */
+export function buildRows(view, context) {
+    return SECTIONS.flatMap((s) => s.rows(view, context));
+}

package/dist/view/sections/instructions.d.ts

@@ -0,0 +1,6 @@
+export declare const STATUS: {
+    readonly loaded: "loaded";
+    readonly "on-match": "on match";
+    readonly skipped: "skipped";
+};
+export declare const instructions: import("./types.ts").ViewSection<import("./types.ts").Row>;

package/dist/view/sections/instructions.js

@@ -0,0 +1,38 @@
+import { defineSection } from "./types.js";
+export const STATUS = { loaded: "loaded", "on-match": "on match", skipped: "skipped" };
+export const instructions = defineSection({
+    id: "instructions",
+    title: "Instructions",
+    rows: (view) => view.instructions.map((item, index) => ({
+        id: `ins:${item.path}`,
+        section: "instructions",
+        line: item.scope,
+        item,
+        order: index + 1,
+    })),
+    columns: [
+        { label: "#", sort: (r) => r.order },
+        { label: "" },
+        { label: "File", sort: (r) => r.item.path },
+        { label: "Status", sort: (r) => r.item.status },
+        { label: "Why" },
+        { label: "Lines", sort: (r) => r.item.lines },
+        { label: "Visibility", sort: (r) => r.item.visibility ?? "" },
+    ],
+    empty: () => "No CLAUDE.md, AGENTS.md or rules apply here.",
+    dimmed: (row) => row.item.status === "skipped",
+    text: (row) => `${row.item.path} ${row.item.reason}`,
+    label: (row, { format }) => format.tilde(row.item.path),
+    // The file and its folder, or the whole ~ path when that is as short: ~/.claude/CLAUDE.md is
+    // your user file, while .claude/CLAUDE.md would read as the project's.
+    heading: (row, { format }) => {
+        const short = format.tilde(row.item.path);
+        const parts = short.split(/[/\\]/);
+        return parts.length <= 3 ? short : parts.slice(-2).join("/");
+    },
+    facet: {
+        label: "Filter instructions by status",
+        of: (row) => STATUS[row.item.status],
+        order: () => Object.values(STATUS),
+    },
+});

package/dist/view/sections/mcp.d.ts

@@ -0,0 +1,3 @@
+import { type McpStatus } from "../../shared/types.ts";
+export declare const STATUS: Record<McpStatus, string>;
+export declare const mcp: import("./types.ts").ViewSection<import("./types.ts").Row>;

package/dist/view/sections/mcp.js

@@ -0,0 +1,38 @@
+import {} from "../../shared/types.js";
+import { defineSection } from "./types.js";
+export const STATUS = {
+    active: "configured",
+    pending: "needs approval",
+    shadowed: "overridden",
+    disabled: "turned off",
+    rejected: "rejected",
+    blocked: "blocked",
+    invalid: "invalid",
+};
+export const mcp = defineSection({
+    id: "mcp",
+    title: "MCP servers",
+    rows: (view) => view.inventory.mcpServers.map((item) => ({
+        id: `mcp:${item.scope}:${item.plugin ?? ""}:${item.name}`,
+        section: "mcp",
+        line: item.scope,
+        item,
+    })),
+    columns: [
+        { label: "", sort: (r) => r.item.scope },
+        { label: "Server", sort: (r) => r.item.name },
+        { label: "Transport", sort: (r) => r.item.transport },
+        { label: "Target" },
+        { label: "Status", sort: (r) => Object.keys(STATUS).indexOf(r.item.status) },
+    ],
+    empty: () => "No MCP servers are configured for this directory.",
+    dimmed: (row) => row.item.status !== "active",
+    text: (row) => `${row.item.name} ${row.item.target}`,
+    label: (row) => `MCP ${row.item.name}`,
+    heading: (row) => row.item.name,
+    facet: {
+        label: "Filter MCP servers by status",
+        of: (row) => STATUS[row.item.status],
+        order: () => Object.values(STATUS),
+    },
+});

package/dist/view/sections/memory.d.ts

@@ -0,0 +1 @@
+export declare const memory: import("./types.ts").ViewSection<import("./types.ts").Row>;

package/dist/view/sections/memory.js

@@ -0,0 +1,31 @@
+import {} from "../../shared/types.js";
+import { defineSection } from "./types.js";
+const MEMORY_TYPES = ["user", "feedback", "project", "reference", "unknown"];
+export const memory = defineSection({
+    id: "memory",
+    title: "Memory",
+    rows: (view) => view.memory.memories.map((item) => ({
+        id: `mem:${item.path}`,
+        section: "memory",
+        line: "memory",
+        item,
+    })),
+    columns: [
+        { label: "" },
+        { label: "Name", sort: (r) => r.item.name },
+        { label: "Type", sort: (r) => MEMORY_TYPES.indexOf(r.item.type) },
+        { label: "Description" },
+        {
+            label: "Checks",
+            sort: (r) => Number(!r.item.inIndex) * 10 + r.item.brokenLinks.length,
+        },
+        { label: "Updated", sort: (r) => r.item.mtime },
+    ],
+    empty: (view) => view.memory.index
+        ? "MEMORY.md is here, but no memory files."
+        : "Claude hasn't saved any memory for this directory yet.",
+    text: (row) => `${row.item.name} ${row.item.description} ${row.item.type} ${row.item.body}`,
+    label: (row) => `memory ${row.item.name}`,
+    heading: (row) => row.item.name,
+    facet: { label: "Filter memory by type", of: (row) => row.item.type, order: () => MEMORY_TYPES },
+});

package/dist/view/sections/permissions.d.ts

@@ -0,0 +1,17 @@
+import { type Permission, type Usage } from "../../shared/types.ts";
+import { type RowOf } from "./types.ts";
+type R = RowOf<"permissions">;
+export type Suggested = Extract<R, {
+    suggested: true;
+}>;
+export type Rule = Extract<Permission, {
+    kind: "rule";
+}>;
+export declare function isSuggested(row: R): row is Suggested;
+/**
+ * An allow rule in effect that covered none of the calls counted here. Ask rules are not flagged:
+ * they guard calls, so one that never fired is no reason to remove it.
+ */
+export declare function unused(rule: Permission, usage: Usage | null | undefined): rule is Rule;
+export declare const permissions: import("./types.ts").ViewSection<import("./types.ts").Row>;
+export {};