@arnilo/prism-server 0.2.3 → 0.2.5

package/dist/handler/readers.js

@@ -0,0 +1,197 @@
+import { HARD_MAX_DECISION_REASON_BYTES, HARD_MAX_ELICITATION_BYTES, HARD_MAX_PENDING_DECISIONS } from "@arnilo/prism";
+import { PrismServerError } from "../types.js";
+export async function readJsonObject(request, maxBytes, signal) {
+    const type = request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+    if (type !== "application/json")
+        throw new PrismServerError("Content-Type must be application/json", 415, "ERR_PRISM_SERVER_CONTENT_TYPE");
+    const declared = Number(request.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > maxBytes)
+        throw new PrismServerError("Request body too large", 413, "ERR_PRISM_SERVER_BODY_LIMIT");
+    const reader = request.body?.getReader();
+    if (!reader)
+        throw new PrismServerError("JSON body is required", 400, "ERR_PRISM_SERVER_BODY");
+    const chunks = [];
+    let size = 0;
+    const abort = () => {
+        void reader.cancel(signal.reason);
+    };
+    if (signal.aborted)
+        abort();
+    else
+        signal.addEventListener("abort", abort, { once: true });
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            size += next.value.byteLength;
+            if (size > maxBytes) {
+                await reader.cancel();
+                throw new PrismServerError("Request body too large", 413, "ERR_PRISM_SERVER_BODY_LIMIT");
+            }
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+        reader.releaseLock();
+    }
+    if (signal.aborted)
+        throw new PrismServerError("Request timed out or disconnected", 408, "ERR_PRISM_SERVER_ABORTED");
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    try {
+        const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("object required");
+        return value;
+    }
+    catch (error) {
+        if (error instanceof PrismServerError)
+            throw error;
+        throw new PrismServerError("Invalid JSON object body", 400, "ERR_PRISM_SERVER_BODY");
+    }
+}
+export function readAgentInput(value) {
+    if (typeof value === "string")
+        return value;
+    if (isMessage(value))
+        return value;
+    if (Array.isArray(value) && value.length > 0 && value.every(isMessage))
+        return value;
+    throw new PrismServerError("input must be a string, message, or non-empty message array", 400, "ERR_PRISM_SERVER_INPUT");
+}
+function isMessage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const item = value;
+    return ["system", "user", "assistant", "tool"].includes(String(item.role)) && Array.isArray(item.content);
+}
+const RUN_DECISION_OUTCOMES = new Set(["allow_once", "allow_for_run", "reject_once", "reject_for_run"]);
+const RUN_DECISION_KEYS = new Set(["approvalId", "outcome", "reason", "modifiedArguments", "elicitation"]);
+/** Boundary validation for a client-supplied decision batch; core re-validates under CAS. */
+function readAgentDecisions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > HARD_MAX_PENDING_DECISIONS) {
+        throw new PrismServerError("decisions must be a non-empty bounded array", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    return value.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new PrismServerError("decision entry must be an object", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        const row = entry;
+        if (Object.keys(row).some((key) => !RUN_DECISION_KEYS.has(key))) {
+            throw new PrismServerError("decision entry has unknown keys", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        if (typeof row.approvalId !== "string" || row.approvalId.length === 0 || row.approvalId.length > 128) {
+            throw new PrismServerError("decision approvalId is invalid", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        if (typeof row.outcome !== "string" || !RUN_DECISION_OUTCOMES.has(row.outcome)) {
+            throw new PrismServerError("decision outcome is invalid", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        if (row.reason !== undefined &&
+            (typeof row.reason !== "string" || Buffer.byteLength(row.reason, "utf8") > HARD_MAX_DECISION_REASON_BYTES)) {
+            throw new PrismServerError("decision reason exceeds limits", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        for (const key of ["modifiedArguments", "elicitation"]) {
+            const field = row[key];
+            if (field === undefined)
+                continue;
+            if (!field || typeof field !== "object" || Array.isArray(field)) {
+                throw new PrismServerError(`decision ${key} must be an object`, 400, "ERR_PRISM_SERVER_RESUME");
+            }
+            const text = JSON.stringify(field);
+            if (text === undefined || Buffer.byteLength(text, "utf8") > HARD_MAX_ELICITATION_BYTES) {
+                throw new PrismServerError(`decision ${key} exceeds limits`, 400, "ERR_PRISM_SERVER_RESUME");
+            }
+        }
+        return entry;
+    });
+}
+export function readAgentResume(body) {
+    if (Object.keys(body).some((key) => key !== "decision" && key !== "decisions" && key !== "expectedVersion")) {
+        throw new PrismServerError("Invalid agent resume body", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    if (!Number.isSafeInteger(body.expectedVersion) || Number(body.expectedVersion) < 1) {
+        throw new PrismServerError("expectedVersion must be a positive safe integer", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    if (body.decision !== undefined && body.decisions !== undefined) {
+        throw new PrismServerError("provide exactly one of decision or decisions", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    if (body.decision !== undefined) {
+        if (body.decision !== "approve" && body.decision !== "deny") {
+            throw new PrismServerError("decision must be approve or deny", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        return { decision: body.decision, expectedVersion: Number(body.expectedVersion) };
+    }
+    if (body.decisions === undefined) {
+        throw new PrismServerError("provide decision or decisions", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    return { decisions: readAgentDecisions(body.decisions), expectedVersion: Number(body.expectedVersion) };
+}
+export function readResume(body) {
+    if (body.decision !== "approve" && body.decision !== "deny") {
+        throw new PrismServerError("decision must be approve or deny", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    if (!Number.isSafeInteger(body.expectedVersion) || Number(body.expectedVersion) < 1) {
+        throw new PrismServerError("expectedVersion must be a positive safe integer", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    return { decision: body.decision, input: body.input, expectedVersion: Number(body.expectedVersion) };
+}
+export function readRequiredString(value, name) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new PrismServerError(`${name} is required`, 400, "ERR_PRISM_SERVER_INPUT");
+    return value;
+}
+export function readRequiredId(value, name) {
+    const result = readOptionalId(value, name);
+    if (!result)
+        throw new PrismServerError(`${name} is required`, 400, "ERR_PRISM_SERVER_ID");
+    return result;
+}
+export function readPositiveInteger(value, name) {
+    const number = typeof value === "string" ? Number(value) : value;
+    if (!Number.isSafeInteger(number) || Number(number) < 1)
+        throw new PrismServerError(`${name} must be a positive safe integer`, 400, "ERR_PRISM_SERVER_INPUT");
+    return Number(number);
+}
+export function readOptionalObject(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new PrismServerError(`${name} must be an object`, 400, "ERR_PRISM_SERVER_INPUT");
+    return value;
+}
+export function readScheduleStatus(value) {
+    if (value === null)
+        return undefined;
+    if (value === "active" || value === "paused" || value === "completed")
+        return value;
+    throw new PrismServerError("status is invalid", 400, "ERR_PRISM_SERVER_INPUT");
+}
+export function readOptionalId(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !validId(value))
+        throw new PrismServerError(`${name} is invalid`, 400, "ERR_PRISM_SERVER_ID");
+    return value;
+}
+export function validId(value) {
+    return value.length <= 128 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value);
+}
+export function replayCursor(request, maxBytes) {
+    const query = new URL(request.url).searchParams.get("cursor") ?? undefined;
+    const header = request.headers.get("last-event-id") ?? undefined;
+    if (query !== undefined && header !== undefined && query !== header) {
+        throw new PrismServerError("Conflicting event cursors", 400, "ERR_PRISM_SERVER_REPLAY_CURSOR");
+    }
+    const cursor = header ?? query;
+    if (cursor !== undefined && (Buffer.byteLength(cursor, "utf8") > maxBytes || /\r|\n|\0/.test(cursor))) {
+        throw new PrismServerError("Invalid event cursor", 400, "ERR_PRISM_SERVER_REPLAY_CURSOR");
+    }
+    return cursor;
+}
+//# sourceMappingURL=readers.js.map

package/dist/handler/respond.d.ts

@@ -0,0 +1,5 @@
+import type { CreatePrismHandlerOptions } from "../types.js";
+import type { ResolvedPrismServerLimits } from "../limits.js";
+export declare function json(value: unknown, status: number, limits: ResolvedPrismServerLimits, options: CreatePrismHandlerOptions): Response;
+export declare function errorResponse(error: unknown, limits: ResolvedPrismServerLimits, options: CreatePrismHandlerOptions): Response;
+export declare function addHeaders(response: Response, extra?: Readonly<Record<string, string>>): Response;

package/dist/handler/respond.js

@@ -0,0 +1,56 @@
+/** respond (0.2.5 plan 025 Task 1 split). Moved verbatim from handler.ts; public surface unchanged behind the barrel. */
+import { AgentRunStateError } from "@arnilo/prism";
+import { PrismServerError } from "../types.js";
+import { JSON_HEADERS } from "./consts.js";
+export function json(value, status, limits, options) {
+    const safe = options.redactor?.redact(value) ?? value;
+    const text = JSON.stringify(safe);
+    if (text === undefined || new TextEncoder().encode(text).byteLength > limits.maxResponseBytes) {
+        throw new PrismServerError("Response too large", 507, "ERR_PRISM_SERVER_RESPONSE_LIMIT");
+    }
+    return new Response(text, { status, headers: JSON_HEADERS });
+}
+export function errorResponse(error, limits, options) {
+    const workflowCode = error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : undefined;
+    const mapped = workflowCode === "ERR_PRISM_WORKFLOW_SCHEDULE_BUSY"
+        ? { status: 409, code: workflowCode, message: "Schedule is busy" }
+        : workflowCode === "ERR_PRISM_WORKFLOW_SCHEDULE"
+            ? { status: 400, code: workflowCode, message: error instanceof Error ? error.message : "Invalid schedule" }
+            : workflowCode === "ERR_PRISM_WORKFLOW_SCHEDULE_OWNERSHIP"
+                ? { status: 403, code: workflowCode, message: "Forbidden" }
+                : workflowCode === "ERR_PRISM_WORKFLOW_NOT_FOUND"
+                    ? { status: 404, code: workflowCode, message: "Not found" }
+                    : workflowCode === "ERR_PRISM_WORKFLOW_CHECKPOINT"
+                        ? { status: 409, code: workflowCode, message: "Workflow checkpoint operation rejected" }
+                        : undefined;
+    const known = error instanceof PrismServerError;
+    const agentState = error instanceof AgentRunStateError;
+    const status = mapped?.status ?? (agentState ? 404 : known ? error.status : error instanceof DOMException && error.name === "AbortError" ? 499 : 500);
+    const code = mapped?.code ??
+        (agentState
+            ? "ERR_PRISM_SERVER_NOT_FOUND"
+            : known
+                ? error.code
+                : status === 499
+                    ? "ERR_PRISM_SERVER_ABORTED"
+                    : "ERR_PRISM_SERVER_INTERNAL");
+    const message = mapped?.message ?? (agentState ? "Not found" : known ? error.message : status === 499 ? "Request aborted" : "Internal server error");
+    try {
+        const response = json({ error: { code, message } }, status, limits, options);
+        if (known && error.headers)
+            return addHeaders(response, error.headers);
+        return response;
+    }
+    catch {
+        return new Response(null, { status });
+    }
+}
+export function addHeaders(response, extra) {
+    if (!extra)
+        return response;
+    const headers = new Headers(response.headers);
+    for (const [name, value] of Object.entries(extra))
+        headers.set(name, value);
+    return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}
+//# sourceMappingURL=respond.js.map

package/dist/handler/routing.d.ts

@@ -0,0 +1,71 @@
+type Route = {
+    readonly kind: "agent-run" | "agent-stream";
+    readonly operation: "agent.run" | "agent.stream";
+    readonly capabilityId: string;
+} | {
+    readonly kind: "agent-status";
+    readonly operation: "agent.status";
+    readonly capabilityId: string;
+    readonly runId: string;
+} | {
+    readonly kind: "agent-resume";
+    readonly operation: "agent.resume";
+    readonly capabilityId: string;
+    readonly runId: string;
+} | {
+    readonly kind: "agent-events";
+    readonly operation: "agent.events";
+    readonly capabilityId: string;
+    readonly runId: string;
+} | {
+    readonly kind: "workflow-run" | "workflow-stream" | "workflow-enqueue";
+    readonly operation: "workflow.run" | "workflow.stream" | "workflow.enqueue";
+    readonly capabilityId: string;
+} | {
+    readonly kind: "workflow-status";
+    readonly operation: "workflow.status";
+    readonly capabilityId: string;
+    readonly runId: string;
+} | {
+    readonly kind: "workflow-cancel";
+    readonly operation: "workflow.cancel";
+    readonly capabilityId: string;
+    readonly runId: string;
+} | {
+    readonly kind: "workflow-resume";
+    readonly operation: "workflow.resume";
+    readonly capabilityId: string;
+    readonly runId: string;
+} | {
+    readonly kind: "workflow-replay";
+    readonly operation: "workflow.replay";
+    readonly capabilityId: string;
+    readonly runId: string;
+} | {
+    readonly kind: "schedule-list";
+    readonly operation: "schedule.list";
+    readonly capabilityId: "*";
+} | {
+    readonly kind: "schedule-create";
+    readonly operation: "schedule.create";
+    readonly capabilityId: string;
+} | {
+    readonly kind: "schedule-pause";
+    readonly operation: "schedule.pause";
+    readonly capabilityId: string;
+} | {
+    readonly kind: "schedule-resume";
+    readonly operation: "schedule.resume";
+    readonly capabilityId: string;
+} | {
+    readonly kind: "schedule-trigger";
+    readonly operation: "schedule.trigger";
+    readonly capabilityId: string;
+} | {
+    readonly kind: "schedule-delete";
+    readonly operation: "schedule.delete";
+    readonly capabilityId: string;
+};
+export declare function parseRoute(request: Request, base: string): Route | undefined;
+export declare function normalizeBasePath(value: string): string;
+export {};

package/dist/handler/routing.js

@@ -0,0 +1,83 @@
+/** routing (0.2.5 plan 025 Task 1 split). Moved verbatim from handler.ts; public surface unchanged behind the barrel. */
+import { PrismServerError } from "../types.js";
+import { validId } from "./readers.js";
+export function parseRoute(request, base) {
+    const pathname = new URL(request.url).pathname;
+    if (pathname !== base && !pathname.startsWith(`${base}/`))
+        return undefined;
+    let parts;
+    try {
+        parts = pathname.slice(base.length).split("/").filter(Boolean).map(decodeURIComponent);
+    }
+    catch {
+        throw new PrismServerError("Invalid route", 400, "ERR_PRISM_SERVER_ROUTE");
+    }
+    const [group, id, segment, runId, action] = parts;
+    if (group === "schedules" && parts.length === 1 && request.method === "GET") {
+        return { kind: "schedule-list", operation: "schedule.list", capabilityId: "*" };
+    }
+    if (!id || !validId(id))
+        return undefined;
+    if (group === "schedules") {
+        if (parts.length === 2 && request.method === "POST")
+            return { kind: "schedule-create", operation: "schedule.create", capabilityId: id };
+        if (parts.length === 2 && request.method === "DELETE")
+            return { kind: "schedule-delete", operation: "schedule.delete", capabilityId: id };
+        if (parts.length === 3 && segment === "pause" && request.method === "POST")
+            return { kind: "schedule-pause", operation: "schedule.pause", capabilityId: id };
+        if (parts.length === 3 && segment === "resume" && request.method === "POST")
+            return { kind: "schedule-resume", operation: "schedule.resume", capabilityId: id };
+        if (parts.length === 3 && segment === "trigger" && request.method === "POST")
+            return { kind: "schedule-trigger", operation: "schedule.trigger", capabilityId: id };
+        return undefined;
+    }
+    if (group === "agents" && segment === "runs" && parts.length === 3 && request.method === "POST") {
+        return { kind: "agent-run", operation: "agent.run", capabilityId: id };
+    }
+    if (group === "agents" && segment === "stream" && parts.length === 3 && request.method === "POST") {
+        return { kind: "agent-stream", operation: "agent.stream", capabilityId: id };
+    }
+    if (group === "agents" && segment === "runs" && runId && validId(runId)) {
+        if (parts.length === 4 && request.method === "GET")
+            return { kind: "agent-status", operation: "agent.status", capabilityId: id, runId };
+        if (parts.length === 5 && action === "resume" && request.method === "POST")
+            return { kind: "agent-resume", operation: "agent.resume", capabilityId: id, runId };
+        if (parts.length === 5 && action === "events" && request.method === "GET")
+            return { kind: "agent-events", operation: "agent.events", capabilityId: id, runId };
+    }
+    if (group !== "workflows")
+        return undefined;
+    if (segment === "runs" && parts.length === 3 && request.method === "POST") {
+        return { kind: "workflow-run", operation: "workflow.run", capabilityId: id };
+    }
+    if (segment === "stream" && parts.length === 3 && request.method === "POST") {
+        return { kind: "workflow-stream", operation: "workflow.stream", capabilityId: id };
+    }
+    if (segment === "enqueue" && parts.length === 3 && request.method === "POST") {
+        return { kind: "workflow-enqueue", operation: "workflow.enqueue", capabilityId: id };
+    }
+    if (segment !== "runs" || !runId || !validId(runId))
+        return undefined;
+    if (parts.length === 4 && request.method === "GET") {
+        return { kind: "workflow-status", operation: "workflow.status", capabilityId: id, runId };
+    }
+    if (parts.length === 4 && request.method === "DELETE") {
+        return { kind: "workflow-cancel", operation: "workflow.cancel", capabilityId: id, runId };
+    }
+    if (parts.length === 5 && action === "resume" && request.method === "POST") {
+        return { kind: "workflow-resume", operation: "workflow.resume", capabilityId: id, runId };
+    }
+    if (parts.length === 5 && action === "replay" && request.method === "POST") {
+        return { kind: "workflow-replay", operation: "workflow.replay", capabilityId: id, runId };
+    }
+    return undefined;
+}
+export function normalizeBasePath(value) {
+    if (!value.startsWith("/") || value.includes("?") || value.includes("#"))
+        throw new RangeError("basePath must be an absolute URL path");
+    const normalized = value.length > 1 ? value.replace(/\/+$/, "") : value;
+    if (normalized === "/")
+        throw new RangeError("basePath cannot expose the URL root");
+    return normalized;
+}
+//# sourceMappingURL=routing.js.map

package/dist/handler/sse.d.ts

@@ -0,0 +1,8 @@
+/** sse (0.2.5 plan 025 Task 1 split). Moved verbatim from handler.ts; public surface unchanged behind the barrel. */
+import type { AgentEvent, AgentEventEnvelope } from "@arnilo/prism";
+import type { CreatePrismHandlerOptions } from "../types.js";
+import type { ResolvedPrismServerLimits } from "../limits.js";
+import type { WorkflowEvent } from "@arnilo/prism-workflows";
+import { ownedSignal } from "./policy.js";
+export declare function sseAgentEvents(source: AsyncIterable<AgentEventEnvelope>, owned: ReturnType<typeof ownedSignal>, limits: ResolvedPrismServerLimits, options: CreatePrismHandlerOptions, release: () => void): Response;
+export declare function sse(source: AsyncIterable<AgentEvent | WorkflowEvent>, owned: ReturnType<typeof ownedSignal>, limits: ResolvedPrismServerLimits, options: CreatePrismHandlerOptions, release: () => void): Response;

package/dist/handler/sse.js

@@ -0,0 +1,71 @@
+import { PrismServerError } from "../types.js";
+import { SSE_HEADERS } from "./consts.js";
+export function sseAgentEvents(source, owned, limits, options, release) {
+    return sseStream(source, ({ record, cursor }) => {
+        if (/\r|\n|\0/.test(cursor) || Buffer.byteLength(cursor, "utf8") > limits.maxReplayCursorBytes) {
+            throw new PrismServerError("Invalid event cursor", 500, "ERR_PRISM_SERVER_REPLAY_CURSOR");
+        }
+        const safe = options.redactor?.redact(record.event) ?? record.event;
+        return `id: ${cursor}\ndata: ${JSON.stringify(safe)}\n\n`;
+    }, owned, limits, release);
+}
+export function sse(source, owned, limits, options, release) {
+    return sseStream(source, (value) => `data: ${JSON.stringify(options.redactor?.redact(value) ?? value)}\n\n`, owned, limits, release);
+}
+function sseStream(source, serialize, owned, limits, release) {
+    const iterator = source[Symbol.asyncIterator]();
+    const encoder = new TextEncoder();
+    let events = 0;
+    let bytes = 0;
+    let finished = false;
+    const onAbort = () => {
+        void finish(owned.signal.reason);
+    };
+    const finish = async (reason) => {
+        if (finished)
+            return;
+        finished = true;
+        owned.signal.removeEventListener("abort", onAbort);
+        owned.abort(reason);
+        owned.dispose();
+        release();
+        await iterator.return?.();
+    };
+    owned.signal.addEventListener("abort", onAbort, { once: true });
+    const stream = new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    await finish();
+                    controller.close();
+                    return;
+                }
+                const chunk = encoder.encode(serialize(next.value));
+                events += 1;
+                bytes += chunk.byteLength;
+                if (chunk.byteLength > limits.maxEventBytes || events > limits.maxStreamEvents || bytes > limits.maxStreamBytes) {
+                    const error = encoder.encode('data: {"type":"error","error":{"code":"ERR_PRISM_SERVER_STREAM_LIMIT","message":"stream limit exceeded"}}\n\n');
+                    if (error.byteLength <= limits.maxEventBytes)
+                        controller.enqueue(error);
+                    await finish(new Error("stream limit exceeded"));
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(chunk);
+            }
+            catch {
+                const error = encoder.encode('data: {"type":"error","error":{"code":"ERR_PRISM_SERVER_STREAM","message":"stream failed"}}\n\n');
+                if (error.byteLength <= limits.maxEventBytes)
+                    controller.enqueue(error);
+                await finish(new Error("stream failed"));
+                controller.close();
+            }
+        },
+        cancel(reason) {
+            return finish(reason);
+        },
+    });
+    return new Response(stream, { status: 200, headers: SSE_HEADERS });
+}
+//# sourceMappingURL=sse.js.map

package/dist/handler.d.ts

@@ -1,2 +1,10 @@
-import type { CreatePrismHandlerOptions, PrismRequestHandler } from "./types.js";
-export declare function createPrismHandler(options: CreatePrismHandlerOptions): PrismRequestHandler;
+/** handler.ts barrel (0.2.5 plan 025 Task 1 god-module split): re-exports the
+ * public surface from cohesive family modules (0.1.4 barrel precedent). */
+export * from "./handler/consts.js";
+export * from "./handler/core.js";
+export * from "./handler/routing.js";
+export * from "./handler/authorize.js";
+export * from "./handler/readers.js";
+export * from "./handler/policy.js";
+export * from "./handler/sse.js";
+export * from "./handler/respond.js";