react-agentic 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,3320 @@
+import { ReactNode } from 'react';
+import { SourceFile, Project, JsxElement, JsxSelfClosingElement, JsxFragment, JsxOpeningElement, InterfaceDeclaration, JsxText, JsxExpression, ObjectLiteralExpression, Node } from 'ts-morph';
+
+/**
+ * Markdown Primitives - Compile-time JSX components
+ *
+ * These components are compile-time only - they're transformed by the transpiler
+ * and never executed at runtime. They exist to provide TypeScript type checking.
+ */
+
+/**
+ * Props for the Markdown component
+ */
+interface MarkdownProps {
+    /** Raw Markdown content to pass through */
+    children?: ReactNode;
+}
+/**
+ * Markdown component - passes content through as raw Markdown
+ *
+ * This is a compile-time component transformed by react-agentic.
+ * It's never executed at runtime.
+ *
+ * @example
+ * <Markdown>
+ * ## Pre-formatted Section
+ *
+ * Content that is already in Markdown format.
+ * </Markdown>
+ */
+declare function Markdown(_props: MarkdownProps): null;
+/**
+ * Props for the XmlBlock component
+ */
+interface XmlBlockProps {
+    /** XML tag name for the block */
+    name: string;
+    /** Block content */
+    children?: ReactNode;
+}
+/**
+ * XmlBlock component - creates a named XML block
+ *
+ * This is a compile-time component transformed by react-agentic.
+ * It's never executed at runtime.
+ *
+ * @example
+ * <XmlBlock name="instructions">
+ *   <p>Content inside the block</p>
+ * </XmlBlock>
+ *
+ * Outputs:
+ * <instructions>
+ * Content inside the block
+ * </instructions>
+ */
+declare function XmlBlock(_props: XmlBlockProps): null;
+/**
+ * Props for the Indent component
+ */
+interface IndentProps {
+    /** Number of spaces to indent (default: 2) */
+    spaces?: number;
+    /** Block content to indent */
+    children?: ReactNode;
+}
+/**
+ * Indent component - indents content by a specified number of spaces
+ *
+ * This is a compile-time component transformed by react-agentic.
+ * It's never executed at runtime.
+ *
+ * @example
+ * <Indent spaces={4}>
+ *   This content will be indented by 4 spaces.
+ *   Each line gets the same indentation.
+ * </Indent>
+ *
+ * Outputs:
+ *     This content will be indented by 4 spaces.
+ *     Each line gets the same indentation.
+ */
+declare function Indent(_props: IndentProps): null;
+
+/**
+ * Structured Data Components - Compile-time JSX components
+ *
+ * These components are compile-time only - they're transformed by the transpiler
+ * and never executed at runtime. They exist to provide TypeScript type checking.
+ */
+/**
+ * Alignment options for table columns
+ */
+type TableAlignment = 'left' | 'center' | 'right';
+/**
+ * Props for the Table component
+ */
+interface TableProps {
+    /** Optional header row */
+    headers?: string[];
+    /** Data rows - each row is an array of cell values (null/undefined use emptyCell) */
+    rows: (string | number | null | undefined)[][];
+    /** Per-column alignment (defaults to 'left' for all columns) */
+    align?: TableAlignment[];
+    /** Content for empty cells (defaults to empty string) */
+    emptyCell?: string;
+}
+/**
+ * Table component - emits markdown table from structured props
+ *
+ * This is a compile-time component transformed by react-agentic.
+ * It's never executed at runtime.
+ *
+ * @example
+ * <Table
+ *   headers={["Name", "Age", "City"]}
+ *   rows={[
+ *     ["Alice", 30, "NYC"],
+ *     ["Bob", 25, "LA"],
+ *   ]}
+ *   align={["left", "right", "center"]}
+ * />
+ *
+ * Outputs:
+ * | Name | Age | City |
+ * | :--- | ---: | :---: |
+ * | Alice | 30 | NYC |
+ * | Bob | 25 | LA |
+ */
+declare function Table(_props: TableProps): null;
+/**
+ * Props for the List component
+ */
+interface ListProps {
+    /** List items */
+    items: (string | number)[];
+    /** Use ordered (numbered) list (default: false for bullet list) */
+    ordered?: boolean;
+    /** Starting number for ordered lists (default: 1) */
+    start?: number;
+}
+/**
+ * List component - emits markdown list from structured props
+ *
+ * This is a compile-time component transformed by react-agentic.
+ * It's never executed at runtime.
+ *
+ * @example
+ * <List items={["First item", "Second item", "Third item"]} />
+ *
+ * Outputs:
+ * - First item
+ * - Second item
+ * - Third item
+ *
+ * @example
+ * <List items={["Step one", "Step two"]} ordered start={5} />
+ *
+ * Outputs:
+ * 5. Step one
+ * 6. Step two
+ */
+declare function List(_props: ListProps): null;
+
+/**
+ * Command Component - Compile-time JSX component
+ *
+ * This component is compile-time only - it's transformed by the transpiler
+ * and never executed at runtime. It exists to provide TypeScript type checking.
+ */
+
+/**
+ * Command argument definition
+ * Used for commands that accept arguments via the skill system
+ */
+interface CommandArgument {
+    /** Argument name */
+    name: string;
+    /** Description of the argument */
+    description: string;
+    /** Whether the argument is required (default: false) */
+    required?: boolean;
+}
+/**
+ * Context available in Command render props pattern
+ * All values resolved at compile time, static in output
+ */
+interface CommandContext {
+    /** Command name from props */
+    name: string;
+    /** Command description from props */
+    description: string;
+    /** Skill name if invoked via skill (undefined otherwise) */
+    skill?: string;
+    /** Subfolder for output path (e.g., "gsd" → .claude/commands/gsd/my-cmd.md) */
+    folder?: string;
+    /** Resolved output path (e.g., .claude/commands/my-cmd.md) */
+    outputPath: string;
+    /** Source TSX file path */
+    sourcePath: string;
+}
+/**
+ * Props for the Command component
+ */
+interface CommandProps {
+    /** Command name (used in frontmatter) */
+    name: string;
+    /** Command description (used in frontmatter) */
+    description: string;
+    /** Optional argument hint (maps to argument-hint in frontmatter) */
+    argumentHint?: string;
+    /** Optional agent name (maps to agent in frontmatter) */
+    agent?: string;
+    /** Optional list of allowed tools (maps to allowed-tools in frontmatter) */
+    allowedTools?: string[];
+    /** Subfolder for output path (e.g., "gsd" → .claude/commands/gsd/my-cmd.md) */
+    folder?: string;
+    /** Arguments array (maps to arguments in frontmatter) */
+    arguments?: CommandArgument[];
+    /**
+     * Command body content - either regular JSX or render props function
+     * Render props: (ctx: CommandContext) => ReactNode
+     */
+    children?: ReactNode | ((ctx: CommandContext) => ReactNode);
+}
+/**
+ * Command component - creates a Claude Code command with frontmatter
+ *
+ * This is a compile-time component transformed by react-agentic.
+ * It's never executed at runtime.
+ *
+ * @example
+ * <Command name="my-command" description="Does something useful">
+ *   <p>Command instructions here</p>
+ * </Command>
+ */
+declare function Command(_props: CommandProps): null;
+
+/**
+ * Runtime Variable System for Hybrid Runtime
+ *
+ * RuntimeVar is a branded type that tracks JSON variable paths at compile time.
+ * The proxy pattern captures property access for jq expression generation.
+ *
+ * Usage:
+ * const ctx = useRuntimeVar<MyType>('CTX');
+ * // ctx.error becomes $(echo "$CTX" | jq -r '.error')
+ * // ctx.user.name becomes $(echo "$CTX" | jq -r '.user.name')
+ */
+/**
+ * Brand symbol for compile-time type safety
+ * Prevents accidental mixing of RuntimeVar with regular values
+ */
+declare const __runtimeVarBrand: unique symbol;
+/**
+ * Internal RuntimeVar metadata interface
+ */
+interface RuntimeVarMeta<T> {
+    readonly [__runtimeVarBrand]: T;
+    /** Shell variable name (e.g., 'CTX') */
+    readonly __varName: string;
+    /** Property access path (e.g., ['user', 'name']) */
+    readonly __path: readonly string[];
+}
+/**
+ * Base RuntimeVar type - branded string intersection
+ *
+ * By intersecting with `string`, RuntimeVar becomes assignable to:
+ * - string (for comparisons like `ctx.status === 'SUCCESS'`)
+ * - ReactNode (for JSX interpolation like `{ctx.message}`)
+ *
+ * The brand ensures type safety while allowing ergonomic usage in JSX.
+ * At runtime, the proxy's toString() returns the jq expression.
+ */
+type RuntimeVar<T> = string & RuntimeVarMeta<T>;
+/**
+ * RuntimeVarProxy enables deep property access tracking
+ * Each property access returns a new proxy with extended path
+ *
+ * @example
+ * const ctx = useRuntimeVar<{user: {name: string}}>('CTX');
+ * ctx.__path // []
+ * ctx.user.__path // ['user']
+ * ctx.user.name.__path // ['user', 'name']
+ *
+ * // Works in JSX:
+ * <p>Hello, {ctx.user.name}</p>
+ *
+ * // Works in comparisons:
+ * if (ctx.status === 'SUCCESS') { ... }
+ */
+type RuntimeVarProxy<T> = RuntimeVar<T> & {
+    readonly [K in keyof T]: T[K] extends object ? RuntimeVarProxy<T[K]> : RuntimeVar<T[K]>;
+};
+/**
+ * Create a typed runtime variable reference
+ *
+ * This hook-style function creates a compile-time reference to a shell variable
+ * that will be populated at runtime by a RuntimeFn call.
+ *
+ * The returned proxy tracks property access paths, which the transformer
+ * converts to jq expressions for shell execution.
+ *
+ * @param name - Shell variable name (should be UPPER_SNAKE_CASE)
+ * @returns RuntimeVarProxy that tracks property access
+ *
+ * @example
+ * interface Context {
+ *   error?: string;
+ *   data: { count: number };
+ * }
+ *
+ * const ctx = useRuntimeVar<Context>('CTX');
+ *
+ * // In JSX:
+ * <If condition={ctx.error}>...</If>
+ * // Emits: **If $(echo "$CTX" | jq -r '.error'):**
+ *
+ * <p>Count: {ctx.data.count}</p>
+ * // Emits: Count: $(echo "$CTX" | jq -r '.data.count')
+ */
+declare function useRuntimeVar<T>(name: string): RuntimeVarProxy<T>;
+/**
+ * Check if a value is a RuntimeVar proxy
+ *
+ * Used by transformers to detect when to generate jq expressions
+ * instead of literal values.
+ *
+ * @param value - Value to check
+ * @returns true if value is a RuntimeVar proxy
+ */
+declare function isRuntimeVar(value: unknown): value is RuntimeVar<unknown>;
+/**
+ * Extract RuntimeVar metadata from a proxy
+ *
+ * @param runtimeVar - RuntimeVar proxy
+ * @returns Object with varName and path
+ */
+declare function getRuntimeVarInfo(runtimeVar: RuntimeVar<unknown>): {
+    varName: string;
+    path: readonly string[];
+};
+/**
+ * Convert RuntimeVar to jq shell expression
+ *
+ * @param runtimeVar - RuntimeVar proxy
+ * @returns Shell command string like $(echo "$VAR" | jq -r '.path')
+ *
+ * @example
+ * toJqExpression(ctx.user.name)
+ * // Returns: $(echo "$CTX" | jq -r '.user.name')
+ */
+declare function toJqExpression(runtimeVar: RuntimeVar<unknown>): string;
+/**
+ * Convert RuntimeVar to raw jq path expression (without shell wrapper)
+ *
+ * @param runtimeVar - RuntimeVar proxy
+ * @returns jq path string like '.user.name'
+ */
+declare function toJqPath(runtimeVar: RuntimeVar<unknown>): string;
+/**
+ * Allow a value OR its RuntimeVar equivalent
+ *
+ * Use for component props that should accept runtime interpolation.
+ * This enables props to accept either static values or RuntimeVar references.
+ *
+ * @example
+ * interface MyProps {
+ *   count: OrRuntimeVar<number>;  // Accepts 5 or ctx.count
+ *   name: OrRuntimeVar<string>;   // Accepts "hello" or ctx.name
+ * }
+ */
+type OrRuntimeVar<T> = T | RuntimeVar<T> | RuntimeVarProxy<T>;
+/**
+ * Transform object type so each property accepts RuntimeVar
+ *
+ * Use for complex props like RuntimeFn args where each property
+ * can be either a static value or a RuntimeVar reference.
+ *
+ * @example
+ * interface Args { x: number; y: string; }
+ * type FlexibleArgs = AllowRuntimeVars<Args>;
+ * // { x: number | RuntimeVar<number>; y: string | RuntimeVar<string>; }
+ */
+type AllowRuntimeVars<T> = T extends object ? {
+    [K in keyof T]: OrRuntimeVar<T[K]>;
+} : OrRuntimeVar<T>;
+
+/**
+ * Agent Components - Compile-time JSX components
+ *
+ * These components are compile-time only - they're transformed by the transpiler
+ * and never executed at runtime. They exist to provide TypeScript type checking.
+ */
+
+/**
+ * Standard agent status values
+ */
+type AgentStatus = 'SUCCESS' | 'BLOCKED' | 'NOT_FOUND' | 'ERROR' | 'CHECKPOINT';
+/**
+ * Base output interface for all agents
+ */
+interface BaseOutput {
+    /** Agent completion status */
+    status: AgentStatus;
+    /** Explanation when blocked */
+    blockedBy?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Context available in Agent render props pattern
+ * Extends CommandContext with agent-specific fields
+ */
+interface AgentContext extends CommandContext {
+    /** Space-separated tool names if defined */
+    tools?: string;
+    /** Model name if specified in agent */
+    model?: string;
+}
+/**
+ * Props for the Agent component
+ * @typeParam TInput - Type interface for agent input contract (compile-time only)
+ * @typeParam TOutput - Type interface for agent output contract (compile-time only)
+ */
+interface AgentProps<TInput = unknown, TOutput = unknown> {
+    /** Agent name (used in frontmatter and Task() spawning) */
+    name: string;
+    /** Agent description (used in frontmatter) */
+    description: string;
+    /** Space-separated tool names (optional) */
+    tools?: string;
+    /** Terminal color for agent output (optional) */
+    color?: string;
+    /** Subfolder for output path (optional) - determines namespaced agent name */
+    folder?: string;
+    /** Model name (optional) - for AgentContext access */
+    model?: string;
+    /**
+     * Agent body content - either regular JSX or render props function
+     * Render props: (ctx: AgentContext) => ReactNode
+     */
+    children?: ReactNode | ((ctx: AgentContext) => ReactNode);
+}
+/**
+ * Configuration for defining an agent reference
+ */
+interface DefineAgentConfig<TInput = unknown> {
+    /** Agent name (must match the Agent's name prop) */
+    name: string;
+    /** Optional path to the agent markdown file for loadFromFile pattern */
+    path?: string;
+    /** Input type - only for compile-time inference, not used at runtime */
+    _inputType?: TInput;
+}
+/**
+ * Type-safe reference to an agent definition
+ */
+interface AgentRef<TInput = unknown> {
+    /** Agent name for Task() subagent_type */
+    name: string;
+    /** Optional path for loadFromFile pattern */
+    path?: string;
+    /** Marker for type guard */
+    readonly __isAgentRef: true;
+    /** Phantom type for input validation */
+    readonly __inputType?: TInput;
+}
+/**
+ * Define a type-safe reference to an agent
+ */
+declare function defineAgent<TInput = unknown>(config: DefineAgentConfig<TInput>): AgentRef<TInput>;
+/**
+ * Type guard for AgentRef
+ */
+declare function isAgentRef(value: unknown): value is AgentRef;
+/**
+ * Get agent name from string or AgentRef
+ */
+declare function getAgentName(agent: string | AgentRef): string;
+/**
+ * Get agent path from AgentRef (undefined for string)
+ */
+declare function getAgentPath(agent: string | AgentRef): string | undefined;
+/**
+ * Props for the SpawnAgent component
+ * @typeParam TInput - Type interface to validate against Agent's contract (compile-time only)
+ */
+interface SpawnAgentProps<TInput = unknown> {
+    /**
+     * Agent to spawn - either:
+     * - String: Agent name directly (e.g., 'gsd-researcher')
+     * - AgentRef: Type-safe reference from defineAgent()
+     */
+    agent: string | AgentRef<TInput>;
+    /** Model to use - supports {variable} placeholders */
+    model: string;
+    /** Human-readable description of the task */
+    description: string;
+    /**
+     * Enable "load from file" pattern for spawning.
+     */
+    loadFromFile?: boolean | string;
+    /** Prompt content - supports multi-line and {variable} placeholders */
+    prompt?: string;
+    /** Variable name containing the prompt (for runtime concatenation) */
+    promptVariable?: string;
+    /** Typed input - either a variable ref or an object literal */
+    input?: Partial<TInput>;
+    /** Optional extra instructions appended to the auto-generated prompt */
+    children?: ReactNode;
+}
+/**
+ * V3-compatible SpawnAgent props with RuntimeVar support
+ */
+interface V3SpawnAgentProps<TInput = unknown> {
+    /** Agent to spawn - accepts RuntimeVar for runtime resolution */
+    agent: OrRuntimeVar<string> | AgentRef<TInput>;
+    /** Model to use - supports static string or RuntimeVar */
+    model: OrRuntimeVar<string>;
+    /** Human-readable description - accepts static or RuntimeVar */
+    description: OrRuntimeVar<string>;
+    /** Enable "load from file" pattern - accepts RuntimeVar */
+    loadFromFile?: OrRuntimeVar<string | boolean>;
+    /** Prompt content - supports RuntimeVar interpolation */
+    prompt?: OrRuntimeVar<string>;
+    /** Typed input - accepts RuntimeVar values */
+    input?: RuntimeVarProxy<TInput> | Partial<AllowRuntimeVars<TInput>>;
+    /** RuntimeVar to store the agent's output */
+    output?: RuntimeVarProxy<string>;
+    /** Optional extra instructions */
+    children?: ReactNode;
+}
+/**
+ * Output reference for OnStatus matching
+ */
+interface OutputRef {
+    agent: string;
+}
+/**
+ * Create an output reference for OnStatus
+ */
+declare function useOutput<T = unknown>(agent: string): OutputRef & {
+    field: (name: keyof T) => string;
+};
+/**
+ * Props for the OnStatus component
+ */
+interface OnStatusProps {
+    /** Output reference from useOutput */
+    output: OutputRef;
+    /** Status value to match (SUCCESS, BLOCKED, etc.) */
+    status: AgentStatus;
+    /** Block content for this status */
+    children?: ReactNode;
+}
+/**
+ * Agent component - creates a Claude Code agent with frontmatter
+ *
+ * @typeParam TInput - Type interface for agent input contract
+ * @typeParam TOutput - Type interface for agent output contract
+ */
+declare function Agent<TInput = unknown, TOutput = unknown>(_props: AgentProps<TInput, TOutput>): null;
+/**
+ * SpawnAgent component - emits Task() syntax inside a Command
+ *
+ * @typeParam TInput - Type interface to validate against Agent's contract
+ */
+declare function SpawnAgent<TInput = unknown>(_props: SpawnAgentProps<TInput> | V3SpawnAgentProps<TInput>): null;
+/**
+ * OnStatus component - conditional block for agent status handling
+ */
+declare function OnStatus(_props: OnStatusProps): null;
+
+/**
+ * Runtime Function System for Hybrid Runtime
+ *
+ * RuntimeFn wraps TypeScript functions for extraction to runtime.js.
+ * Each wrapped function gets a `.Call` component for JSX invocation.
+ *
+ * Usage:
+ * // Define function
+ * async function init(args: InitArgs): Promise<InitResult> { ... }
+ *
+ * // Wrap for compile-time
+ * const Init = runtimeFn(init);
+ *
+ * // Use in JSX
+ * <Init.Call args={{ x: "1" }} output={ctx} />
+ *
+ * // Emits: CTX=$(node runtime.js init '{"x":"1"}')
+ */
+
+/**
+ * Async function that can be wrapped as a RuntimeFn
+ * Must be a named async function for extraction
+ */
+type RuntimeFunction<TArgs extends object, TReturn> = (args: TArgs) => Promise<TReturn>;
+/**
+ * Props for the .Call component
+ *
+ * @param args - Arguments to pass to the function (each can be static or RuntimeVar)
+ * @param output - RuntimeVar to store the result (must match TReturn type)
+ */
+interface RuntimeCallProps<TArgs extends object, TReturn> {
+    /** Arguments passed to the runtime function. Each property can be static or RuntimeVar. */
+    args: AllowRuntimeVars<TArgs>;
+    /** RuntimeVar to store the function result */
+    output: RuntimeVarProxy<TReturn>;
+}
+/**
+ * The .Call component type
+ * This is what users invoke in JSX
+ */
+type RuntimeCallComponent<TArgs extends object, TReturn> = (props: RuntimeCallProps<TArgs, TReturn>) => null;
+/**
+ * Wrapper returned by runtimeFn()
+ * Contains the .Call component and metadata for extraction
+ */
+interface RuntimeFnComponent<TArgs extends object, TReturn> {
+    /** JSX component for invoking the function */
+    Call: RuntimeCallComponent<TArgs, TReturn>;
+    /** Original function name for extraction */
+    readonly fnName: string;
+    /** Original function reference for extraction */
+    readonly fn: RuntimeFunction<TArgs, TReturn>;
+    /** Marker for type guard */
+    readonly __isRuntimeFn: true;
+}
+/**
+ * Wrap a TypeScript function for runtime extraction
+ *
+ * The wrapped function:
+ * 1. Gets extracted to runtime.js during build
+ * 2. Provides a .Call component for JSX invocation
+ * 3. Maintains full type safety between args/output
+ *
+ * @param fn - Async function to wrap
+ * @returns RuntimeFnComponent with .Call and metadata
+ *
+ * @example
+ * // Define the function
+ * interface InitArgs { projectPath: string }
+ * interface InitResult { success: boolean; error?: string }
+ *
+ * async function initProject(args: InitArgs): Promise<InitResult> {
+ *   const exists = await checkPath(args.projectPath);
+ *   return exists
+ *     ? { success: true }
+ *     : { success: false, error: 'Path not found' };
+ * }
+ *
+ * // Wrap for JSX use
+ * const Init = runtimeFn(initProject);
+ *
+ * // Use in Command
+ * export default (
+ *   <Command name="setup">
+ *     {() => {
+ *       const result = useRuntimeVar<InitResult>('RESULT');
+ *       return (
+ *         <>
+ *           <Init.Call args={{ projectPath: "." }} output={result} />
+ *           <If condition={result.error}>
+ *             <p>Error: {result.error}</p>
+ *           </If>
+ *         </>
+ *       );
+ *     }}
+ *   </Command>
+ * );
+ */
+declare function runtimeFn<TArgs extends object, TReturn>(fn: RuntimeFunction<TArgs, TReturn>): RuntimeFnComponent<TArgs, TReturn>;
+/**
+ * Check if a value is a RuntimeFn wrapper
+ *
+ * @param value - Value to check
+ * @returns true if value is a RuntimeFnComponent
+ */
+declare function isRuntimeFn(value: unknown): value is RuntimeFnComponent<object, unknown>;
+/**
+ * Get all registered runtime functions
+ *
+ * Used by the runtime emitter to extract functions to runtime.js
+ *
+ * @returns Map of function name -> function
+ */
+declare function getRuntimeFnRegistry(): Map<string, RuntimeFunction<object, unknown>>;
+/**
+ * Clear the runtime function registry
+ *
+ * Used between builds to ensure clean state
+ */
+declare function clearRuntimeFnRegistry(): void;
+/**
+ * Get a specific runtime function by name
+ *
+ * @param name - Function name
+ * @returns Function if found, undefined otherwise
+ */
+declare function getRuntimeFn(name: string): RuntimeFunction<object, unknown> | undefined;
+
+/**
+ * Control Flow Components
+ *
+ * These components provide typed control flow for commands:
+ * - If: Conditional based on RuntimeVar (not shell test strings)
+ * - Else: Paired with If for else blocks
+ * - Loop: Bounded iteration with max count
+ * - Break: Exit current loop
+ * - Return: Exit command early
+ *
+ * Key difference from v1: conditions are RuntimeVar<boolean> expressions,
+ * not shell test strings. This enables proper TypeScript type checking.
+ */
+
+/**
+ * Condition can be:
+ * - RuntimeVar<boolean> (direct reference)
+ * - RuntimeVar<T> (truthy check - undefined/null/empty string = false)
+ * - Boolean expression combining RuntimeVars
+ * - undefined (from optional property access - treated as falsy)
+ *
+ * The transformer parses these to Condition IR nodes.
+ */
+type Condition$1<T = unknown> = RuntimeVar<T> | RuntimeVarProxy<T> | boolean | undefined;
+/**
+ * Props for If component
+ *
+ * Takes a `condition: RuntimeVar` for type-safe conditions.
+ */
+interface IfProps {
+    /**
+     * Condition to evaluate
+     *
+     * Can be:
+     * - RuntimeVar<boolean> for direct boolean check
+     * - RuntimeVar<T> for truthy check (falsy = false, truthy = true)
+     *
+     * @example
+     * <If condition={ctx.error}>...</If>
+     * // Emits: **If $(echo "$CTX" | jq -r '.error'):**
+     *
+     * @example
+     * <If condition={ctx.flags.verbose}>...</If>
+     * // Emits: **If $(echo "$CTX" | jq -r '.flags.verbose') = "true":**
+     */
+    condition: Condition$1;
+    /** Content to render when condition is true */
+    children?: React.ReactNode;
+}
+/**
+ * Conditional block
+ *
+ * Renders children only if condition is truthy.
+ * Works with RuntimeVar for type-safe runtime checks.
+ *
+ * @example
+ * const ctx = useRuntimeVar<{ error?: string }>('CTX');
+ *
+ * <If condition={ctx.error}>
+ *   <p>Error occurred: {ctx.error}</p>
+ * </If>
+ */
+declare function If(_props: IfProps): null;
+/**
+ * Props for Else component
+ */
+interface ElseProps {
+    /** Content to render when preceding If condition is false */
+    children?: React.ReactNode;
+}
+/**
+ * Else block - must follow If as sibling
+ *
+ * @example
+ * <If condition={ctx.success}>
+ *   <p>Operation succeeded</p>
+ * </If>
+ * <Else>
+ *   <p>Operation failed</p>
+ * </Else>
+ */
+declare function Else(_props: ElseProps): null;
+/**
+ * Props for Loop component
+ *
+ * Loop is bounded iteration, not array iteration.
+ * It executes up to `max` times, with optional counter variable.
+ */
+interface LoopProps {
+    /**
+     * Maximum number of iterations
+     *
+     * Required for loops to prevent infinite loops.
+     * Claude will stop after this many iterations.
+     * Accepts static number or RuntimeVar<number> for runtime resolution.
+     */
+    max: OrRuntimeVar<number>;
+    /**
+     * Optional counter variable
+     *
+     * If provided, stores the current iteration number (0-indexed).
+     * Useful for conditional logic based on iteration count.
+     *
+     * @example
+     * const i = useRuntimeVar<number>('I');
+     * <Loop max={5} counter={i}>
+     *   <p>Iteration: {i}</p>
+     * </Loop>
+     */
+    counter?: RuntimeVarProxy<number>;
+    /** Loop body content */
+    children?: React.ReactNode;
+}
+/**
+ * Bounded loop
+ *
+ * Executes children up to `max` times.
+ * Use Break to exit early, Return to exit the entire command.
+ *
+ * @example
+ * <Loop max={10}>
+ *   <RuntimeFn.Call args={{}} output={result} />
+ *   <If condition={result.done}>
+ *     <Break />
+ *   </If>
+ * </Loop>
+ */
+declare function Loop(_props: LoopProps): null;
+/**
+ * Props for Break component
+ */
+interface BreakProps {
+    /** Optional message to display when breaking. Accepts static string or RuntimeVar. */
+    message?: OrRuntimeVar<string>;
+}
+/**
+ * Exit the current loop early
+ *
+ * Only valid inside a Loop component.
+ * Execution continues after the Loop.
+ *
+ * @example
+ * <Loop max={10}>
+ *   <RuntimeFn.Call args={{}} output={result} />
+ *   <If condition={result.error}>
+ *     <Break message="Error encountered, stopping retry loop" />
+ *   </If>
+ * </Loop>
+ */
+declare function Break(_props: BreakProps): null;
+/**
+ * Standard return status values
+ */
+type ReturnStatus = 'SUCCESS' | 'BLOCKED' | 'NOT_FOUND' | 'ERROR' | 'CHECKPOINT';
+/**
+ * Props for Return component
+ */
+interface ReturnProps {
+    /**
+     * Optional status to return
+     *
+     * Used when the command needs to indicate success/failure
+     * to a parent orchestrator. Accepts static status or RuntimeVar.
+     */
+    status?: OrRuntimeVar<ReturnStatus>;
+    /** Optional message to display when returning. Accepts static string or RuntimeVar. */
+    message?: OrRuntimeVar<string>;
+}
+/**
+ * Exit the command early
+ *
+ * Stops execution of the entire command.
+ * Use for early exit conditions or error handling.
+ *
+ * @example
+ * <If condition={ctx.alreadyExists}>
+ *   <Return status="SUCCESS" message="Already initialized, nothing to do" />
+ * </If>
+ *
+ * @example
+ * <If condition={ctx.criticalError}>
+ *   <Return status="ERROR" message="Cannot continue due to error" />
+ * </If>
+ */
+declare function Return(_props: ReturnProps): null;
+/**
+ * Marker symbols for control components
+ */
+declare const IF_MARKER: unique symbol;
+declare const ELSE_MARKER: unique symbol;
+declare const LOOP_MARKER: unique symbol;
+declare const BREAK_MARKER: unique symbol;
+declare const RETURN_MARKER: unique symbol;
+
+/**
+ * AskUser Component for Hybrid Runtime
+ *
+ * Prompts the user with a question and stores the response
+ * in a RuntimeVar for subsequent logic.
+ *
+ * Emits as Claude Code's AskUserQuestion tool syntax.
+ */
+
+/**
+ * Option in the AskUser question
+ */
+interface AskUserOption {
+    /** Internal value stored in output variable */
+    value: string;
+    /** Display label shown to user */
+    label: string;
+    /** Optional description for the option */
+    description?: string;
+}
+/**
+ * Props for AskUser component
+ */
+interface AskUserProps {
+    /**
+     * Question to ask the user
+     *
+     * Should be clear and specific, ending with a question mark.
+     * Accepts static string or RuntimeVar for runtime interpolation.
+     *
+     * @example "Which database should we use?"
+     */
+    question: OrRuntimeVar<string>;
+    /**
+     * Available options for the user to choose from
+     *
+     * Must have 2-4 options. User can always select "Other" to provide custom input.
+     * Accepts static array or RuntimeVar<AskUserOption[]> for runtime resolution.
+     *
+     * @example
+     * options={[
+     *   { value: 'postgres', label: 'PostgreSQL', description: 'Recommended for production' },
+     *   { value: 'sqlite', label: 'SQLite', description: 'Good for development' },
+     * ]}
+     */
+    options: AskUserOption[] | RuntimeVar<AskUserOption[]> | RuntimeVarProxy<AskUserOption[]>;
+    /**
+     * RuntimeVar to store the user's response
+     *
+     * Will contain the `value` from the selected option,
+     * or custom text if user selected "Other".
+     */
+    output: RuntimeVarProxy<string>;
+    /**
+     * Optional header/chip label (max 12 chars)
+     *
+     * Short label displayed as a chip/tag above the question.
+     * Accepts static string or RuntimeVar.
+     *
+     * @example "Database"
+     */
+    header?: OrRuntimeVar<string>;
+    /**
+     * Allow multiple selections
+     *
+     * When true, user can select multiple options.
+     * Output will contain comma-separated values.
+     * Accepts static boolean or RuntimeVar.
+     *
+     * @default false
+     */
+    multiSelect?: OrRuntimeVar<boolean>;
+}
+/**
+ * Ask the user a question and store their response
+ *
+ * Emits as Claude Code's AskUserQuestion tool invocation.
+ * The response is stored in the output RuntimeVar for use
+ * in subsequent If conditions or interpolation.
+ *
+ * @example
+ * const dbChoice = useRuntimeVar<string>('DB_CHOICE');
+ *
+ * <AskUser
+ *   question="Which database should we use?"
+ *   header="Database"
+ *   options={[
+ *     { value: 'postgres', label: 'PostgreSQL (Recommended)', description: 'Best for production' },
+ *     { value: 'sqlite', label: 'SQLite', description: 'Good for development' },
+ *   ]}
+ *   output={dbChoice}
+ * />
+ *
+ * <If condition={dbChoice === 'postgres'}>
+ *   <p>Setting up PostgreSQL...</p>
+ * </If>
+ */
+declare function AskUser(_props: AskUserProps): null;
+/**
+ * Marker symbol for AskUser component
+ */
+declare const ASK_USER_MARKER: unique symbol;
+
+/**
+ * IR Node Types - Discriminated unions for intermediate representation
+ *
+ * All nodes have a `kind` property that serves as the discriminator,
+ * enabling exhaustive type checking in switch statements.
+ */
+/**
+ * Plain text content
+ */
+interface TextNode {
+    kind: 'text';
+    value: string;
+}
+/**
+ * Bold/strong text - uses asterisks (**text**)
+ */
+interface BoldNode {
+    kind: 'bold';
+    children: InlineNode[];
+}
+/**
+ * Italic/emphasis text - uses asterisks (*text*)
+ */
+interface ItalicNode {
+    kind: 'italic';
+    children: InlineNode[];
+}
+/**
+ * Inline code - uses backticks (`code`)
+ */
+interface InlineCodeNode {
+    kind: 'inlineCode';
+    value: string;
+}
+/**
+ * Hyperlink with optional text
+ */
+interface LinkNode {
+    kind: 'link';
+    url: string;
+    children: InlineNode[];
+}
+/**
+ * Line break within a block element
+ */
+interface LineBreakNode {
+    kind: 'lineBreak';
+}
+/**
+ * Union of all inline node types
+ */
+type InlineNode = TextNode | BoldNode | ItalicNode | InlineCodeNode | LinkNode | LineBreakNode;
+/**
+ * Heading levels 1-6
+ */
+interface HeadingNode {
+    kind: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: InlineNode[];
+}
+/**
+ * Paragraph containing inline content
+ */
+interface ParagraphNode {
+    kind: 'paragraph';
+    children: InlineNode[];
+}
+/**
+ * List item containing block content
+ */
+interface ListItemNode {
+    kind: 'listItem';
+    children: BaseBlockNode[];
+}
+/**
+ * Ordered or unordered list
+ */
+interface ListNode {
+    kind: 'list';
+    ordered: boolean;
+    items: ListItemNode[];
+    start?: number;
+}
+/**
+ * Fenced code block with optional language
+ */
+interface CodeBlockNode {
+    kind: 'codeBlock';
+    language?: string;
+    content: string;
+}
+/**
+ * Blockquote containing block content
+ */
+interface BlockquoteNode {
+    kind: 'blockquote';
+    children: BaseBlockNode[];
+}
+/**
+ * Horizontal rule / thematic break
+ */
+interface ThematicBreakNode {
+    kind: 'thematicBreak';
+}
+/**
+ * Markdown table with optional headers and column alignment
+ */
+interface TableNode {
+    kind: 'table';
+    headers?: string[];
+    rows: string[][];
+    align?: ('left' | 'center' | 'right')[];
+    emptyCell?: string;
+}
+/**
+ * ExecutionContext - emits <execution_context> XML with file paths
+ */
+interface ExecutionContextNode {
+    kind: 'executionContext';
+    paths: string[];
+    prefix: string;
+    children: BaseBlockNode[];
+}
+/**
+ * SuccessCriteria item data
+ */
+interface SuccessCriteriaItemData {
+    text: string;
+    checked: boolean;
+}
+/**
+ * SuccessCriteria - emits <success_criteria> XML with checkbox list
+ */
+interface SuccessCriteriaNode {
+    kind: 'successCriteria';
+    items: SuccessCriteriaItemData[];
+}
+/**
+ * OfferNext route data
+ */
+interface OfferNextRouteData {
+    name: string;
+    description?: string;
+    path: string;
+}
+/**
+ * OfferNext - emits <offer_next> XML with route bullet list
+ */
+interface OfferNextNode {
+    kind: 'offerNext';
+    routes: OfferNextRouteData[];
+}
+/**
+ * XML-style block element (e.g., <example>content</example>)
+ * Used for Claude Code's special sections
+ */
+interface XmlBlockNode {
+    kind: 'xmlBlock';
+    name: string;
+    attributes?: Record<string, string>;
+    children: BaseBlockNode[];
+}
+/**
+ * Invisible grouping container for tight block spacing
+ * Used for <div> without name attribute - no wrapper output, single newlines between children
+ */
+interface GroupNode {
+    kind: 'group';
+    children: BaseBlockNode[];
+}
+/**
+ * Raw markdown content passed through without transformation
+ */
+interface RawMarkdownNode {
+    kind: 'raw';
+    content: string;
+}
+/**
+ * Indented block - prepends spaces to each line of content
+ */
+interface IndentNode {
+    kind: 'indent';
+    spaces: number;
+    children: BaseBlockNode[];
+}
+/**
+ * Shell variable assignment from useVariable/Assign
+ * Emits as bash code block with variable assignment
+ */
+interface AssignNode {
+    kind: 'assign';
+    variableName: string;
+    assignment: {
+        type: 'bash' | 'value' | 'env';
+        content: string;
+    };
+    comment?: string;
+    blankBefore?: boolean;
+}
+/**
+ * Group of shell variable assignments
+ * Emits as single bash code block with all assignments
+ */
+interface AssignGroupNode {
+    kind: 'assignGroup';
+    assignments: AssignNode[];
+}
+/**
+ * Reference to an agent's output in the IR
+ * Captures the agent name for output binding
+ */
+interface OutputReference {
+    kind: 'outputReference';
+    /** Agent name this output refers to */
+    agent: string;
+}
+/**
+ * OnStatus block - conditional based on agent return status
+ * Emits as **On {status}:** prose pattern
+ */
+interface OnStatusNode {
+    kind: 'onStatus';
+    /** Output reference from useOutput */
+    outputRef: OutputReference;
+    /** Status to match (SUCCESS, BLOCKED, etc.) */
+    status: 'SUCCESS' | 'BLOCKED' | 'NOT_FOUND' | 'ERROR' | 'CHECKPOINT';
+    /** Block content for this status */
+    children: BaseBlockNode[];
+}
+/**
+ * Read state value from registry
+ * Emits as bash JSON read operation
+ */
+interface ReadStateNode {
+    kind: 'readState';
+    /** State key identifier (e.g., 'projectContext') */
+    stateKey: string;
+    /** Variable to store result (from useVariable) */
+    variableName: string;
+    /** Optional: nested field path (e.g., 'user.preferences.theme') */
+    field?: string;
+}
+/**
+ * Write state value to registry
+ * Emits as bash JSON write operation
+ */
+interface WriteStateNode {
+    kind: 'writeState';
+    /** State key identifier (e.g., 'projectContext') */
+    stateKey: string;
+    /** Write mode: 'field' for single field, 'merge' for partial update */
+    mode: 'field' | 'merge';
+    /** For field mode: nested field path (e.g., 'user.name') */
+    field?: string;
+    /** Value to write - either variable reference or literal */
+    value: {
+        type: 'variable' | 'literal';
+        content: string;
+    };
+}
+/**
+ * PromptTemplate node - wraps children in markdown code fence
+ * Used to avoid nested escaping in prompt content
+ */
+interface PromptTemplateNode {
+    kind: 'promptTemplate';
+    children: BaseBlockNode[];
+}
+/**
+ * File entry for ReadFilesNode
+ */
+interface ReadFileEntry {
+    /** Variable name for content (e.g., "STATE_CONTENT") */
+    varName: string;
+    /** File path (may contain variable references) */
+    path: string;
+    /** Whether file is required (affects error suppression) */
+    required: boolean;
+}
+/**
+ * ReadFiles node - emit bash commands to read multiple files
+ * Emits as single bash code block with cat commands
+ */
+interface ReadFilesNode {
+    kind: 'readFiles';
+    files: ReadFileEntry[];
+}
+/**
+ * Step output variant
+ */
+type StepVariant = 'heading' | 'bold' | 'xml';
+/**
+ * Numbered workflow step
+ * Emits formatted step section based on variant
+ */
+interface StepNode {
+    kind: 'step';
+    /** Step number (string to support "1.1" sub-steps) */
+    number: string;
+    /** Step name/title */
+    name: string;
+    /** Output format variant (default: 'heading') */
+    variant: StepVariant;
+    /** Step body content */
+    children: BaseBlockNode[];
+}
+/**
+ * Base union of all block node types (without runtime nodes)
+ * Use BlockNode from runtime-nodes.ts for the full union including runtime nodes
+ */
+type BaseBlockNode = HeadingNode | ParagraphNode | ListNode | CodeBlockNode | BlockquoteNode | ThematicBreakNode | TableNode | ExecutionContextNode | SuccessCriteriaNode | OfferNextNode | XmlBlockNode | GroupNode | RawMarkdownNode | IndentNode | AssignNode | AssignGroupNode | OnStatusNode | ReadStateNode | WriteStateNode | ReadFilesNode | PromptTemplateNode | MCPServerNode | StepNode;
+/**
+ * Internal alias for backward compatibility within this file
+ * @internal
+ */
+type BlockNode$1 = BaseBlockNode;
+/**
+ * Agent YAML frontmatter data
+ * Uses GSD format: tools as space-separated string, not array like Command
+ */
+interface AgentFrontmatterNode {
+    kind: 'agentFrontmatter';
+    name: string;
+    description: string;
+    tools?: string;
+    color?: string;
+    inputType?: TypeReference;
+    outputType?: TypeReference;
+}
+/**
+ * Agent document root node
+ * Similar to DocumentNode but with required AgentFrontmatterNode
+ */
+interface AgentDocumentNode {
+    kind: 'agentDocument';
+    frontmatter: AgentFrontmatterNode;
+    children: BaseBlockNode[];
+}
+/**
+ * MCP Server configuration node
+ * Represents a single MCP server definition
+ */
+interface MCPServerNode {
+    kind: 'mcpServer';
+    name: string;
+    type: 'stdio' | 'http' | 'sse';
+    command?: string;
+    args?: string[];
+    url?: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+}
+/**
+ * MCP configuration document root node
+ * Contains one or more MCP server definitions
+ */
+interface MCPConfigDocumentNode {
+    kind: 'mcpConfigDocument';
+    servers: MCPServerNode[];
+}
+/**
+ * Flattened state schema field
+ * Represents a single column in the generated SQLite table
+ */
+interface StateSchemaField {
+    /** Column name (flattened path, e.g., "config_debug") */
+    name: string;
+    /** TypeScript type (string, number, boolean, Date) */
+    tsType: string;
+    /** SQL type (TEXT, INTEGER) */
+    sqlType: 'TEXT' | 'INTEGER';
+    /** Default value for init SQL */
+    defaultValue: string;
+    /** Optional: enum values for CHECK constraint */
+    enumValues?: string[];
+}
+/**
+ * Parsed state schema from TypeScript interface
+ * Fields are flattened (nested objects become underscore-separated)
+ */
+interface StateSchema {
+    /** Interface name (e.g., "ReleasesState") */
+    interfaceName: string;
+    /** Flattened fields for SQL columns */
+    fields: StateSchemaField[];
+}
+/**
+ * Custom operation node
+ * Represents an Operation child of State component
+ */
+interface OperationNode {
+    kind: 'operation';
+    /** Operation name (e.g., "record") - becomes skill suffix */
+    name: string;
+    /** SQL template body with $variable placeholders */
+    sqlTemplate: string;
+    /** Inferred argument names from $variable references */
+    args: string[];
+}
+/**
+ * State node representing parsed State component
+ */
+interface StateNode {
+    kind: 'state';
+    /** State name (e.g., "releases") - becomes skill prefix */
+    name: string;
+    /** Provider type (only "sqlite" for now) */
+    provider: 'sqlite';
+    /** Provider-specific configuration */
+    config: {
+        /** Database file path */
+        database: string;
+    };
+    /** Parsed schema from generic type parameter */
+    schema: StateSchema;
+    /** Custom operations defined as children */
+    operations: OperationNode[];
+}
+/**
+ * State document root node
+ * Produces multiple skill files in .claude/skills/
+ */
+interface StateDocumentNode {
+    kind: 'stateDocument';
+    /** The State definition */
+    state: StateNode;
+}
+/**
+ * Skill YAML frontmatter data
+ * Uses Claude Code skills format with kebab-case field names
+ */
+interface SkillFrontmatterNode {
+    kind: 'skillFrontmatter';
+    name: string;
+    description: string;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    allowedTools?: string[];
+    argumentHint?: string;
+    model?: string;
+    context?: 'fork';
+    agent?: string;
+}
+/**
+ * SkillFile node for generated files within skill
+ * Each SkillFile produces an output file in the skill directory
+ */
+interface SkillFileNode {
+    kind: 'skillFile';
+    name: string;
+    children: BaseBlockNode[];
+}
+/**
+ * SkillStatic node for static file copying
+ * Copies files from source location to skill directory
+ */
+interface SkillStaticNode {
+    kind: 'skillStatic';
+    src: string;
+    dest?: string;
+}
+/**
+ * Skill document root node
+ * Produces a skill directory with SKILL.md plus optional supporting files
+ */
+interface SkillDocumentNode {
+    kind: 'skillDocument';
+    frontmatter: SkillFrontmatterNode;
+    children: BaseBlockNode[];
+    files: SkillFileNode[];
+    statics: SkillStaticNode[];
+}
+/**
+ * Reference to a TypeScript type across files
+ * Used for tracking Agent interface imports in SpawnAgent
+ * Actual validation happens in Phase 11
+ */
+interface TypeReference {
+    kind: 'typeReference';
+    name: string;
+    sourceFile?: string;
+    resolved?: boolean;
+}
+/**
+ * Union of all IR node types
+ */
+type IRNode = BlockNode$1 | InlineNode | AgentFrontmatterNode | SkillFrontmatterNode | SkillFileNode | SkillStaticNode | ListItemNode | AgentDocumentNode | SkillDocumentNode | MCPConfigDocumentNode | StateDocumentNode | TypeReference;
+/**
+ * Helper for exhaustiveness checking in switch statements.
+ * If TypeScript complains that the argument is not of type 'never',
+ * it means there's an unhandled case in the switch.
+ */
+declare function assertNever(x: never): never;
+
+/**
+ * Runtime IR Node Types
+ *
+ * Node types for runtime-enabled commands:
+ * - Runtime variable declarations and references
+ * - Runtime function calls
+ * - Typed control flow (condition-based)
+ * - User prompts
+ *
+ * All nodes follow the discriminated union pattern with `kind` property.
+ */
+
+/**
+ * Runtime variable declaration
+ *
+ * Created from useRuntimeVar<T>('NAME') calls.
+ * Tracks the variable name and TypeScript type for validation.
+ */
+interface RuntimeVarDeclNode {
+    kind: 'runtimeVarDecl';
+    /** Shell variable name (e.g., 'CTX') */
+    varName: string;
+    /** TypeScript type name for documentation (e.g., 'InitResult') */
+    tsType?: string;
+}
+/**
+ * Runtime variable reference
+ *
+ * Created from property access on RuntimeVar proxies.
+ * Tracks the full path for jq expression generation.
+ */
+interface RuntimeVarRefNode {
+    kind: 'runtimeVarRef';
+    /** Shell variable name (e.g., 'CTX') */
+    varName: string;
+    /** Property access path (e.g., ['user', 'name']) */
+    path: string[];
+}
+/**
+ * Runtime function call
+ *
+ * Created from <RuntimeFn.Call args={...} output={...} /> elements.
+ * Emits as: VAR=$(node runtime.js fnName '{"args"}')
+ */
+interface RuntimeCallNode {
+    kind: 'runtimeCall';
+    /** Function name in the runtime registry */
+    fnName: string;
+    /** JSON-serializable arguments */
+    args: Record<string, unknown>;
+    /** Output variable name to store result */
+    outputVar: string;
+}
+/**
+ * Condition expression tree
+ *
+ * Represents parsed condition expressions for If.
+ * Supports references, literals, and logical operators.
+ */
+type Condition = ConditionRef | ConditionLiteral | ConditionNot | ConditionAnd | ConditionOr | ConditionEq | ConditionNeq | ConditionGt | ConditionGte | ConditionLt | ConditionLte;
+/**
+ * Reference to a runtime variable (truthy check)
+ */
+interface ConditionRef {
+    type: 'ref';
+    ref: RuntimeVarRefNode;
+}
+/**
+ * Literal boolean value
+ */
+interface ConditionLiteral {
+    type: 'literal';
+    value: boolean;
+}
+/**
+ * Logical NOT
+ */
+interface ConditionNot {
+    type: 'not';
+    operand: Condition;
+}
+/**
+ * Logical AND
+ */
+interface ConditionAnd {
+    type: 'and';
+    left: Condition;
+    right: Condition;
+}
+/**
+ * Logical OR
+ */
+interface ConditionOr {
+    type: 'or';
+    left: Condition;
+    right: Condition;
+}
+/**
+ * Equality check
+ */
+interface ConditionEq {
+    type: 'eq';
+    left: Condition;
+    right: string | number | boolean;
+}
+/**
+ * Inequality check
+ */
+interface ConditionNeq {
+    type: 'neq';
+    left: Condition;
+    right: string | number | boolean;
+}
+/**
+ * Greater than check
+ */
+interface ConditionGt {
+    type: 'gt';
+    left: Condition;
+    right: number;
+}
+/**
+ * Greater than or equal check
+ */
+interface ConditionGte {
+    type: 'gte';
+    left: Condition;
+    right: number;
+}
+/**
+ * Less than check
+ */
+interface ConditionLt {
+    type: 'lt';
+    left: Condition;
+    right: number;
+}
+/**
+ * Less than or equal check
+ */
+interface ConditionLte {
+    type: 'lte';
+    left: Condition;
+    right: number;
+}
+/**
+ * If node - condition-based conditional
+ *
+ * Uses a Condition tree for typed conditional logic.
+ */
+interface IfNode {
+    kind: 'if';
+    /** Parsed condition expression tree */
+    condition: Condition;
+    /** "then" block content */
+    children: BlockNode[];
+}
+/**
+ * Else node - paired with If
+ */
+interface ElseNode {
+    kind: 'else';
+    /** "else" block content */
+    children: BlockNode[];
+}
+/**
+ * Loop node - bounded iteration
+ *
+ * Executes up to `max` times.
+ */
+interface LoopNode {
+    kind: 'loop';
+    /** Maximum iteration count */
+    max: number;
+    /** Optional counter variable name */
+    counterVar?: string;
+    /** Loop body content */
+    children: BlockNode[];
+}
+/**
+ * Break node - exit current loop
+ */
+interface BreakNode {
+    kind: 'break';
+    /** Optional message to display */
+    message?: string;
+}
+/**
+ * Return node - exit command early
+ */
+interface ReturnNode {
+    kind: 'return';
+    /** Optional status code */
+    status?: 'SUCCESS' | 'BLOCKED' | 'NOT_FOUND' | 'ERROR' | 'CHECKPOINT';
+    /** Optional message to display */
+    message?: string;
+}
+/**
+ * Option for AskUser
+ */
+interface AskUserOptionNode {
+    value: string;
+    label: string;
+    description?: string;
+}
+/**
+ * AskUser node - prompt user for input
+ *
+ * Emits as AskUserQuestion tool syntax.
+ */
+interface AskUserNode {
+    kind: 'askUser';
+    /** Question text */
+    question: string;
+    /** Available options */
+    options: AskUserOptionNode[];
+    /** Output variable name */
+    outputVar: string;
+    /** Optional header/chip label */
+    header?: string;
+    /** Allow multiple selections */
+    multiSelect: boolean;
+}
+/**
+ * SpawnAgent with output capture
+ */
+interface SpawnAgentNode {
+    kind: 'spawnAgent';
+    /** Agent name/reference */
+    agent: string;
+    /** Model to use */
+    model: string;
+    /** Human-readable description */
+    description: string;
+    /** Prompt content or variable */
+    prompt?: string;
+    /** Input object (alternative to prompt) */
+    input?: SpawnAgentInput;
+    /** Output variable name to store agent result */
+    outputVar?: string;
+    /** Load agent from file path */
+    loadFromFile?: string;
+}
+/**
+ * SpawnAgent input types
+ */
+type SpawnAgentInput = {
+    type: 'object';
+    properties: InputProperty[];
+} | {
+    type: 'variable';
+    varName: string;
+};
+/**
+ * Property in SpawnAgent input object
+ */
+interface InputProperty {
+    name: string;
+    value: InputValue;
+}
+/**
+ * Value types for SpawnAgent input
+ */
+type InputValue = {
+    type: 'string';
+    value: string;
+} | {
+    type: 'runtimeVarRef';
+    ref: RuntimeVarRefNode;
+} | {
+    type: 'json';
+    value: unknown;
+};
+/**
+ * Runtime-specific block nodes
+ */
+type RuntimeBlockNode = RuntimeVarDeclNode | RuntimeCallNode | IfNode | ElseNode | LoopNode | BreakNode | ReturnNode | AskUserNode | SpawnAgentNode;
+/**
+ * Union of base and runtime block nodes
+ */
+type BlockNode = BaseBlockNode | RuntimeBlockNode;
+/**
+ * Command frontmatter
+ */
+interface FrontmatterNode {
+    kind: 'frontmatter';
+    data: Record<string, unknown>;
+}
+/**
+ * Build-time metadata (not emitted to output)
+ */
+interface DocumentMetadata {
+    /** Subfolder for output path (e.g., "gsd" → .claude/commands/gsd/cmd.md) */
+    folder?: string;
+}
+/**
+ * Document root node
+ *
+ * Represents a command that produces dual output:
+ * - COMMAND.md (markdown for Claude)
+ * - runtime.js (extracted TypeScript functions)
+ */
+interface DocumentNode {
+    kind: 'document';
+    frontmatter?: FrontmatterNode;
+    /** Build-time metadata (not emitted to output) */
+    metadata?: DocumentMetadata;
+    /** Runtime variable declarations */
+    runtimeVars: RuntimeVarDeclNode[];
+    /** Runtime function names used (for extraction) */
+    runtimeFunctions: string[];
+    /** Body content */
+    children: BlockNode[];
+}
+/**
+ * Type guard for runtime-specific nodes
+ */
+declare function isRuntimeNode(node: unknown): node is RuntimeBlockNode;
+/**
+ * Type guard for document
+ */
+declare function isDocument(node: unknown): node is DocumentNode;
+
+/**
+ * Markdown Emitter - Converts IR to Markdown output
+ *
+ * Uses switch-based emission with exhaustiveness checking.
+ * Handles nested structures (lists, inline formatting) through recursive calls.
+ */
+
+/**
+ * Convenience function for emitting a document
+ */
+declare function emit(doc: DocumentNode): string;
+/**
+ * Convenience function for emitting an agent document
+ */
+declare function emitAgent(doc: AgentDocumentNode, sourceFile?: SourceFile): string;
+/**
+ * Convenience function for emitting a skill document
+ */
+declare function emitSkill(doc: SkillDocumentNode): string;
+/**
+ * Convenience function for emitting a skill file
+ */
+declare function emitSkillFile(node: SkillFileNode): string;
+
+/**
+ * MCP server configuration format for settings.json
+ */
+interface MCPServerConfig {
+    type: 'stdio' | 'http' | 'sse';
+    command?: string;
+    args?: string[];
+    url?: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+}
+/**
+ * Convert MCPConfigDocumentNode to mcpServers object
+ *
+ * @param doc - MCP config document from transformer
+ * @returns mcpServers object keyed by server name
+ */
+declare function emitSettings(doc: MCPConfigDocumentNode): Record<string, MCPServerConfig>;
+/**
+ * Merge MCP servers into existing .mcp.json
+ *
+ * Read-modify-write pattern:
+ * 1. Read existing .mcp.json (or start fresh)
+ * 2. Update only mcpServers section
+ * 3. Write back with pretty formatting
+ *
+ * @param mcpPath - Path to .mcp.json (typically in project root)
+ * @param servers - New mcpServers to merge
+ */
+declare function mergeSettings(mcpPath: string, servers: Record<string, MCPServerConfig>): Promise<void>;
+
+/**
+ * V3 Markdown Emitter
+ *
+ * Converts V3 IR nodes to Markdown output with jq expressions.
+ * Extends v1 emitter patterns for shared block types.
+ *
+ * Key differences from v1:
+ * - RuntimeCallNode emits as bash code block with node invocation
+ * - IfNode emits with jq-based conditions
+ * - RuntimeVar interpolation uses jq expressions
+ */
+
+/**
+ * Emitter for V3 documents
+ */
+declare class RuntimeMarkdownEmitter {
+    /**
+     * Emit a complete V3 document
+     */
+    emit(doc: DocumentNode): string;
+    /**
+     * Emit a block node
+     */
+    private emitBlock;
+    /**
+     * Emit RuntimeCallNode as bash code block
+     *
+     * Output:
+     * ```bash
+     * CTX=$(node runtime.js fnName '{"args"}')
+     * ```
+     */
+    private emitRuntimeCall;
+    /**
+     * Emit IfNode as prose conditional with jq
+     *
+     * Output:
+     * **If ctx.error:**
+     *
+     * {children}
+     */
+    private emitIf;
+    /**
+     * Emit ElseNode
+     */
+    private emitElse;
+    /**
+     * Emit LoopNode as bounded loop
+     *
+     * Output:
+     * **Loop up to N times:**
+     *
+     * {children}
+     */
+    private emitLoop;
+    /**
+     * Emit BreakNode
+     */
+    private emitBreak;
+    /**
+     * Emit ReturnNode
+     */
+    private emitReturn;
+    /**
+     * Emit AskUserNode as AskUserQuestion syntax
+     */
+    private emitAskUser;
+    /**
+     * Emit SpawnAgentNode as Task() syntax
+     */
+    private emitSpawnAgent;
+    /**
+     * Format V3 input for prompt
+     */
+    private formatInput;
+    /**
+     * Format InputValue
+     */
+    private formatInputValue;
+    private emitInlineChildren;
+    private emitInline;
+    private emitList;
+    private emitBlockquote;
+    private emitTable;
+    private emitXmlBlock;
+    /**
+     * Format a value for YAML output
+     * Quotes strings that contain special YAML characters
+     */
+    private formatYamlValue;
+    private emitExecutionContext;
+    private emitIndent;
+}
+/**
+ * Emit a V3 document to markdown
+ */
+declare function emitDocument(doc: DocumentNode): string;
+
+/**
+ * Runtime Emitter
+ *
+ * Extracts runtime functions from source files and generates runtime.js.
+ * The runtime.js file is a CLI-invocable bundle that Claude calls via bash.
+ *
+ * Output format:
+ * ```javascript
+ * #!/usr/bin/env node
+ * // Extracted functions
+ * async function init(args) { ... }
+ * async function getContext(args) { ... }
+ *
+ * // Registry
+ * const registry = { init, getContext };
+ *
+ * // CLI entry
+ * const [,, fnName, argsJson] = process.argv;
+ * const result = await registry[fnName](JSON.parse(argsJson));
+ * console.log(JSON.stringify(result));
+ * ```
+ */
+
+/**
+ * Extracted function information
+ */
+interface ExtractedFunction {
+    /** Function name */
+    name: string;
+    /** Function source code (body only, without signature) */
+    body: string;
+    /** Parameter names */
+    params: string[];
+    /** Whether it's async */
+    isAsync: boolean;
+    /** Original source file path */
+    sourcePath: string;
+}
+/**
+ * Extracted constant information
+ */
+interface ExtractedConstant {
+    /** Constant name */
+    name: string;
+    /** Constant value as source code */
+    value: string;
+    /** Original source file path */
+    sourcePath: string;
+}
+/**
+ * Runtime emission result
+ */
+interface RuntimeEmitResult {
+    /** Generated runtime.js content */
+    content: string;
+    /** List of functions included (namespaced if applicable) */
+    functions: string[];
+    /** Function bodies for merging (keyed by namespaced name) */
+    functionBodies: Map<string, string>;
+    /** Constants for merging (keyed by name) */
+    constants: Map<string, string>;
+    /** Any warnings during extraction */
+    warnings: string[];
+}
+/**
+ * Extract ALL function declarations from a source file
+ *
+ * When extractAll is true, extracts all functions (for runtime files).
+ * Otherwise, only extracts functions in functionNames set.
+ *
+ * @param sourceFile - Source file to scan
+ * @param functionNames - Names of functions to extract (if extractAll is false)
+ * @param extractAll - If true, extract all functions regardless of names
+ * @returns Map of function name -> extracted info
+ */
+declare function extractFunctions(sourceFile: SourceFile, functionNames: Set<string>, extractAll?: boolean): Map<string, ExtractedFunction>;
+/**
+ * Generate runtime.js content from extracted functions and constants
+ *
+ * @param functions - Map of original function name -> extracted info
+ * @param constants - Map of constant name -> extracted info
+ * @param namespace - Optional namespace prefix for function names
+ */
+declare function generateRuntime(functions: Map<string, ExtractedFunction>, constants?: Map<string, ExtractedConstant>, namespace?: string): RuntimeEmitResult;
+/**
+ * Emit runtime.js from a V3 document's runtime function usage
+ *
+ * @param project - ts-morph project for file resolution
+ * @param mainSourcePath - Path to the main TSX source file
+ * @param functionNames - Names of functions that need to be extracted
+ * @param importPaths - Import paths where functions might be defined
+ * @param namespace - Optional namespace prefix for function names (e.g., 'planPhase')
+ * @returns Runtime emit result with content and metadata
+ */
+declare function emitRuntime(project: Project, mainSourcePath: string, functionNames: string[], importPaths: string[], namespace?: string): RuntimeEmitResult;
+/**
+ * Check if a source file contains V3 runtime usage
+ *
+ * Looks for:
+ * - useRuntimeVar imports/usage
+ * - runtimeFn imports/usage
+ *
+ * @param sourceFile - Source file to check
+ * @returns true if file uses V3 runtime features
+ */
+declare function isRuntimeFile(sourceFile: SourceFile): boolean;
+
+/**
+ * esbuild-based Runtime Bundler
+ *
+ * Uses esbuild to bundle .runtime.ts files with full npm package support.
+ * This replaces the manual type-stripping approach with proper bundling.
+ */
+
+/**
+ * Information about a runtime file for single-entry bundling
+ */
+interface RuntimeFileInfo {
+    /** Absolute path to the .runtime.ts source file */
+    sourcePath: string;
+    /** Namespace prefix for functions (e.g., 'planPhase') */
+    namespace: string;
+    /** Exported function names found in source (without namespace prefix) */
+    exportedFunctions: string[];
+}
+/**
+ * Options for single-entry bundling
+ */
+interface SingleEntryBundleOptions {
+    /** Runtime file info from all V3 files */
+    runtimeFiles: RuntimeFileInfo[];
+    /** Output path for the final runtime.js */
+    outputPath: string;
+    /** Directory for temporary entry file (default: .generated) */
+    entryDir?: string;
+    /** Minify the output bundle (default: false) */
+    minify?: boolean;
+}
+/**
+ * Options for code-split bundling
+ */
+interface CodeSplitBundleOptions {
+    /** Runtime file info from all V3 files */
+    runtimeFiles: RuntimeFileInfo[];
+    /** Output directory for split bundles */
+    outputDir: string;
+    /** Directory for temporary entry files (default: .generated) */
+    entryDir?: string;
+    /** Minify output bundles (default: false) */
+    minify?: boolean;
+}
+/**
+ * Result from code-split bundling
+ */
+interface CodeSplitBundleResult {
+    /** Dispatcher runtime.js content */
+    dispatcherContent: string;
+    /** Map of namespace -> bundled module content */
+    moduleContents: Map<string, string>;
+    /** All function names (with namespace prefixes) */
+    functions: string[];
+    /** Warnings from bundling */
+    warnings: string[];
+}
+/**
+ * Result from single-entry bundling
+ */
+interface SingleEntryBundleResult {
+    /** Final runtime.js content */
+    content: string;
+    /** All function names in registry (with namespace prefixes) */
+    functions: string[];
+    /** Warnings from bundling */
+    warnings: string[];
+}
+/**
+ * Extract exported function names from a TypeScript source file
+ */
+declare function extractExportedFunctionNames(sourceFile: SourceFile): string[];
+/**
+ * Bundle all runtime files using a single entry point
+ *
+ * This approach:
+ * 1. Generates a TypeScript entry file that imports all runtime modules
+ * 2. Bundles with esbuild (deduplicates shared code automatically)
+ * 3. Wraps with CLI entry point
+ * 4. Cleans up temporary files
+ */
+declare function bundleSingleEntryRuntime(options: SingleEntryBundleOptions): Promise<SingleEntryBundleResult>;
+/**
+ * Bundle all runtime files using code-split approach
+ *
+ * This approach:
+ * 1. Generates a TypeScript entry file for each namespace
+ * 2. Bundles each namespace separately with esbuild (in parallel)
+ * 3. Generates a small dispatcher that loads modules on-demand
+ * 4. Cleans up temporary files
+ *
+ * Benefits:
+ * - Faster startup (only loads dispatcher, ~2KB)
+ * - Modules loaded on-demand when function is called
+ * - Each module independently tree-shaken
+ */
+declare function bundleCodeSplit(options: CodeSplitBundleOptions): Promise<CodeSplitBundleResult>;
+
+/**
+ * ts-morph Parser - TSX file parsing and JSX AST extraction
+ *
+ * Provides utilities for parsing TSX files and extracting JSX elements
+ * for transformation into IR nodes.
+ */
+
+/**
+ * Add and parse a file from the filesystem
+ */
+declare function parseFile(project: Project, filePath: string): SourceFile;
+/**
+ * Parse an in-memory TSX string
+ */
+declare function parseSource(project: Project, source: string, fileName?: string): SourceFile;
+/**
+ * Get the element tag name from a JSX element or self-closing element
+ */
+declare function getElementName(node: JsxElement | JsxSelfClosingElement): string;
+/**
+ * JSX child node types
+ */
+type JsxChild = JsxElement | JsxSelfClosingElement | JsxText | JsxExpression;
+/**
+ * Get the JSX children of an element
+ */
+declare function getJsxChildren(node: JsxElement): JsxChild[];
+/**
+ * Get the value of a JSX attribute by name
+ *
+ * Handles both string literals (attr="value") and JSX expressions with
+ * string literals (attr={"value"}).
+ *
+ * Returns undefined if attribute is missing or not a string.
+ */
+declare function getAttributeValue(element: JsxOpeningElement | JsxSelfClosingElement, name: string): string | undefined;
+/**
+ * Find the root JSX element returned by the default export function
+ *
+ * Searches for a ReturnStatement containing JSX within the file.
+ * Returns null if no JSX is found.
+ */
+declare function findRootJsxElement(sourceFile: SourceFile): JsxElement | JsxSelfClosingElement | JsxFragment | null;
+/**
+ * Check if a JsxText node contains only whitespace (formatting between elements)
+ */
+declare function isWhitespaceOnlyText(node: JsxText): boolean;
+/**
+ * Normalize whitespace in text content
+ *
+ * Collapses multiple spaces/newlines to a single space and trims edges.
+ */
+declare function normalizeWhitespace(text: string): string;
+/**
+ * Extract text content from a JsxText node
+ *
+ * Returns null for whitespace-only nodes (formatting between elements).
+ * Otherwise returns normalized text content.
+ */
+declare function extractText(node: JsxText): string | null;
+/**
+ * Get the value of a JSX array attribute by name
+ *
+ * Handles JSX expressions containing array literals: attr={["a", "b"]}
+ * Returns undefined if attribute is missing or not a string array.
+ */
+declare function getArrayAttributeValue(element: JsxOpeningElement | JsxSelfClosingElement, name: string): string[] | undefined;
+/**
+ * Extract the JSX returned by a component function
+ *
+ * Handles:
+ * - Function declarations: function Foo() { return <div />; }
+ * - Arrow functions: const Foo = () => <div />;
+ * - Arrow functions with body: const Foo = () => { return <div />; };
+ *
+ * @param decl - The component's declaration node
+ * @returns The JSX element/fragment returned, or null if not found
+ */
+/**
+ * Extract generic type arguments from a JSX element
+ *
+ * For <SpawnAgent<ResearcherInput>> returns ['ResearcherInput']
+ * For <Agent<MyInput>> returns ['MyInput']
+ * Returns undefined if no type arguments present
+ *
+ * Uses ts-morph's getDescendantsOfKind to find TypeReference nodes within the
+ * opening element's tag, which is where JSX type arguments are attached.
+ */
+declare function extractTypeArguments(element: JsxElement | JsxSelfClosingElement): string[] | undefined;
+/**
+ * Result of resolving a type import
+ */
+interface ResolvedType {
+    sourceFile: SourceFile;
+    interfaceName: string;
+    interface: InterfaceDeclaration;
+}
+/**
+ * Resolve a type name to its interface declaration
+ * Follows import declarations to find the source file and interface
+ *
+ * @param typeName - Name of the type to resolve (e.g., 'ResearcherInput')
+ * @param sourceFile - Source file containing the import
+ * @returns ResolvedType with source file and interface, or undefined if not found
+ */
+declare function resolveTypeImport(typeName: string, sourceFile: SourceFile): ResolvedType | undefined;
+/**
+ * Property information extracted from an interface
+ */
+interface InterfaceProperty {
+    name: string;
+    required: boolean;
+    type: string;
+}
+/**
+ * Extract property information from an interface
+ *
+ * @param iface - Interface declaration to extract from
+ * @returns Array of property information
+ */
+declare function extractInterfaceProperties(iface: InterfaceDeclaration): InterfaceProperty[];
+/**
+ * Extract {placeholder} patterns from a prompt string
+ *
+ * @param prompt - Prompt string with {variable} placeholders
+ * @returns Set of placeholder names (without braces)
+ */
+declare function extractPromptPlaceholders(prompt: string): Set<string>;
+/**
+ * Extracted variable information from useVariable() call
+ */
+interface ExtractedVariable {
+    /** Local const name (e.g., "phaseDir") */
+    localName: string;
+    /** Shell variable name (e.g., "PHASE_DIR") */
+    envName: string;
+}
+/**
+ * Extract all useVariable() and defineVars() declarations from a source file
+ *
+ * Finds patterns like:
+ *   const phaseDir = useVariable("PHASE_DIR");
+ *   const vars = defineVars({ MODEL_PROFILE: { type: 'string' } });
+ *
+ * For defineVars, each property becomes a separate entry:
+ *   vars.MODEL_PROFILE -> { localName: 'vars.MODEL_PROFILE', envName: 'MODEL_PROFILE' }
+ *
+ * @param sourceFile - Source file to extract from
+ * @returns Map from local variable name to ExtractedVariable info
+ */
+declare function extractVariableDeclarations(sourceFile: SourceFile): Map<string, ExtractedVariable>;
+
+/**
+ * Extract SpawnAgent input object literal properties
+ *
+ * Handles property values:
+ * - String literal: { propName: "value" } -> { type: 'string', value: str }
+ * - {placeholder} pattern: { propName: "{var}" } -> { type: 'placeholder', name: var }
+ * - Identifier referencing variable: { propName: varRef } -> { type: 'variable', name: envName }
+ *
+ * @param objLiteral - The ObjectLiteralExpression from JSX input prop
+ * @param variables - Map of declared useVariable results
+ * @returns Array of InputProperty with proper InputValue types
+ */
+declare function extractInputObjectLiteral(objLiteral: ObjectLiteralExpression, variables: Map<string, ExtractedVariable>): InputProperty[];
+
+/**
+ * Information about a useRuntimeVar declaration
+ */
+interface RuntimeVarInfo {
+    /** Variable name (shell variable) */
+    varName: string;
+    /** TypeScript identifier name in source */
+    identifierName: string;
+    /** TypeScript type argument (if provided) */
+    tsType?: string;
+    /** Source location for error messages */
+    location: {
+        line: number;
+        column: number;
+    };
+}
+/**
+ * Information about a runtimeFn declaration
+ */
+interface RuntimeFunctionInfo {
+    /** Function name */
+    fnName: string;
+    /** Identifier name of the wrapper (e.g., 'Init' from 'const Init = runtimeFn(init)') */
+    wrapperName: string;
+    /** Source file path where function is defined */
+    sourceFilePath: string;
+    /** Whether the function is imported vs defined locally */
+    isImported: boolean;
+    /** Import path if imported (e.g., './runtime/init') */
+    importPath?: string;
+}
+/**
+ * Information about a local component definition
+ *
+ * Tracks PascalCase function components defined in the same file
+ * or imported from external files for build-time inlining.
+ */
+interface LocalComponentInfo {
+    /** Component name (PascalCase) */
+    name: string;
+    /** The AST node of the declaration (VariableDeclaration or FunctionDeclaration) */
+    declaration: Node;
+    /** Names of props (from destructured params or single param name) */
+    propNames: string[];
+    /** Cached JSX returned by the component (filled on first expansion) */
+    jsx?: JsxElement | JsxSelfClosingElement | JsxFragment;
+    /** Source file path where component is defined (for external components) */
+    sourceFilePath?: string;
+    /** Whether this component is imported from an external file */
+    isExternal?: boolean;
+    /** Import path if imported (e.g., './components/banner') */
+    importPath?: string;
+}
+/**
+ * Context for runtime transformers
+ *
+ * Tracks:
+ * - RuntimeVar declarations (for type-safe references)
+ * - RuntimeFn usage (for extraction to runtime.js)
+ */
+interface RuntimeTransformContext {
+    /** Source file being transformed */
+    sourceFile: SourceFile | undefined;
+    /** Namespace for runtime functions (derived from filename) */
+    namespace: string;
+    /** Visited paths for circular import detection */
+    visitedPaths: Set<string>;
+    /** Runtime variable declarations: identifier name -> info */
+    runtimeVars: Map<string, RuntimeVarInfo>;
+    /** Runtime function wrappers: wrapper name -> info */
+    runtimeFunctions: Map<string, RuntimeFunctionInfo>;
+    /** Runtime function imports: paths to extract from */
+    runtimeImports: Set<string>;
+    /** Create error with source location */
+    createError: (message: string, node: Node) => Error;
+    /** Track runtime function usage during transformation */
+    usedRuntimeFunctions: Set<string>;
+    /** Local component definitions: name -> info */
+    localComponents: Map<string, LocalComponentInfo>;
+    /** Component expansion stack for circular reference detection */
+    componentExpansionStack: Set<string>;
+    /** Current component props during expansion (for prop substitution) */
+    componentProps: Map<string, unknown> | null;
+    /** Current component children during expansion (for children substitution) */
+    componentChildren: BlockNode[] | null;
+}
+/**
+ * Create a fresh runtime transform context
+ *
+ * @param sourceFile - Source file being transformed (optional)
+ * @param namespace - Namespace for runtime functions (defaults to basename of sourceFile)
+ */
+declare function createRuntimeContext(sourceFile?: SourceFile, namespace?: string): RuntimeTransformContext;
+/**
+ * Result of runtime transformation
+ *
+ * Contains the document node and metadata needed for dual emission.
+ */
+interface RuntimeTransformResult {
+    /** Transformed document */
+    document: DocumentNode;
+    /** Runtime variable declarations (for markdown emission) */
+    runtimeVars: RuntimeVarDeclNode[];
+    /** Runtime function names used (for runtime.js extraction) */
+    runtimeFunctions: string[];
+    /** Import paths to extract functions from */
+    runtimeImportPaths: string[];
+}
+
+/**
+ * Runtime Component Transformer
+ *
+ * Handles build-time inlining of local function components.
+ * Enables React-style component definitions:
+ *
+ * ```tsx
+ * const Glenn = () => <h2>Glenn</h2>;
+ * const Greeting = ({ name }: { name: string }) => <p>Hello {name}</p>;
+ *
+ * // Usage
+ * <Glenn />
+ * <Greeting name="World" />
+ * ```
+ */
+
+/**
+ * Extract all local component definitions from a source file
+ *
+ * Scans for:
+ * - Variable declarations: `const Glenn = () => <h2>Glenn</h2>`
+ * - Function declarations: `function Glenn() { return <h2>Glenn</h2> }`
+ *
+ * Components must:
+ * - Have PascalCase names
+ * - Be arrow functions, function expressions, or function declarations
+ * - Return JSX
+ */
+declare function extractLocalComponentDeclarations(sourceFile: SourceFile, ctx: RuntimeTransformContext): void;
+/**
+ * Extract external component declarations from imports
+ *
+ * Scans for relative imports that reference PascalCase components
+ * and registers them in the context for build-time inlining.
+ *
+ * Supports:
+ * - Default imports: `import Banner from './banner'`
+ * - Named imports: `import { Header, Footer } from './ui'`
+ */
+declare function extractExternalComponentDeclarations(sourceFile: SourceFile, ctx: RuntimeTransformContext): void;
+
+/**
+ * Runtime Variable Transformer
+ *
+ * Extracts useRuntimeVar<T>('NAME') declarations from source files.
+ * Populates the RuntimeTransformContext with variable info for reference resolution.
+ */
+
+/**
+ * Extract all useRuntimeVar declarations from a source file
+ *
+ * Searches for patterns like:
+ * - const ctx = useRuntimeVar<Type>('NAME')
+ * - const { a, b } = useRuntimeVar<Type>('NAME') (not supported, error)
+ *
+ * @param sourceFile - Source file to scan
+ * @param ctx - Transform context to populate
+ */
+declare function extractRuntimeVarDeclarations(sourceFile: SourceFile, ctx: RuntimeTransformContext): void;
+
+/**
+ * Runtime Function Transformer
+ *
+ * Extracts runtimeFn(fn) declarations from source files.
+ * Tracks wrapper names and import paths for runtime.js extraction.
+ */
+
+/**
+ * Extract all runtimeFn declarations from a source file
+ *
+ * Searches for patterns like:
+ * - const Init = runtimeFn(initFunction)
+ * - const GetContext = runtimeFn(getContext)
+ *
+ * Also tracks imports of the wrapped functions for extraction.
+ *
+ * @param sourceFile - Source file to scan
+ * @param ctx - Transform context to populate
+ */
+declare function extractRuntimeFnDeclarations(sourceFile: SourceFile, ctx: RuntimeTransformContext): void;
+/**
+ * Get runtime function names from context
+ *
+ * Returns the list of function names (not wrapper names) that need
+ * to be extracted to runtime.js.
+ */
+declare function getRuntimeFunctionNames(ctx: RuntimeTransformContext): string[];
+/**
+ * Get runtime import paths from context
+ *
+ * Returns paths that need to be parsed for function extraction.
+ */
+declare function getRuntimeImportPaths(ctx: RuntimeTransformContext): string[];
+
+/**
+ * Runtime Central Transform Dispatcher
+ *
+ * Routes JSX elements to appropriate runtime transformers.
+ * Delegates unchanged elements (headings, lists, etc.) to shared transformers.
+ */
+
+/**
+ * Transform a JSX node to BlockNode
+ */
+declare function transformToRuntimeBlock(node: Node, ctx: RuntimeTransformContext): BlockNode | null;
+/**
+ * Transform JSX children to BlockNodes, handling If/Else sibling pairs
+ */
+declare function transformRuntimeBlockChildren(parent: JsxElement, ctx: RuntimeTransformContext): BlockNode[];
+/**
+ * Transform a V3 Command element to DocumentNode
+ *
+ * Supports two patterns:
+ * 1. Render props: <Command>{() => { return (<>...</>) }}</Command>
+ * 2. Direct children: <Command>...</Command>
+ */
+declare function transformRuntimeCommand(root: JsxElement | JsxSelfClosingElement, ctx: RuntimeTransformContext): DocumentNode;
+
+/**
+ * Runtime Build Pipeline
+ *
+ * Transforms TSX files to dual output:
+ * - COMMAND.md (markdown for Claude)
+ * - runtime.js (bundled TypeScript functions via esbuild)
+ */
+
+/**
+ * V3 build result
+ */
+interface RuntimeBuildResult {
+    /** Generated markdown content */
+    markdown: string;
+    /** Generated runtime.js content (empty - bundling happens at end) */
+    runtime: string;
+    /** Full runtime result for merging (null if no runtime functions) - LEGACY */
+    runtimeResult: RuntimeEmitResult | null;
+    /** Runtime file info for single-entry bundling (null if no runtime functions) */
+    runtimeFileInfo: RuntimeFileInfo | null;
+    /** Path where markdown should be written */
+    markdownPath: string;
+    /** Path where runtime should be written */
+    runtimePath: string;
+    /** List of runtime functions extracted (without namespace prefix) */
+    runtimeFunctions: string[];
+    /** Any warnings during build */
+    warnings: string[];
+}
+/**
+ * V3 build options
+ */
+interface RuntimeBuildOptions {
+    /** Output directory for commands */
+    commandsOut: string;
+    /** Output directory for runtime */
+    runtimeOut: string;
+    /** Dry run - don't write files */
+    dryRun?: boolean;
+}
+/**
+ * Build a Runtime file to markdown and runtime.js
+ *
+ * @param sourceFile - Source file to build
+ * @param project - ts-morph project for resolution
+ * @param options - Build options
+ * @returns Build result with content and paths
+ */
+declare function buildRuntimeFile(sourceFile: SourceFile, project: Project, options: RuntimeBuildOptions): Promise<RuntimeBuildResult>;
+/**
+ * Check if a source file is a runtime file
+ *
+ * Uses import detection to determine if file uses runtime features.
+ */
+declare function detectRuntime(sourceFile: SourceFile): boolean;
+/**
+ * Quick check for runtime markers in file content
+ *
+ * Faster than full parse - checks for import patterns.
+ */
+declare function hasRuntimeImports(content: string): boolean;
+
+/**
+ * ts-morph Project creation and file parsing utilities
+ */
+
+interface CreateProjectOptions {
+    /**
+     * Use in-memory filesystem (default: false)
+     * Set to true for test scenarios where files don't exist on disk
+     */
+    inMemory?: boolean;
+}
+/**
+ * Create a ts-morph Project configured for JSX parsing
+ *
+ * @param options.inMemory - Use in-memory filesystem (default: false)
+ */
+declare function createProject(options?: CreateProjectOptions): Project;
+
+/**
+ * Transformer - JSX AST to IR Node transformation
+ *
+ * Converts parsed JSX elements from ts-morph into IR nodes
+ * for emission to Markdown.
+ */
+
+declare class Transformer {
+    /** Source file for component resolution (optional - only needed for composition) */
+    private sourceFile;
+    /** Visited paths for circular import detection */
+    private visitedPaths;
+    /** Extracted useVariable declarations from source file */
+    private variables;
+    /** Extracted useOutput declarations: identifier name -> agent name */
+    private outputs;
+    /** Extracted useStateRef declarations: identifier name -> state key */
+    private stateRefs;
+    /** Current render props context for interpolation (set during Command/Agent transformation) */
+    private renderPropsContext;
+    /**
+     * Create a TranspileError with source location context from a node
+     */
+    private createError;
+    /**
+     * Build a TransformContext from instance state for delegation to document transformers
+     */
+    private buildContext;
+    /**
+     * Transform a root JSX element/fragment into AgentDocumentNode, SkillDocumentNode, MCPConfigDocumentNode, or StateDocumentNode
+     *
+     * Note: Command documents use the runtime transformer (transformRuntimeCommand) for runtime feature support.
+     *
+     * @param node - The root JSX element/fragment to transform
+     * @param sourceFile - Optional source file for component composition resolution
+     */
+    transform(node: JsxElement | JsxSelfClosingElement | JsxFragment, sourceFile?: SourceFile): AgentDocumentNode | SkillDocumentNode | MCPConfigDocumentNode | StateDocumentNode;
+    /**
+     * Merge Command props from spread attributes and explicit attributes
+     *
+     * Processes attributes in order - later props override earlier ones.
+     * Supports spread attributes: {...baseProps}
+     * Supports explicit attributes: name="value" or name={"value"} or name={["a", "b"]}
+     */
+    private mergeCommandProps;
+    /**
+     * Transform a Command element
+     *
+     * NOTE: This transformer is deprecated for Commands. Commands should use the runtime transformer
+     * which supports runtime features (useRuntimeVar, If/Else/Loop, etc.).
+     */
+    private transformCommand;
+    /**
+     * Transform an Agent element to AgentDocumentNode with frontmatter
+     * Delegates to document.ts transformAgent()
+     */
+    private transformAgent;
+    /**
+     * Transform a Skill element to SkillDocumentNode with frontmatter, body, files, and statics
+     * Delegates to document.ts transformSkill()
+     */
+    private transformSkill;
+    private transformFragmentChildren;
+    /**
+     * Transform arrow function body to IR blocks
+     * Handles both block body { return ... } and expression body
+     */
+    private transformArrowFunctionBody;
+    private transformToBlock;
+    private transformElement;
+    private transformList;
+    private transformListItem;
+    private transformBlockquote;
+    private transformCodeBlock;
+    private extractCodeContent;
+    private transformInlineChildren;
+    private trimBoundaryTextNodes;
+    private transformToInline;
+    private transformInlineElement;
+    private extractAllText;
+    private transformLink;
+    private transformDiv;
+    /**
+     * Transform mixed children (inline + block elements)
+     * Consecutive inline elements and text are wrapped in a single paragraph
+     * Block elements are transformed normally
+     */
+    private transformMixedChildren;
+    /**
+     * Transform a list of nodes to inline nodes
+     * Used by transformMixedChildren for inline accumulation
+     */
+    private transformInlineNodes;
+    private transformXmlBlock;
+    /**
+     * Transform Table component to TableNode IR
+     */
+    private transformTable;
+    /**
+     * Parse rows attribute (array of arrays)
+     */
+    private parseRowsAttribute;
+    /**
+     * Interpolate a PropertyAccessExpression if it references render props context
+     * Returns the interpolated value or null if not a context access
+     */
+    private interpolatePropertyAccess;
+    /**
+     * Transform List component (prop-based) to ListNode IR
+     * This is separate from HTML <ul>/<ol> transformation
+     */
+    private transformPropList;
+    private transformExecutionContext;
+    private transformSuccessCriteria;
+    /**
+     * Parse items attribute for SuccessCriteria
+     * Handles both string shorthand and {text, checked} objects
+     */
+    private parseSuccessCriteriaItems;
+    private transformOfferNext;
+    /**
+     * Parse routes attribute for OfferNext
+     * Each route is an object with name, path, and optional description
+     */
+    private parseOfferNextRoutes;
+    /**
+     * Transform Step component to StepNode IR
+     */
+    private transformStep;
+    /**
+     * Transform <Bash> to CodeBlockNode with language 'bash'
+     *
+     * <Bash>ls -la</Bash>
+     * becomes:
+     * ```bash
+     * ls -la
+     * ```
+     */
+    private transformBash;
+    /**
+     * Transform <ReadFiles> to ReadFilesNode
+     *
+     * Extracts the files prop (which should be a defineFiles() result)
+     * and creates a ReadFilesNode with file entries.
+     */
+    private transformReadFiles;
+    /**
+     * Extract file entries from defineFiles schema object literal
+     */
+    private extractFilesFromSchema;
+    /**
+     * Extract path from template expression, preserving ${} for shell
+     */
+    private extractTemplatePath;
+    /**
+     * Transform <PromptTemplate> to PromptTemplateNode
+     *
+     * <PromptTemplate>
+     *   <XmlBlock name="objective">...</XmlBlock>
+     * </PromptTemplate>
+     *
+     * Becomes:
+     * ```markdown
+     * <objective>
+     * ...
+     * </objective>
+     * ```
+     */
+    private transformPromptTemplate;
+    private transformXmlSection;
+    private transformXmlWrapper;
+    private transformMarkdown;
+    /**
+     * Transform a custom component by resolving its import and inlining its JSX
+     *
+     * Custom components are user-defined TSX fragments that get inlined at
+     * transpile time. Component props are NOT supported in v1 - only parameterless
+     * composition.
+     */
+    private transformCustomComponent;
+    /**
+     * Transform a SpawnAgent element to SpawnAgentNode
+     * SpawnAgent is a block-level element that emits Task() syntax
+     *
+     * Supports two modes:
+     * 1. prompt prop (deprecated): Manual prompt string
+     * 2. input prop (preferred): Typed input - VariableRef or object literal
+     *
+     * Also supports:
+     * - agent={AgentRef} for type-safe agent references
+     * - loadFromFile prop for "load from file" pattern
+     */
+    private transformSpawnAgent;
+    /**
+     * Extract agent prop - handles string OR AgentRef identifier
+     *
+     * Returns:
+     * - agentName: The agent name string (required)
+     * - agentPath: The agent's file path (if AgentRef with path)
+     */
+    private extractAgentProp;
+    /**
+     * Try to resolve an identifier to an AgentRef definition
+     *
+     * Looks for:
+     * 1. Imported AgentRef (from defineAgent call in source file)
+     * 2. Local AgentRef constant
+     */
+    private resolveAgentRef;
+    /**
+     * Resolve an imported AgentRef by tracing to its source file
+     */
+    private resolveImportedAgentRef;
+    /**
+     * Extract AgentRef properties from defineAgent config object
+     */
+    private extractAgentRefFromObject;
+    /**
+     * Extract loadFromFile prop
+     *
+     * Supports:
+     * - loadFromFile (boolean true shorthand)
+     * - loadFromFile={true}
+     * - loadFromFile="explicit/path.md"
+     *
+     * When true, uses agentPath from AgentRef.
+     * Returns resolved path string or undefined.
+     */
+    private extractLoadFromFileProp;
+    /**
+     * Extract input prop - handles VariableRef identifier or object literal
+     *
+     * Supports:
+     * - input={varRef} - Reference to useVariable result
+     * - input={{ key: "value" }} - Object literal with properties
+     */
+    private extractInputProp;
+    /**
+     * Extract extra instructions from SpawnAgent children
+     *
+     * Treats children as raw text content (like Markdown component).
+     * Returns undefined if no children or only whitespace.
+     */
+    private extractExtraInstructions;
+    /**
+     * Extract type argument from SpawnAgent<T> syntax
+     *
+     * Returns the type name string (e.g., "ResearcherInput") or undefined
+     * if no type argument is present.
+     */
+    private extractSpawnAgentTypeParam;
+    /**
+     * Validate input object properties against SpawnAgent<T> type parameter.
+     *
+     * Throws compile error if required interface properties are missing.
+     * Only validates object literal inputs (VariableRef is runtime-checked).
+     *
+     * @param input - The parsed SpawnAgentInput (may be variable or object)
+     * @param typeParam - The type parameter name (e.g., "ResearcherInput")
+     * @param element - The JSX element for error reporting
+     */
+    private validateInputAgainstInterface;
+    /**
+     * Transform an If element to IfNode
+     *
+     * NOTE: V1 control flow is deprecated. Use V3 transformer with useRuntimeVar and condition-based If.
+     */
+    private transformIf;
+    /**
+     * Transform an Else element to ElseNode
+     *
+     * NOTE: V1 control flow is deprecated. Use V3 transformer with useRuntimeVar and condition-based If/Else.
+     */
+    private transformElse;
+    /**
+     * Transform Loop component to LoopNode IR
+     *
+     * NOTE: V1 control flow is deprecated. Use V3 transformer with useRuntimeVar and max-based Loop.
+     */
+    private transformLoop;
+    /**
+     * Extract useOutput declarations from source file
+     * Returns map of identifier name -> agent name
+     *
+     * Uses forEachDescendant to find declarations inside function bodies,
+     * following the same pattern as extractVariableDeclarations in parser.ts
+     */
+    private extractOutputDeclarations;
+    /**
+     * Extract useStateRef declarations from source file
+     * Returns map of identifier name -> state key
+     *
+     * Uses forEachDescendant to find declarations inside function bodies,
+     * following the same pattern as extractOutputDeclarations
+     */
+    private extractStateRefDeclarations;
+    /**
+     * Transform ReadState JSX element into IR node
+     *
+     * Extracts:
+     * - state: StateRef with key property
+     * - into: VariableRef with name property
+     * - field: optional nested path string
+     */
+    private transformReadState;
+    /**
+     * Extract state key from StateRef expression
+     * Handles: identifier pointing to useStateRef result
+     */
+    private extractStateKey;
+    /**
+     * Extract variable name from VariableRef expression
+     * Handles: identifier pointing to useVariable result
+     */
+    private extractVariableName;
+    /**
+     * Transform WriteState JSX element into IR node
+     *
+     * Two modes:
+     * 1. Field mode: field="path" value={val}
+     * 2. Merge mode: merge={partial}
+     */
+    private transformWriteState;
+    /**
+     * Transform an OnStatus element to OnStatusNode
+     * OnStatus is a block-level element that emits status-based conditionals
+     */
+    private transformOnStatus;
+    /**
+     * Transform an MCPConfig element to MCPConfigDocumentNode
+     * MCPConfig wraps multiple MCPServer elements into a single document
+     * Delegates to document.ts transformMCPConfig()
+     */
+    private transformMCPConfig;
+    /**
+     * Transform JSX children to BlockNodes, handling If/Else sibling pairs
+     */
+    private transformBlockChildren;
+    /**
+     * Transform an Assign element to AssignNode
+     * Assign emits a bash code block with variable assignment
+     *
+     * Supports three assignment types (exactly one required):
+     * - bash: VAR=$(command)
+     * - value: VAR=value (quoted if spaces)
+     * - env: VAR=$ENV_VAR
+     */
+    private transformAssign;
+    /**
+     * Transform an AssignGroup element to AssignGroupNode
+     * AssignGroup collects Assign children into a single bash code block
+     */
+    private transformAssignGroup;
+    /**
+     * Extract assignment prop value from Assign element
+     * Handles string literals, JSX expressions with strings, and template literals
+     */
+    private extractAssignPropValue;
+    /**
+     * Extract template literal content preserving ${VAR} syntax for bash
+     */
+    private extractBashTemplate;
+    /**
+     * Extract prompt prop value, preserving multi-line content and {variable} placeholders
+     * Supports: prompt="string", prompt={"string"}, prompt={`template`}
+     */
+    private extractPromptProp;
+    /**
+     * Extract text from a template expression, converting ${var} to {var}
+     * This preserves GSD's {variable} placeholder syntax
+     */
+    private extractTemplateText;
+    /**
+     * Transform a State component into StateDocumentNode
+     * Delegates to document.ts transformState()
+     */
+    private transformState;
+    /**
+     * Evaluate a binary expression that represents string concatenation.
+     * Handles chains like: `text ` + AGENT_PATHS.researcher + ` more`
+     * Returns the concatenated string or null if not evaluable.
+     */
+    private evaluateStringConcatenation;
+    /**
+     * Evaluate an expression that should resolve to a string value.
+     * Handles: string literals, template literals, property access, binary expressions.
+     */
+    private evaluateStringExpression;
+    /**
+     * Resolve a property access expression (e.g., AGENT_PATHS.researcher) to its value.
+     * Only works for const declarations with object literals.
+     */
+    private resolvePropertyAccess;
+}
+/**
+ * Convenience function to transform a JSX element to an AgentDocumentNode, SkillDocumentNode, MCPConfigDocumentNode, or StateDocumentNode
+ */
+declare function transform(node: JsxElement | JsxSelfClosingElement | JsxFragment, sourceFile?: SourceFile): AgentDocumentNode | SkillDocumentNode | MCPConfigDocumentNode | StateDocumentNode;
+
+/**
+ * JSX component stubs for react-agentic - Variable primitives
+ *
+ * These components are compile-time only - they're transformed by the transpiler
+ * and never executed at runtime. They exist to provide TypeScript type checking.
+ */
+/**
+ * Reference to a shell variable created by useVariable
+ * @typeParam T - Phantom type for value (compile-time only)
+ */
+interface VariableRef<T = string> {
+    /** Shell variable name (e.g., "PHASE_DIR") */
+    name: string;
+    /** Same as name - for interpolation in bash strings */
+    ref: string;
+    /** Phantom type marker (compile-time only) */
+    _type?: T;
+}
+
+/**
+ * Schema-based declarations for react-agentic
+ *
+ * Provides compile-time helpers for declaring variables, files, and context
+ * with TypeScript type safety.
+ */
+
+/**
+ * Definition for a single variable in defineVars schema
+ */
+interface VarDef {
+    /** TypeScript type hint (compile-time only) */
+    type?: 'string' | 'number' | 'boolean';
+    /** Default value if not assigned */
+    default?: string | number | boolean;
+}
+/**
+ * Schema type for defineVars - maps names to VarDef
+ */
+type VarSchema = Record<string, VarDef | undefined>;
+/**
+ * Infer TypeScript type from VarDef
+ */
+type InferVarType<T extends VarDef | undefined> = T extends {
+    type: 'number';
+} ? number : T extends {
+    type: 'boolean';
+} ? boolean : string;
+/**
+ * Output type from defineVars - maps schema keys to VariableRefs
+ */
+type VarsFromSchema<T extends VarSchema> = {
+    [K in keyof T]: VariableRef<InferVarType<T[K]>>;
+};
+/**
+ * Declare multiple shell variables from a schema
+ *
+ * This is a compile-time helper that creates VariableRef objects.
+ * The actual assignment is specified on <Assign> where you emit it.
+ *
+ * @param schema - Object mapping variable names to VarDef options
+ * @returns Object with VariableRef for each schema key
+ *
+ * @example Basic usage
+ * const vars = defineVars({
+ *   PHASE: { type: 'string' },
+ *   MODEL_PROFILE: { default: 'balanced' },
+ *   DEBUG: { type: 'boolean' },
+ * });
+ *
+ * // Use in JSX:
+ * <Assign var={vars.PHASE} bash={`echo $PHASE_NUMBER`} />
+ * <If test={`[ "${vars.MODEL_PROFILE.ref}" = "quality" ]`}>
+ *
+ * @example Replaces multiple useVariable calls
+ * // Before:
+ * const phase = useVariable('PHASE');
+ * const model = useVariable('MODEL_PROFILE');
+ * const debug = useVariable('DEBUG');
+ *
+ * // After:
+ * const vars = defineVars({
+ *   PHASE: {},
+ *   MODEL_PROFILE: { default: 'balanced' },
+ *   DEBUG: { type: 'boolean' },
+ * });
+ */
+declare function defineVars<T extends VarSchema>(schema: T): VarsFromSchema<T>;
+/**
+ * Definition for a single file in defineFiles schema
+ */
+interface FileDef {
+    /** File path - static string or function using vars */
+    path: string | ((vars: Record<string, string>) => string);
+    /** Whether file must exist (default: true) */
+    required?: boolean;
+}
+/**
+ * Schema type for defineFiles - maps names to FileDef
+ */
+type FileSchema = Record<string, FileDef>;
+/**
+ * Reference to a file defined in schema
+ */
+interface FileRef {
+    /** Variable name for content (e.g., "STATE_CONTENT") */
+    varName: string;
+    /** Original key from schema (e.g., "state") */
+    key: string;
+    /** File path (may contain variable references) */
+    path: string;
+    /** Whether file is required */
+    required: boolean;
+}
+/**
+ * Output type from defineFiles - maps schema keys to FileRefs
+ */
+type FilesFromSchema<T extends FileSchema> = {
+    [K in keyof T]: FileRef;
+} & {
+    /** Get all FileRefs as array (for ReadFiles component) */
+    _refs: FileRef[];
+};
+/**
+ * Declare file contracts with paths and requirements
+ *
+ * This is a compile-time helper that creates FileRef objects for use
+ * with the <ReadFiles> component.
+ *
+ * @param schema - Object mapping file names to FileDef options
+ * @returns Object with FileRef for each schema key, plus _refs array
+ *
+ * @example Basic usage
+ * const files = defineFiles({
+ *   state: { path: '.planning/STATE.md', required: true },
+ *   requirements: { path: '.planning/REQUIREMENTS.md', required: false },
+ * });
+ *
+ * // Use with ReadFiles:
+ * <ReadFiles files={files} />
+ *
+ * // Access individual file content variable:
+ * <If test={`[ -n "${files.state.varName}" ]`}>
+ *
+ * @example Dynamic paths using variables
+ * const files = defineFiles({
+ *   context: {
+ *     path: (v) => `${v.PHASE_DIR}/*-CONTEXT.md`,
+ *     required: false,
+ *   },
+ * });
+ */
+declare function defineFiles<T extends FileSchema>(schema: T): FilesFromSchema<T>;
+/**
+ * Agent reference for defineContext
+ */
+interface AgentDef {
+    /** Path to agent markdown file */
+    path: string;
+    /** Optional model override */
+    model?: string;
+}
+/**
+ * Definition for defineContext
+ */
+interface ContextDef {
+    /** Agent definitions */
+    agents?: Record<string, string | AgentDef>;
+    /** Variable definitions (from defineVars) */
+    vars?: VarsFromSchema<VarSchema>;
+    /** File definitions (from defineFiles) */
+    files?: FilesFromSchema<FileSchema>;
+}
+/**
+ * Output type from defineContext
+ */
+interface Context {
+    /** Resolved agent references */
+    agents: Record<string, {
+        path: string;
+        model?: string;
+    }>;
+    /** Variable refs (passthrough from defineVars) */
+    vars: VarsFromSchema<VarSchema>;
+    /** File refs (passthrough from defineFiles) */
+    files: FilesFromSchema<FileSchema>;
+}
+/**
+ * Create unified context for Command or Agent
+ *
+ * Combines agents, variables, and files into a single context object.
+ * This is a compile-time helper - the context is available for
+ * use in the component body.
+ *
+ * @param def - Context definition with agents, vars, and files
+ * @returns Unified context object
+ *
+ * @example Basic usage
+ * const ctx = defineContext({
+ *   agents: {
+ *     researcher: '~/.claude/agents/gsd-phase-researcher.md',
+ *     planner: { path: '~/.claude/agents/gsd-planner.md', model: 'sonnet' },
+ *   },
+ *   vars: defineVars({
+ *     PHASE: { type: 'string' },
+ *     MODEL_PROFILE: { default: 'balanced' },
+ *   }),
+ *   files: defineFiles({
+ *     state: { path: '.planning/STATE.md', required: true },
+ *   }),
+ * });
+ *
+ * <Command name="my-cmd" context={ctx}>
+ *   <Assign var={ctx.vars.PHASE} bash={`...`} />
+ *   <ReadFiles files={ctx.files} />
+ *   <SpawnAgent agent={ctx.agents.researcher} ... />
+ * </Command>
+ */
+declare function defineContext(def: ContextDef): Context;
+
+/**
+ * JSX component stubs for react-agentic - Semantic wrapper components
+ *
+ * These components are compile-time only - they're transformed by the transpiler
+ * and never executed at runtime. They exist to provide TypeScript type checking.
+ */
+
+/**
+ * Props for the ExecutionContext component
+ */
+interface ExecutionContextProps {
+    /** File paths to include in execution context */
+    paths: string[];
+    /** Prefix for paths (defaults to '@') */
+    prefix?: string;
+    /** Optional additional content inside execution_context block */
+    children?: ReactNode;
+}
+/**
+ * ExecutionContext component - emits <execution_context> XML with file paths
+ *
+ * This is a compile-time component transformed by react-agentic.
+ * It's never executed at runtime.
+ *
+ * @example
+ * <ExecutionContext
+ *   paths={[
+ *     "/Users/user/.claude/workflow.md",
+ *     "/Users/user/.claude/templates/summary.md"
+ *   ]}
+ * />
+ *
+ * Outputs:
+ * <execution_context>
+ * @/Users/user/.claude/workflow.md
+ * @/Users/user/.claude/templates/summary.md
+ * </execution_context>
+ *
+ * @example
+ * <ExecutionContext
+ *   paths={["~/docs/guide.md"]}
+ *   prefix="$"
+ * >
+ *   <Markdown>See these files for context.</Markdown>
+ * </ExecutionContext>
+ *
+ * Outputs:
+ * <execution_context>
+ * $/Users/user/docs/guide.md
+ * See these files for context.
+ * </execution_context>
+ */
+declare function ExecutionContext(_props: ExecutionContextProps): null;
+
+export { ASK_USER_MARKER, Agent, type AgentContext, type AgentDocumentNode, type AgentFrontmatterNode, type AgentProps, type AgentRef, type AgentStatus, type AllowRuntimeVars, AskUser, type AskUserNode, type AskUserOption, type AskUserOptionNode, type AskUserProps, type AssignGroupNode, type AssignNode, BREAK_MARKER, type BaseBlockNode, type BaseOutput, type BlockNode, type BlockquoteNode, type BoldNode, Break, type BreakNode, type BreakProps, type CodeBlockNode, type CodeSplitBundleResult, Command, type CommandArgument, type CommandContext, type CommandProps, type Condition$1 as Condition, type ConditionAnd, type ConditionEq, type ConditionGt, type ConditionGte, type ConditionLiteral, type ConditionLt, type ConditionLte, type ConditionNeq, type ConditionNot, type ConditionOr, type ConditionRef, type DefineAgentConfig, type DocumentMetadata, type DocumentNode, ELSE_MARKER, Else, type ElseNode, type ElseProps, ExecutionContext, type ExecutionContextNode, type ExecutionContextProps, type ExtractedFunction, type ExtractedVariable, type FrontmatterNode, type GroupNode, type HeadingNode, IF_MARKER, type IRNode, If, type IfNode, type IfProps, Indent, type IndentNode, type IndentProps, type InlineCodeNode, type InlineNode, type InputProperty, type InputValue, type ItalicNode, type JsxChild, LOOP_MARKER, type LineBreakNode, type LinkNode, List, type ListItemNode, type ListNode, type ListProps, type LocalComponentInfo, Loop, type LoopNode, type LoopProps, type MCPConfigDocumentNode, type MCPServerNode, Markdown, type MarkdownProps, type OfferNextNode, type OfferNextRouteData, OnStatus, type OnStatusNode, type OnStatusProps, type OperationNode, type OrRuntimeVar, type OutputRef, type OutputReference, type ParagraphNode, type PromptTemplateNode, RETURN_MARKER, type RawMarkdownNode, type ReadFileEntry, type ReadFilesNode, type ReadStateNode, Return, type ReturnNode, type ReturnProps, type ReturnStatus, type RuntimeBlockNode, type RuntimeBuildOptions, type RuntimeBuildResult, type RuntimeCallComponent, type RuntimeCallNode, type RuntimeCallProps, type RuntimeEmitResult, type RuntimeFileInfo, type RuntimeFnComponent, type RuntimeFunction, type RuntimeFunctionInfo, RuntimeMarkdownEmitter, type RuntimeTransformContext, type RuntimeTransformResult, type RuntimeVar, type RuntimeVarDeclNode, type RuntimeVarInfo, type RuntimeVarProxy, type RuntimeVarRefNode, type SingleEntryBundleResult, type SkillDocumentNode, type SkillFileNode, type SkillFrontmatterNode, type SkillStaticNode, SpawnAgent, type SpawnAgentInput, type SpawnAgentNode, type SpawnAgentProps, type StateDocumentNode, type StateNode, type StateSchema, type StateSchemaField, type StepNode, type StepVariant, type SuccessCriteriaItemData, type SuccessCriteriaNode, Table, type TableAlignment, type TableNode, type TableProps, type TextNode, type ThematicBreakNode, Transformer, type TypeReference, type V3SpawnAgentProps, type WriteStateNode, XmlBlock, type XmlBlockNode, type XmlBlockProps, assertNever, buildRuntimeFile, bundleCodeSplit, bundleSingleEntryRuntime, clearRuntimeFnRegistry, createProject, createRuntimeContext, defineAgent, defineContext, defineFiles, defineVars, detectRuntime, emit, emitAgent, emitDocument, emitRuntime, emitSettings, emitSkill, emitSkillFile, extractExportedFunctionNames, extractExternalComponentDeclarations, extractFunctions, extractInputObjectLiteral, extractInterfaceProperties, extractLocalComponentDeclarations, extractPromptPlaceholders, extractRuntimeFnDeclarations, extractRuntimeVarDeclarations, extractText, extractTypeArguments, extractVariableDeclarations, findRootJsxElement, generateRuntime, getAgentName, getAgentPath, getArrayAttributeValue, getAttributeValue, getElementName, getJsxChildren, getRuntimeFn, getRuntimeFnRegistry, getRuntimeFunctionNames, getRuntimeImportPaths, getRuntimeVarInfo, hasRuntimeImports, isAgentRef, isDocument, isRuntimeFile, isRuntimeFn, isRuntimeNode, isRuntimeVar, isWhitespaceOnlyText, mergeSettings, normalizeWhitespace, parseFile, parseSource, resolveTypeImport, runtimeFn, toJqExpression, toJqPath, transform, transformRuntimeBlockChildren, transformRuntimeCommand, transformToRuntimeBlock, useOutput, useRuntimeVar };