@manta-eu/horns-server 0.1.0

package/dist/manta-proxy-policy.js

@@ -0,0 +1,129 @@
+import sparqljs from "sparqljs";
+import { isPresent } from "@manta-eu/lib/present";
+import { isRecord } from "@manta-eu/horns";
+export const crossOriginBlockedMessage = "Cross-origin requests to the Horns proxy are blocked.";
+export const proxyPathBlockedMessage = "This proxy only forwards the Manta paths Horns uses.";
+export const proxyMethodBlockedMessage = "This proxy does not allow that method on this path.";
+export const sparqlEmptyMessage = "SPARQL query is empty.";
+export const sparqlParseFailedMessage = "SPARQL query could not be parsed as a single query.";
+export const sparqlWriteBlockedMessage = "This proxy only forwards read-only SPARQL.";
+export const sparqlFederationBlockedMessage = "This proxy does not forward SERVICE, FROM or FROM NAMED.";
+function denied(status, error) {
+    return { allow: false, status, error };
+}
+const authProxyPaths = new Set(["/login", "/auth/callback", "/logout"]);
+// Keycloak hands the browser back from its own origin, so these two cannot demand same-origin.
+const crossOriginAuthPaths = new Set(["/login", "/auth/callback"]);
+export function isAuthProxyPath(pathname) {
+    return authProxyPaths.has(pathname);
+}
+export function originAllowsRequest({ request }) {
+    const origin = request.headers.get("origin");
+    const requestOrigin = new URL(request.url).origin;
+    if (isPresent(origin))
+        return origin === requestOrigin;
+    const fetchSite = request.headers.get("sec-fetch-site");
+    if (fetchSite === "same-origin")
+        return true;
+    if (fetchSite === "cross-site" || fetchSite === "same-site")
+        return false;
+    const isWebSocket = request.headers.get("upgrade")?.toLowerCase() === "websocket";
+    if (isWebSocket)
+        return false;
+    return request.method === "GET" || request.method === "HEAD";
+}
+export function sameOriginDeniedResponse(request) {
+    if (originAllowsRequest({ request }))
+        return undefined;
+    return Response.json({ error: crossOriginBlockedMessage }, { status: 403 });
+}
+export const isDatastoreId = (value) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
+// The proxy's own boundary: nothing reaches agents that is not named here. There is deliberately no
+// sparql-update route — every write is built and guarded by the worker itself (ARCHITECTURE.md §11) — and no
+// GraphQL route: the worker calls the one mutation Horns needs, running an action plan, itself.
+const proxyRoutes = [
+    { path: "/d/:datastoreId/sparql", methods: ["POST"], params: { datastoreId: isDatastoreId }, body: "sparql" },
+    // Where a Horn's row links: agents resolves an entity to its platform's page. A read, and a navigation.
+    { path: "/d/:datastoreId/redirect", methods: ["GET"], params: { datastoreId: isDatastoreId } },
+    { path: "/login", methods: ["GET"] },
+    { path: "/auth/callback", methods: ["GET"] },
+    { path: "/logout", methods: ["GET", "POST"] },
+    { path: "/api/login", methods: ["GET"] },
+    { path: "/api/data/context", methods: ["GET"] },
+    { path: "/api/switch-datastore", methods: ["POST"] },
+];
+function routeMatches(route, pathname) {
+    const wanted = route.path.split("/");
+    const given = pathname.split("/");
+    if (wanted.length !== given.length)
+        return false;
+    return wanted.every((segment, at) => {
+        const value = given[at] ?? "";
+        if (!segment.startsWith(":"))
+            return segment === value;
+        if (!isPresent(value))
+            return false;
+        const guard = route.params?.[segment.slice(1)];
+        return guard ? guard(value) : true;
+    });
+}
+export function matchProxyRoute(pathname) {
+    return proxyRoutes.find((route) => routeMatches(route, pathname));
+}
+export function isAllowedProxyPath(args) {
+    const route = matchProxyRoute(args.pathname);
+    if (!route)
+        return { allowed: false, methodAllowed: false };
+    return { allowed: true, methodAllowed: !args.isWebSocket && route.methods.includes(args.method) };
+}
+function mentionsService(node) {
+    if (Array.isArray(node))
+        return node.some(mentionsService);
+    if (!isRecord(node))
+        return false;
+    return node["type"] === "service" || Object.values(node).some(mentionsService);
+}
+// Parsed, never pattern-matched: a lexer that skips text it thinks is an IRI or a string can be made to skip
+// an update. The body must be exactly one query — no update, no second operation — and may neither federate
+// (SERVICE) nor pick its own graphs (FROM, FROM NAMED), the same rules bindings compile under.
+export function checkReadOnlySparql(text) {
+    let parsed;
+    try {
+        parsed = new sparqljs.Parser().parse(text);
+    }
+    catch {
+        return { ok: false, status: 400, error: sparqlParseFailedMessage };
+    }
+    if (parsed.type !== "query")
+        return { ok: false, status: 403, error: sparqlWriteBlockedMessage };
+    const pickedGraphs = (parsed.from?.default.length ?? 0) + (parsed.from?.named.length ?? 0);
+    if (pickedGraphs > 0 || mentionsService(parsed)) {
+        return { ok: false, status: 403, error: sparqlFederationBlockedMessage };
+    }
+    return { ok: true };
+}
+export function isReadOnlySparql(text) {
+    return checkReadOnlySparql(text).ok;
+}
+function evaluateSparqlBody(bodyText) {
+    if (!isPresent(bodyText.trim()))
+        return denied(400, sparqlEmptyMessage);
+    const verdict = checkReadOnlySparql(bodyText);
+    return verdict.ok ? { allow: true, bodyText } : denied(verdict.status, verdict.error);
+}
+export async function evaluateProxyPolicy(request) {
+    const url = new URL(request.url);
+    if (!crossOriginAuthPaths.has(url.pathname) && !originAllowsRequest({ request })) {
+        return denied(403, crossOriginBlockedMessage);
+    }
+    const route = matchProxyRoute(url.pathname);
+    if (!route)
+        return denied(403, proxyPathBlockedMessage);
+    const isWebSocket = request.headers.get("upgrade")?.toLowerCase() === "websocket";
+    if (isWebSocket || !route.methods.includes(request.method))
+        return denied(405, proxyMethodBlockedMessage);
+    if (request.method === "GET" || request.method === "HEAD")
+        return { allow: true };
+    const bodyText = await request.text();
+    return route.body === "sparql" ? evaluateSparqlBody(bodyText) : { allow: true, bodyText };
+}

package/dist/manta-rules.d.ts

@@ -0,0 +1,15 @@
+import { type RuleStager } from "@manta-eu/horns/studio";
+import { type AgentsCaller } from "./agents-proxy.ts";
+export type RuleWriter = AgentsCaller;
+/** What the SDK's `ask_manta_for_rule` hands back, so the two cannot drift apart. */
+export type StagedRule = Awaited<ReturnType<RuleStager>>;
+/**
+ * A rule Manta has checked and staged for a person to read. The syntax check runs first because a malformed
+ * rule staged is a rule somebody has to unstage; the stratifiability check runs after, because it is the whole
+ * staged set that either stratifies or does not, and that answer is worth handing back even when it is bad
+ * news — a rule that stages but breaks the set is exactly what a reviewer needs told.
+ */
+export declare function stageRule(writer: RuleWriter, rule: {
+    text: string;
+    humanIntent: string;
+}): Promise<StagedRule>;

package/dist/manta-rules.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { isPresent } from "@manta-eu/lib/present";
+import { maxHumanIntent } from "@manta-eu/horns/studio";
+import { agentsGraphql } from "./agents-proxy.js";
+// Manta writes the rules. The Studio knows what a Horn needs to draw; Manta's own graph knows what a rule may
+// say and whether the set of them still stratifies — so a derived value the chart vocabulary cannot reach is
+// asked for here rather than invented in a binding.
+//
+// Staged, never committed. `stageRuleOperation` needs a real person (its resolver calls `requireUserId`), so
+// this runs as the viewer on their replayed session, the way uploads and plan runs do. `commitStagedRules`
+// asks only for a datastore — agents will not stop an unconfirmed commit, so the commit is not offered here at
+// all: a staged rule waits on the rules page for somebody to read it.
+const validateMutation = "mutation ValidateRDFoxRule($input: ValidateRDFoxRuleInput!) { validateRDFoxRule(input: $input) " +
+    "{ valid error } }";
+const stageMutation = "mutation StageRuleOperation($input: StageRuleOperationInput!) { stageRuleOperation(input: $input) " +
+    "{ success operation ruleIri error } }";
+const validateStagedMutation = "mutation ValidateStagedRules { validateStagedRules { isValid isStratifiable nonStratifiableComponents syntaxErrors } }";
+const validateAnswer = z.object({ valid: z.boolean(), error: z.string().nullish() });
+// Only what is read. `operation` was required and never used, so agents answering without it turned a rule
+// that did stage into a refusal — and a model told the ask failed asks again, leaving two to unstage.
+const stageAnswer = z.object({
+    success: z.boolean(),
+    ruleIri: z.string().nullish(),
+    error: z.string().nullish(),
+});
+const stagedAnswer = z.object({
+    isValid: z.boolean(),
+    isStratifiable: z.boolean(),
+    nonStratifiableComponents: z.array(z.string()),
+    syntaxErrors: z.array(z.string()),
+});
+/**
+ * What the staged set looks like now that this rule is in it.
+ *
+ * Not getting an answer is itself worth reporting: the rule is staged either way, and a reviewer told
+ * nothing would read that as a clean bill of health. So every way of not knowing says so.
+ */
+async function setHealth(writer) {
+    const set = await agentsGraphql(writer, validateStagedMutation, {}, "validateStagedRules");
+    if (!set.ok)
+        return [`Manta could not check the staged set: ${set.error}`];
+    const health = stagedAnswer.safeParse(set.value);
+    if (!health.success)
+        return ["Manta did not say whether the staged rules still hold together."];
+    return [
+        ...health.data.syntaxErrors,
+        ...(health.data.isStratifiable
+            ? []
+            : [`The staged rules no longer stratify: ${health.data.nonStratifiableComponents.join(", ")}`]),
+        // `isValid` is agents' own summary of the two above. It can be false with neither populated, and that is
+        // still something a reviewer needs told.
+        ...(health.data.isValid || isPresent(health.data.syntaxErrors) || !health.data.isStratifiable
+            ? []
+            : ["Manta says the staged rules are not valid, without saying why."]),
+    ];
+}
+/**
+ * A rule Manta has checked and staged for a person to read. The syntax check runs first because a malformed
+ * rule staged is a rule somebody has to unstage; the stratifiability check runs after, because it is the whole
+ * staged set that either stratifies or does not, and that answer is worth handing back even when it is bad
+ * news — a rule that stages but breaks the set is exactly what a reviewer needs told.
+ */
+export async function stageRule(writer, rule) {
+    const text = rule.text.trim();
+    // Checked here rather than sent, so the message says who refused it: `write-tools.ts` prefixes a refusal
+    // with "Manta would not take that rule", which would be a lie about a rule Manta never saw.
+    if (!text.endsWith("."))
+        return { ok: false, error: "Not sent: a Datalog rule has to end with a period." };
+    const checked = await agentsGraphql(writer, validateMutation, { input: { rule: text } }, "validateRDFoxRule");
+    if (!checked.ok)
+        return { ok: false, error: checked.error };
+    const verdict = validateAnswer.safeParse(checked.value);
+    if (!verdict.success)
+        return { ok: false, error: "Manta did not say whether the rule is valid." };
+    if (!verdict.data.valid)
+        return { ok: false, error: verdict.data.error ?? "Manta will not accept that rule." };
+    const staged = await agentsGraphql(writer, stageMutation, { input: { operation: "ADD", newRule: text, humanIntent: rule.humanIntent.slice(0, maxHumanIntent) } }, "stageRuleOperation");
+    if (!staged.ok)
+        return { ok: false, error: staged.error };
+    const answer = stageAnswer.safeParse(staged.value);
+    if (!answer.success)
+        return { ok: false, error: "Manta did not say what it staged." };
+    if (!answer.data.success)
+        return { ok: false, error: answer.data.error ?? "Manta would not stage that rule." };
+    return { ok: true, ruleIri: answer.data.ruleIri ?? undefined, warnings: await setHealth(writer) };
+}

package/dist/manta-upload.d.ts

@@ -0,0 +1,18 @@
+import { type AgentsCaller } from "./agents-proxy.ts";
+export type Uploader = AgentsCaller;
+export type UploadResult = {
+    ok: true;
+    fileIri: string;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+/**
+ * A PNG stored in the datastore the viewer is looking at, returned as the IRI it now has. The name decides the
+ * type agents records — it reads the extension and ignores anything a caller claims — so it ends in `.png`.
+ */
+export declare function uploadPng(uploader: Uploader, file: {
+    fileName: string;
+    bytes: Uint8Array;
+}): Promise<UploadResult>;

package/dist/manta-upload.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { isPresent } from "@manta-eu/lib/present";
+import { pngSize } from "@manta-eu/horns/render";
+import { agentsGraphql } from "./agents-proxy.js";
+// Putting a file in Manta: agents hands out presigned URLs, the bytes go straight to storage, and agents is
+// told when they landed — it never carries them itself. The worker does this rather than the browser because
+// the browser gets no GraphQL route; and it does it as the viewer, because a completed upload is attributed to
+// a person and the write key cannot stand in for one.
+const initiateMutation = "mutation InitiateUpload($input: InitiateUploadInput!) { initiateUpload(input: $input) " +
+    "{ uploadId storageKey partUrls { partNumber url } } }";
+const completeMutation = "mutation CompleteUpload($input: CompleteUploadInput!) { completeUpload(input: $input) { fileIri mediaType } }";
+const abortMutation = "mutation AbortUpload($input: AbortUploadInput!) { abortUpload(input: $input) { ok } }";
+// Agents' own part size. A Horn's picture is one part; the loop is here so a bigger file is not a new bug.
+const partSize = 8 * 1024 * 1024;
+const initiateAnswerSchema = z.object({
+    uploadId: z.string(),
+    storageKey: z.string(),
+    partUrls: z.array(z.object({ partNumber: z.number(), url: z.url() })),
+});
+const completeAnswerSchema = z.object({ fileIri: z.string(), mediaType: z.string() });
+function hex(digest) {
+    return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/** WebCrypto wants a buffer of its own; a view over one it cannot name is not one. */
+async function sha256(bytes) {
+    const buffer = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(buffer).set(bytes);
+    return hex(await crypto.subtle.digest("SHA-256", buffer));
+}
+/**
+ * A PNG stored in the datastore the viewer is looking at, returned as the IRI it now has. The name decides the
+ * type agents records — it reads the extension and ignores anything a caller claims — so it ends in `.png`.
+ */
+export async function uploadPng(uploader, file) {
+    const started = await agentsGraphql(uploader, initiateMutation, { input: { fileName: file.fileName, byteSize: file.bytes.byteLength } }, "initiateUpload");
+    if (!started.ok)
+        return started;
+    const begun = initiateAnswerSchema.safeParse(started.value);
+    if (!begun.success)
+        return { ok: false, status: 502, error: "Manta did not say where to put the file." };
+    const { uploadId, storageKey, partUrls } = begun.data;
+    const giveUp = async () => {
+        await agentsGraphql(uploader, abortMutation, { input: { uploadId, storageKey } }, "abortUpload").catch(() => undefined);
+    };
+    try {
+        const parts = [];
+        for (const [index, part] of partUrls.entries()) {
+            const chunk = file.bytes.slice(index * partSize, (index + 1) * partSize);
+            const sent = await fetch(part.url, { method: "PUT", body: chunk });
+            const etag = sent.headers.get("etag");
+            if (!sent.ok || !isPresent(etag)) {
+                await giveUp();
+                return { ok: false, status: 502, error: `Part ${part.partNumber} of the file did not store.` };
+            }
+            parts.push({ partNumber: part.partNumber, etag });
+        }
+        const { width, height } = pngSize(file.bytes);
+        const landed = await agentsGraphql(uploader, completeMutation, {
+            input: {
+                uploadId,
+                storageKey,
+                fileName: file.fileName,
+                parts,
+                facts: { byteSize: file.bytes.byteLength, sha256: await sha256(file.bytes), width, height },
+            },
+        }, "completeUpload");
+        if (!landed.ok) {
+            await giveUp();
+            return landed;
+        }
+        const done = completeAnswerSchema.safeParse(landed.value);
+        if (!done.success)
+            return { ok: false, status: 502, error: "Manta stored the file but did not name it." };
+        return { ok: true, fileIri: done.data.fileIri };
+    }
+    catch (caught) {
+        await giveUp();
+        return { ok: false, status: 502, error: caught instanceof Error ? caught.message : String(caught) };
+    }
+}

package/dist/ndjson-reader.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reads what `ndjsonResponse` wrote: one JSON object per line, the last of which is the result. `onLine` sees
+ * each as it arrives, which is what makes a minute-long turn show its work rather than a spinner.
+ */
+export declare function readNdjson(response: Response, onLine?: (line: Record<string, unknown>) => void): Promise<Record<string, unknown> | undefined>;

package/dist/ndjson-reader.js

@@ -0,0 +1,36 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { isRecord } from "@manta-eu/horns";
+/**
+ * Reads what `ndjsonResponse` wrote: one JSON object per line, the last of which is the result. `onLine` sees
+ * each as it arrives, which is what makes a minute-long turn show its work rather than a spinner.
+ */
+export async function readNdjson(response, onLine = () => undefined) {
+    const reader = response.body?.getReader();
+    if (!isPresent(reader))
+        return undefined;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let last;
+    const take = (text) => {
+        const line = text.trim();
+        if (!isPresent(line))
+            return;
+        const parsed = JSON.parse(line);
+        if (!isRecord(parsed))
+            return;
+        last = parsed;
+        onLine(parsed);
+    };
+    for (;;) {
+        const { done, value } = await reader.read();
+        buffer += decoder.decode(value ?? new Uint8Array(), { stream: !done });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines)
+            take(line);
+        if (done)
+            break;
+    }
+    take(buffer);
+    return last;
+}

package/dist/ndjson.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A turn as a stream: one JSON object per line, as the turn produces them, the last of which is the result.
+ * A turn is several model rounds and takes a minute, and a minute of nothing reads as a hang.
+ *
+ * `run` starts now, not when someone reads: a client that walks away must not leave half a turn behind, so the
+ * lines queue until a reader wants them. Anything `run` throws becomes a last `{ type: "error" }` line, because
+ * by then the status is already sent.
+ */
+export declare function ndjsonResponse(run: (emit: (line: unknown) => void) => Promise<void>, headers?: Readonly<Record<string, string>>): Response;

package/dist/ndjson.js

@@ -0,0 +1,48 @@
+import { isPresent } from "@manta-eu/lib/present";
+/**
+ * A turn as a stream: one JSON object per line, as the turn produces them, the last of which is the result.
+ * A turn is several model rounds and takes a minute, and a minute of nothing reads as a hang.
+ *
+ * `run` starts now, not when someone reads: a client that walks away must not leave half a turn behind, so the
+ * lines queue until a reader wants them. Anything `run` throws becomes a last `{ type: "error" }` line, because
+ * by then the status is already sent.
+ */
+export function ndjsonResponse(run, headers = {}) {
+    const encoder = new TextEncoder();
+    const queued = [];
+    let finished = false;
+    let notify;
+    const emit = (line) => {
+        queued.push(`${JSON.stringify(line)}\n`);
+        notify?.();
+    };
+    void (async () => {
+        try {
+            await run(emit);
+        }
+        catch (caught) {
+            emit({ type: "error", error: caught instanceof Error ? caught.message : String(caught) });
+        }
+        finally {
+            finished = true;
+            notify?.();
+        }
+    })();
+    const stream = new ReadableStream({
+        async pull(controller) {
+            while (!isPresent(queued) && !finished) {
+                await new Promise((resolve) => {
+                    notify = resolve;
+                });
+            }
+            const next = queued.shift();
+            if (next === undefined)
+                controller.close();
+            else
+                controller.enqueue(encoder.encode(next));
+        },
+    });
+    return new Response(stream, {
+        headers: { ...headers, "content-type": "application/x-ndjson", "x-accel-buffering": "no" },
+    });
+}

package/dist/pii.d.ts

@@ -0,0 +1,4 @@
+import type { ErrorEvent } from "@sentry/core";
+export declare const diagnosticExtraKeys: Set<string>;
+export declare function onlyDiagnosticExtra(extra: ErrorEvent["extra"]): ErrorEvent["extra"];
+export declare function withoutPiiErrorEvent(event: ErrorEvent): ErrorEvent;

package/dist/pii.js

@@ -0,0 +1,22 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { redactedUrl } from "./redact.js";
+export const diagnosticExtraKeys = new Set(["method", "path", "status"]);
+export function onlyDiagnosticExtra(extra) {
+    if (!isPresent(extra))
+        return {};
+    return Object.fromEntries(Object.entries(extra).filter(([key]) => diagnosticExtraKeys.has(key)));
+}
+export function withoutPiiErrorEvent(event) {
+    if (event.request) {
+        delete event.request.headers;
+        delete event.request.cookies;
+        delete event.request.query_string;
+        delete event.request.data;
+        event.request.url = isPresent(event.request.url) ? redactedUrl(event.request.url) : event.request.url;
+    }
+    delete event.user;
+    delete event.contexts?.culture;
+    delete event.breadcrumbs;
+    event.extra = onlyDiagnosticExtra(event.extra);
+    return event;
+}

package/dist/redact.d.ts

@@ -0,0 +1,2 @@
+export declare function redactShareTokens(value: string): string;
+export declare function redactedUrl(value: string): string;

package/dist/redact.js

@@ -0,0 +1,7 @@
+const shareTokenPath = /\/(review|r)\/[^/?#]+/gi;
+export function redactShareTokens(value) {
+    return value.replace(shareTokenPath, "/$1/redacted");
+}
+export function redactedUrl(value) {
+    return redactShareTokens(value.split("?")[0] ?? value);
+}

package/dist/render-document.d.ts

@@ -0,0 +1,8 @@
+import type { HornViewMode } from "@manta-eu/horns-kit";
+import type { HornSnapshot } from "@manta-eu/horns/render";
+export declare const hornTemplatePath = "/horn.html";
+export declare function renderHornDocument(args: {
+    template: string;
+    snapshot: HornSnapshot;
+    mode: Exclude<HornViewMode, "capture">;
+}): string;

package/dist/render-document.js

@@ -0,0 +1,18 @@
+import { renderHornEmbed } from "@manta-eu/horns-kit/server";
+export const hornTemplatePath = "/horn.html";
+const titlePlaceholder = "<!--horn-title-->";
+const embedPlaceholder = "<!--horn-embed-->";
+function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+// Fills horn.html as Vite built or serves it, so its script links stay right. Replacer functions keep a
+// `$&` in the data literal.
+export function renderHornDocument(args) {
+    const { template, snapshot, mode } = args;
+    if (!template.includes(titlePlaceholder) || !template.includes(embedPlaceholder)) {
+        throw new Error(`${hornTemplatePath} has lost its placeholders.`);
+    }
+    return template
+        .replace(titlePlaceholder, () => escapeHtml(snapshot.horn.title))
+        .replace(embedPlaceholder, () => renderHornEmbed({ snapshot, mode }));
+}

package/dist/sentry.d.ts

@@ -0,0 +1,23 @@
+import { withoutPiiErrorEvent } from "./pii.ts";
+import type { Env } from "./env.ts";
+export declare function deployedEnvironment(env: Env): string | undefined;
+export declare function sentryOptions(env: Env): {
+    dsn: string | undefined;
+    release: string;
+    environment: string;
+    sendDefaultPii: boolean;
+    integrations: (import("@sentry/core").Integration & {
+        name: string;
+    })[];
+    beforeSend: typeof withoutPiiErrorEvent;
+};
+export declare function sentryOptionsForDeploy(env: Env): {
+    dsn: string | undefined;
+    release: string;
+    environment: string;
+    sendDefaultPii: boolean;
+    integrations: (import("@sentry/core").Integration & {
+        name: string;
+    })[];
+    beforeSend: typeof withoutPiiErrorEvent;
+} | undefined;

package/dist/sentry.js

@@ -0,0 +1,18 @@
+import { httpServerIntegration } from "@sentry/cloudflare";
+import { withoutPiiErrorEvent } from "./pii.js";
+export function deployedEnvironment(env) {
+    return env.CLOUDFLARE_ENV ?? import.meta.env.DEPLOYED_ENVIRONMENT;
+}
+export function sentryOptions(env) {
+    return {
+        dsn: env.SENTRY_DSN,
+        release: env.CF_VERSION_METADATA?.id ?? "local-dev",
+        environment: deployedEnvironment(env) ?? "local",
+        sendDefaultPii: false,
+        integrations: [httpServerIntegration({ maxRequestBodySize: "none" })],
+        beforeSend: withoutPiiErrorEvent,
+    };
+}
+export function sentryOptionsForDeploy(env) {
+    return deployedEnvironment(env) === undefined ? undefined : sentryOptions(env);
+}

package/dist/session.d.ts

@@ -0,0 +1,23 @@
+export declare const agentsJwtCookieName = "auth";
+export declare const sessionCookiePrefix = "mh_session";
+export declare const maxSessionCookieChunks = 8;
+export type MantaSessionState = {
+    upstreamCookies: Record<string, string>;
+};
+type CookieAttributes = {
+    secure: boolean;
+    maxAge?: number;
+};
+export declare function isForwardableCookie(name: string, value: string): boolean;
+export declare function parseCookieHeader(header: string | null | undefined): Record<string, string>;
+export declare function serializeCookie(name: string, value: string, attributes: CookieAttributes): string;
+export declare function requestIsSecure(requestUrl: string): boolean;
+export declare function sessionSetCookies(state: MantaSessionState, attributes: CookieAttributes): string[];
+export declare function clearSessionSetCookies(attributes: CookieAttributes): string[];
+export declare function readSessionState(cookieHeader: string | null | undefined): MantaSessionState | undefined;
+export declare function isSignedIn(state: MantaSessionState | undefined): boolean;
+export declare function upstreamCookieHeader(state: MantaSessionState): string;
+export declare function setCookieHeadersOf(response: Response): string[];
+export declare function captureUpstreamCookies(state: MantaSessionState, response: Response, now?: number): MantaSessionState;
+export declare function sessionsDiffer(before: MantaSessionState, after: MantaSessionState): boolean;
+export {};