@wjarka/cezarion 0.16.0 → 0.17.0

package/dist/contract/live-coordination.d.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+import { liveRunFrameSchema } from './live.ts';
+export declare const LIVE_PROTOCOL = 1;
+export declare const LIVE_WORKER_NAME = "cezar-live-v1";
+export declare const LEASE_MS = 15000;
+export declare const RENEW_MS = 5000;
+/** Only periodic public cockpit GET families; never arbitrary URLs or mutation execution. */
+export declare function allowedLiveRead(path: string): boolean;
+export declare const liveDemandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"workspace">;
+}, z.core.$strip>, z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    afterSeq: z.ZodNumber;
+    kind: z.ZodLiteral<"run">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"topic">;
+    topic: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"read">;
+    path: z.ZodString;
+    intervalMs: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+export type LiveDemand = z.infer<typeof liveDemandSchema>;
+export declare const liveEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    demand: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"workspace">;
+    }, z.core.$strip>, z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        cursor: z.ZodOptional<z.ZodString>;
+        afterSeq: z.ZodNumber;
+        kind: z.ZodLiteral<"run">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"topic">;
+        topic: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"read">;
+        path: z.ZodString;
+        intervalMs: z.ZodNumber;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export declare const ownerInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    documentId: z.ZodString;
+    epoch: z.ZodNumber;
+    type: z.ZodLiteral<"sync">;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        demand: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"workspace">;
+        }, z.core.$strip>, z.ZodObject<{
+            projectId: z.ZodString;
+            runId: z.ZodString;
+            cursor: z.ZodOptional<z.ZodString>;
+            afterSeq: z.ZodNumber;
+            kind: z.ZodLiteral<"run">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"topic">;
+            topic: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"read">;
+            path: z.ZodString;
+            intervalMs: z.ZodNumber;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    documentId: z.ZodString;
+    epoch: z.ZodNumber;
+    type: z.ZodLiteral<"ack">;
+    id: z.ZodString;
+    seq: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    documentId: z.ZodString;
+    epoch: z.ZodNumber;
+    type: z.ZodLiteral<"refresh">;
+    id: z.ZodString;
+}, z.core.$strip>], "type">;
+export type OwnerInput = z.infer<typeof ownerInputSchema>;
+export declare const wireFrameSchema: z.ZodObject<{
+    event: z.ZodString;
+    data: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const ownerOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"unavailable">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    version: z.ZodLiteral<1>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"alive">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"frame">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+    id: z.ZodString;
+    frame: z.ZodUnion<readonly [z.ZodObject<{
+        event: z.ZodString;
+        data: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"ready">;
+        generation: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ping">;
+    }, z.core.$strip>, z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        type: z.ZodLiteral<"event">;
+        name: z.ZodEnum<{
+            "run-event": "run-event";
+            "ui-event": "ui-event";
+        }>;
+        event: z.ZodObject<{
+            seq: z.ZodNumber;
+            ts: z.ZodString;
+            stepId: z.ZodOptional<z.ZodString>;
+            type: z.ZodString;
+        }, z.core.$catchall<z.ZodAny>>;
+    }, z.core.$strip>, z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        type: z.ZodEnum<{
+            error: "error";
+            reset: "reset";
+        }>;
+        status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+        error: z.ZodString;
+    }, z.core.$strip>]>]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"value">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+    id: z.ZodString;
+    value: z.ZodUnknown;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reset">;
+    version: z.ZodLiteral<1>;
+    epoch: z.ZodNumber;
+    id: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>], "type">;
+export type OwnerOutput = z.infer<typeof ownerOutputSchema>;
+export type LiveFrame = z.infer<typeof wireFrameSchema> | z.infer<typeof liveRunFrameSchema>;
+export declare const runKey: (run: {
+    projectId: string;
+    runId: string;
+}) => string;

package/dist/contract/live-limits.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bounds of one live-runs batch, shared by the route and the cockpit's reader.
+ *
+ * No runtime import, so a consumer of these loads no schema (hearsay-tools/cezarion#1237).
+ */
+export declare const LIVE_RUN_LIMIT = 32;
+export declare const LIVE_EVENT_LIMIT = 256;
+export declare const LIVE_BYTE_LIMIT: number;

package/dist/contract/live.d.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+export declare const liveRunDemandSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    afterSeq: z.ZodNumber;
+}, z.core.$strip>;
+export type LiveRunDemand = z.infer<typeof liveRunDemandSchema>;
+export declare const liveRunsRequestSchema: z.ZodObject<{
+    runs: z.ZodArray<z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        cursor: z.ZodOptional<z.ZodString>;
+        afterSeq: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LiveRunsRequest = z.infer<typeof liveRunsRequestSchema>;
+export declare const liveRunErrorSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodEnum<{
+        error: "error";
+        reset: "reset";
+    }>;
+    status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+    error: z.ZodString;
+}, z.core.$strip>;
+export declare const liveRunBatchSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodLiteral<"batch">;
+    events: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodAny>>>;
+    cursor: z.ZodString;
+    afterSeq: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+export type LiveRunBatch = z.infer<typeof liveRunBatchSchema>;
+export declare const liveRunBatchResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodLiteral<"batch">;
+    events: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodAny>>>;
+    cursor: z.ZodString;
+    afterSeq: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodEnum<{
+        error: "error";
+        reset: "reset";
+    }>;
+    status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+    error: z.ZodString;
+}, z.core.$strip>]>;
+export type LiveRunBatchResult = z.infer<typeof liveRunBatchResultSchema>;
+export declare const liveRunBatchResponseSchema: z.ZodObject<{
+    generation: z.ZodString;
+    results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        type: z.ZodLiteral<"batch">;
+        events: z.ZodArray<z.ZodObject<{
+            seq: z.ZodNumber;
+            ts: z.ZodString;
+            stepId: z.ZodOptional<z.ZodString>;
+            type: z.ZodString;
+        }, z.core.$catchall<z.ZodAny>>>;
+        cursor: z.ZodString;
+        afterSeq: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        projectId: z.ZodString;
+        runId: z.ZodString;
+        type: z.ZodEnum<{
+            error: "error";
+            reset: "reset";
+        }>;
+        status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+        error: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export type LiveRunBatchResponse = z.infer<typeof liveRunBatchResponseSchema>;
+export declare const liveRunFrameSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"ready">;
+    generation: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strip>, z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodLiteral<"event">;
+    name: z.ZodEnum<{
+        "run-event": "run-event";
+        "ui-event": "ui-event";
+    }>;
+    event: z.ZodObject<{
+        seq: z.ZodNumber;
+        ts: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+    }, z.core.$catchall<z.ZodAny>>;
+}, z.core.$strip>, z.ZodObject<{
+    projectId: z.ZodString;
+    runId: z.ZodString;
+    type: z.ZodEnum<{
+        error: "error";
+        reset: "reset";
+    }>;
+    status: z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<404>, z.ZodLiteral<409>, z.ZodLiteral<413>, z.ZodLiteral<503>]>;
+    error: z.ZodString;
+}, z.core.$strip>]>;
+export type LiveRunFrame = z.infer<typeof liveRunFrameSchema>;

package/dist/contract/pending-ask.d.ts

@@ -0,0 +1,58 @@
+import { type AskQuestion, type AskRequest } from './ask-schema.ts';
+import type { RunEvent } from './events.ts';
+/** What an ask says: its questions and, since hearsay-tools/cezarion#1458, the Markdown above them. */
+export interface AskContent {
+    questions: unknown;
+    context?: unknown;
+}
+/** The payload of one `ask.requested` event. */
+export interface AskPayload extends AskContent {
+    requestId: string;
+}
+/** An ask and the `seq` of the event that holds it, which every receipt for it names as `askSeq`. */
+export interface PendingAsk extends AskPayload {
+    seq: number;
+}
+/**
+ * The payload of an `ask.requested` event, or undefined for any other event or one with no string
+ * `requestId`. The questions are not validated: the card renders an ask the questions schema
+ * rejects, and the live runner event has no `seq`.
+ */
+export declare function askPayloadOf(event: {
+    type: string;
+    requestId?: unknown;
+    questions?: unknown;
+    context?: unknown;
+}): AskPayload | undefined;
+/** The ask a stored `ask.requested` event holds. Not necessarily pending: see `pendingAskOf`. */
+export declare function askOf(event: RunEvent): PendingAsk | undefined;
+/**
+ * One step of the fold `pendingAskOf` runs, for a reader that folds a transcript as it grows:
+ * the next pending ask after `event`. Same ask in, same object out; a newer valid ask replaces it,
+ * and a delivery or Finish that names it retires it (`advancePendingHumanAsk` holds that rule).
+ */
+export declare function advancePendingAsk<T extends Pick<PendingAsk, 'seq'>>(pending: T | undefined, event: RunEvent): T | PendingAsk | undefined;
+/** The ask a run waits on in `events`, in order, or undefined. */
+export declare function pendingAskOf(events: Iterable<RunEvent>): PendingAsk | undefined;
+/** The ask as a validated `AskRequest`, which a worker's parent receives. Undefined when it fails the schema. */
+export declare function askRequestOf(ask: AskContent): AskRequest | undefined;
+/** What `cez task status` and the task webhook print: the questions as `question`, the context as `questionContext`. */
+export declare function askStatusFields(ask: AskContent | undefined): {
+    question?: unknown;
+    questionContext?: unknown;
+};
+/** The cockpit card's model of an ask. */
+export interface AskCardFields {
+    id: string;
+    questions: AskQuestion[];
+    /** Absent when the ask has none, or an empty one. */
+    context?: string;
+    askSeq: number;
+}
+/**
+ * The card for an ask, or undefined when it has no question the card can show. The card is more
+ * lenient than the pending rule: it keeps a question that has a string `header` and no options
+ * or a list of them, so an ask the questions schema now rejects still shows; a question without
+ * options is an open one (hearsay-tools/cezarion#1234).
+ */
+export declare function askCardOf(ask: PendingAsk): AskCardFields | undefined;

package/dist/contract/permissions.d.ts

@@ -0,0 +1,54 @@
+/** Human permission decisions carry opaque IDs; only the runner owns native grants. */
+import { z } from 'zod';
+export declare const permissionOptionKindSchema: z.ZodEnum<{
+    allow_always: "allow_always";
+    allow_once: "allow_once";
+    reject_always: "reject_always";
+    reject_once: "reject_once";
+}>;
+export type PermissionOptionKind = z.infer<typeof permissionOptionKindSchema>;
+export declare const permissionOptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+        allow_always: "allow_always";
+        allow_once: "allow_once";
+        reject_always: "reject_always";
+        reject_once: "reject_once";
+    }>;
+}, z.core.$strict>;
+export type PermissionOption = z.infer<typeof permissionOptionSchema>;
+export declare const permissionRequestedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"permission.requested">;
+    requestId: z.ZodString;
+    itemId: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    details: z.ZodOptional<z.ZodString>;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            allow_always: "allow_always";
+            allow_once: "allow_once";
+            reject_always: "reject_always";
+            reject_once: "reject_once";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PermissionRequest = z.infer<typeof permissionRequestedSchema>;
+export declare const permissionResolvedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"permission.resolved">;
+    requestId: z.ZodString;
+    optionId: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PermissionResolution = z.infer<typeof permissionResolvedSchema>;
+export declare const permissionDecisionSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    optionId: z.ZodString;
+}, z.core.$strict>;
+export type PermissionDecision = z.infer<typeof permissionDecisionSchema>;
+export declare const permissionDecisionResponseSchema: z.ZodObject<{
+    delivered: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type PermissionDecisionResponse = z.infer<typeof permissionDecisionResponseSchema>;

package/dist/contract/preview.d.ts

@@ -99,6 +99,19 @@ export declare const previewServerStateSchema: z.ZodEnum<{
     up: "up";
 }>;
 export type PreviewServerState = z.infer<typeof previewServerStateSchema>;
+/**
+ * The `preview.agent-browser` run event (hearsay-tools/cezarion#784): appended when the first agent
+ * CDP connection to the task's browser opens and when the last one closes. The pane lists the
+ * agent's page beside the registered servers while the latest one says `connected`.
+ */
+export declare const previewAgentBrowserEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"preview.agent-browser">;
+    state: z.ZodEnum<{
+        connected: "connected";
+        disconnected: "disconnected";
+    }>;
+}, z.core.$strip>;
+export type PreviewAgentBrowserEvent = z.infer<typeof previewAgentBrowserEventSchema>;
 /** Mouse and key vocabularies are the prototype's: CDP's own names, nothing else gets through. */
 export declare const previewMouseTypeSchema: z.ZodEnum<{
     mouseMoved: "mouseMoved";
@@ -120,10 +133,14 @@ export declare const previewKeyTypeSchema: z.ZodEnum<{
 /** Client to server. A whitelist: a message outside it is dropped and logged once per connection. */
 export declare const previewClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     t: z.ZodLiteral<"open">;
+    viewerId: z.ZodOptional<z.ZodString>;
+    resume: z.ZodOptional<z.ZodBoolean>;
     target: z.ZodUnion<readonly [z.ZodObject<{
         port: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
         url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        agent: z.ZodLiteral<true>;
     }, z.core.$strip>]>;
 }, z.core.$strip>, z.ZodObject<{
     t: z.ZodLiteral<"run">;
@@ -228,7 +245,12 @@ export declare const previewStateMessageSchema: z.ZodDiscriminatedUnion<[z.ZodOb
 }, z.core.$strip>, z.ZodObject<{
     t: z.ZodLiteral<"state">;
     stage: z.ZodLiteral<"browser-exited">;
+    reason: z.ZodOptional<z.ZodEnum<{
+        exited: "exited";
+        timeout: "timeout";
+    }>>;
     signal: z.ZodOptional<z.ZodString>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
     stderrTail: z.ZodString;
     serverUp: z.ZodBoolean;
 }, z.core.$strip>, z.ZodObject<{
@@ -340,6 +362,9 @@ export declare const previewStateMessageSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     t: z.ZodLiteral<"state">;
     stage: z.ZodLiteral<"streaming">;
     adopted: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"state">;
+    stage: z.ZodLiteral<"agent-idle">;
 }, z.core.$strip>], "stage">;
 /** Server to client JSON messages. JPEG frames travel as binary and have no schema here. */
 export declare const previewServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -364,7 +389,12 @@ export declare const previewServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodD
 }, z.core.$strip>, z.ZodObject<{
     t: z.ZodLiteral<"state">;
     stage: z.ZodLiteral<"browser-exited">;
+    reason: z.ZodOptional<z.ZodEnum<{
+        exited: "exited";
+        timeout: "timeout";
+    }>>;
     signal: z.ZodOptional<z.ZodString>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
     stderrTail: z.ZodString;
     serverUp: z.ZodBoolean;
 }, z.core.$strip>, z.ZodObject<{
@@ -476,6 +506,9 @@ export declare const previewServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodD
     t: z.ZodLiteral<"state">;
     stage: z.ZodLiteral<"streaming">;
     adopted: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"state">;
+    stage: z.ZodLiteral<"agent-idle">;
 }, z.core.$strip>], "stage">, z.ZodObject<{
     t: z.ZodLiteral<"url">;
     url: z.ZodString;

package/dist/contract/project-limits.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bounds a project's name, tags and webhook, shared by its schemas, the registry and the cockpit.
+ *
+ * No runtime import, so a consumer of these loads no schema (hearsay-tools/cezarion#1237).
+ */
+/** Bounds for one tag and for a project's tag list. Named because three places must agree: the
+ *  PATCH body's schema, the registry schema that must never `.catch` away a value this accepts
+ *  (`workspaceProjectSchema` in the service), and the settings editor that refuses input early. */
+export declare const PROJECT_TAG_MAX_LENGTH = 32;
+export declare const PROJECT_TAGS_MAX = 20;
+/** Bounds shared by the PATCH body and the registry schema, so a stored value can never be
+ *  degraded away by the next load's `.catch`. */
+export declare const PROJECT_WEBHOOK_URL_MAX_LENGTH = 2048;
+export declare const PROJECT_WEBHOOK_TOKEN_MAX_LENGTH = 1024;
+/**
+ * A new project's name: GitHub's repository-name characters (letters, digits, `.`, `-`, `_`, at
+ * most 100), starting with a letter or digit as every checkout folder must. It is the folder name
+ * and, with `github`, the repository name, so a name GitHub would rewrite is refused — and the
+ * schema, the server and the dialog share this ONE rule, so the middleware never passes a name the
+ * handler then rejects.
+ */
+export declare const PROJECT_NAME_PATTERN: RegExp;
+/** Bounds for the project webhook list (hearsay-tools/cezarion#1576): the create and edit bodies,
+ *  the registry schema and the settings form share them. */
+export declare const PROJECT_WEBHOOKS_MAX = 16;
+export declare const PROJECT_WEBHOOK_NAME_MAX_LENGTH = 80;
+export declare const PROJECT_WEBHOOK_DESCRIPTION_MAX_LENGTH = 1000;
+/** A webhook's stable id: generated on create, never edited. `task-webhook` names the entry read
+ *  from the single `webhook` key a project stored before #1576. */
+export declare const PROJECT_WEBHOOK_ID_PATTERN: RegExp;
+/** Bounds of one agent report (hearsay-tools/cezarion#1576). */
+export declare const AGENT_REPORT_TITLE_MAX_LENGTH = 200;
+export declare const AGENT_REPORT_MESSAGE_MAX_LENGTH: number;