@sigx/server-renderer 0.1.5 → 0.1.6

package/dist/client/plugin.d.ts

@@ -0,0 +1,52 @@
+/**
+ * SSR Client Plugin
+ *
+ * Provides app.hydrate() method for client-side hydration of server-rendered HTML.
+ * This plugin follows the same pattern as the router plugin.
+ */
+import type { Plugin, AppContext } from '@sigx/runtime-core';
+/**
+ * Hydrate function signature - matches MountFn pattern
+ */
+export type HydrateFn<TContainer = any> = (element: any, container: TContainer, appContext: AppContext) => (() => void) | void;
+declare module '@sigx/runtime-core' {
+    interface App<TContainer = any> {
+        /**
+         * Hydrate the app from server-rendered HTML.
+         *
+         * Unlike mount() which creates new DOM, hydrate() attaches to existing
+         * server-rendered DOM, adding event handlers and establishing reactivity.
+         *
+         * @example
+         * ```tsx
+         * import { defineApp } from 'sigx';
+         * import { ssrClientPlugin } from '@sigx/server-renderer/client';
+         *
+         * const app = defineApp(<App />);
+         * app.use(router)
+         *    .use(ssrClientPlugin)
+         *    .hydrate(document.getElementById('app')!);
+         * ```
+         */
+        hydrate(container: TContainer): App<TContainer>;
+    }
+}
+/**
+ * SSR Client Plugin
+ *
+ * Adds the hydrate() method to the app instance for client-side hydration.
+ * Also registers the SSR context extension for all components.
+ *
+ * @example
+ * ```tsx
+ * import { defineApp } from 'sigx';
+ * import { ssrClientPlugin } from '@sigx/server-renderer/client';
+ *
+ * const app = defineApp(<App />);
+ * app.use(ssrClientPlugin)
+ *    .use(router)
+ *    .hydrate('#app');
+ * ```
+ */
+export declare const ssrClientPlugin: Plugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/client/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/client/plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAO,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAQlE;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,UAAU,GAAG,GAAG,IAAI,CACtC,OAAO,EAAE,GAAG,EACZ,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,UAAU,KACrB,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzB,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,GAAG,CAAC,UAAU,GAAG,GAAG;QAC1B;;;;;;;;;;;;;;;;WAgBG;QACH,OAAO,CAAC,SAAS,EAAE,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC;KACnD;CACJ;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,EAAE,MAmD7B,CAAC"}

package/dist/client/registry.d.ts

@@ -3,7 +3,15 @@
  *
  * Components must be registered before they can be hydrated as islands.
  */
-import type { ComponentFactory } from './types.js';
+/**
+ * Minimal type for component factories used in hydration registry.
+ * Compatible with ComponentFactory from runtime-core.
+ */
+export interface ComponentFactory {
+    __setup: Function;
+    __name?: string;
+    __async?: boolean;
+}
 /**
  * Register a component for island hydration.
  * Components must be registered before hydrateIslands() is called.

package/dist/client/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/client/registry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAOnD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAEjF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,IAAI,CAMrF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEvE;AASD;;GAEG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,UAAU,CAAuC;IAEzD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,GAAG,IAAI;IAKzD,WAAW,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,IAAI;IAS/D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAI/C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAG7B"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/client/registry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAOD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAEjF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,IAAI,CAMrF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAEvE;AAID;;GAEG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,UAAU,CAAuC;IAEzD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,GAAG,IAAI;IAKzD,WAAW,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,IAAI;IAS/D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAI/C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAG7B"}

package/dist/client/types.d.ts

@@ -1,14 +1,7 @@
 /**
  * Shared types for client-side hydration
  */
-/**
- * Component factory with setup function
- */
-export interface ComponentFactory {
-    __setup: Function;
-    __name?: string;
-    __async?: boolean;
-}
+export type { VNode } from 'sigx';
 /**
  * Hydration options
  */
@@ -27,17 +20,4 @@ export interface IslandInfo {
     /** Captured signal state from async setup for client hydration */
     state?: Record<string, any>;
 }
-/**
- * VNode representation
- */
-export interface VNode {
-    type: any;
-    props: Record<string, any>;
-    key: string | number | null;
-    children: VNode[];
-    dom: any | null;
-    text?: string | number;
-    parent?: VNode | null;
-    cleanup?: () => void;
-}
 //# sourceMappingURL=types.d.ts.map

package/dist/client/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;CACzE;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,KAAK;IAClB,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,YAAY,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAElC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;CACzE;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B"}

package/dist/client-DiLwBAD-.js

@@ -0,0 +1,541 @@
+import { Fragment, Text, createEmit, createPropsAccessor, createSlots, effect, filterClientDirectives, getCurrentInstance, getHydrationDirective, isComponent, mount, normalizeSubTree, patch, patchProp, provideAppContext, registerContextExtension, render, setCurrentInstance, signal } from "sigx";
+var componentRegistry = /* @__PURE__ */ new Map();
+function registerComponent(name, component) {
+	componentRegistry.set(name, component);
+}
+function registerComponents(components) {
+	for (const [name, component] of Object.entries(components)) if (isComponent(component)) registerComponent(name, component);
+}
+function getComponent(name) {
+	return componentRegistry.get(name);
+}
+var HydrationRegistry = class {
+	constructor() {
+		this.components = /* @__PURE__ */ new Map();
+	}
+	register(name, component) {
+		this.components.set(name, component);
+		return this;
+	}
+	registerAll(components) {
+		for (const [name, component] of Object.entries(components)) if (isComponent(component)) this.register(name, component);
+		return this;
+	}
+	get(name) {
+		return this.components.get(name);
+	}
+	has(name) {
+		return this.components.has(name);
+	}
+};
+var _pendingServerState = null;
+var _currentAppContext = null;
+function setPendingServerState(state) {
+	_pendingServerState = state;
+}
+registerContextExtension((ctx) => {
+	const serverState = _pendingServerState;
+	if (serverState) {
+		ctx._serverState = serverState;
+		_pendingServerState = null;
+		ctx.signal = createRestoringSignal(serverState);
+		ctx.ssr = {
+			load: (_fn) => {},
+			isServer: false,
+			isHydrating: true
+		};
+	} else if (ctx._serverState) ctx.ssr = {
+		load: (_fn) => {},
+		isServer: false,
+		isHydrating: true
+	};
+	else ctx.ssr = {
+		load: (fn) => {
+			fn().catch((err) => console.error("[SSR] load error:", err));
+		},
+		isServer: false,
+		isHydrating: false
+	};
+});
+function createRestoringSignal(serverState) {
+	let signalIndex = 0;
+	return function restoringSignal(initial, name) {
+		const key = name ?? `$${signalIndex++}`;
+		if (key in serverState) return signal(serverState[key]);
+		return signal(initial);
+	};
+}
+function hydrate(element, container, appContext) {
+	const vnode = normalizeElement(element);
+	if (!vnode) return;
+	_currentAppContext = appContext ?? null;
+	hydrateNode(vnode, container.firstChild, container);
+	container._vnode = vnode;
+}
+var _cachedIslandData = null;
+function invalidateIslandCache() {
+	_cachedIslandData = null;
+}
+function getIslandData() {
+	if (_cachedIslandData !== null) return _cachedIslandData;
+	const dataScript = document.getElementById("__SIGX_ISLANDS__");
+	if (!dataScript) {
+		_cachedIslandData = {};
+		return _cachedIslandData;
+	}
+	try {
+		_cachedIslandData = JSON.parse(dataScript.textContent || "{}");
+	} catch {
+		console.error("Failed to parse island data");
+		_cachedIslandData = {};
+	}
+	return _cachedIslandData;
+}
+function getIslandServerState(componentId) {
+	return getIslandData()[String(componentId)]?.state;
+}
+function normalizeElement(element) {
+	if (element == null || element === true || element === false) return null;
+	if (typeof element === "string" || typeof element === "number") return {
+		type: Text,
+		props: {},
+		key: null,
+		children: [],
+		dom: null,
+		text: element
+	};
+	return element;
+}
+function hydrateNode(vnode, dom, parent) {
+	if (!vnode) return dom;
+	while (dom && dom.nodeType === Node.COMMENT_NODE) {
+		if (dom.data.startsWith("$c:")) break;
+		dom = dom.nextSibling;
+	}
+	if (vnode.type === Text) {
+		if (dom && dom.nodeType === Node.TEXT_NODE) {
+			vnode.dom = dom;
+			return dom.nextSibling;
+		}
+		return dom;
+	}
+	if (vnode.type === Fragment) {
+		let current = dom;
+		for (const child of vnode.children) current = hydrateNode(child, current, parent);
+		return current;
+	}
+	if (isComponent(vnode.type)) {
+		const strategy = vnode.props ? getHydrationDirective(vnode.props) : null;
+		if (strategy) return scheduleComponentHydration(vnode, dom, parent, strategy);
+		return hydrateComponent(vnode, dom, parent);
+	}
+	if (typeof vnode.type === "string") {
+		if (!dom || dom.nodeType !== Node.ELEMENT_NODE) {
+			console.warn("[Hydrate] Expected element but got:", dom);
+			return dom;
+		}
+		const el = dom;
+		vnode.dom = el;
+		if (vnode.props) for (const key in vnode.props) {
+			if (key === "children" || key === "key") continue;
+			if (key.startsWith("client:")) continue;
+			patchProp(el, key, null, vnode.props[key]);
+		}
+		let childDom = el.firstChild;
+		for (const child of vnode.children) childDom = hydrateNode(child, childDom, el);
+		if (vnode.type === "select" && vnode.props) fixSelectValue(el, vnode.props);
+		return el.nextSibling;
+	}
+	return dom;
+}
+function scheduleComponentHydration(vnode, dom, parent, strategy) {
+	const { contentStart, trailingMarker } = findComponentBoundaries(dom);
+	const capturedAppContext = _currentAppContext;
+	const doHydrate = () => {
+		const prevAppContext = _currentAppContext;
+		_currentAppContext = capturedAppContext;
+		try {
+			hydrateComponent(vnode, contentStart, parent, void 0, trailingMarker);
+		} finally {
+			_currentAppContext = prevAppContext;
+		}
+	};
+	switch (strategy.strategy) {
+		case "load":
+			doHydrate();
+			break;
+		case "idle":
+			if ("requestIdleCallback" in window) requestIdleCallback(() => doHydrate());
+			else setTimeout(() => doHydrate(), 200);
+			break;
+		case "visible":
+			observeComponentVisibility(contentStart, trailingMarker, doHydrate);
+			break;
+		case "media":
+			if (strategy.media) {
+				const mql = window.matchMedia(strategy.media);
+				if (mql.matches) doHydrate();
+				else {
+					const handler = (e) => {
+						if (e.matches) {
+							mql.removeEventListener("change", handler);
+							doHydrate();
+						}
+					};
+					mql.addEventListener("change", handler);
+				}
+			}
+			break;
+		case "only":
+			doHydrate();
+			break;
+	}
+	return trailingMarker ? trailingMarker.nextSibling : dom;
+}
+function findComponentBoundaries(dom) {
+	let contentStart = dom;
+	let trailingMarker = null;
+	let current = dom;
+	while (current) {
+		if (current.nodeType === Node.COMMENT_NODE) {
+			if (current.data.startsWith("$c:")) {
+				trailingMarker = current;
+				break;
+			}
+		}
+		current = current.nextSibling;
+	}
+	return {
+		contentStart,
+		trailingMarker
+	};
+}
+function observeComponentVisibility(contentStart, trailingMarker, callback) {
+	let targetElement = null;
+	let current = contentStart;
+	while (current && current !== trailingMarker) {
+		if (current.nodeType === Node.ELEMENT_NODE) {
+			targetElement = current;
+			break;
+		}
+		current = current.nextSibling;
+	}
+	if (!targetElement) {
+		callback();
+		return;
+	}
+	const observer = new IntersectionObserver((entries) => {
+		for (const entry of entries) if (entry.isIntersecting) {
+			observer.disconnect();
+			callback();
+			break;
+		}
+	}, { rootMargin: "50px" });
+	observer.observe(targetElement);
+}
+function hydrateComponent(vnode, dom, parent, serverState, trailingMarker) {
+	const componentFactory = vnode.type;
+	const setup = componentFactory.__setup;
+	const componentName = componentFactory.__name || "Anonymous";
+	if (componentName && componentName !== "Anonymous") registerComponent(componentName, componentFactory);
+	let anchor = trailingMarker || null;
+	let componentId = null;
+	if (!anchor) {
+		let current = dom;
+		while (current) {
+			if (current.nodeType === Node.COMMENT_NODE) {
+				const text = current.data;
+				if (text.startsWith("$c:")) {
+					anchor = current;
+					componentId = parseInt(text.slice(3), 10);
+					break;
+				}
+			}
+			current = current.nextSibling;
+		}
+	} else {
+		const text = anchor.data;
+		if (text.startsWith("$c:")) componentId = parseInt(text.slice(3), 10);
+	}
+	if (!serverState && componentId !== null) serverState = getIslandServerState(componentId);
+	const internalVNode = vnode;
+	const { children, slots: slotsFromProps, $models: modelsData, ...propsData } = filterClientDirectives(vnode.props || {});
+	const reactiveProps = signal(propsData);
+	internalVNode._componentProps = reactiveProps;
+	const slots = createSlots(children, slotsFromProps);
+	internalVNode._slots = slots;
+	const mountHooks = [];
+	const unmountHooks = [];
+	const createdHooks = [];
+	const updatedHooks = [];
+	const parentInstance = getCurrentInstance();
+	const signalFn = serverState ? createRestoringSignal(serverState) : signal;
+	const ssrHelper = {
+		load(_fn) {},
+		isServer: false,
+		isHydrating: !!serverState
+	};
+	const componentCtx = {
+		el: parent,
+		signal: signalFn,
+		props: createPropsAccessor(reactiveProps),
+		slots,
+		emit: createEmit(reactiveProps),
+		parent: parentInstance,
+		onMounted: (fn) => {
+			mountHooks.push(fn);
+		},
+		onUnmounted: (fn) => {
+			unmountHooks.push(fn);
+		},
+		onCreated: (fn) => {
+			createdHooks.push(fn);
+		},
+		onUpdated: (fn) => {
+			updatedHooks.push(fn);
+		},
+		expose: () => {},
+		renderFn: null,
+		update: () => {},
+		ssr: ssrHelper,
+		_serverState: serverState
+	};
+	if (!parentInstance && _currentAppContext) provideAppContext(componentCtx, _currentAppContext);
+	const prev = setCurrentInstance(componentCtx);
+	let renderFn;
+	try {
+		renderFn = setup(componentCtx);
+	} catch (err) {
+		console.error(`Error hydrating component ${componentName}:`, err);
+	} finally {
+		setCurrentInstance(prev);
+	}
+	let endDom = dom;
+	if (renderFn) {
+		componentCtx.renderFn = renderFn;
+		let isFirstRender = true;
+		const componentEffect = effect(() => {
+			const prevInstance = setCurrentInstance(componentCtx);
+			try {
+				const subTreeResult = componentCtx.renderFn();
+				const prevSubTree = internalVNode._subTree;
+				if (subTreeResult == null) {
+					if (isFirstRender) isFirstRender = false;
+					else if (prevSubTree && prevSubTree.dom) {
+						const patchContainer = prevSubTree.dom.parentNode || parent;
+						const emptyNode = normalizeSubTree(null);
+						patch(prevSubTree, emptyNode, patchContainer);
+						internalVNode._subTree = emptyNode;
+					}
+					return;
+				}
+				const subTree = normalizeSubTree(subTreeResult);
+				if (isFirstRender) {
+					isFirstRender = false;
+					endDom = hydrateNode(subTree, dom, parent);
+					internalVNode._subTree = subTree;
+				} else {
+					if (prevSubTree) patch(prevSubTree, subTree, prevSubTree.dom?.parentNode || parent);
+					else mount(subTree, parent, anchor || null);
+					internalVNode._subTree = subTree;
+				}
+			} finally {
+				setCurrentInstance(prevInstance);
+			}
+		});
+		internalVNode._effect = componentEffect;
+		componentCtx.update = () => componentEffect();
+	}
+	vnode.dom = anchor || endDom;
+	const mountCtx = { el: parent };
+	createdHooks.forEach((hook) => hook());
+	mountHooks.forEach((hook) => hook(mountCtx));
+	vnode.cleanup = () => {
+		unmountHooks.forEach((hook) => hook(mountCtx));
+	};
+	return anchor ? anchor.nextSibling : endDom;
+}
+function fixSelectValue(dom, props) {
+	if (dom.tagName === "SELECT" && "value" in props) {
+		const val = props.value;
+		if (dom.multiple) {
+			const options = dom.options;
+			const valArray = Array.isArray(val) ? val : [val];
+			for (let i = 0; i < options.length; i++) options[i].selected = valArray.includes(options[i].value);
+		} else dom.value = String(val);
+	}
+}
+function hydrateIslands() {
+	const dataScript = document.getElementById("__SIGX_ISLANDS__");
+	if (!dataScript) return;
+	let islandData;
+	try {
+		islandData = JSON.parse(dataScript.textContent || "{}");
+	} catch {
+		console.error("Failed to parse island data");
+		return;
+	}
+	for (const [idStr, info] of Object.entries(islandData)) scheduleHydration(parseInt(idStr, 10), info);
+}
+function scheduleHydration(id, info) {
+	const marker = findIslandMarker(id);
+	if (!marker) {
+		console.warn(`Island marker not found for id ${id}`);
+		return;
+	}
+	const component = info.componentId ? getComponent(info.componentId) : null;
+	if (!component && info.strategy !== "only") {
+		console.warn(`Component "${info.componentId}" not registered for hydration`);
+		return;
+	}
+	switch (info.strategy) {
+		case "load":
+			hydrateIsland(marker, component, info);
+			break;
+		case "idle":
+			if ("requestIdleCallback" in window) requestIdleCallback(() => hydrateIsland(marker, component, info));
+			else setTimeout(() => hydrateIsland(marker, component, info), 200);
+			break;
+		case "visible":
+			observeVisibility(marker, () => hydrateIsland(marker, component, info));
+			break;
+		case "media":
+			if (info.media) {
+				const mql = window.matchMedia(info.media);
+				if (mql.matches) hydrateIsland(marker, component, info);
+				else mql.addEventListener("change", function handler(e) {
+					if (e.matches) {
+						mql.removeEventListener("change", handler);
+						hydrateIsland(marker, component, info);
+					}
+				});
+			}
+			break;
+		case "only":
+			if (component) mountClientOnly(marker, component, info);
+			break;
+	}
+}
+function findIslandMarker(id) {
+	const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_COMMENT, null);
+	let node;
+	while (node = walker.nextNode()) if (node.data === `$c:${id}`) return node;
+	return null;
+}
+function observeVisibility(marker, callback) {
+	let node = marker.previousSibling;
+	while (node && node.nodeType !== Node.ELEMENT_NODE) node = node.previousSibling;
+	if (!node) {
+		callback();
+		return;
+	}
+	const observer = new IntersectionObserver((entries) => {
+		for (const entry of entries) if (entry.isIntersecting) {
+			observer.disconnect();
+			callback();
+			break;
+		}
+	});
+	observer.observe(node);
+}
+function hydrateIsland(marker, component, info) {
+	let container = marker.previousSibling;
+	while (container && container.nodeType !== Node.ELEMENT_NODE) container = container.previousSibling;
+	if (!container || container.nodeType !== Node.ELEMENT_NODE) {
+		console.warn("No element found for island hydration");
+		return;
+	}
+	const props = info.props || {};
+	if (info.state) setPendingServerState(info.state);
+	const vnode = {
+		type: component,
+		props,
+		key: null,
+		children: [],
+		dom: null
+	};
+	const wrapper = document.createElement("div");
+	wrapper.style.display = "contents";
+	const parent = container.parentNode;
+	parent.insertBefore(wrapper, container);
+	parent.removeChild(container);
+	render(vnode, wrapper);
+}
+function mountClientOnly(marker, component, info) {
+	let placeholder = marker.previousSibling;
+	while (placeholder && placeholder.nodeType !== Node.ELEMENT_NODE) placeholder = placeholder.previousSibling;
+	if (!placeholder || !placeholder.hasAttribute?.("data-island")) return;
+	const props = info.props || {};
+	const container = placeholder;
+	container.innerHTML = "";
+	render({
+		type: component,
+		props,
+		key: null,
+		children: [],
+		dom: null
+	}, container);
+}
+var _asyncListenerSetup = false;
+function ensureAsyncHydrationListener() {
+	if (_asyncListenerSetup) return;
+	_asyncListenerSetup = true;
+	document.addEventListener("sigx:async-ready", (event) => {
+		const { id, state } = event.detail || {};
+		invalidateIslandCache();
+		const placeholder = document.querySelector(`[data-async-placeholder="${id}"]`);
+		if (!placeholder) {
+			console.warn(`[Hydrate] Could not find placeholder for async component ${id}`);
+			return;
+		}
+		const info = getIslandData()[String(id)];
+		if (!info) {
+			console.warn(`[Hydrate] No island data for async component ${id}`);
+			return;
+		}
+		hydrateAsyncComponent(placeholder, info);
+	});
+}
+if (typeof document !== "undefined") ensureAsyncHydrationListener();
+function hydrateAsyncComponent(container, info) {
+	if (!info.componentId) {
+		console.error(`[Hydrate] No componentId in island info`);
+		return;
+	}
+	const component = getComponent(info.componentId);
+	if (!component) {
+		console.error(`[Hydrate] Component "${info.componentId}" not registered`);
+		return;
+	}
+	const props = info.props || {};
+	const serverState = info.state;
+	container.innerHTML = "";
+	if (serverState) setPendingServerState(serverState);
+	render({
+		type: component,
+		props,
+		key: null,
+		children: [],
+		dom: null
+	}, container);
+}
+const ssrClientPlugin = {
+	name: "@sigx/server-renderer/client",
+	install(app) {
+		app.hydrate = function(container) {
+			const resolvedContainer = typeof container === "string" ? document.querySelector(container) : container;
+			if (!resolvedContainer) throw new Error(`[ssrClientPlugin] Cannot find container: ${container}. Make sure the element exists in the DOM before calling hydrate().`);
+			const rootComponent = app._rootComponent;
+			if (!rootComponent) throw new Error("[ssrClientPlugin] No root component found on app. Make sure you created the app with defineApp(<Component />).");
+			const hasSSRContent = resolvedContainer.firstElementChild !== null || resolvedContainer.firstChild !== null && resolvedContainer.firstChild.nodeType !== Node.COMMENT_NODE;
+			const appContext = app._context;
+			if (hasSSRContent) hydrate(rootComponent, resolvedContainer, appContext);
+			else render(rootComponent, resolvedContainer, appContext);
+			resolvedContainer._app = app;
+			return app;
+		};
+	}
+};
+export { registerComponents as a, registerComponent as i, hydrateIslands as n, HydrationRegistry as r, ssrClientPlugin as t };
+
+//# sourceMappingURL=client-DiLwBAD-.js.map