@mind-harness/mh-browser 0.0.0-stage → 0.1.1

package/lib/types/presence/record.d.ts

@@ -0,0 +1,47 @@
+/** Structured presence record carried on a message source. The model sees the rendered text, not this. */
+export declare const PRESENCE_SOURCES: readonly ["person via sidebar", "cwd reference", "model"];
+export type PresenceSource = (typeof PRESENCE_SOURCES)[number];
+export type PresenceOp = 'present' | 'added' | 'changed' | 'absent' | 'removed';
+export interface PresenceEntryRecord {
+    op: PresenceOp;
+    url: string;
+    source: PresenceSource;
+    version?: string;
+    observedAt: string;
+    digest: string;
+    /** The `id` the Agent View declares; `browser_invoke` takes it as well as `url`. */
+    id?: string;
+    reason?: string;
+}
+export interface PresenceRecord {
+    kind: 'baseline' | 'delta';
+    replaces?: true;
+    entries: PresenceEntryRecord[];
+}
+/** One page in the folded presence set. */
+export interface HeldPage {
+    url: string;
+    source: PresenceSource;
+    state: 'committed' | 'pending';
+    order: number;
+    seen?: {
+        version?: string;
+        digest: string;
+        observedAt: string;
+        id?: string;
+    } | {
+        absent: string;
+    };
+    title?: string;
+    representation?: 'agent-view' | 'snapshot';
+    body?: string;
+    agentViewError?: string;
+    fragment?: string;
+    requires?: string[];
+    viewUrl?: string;
+}
+export interface PresenceReceipt {
+    url: string;
+    receipt: 'added (pending)' | 'already in presence' | 'removed (pending)' | 'not in presence';
+}
+//# sourceMappingURL=record.d.ts.map

package/lib/types/presence/register.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent, PreStepDecision } from '@deepseek-ai/dsh-agent';
+import { type UserMessage } from '@deepseek-ai/dsh-llm';
+import type { MhBrowserService } from '../service/service.ts';
+import { type PresenceLogState } from './fold.ts';
+import './source.ts';
+/**
+ * Track browser touches, check the pages they named after the step, and merge
+ * the reminder after the claimed input. `await next()` runs first, so a
+ * caller that puts pages and then returns `next()` is folded into this step.
+ */
+export declare function registerPresence(ctx: Context): void;
+/**
+ * The reminder this step should carry. A set the log has but this process has
+ * not checked (a resumed session) is re-read; one whose reminder a canceled
+ * splice discarded is re-announced whole.
+ */
+export declare function compose(service: MhBrowserService, agent: Agent, log: PresenceLogState, claimed: readonly UserMessage[], signal?: AbortSignal): Promise<UserMessage | undefined>;
+/** A presence reminder stays pending when the step is rejected or the first step has nothing to say. */
+export declare function mergePresence(agent: Agent, log: PresenceLogState, claimed: readonly UserMessage[], step: number, decision: PreStepDecision, desired: UserMessage | undefined): PreStepDecision;
+//# sourceMappingURL=register.d.ts.map

package/lib/types/presence/source.d.ts

@@ -0,0 +1,18 @@
+import type { PresenceRecord } from './record.ts';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        /**
+         * mh-browser presence reminders and takeover notices; folded by kind.
+         * @persistenceAttribution
+         */
+        'mh-browser': {
+            kind: 'mh-browser';
+            presence?: PresenceRecord;
+            takeover?: {
+                operations: number;
+                tabs: string[];
+            };
+        };
+    }
+}
+//# sourceMappingURL=source.d.ts.map

package/lib/types/projections.d.ts

@@ -0,0 +1,25 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Session } from '@deepseek-ai/dsh-session';
+import { type PresenceLogState } from './presence/fold.ts';
+import { type AttachmentState } from './tools/attachments.ts';
+import { type DeliveryState } from './tools/delivery.ts';
+import { type TabLogState } from './tools/tab-log.ts';
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        mhBrowserDeliveries: DeliveryState;
+        mhBrowserPresence: PresenceLogState;
+        mhBrowserAttachments: AttachmentState;
+        mhBrowserTabs: TabLogState;
+    }
+}
+/** Host-only folds over the session log; every read of what the log says goes through these. */
+export declare function registerProjections(ctx: Context): void;
+export interface LogReader {
+    deliveries(session: Session): DeliveryState;
+    presence(session: Session): PresenceLogState;
+    attachments(session: Session): AttachmentState;
+    tabs(session: Session): TabLogState;
+}
+/** Fails closed when the registry or a unit is not active. */
+export declare function logReader(ctx: Context): LogReader;
+//# sourceMappingURL=projections.d.ts.map

package/lib/types/render/envelope.d.ts

@@ -0,0 +1,80 @@
+import type { PageError, PageView, TabInfo } from '../types.ts';
+/**
+ * Escape a closer a site could use to end a frame the service opened. Only
+ * its opening `</name` is rewritten, so a closer cut off before `>` is caught
+ * and no site text is dropped.
+ */
+export declare function escapeBody(text: string): string;
+/** Escape text the service writes into an attribute. */
+export declare function escapeAttr(text: string): string;
+/** Site text that must stay on one line, such as a title in `<tabs>`. */
+export declare function oneLine(text: string): string;
+export declare function incompleteText(incomplete: {
+    load: boolean;
+    pendingRequests: number;
+}): string;
+export declare function waitedText(waited: {
+    met: 'text' | 'textGone' | 'time' | false;
+    seconds: number;
+}): string;
+/**
+ * `withDigest` is for a page attached to a tool error: an error result has no
+ * meta, so the digest in the header is what records the delivery.
+ */
+export declare function renderPage(view: PageView, screenshot?: string, omitBody?: boolean, withDigest?: boolean): string;
+export declare function renderActionResponse(response: {
+    name: string;
+    status?: number;
+    location?: string;
+    mediaType?: string;
+    body?: string;
+    bytes?: number;
+    lost?: boolean;
+}): string;
+export declare function renderPageError(error: PageError): string;
+export declare function renderTabs(tabs: TabInfo[], closed: string[]): string;
+export declare function renderDialog(type: string, message: string): string;
+export declare function renderDownload(download: {
+    kind: 'saved';
+    path: string;
+    url: string;
+    mediaType?: string;
+    bytes: number;
+    sha256: string;
+    observed: string;
+} | {
+    kind: 'error';
+    url: string;
+    status?: number;
+    reason: string;
+}): string;
+export declare function renderAbsent(input: {
+    url: string;
+    title: string;
+    reason: string;
+    source?: string;
+    declaredBy?: string;
+}): string;
+/**
+ * `omitInPresence`: the page's body is the same one presence carries, so a
+ * page in presence gets only its attributes.
+ */
+export declare function renderOutcome(pages: Array<PageView | PageError>, tabs: TabInfo[], closed: string[], screenshot?: string, omitInPresence?: boolean): string;
+export interface PageReading {
+    url: string;
+    tab?: string;
+    representation: 'agent-view' | 'snapshot';
+    version?: string;
+    digest?: string;
+    /** The `id` the Agent View declares; `browser_invoke` takes it as well as `url`. */
+    id?: string;
+    incomplete?: string;
+    reason?: string;
+}
+/** Reading fields persisted in tool meta. `by` marks the result as this plugin's. */
+export declare function readingsOf(pages: Array<PageView | PageError>, action: string): {
+    by: 'mh-browser';
+    action: string;
+    pages: PageReading[];
+};
+//# sourceMappingURL=envelope.d.ts.map

package/lib/types/representation/agent-view.d.ts

@@ -0,0 +1,61 @@
+export declare const AGENT_VIEW_VERSION = "0.1";
+export declare const AGENT_VIEW_ACCEPT = "text/markdown; variant=agent-view";
+export interface AgentViewRequest {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: Record<string, string>;
+}
+export interface AgentViewAction {
+    description: string;
+    scope?: 'resource' | 'item';
+    request: AgentViewRequest;
+    inputSchema?: {
+        type: 'object';
+        properties: Record<string, {
+            type: string;
+            description?: string;
+        }>;
+        required?: string[];
+    };
+}
+export interface AgentViewLink {
+    rel: string;
+    href: string;
+    title?: string;
+}
+export interface AgentViewDoc {
+    agentView: string;
+    id: string;
+    version?: string;
+    links: AgentViewLink[];
+    requires: string[];
+    actions: Record<string, AgentViewAction>;
+    items: Array<Record<string, unknown>>;
+    body: string;
+    raw: string;
+}
+export type AgentViewRead = {
+    ok: true;
+    doc: AgentViewDoc;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * `variant=agent-view` is an Agent View. Another variant is not. Unlabelled
+ * `text/markdown` is one only when the body opens with front matter that names
+ * `agentView`.
+ */
+export declare function isAgentViewContentType(value: string | undefined, body?: string): boolean;
+export declare function readAgentView(text: string, pageUrl: string): AgentViewRead;
+/** The `id` a usable document declares, on the origin it was read from. */
+export declare function agentViewId(text: string, pageUrl: string): string | undefined;
+export declare function parseAgentView(text: string): AgentViewDoc;
+/** Why this document cannot be used. Absent when it can. */
+export declare function unreadableReason(doc: AgentViewDoc, pageUrl: string): string | undefined;
+/** SHA-256 of the document with the front matter `rendered` line removed. */
+export declare function representationDigest(raw: string): string;
+export declare function expandRequest(request: AgentViewRequest, values: Record<string, string>): AgentViewRequest;
+export declare function itemScalars(item: Record<string, unknown>): Record<string, string>;
+//# sourceMappingURL=agent-view.d.ts.map

package/lib/types/representation/agent-view.js

@@ -0,0 +1,279 @@
+import { createHash } from 'node:crypto';
+import { parse as parseYaml } from 'yaml';
+export const AGENT_VIEW_VERSION = '0.1';
+export const AGENT_VIEW_ACCEPT = 'text/markdown; variant=agent-view';
+const FENCE_OPEN = /```agent-view\b/g;
+const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'DELETE']);
+const PLACEHOLDER = /\{[^{}]+\}/;
+const YAML_OPTIONS = { maxAliasCount: 50 };
+/**
+ * `variant=agent-view` is an Agent View. Another variant is not. Unlabelled
+ * `text/markdown` is one only when the body opens with front matter that names
+ * `agentView`.
+ */
+export function isAgentViewContentType(value, body) {
+    if (!value)
+        return false;
+    const [type, ...params] = value.split(';').map((part) => part.trim().toLowerCase());
+    if (type !== 'text/markdown')
+        return false;
+    const variant = params.find((param) => param.startsWith('variant='));
+    if (variant !== undefined) {
+        return variant.slice('variant='.length).replace(/"/g, '') === 'agent-view';
+    }
+    return body !== undefined && hasAgentViewMarker(body);
+}
+export function readAgentView(text, pageUrl) {
+    let doc;
+    try {
+        doc = parseAgentView(text);
+    }
+    catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    const reason = unreadableReason(doc, pageUrl);
+    if (reason !== undefined)
+        return { ok: false, reason };
+    return { ok: true, doc };
+}
+/** The `id` a usable document declares, on the origin it was read from. */
+export function agentViewId(text, pageUrl) {
+    const read = readAgentView(text, pageUrl);
+    return read.ok ? read.doc.id : undefined;
+}
+export function parseAgentView(text) {
+    if (!opensFrontMatter(text)) {
+        throw new Error('front matter is missing');
+    }
+    const end = frontMatterEnd(text);
+    if (end < 0)
+        throw new Error('front matter is not closed');
+    const frontText = text.slice(4, end).trim();
+    const body = text.slice(end + 4).replace(/^[ \t]*\r?\n?/, '');
+    const front = parseYaml(frontText, YAML_OPTIONS);
+    if (front === null || typeof front !== 'object' || Array.isArray(front)) {
+        throw new Error('front matter must be a mapping');
+    }
+    const record = front;
+    const actions = normalizeActions(record.actions);
+    const items = [];
+    for (const match of body.matchAll(/```agent-view\s*\n([\s\S]*?)```/g)) {
+        const inner = (match[1] ?? '').trim();
+        const parsed = parseYaml(inner, YAML_OPTIONS);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            items.push(parsed);
+        }
+    }
+    const fenceCount = [...text.matchAll(FENCE_OPEN)].length;
+    if (fenceCount !== items.length) {
+        throw new Error('agent-view fence count does not match item blocks');
+    }
+    const doc = {
+        agentView: String(record.agentView ?? ''),
+        id: String(record.id ?? ''),
+        links: normalizeLinks(record.links),
+        requires: Array.isArray(record.requires) ? record.requires.map((item) => String(item)) : [],
+        actions,
+        items,
+        body,
+        raw: text,
+    };
+    if (record.version !== undefined)
+        doc.version = String(record.version);
+    return doc;
+}
+/** Why this document cannot be used. Absent when it can. */
+export function unreadableReason(doc, pageUrl) {
+    if (doc.agentView !== AGENT_VIEW_VERSION)
+        return 'agentView must be "0.1"';
+    let page;
+    try {
+        page = new URL(pageUrl);
+    }
+    catch {
+        return 'page address is not a URL';
+    }
+    if (!isAbsoluteHttp(doc.id))
+        return `id must be an absolute http(s) URL: ${doc.id}`;
+    if (new URL(doc.id).origin !== page.origin)
+        return 'id is on another origin';
+    for (const [name, action] of Object.entries(doc.actions)) {
+        const method = action.request.method.toUpperCase();
+        if (!HTTP_METHODS.has(method))
+            return `action ${name} has method ${method || 'missing'}`;
+        if ((action.scope ?? 'resource') === 'resource' && requestHasPlaceholder(action.request)) {
+            return `action ${name} request has a placeholder`;
+        }
+    }
+    const itemActions = Object.entries(doc.actions).filter(([, action]) => (action.scope ?? 'resource') === 'item');
+    for (const item of doc.items) {
+        if (Number(item.status) === 410)
+            continue;
+        for (const [name] of itemActions) {
+            const count = answerCount(item[name]);
+            if (count === 0)
+                return `item ${String(item.id)} has no answer for ${name}`;
+            if (count !== 1)
+                return `item ${String(item.id)} has more than one answer for ${name}`;
+        }
+    }
+    return undefined;
+}
+/** SHA-256 of the document with the front matter `rendered` line removed. */
+export function representationDigest(raw) {
+    return createHash('sha256').update(stripRendered(raw)).digest('hex');
+}
+export function expandRequest(request, values) {
+    return {
+        method: request.method,
+        url: expandPlaceholders(request.url, values),
+        ...(request.headers
+            ? {
+                headers: Object.fromEntries(Object.entries(request.headers).map(([name, value]) => [
+                    name,
+                    expandPlaceholders(value, values),
+                ])),
+            }
+            : {}),
+        ...(request.body
+            ? {
+                body: Object.fromEntries(Object.entries(request.body).map(([name, value]) => [
+                    name,
+                    expandPlaceholders(value, values),
+                ])),
+            }
+            : {}),
+    };
+}
+export function itemScalars(item) {
+    const out = {};
+    for (const [key, value] of Object.entries(item)) {
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            out[key] = String(value);
+        }
+    }
+    return out;
+}
+function expandPlaceholders(template, values) {
+    return template.replace(/\{([^{}]+)\}/g, (_, key) => {
+        const value = values[key];
+        if (value === undefined || value === '')
+            throw new Error(`missing value for {${key}}`);
+        return value;
+    });
+}
+function opensFrontMatter(text) {
+    return /^---[ \t]*\r?\n/.test(text);
+}
+/** Index of the newline before the closing `---` line; a line such as `----` does not close it. */
+function frontMatterEnd(text) {
+    const close = /\n---[ \t]*(?:\r?\n|$)/g;
+    close.lastIndex = 3;
+    return close.exec(text)?.index ?? -1;
+}
+function hasAgentViewMarker(body) {
+    if (!opensFrontMatter(body))
+        return false;
+    const end = frontMatterEnd(body);
+    if (end < 0)
+        return false;
+    return /^agentView:/m.test(body.slice(0, end));
+}
+function stripRendered(raw) {
+    if (!opensFrontMatter(raw))
+        return raw;
+    const end = frontMatterEnd(raw);
+    if (end < 0)
+        return raw;
+    const front = raw
+        .slice(0, end)
+        .split('\n')
+        .filter((line) => !line.startsWith('rendered:'))
+        .join('\n');
+    return front + raw.slice(end);
+}
+function requestHasPlaceholder(request) {
+    if (PLACEHOLDER.test(request.url))
+        return true;
+    for (const value of Object.values(request.headers ?? {})) {
+        if (PLACEHOLDER.test(value))
+            return true;
+    }
+    for (const value of Object.values(request.body ?? {})) {
+        if (PLACEHOLDER.test(value))
+            return true;
+    }
+    return false;
+}
+function answerCount(value) {
+    if (value === true || value === 'yes')
+        return 1;
+    if (Array.isArray(value))
+        return value.length;
+    if (value && typeof value === 'object' && 'no' in value)
+        return Object.keys(value).length;
+    return 0;
+}
+function normalizeLinks(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const row = item;
+        if (typeof row.rel === 'string' && typeof row.href === 'string') {
+            out.push({
+                rel: row.rel,
+                href: row.href,
+                ...(typeof row.title === 'string' ? { title: row.title } : {}),
+            });
+        }
+    }
+    return out;
+}
+function normalizeActions(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const out = {};
+    for (const [name, raw] of Object.entries(value)) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const row = raw;
+        const requestRaw = (row.request ?? {});
+        const request = {
+            method: String(requestRaw.method ?? '').toUpperCase(),
+            url: String(requestRaw.url ?? ''),
+        };
+        if (requestRaw.headers && typeof requestRaw.headers === 'object') {
+            request.headers = Object.fromEntries(Object.entries(requestRaw.headers).map(([key, item]) => [
+                key,
+                String(item),
+            ]));
+        }
+        if (requestRaw.body && typeof requestRaw.body === 'object' && !Array.isArray(requestRaw.body)) {
+            request.body = Object.fromEntries(Object.entries(requestRaw.body).map(([key, item]) => [
+                key,
+                String(item),
+            ]));
+        }
+        const action = { description: String(row.description ?? name), request };
+        if (row.scope === 'item' || row.scope === 'resource')
+            action.scope = row.scope;
+        if (row.inputSchema && typeof row.inputSchema === 'object') {
+            action.inputSchema = row.inputSchema;
+        }
+        out[name] = action;
+    }
+    return out;
+}
+function isAbsoluteHttp(uri) {
+    try {
+        const parsed = new URL(uri);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=agent-view.js.map

package/lib/types/representation/discovery.d.ts

@@ -0,0 +1,23 @@
+export interface DeclaredLink {
+    rel: string;
+    href: string;
+    title?: string;
+}
+export type AgentViewDeclaration = {
+    kind: 'href';
+    href: string;
+    title?: string;
+} | {
+    kind: 'cross-origin';
+    href: string;
+};
+/**
+ * The first `rel=agent-view` wins. Header links come before links in HTML.
+ * A cross-origin href is not fetched and does not fall through to a later one.
+ */
+export declare function chooseAgentView(pageUrl: string, header: string | undefined, dom: DeclaredLink[]): AgentViewDeclaration | undefined;
+export declare function samePage(left: string, right: string): boolean;
+/** RFC 8288, including comma-separated values and `title*` (RFC 8187). */
+export declare function parseLinkHeader(header: string | undefined, base: string): DeclaredLink[];
+export declare function linksInHtml(html: string, base: string): DeclaredLink[];
+//# sourceMappingURL=discovery.d.ts.map

package/lib/types/representation/read.d.ts

@@ -0,0 +1,45 @@
+import type { FetchResponse } from '../types.ts';
+import { type DeclaredLink } from './discovery.ts';
+export interface Shown {
+    pageUrl: string;
+    fragment?: string;
+    href?: string;
+    etag?: string;
+    raw?: string;
+    version?: string;
+    digest: string;
+    kind: 'agent-view' | 'snapshot';
+    text: string;
+    snapshot: string;
+    agentViewError?: string;
+    status?: number;
+    mediaType?: string;
+    /** Response text of a textual non-HTML document navigation, shown in place of the snapshot. */
+    body?: string;
+}
+export interface MainDocument {
+    status: number;
+    mediaType?: string;
+    finalUrl: string;
+    link?: string;
+    body: string;
+}
+type FetchText = (url: string, accept: string, ifNoneMatch?: string) => Promise<FetchResponse>;
+/**
+ * Decide what a tab is showing. A document navigation (`main` given) is
+ * discovered again from its response. A relocated page is read from a fresh
+ * HTML response, not from the live DOM. A conditional read keeps the
+ * previous document when the server answers 304.
+ */
+export declare function loadShown(input: {
+    pageUrl: string;
+    fragment?: string;
+    snapshot: string;
+    main?: MainDocument;
+    domLinks?: DeclaredLink[];
+    previous?: Shown;
+    relocate: boolean;
+    fetch: FetchText;
+}): Promise<Shown>;
+export {};
+//# sourceMappingURL=read.d.ts.map

package/lib/types/service/actions.d.ts

@@ -0,0 +1,7 @@
+import type { Page } from 'playwright';
+import type { ActAction } from '../types.ts';
+/** Run one snapshot action. Dialog, wait, and look are handled by the service. */
+export declare function runAction(page: Page, action: Exclude<ActAction, {
+    kind: 'dialog' | 'wait' | 'look';
+}>, signal: AbortSignal | undefined): Promise<boolean>;
+//# sourceMappingURL=actions.d.ts.map

package/lib/types/service/browser.d.ts

@@ -0,0 +1,16 @@
+import type { BrowserContext } from 'playwright';
+import type { BrowserName } from '../types.ts';
+export interface LaunchOptions {
+    browser: BrowserName;
+    headless: boolean;
+    profileDir: string;
+    /** Test hook: point at a missing executable to exercise the not-found message. */
+    executablePath?: string;
+}
+/**
+ * One persistent context for the whole process. `chromium` omits `channel`
+ * so Playwright uses its own browser; the others use a local install.
+ * A missing browser is reported and not downloaded.
+ */
+export declare function launchBrowser(options: LaunchOptions): Promise<BrowserContext>;
+//# sourceMappingURL=browser.d.ts.map

package/lib/types/service/control.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Who holds the browser for one session. Person input outside a service
+ * dispatch moves it to the person and aborts the action still waiting.
+ * A model handover keeps the hold until hand-back or a stopped call.
+ */
+export declare class Control {
+    private readonly who;
+    private readonly holding;
+    private readonly inflight;
+    private readonly operations;
+    private readonly tabs;
+    private readonly since;
+    private readonly named;
+    of(owner: string): 'model' | 'person';
+    /** Abort this session's waiting action when the caller aborts or the person takes over. */
+    link(owner: string, caller: AbortSignal | undefined): {
+        signal: AbortSignal;
+        release(): void;
+    };
+    /**
+     * One person action on a session tab. The person's own window is ignored.
+     * Events that arrive while the service is dispatching to this page never
+     * reach here.
+     */
+    note(owner: string, tab: string | undefined): void;
+    /** A handover is waiting for the person to hand the browser back. */
+    holds(owner: string): boolean;
+    /** The tab the handover named, if it named one. */
+    namedTab(owner: string): string | undefined;
+    /** The model hands the browser to the person and waits for the card. */
+    handover(owner: string, tab: string | undefined): void;
+    /** The person is done. The caller decides whether a step is still open. */
+    finish(owner: string): Taken | undefined;
+    /** Stop a handover the model did not finish. Control returns to the model. */
+    releaseIfHeld(owner: string): boolean;
+    /** Between turns, the person's next message is the hand-back. A waiting card is not. */
+    takePerson(owner: string): Taken | undefined;
+    /** The Session is gone. Its in-flight calls are aborted. */
+    forget(owner: string): void;
+    private clear;
+}
+export interface Taken {
+    operations: number;
+    tabs: string[];
+    from: string;
+    to: string;
+    tab?: string;
+}
+//# sourceMappingURL=control.d.ts.map