@manta-eu/horns-client 0.2.0 → 0.2.1

package/dist/app/nav.d.ts

@@ -0,0 +1,20 @@
+import type { LucideIcon } from "lucide-react";
+export type HornsNavItem = {
+    to: string;
+    label: string;
+    icon: LucideIcon;
+    /** Exact for a page that is one page, a prefix where the page has children. */
+    isCurrent: (pathname: string) => boolean;
+};
+export type HornsNavSection = {
+    label: string;
+    items: HornsNavItem[];
+};
+/**
+ * Where a person can go inside Horns, in one list.
+ *
+ * `AppShell` draws it as its sidebar, and a host that supplies a `shell` of its own draws it wherever its
+ * own chrome puts navigation — `manta/agents` renders it beside the page, the way Data Explorer does. Two
+ * renderings of one list, so a page added here cannot go missing from the other.
+ */
+export declare function hornsNavSections(): HornsNavSection[];

package/dist/app/nav.js

@@ -0,0 +1,34 @@
+import { Boxes, Columns3, LayoutGrid, ListChecks, Sigma } from "lucide-react";
+import { hornsPath, plansPath, rulesPath, shapesPath, showcasePath } from "./paths";
+const exact = (path) => (pathname) => pathname === path;
+const under = (path) => (pathname) => pathname.startsWith(path);
+/**
+ * Where a person can go inside Horns, in one list.
+ *
+ * `AppShell` draws it as its sidebar, and a host that supplies a `shell` of its own draws it wherever its
+ * own chrome puts navigation — `manta/agents` renders it beside the page, the way Data Explorer does. Two
+ * renderings of one list, so a page added here cannot go missing from the other.
+ */
+export function hornsNavSections() {
+    return [
+        {
+            label: "Horns",
+            items: [
+                { to: showcasePath(), label: "Showcase", icon: LayoutGrid, isCurrent: exact(showcasePath()) },
+                { to: hornsPath(), label: "Horns", icon: Columns3, isCurrent: exact(hornsPath()) },
+            ],
+        },
+        // The tools behind a Horn: for the people who build them, kept apart so it is not the first thing
+        // everyone else is offered.
+        {
+            label: "For builders",
+            items: [
+                { to: shapesPath(), label: "Data shapes", icon: Boxes, isCurrent: under(shapesPath()) },
+                // The other half of what the datastore knows: not what a thing is, but what Manta works out.
+                { to: rulesPath(), label: "Rules", icon: Sigma, isCurrent: under(rulesPath()) },
+                // What those rules drafted, and where a Horn is started from one.
+                { to: plansPath(), label: "Action plans", icon: ListChecks, isCurrent: under(plansPath()) },
+            ],
+        },
+    ];
+}

package/dist/app/routes.d.ts

@@ -1,3 +1,4 @@
+import type { ReactNode } from "react";
 /**
  * Horns' routes as `<Route>` children, for a host that splices them into its own `<Routes>`. A nested
  * `<Routes>` would rebase every path on its parent's match, so a host mounting Horns under a prefix would
@@ -5,8 +6,15 @@
  *
  * `catchAll` is for the host that gives Horns the whole URL space, as `mountHorns` does. A host with routes
  * of its own leaves it off and keeps its own 404.
+ *
+ * `shell` is the layout the listed pages draw inside, defaulting to Horns' own. A host that has a shell
+ * already passes it, and a Horn then reads as one of that host's pages rather than swapping the chrome for
+ * Horns'. It is a layout route's element, so it renders an `<Outlet />`; the Studio and a saved Horn ignore
+ * it, because each is a whole screen with nothing beside it.
  */
-export declare function hornsRoutes({ catchAll }?: {
+export type HornsRoutesOptions = {
     catchAll?: boolean;
-}): import("react").JSX.Element;
+    shell?: ReactNode;
+};
+export declare function hornsRoutes({ catchAll, shell }?: HornsRoutesOptions): import("react").JSX.Element;
 export declare function AppRoutes(): import("react").JSX.Element;

package/dist/app/routes.js

@@ -15,19 +15,11 @@ import { ShapeZooPage } from "./shape-zoo-page";
 import { ShapesPage } from "./shapes-page";
 import { ShowcasePage } from "./showcase-page";
 import { ReferencePage } from "./reference-page";
-/**
- * Horns' routes as `<Route>` children, for a host that splices them into its own `<Routes>`. A nested
- * `<Routes>` would rebase every path on its parent's match, so a host mounting Horns under a prefix would
- * push `d/:datastoreId/...` a segment too deep; spliced in, the paths are the ones `paths.ts` writes.
- *
- * `catchAll` is for the host that gives Horns the whole URL space, as `mountHorns` does. A host with routes
- * of its own leaves it off and keeps its own 404.
- */
-export function hornsRoutes({ catchAll = false } = {}) {
+export function hornsRoutes({ catchAll = false, shell } = {}) {
     return (
     // Here rather than at the mount: a host splicing these into its own router gets it too, and a Horn page
     // reads its variables through nuqs on every render — without an adapter that throws rather than degrades.
-    _jsxs(Route, { element: _jsx(NuqsAdapter, { children: _jsx(Outlet, {}) }), children: [_jsx(Route, { path: "horns/new", element: _jsx(NewHornPage, {}) }), _jsx(Route, { path: "horns/:slug", element: _jsx(HornPage, {}) }), _jsxs(Route, { element: _jsx(AppShell, {}), children: [_jsx(Route, { path: "horns", element: _jsx(HornsPage, {}) }), _jsx(Route, { path: "horns/:slug/view", element: _jsx(HornViewPage, {}) }), _jsx(Route, { path: "horns/showcase", element: _jsx(ShowcasePage, {}) }), _jsx(Route, { path: "horns/plans", element: _jsx(PlansPage, {}) }), _jsx(Route, { path: "horns/rules", element: _jsx(RulesPage, {}) }), _jsx(Route, { path: "horns/rules/:rule", element: _jsx(RulePage, {}) }), _jsx(Route, { path: "horns/shapes", element: _jsx(ShapesPage, {}) }), _jsx(Route, { path: "horns/shapes/:schema", element: _jsx(ShapeZooPage, {}) }), _jsx(Route, { path: "horns/shapes/:schema/entity", element: _jsx(ShapeEntityPage, {}) }), import.meta.env.DEV ? _jsx(Route, { path: "horns/reference", element: _jsx(ReferencePage, {}) }) : null, catchAll ? _jsx(Route, { index: true, element: _jsx(HomePage, {}) }) : null] }), catchAll ? _jsx(Route, { path: "*", element: _jsx(Navigate, { to: "/", replace: true }) }) : null] }));
+    _jsxs(Route, { element: _jsx(NuqsAdapter, { children: _jsx(Outlet, {}) }), children: [_jsx(Route, { path: "horns/new", element: _jsx(NewHornPage, {}) }), _jsx(Route, { path: "horns/:slug", element: _jsx(HornPage, {}) }), _jsxs(Route, { element: shell ?? _jsx(AppShell, {}), children: [_jsx(Route, { path: "horns", element: _jsx(HornsPage, {}) }), _jsx(Route, { path: "horns/:slug/view", element: _jsx(HornViewPage, {}) }), _jsx(Route, { path: "horns/showcase", element: _jsx(ShowcasePage, {}) }), _jsx(Route, { path: "horns/plans", element: _jsx(PlansPage, {}) }), _jsx(Route, { path: "horns/rules", element: _jsx(RulesPage, {}) }), _jsx(Route, { path: "horns/rules/:rule", element: _jsx(RulePage, {}) }), _jsx(Route, { path: "horns/shapes", element: _jsx(ShapesPage, {}) }), _jsx(Route, { path: "horns/shapes/:schema", element: _jsx(ShapeZooPage, {}) }), _jsx(Route, { path: "horns/shapes/:schema/entity", element: _jsx(ShapeEntityPage, {}) }), import.meta.env.DEV ? _jsx(Route, { path: "horns/reference", element: _jsx(ReferencePage, {}) }) : null, catchAll ? _jsx(Route, { index: true, element: _jsx(HomePage, {}) }) : null] }), catchAll ? _jsx(Route, { path: "*", element: _jsx(Navigate, { to: "/", replace: true }) }) : null] }));
 }
 export function AppRoutes() {
     return _jsx(Routes, { children: hornsRoutes({ catchAll: true }) });

package/dist/components/app-shell.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { isPresent } from "@manta-eu/lib/present";
 import { Link, Outlet, useLocation } from "react-router";
-import { Boxes, Columns3, Database, LayoutGrid, ListChecks, Sigma } from "lucide-react";
+import { Database } from "lucide-react";
 import { MainContent, MantaLogo, NavUser, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarMenu, SidebarMenuButton, SidebarMenuItem, SidebarProvider, SidebarTrigger, } from "@manta-eu/react";
-import { hornsPath, plansPath, rulesPath, shapesPath, showcasePath } from "../app/paths";
+import { hornsNavSections } from "../app/nav";
 import { useActiveDatastore } from "@manta-eu/react/providers";
 import { useAuthContext } from "@manta-eu/react/providers/AuthContext";
 function NavLink({ to, icon, label, active }) {
@@ -15,5 +15,5 @@ export function AppShell() {
     const { user, datastore, datastores = [] } = useAuthContext();
     const current = datastores.find((candidate) => candidate.id === datastoreId) ?? datastore;
     const inDatastore = isPresent(datastoreId) && isPresent(current);
-    return (_jsxs(SidebarProvider, { children: [_jsxs(Sidebar, { collapsible: "icon", children: [_jsx(SidebarHeader, { children: _jsxs(Link, { to: "/", className: "flex items-center gap-2 px-2 py-1.5", "aria-label": "Manta Horns", children: [_jsx(MantaLogo, { size: 24 }), _jsx("span", { className: "font-semibold group-data-[collapsible=icon]:hidden", children: "Horns" })] }) }), _jsx(SidebarContent, { children: _jsxs("nav", { "aria-label": "Datastore", className: "flex flex-col gap-2", children: [isPresent(datastoreId) && inDatastore ? (_jsxs(_Fragment, { children: [_jsxs(SidebarGroup, { children: [_jsx(SidebarGroupLabel, { children: current.name }), _jsx(SidebarGroupContent, { children: _jsxs(SidebarMenu, { children: [_jsx(NavLink, { to: showcasePath(), icon: _jsx(LayoutGrid, { "aria-hidden": "true" }), label: "Showcase", active: pathname === showcasePath() }), _jsx(NavLink, { to: hornsPath(), icon: _jsx(Columns3, { "aria-hidden": "true" }), label: "Horns", active: pathname === hornsPath() })] }) })] }), _jsxs(SidebarGroup, { children: [_jsx(SidebarGroupLabel, { children: "For builders" }), _jsx(SidebarGroupContent, { children: _jsxs(SidebarMenu, { children: [_jsx(NavLink, { to: shapesPath(), icon: _jsx(Boxes, { "aria-hidden": "true" }), label: "Data shapes", active: pathname.startsWith(shapesPath()) }), _jsx(NavLink, { to: rulesPath(), icon: _jsx(Sigma, { "aria-hidden": "true" }), label: "Rules", active: pathname.startsWith(rulesPath()) }), _jsx(NavLink, { to: plansPath(), icon: _jsx(ListChecks, { "aria-hidden": "true" }), label: "Action plans", active: pathname.startsWith(plansPath()) })] }) })] })] })) : null, _jsxs(SidebarGroup, { children: [_jsx(SidebarGroupLabel, { children: "All datastores" }), _jsx(SidebarGroupContent, { children: _jsx(SidebarMenu, { children: _jsx(NavLink, { to: "/", icon: _jsx(Database, { "aria-hidden": "true" }), label: `Datastores (${datastores.length})`, active: pathname === "/" }) }) })] })] }) }), _jsx(SidebarFooter, { children: _jsx(NavUser, { name: user?.name ?? user?.email ?? "Signed in", currentDatastore: { name: current?.name ?? "No datastore" }, onNavigateToAccount: () => window.location.assign("/"), onLogout: () => window.location.assign("/logout") }) })] }), _jsx(MainContent, { className: "pb-8", children: _jsxs("div", { className: "flex w-full flex-col gap-4 px-4 sm:px-6", children: [_jsx(SidebarTrigger, { "aria-label": "Toggle Sidebar" }), _jsx(Outlet, {})] }) })] }));
+    return (_jsxs(SidebarProvider, { children: [_jsxs(Sidebar, { collapsible: "icon", children: [_jsx(SidebarHeader, { children: _jsxs(Link, { to: "/", className: "flex items-center gap-2 px-2 py-1.5", "aria-label": "Manta Horns", children: [_jsx(MantaLogo, { size: 24 }), _jsx("span", { className: "font-semibold group-data-[collapsible=icon]:hidden", children: "Horns" })] }) }), _jsx(SidebarContent, { children: _jsxs("nav", { "aria-label": "Datastore", className: "flex flex-col gap-2", children: [isPresent(datastoreId) && inDatastore ? (_jsx(_Fragment, { children: hornsNavSections().map((section, index) => (_jsxs(SidebarGroup, { children: [_jsx(SidebarGroupLabel, { children: index === 0 ? current.name : section.label }), _jsx(SidebarGroupContent, { children: _jsx(SidebarMenu, { children: section.items.map(({ to, label, icon: Icon, isCurrent }) => (_jsx(NavLink, { to: to, icon: _jsx(Icon, { "aria-hidden": "true" }), label: label, active: isCurrent(pathname) }, to))) }) })] }, section.label))) })) : null, _jsxs(SidebarGroup, { children: [_jsx(SidebarGroupLabel, { children: "All datastores" }), _jsx(SidebarGroupContent, { children: _jsx(SidebarMenu, { children: _jsx(NavLink, { to: "/", icon: _jsx(Database, { "aria-hidden": "true" }), label: `Datastores (${datastores.length})`, active: pathname === "/" }) }) })] })] }) }), _jsx(SidebarFooter, { children: _jsx(NavUser, { name: user?.name ?? user?.email ?? "Signed in", currentDatastore: { name: current?.name ?? "No datastore" }, onNavigateToAccount: () => window.location.assign("/"), onLogout: () => window.location.assign("/logout") }) })] }), _jsx(MainContent, { className: "pb-8", children: _jsxs("div", { className: "flex w-full flex-col gap-4 px-4 sm:px-6", children: [_jsx(SidebarTrigger, { "aria-label": "Toggle Sidebar" }), _jsx(Outlet, {})] }) })] }));
 }

package/dist/embed/horn-about.d.ts

@@ -1,3 +1,4 @@
+import { type Horn } from "@manta-eu/horns";
 import { type HornSnapshotViewProps } from "@manta-eu/horns-kit";
 /**
  * Where the worker answers for a thing. The IRI goes in a query parameter and is encoded: a plan's carries
@@ -6,6 +7,29 @@ import { type HornSnapshotViewProps } from "@manta-eu/horns-kit";
 export declare function hornAboutPath(datastoreId: string, about: string): string;
 /** Where a Horn is turned into rows to draw. */
 export declare function hornSnapshotPath(datastoreId: string): string;
+/** Where every Horn about a thing is listed. */
+export declare function hornsAboutPath(datastoreId: string, about: string, limit?: number): string;
+/** What the drawing needs, apart from which Horn it is. */
+export type HornDrawProps = {
+    mode?: HornSnapshotViewProps["mode"];
+    planActions?: HornSnapshotViewProps["planActions"];
+    explain?: HornSnapshotViewProps["explain"];
+    onVariableChange?: HornSnapshotViewProps["onVariableChange"];
+};
+/**
+ * One Horn, turned into rows by the worker and drawn.
+ *
+ * Written views and catalog cards are bound here because they need `@manta-eu/react`, which the kit has
+ * not got. Everything else a host wants to hang on it is a prop.
+ */
+export type HornDrawnProps = HornDrawProps & {
+    datastoreId: string;
+    horn: Horn;
+    /** What a redraw keys on: the revision where there is one, or the thing the Horn was built for. */
+    cacheKey: string;
+    variables?: Record<string, unknown>;
+};
+export declare function HornDrawn(props: HornDrawnProps): import("react").JSX.Element;
 export type HornAboutProps = {
     datastoreId: string;
     /** The thing to show: an action plan, a rule. Opaque — it is only ever passed on. */

package/dist/embed/horn-about.js

@@ -28,6 +28,35 @@ export function hornAboutPath(datastoreId, about) {
 export function hornSnapshotPath(datastoreId) {
     return `/api/d/${encodeURIComponent(datastoreId)}/horns/snapshot`;
 }
+/** Where every Horn about a thing is listed. */
+export function hornsAboutPath(datastoreId, about, limit) {
+    const capped = limit === undefined ? "" : `&limit=${limit}`;
+    return `/api/d/${encodeURIComponent(datastoreId)}/horns/by/about/list?iri=${encodeURIComponent(about)}${capped}`;
+}
+export function HornDrawn(props) {
+    const { datastoreId, horn, cacheKey, variables = {}, mode = "embed", planActions, explain, onVariableChange } = props;
+    const snapshot = useQuery({
+        enabled: isPresent(horn),
+        queryKey: ["horn-snapshot", datastoreId, cacheKey, variables],
+        queryFn: async ({ signal }) => {
+            const response = await fetch(hornSnapshotPath(datastoreId), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ horn, variables }),
+                signal,
+            });
+            if (!response.ok)
+                throw new Error(await problemFrom(response, "The Horn could not be drawn."));
+            const body = await response.json();
+            return hornSnapshotSchema.parse(isRecord(body) ? body["snapshot"] : undefined);
+        },
+    });
+    if (snapshot.isError)
+        return _jsx(ErrorState, { title: "This could not be drawn", hint: snapshot.error.message });
+    if (!isPresent(snapshot.data))
+        return _jsx(Loading, { label: "Drawing this\u2026", rows: 3 });
+    return (_jsx(HornSnapshotView, { snapshot: snapshot.data, mode: mode, theme: appTheme(), writtenView: writtenHornView, planStrip: PlanChanges, catalogCard: catalogCardView, ...(isPresent(planActions) ? { planActions } : {}), ...(isPresent(explain) ? { explain } : {}), ...(isPresent(onVariableChange) ? { onVariableChange } : {}) }));
+}
 /**
  * The Horn for a thing, drawn wherever a host puts it.
  *
@@ -49,28 +78,10 @@ export function HornAbout(props) {
             return aboutAnswer.parse(await response.json());
         },
     });
-    const horn = seed.data?.horn;
-    const snapshot = useQuery({
-        enabled: isPresent(horn),
-        queryKey: ["horn-about-snapshot", datastoreId, about, seed.data?.revision ?? "", variables],
-        queryFn: async ({ signal }) => {
-            const response = await fetch(hornSnapshotPath(datastoreId), {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ horn, variables }),
-                signal,
-            });
-            if (!response.ok)
-                throw new Error(await problemFrom(response, "The Horn could not be drawn."));
-            const body = await response.json();
-            return hornSnapshotSchema.parse(isRecord(body) ? body["snapshot"] : undefined);
-        },
-    });
     if (seed.isError)
         return _jsx(ErrorState, { title: "Nothing could be shown for this", hint: seed.error.message });
-    if (snapshot.isError)
-        return _jsx(ErrorState, { title: "This could not be drawn", hint: snapshot.error.message });
-    if (!isPresent(snapshot.data))
+    const horn = seed.data?.horn;
+    if (!isPresent(horn))
         return _jsx(Loading, { label: "Drawing this\u2026", rows: 3 });
-    return (_jsx(HornSnapshotView, { snapshot: snapshot.data, mode: mode, theme: appTheme(), writtenView: writtenHornView, planStrip: PlanChanges, catalogCard: catalogCardView, ...(isPresent(planActions) ? { planActions } : {}), ...(isPresent(explain) ? { explain } : {}), ...(isPresent(onVariableChange) ? { onVariableChange } : {}) }));
+    return (_jsx(HornDrawn, { datastoreId: datastoreId, horn: horn, cacheKey: seed.data?.revision ?? about, variables: variables, mode: mode, ...(isPresent(planActions) ? { planActions } : {}), ...(isPresent(explain) ? { explain } : {}), ...(isPresent(onVariableChange) ? { onVariableChange } : {}) }));
 }

package/dist/embed/horns-about.d.ts

@@ -0,0 +1,29 @@
+import { type HornDrawProps } from "./horn-about";
+export type HornsAboutProps = HornDrawProps & {
+    datastoreId: string;
+    /** The thing these are about: a rule, a plan, a campaign, a person. Opaque — only ever passed on. */
+    about: string;
+    /** How many to draw. The worker caps it; leaving it off takes the worker's default. */
+    limit?: number;
+    variables?: Record<string, unknown>;
+    /**
+     * Where a Horn opens in full, where the host has somewhere to send a person. A plain href, not a route:
+     * the Horns UI may be another document, or another origin entirely.
+     */
+    hornHref?: (slug: string) => string;
+    /** What to say when nothing is about this thing yet. */
+    emptyHint?: string;
+};
+/**
+ * Every Horn about one thing, drawn.
+ *
+ * This is the whole of embedding Horns: a host that has an IRI — a rule, an action plan, a campaign, a
+ * person — puts this beside it and gets what Manta already knows about that thing, as pictures rather than
+ * links. It needs no saved Horn, no route of the host's and no Studio: the worker answers with the kept
+ * ones, or builds one from the rule or plan itself.
+ *
+ * The one thing a host must bring is the policy. A written view runs in the page's own realm, so the
+ * document has to carry `connect-src 'self'` and the rest of `contentSecurityPolicy()`; without it the
+ * views still draw, but nothing fences the code they came from.
+ */
+export declare function HornsAbout(props: HornsAboutProps): import("react").JSX.Element;

package/dist/embed/horns-about.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useQuery } from "@tanstack/react-query";
+import { z } from "zod";
+import { isPresent } from "@manta-eu/lib/present";
+import { hornSchema } from "@manta-eu/horns";
+import { EmptyState, ErrorState, Loading } from "../components/states";
+import { problemFrom } from "../lib/problem";
+import { HornDrawn, hornsAboutPath } from "./horn-about";
+const listAnswer = z.object({
+    horns: z.array(z.object({
+        horn: hornSchema,
+        kept: z.boolean(),
+        slug: z.string().min(1).optional(),
+        revision: z.string().min(1).optional(),
+    })),
+    total: z.number().int().min(0),
+});
+/**
+ * Every Horn about one thing, drawn.
+ *
+ * This is the whole of embedding Horns: a host that has an IRI — a rule, an action plan, a campaign, a
+ * person — puts this beside it and gets what Manta already knows about that thing, as pictures rather than
+ * links. It needs no saved Horn, no route of the host's and no Studio: the worker answers with the kept
+ * ones, or builds one from the rule or plan itself.
+ *
+ * The one thing a host must bring is the policy. A written view runs in the page's own realm, so the
+ * document has to carry `connect-src 'self'` and the rest of `contentSecurityPolicy()`; without it the
+ * views still draw, but nothing fences the code they came from.
+ */
+export function HornsAbout(props) {
+    const { datastoreId, about, limit, variables = {}, hornHref, emptyHint, ...draw } = props;
+    const listed = useQuery({
+        queryKey: ["horns-about", datastoreId, about, limit ?? "default"],
+        queryFn: async ({ signal }) => {
+            const response = await fetch(hornsAboutPath(datastoreId, about, limit), { signal });
+            if (!response.ok)
+                throw new Error(await problemFrom(response, `The answer was ${response.status}.`));
+            return listAnswer.parse(await response.json());
+        },
+    });
+    if (listed.isError)
+        return _jsx(ErrorState, { title: "Nothing could be shown for this", hint: listed.error.message });
+    if (!isPresent(listed.data))
+        return _jsx(Loading, { label: "Looking for what is known about this\u2026", rows: 2 });
+    const { horns, total } = listed.data;
+    if (horns.length === 0) {
+        return (_jsx(EmptyState, { title: "Nothing is about this yet", hint: emptyHint ?? "Once somebody makes a Horn about it, it will be drawn here." }));
+    }
+    return (_jsxs("div", { "data-horns-about": true, className: "flex w-full flex-col gap-8", children: [horns.map(({ horn, slug, revision }) => (_jsxs("section", { "data-horn": slug, className: "flex flex-col gap-3", children: [_jsxs("div", { className: "flex flex-col gap-1", children: [_jsx("h2", { className: "text-lg font-semibold text-default-foreground", children: isPresent(slug) && isPresent(hornHref) ? (_jsx("a", { href: hornHref(slug), className: "hover:underline", children: horn.title })) : (horn.title) }), isPresent(horn.summary) ? _jsx("p", { className: "text-muted-foreground text-sm", children: horn.summary }) : null] }), _jsx(HornDrawn, { datastoreId: datastoreId, horn: horn, cacheKey: revision ?? slug ?? about, variables: variables, ...draw })] }, slug ?? revision ?? horn.title))), total > horns.length ? (_jsxs("p", { className: "text-sm text-muted-foreground", children: [total - horns.length, " more ", total - horns.length === 1 ? "Horn is" : "Horns are", " about this."] })) : null] }));
+}

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-export { AppRoutes, hornsRoutes } from "./app/routes.tsx";
+export { AppRoutes, hornsRoutes, type HornsRoutesOptions } from "./app/routes.tsx";
+export { hornsNavSections, type HornsNavItem, type HornsNavSection } from "./app/nav.ts";
 export { HornsApp } from "./standalone/app.tsx";
-export { HornAbout, type HornAboutProps } from "./embed/horn-about.tsx";
+export { HornAbout, HornDrawn, hornAboutPath, hornsAboutPath, hornSnapshotPath } from "./embed/horn-about.tsx";
+export type { HornAboutProps, HornDrawProps, HornDrawnProps } from "./embed/horn-about.tsx";
+export { HornsAbout, type HornsAboutProps } from "./embed/horns-about.tsx";
 export { AppShell } from "./components/app-shell.tsx";
 export { signInHref } from "./lib/manta/sign-in.ts";
 export { useSparqlSelect } from "./lib/manta/sparql-select.ts";

package/dist/index.js

@@ -7,12 +7,16 @@
 // What the browser needs beyond this is the stylesheet: `@manta-eu/horns-client/styles.css`, built here
 // rather than compiled by the host, so a host with no Tailwind still gets the app looking like Manta.
 export { AppRoutes, hornsRoutes } from "./app/routes.js";
+// What a host with a shell of its own draws as navigation, so a page cannot be in one list and not the other.
+export { hornsNavSections } from "./app/nav.js";
 // The session gate, and the only thing that provides the AuthContext every Horns page reads. A host
 // splicing `hornsRoutes()` into a router of its own mounts this above them, or provides that context itself.
 export { HornsApp } from "./standalone/app.js";
 // A thing's Horn, drawn inside a host's own screen: it asks the worker for the kept Horn or one built
 // from the plan or rule itself, so a host needs no saved Horn and no route of its own.
-export { HornAbout } from "./embed/horn-about.js";
+export { HornAbout, HornDrawn, hornAboutPath, hornsAboutPath, hornSnapshotPath } from "./embed/horn-about.js";
+// Every Horn about one thing: what a host with an IRI embeds.
+export { HornsAbout } from "./embed/horns-about.js";
 export { AppShell } from "./components/app-shell.js";
 export { signInHref } from "./lib/manta/sign-in.js";
 export { useSparqlSelect } from "./lib/manta/sparql-select.js";