@sigx/server-renderer 0.1.4 → 0.1.6

package/dist/server-BCOJt2Bi.js

@@ -0,0 +1,459 @@
+import { Fragment, Text, createPropsAccessor, filterClientDirectives, getHydrationDirective, isComponent, provideAppContext, serializeProps, setCurrentInstance, signal } from "sigx";
+function createSSRContext(options = {}) {
+	let componentId = 0;
+	const componentStack = [];
+	const islands = /* @__PURE__ */ new Map();
+	const head = [];
+	const pendingAsync = [];
+	return {
+		_componentId: componentId,
+		_componentStack: componentStack,
+		_islands: islands,
+		_head: head,
+		_pendingAsync: pendingAsync,
+		nextId() {
+			return ++componentId;
+		},
+		pushComponent(id) {
+			componentStack.push(id);
+		},
+		popComponent() {
+			return componentStack.pop();
+		},
+		registerIsland(id, info) {
+			islands.set(id, info);
+		},
+		getIslands() {
+			return islands;
+		},
+		addHead(html) {
+			head.push(html);
+		},
+		getHead() {
+			return head.join("\n");
+		},
+		addPendingAsync(pending) {
+			pendingAsync.push(pending);
+		},
+		getPendingAsync() {
+			return pendingAsync;
+		}
+	};
+}
+function isApp(input) {
+	return input && typeof input === "object" && "_rootComponent" in input && "_context" in input;
+}
+function createTrackingSignal(signalMap) {
+	let signalIndex = 0;
+	return function trackingSignal(initial, name) {
+		const key = name ?? `$${signalIndex++}`;
+		const sig = signal(initial);
+		signalMap.set(key, initial);
+		return new Proxy(sig, {
+			get(target, prop) {
+				if (prop === "value") return target.value;
+				return target[prop];
+			},
+			set(target, prop, newValue) {
+				if (prop === "value") {
+					target.value = newValue;
+					signalMap.set(key, newValue);
+					return true;
+				}
+				target[prop] = newValue;
+				return true;
+			}
+		});
+	};
+}
+function serializeSignalState(signalMap) {
+	if (signalMap.size === 0) return void 0;
+	const state = {};
+	for (const [key, value] of signalMap) try {
+		JSON.stringify(value);
+		state[key] = value;
+	} catch {
+		console.warn(`SSR: Signal "${key}" has non-serializable value, skipping`);
+	}
+	return Object.keys(state).length > 0 ? state : void 0;
+}
+async function* renderToChunks(element, ctx, parentCtx = null, appContext = null) {
+	if (element == null || element === false || element === true) return;
+	if (typeof element === "string" || typeof element === "number") {
+		yield escapeHtml(String(element));
+		return;
+	}
+	const vnode = element;
+	if (vnode.type === Text) {
+		yield escapeHtml(String(vnode.text));
+		return;
+	}
+	if (vnode.type === Fragment) {
+		for (const child of vnode.children) yield* renderToChunks(child, ctx, parentCtx, appContext);
+		return;
+	}
+	if (isComponent(vnode.type)) {
+		const setup = vnode.type.__setup;
+		const componentName = vnode.type.__name || "Anonymous";
+		const allProps = vnode.props || {};
+		const hydration = getHydrationDirective(allProps);
+		const { children, slots: slotsFromProps, $models: modelsData, ...propsData } = filterClientDirectives(allProps);
+		const id = ctx.nextId();
+		ctx.pushComponent(id);
+		const signalMap = /* @__PURE__ */ new Map();
+		const shouldTrackState = !!hydration;
+		if (hydration) {
+			const islandInfo = {
+				strategy: hydration.strategy,
+				media: hydration.media,
+				props: serializeProps(propsData),
+				componentId: componentName
+			};
+			ctx.registerIsland(id, islandInfo);
+		}
+		if (hydration?.strategy === "only") {
+			yield `<div data-island="${id}"></div>`;
+			yield `<!--$c:${id}-->`;
+			ctx.popComponent();
+			return;
+		}
+		const slots = {
+			default: () => children ? Array.isArray(children) ? children : [children] : [],
+			...slotsFromProps
+		};
+		const signalFn = shouldTrackState ? createTrackingSignal(signalMap) : signal;
+		const ssrLoads = [];
+		const componentCtx = {
+			el: null,
+			signal: signalFn,
+			props: createPropsAccessor(propsData),
+			slots,
+			emit: () => {},
+			parent: parentCtx,
+			onMounted: () => {},
+			onUnmounted: () => {},
+			onCreated: () => {},
+			onUpdated: () => {},
+			expose: () => {},
+			renderFn: null,
+			update: () => {},
+			ssr: {
+				load(fn) {
+					ssrLoads.push(fn());
+				},
+				isServer: true,
+				isHydrating: false
+			},
+			_signals: shouldTrackState ? signalMap : void 0,
+			_ssrLoads: ssrLoads
+		};
+		if (!parentCtx && appContext) provideAppContext(componentCtx, appContext);
+		const prev = setCurrentInstance(componentCtx);
+		try {
+			let renderFn = setup(componentCtx);
+			if (renderFn && typeof renderFn.then === "function") renderFn = await renderFn;
+			if (ssrLoads.length > 0 && hydration) {
+				const deferredRender = (async () => {
+					await Promise.all(ssrLoads);
+					let html = "";
+					if (renderFn) {
+						const result = renderFn();
+						if (result) html = await renderVNodeToString(result, ctx);
+					}
+					if (signalMap.size > 0) {
+						const state = serializeSignalState(signalMap);
+						if (state) {
+							const islandInfo = ctx.getIslands().get(id);
+							if (islandInfo) islandInfo.state = state;
+						}
+					}
+					return html;
+				})();
+				const islandInfo = ctx.getIslands().get(id);
+				ctx.addPendingAsync({
+					id,
+					promise: deferredRender,
+					signalMap,
+					islandInfo
+				});
+				yield `<div data-async-placeholder="${id}" style="display:contents;">`;
+				if (renderFn) {
+					const result = renderFn();
+					if (result) if (Array.isArray(result)) for (const item of result) yield* renderToChunks(item, ctx, componentCtx, appContext);
+					else yield* renderToChunks(result, ctx, componentCtx, appContext);
+				}
+				yield `</div>`;
+			} else {
+				if (ssrLoads.length > 0) await Promise.all(ssrLoads);
+				if (shouldTrackState && signalMap.size > 0) {
+					const state = serializeSignalState(signalMap);
+					if (state) {
+						const islandInfo = ctx.getIslands().get(id);
+						if (islandInfo) islandInfo.state = state;
+					}
+				}
+				if (renderFn) {
+					const result = renderFn();
+					if (result) if (Array.isArray(result)) for (const item of result) yield* renderToChunks(item, ctx, componentCtx, appContext);
+					else yield* renderToChunks(result, ctx, componentCtx, appContext);
+				}
+			}
+		} catch (e) {
+			console.error(`Error rendering component ${componentName}:`, e);
+		} finally {
+			setCurrentInstance(prev || null);
+		}
+		yield `<!--$c:${id}-->`;
+		ctx.popComponent();
+		return;
+	}
+	if (typeof vnode.type === "string") {
+		const tagName = vnode.type;
+		let props = "";
+		for (const key in vnode.props) {
+			const value = vnode.props[key];
+			if (key === "children" || key === "key" || key === "ref") continue;
+			if (key.startsWith("client:")) continue;
+			if (key === "style") {
+				const styleString = typeof value === "object" ? Object.entries(value).map(([k, v]) => `${camelToKebab(k)}:${v}`).join(";") : String(value);
+				props += ` style="${escapeHtml(styleString)}"`;
+			} else if (key === "className") props += ` class="${escapeHtml(String(value))}"`;
+			else if (key.startsWith("on")) {} else if (value === true) props += ` ${key}`;
+			else if (value !== false && value != null) props += ` ${key}="${escapeHtml(String(value))}"`;
+		}
+		if ([
+			"area",
+			"base",
+			"br",
+			"col",
+			"embed",
+			"hr",
+			"img",
+			"input",
+			"link",
+			"meta",
+			"param",
+			"source",
+			"track",
+			"wbr"
+		].includes(tagName)) {
+			yield `<${tagName}${props}>`;
+			return;
+		}
+		yield `<${tagName}${props}>`;
+		let prevWasText = false;
+		for (const child of vnode.children) {
+			const isText = isTextContent(child);
+			if (isText && prevWasText) yield "<!--t-->";
+			yield* renderToChunks(child, ctx, parentCtx, appContext);
+			prevWasText = isText;
+		}
+		yield `</${tagName}>`;
+	}
+}
+function isTextContent(element) {
+	if (element == null || element === false || element === true) return false;
+	if (typeof element === "string" || typeof element === "number") return true;
+	return element.type === Text;
+}
+async function renderVNodeToString(element, ctx, appContext = null) {
+	let result = "";
+	for await (const chunk of renderToChunks(element, ctx, null, appContext)) result += chunk;
+	return result;
+}
+function renderToStream(input, context) {
+	const ctx = context || createSSRContext();
+	let element;
+	let appContext = null;
+	if (isApp(input)) {
+		element = input._rootComponent;
+		appContext = input._context;
+	} else element = input;
+	return new ReadableStream({ async start(controller) {
+		try {
+			for await (const chunk of renderToChunks(element, ctx, null, appContext)) controller.enqueue(chunk);
+			const pendingAsync = ctx.getPendingAsync();
+			if (pendingAsync.length > 0) {
+				controller.enqueue(generateStreamingScript());
+				await Promise.all(pendingAsync.map(async (pending) => {
+					try {
+						const html = await pending.promise;
+						const state = serializeSignalState(pending.signalMap);
+						if (state) pending.islandInfo.state = state;
+						controller.enqueue(generateReplacementScript(pending.id, html, state));
+					} catch (error) {
+						console.error(`Error streaming async component ${pending.id}:`, error);
+						controller.enqueue(generateReplacementScript(pending.id, `<div style="color:red;">Error loading component</div>`, void 0));
+					}
+				}));
+			}
+			if (ctx.getIslands().size > 0) controller.enqueue(generateHydrationScript(ctx));
+			controller.enqueue(`<script>window.__SIGX_STREAMING_COMPLETE__ = true; window.dispatchEvent(new Event('sigx:ready'));<\/script>`);
+			controller.close();
+		} catch (error) {
+			controller.error(error);
+		}
+	} });
+}
+async function renderToStreamWithCallbacks(input, callbacks, context) {
+	const ctx = context || createSSRContext();
+	let element;
+	let appContext = null;
+	if (isApp(input)) {
+		element = input._rootComponent;
+		appContext = input._context;
+	} else element = input;
+	try {
+		let shellHtml = "";
+		for await (const chunk of renderToChunks(element, ctx, null, appContext)) shellHtml += chunk;
+		const pendingAsync = ctx.getPendingAsync();
+		const syncIslandIds = /* @__PURE__ */ new Set();
+		const pendingAsyncIds = new Set(pendingAsync.map((p) => p.id));
+		ctx.getIslands().forEach((_, id) => {
+			if (!pendingAsyncIds.has(id)) syncIslandIds.add(id);
+		});
+		if (syncIslandIds.size > 0) shellHtml += generateSyncHydrationScript(ctx, syncIslandIds);
+		if (pendingAsync.length > 0) shellHtml += `<script>window.__SIGX_PENDING_ISLANDS__ = {};<\/script>`;
+		shellHtml += `<script>window.__SIGX_STREAMING_COMPLETE__ = true; window.dispatchEvent(new Event('sigx:ready'));<\/script>`;
+		callbacks.onShellReady(shellHtml);
+		if (pendingAsync.length > 0) {
+			callbacks.onAsyncChunk(generateStreamingScript());
+			await Promise.all(pendingAsync.map(async (pending) => {
+				try {
+					const html = await pending.promise;
+					const state = serializeSignalState(pending.signalMap);
+					if (state) pending.islandInfo.state = state;
+					callbacks.onAsyncChunk(generateReplacementScriptWithIsland(pending.id, html, pending.islandInfo));
+				} catch (error) {
+					console.error(`Error streaming async component ${pending.id}:`, error);
+					callbacks.onAsyncChunk(generateReplacementScript(pending.id, `<div style="color:red;">Error loading component</div>`, void 0));
+				}
+			}));
+			callbacks.onAsyncChunk(`<script>window.dispatchEvent(new Event('sigx:async-complete'));<\/script>`);
+		}
+		callbacks.onComplete();
+	} catch (error) {
+		callbacks.onError(error);
+	}
+}
+async function renderToString(input, context) {
+	const ctx = context || createSSRContext();
+	let element;
+	let appContext = null;
+	if (isApp(input)) {
+		element = input._rootComponent;
+		appContext = input._context;
+	} else element = input;
+	let result = "";
+	for await (const chunk of renderToChunks(element, ctx, null, appContext)) result += chunk;
+	const pendingAsync = ctx.getPendingAsync();
+	if (pendingAsync.length > 0) {
+		result += generateStreamingScript();
+		await Promise.all(pendingAsync.map(async (pending) => {
+			try {
+				const html = await pending.promise;
+				const state = serializeSignalState(pending.signalMap);
+				if (state) pending.islandInfo.state = state;
+				result += generateReplacementScript(pending.id, html, state);
+			} catch (error) {
+				console.error(`Error rendering async component ${pending.id}:`, error);
+				result += generateReplacementScript(pending.id, `<div style="color:red;">Error loading component</div>`, void 0);
+			}
+		}));
+	}
+	if (ctx.getIslands().size > 0) result += generateHydrationScript(ctx);
+	return result;
+}
+function generateStreamingScript() {
+	return `
+<script>
+window.$SIGX_REPLACE = function(id, html, state) {
+    var placeholder = document.querySelector('[data-async-placeholder="' + id + '"]');
+    if (placeholder) {
+        // Create a template to parse the HTML
+        var template = document.createElement('template');
+        template.innerHTML = html;
+        
+        // Replace placeholder content
+        placeholder.innerHTML = '';
+        while (template.content.firstChild) {
+            placeholder.appendChild(template.content.firstChild);
+        }
+        
+        // Update island state in the hydration data
+        if (state) {
+            var dataScript = document.getElementById('__SIGX_ISLANDS__');
+            if (dataScript) {
+                try {
+                    var data = JSON.parse(dataScript.textContent || '{}');
+                    if (data[id]) {
+                        data[id].state = state;
+                        dataScript.textContent = JSON.stringify(data);
+                    }
+                } catch(e) {}
+            }
+        }
+        
+        // Dispatch event for hydration to pick up
+        placeholder.dispatchEvent(new CustomEvent('sigx:async-ready', { bubbles: true, detail: { id: id, state: state } }));
+    }
+};
+<\/script>`;
+}
+function generateReplacementScript(id, html, state) {
+	return `<script>$SIGX_REPLACE(${id}, ${JSON.stringify(html)}, ${state ? JSON.stringify(state) : "null"});<\/script>`;
+}
+function generateReplacementScriptWithIsland(id, html, islandInfo) {
+	const escapedHtml = JSON.stringify(html);
+	return `<script>
+(function() {
+    // Add island data to the existing hydration data
+    var dataScript = document.getElementById('__SIGX_ISLANDS__');
+    if (dataScript) {
+        try {
+            var data = JSON.parse(dataScript.textContent || '{}');
+            data[${id}] = ${JSON.stringify(islandInfo)};
+            dataScript.textContent = JSON.stringify(data);
+        } catch(e) { console.error('Failed to update island data:', e); }
+    }
+    // Replace the placeholder content
+    $SIGX_REPLACE(${id}, ${escapedHtml}, ${islandInfo.state ? JSON.stringify(islandInfo.state) : "null"});
+})();
+<\/script>`;
+}
+function generateSyncHydrationScript(ctx, syncIslandIds) {
+	const islands = ctx.getIslands();
+	const islandData = {};
+	islands.forEach((info, id) => {
+		if (syncIslandIds.has(id)) islandData[id] = info;
+	});
+	if (Object.keys(islandData).length === 0) return "";
+	return `
+<script type="application/json" id="__SIGX_ISLANDS__">${JSON.stringify(islandData)}<\/script>`;
+}
+function generateHydrationScript(ctx) {
+	const islands = ctx.getIslands();
+	if (islands.size === 0) return "";
+	const islandData = {};
+	islands.forEach((info, id) => {
+		islandData[id] = info;
+	});
+	return `
+<script type="application/json" id="__SIGX_ISLANDS__">${JSON.stringify(islandData)}<\/script>`;
+}
+var ESCAPE = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function escapeHtml(s) {
+	return s.replace(/[&<>"']/g, (c) => ESCAPE[c]);
+}
+function camelToKebab(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+export { createSSRContext as i, renderToStreamWithCallbacks as n, renderToString as r, renderToStream as t };
+
+//# sourceMappingURL=server-BCOJt2Bi.js.map

package/dist/server-BCOJt2Bi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-BCOJt2Bi.js","names":[],"sources":["../src/server/context.ts","../src/server/stream.ts"],"sourcesContent":["/**\r\n * SSR Context - tracks component boundaries and hydration markers during rendering\r\n */\r\n\r\nexport interface SSRContextOptions {\r\n    /**\r\n     * Enable streaming mode (default: true)\r\n     */\r\n    streaming?: boolean;\r\n}\r\n\r\nexport interface RenderOptions {\r\n    /**\r\n     * Custom SSR context (created automatically if not provided)\r\n     */\r\n    context?: SSRContext;\r\n}\r\n\r\nexport interface SSRContext {\r\n    /**\r\n     * Unique ID counter for component markers\r\n     */\r\n    _componentId: number;\r\n\r\n    /**\r\n     * Stack of component IDs for nested tracking\r\n     */\r\n    _componentStack: number[];\r\n\r\n    /**\r\n     * Registered islands and their hydration strategies\r\n     */\r\n    _islands: Map<number, IslandInfo>;\r\n\r\n    /**\r\n     * Collected head elements (scripts, styles, etc.)\r\n     */\r\n    _head: string[];\r\n\r\n    /**\r\n     * Pending async components for streaming\r\n     */\r\n    _pendingAsync: PendingAsyncComponent[];\r\n\r\n    /**\r\n     * Generate next component ID\r\n     */\r\n    nextId(): number;\r\n\r\n    /**\r\n     * Push a component onto the stack\r\n     */\r\n    pushComponent(id: number): void;\r\n\r\n    /**\r\n     * Pop the current component from stack\r\n     */\r\n    popComponent(): number | undefined;\r\n\r\n    /**\r\n     * Register an island for selective hydration\r\n     */\r\n    registerIsland(id: number, info: IslandInfo): void;\r\n\r\n    /**\r\n     * Get all registered islands\r\n     */\r\n    getIslands(): Map<number, IslandInfo>;\r\n\r\n    /**\r\n     * Add a head element\r\n     */\r\n    addHead(html: string): void;\r\n\r\n    /**\r\n     * Get collected head HTML\r\n     */\r\n    getHead(): string;\r\n\r\n    /**\r\n     * Register a pending async component for streaming\r\n     */\r\n    addPendingAsync(pending: PendingAsyncComponent): void;\r\n\r\n    /**\r\n     * Get all pending async components\r\n     */\r\n    getPendingAsync(): PendingAsyncComponent[];\r\n}\r\n\r\nexport interface IslandInfo {\r\n    /**\r\n     * Hydration strategy: 'load' | 'idle' | 'visible' | 'media' | 'only'\r\n     */\r\n    strategy: HydrationStrategy;\r\n\r\n    /**\r\n     * Media query for 'media' strategy\r\n     */\r\n    media?: string;\r\n\r\n    /**\r\n     * Component props to serialize for client hydration\r\n     */\r\n    props?: Record<string, any>;\r\n\r\n    /**\r\n     * Component name/identifier for client\r\n     */\r\n    componentId?: string;\r\n\r\n    /**\r\n     * Captured signal state from async setup for client hydration\r\n     */\r\n    state?: Record<string, any>;\r\n\r\n    /**\r\n     * Placeholder HTML for streaming async components\r\n     */\r\n    placeholder?: string;\r\n}\r\n\r\n/**\r\n * Pending async component that will be streamed later\r\n */\r\nexport interface PendingAsyncComponent {\r\n    /** Component ID */\r\n    id: number;\r\n    /** Promise that resolves to rendered HTML */\r\n    promise: Promise<string>;\r\n    /** Signal state captured during render */\r\n    signalMap: Map<string, any>;\r\n    /** Island info reference */\r\n    islandInfo: IslandInfo;\r\n}\r\n\r\nexport type HydrationStrategy = 'load' | 'idle' | 'visible' | 'media' | 'only';\r\n\r\n/**\r\n * Create a new SSR context for rendering\r\n */\r\nexport function createSSRContext(options: SSRContextOptions = {}): SSRContext {\r\n    let componentId = 0;\r\n    const componentStack: number[] = [];\r\n    const islands = new Map<number, IslandInfo>();\r\n    const head: string[] = [];\r\n    const pendingAsync: PendingAsyncComponent[] = [];\r\n\r\n    return {\r\n        _componentId: componentId,\r\n        _componentStack: componentStack,\r\n        _islands: islands,\r\n        _head: head,\r\n        _pendingAsync: pendingAsync,\r\n\r\n        nextId() {\r\n            return ++componentId;\r\n        },\r\n\r\n        pushComponent(id: number) {\r\n            componentStack.push(id);\r\n        },\r\n\r\n        popComponent() {\r\n            return componentStack.pop();\r\n        },\r\n\r\n        registerIsland(id: number, info: IslandInfo) {\r\n            islands.set(id, info);\r\n        },\r\n\r\n        getIslands() {\r\n            return islands;\r\n        },\r\n\r\n        addHead(html: string) {\r\n            head.push(html);\r\n        },\r\n\r\n        getHead() {\r\n            return head.join('\\n');\r\n        },\r\n\r\n        addPendingAsync(pending: PendingAsyncComponent) {\r\n            pendingAsync.push(pending);\r\n        },\r\n\r\n        getPendingAsync() {\r\n            return pendingAsync;\r\n        }\r\n    };\r\n}\r\n","/**\r\n * Streaming SSR renderer with hydration markers\r\n */\r\n\r\nimport {\r\n    VNode,\r\n    Fragment,\r\n    JSXElement,\r\n    ComponentSetupContext,\r\n    setCurrentInstance,\r\n    getCurrentInstance,\r\n    signal,\r\n    Signal,\r\n    Text,\r\n    SlotsObject,\r\n    PropsAccessor,\r\n    isComponent,\r\n    createPropsAccessor,\r\n    getHydrationDirective,\r\n    filterClientDirectives,\r\n    serializeProps,\r\n    provideAppContext\r\n} from 'sigx';\r\nimport type { App, AppContext } from 'sigx';\r\nimport { SSRContext, createSSRContext, IslandInfo, HydrationStrategy, PendingAsyncComponent } from './context.js';\r\n\r\n/**\r\n * Check if the input is an App instance (created via defineApp)\r\n */\r\nfunction isApp(input: any): input is App<any> {\r\n    return input && typeof input === 'object' && '_rootComponent' in input && '_context' in input;\r\n}\r\n\r\n/**\r\n * Creates a tracking signal function that records signal names and values.\r\n * Used during async setup to capture state for client hydration.\r\n */\r\nfunction createTrackingSignal(signalMap: Map<string, any>) {\r\n    let signalIndex = 0;\r\n\r\n    return function trackingSignal<T extends object>(initial: T, name?: string): Signal<T> {\r\n        // Generate a stable key for this signal\r\n        const key = name ?? `$${signalIndex++}`;\r\n\r\n        // Create the real signal\r\n        const sig = signal(initial);\r\n\r\n        // Capture initial value\r\n        signalMap.set(key, initial);\r\n\r\n        // Create a proxy that tracks writes\r\n        const proxy = new Proxy(sig, {\r\n            get(target, prop) {\r\n                if (prop === 'value') {\r\n                    // Return current value from the real signal\r\n                    return (target as any).value;\r\n                }\r\n                return (target as any)[prop];\r\n            },\r\n            set(target, prop, newValue) {\r\n                if (prop === 'value') {\r\n                    // Update the signal and track the new value\r\n                    (target as any).value = newValue;\r\n                    signalMap.set(key, newValue);\r\n                    return true;\r\n                }\r\n                (target as any)[prop] = newValue;\r\n                return true;\r\n            }\r\n        });\r\n\r\n        return proxy as Signal<T>;\r\n    };\r\n}\r\n\r\n/**\r\n * Serialize captured signal state for client hydration\r\n */\r\nfunction serializeSignalState(signalMap: Map<string, any>): Record<string, any> | undefined {\r\n    if (signalMap.size === 0) return undefined;\r\n\r\n    const state: Record<string, any> = {};\r\n    for (const [key, value] of signalMap) {\r\n        try {\r\n            // Test if serializable\r\n            JSON.stringify(value);\r\n            state[key] = value;\r\n        } catch {\r\n            // Skip non-serializable values\r\n            console.warn(`SSR: Signal \"${key}\" has non-serializable value, skipping`);\r\n        }\r\n    }\r\n    return Object.keys(state).length > 0 ? state : undefined;\r\n}\r\n\r\n// getHydrationDirective, filterClientDirectives, and serializeProps are imported from sigx\r\n\r\n/**\r\n * Render element to string chunks (generator for streaming)\r\n * @param element - The JSX element to render\r\n * @param ctx - The SSR context for tracking state\r\n * @param parentCtx - The parent component context for provide/inject\r\n * @param appContext - The app context for app-level provides (from defineApp)\r\n */\r\nasync function* renderToChunks(\r\n    element: JSXElement,\r\n    ctx: SSRContext,\r\n    parentCtx: ComponentSetupContext | null = null,\r\n    appContext: AppContext | null = null\r\n): AsyncGenerator<string> {\r\n    if (element == null || element === false || element === true) {\r\n        return;\r\n    }\r\n\r\n    if (typeof element === 'string' || typeof element === 'number') {\r\n        yield escapeHtml(String(element));\r\n        return;\r\n    }\r\n\r\n    const vnode = element as VNode;\r\n\r\n    if (vnode.type === Text) {\r\n        yield escapeHtml(String(vnode.text));\r\n        return;\r\n    }\r\n\r\n    if (vnode.type === Fragment) {\r\n        for (const child of vnode.children) {\r\n            yield* renderToChunks(child, ctx, parentCtx, appContext);\r\n        }\r\n        return;\r\n    }\r\n\r\n    // Handle Components\r\n    if (isComponent(vnode.type)) {\r\n        const setup = vnode.type.__setup;\r\n        const componentName = vnode.type.__name || 'Anonymous';\r\n        const allProps = vnode.props || {};\r\n\r\n        // Check for hydration directive\r\n        const hydration = getHydrationDirective(allProps);\r\n        const { children, slots: slotsFromProps, $models: modelsData, ...propsData } = filterClientDirectives(allProps);\r\n\r\n        const id = ctx.nextId();\r\n        ctx.pushComponent(id);\r\n\r\n        // Track signals for islands that may need state serialization\r\n        const signalMap = new Map<string, any>();\r\n        const shouldTrackState = !!hydration;\r\n\r\n        // If this is an island, register it (island data goes to __SIGX_ISLANDS__ JSON, no marker needed)\r\n        if (hydration) {\r\n            const islandInfo: IslandInfo = {\r\n                strategy: hydration.strategy,\r\n                media: hydration.media,\r\n                props: serializeProps(propsData),\r\n                componentId: componentName\r\n            };\r\n            ctx.registerIsland(id, islandInfo);\r\n        }\r\n\r\n        // For client:only, don't render component content (placeholder only)\r\n        if (hydration?.strategy === 'only') {\r\n            yield `<div data-island=\"${id}\"></div>`;\r\n            yield `<!--$c:${id}-->`;\r\n            ctx.popComponent();\r\n            return;\r\n        }\r\n\r\n        // Create slots from children\r\n        const slots: SlotsObject<any> = {\r\n            default: () => children ? (Array.isArray(children) ? children : [children]) : [],\r\n            ...slotsFromProps\r\n        };\r\n\r\n        // Use tracking signal for async islands, regular signal otherwise\r\n        const signalFn = shouldTrackState ? createTrackingSignal(signalMap) : signal;\r\n\r\n        // Track SSR loads for this component\r\n        const ssrLoads: Promise<void>[] = [];\r\n        let ssrLoadResolved = false;\r\n\r\n        // Create SSR helper for async data loading\r\n        const ssrHelper = {\r\n            load(fn: () => Promise<void>): void {\r\n                // Queue the async work - will be processed in parallel\r\n                ssrLoads.push(fn());\r\n            },\r\n            isServer: true,\r\n            isHydrating: false\r\n        };\r\n\r\n        const componentCtx: ComponentSetupContext = {\r\n            el: null as any,\r\n            signal: signalFn as typeof signal,\r\n            props: createPropsAccessor(propsData),\r\n            slots: slots,\r\n            emit: () => { },\r\n            parent: parentCtx,\r\n            onMounted: () => { },\r\n            onUnmounted: () => { },\r\n            onCreated: () => { },\r\n            onUpdated: () => { },\r\n            expose: () => { },\r\n            renderFn: null,\r\n            update: () => { },\r\n            ssr: ssrHelper,\r\n            _signals: shouldTrackState ? signalMap : undefined,\r\n            _ssrLoads: ssrLoads\r\n        };\r\n\r\n        // For ROOT component only (no parent), provide the AppContext\r\n        // This enables the DI system to find app-level provides by traversing up the tree\r\n        if (!parentCtx && appContext) {\r\n            provideAppContext(componentCtx, appContext);\r\n        }\r\n\r\n        const prev = setCurrentInstance(componentCtx);\r\n        try {\r\n            // Run setup synchronously - it registers ssr.load() callbacks\r\n            let renderFn = setup(componentCtx);\r\n\r\n            // Support legacy async setup - await if it returns a promise\r\n            if (renderFn && typeof (renderFn as any).then === 'function') {\r\n                renderFn = await (renderFn as Promise<any>);\r\n            }\r\n\r\n            // Check if we have pending ssr.load() calls\r\n            if (ssrLoads.length > 0 && hydration) {\r\n                // NON-BLOCKING: Don't await! Render placeholder, stream content later\r\n\r\n                // Create a promise that will render the component after data loads\r\n                const deferredRender = (async () => {\r\n                    await Promise.all(ssrLoads);\r\n                    ssrLoadResolved = true;\r\n\r\n                    // Now render the component with loaded data\r\n                    let html = '';\r\n                    if (renderFn) {\r\n                        const result = (renderFn as () => any)();\r\n                        if (result) {\r\n                            // Render to string (no streaming for deferred content)\r\n                            html = await renderVNodeToString(result, ctx);\r\n                        }\r\n                    }\r\n\r\n                    // Capture signal state for hydration\r\n                    if (signalMap.size > 0) {\r\n                        const state = serializeSignalState(signalMap);\r\n                        if (state) {\r\n                            const islandInfo = ctx.getIslands().get(id);\r\n                            if (islandInfo) {\r\n                                islandInfo.state = state;\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    return html;\r\n                })();\r\n\r\n                // Register for streaming later\r\n                const islandInfo = ctx.getIslands().get(id)!;\r\n                ctx.addPendingAsync({\r\n                    id,\r\n                    promise: deferredRender,\r\n                    signalMap,\r\n                    islandInfo\r\n                });\r\n\r\n                // Render placeholder immediately\r\n                yield `<div data-async-placeholder=\"${id}\" style=\"display:contents;\">`;\r\n\r\n                // Render with initial state (before data loads)\r\n                if (renderFn) {\r\n                    const result = (renderFn as () => any)();\r\n                    if (result) {\r\n                        if (Array.isArray(result)) {\r\n                            for (const item of result) {\r\n                                yield* renderToChunks(item, ctx, componentCtx, appContext);\r\n                            }\r\n                        } else {\r\n                            yield* renderToChunks(result, ctx, componentCtx, appContext);\r\n                        }\r\n                    }\r\n                }\r\n\r\n                yield `</div>`;\r\n            } else {\r\n                // Synchronous component or no ssr.load() calls - await if needed\r\n                if (ssrLoads.length > 0) {\r\n                    await Promise.all(ssrLoads);\r\n                }\r\n\r\n                // After async loads complete, capture signal state for hydration\r\n                if (shouldTrackState && signalMap.size > 0) {\r\n                    const state = serializeSignalState(signalMap);\r\n                    if (state) {\r\n                        // Update the island info with captured state\r\n                        const islandInfo = ctx.getIslands().get(id);\r\n                        if (islandInfo) {\r\n                            islandInfo.state = state;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                if (renderFn) {\r\n                    const result = (renderFn as () => any)();\r\n                    if (result) {\r\n                        if (Array.isArray(result)) {\r\n                            for (const item of result) {\r\n                                yield* renderToChunks(item, ctx, componentCtx, appContext);\r\n                            }\r\n                        } else {\r\n                            yield* renderToChunks(result, ctx, componentCtx, appContext);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        } catch (e) {\r\n            console.error(`Error rendering component ${componentName}:`, e);\r\n        } finally {\r\n            setCurrentInstance(prev || null);\r\n        }\r\n\r\n        // Emit trailing component marker (unified with runtime-core pattern)\r\n        yield `<!--$c:${id}-->`;\r\n        ctx.popComponent();\r\n        return;\r\n    }\r\n\r\n    // Handle host elements\r\n    if (typeof vnode.type === 'string') {\r\n        const tagName = vnode.type;\r\n        let props = '';\r\n\r\n        // Serialize props\r\n        for (const key in vnode.props) {\r\n            const value = vnode.props[key];\r\n            if (key === 'children' || key === 'key' || key === 'ref') continue;\r\n            if (key.startsWith('client:')) continue; // Skip client directives\r\n\r\n            if (key === 'style') {\r\n                const styleString = typeof value === 'object'\r\n                    ? Object.entries(value).map(([k, v]) => `${camelToKebab(k)}:${v}`).join(';')\r\n                    : String(value);\r\n                props += ` style=\"${escapeHtml(styleString)}\"`;\r\n            } else if (key === 'className') {\r\n                props += ` class=\"${escapeHtml(String(value))}\"`;\r\n            } else if (key.startsWith('on')) {\r\n                // Skip event listeners on server\r\n            } else if (value === true) {\r\n                props += ` ${key}`;\r\n            } else if (value !== false && value != null) {\r\n                props += ` ${key}=\"${escapeHtml(String(value))}\"`;\r\n            }\r\n        }\r\n\r\n        // Void elements\r\n        const voidElements = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];\r\n        if (voidElements.includes(tagName)) {\r\n            yield `<${tagName}${props}>`;\r\n            return;\r\n        }\r\n\r\n        yield `<${tagName}${props}>`;\r\n\r\n        // Render children with text boundary markers\r\n        // Adjacent text nodes get merged by the browser, so we insert <!--t--> markers\r\n        let prevWasText = false;\r\n        for (const child of vnode.children) {\r\n            const isText = isTextContent(child);\r\n            if (isText && prevWasText) {\r\n                // Insert marker between adjacent text nodes\r\n                yield '<!--t-->';\r\n            }\r\n            yield* renderToChunks(child, ctx, parentCtx, appContext);\r\n            prevWasText = isText;\r\n        }\r\n\r\n        yield `</${tagName}>`;\r\n    }\r\n}\r\n\r\n/**\r\n * Check if element will render as text content\r\n */\r\nfunction isTextContent(element: JSXElement): boolean {\r\n    if (element == null || element === false || element === true) return false;\r\n    if (typeof element === 'string' || typeof element === 'number') return true;\r\n    const vnode = element as VNode;\r\n    return vnode.type === Text;\r\n}\r\n\r\n/**\r\n * Helper to render a VNode to string (for deferred async content)\r\n */\r\nasync function renderVNodeToString(element: JSXElement, ctx: SSRContext, appContext: AppContext | null = null): Promise<string> {\r\n    let result = '';\r\n    for await (const chunk of renderToChunks(element, ctx, null, appContext)) {\r\n        result += chunk;\r\n    }\r\n    return result;\r\n}\r\n\r\n/**\r\n * Render JSX element or App to a ReadableStream with streaming async support.\r\n * \r\n * @example\r\n * ```tsx\r\n * // Simple usage with JSX\r\n * renderToStream(<App />)\r\n * \r\n * // With App instance for DI/plugins\r\n * const app = defineApp(<App />).use(router);\r\n * renderToStream(app)\r\n * ```\r\n */\r\nexport function renderToStream(input: JSXElement | App, context?: SSRContext): ReadableStream<string> {\r\n    const ctx = context || createSSRContext();\r\n    \r\n    // Extract element and app context\r\n    let element: JSXElement;\r\n    let appContext: AppContext | null = null;\r\n    \r\n    if (isApp(input)) {\r\n        element = input._rootComponent;\r\n        appContext = input._context;\r\n    } else {\r\n        element = input;\r\n    }\r\n\r\n    return new ReadableStream<string>({\r\n        async start(controller) {\r\n            try {\r\n                // Phase 1: Render the main page (async components get placeholders)\r\n                for await (const chunk of renderToChunks(element, ctx, null, appContext)) {\r\n                    controller.enqueue(chunk);\r\n                }\r\n\r\n                // Phase 2: Stream async component replacements as they resolve\r\n                const pendingAsync = ctx.getPendingAsync();\r\n                if (pendingAsync.length > 0) {\r\n                    // Inject the streaming replacement script\r\n                    controller.enqueue(generateStreamingScript());\r\n\r\n                    // Wait for all pending async components and stream their content\r\n                    await Promise.all(\r\n                        pendingAsync.map(async (pending) => {\r\n                            try {\r\n                                const html = await pending.promise;\r\n\r\n                                // Get the updated state after data loaded\r\n                                const state = serializeSignalState(pending.signalMap);\r\n                                if (state) {\r\n                                    pending.islandInfo.state = state;\r\n                                }\r\n\r\n                                // Stream the replacement\r\n                                controller.enqueue(generateReplacementScript(\r\n                                    pending.id,\r\n                                    html,\r\n                                    state\r\n                                ));\r\n                            } catch (error) {\r\n                                console.error(`Error streaming async component ${pending.id}:`, error);\r\n                                // Stream error fallback\r\n                                controller.enqueue(generateReplacementScript(\r\n                                    pending.id,\r\n                                    `<div style=\"color:red;\">Error loading component</div>`,\r\n                                    undefined\r\n                                ));\r\n                            }\r\n                        })\r\n                    );\r\n                }\r\n\r\n                // Phase 3: Append the hydration data script (with final state)\r\n                if (ctx.getIslands().size > 0) {\r\n                    controller.enqueue(generateHydrationScript(ctx));\r\n                }\r\n\r\n                // Phase 4: Signal that streaming is complete - client can now hydrate\r\n                controller.enqueue(`<script>window.__SIGX_STREAMING_COMPLETE__ = true; window.dispatchEvent(new Event('sigx:ready'));</script>`);\r\n\r\n                controller.close();\r\n            } catch (error) {\r\n                controller.error(error);\r\n            }\r\n        }\r\n    });\r\n}\r\n\r\n/**\r\n * Streaming callbacks interface\r\n */\r\nexport interface StreamCallbacks {\r\n    /** Called when the initial shell (synchronous content) is ready */\r\n    onShellReady: (html: string) => void;\r\n    /** Called for each async chunk (replacement scripts, hydration data) */\r\n    onAsyncChunk: (chunk: string) => void;\r\n    /** Called when all streaming is complete */\r\n    onComplete: () => void;\r\n    /** Called on error */\r\n    onError: (error: Error) => void;\r\n}\r\n\r\n/**\r\n * Render with callbacks for fine-grained streaming control.\r\n * This allows the server to inject scripts between shell and async content.\r\n * \r\n * @example\r\n * ```tsx\r\n * // With App instance for DI/plugins\r\n * const app = defineApp(<App />).use(router);\r\n * await renderToStreamWithCallbacks(app, callbacks)\r\n * ```\r\n */\r\nexport async function renderToStreamWithCallbacks(\r\n    input: JSXElement | App,\r\n    callbacks: StreamCallbacks,\r\n    context?: SSRContext\r\n): Promise<void> {\r\n    const ctx = context || createSSRContext();\r\n    \r\n    // Extract element and app context\r\n    let element: JSXElement;\r\n    let appContext: AppContext | null = null;\r\n    \r\n    if (isApp(input)) {\r\n        element = input._rootComponent;\r\n        appContext = input._context;\r\n    } else {\r\n        element = input;\r\n    }\r\n\r\n    try {\r\n        // Phase 1: Render the shell (sync content + async placeholders)\r\n        let shellHtml = '';\r\n        for await (const chunk of renderToChunks(element, ctx, null, appContext)) {\r\n            shellHtml += chunk;\r\n        }\r\n\r\n        // Phase 2: Include sync island data immediately so sync components can hydrate\r\n        // At this point, only sync component islands are registered (async have placeholders)\r\n        const pendingAsync = ctx.getPendingAsync();\r\n        const syncIslandIds = new Set<number>();\r\n\r\n        // Get islands that are NOT pending async (they're sync)\r\n        const pendingAsyncIds = new Set(pendingAsync.map(p => p.id));\r\n        ctx.getIslands().forEach((_, id) => {\r\n            if (!pendingAsyncIds.has(id)) {\r\n                syncIslandIds.add(id);\r\n            }\r\n        });\r\n\r\n        // Generate sync islands data script\r\n        if (syncIslandIds.size > 0) {\r\n            shellHtml += generateSyncHydrationScript(ctx, syncIslandIds);\r\n        }\r\n\r\n        // If there are pending async, set up the async islands container\r\n        if (pendingAsync.length > 0) {\r\n            shellHtml += `<script>window.__SIGX_PENDING_ISLANDS__ = {};</script>`;\r\n        }\r\n\r\n        // Signal that sync hydration can start\r\n        shellHtml += `<script>window.__SIGX_STREAMING_COMPLETE__ = true; window.dispatchEvent(new Event('sigx:ready'));</script>`;\r\n\r\n        // Send the shell immediately - this lets scripts start loading and sync components hydrate!\r\n        callbacks.onShellReady(shellHtml);\r\n\r\n        // Phase 3: Wait for async components and stream replacements\r\n        if (pendingAsync.length > 0) {\r\n            // Send the streaming replacement script\r\n            callbacks.onAsyncChunk(generateStreamingScript());\r\n\r\n            // Wait for all pending async components\r\n            await Promise.all(\r\n                pendingAsync.map(async (pending) => {\r\n                    try {\r\n                        const html = await pending.promise;\r\n\r\n                        const state = serializeSignalState(pending.signalMap);\r\n                        if (state) {\r\n                            pending.islandInfo.state = state;\r\n                        }\r\n\r\n                        // Include island data with the replacement\r\n                        callbacks.onAsyncChunk(generateReplacementScriptWithIsland(pending.id, html, pending.islandInfo));\r\n                    } catch (error) {\r\n                        console.error(`Error streaming async component ${pending.id}:`, error);\r\n                        callbacks.onAsyncChunk(generateReplacementScript(\r\n                            pending.id,\r\n                            `<div style=\"color:red;\">Error loading component</div>`,\r\n                            undefined\r\n                        ));\r\n                    }\r\n                })\r\n            );\r\n\r\n            // Signal async streaming complete\r\n            callbacks.onAsyncChunk(`<script>window.dispatchEvent(new Event('sigx:async-complete'));</script>`);\r\n        }\r\n\r\n        callbacks.onComplete();\r\n    } catch (error) {\r\n        callbacks.onError(error as Error);\r\n    }\r\n}\r\n\r\n/**\r\n * Render JSX element or App to string (convenience wrapper around stream).\r\n * For renderToString, we wait for all async components to complete,\r\n * then include the replacement scripts inline so the final HTML is complete.\r\n * \r\n * @example\r\n * ```tsx\r\n * // Simple usage with JSX\r\n * const html = await renderToString(<App />);\r\n * \r\n * // With App instance for DI/plugins\r\n * const app = defineApp(<App />).use(router);\r\n * const html = await renderToString(app);\r\n * ```\r\n */\r\nexport async function renderToString(input: JSXElement | App, context?: SSRContext): Promise<string> {\r\n    const ctx = context || createSSRContext();\r\n    \r\n    // Extract element and app context\r\n    let element: JSXElement;\r\n    let appContext: AppContext | null = null;\r\n    \r\n    if (isApp(input)) {\r\n        element = input._rootComponent;\r\n        appContext = input._context;\r\n    } else {\r\n        element = input;\r\n    }\r\n    \r\n    let result = '';\r\n\r\n    // Phase 1: Render main content (async components get placeholders)\r\n    for await (const chunk of renderToChunks(element, ctx, null, appContext)) {\r\n        result += chunk;\r\n    }\r\n\r\n    // Phase 2: Wait for pending async components and add replacement scripts\r\n    const pendingAsync = ctx.getPendingAsync();\r\n    if (pendingAsync.length > 0) {\r\n        // Add the streaming replacement script\r\n        result += generateStreamingScript();\r\n\r\n        // Wait for all pending async components\r\n        await Promise.all(\r\n            pendingAsync.map(async (pending) => {\r\n                try {\r\n                    const html = await pending.promise;\r\n\r\n                    // Get the updated state after data loaded\r\n                    const state = serializeSignalState(pending.signalMap);\r\n                    if (state) {\r\n                        pending.islandInfo.state = state;\r\n                    }\r\n\r\n                    // Add the replacement script\r\n                    result += generateReplacementScript(pending.id, html, state);\r\n                } catch (error) {\r\n                    console.error(`Error rendering async component ${pending.id}:`, error);\r\n                    result += generateReplacementScript(\r\n                        pending.id,\r\n                        `<div style=\"color:red;\">Error loading component</div>`,\r\n                        undefined\r\n                    );\r\n                }\r\n            })\r\n        );\r\n    }\r\n\r\n    // Phase 3: Append hydration script with final state\r\n    if (ctx.getIslands().size > 0) {\r\n        result += generateHydrationScript(ctx);\r\n    }\r\n\r\n    return result;\r\n}\r\n\r\n/**\r\n * Generate the streaming replacement script (injected once before any replacements)\r\n * This script provides the $SIGX_REPLACE function used by replacement chunks\r\n */\r\nfunction generateStreamingScript(): string {\r\n    return `\r\n<script>\r\nwindow.$SIGX_REPLACE = function(id, html, state) {\r\n    var placeholder = document.querySelector('[data-async-placeholder=\"' + id + '\"]');\r\n    if (placeholder) {\r\n        // Create a template to parse the HTML\r\n        var template = document.createElement('template');\r\n        template.innerHTML = html;\r\n        \r\n        // Replace placeholder content\r\n        placeholder.innerHTML = '';\r\n        while (template.content.firstChild) {\r\n            placeholder.appendChild(template.content.firstChild);\r\n        }\r\n        \r\n        // Update island state in the hydration data\r\n        if (state) {\r\n            var dataScript = document.getElementById('__SIGX_ISLANDS__');\r\n            if (dataScript) {\r\n                try {\r\n                    var data = JSON.parse(dataScript.textContent || '{}');\r\n                    if (data[id]) {\r\n                        data[id].state = state;\r\n                        dataScript.textContent = JSON.stringify(data);\r\n                    }\r\n                } catch(e) {}\r\n            }\r\n        }\r\n        \r\n        // Dispatch event for hydration to pick up\r\n        placeholder.dispatchEvent(new CustomEvent('sigx:async-ready', { bubbles: true, detail: { id: id, state: state } }));\r\n    }\r\n};\r\n</script>`;\r\n}\r\n\r\n/**\r\n * Generate a replacement script for a specific async component\r\n */\r\nfunction generateReplacementScript(id: number, html: string, state?: Record<string, any>): string {\r\n    // Escape the HTML for embedding in a script\r\n    const escapedHtml = JSON.stringify(html);\r\n    const stateJson = state ? JSON.stringify(state) : 'null';\r\n\r\n    return `<script>$SIGX_REPLACE(${id}, ${escapedHtml}, ${stateJson});</script>`;\r\n}\r\n\r\n/**\r\n * Generate a replacement script that also includes island data for async component\r\n */\r\nfunction generateReplacementScriptWithIsland(id: number, html: string, islandInfo: IslandInfo): string {\r\n    const escapedHtml = JSON.stringify(html);\r\n    const islandJson = JSON.stringify(islandInfo);\r\n\r\n    return `<script>\r\n(function() {\r\n    // Add island data to the existing hydration data\r\n    var dataScript = document.getElementById('__SIGX_ISLANDS__');\r\n    if (dataScript) {\r\n        try {\r\n            var data = JSON.parse(dataScript.textContent || '{}');\r\n            data[${id}] = ${islandJson};\r\n            dataScript.textContent = JSON.stringify(data);\r\n        } catch(e) { console.error('Failed to update island data:', e); }\r\n    }\r\n    // Replace the placeholder content\r\n    $SIGX_REPLACE(${id}, ${escapedHtml}, ${islandInfo.state ? JSON.stringify(islandInfo.state) : 'null'});\r\n})();\r\n</script>`;\r\n}\r\n\r\n/**\r\n * Generate hydration script for sync islands only\r\n */\r\nfunction generateSyncHydrationScript(ctx: SSRContext, syncIslandIds: Set<number>): string {\r\n    const islands = ctx.getIslands();\r\n    const islandData: Record<number, IslandInfo> = {};\r\n\r\n    islands.forEach((info, id) => {\r\n        if (syncIslandIds.has(id)) {\r\n            islandData[id] = info;\r\n        }\r\n    });\r\n\r\n    if (Object.keys(islandData).length === 0) return '';\r\n\r\n    return `\r\n<script type=\"application/json\" id=\"__SIGX_ISLANDS__\">${JSON.stringify(islandData)}</script>`;\r\n}\r\n\r\n/**\r\n * Generate the hydration bootstrap script\r\n */\r\nfunction generateHydrationScript(ctx: SSRContext): string {\r\n    const islands = ctx.getIslands();\r\n    if (islands.size === 0) return '';\r\n\r\n    const islandData: Record<number, IslandInfo> = {};\r\n    islands.forEach((info, id) => {\r\n        islandData[id] = info;\r\n    });\r\n\r\n    // Only output the JSON data - the client entry is responsible for calling hydrateIslands()\r\n    // We don't inject a script tag because the browser can't resolve npm package specifiers\r\n    // The client bundle (via Vite/Rollup) handles the import resolution\r\n    return `\r\n<script type=\"application/json\" id=\"__SIGX_ISLANDS__\">${JSON.stringify(islandData)}</script>`;\r\n}\r\n\r\n// HTML escaping\r\nconst ESCAPE: Record<string, string> = {\r\n    '&': '&amp;',\r\n    '<': '&lt;',\r\n    '>': '&gt;',\r\n    '\"': '&quot;',\r\n    \"'\": '&#39;'\r\n};\r\n\r\nfunction escapeHtml(s: string): string {\r\n    return s.replace(/[&<>\"']/g, c => ESCAPE[c]);\r\n}\r\n\r\nfunction camelToKebab(str: string): string {\r\n    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();\r\n}\r\n"],"mappings":"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"}

package/dist/shared/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared utilities for server-renderer
+ *
+ * @deprecated These utilities are now exported from `sigx` directly.
+ * Import from `sigx` or `sigx/hydration` instead.
+ * This module re-exports for backwards compatibility.
+ */
+export { CLIENT_DIRECTIVE_PREFIX, CLIENT_DIRECTIVES, type ClientDirective, type HydrationStrategy, type HydrationDirective, filterClientDirectives, getHydrationDirective, hasClientDirective, serializeProps, createEmit } from 'sigx';
+//# sourceMappingURL=utils.d.ts.map

package/dist/shared/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/shared/utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACH,uBAAuB,EACvB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,cAAc,EACd,UAAU,EACb,MAAM,MAAM,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sigx/server-renderer",
-  "version": "0.1.4",
-  "description": "Server-side renderer for SignalX",
+  "version": "0.1.6",
+  "description": "Server-side rendering and client hydration for SigX",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,17 +9,31 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./server": {
+      "import": "./dist/server/index.js",
+      "types": "./dist/server/index.d.ts"
+    },
+    "./client": {
+      "import": "./dist/client/index.js",
+      "types": "./dist/client/index.d.ts"
+    },
+    "./jsx": {
+      "types": "./src/jsx.d.ts"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src/jsx.d.ts"
   ],
   "keywords": [
     "sigx",
     "ssr",
     "server-side-rendering",
     "server",
-    "renderer"
+    "renderer",
+    "hydration",
+    "islands"
   ],
   "author": "Andreas Ekdahl",
   "license": "MIT",
@@ -33,15 +47,15 @@
     "url": "https://github.com/signalxjs/core/issues"
   },
   "dependencies": {
-    "@sigx/runtime-core": "^0.1.4",
-    "@sigx/reactivity": "^0.1.4"
+    "sigx": "^0.1.6"
   },
   "devDependencies": {
-    "rolldown": "^1.0.0-beta.52",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vite": "^8.0.0-beta.9",
+    "@sigx/vite": "^0.1.6"
   },
   "scripts": {
-    "build": "rolldown -c && tsc --emitDeclarationOnly",
-    "dev": "rolldown -c -w"
+    "build": "vite build && tsc --emitDeclarationOnly",
+    "dev": "vite build --watch"
   }
 }