@theoremjs/react 0.3.3 → 0.3.4-next.373.gab46e23

package/ui/ShapedData.js

@@ -12,8 +12,8 @@ import { Table } from '@astryxdesign/core/Table';
 import { Text } from '@astryxdesign/core/Text';
 import { Token } from '@astryxdesign/core/Token';
 import { VStack } from '@astryxdesign/core/VStack';
+import { fieldLabel, fieldReading, isPlain, isProse, isRow, json, MAX_ROWS, plainReading, rowHeading, shapeOf, splitFields, unpacked, withUnit, } from '@theoremjs/web/client';
 import { Component, useMemo, useState } from 'react';
-import { fieldLabel, fieldReading, isPlain, isProse, isRow, json, MAX_ROWS, plainReading, rowHeading, shapeOf, splitFields, unpacked, withUnit, } from "../client/shaped-data.js";
 import { Arrive, useArrive } from "./arrive.js";
 import { useLabels } from "./labels-provider.js";
 import { useMarkdownPlugins } from "./markdown-plugins.js";

package/ui/StateFields.js

@@ -15,9 +15,9 @@ import { Thumbnail } from '@astryxdesign/core/Thumbnail';
 import { Tokenizer } from '@astryxdesign/core/Tokenizer';
 import { VStack } from '@astryxdesign/core/VStack';
 import { IconPlus, IconX } from '@tabler/icons-react';
+import { humanize, isPlain } from '@theoremjs/web/client';
 import { createContext, useContext, useId, useState } from 'react';
 import { IMAGE_ACCEPT, imageSrc } from "../client/decision-images.js";
-import { humanize, isPlain } from "../client/shaped-data.js";
 import { blankLike, isWordList, tableColumns } from "../client/state-fields.js";
 import { useImageReader } from "./DecisionImages.js";
 import { useLabels } from "./labels-provider.js";

package/ui/TheoremChat.d.ts

@@ -1,7 +1,7 @@
 import type { DefinedTheme } from '@astryxdesign/core/theme';
+import type { PageTools } from '@theoremjs/web/client';
+import { type ConversationView, type HttpTransportOptions, type TheoremTransport } from '@theoremjs/web/client';
 import { type ReactNode, type Ref } from 'react';
-import type { PageTools } from '../client/live/live-page-tool.ts';
-import { type ConversationView, type HttpTransportOptions, type TheoremTransport } from '../client/transport.ts';
 import { type SentTurn, type UseTheoremChatOptions } from '../hooks/use-theorem-chat.ts';
 import type { TheoremLabels } from './labels.ts';
 export type TheoremChatProps = {

package/ui/TheoremChat.js

@@ -6,9 +6,9 @@ import { Layout, LayoutContent } from '@astryxdesign/core/Layout';
 import { Text } from '@astryxdesign/core/Text';
 import { VStack } from '@astryxdesign/core/VStack';
 import { moveComposerPendingWithinKind, removeComposerPendingMessage, } from '@theoremjs/agents/interface';
+import { createHttpTransport, } from '@theoremjs/web/client';
 import { useImperativeHandle, useMemo, useRef, } from 'react';
 import { parseAspectRatio } from "../client/image-output.js";
-import { createHttpTransport, } from "../client/transport.js";
 import { useTheoremChat, } from "../hooks/use-theorem-chat.js";
 import { useTheoremInterface } from "../hooks/use-theorem-interface.js";
 import { ChatComposerBar } from "./ChatComposerBar.js";

package/ui/TheoremDecision.d.ts

@@ -1,5 +1,5 @@
+import { type DecisionTransport } from '@theoremjs/web/client';
 import { type DecisionImages } from '../client/decision-images.ts';
-import { type DecisionTransport } from '../client/decision-transport.ts';
 import { type ConsolePageProps } from './ConsoleFrame.tsx';
 import { type TheoremDecisionAnswersProps } from './DecisionAnswers.tsx';
 export type TheoremDecisionProps = ConsolePageProps & {

package/ui/TheoremDecision.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Banner } from '@astryxdesign/core/Banner';
+import { createDecisionTransport, } from '@theoremjs/web/client';
 import { useMemo, useRef, useState } from 'react';
 import { droppedImages, namedImages, stateFields, } from "../client/decision-images.js";
-import { createDecisionTransport, } from "../client/decision-transport.js";
 import { useTheoremDecision } from "../hooks/use-theorem-decision.js";
 import { ConsoleFrame, JsonRequest, RequestCard, ResponseColumn, RunBar, useBytes, } from "./ConsoleFrame.js";
 import { TheoremDecisionAnswers } from "./DecisionAnswers.js";

package/ui/TheoremEmbedding.d.ts

@@ -1,4 +1,4 @@
-import { type EmbeddingTransport } from '../client/embedding-transport.ts';
+import { type EmbeddingTransport } from '@theoremjs/web/client';
 import { type ConsolePageProps } from './ConsoleFrame.tsx';
 import { type EmbeddingDocument } from './EmbeddingDocuments.tsx';
 export type TheoremEmbeddingProps = ConsolePageProps & {

package/ui/TheoremEmbedding.js

@@ -1,8 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { VStack } from '@astryxdesign/core/VStack';
+import { createEmbeddingTransport, rankMatches, } from '@theoremjs/web/client';
 import { useMemo, useRef, useState } from 'react';
-import { rankMatches } from "../client/embedding-input.js";
-import { createEmbeddingTransport, } from "../client/embedding-transport.js";
 import { useEmbeddingIndex } from "../hooks/use-embedding-index.js";
 import { useTheoremEmbedding } from "../hooks/use-theorem-embedding.js";
 import { ConsoleFrame, ConsoleSection, ResponseColumn, } from "./ConsoleFrame.js";

package/ui/TheoremHost.d.ts

@@ -1,8 +1,7 @@
 import type { DefinedTheme } from '@astryxdesign/core/theme';
+import type { HttpOptions, PageTools } from '@theoremjs/web/client';
+import { type HostTransport } from '@theoremjs/web/client';
 import { type CSSProperties } from 'react';
-import { type HostTransport } from '../client/host-transport.ts';
-import type { PageTools } from '../client/live/live-page-tool.ts';
-import type { HttpOptions } from '../client/transport.ts';
 import { type TheoremLabels } from './labels.ts';
 export type TheoremHostProps = {
     /** Where `createTheoremHostHandler` is mounted. Default `/api/host`. Ignored when `transport` is set. */

package/ui/TheoremHost.js

@@ -10,11 +10,9 @@ import { Text } from '@astryxdesign/core/Text';
 import { Token } from '@astryxdesign/core/Token';
 import { VStack } from '@astryxdesign/core/VStack';
 import { IconMathFunction, IconWorld } from '@tabler/icons-react';
+import { createHostTransport, isRow, json, missingFields, } from '@theoremjs/web/client';
 import { useMemo, useRef, useState } from 'react';
 import { hostCallFailure, hostCallStatus, hostConsoleView, } from "../client/host-call.js";
-import { createHostTransport, } from "../client/host-transport.js";
-import { missingFields } from "../client/schema-fields.js";
-import { isRow, json } from "../client/shaped-data.js";
 import { toolCallLabel } from "../client/transcript-groups.js";
 import { useSecondTicker } from "../hooks/use-second-ticker.js";
 import { useTheoremHost } from "../hooks/use-theorem-host.js";

package/ui/ToolGateCard.d.ts

@@ -1,5 +1,5 @@
 import type { ToolGate } from '@theoremjs/agents/kernel';
-import type { ToolDecisionAction } from '../client/tool-resume.ts';
+import type { ToolDecisionAction } from '@theoremjs/web/client';
 export type ToolDecision = ToolDecisionAction;
 /** The widest a gate card gets, in pixels. */
 export declare const GATE_CARD_WIDTH = 400;

package/ui/ToolGateCard.js

@@ -11,9 +11,8 @@ import { TextInput } from '@astryxdesign/core/TextInput';
 import { Token } from '@astryxdesign/core/Token';
 import { VStack } from '@astryxdesign/core/VStack';
 import { IconEye, IconFlame, IconPencil } from '@tabler/icons-react';
+import { humanize, isOAuthComplete } from '@theoremjs/web/client';
 import { useCallback, useEffect, useState } from 'react';
-import { isOAuthComplete } from "../client/oauth-popup.js";
-import { humanize } from "../client/shaped-data.js";
 import { approvalHeading } from "./approval-heading.js";
 import { TheoremLabelsProvider, useLabels } from "./labels-provider.js";
 /** The widest a gate card gets, in pixels. */

package/ui/ToolResult.d.ts

@@ -1,4 +1,4 @@
-import { type ResultMedia } from '../client/tool-result.ts';
+import { type ResultMedia } from '@theoremjs/web/client';
 /**
  * A tool's output under one Response heading, led by what answers it (figures,
  * charts, the images and audio it returned), then the data itself drawn by its shape, with its JSON one

package/ui/ToolResult.js

@@ -6,9 +6,8 @@ import { useLocale } from '@astryxdesign/core/i18n';
 import { Lightbox } from '@astryxdesign/core/Lightbox';
 import { Skeleton } from '@astryxdesign/core/Skeleton';
 import { VStack } from '@astryxdesign/core/VStack';
+import { hasLead, layoutResult, returnedMedia, withUnit, } from '@theoremjs/web/client';
 import { lazy, Suspense, useMemo, useState } from 'react';
-import { withUnit } from "../client/shaped-data.js";
-import { hasLead, layoutResult, returnedMedia, } from "../client/tool-result.js";
 import { Arrive } from "./arrive.js";
 import { useLabels } from "./labels-provider.js";
 import { keyedByContent } from "./row-keys.js";

package/ui/ToolResultCharts.d.ts

@@ -1,4 +1,4 @@
-import { type ResultChart } from '../client/tool-result.ts';
+import { type ResultChart } from '@theoremjs/web/client';
 /** Each chart in its card, side by side where the column is wide enough. */
 export declare function ToolResultCharts({ charts }: {
     charts: readonly ResultChart[];

package/ui/ToolResultCharts.js

@@ -3,10 +3,9 @@ import { HStack } from '@astryxdesign/core/HStack';
 import { useLocale } from '@astryxdesign/core/i18n';
 import { Text } from '@astryxdesign/core/Text';
 import { VStack } from '@astryxdesign/core/VStack';
+import { timeFormats, withUnit } from '@theoremjs/web/client';
 import { useMemo } from 'react';
 import { Bar, BarChart, Cell, Line, LineChart, ResponsiveContainer, Tooltip, XAxis, YAxis, } from 'recharts';
-import { withUnit } from "../client/shaped-data.js";
-import { timeFormats } from "../client/tool-result.js";
 import { Arrive } from "./arrive.js";
 import { CardWall } from "./CardWall.js";
 import { ChartFrame, ChartTip, FIRST_WIDTH_PX } from "./TraceOverview.js";

package/ui/TraceInspector.d.ts

@@ -1,6 +1,6 @@
 import type { TraceRecord } from '@theoremjs/agents';
+import type { TraceFeed } from '@theoremjs/web/client';
 import { type ReactNode } from 'react';
-import type { TraceFeed } from '../client/trace-feed.ts';
 /** The inspector over the records a feed has delivered; the panel loads this module when it first opens. */
 export declare function TraceFeedBody({ traces, isWide, }: {
     traces: TraceFeed | undefined;

package/ui/TraceInspectorPanel.d.ts

@@ -1,7 +1,7 @@
 import type { TraceRecord } from '@theoremjs/agents';
 import type { ProfileObservabilityView } from '@theoremjs/agents/interface';
+import type { TraceFeed } from '@theoremjs/web/client';
 import { type ReactNode } from 'react';
-import type { TraceFeed } from '../client/trace-feed.ts';
 import { type SidePanelLabels } from './SidePanel.tsx';
 export type TraceInspector = {
     /** The header toggle; null when the host drives the trace or the profile records none. */

package/ui/approval-heading.js

@@ -1,4 +1,4 @@
-import { humanize } from "../client/shaped-data.js";
+import { humanize } from '@theoremjs/web/client';
 /** "@concierge wants to check the weather": the tool's `labels.request`, else its name in words. */
 export function approvalHeading(t, gate, toolName, agent) {
     const request = gate.request ??

package/ui/embedding-space-gl.d.ts

@@ -8,8 +8,8 @@
  *
  * @module
  */
-import type { EmbeddingSpace, SpacePoint } from '../client/embedding-space.ts';
-import { type QueryMatch } from '../client/space-geometry.ts';
+import type { EmbeddingSpace, SpacePoint } from '@theoremjs/web/client';
+import { type QueryMatch } from '@theoremjs/web/client';
 /** What the space highlights: a query's matches, and the document under the pointer. */
 export type SpaceFocus = {
     query: SpacePoint | null;

package/ui/embedding-space-gl.js

@@ -8,7 +8,7 @@
  *
  * @module
  */
-import { DOT_FLOATS, FRAME_SLOT, queryGeometry, SEGMENT_FLOATS, spaceGeometry, } from "../client/space-geometry.js";
+import { DOT_FLOATS, FRAME_SLOT, queryGeometry, SEGMENT_FLOATS, spaceGeometry, } from '@theoremjs/web/client';
 /** Slot states per texture row. */
 const STATE_ROW = 1024;
 /** Field of view, in radians. */

package/ui/index.d.ts

@@ -8,8 +8,8 @@
  *
  * @module
  */
+export type { LiveCallOptions, PageTool, PageToolAnswer, PageTools, } from '@theoremjs/web/client';
 export type { InkWaveStatus } from '../client/ink-waveform.ts';
-export type { LiveCallOptions, PageTool, PageToolAnswer, PageTools, } from '../client/live/live-page-tool.ts';
 export { useLiveCaptionLog } from '../client/live/use-live-caption-log.ts';
 export { InkWaveform, type InkWaveformProps, type InkWaveLevels, } from '../components/InkWaveform.tsx';
 export { useLiveRunnerModel } from '../components/live/use-live-runner-model.ts';

package/ui/labels.d.ts

@@ -7,8 +7,8 @@
  *
  * @module
  */
+import type { LiveState } from '@theoremjs/web/client';
 import type { ComposerDrawerSummary } from '../client/composer-drawer.ts';
-import type { LiveState } from '../client/live/live-state.ts';
 import type { TurnUsage, WorkStatus } from '../client/transcript-groups.ts';
 export declare const THEOREM_UI_CATALOG: {
     readonly '@theorem.agent.handle': {

package/client/audio-level.d.ts

@@ -1,5 +0,0 @@
-/** 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

@@ -1,24 +0,0 @@
-/** 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/decision-transport.d.ts

@@ -1,70 +0,0 @@
-/**
- * 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;

package/client/decision-transport.js

@@ -1,175 +0,0 @@
-/**
- * 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 { resolveObservabilityPolicy, TheoremError, traceRecordSchema, z, } from '@theoremjs/agents';
-import { fetchJson } from "./transport.js";
-import { checkWire } from "./wire-line.js";
-/** A score level's name: its text, or the first text inside a structured entry. */
-function entryLabel(entry, fallback) {
-    if (typeof entry === 'string')
-        return entry;
-    const entries = Array.isArray(entry) ? entry : Object.keys(entry);
-    return entries.length ? entryLabel(entries[0], fallback) : fallback;
-}
-function withField(field) {
-    return field === undefined ? {} : { field };
-}
-/** The first field an entry names in backticks, as in "the mug in `photo`". */
-function namedField(entry) {
-    if (typeof entry === 'string')
-        return /\x60([^\x60\s]+)\x60/.exec(entry)?.[1];
-    const entries = Array.isArray(entry) ? entry : Object.values(entry);
-    for (const each of entries) {
-        const field = namedField(each);
-        if (field !== undefined)
-            return field;
-    }
-    return undefined;
-}
-/** The page's view of a decision profile, the questions its host asks, and the host's own images. */
-export function decisionInterface(profile, questions, images) {
-    return {
-        type: 'decision',
-        identity: { handle: profile.identity.handle },
-        contract: profile.decision.contract,
-        ...(profile.inputs.maxStateBytes === undefined
-            ? {}
-            : { maxStateBytes: profile.inputs.maxStateBytes }),
-        questions: Object.entries(questions).map(([id, question]) => ({
-            id,
-            type: question.type,
-            labels: question.type === 'choice'
-                ? Object.keys(question.criteria)
-                : question.type === 'score'
-                    ? question.criteria.map((entry, level) => entryLabel(entry, String(level)))
-                    : [],
-            ...(question.type === 'box'
-                ? withField(question.image ?? namedField(question.instructions))
-                : {}),
-        })),
-        ...(images && Object.keys(images).length > 0 ? { images } : {}),
-        ...(profile.observability
-            ? { observability: { record: resolveObservabilityPolicy(profile.observability).record } }
-            : {}),
-    };
-}
-/**
- * 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 function decisionAssets(host, page) {
-    const clash = Object.keys(page ?? {}).find((name) => host && Object.hasOwn(host, name));
-    if (clash !== undefined)
-        // labels-exempt: internal diagnostic; the user reads error.request
-        throw new TheoremError('request', `the image ${clash} is the host's, so the page's needs another name`);
-    const all = { ...host, ...page };
-    return Object.keys(all).length > 0 ? all : undefined;
-}
-const probability = z.number().min(0).max(1);
-const probabilities = z
-    .record(z.string(), probability)
-    .refine((record) => Math.abs(Object.values(record).reduce((sum, value) => sum + value, 0) - 1) <= 0.001);
-const answerSchema = z.discriminatedUnion('type', [
-    z.object({
-        type: z.literal('choice'),
-        choice: z.string(),
-        confidence: probability,
-        probabilities,
-    }),
-    z.object({ type: z.literal('noul'), noul: probability }),
-    z.object({
-        type: z.literal('box'),
-        box: z.object({ top: probability, bottom: probability, left: probability, right: probability }),
-        confidence: probability,
-    }),
-    z.object({
-        type: z.literal('score'),
-        score: z.number().nonnegative(),
-        confidence: probability,
-        legend: z.record(z.string(), z.string().min(1)),
-        probabilities,
-    }),
-]);
-const replySchema = z.object({
-    result: z.object({
-        model: z.string().min(1),
-        answers: z.record(z.string(), answerSchema),
-        usage: z
-            .object({
-            inputTokens: z.number().int().nonnegative(),
-            outputTokens: z.number().int().nonnegative(),
-            costUsd: z.number().nonnegative().optional(),
-        })
-            .optional(),
-    }),
-    traces: z.array(traceRecordSchema).optional(),
-});
-/** The trace records a failed decision left, by the failure thrown for it. */
-const traceFailures = new WeakMap();
-/** Marks a decision's failure with the trace records it left, for the page's inspector. */
-export function withFailedTraces(err, traces) {
-    if (traces.length > 0 && typeof err === 'object' && err !== null)
-        traceFailures.set(err, traces);
-    return err;
-}
-/** The trace records a failed decision left; none when its host sent none. */
-export function failedTraces(err) {
-    return (typeof err === 'object' && err !== null && traceFailures.get(err)) || [];
-}
-export const failedDecisionTraces = failedTraces;
-const failedBody = z.object({ traces: z.array(traceRecordSchema) });
-/** POSTs `body` and reads its reply with `read`; a failure keeps the trace records its body carried. */
-export async function postWithTraces(url, body, signal, options, read) {
-    let traces = [];
-    const failed = (raw) => {
-        const parsed = failedBody.safeParse(raw);
-        if (parsed.success)
-            traces = parsed.data.traces;
-    };
-    try {
-        return read(await fetchJson(url, { body, signal, failed }, options));
-    }
-    catch (err) {
-        throw withFailedTraces(err, traces);
-    }
-}
-/** POSTs a decision and reads its reply; a failure keeps the trace records its body carried. */
-export function postDecision(url, body, signal, options = {}) {
-    return postWithTraces(url, body, signal, options, readDecisionReply);
-}
-/** A host's decide reply, checked: the answers, and any trace records it delivers. */
-export function readDecisionReply(raw) {
-    // labels-exempt: internal diagnostic; the user reads error.bad_response
-    return checkWire(replySchema, raw, 'the decision');
-}
-const describedSchema = z.object({
-    interface: z.object({
-        type: z.literal('decision'),
-        identity: z.object({ handle: z.string() }),
-        contract: z.string(),
-        maxStateBytes: z.number().optional(),
-        questions: z.array(z.object({
-            id: z.string(),
-            type: z.enum(['choice', 'noul', 'score', 'box']),
-            labels: z.array(z.string()),
-            field: z.string().optional(),
-        })),
-        images: z
-            .record(z.string(), z.object({ mimeType: z.enum(['image/png', 'image/jpeg']), data: z.string() }))
-            .optional(),
-        observability: z.object({ record: z.boolean() }).optional(),
-    }),
-});
-/** Transport for a host mounted with `createTheoremDecisionHandler`. Default endpoint `/api/decision`. */
-export function createDecisionTransport(options = {}) {
-    const base = (options.endpoint ?? '/api/decision').replace(/\/$/, '');
-    return {
-        async describe(signal) {
-            return checkWire(describedSchema, await fetchJson(base, { signal }, options), 'the decision description').interface;
-        },
-        decide: (state, signal, assets) => postDecision(`${base}/decide`, { state, ...(assets ? { assets } : {}) }, signal, options),
-    };
-}

package/client/decode-composer-draft.d.ts

@@ -1,11 +0,0 @@
-/**
- * Restore composer fields from a serializable pending `UserTurnDraft`.
- */
-import type { UserTurnDraft } from '@theoremjs/agents/interface';
-export type ComposerDraftFields = {
-    text: string;
-    files: File[];
-    voice: File[];
-};
-/** Map an encoded pending draft back into live composer file fields. */
-export declare function composerFieldsFromDraft(draft: UserTurnDraft): ComposerDraftFields;

package/client/decode-composer-draft.js

@@ -1,12 +0,0 @@
-/**
- * Restore composer fields from a serializable pending `UserTurnDraft`.
- */
-import { pendingAttachmentsToFiles } from "./encode-files.js";
-/** Map an encoded pending draft back into live composer file fields. */
-export function composerFieldsFromDraft(draft) {
-    return {
-        text: draft.text ?? '',
-        files: pendingAttachmentsToFiles(draft.attachments ?? []),
-        voice: pendingAttachmentsToFiles(draft.voice ?? []),
-    };
-}

package/client/embedding-input.d.ts

@@ -1,84 +0,0 @@
-/**
- * The rules behind an embedding console: the inputs as the JSON a request
- * sends, text split into documents, documents packed into the requests the
- * profile allows, all checked the way the kernel checks them, and documents
- * ranked by how alike they point to a query.
- *
- * @module
- */
-import { type EmbeddingInput, type EmbeddingPart, type EmbeddingUsage } from '@theoremjs/agents';
-import type { AttachmentValidationIssue } from '@theoremjs/agents/interface';
-import type { EmbeddingInterface } from './embedding-transport.ts';
-/** A part that is not text: a file sent inline, or one the provider already holds. */
-export type EmbeddingMediaPart = Exclude<EmbeddingPart, {
-    type: 'text';
-}>;
-export type EmbeddingInputCheck = {
-    ok: true;
-    inputs: EmbeddingInput[];
-} | {
-    ok: false;
-    reason: 'invalid_json' | 'no_inputs';
-} | {
-    ok: false;
-    reason: 'too_many_inputs';
-    max: number;
-    inputs: EmbeddingInput[];
-} | {
-    ok: false;
-    reason: 'empty_input' | 'text_off';
-    index: number;
-    inputs: EmbeddingInput[];
-} | {
-    ok: false;
-    reason: 'attachments';
-    issues: AttachmentValidationIssue[];
-    inputs: EmbeddingInput[];
-};
-/** The request's inputs, read from its JSON; `undefined` when it is not a list of inputs. */
-export declare function readEmbeddingInputs(text: string): EmbeddingInput[] | undefined;
-/** One input, read from its JSON; `undefined` when it is not one. */
-export declare function readEmbeddingInput(text: string): EmbeddingInput | undefined;
-/** One input as fields edit it: its words, and the files beside them. */
-export type EmbeddingFields = {
-    text: string;
-    media: EmbeddingMediaPart[];
-};
-/** The input as fields, or `null` when it holds more than one text part and fields would lose it. */
-export declare function inputFields(input: EmbeddingInput): EmbeddingFields | null;
-/** Fields as the input they send: plain text alone, else its parts with the text first. */
-export declare function fieldsInput(fields: EmbeddingFields): EmbeddingInput;
-/** The inputs, held to the profile's rules and its model's limits as the kernel holds them in one request. */
-export declare function checkInputs(inputs: readonly EmbeddingInput[], rules: EmbeddingInterface['inputs']): EmbeddingInputCheck;
-/** The request's JSON as the inputs it sends, held to the profile's rules. */
-export declare function checkEmbeddingInputs(text: string, rules: EmbeddingInterface['inputs']): EmbeddingInputCheck;
-/** Where text is cut into documents: not at all, at each line, at blank lines, at commas, or at a separator of your own. */
-export type EmbeddingSplit = 'whole' | 'lines' | 'paragraphs' | 'commas' | {
-    separator: string;
-};
-/** The text as documents, each trimmed, none empty. */
-export declare function splitText(text: string, split: EmbeddingSplit): string[];
-/** A file read as words and split, not sent as media: plain text, Markdown, CSV, and JSON. */
-export declare function readsAsText(file: {
-    name: string;
-    type: string;
-}): boolean;
-/** The most inputs the console sends in one request when the model sets no cap. */
-export declare const MAX_BATCH_INPUTS = 100;
-/**
- * The inputs, in order, as the fewest requests the profile and its model
- * allow: each holds at most `most` inputs and passes {@linkcode checkInputs}.
- * An input refused on its own goes alone, for the kernel to refuse.
- */
-export declare function embeddingBatches(inputs: readonly EmbeddingInput[], rules: EmbeddingInterface['inputs'], most?: number): EmbeddingInput[][];
-/** Two calls' usage as one: token counts and costs added, estimated when either was. */
-export declare function addUsage(a: EmbeddingUsage | undefined, b: EmbeddingUsage | undefined): EmbeddingUsage | undefined;
-/** How alike two vectors point, from -1 to 1. */
-export declare function cosineSimilarity(a: readonly number[], b: readonly number[]): number;
-/** A document and how alike it points to the query, from -1 to 1. */
-export type EmbeddingMatch = {
-    index: number;
-    score: number;
-};
-/** The documents, most alike to the query first; a vector of another width is left out. */
-export declare function rankMatches(query: readonly number[], documents: readonly (readonly number[])[]): EmbeddingMatch[];