@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/{model-C8U0HZxL.d.ts → intakes/model.d.ts}

@@ -20,23 +20,23 @@
  * answer can never enter the payload.
  */
 /** The kinds of answer a question accepts. */
-type IntakeAnswerType = 'text' | 'long-text' | 'single-select' | 'multi-select' | 'boolean' | 'number' | 'url' | 'email';
+export type IntakeAnswerType = 'text' | 'long-text' | 'single-select' | 'multi-select' | 'boolean' | 'number' | 'url' | 'email';
 /** A selectable option for single/multi-select questions. */
-interface IntakeOption {
+export interface IntakeOption {
     value: string;
     label: string;
 }
 /** A flat map of answers keyed by question id. */
-type IntakeAnswers = Record<string, IntakeAnswerValue>;
+export type IntakeAnswers = Record<string, IntakeAnswerValue>;
 /** Any value an answer can hold; the type is validated per-question. */
-type IntakeAnswerValue = string | string[] | number | boolean | null;
+export type IntakeAnswerValue = string | string[] | number | boolean | null;
 /**
  * One question in the graph. `next` (optional) makes the graph branch: given
  * the answers so far it returns the id of the question to ask next, or null to
  * end the interview early. With no `next`, traversal falls through to the next
  * question in declaration order.
  */
-interface IntakeQuestion {
+export interface IntakeQuestion {
     id: string;
     /** The prompt the interviewer asks. */
     prompt: string;
@@ -58,7 +58,7 @@ interface IntakeQuestion {
     next?(answers: IntakeAnswers): string | null;
 }
 /** The intake definition: an ordered, addressable set of questions. */
-interface IntakeGraph {
+export interface IntakeGraph {
     /** Stable id for the intake definition (e.g. 'user-onboarding-v1'). */
     id: string;
     /** Human title shown at the top of the interview. */
@@ -69,22 +69,22 @@ interface IntakeGraph {
     questions: IntakeQuestion[];
 }
 /** The reason an answer failed validation. */
-type AnswerRejectionReason = 'required' | 'wrong-type' | 'too-short' | 'too-long' | 'too-small' | 'too-large' | 'not-an-option' | 'invalid-url' | 'invalid-email' | 'unknown-question';
+export type AnswerRejectionReason = 'required' | 'wrong-type' | 'too-short' | 'too-long' | 'too-small' | 'too-large' | 'not-an-option' | 'invalid-url' | 'invalid-email' | 'unknown-question';
 /** Describe validation outcome of an answer including success status and optional rejection reason */
-interface AnswerValidationResult {
+export interface AnswerValidationResult {
     ok: boolean;
     reason?: AnswerRejectionReason;
 }
 /** Look up a question by id, or null if the graph has none. */
-declare function getQuestion(graph: IntakeGraph, questionId: string): IntakeQuestion | null;
+export declare function getQuestion(graph: IntakeGraph, questionId: string): IntakeQuestion | null;
 /** True when an answer value is present (not null/undefined/empty). */
-declare function hasAnswer(value: IntakeAnswerValue | undefined): boolean;
+export declare function hasAnswer(value: IntakeAnswerValue | undefined): boolean;
 /**
  * Validate one answer against its question. Pure: no I/O, no graph mutation.
  * An empty value is rejected as `required` only when the question is required;
  * an empty value for an optional question is OK (the user skipped it).
  */
-declare function validateAnswer(question: IntakeQuestion, value: IntakeAnswerValue | undefined): AnswerValidationResult;
+export declare function validateAnswer(question: IntakeQuestion, value: IntakeAnswerValue | undefined): AnswerValidationResult;
 /**
  * The single question to ask next given the answers so far, or null when the
  * interview is done. Walks the graph from the first question, following each
@@ -95,23 +95,21 @@ declare function validateAnswer(question: IntakeQuestion, value: IntakeAnswerVal
  * malformed graph terminates rather than looping. A visited-set guards against
  * a cyclic `next`.
  */
-declare function nextQuestion(graph: IntakeGraph, answers: IntakeAnswers): IntakeQuestion | null;
+export declare function nextQuestion(graph: IntakeGraph, answers: IntakeAnswers): IntakeQuestion | null;
 /**
  * True when every REQUIRED question reachable under the current answers has a
  * valid answer. Pure: it replays the same traversal `nextQuestion` uses and is
  * complete exactly when that traversal has no question left to ask.
  */
-declare function isComplete(graph: IntakeGraph, answers: IntakeAnswers): boolean;
+export declare function isComplete(graph: IntakeGraph, answers: IntakeAnswers): boolean;
 /**
  * Progress as answered-vs-total over the REACHABLE required questions under the
  * current answers — what a progress bar renders. Optional questions don't count
  * toward the denominator (they never block completion).
  */
-declare function intakeProgress(graph: IntakeGraph, answers: IntakeAnswers): {
+export declare function intakeProgress(graph: IntakeGraph, answers: IntakeAnswers): {
     answered: number;
     total: number;
 };
 /** The questions reachable under the current answers, in traversal order. */
-declare function reachableQuestions(graph: IntakeGraph, answers: IntakeAnswers): IntakeQuestion[];
-
-export { type AnswerRejectionReason as A, type IntakeAnswerValue as I, type IntakeQuestion as a, type IntakeGraph as b, type AnswerValidationResult as c, type IntakeAnswerType as d, type IntakeAnswers as e, type IntakeOption as f, getQuestion as g, hasAnswer as h, intakeProgress as i, isComplete as j, nextQuestion as n, reachableQuestions as r, validateAnswer as v };
+export declare function reachableQuestions(graph: IntakeGraph, answers: IntakeAnswers): IntakeQuestion[];

package/dist/intakes-react/components/BrandMark.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Load the canonical Tangle knot only when an intakes surface renders it.
+ * `/brand` imports the optional `@tangle-network/brand` peer, so a failed load
+ * renders a fixed-size spacer instead of crashing the panel.
+ */
+export interface BrandMarkProps {
+    size: number;
+    className?: string;
+}
+export declare function BrandMark({ size, className }: BrandMarkProps): import("react").JSX.Element;

package/dist/intakes-react/components/IntakeInterview.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Agent-led intake interview: asks one question at a time, advancing as each
+ * answer is saved. Fully callback-driven — the host supplies the loaded `view`
+ * and the async `onAnswer` / `onComplete` callbacks (backed by `./intakes/api`),
+ * so this imports no app router, fetch client, or toast. Styled with the
+ * shipped Tangle Quiet tokens (`var(--*)`).
+ *
+ * The server owns traversal: each `onAnswer` resolves with the next view (next
+ * question + progress), so the component never re-derives the graph — it renders
+ * `view.nextQuestion`, and when that is null and the view is completable it
+ * shows the finish action. Local validation only gates the submit button; the
+ * authoritative validation runs in the store.
+ */
+import type { IntakeInterviewProps } from '../contracts';
+export declare function IntakeInterview({ view: initialView, onAnswer, onComplete, onDone, onNotice, }: IntakeInterviewProps): import("react").JSX.Element;

package/dist/intakes-react/components/index.d.ts

@@ -0,0 +1 @@
+export * from './IntakeInterview';

package/dist/intakes-react/contracts.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Seams between the intakes React surface and the host app. Everything here is
+ * interface-only and callback-driven: the components never import an app's
+ * router, fetch client, or toast system. The host passes the loaded view in and
+ * supplies the async callbacks (which it backs with `./intakes/api` over fetch),
+ * so the same interview mounts in any app and for either scope (user / project).
+ */
+import type { IntakeAnswerValue, IntakeQuestion } from '../intakes/model';
+/** The state the interview renders — the shape `./intakes/api` returns. */
+export interface IntakeView {
+    title: string;
+    description?: string;
+    answers: Record<string, IntakeAnswerValue>;
+    /** The next question to ask, or null when the interview is done. */
+    nextQuestion: IntakeQuestion | null;
+    completed: boolean;
+    progress: {
+        answered: number;
+        total: number;
+    };
+}
+/** Define properties and callbacks for managing the intake interview flow and user interactions */
+export interface IntakeInterviewProps {
+    view: IntakeView;
+    /**
+     * Persist one answer; resolve with the next view (the server re-derives the
+     * next question + progress). The component re-renders from the returned view.
+     */
+    onAnswer(input: {
+        questionId: string;
+        value: IntakeAnswerValue;
+    }): Promise<IntakeView>;
+    /** Finish the interview; resolve with the final view. */
+    onComplete(): Promise<IntakeView>;
+    /** Called once when the interview is done (completed view), for navigation. */
+    onDone?(): void;
+    /** Optional toast/notice hook; defaults to a no-op (host owns its UX). */
+    onNotice?(notice: {
+        kind: 'success' | 'error';
+        message: string;
+    }): void;
+}

package/dist/intakes-react/index.d.ts

@@ -1,49 +1,14 @@
-import { I as IntakeAnswerValue, a as IntakeQuestion } from '../model-C8U0HZxL.js';
-import * as react from 'react';
-
 /**
- * Seams between the intakes React surface and the host app. Everything here is
- * interface-only and callback-driven: the components never import an app's
- * router, fetch client, or toast system. The host passes the loaded view in and
- * supplies the async callbacks (which it backs with `./intakes/api` over fetch),
- * so the same interview mounts in any app and for either scope (user / project).
+ * React surface for the intakes module: the IntakeInterview (one question at a
+ * time, agent-led), plus its seams. Everything is callback-driven — no app
+ * router, fetch client, or toast import — so any app mounts it and wires it to
+ * `./intakes/api` over fetch, for either the per-user onboarding scope or the
+ * per-project intake scope.
+ *
+ * Never re-exported from the package root: `react` is an optional peer (the
+ * `web-react` / `teams-react` precedent). DOM access begins only inside
+ * component render. A `React.lazy` code-split entry lives at
+ * `./intakes-react/lazy`.
  */
-
-/** The state the interview renders — the shape `./intakes/api` returns. */
-interface IntakeView {
-    title: string;
-    description?: string;
-    answers: Record<string, IntakeAnswerValue>;
-    /** The next question to ask, or null when the interview is done. */
-    nextQuestion: IntakeQuestion | null;
-    completed: boolean;
-    progress: {
-        answered: number;
-        total: number;
-    };
-}
-/** Define properties and callbacks for managing the intake interview flow and user interactions */
-interface IntakeInterviewProps {
-    view: IntakeView;
-    /**
-     * Persist one answer; resolve with the next view (the server re-derives the
-     * next question + progress). The component re-renders from the returned view.
-     */
-    onAnswer(input: {
-        questionId: string;
-        value: IntakeAnswerValue;
-    }): Promise<IntakeView>;
-    /** Finish the interview; resolve with the final view. */
-    onComplete(): Promise<IntakeView>;
-    /** Called once when the interview is done (completed view), for navigation. */
-    onDone?(): void;
-    /** Optional toast/notice hook; defaults to a no-op (host owns its UX). */
-    onNotice?(notice: {
-        kind: 'success' | 'error';
-        message: string;
-    }): void;
-}
-
-declare function IntakeInterview({ view: initialView, onAnswer, onComplete, onDone, onNotice, }: IntakeInterviewProps): react.JSX.Element;
-
-export { IntakeInterview, type IntakeInterviewProps, type IntakeView };
+export * from './contracts';
+export * from './components/index';

package/dist/intakes-react/lazy.d.ts

@@ -1,9 +1,10 @@
-import * as react from 'react';
-import { IntakeInterview } from './index.js';
-export { IntakeInterviewProps } from './index.js';
-import '../model-C8U0HZxL.js';
-
+/**
+ * Code-split entry for the intakes React surface. Products that don't need the
+ * interview UI on initial load import this `React.lazy` handle instead of the
+ * component directly, so the interview chunk loads on first render. Mount inside
+ * a `<Suspense>` boundary; the product provides the fallback.
+ */
+import type { IntakeInterviewProps } from './contracts';
+export type { IntakeInterviewProps };
 /** Load IntakeInterview component lazily to optimize initial application rendering */
-declare const IntakeInterviewLazy: react.LazyExoticComponent<typeof IntakeInterview>;
-
-export { IntakeInterviewLazy };
+export declare const IntakeInterviewLazy: import("react").LazyExoticComponent<typeof import("./components").IntakeInterview>;

package/dist/integrations/index.d.ts

@@ -1,9 +1,9 @@
 /** `{ success: false }` codes the hub returns on `/exec`. */
-type HubExecErrorCode = 'HUB_APPROVAL_REQUIRED' | 'HUB_POLICY_DENIED' | 'HUB_CONNECTION_MISSING' | 'HUB_CONNECTION_REVOKED' | 'HUB_CONFIG_MISSING' | 'HUB_NOT_FOUND' | string;
+export type HubExecErrorCode = 'HUB_APPROVAL_REQUIRED' | 'HUB_POLICY_DENIED' | 'HUB_CONNECTION_MISSING' | 'HUB_CONNECTION_REVOKED' | 'HUB_CONFIG_MISSING' | 'HUB_NOT_FOUND' | string;
 /** Outcome of a hub `/exec` call. Callers MUST inspect `succeeded` before
  *  reading `result` — a denied or approval-gated write resolves with
  *  `succeeded: false` and a populated `code`, never a thrown silent failure. */
-type HubExecResult = {
+export type HubExecResult = {
     succeeded: true;
     result: unknown;
 } | {
@@ -13,7 +13,7 @@ type HubExecResult = {
     approval?: unknown;
 };
 /** Define configuration options for initializing a Hub execution client */
-interface HubExecClientOptions {
+export interface HubExecClientOptions {
     /** Platform base URL (e.g. `TANGLE_PLATFORM_URL`). */
     baseUrl: string;
     /** Calling user's Tangle API key — the hub principal bearer. */
@@ -23,7 +23,7 @@ interface HubExecClientOptions {
 }
 /** The provider/connector/action a hub action path addresses, plus the dotted
  *  `path` the hub `/exec` endpoint expects. */
-interface ParsedIntegrationAction {
+export interface ParsedIntegrationAction {
     providerId: string;
     connectorId: string;
     actionId: string;
@@ -36,13 +36,13 @@ interface ParsedIntegrationAction {
  * catalog integration tool, so the chat loop routes non-integration calls
  * elsewhere instead of misrouting them to the hub.
  */
-declare function resolveIntegrationAction(toolName: string): ParsedIntegrationAction | undefined;
+export declare function resolveIntegrationAction(toolName: string): ParsedIntegrationAction | undefined;
 /** Typed client over the platform hub `/v1/hub/exec`. The hub holds the user's
  *  credentials, resolves the connection from the bearer principal, evaluates
  *  per-action policy (read → allow, write/destructive → approval), and runs the
  *  action server-side. Never throws on a policy block — a gated write is a
  *  normal `succeeded: false` outcome. */
-declare class HubExecClient {
+export declare class HubExecClient {
     private readonly baseUrl;
     private readonly bearer;
     private readonly fetchImpl;
@@ -55,19 +55,19 @@ declare class HubExecClient {
     private readEnvelope;
 }
 /** Define input parameters for invoking a hub tool with user ID, tool name, and optional arguments */
-interface HubInvokeInput {
+export interface HubInvokeInput {
     userId: string;
     /** The MCP tool name the agent called (`int_<provider>_<connector>_<action>`). */
     toolName: string;
     args?: Record<string, unknown>;
 }
 /** Describe the outcome of a hub invocation including status and response body */
-interface HubInvokeOutcome {
+export interface HubInvokeOutcome {
     status: number;
     body: Record<string, unknown>;
 }
 /** Define dependencies for invoking hub operations including API key resolution and optional configuration */
-interface HubInvokeDeps {
+export interface HubInvokeDeps {
     /** Resolve the user's Tangle API key (the hub principal bearer). Required —
      *  the product binds its own session-key resolver. Null → user not linked. */
     apiKeyResolver: (userId: string) => Promise<string | null>;
@@ -83,6 +83,4 @@ interface HubInvokeDeps {
  * 400 unknown-tool / 409 approval-required / 502 hub-error). A write that's
  * approval-gated surfaces verbatim as 409, never silently executed.
  */
-declare function invokeIntegrationHub(input: HubInvokeInput, deps: HubInvokeDeps): Promise<HubInvokeOutcome>;
-
-export { HubExecClient, type HubExecClientOptions, type HubExecErrorCode, type HubExecResult, type HubInvokeDeps, type HubInvokeInput, type HubInvokeOutcome, type ParsedIntegrationAction, invokeIntegrationHub, resolveIntegrationAction };
+export declare function invokeIntegrationHub(input: HubInvokeInput, deps: HubInvokeDeps): Promise<HubInvokeOutcome>;

package/dist/{contract-OxG_jVMx.d.ts → interactions/contract.d.ts}

@@ -1,19 +1,19 @@
-import { InteractionField, InteractionRequest, InteractionData } from '@tangle-network/agent-interface';
-
+import { type InteractionData, type InteractionField, type InteractionOutcome, type InteractionRequest } from '@tangle-network/agent-interface';
+export type { InteractionData, InteractionOutcome, InteractionRequest };
 /** Sidecar → client: the agent raised an ask; data = `{ request }`. */
-declare const INTERACTION_EVENT: "interaction";
+export declare const INTERACTION_EVENT: "interaction";
 /** Sidecar → client: the ask was withdrawn; data = `{ id, reason? }`. */
-declare const INTERACTION_CANCEL_EVENT: "interaction.cancel";
+export declare const INTERACTION_CANCEL_EVENT: "interaction.cancel";
 /** An ask was answered; data = `{ id, status }`. In the wire contract so a
  *  server broadcast and a client-local mark share one event name. */
-declare const INTERACTION_RESOLVED_EVENT: "interaction.resolved";
+export declare const INTERACTION_RESOLVED_EVENT: "interaction.resolved";
 /** Resolve if the given interaction kind is renderable within the application context */
-declare function isRenderableInteractionKind(kind: string): boolean;
+export declare function isRenderableInteractionKind(kind: string): boolean;
 /** Answer/field keys the sidecar will accept: identifier-safe and never a
  *  prototype-pollution vector. */
-declare function isSafeInteractionFieldKey(key: string): boolean;
+export declare function isSafeInteractionFieldKey(key: string): boolean;
 /** Extract select-type interaction fields and optionally allow custom values */
-type ChatSelectField = Extract<InteractionField, {
+export type ChatSelectField = Extract<InteractionField, {
     type: 'select';
 }>;
 /**
@@ -30,24 +30,24 @@ type ChatSelectField = Extract<InteractionField, {
  * The request author chooses this value; omission means the shared contract
  * imposes no length limit.
  */
-type ChatFreeTextField = Extract<InteractionField, {
+export type ChatFreeTextField = Extract<InteractionField, {
     type: 'text' | 'secret';
 }>;
 /** The shared field contract under the UI-facing name used by this package. */
-type ChatInteractionField = InteractionField;
+export type ChatInteractionField = InteractionField;
 /** The shared request contract under the wire-facing name used by this package. */
-type InteractionRequestWire = InteractionRequest;
+export type InteractionRequestWire = InteractionRequest;
 /** Define possible statuses representing the state of a chat interaction */
-type ChatInteractionStatus = 'pending' | 'answered' | 'declined' | 'cancelled' | 'expired';
+export type ChatInteractionStatus = 'pending' | 'answered' | 'declined' | 'cancelled' | 'expired';
 /** Accepted field selections keyed by answer-spec field name. */
 /** Accepted answer values. Select fields historically used `string[]`; the
  * wider scalar union is additive and lets durable stores preserve text,
  * numeric, and boolean answer fields without coercion. */
-type InteractionAnswerValue = string | number | boolean | string[];
+export type InteractionAnswerValue = string | number | boolean | string[];
 /** Map interaction identifiers to their corresponding answer values */
-type InteractionAnswers = Record<string, InteractionAnswerValue>;
+export type InteractionAnswers = Record<string, InteractionAnswerValue>;
 /** Resolve the result of parsing interaction answers with success status and corresponding data or error message */
-type ParseInteractionAnswersResult = {
+export type ParseInteractionAnswersResult = {
     succeeded: true;
     value: InteractionAnswers;
 } | {
@@ -55,9 +55,9 @@ type ParseInteractionAnswersResult = {
     error: string;
 };
 /** Strictly validates and copies persisted answer selections. */
-declare function parseInteractionAnswers(value: unknown): ParseInteractionAnswersResult;
+export declare function parseInteractionAnswers(value: unknown): ParseInteractionAnswersResult;
 /** The client/persisted view of one ask. `fields` come verbatim off the wire. */
-interface ChatInteraction {
+export interface ChatInteraction {
     id: string;
     kind: string;
     title: string;
@@ -70,18 +70,18 @@ interface ChatInteraction {
     cancelReason?: string;
 }
 /** Resolve if the interaction status is a terminal state excluding pending */
-declare function isTerminalInteractionStatus(status: ChatInteractionStatus): boolean;
+export declare function isTerminalInteractionStatus(status: ChatInteractionStatus): boolean;
 /** Statuses only move forward (pending → terminal); a replayed/stale `pending`
  *  must never resurrect a resolved card. */
-declare function canTransitionInteractionStatus(from: ChatInteractionStatus, to: ChatInteractionStatus): boolean;
+export declare function canTransitionInteractionStatus(from: ChatInteractionStatus, to: ChatInteractionStatus): boolean;
 /** Maps an `interaction.cancel` reason to the card's terminal status. */
-declare function cancelStatusFor(reason: string | undefined): ChatInteractionStatus;
+export declare function cancelStatusFor(reason: string | undefined): ChatInteractionStatus;
 /** Content identity for duplicate safety nets. Excludes volatile ids/statuses. */
-declare function questionInteractionContentSignature(interaction: ChatInteraction): string | null;
+export declare function questionInteractionContentSignature(interaction: ChatInteraction): string | null;
 /** Remove duplicate question interactions based on their content signature to ensure uniqueness */
-declare function dedupeQuestionInteractionsByContent(interactions: ChatInteraction[]): ChatInteraction[];
+export declare function dedupeQuestionInteractionsByContent(interactions: ChatInteraction[]): ChatInteraction[];
 /** Resolve interaction parsing outcome as success with value or failure with error message */
-type ParseInteractionResult = {
+export type ParseInteractionResult = {
     succeeded: true;
     value: InteractionRequestWire;
 } | {
@@ -89,14 +89,14 @@ type ParseInteractionResult = {
     error: string;
 };
 /** Parses an `interaction` event's data (`{ request }`) with the shared schema. */
-declare function parseInteractionRequest(data: Record<string, unknown> | undefined): ParseInteractionResult;
+export declare function parseInteractionRequest(data: Record<string, unknown> | undefined): ParseInteractionResult;
 /** Describe data required to cancel an interaction including its identifier and optional reason */
-interface InteractionCancelData {
+export interface InteractionCancelData {
     id: string;
     reason?: string;
 }
 /** Parse interaction cancel data and return success status with parsed value or error message */
-declare function parseInteractionCancel(data: Record<string, unknown> | undefined): {
+export declare function parseInteractionCancel(data: Record<string, unknown> | undefined): {
     succeeded: true;
     value: InteractionCancelData;
 } | {
@@ -104,24 +104,24 @@ declare function parseInteractionCancel(data: Record<string, unknown> | undefine
     error: string;
 };
 /** Determine if a chat interaction field allows free text input */
-declare function fieldAcceptsFreeText(field: ChatInteractionField): boolean;
+export declare function fieldAcceptsFreeText(field: ChatInteractionField): boolean;
 /** Define the structure for delivering answers linked to a specific chat interaction and field */
-interface ComposerAnswerDelivery {
+export interface ComposerAnswerDelivery {
     interactionId: string;
     field: ChatInteractionField;
 }
 /** One delivery per pending ask: the first free-text-capable field, else the
  *  first field. Zero-field asks are skipped (nothing to carry the text). */
-declare function composerAnswerDeliveries(pending: ChatInteraction[]): ComposerAnswerDelivery[];
+export declare function composerAnswerDeliveries(pending: ChatInteraction[]): ComposerAnswerDelivery[];
 /** Shapes composer text into the respond payload for the routed field
  *  (select answers are string arrays on the wire; text answers are strings). */
-declare function composerAnswerData(field: ChatInteractionField, text: string): InteractionData;
+export declare function composerAnswerData(field: ChatInteractionField, text: string): InteractionData;
 /** Generate a unique key string for an interaction using the given identifier */
-declare function interactionPartKey(id: string): string;
+export declare function interactionPartKey(id: string): string;
 /** Generate a unique key string for a notice using the given identifier */
-declare function noticePartKey(id: string): string;
+export declare function noticePartKey(id: string): string;
 /** Define specific string literals representing different kinds of notices */
-type NoticeKind = 'warning' | 'auto-declined';
+export type NoticeKind = 'warning' | 'auto-declined';
 /**
  * Persisted-part shapes the codecs below produce — the SAME rows
  * `/chat-store`'s `ChatInteractionPart`/`ChatNoticePart` store, typed at the
@@ -130,7 +130,7 @@ type NoticeKind = 'warning' | 'auto-declined';
  * signature keeps them assignable to the `Record<string, unknown>` these
  * codecs previously returned, so existing consumers stay source-compatible.
  */
-type InteractionPersistedPart = {
+export type InteractionPersistedPart = {
     type: 'interaction';
     id: string;
     kind: string;
@@ -144,7 +144,7 @@ type InteractionPersistedPart = {
     cancelReason?: string;
 };
 /** Define a persisted notice part with type, id, kind, and text properties */
-type NoticePersistedPart = {
+export type NoticePersistedPart = {
     type: 'notice';
     id: string;
     noticeKind: NoticeKind;
@@ -152,16 +152,14 @@ type NoticePersistedPart = {
 };
 /** Builds the persisted/streamed `notice` part — a one-line transcript notice
  *  explaining an out-of-band event (warning, auto-declined interaction). */
-declare function noticePart(noticeKind: NoticeKind, id: string, text: string): NoticePersistedPart;
+export declare function noticePart(noticeKind: NoticeKind, id: string, text: string): NoticePersistedPart;
 /** Reads a wire request into the client's pending `ChatInteraction`. */
-declare function interactionFromWireRequest(request: InteractionRequestWire): ChatInteraction;
+export declare function interactionFromWireRequest(request: InteractionRequestWire): ChatInteraction;
 /** Builds the persisted/streamed `interaction` part from a wire request. */
-declare function interactionToPersistedPart(request: InteractionRequestWire, status: ChatInteractionStatus, cancelReason?: string, answers?: InteractionAnswers): InteractionPersistedPart;
+export declare function interactionToPersistedPart(request: InteractionRequestWire, status: ChatInteractionStatus, cancelReason?: string, answers?: InteractionAnswers): InteractionPersistedPart;
 /** Stamps accepted values onto matching persisted interaction parts without
  * mutating the caller's transcript or answer maps. */
-declare function stampInteractionAnswers(parts: Array<Record<string, unknown>>, answersByInteractionId: Readonly<Record<string, InteractionAnswers>>): Array<Record<string, unknown>>;
+export declare function stampInteractionAnswers(parts: Array<Record<string, unknown>>, answersByInteractionId: Readonly<Record<string, InteractionAnswers>>): Array<Record<string, unknown>>;
 /** Reads a persisted/streamed `interaction` part back into a `ChatInteraction`.
  *  Returns null (caller logs) when the part is not one of ours. */
-declare function persistedPartToInteraction(part: Record<string, unknown>): ChatInteraction | null;
-
-export { noticePart as A, noticePartKey as B, type ChatInteractionField as C, parseInteractionAnswers as D, parseInteractionCancel as E, parseInteractionRequest as F, persistedPartToInteraction as G, questionInteractionContentSignature as H, type InteractionAnswers as I, stampInteractionAnswers as J, type NoticeKind as N, type ParseInteractionAnswersResult as P, type ChatInteractionStatus as a, type ChatInteraction as b, type InteractionCancelData as c, type ChatSelectField as d, type InteractionRequestWire as e, type ChatFreeTextField as f, type ComposerAnswerDelivery as g, INTERACTION_CANCEL_EVENT as h, INTERACTION_EVENT as i, INTERACTION_RESOLVED_EVENT as j, type InteractionAnswerValue as k, type InteractionPersistedPart as l, type NoticePersistedPart as m, type ParseInteractionResult as n, canTransitionInteractionStatus as o, cancelStatusFor as p, composerAnswerData as q, composerAnswerDeliveries as r, dedupeQuestionInteractionsByContent as s, fieldAcceptsFreeText as t, interactionFromWireRequest as u, interactionPartKey as v, interactionToPersistedPart as w, isRenderableInteractionKind as x, isSafeInteractionFieldKey as y, isTerminalInteractionStatus as z };
+export declare function persistedPartToInteraction(part: Record<string, unknown>): ChatInteraction | null;