ilha 0.7.0 → 0.8.0

package/dist/index-Dy3wGh4z.d.ts

@@ -0,0 +1,297 @@
+//#region src/index.d.ts
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  interface Props<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: Types<Input, Output> | undefined;
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+  }
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  interface SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+  }
+  interface FailureResult {
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  interface Issue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  interface PathSegment {
+    readonly key: PropertyKey;
+  }
+  interface Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+  }
+  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+declare const RAW: unique symbol;
+declare const SIGNAL_ACCESSOR: unique symbol;
+declare const ISLAND: unique symbol;
+declare const ISLAND_CALL: unique symbol;
+/** @internal Internal hook used by a parent's mountSlots to mount a child island and
+ * retain a handle to push updated props into it on subsequent parent
+ * re-renders. Not part of the public surface. */
+declare const ISLAND_MOUNT_INTERNAL: unique symbol;
+interface RawHtml {
+  [RAW]: true;
+  value: string;
+}
+interface IslandCall {
+  [ISLAND_CALL]: true;
+  island: AnyIsland;
+  props: Record<string, unknown> | undefined;
+  key: string | undefined;
+}
+interface MarkedSignalAccessor<T> {
+  (): T;
+  (...args: [value: T]): void;
+  select<S>(selector: (state: T) => S): MarkedSignalAccessor<S>;
+  [SIGNAL_ACCESSOR]: true;
+}
+declare function ilhaRaw(value: string): RawHtml;
+declare function ilhaCss(strings: TemplateStringsArray | string, ...values: (string | number)[]): string;
+declare function ilhaHtml(strings: TemplateStringsArray, ...values: unknown[]): RawHtml;
+type ContextSignal<T> = {
+  (): T;
+  (value: T): void;
+};
+declare function ilhaContext<T>(key: string, initial: T): ContextSignal<T>;
+/**
+ * Create a free-standing reactive signal that lives outside any island.
+ * Useful for sharing state across islands without prop drilling, or for
+ * binding form inputs to module-level state via the `bind:value=${signal}`
+ * template syntax.
+ *
+ * The returned accessor is a getter when called with no arguments and a
+ * setter when called with one. Reading it inside a `.derived()`, `.effect()`,
+ * or `.render()` automatically subscribes the surrounding reactive scope —
+ * so when the signal changes, dependents re-run as if it were local state.
+ */
+declare function ilhaSignal<T>(initial: T): SignalAccessor<T>;
+/**
+ * Run `fn` with reactive tracking suspended. Reading signals inside `fn`
+ * returns their current value without subscribing the surrounding scope.
+ * Use this in effects/deriveds when you want to peek at state without
+ * causing a re-run on its changes.
+ */
+declare function untrack<T>(fn: () => T): T;
+/**
+ * Run `fn` as an atomic batch — multiple signal writes inside the callback
+ * produce a single propagation pass, so dependents (effects, deriveds,
+ * island re-renders) see the final state and run once instead of once per
+ * write. Returns whatever `fn` returns.
+ *
+ * Note: `.on()` handlers and `.effect()` runs are batched implicitly, so
+ * you only need this when triggering multiple writes from outside an
+ * island (e.g. from a top-level event listener or async callback).
+ */
+declare function batch<T>(fn: () => T): T;
+interface DerivedValue<T> {
+  loading: boolean;
+  value: T | undefined;
+  error: Error | undefined;
+}
+type DerivedAccessor<T> = {
+  readonly loading: boolean;
+  readonly value: T | undefined;
+  readonly error: Error | undefined;
+  (): T | undefined;
+  (value: T): void;
+};
+type DerivedFnContext<TInput, TStateMap extends Record<string, unknown>> = {
+  state: IslandState<TStateMap>;
+  input: TInput;
+  signal: AbortSignal;
+};
+type DerivedFn<TInput, TStateMap extends Record<string, unknown>, V> = (ctx: DerivedFnContext<TInput, TStateMap>) => V | Promise<V>;
+interface DerivedEntry<TInput, TStateMap extends Record<string, unknown>> {
+  key: string;
+  fn: DerivedFn<TInput, TStateMap, unknown>;
+}
+type IslandDerived<TDerivedMap extends Record<string, unknown>> = { readonly [K in keyof TDerivedMap]: DerivedAccessor<TDerivedMap[K]> };
+type ExternalSignal<T = unknown> = SignalAccessor<T>;
+type SignalAccessor<T> = MarkedSignalAccessor<T>;
+type MergeState<TStateMap extends Record<string, unknown>, K extends string, V> = Omit<TStateMap, K> & Record<K, V>;
+type IslandState<TStateMap extends Record<string, unknown>> = { readonly [K in keyof TStateMap]-?: SignalAccessor<TStateMap[K]> };
+interface HydratableOptions {
+  name: string;
+  as?: string;
+  snapshot?: boolean | {
+    state?: boolean;
+    derived?: boolean;
+  };
+  skipOnMount?: boolean;
+}
+interface Island<TInput = Record<string, unknown>, _TStateMap extends Record<string, unknown> = Record<string, unknown>> {
+  (props?: Partial<TInput>): string | Promise<string>;
+  toString(props?: Partial<TInput>): string;
+  mount(host: Element, props?: Partial<TInput>): () => void;
+  hydratable(props: Partial<TInput>, options: HydratableOptions): Promise<string>;
+  key(key: string): KeyedIsland<TInput>;
+  [ISLAND]: true;
+}
+interface KeyedIsland<TInput> {
+  (props?: Partial<TInput>): IslandCall;
+  [ISLAND_CALL]: true;
+}
+type AnyIsland = Island<any, any>;
+type RenderContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> = {
+  state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
+  input: TInput;
+};
+type EffectContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
+  state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
+  input: TInput;
+  host: Element;
+  /**
+   * AbortSignal that aborts when the effect re-runs (because a dependency
+   * changed) or when the island unmounts. Pass to `fetch` or check
+   * `signal.aborted` after `await` boundaries to bail out of stale work
+   * without needing a manual cleanup function.
+   */
+  signal: AbortSignal;
+};
+type OnMountContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
+  state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
+  input: TInput;
+  host: Element;
+  hydrated: boolean;
+};
+type HandlerContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
+  state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
+  input: TInput;
+  host: Element;
+  target: Element;
+  event: Event;
+  /**
+   * AbortSignal that fires when the island unmounts. If the handler's selector
+   * was registered with the `:abortable` modifier, the signal is also aborted
+   * when the same listener fires again on the same target (giving you free
+   * race-cancellation for things like search-as-you-type fetches). Pass this
+   * to `fetch`, `AbortController`-aware APIs, or check `signal.aborted`
+   * after `await` boundaries to bail out of stale work.
+   */
+  signal: AbortSignal;
+};
+type HTMLEventFor<E extends string> = E extends keyof HTMLElementEventMap ? HTMLElementEventMap[E] : Event;
+type HTMLTargetFor<E extends string> = E extends keyof HTMLElementEventMap ? NonNullable<HTMLElementEventMap[E]["target"]> extends Element ? NonNullable<HTMLElementEventMap[E]["target"]> : Element : Element;
+type HandlerContextFor<TInput, TStateMap extends Record<string, unknown>, TEventName extends string, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
+  state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
+  input: TInput;
+  host: Element;
+  target: HTMLTargetFor<TEventName>;
+  event: HTMLEventFor<TEventName>;
+  /**
+   * AbortSignal that fires when the island unmounts. If the handler's selector
+   * was registered with the `:abortable` modifier, the signal is also aborted
+   * when the same listener fires again on the same target.
+   */
+  signal: AbortSignal;
+};
+type StateInit<TInput, V> = V | ((input: TInput) => V);
+interface StateEntry<TInput> {
+  key: string;
+  init: StateInit<TInput, unknown>;
+}
+interface OnEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> {
+  selector: string;
+  event: string;
+  options: AddEventListenerOptions;
+  abortable: boolean;
+  handler: (ctx: HandlerContext<TInput, TStateMap, TDerivedMap>) => void | Promise<void>;
+}
+interface EffectEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
+  fn: (ctx: EffectContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void;
+}
+/** Where the error originated. `"on"` covers sync throws and async rejections
+ *  from `.on()` handlers; `"effect"` covers sync throws from `.effect()` runs
+ *  (async work spawned inside an effect is not awaited by the runtime). */
+type ErrorSource = "on" | "effect";
+type ErrorContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
+  error: Error;
+  source: ErrorSource;
+  state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
+  input: TInput;
+  host: Element;
+};
+interface OnErrorEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
+  fn: (ctx: ErrorContext<TInput, TStateMap, TDerivedMap>) => void;
+}
+interface OnMountEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
+  fn: (ctx: OnMountContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void;
+}
+interface TransitionOptions {
+  enter?: (host: Element) => Promise<void> | void;
+  leave?: (host: Element) => Promise<void> | void;
+}
+interface MountOptions {
+  root?: Element;
+  lazy?: boolean;
+}
+interface MountResult {
+  unmount: () => void | Promise<void>;
+}
+interface BuilderConfig<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
+  schema: StandardSchemaV1 | null;
+  states: StateEntry<TInput>[];
+  deriveds: DerivedEntry<TInput, TStateMap>[];
+  ons: OnEntry<TInput, TStateMap, TDerivedMap>[];
+  effects: EffectEntry<TInput, TStateMap, TDerivedMap>[];
+  onMounts: OnMountEntry<TInput, TStateMap, TDerivedMap>[];
+  onErrors: OnErrorEntry<TInput, TStateMap, TDerivedMap>[];
+  transition: TransitionOptions | null;
+  css: string | null;
+  /** Slot wrapper tag when this island is embedded in a parent (default div). */
+  as: string | null;
+}
+declare class IlhaBuilder<TInput extends Record<string, unknown>, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> {
+  readonly _cfg: BuilderConfig<TInput, TStateMap, TDerivedMap>;
+  constructor(cfg: BuilderConfig<TInput, TStateMap, TDerivedMap>);
+  input<T extends Record<string, unknown>>(): IlhaBuilder<T, Record<never, never>, Record<never, never>>;
+  input<S extends StandardSchemaV1>(schema: S): IlhaBuilder<StandardSchemaV1.InferOutput<S> & Record<string, unknown>, Record<never, never>, Record<never, never>>;
+  as<Tag extends string>(tag: Tag): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
+  state<V = undefined, K extends string = string>(key: K, init?: StateInit<TInput, V> | undefined): IlhaBuilder<TInput, MergeState<TStateMap, K, V>, TDerivedMap>;
+  derived<K extends string, V>(key: K, fn: DerivedFn<TInput, TStateMap, V>): IlhaBuilder<TInput, TStateMap, TDerivedMap & Record<K, V>>;
+  on<S extends string>(selectorOrCombined: S, handler: (ctx: S extends `${string}@${infer E}:${string}` ? HandlerContextFor<TInput, TStateMap, E, TDerivedMap> : S extends `${string}@${infer E}` ? HandlerContextFor<TInput, TStateMap, E, TDerivedMap> : HandlerContext<TInput, TStateMap, TDerivedMap>) => void | Promise<void>): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
+  effect(fn: (ctx: EffectContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
+  onMount(fn: (ctx: OnMountContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
+  onError(fn: (ctx: ErrorContext<TInput, TStateMap, TDerivedMap>) => void): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
+  transition(opts: TransitionOptions): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
+  css(strings: TemplateStringsArray | string, ...values: (string | number)[]): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
+  render(fn: (ctx: RenderContext<TInput, TStateMap, TDerivedMap>) => string | RawHtml): Island<TInput, TStateMap>;
+}
+declare function ilhaFrom<TInput, TStateMap extends Record<string, unknown>>(selector: string | Element, island: Island<TInput, TStateMap>, props?: Partial<TInput>): (() => void) | null;
+type IslandRegistry = Record<string, AnyIsland>;
+declare function mountAll(registry: IslandRegistry, options?: MountOptions): MountResult;
+declare const ilha: IlhaBuilder<Record<string, unknown>, Record<never, never>, Record<never, never>> & {
+  html: typeof ilhaHtml;
+  raw: typeof ilhaRaw;
+  mount: typeof mountAll;
+  from: typeof ilhaFrom;
+  context: typeof ilhaContext;
+  signal: typeof ilhaSignal;
+  batch: typeof batch;
+  untrack: typeof untrack;
+};
+/** @internal Used by the separate JSX runtime entry to preserve island slot composition. */
+declare function __ilhaJsxSlot(island: unknown, props: Record<string, unknown> | undefined, key: string | undefined): RawHtml;
+declare const html: typeof ilhaHtml;
+declare const raw: typeof ilhaRaw;
+declare const css: typeof ilhaCss;
+declare const mount: typeof mountAll;
+declare const from: typeof ilhaFrom;
+declare const context: typeof ilhaContext;
+//#endregion
+export { untrack as A, css as C, ilhaSignal as D, ilha as E, mount as O, context as S, html as T, OnMountContext as _, ErrorSource as a, __ilhaJsxSlot as b, HandlerContextFor as c, Island as d, IslandDerived as f, MountResult as g, MountOptions as h, ErrorContext as i, raw as k, HydratableOptions as l, KeyedIsland as m, DerivedValue as n, ExternalSignal as o, IslandState as p, EffectContext as r, HandlerContext as s, DerivedAccessor as t, ISLAND_MOUNT_INTERNAL as u, RawHtml as v, from as w, batch as x, SignalAccessor as y };

package/dist/index.d.ts

@@ -1,308 +1,2 @@
-//#region src/index.d.ts
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-  interface Props<Input = unknown, Output = Input> {
-    readonly version: 1;
-    readonly vendor: string;
-    readonly types?: Types<Input, Output> | undefined;
-    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-  }
-  type Result<Output> = SuccessResult<Output> | FailureResult;
-  interface SuccessResult<Output> {
-    readonly value: Output;
-    readonly issues?: undefined;
-  }
-  interface FailureResult {
-    readonly issues: ReadonlyArray<Issue>;
-  }
-  interface Issue {
-    readonly message: string;
-    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-  }
-  interface PathSegment {
-    readonly key: PropertyKey;
-  }
-  interface Types<Input = unknown, Output = Input> {
-    readonly input: Input;
-    readonly output: Output;
-  }
-  type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}
-declare const RAW: unique symbol;
-declare const SIGNAL_ACCESSOR: unique symbol;
-declare const ISLAND: unique symbol;
-declare const ISLAND_CALL: unique symbol;
-/** @internal Internal hook used by a parent's mountSlots to mount a child island and
- * retain a handle to push updated props into it on subsequent parent
- * re-renders. Not part of the public surface. */
-declare const ISLAND_MOUNT_INTERNAL: unique symbol;
-interface RawHtml {
-  [RAW]: true;
-  value: string;
-}
-interface IslandCall {
-  [ISLAND_CALL]: true;
-  island: AnyIsland;
-  props: Record<string, unknown> | undefined;
-  key: string | undefined;
-}
-interface MarkedSignalAccessor<T> {
-  (): T;
-  (...args: [value: T]): void;
-  select<S>(selector: (state: T) => S): MarkedSignalAccessor<S>;
-  [SIGNAL_ACCESSOR]: true;
-}
-declare function ilhaRaw(value: string): RawHtml;
-declare function ilhaCss(strings: TemplateStringsArray | string, ...values: (string | number)[]): string;
-type JsxChild = unknown;
-type JsxProps = Record<string, unknown> | null | undefined;
-type JsxType = string | ((props: Record<string, unknown>) => unknown);
-declare function ilhaJsx(type: JsxType, props: JsxProps, maybeKey?: JsxChild | string | number, ...restChildren: JsxChild[]): RawHtml;
-declare function ilhaFragment(props: {
-  children?: JsxChild;
-} | null, ...children: JsxChild[]): RawHtml;
-declare function ilhaJsxDEV(type: JsxType, props: JsxProps, maybeKey?: string | number, _source?: unknown, _self?: unknown): RawHtml;
-declare function ilhaHtml(strings: TemplateStringsArray, ...values: unknown[]): RawHtml;
-type ContextSignal<T> = {
-  (): T;
-  (value: T): void;
-};
-declare function ilhaContext<T>(key: string, initial: T): ContextSignal<T>;
-/**
- * Create a free-standing reactive signal that lives outside any island.
- * Useful for sharing state across islands without prop drilling, or for
- * binding form inputs to module-level state via the `bind:value=${signal}`
- * template syntax.
- *
- * The returned accessor is a getter when called with no arguments and a
- * setter when called with one. Reading it inside a `.derived()`, `.effect()`,
- * or `.render()` automatically subscribes the surrounding reactive scope —
- * so when the signal changes, dependents re-run as if it were local state.
- */
-declare function ilhaSignal<T>(initial: T): SignalAccessor<T>;
-/**
- * Run `fn` with reactive tracking suspended. Reading signals inside `fn`
- * returns their current value without subscribing the surrounding scope.
- * Use this in effects/deriveds when you want to peek at state without
- * causing a re-run on its changes.
- */
-declare function untrack<T>(fn: () => T): T;
-/**
- * Run `fn` as an atomic batch — multiple signal writes inside the callback
- * produce a single propagation pass, so dependents (effects, deriveds,
- * island re-renders) see the final state and run once instead of once per
- * write. Returns whatever `fn` returns.
- *
- * Note: `.on()` handlers and `.effect()` runs are batched implicitly, so
- * you only need this when triggering multiple writes from outside an
- * island (e.g. from a top-level event listener or async callback).
- */
-declare function batch<T>(fn: () => T): T;
-interface DerivedValue<T> {
-  loading: boolean;
-  value: T | undefined;
-  error: Error | undefined;
-}
-type DerivedAccessor<T> = {
-  readonly loading: boolean;
-  readonly value: T | undefined;
-  readonly error: Error | undefined;
-  (): T | undefined;
-  (value: T): void;
-};
-type DerivedFnContext<TInput, TStateMap extends Record<string, unknown>> = {
-  state: IslandState<TStateMap>;
-  input: TInput;
-  signal: AbortSignal;
-};
-type DerivedFn<TInput, TStateMap extends Record<string, unknown>, V> = (ctx: DerivedFnContext<TInput, TStateMap>) => V | Promise<V>;
-interface DerivedEntry<TInput, TStateMap extends Record<string, unknown>> {
-  key: string;
-  fn: DerivedFn<TInput, TStateMap, unknown>;
-}
-type IslandDerived<TDerivedMap extends Record<string, unknown>> = { readonly [K in keyof TDerivedMap]: DerivedAccessor<TDerivedMap[K]> };
-type ExternalSignal<T = unknown> = SignalAccessor<T>;
-type SignalAccessor<T> = MarkedSignalAccessor<T>;
-type MergeState<TStateMap extends Record<string, unknown>, K extends string, V> = Omit<TStateMap, K> & Record<K, V>;
-type IslandState<TStateMap extends Record<string, unknown>> = { readonly [K in keyof TStateMap]-?: SignalAccessor<TStateMap[K]> };
-interface HydratableOptions {
-  name: string;
-  as?: string;
-  snapshot?: boolean | {
-    state?: boolean;
-    derived?: boolean;
-  };
-  skipOnMount?: boolean;
-}
-interface Island<TInput = Record<string, unknown>, _TStateMap extends Record<string, unknown> = Record<string, unknown>> {
-  (props?: Partial<TInput>): string | Promise<string>;
-  toString(props?: Partial<TInput>): string;
-  mount(host: Element, props?: Partial<TInput>): () => void;
-  hydratable(props: Partial<TInput>, options: HydratableOptions): Promise<string>;
-  key(key: string): KeyedIsland<TInput>;
-  [ISLAND]: true;
-}
-interface KeyedIsland<TInput> {
-  (props?: Partial<TInput>): IslandCall;
-  [ISLAND_CALL]: true;
-}
-type AnyIsland = Island<any, any>;
-type RenderContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> = {
-  state: IslandState<TStateMap>;
-  derived: IslandDerived<TDerivedMap>;
-  input: TInput;
-};
-type EffectContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
-  state: IslandState<TStateMap>;
-  derived: IslandDerived<TDerivedMap>;
-  input: TInput;
-  host: Element;
-  /**
-   * AbortSignal that aborts when the effect re-runs (because a dependency
-   * changed) or when the island unmounts. Pass to `fetch` or check
-   * `signal.aborted` after `await` boundaries to bail out of stale work
-   * without needing a manual cleanup function.
-   */
-  signal: AbortSignal;
-};
-type OnMountContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
-  state: IslandState<TStateMap>;
-  derived: IslandDerived<TDerivedMap>;
-  input: TInput;
-  host: Element;
-  hydrated: boolean;
-};
-type HandlerContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
-  state: IslandState<TStateMap>;
-  derived: IslandDerived<TDerivedMap>;
-  input: TInput;
-  host: Element;
-  target: Element;
-  event: Event;
-  /**
-   * AbortSignal that fires when the island unmounts. If the handler's selector
-   * was registered with the `:abortable` modifier, the signal is also aborted
-   * when the same listener fires again on the same target (giving you free
-   * race-cancellation for things like search-as-you-type fetches). Pass this
-   * to `fetch`, `AbortController`-aware APIs, or check `signal.aborted`
-   * after `await` boundaries to bail out of stale work.
-   */
-  signal: AbortSignal;
-};
-type HTMLEventFor<E extends string> = E extends keyof HTMLElementEventMap ? HTMLElementEventMap[E] : Event;
-type HTMLTargetFor<E extends string> = E extends keyof HTMLElementEventMap ? NonNullable<HTMLElementEventMap[E]["target"]> extends Element ? NonNullable<HTMLElementEventMap[E]["target"]> : Element : Element;
-type HandlerContextFor<TInput, TStateMap extends Record<string, unknown>, TEventName extends string, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
-  state: IslandState<TStateMap>;
-  derived: IslandDerived<TDerivedMap>;
-  input: TInput;
-  host: Element;
-  target: HTMLTargetFor<TEventName>;
-  event: HTMLEventFor<TEventName>;
-  /**
-   * AbortSignal that fires when the island unmounts. If the handler's selector
-   * was registered with the `:abortable` modifier, the signal is also aborted
-   * when the same listener fires again on the same target.
-   */
-  signal: AbortSignal;
-};
-type StateInit<TInput, V> = V | ((input: TInput) => V);
-interface StateEntry<TInput> {
-  key: string;
-  init: StateInit<TInput, unknown>;
-}
-interface OnEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> {
-  selector: string;
-  event: string;
-  options: AddEventListenerOptions;
-  abortable: boolean;
-  handler: (ctx: HandlerContext<TInput, TStateMap, TDerivedMap>) => void | Promise<void>;
-}
-interface EffectEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
-  fn: (ctx: EffectContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void;
-}
-/** Where the error originated. `"on"` covers sync throws and async rejections
- *  from `.on()` handlers; `"effect"` covers sync throws from `.effect()` runs
- *  (async work spawned inside an effect is not awaited by the runtime). */
-type ErrorSource = "on" | "effect";
-type ErrorContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> = {
-  error: Error;
-  source: ErrorSource;
-  state: IslandState<TStateMap>;
-  derived: IslandDerived<TDerivedMap>;
-  input: TInput;
-  host: Element;
-};
-interface OnErrorEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
-  fn: (ctx: ErrorContext<TInput, TStateMap, TDerivedMap>) => void;
-}
-interface OnMountEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
-  fn: (ctx: OnMountContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void;
-}
-interface TransitionOptions {
-  enter?: (host: Element) => Promise<void> | void;
-  leave?: (host: Element) => Promise<void> | void;
-}
-interface MountOptions {
-  root?: Element;
-  lazy?: boolean;
-}
-interface MountResult {
-  unmount: () => void | Promise<void>;
-}
-interface BuilderConfig<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
-  schema: StandardSchemaV1 | null;
-  states: StateEntry<TInput>[];
-  deriveds: DerivedEntry<TInput, TStateMap>[];
-  ons: OnEntry<TInput, TStateMap, TDerivedMap>[];
-  effects: EffectEntry<TInput, TStateMap, TDerivedMap>[];
-  onMounts: OnMountEntry<TInput, TStateMap, TDerivedMap>[];
-  onErrors: OnErrorEntry<TInput, TStateMap, TDerivedMap>[];
-  transition: TransitionOptions | null;
-  css: string | null;
-}
-declare class IlhaBuilder<TInput extends Record<string, unknown>, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<never, never>> {
-  readonly _cfg: BuilderConfig<TInput, TStateMap, TDerivedMap>;
-  constructor(cfg: BuilderConfig<TInput, TStateMap, TDerivedMap>);
-  input<T extends Record<string, unknown>>(): IlhaBuilder<T, Record<never, never>, Record<never, never>>;
-  input<S extends StandardSchemaV1>(schema: S): IlhaBuilder<StandardSchemaV1.InferOutput<S> & Record<string, unknown>, Record<never, never>, Record<never, never>>;
-  state<V = undefined, K extends string = string>(key: K, init?: StateInit<TInput, V> | undefined): IlhaBuilder<TInput, MergeState<TStateMap, K, V>, TDerivedMap>;
-  derived<K extends string, V>(key: K, fn: DerivedFn<TInput, TStateMap, V>): IlhaBuilder<TInput, TStateMap, TDerivedMap & Record<K, V>>;
-  on<S extends string>(selectorOrCombined: S, handler: (ctx: S extends `${string}@${infer E}:${string}` ? HandlerContextFor<TInput, TStateMap, E, TDerivedMap> : S extends `${string}@${infer E}` ? HandlerContextFor<TInput, TStateMap, E, TDerivedMap> : HandlerContext<TInput, TStateMap, TDerivedMap>) => void | Promise<void>): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
-  effect(fn: (ctx: EffectContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
-  onMount(fn: (ctx: OnMountContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
-  onError(fn: (ctx: ErrorContext<TInput, TStateMap, TDerivedMap>) => void): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
-  transition(opts: TransitionOptions): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
-  css(strings: TemplateStringsArray | string, ...values: (string | number)[]): IlhaBuilder<TInput, TStateMap, TDerivedMap>;
-  render(fn: (ctx: RenderContext<TInput, TStateMap, TDerivedMap>) => string | RawHtml): Island<TInput, TStateMap>;
-}
-declare function ilhaFrom<TInput, TStateMap extends Record<string, unknown>>(selector: string | Element, island: Island<TInput, TStateMap>, props?: Partial<TInput>): (() => void) | null;
-type IslandRegistry = Record<string, AnyIsland>;
-declare function mountAll(registry: IslandRegistry, options?: MountOptions): MountResult;
-declare const ilha: IlhaBuilder<Record<string, unknown>, Record<never, never>, Record<never, never>> & {
-  html: typeof ilhaHtml;
-  raw: typeof ilhaRaw;
-  jsx: typeof ilhaJsx;
-  jsxs: typeof ilhaJsx;
-  jsxDEV: typeof ilhaJsxDEV;
-  Fragment: typeof ilhaFragment;
-  mount: typeof mountAll;
-  from: typeof ilhaFrom;
-  context: typeof ilhaContext;
-  signal: typeof ilhaSignal;
-  batch: typeof batch;
-  untrack: typeof untrack;
-};
-declare const html: typeof ilhaHtml;
-declare const raw: typeof ilhaRaw;
-declare const jsx: typeof ilhaJsx;
-declare const jsxs: typeof ilhaJsx;
-declare const jsxDEV: typeof ilhaJsxDEV;
-declare const Fragment: typeof ilhaFragment;
-declare const css: typeof ilhaCss;
-declare const mount: typeof mountAll;
-declare const from: typeof ilhaFrom;
-declare const context: typeof ilhaContext;
-//#endregion
-export { DerivedAccessor, DerivedValue, EffectContext, ErrorContext, ErrorSource, ExternalSignal, Fragment, HandlerContext, HandlerContextFor, HydratableOptions, ISLAND_MOUNT_INTERNAL, Island, IslandDerived, IslandState, KeyedIsland, MountOptions, MountResult, OnMountContext, RawHtml, SignalAccessor, batch, context, css, ilha as default, from, html, ilhaSignal, ilhaSignal as signal, jsx, jsxDEV, jsxs, mount, raw, untrack };
+import { A as untrack, C as css, D as ilhaSignal, E as ilha, O as mount, S as context, T as html, _ as OnMountContext, a as ErrorSource, b as __ilhaJsxSlot, c as HandlerContextFor, d as Island, f as IslandDerived, g as MountResult, h as MountOptions, i as ErrorContext, k as raw, l as HydratableOptions, m as KeyedIsland, n as DerivedValue, o as ExternalSignal, p as IslandState, r as EffectContext, s as HandlerContext, t as DerivedAccessor, u as ISLAND_MOUNT_INTERNAL, v as RawHtml, w as from, x as batch, y as SignalAccessor } from "./index-Dy3wGh4z.js";
+export { DerivedAccessor, DerivedValue, EffectContext, ErrorContext, ErrorSource, ExternalSignal, HandlerContext, HandlerContextFor, HydratableOptions, ISLAND_MOUNT_INTERNAL, Island, IslandDerived, IslandState, KeyedIsland, MountOptions, MountResult, OnMountContext, RawHtml, SignalAccessor, __ilhaJsxSlot, batch, context, css, ilha as default, from, html, ilhaSignal, ilhaSignal as signal, mount, raw, untrack };