akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/types/ui/UiOverride/{context.d.ts → UiOverride.d.ts}

@@ -1,4 +1,4 @@
-import type { ComponentType } from "react";
+import { type ComponentType, type ReactNode } from "react";
 import type { ClassNameValue as ClassValue } from "tailwind-merge";
 import type { ApprovalProps as AgentApprovalProps } from "../Agent/Approval.d.ts";
 import type { BubbleProps as AgentBubbleProps } from "../Agent/Bubble.d.ts";
@@ -9,17 +9,17 @@ import type { CodeProps as AgentCodeProps, MarkdownProps as AgentMarkdownProps }
 import type { MenuProps as AgentMenuProps } from "../Agent/Menu.d.ts";
 import type { QuestionProps as AgentQuestionProps } from "../Agent/Question.d.ts";
 import type { QueuedProps as AgentQueuedProps } from "../Agent/Queued.d.ts";
+import type { StepsProps as AgentStepsProps } from "../Agent/Steps.d.ts";
+import type { ToolCardProps as AgentToolCardProps } from "../Agent/ToolCard.d.ts";
 import type { BadgeProps } from "../Badge.d.ts";
 import type { ButtonProps } from "../Button.d.ts";
 import type { DatePickerProps, RangePickerProps, TimePickerProps } from "../DatePicker.d.ts";
 import type { DropdownProps } from "../Dropdown.d.ts";
 import type { EmptyProps } from "../Empty.d.ts";
 import type { CheckboxProps, EmailProps, InputProps, NumberProps, PasswordProps, TextAreaProps } from "../Input.d.ts";
-import type { LoadingProps as LoadingButtonProps } from "../Loading/Button.d.ts";
-import type { LoadingProps as LoadingInputProps } from "../Loading/Input.d.ts";
 import type { ProgressBarProps } from "../Loading/ProgressBar.d.ts";
 import type { SkeletonProps } from "../Loading/Skeleton.d.ts";
-import type { SpinProps } from "../Loading/Spin.d.ts";
+import type { AreaProps, SpinProps } from "../Loading/Spin.d.ts";
 import type { MenuProps } from "../Menu.d.ts";
 import type { ModalProps } from "../Modal.d.ts";
 import type { DraftBarViewProps } from "../Model/DraftBar.d.ts";
@@ -33,18 +33,7 @@ import type { ToastItemProps, ToastProps } from "../Toast.d.ts";
 import type { MultiProps as ToggleSelectMultiProps, ToggleSelectProps } from "../ToggleSelect.d.ts";
 import type { TooltipProps } from "../Tooltip.d.ts";
 import type { UnauthorizedProps } from "../Unauthorized.d.ts";
-/**
- * Registry of framework UI components an app may replace per-route through a
- * `page/**\/_overrides.tsx` manifest. Each entry is keyed by the framework
- * component name and typed to that component's public prop contract, so an
- * override is checked as a drop-in replacement.
- *
- * Extend this interface (and add a matching `createOverridable(...)` call in the
- * component file) to make another component overridable. Generic components
- * (e.g. `Button`, `Select`) and compound components that carry static
- * sub-components (e.g. `Tab`, `Field`, `Input`) need dedicated slot support
- * before they can be listed here without losing call-site typing.
- */
+/** Components a `page/**\/_overrides.tsx` manifest may replace, each typed to its public prop contract. */
 export interface AkanUiOverrides {
     Badge: ComponentType<BadgeProps>;
     Modal: ComponentType<ModalProps>;
@@ -60,12 +49,14 @@ export interface AkanUiOverrides {
     AgentChat: ComponentType<AgentChatProps>;
     AgentLauncher: ComponentType<AgentLauncherProps>;
     AgentBubble: ComponentType<AgentBubbleProps>;
+    AgentSteps: ComponentType<AgentStepsProps>;
     AgentComposer: ComponentType<AgentComposerProps>;
     AgentApproval: ComponentType<AgentApprovalProps>;
     AgentQuestion: ComponentType<AgentQuestionProps>;
     AgentQueued: ComponentType<AgentQueuedProps>;
     AgentMenu: ComponentType<AgentMenuProps>;
     AgentMarkdown: ComponentType<AgentMarkdownProps>;
+    AgentToolCard: ComponentType<AgentToolCardProps>;
     AgentCode: ComponentType<AgentCodeProps>;
     Button: ComponentType<ButtonProps<unknown>>;
     Select: ComponentType<SelectProps<string | number | boolean | null | undefined>>;
@@ -87,29 +78,15 @@ export interface AkanUiOverrides {
     LoadingSpin: ComponentType<SpinProps>;
     LoadingSkeleton: ComponentType<SkeletonProps>;
     LoadingProgressBar: ComponentType<ProgressBarProps>;
-    LoadingButton: ComponentType<LoadingButtonProps>;
-    LoadingInput: ComponentType<LoadingInputProps>;
-    LoadingArea: ComponentType<Record<string, never>>;
+    LoadingButton: ComponentType<SkeletonProps>;
+    LoadingInput: ComponentType<SkeletonProps>;
+    LoadingArea: ComponentType<AreaProps>;
 }
 export type AkanUiOverrideName = keyof AkanUiOverrides;
 /** Prop contract an app-authored Modal override must satisfy. */
 export type AkanModalComponent = AkanUiOverrides["Modal"];
-/**
- * Registry of framework recipe slots an app may swap through the same `_overrides.tsx`
- * manifest: `override({ recipes: { button: neonButtonRecipe } })`. A recipe swap changes
- * only the className factory — the component's structure/behavior (async states, focus,
- * a11y) is untouched. Each replacement must accept the framework recipe's full variant
- * contract, so every call site keeps working (a replacement with *extra* optional axes is
- * assignable — contravariance — but those axes are only reachable from code that knows the
- * replacement's own type).
- *
- * Scope: a recipe slot is a **client-side, route-scoped restyle**. It reaches framework
- * client components, which resolve through `useUiRecipe(...)`. It never reaches a raw
- * `xRecipe(...)` call in app JSX (statically imported — no context), nor server components
- * (`Unit`/`View`), which intentionally render the canonical framework recipe. Extending the
- * *vocabulary* is not this slot's job: add the axis to the framework recipe, or author an
- * app recipe in `apps/<app>/ui/Recipe/`.
- */
+/** Recipe slots `override({ recipes })` may swap: a client-side, route-scoped restyle that reaches framework client
+ *  components only, never a raw `xRecipe()` call or a server component. */
 export interface AkanUiRecipes {
     button: (variants?: ButtonVariants, className?: ClassValue) => string;
     badge: (variants?: BadgeVariants, className?: ClassValue) => string;
@@ -119,9 +96,16 @@ export interface AkanUiRecipes {
 export type AkanUiOverrideManifest = Partial<AkanUiOverrides> & {
     recipes?: Partial<AkanUiRecipes>;
 };
-/**
- * Holds the override map for the current route subtree. Empty at the root, then
- * merged (child wins) by each nested `UiOverrideProvider`, mirroring how nested
- * `_layout.tsx` / `_overrides.tsx` stack down the route tree.
- */
 export declare const UiOverrideContext: import("react").Context<AkanUiOverrideManifest>;
+/** The active override for `name` in this route subtree, or `undefined`. */
+export declare const useUiOverride: <K extends keyof AkanUiOverrides>(name: K) => AkanUiOverrides[K] | undefined;
+/** The active recipe swap for `name` in this route subtree, or `undefined`. */
+export declare const useUiRecipe: <K extends keyof AkanUiRecipes>(name: K) => AkanUiRecipes[K] | undefined;
+/** Renders the nearest `_overrides.tsx` entry for `name`, else `Default`. */
+export declare const createOverridable: <K extends keyof AkanUiOverrides>(name: K, Default: AkanUiOverrides[K]) => AkanUiOverrides[K];
+export interface UiOverrideProviderProps {
+    value?: AkanUiOverrideManifest;
+    children?: ReactNode;
+}
+/** Merges `value` over the inherited overrides (closest wins; `recipes` merges per slot). */
+export declare const UiOverrideProvider: ({ value, children }: UiOverrideProviderProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,6 +1,3 @@
-export type { AkanModalComponent, AkanUiOverrideManifest, AkanUiOverrideName, AkanUiOverrides, AkanUiRecipes, } from "./context.d.ts";
-export { createOverridable } from "./createOverridable.d.ts";
 export { override } from "./override.d.ts";
-export { UiOverrideProvider, type UiOverrideProviderProps } from "./Provider.d.ts";
-export { useUiOverride } from "./useUiOverride.d.ts";
-export { useUiRecipe } from "./useUiRecipe.d.ts";
+export type { AkanModalComponent, AkanUiOverrideManifest, AkanUiOverrideName, AkanUiOverrides, AkanUiRecipes, } from "./UiOverride.d.ts";
+export { createOverridable, UiOverrideProvider, type UiOverrideProviderProps, useUiOverride, useUiRecipe, } from "./UiOverride.d.ts";

package/types/ui/UiOverride/override.d.ts

@@ -1,19 +1,3 @@
-import type { AkanUiOverrideManifest } from "./context.d.ts";
-/**
- * Typed manifest builder for a `page/_overrides.tsx` file:
- *
- * ```tsx
- * export default override({ Modal: BrandModal, recipes: { button: neonButtonRecipe } });
- * ```
- *
- * It type-checks each binding against that slot's public contract and rejects unknown slot names as
- * excess properties — so the manifest is validated at compile time and app components need no annotation of
- * their own. Component keys are the framework component names (`Modal`), matching `useUiOverride` and the
- * `<Modal>` call sites; the optional `recipes` map swaps recipe slots (look only, behavior untouched),
- * matching `useUiRecipe` and the recipe names in `AkanUiRecipes`.
- *
- * It is a pure, server-safe identity function (no React, no `createContext`), so the manifest needs no
- * `"use client"` directive. The framework generates a `"use client"` wrapper layout that reads this map and
- * mounts the override provider around the route subtree (see `writeGeneratedOverridesLayoutFile`).
- */
+import type { AkanUiOverrideManifest } from "./UiOverride.d.ts";
+/** Checks an `_overrides.tsx` manifest against each slot's contract; a server-safe identity, so no `"use client"`. */
 export declare const override: (overrides: AkanUiOverrideManifest) => AkanUiOverrideManifest;

package/types/ui/Unauthorized.d.ts

@@ -1,16 +1,10 @@
 import type { ReactNode } from "react";
 export interface UnauthorizedProps {
     className?: string;
-    /** The mark above the description. */
     icon?: ReactNode;
     description?: ReactNode;
     children?: ReactNode;
     minHeight?: number;
 }
 export declare const DefaultUnauthorized: ({ className, icon, description, children, minHeight, }: UnauthorizedProps) => import("react/jsx-runtime").JSX.Element;
-/**
- * Unauthorized-state placeholder. Resolves to a route-scoped override when a
- * `page/**\/_overrides.tsx` in the route's ancestry declares one, otherwise
- * renders {@link DefaultUnauthorized}.
- */
 export declare const Unauthorized: import("react").ComponentType<UnauthorizedProps>;

package/types/ui/agentAttrs.d.ts

@@ -1,14 +1,7 @@
-/**
- * The `data-akan-*` attributes for a handler the caller passed by reference.
- *
- * `{}` when the handler is an inline arrow, which is the honest answer: a closure the caller wrote says nothing
- * about what it does, and a guessed annotation is worse than none. The house form for a model field is the setter
- * itself (`onChange={st.do.setNameOnUser}`), so the fields that matter are annotated without an app writing anything.
- *
- * What it buys, beyond an in-page agent: an accessibility tree and E2E selectors that name the action rather than a
- * class, and an external browser agent — one this framework has no bridge into — reading the same names.
- */
-export declare const agentAttrs: (handler: unknown) => {
+/** `data-akan-*` attributes for a handler passed by reference, `{}` for an inline arrow. `key` tells apart the
+ *  controls sharing one handler (a tab's menus, a list's rows), in the vocabulary of the call's argument. */
+export declare const agentAttrs: (handler: unknown, key?: string | number) => {
     "data-akan-action"?: string;
     "data-akan-state"?: string;
+    "data-akan-key"?: string;
 } | Record<string, never>;

package/types/ui/index.d.ts

@@ -1,12 +1,14 @@
-export { AgentProvider, type AgentProviderProps, type AgentRunner, AgentSession, type AgentSessionOptions, type ChatMessage, type CompactOptions, type ContextBlock, httpRunner, type PublishedTool, type RunnerEvent, type RunnerRequest, SessionContext, type SessionHistory, type SurfaceView, useAgent, } from "../vendor/use-agentic.d.ts";
+export { type AgentReferenceInput, useAgentReference } from "akanjs/store";
+export { AgentProvider, type AgentProviderProps, type AgentRunner, AgentSession, type AgentSessionOptions, type ChatMessage, type CompactOptions, type ContextBlock, httpRunner, type MessageAttachment, type MessageReference, type PublishedTool, Reference, type RunnerEvent, type RunnerRequest, SessionContext, type SessionHistory, type SurfaceView, useAgent, } from "../vendor/use-agentic.d.ts";
 export { Agent } from "./Agent.d.ts";
 export { type ApprovalProps, DefaultApproval } from "./Agent/Approval.d.ts";
-export { type AgentSessionSetup, agentSessionOf } from "./Agent/agentSessionOf.d.ts";
+export { Chips as AgentAttachments, type ChipsProps as AgentAttachmentsProps } from "./Agent/Attach.d.ts";
+export { type AgentBuiltin, type AgentSessionSetup, agentSessionOf, type BuiltinOption, type PersistOption, } from "./Agent/agentSessionOf.d.ts";
 export { type AttachLimits, type AttachReader, maxAttachmentBytes, maxMessageAttachmentBytes, maxMessageAttachments, } from "./Agent/attachment.d.ts";
 export { type BubbleProps, DefaultBubble } from "./Agent/Bubble.d.ts";
 export type { ChatProps } from "./Agent/Chat.d.ts";
 export { type ChatCommand, ChatCommands } from "./Agent/ChatCommands.d.ts";
-export { type ComposerProps, DefaultComposer } from "./Agent/Composer.d.ts";
+export { type ComposerHandle, type ComposerProps, DefaultComposer } from "./Agent/Composer.d.ts";
 export { fetchRunner } from "./Agent/fetchRunner.d.ts";
 export type { HistoryProps as AgentHistoryProps } from "./Agent/History.d.ts";
 export { DefaultLauncher, type LauncherProps } from "./Agent/Launcher.d.ts";
@@ -14,10 +16,12 @@ export { type CodeProps, DefaultCode, DefaultMarkdown, type MarkdownProps } from
 export { DefaultAgentMenu, type MenuProps as AgentMenuProps, type MenuRow } from "./Agent/Menu.d.ts";
 export { DefaultQuestion, type QuestionProps } from "./Agent/Question.d.ts";
 export { DefaultQueued, type QueuedProps } from "./Agent/Queued.d.ts";
-export type { PersistOption } from "./Agent/sessionHistory.d.ts";
-export type { AgentBuiltin, BuiltinOption } from "./Agent/sessionView.d.ts";
+export { ReferenceChips as AgentReferences, type ReferenceChipsProps as AgentReferencesProps, } from "./Agent/Refer.d.ts";
+export { DefaultSteps, type StepsProps } from "./Agent/Steps.d.ts";
+export { DefaultToolCard, type ToolCardProps } from "./Agent/ToolCard.d.ts";
 export { tokenCount } from "./Agent/tokenCount.d.ts";
 export type { QueuedMessage } from "./Agent/useChatQueue.d.ts";
+export type { ReferenceCandidate, ReferenceSource } from "./Agent/useReferenceMenu.d.ts";
 export type { VoiceEngine, VoiceHandlers, VoiceListener, VoiceSpeech } from "./Agent/voice.d.ts";
 export { agentAttrs } from "./agentAttrs.d.ts";
 export { animated } from "./animated.d.ts";

package/types/ui/overlayLayer.d.ts

@@ -1,37 +1,17 @@
-/**
- * Overlay surfaces render through `createPortal(document.body)`, so they leave the DOM subtree of the
- * component that opened them, and a dismiss check asking `ref.current.contains(target)` reads every
- * click inside a dialog it opened *itself* as an outside click.
- *
- * React context reaches through a portal where the DOM does not, so an overlay can read which
- * dismissable scope rendered it and stamp that owner on the roots it portals out. A scope then
- * recognises its own overlays exactly, instead of guessing from how close a dialog happens to be.
- */
 export declare const OVERLAY_LAYER_ATTR = "data-akan-overlay";
-/**
- * Stacking order for overlays that portal to `document.body`, where nesting no longer decides who is on
- * top. A Popconfirm outranks a dropdown menu because `Model.Remove` draws one from inside a menu item,
- * and its scrim outranks the menu so the click that answers the confirm is not also a menu selection.
- * A Select's options stay under both: it is a field, and whatever opened over it took the click that
- * dismisses it.
- */
 export declare const overlayZ: {
     readonly select: 90;
     readonly dropdown: 100;
     readonly popconfirmScrim: 105;
     readonly popconfirm: 110;
 };
-/** Wrap the content a dismissable container owns, with the scope from {@link useOverlayScope}. */
+/** Takes the scope from {@link useOverlayScope}. */
 export declare const OverlayOwnerProvider: import("react").Provider<string>;
-/** Scope a dismissable container hands to its content. Nests as a `parent/child` path. */
+/** Nests under the enclosing scope as a `parent/child` path. */
 export declare const useOverlayScope: (id: string) => string;
-/** Props an overlay spreads onto every root it portals out of its own tree. */
+/** Spread onto every root an overlay portals out of its own tree. */
 export declare const useOverlayLayerProps: () => {
     "data-akan-overlay": string;
 };
-/**
- * True when the click landed in an overlay that `scope` — or a scope nested inside it — rendered.
- * An overlay nobody owns, and one owned by an unrelated scope, both read as an ordinary outside
- * click, so a menu does not linger behind a dialog it has nothing to do with.
- */
+/** True when the click landed in an overlay `scope`, or a scope nested in it, rendered; any other is outside. */
 export declare const isOwnOverlayClick: (target: EventTarget | null, scope: string) => boolean;

package/types/ui/overlayPosition.d.ts

@@ -2,27 +2,15 @@ import { type RefObject } from "react";
 export interface OverlayPosition {
     top: number;
     left: number;
-    /** Placed above the trigger, because there was no room below. */
     above: boolean;
     /** The trigger's centre relative to the panel's left edge, held clear of the panel's rounded corners. */
     anchorOffset: number;
-    /** The trigger's own width, for a panel that lines up with the control it drops out of. */
     anchorWidth: number;
 }
-/**
- * Places a portalled panel against its trigger in viewport coordinates.
- *
- * A panel positioned inside its own tree is clipped by every `overflow` ancestor it has — the modal
- * surface, the modal's scrolling body, a table's scroll container, the dropdown menu a row verb sits in —
- * so overlay panels portal out to `document.body` and are placed here instead of by CSS.
- * `position: fixed` in place would not do it either: a fixed element inside a transformed ancestor is laid
- * out and clipped by that ancestor, and the modal surface animates a transform.
- */
 export declare const useOverlayPosition: ({ opened, triggerRef, panelRef, align, gap, }: {
     opened: boolean;
     triggerRef: RefObject<HTMLElement | null>;
     panelRef: RefObject<HTMLElement | null>;
     align: "start" | "end";
-    /** Distance from the trigger. Raise it for a panel whose pointer sticks out past its own edge. */
     gap?: number;
 }) => OverlayPosition | null;

package/types/ui/recipe/badgeRecipe.d.ts

@@ -2,14 +2,14 @@
 export declare const badgeRecipe: (variants?: Omit<({
     size?: "lg" | "md" | "sm" | "xs" | undefined;
     outline?: boolean | undefined;
-    variant?: "default" | "info" | "error" | "success" | "warning" | "primary" | "secondary" | "accent" | "neutral" | "outline" | undefined;
+    variant?: "default" | "error" | "info" | "warning" | "success" | "primary" | "secondary" | "accent" | "neutral" | "outline" | undefined;
 } & {
     class?: import("tailwind-variants").ClassValue;
     className?: never;
 }) | ({
     size?: "lg" | "md" | "sm" | "xs" | undefined;
     outline?: boolean | undefined;
-    variant?: "default" | "info" | "error" | "success" | "warning" | "primary" | "secondary" | "accent" | "neutral" | "outline" | undefined;
+    variant?: "default" | "error" | "info" | "warning" | "success" | "primary" | "secondary" | "accent" | "neutral" | "outline" | undefined;
 } & {
     class?: never;
     className?: import("tailwind-variants").ClassValue;

package/types/ui/recipe/buttonRecipe.d.ts

@@ -2,7 +2,7 @@
 export declare const buttonRecipe: (variants?: Omit<({
     size?: "lg" | "md" | "sm" | "xs" | "icon" | undefined;
     outline?: boolean | undefined;
-    variant?: "link" | "default" | "info" | "success" | "warning" | "primary" | "secondary" | "accent" | "destructive" | "neutral" | "outline" | "ghost" | undefined;
+    variant?: "link" | "default" | "info" | "warning" | "success" | "primary" | "secondary" | "accent" | "destructive" | "neutral" | "outline" | "ghost" | undefined;
     shape?: "default" | "circle" | "square" | undefined;
 } & {
     class?: import("tailwind-variants").ClassValue;
@@ -10,7 +10,7 @@ export declare const buttonRecipe: (variants?: Omit<({
 }) | ({
     size?: "lg" | "md" | "sm" | "xs" | "icon" | undefined;
     outline?: boolean | undefined;
-    variant?: "link" | "default" | "info" | "success" | "warning" | "primary" | "secondary" | "accent" | "destructive" | "neutral" | "outline" | "ghost" | undefined;
+    variant?: "link" | "default" | "info" | "warning" | "success" | "primary" | "secondary" | "accent" | "destructive" | "neutral" | "outline" | "ghost" | undefined;
     shape?: "default" | "circle" | "square" | undefined;
 } & {
     class?: never;

package/types/ui/recipe/factory.d.ts

@@ -1,24 +1,4 @@
 import type { ClassNameValue as ClassValue } from "tailwind-merge";
-/**
- * recipe 팩토리 모듈 — 변형 팩토리를 만드는 **인프라**. **서버-안전** (절대 `"use client"` 금지).
- * 실제 recipe 정의는 이 폴더의 형제 파일 하나당 하나씩 둔다 — 프레임워크는 `./<name>Recipe.ts`,
- * 각 앱은 `apps/<app>/ui/Recipe/<name>.ts`.
- */
 export declare const tv: import("tailwind-variants").TV;
-/**
- * recipe 팩토리 — `tv({...})` 인스턴스를 받아 겉을 `(변형, className?)` 2-인자로 노출하고,
- * className 병합(cn)을 안으로 숨긴다. 타입은 넘겨받은 tv 인스턴스에서 그대로 추론되어 변형 타입이
- * 정확히 보존된다. 반환은 순수 className 문자열이라 서버-안전.
- *
- *   export const xRecipe = recipe(tv({ base, variants }));
- *   xRecipe({ variant: "primary" }, "w-full")            // cn 불필요
- *
- * 2번째 인자는 `ClassNameValue` — 문자열 하나만이 아니라 **배열·중첩 배열·falsy 값**을 그대로 받는다.
- * 여러 클래스를 합칠 때 `cn(...)` 으로 감쌀 이유가 없다(모르면 감싸게 되는데, cn 을 몰아내려고 만든
- * 2-인자 계약이 거기서 새어나간다):
- *
- *   xRecipe({}, ["h-full", className])                   // ✅ cn 불필요
- *   xRecipe({}, ["h-full", isWide && "w-full"])          // ✅ falsy 는 무시됨
- *   xRecipe({}, cn("h-full", className))                 // ❌ 불필요한 래핑
- */
+/** `className` takes arrays and falsy values and is merged inside, so never wrap it in `cn()`. */
 export declare const recipe: <P extends object>(styles: (props?: P) => string) => (variants?: Omit<P, "class" | "className">, className?: ClassValue) => string;

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

@@ -1,17 +1,3 @@
-/**
- * recipe 레이어 — 프리미티브의 스타일 recipe(변형)를 모으는 **서버-안전** 폴더.
- * **여기엔 절대 `"use client"` 를 붙이지 않는다.** 팩토리(`recipe`/`tv`)는 `./factory` 에 있다.
- *
- * 구조: recipe 하나당 파일 하나(`<name>Recipe.ts`), 이 index 는 재수출만 한다. 앱도 같은 구조를
- * `apps/<app>/ui/Recipe/` 에서 계승한다.
- *
- * 호출 규격: `xRecipe(변형객체, 커스텀클래스?)`. 두 번째 인자 className 은 recipe 안에서 tailwind-merge 로
- * 자동 병합되므로 호출부에서 `cn(...)` 으로 감쌀 필요가 없다. 문자열 하나만이 아니라 배열도 받는다:
- *   buttonRecipe({ variant: "primary" }, "w-full rounded-2xl")   // ✅ cn 불필요
- *   buttonRecipe({ variant: "primary" }, ["h-full", className])  // ✅ 배열 — 여기서도 cn 불필요
- *
- * 레이어: styles.css(토큰) → recipe(변형) → 컴포넌트(동작).
- */
 export { type BadgeVariants, badgeRecipe } from "./badgeRecipe.d.ts";
 export { type ButtonVariants, buttonRecipe } from "./buttonRecipe.d.ts";
 export { recipe, tv } from "./factory.d.ts";

package/types/ui/recipe/inputRecipe.d.ts

@@ -1,14 +1,14 @@
-/** 입력 표면 look — Input/TextArea/Select 가 공유하는 필드 셸. kind 로 한 줄 필드(field)/멀티라인(area), tone 으로 강조/오류 상태를 고른다. */
+/** 입력 표면 look — Input/TextArea/DatePicker 가 공유하는 필드 셸. kind 로 한 줄 필드(field)/멀티라인(area), tone 으로 강조/오류 상태를 고른다. */
 export declare const inputRecipe: (variants?: Omit<({
-    size?: "xl" | "lg" | "md" | "sm" | "xs" | undefined;
     kind?: "field" | "area" | undefined;
+    size?: "xl" | "lg" | "md" | "sm" | "xs" | undefined;
     tone?: "default" | "error" | "primary" | undefined;
 } & {
     class?: import("tailwind-variants").ClassValue;
     className?: never;
 }) | ({
-    size?: "xl" | "lg" | "md" | "sm" | "xs" | undefined;
     kind?: "field" | "area" | undefined;
+    size?: "xl" | "lg" | "md" | "sm" | "xs" | undefined;
     tone?: "default" | "error" | "primary" | undefined;
 } & {
     class?: never;

package/types/ui/sliceNamesOf.d.ts

@@ -0,0 +1,78 @@
+export declare const sliceNamesOf: (model: string, sliceName: string) => {
+    names: {
+        model: string;
+        modelId: string;
+        modelObjList: string;
+        modelObjInsight: string;
+        newModel: string;
+        editModel: string;
+        viewModel: string;
+        removeModel: string;
+        setViewOfModel: string;
+        exportCsvOfModel: string;
+        exportJsonOfModel: string;
+        initModel: string;
+        refreshModel: string;
+        selectModel: string;
+        setPageOfModel: string;
+        loadMoreOfModel: string;
+        setLimitOfModel: string;
+        setQueryArgsOfModel: string;
+        setSortOfModel: string;
+        applyLiveModel: string;
+        watchLiveModel: string;
+        defaultModel: string;
+        modelInsight: string;
+        modelList: string;
+        modelListLoading: string;
+        modelInitList: string;
+        modelInitAt: string;
+        modelStaleAt: string;
+        modelSelection: string;
+        lastPageOfModel: string;
+        pageOfModel: string;
+        limitOfModel: string;
+        hasMoreOfModel: string;
+        isCumulativeOfModel: string;
+        queryArgsOfModel: string;
+        sortOfModel: string;
+    };
+    namesOfSlice: {
+        model: string;
+        modelId: string;
+        modelObjList: string;
+        modelObjInsight: string;
+        newModel: string;
+        editModel: string;
+        viewModel: string;
+        removeModel: string;
+        setViewOfModel: string;
+        exportCsvOfModel: string;
+        exportJsonOfModel: string;
+        initModel: string;
+        refreshModel: string;
+        selectModel: string;
+        setPageOfModel: string;
+        loadMoreOfModel: string;
+        setLimitOfModel: string;
+        setQueryArgsOfModel: string;
+        setSortOfModel: string;
+        applyLiveModel: string;
+        watchLiveModel: string;
+        defaultModel: string;
+        modelInsight: string;
+        modelList: string;
+        modelListLoading: string;
+        modelInitList: string;
+        modelInitAt: string;
+        modelStaleAt: string;
+        modelSelection: string;
+        lastPageOfModel: string;
+        pageOfModel: string;
+        limitOfModel: string;
+        hasMoreOfModel: string;
+        isCumulativeOfModel: string;
+        queryArgsOfModel: string;
+        sortOfModel: string;
+    };
+};

package/types/ui/triggerSlot.d.ts

@@ -6,18 +6,8 @@ interface TriggerSlotOptions {
     /** Host element for a trigger that cannot be cloned — a string, a fragment, several children. */
     as?: "div" | "span";
 }
-/**
- * Puts a disclosure's click and aria state onto the element the caller handed in, rather than wrapping it.
- *
- * Reach for this **only when an attribute has to ride the caller's own control** — `aria-expanded` /
- * `aria-haspopup` on a wrapper names a box rather than the button a screen reader activates. Everywhere else
- * the framework wraps instead: a wrapper works with any node, and a clone is silently inert on a component
- * that does not forward `className` / `onClick` (every `ModelProps` component, whose `onClick` takes the model
- * rather than the event).
- *
- * The caller's own `onClick` runs first and can call `preventDefault()` to stop the surface from acting. A
- * trigger that is not a single element has nothing to clone onto, so it keeps a host element.
- */
+/** Clones a disclosure's click and aria state onto the caller's element; the caller's `onClick` runs first and may
+ *  `preventDefault()`. Only for aria that must ride the caller's control: a clone is inert on one not forwarding it. */
 export declare const triggerSlot: (trigger: ReactNode, { className, onClick, as: Host, ...attrs }: TriggerSlotOptions & {
     [key: string]: unknown;
 }) => import("react/jsx-runtime").JSX.Element;

package/types/vendor/use-agentic/AgentProgress.d.ts

@@ -1,8 +1,19 @@
+export interface AgentProgressStep {
+    id: string;
+    label: string;
+    status: "pending" | "running" | "done" | "error";
+    detail?: string;
+}
 export interface AgentProgressReport {
     /** One short line about the step in flight. Read by the user, not the model — keep it prose. */
     message: string;
     done?: number;
     total?: number;
+    /**
+     * The activity of work running somewhere else — a server job, a code worker — that this one call is waiting on.
+     * Each report replaces the list whole, so a relay forwards what it has and never merges.
+     */
+    steps?: AgentProgressStep[];
 }
 /**
  * The progress channel for the tool call running now.
@@ -20,6 +31,7 @@ export declare class AgentProgress {
     static report(message: string, amount?: {
         done?: number;
         total?: number;
+        steps?: AgentProgressStep[];
     }): void;
     /** True while someone is rendering the reports, for a message that costs something to assemble. */
     static get watching(): boolean;