@kottera/tera-web 0.0.0-stage → 0.1.0-rc.10

package/dist/generated/feed.d.ts

@@ -0,0 +1,199 @@
+/**
+ * feed connect-time parameters.
+ *
+ * The query parameters of a feed URL (`GET /feeds/<name>?…`), each a repeatable query key. The query is a closed vocabulary: an unknown parameter is refused at connect.
+ *
+ * Schema: sdk/feed/schema/v1/connect.params.json
+ */
+export type FeedConnectParams = {
+    /** Precedes the live stream with the stored history of the selected run. */
+    backfill?: "all";
+    /** Overrides the delivery window: a duration such as `2s`, or `0` for no batching. */
+    batch_window?: string;
+    /** Selects a subset of the topics the connection would otherwise receive; each occurrence may be a comma-separated list. */
+    topics?: string[];
+    /** Adds or tightens one predicate, `<field>=<value>[,<value>…]`, once per field. */
+    where?: string[];
+};
+/**
+ * The vocabulary of the feed drop reason (sdk/feed.DropReason).
+ *
+ * Every member the daemon writes. A later level adds members and removes none (ADR-143 D3); how a consumer reads an unknown member is ADR-143 D13's.
+ *
+ * Schema: sdk/feed/schema/v1/drop-reason.json
+ */
+export type FeedDropReason = "slow_consumer" | "rate_limit" | "connection_closed";
+/**
+ * The vocabulary of the feed frame `type` (sdk/feed.FrameType).
+ *
+ * Every member the daemon writes. A later level adds members and removes none (ADR-143 D3); how a consumer reads an unknown member is ADR-143 D13's.
+ *
+ * Schema: sdk/feed/schema/v1/frame-type.json
+ */
+export type FeedFrameType = "record" | "status" | "heartbeat" | "batch";
+/**
+ * `batch` frame (tera.feed.v1).
+ *
+ * A `batch` frame, generated from feed.BatchFrame.
+ *
+ * Schema: sdk/feed/schema/v1/frame.batch.json
+ */
+export type FeedFrameBatch = {
+    /** The frame's type; a consumer skips a frame whose type it does not know (ADR-143 D13). */
+    type: string;
+    /** The feed's name. */
+    feed: string;
+    /** This frame's own place in the connection's sequence; the records inside precede it. */
+    seq: number;
+    /** When the daemon wrote the frame, RFC 3339. */
+    at: string;
+    /** The delivery window in force, in seconds. */
+    window_seconds: number;
+    /** The number of records in the batch. */
+    count: number;
+    /** The window's records, in order; each element is a record frame. */
+    records: unknown[] | null;
+    /** Records dropped during this window. */
+    dropped?: number;
+    /** The connection's running total of dropped records. */
+    dropped_total?: number;
+    /** Why records were dropped; a member of the drop-reason vocabulary. */
+    drop_reason?: string;
+};
+/**
+ * `heartbeat` frame (tera.feed.v1).
+ *
+ * A `heartbeat` frame, generated from feed.HeartbeatFrame.
+ *
+ * Schema: sdk/feed/schema/v1/frame.heartbeat.json
+ */
+export type FeedFrameHeartbeat = {
+    /** The frame's type; a consumer skips a frame whose type it does not know (ADR-143 D13). */
+    type: string;
+    /** The feed's name. */
+    feed: string;
+    /** This frame's place in the connection's single sequence, which has no gaps. */
+    seq: number;
+    /** When the daemon wrote the frame, RFC 3339. */
+    at: string;
+    /** How long the connection has been idle, in seconds. */
+    idle_seconds: number;
+    /** The connection's running total of dropped records. */
+    dropped_total?: number;
+};
+/**
+ * `record` frame (tera.feed.v1).
+ *
+ * A `record` frame, generated from feed.RecordFrame.
+ *
+ * Schema: sdk/feed/schema/v1/frame.record.json
+ */
+export type FeedFrameRecord = {
+    /** The frame's type; a consumer skips a frame whose type it does not know (ADR-143 D13). */
+    type: string;
+    /** The feed's name. */
+    feed: string;
+    /** This record's place in the connection's single sequence, which has no gaps. */
+    seq: number;
+    /** The broker topic the record was published on. */
+    topic: string;
+    /** When the daemon observed the record, RFC 3339. */
+    observed_at: string;
+    /** The publishing principal, when one is known (ADR-083 D11). */
+    publisher?: string;
+    /** Whether the publisher was verified rather than claimed (ADR-011 Amendment 1); always present. */
+    publisher_verified: boolean;
+    /** The content type the publishing adapter declared: raw, json, text, protobuf, jsonrpc, formdata, or unknown/<n>. A label, not the arbiter of which payload key is set. */
+    content_type: string;
+    /** The record's payload as JSON, when its content type is JSON; its shape is the publishing family's. */
+    payload?: unknown;
+    /** The record's payload, when it is valid UTF-8 that is not JSON. */
+    payload_text?: string;
+    /** The record's payload, base64-encoded, when it is neither JSON nor UTF-8 text. */
+    payload_base64?: string;
+};
+/**
+ * `status` frame (tera.feed.v1).
+ *
+ * A `status` frame, generated from feed.StatusFrame.
+ *
+ * Schema: sdk/feed/schema/v1/frame.status.json
+ */
+export type FeedFrameStatus = {
+    /** The frame's type; a consumer skips a frame whose type it does not know (ADR-143 D13). */
+    type: string;
+    /** The status value; a consumer reads one it does not know as possible loss and reconciles (ADR-143 D13). */
+    status: string;
+    /** The feed's name. */
+    feed: string;
+    /** This frame's place in the connection's single sequence, which has no gaps. */
+    seq: number;
+    /** When the daemon wrote the frame, RFC 3339. */
+    at: string;
+    /** A human-readable explanation. Never the machine-readable answer: that is status. */
+    message?: string;
+    /** Accompanies open and partial_authorization. On open, the effective filter set this connection delivers, after any connect-time narrowing. */
+    filters?: string[];
+    /** Accompanies open and partial_authorization: the feed's filters the principal is not granted. */
+    denied?: string[];
+    /** On narrowed, the authorized filter set the connection was narrowed from. */
+    narrowed_from?: string[];
+    /** On narrowed, the effective predicates after the client's request was folded into the feed's own. */
+    where?: string[];
+    /** On open, the heartbeat interval in seconds: the consumer's silence budget. */
+    heartbeat_interval_seconds?: number;
+    /** On open, on a batching connection, the effective delivery window in seconds. */
+    batch_window_seconds?: number;
+    /** On open, on a batching connection, the ceiling on one batch's record count. */
+    batch_max_records?: number;
+    /** On records_dropped, the records dropped since the last report. */
+    dropped?: number;
+    /** The connection's running total of dropped records; also carried on every terminal frame. */
+    dropped_total?: number;
+    /** Why records were dropped; a member of the drop-reason vocabulary. */
+    drop_reason?: string;
+    /** On a terminal frame, the WebSocket close code that follows it. */
+    close_code?: number;
+    /** On backfill_gap and backfill_unavailable, the run the statement is about. */
+    run?: string;
+    /** On backfill_gap, the first day of the inclusive range the store no longer reaches. */
+    missing_from?: string;
+    /** On backfill_gap, the last day of the inclusive range the store no longer reaches. */
+    missing_to?: string;
+    /** On backfill_gap, the number of days in the missing range. */
+    missing_days?: number;
+    /** On backfill_gap, records lost inside days that were read. */
+    missing_records?: number;
+    /** On backfill_gap and backfill_unavailable, the machine-readable cause. Its vocabulary is not yet part of this contract. */
+    reason?: string;
+    /** On backfill_unavailable, the partition's admission sampling rate: one session in N is kept (ADR-114 D8). */
+    sampling_rate?: number;
+    /** On backfill_complete, how many records came from the store. */
+    records?: number;
+    /** On backfill_complete, how many sessions those records came from. */
+    sessions?: number;
+    /** On backfill_degraded, the stored record schema versions the daemon met and does not understand. */
+    schema_versions?: number[];
+};
+/**
+ * The vocabulary of the feed `status` value (sdk/feed.Status).
+ *
+ * Every member the daemon writes. A later level adds members and removes none (ADR-143 D3); how a consumer reads an unknown member is ADR-143 D13's.
+ *
+ * Schema: sdk/feed/schema/v1/status.json
+ */
+export type FeedStatus = "open" | "partial_authorization" | "narrowed" | "records_dropped" | "upstream_lost" | "shutting_down" | "selection_changed" | "credential_expired" | "backfill_complete" | "backfill_gap" | "backfill_unavailable" | "backfill_degraded";
+/**
+ * Every type this module declares, mapped to the repository path of the schema
+ * it was generated from.
+ */
+export declare const FEED_SCHEMAS: {
+    readonly FeedConnectParams: "sdk/feed/schema/v1/connect.params.json";
+    readonly FeedDropReason: "sdk/feed/schema/v1/drop-reason.json";
+    readonly FeedFrameType: "sdk/feed/schema/v1/frame-type.json";
+    readonly FeedFrameBatch: "sdk/feed/schema/v1/frame.batch.json";
+    readonly FeedFrameHeartbeat: "sdk/feed/schema/v1/frame.heartbeat.json";
+    readonly FeedFrameRecord: "sdk/feed/schema/v1/frame.record.json";
+    readonly FeedFrameStatus: "sdk/feed/schema/v1/frame.status.json";
+    readonly FeedStatus: "sdk/feed/schema/v1/status.json";
+};

package/dist/generated/feed.js

@@ -0,0 +1,16 @@
+// Code generated by cmd/internal/genwebtypes from sdk/feed/schema/v1/; DO NOT EDIT.
+// Regenerate with `make web-types` (ADR-162 D4 item 1).
+/**
+ * Every type this module declares, mapped to the repository path of the schema
+ * it was generated from.
+ */
+export const FEED_SCHEMAS = {
+    FeedConnectParams: "sdk/feed/schema/v1/connect.params.json",
+    FeedDropReason: "sdk/feed/schema/v1/drop-reason.json",
+    FeedFrameType: "sdk/feed/schema/v1/frame-type.json",
+    FeedFrameBatch: "sdk/feed/schema/v1/frame.batch.json",
+    FeedFrameHeartbeat: "sdk/feed/schema/v1/frame.heartbeat.json",
+    FeedFrameRecord: "sdk/feed/schema/v1/frame.record.json",
+    FeedFrameStatus: "sdk/feed/schema/v1/frame.status.json",
+    FeedStatus: "sdk/feed/schema/v1/status.json",
+};

package/dist/generated/kit.d.ts

@@ -0,0 +1,374 @@
+import type { FeedFrameRecord, FeedFrameStatus } from "./feed.ts";
+/**
+ * The vocabulary of the kit's own error codes (sdk/plugin/webui.KitCodes).
+ *
+ * Every code the kit answers with when no verb gave a verdict, and sign_in_required, which tera's UI proxy answers in front of the kit when a request that is not a page load reaches the plugin's origin with no live session: load the page again to sign in; and the codes the proxy answers such a request with when it did not reach the plugin: plugin_busy (503, the plugin is at its runner link's stream cap, with Retry-After), plugin_starting (503, tera has not yet settled where the plugin runs, with Retry-After), plugin_runner_unreachable (502, the plugin's runner has no live link) and plugin_not_answering (502, the plugin's UI did not answer on its socket). Only tera_unavailable and those four are retryable. A failure envelope may also carry a verb's own code, or tera's own code for a call it refused, verbatim, which is not a member: a reader keeps a code it does not know as it arrived and branches on retryable.
+ *
+ * Schema: sdk/plugin/webui/schema/v1/error-code.json
+ */
+export type KitErrorCode = "unauthenticated" | "cross_origin" | "route_not_found" | "method_not_allowed" | "route_not_served" | "invalid_request" | "exchange_refused" | "tera_unavailable" | "step_up_required" | "sign_in_required" | "plugin_busy" | "plugin_starting" | "plugin_runner_unreachable" | "plugin_not_answering";
+/**
+ * Kit error envelope.
+ *
+ * Every kit route's failure (ADR-162 D2 item 8). The outer form is ADR-035's management-API envelope.
+ *
+ * Schema: sdk/plugin/webui/schema/v1/error.json
+ */
+export type KitError = {
+    /** The failure. */
+    error: {
+        /** What failed: one of the kit's own codes (the error-code vocabulary) when the kit refused before any verb ran, tera's own code, verbatim, when tera refused a call the kit relayed, or a verb's own code, verbatim, when a verb refused. A code a reader does not know is kept as it arrived. */
+        code: string;
+        /** A sentence for a person saying what failed. Never carries a secret. */
+        message: string;
+        /** Whether the identical request may succeed if it is sent again later with nothing changed. A reader branches on this, never on a list of codes. */
+        retryable: boolean;
+        /** How long to wait before retrying, in milliseconds, when the refusing verb said. */
+        retry_after_ms?: number;
+        /** Structured detail the refusing verb attached, whose shape the verb decides. The kit's own refusals attach none. */
+        data?: unknown;
+        /** The step-up a step_up_required, step_up_pending or step_up_mismatch refusal of the kit's is about. On a step-up just begun it carries the id, the page (url) the person confirms it on, its expiry and the methods the act accepts: open the page, poll the step-up route until it is satisfied, declined or expired, and send the identical request again with the Tera-Step-Up header set to the id. */
+        step_up?: {
+            id: string;
+            url?: string;
+            methods?: string[];
+            expires_at?: string;
+            label?: string;
+            state?: string;
+        };
+    };
+};
+/**
+ * The feed's reauthenticate event.
+ *
+ * The data of the last event of a feed stream closed because the person's token expired.
+ *
+ * Schema: sdk/plugin/webui/schema/v1/feed.event.reauthenticate.json
+ */
+export type KitFeedEventReauthenticate = {
+    /** Why the stream closed. token_expired is the reason this version sends; a reader reconnects at once whatever the reason. */
+    reason: string;
+};
+/**
+ * POST /tera/v1/invoke/{capability} response.
+ *
+ * The verb's reply envelope, HTTP 200 whenever the verb ran: workorder.HTTPInvoker's reading of the management invoke route.
+ *
+ * Schema: sdk/plugin/webui/schema/v1/invoke.response.json
+ */
+export type KitInvokeResponse = {
+    /** success when the verb answered; error when it refused. */
+    status: "success" | "error";
+    /** The verb's answer, present when status is success. */
+    result?: {
+        /** The verb's result. For a work_order.* verb, valid against sdk/workorder/schema/v1/<verb>.result.json. */
+        structured: unknown;
+    };
+    /** The verb's refusal, present when status is error. */
+    error?: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        retry_after_ms?: number;
+        /** Structured detail the refusing tool attached, whose shape the tool and its code decide. */
+        data?: unknown;
+    };
+};
+/**
+ * GET /tera/v1/me response.
+ *
+ * The signed-in person.
+ *
+ * Schema: sdk/plugin/webui/schema/v1/me.response.json
+ */
+export type KitMeResponse = {
+    /** The signed-in person, as tera's caller assertion names them: spelled as a Work Order that person filed would name them. */
+    subject: string;
+    /** Where to send the person to sign out: tera's own sign-out, as a path relative to the app's base, which a page resolves against that base (/ on the plugin's own origin, /plugins/<name>/ on a path-based installation). It is never root-absolute. */
+    signout_path: string;
+    /** Where to send the person to open a page on their phone: tera's proxy's redirect to tera's phone page, given the page's own URL as the next query parameter. A path relative to the app's base, resolved as signout_path is. It is never root-absolute. */
+    phone_path: string;
+    /** What to call the signed-in person, as tera's record of them holds it; absent when it holds none. Presentation only: subject is the identity, and nothing is decided by this. */
+    display_name?: string;
+    /** The address tera's record of the signed-in person holds; absent when it holds none. Presentation only: subject is the identity, and nothing is decided by this. */
+    email?: string;
+};
+/**
+ * GET /tera/v1/step-ups/{id} response.
+ *
+ * Where one of the person's own step-ups is in its life (ADR-173 D11).
+ *
+ * Schema: sdk/plugin/webui/schema/v1/step-up.response.json
+ */
+export type KitStepUpResponse = {
+    /** The step-up's id. */
+    id: string;
+    /** Where the step-up is in its life: pending until the person confirms or declines it, satisfied once confirmed, spent once the act used it, declined, or expired. A reader polls until it is satisfied, declined or expired. */
+    state: "pending" | "satisfied" | "spent" | "declined" | "expired";
+    /** tera's own text for the act the step-up confirms. */
+    display: string;
+    /** The methods the act accepts: passkey, and email_code when the act accepts it. */
+    methods: string[] | null;
+    /** When the step-up stops waiting, in RFC 3339. */
+    expires_at: string;
+    /** What satisfied it, passkey or email_code; absent until it is satisfied. */
+    method?: string;
+    /** For a passkey, the kind of sign-in that registered it; a passkey anchored on email_code is worth an email code. Absent otherwise. */
+    anchor?: string;
+    /** When the person confirmed it, in RFC 3339; absent until then. */
+    satisfied_at?: string;
+};
+/**
+ * POST /tera/v1/uploads response.
+ *
+ * The staged artifact an upload made (ADR-123).
+ *
+ * Schema: sdk/plugin/webui/schema/v1/upload.response.json
+ */
+export type KitUploadResponse = {
+    /** The artifact handle, which a Work Order's attachments name. */
+    handle: string;
+    /** The file's name, as the upload gave it. */
+    filename: string;
+    /** The file's media type, as the upload gave it. */
+    mime_type: string;
+    /** The file's length in bytes. */
+    size_bytes: number;
+    /** The sha256 of the bytes tera stored, as sha256:<hex>. */
+    digest: string;
+    /** The file's description, when the upload gave one. */
+    description?: string;
+    /** When the staged artifact is discarded if no Work Order has attached it, in RFC 3339. */
+    staged_expires_at: string;
+};
+/**
+ * Every type this module declares, mapped to the repository path of the schema
+ * it was generated from.
+ */
+export declare const KIT_SCHEMAS: {
+    readonly KitErrorCode: "sdk/plugin/webui/schema/v1/error-code.json";
+    readonly KitError: "sdk/plugin/webui/schema/v1/error.json";
+    readonly KitFeedEventReauthenticate: "sdk/plugin/webui/schema/v1/feed.event.reauthenticate.json";
+    readonly KitInvokeResponse: "sdk/plugin/webui/schema/v1/invoke.response.json";
+    readonly KitMeResponse: "sdk/plugin/webui/schema/v1/me.response.json";
+    readonly KitStepUpResponse: "sdk/plugin/webui/schema/v1/step-up.response.json";
+    readonly KitUploadResponse: "sdk/plugin/webui/schema/v1/upload.response.json";
+};
+/** The prefix every kit route is served under (ADR-162 D3), below the app's base. */
+export declare const KIT_ROUTE_PREFIX = "/tera/v1/";
+/** tera's own sign-out path, which `GET /tera/v1/me` answers as signout_path: relative, resolved against the app's base. */
+export declare const KIT_SIGNOUT_PATH = "_tera/signout";
+/** tera's proxy's phone path, which `GET /tera/v1/me` answers as phone_path: relative, resolved against the app's base. */
+export declare const KIT_PHONE_PATH = "_tera/phone";
+/** The kit's route table (ADR-162 D3), as sdk/plugin/webui declares it. */
+export declare const KIT_ROUTE_TABLE: {
+    readonly prefix: "/tera/v1/";
+    readonly signout_path: "_tera/signout";
+    readonly phone_path: "_tera/phone";
+    readonly same_origin: "A route marked same_origin refuses a request unless it is same-origin: when the request carries Sec-Fetch-Site, that header must be same-origin; when it does not, its Origin must equal the request's own (scheme http or https, and the Host the request was sent to). The refusal is 403 cross_origin.";
+    readonly public: "None. Every route under the prefix refuses a request with no verified caller, 401 unauthenticated, before anything else is decided. Only the app's assets, outside the prefix, are served to an anonymous request.";
+    readonly error: {
+        readonly media_type: "application/json";
+        readonly schema: "https://kottera.dev/schemas/plugin/webui/error/v1";
+        readonly description: "Every failure of every route: the kit's own refusal, under one of the error-code vocabulary, or a verb's refusal passed through as the verb gave it.";
+    };
+    readonly routes: readonly [{
+        readonly name: "me";
+        readonly method: "GET";
+        readonly path: "/tera/v1/me";
+        readonly summary: "Who is signed in, where to send them to sign out, and where to send them to open a page on their phone.";
+        readonly same_origin: false;
+        readonly response: {
+            readonly media_type: "application/json";
+            readonly schema: "https://kottera.dev/schemas/plugin/webui/me.response/v1";
+            readonly description: "The signed-in person.";
+        };
+    }, {
+        readonly name: "invoke";
+        readonly method: "POST";
+        readonly path: "/tera/v1/invoke/{capability}";
+        readonly summary: "Invoke one capability as the person, with the request body as its params. tera decides it on the person's token; the kit vets nothing.";
+        readonly same_origin: true;
+        readonly path_params: readonly [{
+            readonly name: "capability";
+            readonly description: "The capability to invoke, e.g. work_order.get.";
+            readonly required: true;
+        }];
+        readonly request: {
+            readonly media_type: "application/json";
+            readonly description: "The capability's params. For a work_order.* verb, valid against sdk/workorder/schema/v1/<verb>.params.json.";
+        };
+        readonly response: {
+            readonly media_type: "application/json";
+            readonly schema: "https://kottera.dev/schemas/plugin/webui/invoke.response/v1";
+            readonly description: "The verb's reply envelope, HTTP 200 whenever the verb ran, refusals included.";
+        };
+    }, {
+        readonly name: "feed";
+        readonly method: "GET";
+        readonly path: "/tera/v1/feeds/{feed}";
+        readonly summary: "Open a feed as the person: server-sent events carrying feed records and status frames verbatim.";
+        readonly same_origin: false;
+        readonly path_params: readonly [{
+            readonly name: "feed";
+            readonly description: "The feed's name.";
+            readonly required: true;
+        }];
+        readonly query: readonly [{
+            readonly name: "topics";
+            readonly description: "Selects a subset of the topics the person may subscribe to; each occurrence may be a comma-separated list. Widening is refused.";
+            readonly repeated: true;
+        }, {
+            readonly name: "backfill";
+            readonly description: "Precede the live stream with the stored history of the run the connection selected.";
+            readonly values: readonly ["all"];
+        }];
+        readonly response: {
+            readonly media_type: "text/event-stream";
+            readonly description: "A stream of the events below, until the person's token expires or either side closes it. Any other feed frame (a heartbeat, a batch, a type this kit does not know) is relayed verbatim as an unnamed event, read by its own type.";
+        };
+        readonly events: readonly [{
+            readonly name: "record";
+            readonly schema: "https://kottera.dev/schemas/feed/frame.record/v1";
+            readonly description: "A feed record frame, verbatim.";
+        }, {
+            readonly name: "status";
+            readonly schema: "https://kottera.dev/schemas/feed/frame.status/v1";
+            readonly description: "A feed status frame, verbatim; loss is reported here and nowhere else.";
+        }, {
+            readonly name: "reauthenticate";
+            readonly schema: "https://kottera.dev/schemas/plugin/webui/feed.event.reauthenticate/v1";
+            readonly description: "The last event of a stream closed because the person's token expired. Reconnect at once.";
+        }];
+    }, {
+        readonly name: "upload";
+        readonly method: "POST";
+        readonly path: "/tera/v1/uploads";
+        readonly summary: "Upload one file as the person (ADR-123): the kit streams the body once, digesting it, then authorizes and stores it.";
+        readonly same_origin: true;
+        readonly headers: readonly [{
+            readonly name: "Content-Type";
+            readonly description: "The file's media type.";
+            readonly required: true;
+        }, {
+            readonly name: "Tera-Upload-Filename";
+            readonly description: "The file's name, percent-encoded UTF-8.";
+            readonly required: true;
+        }, {
+            readonly name: "Tera-Upload-Description";
+            readonly description: "A description of the file, percent-encoded UTF-8.";
+        }];
+        readonly request: {
+            readonly media_type: "application/octet-stream";
+            readonly description: "The file's bytes, any media type. The body is read against its declared Content-Length, capped by the 33554432-byte (32 MiB) bound on an input artifact; a body with no declared length is held to the cap. A declaration over the cap is refused before the body is read, and a body is refused at the first byte past its bound, never after it is read whole.";
+        };
+        readonly response: {
+            readonly media_type: "application/json";
+            readonly schema: "https://kottera.dev/schemas/plugin/webui/upload.response/v1";
+            readonly description: "The staged artifact.";
+        };
+    }, {
+        readonly name: "step_up";
+        readonly method: "GET";
+        readonly path: "/tera/v1/step-ups/{id}";
+        readonly summary: "Read one of the person's own step-ups as the person (ADR-173 D11): what a page polls, after opening the step-up's url, until it is satisfied, declined or expired. A step-up that is not the person's is tera's 404, the same as an id no step-up carries.";
+        readonly same_origin: false;
+        readonly path_params: readonly [{
+            readonly name: "id";
+            readonly description: "The step-up's id, as a step_up_required refusal's step_up names it.";
+            readonly required: true;
+        }];
+        readonly response: {
+            readonly media_type: "application/json";
+            readonly schema: "https://kottera.dev/schemas/plugin/webui/step-up.response/v1";
+            readonly description: "The step-up's state.";
+        };
+    }, {
+        readonly name: "terminal";
+        readonly method: "GET";
+        readonly path: "/tera/v1/workorders/{id}/terminal";
+        readonly summary: "Open one view of an attended session's terminal as the person (ADR-181 D8): a WebSocket the kit splices to tera's terminal door, opened with the person's token. Which Work Order it is, and whether the person may see it, is tera's to decide; the kit keeps no list of sessions. Every refusal after the upgrade is a close: a query of the wrong shape is refused invalid_request; tera's 401 is reconnect, reason reauthenticate, and a second within the minute refused; its 400, 403 and 404 are refused with tera's code (not_attendee, attend_view_not_granted, not_found); its 410 is refused, reason ended, a session with no process and none coming without the person's act; its 409 (not_running, a session whose process is coming), 408, 429 and 5xx, and no answer, are retry_later with tera's code or tera_unavailable. A text message is refused binary_only.";
+        readonly same_origin: true;
+        readonly path_params: readonly [{
+            readonly name: "id";
+            readonly description: "The attended Work Order's id.";
+            readonly required: true;
+        }];
+        readonly query: readonly [{
+            readonly name: "view";
+            readonly description: "The view's id: a canonical, lower-case UUIDv7 the page mints per pane and keeps across reconnects.";
+            readonly required: true;
+        }, {
+            readonly name: "want";
+            readonly description: "Whether the view asks to type (control), only to watch (view), or to watch without being counted as attached (peek).";
+            readonly required: true;
+            readonly values: readonly ["control", "view", "peek"];
+        }, {
+            readonly name: "resume";
+            readonly description: "The output offset the page has handed to its renderer so far, a decimal integer from 0 to 9007199254740991; absent on a fresh view, which replays.";
+        }, {
+            readonly name: "cols";
+            readonly description: "The view's width in cells, a decimal integer from 1 to 65535.";
+            readonly required: true;
+        }, {
+            readonly name: "rows";
+            readonly description: "The view's height in cells, a decimal integer from 1 to 65535.";
+            readonly required: true;
+        }];
+        readonly response: {
+            readonly media_type: "application/octet-stream";
+            readonly description: "A WebSocket upgrade (101), then messages both ways until either side closes, with the close vocabulary.";
+        };
+        readonly upgrade: "websocket";
+        readonly subprotocol: "tera.terminalwire.v1";
+        readonly messages: {
+            readonly media_type: "application/octet-stream";
+            readonly description: "One sdk/terminalwire frame per binary message, each way, at most 16388 bytes. The kit relays each as it arrived, reading no payload and redacting nothing.";
+        };
+    }];
+    readonly close_codes: readonly [{
+        readonly code: 1000;
+        readonly name: "ended";
+        readonly does: "what the protocol above said last; otherwise nothing";
+    }, {
+        readonly code: 1001;
+        readonly name: "going_away";
+        readonly does: "reconnects after backoff: the peer is stopping or stopped answering pings";
+    }, {
+        readonly code: 1009;
+        readonly name: "too_big";
+        readonly does: "nothing: a message broke the route's bound, a client defect";
+    }, {
+        readonly code: 4000;
+        readonly name: "reconnect";
+        readonly does: "reconnects at once with the same identity: a token renewal";
+    }, {
+        readonly code: 4001;
+        readonly name: "retry_later";
+        readonly does: "reconnects after backoff: the far side is unreachable or not ready";
+    }, {
+        readonly code: 4003;
+        readonly name: "refused";
+        readonly does: "nothing until something changes; the reason is the error code";
+    }];
+};
+/** The name of a route in KIT_ROUTE_TABLE. */
+export type KitRouteName = (typeof KIT_ROUTE_TABLE)["routes"][number]["name"];
+/**
+ * The JSON body each route answers on success, by route name. A route not
+ * here answers a body that is not JSON.
+ */
+export type KitRouteResponses = {
+    me: KitMeResponse;
+    invoke: KitInvokeResponse;
+    upload: KitUploadResponse;
+    step_up: KitStepUpResponse;
+};
+/** The data of each server-sent event a feed stream carries, by event name. */
+export type KitFeedEvents = {
+    record: FeedFrameRecord;
+    status: FeedFrameStatus;
+    reauthenticate: KitFeedEventReauthenticate;
+};
+/** Every route's failure body. */
+export type KitRouteError = KitError;