@manta-eu/horns-client 0.1.0 → 0.1.2

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;

package/dist/lib/surface/declarations.js

@@ -0,0 +1,77 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { moduleOfExport, sdkModules, surfaceExports } from "@manta-eu/horns/render";
+/** Above this an entry is a type tree nobody can read, and the walk stopped somewhere it should not have. */
+const maxEntryChars = 6000;
+/** Node only: `import.meta.resolve` is unavailable under vitest's transform, so a test passes its own root. */
+export function sdkDistRoot() {
+    return join(dirname(dirname(fileURLToPath(import.meta.resolve("@manta-eu/react")))), "dist");
+}
+function declarationFilesIn(directory) {
+    return readdirSync(directory).flatMap((entry) => {
+        const path = join(directory, entry);
+        if (statSync(path).isDirectory())
+            return declarationFilesIn(path);
+        return path.endsWith(".d.ts") ? [path] : [];
+    });
+}
+/** A declaration and its body, from `export …` to the `;` that closes it. */
+function blockOf(texts, name) {
+    const pattern = new RegExp(`^export (?:declare (?:const|function|class)|type|interface) ${name}\\b`, "m");
+    for (const text of texts) {
+        const start = text.search(pattern);
+        if (start < 0)
+            continue;
+        let depth = 0;
+        for (let at = start; at < text.length; at += 1) {
+            const character = text[at];
+            if (character === "{")
+                depth += 1;
+            else if (character === "}")
+                depth -= 1;
+            else if (character === ";" && depth === 0)
+                return text.slice(start, at + 1);
+        }
+        return text.slice(start);
+    }
+    return undefined;
+}
+/**
+ * The export's declaration plus the ones it names, transitively.
+ *
+ * A props type sits beside its component and may name a schema elsewhere — `BarChartProps` reaches
+ * `BarChartData` reaches `barChartSchema`. Following the names keeps the answer to what the export is,
+ * where a whole directory would hand over every chart in the design system.
+ */
+function scopeOf(texts, name, hops) {
+    const first = blockOf(texts, name);
+    if (first === undefined)
+        return undefined;
+    const seen = new Set([name]);
+    const blocks = [first];
+    for (let hop = 0; hop < hops; hop += 1) {
+        const named = [...blocks.join("\n").matchAll(/\b([A-Za-z_$][\w$]*)\b/g)].flatMap((match) => match[1] ?? []);
+        for (const referenced of named) {
+            if (seen.has(referenced))
+                continue;
+            seen.add(referenced);
+            const block = blockOf(texts, referenced);
+            if (block !== undefined)
+                blocks.push(block);
+        }
+    }
+    return blocks.join("\n");
+}
+export function componentApiFrom(root, hops = 3) {
+    const texts = declarationFilesIn(root).map((path) => readFileSync(path, "utf8"));
+    // Only the design system's own: React's hooks and the kit's plan module are not its to declare.
+    const names = [...new Set(sdkModules.flatMap((module) => [...(surfaceExports(module) ?? [])]))].sort();
+    return Object.freeze(Object.fromEntries(names.flatMap((name) => {
+        const scope = scopeOf(texts, name, hops);
+        if (scope === undefined || scope.length > maxEntryChars)
+            return [];
+        const from = moduleOfExport(name);
+        return [[name, `// ${name}, from "${from ?? "@manta-eu/react"}"\n${scope}`]];
+    })));
+}

package/dist/lib/written-surface.js

@@ -1,10 +1,21 @@
 import { useCallback, useId, useMemo, useState } from "react";
+import { viewPowersModule } from "@manta-eu/horns/render";
 // The whole barrel, because a view may reach for any of it; `createSurfaceLoader` narrows it to the declared
 // exports before the view sees it. Dynamic, and held at module scope: `WrittenView` recompiles whenever this
 // identity changes.
 export const loadWrittenSurface = async () => {
-    const [react, chart] = await Promise.all([import("@manta-eu/react"), import("@manta-eu/react/chart")]);
-    return { "@manta-eu/react": react, "@manta-eu/react/chart": chart };
+    const [react, chart, plan, explain] = await Promise.all([
+        import("@manta-eu/react"),
+        import("@manta-eu/react/chart"),
+        import("@manta-eu/horns-kit/plan"),
+        import("@manta-eu/horns-kit/view"),
+    ]);
+    return {
+        "@manta-eu/react": react,
+        "@manta-eu/react/chart": chart,
+        "@manta-eu/horns-kit/plan": plan,
+        [viewPowersModule]: explain,
+    };
 };
 // This app's React, so a view's state lives in the same reconciler as the page rather than in a second copy.
 export const writtenHooks = { useState, useMemo, useCallback, useId };