ilha 0.13.0 → 0.14.0

package/dist/types-DU46exHq.d.ts

@@ -0,0 +1,33 @@
+import "effect/Scope";
+import { AtomRegistry } from "effect/unstable/reactivity/AtomRegistry";
+import { Effect, Stream } from "effect";
+import { Atom } from "effect/unstable/reactivity";
+//#region src/types.d.ts
+type JsonText = string | number | bigint | boolean | null | undefined;
+type View = VNode | JsonText | AtomHandle<any> | Stream.Stream<View, any, any> | GeneratorFn | Component | View[] | Iterable<View>;
+declare const Fragment: unique symbol;
+type Fragment = typeof Fragment;
+interface VNode {
+  readonly $$ilha: 1;
+  readonly type: string | Fragment | ((props: Record<string, unknown>) => unknown);
+  readonly props: Record<string, unknown>;
+  readonly children: View[];
+  readonly key?: string | number;
+}
+type GeneratorFn = (this: void, ...args: any[]) => Generator<Yielded, View | void, unknown>;
+type Yielded = View | Instruction<any> | Effect.Effect<any, any, any>;
+interface Instruction<A, E = unknown> extends Iterable<Instruction<A, E>, A>, PromiseLike<A> {
+  readonly $$ilhaOp: 1;
+  readonly effect: Effect.Effect<A, E, AtomRegistry>;
+}
+type Component = (() => View | void | Promise<View | void>) | GeneratorFn;
+interface AtomHandle<A> {
+  readonly $$atom: 1;
+  readonly atom: Atom.Atom<A>;
+  (): A;
+  set(next: A): void;
+  update(f: (current: A) => A): void;
+}
+type Done<A> = (value: A) => void;
+//#endregion
+export { Instruction as a, Yielded as c, Fragment as i, Component as n, VNode as o, Done as r, View as s, AtomHandle as t };

package/dist/vnode-BZLcG8lC.d.ts

@@ -0,0 +1,20 @@
+import { i as Fragment, o as VNode, s as View } from "./types-DU46exHq.js";
+//#region src/jsx-types.d.ts
+declare namespace JSX {
+  type Element = View;
+  type ElementType = string | ((props: Record<string, unknown>) => View | Promise<View | void> | Generator<unknown, View | void, unknown>);
+  interface IntrinsicElements {
+    [tag: string]: {
+      ref?: (el: globalThis.Element | null) => void;
+      [key: string]: unknown;
+    };
+  }
+  interface ElementChildrenAttribute {
+    children: {};
+  }
+}
+//#endregion
+//#region src/vnode.d.ts
+declare function h(type: string | Fragment | ((props: Record<string, unknown>) => unknown), props: Record<string, unknown> | null | undefined, ...rest: View[]): VNode;
+//#endregion
+export { JSX as n, h as t };

package/dist/vnode-DHN2EFHi.js

@@ -0,0 +1,37 @@
+//#region src/types.ts
+const Fragment = Symbol("ilha.Fragment");
+
+//#endregion
+//#region src/vnode.ts
+function h(type, props, ...rest) {
+	const p = { ...props };
+	const fromProps = p.children;
+	delete p.children;
+	const children = flatten([...fromProps === void 0 ? [] : [fromProps], ...rest]);
+	const key = p.key;
+	delete p.key;
+	return {
+		$$ilha: 1,
+		type,
+		props: p,
+		children,
+		key
+	};
+}
+function flatten(xs) {
+	const out = [];
+	for (const x of xs) if (Array.isArray(x)) out.push(...flatten(x));
+	else out.push(x);
+	return out;
+}
+function isVNode(x) {
+	return typeof x === "object" && x !== null && x.$$ilha === 1;
+}
+function isSetupFn(x) {
+	if (typeof x !== "function") return false;
+	const n = x.constructor?.name;
+	return n === "GeneratorFunction" || n === "AsyncFunction";
+}
+
+//#endregion
+export { Fragment as i, isSetupFn as n, isVNode as r, h as t };

package/package.json

@@ -1,18 +1,15 @@
 {
   "name": "ilha",
-  "version": "0.13.0",
-  "description": "A tiny, framework-free island architecture library",
+  "version": "0.14.0",
+  "description": "Generator-first island UI on Effect",
   "keywords": [
-    "framework-free",
+    "effect",
     "frontend",
     "hydration",
     "island-architecture",
     "islands",
     "jsx",
-    "reactive",
-    "signals",
-    "ssr",
-    "web-components"
+    "ssr"
   ],
   "homepage": "https://github.com/ilhajs/ilha#readme",
   "bugs": {
@@ -42,29 +39,36 @@
     },
     "./jsx-runtime": {
       "types": "./dist/jsx-runtime.d.ts",
-      "import": "./dist/jsx-runtime.js"
+      "import": "./dist/jsx-runtime.js",
+      "default": "./src/jsx-runtime.ts"
     },
+    "./jsx-runtime.ts": "./src/jsx-runtime.ts",
     "./jsx-dev-runtime": {
       "types": "./dist/jsx-dev-runtime.d.ts",
-      "import": "./dist/jsx-dev-runtime.js"
+      "import": "./dist/jsx-dev-runtime.js",
+      "default": "./src/jsx-dev-runtime.ts"
     },
-    "./internal": {
-      "types": "./dist/internal.d.ts",
-      "import": "./dist/internal.js"
+    "./jsx-dev-runtime.ts": "./src/jsx-dev-runtime.ts",
+    "./define": {
+      "types": "./dist/define.d.ts",
+      "import": "./dist/define.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && tsdown",
+    "build": "tsdown",
     "cleanup": "rimraf dist node_modules",
     "test": "bun test"
   },
   "dependencies": {
-    "alien-signals": "3.2.1"
+    "@happy-dom/global-registrator": "^20.11.2"
   },
   "devDependencies": {
-    "zod": "^4.4.3"
+    "effect": "^4.0.0-rc.112"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.0-rc.112"
   }
 }

package/dist/index-CVOjC94p.d.ts

@@ -1,395 +0,0 @@
-//#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"];
-}
-/** Strict single-URL check — all data: URLs rejected. */
-declare function isSafeUrl(value: string): boolean;
-/** Element- and attribute-aware URL policy for rendered attributes.
- * `srcset`/`imagesrcset` validate each comma-separated candidate URL. */
-declare function isSafeUrlAttrValue(tagName: string, attrName: string, value: string): boolean;
-declare function isUrlAttributeName(name: string): boolean;
-declare function serializeStyle(value: Record<string, unknown>): string;
-declare const RAW: unique symbol;
-declare const SIGNAL_ACCESSOR: unique symbol;
-declare const ISLAND: unique symbol;
-declare const ISLAND_CALL: unique symbol;
-/** Hydration manifest mapping `${type}:${index}` event-sentinel pairs to the
- * action keys that own them. Emitted by hydratable(); lets server-owned
- * islands (whose render fn never ships to the client) reconnect their
- * interactive surface. */
-interface RawHtml {
-  [RAW]: true;
-  value: string;
-}
-/** Mapped list result — usable directly in templates; chain `.else()` for empty fallback. */
-type EachResult<TItem, TOut> = TOut[] & {
-  else<TEmpty>(fn: (items: readonly TItem[]) => TEmpty): TOut[] | TEmpty;
-  else<TEmpty>(value: TEmpty): TOut[] | TEmpty;
-};
-interface EachKeyedBuilder<TItem, TKey> {
-  as<TOut>(fn: (item: TItem, index: number, key: TKey) => TOut): EachResult<TItem, TOut>;
-}
-interface EachBuilder<TItem> {
-  key<TKey>(fn: (item: TItem, index: number) => TKey): EachKeyedBuilder<TItem, TKey>;
-  as<TOut>(fn: (item: TItem, index: number) => TOut): EachResult<TItem, TOut>;
-}
-/**
- * Svelte-style `{#each}` helper for mapping collections to rendered output
- * with an optional empty fallback.
- *
- * @example — plain list (empty → [])
- * each(items).as((item) => html`<li>${item.name}</li>`)
- *
- * @example — keyed list feeding island.key(), with empty fallback
- * each(items)
- *   .key((item) => item.id)
- *   .as((item, _i, id) => Row.key(id)({ item }))
- *   .else(() => html`<EmptyState />`)
- */
-declare function each<TItem>(items: readonly TItem[]): EachBuilder<TItem>;
-interface IslandCall {
-  [ISLAND_CALL]: true;
-  island: AnyIsland;
-  props: Record<string, unknown> | undefined;
-  key: string | undefined;
-}
-type NativeEventModifier = "abortable" | "once" | "capture" | "passive";
-interface NativeEventContext {
-  readonly signal: AbortSignal;
-}
-type NativeEventHandler<E extends Event = Event> = (event: E, context: NativeEventContext) => unknown;
-declare const SIGNAL_WRITER_TYPE: unique symbol;
-/** @internal Type-level write target carried by signal accessors. */
-interface SignalWriter<T> {
-  readonly [SIGNAL_WRITER_TYPE]?: (value: T) => void;
-}
-type PathValue<T, P extends readonly PathSegment[]> = P extends readonly [infer Head, ...infer Tail] ? Head extends keyof T ? Tail extends readonly PathSegment[] ? PathValue<T[Head], Tail> : never : unknown : T;
-interface MarkedSignalAccessor<T> extends SignalWriter<T> {
-  (): T;
-  set(value: T): void;
-  update(fn: (previous: T) => T): void;
-  select<S>(selector: (state: T) => S): MarkedSignalAccessor<S>;
-  select<const P extends readonly PathSegment[]>(...path: P): MarkedSignalAccessor<PathValue<T, P>>;
-  [SIGNAL_ACCESSOR]: true;
-}
-type PathSegment = string | number;
-declare function ilhaRaw(value: string): RawHtml;
-/**
- * Serialize a JSON-safe value into executable `<script>` content safely. `<`
- * is escaped as `\u003C`, so a value can never close the script block or open
- * the `<!--` escape hatch. Use it for script-element data:
- *
- * ```ts
- * html`<script>const d = ${json(payload)};</script>`
- * ```
- *
- * Like `raw()`, `json()` is for element *content* only — interpolating it into
- * an attribute is author error. It does not protect against values that are
- * not valid JSON (functions, symbols, undefined, cyclic objects are dropped
- * or throw, matching `JSON.stringify`).
- */
-declare function json(value: unknown): RawHtml;
-/**
- * Escape text for a `<style>` element body. `<` becomes the CSS hex escape
- * `\3C `, so the value can never close the style block or open the `<!--`
- * escape hatch while surviving CSS parsing:
- *
- * ```ts
- * html`<style>${css(cssSource)}</style>`
- * ```
- *
- * Like `raw()`, `css()` is for element *content* only — interpolating it into
- * an attribute is author error.
- */
-declare function css(value: string): RawHtml;
-declare const TEMPLATE_PARTS: unique symbol;
-interface TemplateParts {
-  [TEMPLATE_PARTS]: true;
-  values: unknown[];
-}
-type TemplateNode = {
-  kind: "fragment";
-  children: TemplateNode[];
-} | {
-  kind: "element";
-  tag: string;
-  props: Record<string, unknown>;
-  children: TemplateNode[];
-  selfClosing?: boolean;
-} | {
-  kind: "text";
-  value: string;
-} | {
-  kind: "comment";
-  value: string | TemplateParts;
-} | {
-  kind: "dynamic";
-  value: unknown;
-};
-declare function ilhaHtml(strings: TemplateStringsArray, ...values: unknown[]): RawHtml;
-type ContextSignal<T> = SignalAccessor<T>;
-declare function ilhaContextFn<T>(key: string, initial: T): ContextSignal<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;
-/** Minimal storage surface — `localStorage`, `sessionStorage`, or a custom adapter. */
-type PersistStorage = Pick<Storage, "getItem" | "setItem">;
-interface PersistOptions<T> {
-  /** Storage backend. Default: `window.localStorage`. */
-  storage?: PersistStorage;
-  /**
-   * Mirror writes from other tabs via the window `storage` event. Only active
-   * for the default `localStorage` backend. Default: `true`.
-   */
-  crossTab?: boolean;
-  /** Value → string. Default: `JSON.stringify`. */
-  serialize?: (value: T) => string;
-  /** String → value. Default: `JSON.parse` (malformed payloads are ignored). */
-  deserialize?: (raw: string) => T | null;
-}
-/**
- * Keep a standalone signal in sync with persistent storage:
- *
- * 1. On call, reads `key` and writes the stored value into the signal.
- * 2. Subscribes to the signal and writes its value back on every change.
- * 3. Optionally mirrors writes from other tabs (`storage` events).
- *
- * No-op on the server (returns an inert unsubscribe). Call the returned
- * unsubscribe to stop syncing.
- *
- * ```ts
- * const cart = signal([] as string[]);
- * persist(cart, "cart");
- * ```
- */
-declare function persist<T>(accessor: SignalAccessor<T>, key: string, options?: PersistOptions<T>): () => void;
-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;
-  set(value: T): void;
-  update(fn: (previous: T | undefined) => T | undefined): void;
-};
-type ExternalSignal<T = unknown> = SignalAccessor<T>;
-type SignalAccessor<T> = MarkedSignalAccessor<T>;
-/** Island-local reactive state returned by the state() primitive. */
-type StateAccessor<T> = MarkedSignalAccessor<T>;
-/** A function component body: receives current props, returns HTML. */
-type IslandComponent<P> = (props: P) => string | RawHtml;
-interface HydratableOptions {
-  name: string;
-  as?: string;
-  snapshot?: boolean | {
-    state?: boolean;
-    derived?: boolean;
-  };
-  skipOnMount?: boolean;
-}
-interface Island<TInput = Record<string, unknown>> {
-  (props?: Partial<TInput>): IslandCall;
-  toString(props?: Partial<TInput>): string;
-  /**
-   * Async SSR: renders the island and awaits async derived values before
-   * returning the HTML string. Always returns a Promise.
-   */
-  toStringAsync(props?: Partial<TInput>): Promise<string>;
-  mount(host: Element, props?: Partial<TInput>): () => void;
-  hydratable(props: Partial<TInput>, options: HydratableOptions): Promise<string>;
-  key(key: string): KeyedIsland<TInput>;
-  /**
-   * Register this island as a custom element, usable from plain HTML or any
-   * framework: `Counter.define("x-counter", { observe: ["label"] })` then
-   * `<x-counter label="hi"></x-counter>`. Observed attributes become string
-   * props and re-resolve on change; richer props can be assigned via the
-   * element's `props` property. Mounts on connect, unmounts on disconnect.
-   * No-op (with a dev warning) where customElements is missing.
-   */
-  define(tagName: string, options?: {
-    observe?: string[];
-  }): void;
-  [ISLAND]: true;
-}
-interface KeyedIsland<TInput> {
-  (props?: Partial<TInput>): IslandCall;
-  [ISLAND_CALL]: true;
-}
-type AnyIsland = Island<any>;
-type ActionCall<P> = [P] extends [undefined] ? () => void : unknown extends P ? () => void : (payload: P) => void;
-/** A bound action can back native events or component callback props.
- * Runtime arguments are ignored when `.with()` binds a payload. */
-type BoundActionHandler = (...runtimeArgs: unknown[]) => unknown;
-/**
- * Reactive operation with execution state. `pending`, `data`, and `error`
- * are reactive: reading them during render subscribes the island render.
- */
-type ActionAccessor<P = undefined, R = void> = ActionCall<P> & {
-  readonly pending: boolean;
-  readonly data: Awaited<R> | undefined;
-  readonly error: Error | undefined;
-  /** Bind an explicit serializable payload into an RPC-replayable action
-   * reference for server-owned islands (`onclick={remove.with(id)}`).
-   * Arguments are validated JSON-safe (≤ 8 KiB serialized) at bind time and
-   * stored in the hydration manifest — never extracted by executing code. */
-  with: (...args: unknown[]) => BoundActionHandler;
-};
-interface EffectContext {
-  /**
-   * AbortSignal that aborts when the effect re-runs (a dependency changed)
-   * or when the island unmounts. Pass to `fetch` or check `signal.aborted`
-   * after `await` boundaries to bail out of stale work.
-   */
-  signal: AbortSignal;
-}
-interface EffectOnceContext {
-  host: Element;
-  /** AbortSignal that aborts when the island unmounts. */
-  signal: AbortSignal;
-  /** True when hydration restored existing markup/state for this instance. */
-  hydrated: boolean;
-}
-type EffectFn = (ctx: EffectContext) => void | (() => void);
-type EffectOnceFn = (ctx: EffectOnceContext) => void | (() => void);
-type ErrorSource = "effect" | "once" | "event" | "action";
-/**
- * Register a global error handler invoked when any island reports an error
- * and has no local onError() handler. Returns an unsubscribe function.
- */
-declare function onUncaughtError(fn: (error: Error, source: ErrorSource) => void): () => void;
-interface ErrorContext {
-  error: Error;
-  source: ErrorSource;
-  host: Element;
-}
-interface MountOptions {
-  root?: Element;
-  lazy?: boolean;
-}
-interface MountResult {
-  unmount: () => void | Promise<void>;
-}
-/**
- * Declare island-local reactive state at this call position. The initializer
- * applies only when the instance is created — later renders reuse the same
- * underlying signal, so prop-driven initializers never reset user state.
- *
- * A function argument is treated as a lazy initializer:
- *   const count = state(() => expensiveInitialValue());
- * To store a function VALUE, pass it to `.set`:
- *   onSave.set(nextCallback);
- */
-declare function state<T>(init?: T | (() => T)): StateAccessor<T>;
-/**
- * Declare derived state at this call position: synchronous computations,
- * Promises, or async generators. Reads track their dependencies; async work
- * races latest-run-wins and aborts stale runs through `ctx.signal`.
- */
-declare function derived<V>(fn: (ctx: {
-  signal: AbortSignal;
-}) => V | Promise<V> | AsyncIterable<V>): DerivedAccessor<V>;
-/**
- * Declare a reactive operation at this call position. Use plain functions
- * for ordinary operations; action() adds pending/data/error tracking,
- * concurrent-invocation bookkeeping, and lifecycle cancellation.
- */
-declare function action<P, R>(fn: (payload: P, ctx: {
-  signal: AbortSignal;
-}) => R): ActionAccessor<P, R>;
-/**
- * Reactive side effect. Inside an island render, registers an ordered effect
- * slot that tracks signals read in the body, reruns on change, cleans up
- * before rerun and on unmount, and is client-only. Outside an island render,
- * behaves as the standalone reactive effect and returns a stop function.
- *
- * @returns Inside an island render, `void` (an effect slot is registered and
- * cleaned up automatically). At module scope, a stop function that disposes
- * the effect and runs its final cleanup. The union return type is deliberate:
- * the same call shape cannot be discriminated at the call site.
- */
-declare const effect: ((fn: EffectFn) => void | (() => void)) & {
-  once(fn: EffectOnceFn): void;
-};
-/**
- * Register an error handler slot for this island. Handlers run in
- * declaration order; state, derived values, actions, and props should be
- * accessed through lexical closure rather than the context object.
- */
-declare function onError(fn: (ctx: ErrorContext) => void): void;
-type IlhaFactory = {
-  <P>(component: IslandComponent<P>): Island<P>;
-  <P>(component: IslandComponent<P>, options: {
-    as?: string;
-  }): Island<P>;
-  <S extends StandardSchemaV1>(schema: S, component: IslandComponent<StandardSchemaV1.InferOutput<S>>): Island<StandardSchemaV1.InferOutput<S>>;
-  <S extends StandardSchemaV1>(schema: S, component: IslandComponent<StandardSchemaV1.InferOutput<S>>, options: {
-    as?: string;
-  }): Island<StandardSchemaV1.InferOutput<S>>;
-};
-declare const ilha: IlhaFactory;
-type IslandRegistry = Record<string, AnyIsland>;
-declare function mountAll(registry: IslandRegistry, options?: MountOptions): MountResult;
-/**
- * Morph an element's children toward `html`, patching in place: surviving
- * elements keep their identity, listeners, and focus (see the morph engine).
- * Falls back to an innerHTML write when the root tags don't match.
- */
-declare function morph(host: Element, html: string): void;
-declare const html: typeof ilhaHtml;
-declare const raw: typeof ilhaRaw;
-declare const mount: typeof mountAll;
-declare const context: typeof ilhaContextFn & {
-  /** Remove a context signal from the registry. Returns true if it existed. */
-  delete(key: string): boolean;
-  /** Remove all context signals from the registry (e.g. between tests). */
-  clear(): void;
-};
-//#endregion
-export { action as A, isSafeUrlAttrValue as B, PersistOptions as C, SignalWriter as D, SignalAccessor as E, each as F, onError as G, json as H, effect as I, raw as J, onUncaughtError as K, html as L, context as M, css as N, StateAccessor as O, derived as P, ilha as R, NativeEventModifier as S, RawHtml as T, morph as U, isUrlAttributeName as V, mount as W, state as X, serializeStyle as Y, untrack as Z, KeyedIsland as _, EachKeyedBuilder as a, NativeEventContext as b, EffectFn as c, ErrorContext as d, ErrorSource as f, IslandComponent as g, Island as h, EachBuilder as i, batch as j, TemplateNode as k, EffectOnceContext as l, HydratableOptions as m, DerivedAccessor as n, EachResult as o, ExternalSignal as p, persist as q, DerivedValue as r, EffectContext as s, ActionAccessor as t, EffectOnceFn as u, MountOptions as v, PersistStorage as w, NativeEventHandler as x, MountResult as y, isSafeUrl as z };

package/dist/internal.d.ts

@@ -1,77 +0,0 @@
-import { S as NativeEventModifier, T as RawHtml, k as TemplateNode, x as NativeEventHandler } from "./index-CVOjC94p.js";
-//#region src/internal.d.ts
-type ServerAction<A extends unknown[] = unknown[], R = unknown> = ((...args: A) => R) & {
-  with: (...args: unknown[]) => (...runtimeArgs: unknown[]) => unknown;
-};
-type ServerActionBinder = <A extends unknown[], R>(fn: (...args: A) => R, manifestId?: string) => ServerAction<A, R>;
-/** @internal Register core's action branding implementation. */
-declare function setServerActionBinder(binder: ServerActionBinder): void;
-/** @internal Brand an external server action for hydration-manifest replay. */
-declare function bindServerAction<A extends unknown[], R>(fn: (...args: A) => R, manifestId?: string): ServerAction<A, R>;
-/** Registry of live island mount handles keyed by host element. */
-declare const ISLAND_MOUNT_HANDLES: WeakMap<Element, {
-  unmount: () => void | Promise<void>;
-  updateProps: (props?: Record<string, unknown>) => void;
-}>;
-/** Hook a parent's mountSlots uses to mount a child island and keep a handle
- * for pushing updated props on later parent re-renders. */
-declare const ISLAND_MOUNT_INTERNAL: unique symbol;
-interface JsxEventRegistration {
-  type: string;
-  handler: NativeEventHandler;
-  modifier?: NativeEventModifier;
-}
-/**
- * Bridge between the framework-agnostic JSX runtime and the active render.
- * The core registers an implementation at module init; before that (or
- * outside an island render) event registration yields no sentinel.
- */
-interface JsxRuntimeBridge {
-  registerEvent(registration: JsxEventRegistration): number | undefined;
-  /** Compose a child-island slot marker for direct `<Island />` calls. */
-  slot(options: {
-    island: unknown;
-    props: Record<string, unknown> | undefined;
-    key: string | undefined;
-  }): RawHtml;
-}
-/** Register the core's bridge implementation. Internal — called once by ilha. */
-declare function setJsxRuntimeBridge(implementation: JsxRuntimeBridge): void;
-/** @internal Register a native event handler with the active render context. */
-declare function __ilhaJsxEvent(registration: JsxEventRegistration): number | undefined;
-/** @internal Preserve island slot composition from the JSX runtime. */
-declare function __ilhaJsxSlot(options: {
-  island: unknown;
-  props: Record<string, unknown> | undefined;
-  key: string | undefined;
-}): RawHtml;
-type TemplateRenderer = (node: TemplateNode) => RawHtml;
-/** Register the core's template→HTML renderer. Internal — called once by ilha. */
-declare function setTemplateRenderer(renderer: TemplateRenderer): void;
-/**
- * @internal Render a template IR node to RawHtml. Used by the JSX runtime so
- * elements skip the html`` string/parse round-trip.
- */
-declare function __ilhaRenderTemplate(node: TemplateNode): RawHtml;
-/** A hydration-manifest entry: sentinel key → action id or captured payload. */
-type ManifestEntry = string | {
-  k: string;
-  a: unknown[];
-};
-interface ServerManifestSerializer {
-  /**
-   * Serialize one island's event→action manifest into markup hoisted ahead of
-   * the island HTML (e.g. a `<template data-ilha-actions>` element).
-   */
-  template(manifest: Map<string, ManifestEntry>): string;
-}
-/**
- * Register the server-manifest serializer. Owned by @ilha/router — core only
- * collects manifest data and delegates all markup serialization to the
- * registered adapter (no-op until one registers).
- */
-declare function setServerManifestSerializer(serializer: ServerManifestSerializer | null): void;
-/** @internal Used by island rendering to serialize nested child manifests. */
-declare function serializeServerManifest(manifest: Map<string, ManifestEntry>): string;
-//#endregion
-export { ISLAND_MOUNT_HANDLES, ISLAND_MOUNT_INTERNAL, JsxEventRegistration, JsxRuntimeBridge, ManifestEntry, ServerAction, ServerManifestSerializer, __ilhaJsxEvent, __ilhaJsxSlot, __ilhaRenderTemplate, bindServerAction, serializeServerManifest, setJsxRuntimeBridge, setServerActionBinder, setServerManifestSerializer, setTemplateRenderer };