@manta-eu/horns-client 0.1.0

package/dist/lib/horn-review.js

@@ -0,0 +1,59 @@
+import { hornSnapshotSchema } from "@manta-eu/horns/render";
+import { rasterizeHorn } from "../components/rasterize";
+import { isRecord } from "@manta-eu/horns";
+/**
+ * Draw the Horn that was just made, look at it, and say what is wrong.
+ *
+ * The browser is the only thing that can draw a Horn, so both answers come from one off-screen draw: a view
+ * that throws throws here, and the picture of the rest goes to a second model. Never throws — a Horn that
+ * changed has changed whether or not anyone managed to look at it.
+ */
+export async function reviewHorn(args) {
+    let problems = [];
+    try {
+        const snapshot = await snapshotOf(args);
+        const drawn = await rasterizeHorn(snapshot);
+        problems = drawn.problems;
+        const image = await dataUrl(drawn.png);
+        const response = await fetch(`/api/d/${encodeURIComponent(args.datastoreId)}/horns/review`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ image, asked: args.asked }),
+        });
+        const body = await response.json().catch(() => undefined);
+        if (!response.ok) {
+            const reason = isRecord(body) && typeof body["error"] === "string" ? body["error"] : undefined;
+            return { advice: [], problems, unavailable: reason ?? `The reviewer answered ${response.status}.` };
+        }
+        const said = isRecord(body) ? body["advice"] : undefined;
+        const advice = Array.isArray(said) ? said.filter((one) => typeof one === "string") : [];
+        return { advice, problems };
+    }
+    catch (caught) {
+        return {
+            advice: [],
+            problems,
+            unavailable: caught instanceof Error ? caught.message : "The Horn could not be drawn to look at.",
+        };
+    }
+}
+// The draft as it stands, not the preview's: the preview is still refetching when a turn ends.
+async function snapshotOf(args) {
+    const response = await fetch(`/api/d/${encodeURIComponent(args.datastoreId)}/horns/snapshot`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ horn: args.horn, ...(args.variables ? { variables: args.variables } : {}) }),
+    });
+    if (!response.ok)
+        throw new Error(`The draft could not be drawn (${response.status}).`);
+    const body = await response.json();
+    return hornSnapshotSchema.parse(isRecord(body) ? body["snapshot"] : undefined);
+}
+function dataUrl(png) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onerror = () => reject(new Error("The picture could not be read back."));
+        reader.onload = () => resolve(typeof reader.result === "string" ? reader.result : "");
+        reader.readAsDataURL(png);
+    });
+}

package/dist/lib/manta/__tests__/sdk-realm.d.ts

@@ -0,0 +1,2 @@
+import { type Realm } from "@manta-eu/horns";
+export declare function expectSdkRealm(realm: Realm): Promise<void>;

package/dist/lib/manta/__tests__/sdk-realm.js

@@ -0,0 +1,17 @@
+import { realmEnv, realmNamespace, realmNamespaces } from "@manta-eu/horns";
+import { expect, vi } from "vitest";
+// The SDK reads its realm once per module load, so each realm gets its own test file (and with it
+// a fresh module graph) rather than sharing one.
+export async function expectSdkRealm(realm) {
+    for (const [key, value] of Object.entries(realmEnv(realm)))
+        vi.stubEnv(key, value);
+    const { activeRealm, namespaces } = await import("@manta-eu/rdf-lib/namespaces");
+    const clientNamespaces = Object.fromEntries(Object.entries(namespaces).filter((entry) => typeof entry[1] === "string"));
+    expect(activeRealm()).toBe(realm);
+    expect(clientNamespaces[""]).toBe(realmNamespace(realm));
+    // Catalog CURIEs are expanded by @manta-eu/horns; they must land on the IRIs the SDK queries.
+    const shared = Object.entries(realmNamespaces(realm)).filter(([prefix]) => prefix in clientNamespaces);
+    expect(shared.length).toBeGreaterThan(10);
+    for (const [prefix, iri] of shared)
+        expect({ prefix, iri }).toEqual({ prefix, iri: clientNamespaces[prefix] });
+}

package/dist/lib/manta/ldo.d.ts

@@ -0,0 +1,6 @@
+import { activeRealm } from "@manta-eu/ldo/realm";
+export { activeRealm };
+export { namespaces, namespacesForRealm } from "@manta-eu/rdf-lib/namespaces";
+export { createSparqlEngine, createSparqlOptions } from "@manta-eu/react/engine";
+export { SparqlContext, optionsToContext, useSparqlEngine, useSparqlOptions, } from "@manta-eu/react/hooks/use-sparql-options";
+export { bindingValue, collectBindings } from "@manta-eu/react/ldo-ui";

package/dist/lib/manta/ldo.js

@@ -0,0 +1,14 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { activeRealm } from "@manta-eu/ldo/realm";
+export { activeRealm };
+export { namespaces, namespacesForRealm } from "@manta-eu/rdf-lib/namespaces";
+export { createSparqlEngine, createSparqlOptions } from "@manta-eu/react/engine";
+export { SparqlContext, optionsToContext, useSparqlEngine, useSparqlOptions, } from "@manta-eu/react/hooks/use-sparql-options";
+export { bindingValue, collectBindings } from "@manta-eu/react/ldo-ui";
+// The SDK composes every vocabulary IRI from the realm it resolved at module load. If the realm
+// shim in index.html did not run first, reads would silently return nothing, so fail loudly.
+const buildRealm = import.meta.env.VITE_KEYCLOAK_REALM;
+if (isPresent(buildRealm) && activeRealm() !== buildRealm) {
+    throw new Error(`The Manta SDK resolved the "${activeRealm()}" realm, but this build is for "${buildRealm}". ` +
+        "The realm shim must run before any module script.");
+}

package/dist/lib/manta/providers.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+import { QueryClient } from "@tanstack/react-query";
+export declare function datastoreSparqlPath(datastoreId: string): string;
+export declare function queryClientFor(datastoreId: string): QueryClient;
+type MantaSparqlProviderProps = {
+    datastoreId: string;
+    children: ReactNode;
+};
+export declare function MantaSparqlProvider({ datastoreId, children }: MantaSparqlProviderProps): import("react").JSX.Element;
+export {};

package/dist/lib/manta/providers.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { isRecord } from "@manta-eu/horns";
+import { SparqlContext, createSparqlEngine, createSparqlOptions } from "./ldo";
+export function datastoreSparqlPath(datastoreId) {
+    return `/d/${encodeURIComponent(datastoreId)}/sparql`;
+}
+function fetchWithSparqlErrorBody(baseFetch) {
+    return async (input, init) => {
+        const response = await baseFetch(input, init);
+        if (response.ok)
+            return response;
+        const text = await response.text();
+        let detail = text;
+        try {
+            const parsed = JSON.parse(text);
+            if (isRecord(parsed) && typeof parsed.error === "string" && parsed.error.trim())
+                detail = parsed.error;
+        }
+        catch {
+            // Non-JSON upstream body — keep the raw text.
+        }
+        throw new Error(`${response.status} ${response.statusText} — ${detail}`);
+    };
+}
+// One cache per datastore: a cache shared across datastores would answer one tenant's rows under
+// another tenant's name the moment someone opens a different datastore.
+const clientsByDatastore = new Map();
+export function queryClientFor(datastoreId) {
+    const existing = clientsByDatastore.get(datastoreId);
+    if (existing)
+        return existing;
+    const created = new QueryClient({ defaultOptions: { queries: { refetchOnWindowFocus: false, retry: 1 } } });
+    clientsByDatastore.set(datastoreId, created);
+    return created;
+}
+export function MantaSparqlProvider({ datastoreId, children }) {
+    const client = queryClientFor(datastoreId);
+    const value = useMemo(() => {
+        const options = createSparqlOptions({ sparqlEndpoint: datastoreSparqlPath(datastoreId) });
+        return {
+            options: { ...options, fetch: fetchWithSparqlErrorBody(options.fetch ?? fetch) },
+            engine: createSparqlEngine(),
+        };
+    }, [datastoreId]);
+    return (_jsx(QueryClientProvider, { client: client, children: _jsx(SparqlContext.Provider, { value: value, children: children }) }));
+}

package/dist/lib/manta/session.d.ts

@@ -0,0 +1,47 @@
+import { type ReactNode } from "react";
+export type MantaDatastore = {
+    id: string;
+    name: string;
+    depth?: number;
+    selectable?: boolean;
+};
+export type MantaSessionUser = {
+    id: string;
+    email: string;
+    name?: string;
+    isOperator: boolean;
+    datastore?: MantaDatastore;
+};
+export type MantaSessionStatus = "loading" | "signed-out" | "ready" | "error";
+export type MantaSessionValue = {
+    status: MantaSessionStatus;
+    isLive: boolean;
+    user?: MantaSessionUser;
+    datastore?: MantaDatastore;
+    datastores: MantaDatastore[];
+    isOperator: boolean;
+    canSwitchDatastore: boolean;
+    error?: string;
+    authError?: string;
+    justSignedIn: boolean;
+    revision: number;
+    reload: () => void;
+};
+export declare function signInHref(redirect?: string): string;
+export declare function readJsonError(response: Response, fallback: string): Promise<string>;
+export declare class RequestFailed extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare function statusOf(caught: unknown): number | undefined;
+export declare function requestJson<T>(path: string, init: RequestInit, fallback: string, parse: (body: unknown) => T): Promise<T | undefined>;
+export type SessionGate = "loading" | "sign-in" | "looped" | "blocked" | "ready";
+export declare function sessionGate(value: Pick<MantaSessionValue, "status" | "authError" | "justSignedIn">): SessionGate;
+export declare function realmDatastore(value: Pick<MantaSessionValue, "datastores">): MantaDatastore | undefined;
+export declare function activeDatastore(value: Pick<MantaSessionValue, "isOperator" | "user" | "datastores">): MantaDatastore | undefined;
+type MantaSessionProviderProps = {
+    children: ReactNode;
+};
+export declare function MantaSessionProvider({ children }: MantaSessionProviderProps): import("react").JSX.Element;
+export declare function useMantaSession(): MantaSessionValue;
+export {};

package/dist/lib/manta/session.js

@@ -0,0 +1,204 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, use, useCallback, useEffect, useMemo, useState } from "react";
+import { isPresent } from "@manta-eu/lib/present";
+import { isRecord, isString } from "@manta-eu/horns";
+import { signedInParam } from "@manta-eu/horns-server/shared";
+export function signInHref(redirect) {
+    const params = new URLSearchParams();
+    if (isPresent(redirect) && redirect !== "/")
+        params.set("redirect", redirect);
+    const query = params.toString();
+    return `/login${query ? `?${query}` : ""}`;
+}
+export async function readJsonError(response, fallback) {
+    const body = await response.json().catch(() => undefined);
+    if (typeof body === "object" && isPresent(body) && "error" in body && typeof body.error === "string") {
+        return body.error;
+    }
+    return fallback;
+}
+export class RequestFailed extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = "RequestFailed";
+        this.status = status;
+    }
+}
+export function statusOf(caught) {
+    return caught instanceof RequestFailed ? caught.status : undefined;
+}
+// 204 responses are success, not a parse failure. The body is untrusted until `parse` has checked it.
+export async function requestJson(path, init, fallback, parse) {
+    const response = await fetch(path, { credentials: "same-origin", ...init });
+    if (!response.ok)
+        throw new RequestFailed(response.status, await readJsonError(response, fallback));
+    const text = await response.text();
+    if (!isPresent(text.trim()))
+        return undefined;
+    const body = JSON.parse(text);
+    return parse(body);
+}
+const readJson = (path, fallback, parse) => requestJson(path, { headers: { accept: "application/json" } }, fallback, parse);
+function parseDatastore(value) {
+    if (!isRecord(value) || typeof value.id !== "string" || typeof value.name !== "string")
+        return undefined;
+    return {
+        id: value.id,
+        name: value.name,
+        ...(typeof value.depth === "number" ? { depth: value.depth } : {}),
+        ...(typeof value.selectable === "boolean" ? { selectable: value.selectable } : {}),
+    };
+}
+function parseLoginStatus(body) {
+    if (!isRecord(body) || typeof body.valid !== "boolean")
+        throw new Error("Sign-in status is malformed.");
+    return {
+        valid: body.valid,
+        canSwitchDatastore: body.canSwitchDatastore === true,
+        allowedModels: Array.isArray(body.allowedModels) ? body.allowedModels.filter(isString) : [],
+    };
+}
+function parseUserContext(body) {
+    if (!isRecord(body) || !isRecord(body.user))
+        throw new Error("User context is malformed.");
+    const { user } = body;
+    if (typeof user.id !== "string" || typeof user.email !== "string")
+        throw new Error("User context is malformed.");
+    const datastore = parseDatastore(user.datastore);
+    return {
+        user: {
+            id: user.id,
+            email: user.email,
+            isOperator: user.isOperator === true,
+            ...(typeof user.name === "string" ? { name: user.name } : {}),
+            ...(datastore ? { datastore } : {}),
+        },
+        datastores: Array.isArray(body.datastores) ? body.datastores.flatMap((entry) => parseDatastore(entry) ?? []) : [],
+    };
+}
+export function sessionGate(value) {
+    if (isPresent(value.authError))
+        return "blocked";
+    if (value.status === "loading")
+        return "loading";
+    if (value.status === "error")
+        return "blocked";
+    if (value.status === "signed-out")
+        return value.justSignedIn ? "looped" : "sign-in";
+    return "ready";
+}
+// The realm's own top-level datastore is the one with no depth that cannot be picked.
+export function realmDatastore(value) {
+    return value.datastores.find((datastore) => !isPresent(datastore.depth) && datastore.selectable !== true);
+}
+export function activeDatastore(value) {
+    if (isPresent(value.user?.datastore))
+        return value.user.datastore;
+    if (!value.isOperator)
+        return undefined;
+    return realmDatastore(value);
+}
+const MantaSessionContext = createContext(undefined);
+function readAuthError() {
+    const raw = new URLSearchParams(window.location.search).get("auth_error");
+    return isPresent(raw) ? raw : undefined;
+}
+function readJustSignedIn() {
+    return new URLSearchParams(window.location.search).get(signedInParam) === "1";
+}
+export function MantaSessionProvider({ children }) {
+    const [status, setStatus] = useState("loading");
+    const [context, setContext] = useState();
+    const [canSwitchDatastore, setCanSwitchDatastore] = useState(false);
+    const [error, setError] = useState();
+    const [reloads, setReloads] = useState(0);
+    const [revision, setRevision] = useState(0);
+    const [authError, setAuthError] = useState(readAuthError);
+    const [justSignedIn] = useState(readJustSignedIn);
+    useEffect(() => {
+        if (!isPresent(authError) && !justSignedIn)
+            return;
+        const url = new URL(window.location.href);
+        url.searchParams.delete("auth_error");
+        url.searchParams.delete(signedInParam);
+        window.history.replaceState(window.history.state, "", url.pathname + url.search);
+    }, [authError, justSignedIn]);
+    useEffect(() => {
+        let live = true;
+        void (async () => {
+            if (reloads === 0)
+                setStatus("loading");
+            setError(undefined);
+            try {
+                const login = await readJson("/api/login", "Sign-in status is unavailable.", parseLoginStatus);
+                if (!live)
+                    return;
+                if (!isPresent(login))
+                    throw new Error("Sign-in status is unavailable.");
+                setCanSwitchDatastore(login.canSwitchDatastore);
+                if (!login.valid) {
+                    setContext(undefined);
+                    setStatus("signed-out");
+                    return;
+                }
+                const loaded = await readJson("/api/data/context", "User context is unavailable.", parseUserContext);
+                if (!live)
+                    return;
+                if (!isPresent(loaded))
+                    throw new Error("User context is unavailable.");
+                setContext(loaded);
+                setStatus("ready");
+                setRevision((count) => count + 1);
+            }
+            catch (caught) {
+                if (!live)
+                    return;
+                // The upstream session can expire between the /api/login check and this fetch.
+                if (statusOf(caught) === 401) {
+                    setContext(undefined);
+                    setStatus("signed-out");
+                    return;
+                }
+                setError(caught instanceof Error ? caught.message : "Manta Horns is unavailable.");
+                setStatus("error");
+            }
+        })();
+        return () => {
+            live = false;
+        };
+    }, [reloads]);
+    const reload = useCallback(() => {
+        setAuthError(undefined);
+        setReloads((count) => count + 1);
+    }, []);
+    const value = useMemo(() => {
+        const isOperator = context?.user.isOperator ?? false;
+        const datastore = activeDatastore({
+            isOperator,
+            ...(isPresent(context) ? { user: context.user } : {}),
+            datastores: context?.datastores ?? [],
+        });
+        return {
+            status,
+            isLive: status === "ready",
+            ...(isPresent(context) ? { user: context.user } : {}),
+            ...(isPresent(datastore) ? { datastore } : {}),
+            datastores: context?.datastores ?? [],
+            isOperator,
+            canSwitchDatastore,
+            ...(isPresent(error) ? { error } : {}),
+            ...(isPresent(authError) ? { authError } : {}),
+            justSignedIn,
+            revision,
+            reload,
+        };
+    }, [status, context, canSwitchDatastore, error, authError, justSignedIn, revision, reload]);
+    return _jsx(MantaSessionContext.Provider, { value: value, children: children });
+}
+export function useMantaSession() {
+    const value = use(MantaSessionContext);
+    if (!isPresent(value))
+        throw new Error("useMantaSession must be used inside MantaSessionProvider");
+    return value;
+}

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

@@ -0,0 +1,2 @@
+import { type SparqlSelect } from "@manta-eu/horns";
+export declare function browserSparqlSelect(datastoreId: string): SparqlSelect;

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

@@ -0,0 +1,19 @@
+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) {
+    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,
+            ...(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);
+    };
+}

package/dist/lib/plan-runs.d.ts

@@ -0,0 +1,14 @@
+import type { PlanStatus } from "@manta-eu/horns/render";
+export declare const planPollInterval = 2000;
+export declare const planPollAttempts = 120;
+/**
+ * Whether the graph has caught up with a run just started: a run newer than the one before it, and finished. Right
+ * after starting, the graph still says how the previous run ended, which is not an answer.
+ */
+export declare function runSettled(status: PlanStatus, startedBefore: string | undefined): boolean;
+export declare function runSeen(status: PlanStatus, startedBefore: string | undefined): boolean;
+export declare function startPlanRun(args: {
+    datastoreId: string;
+    plan: string;
+    preview: boolean;
+}): Promise<void>;

package/dist/lib/plan-runs.js

@@ -0,0 +1,26 @@
+import { problemFrom } from "./problem";
+export const planPollInterval = 2000;
+export const planPollAttempts = 120;
+/**
+ * Whether the graph has caught up with a run just started: a run newer than the one before it, and finished. Right
+ * after starting, the graph still says how the previous run ended, which is not an answer.
+ */
+export function runSettled(status, startedBefore) {
+    const started = status.lastRun?.startedAt;
+    return started !== undefined && started !== startedBefore && status.state !== "running";
+}
+export function runSeen(status, startedBefore) {
+    const started = status.lastRun?.startedAt;
+    return started !== undefined && started !== startedBefore;
+}
+export async function startPlanRun(args) {
+    const response = await fetch(`/api/d/${encodeURIComponent(args.datastoreId)}/action-plans/run`, {
+        method: "POST",
+        credentials: "same-origin",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ plan: args.plan, preview: args.preview }),
+    });
+    if (response.ok)
+        return;
+    throw new Error(await problemFrom(response, `The plan could not be started (${response.status}).`));
+}

package/dist/lib/problem.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The sentence to show when a request did not work out. Every route answers `{ error }` when it has something
+ * to say; anything else — a proxy's HTML, an empty body, a worker that crashed — has only its status, so the
+ * caller supplies the words for that case.
+ */
+export declare function problemOf(body: unknown, fallback: string): string;
+/** The same, for a response nobody has read yet: a body that is not JSON is no worse than one without `error`. */
+export declare function problemFrom(response: Response, fallback: string): Promise<string>;

package/dist/lib/problem.js

@@ -0,0 +1,16 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { isRecord } from "@manta-eu/horns";
+/**
+ * The sentence to show when a request did not work out. Every route answers `{ error }` when it has something
+ * to say; anything else — a proxy's HTML, an empty body, a worker that crashed — has only its status, so the
+ * caller supplies the words for that case.
+ */
+export function problemOf(body, fallback) {
+    const said = isRecord(body) ? body["error"] : undefined;
+    return typeof said === "string" && isPresent(said) ? said : fallback;
+}
+/** The same, for a response nobody has read yet: a body that is not JSON is no worse than one without `error`. */
+export async function problemFrom(response, fallback) {
+    const body = await response.json().catch(() => undefined);
+    return problemOf(body, fallback);
+}

package/dist/lib/shapes/catalog.d.ts

@@ -0,0 +1,14 @@
+import { type Realm } from "@manta-eu/horns";
+import type { ShapeCatalog } from "@manta-eu/horns/shapes";
+export declare function shapesRealm(): Realm;
+export type ShapeCatalogSource = (realm: Realm) => ShapeCatalog;
+/**
+ * Hand Horns the realm's SHACL-derived shapes. A host builds them from its own `@manta-eu/ldo` schemas with
+ * `shapeCatalogFromLdkit`, at build time, and passes the result here before mounting.
+ *
+ * Horns ships no catalog of its own: the shapes describe a realm's data model, so they belong to whoever
+ * deploys rather than to the library.
+ */
+export declare function provideShapeCatalog(next: ShapeCatalogSource): void;
+/** The realm's shapes, as the host supplied them. */
+export declare function ldkitShapeCatalog(): ShapeCatalog;

package/dist/lib/shapes/catalog.js

@@ -0,0 +1,25 @@
+import { activeRealm } from "@manta-eu/ldo/realm";
+import { parseRealm } from "@manta-eu/horns";
+export function shapesRealm() {
+    return parseRealm(activeRealm());
+}
+let source;
+/**
+ * Hand Horns the realm's SHACL-derived shapes. A host builds them from its own `@manta-eu/ldo` schemas with
+ * `shapeCatalogFromLdkit`, at build time, and passes the result here before mounting.
+ *
+ * Horns ships no catalog of its own: the shapes describe a realm's data model, so they belong to whoever
+ * deploys rather than to the library.
+ */
+export function provideShapeCatalog(next) {
+    source = next;
+}
+/** The realm's shapes, as the host supplied them. */
+export function ldkitShapeCatalog() {
+    if (!source) {
+        throw new Error("No shape catalog: call provideShapeCatalog() before mounting. Build one for your realm with " +
+            "shapeCatalogFromLdkit() from @manta-eu/horns/shapes. Answering with no shapes would look like an " +
+            "empty datastore rather than a missing build step.");
+    }
+    return source(shapesRealm());
+}

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

@@ -0,0 +1,14 @@
+import type { Realm } from "@manta-eu/horns";
+export type LdkitSource = {
+    /** An LDkit schema module: every `…Schema` export, as `shapeCatalogFromLdkit` reads them. */
+    module: object;
+    /** Whether this realm's own shapes were read, or the canonical set stood in for them. */
+    origin: "generated" | "canonical";
+};
+/** Where `just generate` writes. A parameter only so a test can point at a fixture tree. */
+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. */
+export declare function ldkitSchemasFor(realm: Realm, root?: URL, preferGenerated?: boolean): Promise<LdkitSource>;

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

@@ -0,0 +1,26 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from "node:fs";
+/** Where `just generate` writes. A parameter only so a test can point at a fixture tree. */
+export const generatedRoot = new URL("../../generated/ldkit/", import.meta.url);
+function generatedDirFor(realm, root) {
+    return new URL(`${realm}/`, root);
+}
+/** Whether `just generate` has been run for this realm in this checkout. */
+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. */
+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" };
+    }
+    return { module: await import("@manta-eu/ldo/schemas"), origin: "canonical" };
+}

package/dist/lib/studio-progress.d.ts

@@ -0,0 +1,7 @@
+/** One thing a turn did, as a watcher reads it: what it was, and what it was on. */
+export type StudioStep = {
+    title: string;
+    detail?: string;
+};
+/** One line for one streamed event, or nothing for an event not worth a line of its own. */
+export declare function studioProgressLine(line: Record<string, unknown>): StudioStep | undefined;

package/dist/lib/studio-progress.js

@@ -0,0 +1,36 @@
+import { match } from "ts-pattern";
+import { isRecord } from "@manta-eu/horns";
+// What a Horn turn is doing, in words, from the events the route streams. A tool name is the model's
+// vocabulary; the person watching wants to know what is being looked at.
+const toolLines = {
+    list_classes: "Looking at what this datastore holds",
+    describe_class: "Reading how a kind of thing is described",
+    components_for_class: "Looking for components that already fit",
+    run_sparql: "Querying the datastore",
+    investigate_data: "Investigating the data",
+    propose_horn_patch: "Changing the Horn",
+    propose_library_item: "Offering a part for the library",
+    report_harness_issue: "Noting a problem with the tools",
+};
+// A turn can start a loop of its own. Its steps are the same steps, said by somebody else.
+const agentNames = { investigate: "Investigating" };
+/** One line for one streamed event, or nothing for an event not worth a line of its own. */
+export function studioProgressLine(line) {
+    const event = line["event"];
+    if (!isRecord(event))
+        return undefined;
+    const name = typeof event["name"] === "string" ? event["name"] : "";
+    const detail = typeof event["detail"] === "string" ? event["detail"] : undefined;
+    const agent = typeof event["agent"] === "string" ? (agentNames[event["agent"]] ?? event["agent"]) : undefined;
+    const step = (title) => title === undefined
+        ? undefined
+        : { title: agent === undefined ? title : `${agent} · ${title}`, ...(detail === undefined ? {} : { detail }) };
+    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("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"))
+        .otherwise(() => undefined);
+}

package/dist/lib/telemetry/sentry.d.ts

@@ -0,0 +1 @@
+export declare function initSentry(): void;