@karmaniverous/jeeves-server-core 0.3.0 → 0.5.0

package/dist/scripts/openapiInfo.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Location and `info` block of jeeves-server-core's committed OpenAPI document (`openapi.json`), shared by the writer (`write-openapi.ts`) and the drift test. Reads `package.json`; no writes.
+ *
+ * @packageDocumentation
+ */
+import type { OpenApiInfo } from '@karmaniverous/jeeves/openapi';
+/** The committed document. */
+export declare const OPENAPI_FILE: string;
+/**
+ * The document's `info`: title, jeeves-server-core's current version,
+ * description.
+ *
+ * @returns OpenAPI `info`.
+ */
+export declare function openApiInfo(): OpenApiInfo;

package/dist/src/catalog/browserSafe.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The `./catalog` entry is browser-safe: its whole import graph (core's own modules and the parts of `@karmaniverous/jeeves/catalog` it loads) reaches only `zod` and `@karmaniverous/jeeves/catalog`, never a Node built-in or any other package.
+ */
+export {};

package/dist/src/catalog/contentEntries.d.ts

@@ -0,0 +1,468 @@
+/**
+ * The content entries of the server catalog: drives, browse, file content, write and mutate, raw, exports, export cache clear, link info, diagrams and public content. Content and navigation entries take the share parameters (`shareQuerySchema`) in their query. Pure.
+ *
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+/** The content entries. */
+export declare const CONTENT_ENTRIES: readonly [{
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodArray<z.ZodObject<{
+        letter: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "drives";
+    readonly method: "GET";
+    readonly path: "/api/drives";
+    readonly description: "List available root drives/labels configured on the server.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        path: z.ZodString;
+        ext: z.ZodString;
+        size: z.ZodNumber;
+        mtime: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        entries: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+            }>;
+            ext: z.ZodString;
+            size: z.ZodNullable<z.ZodNumber>;
+            mtime: z.ZodNullable<z.ZodString>;
+            itemCount: z.ZodNullable<z.ZodNumber>;
+            shareUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        breadcrumbs: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        isInsider: z.ZodBoolean;
+    }, z.core.$strip>]>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "browse";
+    readonly method: "GET";
+    readonly path: "/api/path/*";
+    readonly description: "Get file or directory metadata. For files: size, mtime, content type, rendered HTML availability. For directories: listing of entries.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        raw: z.ZodOptional<z.ZodString>;
+        render_diagrams: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        type: z.ZodEnum<{
+            plantuml: "plantuml";
+            text: "text";
+            markdown: "markdown";
+            mermaid: "mermaid";
+            svg: "svg";
+            csv: "csv";
+            image: "image";
+            binary: "binary";
+        }>;
+        content: z.ZodOptional<z.ZodString>;
+        html: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        headings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            text: z.ZodString;
+            slug: z.ZodString;
+        }, z.core.$strip>>>;
+        size: z.ZodOptional<z.ZodNumber>;
+        fileName: z.ZodString;
+        breadcrumbs: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        isInsider: z.ZodBoolean;
+        mtime: z.ZodOptional<z.ZodNumber>;
+        renderAs: z.ZodOptional<z.ZodString>;
+        matchedRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "fileContent";
+    readonly method: "GET";
+    readonly path: "/api/file/*";
+    readonly description: "Get a file with type-specific handling: Markdown, CSV and diagrams rendered to HTML, other text as is, images and binaries by name. `raw=1` skips rendering.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly body: z.ZodObject<{
+        content: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        path: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "write";
+    readonly name: "fileWrite";
+    readonly method: "PUT";
+    readonly path: "/api/file/*";
+    readonly description: "Overwrite the content of an existing file. Insider-only; the file must already exist.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly body: z.ZodObject<{
+        action: z.ZodEnum<{
+            "edit-block": "edit-block";
+            "delete-block": "delete-block";
+            "insert-block": "insert-block";
+            "edit-cell": "edit-cell";
+            "toggle-checkbox": "toggle-checkbox";
+        }>;
+        startLine: z.ZodOptional<z.ZodNumber>;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        content: z.ZodOptional<z.ZodString>;
+        atLine: z.ZodOptional<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodEnum<{
+            before: "before";
+            after: "after";
+        }>>;
+        context: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        col: z.ZodOptional<z.ZodNumber>;
+        index: z.ZodOptional<z.ZodNumber>;
+        checked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "write";
+    readonly name: "fileMutate";
+    readonly method: "POST";
+    readonly path: "/api/file/*";
+    readonly description: "Apply a structured mutation to a .md file. Insider-only. Supports: edit-block, delete-block, insert-block, edit-cell, toggle-checkbox.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        download: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "application/octet-stream";
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "raw";
+    readonly method: "GET";
+    readonly path: "/api/raw/*";
+    readonly description: "Download a file as is, with its own content type. `download=1` always sends it as an attachment.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<{
+            pdf: "pdf";
+            docx: "docx";
+            zip: "zip";
+            tar: "tar";
+        }>>;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "application/octet-stream";
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "export";
+    readonly method: "GET";
+    readonly path: "/api/export/*";
+    readonly description: "Export a Markdown document as PDF or DOCX, or a directory as a ZIP or Tar archive (archives for insiders only).";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        cleared: z.ZodObject<{
+            exports: z.ZodNumber;
+            diagrams: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+        readonly insiderOnly: true;
+    };
+    readonly kind: "write";
+    readonly name: "exportCacheClear";
+    readonly method: "DELETE";
+    readonly path: "/api/export-cache/*";
+    readonly description: "Clear the export and diagram caches for a given path.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "application/octet-stream";
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "exportMermaid";
+    readonly method: "GET";
+    readonly path: "/api/mermaid-export/*";
+    readonly description: "Export a Mermaid diagram file as SVG, PNG or PDF.";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "application/octet-stream";
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "exportPlantUml";
+    readonly method: "GET";
+    readonly path: "/api/plantuml-export/*";
+    readonly description: "Export a PlantUML diagram file in one of the formats the configured renderers support (SVG, PNG, PDF, EPS).";
+}, {
+    readonly params: z.ZodObject<{
+        '*': z.ZodString;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+        exp: z.ZodOptional<z.ZodString>;
+        d: z.ZodOptional<z.ZodString>;
+        dirs: z.ZodOptional<z.ZodString>;
+        s: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        exists: z.ZodBoolean;
+        isDirectory: z.ZodOptional<z.ZodBoolean>;
+        pageUrl: z.ZodOptional<z.ZodString>;
+        rawUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        downloadUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        exportLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            format: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    readonly auth: {
+        readonly schemes: readonly [{
+            readonly in: "query";
+            readonly name: "k";
+        }, {
+            readonly in: "cookie";
+            readonly name: "jeeves_session";
+        }];
+    };
+    readonly kind: "read";
+    readonly name: "linkInfo";
+    readonly method: "GET";
+    readonly path: "/api/link-info/*";
+    readonly description: "Query available link types for a path (exists, page URL, raw URL, export links for PDF/DOCX/SVG/PNG).";
+}, {
+    readonly params: z.ZodObject<{
+        type: z.ZodEnum<{
+            plantuml: "plantuml";
+            mermaid: "mermaid";
+        }>;
+        hash: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodInstanceOf<Uint8Array<ArrayBuffer>>;
+    readonly contentType: "image/svg+xml";
+    readonly auth: "none";
+    readonly kind: "read";
+    readonly name: "diagram";
+    readonly method: "GET";
+    readonly path: "/api/diagram/:type/:hash";
+    readonly description: "Get a diagram embedded in a rendered document, as SVG, by its type and content hash.";
+}, {
+    readonly params: z.ZodObject<{
+        slug: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+        type: z.ZodEnum<{
+            plantuml: "plantuml";
+            text: "text";
+            markdown: "markdown";
+            mermaid: "mermaid";
+            svg: "svg";
+            csv: "csv";
+            image: "image";
+            binary: "binary";
+        }>;
+        content: z.ZodOptional<z.ZodString>;
+        html: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        headings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            level: z.ZodNumber;
+            text: z.ZodString;
+            slug: z.ZodString;
+        }, z.core.$strip>>>;
+        size: z.ZodOptional<z.ZodNumber>;
+        fileName: z.ZodString;
+        breadcrumbs: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>>;
+        isInsider: z.ZodBoolean;
+        mtime: z.ZodOptional<z.ZodNumber>;
+        renderAs: z.ZodOptional<z.ZodString>;
+        matchedRules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly auth: "none";
+    readonly kind: "read";
+    readonly name: "publicContent";
+    readonly method: "GET";
+    readonly path: "/api/public-content/:slug";
+    readonly description: "Get one of the public pages of the server (readme, privacy, terms) rendered as Markdown.";
+}];

package/dist/src/catalog/contentEntries.js

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+import { drivesResponseSchema, browseResponseSchema, fileContentResponseSchema, fileWriteResponseSchema, fileWriteBodySchema, okResponseSchema, exportCacheClearResponseSchema, linkInfoResponseSchema, fileContentQuerySchema } from './contentSchemas.js';
+import { fileMutateBodySchema } from './fileMutateSchema.js';
+import { KEY_OR_SESSION, shareQuerySchema, browsePathParams, INSIDER_ONLY, PUBLIC, route, wildcardParams } from './route.js';
+
+/**
+ * The content entries of the server catalog: drives, browse, file content, write and mutate, raw, exports, export cache clear, link info, diagrams and public content. Content and navigation entries take the share parameters (`shareQuerySchema`) in their query. Pure.
+ *
+ * @packageDocumentation
+ */
+/** Bytes: the response of a binary entry. */
+const bytes = z.instanceof(Uint8Array);
+/** Content type of binary entries whose type depends on the file. */
+const OCTET_STREAM = 'application/octet-stream';
+/** An optional `format` query field. */
+const formatQuery = (description) => z.string().optional().describe(description);
+/** The content entries. */
+const CONTENT_ENTRIES = [
+    {
+        ...route('drives', 'GET', '/api/drives'),
+        query: shareQuerySchema,
+        response: drivesResponseSchema,
+        auth: KEY_OR_SESSION,
+        kind: 'read',
+    },
+    {
+        ...route('browse', 'GET', '/api/path/*'),
+        params: wildcardParams('Browse path (e.g. "<drive>/path/to/dir")'),
+        query: shareQuerySchema,
+        response: browseResponseSchema,
+        auth: KEY_OR_SESSION,
+        kind: 'read',
+    },
+    {
+        ...route('fileContent', 'GET', '/api/file/*'),
+        params: browsePathParams,
+        query: shareQuerySchema.extend(fileContentQuerySchema.shape),
+        response: fileContentResponseSchema,
+        auth: KEY_OR_SESSION,
+        kind: 'read',
+    },
+    {
+        ...route('fileWrite', 'PUT', '/api/file/*'),
+        params: browsePathParams,
+        query: shareQuerySchema,
+        body: fileWriteBodySchema,
+        response: fileWriteResponseSchema,
+        auth: INSIDER_ONLY,
+        kind: 'write',
+    },
+    {
+        ...route('fileMutate', 'POST', '/api/file/*'),
+        params: wildcardParams('File path (must be a .md file)'),
+        query: shareQuerySchema,
+        body: fileMutateBodySchema,
+        response: okResponseSchema,
+        auth: INSIDER_ONLY,
+        kind: 'write',
+    },
+    {
+        ...route('raw', 'GET', '/api/raw/*'),
+        params: browsePathParams,
+        query: shareQuerySchema.extend({
+            download: z
+                .string()
+                .optional()
+                .describe('1 (or true): send Content-Disposition: attachment for any file type.'),
+        }),
+        response: bytes,
+        contentType: OCTET_STREAM,
+        auth: KEY_OR_SESSION,
+        kind: 'read',
+    },
+    {
+        ...route('export', 'GET', '/api/export/*'),
+        params: browsePathParams,
+        query: shareQuerySchema.extend({
+            format: z
+                .enum(['pdf', 'docx', 'zip', 'tar'])
+                .optional()
+                .describe('pdf (default) or docx for Markdown documents; zip or tar for directories.'),
+        }),
+        response: bytes,
+        contentType: OCTET_STREAM,
+        auth: KEY_OR_SESSION,
+        kind: 'read',
+    },
+    {
+        ...route('exportCacheClear', 'DELETE', '/api/export-cache/*'),
+        params: wildcardParams('Browse path to clear caches for'),
+        query: shareQuerySchema,
+        response: exportCacheClearResponseSchema,
+        auth: INSIDER_ONLY,
+        kind: 'write',
+    },
+    {
+        ...route('exportMermaid', 'GET', '/api/mermaid-export/*'),
+        params: browsePathParams,
+        query: shareQuerySchema.extend({
+            format: formatQuery('svg (default), png or pdf.'),
+        }),
+        response: bytes,
+        contentType: OCTET_STREAM,
+        auth: KEY_OR_SESSION,
+        kind: 'read',
+    },
+    {
+        ...route('exportPlantUml', 'GET', '/api/plantuml-export/*'),
+        params: browsePathParams,
+        query: shareQuerySchema.extend({
+            format: formatQuery('svg (default), or another format the renderers support (png, pdf, eps).'),
+        }),
+        response: bytes,
+        contentType: OCTET_STREAM,
+        auth: KEY_OR_SESSION,
+        kind: 'read',
+    },
+    {
+        ...route('linkInfo', 'GET', '/api/link-info/*'),
+        params: browsePathParams,
+        query: shareQuerySchema,
+        response: linkInfoResponseSchema,
+        auth: KEY_OR_SESSION,
+        kind: 'read',
+    },
+    {
+        ...route('diagram', 'GET', '/api/diagram/:type/:hash'),
+        params: z.object({
+            type: z.enum(['mermaid', 'plantuml']).describe('Diagram type.'),
+            hash: z
+                .string()
+                .describe('SHA-256 of the diagram source (hex), optionally with .svg.'),
+        }),
+        response: bytes,
+        contentType: 'image/svg+xml',
+        auth: PUBLIC,
+        kind: 'read',
+    },
+    {
+        ...route('publicContent', 'GET', '/api/public-content/:slug'),
+        params: z.object({
+            slug: z.string().describe('Page: readme, privacy or terms.'),
+        }),
+        response: fileContentResponseSchema,
+        auth: PUBLIC,
+        kind: 'read',
+    },
+];
+
+export { CONTENT_ENTRIES };