@manta-eu/horns-client 0.1.0 → 0.1.1

package/dist/vite/component-api.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "vite";
+export declare const componentApiModuleId = "virtual:horns/component-api";
+/**
+ * What each surfaced component takes, as `virtual:horns/component-api`, read from `@manta-eu/react`'s `.d.ts`.
+ *
+ * A worker has no filesystem, so the declarations arrive as data, the way the shape catalog does.
+ */
+export declare function hornsComponentApi(): Plugin;

package/dist/vite/component-api.js

@@ -0,0 +1,24 @@
+import { componentApiFrom, sdkDistRoot } from "../lib/surface/declarations.js";
+export const componentApiModuleId = "virtual:horns/component-api";
+/**
+ * What each surfaced component takes, as `virtual:horns/component-api`, read from `@manta-eu/react`'s `.d.ts`.
+ *
+ * A worker has no filesystem, so the declarations arrive as data, the way the shape catalog does.
+ */
+export function hornsComponentApi() {
+    const resolved = `\0${componentApiModuleId}`;
+    let built;
+    return {
+        name: "horns-component-api",
+        resolveId: (id) => (id === componentApiModuleId ? resolved : undefined),
+        load(id) {
+            if (id !== resolved)
+                return undefined;
+            if (built !== undefined)
+                return built;
+            const api = componentApiFrom(sdkDistRoot());
+            built = `export const api = ${JSON.stringify(api)};\n`;
+            return built;
+        },
+    };
+}

package/dist/vite/index.d.ts

@@ -0,0 +1,3 @@
+export { hornsShapeCatalog, shapeCatalogModuleId } from "./shape-catalog.ts";
+export { hornsComponentApi, componentApiModuleId } from "./component-api.ts";
+export { hornsTypecheckFs, typecheckFsModuleId } from "./typecheck-fs.ts";

package/dist/vite/index.js

@@ -0,0 +1,3 @@
+export { hornsShapeCatalog, shapeCatalogModuleId } from "./shape-catalog.js";
+export { hornsComponentApi, componentApiModuleId } from "./component-api.js";
+export { hornsTypecheckFs, typecheckFsModuleId } from "./typecheck-fs.js";

package/dist/vite/shape-catalog.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from "vite";
+import { type Realm } from "@manta-eu/horns";
+export declare const shapeCatalogModuleId = "virtual:horns/shape-catalog";
+/**
+ * The realm's shape catalog as `virtual:horns/shape-catalog`, built from `@manta-eu/ldo` at build time.
+ *
+ * A worker cannot import the SDK's schema entry without stopping workerd, so the catalog has to arrive as
+ * data. One realm per build, because the SDK resolves its realm at module load.
+ */
+export declare function hornsShapeCatalog(realm: Realm): Plugin;

package/dist/vite/shape-catalog.js

@@ -0,0 +1,35 @@
+import { realmEnv } from "@manta-eu/horns";
+import { shapeCatalogFromLdkit } from "@manta-eu/horns/shapes";
+import { ldkitSchemasFor } from "../lib/shapes/ldkit-source.js";
+export const shapeCatalogModuleId = "virtual:horns/shape-catalog";
+// Sorted, so the emitted chunk changes when the shapes do and not when the SDK reorders its exports.
+function stable(catalog) {
+    const compare = (a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b));
+    return { shapes: [...catalog.shapes].sort(compare), untargeted: [...catalog.untargeted].sort() };
+}
+/**
+ * The realm's shape catalog as `virtual:horns/shape-catalog`, built from `@manta-eu/ldo` at build time.
+ *
+ * A worker cannot import the SDK's schema entry without stopping workerd, so the catalog has to arrive as
+ * data. One realm per build, because the SDK resolves its realm at module load.
+ */
+export function hornsShapeCatalog(realm) {
+    const resolved = `\0${shapeCatalogModuleId}`;
+    let built;
+    return {
+        name: "horns-shape-catalog",
+        resolveId: (id) => (id === shapeCatalogModuleId ? resolved : undefined),
+        async load(id) {
+            if (id !== resolved)
+                return undefined;
+            if (built !== undefined)
+                return built;
+            // Before the import, not after: the schemas read the realm as they load.
+            Object.assign(process.env, realmEnv(realm));
+            const { module } = await ldkitSchemasFor(realm);
+            const catalog = stable(shapeCatalogFromLdkit(module, realm));
+            built = `export const catalog = ${JSON.stringify(catalog)};\n`;
+            return built;
+        },
+    };
+}

package/dist/vite/typecheck-fs.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "vite";
+export declare const typecheckFsModuleId = "virtual:horns/typecheck-fs";
+/** Node only: it reads the filesystem. The plugin calls it at build time; a worker never does. */
+export declare function typecheckFsFrom(): Record<string, string>;
+/** `virtual:horns/typecheck-fs`: TypeScript's own lib files plus the typings a view may import. */
+export declare function hornsTypecheckFs(): Plugin;

package/dist/vite/typecheck-fs.js

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { createRequire } from "node:module";
+export const typecheckFsModuleId = "virtual:horns/typecheck-fs";
+// The declarations a written view is checked against, gathered at build time because a worker has no
+// filesystem. Only `.d.ts` and the manifests the resolver reads: no implementation ships.
+const typed = ["@manta-eu/react", "@types/react", "csstype", "zod"];
+// The kit's own surface module. It is a workspace package whose `exports` point at `.tsx`, so what the
+// resolver wants is the source, not declarations — there are none to collect in this repo.
+const typedFromSource = ["@manta-eu/horns-kit"];
+function declarationsOf(pkg, root, into, fromSource = false) {
+    const extensions = fromSource ? [".ts", ".tsx"] : [".d.ts"];
+    const walk = (directory) => {
+        for (const entry of readdirSync(directory)) {
+            const path = join(directory, entry);
+            if (statSync(path).isDirectory()) {
+                // A workspace package is a link to its own checkout, so its `node_modules` and a built `dist` sit
+                // under it: following either pulls the tree in twice over, and `exports` points at `src` anyway.
+                // A published package is the other way round — `dist` is exactly where its typings are.
+                if (entry === "node_modules" || (fromSource && entry === "dist"))
+                    continue;
+                walk(path);
+                continue;
+            }
+            if (!extensions.some((one) => path.endsWith(one)) && entry !== "package.json")
+                continue;
+            into.set(`/node_modules/${pkg}/${relative(root, path).split("\\").join("/")}`, readFileSync(path, "utf8"));
+        }
+    };
+    walk(root);
+}
+/** Node only: it reads the filesystem. The plugin calls it at build time; a worker never does. */
+export function typecheckFsFrom() {
+    const require = createRequire(import.meta.url);
+    const files = new Map();
+    const lib = dirname(require.resolve("typescript"));
+    for (const entry of readdirSync(lib)) {
+        if (/^lib\..*\.d\.ts$/.test(entry))
+            files.set(`/${entry}`, readFileSync(join(lib, entry), "utf8"));
+    }
+    for (const pkg of [...typed, ...typedFromSource]) {
+        // Found by path, not by resolving `${pkg}/package.json`: an `exports` map may not list the manifest
+        // (`@manta-eu/react` does not), and a types-only package has no entry to resolve at all.
+        const root = (require.resolve.paths(pkg) ?? [])
+            .map((base) => join(base, pkg))
+            .find((candidate) => existsSync(join(candidate, "package.json")));
+        if (root === undefined)
+            throw new Error(`No typings found for ${pkg}; a written view cannot be checked.`);
+        declarationsOf(pkg, root, files, typedFromSource.includes(pkg));
+    }
+    // Sorted, so the chunk changes when the typings do and not when a directory is read back in another order.
+    return Object.fromEntries([...files].sort(([a], [b]) => a.localeCompare(b)));
+}
+/** `virtual:horns/typecheck-fs`: TypeScript's own lib files plus the typings a view may import. */
+export function hornsTypecheckFs() {
+    const resolved = `\0${typecheckFsModuleId}`;
+    let built;
+    return {
+        name: "horns-typecheck-fs",
+        resolveId: (id) => (id === typecheckFsModuleId ? resolved : undefined),
+        load(id) {
+            if (id !== resolved)
+                return undefined;
+            built ??= `export const fs = ${JSON.stringify(typecheckFsFrom())};\n`;
+            return built;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manta-eu/horns-client",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "The Manta Horns app as a library: routes, providers and the written-view runtime for a React host.",
   "license": "MIT",
   "repository": {
@@ -11,7 +11,10 @@
   "type": "module",
   "files": [
     "dist",
-    "LICENSE"
+    "LICENSE",
+    "shape-catalog.d.ts",
+    "component-api.d.ts",
+    "typecheck-fs.d.ts"
   ],
   "exports": {
     ".": {
@@ -24,12 +27,27 @@
     },
     "./styles.css": "./dist/styles.css",
     "./mount": {
-      "types": "./dist/client.d.ts",
-      "default": "./dist/client.js"
+      "types": "./dist/standalone/client.d.ts",
+      "default": "./dist/standalone/client.js"
     },
     "./ldkit-source": {
       "types": "./dist/lib/shapes/ldkit-source.d.ts",
       "default": "./dist/lib/shapes/ldkit-source.js"
+    },
+    "./vite": {
+      "types": "./dist/vite/index.d.ts",
+      "default": "./dist/vite/index.js"
+    },
+    "./shape-catalog": "./shape-catalog.d.ts",
+    "./component-api": "./component-api.d.ts",
+    "./surface-declarations": {
+      "types": "./dist/lib/surface/declarations.d.ts",
+      "default": "./dist/lib/surface/declarations.js"
+    },
+    "./typecheck-fs": "./typecheck-fs.d.ts",
+    "./typecheck-fs-source": {
+      "types": "./dist/vite/typecheck-fs.d.ts",
+      "default": "./dist/vite/typecheck-fs.js"
     }
   },
   "publishConfig": {
@@ -38,25 +56,31 @@
   },
   "dependencies": {
     "@ai-sdk/react": "^3.0.237",
-    "@manta-eu/ldo": "0.1.4",
-    "@manta-eu/lib": "0.1.4",
-    "@manta-eu/rdf-lib": "0.1.4",
-    "@manta-eu/react": "0.1.4",
+    "@manta-eu/client": "0.1.5",
+    "@manta-eu/ldo": "0.1.5",
+    "@manta-eu/lib": "0.1.5",
+    "@manta-eu/rdf-lib": "0.1.5",
+    "@manta-eu/react": "0.1.5",
     "@posthog/react": "^1.10.3",
     "@sentry/react": "^10.70.0",
     "@tanstack/react-query": "^5.101.4",
+    "@ulb-darmstadt/shacl-form": "^2.1.1-rc1",
+    "@xyflow/react": "^12.4.4",
+    "graphql-request": "^7.3.0",
     "html-to-image": "1.11.13",
-    "ldkit": "2.8.0",
+    "ldkit": "2.9.0",
     "lucide-react": "^0.525.0",
+    "next-themes": "^0.4.6",
+    "nuqs": "^2.10.1",
     "posthog-js": "^1.418.0",
     "react": "19.2.4",
     "react-dom": "19.2.4",
     "react-router": "^7.9.6",
     "ts-pattern": "^5.9.0",
     "zod": "^4.5.4",
-    "@manta-eu/horns-kit": "0.1.0",
-    "@manta-eu/horns-server": "0.1.0",
-    "@manta-eu/horns": "0.1.0"
+    "@manta-eu/horns": "0.1.1",
+    "@manta-eu/horns-kit": "0.1.1",
+    "@manta-eu/horns-server": "0.1.1"
   },
   "devDependencies": {
     "@tailwindcss/cli": "^4",

package/shape-catalog.d.ts

@@ -0,0 +1,9 @@
+// The module `hornsShapeCatalog` serves. A host picks up these types with
+// `/// <reference types="@manta-eu/horns-client/shape-catalog" />`, because a virtual module has no file
+// for TypeScript to find on its own.
+declare module "virtual:horns/shape-catalog" {
+  import type { ShapeCatalog } from "@manta-eu/horns/shapes";
+
+  /** The realm's shapes, as the build resolved them. */
+  export const catalog: ShapeCatalog;
+}

package/typecheck-fs.d.ts

@@ -0,0 +1,6 @@
+// The module `hornsTypecheckFs` serves. A host picks up these types with
+// `/// <reference types="@manta-eu/horns-client/typecheck-fs" />`.
+declare module "virtual:horns/typecheck-fs" {
+  /** Every `.d.ts` a written view is checked against, keyed by the path the compiler looks for. */
+  export const fs: Readonly<Record<string, string>>;
+}

package/dist/app/session-gate.d.ts

@@ -1,6 +0,0 @@
-import type { ReactNode } from "react";
-type SessionGateProps = {
-    children: ReactNode;
-};
-export declare function SessionGate({ children }: SessionGateProps): ReactNode;
-export {};

package/dist/app/session-gate.js

@@ -1,19 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useLocation } from "react-router";
-import { match } from "ts-pattern";
-import { sessionGate, signInHref, useMantaSession } from "../lib/manta/session";
-function Centered({ children }) {
-    return _jsx("main", { className: "grid min-h-screen place-items-center p-8 text-center", children: children });
-}
-export function SessionGate({ children }) {
-    const session = useMantaSession();
-    const location = useLocation();
-    const signIn = signInHref(`${location.pathname}${location.search}`);
-    return match(sessionGate(session))
-        .with("loading", () => (_jsx(Centered, { children: _jsx("p", { className: "text-sm opacity-70", children: "Loading\u2026" }) })))
-        .with("sign-in", () => (_jsx(Centered, { children: _jsxs("div", { className: "flex flex-col items-center gap-4", children: [_jsx("h1", { className: "text-xl font-semibold", children: "Sign in to Manta Horns" }), _jsx("a", { className: "rounded-md border px-4 py-2", href: signIn, children: "Sign in" })] }) })))
-        .with("looped", () => (_jsx(Centered, { children: _jsxs("div", { className: "flex flex-col items-center gap-4", children: [_jsx("p", { role: "alert", children: "Signing in did not complete. Try again, or ask an admin to check your access." }), _jsx("a", { className: "rounded-md border px-4 py-2", href: signIn, children: "Sign in" })] }) })))
-        .with("blocked", () => (_jsx(Centered, { children: _jsxs("div", { className: "flex flex-col items-center gap-4", children: [_jsx("p", { role: "alert", children: session.authError ?? session.error ?? "Manta Horns is unavailable." }), _jsx("a", { className: "rounded-md border px-4 py-2", href: signIn, children: "Try again" })] }) })))
-        .with("ready", () => children)
-        .exhaustive();
-}

package/dist/client.d.ts

@@ -1,10 +0,0 @@
-import { type ShapeCatalogSource } from "./lib/shapes/catalog";
-import "./app/globals.css";
-export type MountHornsOptions = {
-    /** The realm's shapes. Horns ships none: they describe a deployment's data model, not the library's. */
-    shapes: ShapeCatalogSource;
-    /** Defaults to `#app`, which is what this package's own document declares. */
-    container?: HTMLElement;
-};
-/** Mount Horns as a whole page. A host with a router of its own splices `hornsRoutes()` in instead. */
-export declare function mountHorns({ shapes, container }: MountHornsOptions): void;

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

@@ -1,10 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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;
-}