@superxd-studio/adptr 0.5.0

package/types/reusable/interactions/web.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from "react";
+import type { AgentController } from "./agent.js";
+import type { ArtifactController } from "./artifact.js";
+import type { FeedbackController } from "./feedback.js";
+import type { ThreadController, ThreadDocument } from "./threads.js";
+export declare function AgentSupervision({ controller, label, }: {
+    controller: AgentController;
+    label?: string;
+}): import("react").JSX.Element;
+export declare function ArtifactWorkspace({ controller, label, }: {
+    controller: ArtifactController;
+    label?: string;
+}): import("react").JSX.Element;
+export declare function ResponseFeedback({ controller, label, }: {
+    controller: FeedbackController;
+    label?: string;
+}): import("react").JSX.Element;
+export declare function ConversationHistory({ controller, renderThread, label, }: {
+    controller: ThreadController;
+    renderThread: (thread: ThreadDocument) => ReactNode;
+    label?: string;
+}): import("react").JSX.Element;

package/types/reusable/langgraph-review/index.d.ts

@@ -0,0 +1,5 @@
+import { type ReviewProposal, type ReviewDecision, type ReviewReceipt } from "../review/types.js";
+export declare function createLangGraphReviewDriver(commit: (decision: ReviewDecision) => Promise<ReviewReceipt>): {
+    start(proposal: ReviewProposal, threadId: string): Promise<import("@langchain/langgraph").Interrupt<unknown> | undefined>;
+    resume(value: ReviewDecision, threadId: string): Promise<ReviewReceipt>;
+};

package/types/reusable/review/controller.d.ts

@@ -0,0 +1,52 @@
+import { type ReviewAdapter, type ReviewDecision, type ReviewRecord, type ReviewReceipt, type ReviewSnapshot } from "./types.js";
+type Action = {
+    type: "loading";
+} | {
+    type: "loaded";
+    record: ReviewRecord;
+} | {
+    type: "selected";
+    ids: readonly string[];
+} | {
+    type: "prepared";
+    decision: ReviewDecision;
+} | {
+    type: "back";
+} | {
+    type: "sending";
+} | {
+    type: "checking";
+} | {
+    type: "settled";
+    receipt: ReviewReceipt;
+} | {
+    type: "unapplied";
+} | {
+    type: "failed";
+    status: "load-error" | "uncertain" | "conflict" | "blocked";
+};
+/** One owner for the task, selection and immutable confirmation across all presentations. */
+export declare function reviewReducer(state: ReviewSnapshot, action: Action): ReviewSnapshot;
+export declare class ReviewController {
+    private adapter;
+    private newId;
+    private state;
+    private listeners;
+    private operation;
+    private generation;
+    constructor(adapter: ReviewAdapter, newId?: () => string);
+    getSnapshot: () => ReviewSnapshot;
+    subscribe: (callback: () => void) => (() => void);
+    private dispatch;
+    private run;
+    load: () => boolean;
+    select: (id: string, selected: boolean) => boolean;
+    prepare: (choice: ReviewDecision["choice"]) => boolean;
+    back: () => boolean;
+    private verifyReceipt;
+    submit: () => boolean;
+    recover: () => boolean;
+    /** End host-owned observation explicitly, never on a presentation unmount. Cannot undo server work. */
+    disconnect: () => void;
+}
+export {};

package/types/reusable/review/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./types.js";
+export { ReviewController, reviewReducer } from "./controller.js";
+import { type ReviewAdapter } from "./types.js";
+export interface HttpReviewOptions {
+    /** URL for an existing customer-owned review. Never place credentials in this URL. */
+    endpoint: string;
+    headers?: () => HeadersInit | Promise<HeadersInit>;
+    credentials?: RequestCredentials;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+}
+export declare function createHttpReviewAdapter(options: HttpReviewOptions): ReviewAdapter;

package/types/reusable/review/types.d.ts

@@ -0,0 +1,61 @@
+/** Portable review contract. The host owns authorization, revisions and side effects. */
+export interface ReviewChange {
+    readonly id: string;
+    readonly title: string;
+    readonly before: string;
+    readonly after: string;
+    readonly reason: string;
+}
+export interface ReviewProposal {
+    readonly id: string;
+    readonly revision: number;
+    readonly title: string;
+    readonly destination: string;
+    readonly changes: readonly ReviewChange[];
+    readonly canDecide: boolean;
+}
+export interface ReviewRecord {
+    readonly proposal: ReviewProposal;
+    readonly appliedIds: readonly string[];
+    readonly remainingIds: readonly string[];
+    readonly outcome: "pending" | "partial" | "complete" | "denied";
+}
+export interface ReviewDecision {
+    readonly requestId: string;
+    readonly proposalId: string;
+    readonly revision: number;
+    readonly choice: "approve" | "deny";
+    readonly changeIds: readonly string[];
+}
+export interface ReviewReceipt {
+    readonly requestId: string;
+    readonly choice: "approve" | "deny";
+    readonly appliedIds: readonly string[];
+    readonly record: ReviewRecord;
+}
+export interface ReviewRecovery {
+    readonly record: ReviewRecord;
+    readonly receipt: ReviewReceipt | null;
+}
+export interface ReviewAdapter {
+    load(signal: AbortSignal): Promise<ReviewRecord>;
+    decide(decision: ReviewDecision, signal: AbortSignal): Promise<ReviewReceipt>;
+    recover(requestId: string, signal: AbortSignal): Promise<ReviewRecovery>;
+}
+export type ReviewStatus = "idle" | "loading" | "ready" | "confirming" | "submitting" | "checking" | "load-error" | "uncertain" | "conflict" | "blocked" | "partial" | "complete" | "denied";
+export interface ReviewSnapshot {
+    readonly status: ReviewStatus;
+    readonly record: ReviewRecord | null;
+    readonly selectedIds: readonly string[];
+    readonly decision: ReviewDecision | null;
+    readonly issue: "not-applied" | null;
+}
+export declare class ReviewFault extends Error {
+    readonly kind: "conflict" | "blocked";
+    constructor(kind: "conflict" | "blocked");
+}
+export declare function parseReviewProposal(value: unknown): ReviewProposal;
+export declare function parseReviewDecision(value: unknown): ReviewDecision;
+export declare function parseReviewRecord(value: unknown): ReviewRecord;
+export declare function parseReviewReceipt(value: unknown): ReviewReceipt;
+export declare function parseReviewRecovery(value: unknown): ReviewRecovery;

package/types/reusable/ui/index.d.ts

@@ -0,0 +1,19 @@
+/** Standalone React web foundations, styled by the host's SuperXD tokens. */
+export * from "../../components/ui/selection.js";
+export * from "../../components/ui/navigation.js";
+export * from "../../components/ui/display.js";
+export { uiCopy } from "../../components/ui/copy.js";
+export { Button, ButtonLink, TextLink, buttonStyles } from "../../components/button.js";
+export type { ButtonProps, ButtonLinkProps, ButtonSize, ButtonVariant, } from "../../components/button.js";
+export type { TextFieldProps } from "../../components/text-field.js";
+export { Switch } from "../../components/switch.js";
+export { SearchPicker } from "../../components/search-picker.js";
+export { SegmentedControl } from "../../components/segmented-control.js";
+export { Callout } from "../../components/callout.js";
+export { Avatar } from "../../components/avatar.js";
+export { Skeleton } from "../../components/skeleton.js";
+export { Spinner } from "../../components/spinner.js";
+export { ScrollArea } from "../../components/scroll-area.js";
+export { ResponsiveOverlay } from "../../components/responsive-overlay.js";
+export { DateTimeField } from "../../components/date-time-field.js";
+export { ScenarioPicker } from "../../components/scenario-picker/index.js";

package/types/reusable/uploads/index.d.ts

@@ -0,0 +1,11 @@
+import { type UploadAdapter } from "../core/index.js";
+export interface HttpUploadOptions {
+    endpoint: string;
+    headers?: () => HeadersInit | Promise<HeadersInit>;
+    credentials?: RequestCredentials;
+    fetch?: typeof globalThis.fetch;
+    /** Consumer-provided deletion endpoint, only for draft references it owns. */
+    releaseEndpoint?: (id: string) => string;
+}
+/** Raw binary upload, with Unicode-safe filename metadata. Auth is consumer-owned. */
+export declare function createHttpUploadAdapter(options: HttpUploadOptions): UploadAdapter<Blob>;

package/types/reusable/web/attachments/copy.d.ts

@@ -0,0 +1,25 @@
+export declare const attachmentCopy: {
+    readonly label: "Attachments";
+    readonly add: "Add files";
+    readonly empty: "No files attached";
+    readonly uploading: "Uploading";
+    readonly ready: "Ready";
+    readonly error: "Upload failed";
+    readonly cancelled: "Upload stopped";
+    readonly rejected: "Can’t attach this file";
+    readonly remove: "Remove";
+    readonly retry: "Retry upload";
+    readonly cancel: "Stop upload";
+    readonly type: "Choose a supported file type.";
+    readonly size: "This file is empty or exceeds the size limit.";
+    readonly count: "The file limit is reached. Remove a file before adding more.";
+    readonly failed: "The file couldn’t upload. Retry or remove it; your message is still here.";
+    readonly unavailable: "File uploads aren’t available in this connection.";
+    readonly selected: "files selected";
+    readonly image: "Image";
+    readonly document: "Document";
+    readonly file: "File";
+};
+export type AttachmentCopy = {
+    [Key in keyof typeof attachmentCopy]: string;
+};

package/types/reusable/web/attachments/index.d.ts

@@ -0,0 +1,24 @@
+import { type AttachmentController, type AttachmentItem } from "../../core/index.js";
+import { type AttachmentCopy } from "./copy.js";
+export declare function useAttachments<Data>(controller: AttachmentController<Data>): import("../../core/attachments.js").AttachmentSnapshot;
+export interface AttachmentListProps {
+    items: readonly AttachmentItem[];
+    variant?: "list" | "grid" | "inline";
+    className?: string;
+    copy?: AttachmentCopy;
+    /** Explicit opt-in: host is responsible for trusting image origins. No PDFs/HTML are embedded. */
+    previewImages?: boolean;
+    onRemove?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    onCancel?: (id: string) => void;
+}
+/** Standalone supplied-data display; no chat, upload or vendor provider is required. */
+export declare function AttachmentList({ items, variant, className, copy, previewImages, onRemove, onRetry, onCancel, }: AttachmentListProps): import("react").JSX.Element;
+export interface AttachmentPickerProps {
+    controller: AttachmentController<Blob>;
+    isDisabled?: boolean;
+    description: string;
+    copy?: AttachmentCopy;
+    className?: string;
+}
+export declare function AttachmentPicker({ controller, isDisabled, description, copy, className, }: AttachmentPickerProps): import("react").JSX.Element;

package/types/reusable/web/copy.d.ts

@@ -0,0 +1,24 @@
+export declare const chatCopy: {
+    readonly label: "Conversation";
+    readonly emptyTitle: "What are you working on?";
+    readonly emptyNote: "Start with a question, an idea or something you want to make clearer.";
+    readonly user: "You";
+    readonly assistant: "Assistant";
+    readonly input: "Message";
+    readonly placeholder: "Ask a question or describe what you need";
+    readonly send: "Send message";
+    readonly stop: "Stop response";
+    readonly retry: "Restart response";
+    readonly hint: "Enter to send · Shift + Enter for a new line";
+    readonly touchHint: "Use Send to submit your message";
+    readonly idle: "";
+    readonly waiting: "Preparing a response";
+    readonly streaming: "Responding";
+    readonly complete: "Response ready";
+    readonly cancelled: "Response stopped. Your partial response is still here.";
+    readonly error: "The response couldn’t finish. Your message is still here.";
+    readonly interrupted: "The connection ended before the response finished. Restart to try again.";
+};
+export type ChatCopy = {
+    [Key in keyof typeof chatCopy]: string;
+};

package/types/reusable/web/index.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode } from "react";
+import type { ChatActions, ChatController, ChatFile, ChatMessage, ChatSnapshot } from "../core/index.js";
+export { AttachmentList, AttachmentPicker, useAttachments } from "./attachments/index.js";
+export type { AttachmentListProps, AttachmentPickerProps } from "./attachments/index.js";
+export { attachmentCopy } from "./attachments/copy.js";
+import { type ChatCopy } from "./copy.js";
+import { type MessageCopy } from "./message/index.js";
+export { BranchPicker, CopyButton, CodeBlock, MessageEditor, MessageMarkdown, StreamingMessage, messageCopy, } from "./message/index.js";
+export type { BranchPickerProps, CopyButtonProps, CodeBlockProps, MessageEditorProps, MessageMarkdownProps, MessageCopy, } from "./message/index.js";
+export type { ChatCopy } from "./copy.js";
+export type { ChatActions, ChatMessage, ChatSnapshot } from "../core/index.js";
+export declare function useChatController(controller: ChatController): ChatSnapshot;
+export interface ChatProps {
+    snapshot: ChatSnapshot;
+    actions: ChatActions;
+    copy?: ChatCopy;
+    className?: string;
+    /** Render supplied text using the application's safe Markdown renderer if wanted. */
+    renderMessage?: (message: ChatMessage) => ReactNode;
+    footer?: ReactNode;
+    attachmentPicker?: ReactNode;
+    draftFiles?: readonly ChatFile[];
+    isAttachmentBlocked?: boolean;
+    /** Clear a draft queue only after the state owner accepts the message. */
+    onSent?: () => void;
+    messageCopy?: MessageCopy;
+    writeText?: (text: string) => Promise<void>;
+    /** Opt into the existing bounded conversation height; follows only while at the bottom. */
+    scrollable?: boolean;
+    autoScroll?: boolean;
+    /** Prompts offered in an empty conversation. Choosing one puts it in the message box. */
+    suggestions?: readonly string[];
+    /** Text already in the message box when the conversation first appears. */
+    defaultDraft?: string;
+    /** A user message already open for editing when it first appears (specimens; no focus move). */
+    defaultEditing?: string;
+}
+/** A controlled presentation: state comes from the host, not a mandatory provider. */
+export declare function Chat({ snapshot, actions, copy, className, renderMessage, footer, attachmentPicker, draftFiles, isAttachmentBlocked, onSent, messageCopy: words, writeText, scrollable, autoScroll, suggestions, defaultDraft, defaultEditing, }: ChatProps): import("react").JSX.Element;
+export { DraftReview, ReviewChangeCard, ReviewDecisionPanel, useReview, reviewCopy, } from "./review/index.js";
+export type { DraftReviewProps, ReviewChangeCardProps, ReviewDecisionPanelProps, ReviewCopy, } from "./review/index.js";

package/types/reusable/web/message/copy.d.ts

@@ -0,0 +1,27 @@
+export declare const messageCopy: {
+    readonly copy: "Copy response";
+    readonly copyCode: "Copy code";
+    readonly copying: "Copying";
+    readonly copied: "Copied";
+    readonly copyFailed: "Couldn’t copy. Select the text and copy it instead.";
+    readonly code: "Code";
+    readonly table: "Response table";
+    readonly footnotes: "Notes";
+    readonly back: "Back to the reference";
+    readonly previous: "Previous version";
+    readonly next: "Next version";
+    readonly versions: "Message versions";
+    readonly version: "Version";
+    readonly edit: "Edit your message";
+    readonly editInput: "Edit message";
+    readonly save: "Save and resend";
+    readonly cancel: "Cancel edit";
+    readonly editNote: "Resending creates a new version. The original conversation stays available.";
+    readonly editFailed: "This message couldn’t be resent. Your edit is still here. Try again when the response has stopped.";
+    readonly regenerate: "Regenerate response";
+    readonly latest: "Jump to latest message";
+    readonly transcript: "Conversation messages";
+};
+export type MessageCopy = {
+    [Key in keyof typeof messageCopy]: string;
+};

package/types/reusable/web/message/index.d.ts

@@ -0,0 +1,56 @@
+import type { ChatBranch } from "../../core/index.js";
+import { type MessageCopy } from "./copy.js";
+export { messageCopy } from "./copy.js";
+export type { MessageCopy } from "./copy.js";
+export interface CopyButtonProps {
+    text: string;
+    label?: string;
+    iconOnly?: boolean;
+    isDisabled?: boolean;
+    copy?: MessageCopy;
+    /** Consumer-owned clipboard I/O. Rejections never report success. */
+    writeText?: (text: string) => Promise<void>;
+}
+export declare function CopyButton({ text, label, iconOnly, isDisabled, copy, writeText, }: CopyButtonProps): import("react").JSX.Element;
+export interface CodeBlockProps extends Pick<CopyButtonProps, "writeText" | "copy"> {
+    code: string;
+    language?: string;
+    className?: string;
+    isStreaming?: boolean;
+}
+/** Code is readable/copyable text, never executed or embedded. */
+export declare function CodeBlock({ code, language, className, isStreaming, writeText, copy, }: CodeBlockProps): import("react").JSX.Element;
+export declare function safeMarkdownUrl(url: string): string;
+export interface MessageMarkdownProps extends Pick<CodeBlockProps, "copy" | "writeText" | "isStreaming"> {
+    text: string;
+    className?: string;
+    /** The answer is arriving now: tint the newest words and show the cursor. */
+    streamingTail?: boolean;
+}
+/** Established CommonMark/GFM parser, without raw HTML, remote images or executable previews. */
+export declare function MessageMarkdown({ text, className, copy, writeText, isStreaming, streamingTail, }: MessageMarkdownProps): import("react").JSX.Element;
+/**
+ * A streaming answer, like assistant-ui's streaming text: the newest words arrive tinted in
+ * the info colour and fade back to plain text as more arrive; the cursor follows the
+ * last word. When the stream ends, it's ordinary text.
+ */
+export declare function StreamingMessage(props: Omit<MessageMarkdownProps, "isStreaming" | "streamingTail">): import("react").JSX.Element;
+export interface BranchPickerProps {
+    branch: ChatBranch;
+    isDisabled?: boolean;
+    onPrevious?: () => void;
+    onNext?: () => void;
+    copy?: MessageCopy;
+}
+export declare function BranchPicker({ branch, isDisabled, onPrevious, onNext, copy, }: BranchPickerProps): import("react").JSX.Element | null;
+export interface MessageEditorProps {
+    text: string;
+    /** Enable only for an editor opened by the visitor. Specimens do not move focus. */
+    autoFocus?: boolean;
+    hasFiles?: boolean;
+    isDisabled?: boolean;
+    onSave: (text: string) => boolean;
+    onCancel: () => void;
+    copy?: MessageCopy;
+}
+export declare function MessageEditor({ text, autoFocus, hasFiles, isDisabled, onSave, onCancel, copy, }: MessageEditorProps): import("react").JSX.Element;

package/types/reusable/web/message/streaming.d.ts

@@ -0,0 +1,27 @@
+interface Text {
+    type: "text";
+    value: string;
+}
+interface Element {
+    type: "element";
+    tagName: string;
+    properties: Record<string, unknown>;
+    children: Node[];
+}
+type Node = Text | Element | {
+    type: string;
+    children?: Node[];
+};
+interface Root {
+    type: "root";
+    children: Node[];
+}
+/**
+ * For an answer that is still arriving: wraps each word so the newest ones can be tinted, and
+ * puts the cursor after the last word. The tint fades back to plain text (see library.css) as
+ * newer words arrive. Modelled on assistant-ui's streaming text.
+ */
+export declare function rehypeStreamingTail({ fresh }?: {
+    fresh?: number;
+}): (tree: Root) => void;
+export {};

package/types/reusable/web/review/copy.d.ts

@@ -0,0 +1,72 @@
+export declare const reviewCopy: {
+    readonly proposed: "Proposed changes";
+    readonly before: "Current";
+    readonly after: "Proposed";
+    readonly reason: "Why this change";
+    readonly applied: "Applied";
+    readonly unchanged: "Unchanged";
+    readonly viewChange: (title: string) => string;
+    readonly selectChange: (title: string) => string;
+    readonly selected: (n: number, total: number) => string;
+    readonly review: (n: number) => string;
+    readonly apply: (n: number) => string;
+    readonly complete: (n: number) => string;
+    readonly kept: (n: number) => string;
+    readonly confirm: "Confirm your decision";
+    readonly summary: "Your selection";
+    readonly target: "Apply to";
+    readonly applying: "Applying";
+    readonly checking: "Checking status";
+    readonly noSelection: "Choose the changes you want to keep.";
+    readonly approvalNote: "Only these changes will be applied. The rest stay as they are.";
+    readonly deny: "Decline all";
+    readonly declineRemaining: "Decline remaining";
+    readonly declineRemainingTitle: "Decline the remaining changes?";
+    readonly declineRemainingNote: "Applied changes are kept. The remaining changes will stay as they were.";
+    readonly denyConfirm: "Decline these changes?";
+    readonly denyAction: "Decline changes";
+    readonly denyNote: "The current draft will stay as it is.";
+    readonly denied: "Changes declined";
+    readonly deniedNote: "The draft is unchanged.";
+    readonly back: "Back to review";
+    readonly retry: "Try again";
+    readonly check: "Check status";
+    readonly reload: "Review latest draft";
+    readonly loading: "Preparing your review";
+    readonly loadingNote: "The proposed changes are being loaded.";
+    readonly loadError: "The review couldn’t be loaded.";
+    readonly loadErrorNote: "Try again to see the proposed changes.";
+    readonly uncertain: "Let’s check what happened.";
+    readonly uncertainNote: "Your decision may have reached the server. Check its status before trying again. Your choices are kept.";
+    readonly notApplied: "No changes recorded yet.";
+    readonly notAppliedNote: "Your choices are kept. You can check again or confirm the same decision.";
+    readonly conflict: "The draft has changed.";
+    readonly conflictNote: "Nothing from this decision was applied. Review the latest draft before deciding again.";
+    readonly blocked: "You can view this review.";
+    readonly blockedNote: "You don’t have permission to apply or decline these changes.";
+    readonly partial: (applied: number, left: number) => string;
+    readonly partialNote: "The applied changes are kept. Review the remaining changes before trying them again.";
+    readonly empty: "No changes to review";
+    readonly emptyNote: "The current draft is unchanged.";
+    readonly unavailable: "Review not available";
+    readonly announcement: {
+        readonly ready: "Changes ready to review.";
+        readonly confirming: "Decision ready to confirm.";
+        readonly submitting: "Applying your decision.";
+        readonly checking: "Checking your decision’s status.";
+        readonly partial: "Some changes were applied. Review the remaining changes.";
+        readonly complete: "Selected changes applied.";
+        readonly denied: "Changes declined. The draft is unchanged.";
+        readonly conflict: "The draft changed. Review it again.";
+        readonly blocked: "You do not have permission to decide.";
+        readonly uncertain: "Check status before retrying your decision.";
+        readonly "load-error": "The review could not be loaded.";
+        readonly loading: "Preparing your review.";
+        readonly idle: "";
+    };
+};
+type CustomWords<T> = {
+    [K in keyof T]: T[K] extends string ? string : T[K] extends (...args: infer A) => string ? (...args: A) => string : CustomWords<T[K]>;
+};
+export type ReviewCopy = CustomWords<typeof reviewCopy>;
+export {};

package/types/reusable/web/review/flow.d.ts

@@ -0,0 +1,3 @@
+import { type FlowType } from "../../../components/flow-motion.js";
+import type { ReviewStatus } from "../../review/types.js";
+export declare function reviewFlow(from: ReviewStatus, to: ReviewStatus): FlowType | null;

package/types/reusable/web/review/index.d.ts

@@ -0,0 +1,38 @@
+import type { ReviewChange, ReviewSnapshot } from "../../review/types.js";
+import type { ReviewController } from "../../review/controller.js";
+import { type ReviewCopy } from "./copy.js";
+export { reviewCopy } from "./copy.js";
+export type { ReviewCopy } from "./copy.js";
+export interface ReviewChangeCardProps {
+    change: ReviewChange;
+    isSelected?: boolean;
+    onSelectionChange?: (selected: boolean) => void;
+    isDisabled?: boolean;
+    isApplied?: boolean;
+    isExpanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    /** Side-by-side comparison on a roomy canvas. The content remains the same. */
+    comparison?: "columns" | "stacked";
+    copy?: ReviewCopy;
+}
+export declare function ReviewChangeCard({ change, isSelected, onSelectionChange, isDisabled, isApplied, isExpanded, onExpandedChange, comparison, copy, }: ReviewChangeCardProps): import("react").JSX.Element;
+export interface ReviewDecisionPanelProps {
+    snapshot: ReviewSnapshot;
+    headingLevel?: 2 | 3;
+    onReview: () => void;
+    onDecline: () => void;
+    onConfirm: () => void;
+    onBack: () => void;
+    onRecover: () => void;
+    onReload: () => void;
+    copy?: ReviewCopy;
+}
+/** Provider-free decision display. The controller and the server, not this panel, own authority. */
+export declare function ReviewDecisionPanel({ snapshot: s, headingLevel, onReview, onDecline, onConfirm, onBack, onRecover, onReload, copy, }: ReviewDecisionPanelProps): import("react").JSX.Element;
+export declare function useReview(controller: ReviewController): ReviewSnapshot;
+export interface DraftReviewProps {
+    controller: ReviewController;
+    copy?: ReviewCopy;
+    className?: string;
+}
+export declare function DraftReview(props: DraftReviewProps): import("react").JSX.Element;

package/types/reusable/web/styles.d.ts

@@ -0,0 +1,2 @@
+import "../../styles/library.css";
+import "./message/styles.css";

package/ui/index.js

@@ -0,0 +1,4 @@
+"use client";
+import { a as e, i as t, n, o as r, r as i, t as a } from "../chunks/callout-DKMHSnjc.js";
+import { A as o, C as s, D as c, E as l, F as u, M as d, N as f, O as p, P as m, S as h, T as g, _, a as v, b as y, c as b, d as x, f as S, g as C, h as w, i as T, j as E, k as D, l as O, m as k, n as A, o as j, p as M, r as N, s as P, t as F, u as I, v as L, w as R, x as z, y as B } from "../chunks/ui-9DyNsYXY.js";
+export { y as Accordion, I as AspectRatio, j as Avatar, x as Badge, z as Breadcrumbs, n as Button, i as ButtonLink, a as Callout, S as Card, c as Checkbox, p as CheckboxGroup, M as DataTable, A as DateTimeField, D as Form, k as KeyboardHint, h as Menu, s as ModalDialog, R as Pagination, w as Progress, o as RadioGroup, N as ResponsiveOverlay, F as ScenarioPicker, T as ScrollArea, b as SearchPicker, P as SegmentedControl, E as Select, C as Separator, v as Skeleton, d as Slider, r as Spinner, O as Switch, g as Tabs, f as TextField, t as TextLink, _ as ToastRegion, m as Toggle, l as Tooltip, e as buttonStyles, L as createNotificationQueue, B as sortRows, u as uiCopy };

package/uploads/index.js

@@ -0,0 +1,34 @@
+import { i as e } from "../chunks/core-BCqVRLUy.js";
+//#region src/reusable/uploads/index.ts
+function t(t) {
+	let n = t.fetch ?? globalThis.fetch, r = t.releaseEndpoint;
+	return {
+		async upload(r, i) {
+			let a = await n(t.endpoint, {
+				method: "POST",
+				signal: i,
+				credentials: t.credentials ?? "same-origin",
+				headers: {
+					...Object.fromEntries(new Headers(await t.headers?.()).entries()),
+					"content-type": r.mediaType,
+					"x-file-name": encodeURIComponent(r.name),
+					"x-upload-id": r.id ?? globalThis.crypto.randomUUID()
+				},
+				body: r.data
+			});
+			if (!a.ok || !a.headers.get("content-type")?.startsWith("application/json")) throw Error("Upload unavailable");
+			let o = await a.text();
+			if (o.length > 1e4) throw Error("Upload reference too large");
+			return e(JSON.parse(o));
+		},
+		...r ? { async release(e) {
+			if (!(await n(r(e.id), {
+				method: "DELETE",
+				credentials: t.credentials ?? "same-origin",
+				headers: await t.headers?.()
+			})).ok) throw Error("Release unavailable");
+		} } : {}
+	};
+}
+//#endregion
+export { t as createHttpUploadAdapter };