@anchrd/colab-sdk 0.0.0-stage → 0.1.1

package/dist/roles/roles.d.ts

@@ -0,0 +1,135 @@
+import { z } from "zod";
+export declare const RoleId: z.ZodTemplateLiteral<`role_${string}`>;
+export declare const RightPath: z.ZodString;
+export declare const RoleListInput: z.ZodObject<{
+    archived: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
+    cursor: z.ZodOptional<z.ZodTemplateLiteral<`role_${string}`>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type RoleListInput = z.infer<typeof RoleListInput>;
+export declare const RoleGetInput: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+}, z.core.$strict>;
+export type RoleGetInput = z.infer<typeof RoleGetInput>;
+export declare const RoleCreateInput: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RoleCreateInput = z.infer<typeof RoleCreateInput>;
+export declare const RoleUpdateInput: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RoleUpdateInput = z.infer<typeof RoleUpdateInput>;
+export declare const RoleArchiveInput: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+}, z.core.$strict>;
+export type RoleArchiveInput = z.infer<typeof RoleArchiveInput>;
+export declare const RoleRestoreInput: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+}, z.core.$strict>;
+export type RoleRestoreInput = z.infer<typeof RoleRestoreInput>;
+export declare const RoleGrantCreateInput: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+    permission: z.ZodString;
+}, z.core.$strict>;
+export type RoleGrantCreateInput = z.infer<typeof RoleGrantCreateInput>;
+export declare const RoleGrantRevokeInput: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+    permission: z.ZodString;
+}, z.core.$strict>;
+export type RoleGrantRevokeInput = z.infer<typeof RoleGrantRevokeInput>;
+export declare const Role: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+    name: z.ZodString;
+    description: z.ZodString;
+    fixed: z.ZodBoolean;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type Role = z.infer<typeof Role>;
+export declare const RoleList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        roleId: z.ZodTemplateLiteral<`role_${string}`>;
+        name: z.ZodString;
+        description: z.ZodString;
+        fixed: z.ZodBoolean;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`role_${string}`>>;
+}, z.core.$strict>;
+export type RoleList = z.infer<typeof RoleList>;
+export declare const RightInCode: z.ZodEnum<{
+    fixed: "fixed";
+    automatic: "automatic";
+}>;
+export type RightInCode = z.infer<typeof RightInCode>;
+export declare const RightTree: z.ZodArray<z.ZodObject<{
+    resources: z.ZodArray<z.ZodObject<{
+        actions: z.ZodArray<z.ZodObject<{
+            action: z.ZodString;
+            permission: z.ZodString;
+            on: z.ZodBoolean;
+            orphaned: z.ZodOptional<z.ZodLiteral<true>>;
+            inCode: z.ZodOptional<z.ZodEnum<{
+                fixed: "fixed";
+                automatic: "automatic";
+            }>>;
+        }, z.core.$strict>>;
+        on: z.ZodBoolean;
+        granted: z.ZodNumber;
+        total: z.ZodNumber;
+        resource: z.ZodString;
+    }, z.core.$strict>>;
+    on: z.ZodBoolean;
+    granted: z.ZodNumber;
+    total: z.ZodNumber;
+    package: z.ZodString;
+}, z.core.$strict>>;
+export type RightTree = z.infer<typeof RightTree>;
+export declare const RoleDetail: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+    name: z.ZodString;
+    description: z.ZodString;
+    fixed: z.ZodBoolean;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    rights: z.ZodArray<z.ZodObject<{
+        resources: z.ZodArray<z.ZodObject<{
+            actions: z.ZodArray<z.ZodObject<{
+                action: z.ZodString;
+                permission: z.ZodString;
+                on: z.ZodBoolean;
+                orphaned: z.ZodOptional<z.ZodLiteral<true>>;
+                inCode: z.ZodOptional<z.ZodEnum<{
+                    fixed: "fixed";
+                    automatic: "automatic";
+                }>>;
+            }, z.core.$strict>>;
+            on: z.ZodBoolean;
+            granted: z.ZodNumber;
+            total: z.ZodNumber;
+            resource: z.ZodString;
+        }, z.core.$strict>>;
+        on: z.ZodBoolean;
+        granted: z.ZodNumber;
+        total: z.ZodNumber;
+        package: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RoleDetail = z.infer<typeof RoleDetail>;
+export declare const GrantChange: z.ZodObject<{
+    roleId: z.ZodTemplateLiteral<`role_${string}`>;
+    permissions: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type GrantChange = z.infer<typeof GrantChange>;
+export declare const PermissionsResponse: z.ZodObject<{
+    permissions: z.ZodArray<z.ZodString>;
+    admin: z.ZodBoolean;
+}, z.core.$strict>;
+export type PermissionsResponse = z.infer<typeof PermissionsResponse>;

package/dist/roles/roles.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Flag, Limit } from "../list-input.js";
+// Roles and their rights (Einstellungen › Rollen, #24): the inputs of the `access_role_*` tools and
+// their routes, and the answers the UI reads. A right is `package / resource / action`, every word one
+// word (E64).
+export const RoleId = idSchema("role");
+// A right (`access / role / list`) or the prefix of a level (`intelligence / document`, `connectors`).
+// The spaces around `/` are optional; `access` stores the form with them. The last word may be a
+// connector's function, `connectors / shopify / order-list` (#5): resource and action joined by a
+// dash, because the connector id stands where the resource stands elsewhere.
+export const RightPath = z
+    .string()
+    .regex(/^[a-z][a-z0-9]*(\s*\/\s*[a-z][a-z0-9]*(\s*\/\s*[a-z][a-z0-9]*(-[a-z][a-z0-9]*)*)?)?$/, "A right is package / resource / action");
+const RoleName = z.string().trim().min(1).max(64);
+const RoleDescription = z.string().trim().max(500);
+export const RoleListInput = z.strictObject({
+    // The archive instead of the roles in use.
+    archived: Flag.optional(),
+    cursor: RoleId.optional(),
+    limit: Limit.optional(),
+});
+export const RoleGetInput = z.strictObject({ roleId: RoleId });
+export const RoleCreateInput = z.strictObject({
+    name: RoleName,
+    description: RoleDescription.optional(),
+});
+export const RoleUpdateInput = z
+    .strictObject({
+    roleId: RoleId,
+    name: RoleName.optional(),
+    description: RoleDescription.optional(),
+})
+    .refine((input) => input.name !== undefined || input.description !== undefined, {
+    message: "Name a field to change: name or description.",
+});
+export const RoleArchiveInput = z.strictObject({ roleId: RoleId });
+export const RoleRestoreInput = z.strictObject({ roleId: RoleId });
+// Switches a right, or every right under a level, on. ⚠️ The right travels in the body of a `POST`,
+// never in the body of a `DELETE` (trap P296).
+export const RoleGrantCreateInput = z.strictObject({ roleId: RoleId, permission: RightPath });
+export const RoleGrantRevokeInput = z.strictObject({ roleId: RoleId, permission: RightPath });
+export const Role = z.strictObject({
+    roleId: RoleId,
+    name: z.string(),
+    description: z.string(),
+    // `admin`, `mitglied` and `validator`: no rename, no archive; `admin` has no switches, and
+    // `validator` keeps its rights in code switched on (E9, E80). Operator is a normal role.
+    fixed: z.boolean(),
+    archivedAt: z.iso.datetime().nullable(),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+});
+export const RoleList = z.strictObject({ items: z.array(Role), nextCursor: RoleId.nullable() });
+// One switch per level: on as soon as one right below is on, with the count for "2 / 3".
+const Level = { on: z.boolean(), granted: z.number().int(), total: z.number().int() };
+// A right the fixed role `validator` holds in code (#367, E80): `fixed` for the reads of nodes and the
+// validation's writes, `automatic` for the reads of every connector and outside service. Locked on in
+// the tree; switching it off answers `conflict`. Set only on the tree of `validator`.
+export const RightInCode = z.enum(["fixed", "automatic"]);
+export const RightTree = z.array(z.strictObject({
+    package: z.string(),
+    ...Level,
+    resources: z.array(z.strictObject({
+        resource: z.string(),
+        ...Level,
+        actions: z.array(z.strictObject({
+            action: z.string(),
+            permission: z.string(),
+            on: z.boolean(),
+            // A stored grant whose right no tool carries any more, for instance of a connector taken
+            // out of `colab.config.ts` (#5). It stays on the role until an admin removes it.
+            orphaned: z.literal(true).optional(),
+            inCode: RightInCode.optional(),
+        })),
+    })),
+}));
+export const RoleDetail = Role.extend({ rights: RightTree });
+// The answer of a grant or a revoke: the rights that were really switched (trap P334). Empty when
+// nothing changed, which is no error.
+export const GrantChange = z.strictObject({ roleId: RoleId, permissions: z.array(z.string()) });
+// `GET /auth/permissions`: the caller's own rights as they act right now (masked without admin mode,
+// E71), and whether they hold `admin` at all, so the UI can draw the switch (#68).
+export const PermissionsResponse = z.strictObject({
+    permissions: z.array(z.string()),
+    admin: z.boolean(),
+});

package/dist/runs/runs.d.ts

@@ -0,0 +1,244 @@
+import { z } from "zod";
+export declare const RunId: z.ZodTemplateLiteral<`run_${string}`>;
+export type RunId = z.infer<typeof RunId>;
+export declare const runStatuses: readonly ["running", "done", "open", "error"];
+export declare const RunStatus: z.ZodEnum<{
+    error: "error";
+    open: "open";
+    done: "done";
+    running: "running";
+}>;
+export type RunStatus = z.infer<typeof RunStatus>;
+export declare const RunListInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        open: "open";
+        done: "done";
+        running: "running";
+    }>>;
+    from: z.ZodOptional<z.ZodISODateTime>;
+    to: z.ZodOptional<z.ZodISODateTime>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type RunListInput = z.infer<typeof RunListInput>;
+export declare const RunGetInput: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+}, z.core.$strict>;
+export type RunGetInput = z.infer<typeof RunGetInput>;
+export declare const BoardRunCreateInput: z.ZodObject<{
+    boardId: z.ZodTemplateLiteral<`node_${string}`>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type BoardRunCreateInput = z.infer<typeof BoardRunCreateInput>;
+export declare const DashboardRunCreateInput: z.ZodObject<{
+    dashboardId: z.ZodTemplateLiteral<`node_${string}`>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type DashboardRunCreateInput = z.infer<typeof DashboardRunCreateInput>;
+export declare const RunUpdateInput: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+    values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    yaml: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RunUpdateInput = z.infer<typeof RunUpdateInput>;
+export declare const RunCompleteInput: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+    summary: z.ZodOptional<z.ZodString>;
+    values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    yaml: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RunCompleteInput = z.infer<typeof RunCompleteInput>;
+export declare const RunValueValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodNull]>;
+export type RunValueValue = z.infer<typeof RunValueValue>;
+export declare const RunValue: z.ZodObject<{
+    metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodNull]>;
+        source: z.ZodNullable<z.ZodString>;
+        node: z.ZodNullable<z.ZodObject<{
+            nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        parameter: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        report: z.ZodNullable<z.ZodString>;
+        recommendation: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    summaries: z.ZodRecord<z.ZodString, z.ZodObject<{
+        text: z.ZodNullable<z.ZodString>;
+        report: z.ZodNullable<z.ZodString>;
+        recommendation: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RunValue = z.infer<typeof RunValue>;
+export declare const RunItem: z.ZodObject<{
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    kind: z.ZodEnum<{
+        dashboard: "dashboard";
+        validation: "validation";
+        process: "process";
+    }>;
+    status: z.ZodEnum<{
+        error: "error";
+        open: "open";
+        done: "done";
+        running: "running";
+    }>;
+    dueAt: z.ZodNullable<z.ZodISODateTime>;
+    startedAt: z.ZodISODateTime;
+    startedBy: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>;
+    completedAt: z.ZodNullable<z.ZodISODateTime>;
+    completedBy: z.ZodNullable<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>>;
+    summary: z.ZodNullable<z.ZodString>;
+    values: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodNull]>>>;
+    summaries: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+    reports: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type RunItem = z.infer<typeof RunItem>;
+export declare const RunList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        runId: z.ZodTemplateLiteral<`run_${string}`>;
+        nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+        kind: z.ZodEnum<{
+            dashboard: "dashboard";
+            validation: "validation";
+            process: "process";
+        }>;
+        status: z.ZodEnum<{
+            error: "error";
+            open: "open";
+            done: "done";
+            running: "running";
+        }>;
+        dueAt: z.ZodNullable<z.ZodISODateTime>;
+        startedAt: z.ZodISODateTime;
+        startedBy: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strict>;
+        completedAt: z.ZodNullable<z.ZodISODateTime>;
+        completedBy: z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strict>>;
+        summary: z.ZodNullable<z.ZodString>;
+        values: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodNull]>>>;
+        summaries: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+        reports: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type RunList = z.infer<typeof RunList>;
+export declare const RunDetail: z.ZodObject<{
+    counts: z.ZodNullable<z.ZodRecord<z.ZodEnum<{
+        backlog: "backlog";
+        open: "open";
+        progress: "progress";
+        done: "done";
+        discarded: "discarded";
+        blocked: "blocked";
+        archive: "archive";
+    }> & z.core.$partial, z.ZodNumber>>;
+    columns: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        columnId: z.ZodTemplateLiteral<`column_${string}`>;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            backlog: "backlog";
+            open: "open";
+            progress: "progress";
+            done: "done";
+            discarded: "discarded";
+            blocked: "blocked";
+            archive: "archive";
+        }>;
+        tasks: z.ZodNumber;
+    }, z.core.$strict>>>;
+    entries: z.ZodNullable<z.ZodObject<{
+        metrics: z.ZodRecord<z.ZodString, z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodNull]>;
+            source: z.ZodNullable<z.ZodString>;
+            node: z.ZodNullable<z.ZodObject<{
+                nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+                name: z.ZodString;
+            }, z.core.$strict>>;
+            parameter: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            report: z.ZodNullable<z.ZodString>;
+            recommendation: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        summaries: z.ZodRecord<z.ZodString, z.ZodObject<{
+            text: z.ZodNullable<z.ZodString>;
+            report: z.ZodNullable<z.ZodString>;
+            recommendation: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    assignees: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>>>>;
+    template: z.ZodNullable<z.ZodString>;
+    instruction: z.ZodNullable<z.ZodString>;
+    runId: z.ZodTemplateLiteral<`run_${string}`>;
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    kind: z.ZodEnum<{
+        dashboard: "dashboard";
+        validation: "validation";
+        process: "process";
+    }>;
+    status: z.ZodEnum<{
+        error: "error";
+        open: "open";
+        done: "done";
+        running: "running";
+    }>;
+    dueAt: z.ZodNullable<z.ZodISODateTime>;
+    startedAt: z.ZodISODateTime;
+    startedBy: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>;
+    completedAt: z.ZodNullable<z.ZodISODateTime>;
+    completedBy: z.ZodNullable<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>>;
+    summary: z.ZodNullable<z.ZodString>;
+    values: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodNull]>>>;
+    summaries: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+    reports: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type RunDetail = z.infer<typeof RunDetail>;

package/dist/runs/runs.js

@@ -0,0 +1,137 @@
+import { z } from "zod";
+import { BoardId } from "../boards/boards.js";
+import { ColumnId, ColumnType } from "../columns/columns.js";
+import { DashboardId } from "../dashboards/dashboards.js";
+import { idSchema } from "../ids/ids.js";
+import { Limit } from "../list-input.js";
+import { NodeId, NodePerson } from "../nodes/nodes.js";
+import { IdempotencyKey } from "../primitives/primitives.js";
+// Runs of a process board and of a dashboard (#43, Funktionen › Läufe, Nodes › Board › Prozess,
+// Nodes › Dashboard, E42, E45, E67, E70): the inputs of `intelligence_run_list`, `_get`,
+// `intelligence_board_run_create`, `intelligence_dashboard_run_create`, `intelligence_run_complete`,
+// and the answers. A run is a sub-resource of its board or dashboard when it is made, and a resource
+// of its own afterwards.
+export const RunId = idSchema("run").describe("The run's id, `run_…`, as intelligence_board_run_create, intelligence_dashboard_run_create or intelligence_run_list returned it.");
+export const runStatuses = ["running", "done", "open", "error"];
+export const RunStatus = z
+    .enum(runStatuses)
+    .describe("The run's status, set by Colab from its result, never by the caller: running (started, not completed), done (a process: every task in a done, discarded or archive column; a dashboard: every value and summary there, no report; the validation: no ticket in a column of type open waits on a person), open (a process: a task not in such a column; a dashboard: at least one report; the validation: a ticket in a column of type open is assigned to a person), error (a process: a task in a blocked column; a dashboard and the validation never err, an invalid run is not taken).");
+const Moment = z.iso.datetime({ offset: true });
+export const RunListInput = z.strictObject({
+    nodeId: NodeId.describe("The process board or dashboard whose runs to list, one you can read. Runs never stand in the tree."),
+    status: RunStatus.optional().describe("Only the runs with this status."),
+    from: Moment.optional().describe("Only the runs started at or after this moment, ISO 8601."),
+    to: Moment.optional().describe("Only the runs started at or before this moment, ISO 8601."),
+    cursor: z
+        .string()
+        .max(1000)
+        .optional()
+        .describe("The nextCursor of the previous page, unchanged. Leaving it out starts at the newest."),
+    limit: Limit.optional().describe("How many runs one page holds, 1 to 100. Leaving it out gives 50."),
+});
+export const RunGetInput = z.strictObject({ runId: RunId });
+export const BoardRunCreateInput = z.strictObject({
+    boardId: BoardId.describe("The process board to start a run of, one you can write to. The run is a copy of its columns and of every task of the template, all in the first column."),
+    idempotencyKey: IdempotencyKey,
+});
+export const DashboardRunCreateInput = z.strictObject({
+    dashboardId: DashboardId.describe("The dashboard to start a run of, one you can write to. The run keeps a copy of the configuration as it is now and answers its template."),
+    idempotencyKey: IdempotencyKey,
+});
+const Text = z.string().max(20_000);
+const RunValues = z
+    .record(z.string(), z.unknown())
+    .optional()
+    .describe("A dashboard run's entries as an object, the shape of the template of intelligence_run_get: metrics (value, source, parameter, report, recommendation) and summaries (text, report, recommendation), each under its key. Send at most one of values and yaml.");
+const RunYaml = z
+    .string()
+    .max(200_000)
+    .optional()
+    .describe("A dashboard run's entries as YAML text, the template of intelligence_run_get filled in. Send at most one of values and yaml.");
+// A dashboard run is filled by its assignees, each their own entries (E78, Nodes › Dashboard,
+// Zuständig je Kennzahl): the run closes by itself once every entry is there.
+export const RunUpdateInput = z.strictObject({
+    runId: RunId,
+    values: RunValues.describe("Your entries of a dashboard run as an object: metrics and summaries assigned to you (and those without anybody, where you can write on the dashboard), each under its key with value and source, or text, and a report and a recommendation where something is worth saying. Send exactly one of values and yaml."),
+    yaml: RunYaml.describe("Your entries of a dashboard run as YAML text, the template of intelligence_run_get filled in. Send exactly one of values and yaml."),
+});
+export const RunCompleteInput = z.strictObject({
+    runId: RunId,
+    summary: Text.optional().describe("What the run did, in a few sentences: what people read in the list of runs."),
+    values: RunValues.describe("Only for a dashboard: the last entries you may write, as an object, before it closes. Entries nobody wrote stay missing and the run is open. Send at most one of values and yaml, neither for a process."),
+    yaml: RunYaml.describe("Only for a dashboard: the last entries you may write, as YAML text, before it closes. Send at most one of values and yaml, neither for a process."),
+});
+// A value as a run stores it: a number, a short text, or null when it is missing.
+export const RunValueValue = z.union([z.number(), z.string(), z.null()]);
+// ⚠️ The entries of a dashboard run as records under their key, the shape the Operator sent
+// (`DashboardRun`), never as a list with a field `key`: `/mcp` strikes every field called `key` as a
+// secret (`redactSecrets` in `shared`), and the answer would name no metric.
+export const RunValue = z.strictObject({
+    metrics: z.record(z.string(), z.strictObject({
+        value: RunValueValue,
+        source: z.string().nullable(),
+        // The node a source `colab://node_…` names, when the caller can read it; null for a tool,
+        // and for a node that is gone or the caller cannot read: then neither its id nor its name,
+        // and `source` is null too (#165).
+        node: z.strictObject({ nodeId: NodeId, name: z.string() }).nullable(),
+        parameter: z.record(z.string(), z.unknown()).nullable(),
+        report: z.string().nullable(),
+        recommendation: z.string().nullable(),
+    })),
+    summaries: z.record(z.string(), z.strictObject({
+        text: z.string().nullable(),
+        report: z.string().nullable(),
+        recommendation: z.string().nullable(),
+    })),
+});
+export const RunItem = z.strictObject({
+    runId: RunId,
+    nodeId: NodeId,
+    // A validation run (#47) copies nothing and carries only its summary.
+    kind: z.enum(["process", "dashboard", "validation"]),
+    status: RunStatus,
+    // The moment of the schedule this run stands for, null for a run started by hand.
+    dueAt: z.iso.datetime().nullable(),
+    startedAt: z.iso.datetime(),
+    startedBy: NodePerson,
+    completedAt: z.iso.datetime().nullable(),
+    completedBy: NodePerson.nullable(),
+    summary: z.string().nullable(),
+    // A dashboard's value per metric key, one row of its table; null for a process.
+    values: z.record(z.string(), RunValueValue).nullable(),
+    // A dashboard's summary text per summary key, cut to 280 characters for a cell of its table, null
+    // where the Operator wrote none; null for a process. The whole text is in `entries` of
+    // intelligence_run_get (#164).
+    summaries: z.record(z.string(), z.string().nullable()).nullable(),
+    // A dashboard's count of values and summaries that carry a report; null for a process (#164).
+    reports: z.number().int().nullable(),
+});
+export const RunList = z.strictObject({
+    items: z.array(RunItem),
+    nextCursor: z.string().nullable(),
+});
+export const RunDetail = z.strictObject({
+    ...RunItem.shape,
+    // A process run: how many of its tasks stand in a column of each type.
+    counts: z.partialRecord(ColumnType, z.number().int()).nullable(),
+    // A process run: its own columns, copied when it started, each with how many tasks it holds. A
+    // task of the run moves only between these.
+    columns: z
+        .array(z.strictObject({
+        columnId: ColumnId,
+        name: z.string(),
+        type: ColumnType,
+        tasks: z.number().int(),
+    }))
+        .nullable(),
+    // A dashboard run: every value and summary with where it came from, in the configuration's order.
+    entries: RunValue.nullable(),
+    // A dashboard run: who delivers each metric and summary, by key, as the configuration said when
+    // the run started (E78); null where nobody does. Null for a process.
+    assignees: z.record(z.string(), NodePerson.nullable()).nullable(),
+    // A dashboard run while it runs: the YAML of the entries the caller may write and has not written
+    // yet, to fill in and send to intelligence_run_update; null when there is none.
+    template: z.string().nullable(),
+    // The instruction of the board or dashboard as the run started (E87, #354); null without one.
+    instruction: z.string().nullable(),
+});

package/dist/runtime-config.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const RuntimeConfig: z.ZodObject<{
+    dsn: z.ZodString;
+    installation: z.ZodString;
+    release: z.ZodString;
+    name: z.ZodString;
+    language: z.ZodEnum<{
+        en: "en";
+        de: "de";
+    }>;
+}, z.core.$strict>;
+export type RuntimeConfig = z.infer<typeof RuntimeConfig>;

package/dist/runtime-config.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+// What the UI learns from the Worker at `GET /config.json` before it renders (#19). One build serves
+// every installation, so nothing installation-specific may be baked into the bundle.
+//
+// ⚠️ Public by construction: the route answers without sign-in. A new key here is readable by anyone
+// who can reach the installation, so only values that are safe to show belong in it.
+export const RuntimeConfig = z.strictObject({
+    // The GlitchTip DSN for the browser; empty means report to the console only (E57).
+    dsn: z.string(),
+    // The `installation` and `release` tags on every error report.
+    installation: z.string(),
+    release: z.string(),
+    // The installation's name for people (`INSTALLATION_NAME`, #79), next to the logo on the sign-in
+    // pages and in the sentences that name the installation (#29). Empty when it is not set.
+    name: z.string(),
+    // The installation's default UI language, used when the browser asks for none Colab speaks.
+    language: z.enum(["en", "de"]),
+});