@usetheo/ui 0.12.0 → 0.13.1

package/dist/components/composites/rollback-ui/rollback-ui.d.ts

@@ -0,0 +1,32 @@
+import type { HTMLAttributes } from "react";
+export interface RollbackTarget {
+    id: string;
+    version: string;
+    commitSha: string;
+    commitMessage: string;
+    deployedAt: string;
+    isCurrent?: boolean;
+    /**
+     * Optional duration of the deploy (e.g. "24s") for context.
+     */
+    duration?: string;
+}
+interface RollbackUIProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Deployment history, newest first. The current deploy should have `isCurrent: true`.
+     */
+    history: RollbackTarget[];
+    /**
+     * Fires when user confirms rollback to a specific target.
+     */
+    onRollback?: (targetId: string) => void | Promise<void>;
+}
+/**
+ * RollbackUI — instant rollback selector showing recent versions.
+ *
+ * The current deploy is marked, every other version offers a "Roll back" button.
+ * On select, the row enters confirm state (Confirm / Cancel buttons inline) before
+ * firing onRollback. This protects against accidental rollbacks while still being one click.
+ */
+declare const RollbackUI: import("react").ForwardRefExoticComponent<RollbackUIProps & import("react").RefAttributes<HTMLDivElement>>;
+export { RollbackUI };

package/dist/components/composites/rule-editor/index.d.ts

@@ -0,0 +1 @@
+export { RuleEditor } from "./rule-editor.js";

package/dist/components/composites/rule-editor/rule-editor.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes } from "react";
+import type { Rule } from "../../../types/rule.js";
+/**
+ * RuleEditor — form for creating or editing a Rule (behavior instruction
+ * injected into the system prompt).
+ */
+type RuleDraft = Omit<Rule, "id" | "updatedAt"> & {
+    id?: string;
+    tags?: string[];
+};
+interface RuleEditorProps extends Omit<HTMLAttributes<HTMLFormElement>, "onSubmit" | "onChange"> {
+    initial?: Partial<Rule>;
+    onSave: (draft: RuleDraft) => void;
+    onCancel?: () => void;
+    onDelete?: () => void;
+}
+export declare function RuleEditor({ className, initial, onSave, onCancel, onDelete, ...formProps }: RuleEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/composites/skill-editor/index.d.ts

@@ -0,0 +1 @@
+export { SkillEditor } from "./skill-editor.js";

package/dist/components/composites/skill-editor/skill-editor.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes } from "react";
+import type { Skill } from "../../primitives/skill-card/index.js";
+/**
+ * SkillEditor — form for creating or editing a Skill.
+ */
+type SkillDraft = Omit<Skill, "id"> & {
+    id?: string;
+    instructions?: string;
+};
+interface SkillEditorProps extends Omit<HTMLAttributes<HTMLFormElement>, "onSubmit" | "onChange"> {
+    initial?: Partial<Skill> & {
+        instructions?: string;
+    };
+    onSave: (draft: SkillDraft) => void;
+    onCancel?: () => void;
+    onDelete?: () => void;
+}
+export declare function SkillEditor({ className, initial, onSave, onCancel, onDelete, ...formProps }: SkillEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/composites/skills-list/index.d.ts

@@ -0,0 +1 @@
+export { SkillsList } from "./skills-list.js";

package/dist/components/composites/skills-list/skills-list.d.ts

@@ -0,0 +1,15 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import { type Skill, type SkillState } from "../../primitives/skill-card/index.js";
+interface SkillsListProps extends Omit<HTMLAttributes<HTMLDivElement>, "title" | "onToggle"> {
+    skills: Skill[];
+    title?: ReactNode;
+    /** If true, shows a search input above the grid. */
+    searchable?: boolean;
+    onToggle?: (id: string, next: SkillState) => void;
+}
+/**
+ * SkillsList — grid of SkillCards with optional search + source filter chips.
+ * Pairs with claw-code's `claw skills` inventory but visual.
+ */
+declare const SkillsList: import("react").ForwardRefExoticComponent<SkillsListProps & import("react").RefAttributes<HTMLDivElement>>;
+export { SkillsList };

package/dist/components/composites/slide-deck/context.d.ts

@@ -0,0 +1,23 @@
+/**
+ * DeckContext — internal Context shared between `<SlideDeck>` and its
+ * dot-namespace sub-components (`<SlideDeck.Controls>`, etc.). ADR D14.
+ */
+import { type Dispatch } from "react";
+import type { SlidePlugin } from "../../primitives/slide/index.js";
+import type { SlideDeckSlide, SlideDeckTransition } from "./schema.js";
+import type { DeckAction, DeckState } from "./use-deck-state.js";
+export interface DeckContextValue {
+    state: DeckState;
+    dispatch: Dispatch<DeckAction>;
+    slides: SlideDeckSlide[];
+    transition: SlideDeckTransition;
+    deckId: string;
+    /** Rich-content plugins relayed to every inner `<Slide>` (D15). */
+    plugins?: SlidePlugin[];
+    /** Toggle browser fullscreen on the deck root. Safe to call when unsupported. */
+    toggleFullscreen: () => void | Promise<void>;
+    /** Trigger native print dialog with deck-specific @page CSS. */
+    print: () => void;
+}
+export declare const DeckContext: import("react").Context<DeckContextValue | null>;
+export declare function useDeckContext(): DeckContextValue;

package/dist/components/composites/slide-deck/controls.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `<SlideDeck.Controls>` — prev/next buttons + slide indicator ("3 / 12").
+ */
+import type { FC } from "react";
+export interface ControlsProps {
+    className?: string;
+}
+export declare const Controls: FC<ControlsProps>;

package/dist/components/composites/slide-deck/fragments.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Progressive fragments detector (ADR D12).
+ *
+ * Marpit convention: lists with `*` (asterisco) marker — instead of `-` or `+`
+ * — become fragment-revealed lists. Each item is a step.
+ *
+ * Implementation: regex pre-pass on raw markdown counts top-of-line `* ` markers.
+ * Decision (EC-9): mixed `*` and `-` in the same list is rare; we count ONLY
+ * `* ` items as fragments. Plain `- item` lists remain non-fragmented.
+ *
+ * v0.4: counts only. CSS attribute application happens at render time inside
+ * `<SlideDeck.Slides>`, post-parse, by walking the rendered DOM.
+ */
+/**
+ * Count fragment markers in raw markdown.
+ *
+ * Detects only `*` at start of a line followed by space + non-whitespace.
+ * Avoids matching `**bold**`, `*italic*`, or `_ * _` patterns.
+ */
+export declare function countFragmentsInMarkdown(markdown: string): number;

package/dist/components/composites/slide-deck/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Public surface of `@theokit/ui/slide-deck`. Subpath-isolated composite engine.
+ */
+export { SlideDeck } from "./slide-deck.js";
+export type { SlideDeckProps } from "./slide-deck.js";
+export { slideDeckInput, slideDeckSlide, slideDeckTransition, type SlideDeckInput, type SlideDeckSlide, type SlideDeckTransition, } from "./schema.js";
+export { splitDeck } from "./split-deck.js";
+export { extractNotes } from "./notes.js";
+export { countFragmentsInMarkdown } from "./fragments.js";
+export { formatHash, readHashIndex, readInitialHash, useDeckHashRouting, } from "./use-deck-hash-routing.js";
+export { deckReducer, useDeckState, type DeckAction, type DeckState, } from "./use-deck-state.js";
+export { useDeckKeyboard } from "./use-deck-keyboard.js";
+export { useDeckSwipe } from "./use-deck-swipe.js";
+export { useFullscreen } from "./use-fullscreen.js";
+export { injectPrintStyles, printDeck, removePrintStyles, } from "./print-styles.js";
+export { Controls } from "./controls.js";
+export { ProgressBar } from "./progress-bar.js";
+export { SlideNumber } from "./slide-number.js";
+export { Thumbnails } from "./thumbnails.js";
+export { PresenterView } from "./presenter-view.js";
+export { DeckContext, useDeckContext, type DeckContextValue, } from "./context.js";

package/dist/components/composites/slide-deck/notes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Speaker notes extractor (ADR D11).
+ *
+ * Sintaxe: HTML comments `<!-- notes: ... -->` ou `<!-- note: ... -->`.
+ * Aceita ambos singular e plural. Texto interno é plain (sem markdown nesting
+ * em v0.4 — pode vir em v0.5).
+ *
+ * Returns the body with comments removed and the aggregated notes string.
+ */
+export interface ExtractNotesResult {
+    body: string;
+    notes: string | undefined;
+}
+export declare function extractNotes(md: string): ExtractNotesResult;

package/dist/components/composites/slide-deck/presenter-view.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `<SlideDeck.PresenterView>` — inline split-screen panel.
+ *
+ * Pragmatic v0.4 scope: renders an in-page panel (current slide + next slide +
+ * speaker notes + timer) when `state.presenterMode === true`. The separate
+ * window via `window.open` + `BroadcastChannel` is deferred to v0.5 (consumer
+ * demand will trigger the upgrade — D6 of the plan is reduced to inline panel).
+ *
+ * Toggling presenter mode is dispatched via hotkey (n/N/p/P, see useDeckKeyboard).
+ */
+import { type FC } from "react";
+export interface PresenterViewProps {
+    className?: string;
+}
+export declare const PresenterView: FC<PresenterViewProps>;

package/dist/components/composites/slide-deck/print-styles.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Print CSS injection (ADR D7).
+ *
+ * Injects a `<style id="theo-slide-deck-print">` element into the document
+ * head with `@page` + `@media print` rules that render `.theo-slide-deck-print-container`
+ * with one slide per page. Calls `window.print()`. Removes the style on the
+ * `afterprint` event (cleanup runs regardless of print cancel/complete).
+ */
+export declare function injectPrintStyles(): HTMLStyleElement;
+export declare function removePrintStyles(): void;
+export interface PrintDeckOptions {
+    /** Optional callback fired after print dialog closes (success or cancel). */
+    onAfterPrint?: () => void;
+}
+/**
+ * Trigger native print dialog with deck-specific CSS injected.
+ *
+ * The `afterprint` event listener is cleaned up automatically. Idempotent —
+ * calling twice in quick succession is safe (style is reused).
+ */
+export declare function printDeck(opts?: PrintDeckOptions): void;

package/dist/components/composites/slide-deck/progress-bar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `<SlideDeck.ProgressBar>` — horizontal HTML5 progress element.
+ */
+import type { FC } from "react";
+export interface ProgressBarProps {
+    className?: string;
+}
+export declare const ProgressBar: FC<ProgressBarProps>;

package/dist/components/composites/slide-deck/schema.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Zod schema for `<SlideDeck>` input.
+ *
+ * Two shapes accepted (ADR D4):
+ *   - `string` — full markdown, split internally by `splitDeck` (top-level
+ *     `thematicBreak`, see ADR D3 / D12 of Slide).
+ *   - `SlideDeckSlide[]` — pre-parsed array (CMS/DB consumers).
+ *
+ * See `.claude/knowledge-base/plans/slide-deck-composite-plan.md` §16.3.
+ */
+import { z } from "zod";
+export declare const slideDeckSlide: z.ZodObject<{
+    markdown: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Composed input — `slides` prop accepts either form. */
+export declare const slideDeckInput: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+    markdown: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>]>;
+export type SlideDeckSlide = z.infer<typeof slideDeckSlide>;
+export type SlideDeckInput = z.infer<typeof slideDeckInput>;
+/** Transition presets. ADR D8. */
+export declare const slideDeckTransition: z.ZodEnum<{
+    none: "none";
+    slide: "slide";
+    fade: "fade";
+}>;
+export type SlideDeckTransition = z.infer<typeof slideDeckTransition>;

package/dist/components/composites/slide-deck/slide-deck.d.ts

@@ -0,0 +1,78 @@
+import { type FC, type ReactNode } from "react";
+/**
+ * `<SlideDeck>` — composite engine orchestrating N `<Slide>` primitives.
+ *
+ * Subpath-isolated at `@theokit/ui/slide-deck` (ADR D1). Imports `<Slide>` via
+ * the public package path so consumer's installed peer-deps are reused.
+ *
+ * See RFC 0003 and the plan in
+ * `.claude/knowledge-base/plans/slide-deck-composite-plan.md`.
+ *
+ * Two render modes:
+ *   - DEFAULT layout: no children → renders canonical chrome (Slides + Controls
+ *     + ProgressBar + SlideNumber + PresenterView + buttons).
+ *   - HEADLESS: children provided → consumer composes own layout from
+ *     `<SlideDeck.X>` sub-components and a shared DeckContext.
+ *
+ * SSR-safe: parses markdown only inside `useEffect`. Hash routing uses lazy
+ * `initFromHash` (D17) to avoid hydration mismatch. Reducer clamps
+ * `currentIndex` whenever `slides.length` changes (EC-4 reconciliation).
+ */
+import { type SlidePlugin } from "../../primitives/slide/index.js";
+import { Controls } from "./controls.js";
+import { PresenterView } from "./presenter-view.js";
+import { ProgressBar } from "./progress-bar.js";
+import type { SlideDeckInput, SlideDeckSlide, SlideDeckTransition } from "./schema.js";
+import { SlideNumber } from "./slide-number.js";
+import { Thumbnails } from "./thumbnails.js";
+import "./transitions.css";
+export interface SlideDeckProps {
+    /** Markdown string (auto-split) or pre-parsed slide array. */
+    slides: SlideDeckInput;
+    /** Initial slide index (0-based). Default 0. */
+    initialIndex?: number;
+    /** Transition preset. Default "fade". */
+    transition?: SlideDeckTransition;
+    /** Enable keyboard navigation. Default true. */
+    enableKeyboard?: boolean;
+    /** Enable touch/pointer swipe navigation. Default true. */
+    enableTouch?: boolean;
+    /** Enable hash routing (#/N). Default true. */
+    enableHashRouting?: boolean;
+    /** Optional unique deck id (auto-generated UUID if absent). */
+    deckId?: string;
+    /** Called after each navigation. */
+    onIndexChange?: (index: number, slide: SlideDeckSlide | undefined) => void;
+    /** Headless mode: render custom chrome using `<SlideDeck.X>` sub-components. */
+    children?: ReactNode;
+    /** Outer className for the deck root. */
+    className?: string;
+    /** Accessible label for the deck region. Defaults to "Slide deck". */
+    "aria-label"?: string;
+    /**
+     * Rich-content plugins relayed to every inner `<Slide>` (D15 / RFC 0004).
+     * Pass MEMOIZED arrays to avoid re-parses on every render.
+     */
+    plugins?: SlidePlugin[];
+}
+type SlideDeckComponent = FC<SlideDeckProps> & {
+    Slides: FC<{
+        className?: string;
+    }>;
+    Controls: typeof Controls;
+    ProgressBar: typeof ProgressBar;
+    SlideNumber: typeof SlideNumber;
+    Thumbnails: typeof Thumbnails;
+    PresenterView: typeof PresenterView;
+    PresenterButton: FC<{
+        className?: string;
+    }>;
+    FullscreenButton: FC<{
+        className?: string;
+    }>;
+    PrintButton: FC<{
+        className?: string;
+    }>;
+};
+declare const SlideDeck: SlideDeckComponent;
+export { SlideDeck };

package/dist/components/composites/slide-deck/slide-number.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `<SlideDeck.SlideNumber>` — decorative "N / Total" overlay.
+ *
+ * aria-hidden because the live indicator in <Controls> already announces the
+ * current position; this is purely visual chrome.
+ */
+import type { FC } from "react";
+export interface SlideNumberProps {
+    className?: string;
+}
+export declare const SlideNumber: FC<SlideNumberProps>;

package/dist/components/composites/slide-deck/split-deck.d.ts

@@ -0,0 +1,2 @@
+import type { SlideDeckSlide } from "./schema.js";
+export declare function splitDeck(markdown: string): Promise<SlideDeckSlide[]>;

package/dist/components/composites/slide-deck/thumbnails.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `<SlideDeck.Thumbnails>` — sidebar with mini Slide instances.
+ *
+ * Performance strategy:
+ *   - Each thumbnail renders the actual `<Slide>` inside a scaled wrapper (~0.18×).
+ *   - IntersectionObserver lazy-loads thumbnails — off-screen ones show a
+ *     placeholder skeleton instead of parsing the markdown.
+ *   - EC-13: when IntersectionObserver is undefined (legacy env / SSR), falls
+ *     back to eager render. Acceptable for decks ≤ 50 slides.
+ *
+ * Click handler dispatches JUMP_TO. Auto-scroll keeps current thumbnail visible.
+ */
+import { type FC } from "react";
+export interface ThumbnailsProps {
+    className?: string;
+    /** Scale of each thumbnail. Default 0.18. */
+    scale?: number;
+}
+export declare const Thumbnails: FC<ThumbnailsProps>;

package/dist/components/composites/slide-deck/use-deck-hash-routing.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Hash routing hook (ADR D13).
+ *
+ * Pattern `#/N` (1-based). Bidirectional sync:
+ *   - Initial state: read via `useDeckState`'s lazy `initFromHash` (D17 SSR-safe).
+ *   - hashchange event → JUMP_TO.
+ *   - currentIndex change → `history.replaceState` (does NOT trigger hashchange,
+ *     so no infinite loop — verified in test EC-10).
+ */
+import { type Dispatch } from "react";
+import type { DeckAction } from "./use-deck-state.js";
+export interface UseDeckHashRoutingOptions {
+    enabled?: boolean;
+    totalSlides: number;
+    currentIndex: number;
+}
+/** Read hash → return 0-based index, or undefined if not present/invalid. */
+export declare function readHashIndex(hash: string): number | undefined;
+/** SSR-safe wrapper for initial hash read (D17). */
+export declare function readInitialHash(): number | undefined;
+/** Format index → hash string. */
+export declare function formatHash(zeroBasedIndex: number): string;
+export declare function useDeckHashRouting(dispatch: Dispatch<DeckAction>, opts: UseDeckHashRoutingOptions): void;

package/dist/components/composites/slide-deck/use-deck-keyboard.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Keyboard navigation hook (ADR D9).
+ *
+ * Hardcoded bindings (no remap in v0.4):
+ *   ArrowRight, Space, PageDown → NEXT_SLIDE
+ *   ArrowLeft,  PageUp          → PREV_SLIDE
+ *   Home                        → JUMP_TO 0
+ *   End                         → JUMP_TO last
+ *   Escape                      → SET_FULLSCREEN false
+ *   f / F                       → toggleFullscreen callback
+ *   n / N / p / P               → TOGGLE_PRESENTER
+ *   Ctrl+P / Meta+P             → onPrint callback (preventDefault)
+ *
+ * Guards: ignora events quando target é INPUT, TEXTAREA, ou contentEditable
+ * (consumer pode ter inputs em modais sem conflito).
+ */
+import { type Dispatch } from "react";
+import type { DeckAction } from "./use-deck-state.js";
+export interface UseDeckKeyboardOptions {
+    enabled?: boolean;
+    totalSlides: number;
+    onToggleFullscreen?: () => void;
+    onPrint?: () => void;
+}
+export declare function useDeckKeyboard(dispatch: Dispatch<DeckAction>, opts: UseDeckKeyboardOptions): void;

package/dist/components/composites/slide-deck/use-deck-state.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Deck state machine (ADR D5).
+ *
+ * Single useReducer governs all deck-level state transitions: currentIndex,
+ * currentFragment, presenterMode, fullscreen, transitionDirection.
+ *
+ * NEXT_SLIDE advances fragment first if `currentFragment < totalFragmentsInCurrent`,
+ * else advances slide. PREV_SLIDE mirrors. JUMP_TO clamps to valid range.
+ *
+ * ADR D17: lazy init reads hash via `initFromHash` callback when provided —
+ * SSR-safe (callback guards `typeof window !== "undefined"`).
+ */
+import { type Dispatch } from "react";
+export interface DeckState {
+    currentIndex: number;
+    currentFragment: number;
+    presenterMode: boolean;
+    fullscreen: boolean;
+    transitionDirection: "none" | "next" | "prev";
+    totalSlides: number;
+    totalFragmentsInCurrent: number;
+}
+export type DeckAction = {
+    type: "NEXT_SLIDE";
+} | {
+    type: "PREV_SLIDE";
+} | {
+    type: "JUMP_TO";
+    index: number;
+} | {
+    type: "NEXT_FRAGMENT";
+} | {
+    type: "PREV_FRAGMENT";
+} | {
+    type: "RESET_FRAGMENTS";
+} | {
+    type: "TOGGLE_PRESENTER";
+} | {
+    type: "SET_FULLSCREEN";
+    value: boolean;
+} | {
+    type: "UPDATE_TOTAL_SLIDES";
+    total: number;
+} | {
+    type: "UPDATE_TOTAL_FRAGMENTS";
+    total: number;
+} | {
+    type: "TRANSITION_END";
+};
+export declare function deckReducer(state: DeckState, action: DeckAction): DeckState;
+export interface UseDeckStateOptions {
+    initialIndex?: number;
+    totalSlides: number;
+    /** Lazy initializer hook (D17): returns initial index, e.g. parsing hash. */
+    initFromHash?: () => number | undefined;
+}
+export declare function useDeckState(opts: UseDeckStateOptions): readonly [DeckState, Dispatch<DeckAction>];

package/dist/components/composites/slide-deck/use-deck-swipe.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Touch swipe hook (ADR D10).
+ *
+ * Detecta swipe horizontal via Pointer Events nativos:
+ *   - threshold: 50px de deslocamento
+ *   - velocity: > 0.3 px/ms
+ *   - direction guard: |dx| > 2*|dy| (bloqueia swipe vertical / scroll)
+ *
+ * Swipe left (dx < 0) → NEXT_SLIDE
+ * Swipe right (dx > 0) → PREV_SLIDE
+ *
+ * EC-6: pointercancel limpa o tracking state (mobile browser pode cancelar mid-swipe).
+ * EC-7: tracking limita ao primeiro pointerId (multi-touch é ignorado).
+ */
+import { type Dispatch, type RefObject } from "react";
+import type { DeckAction } from "./use-deck-state.js";
+export interface UseDeckSwipeOptions {
+    enabled?: boolean;
+}
+export declare function useDeckSwipe(ref: RefObject<HTMLElement | null>, dispatch: Dispatch<DeckAction>, opts?: UseDeckSwipeOptions): void;

package/dist/components/composites/slide-deck/use-fullscreen.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cross-browser fullscreen hook (ADR D6 area / EC-8).
+ *
+ * Wraps `Element.requestFullscreen()` + Safari `webkit*` prefix. Listens
+ * `fullscreenchange` (+ webkit) to sync state when user presses Esc via the
+ * native UI.
+ *
+ * EC-8: iOS Safari < 16 doesn't expose fullscreen on arbitrary elements (only
+ * `<video>`). Feature-detect — when unavailable, hook is a no-op and `toggle`
+ * is safe to call.
+ */
+import { type RefObject } from "react";
+export interface UseFullscreenResult {
+    isFullscreen: boolean;
+    toggle: () => Promise<void>;
+    isSupported: boolean;
+}
+export declare function useFullscreen(ref: RefObject<HTMLElement | null>): UseFullscreenResult;

package/dist/components/composites/stability-bundle-viewer/index.d.ts

@@ -0,0 +1 @@
+export { StabilityBundleViewer, type StabilityBundle, type StabilityBundleViewerProps, type StabilitySeverity, } from "./stability-bundle-viewer.js";

package/dist/components/composites/stability-bundle-viewer/stability-bundle-viewer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * StabilityBundleViewer — inspector for a stability-bundle JSON produced by a
+ * server crash. Sections (error, env, config, metadata) collapse independently.
+ *
+ * EC-9: handles bundles missing optional sections gracefully. Renderer DOES
+ * NOT redact env values — bundle writer is expected to redact at emit-time.
+ */
+export type StabilitySeverity = "fatal" | "error" | "warn";
+export interface StabilityBundle {
+    timestamp: string;
+    severity: StabilitySeverity;
+    summary: string;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+    env?: Record<string, string>;
+    config?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface StabilityBundleViewerProps {
+    bundle: StabilityBundle;
+    onCopy?: () => void;
+    className?: string;
+    "data-testid"?: string;
+}
+export declare const StabilityBundleViewer: import("react").ForwardRefExoticComponent<StabilityBundleViewerProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/composites/status-indicator/index.d.ts

@@ -0,0 +1,2 @@
+export { StatusIndicator } from "./status-indicator.js";
+export type { StatusIndicatorKind, StatusIndicatorProps, StatusIndicatorSize, } from "./status-indicator.js";

package/dist/components/composites/status-indicator/status-indicator.d.ts

@@ -0,0 +1,31 @@
+import { type HTMLAttributes } from "react";
+/**
+ * StatusIndicator — semantic operational-state indicator (composite).
+ *
+ * Consumes the `--status-online` / `--status-offline` / `--status-degraded`
+ * / `--status-info` token group (ADR-0007). Statuses describe component
+ * liveness (alive/dead/slow/info-flag), distinct from action-result
+ * semantics (success/destructive/warning/info — see `StatusDot` primitive).
+ *
+ * Hierarchy invariant (T4.1): this composite consumes primitives via
+ * Tailwind tokens (`bg-status-*`), never imports another composite. The
+ * `StatusDot` primitive remains as a separate, more generic API.
+ *
+ * @example
+ *   <StatusIndicator status="online" />
+ *   <StatusIndicator status="degraded" label="Slow" />
+ *   <StatusIndicator status="offline" label="Disconnected" size="md" />
+ */
+export type StatusIndicatorKind = "online" | "offline" | "degraded" | "info";
+export type StatusIndicatorSize = "sm" | "md";
+export interface StatusIndicatorProps extends Omit<HTMLAttributes<HTMLSpanElement>, "children"> {
+    /** Operational state to convey. Maps to `--status-{kind}`. */
+    status: StatusIndicatorKind;
+    /** Optional inline label to the right of the dot. */
+    label?: string;
+    /** Size of the dot. Default `sm` (8px). */
+    size?: StatusIndicatorSize;
+    /** When true, pulses the dot to draw attention (e.g., live state). */
+    pulse?: boolean;
+}
+export declare const StatusIndicator: import("react").ForwardRefExoticComponent<StatusIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/components/composites/task-header/index.d.ts

@@ -0,0 +1 @@
+export { TaskHeader } from "./task-header.js";

package/dist/components/composites/task-header/task-header.d.ts

@@ -0,0 +1,20 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import type { TaskStatus } from "../../../types/task.js";
+interface TaskHeaderProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    title: ReactNode;
+    status?: TaskStatus;
+    /**
+     * If provided, a chevron is shown next to the title and clicking it fires this callback.
+     * Used as the "expand task metadata" affordance in the Infra shell.
+     */
+    onToggle?: () => void;
+    /** Right-side actions (e.g. cancel task, close panel). */
+    actions?: ReactNode;
+}
+/**
+ * TaskHeader — title bar for a task pane.
+ *
+ * Visual: display-md title with chevron + optional status badge with pulse + actions slot.
+ */
+declare const TaskHeader: import("react").ForwardRefExoticComponent<TaskHeaderProps & import("react").RefAttributes<HTMLElement>>;
+export { TaskHeader };

package/dist/components/composites/text-prompt/index.d.ts

@@ -0,0 +1 @@
+export { TextPrompt, type TextPromptProps, type TextPromptResult } from "./text-prompt.js";