@aihu/runtime

function _ensureA11yStyles(): void

function _hmrReplace(element: HTMLElement, newSetup: Setup): void

function _registerAgentDispatcher( element: Element | null | undefined, dispatcher: InstanceAgentDispatcher, ): void

Register a mounted instance's agent dispatcher.

function _registerAgentServerBinding( element: Element | null | undefined, binding: InstanceAgentServerBinding, ): void

Register a mounted instance's FULL server agent binding.

function _setHydrate(fn: HydrateFn): void

function _setMount(fn: MountFn): void

function _setSignal(s: typeof SignalFactory): void

function _takeAgentDispatcher( element: Element | null | undefined, ): InstanceAgentDispatcher | undefined

Look up the instance dispatcher registered for `element` (the mounted host custom element).

function _takeAgentServerBinding( element: Element | null | undefined, ): InstanceAgentServerBinding | undefined

Take (read) the server binding registered for `element`.

function announce(message: string): void

Programmatic ARIA announcement.

function createFocusTrap( active: boolean | (() => boolean), returnFocus: boolean, initialFocus: string | null, childFn: () => Branch, ): Branch

Focus-trap boundary.

function createResource<T>(factory: () => Promise<T>): ResourceHandle<T>

Create a reactive resource backed by an async `factory`.

function createStream(factory: () => Promise<ReadableStream<string> | null>): StreamHandle

Create a reactive stream handle backed by a `ReadableStream<string>` factory.

function defineComponent(setupOrOptions: Setup | ComponentOptions): typeof HTMLElement

function defineElement( name: string, Ctor: typeof HTMLElement, options?: DefineOptions, ): void

function _onAdopt(fn: () => void): void

function _onAttributeChange( fn: (name: string, oldValue: string | null, newValue: string | null) => void, ): void

function _onCleanup(fn: () => void): void

function _onMount(fn: () => void | (() => void)): void

const __aihu_cpath = (p: string): string => …

Comment-safe path for structural markers — the walker's `_commentPath` (`-` → `_` so arbitrary list keys can't terminate the comment early).

const __aihu_eattr = (v: unknown): string => …

Attribute-value escape (`&` and `"`), the walker's `escapeAttr`.

const __aihu_key = (v: unknown): string => …

List-item key normalization — the walker's `String(key).replace(/\./g, '_')` (dots would splice into the path grammar; see `_structuralSubtrees` in

const __aihu_sattr = (k: string, v: unknown): string => …

One serialized attribute (` k="v"` / ` k` / nothing), mirroring the walker's `serializeAttrs` value rules for a RESOLVED value: functions (event handlers) never serialize, `true` renders the bare attribute, `false`/`undefined` render nothing, everything else stringifies escaped.

const __aihu_stext = (v: unknown): string => …

Escaped text hole for a REACTIVE leaf — the walker reads `String(get())`, so `null`/`undefined` stringify ("null"/"undefined"), exactly like a client-side reactive text binding would render them.

const __aihu_stext0 = (v: unknown): string => …

Escaped text hole for an EAGER leaf — the walker's `leafText` renders nullish static values as the empty string.

const _hydrateOnVisible = (element: HTMLElement, hydrate: () => void): void => …

interface ComponentOptions<A extends ReadonlyArray<string> = ReadonlyArray<string>> {
  attrs?: A
  /**
   * R1 ($prop reactivity, template-syntax-v2 round 5): rich per-prop
   * metadata bag describing the Lit-style `attribute` / `reflect` /
   * `converter` lowering. When non-empty, the runtime synthesizes
   * `observedAttributes` from prop entries with `attribute !== false`,
   * wires `attributeChangedCallback`, allocates one `Signal` per prop
   * initialized to `value`, defines a JS property accessor on the class
   * prototype, and (when `reflect: true`) reflects signal writes back to
   * the attribute with a re-entrancy guard.
   *
   * Value flows through to the setup function via `ctx.props.<name>`,
   * a per-name `Signal<unknown>`. Setup callers are expected to read via
   * the signal-getter call (e.g. `props.title()`); writes via
   * `props.title.set(...)` or via the JS property accessor on the host
   * element (`el.title = newValue`) flow back through the same signal.
   */
  props?: PropsConfig
  /**
   * Recipe class-extension (master spec §9.4): the generated element class
   * extends this base custom-element class instead of `HTMLElement`, so the
   * base's `connectedCallback` (role/ARIA/keyboard, form-control inheritance,
   * cross-piece context provision) runs on the host. Emitted by the compiler's
   * `$extends:` macro. Options-form only — base-extending recipes always carry
   * `$prop` declarations, so they compile to the options-form. The base's
   * `connectedCallback` runs BEFORE the template mounts (so a context-providing
   * primitive registers before its slotted child pieces upgrade), and its
   * `disconnectedCallback` runs on teardown; `observedAttributes` are unioned
   * and `attributeChangedCallback` is forwarded to the base.
   */
  base?: typeof HTMLElement
  setup: (ctx: SetupContext & AttrContext<A> & PropsContext) => Branch | Leaf
}

Options passed to the overloaded `defineComponent` when typed `observedAttributes` + per-attribute signals are desired.

interface DefineOptions {
  shadowMode?: ShadowMode
  /** When true, connectedCallback checks window.__aihu_state__[name] and calls the injected hydrate fn. Plan 3.2. */
  hydrate?: boolean
}

interface InstanceAgentDispatcher {
  readonly tag: string
  /** opaqueId → action invoker (called with the positional args array). */
  readonly actions: Record<string, (args: unknown[]) => unknown>
  /** opaqueId → read accessor (current signal value). */
  readonly reads: Record<string, () => unknown>
  /** opaqueId → write accessor. */
  readonly writes: Record<string, (value: unknown) => void>
}

The instance-bound dispatcher shape.

interface InstanceAgentServerBinding {
  readonly tag: string
  /** memberName → action invoker (called with the positional args array). */
  readonly actions: Record<string, (args: unknown) => unknown>
  /** memberName → read accessor (current signal/computed value). */
  readonly reads: Record<string, () => unknown>
  /** memberName → write accessor (prop signal setter). */
  readonly writes: Record<string, (value: unknown) => void>
  /** `$scope` from the `@agent` block, or undefined when unscoped. */
  readonly scope: string | undefined
  /** `$rate-limit` as `'<n>/min'`, or undefined when unlimited. */
  readonly rateLimit: string | undefined
}

The full, per-instance agent binding the SERVER build injects into the setup body.

interface PropDef {
  value?: unknown
  attribute?: boolean | string
  reflect?: boolean
  converter?: (raw: string | null) => unknown
}

R1 — single `$prop` definition.

interface PropSignal {
  (): unknown
  set(v: unknown): void
}

R1 — per-prop signal handle exposed to setup.

interface ResourceHandle<T> {
  /** True while a fetch is in flight (initial load or a refetch). */
  readonly loading: boolean
  /** The latest resolved value, or `null` before the first success. */
  readonly data: T | null
  /** The error from the most recent failed run, or `null`. */
  readonly error: Error | null
  /** Re-run the factory. Resolves when the run settles. */
  refetch(): Promise<void>
}

interface SetupContext {
  readonly host: ShadowRoot | Element
  readonly element: HTMLElement
}

Context passed to a `defineComponent` setup function.

interface StreamHandle {
  readonly value: string
  readonly delta: string
  readonly status: StreamStatus
  readonly error: Error | null
  start(
    source?: ReadableStream<string> | (() => Promise<ReadableStream<string> | null>),
  ): Promise<void>
  stop(): void
}

type PropsConfig = Record<string, PropDef>

type Setup = (ctx: SetupContext) => Branch | Leaf

A `defineComponent` setup function: receives a `SetupContext`, returns the arbor tree to mount.

type ShadowMode = 'light' | 'shadow'

Rendering mode for the custom element — a BINARY choice (DA4 #437).

type StreamStatus = 'idle' | 'streaming' | 'done' | 'error'