@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/agentSession/engineSessionBackgroundStop.js

@@ -1,5 +1,5 @@
 import { engineCapNestedValue } from '../engineCapsCache.js';
-import { isStatusDerivedCoarseCode } from '../engineErrorCodes.js';
+import { LIMIT_RATE_EXCEEDED, isStatusDerivedCoarseCode } from '../engineErrorCodes.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
 import { hostLog } from '../host.js';
@@ -135,7 +135,7 @@ function refusedWhyOf(rawCode, status) {
             return 'session_not_found';
         if (code === 'not_found.route')
             return 'route_absent';
-        if (code === 'limit.rate_exceeded')
+        if (code === LIMIT_RATE_EXCEEDED)
             return 'rate_limited';
         if (code.startsWith('auth.'))
             return 'not_permitted';

package/dist/attachmentRoute.d.ts

@@ -0,0 +1,20 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const TOOLS_LOCATIONS: readonly ["this-machine", "elsewhere", "unconfirmed"];
+export type ToolsLocation = (typeof TOOLS_LOCATIONS)[number];
+export declare const ATTACHMENT_ROUTE_LEGS: readonly ["at_mention", "edited_file", "paste", "ide_selection"];
+export type AttachmentRouteLeg = (typeof ATTACHMENT_ROUTE_LEGS)[number];
+export interface AttachmentRouteFacts {
+    readonly leg: AttachmentRouteLeg;
+    readonly toolsLocation: ToolsLocation;
+}
+export type AttachmentWithheldReason = 'tools-elsewhere' | 'tools-location-unconfirmed';
+export type AttachmentRoute = {
+    readonly route: 'attach_content';
+    readonly localCopy: boolean;
+} | {
+    readonly route: 'withhold';
+    readonly reason: AttachmentWithheldReason;
+};
+export declare function attachmentRouteOf(facts: AttachmentRouteFacts): AttachmentRoute;
+export declare function attachmentWithheldReasonText(reason: AttachmentWithheldReason, lang?: UiLanguage): string;
+export declare function attachmentLocalCopyNote(): string;

package/dist/attachmentRoute.js

@@ -0,0 +1,39 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { readOwnDataNonEmptyString } from './ownKey.js';
+export const TOOLS_LOCATIONS = Object.freeze(['this-machine', 'elsewhere', 'unconfirmed']);
+export const ATTACHMENT_ROUTE_LEGS = Object.freeze(['at_mention', 'edited_file', 'paste', 'ide_selection']);
+const _withheldReasonsPinned = true;
+void _withheldReasonsPinned;
+const ATTACH = Object.freeze({ route: 'attach_content', localCopy: false });
+const ATTACH_LOCAL_COPY = Object.freeze({ route: 'attach_content', localCopy: true });
+const WITHHOLD_ELSEWHERE = Object.freeze({ route: 'withhold', reason: 'tools-elsewhere' });
+const WITHHOLD_UNCONFIRMED = Object.freeze({ route: 'withhold', reason: 'tools-location-unconfirmed' });
+const SNAPSHOT_LEGS = new Set(['paste', 'ide_selection']);
+function closedWord(facts, key, words) {
+    try {
+        if (typeof facts !== 'object' || facts === null)
+            return undefined;
+        const raw = readOwnDataNonEmptyString(facts, key);
+        return raw !== undefined && words.includes(raw) ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function attachmentRouteOf(facts) {
+    const where = closedWord(facts, 'toolsLocation', TOOLS_LOCATIONS);
+    if (where === 'this-machine')
+        return ATTACH;
+    const leg = closedWord(facts, 'leg', ATTACHMENT_ROUTE_LEGS);
+    if (leg !== undefined && SNAPSHOT_LEGS.has(leg))
+        return ATTACH_LOCAL_COPY;
+    return where === 'elsewhere' ? WITHHOLD_ELSEWHERE : WITHHOLD_UNCONFIRMED;
+}
+export function attachmentWithheldReasonText(reason, lang) {
+    return reason === 'tools-elsewhere'
+        ? renderMessage(msg('attachments.withheld.toolsElsewhere.row'), lang)
+        : renderMessage(msg('attachments.withheld.toolsLocationUnconfirmed.row'), lang);
+}
+export function attachmentLocalCopyNote() {
+    return renderMessage(msg('attachments.localCopy.model'));
+}

package/dist/attachmentsWireCaps.js

@@ -25,7 +25,7 @@ const OPT_IN_KEYS = [
     'mcpInstructions',
 ];
 const DEFAULT_ON_ONLY_KEYS = ['agentListing', 'skillsListing'];
-const PRODUCT_DEFAULT_KEYS = ['backgroundTasks', 'toolsDelta', 'todoReminder'];
+const PRODUCT_DEFAULT_KEYS = ['backgroundTasks', 'toolsDelta', 'todoReminder', 'mcpInstructions'];
 function productDefaultAttachments() {
     const out = {};
     for (const k of PRODUCT_DEFAULT_KEYS)

package/dist/builtinOutputStyles.d.ts

@@ -0,0 +1,12 @@
+export type BuiltinOutputStyleName = 'default' | 'Proactive' | 'Concise' | 'Explanatory' | 'Learning';
+export interface BuiltinOutputStyle {
+    readonly name: string;
+    readonly source: 'built-in';
+    readonly description: string;
+    readonly keepCodingInstructions: true;
+    readonly prompt: string;
+    readonly turnReminder?: string;
+    readonly waitingTurnReminder?: string;
+}
+export declare const BUILTIN_OUTPUT_STYLES: Readonly<Record<BuiltinOutputStyleName, BuiltinOutputStyle | null>>;
+export declare function builtinOutputStyleOf(name: string): BuiltinOutputStyle | null | undefined;

package/dist/builtinOutputStyles.js

@@ -0,0 +1,147 @@
+const INSIGHTS_SECTION = `
+## Insights
+In order to encourage learning, before and after writing code, always provide brief educational explanations about implementation choices using (with backticks):
+"\`★ Insight ─────────────────────────────────────\`
+[2-3 key educational points]
+\`─────────────────────────────────────────────────\`"
+
+These insights should be included in the conversation, not in the codebase. You should generally focus on interesting insights that are specific to the codebase or the code you just wrote, rather than general programming concepts.`;
+const PROACTIVE_SECTION = `The user chose continuous, autonomous execution. You should:
+
+1. **Execute immediately** — Start implementing right away. Make reasonable assumptions and proceed on low-risk work.
+2. **Minimize interruptions** — Prefer making reasonable assumptions over asking questions for routine decisions.
+3. **Prefer action over planning** — Do not enter plan mode unless the user explicitly asks. When in doubt, start coding.
+4. **Expect course corrections** — The user may provide suggestions or course corrections at any point; treat those as normal input.
+5. **Do not take overly destructive actions** — This is not a license to destroy. Anything that deletes data or modifies shared or production systems still needs explicit user confirmation. If you reach such a decision point, ask and wait, or course correct to a safer method instead.
+6. **Avoid data exfiltration** — Post even routine messages to chat platforms or work tickets only if the user has directed you to. You must not share secrets (e.g. credentials, internal documentation) unless the user has explicitly authorized both that specific secret and its destination.`;
+const CONCISE_SECTION = `The user chose brevity over narration. You should:
+
+1. **Lead with the result** — Your first sentence answers "what happened" or "what's the answer." No preamble ("Let me...", "Now I'll...") and no closing recap of what you already said.
+2. **Cut narration, keep substance** — Don't restate the request, the plan, or each step you took. Report outcomes, decisions, and anything the user must act on.
+3. **Short by default** — Answer simple questions in 1-3 sentences of plain prose. Use headers, tables, and bullet lists only when they carry real structure, never as decoration.
+4. **State things plainly** — Skip hedging boilerplate. Mention a caveat only when it changes what the user should do next.
+5. **Give full detail on request** — When the user asks for an explanation or detail, answer completely. Conciseness never means withholding requested information.
+6. **Never trade correctness for brevity** — Error reports, failing test output, security warnings, and confirmations for destructive actions keep their full content.
+
+Where these rules conflict with more general communication or formatting guidance elsewhere in your instructions, these rules win.`;
+export const BUILTIN_OUTPUT_STYLES = Object.freeze({
+    default: null,
+    Proactive: Object.freeze({
+        name: 'Proactive',
+        source: 'built-in',
+        description: "Sema executes immediately, minimizes interruptions, and prefers action over planning",
+        keepCodingInstructions: true,
+        prompt: `You are an interactive CLI tool that helps users with software engineering tasks. You should work proactively and autonomously, executing immediately and minimizing interruptions.
+
+# Proactive Style Active
+${PROACTIVE_SECTION}`,
+        turnReminder: "Execute autonomously, minimize interruptions, prefer action over planning.",
+        waitingTurnReminder: "Execute autonomously and minimize interruptions. If the only work left is waiting for a background task or monitor you started, end your turn now: you will be notified when it finishes or fires. Do not poll, sleep, or re-read its output while you wait.",
+    }),
+    Concise: Object.freeze({
+        name: 'Concise',
+        source: 'built-in',
+        description: "Sema responds tersely, leading with results and skipping preamble and narration",
+        keepCodingInstructions: true,
+        prompt: `You are an interactive CLI tool that helps users with software engineering tasks. Keep your responses short and direct while doing the work just as thoroughly.
+
+# Concise Style Active
+${CONCISE_SECTION}`,
+        turnReminder: "Be concise: lead with the result, skip preamble and narration, keep only what the user needs.",
+    }),
+    Explanatory: Object.freeze({
+        name: 'Explanatory',
+        source: 'built-in',
+        description: "Sema explains its implementation choices and codebase patterns",
+        keepCodingInstructions: true,
+        prompt: `You are an interactive CLI tool that helps users with software engineering tasks. In addition to software engineering tasks, you should provide educational insights about the codebase along the way.
+
+You should be clear and educational, providing helpful explanations while remaining focused on the task. Balance educational content with task completion. When providing insights, you may exceed typical length constraints, but remain focused and relevant.
+
+# Explanatory Style Active
+${INSIGHTS_SECTION}`,
+    }),
+    Learning: Object.freeze({
+        name: 'Learning',
+        source: 'built-in',
+        description: "Sema pauses and asks you to write small pieces of code for hands-on practice",
+        keepCodingInstructions: true,
+        prompt: `You are an interactive CLI tool that helps users with software engineering tasks. In addition to software engineering tasks, you should help users learn more about the codebase through hands-on practice and educational insights.
+
+You should be collaborative and encouraging. Balance task completion with learning by requesting user input for meaningful design decisions while handling routine implementation yourself.   
+
+# Learning Style Active
+## Requesting Human Contributions
+In order to encourage learning, ask the human to contribute 2-10 line code pieces when generating 20+ lines involving:
+- Design decisions (error handling, data structures)
+- Business logic with multiple valid approaches  
+- Key algorithms or interface definitions
+
+**TodoList Integration**: If using a TodoList for the overall task, include a specific todo item like "Request human input on [specific decision]" when planning to request human input. This ensures proper task tracking. Note: TodoList is not required for all tasks.
+
+Example TodoList flow:
+   ✓ "Set up component structure with placeholder for logic"
+   ✓ "Request human collaboration on decision logic implementation"
+   ✓ "Integrate contribution and complete feature"
+
+### Request Format
+\`\`\`
+● **Learn by Doing**
+**Context:** [what's built and why this decision matters]
+**Your Task:** [specific function/section in file, mention file and TODO(human) but do not include line numbers]
+**Guidance:** [trade-offs and constraints to consider]
+\`\`\`
+
+### Key Guidelines
+- Frame contributions as valuable design decisions, not busy work
+- You must first add a TODO(human) section into the codebase with your editing tools before making the Learn by Doing request      
+- Make sure there is one and only one TODO(human) section in the code
+- Don't take any action or output anything after the Learn by Doing request. Wait for human implementation before proceeding.
+
+### Example Requests
+
+**Whole Function Example:**
+\`\`\`
+● **Learn by Doing**
+
+**Context:** I've set up the hint feature UI with a button that triggers the hint system. The infrastructure is ready: when clicked, it calls selectHintCell() to determine which cell to hint, then highlights that cell with a yellow background and shows possible values. The hint system needs to decide which empty cell would be most helpful to reveal to the user.
+
+**Your Task:** In sudoku.js, implement the selectHintCell(board) function. Look for TODO(human). This function should analyze the board and return {row, col} for the best cell to hint, or null if the puzzle is complete.
+
+**Guidance:** Consider multiple strategies: prioritize cells with only one possible value (naked singles), or cells that appear in rows/columns/boxes with many filled cells. You could also consider a balanced approach that helps without making it too easy. The board parameter is a 9x9 array where 0 represents empty cells.
+\`\`\`
+
+**Partial Function Example:**
+\`\`\`
+● **Learn by Doing**
+
+**Context:** I've built a file upload component that validates files before accepting them. The main validation logic is complete, but it needs specific handling for different file type categories in the switch statement.
+
+**Your Task:** In upload.js, inside the validateFile() function's switch statement, implement the 'case "document":' branch. Look for TODO(human). This should validate document files (pdf, doc, docx).
+
+**Guidance:** Consider checking file size limits (maybe 10MB for documents?), validating the file extension matches the MIME type, and returning {valid: boolean, error?: string}. The file object has properties: name, size, type.
+\`\`\`
+
+**Debugging Example:**
+\`\`\`
+● **Learn by Doing**
+
+**Context:** The user reported that number inputs aren't working correctly in the calculator. I've identified the handleInput() function as the likely source, but need to understand what values are being processed.
+
+**Your Task:** In calculator.js, inside the handleInput() function, add 2-3 console.log statements after the TODO(human) comment to help debug why number inputs fail.
+
+**Guidance:** Consider logging: the raw input value, the parsed result, and any validation state. This will help us understand where the conversion breaks.
+\`\`\`
+
+### After Contributions
+Share one insight connecting their code to broader patterns or system effects. Avoid praise or repetition.
+
+## Insights
+${INSIGHTS_SECTION}`,
+    }),
+});
+export function builtinOutputStyleOf(name) {
+    if (typeof name !== 'string' || !Object.hasOwn(BUILTIN_OUTPUT_STYLES, name))
+        return undefined;
+    return BUILTIN_OUTPUT_STYLES[name];
+}

package/dist/checkpointRowVerdict.d.ts

@@ -32,3 +32,6 @@ export type CheckpointDeadlineState = 'armed' | 'none' | 'unknown';
 export declare function checkpointDeadlineStateOf(row: object | null | undefined): CheckpointDeadlineState;
 export declare function unboundWayOutContent(state: CheckpointDeadlineState, lang?: UiLanguage | (string & {})): string;
 export declare function rowBarWayOutContent(bar: CheckpointRowBar, state: CheckpointDeadlineState, lang?: UiLanguage | (string & {})): string;
+export type DecisionRefusalWayOut = 'cancel_run' | 'newer_worker';
+export declare function isDecisionRefusalWayOut(v: {} | null | undefined): v is DecisionRefusalWayOut;
+export declare function decisionRefusalWayOutContent(wayOut: DecisionRefusalWayOut | (string & {}), lang?: UiLanguage | (string & {})): string | undefined;

package/dist/checkpointRowVerdict.js

@@ -121,6 +121,19 @@ export function unboundWayOutContent(state, lang) {
 }
 export function rowBarWayOutContent(bar, state, lang) {
     if (bar.kind === 'lacking')
-        return renderMessage(msg('approval.rowUnresumable.lackingWayOut'), isUiLanguage(lang) ? lang : undefined);
+        return lackingWayOutContent(lang);
     return unboundWayOutContent(state, lang);
 }
+function lackingWayOutContent(lang) {
+    return renderMessage(msg('approval.rowUnresumable.lackingWayOut'), isUiLanguage(lang) ? lang : undefined);
+}
+const WAY_OUT_WORDS = Object.freeze({ cancel_run: true, newer_worker: true });
+const DECISION_REFUSAL_WAY_OUTS = Object.freeze(Object.keys(WAY_OUT_WORDS));
+export function isDecisionRefusalWayOut(v) {
+    return typeof v === 'string' && DECISION_REFUSAL_WAY_OUTS.includes(v);
+}
+export function decisionRefusalWayOutContent(wayOut, lang) {
+    if (!isDecisionRefusalWayOut(wayOut))
+        return undefined;
+    return wayOut === 'newer_worker' ? lackingWayOutContent(lang) : unboundWayOutContent('unknown', lang);
+}

package/dist/compactionStatus.d.ts

@@ -1,6 +1,8 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface CompactionStatusReading {
     readonly compacting: boolean;
     readonly since?: number;
+    readonly openTriggers?: readonly string[];
 }
 export type CompactionStatusChange = {
     readonly kind: 'opened';
@@ -32,3 +34,10 @@ export interface PrintCompactionStatusCtx {
 }
 export declare function createCompactionStatusTracker(): CompactionStatusTracker;
 export declare function compactionStatusFrameOf(change: CompactionStatusChange | null | undefined, ctx: PrintCompactionStatusCtx): PrintCompactionStatusFrame | null;
+export type CompactionStopVerdict = {
+    readonly kind: 'compaction_canceled';
+} | {
+    readonly kind: 'interrupted';
+};
+export declare function compactionStopVerdict(reading: CompactionStatusReading | null | undefined): CompactionStopVerdict;
+export declare function compactionCanceledSentence(lang?: UiLanguage): string;

package/dist/compactionStatus.js

@@ -1,4 +1,5 @@
-import { readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { appendOwnElement, readOwnDataValue } from './ownKey.js';
 import { snapshotIsSubFlow, snapshotSegmentIdentity } from './adapter/types.js';
 const _printStatusFramePins = [true, true];
 void _printStatusFramePins;
@@ -20,9 +21,10 @@ function armLane(m) {
 function openOf(pass, lane, startedAt, trigger) {
     if (lane === 'unreadable')
         return null;
-    if (nonEmpty(trigger) === undefined)
+    const t = nonEmpty(trigger);
+    if (t === undefined)
         return null;
-    return { kind: 'open', pass, main: lane === 'main', ...(typeof startedAt === 'number' && Number.isFinite(startedAt) ? { startedAt } : {}) };
+    return { kind: 'open', pass, main: lane === 'main', trigger: t, ...(typeof startedAt === 'number' && Number.isFinite(startedAt) ? { startedAt } : {}) };
 }
 function parse(input) {
     const plane = own(input, 'plane');
@@ -101,7 +103,11 @@ export function createCompactionStatusTracker() {
         if (mainOpen() === 0)
             return { compacting: false };
         const s = since();
-        return { compacting: true, ...(s !== undefined ? { since: s } : {}) };
+        const triggers = [];
+        for (const e of open.values())
+            if (e.main)
+                appendOwnElement(triggers, e.trigger);
+        return { compacting: true, ...(s !== undefined ? { since: s } : {}), openTriggers: Object.freeze(triggers) };
     };
     return {
         take(input) {
@@ -115,7 +121,7 @@ export function createCompactionStatusTracker() {
                     if (open.has(p.pass) || closed.has(p.pass))
                         return null;
                     const before = mainOpen();
-                    open.set(p.pass, { main: p.main === true, ...(p.startedAt !== undefined ? { startedAt: p.startedAt } : {}) });
+                    open.set(p.pass, { main: p.main === true, trigger: p.trigger ?? '', ...(p.startedAt !== undefined ? { startedAt: p.startedAt } : {}) });
                     if (before === 0 && p.main === true) {
                         const s = since();
                         return { kind: 'opened', pass: p.pass, ...(s !== undefined ? { since: s } : {}) };
@@ -194,3 +200,21 @@ export function compactionStatusFrameOf(change, ctx) {
         return null;
     }
 }
+const STOP_CANCELED = Object.freeze({ kind: 'compaction_canceled' });
+const STOP_INTERRUPTED = Object.freeze({ kind: 'interrupted' });
+export function compactionStopVerdict(reading) {
+    try {
+        if (own(reading, 'compacting') !== true)
+            return STOP_INTERRUPTED;
+        const triggers = own(reading, 'openTriggers');
+        if (!Array.isArray(triggers) || own(triggers, 'length') !== 1)
+            return STOP_INTERRUPTED;
+        return own(triggers, '0') === 'manual' ? STOP_CANCELED : STOP_INTERRUPTED;
+    }
+    catch {
+        return STOP_INTERRUPTED;
+    }
+}
+export function compactionCanceledSentence(lang) {
+    return renderMessage(msg('session.compaction.canceled'), lang);
+}

package/dist/consoleCaPin.d.ts

@@ -0,0 +1,136 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const CA_PIN_LIMITS: Readonly<{
+    addressMaxChars: 2048;
+    authorityMaxChars: 300;
+    fingerprintsMax: 16;
+    fingerprintMaxChars: 128;
+    bodyMaxBytes: 1048576;
+    servedMax: 16;
+    pemMaxBytes: 16384;
+    budgetMs: 120000;
+    roundMs: 10000;
+    retriesMax: 3;
+    waitCapMs: 60000;
+    jitterMaxMs: 2000;
+}>;
+export type CenterAddressSeat = 'invite' | 'address';
+export type CenterAddressRefusal = 'bad_input' | 'empty' | 'too_long' | 'unsafe_character' | 'scheme' | 'userinfo' | 'percent_in_host' | 'unparseable' | 'query' | 'fragment' | 'trailing_dot' | 'ip_not_canonical' | 'plaintext_remote' | 'path' | 'fingerprint' | 'too_many_fingerprints';
+export type CenterAddressReading = {
+    readonly ok: true;
+    readonly seat: CenterAddressSeat;
+    readonly origin: string;
+    readonly centerKey: string;
+    readonly fingerprints: readonly string[];
+} | {
+    readonly ok: false;
+    readonly reason: CenterAddressRefusal;
+};
+export type TrustOriginRefusal = 'empty' | 'too_long' | 'unsafe_character' | 'scheme' | 'userinfo' | 'percent_in_host' | 'unparseable' | 'trailing_dot' | 'ip_not_canonical';
+export type TrustOriginReading = {
+    readonly ok: true;
+    readonly origin: string;
+} | {
+    readonly ok: false;
+    readonly reason: TrustOriginRefusal;
+};
+export declare function readCenterAddress(raw: string | null | undefined, seat: CenterAddressSeat): CenterAddressReading;
+export declare function trustOriginOf(url: string | null | undefined): TrustOriginReading;
+export type CaFingerprintsRefusal = 'bad_input' | 'prefix' | 'fingerprint' | 'too_many_fingerprints';
+export type CaFingerprintsReading = {
+    readonly ok: true;
+    readonly fingerprints: readonly string[];
+} | {
+    readonly ok: false;
+    readonly reason: CaFingerprintsRefusal;
+    readonly index?: number;
+};
+export declare function caFingerprintsOf(texts: readonly string[] | null | undefined): CaFingerprintsReading;
+export declare function caFingerprintOfDer(der: Uint8Array): string;
+export declare function caFingerprintDisplay(fp: string | null | undefined): string | undefined;
+export type CaCertificateParser = (der: Uint8Array) => CaCertificateFacts | null | undefined;
+export interface CaCertificateFacts {
+    readonly raw: Uint8Array;
+    readonly subject: string;
+    readonly notAfter: string;
+    readonly selfSigned: boolean;
+}
+export interface CaBootstrapRequest {
+    readonly named?: readonly string[];
+    readonly parseCertificate?: CaCertificateParser;
+}
+export interface CaServedCertificate {
+    readonly fingerprint: string;
+    readonly pem: string;
+    readonly selfSigned: boolean;
+    readonly subject?: string;
+    readonly notAfter?: string;
+}
+export type CaBootstrapRefusal = 'bad_input' | 'parser_unavailable' | 'body_too_large' | 'body_not_json' | 'body_shape' | 'served_count' | 'certificate_too_large' | 'certificate_not_canonical' | 'certificate_unparseable' | 'served_duplicate' | 'named_not_served' | 'anchor_not_self_signed' | 'unconfigured_with_fingerprints';
+export type CaBootstrapReading = {
+    readonly kind: 'unconfigured';
+} | {
+    readonly kind: 'served';
+    readonly certificates: readonly CaServedCertificate[];
+    readonly anchors: readonly CaServedCertificate[];
+} | {
+    readonly kind: 'refused';
+    readonly reason: CaBootstrapRefusal;
+    readonly index?: number;
+};
+export declare function readCaBootstrapBody(body: Uint8Array, request: CaBootstrapRequest): CaBootstrapReading;
+export type CaBootstrapPhase = 'idle' | 'in-flight' | 'reading' | 'waiting' | 'stopped';
+export type CaBootstrapStopReason = 'bad_input' | 'cancelled' | 'timed_out' | 'transport_failed' | 'content_type' | 'ca_unavailable' | 'endpoint_missing' | 'unexpected_status' | 'retry_after_unusable' | 'retry_after_too_long' | 'retries_exhausted' | 'budget_exhausted';
+export interface CaBootstrapStop {
+    readonly action: 'stop';
+    readonly reason: CaBootstrapStopReason;
+    readonly status?: number;
+    readonly retryAfterSec?: number;
+    readonly remainingSec?: number;
+}
+export type CaBootstrapDecision = {
+    readonly action: 'attempt';
+    readonly timeoutMs: number;
+} | {
+    readonly action: 'wait';
+    readonly afterMs: number;
+    readonly retryAfterSec: number;
+} | {
+    readonly action: 'read-body';
+} | {
+    readonly action: 'proceed';
+} | CaBootstrapStop;
+export interface CaBootstrapState {
+    readonly phase: CaBootstrapPhase;
+    readonly deadlineMs: number;
+    readonly lastNowMs: number;
+    readonly attempts: number;
+    readonly roundDeadlineMs?: number;
+    readonly notBeforeMs?: number;
+    readonly retryAfterSec?: number;
+    readonly stop?: CaBootstrapStop;
+}
+export type CaBootstrapEvent = {
+    readonly type: 'begin';
+} | {
+    readonly type: 'response';
+    readonly status: number;
+    readonly contentType?: string;
+    readonly retryAfter?: string;
+    readonly jitter?: number;
+} | {
+    readonly type: 'checkpoint';
+} | {
+    readonly type: 'timed-out';
+} | {
+    readonly type: 'failed';
+} | {
+    readonly type: 'cancelled';
+};
+export interface CaBootstrapStep {
+    readonly state: CaBootstrapState;
+    readonly decision: CaBootstrapDecision;
+}
+export declare function caBootstrapOpen(nowMs: number): CaBootstrapState;
+export declare function caBootstrapStep(state: CaBootstrapState, event: CaBootstrapEvent, nowMs: number): CaBootstrapStep;
+export type CaPinRefusal = CenterAddressRefusal | TrustOriginRefusal | CaFingerprintsRefusal | CaBootstrapRefusal | CaBootstrapStopReason;
+export declare function caPinRefusalSentence(reason: CaPinRefusal | (string & {}), lang?: UiLanguage): string;