@openchamber/sdk 2.5.3 → 2.6.0

package/dist/service-provider-schemas.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import { BROWSER_CONTROL_ACTIONS, SOURCE_CONTROL_OUTBOUND_BODY_MAX, SOURCE_CONTROL_OUTBOUND_METHODS, SOURCE_CONTROL_OUTBOUND_REQUEST_HEADERS, SOURCE_CONTROL_PROVIDER_ERROR_MESSAGE_MAX, SOURCE_CONTROL_PROVIDER_METHODS, SOURCE_CONTROL_PROVIDER_RESPONSE_MAX, SOURCE_CONTROL_PROVIDER_TARGET_MAX, } from './service-providers.js';
+import { BROWSER_CONTROL_ACTIONS, NOTIFICATIONS_PROVIDER_METHODS, SOURCE_CONTROL_OUTBOUND_BODY_MAX, SOURCE_CONTROL_OUTBOUND_METHODS, SOURCE_CONTROL_OUTBOUND_REQUEST_HEADERS, SOURCE_CONTROL_PROVIDER_ERROR_MESSAGE_MAX, SOURCE_CONTROL_PROVIDER_METHODS, SOURCE_CONTROL_PROVIDER_RESPONSE_MAX, SOURCE_CONTROL_PROVIDER_TARGET_MAX, TRACKER_PROVIDER_CONTAINERS_MAX, TRACKER_PROVIDER_LIST_MAX, TRACKER_PROVIDER_LIVE_SUMMARIES_MAX, TRACKER_PROVIDER_METHODS, } from './service-providers.js';
+import { SESSION_EVENT_ERROR_MAX } from './session-events.js';
 /**
  * Host-side parse of what a browser provider answers. `data` stays whatever
  * the service produced: the host hands it to the agent as is, and only
@@ -9,6 +10,19 @@ export const browserProviderResultSchema = z.union([
     z.object({ ok: z.literal(true), data: z.object({}).passthrough() }),
     z.object({ ok: z.literal(false), error: z.string().min(1).max(2_000) }),
 ]);
+/**
+ * Host-side parse of what a service answers a session event with. OpenChamber
+ * acts on nothing in it beyond logging a failure's `error`; an answer that does
+ * not parse is a failed delivery, never a delivered one.
+ */
+export const sessionEventResultSchema = z.union([
+    z.object({ ok: z.literal(true) }).strict(),
+    z.object({ ok: z.literal(false), error: z.string().min(1).max(SESSION_EVENT_ERROR_MAX) }).strict(),
+]);
+const assertSessionEventResultParsed = (value) => value;
+const assertSessionEventResultContract = (value) => value;
+void assertSessionEventResultParsed;
+void assertSessionEventResultContract;
 export const browserControlActionSchema = z.enum(BROWSER_CONTROL_ACTIONS);
 /*
  * Host-side parse of what a source-control provider answers. Every answer is
@@ -230,3 +244,147 @@ export const sourceControlProviderSchemasV1 = {
     data: dataSchemas,
 };
 export const sourceControlProviderMethodSchema = z.enum(SOURCE_CONTROL_PROVIDER_METHODS);
+/*
+ * Host-side parse of what a notifications provider answers. The envelope and
+ * the error are the Git host's: `ok: true` with `data`, or `ok: false` with
+ * `{ message, status?, code? }`, and a 401 writes the account off only when
+ * OpenChamber's proxy saw the channel's server answer it.
+ */
+const notificationsAccountSchema = z.object({
+    account: z.object({
+        id: z.string().min(1).max(256),
+        login: z.string().min(1).max(256),
+        name: optionalText,
+    }),
+});
+const notificationsNotifySchema = z.object({ delivered: z.literal(true) }).strict();
+const notificationsDataSchemas = {
+    'auth.verify': notificationsAccountSchema,
+    'auth.probe': probeSchema,
+    notify: notificationsNotifySchema,
+};
+/** Wire 1 of the notifications role, as the host parses it. `data[method]` checks an `ok: true` answer's `data`. */
+export const notificationsProviderSchemasV1 = {
+    envelope: envelopeSchema,
+    error: errorSchema,
+    account: notificationsAccountSchema,
+    probe: probeSchema,
+    notify: notificationsNotifySchema,
+    outboundRequest: outboundRequestSchema,
+    data: notificationsDataSchemas,
+};
+export const notificationsProviderMethodSchema = z.enum(NOTIFICATIONS_PROVIDER_METHODS);
+/*
+ * Host-side parse of what a tracker answers. The envelope and the error are
+ * the Git host's. Every item is checked in the neutral shapes before the host
+ * hands it to the UI, bounded in count and length, and asserted against the
+ * TypeScript types the service writes against, so the two cannot drift. A
+ * failed parse is a malformed answer, never an empty list.
+ */
+const trackerText = z.string().min(1).max(1_024);
+const trackerTitle = z.string().max(4_096);
+// An item's link is opened and drawn as a link in the app: http(s) only, so an answer cannot hand the UI a `javascript:` URL.
+const trackerUrl = z.string().min(1).max(2_048).refine((value) => /^https?:\/\//i.test(value) && URL.canParse(value), { message: 'must be an http(s) URL' });
+const trackerCategory = z.enum(['triage', 'backlog', 'todo', 'in-progress', 'done', 'canceled']);
+const trackerPriority = z.enum(['none', 'urgent', 'high', 'medium', 'low']);
+const trackerPerson = z.object({ name: z.string().max(256).nullable(), avatarUrl: z.string().max(2_048).nullable() }).strict();
+const trackerContainer = z.object({ id: trackerText, key: z.string().max(64).nullable(), name: z.string().min(1).max(256) }).strict();
+const trackerState = z.object({ id: trackerText.nullable(), name: z.string().max(256), category: trackerCategory.nullable() }).strict();
+const trackerItemFields = {
+    id: trackerText,
+    identifier: z.string().min(1).max(128),
+    title: trackerTitle,
+    url: trackerUrl,
+    state: trackerState.nullable(),
+    priority: trackerPriority.nullable().optional(),
+    labels: z.array(z.object({ id: trackerText, name: z.string().min(1).max(256), color: z.string().max(32).nullable() }).strict()).max(TRACKER_PROVIDER_LIST_MAX).optional(),
+    assignee: trackerPerson.nullable().optional(),
+    container: trackerContainer.nullable().optional(),
+    progress: z.object({ total: z.number().int().nonnegative(), done: z.number().int().nonnegative(), more: z.boolean() }).strict().nullable().optional(),
+    updatedAt: z.string().max(64).nullable().optional(),
+};
+/** A related item (a parent, a child): one level deep, naming no parent of its own (`null` at most). */
+const trackerRelatedItemSchema = z.object({ ...trackerItemFields, parent: z.null().optional() }).strict();
+const trackerItemSummarySchema = z.object({ ...trackerItemFields, parent: trackerRelatedItemSchema.nullable().optional() }).strict();
+const trackerCommentSchema = z.object({
+    id: trackerText,
+    body: z.string().max(65_536),
+    createdAt: z.string().max(64).nullable(),
+    author: trackerPerson.nullable(),
+}).strict();
+const trackerItemSchema = trackerItemSummarySchema.extend({
+    description: z.string().max(262_144).nullable().optional(),
+    comments: z.array(trackerCommentSchema).max(TRACKER_PROVIDER_LIST_MAX).optional(),
+    children: z.array(trackerRelatedItemSchema).max(TRACKER_PROVIDER_LIST_MAX).optional(),
+    childrenMore: z.boolean().optional(),
+}).strict();
+const trackerAccountSchema = z.object({
+    account: z.object({
+        id: z.string().min(1).max(256),
+        login: z.string().min(1).max(256).nullable(),
+        name: optionalText,
+        avatarUrl: z.string().max(2_048).optional(),
+    }).strict(),
+}).strict();
+const trackerListSchema = z.object({
+    items: z.array(trackerItemSummarySchema).max(TRACKER_PROVIDER_LIST_MAX),
+    cursor: z.string().min(1).max(2_048).nullable(),
+    hasMore: z.boolean(),
+}).strict();
+const trackerItemDataSchema = z.object({ item: trackerItemSchema.nullable() }).strict();
+const trackerStatesSchema = z.object({
+    states: z.array(z.object({ id: trackerText, name: z.string().min(1).max(256), category: trackerCategory.nullable(), position: z.number() }).strict()).max(TRACKER_PROVIDER_LIST_MAX * 2),
+}).strict();
+const trackerLiveSummariesSchema = z.object({
+    items: z.array(z.object({
+        identifier: z.string().min(1).max(128),
+        title: trackerTitle,
+        state: z.object({ name: z.string().max(256), category: trackerCategory }).strict(),
+    }).strict()).max(TRACKER_PROVIDER_LIVE_SUMMARIES_MAX),
+}).strict();
+const trackerContainersSchema = z.object({ containers: z.array(trackerContainer).max(TRACKER_PROVIDER_CONTAINERS_MAX) }).strict();
+const trackerCommentDataSchema = z.object({ comment: z.object({ id: trackerText }).strict().nullable() }).strict();
+const assertTrackerSummary = (value) => value;
+const assertTrackerItem = (value) => value;
+const assertTrackerAccount = (value) => value;
+const assertTrackerList = (value) => value;
+const assertTrackerItemData = (value) => value;
+const assertTrackerStates = (value) => value;
+const assertTrackerLive = (value) => value;
+const assertTrackerContainers = (value) => value;
+void assertTrackerSummary;
+void assertTrackerItem;
+void assertTrackerAccount;
+void assertTrackerList;
+void assertTrackerItemData;
+void assertTrackerStates;
+void assertTrackerLive;
+void assertTrackerContainers;
+const trackerDataSchemas = {
+    'auth.probe': probeSchema,
+    'auth.verify': trackerAccountSchema,
+    'items.list': trackerListSchema,
+    'items.get': trackerItemDataSchema,
+    'items.updateState': trackerItemDataSchema,
+    'items.liveSummaries': trackerLiveSummariesSchema,
+    'states.list': trackerStatesSchema,
+    'containers.list': trackerContainersSchema,
+    'comments.create': trackerCommentDataSchema,
+};
+/** Wire 1 of the tracker role, as the host parses it. `data[method]` checks an `ok: true` answer's `data`. */
+export const trackerProviderSchemasV1 = {
+    envelope: envelopeSchema,
+    error: errorSchema,
+    account: trackerAccountSchema,
+    probe: probeSchema,
+    itemSummary: trackerItemSummarySchema,
+    item: trackerItemSchema,
+    list: trackerListSchema,
+    states: trackerStatesSchema,
+    liveSummaries: trackerLiveSummariesSchema,
+    containers: trackerContainersSchema,
+    comment: trackerCommentDataSchema,
+    outboundRequest: outboundRequestSchema,
+    data: trackerDataSchemas,
+};
+export const trackerProviderMethodSchema = z.enum(TRACKER_PROVIDER_METHODS);

package/dist/service-providers.d.ts

@@ -308,7 +308,8 @@ export declare const sourceControlProviderTimeoutMs: (method: SourceControlProvi
 /**
  * Environment variable with the base URL of OpenChamber's callback listener
  * (`http://127.0.0.1:<port>`). Set only for a service that provides
- * `source-control`; `createSourceControlForge` reads it.
+ * `source-control`, `notifications` or `tracker`; `createSourceControlForge`,
+ * `createNotificationsOutbound` and `createTrackerOutbound` read it.
  */
 export declare const OPENCHAMBER_HOST_CALLBACK_URL = "OPENCHAMBER_HOST_CALLBACK_URL";
 /** Route on the callback listener a service sends a forge request to. */
@@ -622,4 +623,424 @@ export type SourceControlForge = {
 export declare const createSourceControlForge: ({ env }: {
     env: Record<string, string | undefined>;
 }) => SourceControlForge;
+/** Route on the service loopback OpenChamber posts every notifications call to. */
+export declare const NOTIFICATIONS_PROVIDER_PATH = "/notifications";
+/** The `v` of every request; a service answers a version it does not know with HTTP 400. */
+export declare const NOTIFICATIONS_PROVIDER_WIRE_VERSION = 1;
+/**
+ * `auth.verify` reads who a candidate token belongs to, `auth.probe` whether
+ * an instance is this channel's server, `notify` delivers one notification.
+ */
+export declare const NOTIFICATIONS_PROVIDER_METHODS: readonly ['auth.verify', 'auth.probe', 'notify'];
+export type NotificationsProviderMethod = (typeof NOTIFICATIONS_PROVIDER_METHODS)[number];
+/** A notification is delivered within this deadline; a slower service drops it. */
+export declare const NOTIFICATIONS_PROVIDER_NOTIFY_TIMEOUT_MS = 10000;
+export declare const NOTIFICATIONS_PROVIDER_AUTH_TIMEOUT_MS = 15000;
+/** Bytes of an answer OpenChamber reads. */
+export declare const NOTIFICATIONS_PROVIDER_RESPONSE_MAX = 16000;
+/** Characters of `error.message` OpenChamber reads. */
+export declare const NOTIFICATIONS_PROVIDER_ERROR_MESSAGE_MAX = 2000;
+/** No call for this long stops the service; the next call starts it again. */
+export declare const NOTIFICATIONS_PROVIDER_IDLE_MS: number;
+/** Route on the callback listener a service sends the channel's requests to. */
+export declare const NOTIFICATIONS_OUTBOUND_PATH = "/notifications/outbound";
+/** One outbound request may take this long; the call's own deadline may end it sooner. */
+export declare const NOTIFICATIONS_OUTBOUND_TIMEOUT_MS = 20000;
+export declare const notificationsProviderTimeoutMs: (method: NotificationsProviderMethod) => number;
+/**
+ * The kinds OpenChamber notifies about. `ready`: the agent finished; `error`:
+ * the turn failed; `question` and `permission`: the agent waits for the user;
+ * `review`: an auto-review ended; the `goal_*` kinds: a session goal settled.
+ * Which kinds reach a channel follows the user's own notification toggles.
+ */
+export declare const GUEST_NOTIFICATION_KINDS: readonly ['ready', 'error', 'question', 'permission', 'review', 'goal_complete', 'goal_blocked', 'goal_budget'];
+export type GuestNotificationKind = (typeof GUEST_NOTIFICATION_KINDS)[number];
+/**
+ * One notification as OpenChamber shows it, after the user's templates. In
+ * enterprise mode `title` is the kind's generic title and `body`,
+ * `sessionName` and `directory` are empty, as they are for the phone.
+ */
+export type GuestNotification = {
+    kind: GuestNotificationKind;
+    title: string;
+    body: string;
+    /** Groups repeats of one thing (`ready-<sessionId>`): a later one may replace an earlier one where the channel can. */
+    tag: string;
+    /** Epoch milliseconds. */
+    at: number;
+    sessionId: string | null;
+    sessionName: string | null;
+    directory: string | null;
+    /** The link that opens the session in OpenChamber, when there is one. */
+    url: string | null;
+};
+/** The connected account a call acts as; `null` in `auth.verify` and `auth.probe`, before one exists. */
+export type NotificationsProviderAccount = {
+    id: string;
+    login: string | null;
+};
+/**
+ * Who a call is for. `instance` is the account's origin (`https://slack.com`,
+ * a Matrix homeserver). `handle` is the capability for this one call: pass it
+ * to `createNotificationsOutbound(...).request`. It stops working when the
+ * call ends; never store it.
+ */
+export type NotificationsProviderSession = {
+    instance: string;
+    handle: string;
+    account: NotificationsProviderAccount | null;
+};
+/** What each method's `input` holds. */
+export type NotificationsProviderInputs = {
+    'auth.verify': Record<string, never>;
+    'auth.probe': Record<string, never>;
+    notify: {
+        notification: GuestNotification;
+    };
+};
+/**
+ * One call, as OpenChamber posts it. `provider` is the id OpenChamber gave
+ * this channel (`ext-<panel.id>`). `input` was built by OpenChamber; its shape
+ * per method is `NotificationsProviderInputs`.
+ */
+export type NotificationsProviderRequest = {
+    v: typeof NOTIFICATIONS_PROVIDER_WIRE_VERSION;
+    requestId: string;
+    method: NotificationsProviderMethod;
+    provider: string;
+    session: NotificationsProviderSession;
+    input: SourceControlJsonObject;
+};
+/** Who the candidate token belongs to; OpenChamber stores the account under `id`. */
+export type NotificationsAccountData = {
+    account: {
+        id: string;
+        login: string;
+        name?: string;
+    };
+};
+export type NotificationsProbeData = {
+    supported: boolean;
+    message?: string;
+};
+export type NotificationsNotifyData = {
+    delivered: true;
+};
+/**
+ * An answer. `error.status` is the HTTP status OpenChamber should treat the
+ * failure as; a 401 writes the account off only when OpenChamber's proxy saw
+ * the channel's server answer 401 itself. `error.code` is `[A-Z_]{1,64}`.
+ */
+export type NotificationsProviderError = SourceControlProviderError;
+export type NotificationsProviderResult = {
+    ok: true;
+    data: SourceControlJson;
+} | {
+    ok: false;
+    error: NotificationsProviderError;
+};
+export declare const isNotificationsProviderMethod: (value: string) => value is NotificationsProviderMethod;
+/**
+ * A service's read of the body OpenChamber posted to
+ * `NOTIFICATIONS_PROVIDER_PATH`. OpenChamber built `input`, so this checks the
+ * envelope, not every field, and the service bundle needs no schema library.
+ * `null` is a body that is not a notifications call of this wire version;
+ * answer it with HTTP 400.
+ */
+export declare const readNotificationsProviderRequest: (body: string) => NotificationsProviderRequest | null;
+/**
+ * OpenChamber refused the request (an expired handle, a path off the
+ * instance, a body too large), could not reach the channel's server, or did
+ * not answer. `status` is the callback listener's HTTP status, `0` when it
+ * gave none; `code` is its error code (`HOST_UNAVAILABLE` when there was no
+ * usable answer).
+ */
+export declare class NotificationsOutboundError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(message: string, code: string, status: number);
+}
+export type NotificationsOutbound = {
+    /** Sends `request` to the server of the account `handle` belongs to, with the stored token when the call has one. */
+    request(handle: string, request: SourceControlOutboundRequest): Promise<SourceControlOutboundResponse>;
+};
+/**
+ * The service's way to the channel's server: OpenChamber's callback listener
+ * (`OPENCHAMBER_HOST_CALLBACK_URL`), which checks the handle, keeps the
+ * request on the account's origin and adds the token. Plain `fetch`, no
+ * dependencies. Throws `NotificationsOutboundError` when OpenChamber refuses
+ * the request; an answer of any status from the server resolves.
+ */
+export declare const createNotificationsOutbound: ({ env }: {
+    env: Record<string, string | undefined>;
+}) => NotificationsOutbound;
+/** Route on the service loopback OpenChamber posts every tracker call to. */
+export declare const TRACKER_PROVIDER_PATH = "/tracker";
+/** The `v` of every request; a service answers a version it does not know with HTTP 400. */
+export declare const TRACKER_PROVIDER_WIRE_VERSION = 1;
+/**
+ * Every call OpenChamber forwards. `auth.probe` asks whether an instance is
+ * this tracker's server, `auth.verify` who a credential belongs to (the handle
+ * carries a pasted token or an OAuth access token); the reads answer in the
+ * neutral shapes; `items.updateState` and `comments.create` are the two
+ * writes, the only calls whose handle may send anything but `GET`.
+ */
+export declare const TRACKER_PROVIDER_METHODS: readonly ['auth.probe', 'auth.verify', 'items.list', 'items.get', 'items.updateState', 'items.liveSummaries', 'states.list', 'containers.list', 'comments.create'];
+export type TrackerProviderMethod = (typeof TRACKER_PROVIDER_METHODS)[number];
+/** The calls that change something on the tracker. */
+export declare const TRACKER_PROVIDER_WRITE_METHODS: readonly ["items.updateState", "comments.create"];
+export declare const TRACKER_PROVIDER_AUTH_TIMEOUT_MS = 15000;
+export declare const TRACKER_PROVIDER_READ_TIMEOUT_MS = 20000;
+export declare const TRACKER_PROVIDER_WRITE_TIMEOUT_MS = 30000;
+/** Bytes of an answer OpenChamber reads: a page of items with their labels and people. */
+export declare const TRACKER_PROVIDER_RESPONSE_MAX = 2000000;
+/** Characters of `error.message` OpenChamber reads. */
+export declare const TRACKER_PROVIDER_ERROR_MESSAGE_MAX = 2000;
+/** No call for this long stops the service; the next call starts it again. */
+export declare const TRACKER_PROVIDER_IDLE_MS: number;
+/** Items in one `items.list` page, children or comments of one item, states of one container. */
+export declare const TRACKER_PROVIDER_LIST_MAX = 100;
+/** Identifiers in one `items.liveSummaries` call. */
+export declare const TRACKER_PROVIDER_LIVE_SUMMARIES_MAX = 50;
+/** Containers in one `containers.list` answer. */
+export declare const TRACKER_PROVIDER_CONTAINERS_MAX = 500;
+/** Route on the callback listener a service sends the tracker's requests to. */
+export declare const TRACKER_OUTBOUND_PATH = "/tracker/outbound";
+/** One outbound request may take this long; the call's own deadline may end it sooner. */
+export declare const TRACKER_OUTBOUND_TIMEOUT_MS = 20000;
+export declare const isTrackerProviderWriteMethod: (method: TrackerProviderMethod) => boolean;
+/** How long OpenChamber waits for the service to answer `method`. */
+export declare const trackerProviderTimeoutMs: (method: TrackerProviderMethod) => number;
+export type TrackerProviderStateCategory = 'triage' | 'backlog' | 'todo' | 'in-progress' | 'done' | 'canceled';
+export type TrackerProviderPriority = 'none' | 'urgent' | 'high' | 'medium' | 'low';
+export type TrackerProviderPerson = {
+    name: string | null;
+    avatarUrl: string | null;
+};
+export type TrackerProviderItemState = {
+    id: string | null;
+    name: string;
+    category: TrackerProviderStateCategory | null;
+};
+export type TrackerProviderContainer = {
+    id: string;
+    key: string | null;
+    name: string;
+};
+export type TrackerProviderLabel = {
+    id: string;
+    name: string;
+    color: string | null;
+};
+/** Only the first few children are counted; `more` says there are others. */
+export type TrackerProviderProgress = {
+    total: number;
+    done: number;
+    more: boolean;
+};
+/** One item in a list, or a related item (a parent, a child), which carries no labels or progress of its own. */
+export type TrackerProviderItemSummary = {
+    /** The tracker's stable id; what `items.get` and `items.updateState` take. */
+    id: string;
+    /** Human key (`PROJ-42`), the shape `contributes.tracker.identifier` declares; compared case-insensitively. */
+    identifier: string;
+    title: string;
+    url: string;
+    state: TrackerProviderItemState | null;
+    priority?: TrackerProviderPriority | null;
+    labels?: TrackerProviderLabel[];
+    assignee?: TrackerProviderPerson | null;
+    container?: TrackerProviderContainer | null;
+    parent?: TrackerProviderItemSummary | null;
+    progress?: TrackerProviderProgress | null;
+    /** ISO 8601. */
+    updatedAt?: string | null;
+};
+export type TrackerProviderComment = {
+    id: string;
+    body: string;
+    createdAt: string | null;
+    author: TrackerProviderPerson | null;
+};
+export type TrackerProviderItem = TrackerProviderItemSummary & {
+    description?: string | null;
+    comments?: TrackerProviderComment[];
+    /** The first page of children in the tracker's order; `childrenMore` says there are others. */
+    children?: TrackerProviderItemSummary[];
+    childrenMore?: boolean;
+};
+export type TrackerProviderWorkflowState = {
+    id: string;
+    name: string;
+    category: TrackerProviderStateCategory | null;
+    position: number;
+};
+export type TrackerProviderLiveSummary = {
+    identifier: string;
+    title: string;
+    state: {
+        name: string;
+        category: TrackerProviderStateCategory;
+    };
+};
+/** The connected account a call acts as; `null` in `auth.verify` and `auth.probe`, before one exists. */
+export type TrackerProviderAccount = {
+    id: string;
+    login: string | null;
+};
+/**
+ * Who a call is for. `instance` is the account's origin (the tracker's one
+ * address, or the server the user typed). `handle` is the capability for this
+ * one call: pass it to `createTrackerOutbound(...).request`. It stops working
+ * when the call ends; never store it.
+ */
+export type TrackerProviderSession = {
+    instance: string;
+    handle: string;
+    account: TrackerProviderAccount | null;
+};
+/** What each method's `input` holds. OpenChamber built and checked every field. */
+export type TrackerProviderInputs = {
+    'auth.probe': Record<string, never>;
+    'auth.verify': Record<string, never>;
+    'items.list': {
+        query?: string;
+        cursor?: string;
+        /** One of the manifest's `stateFilters`. */
+        state: string;
+        people: 'any' | 'me' | 'created';
+        priority: 'all' | TrackerProviderPriority;
+        containerId: string | null;
+    };
+    'items.get': {
+        id: string;
+    };
+    'items.updateState': {
+        id: string;
+        stateId: string;
+    };
+    'items.liveSummaries': {
+        identifiers: string[];
+    };
+    'states.list': {
+        containerId: string;
+    };
+    'containers.list': Record<string, never>;
+    /** `body` is Markdown OpenChamber wrote: "OpenChamber session completed" with a link to the session. */
+    'comments.create': {
+        identifier: string;
+        body: string;
+    };
+};
+/**
+ * One call, as OpenChamber posts it. `provider` is the id OpenChamber gave
+ * this tracker (`ext-<panel.id>`). `input` was built by OpenChamber; its shape
+ * per method is `TrackerProviderInputs`.
+ */
+export type TrackerProviderRequest = {
+    v: typeof TRACKER_PROVIDER_WIRE_VERSION;
+    requestId: string;
+    method: TrackerProviderMethod;
+    provider: string;
+    session: TrackerProviderSession;
+    input: SourceControlJsonObject;
+};
+/** Who the credential belongs to; OpenChamber stores the account under `id` and shows `name`. */
+export type TrackerProviderAccountData = {
+    account: {
+        id: string;
+        login: string | null;
+        name?: string;
+        avatarUrl?: string;
+    };
+};
+export type TrackerProviderProbeData = {
+    supported: boolean;
+    message?: string;
+};
+export type TrackerProviderListData = {
+    items: TrackerProviderItemSummary[];
+    cursor: string | null;
+    hasMore: boolean;
+};
+/** `item` is null when the tracker has no such item. */
+export type TrackerProviderItemData = {
+    item: TrackerProviderItem | null;
+};
+export type TrackerProviderStatesData = {
+    states: TrackerProviderWorkflowState[];
+};
+/** Identifiers the tracker does not know are left out. */
+export type TrackerProviderLiveSummariesData = {
+    items: TrackerProviderLiveSummary[];
+};
+export type TrackerProviderContainersData = {
+    containers: TrackerProviderContainer[];
+};
+/** `comment` is null when the item was not found. */
+export type TrackerProviderCommentData = {
+    comment: {
+        id: string;
+    } | null;
+};
+/** What each method answers in `data`. */
+export type TrackerProviderDataByMethod = {
+    'auth.probe': TrackerProviderProbeData;
+    'auth.verify': TrackerProviderAccountData;
+    'items.list': TrackerProviderListData;
+    'items.get': TrackerProviderItemData;
+    'items.updateState': TrackerProviderItemData;
+    'items.liveSummaries': TrackerProviderLiveSummariesData;
+    'states.list': TrackerProviderStatesData;
+    'containers.list': TrackerProviderContainersData;
+    'comments.create': TrackerProviderCommentData;
+};
+/**
+ * An answer. `error.status` is the HTTP status OpenChamber should treat the
+ * failure as; a 401 writes the account off only when OpenChamber's proxy saw
+ * the tracker's server answer 401 itself. `error.code` is `[A-Z_]{1,64}`.
+ */
+export type TrackerProviderError = SourceControlProviderError;
+export type TrackerProviderResult = {
+    ok: true;
+    data: SourceControlJson;
+} | {
+    ok: false;
+    error: TrackerProviderError;
+};
+export declare const isTrackerProviderMethod: (value: string) => value is TrackerProviderMethod;
+/**
+ * A service's read of the body OpenChamber posted to `TRACKER_PROVIDER_PATH`.
+ * OpenChamber built `input`, so this checks the envelope, not every field, and
+ * the service bundle needs no schema library. `null` is a body that is not a
+ * tracker call of this wire version; answer it with HTTP 400.
+ */
+export declare const readTrackerProviderRequest: (body: string) => TrackerProviderRequest | null;
+/**
+ * OpenChamber refused the request (an expired handle, a path off the
+ * instance, a body too large, a write through a read's handle), could not
+ * reach the tracker's server, or did not answer. `status` is the callback
+ * listener's HTTP status, `0` when it gave none; `code` is its error code
+ * (`HOST_UNAVAILABLE` when there was no usable answer).
+ */
+export declare class TrackerOutboundError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(message: string, code: string, status: number);
+}
+export type TrackerOutbound = {
+    /** Sends `request` to the server of the account `handle` belongs to, with the stored credential when the call has one. */
+    request(handle: string, request: SourceControlOutboundRequest): Promise<SourceControlOutboundResponse>;
+};
+/**
+ * The service's way to the tracker's server: OpenChamber's callback listener
+ * (`OPENCHAMBER_HOST_CALLBACK_URL`), which checks the handle, keeps the
+ * request on the account's origin and adds the credential. Plain `fetch`, no
+ * dependencies. Throws `TrackerOutboundError` when OpenChamber refuses the
+ * request; an answer of any status from the server resolves. A read's handle
+ * sends `GET` only; `items.updateState` and `comments.create` may send writes.
+ */
+export declare const createTrackerOutbound: ({ env }: {
+    env: Record<string, string | undefined>;
+}) => TrackerOutbound;
 export {};