@ox-content/islands 2.90.0 → 3.0.0-alpha.2

package/dist/index.d.mts

@@ -1,2 +1,17 @@
 import { a as HydrateFunction, c as IslandController, i as ComponentRegistry, l as IslandInstance, n as initIslands, o as InitIslandsOptions, r as isIslandsSupported, s as IslandConfig, t as createDeferredInit, u as LoadStrategy } from "./runtime.mjs";
-export { type ComponentRegistry, type HydrateFunction, type InitIslandsOptions, type IslandConfig, type IslandController, type IslandInstance, type LoadStrategy, createDeferredInit, initIslands, isIslandsSupported };
+//#region src/payload.d.ts
+/**
+ * Flatten the Rust MDX island payload (`{ props, expressions, spreads }`)
+ * into the literal props object hydrate functions expect. Legacy flat
+ * `data-ox-props` objects from the Markdown regex path are returned as-is.
+ */
+declare function unwrapIslandProps(parsed: unknown): Record<string, unknown>;
+/**
+ * Slot markup for an island: `data-ox-content` when the regex path set it,
+ * otherwise inner HTML with the Rust JSON payload script stripped.
+ */
+declare function stripIslandPayloadScript(innerHTML: string): string;
+declare function readIslandSlotHtml(element: Pick<HTMLElement, "dataset" | "innerHTML">): string;
+//#endregion
+export { type ComponentRegistry, type HydrateFunction, type InitIslandsOptions, type IslandConfig, type IslandController, type IslandInstance, type LoadStrategy, createDeferredInit, initIslands, isIslandsSupported, readIslandSlotHtml, stripIslandPayloadScript, unwrapIslandProps };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/payload.ts"],"mappings":";;;;;;;iBAQgB,kBAAkB,kBAAkB;;;;;iBAwBpC,yBAAyB;iBAIzB,mBAAmB,SAAS,KAAK"}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { createDeferredInit, initIslands, isIslandsSupported } from "./runtime.mjs";
-export { createDeferredInit, initIslands, isIslandsSupported };
+import { a as stripIslandPayloadScript, i as readIslandSlotHtml, n as initIslands, o as unwrapIslandProps, r as isIslandsSupported, t as createDeferredInit } from "./runtime2.mjs";
+export { createDeferredInit, initIslands, isIslandsSupported, readIslandSlotHtml, stripIslandPayloadScript, unwrapIslandProps };

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/types.ts","../src/runtime.ts"],"mappings":";;;;;;;;;;;;;;KAcY;;;;UAKK;;EAEf;;EAEA;;EAEA,MAAM;;EAEN;;EAEA,OAAO;;;;;;;;KASG,mBACV,SAAS,aACT,OAAO;;;;KAMG,oBAAoB,YAAY;;;;UAK3B;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,kBAAkB,SAAS,aAAa,QAAQ;;EAEhD,gBAAgB,SAAS,aAAa,QAAQ;;EAE9C,kBAAkB,SAAS,aAAa,QAAQ,cAAc,OAAO;;;;;UAMtD;EACf,SAAS;EACT,QAAQ;EACR;EACA;;;;;UAMe;;EAEf,WAAW;;EAEX,UAAU,SAAS;;EAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC+Fc,YACd,SAAS,iBACT,UAAU,qBACT;;;;;;;;;;;;;;;;;;;iBAyJa,mBACd,UAAU,sBACR,SAAS,oBAAoB;;;;iBAOjB"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/types.ts","../src/runtime.ts"],"mappings":";;;;;;;;;;;;;;KAcY;;;;UAKK;;EAEf;;EAEA;;EAEA,MAAM;;EAEN;;EAEA,OAAO;;;;;;;;KASG,mBACV,SAAS,aACT,OAAO;;;;KAMG,oBAAoB,YAAY;;;;UAK3B;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,kBAAkB,SAAS,aAAa,QAAQ;;EAEhD,gBAAgB,SAAS,aAAa,QAAQ;;EAE9C,kBAAkB,SAAS,aAAa,QAAQ,cAAc,OAAO;;;;;UAMtD;EACf,SAAS;EACT,QAAQ;EACR;EACA;;;;;UAMe;;EAEf,WAAW;;EAEX,UAAU,SAAS;;EAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCgGc,YACd,SAAS,iBACT,UAAU,qBACT;;;;;;;;;;;;;;;;;;;iBAyJa,mBACd,UAAU,sBACR,SAAS,oBAAoB;;;;iBAOjB"}

package/dist/runtime.mjs

@@ -1,261 +1,2 @@
-//#region src/runtime.ts
-const defaultOptions = {
-	rootMargin: "200px",
-	threshold: 0,
-	idleTimeout: 200,
-	selector: "[data-ox-island]"
-};
-/**
-* Parse island configuration from element attributes.
-*/
-function parseIslandConfig(element) {
-	const component = element.dataset.oxIsland || "";
-	const load = element.dataset.oxLoad || "eager";
-	const mediaQuery = element.dataset.oxMedia;
-	let props = {};
-	try {
-		const propsJson = element.dataset.oxProps;
-		if (propsJson) props = JSON.parse(propsJson);
-	} catch (e) {
-		console.warn("[ox-islands] Failed to parse props for", element, e);
-	}
-	return {
-		id: element.id || `island-${Math.random().toString(36).slice(2, 9)}`,
-		component,
-		load,
-		mediaQuery,
-		props
-	};
-}
-/**
-* Observe element visibility using IntersectionObserver.
-*/
-function observeVisibility(element, callback, options) {
-	const observer = new IntersectionObserver((entries) => {
-		if (entries[0].isIntersecting) {
-			observer.disconnect();
-			callback();
-		}
-	}, {
-		rootMargin: options.rootMargin,
-		threshold: options.threshold
-	});
-	observer.observe(element);
-	return () => observer.disconnect();
-}
-/**
-* Observe media query changes.
-*/
-function observeMedia(query, callback) {
-	const mql = matchMedia(query);
-	if (mql.matches) {
-		callback();
-		return () => {};
-	}
-	const handler = () => {
-		if (mql.matches) {
-			mql.removeEventListener("change", handler);
-			callback();
-		}
-	};
-	mql.addEventListener("change", handler);
-	return () => mql.removeEventListener("change", handler);
-}
-/**
-* Schedule callback for browser idle time.
-*/
-function scheduleIdle(callback, timeout) {
-	if ("requestIdleCallback" in window) {
-		const id = requestIdleCallback(callback, { timeout });
-		return () => cancelIdleCallback(id);
-	}
-	const id = setTimeout(callback, timeout);
-	return () => clearTimeout(id);
-}
-/**
-* Initialize islands with a hydration function.
-*
-* This is the main entry point for the island system.
-* Pass a hydrate function that knows how to mount your components.
-*
-* @example Vue
-* ```ts
-* import { initIslands } from '@ox-content/islands';
-* import { createApp, h } from 'vue';
-* import Counter from './Counter.vue';
-*
-* const components = { Counter };
-*
-* initIslands((el, props) => {
-*   const name = el.dataset.oxIsland!;
-*   const Component = components[name];
-*   if (!Component) return;
-*
-*   const app = createApp({ render: () => h(Component, props) });
-*   app.mount(el);
-*
-*   return () => app.unmount();
-* });
-* ```
-*
-* @example React
-* ```ts
-* import { initIslands } from '@ox-content/islands';
-* import { createRoot } from 'react-dom/client';
-* import Counter from './Counter';
-*
-* const components = { Counter };
-*
-* initIslands((el, props) => {
-*   const name = el.dataset.oxIsland!;
-*   const Component = components[name];
-*   if (!Component) return;
-*
-*   const root = createRoot(el);
-*   root.render(<Component {...props} />);
-*
-*   return () => root.unmount();
-* });
-* ```
-*
-* @example Vanilla JS
-* ```ts
-* import { initIslands } from '@ox-content/islands';
-*
-* initIslands((el, props) => {
-*   const name = el.dataset.oxIsland!;
-*
-*   if (name === 'Counter') {
-*     let count = props.initial || 0;
-*     const button = el.querySelector('button')!;
-*     const handler = () => {
-*       count++;
-*       button.textContent = String(count);
-*     };
-*     button.addEventListener('click', handler);
-*     return () => button.removeEventListener('click', handler);
-*   }
-* });
-* ```
-*/
-function initIslands(hydrate, options) {
-	const opts = {
-		...defaultOptions,
-		...options
-	};
-	const instances = [];
-	const cleanups = [];
-	/**
-	* Hydrate a single island element.
-	*/
-	function hydrateIsland(element, config) {
-		const instance = instances.find((i) => i.element === element);
-		if (instance?.hydrated) return;
-		try {
-			opts.onHydrateStart?.(element, config);
-			element.classList.add("ox-island-loading");
-			const cleanup = hydrate(element, config.props);
-			element.dataset.oxHydrated = "true";
-			element.classList.remove("ox-island-loading");
-			if (instance) {
-				instance.cleanup = cleanup || void 0;
-				instance.hydrated = true;
-			} else instances.push({
-				element,
-				config,
-				cleanup: cleanup || void 0,
-				hydrated: true
-			});
-			opts.onHydrateEnd?.(element, config);
-		} catch (error) {
-			element.classList.remove("ox-island-loading");
-			element.classList.add("ox-island-error");
-			element.dataset.oxError = error instanceof Error ? error.message : String(error);
-			opts.onHydrateError?.(element, config, error instanceof Error ? error : new Error(String(error)));
-		}
-	}
-	/**
-	* Schedule hydration based on load strategy.
-	*/
-	function scheduleHydration(element, config) {
-		switch (config.load) {
-			case "eager":
-				hydrateIsland(element, config);
-				break;
-			case "idle": {
-				const cancel = scheduleIdle(() => hydrateIsland(element, config), opts.idleTimeout);
-				cleanups.push(cancel);
-				break;
-			}
-			case "visible": {
-				const cancel = observeVisibility(element, () => hydrateIsland(element, config), {
-					rootMargin: opts.rootMargin,
-					threshold: opts.threshold
-				});
-				cleanups.push(cancel);
-				break;
-			}
-			case "media":
-				if (config.mediaQuery) {
-					const cancel = observeMedia(config.mediaQuery, () => hydrateIsland(element, config));
-					cleanups.push(cancel);
-				} else hydrateIsland(element, config);
-				break;
-			default: hydrateIsland(element, config);
-		}
-	}
-	document.querySelectorAll(opts.selector).forEach((element) => {
-		const config = parseIslandConfig(element);
-		instances.push({
-			element,
-			config,
-			hydrated: false
-		});
-		scheduleHydration(element, config);
-	});
-	return {
-		instances,
-		hydrate(element) {
-			hydrateIsland(element, parseIslandConfig(element));
-		},
-		destroy() {
-			cleanups.forEach((cleanup) => cleanup());
-			cleanups.length = 0;
-			instances.forEach((instance) => {
-				if (instance.cleanup) instance.cleanup();
-			});
-			instances.length = 0;
-		}
-	};
-}
-/**
-* Create a deferred hydration wrapper.
-*
-* Returns a function that can be called to hydrate islands later.
-* Useful for frameworks that need to register components first.
-*
-* @example
-* ```ts
-* const deferredInit = createDeferredInit();
-*
-* // Later, after components are ready
-* const components = await loadComponents();
-* deferredInit((el, props) => {
-*   const Component = components[el.dataset.oxIsland!];
-*   // ...
-* });
-* ```
-*/
-function createDeferredInit(options) {
-	return (hydrate) => initIslands(hydrate, options);
-}
-/**
-* Check if islands are supported in the current environment.
-*/
-function isIslandsSupported() {
-	return typeof window !== "undefined" && typeof document !== "undefined" && typeof IntersectionObserver !== "undefined" && typeof MutationObserver !== "undefined";
-}
-//#endregion
+import { n as initIslands, r as isIslandsSupported, t as createDeferredInit } from "./runtime2.mjs";
 export { createDeferredInit, initIslands, isIslandsSupported };
-
-//# sourceMappingURL=runtime.mjs.map

package/dist/runtime2.mjs

@@ -0,0 +1,299 @@
+//#region src/payload.ts
+const RUST_PAYLOAD_KEYS = /* @__PURE__ */ new Set([
+	"props",
+	"expressions",
+	"spreads"
+]);
+const ISLAND_JSON_SCRIPT = /^\s*<script type="application\/json">[\s\S]*?<\/script>/;
+/**
+* Flatten the Rust MDX island payload (`{ props, expressions, spreads }`)
+* into the literal props object hydrate functions expect. Legacy flat
+* `data-ox-props` objects from the Markdown regex path are returned as-is.
+*/
+function unwrapIslandProps(parsed) {
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+	const record = parsed;
+	const keys = Object.keys(record);
+	if (keys.length > 0 && keys.every((key) => RUST_PAYLOAD_KEYS.has(key)) && record.props && typeof record.props === "object" && !Array.isArray(record.props)) return record.props;
+	return record;
+}
+/**
+* Slot markup for an island: `data-ox-content` when the regex path set it,
+* otherwise inner HTML with the Rust JSON payload script stripped.
+*/
+function stripIslandPayloadScript(innerHTML) {
+	return innerHTML.replace(ISLAND_JSON_SCRIPT, "");
+}
+function readIslandSlotHtml(element) {
+	const fromAttr = element.dataset.oxContent;
+	if (fromAttr) return fromAttr;
+	return stripIslandPayloadScript(element.innerHTML);
+}
+//#endregion
+//#region src/runtime.ts
+/**
+* Island Architecture Runtime
+*
+* Framework-agnostic Island controller using pure Vanilla JavaScript.
+* No framework dependencies - works with Vue, React, Svelte, or plain JS.
+*/
+const defaultOptions = {
+	rootMargin: "200px",
+	threshold: 0,
+	idleTimeout: 200,
+	selector: "[data-ox-island]"
+};
+/**
+* Parse island configuration from element attributes.
+*/
+function parseIslandConfig(element) {
+	const component = element.dataset.oxIsland || "";
+	const load = element.dataset.oxLoad || "eager";
+	const mediaQuery = element.dataset.oxMedia;
+	let props = {};
+	try {
+		const propsJson = element.dataset.oxProps;
+		if (propsJson) props = unwrapIslandProps(JSON.parse(propsJson));
+	} catch (e) {
+		console.warn("[ox-islands] Failed to parse props for", element, e);
+	}
+	return {
+		id: element.id || `island-${Math.random().toString(36).slice(2, 9)}`,
+		component,
+		load,
+		mediaQuery,
+		props
+	};
+}
+/**
+* Observe element visibility using IntersectionObserver.
+*/
+function observeVisibility(element, callback, options) {
+	const observer = new IntersectionObserver((entries) => {
+		if (entries[0].isIntersecting) {
+			observer.disconnect();
+			callback();
+		}
+	}, {
+		rootMargin: options.rootMargin,
+		threshold: options.threshold
+	});
+	observer.observe(element);
+	return () => observer.disconnect();
+}
+/**
+* Observe media query changes.
+*/
+function observeMedia(query, callback) {
+	const mql = matchMedia(query);
+	if (mql.matches) {
+		callback();
+		return () => {};
+	}
+	const handler = () => {
+		if (mql.matches) {
+			mql.removeEventListener("change", handler);
+			callback();
+		}
+	};
+	mql.addEventListener("change", handler);
+	return () => mql.removeEventListener("change", handler);
+}
+/**
+* Schedule callback for browser idle time.
+*/
+function scheduleIdle(callback, timeout) {
+	if ("requestIdleCallback" in window) {
+		const id = requestIdleCallback(callback, { timeout });
+		return () => cancelIdleCallback(id);
+	}
+	const id = setTimeout(callback, timeout);
+	return () => clearTimeout(id);
+}
+/**
+* Initialize islands with a hydration function.
+*
+* This is the main entry point for the island system.
+* Pass a hydrate function that knows how to mount your components.
+*
+* @example Vue
+* ```ts
+* import { initIslands } from '@ox-content/islands';
+* import { createApp, h } from 'vue';
+* import Counter from './Counter.vue';
+*
+* const components = { Counter };
+*
+* initIslands((el, props) => {
+*   const name = el.dataset.oxIsland!;
+*   const Component = components[name];
+*   if (!Component) return;
+*
+*   const app = createApp({ render: () => h(Component, props) });
+*   app.mount(el);
+*
+*   return () => app.unmount();
+* });
+* ```
+*
+* @example React
+* ```ts
+* import { initIslands } from '@ox-content/islands';
+* import { createRoot } from 'react-dom/client';
+* import Counter from './Counter';
+*
+* const components = { Counter };
+*
+* initIslands((el, props) => {
+*   const name = el.dataset.oxIsland!;
+*   const Component = components[name];
+*   if (!Component) return;
+*
+*   const root = createRoot(el);
+*   root.render(<Component {...props} />);
+*
+*   return () => root.unmount();
+* });
+* ```
+*
+* @example Vanilla JS
+* ```ts
+* import { initIslands } from '@ox-content/islands';
+*
+* initIslands((el, props) => {
+*   const name = el.dataset.oxIsland!;
+*
+*   if (name === 'Counter') {
+*     let count = props.initial || 0;
+*     const button = el.querySelector('button')!;
+*     const handler = () => {
+*       count++;
+*       button.textContent = String(count);
+*     };
+*     button.addEventListener('click', handler);
+*     return () => button.removeEventListener('click', handler);
+*   }
+* });
+* ```
+*/
+function initIslands(hydrate, options) {
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	const instances = [];
+	const cleanups = [];
+	/**
+	* Hydrate a single island element.
+	*/
+	function hydrateIsland(element, config) {
+		const instance = instances.find((i) => i.element === element);
+		if (instance?.hydrated) return;
+		try {
+			opts.onHydrateStart?.(element, config);
+			element.classList.add("ox-island-loading");
+			const cleanup = hydrate(element, config.props);
+			element.dataset.oxHydrated = "true";
+			element.classList.remove("ox-island-loading");
+			if (instance) {
+				instance.cleanup = cleanup || void 0;
+				instance.hydrated = true;
+			} else instances.push({
+				element,
+				config,
+				cleanup: cleanup || void 0,
+				hydrated: true
+			});
+			opts.onHydrateEnd?.(element, config);
+		} catch (error) {
+			element.classList.remove("ox-island-loading");
+			element.classList.add("ox-island-error");
+			element.dataset.oxError = error instanceof Error ? error.message : String(error);
+			opts.onHydrateError?.(element, config, error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	/**
+	* Schedule hydration based on load strategy.
+	*/
+	function scheduleHydration(element, config) {
+		switch (config.load) {
+			case "eager":
+				hydrateIsland(element, config);
+				break;
+			case "idle": {
+				const cancel = scheduleIdle(() => hydrateIsland(element, config), opts.idleTimeout);
+				cleanups.push(cancel);
+				break;
+			}
+			case "visible": {
+				const cancel = observeVisibility(element, () => hydrateIsland(element, config), {
+					rootMargin: opts.rootMargin,
+					threshold: opts.threshold
+				});
+				cleanups.push(cancel);
+				break;
+			}
+			case "media":
+				if (config.mediaQuery) {
+					const cancel = observeMedia(config.mediaQuery, () => hydrateIsland(element, config));
+					cleanups.push(cancel);
+				} else hydrateIsland(element, config);
+				break;
+			default: hydrateIsland(element, config);
+		}
+	}
+	document.querySelectorAll(opts.selector).forEach((element) => {
+		const config = parseIslandConfig(element);
+		instances.push({
+			element,
+			config,
+			hydrated: false
+		});
+		scheduleHydration(element, config);
+	});
+	return {
+		instances,
+		hydrate(element) {
+			hydrateIsland(element, parseIslandConfig(element));
+		},
+		destroy() {
+			cleanups.forEach((cleanup) => cleanup());
+			cleanups.length = 0;
+			instances.forEach((instance) => {
+				if (instance.cleanup) instance.cleanup();
+			});
+			instances.length = 0;
+		}
+	};
+}
+/**
+* Create a deferred hydration wrapper.
+*
+* Returns a function that can be called to hydrate islands later.
+* Useful for frameworks that need to register components first.
+*
+* @example
+* ```ts
+* const deferredInit = createDeferredInit();
+*
+* // Later, after components are ready
+* const components = await loadComponents();
+* deferredInit((el, props) => {
+*   const Component = components[el.dataset.oxIsland!];
+*   // ...
+* });
+* ```
+*/
+function createDeferredInit(options) {
+	return (hydrate) => initIslands(hydrate, options);
+}
+/**
+* Check if islands are supported in the current environment.
+*/
+function isIslandsSupported() {
+	return typeof window !== "undefined" && typeof document !== "undefined" && typeof IntersectionObserver !== "undefined" && typeof MutationObserver !== "undefined";
+}
+//#endregion
+export { stripIslandPayloadScript as a, readIslandSlotHtml as i, initIslands as n, unwrapIslandProps as o, isIslandsSupported as r, createDeferredInit as t };
+
+//# sourceMappingURL=runtime2.mjs.map

package/dist/runtime2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime2.mjs","names":[],"sources":["../src/payload.ts","../src/runtime.ts"],"sourcesContent":["const RUST_PAYLOAD_KEYS = new Set([\"props\", \"expressions\", \"spreads\"]);\nconst ISLAND_JSON_SCRIPT = /^\\s*<script type=\"application\\/json\">[\\s\\S]*?<\\/script>/;\n\n/**\n * Flatten the Rust MDX island payload (`{ props, expressions, spreads }`)\n * into the literal props object hydrate functions expect. Legacy flat\n * `data-ox-props` objects from the Markdown regex path are returned as-is.\n */\nexport function unwrapIslandProps(parsed: unknown): Record<string, unknown> {\n  if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed)) {\n    return {};\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const keys = Object.keys(record);\n  if (\n    keys.length > 0 &&\n    keys.every((key) => RUST_PAYLOAD_KEYS.has(key)) &&\n    record.props &&\n    typeof record.props === \"object\" &&\n    !Array.isArray(record.props)\n  ) {\n    return record.props as Record<string, unknown>;\n  }\n\n  return record;\n}\n\n/**\n * Slot markup for an island: `data-ox-content` when the regex path set it,\n * otherwise inner HTML with the Rust JSON payload script stripped.\n */\nexport function stripIslandPayloadScript(innerHTML: string): string {\n  return innerHTML.replace(ISLAND_JSON_SCRIPT, \"\");\n}\n\nexport function readIslandSlotHtml(element: Pick<HTMLElement, \"dataset\" | \"innerHTML\">): string {\n  const fromAttr = element.dataset.oxContent;\n  if (fromAttr) return fromAttr;\n  return stripIslandPayloadScript(element.innerHTML);\n}\n","/**\n * Island Architecture Runtime\n *\n * Framework-agnostic Island controller using pure Vanilla JavaScript.\n * No framework dependencies - works with Vue, React, Svelte, or plain JS.\n */\n\nimport { unwrapIslandProps } from \"./payload\";\nimport type {\n  HydrateFunction,\n  InitIslandsOptions,\n  IslandConfig,\n  IslandInstance,\n  IslandController,\n  LoadStrategy,\n} from \"./types\";\n\nconst defaultOptions: Required<\n  Omit<InitIslandsOptions, \"onHydrateStart\" | \"onHydrateEnd\" | \"onHydrateError\">\n> &\n  InitIslandsOptions = {\n  rootMargin: \"200px\",\n  threshold: 0,\n  idleTimeout: 200,\n  selector: \"[data-ox-island]\",\n};\n\n/**\n * Parse island configuration from element attributes.\n */\nfunction parseIslandConfig(element: HTMLElement): IslandConfig {\n  const component = element.dataset.oxIsland || \"\";\n  const load = (element.dataset.oxLoad as LoadStrategy) || \"eager\";\n  const mediaQuery = element.dataset.oxMedia;\n\n  let props: Record<string, unknown> = {};\n  try {\n    const propsJson = element.dataset.oxProps;\n    if (propsJson) {\n      props = unwrapIslandProps(JSON.parse(propsJson));\n    }\n  } catch (e) {\n    console.warn(\"[ox-islands] Failed to parse props for\", element, e);\n  }\n\n  return {\n    id: element.id || `island-${Math.random().toString(36).slice(2, 9)}`,\n    component,\n    load,\n    mediaQuery,\n    props,\n  };\n}\n\n/**\n * Observe element visibility using IntersectionObserver.\n */\nfunction observeVisibility(\n  element: HTMLElement,\n  callback: () => void,\n  options: { rootMargin: string; threshold: number },\n): () => void {\n  const observer = new IntersectionObserver(\n    (entries) => {\n      if (entries[0].isIntersecting) {\n        observer.disconnect();\n        callback();\n      }\n    },\n    {\n      rootMargin: options.rootMargin,\n      threshold: options.threshold,\n    },\n  );\n\n  observer.observe(element);\n\n  return () => observer.disconnect();\n}\n\n/**\n * Observe media query changes.\n */\nfunction observeMedia(query: string, callback: () => void): () => void {\n  const mql = matchMedia(query);\n\n  if (mql.matches) {\n    callback();\n    return () => {};\n  }\n\n  const handler = () => {\n    if (mql.matches) {\n      mql.removeEventListener(\"change\", handler);\n      callback();\n    }\n  };\n\n  mql.addEventListener(\"change\", handler);\n\n  return () => mql.removeEventListener(\"change\", handler);\n}\n\n/**\n * Schedule callback for browser idle time.\n */\nfunction scheduleIdle(callback: () => void, timeout: number): () => void {\n  if (\"requestIdleCallback\" in window) {\n    const id = requestIdleCallback(callback, { timeout });\n    return () => cancelIdleCallback(id);\n  }\n\n  // Fallback for Safari and older browsers\n  const id = setTimeout(callback, timeout);\n  return () => clearTimeout(id);\n}\n\n/**\n * Initialize islands with a hydration function.\n *\n * This is the main entry point for the island system.\n * Pass a hydrate function that knows how to mount your components.\n *\n * @example Vue\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n * import { createApp, h } from 'vue';\n * import Counter from './Counter.vue';\n *\n * const components = { Counter };\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *   const Component = components[name];\n *   if (!Component) return;\n *\n *   const app = createApp({ render: () => h(Component, props) });\n *   app.mount(el);\n *\n *   return () => app.unmount();\n * });\n * ```\n *\n * @example React\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n * import { createRoot } from 'react-dom/client';\n * import Counter from './Counter';\n *\n * const components = { Counter };\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *   const Component = components[name];\n *   if (!Component) return;\n *\n *   const root = createRoot(el);\n *   root.render(<Component {...props} />);\n *\n *   return () => root.unmount();\n * });\n * ```\n *\n * @example Vanilla JS\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *\n *   if (name === 'Counter') {\n *     let count = props.initial || 0;\n *     const button = el.querySelector('button')!;\n *     const handler = () => {\n *       count++;\n *       button.textContent = String(count);\n *     };\n *     button.addEventListener('click', handler);\n *     return () => button.removeEventListener('click', handler);\n *   }\n * });\n * ```\n */\nexport function initIslands(\n  hydrate: HydrateFunction,\n  options?: InitIslandsOptions,\n): IslandController {\n  const opts = { ...defaultOptions, ...options };\n  const instances: IslandInstance[] = [];\n  const cleanups: (() => void)[] = [];\n\n  /**\n   * Hydrate a single island element.\n   */\n  function hydrateIsland(element: HTMLElement, config: IslandConfig): void {\n    // Find existing instance\n    const instance = instances.find((i) => i.element === element);\n    if (instance?.hydrated) return;\n\n    try {\n      opts.onHydrateStart?.(element, config);\n\n      // Mark as loading\n      element.classList.add(\"ox-island-loading\");\n\n      // Call the hydrate function\n      const cleanup = hydrate(element, config.props);\n\n      // Mark as hydrated\n      element.dataset.oxHydrated = \"true\";\n      element.classList.remove(\"ox-island-loading\");\n\n      // Update instance\n      if (instance) {\n        instance.cleanup = cleanup || undefined;\n        instance.hydrated = true;\n      } else {\n        instances.push({\n          element,\n          config,\n          cleanup: cleanup || undefined,\n          hydrated: true,\n        });\n      }\n\n      opts.onHydrateEnd?.(element, config);\n    } catch (error) {\n      element.classList.remove(\"ox-island-loading\");\n      element.classList.add(\"ox-island-error\");\n      element.dataset.oxError = error instanceof Error ? error.message : String(error);\n\n      opts.onHydrateError?.(\n        element,\n        config,\n        error instanceof Error ? error : new Error(String(error)),\n      );\n    }\n  }\n\n  /**\n   * Schedule hydration based on load strategy.\n   */\n  function scheduleHydration(element: HTMLElement, config: IslandConfig): void {\n    switch (config.load) {\n      case \"eager\":\n        hydrateIsland(element, config);\n        break;\n\n      case \"idle\": {\n        const cancel = scheduleIdle(() => hydrateIsland(element, config), opts.idleTimeout);\n        cleanups.push(cancel);\n        break;\n      }\n\n      case \"visible\": {\n        const cancel = observeVisibility(element, () => hydrateIsland(element, config), {\n          rootMargin: opts.rootMargin,\n          threshold: opts.threshold,\n        });\n        cleanups.push(cancel);\n        break;\n      }\n\n      case \"media\": {\n        if (config.mediaQuery) {\n          const cancel = observeMedia(config.mediaQuery, () => hydrateIsland(element, config));\n          cleanups.push(cancel);\n        } else {\n          // No media query specified, fall back to eager\n          hydrateIsland(element, config);\n        }\n        break;\n      }\n\n      default:\n        hydrateIsland(element, config);\n    }\n  }\n\n  // Find and process all island elements\n  const elements = document.querySelectorAll<HTMLElement>(opts.selector);\n\n  elements.forEach((element) => {\n    const config = parseIslandConfig(element);\n\n    // Track instance\n    instances.push({\n      element,\n      config,\n      hydrated: false,\n    });\n\n    // Schedule hydration\n    scheduleHydration(element, config);\n  });\n\n  // Return controller\n  return {\n    instances,\n\n    hydrate(element: HTMLElement): void {\n      const config = parseIslandConfig(element);\n      hydrateIsland(element, config);\n    },\n\n    destroy(): void {\n      // Cancel pending hydrations\n      cleanups.forEach((cleanup) => cleanup());\n      cleanups.length = 0;\n\n      // Cleanup hydrated instances\n      instances.forEach((instance) => {\n        if (instance.cleanup) {\n          instance.cleanup();\n        }\n      });\n      instances.length = 0;\n    },\n  };\n}\n\n/**\n * Create a deferred hydration wrapper.\n *\n * Returns a function that can be called to hydrate islands later.\n * Useful for frameworks that need to register components first.\n *\n * @example\n * ```ts\n * const deferredInit = createDeferredInit();\n *\n * // Later, after components are ready\n * const components = await loadComponents();\n * deferredInit((el, props) => {\n *   const Component = components[el.dataset.oxIsland!];\n *   // ...\n * });\n * ```\n */\nexport function createDeferredInit(\n  options?: InitIslandsOptions,\n): (hydrate: HydrateFunction) => IslandController {\n  return (hydrate: HydrateFunction) => initIslands(hydrate, options);\n}\n\n/**\n * Check if islands are supported in the current environment.\n */\nexport function isIslandsSupported(): boolean {\n  return (\n    typeof window !== \"undefined\" &&\n    typeof document !== \"undefined\" &&\n    typeof IntersectionObserver !== \"undefined\" &&\n    typeof MutationObserver !== \"undefined\"\n  );\n}\n"],"mappings":";AAAA,MAAM,oCAAoB,IAAI,IAAI;CAAC;CAAS;CAAe;AAAS,CAAC;AACrE,MAAM,qBAAqB;;;;;;AAO3B,SAAgB,kBAAkB,QAA0C;CAC1E,IAAI,CAAC,UAAU,OAAO,WAAW,YAAY,MAAM,QAAQ,MAAM,GAC/D,OAAO,CAAC;CAGV,MAAM,SAAS;CACf,MAAM,OAAO,OAAO,KAAK,MAAM;CAC/B,IACE,KAAK,SAAS,KACd,KAAK,OAAO,QAAQ,kBAAkB,IAAI,GAAG,CAAC,KAC9C,OAAO,SACP,OAAO,OAAO,UAAU,YACxB,CAAC,MAAM,QAAQ,OAAO,KAAK,GAE3B,OAAO,OAAO;CAGhB,OAAO;AACT;;;;;AAMA,SAAgB,yBAAyB,WAA2B;CAClE,OAAO,UAAU,QAAQ,oBAAoB,EAAE;AACjD;AAEA,SAAgB,mBAAmB,SAA6D;CAC9F,MAAM,WAAW,QAAQ,QAAQ;CACjC,IAAI,UAAU,OAAO;CACrB,OAAO,yBAAyB,QAAQ,SAAS;AACnD;;;;;;;;;ACvBA,MAAM,iBAGiB;CACrB,YAAY;CACZ,WAAW;CACX,aAAa;CACb,UAAU;AACZ;;;;AAKA,SAAS,kBAAkB,SAAoC;CAC7D,MAAM,YAAY,QAAQ,QAAQ,YAAY;CAC9C,MAAM,OAAQ,QAAQ,QAAQ,UAA2B;CACzD,MAAM,aAAa,QAAQ,QAAQ;CAEnC,IAAI,QAAiC,CAAC;CACtC,IAAI;EACF,MAAM,YAAY,QAAQ,QAAQ;EAClC,IAAI,WACF,QAAQ,kBAAkB,KAAK,MAAM,SAAS,CAAC;CAEnD,SAAS,GAAG;EACV,QAAQ,KAAK,0CAA0C,SAAS,CAAC;CACnE;CAEA,OAAO;EACL,IAAI,QAAQ,MAAM,UAAU,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC;EACjE;EACA;EACA;EACA;CACF;AACF;;;;AAKA,SAAS,kBACP,SACA,UACA,SACY;CACZ,MAAM,WAAW,IAAI,sBAClB,YAAY;EACX,IAAI,QAAQ,EAAE,CAAC,gBAAgB;GAC7B,SAAS,WAAW;GACpB,SAAS;EACX;CACF,GACA;EACE,YAAY,QAAQ;EACpB,WAAW,QAAQ;CACrB,CACF;CAEA,SAAS,QAAQ,OAAO;CAExB,aAAa,SAAS,WAAW;AACnC;;;;AAKA,SAAS,aAAa,OAAe,UAAkC;CACrE,MAAM,MAAM,WAAW,KAAK;CAE5B,IAAI,IAAI,SAAS;EACf,SAAS;EACT,aAAa,CAAC;CAChB;CAEA,MAAM,gBAAgB;EACpB,IAAI,IAAI,SAAS;GACf,IAAI,oBAAoB,UAAU,OAAO;GACzC,SAAS;EACX;CACF;CAEA,IAAI,iBAAiB,UAAU,OAAO;CAEtC,aAAa,IAAI,oBAAoB,UAAU,OAAO;AACxD;;;;AAKA,SAAS,aAAa,UAAsB,SAA6B;CACvE,IAAI,yBAAyB,QAAQ;EACnC,MAAM,KAAK,oBAAoB,UAAU,EAAE,QAAQ,CAAC;EACpD,aAAa,mBAAmB,EAAE;CACpC;CAGA,MAAM,KAAK,WAAW,UAAU,OAAO;CACvC,aAAa,aAAa,EAAE;AAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,YACd,SACA,SACkB;CAClB,MAAM,OAAO;EAAE,GAAG;EAAgB,GAAG;CAAQ;CAC7C,MAAM,YAA8B,CAAC;CACrC,MAAM,WAA2B,CAAC;;;;CAKlC,SAAS,cAAc,SAAsB,QAA4B;EAEvE,MAAM,WAAW,UAAU,MAAM,MAAM,EAAE,YAAY,OAAO;EAC5D,IAAI,UAAU,UAAU;EAExB,IAAI;GACF,KAAK,iBAAiB,SAAS,MAAM;GAGrC,QAAQ,UAAU,IAAI,mBAAmB;GAGzC,MAAM,UAAU,QAAQ,SAAS,OAAO,KAAK;GAG7C,QAAQ,QAAQ,aAAa;GAC7B,QAAQ,UAAU,OAAO,mBAAmB;GAG5C,IAAI,UAAU;IACZ,SAAS,UAAU,WAAW,KAAA;IAC9B,SAAS,WAAW;GACtB,OACE,UAAU,KAAK;IACb;IACA;IACA,SAAS,WAAW,KAAA;IACpB,UAAU;GACZ,CAAC;GAGH,KAAK,eAAe,SAAS,MAAM;EACrC,SAAS,OAAO;GACd,QAAQ,UAAU,OAAO,mBAAmB;GAC5C,QAAQ,UAAU,IAAI,iBAAiB;GACvC,QAAQ,QAAQ,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;GAE/E,KAAK,iBACH,SACA,QACA,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAC1D;EACF;CACF;;;;CAKA,SAAS,kBAAkB,SAAsB,QAA4B;EAC3E,QAAQ,OAAO,MAAf;GACE,KAAK;IACH,cAAc,SAAS,MAAM;IAC7B;GAEF,KAAK,QAAQ;IACX,MAAM,SAAS,mBAAmB,cAAc,SAAS,MAAM,GAAG,KAAK,WAAW;IAClF,SAAS,KAAK,MAAM;IACpB;GACF;GAEA,KAAK,WAAW;IACd,MAAM,SAAS,kBAAkB,eAAe,cAAc,SAAS,MAAM,GAAG;KAC9E,YAAY,KAAK;KACjB,WAAW,KAAK;IAClB,CAAC;IACD,SAAS,KAAK,MAAM;IACpB;GACF;GAEA,KAAK;IACH,IAAI,OAAO,YAAY;KACrB,MAAM,SAAS,aAAa,OAAO,kBAAkB,cAAc,SAAS,MAAM,CAAC;KACnF,SAAS,KAAK,MAAM;IACtB,OAEE,cAAc,SAAS,MAAM;IAE/B;GAGF,SACE,cAAc,SAAS,MAAM;EACjC;CACF;CAKA,SAF0B,iBAA8B,KAAK,QAEtD,CAAC,CAAC,SAAS,YAAY;EAC5B,MAAM,SAAS,kBAAkB,OAAO;EAGxC,UAAU,KAAK;GACb;GACA;GACA,UAAU;EACZ,CAAC;EAGD,kBAAkB,SAAS,MAAM;CACnC,CAAC;CAGD,OAAO;EACL;EAEA,QAAQ,SAA4B;GAElC,cAAc,SADC,kBAAkB,OACL,CAAC;EAC/B;EAEA,UAAgB;GAEd,SAAS,SAAS,YAAY,QAAQ,CAAC;GACvC,SAAS,SAAS;GAGlB,UAAU,SAAS,aAAa;IAC9B,IAAI,SAAS,SACX,SAAS,QAAQ;GAErB,CAAC;GACD,UAAU,SAAS;EACrB;CACF;AACF;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,mBACd,SACgD;CAChD,QAAQ,YAA6B,YAAY,SAAS,OAAO;AACnE;;;;AAKA,SAAgB,qBAA8B;CAC5C,OACE,OAAO,WAAW,eAClB,OAAO,aAAa,eACpB,OAAO,yBAAyB,eAChC,OAAO,qBAAqB;AAEhC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ox-content/islands",
-  "version": "2.90.0",
+  "version": "3.0.0-alpha.2",
   "description": "Framework-agnostic Island Architecture for ox-content",
   "keywords": [
     "framework-agnostic",
@@ -36,10 +36,10 @@
     "access": "public"
   },
   "devDependencies": {
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "@typescript/native-preview": "^7.0.0-dev.20260707.2",
     "typescript": "^7.0.2",
-    "vite-plus": "0.2.8"
+    "vite-plus": "0.2.9"
   },
   "scripts": {
     "build": "vp pack",

package/dist/runtime.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.mjs","names":[],"sources":["../src/runtime.ts"],"sourcesContent":["/**\n * Island Architecture Runtime\n *\n * Framework-agnostic Island controller using pure Vanilla JavaScript.\n * No framework dependencies - works with Vue, React, Svelte, or plain JS.\n */\n\nimport type {\n  HydrateFunction,\n  InitIslandsOptions,\n  IslandConfig,\n  IslandInstance,\n  IslandController,\n  LoadStrategy,\n} from \"./types\";\n\nconst defaultOptions: Required<\n  Omit<InitIslandsOptions, \"onHydrateStart\" | \"onHydrateEnd\" | \"onHydrateError\">\n> &\n  InitIslandsOptions = {\n  rootMargin: \"200px\",\n  threshold: 0,\n  idleTimeout: 200,\n  selector: \"[data-ox-island]\",\n};\n\n/**\n * Parse island configuration from element attributes.\n */\nfunction parseIslandConfig(element: HTMLElement): IslandConfig {\n  const component = element.dataset.oxIsland || \"\";\n  const load = (element.dataset.oxLoad as LoadStrategy) || \"eager\";\n  const mediaQuery = element.dataset.oxMedia;\n\n  let props: Record<string, unknown> = {};\n  try {\n    const propsJson = element.dataset.oxProps;\n    if (propsJson) {\n      props = JSON.parse(propsJson);\n    }\n  } catch (e) {\n    console.warn(\"[ox-islands] Failed to parse props for\", element, e);\n  }\n\n  return {\n    id: element.id || `island-${Math.random().toString(36).slice(2, 9)}`,\n    component,\n    load,\n    mediaQuery,\n    props,\n  };\n}\n\n/**\n * Observe element visibility using IntersectionObserver.\n */\nfunction observeVisibility(\n  element: HTMLElement,\n  callback: () => void,\n  options: { rootMargin: string; threshold: number },\n): () => void {\n  const observer = new IntersectionObserver(\n    (entries) => {\n      if (entries[0].isIntersecting) {\n        observer.disconnect();\n        callback();\n      }\n    },\n    {\n      rootMargin: options.rootMargin,\n      threshold: options.threshold,\n    },\n  );\n\n  observer.observe(element);\n\n  return () => observer.disconnect();\n}\n\n/**\n * Observe media query changes.\n */\nfunction observeMedia(query: string, callback: () => void): () => void {\n  const mql = matchMedia(query);\n\n  if (mql.matches) {\n    callback();\n    return () => {};\n  }\n\n  const handler = () => {\n    if (mql.matches) {\n      mql.removeEventListener(\"change\", handler);\n      callback();\n    }\n  };\n\n  mql.addEventListener(\"change\", handler);\n\n  return () => mql.removeEventListener(\"change\", handler);\n}\n\n/**\n * Schedule callback for browser idle time.\n */\nfunction scheduleIdle(callback: () => void, timeout: number): () => void {\n  if (\"requestIdleCallback\" in window) {\n    const id = requestIdleCallback(callback, { timeout });\n    return () => cancelIdleCallback(id);\n  }\n\n  // Fallback for Safari and older browsers\n  const id = setTimeout(callback, timeout);\n  return () => clearTimeout(id);\n}\n\n/**\n * Initialize islands with a hydration function.\n *\n * This is the main entry point for the island system.\n * Pass a hydrate function that knows how to mount your components.\n *\n * @example Vue\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n * import { createApp, h } from 'vue';\n * import Counter from './Counter.vue';\n *\n * const components = { Counter };\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *   const Component = components[name];\n *   if (!Component) return;\n *\n *   const app = createApp({ render: () => h(Component, props) });\n *   app.mount(el);\n *\n *   return () => app.unmount();\n * });\n * ```\n *\n * @example React\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n * import { createRoot } from 'react-dom/client';\n * import Counter from './Counter';\n *\n * const components = { Counter };\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *   const Component = components[name];\n *   if (!Component) return;\n *\n *   const root = createRoot(el);\n *   root.render(<Component {...props} />);\n *\n *   return () => root.unmount();\n * });\n * ```\n *\n * @example Vanilla JS\n * ```ts\n * import { initIslands } from '@ox-content/islands';\n *\n * initIslands((el, props) => {\n *   const name = el.dataset.oxIsland!;\n *\n *   if (name === 'Counter') {\n *     let count = props.initial || 0;\n *     const button = el.querySelector('button')!;\n *     const handler = () => {\n *       count++;\n *       button.textContent = String(count);\n *     };\n *     button.addEventListener('click', handler);\n *     return () => button.removeEventListener('click', handler);\n *   }\n * });\n * ```\n */\nexport function initIslands(\n  hydrate: HydrateFunction,\n  options?: InitIslandsOptions,\n): IslandController {\n  const opts = { ...defaultOptions, ...options };\n  const instances: IslandInstance[] = [];\n  const cleanups: (() => void)[] = [];\n\n  /**\n   * Hydrate a single island element.\n   */\n  function hydrateIsland(element: HTMLElement, config: IslandConfig): void {\n    // Find existing instance\n    const instance = instances.find((i) => i.element === element);\n    if (instance?.hydrated) return;\n\n    try {\n      opts.onHydrateStart?.(element, config);\n\n      // Mark as loading\n      element.classList.add(\"ox-island-loading\");\n\n      // Call the hydrate function\n      const cleanup = hydrate(element, config.props);\n\n      // Mark as hydrated\n      element.dataset.oxHydrated = \"true\";\n      element.classList.remove(\"ox-island-loading\");\n\n      // Update instance\n      if (instance) {\n        instance.cleanup = cleanup || undefined;\n        instance.hydrated = true;\n      } else {\n        instances.push({\n          element,\n          config,\n          cleanup: cleanup || undefined,\n          hydrated: true,\n        });\n      }\n\n      opts.onHydrateEnd?.(element, config);\n    } catch (error) {\n      element.classList.remove(\"ox-island-loading\");\n      element.classList.add(\"ox-island-error\");\n      element.dataset.oxError = error instanceof Error ? error.message : String(error);\n\n      opts.onHydrateError?.(\n        element,\n        config,\n        error instanceof Error ? error : new Error(String(error)),\n      );\n    }\n  }\n\n  /**\n   * Schedule hydration based on load strategy.\n   */\n  function scheduleHydration(element: HTMLElement, config: IslandConfig): void {\n    switch (config.load) {\n      case \"eager\":\n        hydrateIsland(element, config);\n        break;\n\n      case \"idle\": {\n        const cancel = scheduleIdle(() => hydrateIsland(element, config), opts.idleTimeout);\n        cleanups.push(cancel);\n        break;\n      }\n\n      case \"visible\": {\n        const cancel = observeVisibility(element, () => hydrateIsland(element, config), {\n          rootMargin: opts.rootMargin,\n          threshold: opts.threshold,\n        });\n        cleanups.push(cancel);\n        break;\n      }\n\n      case \"media\": {\n        if (config.mediaQuery) {\n          const cancel = observeMedia(config.mediaQuery, () => hydrateIsland(element, config));\n          cleanups.push(cancel);\n        } else {\n          // No media query specified, fall back to eager\n          hydrateIsland(element, config);\n        }\n        break;\n      }\n\n      default:\n        hydrateIsland(element, config);\n    }\n  }\n\n  // Find and process all island elements\n  const elements = document.querySelectorAll<HTMLElement>(opts.selector);\n\n  elements.forEach((element) => {\n    const config = parseIslandConfig(element);\n\n    // Track instance\n    instances.push({\n      element,\n      config,\n      hydrated: false,\n    });\n\n    // Schedule hydration\n    scheduleHydration(element, config);\n  });\n\n  // Return controller\n  return {\n    instances,\n\n    hydrate(element: HTMLElement): void {\n      const config = parseIslandConfig(element);\n      hydrateIsland(element, config);\n    },\n\n    destroy(): void {\n      // Cancel pending hydrations\n      cleanups.forEach((cleanup) => cleanup());\n      cleanups.length = 0;\n\n      // Cleanup hydrated instances\n      instances.forEach((instance) => {\n        if (instance.cleanup) {\n          instance.cleanup();\n        }\n      });\n      instances.length = 0;\n    },\n  };\n}\n\n/**\n * Create a deferred hydration wrapper.\n *\n * Returns a function that can be called to hydrate islands later.\n * Useful for frameworks that need to register components first.\n *\n * @example\n * ```ts\n * const deferredInit = createDeferredInit();\n *\n * // Later, after components are ready\n * const components = await loadComponents();\n * deferredInit((el, props) => {\n *   const Component = components[el.dataset.oxIsland!];\n *   // ...\n * });\n * ```\n */\nexport function createDeferredInit(\n  options?: InitIslandsOptions,\n): (hydrate: HydrateFunction) => IslandController {\n  return (hydrate: HydrateFunction) => initIslands(hydrate, options);\n}\n\n/**\n * Check if islands are supported in the current environment.\n */\nexport function isIslandsSupported(): boolean {\n  return (\n    typeof window !== \"undefined\" &&\n    typeof document !== \"undefined\" &&\n    typeof IntersectionObserver !== \"undefined\" &&\n    typeof MutationObserver !== \"undefined\"\n  );\n}\n"],"mappings":";AAgBA,MAAM,iBAGiB;CACrB,YAAY;CACZ,WAAW;CACX,aAAa;CACb,UAAU;AACZ;;;;AAKA,SAAS,kBAAkB,SAAoC;CAC7D,MAAM,YAAY,QAAQ,QAAQ,YAAY;CAC9C,MAAM,OAAQ,QAAQ,QAAQ,UAA2B;CACzD,MAAM,aAAa,QAAQ,QAAQ;CAEnC,IAAI,QAAiC,CAAC;CACtC,IAAI;EACF,MAAM,YAAY,QAAQ,QAAQ;EAClC,IAAI,WACF,QAAQ,KAAK,MAAM,SAAS;CAEhC,SAAS,GAAG;EACV,QAAQ,KAAK,0CAA0C,SAAS,CAAC;CACnE;CAEA,OAAO;EACL,IAAI,QAAQ,MAAM,UAAU,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC;EACjE;EACA;EACA;EACA;CACF;AACF;;;;AAKA,SAAS,kBACP,SACA,UACA,SACY;CACZ,MAAM,WAAW,IAAI,sBAClB,YAAY;EACX,IAAI,QAAQ,EAAE,CAAC,gBAAgB;GAC7B,SAAS,WAAW;GACpB,SAAS;EACX;CACF,GACA;EACE,YAAY,QAAQ;EACpB,WAAW,QAAQ;CACrB,CACF;CAEA,SAAS,QAAQ,OAAO;CAExB,aAAa,SAAS,WAAW;AACnC;;;;AAKA,SAAS,aAAa,OAAe,UAAkC;CACrE,MAAM,MAAM,WAAW,KAAK;CAE5B,IAAI,IAAI,SAAS;EACf,SAAS;EACT,aAAa,CAAC;CAChB;CAEA,MAAM,gBAAgB;EACpB,IAAI,IAAI,SAAS;GACf,IAAI,oBAAoB,UAAU,OAAO;GACzC,SAAS;EACX;CACF;CAEA,IAAI,iBAAiB,UAAU,OAAO;CAEtC,aAAa,IAAI,oBAAoB,UAAU,OAAO;AACxD;;;;AAKA,SAAS,aAAa,UAAsB,SAA6B;CACvE,IAAI,yBAAyB,QAAQ;EACnC,MAAM,KAAK,oBAAoB,UAAU,EAAE,QAAQ,CAAC;EACpD,aAAa,mBAAmB,EAAE;CACpC;CAGA,MAAM,KAAK,WAAW,UAAU,OAAO;CACvC,aAAa,aAAa,EAAE;AAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,SAAgB,YACd,SACA,SACkB;CAClB,MAAM,OAAO;EAAE,GAAG;EAAgB,GAAG;CAAQ;CAC7C,MAAM,YAA8B,CAAC;CACrC,MAAM,WAA2B,CAAC;;;;CAKlC,SAAS,cAAc,SAAsB,QAA4B;EAEvE,MAAM,WAAW,UAAU,MAAM,MAAM,EAAE,YAAY,OAAO;EAC5D,IAAI,UAAU,UAAU;EAExB,IAAI;GACF,KAAK,iBAAiB,SAAS,MAAM;GAGrC,QAAQ,UAAU,IAAI,mBAAmB;GAGzC,MAAM,UAAU,QAAQ,SAAS,OAAO,KAAK;GAG7C,QAAQ,QAAQ,aAAa;GAC7B,QAAQ,UAAU,OAAO,mBAAmB;GAG5C,IAAI,UAAU;IACZ,SAAS,UAAU,WAAW,KAAA;IAC9B,SAAS,WAAW;GACtB,OACE,UAAU,KAAK;IACb;IACA;IACA,SAAS,WAAW,KAAA;IACpB,UAAU;GACZ,CAAC;GAGH,KAAK,eAAe,SAAS,MAAM;EACrC,SAAS,OAAO;GACd,QAAQ,UAAU,OAAO,mBAAmB;GAC5C,QAAQ,UAAU,IAAI,iBAAiB;GACvC,QAAQ,QAAQ,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;GAE/E,KAAK,iBACH,SACA,QACA,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAC1D;EACF;CACF;;;;CAKA,SAAS,kBAAkB,SAAsB,QAA4B;EAC3E,QAAQ,OAAO,MAAf;GACE,KAAK;IACH,cAAc,SAAS,MAAM;IAC7B;GAEF,KAAK,QAAQ;IACX,MAAM,SAAS,mBAAmB,cAAc,SAAS,MAAM,GAAG,KAAK,WAAW;IAClF,SAAS,KAAK,MAAM;IACpB;GACF;GAEA,KAAK,WAAW;IACd,MAAM,SAAS,kBAAkB,eAAe,cAAc,SAAS,MAAM,GAAG;KAC9E,YAAY,KAAK;KACjB,WAAW,KAAK;IAClB,CAAC;IACD,SAAS,KAAK,MAAM;IACpB;GACF;GAEA,KAAK;IACH,IAAI,OAAO,YAAY;KACrB,MAAM,SAAS,aAAa,OAAO,kBAAkB,cAAc,SAAS,MAAM,CAAC;KACnF,SAAS,KAAK,MAAM;IACtB,OAEE,cAAc,SAAS,MAAM;IAE/B;GAGF,SACE,cAAc,SAAS,MAAM;EACjC;CACF;CAKA,SAF0B,iBAA8B,KAAK,QAEtD,CAAC,CAAC,SAAS,YAAY;EAC5B,MAAM,SAAS,kBAAkB,OAAO;EAGxC,UAAU,KAAK;GACb;GACA;GACA,UAAU;EACZ,CAAC;EAGD,kBAAkB,SAAS,MAAM;CACnC,CAAC;CAGD,OAAO;EACL;EAEA,QAAQ,SAA4B;GAElC,cAAc,SADC,kBAAkB,OACL,CAAC;EAC/B;EAEA,UAAgB;GAEd,SAAS,SAAS,YAAY,QAAQ,CAAC;GACvC,SAAS,SAAS;GAGlB,UAAU,SAAS,aAAa;IAC9B,IAAI,SAAS,SACX,SAAS,QAAQ;GAErB,CAAC;GACD,UAAU,SAAS;EACrB;CACF;AACF;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,mBACd,SACgD;CAChD,QAAQ,YAA6B,YAAY,SAAS,OAAO;AACnE;;;;AAKA,SAAgB,qBAA8B;CAC5C,OACE,OAAO,WAAW,eAClB,OAAO,aAAa,eACpB,OAAO,yBAAyB,eAChC,OAAO,qBAAqB;AAEhC"}