akanjs 3.0.0-beta.9 → 3.0.0

package/types/ui/Agent/agentSessionOf.d.ts

@@ -1,27 +1,31 @@
-import { type AgentRunner, AgentSession, type AgentSessionOptions, type CompactOptions, type SessionHistory } from "../../vendor/use-agentic.d.ts";
-import { type PersistOption } from "./sessionHistory.d.ts";
-import { type BuiltinOption } from "./sessionView.d.ts";
+import { type AgentVisualOption, StoreSurfaceSource } from "akanjs/store";
+import { type AgenticSurface, type AgentRunner, AgentSession, type AgentSessionOptions, type CompactOptions, type SessionHistory, type SurfaceView } from "../../vendor/use-agentic.d.ts";
+/** A tool the akan runtime contributes to every screen, whatever that screen declares. */
+export type AgentBuiltin = (typeof StoreSurfaceSource.builtins)[number];
+/** `true` (the default) takes all of them, `false` none, an array exactly the ones it names. */
+export type BuiltinOption = boolean | AgentBuiltin[];
+export type PersistOption = boolean | {
+    storage?: "session" | "local";
+    key?: string;
+};
 export interface AgentSessionSetup {
-    /** Read per call rather than captured, so text the session builds follows a language switched mid-conversation. */
+    /** Read per call, so the session's own text follows a language switched mid-conversation. */
     l: (key: string) => string;
-    /** The zone's scope path, empty for the root agent — it picks both the surface view and the persistence key. */
+    /** The zone's scope path, empty for the root agent; it picks both the surface view and the persistence key. */
     view?: string[];
     runner?: AgentRunner;
     instructions?: string;
     maxTurns?: number;
     compact?: CompactOptions;
-    /**
-     * Which of the runtime's own tools this session gets: all of them by default, none with `false`, exactly the
-     * ones an array names. A zone whose conversation must stay on one screen takes `navigate` and `goBack` off it.
-     */
+    /** Every runtime tool by default, `false` none, an array exactly the ones it names. */
     builtins?: BuiltinOption;
-    /** Web storage by default; a `SessionHistory` puts the transcript wherever the app keeps it, including a server. */
+    /** Web storage by default, or an app `SessionHistory`. */
     persist?: PersistOption | SessionHistory;
-    /** Called after a compaction replaced messages with one summary — where a host syncs its own watermark. */
+    /** Called after a compaction replaced messages with one summary. */
     onCompact?: AgentSessionOptions["onCompact"];
+    /** `false` draws nothing while this session drives the page. */
+    visual?: boolean | AgentVisualOption;
 }
-/**
- * The one place a chat session is wired to the akan runtime. Chat and Zone both build one, and building it twice
- * is how a zone came to be the only surface with no `compact` option — an option added on one side of a copy.
- */
-export declare const agentSessionOf: ({ l, view, runner, instructions, maxTurns, compact, builtins, persist, onCompact, }: AgentSessionSetup) => AgentSession;
+export declare const agentSessionOf: ({ l, view, runner, instructions, maxTurns, compact, builtins, persist, onCompact, visual, }: AgentSessionSetup) => AgentSession;
+export declare const sessionView: (surface: AgenticSurface, path: string[], builtins?: BuiltinOption) => SurfaceView;
+export declare const sessionHistoryOf: (persist: PersistOption | SessionHistory | undefined, pathKey?: string) => SessionHistory | undefined;

package/types/ui/Agent/attachment.d.ts

@@ -1,57 +1,23 @@
 import type { MessageAttachment } from "../../vendor/use-agentic.d.ts";
-/** Turns one picked file into an attachment, or `null` to say this reader does not handle that file. */
+/** `null` leaves the file to the built-in reader. */
 export type AttachReader = (file: File) => Promise<MessageAttachment | null>;
-/**
- * Per-file ceiling for the composer. The bytes ride inside one turn's JSON request, so a file past this is not a
- * slow attachment — it is a request the relay and the provider both refuse, and refusing it here is the only place
- * the user learns which file it was.
- */
+/** The bytes ride inside one turn's JSON request, which the relay and the provider both refuse past this. */
 export declare const maxAttachmentBytes: number;
-/**
- * Ceilings for one message rather than one file. The bytes ride inside a single turn's JSON, so what a provider
- * refuses is the sum — and a count cap keeps a whole folder dropped onto the panel from becoming one request that
- * cannot be sent and cannot be edited down without starting over.
- */
+/** A provider refuses the sum of one turn's attachments, not each file. */
 export declare const maxMessageAttachmentBytes: number;
 export declare const maxMessageAttachments = 5;
-/**
- * What the three ceilings above are for an app that knows better. They are a property of the provider the relay is
- * configured with — a larger request limit, or a reader that attaches by `url` and pays none of it — so the
- * defaults are the conservative answer rather than the only one.
- */
 export interface AttachLimits {
-    /** What one attachment may cost the request, measured on what the reader produced. */
+    /** Measured on what the reader produced, not on the source file. */
     perFileBytes?: number;
-    /** What every attachment on one message may cost together. */
     perMessageBytes?: number;
-    /** How many attachments one message may carry. */
     perMessageCount?: number;
 }
 export type AttachFailure = "tooLarge" | "unsupported";
 export declare class Attachment {
     #private;
-    /**
-     * Reads what a browser can read on its own — an image as bytes, a text-ish file as text — and hands everything
-     * else to the app's own reader. That split is the layer boundary: a PDF needs a parser, so extracting one is the
-     * app's business (`attach`), while carrying the result is the framework's.
-     *
-     * The app's reader runs first so it can also replace the built-in handling, which is what downscaling an image
-     * before it costs a megabyte of prompt looks like — and it runs before the ceiling too, because the ceiling is
-     * what the attachment costs the request, which is what the reader decides. A reader that answers a `url` has
-     * already paid it; refusing its file on the source size would refuse it for a cost it does not incur. The
-     * built-in carriers are the file itself, so there the source size *is* the cost, and checking it up front is
-     * also what keeps a huge `arrayBuffer` from being read in order to be refused.
-     */
     static read(file: File, attach?: AttachReader, limits?: AttachLimits): Promise<MessageAttachment | AttachFailure>;
     static failure(value: MessageAttachment | AttachFailure): value is AttachFailure;
-    /** What this attachment costs the request: base64 carries three bytes per four characters, less its padding. */
     static bytesOf(attachment: MessageAttachment): number;
-    /** Which message ceiling these would pass together, or null when one message can carry them all. */
     static overflow(attachments: readonly MessageAttachment[], limits?: AttachLimits): "tooMany" | "tooMuch" | null;
-    /**
-     * Same name and same size is the same file picked twice — the shape a re-drop or a double paste produces. A
-     * host that can name a file says so with `ref`, and then that is the answer: name and size collide for two
-     * crops of one export, which is a wrong `true` the heuristic cannot avoid and an id never reaches.
-     */
     static same(one: MessageAttachment, other: MessageAttachment): boolean;
 }

package/types/ui/Agent/fetchRunner.d.ts

@@ -1,12 +1,5 @@
 import { type AgentRunner } from "../../vendor/use-agentic.d.ts";
-/**
- * Runs each assistant turn against the app's own `runAgentTurn` route — service signals mount unprefixed, so the
- * URL is `<serverHttpUri>/runAgentTurn` — through the shared `httpRunner`, which negotiates streaming via
- * `accept`: a server that streams answers SSE and the text arrives as it is generated; one that does not answers
- * the same JSON turn. The client runtime's fetch proxy is only probed for whether the endpoint exists (the util
- * lib ships one) and for the signed-in JWT; cookies ride the same-origin request on their own. The endpoint is a
- * stateless relay; the loop and every tool execution stay in this browser session.
- */
+/** Runs each turn against `<serverHttpUri>/runAgentTurn` (service signals mount unprefixed) through `httpRunner`. */
 export declare const fetchRunner: (options?: {
     fetcher?: typeof globalThis.fetch;
 }) => AgentRunner;

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

@@ -1,19 +1,15 @@
-import Context from "./Context.d.ts";
-import Section from "./Section.d.ts";
-import StateKey from "./StateKey.d.ts";
-import Tool from "./Tool.d.ts";
-import Transcript from "./Transcript.d.ts";
+import { Context, Section, StateKey, Tool, Transcript } from "./Dock.d.ts";
 export declare const Agent: {
     Chat: import("react").ComponentType<import("./Chat.d.ts").ChatProps>;
     Context: typeof Context;
-    Dock: ({ className, bridge, surface, open }: import("./Dock.d.ts").DockProps) => import("react/jsx-runtime").JSX.Element | null;
+    Dock: ({ className, bridge, surface, open }: import("./Dock.d.ts").DockProps) => import("react").JSX.Element | null;
     Guide: ({ instructions }: import("./Guide.d.ts").GuideProps) => null;
     History: ({ load, save, clear, onCompact }: import("./History.d.ts").HistoryProps) => null;
-    Scope: ({ id, label, kind, children }: import("../../vendor/use-agentic.d.ts").AgentScopeProps) => import("react/jsx-runtime").JSX.Element;
+    Scope: ({ id, label, kind, children }: import("../../vendor/use-agentic.d.ts").AgentScopeProps) => import("react").JSX.Element;
     Section: typeof Section;
-    Skip: ({ className, label, children }: import("./Skip.d.ts").SkipProps) => import("react/jsx-runtime").JSX.Element;
+    Skip: ({ className, label, children }: import("./Skip.d.ts").SkipProps) => import("react").JSX.Element;
     StateKey: typeof StateKey;
     Tool: typeof Tool;
     Transcript: typeof Transcript;
-    Zone: ({ className, id, label, instructions, runner, maxTurns, compact, builtins, persist, onCompact, session: provided, onSession, children, }: import("./Zone.d.ts").ZoneProps) => import("react/jsx-runtime").JSX.Element;
+    Zone: ({ className, id, label, instructions, runner, maxTurns, compact, builtins, persist, onCompact, visual, session: provided, onSession, children, }: import("./Zone.d.ts").ZoneProps) => import("react").JSX.Element;
 };

package/types/ui/Agent/mentionDraft.d.ts

@@ -0,0 +1,9 @@
+import { type LexicalNode } from "lexical";
+export declare class MentionDraft {
+    #private;
+    static read(): string;
+    static write(text: string, caretAt?: number): void;
+    static nodesOf(text: string): LexicalNode[];
+    static caret(): number | null;
+    static place(at: number): void;
+}

package/types/ui/Agent/tokenCount.d.ts

@@ -1,6 +1,2 @@
-/**
- * An estimated token count as a chat-sized label. Rounded hard on purpose: the estimate itself is four characters
- * to a token, so a digit-exact figure would claim a precision it does not have — what a reader needs from it is
- * whether a tool result cost a hundred tokens or a million.
- */
+/** Rounded hard: the estimate is four characters to a token, so exact digits would claim false precision. */
 export declare const tokenCount: (count: number) => string;

package/types/ui/Agent/useChatAttachments.d.ts

@@ -7,11 +7,6 @@ interface ChatAttachmentsSetup {
     limits?: AttachLimits;
     l: (key: string, param?: Record<string, string | number>) => string;
 }
-/**
- * What the composer is holding, and the ceilings it holds it under. Staged files are mirrored in a ref because a
- * multi-file drop reads them one at a time: the cap has to see what the previous file of the same drop added, and
- * React state inside that loop is still the value the render started with.
- */
 export declare const useChatAttachments: ({ session, attach, limits, l }: ChatAttachmentsSetup) => {
     attached: MessageAttachment[];
     pending: number;

package/types/ui/Agent/useChatQueue.d.ts

@@ -1,35 +1,22 @@
 import type { AgentSession, MessageAttachment, MessageReference } from "../../vendor/use-agentic.d.ts";
 import { type AttachLimits } from "./attachment.d.ts";
-/** What the composer held when it was sent: the shape a turn opens with, whether now or after the running one. */
 export interface QueuedMessage {
     text: string;
     attachments: MessageAttachment[];
-    /** What the parked text's tokens pointed at. Carried so a turn that opens later still knows what they held. */
     references: MessageReference[];
-    /** The ask came from the microphone, so the reply it gets is read aloud — carried until the send that opens it. */
+    /** The ask came from the microphone, so its reply is read aloud. */
     byVoice: boolean;
 }
 interface ChatQueueSetup {
     session: AgentSession;
     limits?: AttachLimits;
-    /** The chat's own version snapshot — the turn ending is one of the changes it counts. */
     version: number;
     l: (key: string, param?: Record<string, string | number>) => string;
     onFlush: (message: QueuedMessage) => void;
 }
-/**
- * One message parked while a turn runs, sent the moment the turn ends. One slot rather than a list: a second send
- * joins the first, so what reaches the model is one user message and the user has one thing to take back or drop.
- *
- * Mirrored in a ref because the flush and the drop both race the turn's own wind-down: `/new` empties the slot
- * and then aborts, and the abort's notify would otherwise read the state the render started with and send what
- * was just dropped.
- */
 export declare const useChatQueue: ({ session, limits, version, l, onFlush }: ChatQueueSetup) => {
     queued: QueuedMessage | null;
-    /** Parks a message, joined onto one already waiting. False, with the reason noted, when the files would not fit. */
     push: (message: QueuedMessage) => boolean;
-    /** Empties the slot and answers what was in it — the drop, and the first half of handing it back. */
     take: () => QueuedMessage | null;
 };
 export {};

package/types/ui/Agent/useChatReferences.d.ts

@@ -1,26 +1,15 @@
 import { type RefObject } from "react";
 import { type AgentSession, type MessageReference } from "../../vendor/use-agentic.d.ts";
+import type { ComposerHandle } from "./Composer.d.ts";
 interface ChatReferencesSetup {
     session: AgentSession;
     draft: string;
-    /** The chat's own version snapshot — a `refer` from anywhere on the page is one of the changes it counts. */
     version: number;
-    inputRef: RefObject<HTMLTextAreaElement | null>;
+    handleRef: RefObject<ComposerHandle | null>;
     onDraft: (text: string) => void;
 }
-/**
- * The composer's half of a reference: writing the token for one somebody pointed at elsewhere, and reading back
- * which references the draft now carries.
- *
- * **The text is the source of truth, and the staged values are looked up beside it.** A reference is on the
- * message because its token is in the message — so deleting the token by hand drops it, exactly as deleting the
- * chip does, and neither can leave the other behind. The draft is never scanned to re-derive a value; a token
- * whose value was never staged (pasted out of an earlier message) travels as a pointer with a note saying to read
- * it again, which is the same shape a restored conversation produces.
- */
-export declare const useChatReferences: ({ session, draft, version, inputRef, onDraft }: ChatReferencesSetup) => {
+export declare const useChatReferences: ({ session, draft, version, handleRef, onDraft }: ChatReferencesSetup) => {
     references: MessageReference[];
-    /** Removing the chip removes the token, because the token is what puts the reference on the message. */
     remove: (key: string) => void;
 };
 export {};

package/types/ui/Agent/useChatVoice.d.ts

@@ -3,28 +3,16 @@ import { type VoiceEngine } from "./voice.d.ts";
 interface ChatVoiceSetup {
     session: AgentSession;
     engine?: VoiceEngine;
-    /** The chat's own version snapshot — every transcript change re-runs the reading policy. */
     version: number;
     onTranscript: (text: string) => void;
     onFailed: () => void;
 }
-/**
- * The chat's speech policy, which is the framework's and not the engine's: one utterance per press, the
- * transcript landing in the composer to be corrected, barge-in on the next press or on Stop, and a reply read
- * aloud **only when the ask arrived by voice** — a typed question never turns the speakers on.
- *
- * A question or an approval the loop parked on is read too, and only in that same case: the loop stops there,
- * and a voice user staring at a card they were never told about is a conversation that simply ends.
- */
 export declare const useChatVoice: ({ session, engine, version, onTranscript, onFailed }: ChatVoiceSetup) => {
     listening: boolean;
-    /** A screen that cannot listen renders no microphone — the rule that publishes no tool for a missing control. */
     canListen: boolean;
     silence: () => void;
     lift: () => boolean;
-    /** Puts a lifted flag back, for a parked ask that returned to the composer instead of opening a turn. */
     hold: (spokenAsk: boolean) => void;
-    /** Called by the send that opens a turn: only an ask that arrived by voice is answered out loud. */
     take: (spokenAsk?: boolean) => void;
     toggle: () => void;
 };

package/types/ui/Agent/useDraftRecall.d.ts

@@ -1,14 +1,6 @@
 import type { ChatMessage } from "../../vendor/use-agentic.d.ts";
-/**
- * ↑ walks back through what was sent, ↓ forward, and 0 is the draft it was walked away from. A single-line input
- * does nothing of its own with the vertical arrows, so recall is free to take them.
- *
- * Seeded from the transcript rather than starting empty, because a persisted chat restores the conversation and
- * losing only "what I just typed" across a reload is the one gap a user notices.
- */
 export declare const useDraftRecall: (messages: readonly ChatMessage[]) => {
     has: boolean;
     remember: (text: string) => void;
-    /** Answers the draft to show, or null when the walk cannot go that way. */
     step: (delta: number, draft: string) => string | null;
 };

package/types/ui/Agent/useKeyboardInset.d.ts

@@ -1,8 +1 @@
-/**
- * How much of the layout viewport the on-screen keyboard is covering.
- *
- * `visualViewport` is the only thing that reports it — `dvh` tracks the browser's own chrome and not the
- * keyboard — and a full-screen chat whose composer sits under the keyboard is one nobody can type into. Answers
- * 0 wherever the API is absent, which is every desktop case and the server.
- */
 export declare const useKeyboardInset: () => number;

package/types/ui/Agent/useReferenceMenu.d.ts

@@ -1,28 +1,20 @@
 import { type AgentFieldType } from "akanjs/store";
 import { type AgentSession } from "../../vendor/use-agentic.d.ts";
 import type { MenuRow } from "./Menu.d.ts";
-/** One row the `@` menu offers: a document of its source's model, named the way the screen names it. */
 export interface ReferenceCandidate {
     refId: string;
     label: string;
     description?: string;
 }
-/**
- * A kind of document the `@` menu can point at.
- *
- * `type` is the whole decision about what leaves the browser, in `st.expose`'s vocabulary — a model class masks by
- * that model. **Name the class that actually carries the fields somebody is pointing at**: a `Light<Model>` is
- * usually not it, and a reference masked by one arrives without the field that was the reason for pointing.
- *
- * `search` is the app's own query, because which documents a person may point at is the app's answer and not the
- * framework's; the signal is aborted when the query moves on. `resolve` is called once, when a row is picked.
- */
 export interface ReferenceSource<T extends AgentFieldType = AgentFieldType> {
     refName: string;
     /** What this group of rows is called in the menu. */
     label: string;
+    /** Masks what leaves the browser: name the class carrying the pointed-at fields, which a `Light<Model>` rarely is. */
     type: T;
+    /** The signal aborts when the query moves on. */
     search: (query: string, signal: AbortSignal) => Promise<ReferenceCandidate[]>;
+    /** Called once, when a row is picked. */
     resolve: (refId: string) => Promise<unknown>;
 }
 interface ReferenceMenuSetup {

package/types/ui/Agent/useSlashMenu.d.ts

@@ -5,11 +5,9 @@ interface SlashMenuSetup {
     l: (key: string) => string;
     onCommand: (command: ChatCommand) => void;
 }
-/** The `/` menu's rows — this chat's own commands — and which one the keys are on. */
 export declare const useSlashMenu: ({ draft, l, onCommand }: SlashMenuSetup) => {
     rows: MenuRow[];
     selected: number;
-    /** Reset when the draft is written to: a new query has a new first row, and Escape only hides the old one. */
     reopen: () => void;
     hide: () => void;
     move: (delta: number) => void;

package/types/ui/Agent/voice.d.ts

@@ -1,70 +1,36 @@
-/** A recognition run in progress. `stop` ends it; a final result may still arrive after. */
+/** A final result may still arrive after `stop`. */
 export interface VoiceListener {
     stop: () => void;
 }
-/** One utterance being spoken. `cancel` is barge-in; `done` resolves when it finished or was cancelled. */
+/** `done` resolves when the utterance finished or was cancelled. */
 export interface VoiceSpeech {
     cancel: () => void;
     done: Promise<void>;
 }
 export interface VoiceHandlers {
-    /** Partial text while the user is still speaking. An engine without interim results simply never calls it. */
+    /** Partial text while the user is still speaking; an engine without interim results never calls it. */
     onInterim?: (text: string) => void;
     onFinal: (text: string) => void;
     onError: (message: string) => void;
 }
-/**
- * The seam a voice engine fills — one contract, whatever is behind it: the browser's own recognition, a cloud
- * STT/TTS pair, or a native plugin. The engine speaks and listens; **the framework owns the policy** — when to
- * listen, what to speak, sentence chunking, barge-in, and whether a reply is spoken at all.
- *
- * Shaped as a subscription rather than `listen(): Promise<string>` on purpose. A promise fits push-to-talk and
- * nothing else, and continuous listening could then only arrive as a breaking change; this shape carries both, so
- * hands-free is a later policy decision instead of a later contract.
- *
- * `listen` must be reachable from the click that starts it: microphone permission and, on iOS, the first
- * `speechSynthesis` utterance are both gated on a user gesture.
- */
+/** `listen` must run inside the click that starts it: mic permission and iOS's first utterance need a user gesture. */
 export interface VoiceEngine {
     listen: (handlers: VoiceHandlers) => VoiceListener;
-    /** One sentence at a time, already stripped of markdown. The framework queues; the engine speaks. */
+    /** Handed one markdown-free sentence at a time; the framework queues. */
     speak: (text: string) => VoiceSpeech;
-    /** Answering false hides the controls — a screen that cannot listen should not offer a microphone. */
+    /** `false` hides the microphone. */
     available?: () => boolean;
 }
-/**
- * What of a model's answer should be read aloud.
- *
- * Code blocks, tables, and rules are dropped rather than spoken: a fence read character by character is noise,
- * and a table read cell by cell is worse than silence — in push-to-talk the user is looking at the screen that
- * already renders both. Inline code keeps its content, because that is usually a name worth hearing.
- *
- * Monotonic over a growing source, which is what lets the reader below track one offset: new text never changes
- * how earlier text was rendered, since a fence marker always arrives before the lines it swallows.
- */
 export declare const speechText: (markdown: string) => string;
-/**
- * Reads an assistant answer aloud as it streams in, one sentence at a time.
- *
- * Sentence-at-a-time rather than delta-at-a-time because a delta cuts words in half, and whole-message-at-a-time
- * because that waits for the turn to end. The offset is over `speechText` output, not the raw source, so a code
- * block that arrives mid-answer costs nothing.
- */
 export declare class VoiceReader {
     #private;
     constructor(engine: () => VoiceEngine | undefined);
     get speaking(): boolean;
     /** Call with the whole answer so far, as often as it changes; already-spoken text is never repeated. */
     feed(source: string): void;
-    /**
-     * The turn ended: the last sentence has no whitespace behind it and would otherwise never be spoken. It still
-     * splits what is left, because a whole answer that arrived in one render must not be read as one long utterance.
-     */
+    /** The turn ended: also speaks the last sentence, which has no whitespace behind it. */
     flush(source: string): void;
-    /**
-     * A line that is not part of the answer being tracked — the question or approval the loop parked on. It joins
-     * the same queue, so it is spoken after the sentence in flight rather than over it, and Stop still cancels it.
-     */
+    /** Queued behind the sentence in flight, outside the tracked answer; Stop still cancels it. */
     say(text: string): void;
     cancel(): void;
     reset(): void;

package/types/ui/Badge.d.ts

@@ -2,5 +2,4 @@ import type { HTMLAttributes } from "react";
 import { type BadgeVariants, badgeRecipe } from "./recipe.d.ts";
 export { type BadgeVariants, badgeRecipe };
 export type BadgeProps = HTMLAttributes<HTMLSpanElement> & BadgeVariants;
-/** Status/label pill. Route-overridable via `page/**\/_overrides.tsx` (slot `Badge`). */
 export declare const Badge: import("react").ComponentType<BadgeProps>;

package/types/ui/BottomSheet.d.ts

@@ -1,19 +1,16 @@
 import { type ReactNode } from "react";
 interface BottomSheetProps {
-    /** Additional classes for the sheet surface. */
     className?: string;
-    /** Additional classes for the scrolling body. */
     bodyClassName?: string;
-    /** Controlled open state. Left out, the sheet opens from its own trigger and handle. */
+    /** Left out, the sheet opens from its own trigger and handle. */
     open?: boolean;
     onCancel?: () => void;
-    /** Element that opens the sheet. */
     trigger?: ReactNode;
     /** Whole top row of the sheet, replacing the drag handle or the close row. */
     header?: ReactNode;
     /** The grab handle a `half` sheet draws. */
     handle?: ReactNode;
-    /** Element that closes a `full` sheet, inside the default header row. */
+    /** Closes a `full` sheet, inside the default header row. */
     close?: ReactNode;
     children: ReactNode;
     type: "full" | "half";

package/types/ui/Button.d.ts

@@ -3,34 +3,17 @@ import { type ButtonHTMLAttributes } from "react";
 import { type ButtonVariants, buttonRecipe } from "./recipe.d.ts";
 export { type ButtonVariants, buttonRecipe };
 export type ButtonProps<Result> = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "onClick"> & ButtonVariants & {
-    /**
-     * Click handler. Returning a promise is what opts this button into the async states — a plain
-     * synchronous handler renders as an ordinary button with no spinner. Call onError to show the
-     * localized error state without throwing.
-     */
+    /** Returning a promise opts into the pending/success states; `onError` shows a localized error without throwing. */
     onClick?: (e: React.MouseEvent<HTMLButtonElement>, { onError }: {
         onError: (error: string) => void;
     }) => Promise<Result> | Result;
-    /** Called after the button briefly enters success state. */
+    /** Called after the brief success state. */
     onSuccess?: (result: Result) => void;
-    /**
-     * How the pending/success indicator is drawn. Both modes keep the button's box fixed — CSS cannot
-     * animate an auto width, so a resizing button can only ever snap.
-     *
-     * `hold` (default) fades a bare indicator over the children, so the box stays exactly the children's
-     * size. `replace` cross-fades to a labelled indicator ("Processing…"); both labels stay stacked in the
-     * DOM, so the box is the wider of the two from the start and still never moves — at the cost of an idle
-     * button that is as wide as its longest state.
-     */
+    /** `hold` (default) fades a bare indicator over the children; `replace` cross-fades to a labelled one and sizes
+     *  the box to the wider label. Either way the box never resizes. */
     loadingMode?: "hold" | "replace";
-    /** Whether a failed action renders its message under the button. Off leaves it to the framework toast. */
+    /** Whether a message passed to `onError` renders under the button. A thrown error is left to its thrower. */
     showError?: boolean;
 };
-/**
- * Button whose async states are driven by the handler's return value: return a promise and it shows a
- * pending indicator, then a brief success state; return nothing and it behaves as a plain button. Resolves
- * to a route-scoped override when a `page/**\/_overrides.tsx` in the route's ancestry declares one,
- * otherwise renders {@link DefaultButton}. The public generic signature is preserved, so
- * `<Button<Todo> onSuccess={(r: Todo) => …} />` still infers.
- */
+/** A promise returned from `onClick` shows a pending indicator, then a brief success state. */
 export declare const Button: <Result = unknown>(props: ButtonProps<Result>) => React.ReactElement<ButtonProps<Result>, string | React.JSXElementConstructor<any>>;

package/types/ui/ClientSide.d.ts

@@ -1,8 +1,6 @@
 import { type ReactNode } from "react";
 export interface ClientSideProps {
-    /** Content that should render inside a React Suspense boundary on the client. */
     children: ReactNode;
-    /** Optional Suspense fallback. */
     loading?: ReactNode;
 }
-export declare const ClientSide: ({ children, loading }: ClientSideProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ClientSide: ({ children, loading }: ClientSideProps) => import("react").JSX.Element;

package/types/ui/Constant/Doc.d.ts

@@ -1,11 +1,11 @@
 import { type DatabaseSchema, getConstantSchemaDoc, type ScalarSchema } from "./schemaDoc.d.ts";
-declare function Doc(): import("react/jsx-runtime").JSX.Element;
+declare function Doc(): import("react").JSX.Element;
 declare namespace Doc {
-    var Zone: ({ models, scalars, enums, openAll }: ZoneProps) => import("react/jsx-runtime").JSX.Element;
-    var Print: ({ models, scalars, enums }: ZoneProps) => import("react/jsx-runtime").JSX.Element;
-    var Model: ({ refName, database: databaseProp, openAll }: ModelProps) => import("react/jsx-runtime").JSX.Element | null;
-    var Scalar: ({ refName, scalar: scalarProp, openAll }: ScalarProps) => import("react/jsx-runtime").JSX.Element | null;
-    var Enum: ({ enums }: EnumProps) => import("react/jsx-runtime").JSX.Element;
+    var Zone: ({ models, scalars, enums, openAll }: ZoneProps) => import("react").JSX.Element;
+    var Print: ({ models, scalars, enums }: ZoneProps) => import("react").JSX.Element;
+    var Model: ({ refName, database: databaseProp, openAll }: ModelProps) => import("react").JSX.Element | null;
+    var Scalar: ({ refName, scalar: scalarProp, openAll }: ScalarProps) => import("react").JSX.Element | null;
+    var Enum: ({ enums }: EnumProps) => import("react").JSX.Element;
 }
 export default Doc;
 interface ZoneProps {

package/types/ui/Constant/Graph.d.ts

@@ -7,4 +7,4 @@ export interface GraphProps {
     selectedId?: string | null;
     onSelect?: (nodeId: string) => void;
 }
-export declare const Graph: ({ className, title, nodes, edges, selectedId, onSelect }: GraphProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Graph: ({ className, title, nodes, edges, selectedId, onSelect }: GraphProps) => import("react").JSX.Element;

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

@@ -3,5 +3,5 @@ export * from "./schemaDoc.d.ts";
 export * from "./schemaGraph.d.ts";
 export declare const Constant: {
     Doc: typeof Doc;
-    Graph: ({ className, title, nodes, edges, selectedId, onSelect }: import("./Graph.d.ts").GraphProps) => import("react/jsx-runtime").JSX.Element;
+    Graph: ({ className, title, nodes, edges, selectedId, onSelect }: import("./Graph.d.ts").GraphProps) => import("react").JSX.Element;
 };

package/types/ui/Constant/schemaGraph.d.ts

@@ -25,10 +25,6 @@ export interface PlacedEdge extends SchemaGraphEdge {
     labelX: number;
     labelY: number;
 }
-/**
- * Layered left-to-right placement (longest-path layering + barycenter ordering), the same shape a `flowchart LR`
- * produces without the renderer. Pure geometry so it is unit-testable and runs identically on the server.
- */
 export declare class SchemaGraphLayout {
     #private;
     readonly nodes: PlacedNode[];

package/types/ui/Copy.d.ts

@@ -1,10 +1,9 @@
 import { type ReactNode } from "react";
 export interface CopyProps {
-    /** Text copied to the clipboard. Defaults to an empty string. */
+    /** Defaults to an empty string. */
     text?: string;
-    /** Success message shown through the global store message helper. */
+    /** Defaults to a localized "Copied". */
     copyMessage?: string;
-    /** Copy trigger element. */
     children: ReactNode;
 }
-export declare const Copy: ({ text, copyMessage, children }: CopyProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Copy: ({ text, copyMessage, children }: CopyProps) => import("react").JSX.Element;

package/types/ui/CsrImage.d.ts

@@ -2,6 +2,7 @@ import type { ProtoLightFile } from "akanjs/constant";
 import type { ImgHTMLAttributes } from "react";
 type CsrImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, "alt" | "src"> & {
     src?: string;
+    alt?: string;
     file?: ProtoLightFile | {
         url: string;
         imageSize: [number, number];
@@ -14,5 +15,5 @@ type CsrImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, "alt" | "src"> &
     unoptimized?: boolean;
     fill?: boolean;
 };
-export declare const CsrImage: ({ src, file, className, abstractData, ...props }: CsrImageProps) => import("react/jsx-runtime").JSX.Element;
+export declare const CsrImage: ({ src, alt, file, className, abstractData, ...props }: CsrImageProps) => import("react").JSX.Element;
 export {};

package/types/ui/Data/CardList.d.ts

@@ -32,5 +32,5 @@ export default function CardList<T extends string, Input, Full extends {
     id: string;
 }, Light extends {
     id: string;
-}, Filter extends FilterInstance>({ className, cardListClassName, init, slice, actions, columns, renderItem, renderLoading, renderTemplate, renderView, renderTitle, }: CardListProps<T, Input, Full, Light, Filter>): import("react/jsx-runtime").JSX.Element;
+}, Filter extends FilterInstance>({ className, cardListClassName, init, slice, actions, columns, renderItem, renderLoading, renderTemplate, renderView, renderTitle, }: CardListProps<T, Input, Full, Light, Filter>): import("react").JSX.Element;
 export {};

package/types/ui/Data/Dashboard.d.ts

@@ -4,10 +4,7 @@ export interface DashboardProps<T extends string, State> {
     summary: Record<string, unknown>;
     /** The listing these tiles belong to. Kept so a caller names its target; the labels are app-level keys. */
     slice: SliceMeta;
-    /**
-     * Overrides the filter a column applies. A column left out still narrows the listing when its own field
-     * declares a query with `.meta(...)`; one with neither renders as a plain tile.
-     */
+    /** Overrides a column's filter; a column left out filters through its field's `.meta(...)`, else is a plain tile. */
     queryMap?: {
         [column: string]: QuerySetting;
     };
@@ -21,4 +18,4 @@ export interface DashboardProps<T extends string, State> {
     presents?: string[];
     hidePresents?: boolean;
 }
-export default function Dashboard<T extends string, State>({ className, summary, slice, queryMap, summaryRefName, onSelect, queryKey, columns, presents, hidePresents, }: DashboardProps<T, State>): import("react/jsx-runtime").JSX.Element | null;
+export default function Dashboard<T extends string, State>({ className, summary, slice, queryMap, summaryRefName, onSelect, queryKey, columns, presents, hidePresents, }: DashboardProps<T, State>): import("react").JSX.Element | null;