@manta-eu/horns-client 0.1.0 → 0.1.1

package/dist/components/app-shell.js

@@ -1,18 +1,19 @@
 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, useParams } from "react-router";
-import { Boxes, Columns3, Database, LayoutGrid, Sigma } from "lucide-react";
+import { Link, Outlet, useLocation } from "react-router";
+import { Boxes, Columns3, Database, LayoutGrid, ListChecks, Sigma } 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, rulesPath, shapesPath, showcasePath } from "../app/paths";
-import { useMantaSession } from "../lib/manta/session";
+import { hornsPath, plansPath, rulesPath, shapesPath, showcasePath } from "../app/paths";
+import { useActiveDatastore } from "@manta-eu/react/providers";
+import { useAuthContext } from "@manta-eu/react/providers/AuthContext";
 function NavLink({ to, icon, label, active }) {
     return (_jsx(SidebarMenuItem, { children: _jsx(SidebarMenuButton, { asChild: true, isActive: active, tooltip: label, children: _jsxs(Link, { to: to, "aria-current": active ? "page" : undefined, children: [icon, _jsx("span", { children: label })] }) }) }));
 }
 export function AppShell() {
-    const { datastoreId } = useParams();
+    const { datastoreId } = useActiveDatastore();
     const { pathname } = useLocation();
-    const { user, datastore, datastores } = useMantaSession();
+    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(datastoreId), icon: _jsx(LayoutGrid, { "aria-hidden": "true" }), label: "Showcase", active: pathname === showcasePath(datastoreId) }), _jsx(NavLink, { to: hornsPath(datastoreId), icon: _jsx(Columns3, { "aria-hidden": "true" }), label: "Horns", active: pathname === hornsPath(datastoreId) })] }) })] }), _jsxs(SidebarGroup, { children: [_jsx(SidebarGroupLabel, { children: "For builders" }), _jsx(SidebarGroupContent, { children: _jsxs(SidebarMenu, { children: [_jsx(NavLink, { to: shapesPath(datastoreId), icon: _jsx(Boxes, { "aria-hidden": "true" }), label: "Data shapes", active: pathname.startsWith(shapesPath(datastoreId)) }), _jsx(NavLink, { to: rulesPath(datastoreId), icon: _jsx(Sigma, { "aria-hidden": "true" }), label: "Rules", active: pathname.startsWith(rulesPath(datastoreId)) })] }) })] })] })) : 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 ? (_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, {})] }) })] }));
 }

package/dist/components/catalog-card-view.js

@@ -1,13 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { lazy, Suspense } from "react";
 import { Loader } from "@manta-eu/react";
-import { MantaSparqlProvider } from "../lib/manta/providers";
+import { EmbeddedChatProviders } from "@manta-eu/react/providers";
 // Behind `lazy`: the body pulls in the graph routing and every typed entity card.
 const CatalogCardBody = lazy(async () => {
     const body = await import("./catalog-card-body");
     return { default: body.CatalogCardBody };
 });
-// The provider comes with it, because a card fetches its own entity and the page it draws on may have no
-// providers of its own — a server-rendered Horn document hydrates embeds and nothing else, so a shared link
-// with a card on it spun for ever without this.
-export const catalogCardView = (content, _view, context) => (_jsx(MantaSparqlProvider, { datastoreId: context.datastoreId, children: _jsx(Suspense, { fallback: _jsx(Loader, {}), children: _jsx(CatalogCardBody, { content: content }) }) }));
+// The providers come with it: a card fetches its own entity, and a server-rendered Horn document hydrates
+// embeds and nothing else. The embedded set, because a card must not navigate its host away on a 401.
+export const catalogCardView = (content, _view, context) => (_jsx(EmbeddedChatProviders, { mantaBaseUrl: window.location.origin, datastoreId: context.datastoreId, children: _jsx(Suspense, { fallback: _jsx(Loader, {}), children: _jsx(CatalogCardBody, { content: content }) }) }));

package/dist/components/explain-dialog.d.ts

@@ -0,0 +1,5 @@
+import type { ExplainedFact } from "@manta-eu/horns-kit/view";
+export declare function useExplainDialog(): {
+    open: (fact: ExplainedFact) => void;
+    dialog: import("react").JSX.Element;
+};

package/dist/components/explain-dialog.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useState } from "react";
+import { isRecord } from "@manta-eu/horns";
+import { Dialog, DialogContent, DialogTitle } from "@manta-eu/react";
+import { ExplainFact } from "@manta-eu/react/components/explain-fact/ExplainFact";
+// The explanation a `WhyThis` mark asks for. One per page rather than one per mark: the kit draws the marks
+// and the host owns the modal, because drawing a proof tree needs the design system the kit has not got.
+/**
+ * Whether what a view handed over is an explanation this can draw.
+ *
+ * Checked to the depth the type declares — a map of facts, or of lists of them — because the data came out
+ * of model-written source and the component walks it without asking.
+ */
+function isExplanation(value) {
+    if (!isRecord(value))
+        return false;
+    return Object.values(value).every((one) => Array.isArray(one) ? one.every((fact) => isRecord(fact)) : isRecord(one));
+}
+export function useExplainDialog() {
+    const [shown, setShown] = useState();
+    // Stable, because it reaches the kit through a provider value and would otherwise redraw every view.
+    const open = useCallback((fact) => setShown(fact), []);
+    const explanation = isExplanation(shown?.data) ? shown.data : undefined;
+    const dialog = (_jsx(Dialog, { open: shown !== undefined, onOpenChange: (next) => (next ? undefined : setShown(undefined)), children: _jsxs(DialogContent, { children: [_jsx(DialogTitle, { text: shown?.title ?? "Why this value" }), shown === undefined ? null : (_jsx(ExplainFact, { mode: "compact", subject: shown.subject, object: shown.object, ...(shown.predicate === undefined ? {} : { predicate: shown.predicate }), ...(explanation === undefined ? {} : { data: explanation }) }))] }) }));
+    return { open, dialog };
+}

package/dist/components/plan-runs.js

@@ -3,7 +3,7 @@ import { useEffect, useRef, useState } from "react";
 import { planStatusQuery, readPlanStatus } from "@manta-eu/horns/render";
 import { planSummary } from "@manta-eu/horns-kit";
 import { Button, Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@manta-eu/react";
-import { browserSparqlSelect } from "../lib/manta/sparql-select";
+import { useSparqlSelect } from "../lib/manta/sparql-select";
 import { planPollAttempts, planPollInterval, runSeen, runSettled, startPlanRun } from "../lib/plan-runs";
 /**
  * Previews and runs of the action plans a Horn shows. A preview starts straight away: it changes nothing. A real
@@ -11,6 +11,7 @@ import { planPollAttempts, planPollInterval, runSeen, runSettled, startPlanRun }
  * and a real run that finished redraws the Horn, because the things it changed now look different.
  */
 export function usePlanRuns(args) {
+    const select = useSparqlSelect();
     const { datastoreId, realm, onChanged } = args;
     const [status, setStatus] = useState({});
     const [pending, setPending] = useState(new Set());
@@ -26,7 +27,6 @@ export function usePlanRuns(args) {
         };
     }, []);
     const follow = async (plan, preview, startedBefore) => {
-        const select = browserSparqlSelect(datastoreId);
         for (let attempt = 0; attempt < planPollAttempts && alive.current; attempt += 1) {
             await new Promise((resolve) => setTimeout(resolve, planPollInterval));
             if (!alive.current)

package/dist/components/read-the-code.d.ts

@@ -10,5 +10,24 @@ export type ReadTheCodeProps = {
     onKeep: (edit: VisualEdit) => void;
 };
 export declare function ReadTheCode({ viewId, title, source, state, onKeep }: ReadTheCodeProps): import("react").JSX.Element;
+export type ReadTheCodeDialogProps = ReadTheCodeProps & {
+    open: boolean;
+    onClose: () => void;
+    /** Where this one sits when a save is walking every unread view in turn. */
+    standing?: {
+        at: number;
+        of: number;
+    };
+};
+/**
+ * The reading itself, without the button that opens it.
+ *
+ * Saving drives this too: a Horn that will not save because nobody read its code is a dead end, so Save
+ * offers the reading instead of refusing. It is still the person's action that keeps the code.
+ *
+ * Keeping does not close it — the owner decides what follows, because when a save is walking several views
+ * what follows is the next one.
+ */
+export declare function ReadTheCodeDialog({ viewId, title, source, state, open, onClose, onKeep, standing, }: ReadTheCodeDialogProps): import("react").JSX.Element;
 /** The review state of every written view in a draft, by view id, for the Studio to show on each card. */
 export declare function writtenReviewStates(horn: Horn): Promise<Record<string, ReviewState["state"]>>;

package/dist/components/read-the-code.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { Badge, Button, Dialog, DialogContent, DialogHeader, DialogTitle } from "@manta-eu/react";
 import { reviewOf, reviewStateOf } from "@manta-eu/horns/render";
@@ -24,12 +24,26 @@ const wording = {
 };
 export function ReadTheCode({ viewId, title, source, state, onKeep }) {
     const [open, setOpen] = useState(false);
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { variant: state === "reviewed" ? "ghost" : "secondary", size: "xs", onClick: () => setOpen(true), "aria-label": `${wording[state].title}: ${title}`, children: wording[state].badge }), _jsx(ReadTheCodeDialog, { viewId: viewId, title: title, source: source, state: state, open: open, onClose: () => setOpen(false), onKeep: (change) => {
+                    onKeep(change);
+                    setOpen(false);
+                } })] }));
+}
+/**
+ * The reading itself, without the button that opens it.
+ *
+ * Saving drives this too: a Horn that will not save because nobody read its code is a dead end, so Save
+ * offers the reading instead of refusing. It is still the person's action that keeps the code.
+ *
+ * Keeping does not close it — the owner decides what follows, because when a save is walking several views
+ * what follows is the next one.
+ */
+export function ReadTheCodeDialog({ viewId, title, source, state, open, onClose, onKeep, standing, }) {
     const words = wording[state];
     async function keep() {
         onKeep({ kind: "keep-code", viewId, reviewed: await reviewOf(source, new Date()) });
-        setOpen(false);
     }
-    return (_jsxs(_Fragment, { children: [_jsx(Button, { variant: state === "reviewed" ? "ghost" : "secondary", size: "xs", onClick: () => setOpen(true), "aria-label": `${words.title}: ${title}`, children: words.badge }), _jsx(Dialog, { open: open, onOpenChange: setOpen, children: _jsxs(DialogContent, { className: "max-w-3xl", children: [_jsx(DialogHeader, { children: _jsx(DialogTitle, { text: words.title }) }), _jsxs("div", { className: "flex flex-col gap-3", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Badge, { children: title }), _jsx("span", { className: "text-muted-foreground text-sm", children: words.badge })] }), _jsx("p", { className: "text-muted-foreground m-0 text-sm", children: words.lead }), _jsx("pre", { className: "border-muted-border max-h-[50vh] overflow-auto rounded-lg border p-3 text-xs leading-relaxed", children: _jsx("code", { children: source }) }), _jsx("div", { className: "flex justify-end gap-2", children: state === "reviewed" ? (_jsx(Button, { onClick: () => setOpen(false), children: words.action })) : (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "ghost", onClick: () => setOpen(false), children: "Not yet" }), _jsx(Button, { onClick: () => void keep(), children: words.action })] })) })] })] }) })] }));
+    return (_jsx(Dialog, { open: open, onOpenChange: (next) => (next ? undefined : onClose()), children: _jsxs(DialogContent, { className: "flex h-[92vh] w-[95vw] max-w-[95vw] flex-col sm:max-w-[95vw]", children: [_jsx(DialogHeader, { children: _jsx(DialogTitle, { text: words.title }) }), _jsxs("div", { className: "flex min-h-0 flex-1 flex-col gap-3", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Badge, { children: title }), _jsx("span", { className: "text-muted-foreground text-sm", children: standing === undefined ? words.badge : `${words.badge} · ${standing.at} of ${standing.of}` })] }), _jsx("p", { className: "text-muted-foreground m-0 text-sm", children: words.lead }), _jsx("pre", { className: "border-muted-border min-h-0 flex-1 overflow-auto rounded-lg border p-4 text-sm leading-relaxed", children: _jsx("code", { children: source }) }), _jsx("div", { className: "flex justify-end gap-2", children: state === "reviewed" ? (_jsx(Button, { onClick: onClose, children: words.action })) : (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "ghost", onClick: onClose, children: "Not yet" }), _jsx(Button, { onClick: () => void keep(), children: words.action })] })) })] })] }) }));
 }
 /** The review state of every written view in a draft, by view id, for the Studio to show on each card. */
 export async function writtenReviewStates(horn) {

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 export { AppRoutes, hornsRoutes } from "./app/routes.tsx";
 export { AppShell } from "./components/app-shell.tsx";
-export { MantaSparqlProvider, datastoreSparqlPath, queryClientFor } from "./lib/manta/providers.tsx";
-export { MantaSessionProvider, useMantaSession } from "./lib/manta/session.tsx";
-export { browserSparqlSelect } from "./lib/manta/sparql-select.ts";
+export { signInHref } from "./lib/manta/sign-in.ts";
+export { useSparqlSelect } from "./lib/manta/sparql-select.ts";
 export { ldkitShapeCatalog, provideShapeCatalog, shapesRealm, type ShapeCatalogSource } from "./lib/shapes/catalog.ts";
 export { rasterizeHorn, sendHornScreenshot } from "./components/rasterize.tsx";
 export { reviewHorn, type HornReview } from "./lib/horn-review.ts";

package/dist/index.js

@@ -5,9 +5,8 @@
 // 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";
 export { AppShell } from "./components/app-shell.js";
-export { MantaSparqlProvider, datastoreSparqlPath, queryClientFor } from "./lib/manta/providers.js";
-export { MantaSessionProvider, useMantaSession } from "./lib/manta/session.js";
-export { browserSparqlSelect } from "./lib/manta/sparql-select.js";
+export { signInHref } from "./lib/manta/sign-in.js";
+export { useSparqlSelect } from "./lib/manta/sparql-select.js";
 export { ldkitShapeCatalog, provideShapeCatalog, shapesRealm } from "./lib/shapes/catalog.js";
 export { rasterizeHorn, sendHornScreenshot } from "./components/rasterize.js";
 export { reviewHorn } from "./lib/horn-review.js";

package/dist/lib/horn-review.d.ts

@@ -12,6 +12,13 @@ export type HornReview = {
     problems: RenderProblem[];
     unavailable?: string;
 };
+/**
+ * What the picture calls a view.
+ *
+ * A draw failure knows the id and the reviewer only ever sees the title, so one broken view was arriving as
+ * two findings under two names, and a turn spent itself fixing the second one.
+ */
+export declare function nameOfView(horn: Pick<Horn, "views">, viewId: string): string;
 /**
  * Draw the Horn that was just made, look at it, and say what is wrong.
  *

package/dist/lib/horn-review.js

@@ -1,6 +1,16 @@
 import { hornSnapshotSchema } from "@manta-eu/horns/render";
 import { rasterizeHorn } from "../components/rasterize";
 import { isRecord } from "@manta-eu/horns";
+/**
+ * What the picture calls a view.
+ *
+ * A draw failure knows the id and the reviewer only ever sees the title, so one broken view was arriving as
+ * two findings under two names, and a turn spent itself fixing the second one.
+ */
+export function nameOfView(horn, viewId) {
+    const view = horn.views.find((candidate) => candidate.id === viewId);
+    return view === undefined || "ref" in view ? viewId : view.title;
+}
 /**
  * Draw the Horn that was just made, look at it, and say what is wrong.
  *
@@ -14,6 +24,11 @@ export async function reviewHorn(args) {
         const snapshot = await snapshotOf(args);
         const drawn = await rasterizeHorn(snapshot);
         problems = drawn.problems;
+        // A view that threw leaves a card with an error where the drawing should be. Asking a model what it
+        // thinks of that picture buys three ways of saying "this card is empty", each of which reads like a
+        // separate thing to fix. The failure is the finding, and the reviewer costs money per turn.
+        if (problems.length > 0)
+            return { advice: [], problems };
         const image = await dataUrl(drawn.png);
         const response = await fetch(`/api/d/${encodeURIComponent(args.datastoreId)}/horns/review`, {
             method: "POST",

package/dist/lib/horn-variables.d.ts

@@ -0,0 +1,8 @@
+import type { Horn } from "@manta-eu/horns";
+export type HornVariables = {
+    /** What each variable is set to, ready for `buildHornSnapshot`. Absent keys are the variable's default. */
+    values: Record<string, unknown>;
+    /** Narrows the Horn, or clears the variable with `undefined`. */
+    set: (id: string, value: unknown) => void;
+};
+export declare function useHornVariables(horn: Horn | undefined): HornVariables;

package/dist/lib/horn-variables.js

@@ -0,0 +1,39 @@
+import { useCallback, useMemo } from "react";
+import { parseAsString, useQueryStates } from "nuqs";
+/**
+ * The parameter a variable rides on, or nothing.
+ *
+ * Its `urlParam` and only that: `variablesFromSearch` reads that name and no other, so writing a variable's
+ * id instead would change the URL and leave every binding reading the value it had before.
+ */
+function paramOf(variable) {
+    return variable.urlParam;
+}
+export function useHornVariables(horn) {
+    const variables = useMemo(() => horn?.variables ?? [], [horn]);
+    const keys = useMemo(() => Object.fromEntries(variables.flatMap((variable) => {
+        const param = paramOf(variable);
+        return param === undefined ? [] : [[param, parseAsString]];
+    })), [variables]);
+    const [params, setParams] = useQueryStates(keys);
+    const values = useMemo(() => {
+        const chosen = {};
+        for (const variable of variables) {
+            const param = paramOf(variable);
+            const held = param === undefined ? undefined : params[param];
+            if (held !== null && held !== undefined)
+                chosen[variable.id] = held;
+        }
+        return chosen;
+    }, [variables, params]);
+    const set = useCallback((id, value) => {
+        const variable = variables.find((candidate) => candidate.id === id);
+        const param = variable === undefined ? undefined : paramOf(variable);
+        if (param === undefined)
+            return;
+        // null is how nuqs drops a parameter; anything else rides as text, which is what a URL holds.
+        const next = value === undefined || value === null || value === "" ? null : String(value);
+        void setParams({ [param]: next });
+    }, [variables, setParams]);
+    return { values, set };
+}

package/dist/lib/manta/sign-in.d.ts

@@ -0,0 +1,2 @@
+/** Horns' own `/login`, which proxies to agents and stamps the marker a loop is diagnosed by. */
+export declare function signInHref(redirect?: string): string;

package/dist/lib/manta/sign-in.js

@@ -0,0 +1,9 @@
+import { isPresent } from "@manta-eu/lib/present";
+/** Horns' own `/login`, which proxies to agents and stamps the marker a loop is diagnosed by. */
+export function signInHref(redirect) {
+    const params = new URLSearchParams();
+    if (isPresent(redirect) && redirect !== "/")
+        params.set("redirect", redirect);
+    const query = params.toString();
+    return `/login${query ? `?${query}` : ""}`;
+}

package/dist/lib/manta/sparql-select.d.ts

@@ -1,2 +1,6 @@
-import { type SparqlSelect } from "@manta-eu/horns";
-export declare function browserSparqlSelect(datastoreId: string): SparqlSelect;
+import { SparqlReadError, type SparqlSelect } from "@manta-eu/horns";
+import type { GraphQLClient } from "graphql-request";
+export declare function graphqlSparqlSelect(client: GraphQLClient): SparqlSelect;
+/** The reader this app's pages use. The datastore rides on the client, from the route. */
+export declare function useSparqlSelect(): SparqlSelect;
+export { SparqlReadError };

package/dist/lib/manta/sparql-select.js

@@ -1,19 +1,22 @@
-import { sparqlResultsSchema } from "@manta-eu/horns";
-import { datastoreSparqlPath } from "./providers";
-import { readJsonError } from "./session";
-// SELECTs from the browser through the worker's read-only, grant-checked `/d/:ds/sparql` proxy.
-export function browserSparqlSelect(datastoreId) {
+import { useMemo } from "react";
+import { sparqlResultsOfGraphqlField, SparqlReadError } from "@manta-eu/horns";
+import { SparqlQueryDocument } from "@manta-eu/client";
+import { useMantaClient } from "@manta-eu/react/providers";
+// Imperative rather than `useSparqlQueryQuery`: a `SparqlSelect` is called from inside query functions and
+// from readers that issue one query after another, which a hook cannot serve.
+export function graphqlSparqlSelect(client) {
     return async (query, signal) => {
-        const response = await fetch(datastoreSparqlPath(datastoreId), {
-            method: "POST",
-            credentials: "same-origin",
-            headers: { "content-type": "application/sparql-query", accept: "application/sparql-results+json" },
-            body: query,
+        const answer = await client.request({
+            document: SparqlQueryDocument,
+            variables: { query },
             ...(signal ? { signal } : {}),
         });
-        if (!response.ok)
-            throw new Error(await readJsonError(response, `The datastore answered ${response.status}.`));
-        const body = await response.json();
-        return sparqlResultsSchema.parse(body);
+        return sparqlResultsOfGraphqlField(answer.sparqlQuery);
     };
 }
+/** The reader this app's pages use. The datastore rides on the client, from the route. */
+export function useSparqlSelect() {
+    const { mantaClient } = useMantaClient();
+    return useMemo(() => graphqlSparqlSelect(mantaClient), [mantaClient]);
+}
+export { SparqlReadError };

package/dist/lib/reference/fake-sparql.d.ts

@@ -0,0 +1,4 @@
+import type { SparqlSelect } from "@manta-eu/horns";
+export declare const referenceEntity = "https://data.example/entity/cisco-systems";
+/** A `SparqlSelect` over the fixture. Async because every other one is, not because anything waits. */
+export declare const fakeSparqlSelect: SparqlSelect;

package/dist/lib/reference/fake-sparql.js

@@ -0,0 +1,216 @@
+import { xsd } from "ldkit/namespaces";
+// A datastore that does not exist, for the reference Horn (docs/standard.md). It answers the queries that
+// Horn's bindings compile to and nothing else, so the page can be looked at without a datastore, a session or
+// a worker — which is the only way to judge whether the thing is any good before there is data behind it.
+//
+// Matching on what a query mentions rather than parsing it: these are eight known queries, and the marker is
+// the predicate each one is about. Anything unrecognised answers with no rows, which is what a real datastore
+// does for a thing it has not got.
+const entity = "https://data.example/entity/";
+const country = "https://data.example/country/";
+const alert = "https://data.example/alert/";
+export const referenceEntity = `${entity}cisco-systems`;
+const uri = (value) => ({ type: "uri", value });
+const text = (value) => ({ type: "literal", value });
+const number = (value) => ({
+    type: "literal",
+    value: String(value),
+    datatype: Number.isInteger(value) ? xsd.integer : xsd.decimal,
+});
+const date = (value) => ({ type: "literal", value, datatype: xsd.dateTime });
+const answer = (vars, bindings) => ({
+    head: { vars },
+    results: { bindings },
+});
+const nothing = answer([], []);
+/** What each IRI is called. The label pass asks for these, and every view shows the name and never the IRI. */
+const names = {
+    [referenceEntity]: "Cisco Systems, Inc.",
+    [`${entity}qualcomm`]: "QUALCOMM, Inc.",
+    [`${entity}cisco-supplier`]: "Cisco Systems, Inc.",
+    [`${entity}069hj1e`]: "069HJ1-E",
+    [`${entity}interdigital`]: "InterDigital, Inc.",
+    [`${entity}samsung-electro`]: "Samsung Electro-Mechanics Co., Ltd.",
+    [`${entity}au-optronics`]: "AU Optronics Corp.",
+    [`${entity}huawei`]: "Huawei Investment & Holding Co., Ltd.",
+    [`${country}us`]: "United States",
+    [`${country}cn`]: "China",
+    [`${country}tw`]: "Taiwan",
+    [`${country}kr`]: "South Korea",
+    [`${country}id`]: "Indonesia",
+    [`${country}jp`]: "Japan",
+};
+const suppliers = [
+    { id: "qualcomm", concentration: 78.08, yearOnYear: 72.04, country: "us" },
+    { id: "cisco-supplier", concentration: 1.48, yearOnYear: -4.23, country: "us" },
+    { id: "069hj1e", concentration: 0.94, yearOnYear: -1.72, country: "us" },
+    { id: "interdigital", concentration: 0.75, yearOnYear: -1.88, country: "us" },
+    { id: "samsung-electro", concentration: 0.75, yearOnYear: -1.86, country: "kr" },
+    { id: "au-optronics", concentration: 0.74, yearOnYear: -1.85, country: "tw" },
+    { id: "huawei", concentration: 0.74, yearOnYear: -2.9, country: "cn" },
+];
+const exposures = [
+    { id: "us", buyer: 82, supplier: 64, disruptions: 3 },
+    { id: "cn", buyer: 41, supplier: 88, disruptions: 2 },
+    { id: "tw", buyer: 12, supplier: 74, disruptions: 4 },
+    { id: "kr", buyer: 18, supplier: 46, disruptions: 0 },
+    { id: "id", buyer: 6, supplier: 21, disruptions: 5 },
+    { id: "jp", buyer: 22, supplier: 33, disruptions: 1 },
+];
+const flags = [
+    { kind: "Total supply chain alerts", total: 32, severity: "neutral" },
+    { kind: "Concentration alerts", total: 6, qualifier: "Sources: CN", severity: "medium" },
+    { kind: "Sanction exposures", total: 2, qualifier: "Sources: CN", severity: "high" },
+    { kind: "Tariff exposures", total: 13, qualifier: "Sources: CN", severity: "medium" },
+    { kind: "Disruption exposures", total: 2, qualifier: "1 high priority", severity: "high" },
+    { kind: "ESG alerts", total: 8, qualifier: "Benchmark 4", severity: "medium" },
+];
+const notifications = [
+    {
+        id: "concentration-change",
+        category: "Concentration alerts",
+        headline: "Country concentration change",
+        source: "Transactions",
+        priority: "amber",
+        raised: "2026-09-28T09:14:00Z",
+    },
+    {
+        id: "quake-c9400-a",
+        category: "Disruption exposures",
+        headline: "Earthquake impacts order 2021-11-16_C9400",
+        source: "GDACS",
+        priority: "red",
+        raised: "2026-09-27T22:02:00Z",
+    },
+    {
+        id: "quake-c9400-b",
+        category: "Disruption exposures",
+        headline: "Earthquake impacts order 2022-01-24_C9400",
+        source: "GDACS",
+        priority: "red",
+        raised: "2026-09-27T18:40:00Z",
+    },
+    {
+        id: "tariff-cn",
+        category: "Tariff exposures",
+        headline: "Tariff exposure raised on 13 inbound lanes from CN",
+        source: "Trade",
+        priority: "amber",
+        raised: "2026-09-26T11:20:00Z",
+    },
+];
+const disruptions = [
+    {
+        id: "taiwan-quake",
+        category: "Disruption exposures",
+        headline: "Red earthquake alert (Magnitude 9.8M, Depth 35km) in Taiwan 09/11/2021 06:25 UTC, 1,030,000 people within 100km",
+        source: "GDACS",
+        priority: "red",
+        raised: "2026-09-25T06:25:00Z",
+    },
+    {
+        id: "krakatau",
+        category: "Disruption exposures",
+        headline: "Volcanic eruption is ongoing for Krakatau in Indonesia",
+        source: "GDACS",
+        priority: "green",
+        raised: "2026-09-24T14:10:00Z",
+    },
+];
+/** Concentration climbing through 2019–2022, the way the reference screen's history does. */
+const history = Array.from({ length: 28 }, (_, index) => {
+    const month = new Date(Date.UTC(2019, 9 + index, 1)).toISOString().slice(0, 7);
+    return { month, concentration: Math.round((38 + index * 1.6 + Math.sin(index / 2) * 4) * 100) / 100 };
+});
+const raisedRows = (rows, category) => answer(["this", "headline", "source", "priority", "raised", "category"], rows
+    .filter((row) => category === undefined || row.category === category)
+    .map((row) => ({
+    this: uri(`${alert}${row.id}`),
+    headline: text(row.headline),
+    source: text(row.source),
+    priority: text(row.priority),
+    raised: date(row.raised),
+    category: text(row.category),
+})));
+/**
+ * What a variable was narrowed to, as the compiled query carries it.
+ *
+ * `compileBinding` writes a bound parameter in as `VALUES ?name { <iri> }` or `VALUES ?name { "text" }`, so
+ * a fixture that wants to behave like a datastore reads it back out of the text it was handed.
+ */
+const narrowedTo = (query, name) => {
+    const match = new RegExp(`VALUES \\?${name} \\{\\s*(?:<([^>]+)>|"([^"]*)")`).exec(query);
+    return match?.[1] ?? match?.[2];
+};
+/** The IRIs a label pass is asking about, in the order the `VALUES` names them. */
+const askedFor = (query) => {
+    const values = /VALUES \?entity \{([^}]*)\}/.exec(query)?.[1] ?? "";
+    return [...values.matchAll(/<([^>]+)>/g)].flatMap((match) => (match[1] === undefined ? [] : [match[1]]));
+};
+function respond(query) {
+    // The label pass, which every view depends on: a row carries an IRI and shows the thing's name.
+    if (query.includes("SELECT ?entity ?name") && query.includes("VALUES ?entity")) {
+        return answer(["entity", "name"], askedFor(query).flatMap((iri) => {
+            const name = names[iri];
+            return name === undefined ? [] : [{ entity: uri(iri), name: text(name) }];
+        }));
+    }
+    if (query.includes("factsetIndustry")) {
+        return answer(["this", "name", "industry", "country", "entityType"], [
+            {
+                this: uri(referenceEntity),
+                name: text("Cisco Systems, Inc."),
+                industry: text("Factset Industry · Information Technology Services"),
+                country: uri(`${country}us`),
+                entityType: text("Public company"),
+            },
+        ]);
+    }
+    if (query.includes("placedOrder")) {
+        return answer(["outgoing", "outgoingValue", "suppliers", "customers"], [
+            {
+                outgoing: number(7739),
+                outgoingValue: number(2923174261),
+                suppliers: number(8),
+                customers: number(125),
+            },
+        ]);
+    }
+    if (query.includes('alertKind "notification"'))
+        return raisedRows(notifications, narrowedTo(query, "category"));
+    if (query.includes('alertKind "disruption"'))
+        return raisedRows(disruptions, narrowedTo(query, "category"));
+    if (query.includes("alertKind")) {
+        return answer(["kind", "total", "qualifier", "severity"], flags.map((flag) => ({
+            kind: text(flag.kind),
+            total: number(flag.total),
+            severity: text(flag.severity),
+            ...(flag.qualifier === undefined ? {} : { qualifier: text(flag.qualifier) }),
+        })));
+    }
+    if (query.includes("buyerConcentration")) {
+        return answer(["this", "buyerConcentration", "supplierConcentration", "disruptions"], exposures.map((one) => ({
+            this: uri(`${country}${one.id}`),
+            buyerConcentration: number(one.buyer),
+            supplierConcentration: number(one.supplier),
+            disruptions: number(one.disruptions),
+        })));
+    }
+    if (query.includes("concentrationScore")) {
+        return answer(["month", "concentration"], history.map((one) => ({ month: text(one.month), concentration: number(one.concentration) })));
+    }
+    if (query.includes("ltmConcentration")) {
+        const only = narrowedTo(query, "country");
+        return answer(["this", "concentration", "yearOnYear", "country"], suppliers
+            .filter((one) => only === undefined || `${country}${one.country}` === only)
+            .map((one) => ({
+            this: uri(`${entity}${one.id}`),
+            concentration: number(one.concentration),
+            yearOnYear: number(one.yearOnYear),
+            country: uri(`${country}${one.country}`),
+        })));
+    }
+    return nothing;
+}
+/** A `SparqlSelect` over the fixture. Async because every other one is, not because anything waits. */
+export const fakeSparqlSelect = (query) => Promise.resolve(respond(query));

package/dist/lib/shapes/ldkit-source.d.ts

@@ -10,5 +10,5 @@ export declare const generatedRoot: URL;
 /** Whether `just generate` has been run for this realm in this checkout. */
 export declare function hasGeneratedSchemas(realm: Realm, root?: URL): boolean;
 export declare const generatedNotice = "built from this realm's own datastore shapes, which are a subset of the canonical set";
-/** Node only: it reads the filesystem. The worker reads the snapshot `shapes:snapshot` wrote. */
+/** Node only: it reads the filesystem. `hornsShapeCatalog` calls it at build time; a worker never does. */
 export declare function ldkitSchemasFor(realm: Realm, root?: URL, preferGenerated?: boolean): Promise<LdkitSource>;

package/dist/lib/shapes/ldkit-source.js

@@ -17,7 +17,7 @@ export function hasGeneratedSchemas(realm, root = generatedRoot) {
     return existsSync(new URL("index.ts", generatedDirFor(realm, root)));
 }
 export const generatedNotice = "built from this realm's own datastore shapes, which are a subset of the canonical set";
-/** Node only: it reads the filesystem. The worker reads the snapshot `shapes:snapshot` wrote. */
+/** Node only: it reads the filesystem. `hornsShapeCatalog` calls it at build time; a worker never does. */
 export async function ldkitSchemasFor(realm, root = generatedRoot, preferGenerated = false) {
     if (preferGenerated && hasGeneratedSchemas(realm, root)) {
         return { module: await import(__rewriteRelativeImportExtension(new URL("index.ts", generatedDirFor(realm, root)).href)), origin: "generated" };

package/dist/lib/studio-progress.js

@@ -28,7 +28,9 @@ export function studioProgressLine(line) {
     return match(event["type"])
         .with("reading", () => step("Reading the Horn and the data behind it"))
         .with("round", () => (event["step"] === 1 && agent === undefined ? step("Thinking") : undefined))
-        .with("tool-call", () => event["repeated"] === true || name === "propose_horn_patch" ? undefined : step(toolLines[name] ?? `Using ${name}`))
+        .with("tool-call", () => event["repeated"] === true || name === "propose_horn_patch"
+        ? undefined
+        : step(toolLines[name] ?? `Using ${name}`))
         .with("proposal-accepted", () => (name === "propose_horn_patch" ? step("Changed the Horn") : undefined))
         .with("proposal-rejected", () => step("That change did not hold up against the data, trying again"))
         .with("rehydrated", () => step("Starting over from the Horn as it stands"))

package/dist/lib/surface/declarations.d.ts

@@ -0,0 +1,5 @@
+/** One entry per surfaced export: the declaration text the Studio may read. */
+export type ComponentApi = Readonly<Record<string, string>>;
+/** Node only: `import.meta.resolve` is unavailable under vitest's transform, so a test passes its own root. */
+export declare function sdkDistRoot(): string;
+export declare function componentApiFrom(root: string, hops?: number): ComponentApi;