@theoremjs/react 0.0.0-stage → 0.3.1

package/client/attachment-hover-preview.d.ts

@@ -0,0 +1,11 @@
+/** Hover-card geometry for composer attachment pills (model-sculpt agent_chat parity). */
+export type AttachPreviewStyle = {
+    left: number;
+    top?: number;
+    bottom?: number;
+};
+export declare function formatAttachmentSize(bytes?: number): string;
+export declare function resolveAttachPreviewStyle(anchor: Pick<DOMRect, 'left' | 'top' | 'bottom'>, viewport?: {
+    width: number;
+    height: number;
+}): AttachPreviewStyle;

package/client/attachment-hover-preview.js

@@ -0,0 +1,36 @@
+/** Hover-card geometry for composer attachment pills (model-sculpt agent_chat parity). */
+const ATTACH_PREVIEW_WIDTH_PX = 240;
+const ATTACH_PREVIEW_OFFSET_PX = 6;
+const ATTACH_PREVIEW_VIEWPORT_PAD_PX = 8;
+/** Prefer anchoring above the chip when this much space exists. */
+const ATTACH_PREVIEW_ABOVE_THRESHOLD_PX = 190;
+export function formatAttachmentSize(bytes) {
+    if (!bytes || bytes <= 0)
+        return '';
+    if (bytes < 1024)
+        return `${String(bytes)} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function clampAttachPreviewLeft(anchorLeft, viewportWidth) {
+    const maxLeft = Math.max(ATTACH_PREVIEW_VIEWPORT_PAD_PX, viewportWidth - ATTACH_PREVIEW_WIDTH_PX - ATTACH_PREVIEW_VIEWPORT_PAD_PX);
+    return Math.min(Math.max(ATTACH_PREVIEW_VIEWPORT_PAD_PX, anchorLeft), maxLeft);
+}
+export function resolveAttachPreviewStyle(anchor, viewport = {
+    width: globalThis.innerWidth ?? 0,
+    height: globalThis.innerHeight ?? 0,
+}) {
+    const left = clampAttachPreviewLeft(anchor.left, viewport.width);
+    const hasRoomAbove = anchor.top > ATTACH_PREVIEW_ABOVE_THRESHOLD_PX;
+    if (hasRoomAbove) {
+        return {
+            left,
+            bottom: Math.max(ATTACH_PREVIEW_VIEWPORT_PAD_PX, viewport.height - anchor.top + ATTACH_PREVIEW_OFFSET_PX),
+        };
+    }
+    return {
+        left,
+        top: Math.min(viewport.height - ATTACH_PREVIEW_VIEWPORT_PAD_PX, anchor.bottom + ATTACH_PREVIEW_OFFSET_PX),
+    };
+}

package/client/audio-level.d.ts

@@ -0,0 +1,5 @@
+/** Shared mic RMS → waveform level scaling for live and turn-composer paths. */
+export declare const INPUT_LEVEL_GAIN = 4;
+export declare function float32Rms(samples: Float32Array): number;
+export declare function float32RmsToLevel(samples: Float32Array): number;
+export declare function timeDomainBytesToLevel(samples: Uint8Array<ArrayBufferLike>): number;

package/client/audio-level.js

@@ -0,0 +1,24 @@
+/** Shared mic RMS → waveform level scaling for live and turn-composer paths. */
+export const INPUT_LEVEL_GAIN = 4;
+export function float32Rms(samples) {
+    let sum = 0;
+    for (const sample of samples) {
+        sum += sample * sample;
+    }
+    if (samples.length === 0)
+        return 0;
+    return Math.sqrt(sum / samples.length);
+}
+export function float32RmsToLevel(samples) {
+    return Math.min(1, float32Rms(samples) * INPUT_LEVEL_GAIN);
+}
+export function timeDomainBytesToLevel(samples) {
+    let sum = 0;
+    for (const sample of samples) {
+        const normalized = (sample - 128) / 128;
+        sum += normalized * normalized;
+    }
+    if (samples.length === 0)
+        return 0;
+    return Math.min(1, Math.sqrt(sum / samples.length) * INPUT_LEVEL_GAIN);
+}

package/client/composer-attachments.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Stage file picks against profile `maxFiles` (shared with voice). Excess
+ * incoming files are dropped; the limit hit is an issue the caller words
+ * (`attachmentIssueText`).
+ */
+import type { AttachmentValidationIssue } from '@theoremjs/agents/interface';
+export type StageComposerFilesArgs = {
+    existing: readonly File[];
+    incoming: readonly File[];
+    /** Profile `inputs.maxFiles`. When omitted, no cap. */
+    maxFiles?: number;
+    /** Staged voice notes that share the same maxFiles budget. */
+    voiceCount?: number;
+};
+export type StageComposerFilesResult = {
+    files: File[];
+    dropped: number;
+    /** `too_many_files` when the cap dropped a file. */
+    issues: AttachmentValidationIssue[];
+};
+/** Append `incoming` to `existing`, dropping overflow past maxFiles − voice. */
+export declare function stageComposerFiles(args: StageComposerFilesArgs): StageComposerFilesResult;
+/**
+ * Whether a new voice note fits under maxFiles.
+ * Recording clears any prior staged voice first, so only `fileCount` matters.
+ */
+export declare function canStageVoice(args: {
+    fileCount: number;
+    maxFiles?: number;
+}): boolean;

package/client/composer-attachments.js

@@ -0,0 +1,33 @@
+/**
+ * Stage file picks against profile `maxFiles` (shared with voice). Excess
+ * incoming files are dropped; the limit hit is an issue the caller words
+ * (`attachmentIssueText`).
+ */
+/** Append `incoming` to `existing`, dropping overflow past maxFiles − voice. */
+export function stageComposerFiles(args) {
+    const { existing, incoming, maxFiles } = args;
+    const voiceCount = Math.max(0, args.voiceCount ?? 0);
+    if (maxFiles === undefined || !Number.isFinite(maxFiles) || maxFiles < 0) {
+        return { files: [...existing, ...incoming], dropped: 0, issues: [] };
+    }
+    const room = Math.max(0, maxFiles - voiceCount - existing.length);
+    if (incoming.length <= room) {
+        return { files: [...existing, ...incoming], dropped: 0, issues: [] };
+    }
+    const kept = room === 0 ? [] : incoming.slice(0, room);
+    return {
+        files: [...existing, ...kept],
+        dropped: incoming.length - kept.length,
+        issues: [{ code: 'too_many_files', params: { maxFiles } }],
+    };
+}
+/**
+ * Whether a new voice note fits under maxFiles.
+ * Recording clears any prior staged voice first, so only `fileCount` matters.
+ */
+export function canStageVoice(args) {
+    const maxFiles = args.maxFiles;
+    if (maxFiles === undefined || !Number.isFinite(maxFiles))
+        return true;
+    return args.fileCount < maxFiles;
+}

package/client/composer-drawer.d.ts

@@ -0,0 +1,19 @@
+import type { ComposerPendingMessage } from '@theoremjs/agents/interface';
+/** What waits in the composer, by kind; the UI words each kind. */
+export type ComposerDrawerKind = 'steer' | 'queue' | 'stash' | 'attached';
+/** Collapsed-drawer header: the total, then each waiting kind's count, in display order. */
+export type ComposerDrawerSummary = {
+    count: number;
+    parts: {
+        kind: ComposerDrawerKind;
+        n: number;
+    }[];
+};
+/**
+ * What's waiting in the composer, by kind: steering, queued, stashed, attached
+ * (files and voice notes). Null when nothing waits.
+ */
+export declare function composerDrawerSummary(args: {
+    pendingMessages: readonly Pick<ComposerPendingMessage, 'kind'>[];
+    attachmentCount: number;
+}): ComposerDrawerSummary | null;

package/client/composer-drawer.js

@@ -0,0 +1,15 @@
+/**
+ * What's waiting in the composer, by kind: steering, queued, stashed, attached
+ * (files and voice notes). Null when nothing waits.
+ */
+export function composerDrawerSummary(args) {
+    const countOf = (kind) => args.pendingMessages.filter((message) => message.kind === kind).length;
+    const parts = [
+        { kind: 'steer', n: countOf('steer') },
+        { kind: 'queue', n: countOf('queue') },
+        { kind: 'stash', n: countOf('stash') },
+        { kind: 'attached', n: args.attachmentCount },
+    ].filter((part) => part.n > 0);
+    const count = parts.reduce((sum, part) => sum + part.n, 0);
+    return count === 0 ? null : { count, parts };
+}

package/client/composer-hints.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Composer hints — ephemeral guidance about the current composer interaction
+ * (not pending-message state). Mirrors seance's `stash-selected-draft` hint.
+ */
+/** Stash shortcut in Astryx `Kbd` notation (`mod` is ⌘ on macOS, Ctrl elsewhere). */
+export declare const STASH_SHORTCUT = "mod+shift+s";
+/** Which hint applies, and its shortcut; the UI words it. */
+export type ComposerHint = {
+    id: 'stash-selected-draft';
+    shortcut: string;
+};
+/** Whether a keydown is the stash shortcut (⌘⇧S / Ctrl+Shift+S). */
+export declare function isStashShortcut(event: {
+    code: string;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+}): boolean;
+/** The stash hint — shown while the whole draft is selected in the focused input and it can be stashed. */
+export declare function resolveComposerHint(args: {
+    draftText: string;
+    selectedText: string;
+    canStash: boolean;
+}): ComposerHint | null;

package/client/composer-hints.js

@@ -0,0 +1,20 @@
+/**
+ * Composer hints — ephemeral guidance about the current composer interaction
+ * (not pending-message state). Mirrors seance's `stash-selected-draft` hint.
+ */
+/** Stash shortcut in Astryx `Kbd` notation (`mod` is ⌘ on macOS, Ctrl elsewhere). */
+export const STASH_SHORTCUT = 'mod+shift+s';
+/** Whether a keydown is the stash shortcut (⌘⇧S / Ctrl+Shift+S). */
+export function isStashShortcut(event) {
+    return (event.code === 'KeyS' && event.shiftKey && !event.altKey && (event.metaKey || event.ctrlKey));
+}
+/** The stash hint — shown while the whole draft is selected in the focused input and it can be stashed. */
+export function resolveComposerHint(args) {
+    const draft = args.draftText.trim();
+    if (!args.canStash || !draft || args.selectedText.trim() !== draft)
+        return null;
+    return {
+        id: 'stash-selected-draft',
+        shortcut: STASH_SHORTCUT,
+    };
+}

package/client/composer-primary.d.ts

@@ -0,0 +1,16 @@
+import { type ComposerMenuAction, type ComposerPrimaryAction, type ComposerProfileInterface, type ComposerRunPhase } from '@theoremjs/agents/interface';
+export type ComposerActionState = {
+    primary: ComposerPrimaryAction;
+    menuActions: ComposerMenuAction[];
+    /** Send is off while recording, with nothing to act on, or with an empty draft to send or queue. */
+    primaryDisabled: boolean;
+};
+/** The composer's primary button and send menu for the current draft and run phase. */
+export declare function composerActionState(args: {
+    iface: ComposerProfileInterface;
+    phase: ComposerRunPhase;
+    draftText: string;
+    pendingFiles: readonly File[];
+    pendingVoice: readonly File[];
+    recording: boolean;
+}): ComposerActionState;

package/client/composer-primary.js

@@ -0,0 +1,25 @@
+import { resolveComposerMenuActions, resolveComposerPrimary, userDraftHasPayload, } from '@theoremjs/agents/interface';
+function fileSpecs(files) {
+    return files.map((file) => ({
+        name: file.name,
+        mimeType: file.type || 'application/octet-stream',
+        sizeBytes: file.size,
+    }));
+}
+/** The composer's primary button and send menu for the current draft and run phase. */
+export function composerActionState(args) {
+    const allowSteering = 'allowSteering' in args.iface && Boolean(args.iface.allowSteering);
+    const hasPayload = userDraftHasPayload({
+        ...(args.draftText.trim() ? { text: args.draftText } : {}),
+        ...(args.pendingFiles.length ? { attachments: fileSpecs(args.pendingFiles) } : {}),
+        ...(args.pendingVoice.length ? { voice: fileSpecs(args.pendingVoice) } : {}),
+    });
+    const context = { phase: args.phase, hasPayload, allowSteering };
+    const primary = resolveComposerPrimary(context);
+    const needsPayload = primary === 'send' || primary === 'queue';
+    return {
+        primary,
+        menuActions: resolveComposerMenuActions(context),
+        primaryDisabled: args.recording || primary === 'none' || (needsPayload && !hasPayload),
+    };
+}

package/client/decision-images.d.ts

@@ -0,0 +1,76 @@
+import type { DecisionAsset, DecisionJson } from '@theoremjs/agents';
+/**
+ * An image the page holds for a decision, by its reference: the text the state and the questions
+ * write where the image goes, such as `<pantry_shelf>`.
+ */
+export type DecisionImages = Record<string, DecisionAsset>;
+/** The image types a decision reads. */
+export declare const IMAGE_ACCEPT = "image/png,image/jpeg";
+/**
+ * A reference for a file that no image holds yet: its base name in angle brackets, then `_2`, `_3`,
+ * and so on. The model reads any text as a reference, so the brackets keep it from matching words.
+ */
+export declare function imageName(file: string, taken: readonly string[]): string;
+/** A file as an asset, or null when it is not a PNG or JPEG. */
+export declare function readImage(file: File): Promise<DecisionAsset | null>;
+/** The image as a `src` the page can show. */
+export declare function imageSrc(image: DecisionAsset): string;
+/** The held images the state still names, the only ones a decision sends. */
+export declare function namedImages(images: DecisionImages, state: DecisionJson): DecisionImages;
+/**
+ * The field a dropped file becomes: its reference, unused by any image or field, and the field
+ * named after it, such as `plant` holding `<plant>`.
+ */
+export declare function imageField(file: string, images: DecisionImages, fields: readonly string[]): {
+    key: string;
+    reference: string;
+};
+/** The state as named fields, or undefined when it is a list, a value, or nothing. */
+export declare function stateFields(state: DecisionJson | undefined): Record<string, DecisionJson> | undefined;
+/**
+ * The images and state after files are dropped: each file a field named after it, holding a
+ * reference no image the page or the host holds, nor any field, has yet.
+ */
+export declare function droppedImages(dropped: readonly (readonly [File, DecisionAsset])[], held: {
+    images: DecisionImages;
+    host?: DecisionImages;
+    state: Record<string, DecisionJson>;
+}): {
+    images: DecisionImages;
+    state: Record<string, DecisionJson>;
+};
+/**
+ * The image a box answer is drawn on: `field` itself when it is a held reference, else the one at
+ * that state field, else the first the state refers to, else the first held. A box answer names no image, so this is the
+ * page's best reading of where it points.
+ */
+export declare function boxSource(images: DecisionImages, state: DecisionJson, field?: string): DecisionAsset | undefined;
+/** A box answer's edges, each a share of the image from its top or left. */
+export type DecisionBox = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+/** The box in an image's pixels, and an outline that stays visible at any size. */
+export declare function boxRect(box: DecisionBox, width: number, height: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    line: number;
+};
+/** The colours a marked image is drawn in: the box's outline, and the shade over the rest. */
+export type BoxMarks = {
+    outline: string;
+    shade: string;
+};
+/** The whole image with the box outlined and the rest shaded, as a PNG `src`. */
+export declare function markedBox(src: string, box: DecisionBox, marks: BoxMarks): Promise<string>;
+/** The part of an image a box takes, as the frame's size and the image's place inside it, in percent. */
+export declare function cropOf(box: DecisionBox): {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+};

package/client/decision-images.js

@@ -0,0 +1,139 @@
+const MIME_TYPES = new Set(['image/png', 'image/jpeg']);
+/** The image types a decision reads. */
+export const IMAGE_ACCEPT = 'image/png,image/jpeg';
+/**
+ * A reference for a file that no image holds yet: its base name in angle brackets, then `_2`, `_3`,
+ * and so on. The model reads any text as a reference, so the brackets keep it from matching words.
+ */
+export function imageName(file, taken) {
+    const base = file
+        .replace(/\.[^.]*$/, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '') || 'image';
+    let name = `<${base}>`;
+    for (let n = 2; taken.includes(name); n += 1)
+        name = `<${base}_${String(n)}>`;
+    return name;
+}
+/** A file as an asset, or null when it is not a PNG or JPEG. */
+export async function readImage(file) {
+    if (!MIME_TYPES.has(file.type))
+        return null;
+    const bytes = new Uint8Array(await file.arrayBuffer());
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += 0x8000)
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    return { mimeType: file.type, data: btoa(binary) };
+}
+/** The image as a `src` the page can show. */
+export function imageSrc(image) {
+    return `data:${image.mimeType};base64,${image.data}`;
+}
+function mentions(value, name) {
+    if (typeof value === 'string')
+        return value === name;
+    if (Array.isArray(value))
+        return value.some((each) => mentions(each, name));
+    if (value !== null && typeof value === 'object')
+        return Object.values(value).some((each) => mentions(each, name));
+    return false;
+}
+/** The held images the state still names, the only ones a decision sends. */
+export function namedImages(images, state) {
+    return Object.fromEntries(Object.entries(images).filter(([name]) => mentions(state, name)));
+}
+/**
+ * The field a dropped file becomes: its reference, unused by any image or field, and the field
+ * named after it, such as `plant` holding `<plant>`.
+ */
+export function imageField(file, images, fields) {
+    const reference = imageName(file, [...Object.keys(images), ...fields.map((key) => `<${key}>`)]);
+    return { key: reference.slice(1, -1), reference };
+}
+/** The state as named fields, or undefined when it is a list, a value, or nothing. */
+export function stateFields(state) {
+    return state !== null && typeof state === 'object' && !Array.isArray(state) ? state : undefined;
+}
+/**
+ * The images and state after files are dropped: each file a field named after it, holding a
+ * reference no image the page or the host holds, nor any field, has yet.
+ */
+export function droppedImages(dropped, held) {
+    let { images, state } = held;
+    for (const [file, image] of dropped) {
+        const { key, reference } = imageField(file.name, { ...held.host, ...images }, Object.keys(state));
+        images = { ...images, [reference]: image };
+        state = { ...state, [key]: reference };
+    }
+    return { images, state };
+}
+function at(state, path) {
+    let value = state;
+    for (const step of path.split('.')) {
+        if (value === null || typeof value !== 'object')
+            return undefined;
+        value = Array.isArray(value) ? value[Number(step)] : value[step];
+    }
+    return value;
+}
+/**
+ * The image a box answer is drawn on: `field` itself when it is a held reference, else the one at
+ * that state field, else the first the state refers to, else the first held. A box answer names no image, so this is the
+ * page's best reading of where it points.
+ */
+export function boxSource(images, state, field) {
+    const names = Object.keys(images);
+    const pointed = field === undefined || field in images ? field : at(state, field);
+    const named = (typeof pointed === 'string' && pointed in images ? pointed : undefined) ??
+        names.find((name) => mentions(state, name));
+    return images[named ?? names[0] ?? ''];
+}
+/** The box in an image's pixels, and an outline that stays visible at any size. */
+export function boxRect(box, width, height) {
+    return {
+        x: box.left * width,
+        y: box.top * height,
+        width: (box.right - box.left) * width,
+        height: (box.bottom - box.top) * height,
+        line: Math.max(2, Math.round(Math.min(width, height) / 200)),
+    };
+}
+/** How much of the shade's colour lies over the rest of the image, so the image still shows through it. */
+const SHADE_ALPHA = 0.45;
+/** The whole image with the box outlined and the rest shaded, as a PNG `src`. */
+export async function markedBox(src, box, marks) {
+    const image = new Image();
+    image.src = src;
+    await image.decode();
+    const canvas = document.createElement('canvas');
+    canvas.width = image.naturalWidth;
+    canvas.height = image.naturalHeight;
+    const context = canvas.getContext('2d');
+    if (!context)
+        return src;
+    const rect = boxRect(box, canvas.width, canvas.height);
+    context.drawImage(image, 0, 0);
+    context.fillStyle = marks.shade;
+    context.globalAlpha = SHADE_ALPHA;
+    context.beginPath();
+    context.rect(0, 0, canvas.width, canvas.height);
+    context.rect(rect.x, rect.y, rect.width, rect.height);
+    context.fill('evenodd');
+    context.globalAlpha = 1;
+    context.strokeStyle = marks.outline;
+    context.lineWidth = rect.line;
+    context.strokeRect(rect.x, rect.y, rect.width, rect.height);
+    return canvas.toDataURL('image/png');
+}
+/** The part of an image a box takes, as the frame's size and the image's place inside it, in percent. */
+export function cropOf(box) {
+    const width = box.right - box.left;
+    const height = box.bottom - box.top;
+    return {
+        width: 100 / width,
+        height: 100 / height,
+        left: (-box.left / width) * 100,
+        top: (-box.top / height) * 100,
+    };
+}

package/client/decision-transport.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The browser side of a decision profile: what the host lets the page see of
+ * it, and the one call that asks its questions about some state.
+ *
+ * @module
+ */
+import { type DecisionAsset, type DecisionJson, type DecisionProfile, type DecisionQuestion, type DecisionResult, type TraceRecord } from '@theoremjs/agents';
+import type { TraceFeed } from './trace-feed.ts';
+import { type HttpOptions } from './transport.ts';
+/** One question as the page sees it: its answer type and the names of its options or levels. Instructions stay on the host. */
+export type DecisionQuestionView = {
+    id: string;
+    type: DecisionQuestion['type'];
+    /** A choice's labels, a score's levels from 0 up; empty for a number. */
+    labels: string[];
+    /**
+     * A box's image: the one its question gives, a reference or a state field, else the field its
+     * instructions first name in backticks.
+     */
+    field?: string;
+};
+/** What a decision profile shows the page. */
+export type DecisionInterface = {
+    type: 'decision';
+    identity: {
+        handle: string;
+    };
+    contract: string;
+    maxStateBytes?: number;
+    questions: DecisionQuestionView[];
+    /** The host's own images, by the reference its questions write, sent with every decision. */
+    images?: Record<string, DecisionAsset>;
+    observability?: {
+        record: boolean;
+    };
+};
+/** The page's view of a decision profile, the questions its host asks, and the host's own images. */
+export declare function decisionInterface(profile: Pick<DecisionProfile, 'identity' | 'decision' | 'inputs' | 'observability'>, questions: Record<string, DecisionQuestion>, images?: Record<string, DecisionAsset>): DecisionInterface;
+/**
+ * The images a decision sends: the host's own and the page's. A page image may not take a name
+ * the host's use, so the questions always read the host's picture.
+ */
+export declare function decisionAssets(host: Record<string, DecisionAsset> | undefined, page: Record<string, DecisionAsset> | undefined): Record<string, DecisionAsset> | undefined;
+/** A decision's reply: the answers, and the trace records a host that delivers them sent back. */
+export type DecisionReply = {
+    result: DecisionResult;
+    traces?: TraceRecord[];
+};
+export interface DecisionTransport {
+    describe(signal?: AbortSignal): Promise<DecisionInterface>;
+    /** `assets` are the images the state names, by reference. */
+    decide(state: Exclude<DecisionJson, null>, signal?: AbortSignal, assets?: Record<string, DecisionAsset>): Promise<DecisionReply>;
+    /** Where the host's trace records land, for the inspector. */
+    traces?: TraceFeed;
+}
+/** Marks a decision's failure with the trace records it left, for the page's inspector. */
+export declare function withFailedTraces(err: unknown, traces: readonly TraceRecord[]): unknown;
+/** The trace records a failed decision left; none when its host sent none. */
+export declare function failedTraces(err: unknown): readonly TraceRecord[];
+export declare const failedDecisionTraces: typeof failedTraces;
+/** POSTs `body` and reads its reply with `read`; a failure keeps the trace records its body carried. */
+export declare function postWithTraces<Reply>(url: string, body: unknown, signal: AbortSignal | undefined, options: HttpOptions, read: (raw: unknown) => Reply): Promise<Reply>;
+/** POSTs a decision and reads its reply; a failure keeps the trace records its body carried. */
+export declare function postDecision(url: string, body: unknown, signal: AbortSignal | undefined, options?: HttpOptions): Promise<DecisionReply>;
+/** A host's decide reply, checked: the answers, and any trace records it delivers. */
+export declare function readDecisionReply(raw: unknown): DecisionReply;
+/** Transport for a host mounted with `createTheoremDecisionHandler`. Default endpoint `/api/decision`. */
+export declare function createDecisionTransport(options?: HttpOptions & {
+    endpoint?: string;
+}): DecisionTransport;