@shaferllc/keel 0.66.0 → 0.74.0

package/dist/openapi/provider.js

@@ -0,0 +1,35 @@
+/**
+ * Keel OpenAPI — generate an OpenAPI 3 spec from your routes and serve Swagger UI,
+ * shipped as a Keel package. One line turns it on:
+ *
+ *   app.register(OpenApiServiceProvider);
+ *
+ * The spec is built from Keel's own route table plus whatever each route attaches
+ * with `.config(apiDoc(...))`. Nothing is scraped or guessed: paths and methods
+ * are always right, and schemas are as rich as the metadata a route provides.
+ */
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { PackageProvider } from "../core/package.js";
+import { resolveConfig, defaultConfig } from "./config.js";
+import { registerOpenApiRoutes } from "./routes.js";
+import { exportCommand } from "./export.js";
+const here = dirname(fileURLToPath(import.meta.url));
+export class OpenApiServiceProvider extends PackageProvider {
+    name = "openapi";
+    config;
+    base() {
+        return "/" + this.config.path.replace(/^\/|\/$/g, "");
+    }
+    register() {
+        this.mergeConfig("openapi", defaultConfig);
+        this.config = resolveConfig();
+        this.publishes({ [join(here, "openapi.config.stub")]: "config/openapi.ts" }, "openapi-config");
+        this.commands([exportCommand(() => this.app.router(), this.config, this.base())]);
+    }
+    boot() {
+        if (!this.config.enabled)
+            return;
+        this.routes((r) => registerOpenApiRoutes(r, this.config, this.app.router(), this.base()), { prefix: this.config.path, as: "openapi" });
+    }
+}

package/dist/openapi/routes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The docs HTTP surface: the generated spec at `/openapi.json` and the Swagger UI
+ * at the base path. The spec is built once, lazily, from the full route table
+ * (which is complete only after the app has loaded its routes) and cached.
+ * Both routes are behind the gate.
+ */
+import type { Router } from "../core/http/router.js";
+import type { OpenApiConfig } from "./config.js";
+export declare function registerOpenApiRoutes(r: Router, config: OpenApiConfig, router: Router, base: string): void;

package/dist/openapi/routes.js

@@ -0,0 +1,23 @@
+/**
+ * The docs HTTP surface: the generated spec at `/openapi.json` and the Swagger UI
+ * at the base path. The spec is built once, lazily, from the full route table
+ * (which is complete only after the app has loaded its routes) and cached.
+ * Both routes are behind the gate.
+ */
+import { buildSpec } from "./spec.js";
+import { swaggerHtml } from "./ui.js";
+import { passesGate } from "./gate.js";
+export function registerOpenApiRoutes(r, config, router, base) {
+    let cached;
+    const spec = () => (cached ??= buildSpec(router.all(), config, base));
+    r.get("/openapi.json", async (c) => {
+        if (!(await passesGate(c, config)))
+            return c.json({ error: "Forbidden" }, 403);
+        return c.json(spec());
+    }).name("spec");
+    r.get("/", async (c) => {
+        if (!(await passesGate(c, config)))
+            return c.text("Forbidden", 403);
+        return c.html(swaggerHtml(`${base}/openapi.json`, config));
+    }).name("ui");
+}

package/dist/openapi/spec.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Build an OpenAPI 3.0 document from Keel's own route table. Every registered
+ * route already carries its methods, path, name, param constraints, and any
+ * `.config(apiDoc(...))` metadata — that's the whole input. Paths and methods
+ * come for free; request/response schemas come from the docs metadata a route
+ * chose to attach. A route with no metadata still appears, just bare.
+ */
+import type { RouteDefinition } from "../core/http/router.js";
+import type { OpenApiConfig } from "./config.js";
+export interface OpenApiDocument {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    servers?: {
+        url: string;
+    }[];
+    paths: Record<string, Record<string, unknown>>;
+}
+/** Assemble the whole document from the route table. */
+export declare function buildSpec(routes: RouteDefinition[], config: OpenApiConfig, base: string): OpenApiDocument;

package/dist/openapi/spec.js

@@ -0,0 +1,132 @@
+/**
+ * Build an OpenAPI 3.0 document from Keel's own route table. Every registered
+ * route already carries its methods, path, name, param constraints, and any
+ * `.config(apiDoc(...))` metadata — that's the whole input. Paths and methods
+ * come for free; request/response schemas come from the docs metadata a route
+ * chose to attach. A route with no metadata still appears, just bare.
+ */
+import { OPENAPI_KEY } from "./doc.js";
+import { toJsonSchema } from "./zod.js";
+/** `/users/:id` (and `:id?`) → `/users/{id}` — OpenAPI's path-template syntax. */
+function toTemplate(path) {
+    return path.replace(/:([A-Za-z0-9_]+)\??/g, "{$1}");
+}
+/** The `:param` names in a path, in order. */
+function paramNames(path) {
+    return [...path.matchAll(/:([A-Za-z0-9_]+)\??/g)].map((m) => m[1]);
+}
+/** An operationId that's stable and unique: the route name, else method + path. */
+function operationId(route, method) {
+    if (route.name)
+        return route.name;
+    const slug = route.path.replace(/[^A-Za-z0-9]+/g, "_").replace(/^_|_$/g, "");
+    return `${method.toLowerCase()}_${slug || "root"}`;
+}
+/** Path parameters — from the URL template, enriched by any `params` schema/`where`. */
+function pathParameters(route, doc) {
+    const paramsSchema = doc?.request?.params ? toJsonSchema(doc.request.params) : undefined;
+    const props = (paramsSchema?.properties ?? {});
+    return paramNames(route.path).map((name) => {
+        const schema = props[name] ?? { type: "string" };
+        // A `.where("id", /\d+/)` constraint becomes a pattern hint.
+        if (route.wheres[name] && !("pattern" in schema)) {
+            schema.pattern = `^${route.wheres[name]}$`;
+        }
+        return { name, in: "path", required: true, schema };
+    });
+}
+/** Query parameters — expanded from a `query` schema's top-level properties. */
+function queryParameters(doc) {
+    const schema = doc?.request?.query ? toJsonSchema(doc.request.query) : undefined;
+    if (!schema?.properties)
+        return [];
+    const required = new Set(schema.required ?? []);
+    return Object.entries(schema.properties).map(([name, propSchema]) => ({
+        name,
+        in: "query",
+        required: required.has(name),
+        schema: propSchema,
+    }));
+}
+const HAS_BODY = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+/** Build one operation object for a (route, method) pair. */
+function buildOperation(route, method, doc) {
+    const op = {
+        operationId: doc?.operationId ?? operationId(route, method),
+        tags: doc?.tags ?? [defaultTag(route.path)],
+        parameters: [...pathParameters(route, doc), ...queryParameters(doc)],
+    };
+    if (doc?.summary)
+        op.summary = doc.summary;
+    if (doc?.description)
+        op.description = doc.description;
+    if (doc?.deprecated)
+        op.deprecated = true;
+    const body = doc?.request?.body ? toJsonSchema(doc.request.body) : undefined;
+    if (body && HAS_BODY.has(method)) {
+        op.requestBody = { required: true, content: { "application/json": { schema: body } } };
+    }
+    op.responses = buildResponses(doc);
+    return op;
+}
+/** Responses from the docs, or a sensible default, plus a 422 when input is validated. */
+function buildResponses(doc) {
+    const responses = {};
+    if (doc?.responses) {
+        for (const [status, res] of Object.entries(doc.responses)) {
+            const schema = res.schema ? toJsonSchema(res.schema) : undefined;
+            responses[status] = {
+                description: res.description ?? "",
+                ...(schema ? { content: { "application/json": { schema } } } : {}),
+            };
+        }
+    }
+    if (!Object.keys(responses).length)
+        responses["200"] = { description: "OK" };
+    // A documented request means validation can reject it.
+    if (doc?.request && !responses["422"]) {
+        responses["422"] = { description: "Validation failed" };
+    }
+    return responses;
+}
+/** The tag for an undocumented route: its first path segment. */
+function defaultTag(path) {
+    const seg = path.split("/").filter(Boolean)[0] ?? "default";
+    return seg.startsWith(":") ? "default" : seg;
+}
+/** Whether a route is left out of the spec. */
+function skip(route, config, base) {
+    const doc = route.config?.[OPENAPI_KEY];
+    if (doc?.hidden)
+        return true;
+    if (route.path.includes("*"))
+        return true; // wildcard/asset routes aren't API endpoints
+    if (route.path === base || route.path.startsWith(`${base}/`))
+        return true; // the docs' own routes
+    return config.ignorePaths.some((p) => route.path.startsWith(p));
+}
+/** Assemble the whole document from the route table. */
+export function buildSpec(routes, config, base) {
+    const paths = {};
+    for (const route of routes) {
+        if (skip(route, config, base))
+            continue;
+        const doc = route.config?.[OPENAPI_KEY];
+        const template = toTemplate(route.path);
+        for (const method of route.methods) {
+            if (method === "HEAD" || method === "OPTIONS")
+                continue;
+            (paths[template] ??= {})[method.toLowerCase()] = buildOperation(route, method, doc);
+        }
+    }
+    return {
+        openapi: "3.0.3",
+        info: {
+            title: config.title,
+            version: config.version,
+            ...(config.description ? { description: config.description } : {}),
+        },
+        ...(config.servers.length ? { servers: config.servers.map((url) => ({ url })) } : {}),
+        paths,
+    };
+}

package/dist/openapi/ui.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The docs UI: a Swagger UI shell pointed at the generated spec. Swagger UI's
+ * assets load from the configured `cdn` (pin it, or point it at a copy you host)
+ * — the one external dependency in this package, kept to the UI. The spec itself
+ * (`/openapi.json`) is generated with zero dependencies and works anywhere.
+ */
+import type { OpenApiConfig } from "./config.js";
+export declare function swaggerHtml(specUrl: string, cfg: OpenApiConfig): string;

package/dist/openapi/ui.js

@@ -0,0 +1,31 @@
+/**
+ * The docs UI: a Swagger UI shell pointed at the generated spec. Swagger UI's
+ * assets load from the configured `cdn` (pin it, or point it at a copy you host)
+ * — the one external dependency in this package, kept to the UI. The spec itself
+ * (`/openapi.json`) is generated with zero dependencies and works anywhere.
+ */
+import { escapeHtml } from "../core/template.js";
+export function swaggerHtml(specUrl, cfg) {
+    const cdn = cfg.cdn.replace(/\/+$/, "");
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(cfg.title)} — API docs</title>
+  <link rel="stylesheet" href="${cdn}/swagger-ui.css" />
+  <style>body { margin: 0; }</style>
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="${cdn}/swagger-ui-bundle.js" crossorigin></script>
+  <script>
+    window.ui = SwaggerUIBundle({
+      url: ${JSON.stringify(specUrl)},
+      dom_id: "#swagger-ui",
+      deepLinking: true,
+    });
+  </script>
+</body>
+</html>`;
+}

package/dist/openapi/zod.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Schema conversion. A route documents itself with the same Zod schemas it
+ * validates with; the spec needs JSON Schema. Zod 4 ships that conversion
+ * (`z.toJSONSchema`), so this is a thin, defensive wrapper: Zod schemas are
+ * converted (targeting OpenAPI 3.0's dialect), plain JSON Schema objects pass
+ * through untouched, and anything unrecognized yields `undefined` rather than
+ * throwing — a missing schema shouldn't sink the whole document.
+ */
+type JsonSchema = Record<string, unknown>;
+/** Convert a Zod schema or JSON Schema to an OpenAPI-flavoured JSON Schema. */
+export declare function toJsonSchema(schema: unknown): JsonSchema | undefined;
+export {};

package/dist/openapi/zod.js

@@ -0,0 +1,46 @@
+/**
+ * Schema conversion. A route documents itself with the same Zod schemas it
+ * validates with; the spec needs JSON Schema. Zod 4 ships that conversion
+ * (`z.toJSONSchema`), so this is a thin, defensive wrapper: Zod schemas are
+ * converted (targeting OpenAPI 3.0's dialect), plain JSON Schema objects pass
+ * through untouched, and anything unrecognized yields `undefined` rather than
+ * throwing — a missing schema shouldn't sink the whole document.
+ */
+import { z } from "zod";
+/** Duck-type a Zod (or Zod-like) schema. */
+function isZod(value) {
+    return (!!value &&
+        typeof value.parse === "function" &&
+        typeof value.safeParse === "function");
+}
+/** A value that already looks like a JSON Schema (or a `$ref`). */
+function isJsonSchema(value) {
+    if (!value || typeof value !== "object" || isZod(value))
+        return false;
+    const keys = ["type", "$ref", "properties", "items", "oneOf", "anyOf", "allOf", "enum"];
+    return keys.some((k) => k in value);
+}
+/** Convert a Zod schema or JSON Schema to an OpenAPI-flavoured JSON Schema. */
+export function toJsonSchema(schema) {
+    if (!schema)
+        return undefined;
+    if (isJsonSchema(schema))
+        return schema;
+    if (!isZod(schema))
+        return undefined;
+    const convert = z.toJSONSchema;
+    if (typeof convert !== "function")
+        return undefined;
+    try {
+        // OpenAPI 3.0 uses `nullable` and a few other divergences from raw JSON Schema.
+        return convert(schema, { target: "openapi-3.0", io: "input" });
+    }
+    catch {
+        try {
+            return convert(schema);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}

package/dist/watch/config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Watch configuration. Defaults live here and are merged under `config("watch")`
+ * by the provider; an app overrides any of them in `config/watch.ts` (publish it
+ * with `keel vendor:publish --tag watch-config`).
+ */
+import type { EntryType } from "./entry.js";
+export interface WatchConfig {
+    /** Master switch. Off → no watchers install and the dashboard 404s. */
+    enabled: boolean;
+    /** URL prefix the dashboard and API mount under. Default: "watch". */
+    path: string;
+    /** Where entries live. "database" persists them; "memory" is a per-process ring. */
+    storage: "database" | "memory";
+    /** The database connection to use (when storage is "database"). */
+    connection?: string;
+    /** The table entries are stored in. */
+    table: string;
+    /** Ring size for the memory store, and the default page size for the API. */
+    limit: number;
+    /** Record only this fraction of eligible entries (0–1). 1 records everything. */
+    sampling: number;
+    /** Tag queries slower than this (ms) with `slow`. */
+    slowQueryMs: number;
+    /** Request path prefixes to never record (the dashboard's own are always skipped). */
+    ignorePaths: string[];
+    /** Delete entries older than this many hours when `watch:prune` runs. */
+    retentionHours: number;
+    /** Per-type on/off switches. Noisy watchers (cache, event) default off. */
+    watchers: Record<EntryType, boolean>;
+}
+export declare const defaultConfig: WatchConfig;
+/** Read the effective Watch config off the application, filling any gaps. */
+export declare function resolveConfig(): WatchConfig;

package/dist/watch/config.js

@@ -0,0 +1,38 @@
+/**
+ * Watch configuration. Defaults live here and are merged under `config("watch")`
+ * by the provider; an app overrides any of them in `config/watch.ts` (publish it
+ * with `keel vendor:publish --tag watch-config`).
+ */
+import { config } from "../core/helpers.js";
+export const defaultConfig = {
+    enabled: true,
+    path: "watch",
+    storage: "database",
+    table: "watch_entries",
+    limit: 100,
+    sampling: 1,
+    slowQueryMs: 100,
+    ignorePaths: [],
+    retentionHours: 24,
+    watchers: {
+        request: true,
+        query: true,
+        exception: true,
+        log: true,
+        mail: true,
+        job: true,
+        notification: true,
+        cache: false,
+        event: false,
+        schedule: true,
+    },
+};
+/** Read the effective Watch config off the application, filling any gaps. */
+export function resolveConfig() {
+    const raw = config("watch", {});
+    return {
+        ...defaultConfig,
+        ...raw,
+        watchers: { ...defaultConfig.watchers, ...(raw.watchers ?? {}) },
+    };
+}

package/dist/watch/entry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A recorded entry — one thing that happened in the app: a request, a query, an
+ * exception, a log line. Every watcher produces these; the store persists them;
+ * the dashboard reads them back.
+ *
+ * Two ids give the UI its shape. `batchId` ties an entry to the request (or job,
+ * or scheduled run) it happened inside, so the dashboard can show a request and
+ * every query, log, and exception it produced. `familyHash` groups entries that
+ * are "the same" — the same SQL shape, the same exception — so recurring things
+ * can be counted and collapsed.
+ */
+export type EntryType = "request" | "query" | "exception" | "log" | "mail" | "job" | "notification" | "cache" | "event" | "schedule";
+/** Every entry type, in the order the dashboard shows its tabs. */
+export declare const ENTRY_TYPES: EntryType[];
+export interface Entry {
+    /** Unique id (32 hex). */
+    uuid: string;
+    /** The request/job/run this happened inside; groups related entries. */
+    batchId: string;
+    type: EntryType;
+    /** Groups "the same" entry — same SQL shape, same exception class+message. */
+    familyHash?: string;
+    /** The type-specific detail the dashboard renders. Always JSON-safe. */
+    content: Record<string, unknown>;
+    /** Free-form labels for filtering: `status:500`, `slow`, `connection:default`. */
+    tags: string[];
+    /** Epoch milliseconds. */
+    createdAt: number;
+}
+/** A filter over stored entries, for the list endpoint. */
+export interface EntryFilter {
+    type?: EntryType;
+    tag?: string;
+    batchId?: string;
+    /** Keyset pagination: only entries created strictly before this timestamp. */
+    before?: number;
+    limit?: number;
+}
+/** A 32-hex id for an entry. */
+export declare function newUuid(): string;
+/** A short, stable hash (8 hex) of a string — for `familyHash`. */
+export declare function familyHash(input: string): string;
+/**
+ * Make an arbitrary value safe to store as JSON: unwrap Errors, truncate long
+ * strings, drop functions, and break cycles. Watchers hand user data (request
+ * bodies, job payloads, event payloads) straight through, so this is the barrier
+ * that keeps one weird value from poisoning the whole store.
+ */
+export declare function jsonSafe(value: unknown, seen?: WeakSet<object>): unknown;
+/** Redact auth/cookie headers before an entry is stored or shown. */
+export declare function redactHeaders(headers: Record<string, string>): Record<string, string>;
+/** Collapse a SQL statement to its shape, so `id = 1` and `id = 2` group together. */
+export declare function sqlShape(sql: string): string;

package/dist/watch/entry.js

@@ -0,0 +1,105 @@
+/**
+ * A recorded entry — one thing that happened in the app: a request, a query, an
+ * exception, a log line. Every watcher produces these; the store persists them;
+ * the dashboard reads them back.
+ *
+ * Two ids give the UI its shape. `batchId` ties an entry to the request (or job,
+ * or scheduled run) it happened inside, so the dashboard can show a request and
+ * every query, log, and exception it produced. `familyHash` groups entries that
+ * are "the same" — the same SQL shape, the same exception — so recurring things
+ * can be counted and collapsed.
+ */
+/** Every entry type, in the order the dashboard shows its tabs. */
+export const ENTRY_TYPES = [
+    "request",
+    "query",
+    "exception",
+    "log",
+    "mail",
+    "job",
+    "notification",
+    "cache",
+    "event",
+    "schedule",
+];
+/* --------------------------------- ids ------------------------------------ */
+/** A 32-hex id for an entry. */
+export function newUuid() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/** A short, stable hash (8 hex) of a string — for `familyHash`. */
+export function familyHash(input) {
+    // FNV-1a: tiny, dependency-free, good enough to group like with like.
+    let h = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        h ^= input.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16).padStart(8, "0");
+}
+/* ------------------------------- serializing ------------------------------ */
+const MAX_STRING = 8_000;
+/**
+ * Make an arbitrary value safe to store as JSON: unwrap Errors, truncate long
+ * strings, drop functions, and break cycles. Watchers hand user data (request
+ * bodies, job payloads, event payloads) straight through, so this is the barrier
+ * that keeps one weird value from poisoning the whole store.
+ */
+export function jsonSafe(value, seen = new WeakSet()) {
+    if (value === null || value === undefined)
+        return value ?? null;
+    const t = typeof value;
+    if (t === "string") {
+        const s = value;
+        return s.length > MAX_STRING ? `${s.slice(0, MAX_STRING)}… (${s.length} chars)` : s;
+    }
+    if (t === "number" || t === "boolean")
+        return value;
+    if (t === "bigint")
+        return `${value.toString()}n`;
+    if (t === "function" || t === "symbol")
+        return `[${t}]`;
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: (value.stack ?? "").split("\n").map((l) => l.trim()),
+        };
+    }
+    if (value instanceof Date)
+        return value.toISOString();
+    if (typeof value === "object") {
+        if (seen.has(value))
+            return "[Circular]";
+        seen.add(value);
+        if (Array.isArray(value))
+            return value.slice(0, 200).map((v) => jsonSafe(v, seen));
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = jsonSafe(v, seen);
+        }
+        return out;
+    }
+    return String(value);
+}
+const REDACTED = "[redacted]";
+const SENSITIVE_HEADERS = new Set(["authorization", "cookie", "set-cookie", "proxy-authorization"]);
+/** Redact auth/cookie headers before an entry is stored or shown. */
+export function redactHeaders(headers) {
+    const out = {};
+    for (const [k, v] of Object.entries(headers)) {
+        out[k] = SENSITIVE_HEADERS.has(k.toLowerCase()) ? REDACTED : v;
+    }
+    return out;
+}
+/** Collapse a SQL statement to its shape, so `id = 1` and `id = 2` group together. */
+export function sqlShape(sql) {
+    return sql
+        .replace(/\s+/g, " ")
+        .replace(/'[^']*'/g, "?")
+        .replace(/\b\d+\b/g, "?")
+        .trim()
+        .toLowerCase();
+}

package/dist/watch/gate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Who may see the dashboard. It exposes requests, payloads, and stack traces, so
+ * it must never be world-readable in production. By default it's open only when
+ * `app.debug` is on or the app isn't in production; call `Watch.auth()` to plug
+ * in your own check (an admin session, an allow-list) — mirrors Telescope's gate.
+ */
+import type { Ctx } from "../core/http/router.js";
+export type WatchGate = (c: Ctx) => boolean | Promise<boolean>;
+export declare const Watch: {
+    /**
+     * Restrict dashboard access. Return true to allow the request.
+     *
+     *   Watch.auth((c) => auth().check() && auth().user()?.isAdmin);
+     */
+    auth(fn: WatchGate): void;
+    /** Remove a custom gate, reverting to the default. */
+    clearAuth(): void;
+};
+/** Whether the current request may see the dashboard. */
+export declare function passesGate(c: Ctx): Promise<boolean>;

package/dist/watch/gate.js

@@ -0,0 +1,32 @@
+/**
+ * Who may see the dashboard. It exposes requests, payloads, and stack traces, so
+ * it must never be world-readable in production. By default it's open only when
+ * `app.debug` is on or the app isn't in production; call `Watch.auth()` to plug
+ * in your own check (an admin session, an allow-list) — mirrors Telescope's gate.
+ */
+import { config } from "../core/helpers.js";
+let gate;
+export const Watch = {
+    /**
+     * Restrict dashboard access. Return true to allow the request.
+     *
+     *   Watch.auth((c) => auth().check() && auth().user()?.isAdmin);
+     */
+    auth(fn) {
+        gate = fn;
+    },
+    /** Remove a custom gate, reverting to the default. */
+    clearAuth() {
+        gate = undefined;
+    },
+};
+/** Allow when debugging, or anywhere that isn't production. */
+function defaultGate() {
+    if (config("app.debug", false))
+        return true;
+    return config("app.env", "production") !== "production";
+}
+/** Whether the current request may see the dashboard. */
+export async function passesGate(c) {
+    return gate ? gate(c) : defaultGate();
+}

package/dist/watch/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Keel Watch — a debug dashboard for Keel apps, imported from
+ * `@shaferllc/keel/watch`. Register the provider and open `/watch`:
+ *
+ *   import { WatchServiceProvider } from "@shaferllc/keel/watch";
+ *   app.register(WatchServiceProvider);
+ *
+ * Lock down who can see it with `Watch.auth()`.
+ */
+export { WatchServiceProvider } from "./provider.js";
+export { Watch } from "./gate.js";
+export type { WatchGate } from "./gate.js";
+export { resolveConfig, defaultConfig } from "./config.js";
+export type { WatchConfig } from "./config.js";
+export { MemoryStore, DatabaseStore } from "./store.js";
+export type { EntryStore } from "./store.js";
+export { watchMigration } from "./migration.js";
+export { Recorder } from "./recorder.js";
+export { installWatchers } from "./watchers.js";
+export { ENTRY_TYPES, newUuid, familyHash, jsonSafe, redactHeaders, sqlShape, } from "./entry.js";
+export type { Entry, EntryType, EntryFilter } from "./entry.js";

package/dist/watch/index.js

@@ -0,0 +1,17 @@
+/**
+ * Keel Watch — a debug dashboard for Keel apps, imported from
+ * `@shaferllc/keel/watch`. Register the provider and open `/watch`:
+ *
+ *   import { WatchServiceProvider } from "@shaferllc/keel/watch";
+ *   app.register(WatchServiceProvider);
+ *
+ * Lock down who can see it with `Watch.auth()`.
+ */
+export { WatchServiceProvider } from "./provider.js";
+export { Watch } from "./gate.js";
+export { resolveConfig, defaultConfig } from "./config.js";
+export { MemoryStore, DatabaseStore } from "./store.js";
+export { watchMigration } from "./migration.js";
+export { Recorder } from "./recorder.js";
+export { installWatchers } from "./watchers.js";
+export { ENTRY_TYPES, newUuid, familyHash, jsonSafe, redactHeaders, sqlShape, } from "./entry.js";

package/dist/watch/migration.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The `watch_entries` table. Contributed by the provider via `this.migrations()`
+ * and run by `keel migrate` alongside the app's own — the same path any package
+ * ships schema on.
+ */
+import type { Migration } from "../core/migrations.js";
+export declare function watchMigration(table?: string): Migration;