@moku-labs/web 1.16.1 → 2.0.0

package/dist/{render-KdufA3_b.cjs → render-DHUcHCYs.cjs}

@@ -29,17 +29,17 @@ function renderVNode(vnode, region) {
 	(0, preact.render)(vnode, region);
 }
 /**
-* Commit a component's VNode into its host as a DIFF — the in-interaction render
+* Commit an island's VNode into its host as a DIFF — the in-interaction render
 * path. Unlike {@link renderVNode} (which RESETS the region: unmount → clear → mount,
 * correct for a navigation swap of static SSR markup), this is a plain Preact
 * `render(vnode, host)` that diffs against Preact's retained vdom, preserving focus,
 * scroll, and uncontrolled input state across re-renders triggered by `ctx.set`.
 *
-* Reached ONLY through the lazy `await import("./render")` gate (the component render
-* scheduler in `components.ts`), so an app whose islands never return a VNode never
+* Reached ONLY through the lazy `await import("./render")` gate (the island render
+* scheduler in `islands.ts`), so an app whose islands never return a VNode never
 * pulls Preact's `render` into its main bundle.
 *
-* @param vnode - The VNode produced by a component's `render(state, ctx)`.
+* @param vnode - The VNode produced by an island's `render(state, ctx)`.
 * @param host - The island's host element to render into.
 * @example
 * ```ts

package/dist/{render-UO4nimWr.mjs → render-yXHc9BWI.mjs}

@@ -29,17 +29,17 @@ function renderVNode(vnode, region) {
 	render(vnode, region);
 }
 /**
-* Commit a component's VNode into its host as a DIFF — the in-interaction render
+* Commit an island's VNode into its host as a DIFF — the in-interaction render
 * path. Unlike {@link renderVNode} (which RESETS the region: unmount → clear → mount,
 * correct for a navigation swap of static SSR markup), this is a plain Preact
 * `render(vnode, host)` that diffs against Preact's retained vdom, preserving focus,
 * scroll, and uncontrolled input state across re-renders triggered by `ctx.set`.
 *
-* Reached ONLY through the lazy `await import("./render")` gate (the component render
-* scheduler in `components.ts`), so an app whose islands never return a VNode never
+* Reached ONLY through the lazy `await import("./render")` gate (the island render
+* scheduler in `islands.ts`), so an app whose islands never return a VNode never
 * pulls Preact's `render` into its main bundle.
 *
-* @param vnode - The VNode produced by a component's `render(state, ctx)`.
+* @param vnode - The VNode produced by an island's `render(state, ctx)`.
 * @param host - The island's host element to render into.
 * @example
 * ```ts

package/dist/testing.d.mts

@@ -1,6 +1,6 @@
 //#region src/plugins/spa/types.d.ts
 /**
- * What a component's `render` may return:
+ * What a island's `render` may return:
  * - a Preact `VNode` — committed into the host through the lazy Preact gate (`commitVNode`);
  * - a `Node` — replaces the host's children;
  * - a `string` — set as the host's `innerHTML`;
@@ -12,30 +12,33 @@ type RenderResult = AnyVNode | Node | string | void;
  * `VNode<SomeProps>`; the props generic is invariant under `exactOptionalPropertyTypes`,
  * so the only supertype that accepts every concrete `VNode<P>` is `VNode<any>`.
  */
+/**
+ *
+ */
 type AnyVNode = import("preact").VNode<any>;
 /**
- * Factory that builds a component's typed per-instance state (mirrors a plugin's
+ * Factory that builds a island's typed per-instance state (mirrors a plugin's
  * `createState`). Called ONCE at mount; the returned object is stored on the
- * {@link ComponentInstance} and exposed read-only as `ctx.state`.
+ * {@link IslandInstance} and exposed read-only as `ctx.state`.
  *
- * @param ctx - The component context for this instance (state is not yet set).
+ * @param ctx - The island context for this instance (state is not yet set).
  * @returns The initial per-instance state.
  * @example
  * state: (ctx): BoardState => ({ boardId: ctx.params.id ?? "", cards: [] })
  */
-type ComponentStateFactory<S extends object> = (ctx: ComponentContext<S>) => S;
+type IslandStateFactory<S extends object> = (ctx: IslandContext<S>) => S;
 /**
  * Pure render of `(state, ctx)` → {@link RenderResult}. Called after mount-state-init
  * and again (microtask-batched) after every `ctx.set`. Must be free of side effects
  * beyond producing its result.
  *
  * @param state - The current per-instance state (read-only).
- * @param ctx - The component context for this instance.
+ * @param ctx - The island context for this instance.
  * @returns The render result to commit into the host.
  * @example
  * render: (state) => h(BoardView, { snapshot: state.snapshot })
  */
-type ComponentRender<S extends object> = (state: Readonly<S>, ctx: ComponentContext<S>) => RenderResult;
+type IslandRender<S extends object> = (state: Readonly<S>, ctx: IslandContext<S>) => RenderResult;
 /**
  * A delegated DOM event handler. `target` is the element matched by the key's selector
  * (already resolved via `closest` — no `instanceof`/`closest` ceremony in the body).
@@ -43,14 +46,14 @@ type ComponentRender<S extends object> = (state: Readonly<S>, ctx: ComponentCont
  * Typed `void` for ergonomics (the void-return rule accepts async handlers returning
  * `Promise<void>` too); the kernel ignores any returned value.
  *
- * @param ctx - The component context (carries the live per-instance `state`).
+ * @param ctx - The island context (carries the live per-instance `state`).
  * @param event - The raw DOM event.
  * @param target - The element matched by the selector (the host when no selector).
  * @returns void (a returned promise is ignored by the kernel).
  * @example
  * (ctx, event, button) => { event.preventDefault(); ctx.set({ open: true }); }
  */
-type ComponentEventHandler<S extends object> = (ctx: ComponentContext<S>, event: Event, target: Element) => void;
+type IslandEventHandler<S extends object> = (ctx: IslandContext<S>, event: Event, target: Element) => void;
 /**
  * Declarative delegated event map. Each key is `"<type> <selector>"` (the selector is
  * optional → a host-level listener). ONE real listener per event TYPE is attached to
@@ -63,9 +66,9 @@ type ComponentEventHandler<S extends object> = (ctx: ComponentContext<S>, event:
  *   "submit [data-add]": (ctx, e) => { e.preventDefault(); add(ctx); }
  * }
  */
-type ComponentEvents<S extends object> = Record<string, ComponentEventHandler<S>>;
+type IslandEvents<S extends object> = Record<string, IslandEventHandler<S>>;
 /**
- * Context handed to every component lifecycle hook, render, and event handler — the
+ * Context handed to every island lifecycle hook, render, and event handler — the
  * bound element + page data, plus the matched route's `params`/`meta`/`locale` and a
  * link builder, so an island can read its route context (e.g. a `card` route's
  * `ctx.meta.focus` + `ctx.params.id`) directly, without the page bridging it through
@@ -73,11 +76,11 @@ type ComponentEvents<S extends object> = Record<string, ComponentEventHandler<S>
  *
  * Generic over the per-instance state `S` (default `undefined` so every existing
  * hooks-only island still type-checks). The additive members (`state`/`set`/`flush`/
- * `cleanup`/`component`) are ALWAYS-PRESENT functions — never optional keys — so they
+ * `cleanup`/`island`) are ALWAYS-PRESENT functions — never optional keys — so they
  * never trip `exactOptionalPropertyTypes`.
  */
-interface ComponentContext<S = undefined> {
-  /** The element the component instance is bound to. */
+interface IslandContext<S = undefined> {
+  /** The element the island instance is bound to. */
   el: Element;
   /** Page data extracted from the `script#__DATA__` payload. */
   data: PageData;
@@ -126,107 +129,107 @@ interface ComponentContext<S = undefined> {
    * Resolve another island's registered `api` by name. Returns `undefined` when no
    * provider is registered (optional-dependency semantics, mirroring `ctx.has`).
    *
-   * @param name - The provider island's component name.
+   * @param name - The provider island's island name.
    * @returns The provider's api, or `undefined`.
    * @example
-   * ctx.component<LightboxApi>("lightbox")?.open(slides, index);
+   * ctx.island<LightboxApi>("lightbox")?.open(slides, index);
    */
-  component<T = unknown>(name: string): T | undefined;
+  island<T = unknown>(name: string): T | undefined;
 }
-/** Lifecycle hooks a component may implement. Generic over the per-instance state `S`. */
-interface ComponentHooks<S = undefined> {
+/** Lifecycle hooks a island may implement. Generic over the per-instance state `S`. */
+interface IslandHooks<S = undefined> {
   /**
    * Called once when the instance is created (before DOM attach).
    *
-   * @param ctx - The component context for this instance.
+   * @param ctx - The island context for this instance.
    * @returns void
    * @example
    * onCreate({ el }) { el.dataset.ready = "1"; }
    */
-  onCreate?(ctx: ComponentContext<S>): void;
+  onCreate?(ctx: IslandContext<S>): void;
   /**
    * Called after the instance is attached to its element.
    *
-   * @param ctx - The component context for this instance.
+   * @param ctx - The island context for this instance.
    * @returns void
    * @example
    * onMount({ el }) { el.textContent = "0"; }
    * @example
    * async onMount(ctx) { ctx.set({ items: await load() }); } // async is allowed; the harness awaits it via settle()
    */
-  onMount?(ctx: ComponentContext<S>): void;
+  onMount?(ctx: IslandContext<S>): void;
   /**
    * Called when a navigation begins while this instance is mounted.
    *
-   * @param ctx - The component context for this instance.
+   * @param ctx - The island context for this instance.
    * @returns void
    * @example
    * onNavStart({ el }) { el.dataset.loading = ""; }
    */
-  onNavStart?(ctx: ComponentContext<S>): void;
+  onNavStart?(ctx: IslandContext<S>): void;
   /**
    * Called when a navigation completes while this instance is mounted.
    *
-   * @param ctx - The component context for this instance.
+   * @param ctx - The island context for this instance.
    * @returns void
    * @example
    * onNavEnd({ el }) { delete el.dataset.loading; }
    */
-  onNavEnd?(ctx: ComponentContext<S>): void;
+  onNavEnd?(ctx: IslandContext<S>): void;
   /**
    * Called before the instance is detached from its element.
    *
-   * @param ctx - The component context for this instance.
+   * @param ctx - The island context for this instance.
    * @returns void
    * @example
    * onUnMount({ el }) { el.replaceChildren(); }
    */
-  onUnMount?(ctx: ComponentContext<S>): void;
+  onUnMount?(ctx: IslandContext<S>): void;
   /**
    * Called once when the instance is destroyed (after detach).
    *
-   * @param ctx - The component context for this instance.
+   * @param ctx - The island context for this instance.
    * @returns void
    * @example
    * onDestroy({ el }) { delete el.dataset.ready; }
    */
-  onDestroy?(ctx: ComponentContext<S>): void;
+  onDestroy?(ctx: IslandContext<S>): void;
 }
 /**
- * The spec extras carried on a {@link ComponentDef}, type-erased to `object` state
- * (authors keep full `S` inference at the `createComponent` call site; the registry
+ * The spec extras carried on a {@link IslandDef}, type-erased to `object` state
+ * (authors keep full `S` inference at the `createIsland` call site; the registry
  * stores the runtime-only erased form). Absent for legacy `(name, hooks)` defs.
  */
-interface ComponentSpecExtras {
+interface IslandSpecExtras {
   /** Per-instance state factory. */
-  state?: ComponentStateFactory<object>;
+  state?: IslandStateFactory<object>;
   /** Render called on mount + after every `ctx.set`. */
-  render?: ComponentRender<object>;
+  render?: IslandRender<object>;
   /** Declarative delegated events. */
-  events?: ComponentEvents<object>;
-  /** Public api factory registered under the component name. */
-  api?: (ctx: ComponentContext<object>) => unknown;
+  events?: IslandEvents<object>;
+  /** Public api factory registered under the island name. */
+  api?: (ctx: IslandContext<object>) => unknown;
 }
-/** A registered component definition (an opaque token; author inference lives on `createComponent`). */
-interface ComponentDef {
-  /** Unique component name (matched against `data-component`). */
+/** A registered island definition (an opaque token; author inference lives on `createIsland`). */
+interface IslandDef {
+  /** Unique island name (matched against `data-island`). */
   name: string;
   /** Lifecycle hooks (the subset shared with the legacy form). */
-  hooks: ComponentHooks<object>;
+  hooks: IslandHooks<object>;
   /** Plugin-mirror extras (state/render/events/api). Absent for legacy `(name, hooks)` defs. */
-  spec?: ComponentSpecExtras;
+  spec?: IslandSpecExtras;
 }
 /** The matched-route slice carried on a live instance (params/meta/locale + link builder). */
-type ComponentRouteSlice = Pick<ComponentContext, "params" | "meta" | "locale" | "url">;
+type IslandRouteSlice = Pick<IslandContext, "params" | "meta" | "locale" | "url">;
 /** Page data payload parsed from the inline `script#__DATA__` element. */
 type PageData = Record<string, unknown>;
 //#endregion
-//#region src/plugins/spa/components.d.ts
-/** The matched-route slice merged onto the component context (params/meta/locale + link builder). */
-type RouteSlice = ComponentRouteSlice;
+//#region src/plugins/spa/islands.d.ts
+/** The matched-route slice merged onto the island context (params/meta/locale + link builder). */
+type RouteSlice = IslandRouteSlice;
 //#endregion
 //#region src/testing.d.ts
-/** One captured spa emit (the kernel's `spa:component-mount` / `-unmount`). */
+/** One captured spa emit (the kernel's `spa:island-mount` / `-unmount`). */
 interface CapturedEmit {
   /** The event name. */
   readonly event: string;
@@ -301,7 +304,7 @@ interface IslandHandle<S extends object = object, A = unknown> {
    * handle.unmount();
    */
   unmount(): void;
-  /** Captured `spa:component-mount` / `-unmount` emits, in order. */
+  /** Captured `spa:island-mount` / `-unmount` emits, in order. */
   readonly emitted: ReadonlyArray<CapturedEmit>;
 }
 /** Options for {@link mountIsland}. All optional; sensible headless defaults. */
@@ -322,14 +325,14 @@ interface MountIslandOptions {
   url?: (name: string, params?: Record<string, string>) => string;
   /** Mount OUTSIDE the swap area so the instance is persistent (gets `onNavEnd`). */
   persistent?: boolean;
-  /** Stubbed sibling-island apis resolved by `ctx.component(name)`. */
-  components?: Record<string, unknown>;
+  /** Stubbed sibling-island apis resolved by `ctx.island(name)`. */
+  islands?: Record<string, unknown>;
 }
 /**
  * Mount ONE island headlessly through the REAL spa kernel internals under a DOM. The
  * unit + light-integration tier: no `createApp`, no router, no network.
  *
- * @param definition - The component definition under test (from `createComponent`).
+ * @param definition - The island definition under test (from `createIsland`).
  * @param options - Host HTML/element, route slice, page data, persistence, stub apis.
  * @returns A handle exposing the instance's `state`/`api` + event/nav/flush drivers.
  * @example
@@ -337,7 +340,7 @@ interface MountIslandOptions {
  * h.navEnd({ locale: "en" });
  * expect(h.el.querySelector("[aria-current]")).toBeTruthy();
  */
-declare function mountIsland<S extends object = object, A = unknown>(definition: ComponentDef, options?: MountIslandOptions): IslandHandle<S, A>;
+declare function mountIsland<S extends object = object, A = unknown>(definition: IslandDef, options?: MountIslandOptions): IslandHandle<S, A>;
 /** The result of {@link renderIsland} — a host plus query/flush/teardown helpers. */
 interface RenderIslandResult {
   /** The host element the view rendered into. */
@@ -381,9 +384,9 @@ interface RenderIslandResult {
  * const r = renderIsland(render, { state: { boards: [{ id: "1", title: "Alpha" }] } });
  * expect(r.find("[data-board]")).toBeTruthy();
  */
-declare function renderIsland<S extends object>(render: ComponentRender<S>, input: {
+declare function renderIsland<S extends object>(render: IslandRender<S>, input: {
   state: S;
-  ctx?: Partial<ComponentContext<S>>;
+  ctx?: Partial<IslandContext<S>>;
 }): RenderIslandResult;
 //#endregion
 export { CapturedEmit, IslandHandle, MountIslandOptions, RenderIslandResult, mountIsland, renderIsland };

package/dist/testing.mjs

@@ -2,7 +2,7 @@ import { render } from "preact";
 import { act } from "preact/test-utils";
 //#region src/plugins/spa/types.ts
 /** Allowed hook names — single source of truth for fail-fast validation. */
-const COMPONENT_HOOK_NAMES = [
+const ISLAND_HOOK_NAMES = [
 	"onCreate",
 	"onMount",
 	"onNavStart",
@@ -11,17 +11,17 @@ const COMPONENT_HOOK_NAMES = [
 	"onDestroy"
 ];
 //#endregion
-//#region src/plugins/spa/components.ts
+//#region src/plugins/spa/islands.ts
 /**
-* @file spa plugin — component lifecycle, mounting, the plugin-mirror authoring
-* surface (`createComponent` with a typed `{ state, render, events, api }` spec),
+* @file spa plugin — island lifecycle, mounting, the plugin-mirror authoring
+* surface (`createIsland` with a typed `{ state, render, events, api }` spec),
 * the per-instance state + microtask-batched render scheduler, declarative
 * delegated events, and the cross-island api registry.
 * @see README.md
 */
 /** Error prefix for spa fail-fast failures (spec/11 Part-3). */
 const ERROR_PREFIX = "[web]";
-new Set(COMPONENT_HOOK_NAMES);
+new Set(ISLAND_HOOK_NAMES);
 /** Synchronous re-entrancy cap for the render scheduler (a render that calls `ctx.flush`). */
 const MAX_RENDER_DEPTH = 25;
 /**
@@ -54,7 +54,7 @@ let renderChunk;
 let commitVNodeFunction;
 /**
 * Load the lazy `./render` chunk (once) and cache its `commitVNode` for synchronous
-* use by later renders. Awaited by a component's `mountPromise` so the test harness's
+* use by later renders. Awaited by a island's `mountPromise` so the test harness's
 * `settle()` can deterministically flush a VNode render.
 *
 * @returns A promise that resolves once `commitVNode` is available.
@@ -62,7 +62,7 @@ let commitVNodeFunction;
 * await loadRenderChunk();
 */
 async function loadRenderChunk() {
-	renderChunk ??= import("./render-UO4nimWr.mjs");
+	renderChunk ??= import("./render-yXHc9BWI.mjs");
 	commitVNodeFunction = (await renderChunk).commitVNode;
 }
 /**
@@ -71,7 +71,7 @@ async function loadRenderChunk() {
 * a Preact `VNode` → committed through the lazy gate (loading it on demand if needed).
 *
 * @param host - The island host element to render into.
-* @param result - The value returned by the component's `render`.
+* @param result - The value returned by the island's `render`.
 * @example
 * commitResult(host, h(View, { items }));
 */
@@ -93,7 +93,7 @@ function commitResult(host, result) {
 	loadRenderChunk().then(() => commitVNodeFunction?.(vnode, host)).catch(() => {});
 }
 /**
-* Run a component's `render(state, ctx)` and commit the result now. Guards against
+* Run a island's `render(state, ctx)` and commit the result now. Guards against
 * synchronous re-entrancy (a render that calls `ctx.flush`) with a depth cap.
 *
 * @param instance - The instance to render.
@@ -104,7 +104,7 @@ function commitResult(host, result) {
 function runRender(instance) {
 	const render = instance.def.spec?.render;
 	if (!render) return;
-	if (instance.renderDepth > MAX_RENDER_DEPTH) throw new Error(`${ERROR_PREFIX} component "${instance.def.name}" render re-entered ${MAX_RENDER_DEPTH}+ times\n  → a render must not synchronously trigger its own render (avoid ctx.flush() inside render)`);
+	if (instance.renderDepth > MAX_RENDER_DEPTH) throw new Error(`${ERROR_PREFIX} island "${instance.def.name}" render re-entered ${MAX_RENDER_DEPTH}+ times\n  → a render must not synchronously trigger its own render (avoid ctx.flush() inside render)`);
 	instance.renderDepth += 1;
 	try {
 		commitResult(instance.el, render(instance.state ?? {}, instance.ctx));
@@ -130,12 +130,12 @@ function scheduleRender(instance) {
 	});
 }
 /**
-* Build the single per-instance {@link ComponentContext} reused by every hook, event
+* Build the single per-instance {@link IslandContext} reused by every hook, event
 * handler, and render. Route fields (`params`/`meta`/`locale`/`url`) and `data` read
 * through the instance so a navigation update is reflected without rebuilding the ctx;
-* `state`/`set`/`flush`/`cleanup`/`component` are bound to the instance + plugin state.
+* `state`/`set`/`flush`/`cleanup`/`island` are bound to the instance + plugin state.
 *
-* @param state - The plugin state (for the cross-island `component` resolver).
+* @param state - The plugin state (for the cross-island `island` resolver).
 * @param instance - The instance the context is bound to.
 * @returns The instance-bound context.
 * @example
@@ -239,13 +239,13 @@ function buildContext(state, instance) {
 		/**
 		* Resolve another island's registered api by name (`undefined` when absent).
 		*
-		* @param name - The provider island's component name.
+		* @param name - The provider island's island name.
 		* @returns The provider's api, or `undefined`.
 		* @example
-		* ctx.component("lightbox");
+		* ctx.island("lightbox");
 		*/
-		component(name) {
-			return state.componentApis.get(name);
+		island(name) {
+			return state.islandApis.get(name);
 		}
 	};
 }
@@ -269,7 +269,7 @@ function matchTarget(host, event, selector) {
 	return matched && host.contains(matched) ? matched : void 0;
 }
 /**
-* Attach a component's declarative `events` map: one real listener per event TYPE on
+* Attach a island's declarative `events` map: one real listener per event TYPE on
 * the host (dispatch walks `closest(selector)` for each registered selector), each
 * removed via the instance's cleanup registry on destroy.
 *
@@ -286,7 +286,7 @@ function attachEvents(instance, events) {
 		const space = key.indexOf(" ");
 		const type = (space === -1 ? key : key.slice(0, space)).trim();
 		const selector = space === -1 ? "" : key.slice(space + 1).trim();
-		if (type === "") throw new Error(`${ERROR_PREFIX} component "${instance.def.name}" event key must start with an event type: "${key}"\n  → use "<type>" or "<type> <selector>" (e.g. "click [data-action]")`);
+		if (type === "") throw new Error(`${ERROR_PREFIX} island "${instance.def.name}" event key must start with an event type: "${key}"\n  → use "<type>" or "<type> <selector>" (e.g. "click [data-action]")`);
 		const list = byType.get(type) ?? [];
 		list.push({
 			selector,
@@ -360,30 +360,30 @@ function disposeInstance(state, instance) {
 	} catch {}
 	instance.cleanups.length = 0;
 	instance.renderScheduled = false;
-	if (instance.api !== void 0 && state.componentApis.get(instance.def.name) === instance.api) state.componentApis.delete(instance.def.name);
+	if (instance.api !== void 0 && state.islandApis.get(instance.def.name) === instance.api) state.islandApis.delete(instance.def.name);
 }
 /**
-* Mounts a single `data-component` element: classifies persistent vs page-specific,
+* Mounts a single `data-island` element: classifies persistent vs page-specific,
 * builds the instance + its bound context, initializes per-instance `state`, registers
 * its `api`, attaches declarative `events`, fires `onCreate` then `onMount` (capturing
 * an async `onMount` + render-chunk load as `mountPromise`), schedules the initial
-* render, records it, and emits `spa:component-mount`. No-ops if the element is already
-* mounted, has no component name, or names an unregistered component.
+* render, records it, and emits `spa:island-mount`. No-ops if the element is already
+* mounted, has no island name, or names an unregistered island.
 *
-* @param state - The plugin state (registeredComponents + instances + componentApis).
-* @param emit - The event emitter for spa:component-mount.
+* @param state - The plugin state (registeredIslands + instances + islandApis).
+* @param emit - The event emitter for spa:island-mount.
 * @param swapArea - The swap-region element, or null when none was found.
 * @param data - The current page data payload.
-* @param element - The candidate element carrying a `data-component` attribute.
+* @param element - The candidate element carrying a `data-island` attribute.
 * @param route - The matched-route slice for the current URL (params/meta/locale/url).
 * @example
 * mountElement(state, emit, swapArea, data, element, route);
 */
 function mountElement(state, emit, swapArea, data, element, route = EMPTY_ROUTE) {
 	if (state.instances.has(element)) return;
-	const name = element.dataset.component;
+	const name = element.dataset.island;
 	if (!name) return;
-	const definition = state.registeredComponents.get(name);
+	const definition = state.registeredIslands.get(name);
 	if (!definition) return;
 	const instance = {
 		def: definition,
@@ -409,7 +409,7 @@ function mountElement(state, emit, swapArea, data, element, route = EMPTY_ROUTE)
 	if (spec?.state) instance.state = spec.state(instance.ctx);
 	if (spec?.api) {
 		instance.api = spec.api(instance.ctx);
-		state.componentApis.set(definition.name, instance.api);
+		state.islandApis.set(definition.name, instance.api);
 	}
 	if (spec?.events) attachEvents(instance, spec.events);
 	runHook(instance, "onCreate");
@@ -420,20 +420,20 @@ function mountElement(state, emit, swapArea, data, element, route = EMPTY_ROUTE)
 	if (onMountResult && typeof onMountResult.then === "function") pending.push(onMountResult);
 	instance.mountPromise = pending.length > 0 ? Promise.all(pending).then(() => {}) : void 0;
 	state.instances.set(element, instance);
-	emit("spa:component-mount", {
+	emit("spa:island-mount", {
 		name: definition.name,
 		el: element
 	});
 }
 /**
-* Scans the swap region, mounts components for matching `data-component` elements,
+* Scans the swap region, mounts islands for matching `data-island` elements,
 * classifies persistent (outside swap area) vs page-specific (inside), runs
-* `onCreate`/`onMount` + initial render, and emits `spa:component-mount` per instance.
+* `onCreate`/`onMount` + initial render, and emits `spa:island-mount` per instance.
 * Already-mounted elements are skipped.
 *
-* @param state - The plugin state (registeredComponents + instances + componentApis).
-* @param emit - The event emitter for spa:component-mount.
-* @param swapSelector - CSS selector bounding page-specific components.
+* @param state - The plugin state (registeredIslands + instances + islandApis).
+* @param emit - The event emitter for spa:island-mount.
+* @param swapSelector - CSS selector bounding page-specific islands.
 * @param route - The matched-route slice for the current URL (params/meta/locale/url).
 * @example
 * scanAndMount(state, emit, "main > section", route);
@@ -442,16 +442,16 @@ function scanAndMount(state, emit, swapSelector, route = EMPTY_ROUTE) {
 	if (typeof document === "undefined") return;
 	const swapArea = document.querySelector(swapSelector);
 	const data = extractPageData(document);
-	for (const element of document.querySelectorAll("[data-component]")) mountElement(state, emit, swapArea, data, element, route);
+	for (const element of document.querySelectorAll("[data-island]")) mountElement(state, emit, swapArea, data, element, route);
 }
 /**
 * Unmounts page-specific instances inside the swap region (runs `onUnMount` then
 * `onDestroy`, then their cleanup disposers + api unregister), removes them from state,
-* and emits `spa:component-unmount`. Persistent instances (outside the swap area) are
+* and emits `spa:island-unmount`. Persistent instances (outside the swap area) are
 * left in place.
 *
 * @param state - The plugin state holding live instances.
-* @param emit - The event emitter for spa:component-unmount.
+* @param emit - The event emitter for spa:island-unmount.
 * @example
 * unmountPageSpecific(state, emit);
 */
@@ -464,7 +464,7 @@ function unmountPageSpecific(state, emit) {
 		runHook(instance, "onDestroy");
 		disposeInstance(state, instance);
 		state.instances.delete(element);
-		emit("spa:component-unmount", {
+		emit("spa:island-unmount", {
 			name: instance.def.name,
 			el: element
 		});
@@ -473,11 +473,11 @@ function unmountPageSpecific(state, emit) {
 /**
 * Disposes ALL live instances (persistent and page-specific) on teardown: runs
 * `onUnMount` then `onDestroy`, then their cleanup disposers + api unregister, emits
-* `spa:component-unmount`, and clears the instance + api maps. Used by the kernel's
+* `spa:island-unmount`, and clears the instance + api maps. Used by the kernel's
 * `dispose` on plugin stop.
 *
 * @param state - The plugin state holding live instances.
-* @param emit - The event emitter for spa:component-unmount.
+* @param emit - The event emitter for spa:island-unmount.
 * @example
 * unmountAll(state, emit);
 */
@@ -488,13 +488,13 @@ function unmountAll(state, emit) {
 		runHook(instance, "onUnMount");
 		runHook(instance, "onDestroy");
 		disposeInstance(state, instance);
-		emit("spa:component-unmount", {
+		emit("spa:island-unmount", {
 			name: instance.def.name,
 			el: element
 		});
 	}
 	state.instances.clear();
-	state.componentApis.clear();
+	state.islandApis.clear();
 }
 /**
 * Fires `onNavStart` on every currently-mounted instance (persistent instances
@@ -546,9 +546,9 @@ function notifyNavEnd(state, route = EMPTY_ROUTE) {
 */
 function createState(_ctx) {
 	return {
-		registeredComponents: /* @__PURE__ */ new Map(),
+		registeredIslands: /* @__PURE__ */ new Map(),
 		instances: /* @__PURE__ */ new Map(),
-		componentApis: /* @__PURE__ */ new Map(),
+		islandApis: /* @__PURE__ */ new Map(),
 		currentUrl: "",
 		destroyRouter: null,
 		started: false,
@@ -597,7 +597,7 @@ function parseEventSpec(spec) {
 * Mount ONE island headlessly through the REAL spa kernel internals under a DOM. The
 * unit + light-integration tier: no `createApp`, no router, no network.
 *
-* @param definition - The component definition under test (from `createComponent`).
+* @param definition - The island definition under test (from `createIsland`).
 * @param options - Host HTML/element, route slice, page data, persistence, stub apis.
 * @returns A handle exposing the instance's `state`/`api` + event/nav/flush drivers.
 * @example
@@ -610,10 +610,10 @@ function mountIsland(definition, options = {}) {
 		global: {},
 		config: {}
 	});
-	state.registeredComponents.set(definition.name, definition);
-	if (options.components) for (const [name, api] of Object.entries(options.components)) state.componentApis.set(name, api);
+	state.registeredIslands.set(definition.name, definition);
+	if (options.islands) for (const [name, api] of Object.entries(options.islands)) state.islandApis.set(name, api);
 	const host = options.el ?? document.createElement("div");
-	host.dataset.component = definition.name;
+	host.dataset.island = definition.name;
 	if (options.html !== void 0) host.innerHTML = options.html;
 	const dataScript = options.data ? `<script id="__DATA__" type="application/json">${JSON.stringify(options.data)}<\/script>` : "";
 	document.body.innerHTML = `<main><section id="__moku_swap"></section></main>${dataScript}`;
@@ -811,7 +811,7 @@ function renderIsland(render$1, input) {
 		set: noopStub,
 		flush: noopStub,
 		cleanup: noopStub,
-		component: noopStub,
+		island: noopStub,
 		...input.ctx
 	};
 	commit(host, render$1(input.state, ctx));

package/package.json

@@ -132,5 +132,5 @@
     "test:build-e2e": "bun test src/plugins/build/__tests__/e2e/",
     "test:coverage": "vitest run --project unit --project integration --coverage"
   },
-  "version": "1.16.1"
+  "version": "2.0.0"
 }