@sigx/server-renderer 0.1.5 → 0.1.7

package/dist/server/index.js

@@ -1,574 +1,3 @@
-import { Fragment, Text, setCurrentInstance, signal } from "@sigx/runtime-core";
-
-//#region src/server/context.ts
-/**
-* Create a new SSR context for rendering
-*/
-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;
-		}
-	};
-}
-
-//#endregion
-//#region src/server/stream.ts
-/**
-* Streaming SSR renderer with hydration markers
-*/
-/**
-* Creates a tracking signal function that records signal names and values.
-* Used during async setup to capture state for client hydration.
-*/
-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;
-			}
-		});
-	};
-}
-/**
-* Serialize captured signal state for client hydration
-*/
-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;
-}
-/**
-* Check if a vnode type is a component (has __setup)
-*/
-function isComponent(type) {
-	return typeof type === "function" && "__setup" in type;
-}
-/**
-* Creates a simple props accessor for SSR (no reactivity needed)
-*/
-function createSSRPropsAccessor(rawProps) {
-	let defaults = {};
-	const proxy = new Proxy(function propsAccessor() {}, {
-		get(_, key) {
-			if (typeof key === "symbol") return void 0;
-			const value = rawProps[key];
-			return value != null ? value : defaults[key];
-		},
-		apply(_, __, args) {
-			if (args[0] && typeof args[0] === "object") defaults = {
-				...defaults,
-				...args[0]
-			};
-			return proxy;
-		},
-		has(_, key) {
-			if (typeof key === "symbol") return false;
-			return key in rawProps || key in defaults;
-		},
-		ownKeys() {
-			return [...new Set([...Object.keys(rawProps), ...Object.keys(defaults)])];
-		},
-		getOwnPropertyDescriptor(_, key) {
-			if (typeof key === "symbol") return void 0;
-			if (key in rawProps || key in defaults) return {
-				enumerable: true,
-				configurable: true,
-				writable: false
-			};
-		}
-	});
-	return proxy;
-}
-/**
-* Detect hydration directive from props
-*/
-function getHydrationDirective(props) {
-	if (props["client:load"] !== void 0) return { strategy: "load" };
-	if (props["client:idle"] !== void 0) return { strategy: "idle" };
-	if (props["client:visible"] !== void 0) return { strategy: "visible" };
-	if (props["client:only"] !== void 0) return { strategy: "only" };
-	if (props["client:media"] !== void 0) return {
-		strategy: "media",
-		media: props["client:media"]
-	};
-	return null;
-}
-/**
-* Filter out client directives from props
-*/
-function filterClientDirectives(props) {
-	const filtered = {};
-	for (const key in props) if (!key.startsWith("client:")) filtered[key] = props[key];
-	return filtered;
-}
-/**
-* Serialize props for client hydration (must be JSON-safe)
-*/
-function serializeProps(props) {
-	const serialized = {};
-	for (const key in props) {
-		const value = props[key];
-		if (typeof value === "function" || typeof value === "symbol") continue;
-		if (key === "children" || key === "key" || key === "ref" || key === "slots") continue;
-		if (key.startsWith("on")) continue;
-		try {
-			JSON.stringify(value);
-			serialized[key] = value;
-		} catch {}
-	}
-	return serialized;
-}
-/**
-* Render element to string chunks (generator for streaming)
-*/
-async function* renderToChunks(element, ctx) {
-	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);
-		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, ...propsData } = filterClientDirectives(allProps);
-		const id = ctx.nextId();
-		ctx.pushComponent(id);
-		yield `<!--$c:${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);
-			yield `<!--$island:${hydration.strategy}:${id}${hydration.media ? `:${hydration.media}` : ""}-->`;
-		}
-		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: createSSRPropsAccessor(propsData),
-			slots,
-			emit: () => {},
-			parent: null,
-			onMount: () => {},
-			onCleanup: () => {},
-			expose: () => {},
-			renderFn: null,
-			update: () => {},
-			ssr: {
-				load(fn) {
-					ssrLoads.push(fn());
-				},
-				isServer: true,
-				isHydrating: false
-			},
-			_signals: shouldTrackState ? signalMap : void 0,
-			_ssrLoads: ssrLoads
-		};
-		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$1 = ctx.getIslands().get(id);
-							if (islandInfo$1) islandInfo$1.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);
-					else yield* renderToChunks(result, ctx);
-				}
-				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);
-					else yield* renderToChunks(result, ctx);
-				}
-			}
-		} 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);
-			prevWasText = isText;
-		}
-		yield `</${tagName}>`;
-	}
-}
-/**
-* Check if element will render as text content
-*/
-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;
-}
-/**
-* Helper to render a VNode to string (for deferred async content)
-*/
-async function renderVNodeToString(element, ctx) {
-	let result = "";
-	for await (const chunk of renderToChunks(element, ctx)) result += chunk;
-	return result;
-}
-/**
-* Render JSX element to a ReadableStream with streaming async support
-*/
-function renderToStream(element, context) {
-	const ctx = context || createSSRContext();
-	return new ReadableStream({ async start(controller) {
-		try {
-			for await (const chunk of renderToChunks(element, ctx)) 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);
-		}
-	} });
-}
-/**
-* Render with callbacks for fine-grained streaming control.
-* This allows the server to inject scripts between shell and async content.
-*/
-async function renderToStreamWithCallbacks(element, callbacks, context) {
-	const ctx = context || createSSRContext();
-	try {
-		let shellHtml = "";
-		for await (const chunk of renderToChunks(element, ctx)) 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);
-	}
-}
-/**
-* Render JSX element to string (convenience wrapper around stream)
-* For renderToString, we wait for all async components to complete,
-* then include the replacement scripts inline so the final HTML is complete.
-*/
-async function renderToString(element, context) {
-	const ctx = context || createSSRContext();
-	let result = "";
-	for await (const chunk of renderToChunks(element, ctx)) 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;
-}
-/**
-* Generate the streaming replacement script (injected once before any replacements)
-* This script provides the $SIGX_REPLACE function used by replacement chunks
-*/
-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>`;
-}
-/**
-* Generate a replacement script for a specific async component
-*/
-function generateReplacementScript(id, html, state) {
-	return `<script>$SIGX_REPLACE(${id}, ${JSON.stringify(html)}, ${state ? JSON.stringify(state) : "null"});<\/script>`;
-}
-/**
-* Generate a replacement script that also includes island data for async component
-*/
-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>`;
-}
-/**
-* Generate hydration script for sync islands only
-*/
-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>`;
-}
-/**
-* Generate the hydration bootstrap 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>`;
-}
-const 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();
-}
-
-//#endregion
-export { createSSRContext, renderToStream, renderToStreamWithCallbacks, renderToString };
-//# sourceMappingURL=index.js.map
+import { d as generateStreamingScript, f as renderVNodeToString, l as escapeJsonForScript, n as renderToStreamWithCallbacks, p as createSSRContext, r as renderToString, t as renderToStream, u as generateReplacementScript } from "../server-UBcHtkm-.js";
+import { t as generateSignalKey } from "../types-B4Rf1Xot.js";
+export { createSSRContext, escapeJsonForScript, generateReplacementScript, generateSignalKey, generateStreamingScript, renderToStream, renderToStreamWithCallbacks, renderToString, renderVNodeToString };

package/dist/server/render-api.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Public SSR rendering APIs — convenience wrappers
+ *
+ * These delegate to `createSSR()` internally so there is exactly one
+ * rendering pipeline.  When no plugins are registered the plugin hooks
+ * are simply no-ops, making these equivalent to calling `createSSR()`
+ * directly — but with a simpler call signature for the common case.
+ *
+ * For plugin-driven rendering (islands, streaming async, etc.),
+ * use `createSSR().use(plugin).render()` from `@sigx/server-renderer`.
+ *
+ * Entry points:
+ * - `renderToString()` — full render to a single string
+ * - `renderToStream()` — ReadableStream
+ * - `renderToStreamWithCallbacks()` — callback-based streaming
+ */
+import type { JSXElement } from 'sigx';
+import type { App } from 'sigx';
+import type { SSRContext } from './context';
+import type { StreamCallbacks } from './types';
+export type { StreamCallbacks } from './types';
+/**
+ * Render JSX element or App to a ReadableStream.
+ *
+ * Internally delegates to `createSSR().renderStream()`.
+ *
+ * @example
+ * ```tsx
+ * // Simple usage with JSX
+ * renderToStream(<App />)
+ *
+ * // With App instance for DI/plugins
+ * const app = defineApp(<App />).use(router);
+ * renderToStream(app)
+ * ```
+ */
+export declare function renderToStream(input: JSXElement | App, context?: SSRContext): ReadableStream<string>;
+/**
+ * Render with callbacks for fine-grained streaming control.
+ *
+ * Internally delegates to `createSSR().renderStreamWithCallbacks()`.
+ *
+ * @example
+ * ```tsx
+ * const app = defineApp(<App />).use(router);
+ * await renderToStreamWithCallbacks(app, callbacks)
+ * ```
+ */
+export declare function renderToStreamWithCallbacks(input: JSXElement | App, callbacks: StreamCallbacks, context?: SSRContext): Promise<void>;
+/**
+ * Render JSX element or App to string.
+ *
+ * Internally delegates to `createSSR().render()`.
+ *
+ * @example
+ * ```tsx
+ * const html = await renderToString(<App />);
+ *
+ * const app = defineApp(<App />).use(router);
+ * const html = await renderToString(app);
+ * ```
+ */
+export declare function renderToString(input: JSXElement | App, context?: SSRContext): Promise<string>;
+//# sourceMappingURL=render-api.d.ts.map

package/dist/server/render-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-api.d.ts","sourceRoot":"","sources":["../../src/server/render-api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AACvC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAqB,MAAM,WAAW,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG/C,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK/C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,cAAc,CAAC,MAAM,CAAC,CAEpG;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,2BAA2B,CAC7C,KAAK,EAAE,UAAU,GAAG,GAAG,EACvB,SAAS,EAAE,eAAe,EAC1B,OAAO,CAAC,EAAE,UAAU,GACrB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAEnG"}

package/dist/server/render-core.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Core rendering logic for SSR
+ *
+ * The async generator `renderToChunks` walks a VNode tree and yields HTML strings.
+ * Handles text, fragments, host elements, and delegates components to the
+ * component renderer.
+ *
+ * This module is strategy-agnostic. Island-specific logic (signal tracking,
+ * hydration directives, async streaming) lives in @sigx/ssr-islands and is
+ * injected through the SSRPlugin hooks.
+ */
+import { JSXElement, ComponentSetupContext } from 'sigx';
+import type { AppContext } from 'sigx';
+import type { SSRContext } from './context';
+export declare function escapeHtml(s: string): string;
+export declare function camelToKebab(str: string): string;
+export declare function parseStringStyle(cssText: string): Record<string, string>;
+/**
+ * Serialize a style object to a CSS string.
+ *
+ * Uses for...in + string concat (avoids Object.entries/map/join allocations)
+ * and cached kebab-case conversion.
+ */
+export declare function stringifyStyle(style: Record<string, any>): string;
+/**
+ * Render element to string chunks (generator for streaming)
+ * @param element - The JSX element to render
+ * @param ctx - The SSR context for tracking state
+ * @param parentCtx - The parent component context for provide/inject
+ * @param appContext - The app context for app-level provides (from defineApp)
+ */
+export declare function renderToChunks(element: JSXElement, ctx: SSRContext, parentCtx?: ComponentSetupContext | null, appContext?: AppContext | null): AsyncGenerator<string>;
+/**
+ * Helper to render a VNode to string (for deferred async content)
+ */
+export declare function renderVNodeToString(element: JSXElement, ctx: SSRContext, appContext?: AppContext | null): Promise<string>;
+/**
+ * Synchronous render-to-string that avoids async generator overhead.
+ * Returns null if any async operation is encountered (caller should fall back
+ * to the async generator path).
+ *
+ * For purely synchronous component trees this eliminates thousands of
+ * microtask/Promise allocations from the AsyncGenerator protocol.
+ */
+export declare function renderToStringSync(element: JSXElement, ctx: SSRContext, parentCtx: ComponentSetupContext | null, appContext: AppContext | null, buf: string[]): boolean;
+//# sourceMappingURL=render-core.d.ts.map

package/dist/server/render-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-core.d.ts","sourceRoot":"","sources":["../../src/server/render-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAGH,UAAU,EACV,qBAAqB,EASxB,MAAM,MAAM,CAAC;AAGd,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAY5C,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5C;AAQD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIhD;AAiBD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcxE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CASjE;AA4BD;;;;;;GAMG;AACH,wBAAuB,cAAc,CACjC,OAAO,EAAE,UAAU,EACnB,GAAG,EAAE,UAAU,EACf,SAAS,GAAE,qBAAqB,GAAG,IAAW,EAC9C,UAAU,GAAE,UAAU,GAAG,IAAW,GACrC,cAAc,CAAC,MAAM,CAAC,CAiWxB;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,UAAU,GAAE,UAAU,GAAG,IAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAMrI;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAC9B,OAAO,EAAE,UAAU,EACnB,GAAG,EAAE,UAAU,EACf,SAAS,EAAE,qBAAqB,GAAG,IAAI,EACvC,UAAU,EAAE,UAAU,GAAG,IAAI,EAC7B,GAAG,EAAE,MAAM,EAAE,GACd,OAAO,CAmQT"}