@makinbakin/sdk 0.0.1-rc.4 → 0.0.1-rc.40

package/_internal/core/routing/define.d.ts

@@ -8,6 +8,7 @@
  * from the schemas in the route literal.
  */
 import type { APIRoute, CoreContext, PluginContextLite } from './types';
+import type { ContentFile, NavItem, PluginSettingsSchema } from '../plugin-types';
 /**
  * Declare a plugin route. Handler `ctx` is bound to `PluginContextLite`. The
  * three generics (P/Q/B) are inferred from `params`, `query`, and `body`
@@ -19,16 +20,45 @@ export declare function defineRoute<P = undefined, Q = undefined, B = undefined>
  * Declare a core (host) route. Handler `ctx` is bound to `CoreContext`.
  */
 export declare function defineCoreRoute<P = undefined, Q = undefined, B = undefined>(route: APIRoute<CoreContext, P, Q, B>): APIRoute<CoreContext, P, Q, B>;
-/** Lower-bound shape every plugin definition must satisfy. */
+/**
+ * The exact shape a plugin definition may carry — the full `BakinPlugin`
+ * lifecycle surface plus declarative `routes`. Deliberately CLOSED (no index
+ * signature): a typo'd key (`settingSchema`, `onReadey`, …) fails typecheck
+ * at the `definePlugin` call site instead of silently doing nothing at
+ * runtime (audit 2026-07 H3).
+ */
 export interface DefinePluginInput {
     id: string;
     name: string;
     version: string;
     routes?: ReadonlyArray<APIRoute<PluginContextLite, any, any, any>>;
-    [key: string]: unknown;
+    activate(ctx: any): void | Promise<void>;
+    onReady?(): void | Promise<void>;
+    onShutdown?(): void | Promise<void>;
+    onSettingsChange?(settings: Record<string, unknown>): void | Promise<void>;
+    validateSettings?(value: unknown): {
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    };
+    onUninstall?(ctx: any): void | Promise<void>;
+    beforeUninstall?(ctx: any): void | Promise<void>;
+    settingsSchema?: PluginSettingsSchema;
+    navItems?: NavItem[];
+    contentFiles?: ContentFile[];
 }
 /**
  * Declare a plugin. Returns the input unchanged. Use this instead of a bare
  * `BakinPlugin` annotation so `routes` keeps per-element inference.
+ *
+ * The `& { [K in Exclude<...>]: never }` intersection is the exactness
+ * enforcement: `T extends DefinePluginInput` alone would structurally admit
+ * excess keys, so a typo'd `settingSchema` would compile and silently do
+ * nothing. With the intersection, any key outside `DefinePluginInput` must
+ * be `never` — which no real value satisfies — so typos fail at the call
+ * site (audit 2026-07 H3).
  */
-export declare function definePlugin<const T extends DefinePluginInput>(plugin: T): T;
+export declare function definePlugin<const T extends DefinePluginInput>(plugin: T & {
+    [K in Exclude<keyof T, keyof DefinePluginInput>]: never;
+}): T;

package/_internal/core/routing/dispatcher.d.ts

@@ -11,10 +11,11 @@
  *   - In dev / test, validate the response body against `responses[status]`
  *     and surface mismatches (test → throw, dev → console.warn).
  *
- * Adapter mapping: legacy `APIRoute.input` is treated as a JSON `body` schema
- * and legacy `APIRoute.output` is treated as `responses[200]`. This keeps
- * routes registered via the migration-window `ctx.registerRoute({...})` shim
- * flowing through the same validation path.
+ * There is no legacy `input`/`output` adapter mapping here: `ctx.registerRoute`
+ * and the legacy `APIRoute` shape were deleted (T19) — declarative routes and
+ * core routes are the only producers, and both speak `body`/`responses`.
+ * (The OpenAPI builder keeps a read-side mapping for historical doc callers;
+ * see packages/core/src/openapi/operation.ts.)
  */
 import { z } from 'zod';
 import type { BodySpec, ResponseSpec } from './types';
@@ -32,8 +33,6 @@ export interface DispatchableRoute {
     body?: BodySpec<unknown>;
     responses?: Partial<Record<string | number, ResponseSpec>>;
     handler: (req: Request, ctx: any, parsed?: any) => Response | Promise<Response>;
-    input?: z.ZodType<unknown>;
-    output?: z.ZodType<unknown>;
 }
 export interface DispatchInput {
     req: Request;
@@ -42,3 +41,13 @@ export interface DispatchInput {
     params: Record<string, string>;
 }
 export declare function dispatchRoute(input: DispatchInput): Promise<Response>;
+/**
+ * Loudly reject malformed `body` specs. A typo'd contentType (`'json'`)
+ * previously fell through parseBodySpec as a silent pass-through with an
+ * undefined parsed body — the handler then read `parsed.body.title` off
+ * undefined at request time with no hint why. Definition/registration time
+ * is the right place to fail: defineRoute/defineCoreRoute call this at
+ * module eval, and the plugin registry calls it for bare-literal routes at
+ * activation. `label` names the route in the error (e.g. `POST /items`).
+ */
+export declare function assertValidBodySpec(body: unknown, label: string): void;

package/_internal/core/routing/index.d.ts

@@ -10,6 +10,6 @@ export type { DefinePluginInput } from './define';
 export { RouteRegistry } from './registry';
 export type { RouteScope, RegisteredRoute, RouteMatch } from './registry';
 export { operationIdFor } from './operation-id';
-export { dispatchRoute } from './dispatcher';
+export { assertValidBodySpec, dispatchRoute } from './dispatcher';
 export type { DispatchInput } from './dispatcher';
 export { searchRoute } from './search-route';

package/_internal/core/routing/types.d.ts

@@ -2,17 +2,17 @@
  * Routing primitives — typed route contracts that drive runtime dispatch and
  * OpenAPI emission from a single source.
  *
- * The legacy `APIRoute` interface in `../plugin-types.ts` remains during the
- * migration window; this module's `APIRoute<C, P, Q, B>` is the new
- * declarative shape that plugins move to under T6–T16. The two coexist via the
- * `ctx.registerRoute` adapter wired in T4.
+ * The pure, context-free declarations (the generic `APIRoute`, body/response
+ * specs, `ParsedInput`) are DECLARED in `@makinbakin/sdk/types` (api-route.ts
+ * — a leaf module) and re-exported here bound to the core-tier
+ * `RouteContext`. That direction keeps the package DAG acyclic: core imports
+ * SDK types (as `plugin-types.ts` always has); the SDK never imports core
+ * from its types layer. Only the tier-specific route CONTEXTS live here.
  */
-import type { z } from 'zod';
-import type { ContractStability, ContractVisibility, DocsExample, SourceLocation } from '../docs';
+import type { APIRoute as SdkAPIRoute } from '@makinbakin/sdk/types';
 import type { AgentRuntimeAdapter } from '../adapters/runtime';
 import type { StorageAdapter, EventBus, SearchAPI, ActivityAPI, HookAPI, AssetsAPI, PluginTaskService } from '../plugin-types';
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-export type HttpStatus = 200 | 201 | 202 | 204 | 301 | 302 | 304 | 400 | 401 | 403 | 404 | 409 | 410 | 415 | 422 | 429 | 500 | 502 | 503 | 504;
+export type { HttpMethod, HttpStatus, JsonBodySpec, MultipartBodySpec, RawBodySpec, NoBodySpec, BodySpec, JsonResponseSpec, NoContentResponseSpec, NonJsonResponseSpec, ResponseSpec, ParsedInput, } from '@makinbakin/sdk/types';
 /**
  * Common surface every route handler can rely on, regardless of origin.
  * `PluginContext` and `CoreContext` extend this with their own additions.
@@ -46,69 +46,13 @@ export interface PluginContextLite extends RouteContext {
  * `packages/host/src/core-routes/`.
  */
 export type CoreContext = RouteContext;
-export interface JsonBodySpec<B = unknown> {
-    contentType: 'application/json';
-    schema: z.ZodType<B>;
-}
-export interface MultipartBodySpec<B = unknown> {
-    contentType: 'multipart/form-data';
-    schema?: z.ZodType<B>;
-}
-export interface RawBodySpec<B = unknown> {
-    contentType: '*/*';
-    schema?: z.ZodType<B>;
-}
-export interface NoBodySpec {
-    contentType: 'none';
-}
 /**
- * `body` declaration:
- *   - `z.ZodType` shorthand → JSON body validated against the schema.
- *   - explicit JSON spec → same, content-type stated.
- *   - multipart / raw → handler reads `req.formData()` / `req.body` itself.
- *   - none → dispatcher rejects non-empty bodies with 415.
- *
- * Omit the field entirely on routes that don't consume a body.
+ * Same declaration as `@makinbakin/sdk/types`' `APIRoute`, with the core-tier
+ * `RouteContext` as the default context. An alias (not a copy): the two are
+ * mutually assignable by construction — pinned in
+ * tests/core/plugin-type-contract.test.ts.
  */
-export type BodySpec<B = unknown> = z.ZodType<B> | JsonBodySpec<B> | MultipartBodySpec<B> | RawBodySpec<B> | NoBodySpec;
-export interface JsonResponseSpec {
-    contentType: 'application/json';
-    schema: z.ZodType;
-}
-export interface NoContentResponseSpec {
-    contentType: 'none';
-}
-export interface NonJsonResponseSpec {
-    contentType: 'text/event-stream' | 'text/html' | 'text/plain' | 'application/octet-stream' | 'image/png' | 'image/jpeg' | 'image/svg+xml' | (string & Record<never, never>);
-    schema?: z.ZodType;
-}
-export type ResponseSpec = z.ZodType | JsonResponseSpec | NoContentResponseSpec | NonJsonResponseSpec;
-/** Helper: `{ body: B }` if B is declared (non-undefined), else no fields. */
-type Field<K extends string, T> = [T] extends [undefined] ? unknown : {
-    [P in K]: T;
-};
-type Normalize<T> = {
-    [K in keyof T]: T[K];
-};
-export type ParsedInput<P, Q, B> = Normalize<Field<'params', P> & Field<'query', Q> & Field<'body', B>>;
-export interface APIRoute<C extends RouteContext = RouteContext, P = undefined, Q = undefined, B = undefined> {
-    path: string;
-    method: HttpMethod;
-    summary?: string;
-    description?: string;
-    params?: z.ZodType<P>;
-    query?: z.ZodType<Q>;
-    body?: P extends never ? never : BodySpec<B>;
-    responses?: Partial<Record<HttpStatus, ResponseSpec>>;
-    visibility?: ContractVisibility;
-    stability?: ContractStability;
-    permissions?: string[];
-    examples?: DocsExample[];
-    operationId?: string;
-    tags?: string[];
-    source?: SourceLocation;
-    handler: (req: Request, ctx: C, parsed: ParsedInput<P, Q, B>) => Response | Promise<Response>;
-}
+export type APIRoute<C extends RouteContext = RouteContext, P = undefined, Q = undefined, B = undefined> = SdkAPIRoute<C, P, Q, B>;
 /**
  * Subset of plugin metadata `definePlugin` cares about. The full `BakinPlugin`
  * interface lives in `../plugin-types.ts`; this declares the new fields the
@@ -120,4 +64,3 @@ export interface PluginWithRoutes {
     version: string;
     routes?: ReadonlyArray<APIRoute<PluginContextLite, any, any, any>>;
 }
-export {};

package/_internal/core/storage/atomic-write.d.ts

@@ -0,0 +1,11 @@
+export interface AtomicWriteOptions {
+    /** Append a trailing newline. Default true (pretty JSON convention). */
+    trailingNewline?: boolean;
+}
+/** Atomically write `text` to `path` (temp file + rename), creating parent dirs. */
+export declare function atomicWriteText(path: string, text: string): void;
+/**
+ * Atomically write `value` as pretty-printed JSON. Adds a trailing newline by
+ * default; pass `{ trailingNewline: false }` to match callers that wrote none.
+ */
+export declare function atomicWriteJson(path: string, value: unknown, opts?: AtomicWriteOptions): void;

package/_internal/core/tasks/store.d.ts

@@ -0,0 +1,129 @@
+import type { TaskLogEntry } from '@makinbakin/sdk/types';
+import type { Unsubscribe } from '../adapters/shared';
+export type { TaskLogEntry } from '@makinbakin/sdk/types';
+export interface BakinTask {
+    id: string;
+    title: string;
+    description?: string;
+    agent?: string;
+    /**
+     * Requested team assignment (#189). `team` alone = unresolved team task
+     * (the dispatch resolver picks a member); `team` + `agent` = resolved —
+     * team is retained so the record explains requested vs resolved.
+     * Exclusion semantics live in the app facade (src/core/task-store.ts).
+     */
+    team?: string;
+    createdBy?: string;
+    column: string;
+    order: number;
+    tags: string[];
+    workflowId?: string;
+    scheduleJobId?: string;
+    projectId?: string;
+    /** Brand link (#419) — resolved lazily at dispatch, mirrors projectId. */
+    brandId?: string;
+    /** Repo binding override (same-agent-concurrency D6): dispatch worktree target; project binding via projects.getRepo otherwise. */
+    repoPath?: string;
+    parentId?: string | null;
+    dependsOn?: string;
+    availableAt?: string;
+    dueAt?: string;
+    source?: TaskSource;
+    date?: string;
+    blockedReason?: string;
+    blockedBy: string[];
+    blocking: string[];
+    comments: TaskComment[];
+    pendingDelete: boolean;
+    log: TaskLogEntry[];
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * Optimistic concurrency counter — bumped on every write. Absent on
+     * pre-upgrade tasks (treated as 0; lazy-stamped on the next write).
+     * API mutations may send expectedVersion and get a 409 when stale.
+     */
+    version?: number;
+}
+export interface TaskSource {
+    pluginId?: string;
+    entityType?: string;
+    entityId?: string;
+    purpose?: string;
+}
+export interface CreateBakinTaskInput {
+    id?: string;
+    title: string;
+    description?: string;
+    agent?: string;
+    team?: string;
+    createdBy?: string;
+    column?: string;
+    order?: number;
+    tags?: string[];
+    workflowId?: string;
+    scheduleJobId?: string;
+    projectId?: string;
+    brandId?: string;
+    /** Repo binding override (same-agent-concurrency D6): dispatch worktree target; project binding via projects.getRepo otherwise. */
+    repoPath?: string;
+    parentId?: string | null;
+    dependsOn?: string;
+    availableAt?: string;
+    dueAt?: string;
+    source?: TaskSource;
+}
+export type BakinTaskPatch = Partial<Pick<BakinTask, 'title' | 'description' | 'agent' | 'team' | 'createdBy' | 'column' | 'order' | 'tags' | 'workflowId' | 'scheduleJobId' | 'projectId' | 'brandId' | 'repoPath' | 'parentId' | 'dependsOn' | 'availableAt' | 'dueAt' | 'source' | 'date' | 'blockedReason' | 'blockedBy' | 'blocking' | 'pendingDelete'>>;
+export interface TaskListOpts {
+    column?: string;
+    agent?: string;
+    projectId?: string;
+    brandId?: string;
+    /** Repo binding override (same-agent-concurrency D6): dispatch worktree target; project binding via projects.getRepo otherwise. */
+    repoPath?: string;
+    includePendingDelete?: boolean;
+}
+export interface TaskComment {
+    id: string;
+    author: string;
+    body: string;
+    createdAt: string;
+}
+export interface TaskDependencyPatch {
+    blockedBy?: string[];
+    blocking?: string[];
+}
+export interface BakinTaskStoreEvent {
+    type: 'created' | 'updated' | 'deleted';
+    taskId: string;
+    task?: BakinTask;
+}
+export interface BakinTaskStore {
+    create(input: CreateBakinTaskInput): Promise<BakinTask>;
+    get(id: string): Promise<BakinTask | null>;
+    list(opts?: TaskListOpts): Promise<BakinTask[]>;
+    update(id: string, patch: BakinTaskPatch): Promise<BakinTask>;
+    move(id: string, column: string, order?: number): Promise<BakinTask>;
+    remove(id: string): Promise<void>;
+    appendLog(id: string, entry: TaskLogEntry): Promise<void>;
+    addComment(id: string, comment: TaskComment): Promise<void>;
+    setDependencies(id: string, deps: TaskDependencyPatch): Promise<BakinTask>;
+    markPendingDelete(id: string, pending: boolean): Promise<BakinTask>;
+    subscribe(handler: (event: BakinTaskStoreEvent) => void): Unsubscribe;
+}
+export interface SyncBakinTaskStore extends BakinTaskStore {
+    createSync(input: CreateBakinTaskInput): BakinTask;
+    getSync(id: string): BakinTask | null;
+    findSync(identifier: string): BakinTask | null;
+    listSync(opts?: TaskListOpts): BakinTask[];
+    updateSync(id: string, patch: BakinTaskPatch): BakinTask;
+    removeSync(id: string): void;
+    appendLogSync(id: string, entry: TaskLogEntry): void;
+    addCommentSync(id: string, comment: TaskComment): void;
+    setDependenciesSync(id: string, deps: TaskDependencyPatch): BakinTask;
+    markPendingDeleteSync(id: string, pending: boolean): BakinTask;
+    /** Index-backed column count (excludes pendingDelete, matching listSync). Zero file reads. */
+    countByColumnSync(column: string): number;
+}
+export declare function createEmptyBakinTask(input: CreateBakinTaskInput, now?: string): BakinTask;
+export declare function createFileBakinTaskStore(root: string): SyncBakinTaskStore;

package/_internal/core/tasks/testing.d.ts

@@ -0,0 +1,2 @@
+import type { BakinTask, BakinTaskStore } from './store';
+export declare function createMockBakinTaskStore(seed?: BakinTask[]): BakinTaskStore;

package/_internal/{plugins/workflows/lib → core/workflows}/notification-channel-registry.d.ts

@@ -8,7 +8,7 @@
  * here. Plugin ids are auto-namespaced as `{pluginId}.{id}` to avoid
  * cross-plugin collisions with the shared builtin ids.
  */
-import type { NotificationChannelDef, PluginNotificationChannelInput } from '../../../core/plugin-types';
+import type { NotificationChannelDef, PluginNotificationChannelInput } from '../plugin-types';
 export type { NotificationChannelDef, PluginNotificationChannelInput };
 export declare function registerNotificationChannel(def: NotificationChannelDef): void;
 export declare function getNotificationChannel(id: string): NotificationChannelDef | undefined;

package/_internal/host/ui/action-status.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Legacy host bridge for root `src/components/ui/*` compatibility shims.
+ * Product and plugin consumers should use their existing supported imports;
+ * only the host package and SDK may reach the private implementation.
+ */
+export { Button, buttonVariants } from '../../ui/index';
+export type { ButtonProps, ButtonSize, ButtonVariant, ButtonVariantOptions, LegacyButtonSize, LegacyButtonVariant, } from '../../ui/index';
+export { Progress, ProgressIndicator, ProgressLabel, ProgressTrack, ProgressValue, } from '../../ui/index';
+export type { ProgressIndicatorProps, ProgressProps, ProgressSize, ProgressTone, ProgressTrackProps, } from '../../ui/index';
+export { Alert, AlertAction, AlertDescription, AlertTitle, alertVariants } from '../../ui/index';
+export type { AlertProps, AlertTone, AlertVariantOptions, LegacyAlertVariant, } from '../../ui/index';
+export { Badge, badgeVariants } from '../../ui/index';
+export type { BadgeProps, BadgeSize, BadgeTone, BadgeVariant, BadgeVariantOptions, LegacyBadgeVariant, } from '../../ui/index';

package/_internal/host/ui/modals.d.ts

@@ -0,0 +1,5 @@
+/** Legacy host bridge for the canonical modal and side-overlay primitives. */
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger, } from '../../ui/index';
+export { UnsavedChangesDialog } from '../../ui/patterns/unsaved-changes-dialog';
+export type { UnsavedChangesDialogProps } from '../../ui/patterns/unsaved-changes-dialog';
+export type { DialogCloseProps, DialogContentProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogOverlayProps, DialogPortalProps, DialogProps, DialogTitleProps, DialogTriggerProps, SheetCloseProps, SheetContentProps, SheetDescriptionProps, SheetFooterProps, SheetHeaderProps, SheetOverlayProps, SheetPortalProps, SheetProps, SheetSide, SheetTitleProps, SheetTriggerProps, } from '../../ui/index';

package/_internal/host/ui/resize.d.ts

@@ -0,0 +1,2 @@
+export { ResizeHandle } from '../../ui/behaviors/resize-handle';
+export { usePersistedLeadingEdgeResize } from '../../ui/behaviors/use-persisted-leading-edge-resize';

package/_internal/plugins/team/types.d.ts

@@ -66,13 +66,14 @@ export interface SkillSummary {
  * the server-side `AgentStateInfo` shape but stays self-contained so the
  * client doesn't reach across the package boundary for types.
  *
- * The server today returns 4 states (`absent | unmanaged | adopted | managed`).
- * `drifted` and `update-available` are declared on the badge component for
- * forward-compat — wiring handles them but the API doesn't yet emit them.
+ * The server today returns 3 states (`absent | unmanaged | managed`).
+ * `drifted` and `update-available` are display states layered on top of the
+ * server row when diagnostics or update checks report additional status.
  */
 export interface PackageStateRow {
     agentId: string;
-    state: 'absent' | 'unmanaged' | 'adopted' | 'managed' | 'drifted' | 'update-available';
+    state: 'absent' | 'unmanaged' | 'managed' | 'drifted' | 'update-available';
+    version?: string;
     packageId?: string;
     entry?: {
         source: string;
@@ -82,6 +83,15 @@ export interface PackageStateRow {
         version?: string;
         dependencies?: string[];
     };
+    updateStatus?: {
+        currentVersion: string;
+        latestVersion: string | null;
+        currentCommitSha: string;
+        latestCommitSha: string | null;
+        upgradeAvailable: boolean;
+        checkedAt: string;
+        error?: string;
+    };
 }
 /**
  * Single message from a runtime session JSONL. Used by the Active Context
@@ -129,3 +139,50 @@ export interface HeartbeatRaw {
     content: string;
     lastUpdated: string | null;
 }
+/** Client mirror of a sync-scanner finding (GET /api/agent-packages/{id}/scan). */
+export interface ScanFinding {
+    type: string;
+    severity: 'warn' | 'error';
+    autoFixable: boolean;
+    message: string;
+    agentId?: string;
+    packageId?: string;
+    file?: string;
+    target?: string;
+    staleInputs?: string[];
+    hint?: string;
+}
+/** Client mirror of one timeline event (GET /:agentId/timeline). */
+export type TimelineEventView = {
+    type: 'run';
+    ts: number;
+    runId: string;
+    taskId: string;
+    taskTitle: string | null;
+    seq: number;
+    status: 'running' | 'settled' | 'superseded' | 'lost';
+    settleReason: string | null;
+    startedAt: number;
+    settledAt: number | null;
+    durationMs: number | null;
+    model: string | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    totalTokens: number | null;
+    costUsdMicros: number | null;
+    /** Route receipt (null = pre-migration rows). */
+    workClass: string | null;
+    routeSource: string | null;
+    logs: Array<{
+        ts: string;
+        message: string;
+    }>;
+    logsTruncated: boolean;
+} | {
+    type: 'event';
+    ts: number;
+    event: string;
+    severity: 'info' | 'warn';
+    message: string;
+    taskId: string | null;
+};

package/_internal/plugins/workflows/hooks/use-notification-channels.d.ts

@@ -1,4 +1,4 @@
-import type { NotificationChannelDef } from '../lib/notification-channel-registry';
+import type { NotificationChannelDef } from '../../../core/workflows/notification-channel-registry';
 export declare function useNotificationChannels(): NotificationChannelDef[];
 export declare function getChannelLabel(id: string, channels: NotificationChannelDef[]): string;
 /**

package/_internal/ui/behaviors/clipboard.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Clipboard write that works OUTSIDE secure contexts. Bakin is served over
+ * plain HTTP on the tailnet, where `navigator.clipboard` is UNDEFINED — the
+ * old `navigator.clipboard?.writeText(...)` pattern silently no-opped on
+ * every copy button (the 2026-07-25 chat copy bug). Async Clipboard API
+ * when available, legacy execCommand('copy') via an off-screen textarea
+ * otherwise. Returns whether the copy actually happened so UIs only show
+ * the success check for a real copy.
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;

package/_internal/ui/behaviors/resize-handle.d.ts

@@ -0,0 +1,15 @@
+import type { PersistedResizeHandleProps } from './use-persisted-leading-edge-resize';
+/** Props for the shared grab-bar chrome over `usePersistedLeadingEdgeResize`. */
+export interface ResizeHandleProps {
+    /** Direction of the grab bar itself: `horizontal` resizes height, `vertical` resizes width. */
+    orientation: 'horizontal' | 'vertical';
+    handleProps: PersistedResizeHandleProps;
+    /** Accessible name for the separator, e.g. "Resize message input". */
+    label: string;
+    /** Keep a quiet grab bar visible for panel and drawer boundaries. */
+    visibleAtRest?: boolean;
+    /** Site-owned layout, positioning, and cursor classes. */
+    className?: string;
+}
+/** One resize grab bar; every consumer keeps its own positioning and cursor rules. */
+export declare function ResizeHandle({ orientation, handleProps, label, visibleAtRest, className }: ResizeHandleProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/behaviors/selection-navigation.d.ts

@@ -0,0 +1,5 @@
+export type HorizontalSelectionKey = 'ArrowLeft' | 'ArrowRight' | 'Home' | 'End';
+export type VerticalSelectionKey = 'ArrowUp' | 'ArrowDown' | 'Home' | 'End';
+export declare function horizontalSelectionIndex(disabled: readonly boolean[], currentIndex: number, key: HorizontalSelectionKey): number | undefined;
+/** Vertical twin of `horizontalSelectionIndex` — same wrap and disabled-skip rules. */
+export declare function verticalSelectionIndex(disabled: readonly boolean[], currentIndex: number, key: VerticalSelectionKey): number | undefined;

package/_internal/ui/behaviors/use-persisted-leading-edge-resize.d.ts

@@ -0,0 +1,31 @@
+import { type KeyboardEvent, type PointerEvent } from 'react';
+type ResizeAxis = 'x' | 'y';
+interface PersistedResizeOptions {
+    axis: ResizeAxis;
+    defaultSize: number;
+    minSize: number;
+    maxSize: number;
+    storageKey?: string;
+    disabled?: boolean;
+}
+export interface PersistedResizeHandleProps {
+    role: 'separator';
+    tabIndex: number;
+    'aria-orientation': 'horizontal' | 'vertical';
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'data-resizing': boolean;
+    onPointerDown: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerMove: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerUp: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerCancel: (event: PointerEvent<HTMLDivElement>) => void;
+    onLostPointerCapture: (event: PointerEvent<HTMLDivElement>) => void;
+    onKeyDown: (event: KeyboardEvent<HTMLDivElement>) => void;
+}
+/** Private shared mechanics for a pane resized from its leading edge. */
+export declare function usePersistedLeadingEdgeResize({ axis, defaultSize, minSize, maxSize, storageKey, disabled, }: PersistedResizeOptions): {
+    size: number;
+    handleProps: PersistedResizeHandleProps;
+};
+export {};

package/_internal/ui/charts/area-chart.d.ts

@@ -0,0 +1,27 @@
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+export interface AreaChartProps {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Accessible name for the plot and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    height?: number;
+    /** Stack non-negative series into cumulative bands instead of overlaying them. */
+    stacked?: boolean;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/**
+ * Dependency-free cumulative-magnitude trend chart sharing LineChart's exact
+ * data, missing-value, and focus-equivalence contract. A single-series gap
+ * breaks the fill; a stacked column cannot honestly show a mid-stack gap, so
+ * the missing series is omitted from that column's band boundaries and the
+ * omission is surfaced through the exact table's missing labels.
+ */
+export declare function AreaChart({ data, series, label, description, height, stacked, formatValue, emptyLabel, compactData, showDataTable, dataTableExpandable, }: AreaChartProps): import("react/jsx-runtime").JSX.Element;

package/_internal/ui/charts/axis.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared axis and series-geometry helpers for the hand-rolled SVG chart kit.
+ * Chart-specific value semantics (stacked coercion, negative handling) stay
+ * local to the chart that owns them.
+ */
+/** Non-negative reported value; negative and non-finite readings are explicit gaps. */
+export declare function reportedValue(value: number | undefined): number | null;
+/** Thin dense x-axes to at most ~6 labels while always keeping the last one. */
+export declare function shouldRenderXLabel(index: number, count: number): boolean;
+/** Ellipsize long axis labels so dense axes stay legible. */
+export declare function axisLabel(label: string): string;
+/** Split a point series on gaps (nulls) into contiguous drawable runs. */
+export declare function contiguousSegments<P>(points: readonly (P | null)[]): P[][];

package/_internal/ui/charts/bar-chart.d.ts

@@ -0,0 +1,21 @@
+import { type ChartDatum, type ChartSeries } from './chart-data-table';
+export interface BarChartProps {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Accessible name for the plot and basis for its exact-data caption. */
+    label: string;
+    description?: string;
+    height?: number;
+    /** Stack non-negative series within each x-axis bucket instead of grouping them. */
+    stacked?: boolean;
+    formatValue?: (value: number) => string;
+    emptyLabel?: string;
+    /** Disable only when an equivalent exact table is rendered beside the chart. */
+    showDataTable?: boolean;
+    /** Collapse the exact-data table behind its disclosure for space-tight contexts. */
+    compactData?: boolean;
+    /** When false, the exact-data table renders statically with no disclosure. */
+    dataTableExpandable?: boolean;
+}
+/** Dependency-free grouped or stacked non-negative comparison chart with exact data. */
+export declare function BarChart({ data, series, label, description, height, stacked, formatValue, emptyLabel, showDataTable, compactData, dataTableExpandable, }: BarChartProps): import("react/jsx-runtime").JSX.Element;