schema-components 0.0.0 → 1.0.0

package/dist/html/html.mjs

@@ -0,0 +1,168 @@
+//#region src/html/html.ts
+const VOID_ELEMENTS = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+/**
+* Build an HTML element node.
+*
+* - Tag name is type-checked (must be a known HTML tag)
+* - Attributes are collected as a record — callers get IntelliSense for
+*   common attributes but can also pass `aria-*`, `data-*` etc.
+* - Children are flattened; `undefined`, `null`, and `false` are dropped.
+* - For void elements (input, img, etc.), children are ignored.
+*
+* @param tag - HTML element tag name
+* @param attrs - Optional attributes (class, id, aria-*, etc.)
+* @param children - Child nodes (strings are escaped by the serialiser)
+*/
+function h(tag, attrs, ...children) {
+	return {
+		tag,
+		attributes: attrs ?? {},
+		children: flattenChildren(children)
+	};
+}
+/**
+* Create a text node. The value is NOT escaped — the serialiser handles it.
+* Use this for dynamic text that must appear in the output.
+*/
+function text(value) {
+	return { text: value };
+}
+/**
+* Create a raw HTML node. The value is emitted verbatim — NOT escaped.
+* Use for embedding already-serialised HTML (e.g. from child renderers).
+* Never use for user-supplied data.
+*/
+function raw(html) {
+	return { html };
+}
+function flattenChildren(nodes) {
+	const out = [];
+	for (const node of nodes) {
+		if (node === void 0 || node === null || node === false) continue;
+		if (typeof node === "string") out.push(node);
+		else if ("tag" in node) out.push(node);
+		else if ("html" in node) out.push(node);
+		else if ("text" in node) out.push(node);
+	}
+	return out;
+}
+/**
+* Serialise an HTML node to a string.
+*
+* - Text content is automatically escaped
+* - Void elements are self-closing
+* - Boolean attributes render as just the name (`disabled`, `checked`)
+* - `false`/`undefined` attribute values are omitted
+*
+* @param node - An HtmlElement, HtmlText, or string to serialise
+* @returns HTML string
+*/
+function serialize(node) {
+	if (node === void 0 || node === null || node === false) return "";
+	if (typeof node === "string") return escapeHtml(node);
+	if ("html" in node) return node.html;
+	if ("text" in node) return escapeHtml(node.text);
+	if (node.tag === "") return node.children.map((child) => serialize(child)).join("");
+	return serializeElement(node);
+}
+function serializeElement(el) {
+	const attrs = serializeAttributes(el.attributes);
+	if (VOID_ELEMENTS.has(el.tag)) return `<${el.tag}${attrs}>`;
+	if (el.children.length === 0) return `<${el.tag}${attrs}></${el.tag}>`;
+	const inner = el.children.map((child) => serialize(child)).join("");
+	return `<${el.tag}${attrs}>${inner}</${el.tag}>`;
+}
+function serializeAttributes(attrs) {
+	const parts = [];
+	for (const [key, value] of Object.entries(attrs)) {
+		if (value === void 0 || value === false) continue;
+		if (value === true) parts.push(` ${key}`);
+		else parts.push(` ${key}="${escapeHtml(String(value))}"`);
+	}
+	return parts.join("");
+}
+/**
+* Serialise an HTML node to chunks, yielded at natural element boundaries.
+*
+* - Each top-level child element becomes its own chunk
+* - Leaf text within an element stays with its parent
+* - Void elements are single chunks
+*
+* This is used by the streaming renderer to produce incremental output.
+*
+* @param node - An HTML node to serialise
+* @returns Iterable of HTML string chunks
+*/
+function* serializeChunks(node) {
+	if (node === void 0 || node === null || node === false) return;
+	if (typeof node === "string") {
+		yield escapeHtml(node);
+		return;
+	}
+	if ("html" in node) {
+		yield node.html;
+		return;
+	}
+	if ("text" in node) {
+		yield escapeHtml(node.text);
+		return;
+	}
+	const attrs = serializeAttributes(node.attributes);
+	const tag = node.tag;
+	const open = `<${tag}${attrs}>`;
+	if (VOID_ELEMENTS.has(tag)) {
+		yield open;
+		return;
+	}
+	if (node.children.length === 0) {
+		yield `${open}</${tag}>`;
+		return;
+	}
+	yield open;
+	for (const child of node.children) if (typeof child === "string") yield escapeHtml(child);
+	else if ("html" in child) yield child.html;
+	else if ("text" in child) yield escapeHtml(child.text);
+	else yield* serializeChunks(child);
+	yield `</${tag}>`;
+}
+/**
+* Escape a string for safe inclusion in HTML text content or attribute values.
+*/
+function escapeHtml(str) {
+	return str.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+/**
+* Create a fragment: children rendered sequentially with no wrapping element.
+* Useful when a renderer needs to return multiple top-level nodes.
+*/
+function fragment(...children) {
+	return h("", void 0, ...children);
+}
+/**
+* Serialise a node, treating fragments (empty tag) as just their children.
+*/
+function serializeFragment(node) {
+	if (node === void 0 || node === null || node === false) return "";
+	if (typeof node === "string") return escapeHtml(node);
+	if ("html" in node) return node.html;
+	if ("text" in node) return escapeHtml(node.text);
+	if (node.tag === "") return node.children.map((child) => serialize(child)).join("");
+	return serializeElement(node);
+}
+//#endregion
+export { VOID_ELEMENTS, escapeHtml, fragment, h, raw, serialize, serializeAttributes, serializeChunks, serializeElement, serializeFragment, text };

package/dist/html/renderToHtml.d.mts

@@ -0,0 +1,32 @@
+import { C as HtmlResolver, S as HtmlRenderProps, m as SchemaMeta, x as HtmlRenderFunction } from "../types-BU0ETFHk.mjs";
+
+//#region src/html/renderToHtml.d.ts
+interface RenderToHtmlOptions {
+  /** The data value to render. */
+  value?: unknown;
+  /** For OpenAPI: a ref string like "#/components/schemas/User". */
+  ref?: string;
+  /** Per-field meta overrides. */
+  fields?: Record<string, unknown>;
+  /** Meta overrides applied to the root schema. */
+  meta?: SchemaMeta;
+  /** Force all fields read-only. */
+  readOnly?: boolean;
+  /** Force all fields as inputs. */
+  writeOnly?: boolean;
+  /** Root description. */
+  description?: string;
+  /** Custom HTML resolver. Falls back to defaultHtmlResolver. */
+  resolver?: HtmlResolver;
+}
+declare const defaultHtmlResolver: HtmlResolver;
+/**
+ * Render a schema to an HTML string.
+ *
+ * @param schema - Zod schema, JSON Schema, or OpenAPI document
+ * @param options - Value, overrides, and resolver options
+ * @returns Semantic HTML string with `sc-` prefixed classes
+ */
+declare function renderToHtml(schema: unknown, options?: RenderToHtmlOptions): string;
+//#endregion
+export { type HtmlRenderFunction, type HtmlRenderProps, type HtmlResolver, RenderToHtmlOptions, defaultHtmlResolver, renderToHtml };

package/dist/html/renderToHtml.mjs

@@ -0,0 +1,352 @@
+import { normaliseSchema } from "../core/adapter.mjs";
+import { getHtmlRenderFn, mergeHtmlResolvers } from "../core/renderer.mjs";
+import { walk } from "../core/walker.mjs";
+import { h, raw, serialize } from "./html.mjs";
+import { ariaDescribedByAttrs, ariaLabelAttrs, ariaReadonlyAttrs, ariaRequiredAttrs, buildHintElement, buildInputId, requiredIndicator } from "./a11y.mjs";
+//#region src/html/renderToHtml.ts
+/**
+* HTML renderer — produces semantic HTML from schemas using the typed `h()` builder.
+*
+* Framework-agnostic alternative to the React rendering pipeline.
+* Uses the same walker and adapter (normalise → walk → render) but
+* outputs HTML strings instead of ReactNode.
+*
+* All HTML construction goes through `h()` from `html.ts`, which gives
+* compile-time tag/attribute checking and automatic escaping.
+*
+* Usage:
+*   import { renderToHtml } from "schema-components/html/renderToHtml";
+*   const html = renderToHtml(userSchema, { value: userData });
+*
+* Custom resolver:
+*   const html = renderToHtml(schema, {
+*     value,
+*     resolver: { string: (props) => h("b", {}, String(props.value)) },
+*   });
+*/
+function renderStringHtml(props) {
+	if (props.readOnly) return serialize(renderStringReadOnly(props));
+	return serialize(renderStringEditable(props));
+}
+function renderStringReadOnly(props) {
+	const strValue = typeof props.value === "string" ? props.value : void 0;
+	if (strValue === void 0 || strValue.length === 0) return h("span", {
+		class: "sc-value sc-value--empty",
+		...ariaReadonlyAttrs()
+	}, "—");
+	const format = props.constraints.format;
+	if (format === "email") return h("a", {
+		class: "sc-value",
+		href: `mailto:${strValue}`,
+		...ariaReadonlyAttrs()
+	}, strValue);
+	if (format === "uri" || format === "url") return h("a", {
+		class: "sc-value",
+		href: strValue,
+		...ariaReadonlyAttrs()
+	}, strValue);
+	return h("span", {
+		class: "sc-value",
+		...ariaReadonlyAttrs()
+	}, strValue);
+}
+function renderStringEditable(props) {
+	const strValue = typeof props.value === "string" ? props.value : "";
+	const inputType = props.constraints.format === "email" ? "email" : props.constraints.format === "uri" ? "url" : "text";
+	const id = props.path;
+	const attrs = {
+		class: "sc-input",
+		id,
+		type: inputType,
+		name: id
+	};
+	if (!props.writeOnly) attrs.value = strValue;
+	if (typeof props.meta.description === "string") attrs.placeholder = props.meta.description;
+	if (props.constraints.minLength !== void 0) attrs.minlength = String(props.constraints.minLength);
+	if (props.constraints.maxLength !== void 0) attrs.maxlength = String(props.constraints.maxLength);
+	Object.assign(attrs, ariaRequiredAttrs(props.tree));
+	Object.assign(attrs, ariaDescribedByAttrs(id, props.constraints));
+	return h("input", attrs);
+}
+function renderNumberHtml(props) {
+	if (props.readOnly) return serialize(renderNumberReadOnly(props));
+	return serialize(renderNumberEditable(props));
+}
+function renderNumberReadOnly(props) {
+	if (typeof props.value !== "number") return h("span", {
+		class: "sc-value sc-value--empty",
+		...ariaReadonlyAttrs()
+	}, "—");
+	return h("span", {
+		class: "sc-value",
+		...ariaReadonlyAttrs()
+	}, props.value.toLocaleString());
+}
+function renderNumberEditable(props) {
+	const numValue = typeof props.value === "number" ? String(props.value) : "";
+	const id = props.path;
+	const attrs = {
+		class: "sc-input",
+		id,
+		type: "number",
+		name: id
+	};
+	if (!props.writeOnly) attrs.value = numValue;
+	if (props.constraints.minimum !== void 0) attrs.min = String(props.constraints.minimum);
+	if (props.constraints.maximum !== void 0) attrs.max = String(props.constraints.maximum);
+	Object.assign(attrs, ariaRequiredAttrs(props.tree));
+	Object.assign(attrs, ariaDescribedByAttrs(id, props.constraints));
+	return h("input", attrs);
+}
+function renderBooleanHtml(props) {
+	if (props.readOnly) return serialize(renderBooleanReadOnly(props));
+	return serialize(renderBooleanEditable(props));
+}
+function renderBooleanReadOnly(props) {
+	if (typeof props.value !== "boolean") return h("span", {
+		class: "sc-value sc-value--empty",
+		...ariaReadonlyAttrs()
+	}, "—");
+	return h("span", {
+		class: "sc-value sc-value--boolean",
+		...ariaReadonlyAttrs()
+	}, props.value ? "Yes" : "No");
+}
+function renderBooleanEditable(props) {
+	const id = props.path;
+	const attrs = {
+		class: "sc-input",
+		id,
+		type: "checkbox",
+		name: id
+	};
+	if (props.value === true) attrs.checked = true;
+	Object.assign(attrs, ariaRequiredAttrs(props.tree));
+	Object.assign(attrs, ariaLabelAttrs(props.meta.description));
+	return h("input", attrs);
+}
+function renderEnumHtml(props) {
+	if (props.readOnly) return serialize(renderEnumReadOnly(props));
+	return serialize(renderEnumEditable(props));
+}
+function renderEnumReadOnly(props) {
+	const enumValue = typeof props.value === "string" ? props.value : "";
+	if (enumValue.length === 0) return h("span", {
+		class: "sc-value sc-value--empty",
+		...ariaReadonlyAttrs()
+	}, "—");
+	return h("span", {
+		class: "sc-value",
+		...ariaReadonlyAttrs()
+	}, enumValue);
+}
+function renderEnumEditable(props) {
+	const enumValue = typeof props.value === "string" ? props.value : "";
+	const id = props.path;
+	const selectedValue = props.writeOnly ? "" : enumValue;
+	const optionNodes = [h("option", { value: "" }, "Select…"), ...(props.enumValues ?? []).map((v) => {
+		const attrs = { value: v };
+		if (v === selectedValue) attrs.selected = true;
+		return h("option", attrs, v);
+	})];
+	const selectAttrs = {
+		class: "sc-input",
+		id,
+		name: id
+	};
+	Object.assign(selectAttrs, ariaRequiredAttrs(props.tree));
+	return h("select", selectAttrs, ...optionNodes);
+}
+function renderObjectHtml(props) {
+	return serialize(renderObjectNode(props));
+}
+function renderObjectNode(props) {
+	const fields = props.fields;
+	if (fields === void 0) return "";
+	const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+	const obj = isRecord(props.value) ? props.value : {};
+	const descriptionText = typeof props.meta.description === "string" ? props.meta.description : void 0;
+	const legend = descriptionText !== void 0 ? h("legend", {}, descriptionText) : void 0;
+	if (props.readOnly) {
+		const children = [];
+		if (legend !== void 0) children.push(legend);
+		for (const [key, field] of Object.entries(fields)) {
+			const label = typeof field.meta.description === "string" ? field.meta.description : key;
+			const childValue = obj[key];
+			const childHtml = props.renderChild(field, childValue, key);
+			children.push(h("dt", { class: "sc-label" }, label));
+			children.push(h("dd", { class: "sc-value" }, raw(childHtml)));
+		}
+		const dlAttrs = { class: "sc-object" };
+		Object.assign(dlAttrs, ariaLabelAttrs(descriptionText));
+		return h("dl", dlAttrs, ...children);
+	}
+	const children = [];
+	if (legend !== void 0) children.push(legend);
+	for (const [key, field] of Object.entries(fields)) {
+		const label = typeof field.meta.description === "string" ? field.meta.description : key;
+		const fieldId = buildInputId(props.path, key);
+		const childValue = obj[key];
+		const childHtml = props.renderChild(field, childValue, key);
+		const required = requiredIndicator(field);
+		const labelContent = [label];
+		if (required !== void 0) labelContent.push(required);
+		const fieldChildren = [h("label", {
+			class: "sc-label",
+			for: fieldId
+		}, ...labelContent), raw(childHtml)];
+		const hint = buildHintElement(key, field.constraints);
+		if (hint !== void 0) fieldChildren.push(hint);
+		children.push(h("div", { class: "sc-field" }, ...fieldChildren));
+	}
+	const fieldsetAttrs = { class: "sc-object" };
+	Object.assign(fieldsetAttrs, ariaLabelAttrs(descriptionText));
+	return h("fieldset", fieldsetAttrs, ...children);
+}
+function renderArrayHtml(props) {
+	return serialize(renderArrayNode(props));
+}
+function renderArrayNode(props) {
+	const arr = Array.isArray(props.value) ? props.value : [];
+	const element = props.element;
+	if (element === void 0) return "";
+	const items = arr.map((item) => {
+		return h("li", { class: "sc-item" }, raw(props.renderChild(element, item)));
+	});
+	if (props.readOnly) return h("ul", { class: "sc-array" }, ...items);
+	return h("div", { class: "sc-array" }, ...arr.map((item) => {
+		return h("div", {}, raw(props.renderChild(element, item)));
+	}));
+}
+function renderRecordHtml(props) {
+	return serialize(renderRecordNode(props));
+}
+function renderRecordNode(props) {
+	const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+	const obj = isRecord(props.value) ? props.value : {};
+	const valueType = props.valueType;
+	if (valueType === void 0) return "";
+	const attrs = {
+		class: "sc-record",
+		role: "group"
+	};
+	if (props.readOnly) {
+		const children = [];
+		for (const [key, val] of Object.entries(obj)) {
+			const childHtml = props.renderChild(valueType, val, key);
+			children.push(h("dt", { class: "sc-label" }, key));
+			children.push(h("dd", { class: "sc-value" }, raw(childHtml)));
+		}
+		return h("dl", attrs, ...children);
+	}
+	const children = [];
+	for (const [key, val] of Object.entries(obj)) {
+		const childHtml = props.renderChild(valueType, val, key);
+		children.push(h("div", { class: "sc-field" }, h("label", { class: "sc-label" }, key), raw(childHtml)));
+	}
+	return h("div", attrs, ...children);
+}
+function renderLiteralHtml(props) {
+	const values = props.tree.literalValues;
+	if (values === void 0 || values.length === 0) return serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
+	return serialize(h("span", { class: "sc-value" }, values.map((v) => v === null ? "null" : String(v)).join(", ")));
+}
+function renderUnionHtml(props) {
+	const options = props.options;
+	if (options === void 0 || options.length === 0) {
+		if (props.value === void 0 || props.value === null) return serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
+		return serialize(h("span", { class: "sc-value" }, JSON.stringify(props.value)));
+	}
+	const matched = matchUnionOption(options, props.value);
+	if (matched !== void 0) return props.renderChild(matched, props.value);
+	const firstOption = options[0];
+	if (firstOption !== void 0) return props.renderChild(firstOption, props.value);
+	return serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
+}
+function renderUnknownHtml(props) {
+	if (props.readOnly) {
+		if (props.value === void 0 || props.value === null) return serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
+		if (typeof props.value === "string") return serialize(h("span", { class: "sc-value" }, props.value));
+		return serialize(h("span", { class: "sc-value" }, JSON.stringify(props.value)));
+	}
+	const strValue = typeof props.value === "string" ? props.value : "";
+	const attrs = {
+		class: "sc-input",
+		type: "text",
+		name: props.path
+	};
+	if (!props.writeOnly) attrs.value = strValue;
+	return serialize(h("input", attrs));
+}
+function matchUnionOption(options, value) {
+	if (typeof value === "string") return options.find((o) => o.type === "string" || o.type === "enum");
+	if (typeof value === "number") return options.find((o) => o.type === "number");
+	if (typeof value === "boolean") return options.find((o) => o.type === "boolean");
+	if (Array.isArray(value)) return options.find((o) => o.type === "array");
+	if (typeof value === "object" && value !== null) return options.find((o) => o.type === "object");
+}
+const defaultHtmlResolver = {
+	string: renderStringHtml,
+	number: renderNumberHtml,
+	boolean: renderBooleanHtml,
+	enum: renderEnumHtml,
+	object: renderObjectHtml,
+	array: renderArrayHtml,
+	record: renderRecordHtml,
+	literal: renderLiteralHtml,
+	union: renderUnionHtml,
+	unknown: renderUnknownHtml
+};
+/**
+* Render a schema to an HTML string.
+*
+* @param schema - Zod schema, JSON Schema, or OpenAPI document
+* @param options - Value, overrides, and resolver options
+* @returns Semantic HTML string with `sc-` prefixed classes
+*/
+function renderToHtml(schema, options = {}) {
+	const mergedMeta = { ...options.meta };
+	if (options.readOnly === true) mergedMeta.readOnly = true;
+	if (options.writeOnly === true) mergedMeta.writeOnly = true;
+	if (options.description !== void 0) mergedMeta.description = options.description;
+	const { jsonSchema, rootMeta, rootDocument } = normaliseSchema(schema, options.ref);
+	const tree = walk(jsonSchema, {
+		componentMeta: mergedMeta,
+		rootMeta,
+		fieldOverrides: options.fields,
+		rootDocument
+	});
+	const resolver = options.resolver ?? defaultHtmlResolver;
+	const renderChild = (childTree, childValue, pathSuffix) => {
+		return renderFieldHtml(childTree, childValue, resolver, pathSuffix ?? childTree.meta.description ?? "", renderChild);
+	};
+	return renderFieldHtml(tree, options.value, resolver, "", renderChild);
+}
+function renderFieldHtml(tree, value, resolver, path, renderChild) {
+	const mergedResolver = mergeHtmlResolvers(resolver, defaultHtmlResolver);
+	const renderFn = getHtmlRenderFn(tree.type, mergedResolver);
+	if (renderFn !== void 0) {
+		const props = {
+			value,
+			readOnly: tree.editability === "presentation",
+			writeOnly: tree.editability === "input",
+			meta: tree.meta,
+			constraints: tree.constraints,
+			path,
+			tree,
+			renderChild
+		};
+		if (tree.enumValues !== void 0) props.enumValues = tree.enumValues;
+		if (tree.element !== void 0) props.element = tree.element;
+		if (tree.fields !== void 0) props.fields = tree.fields;
+		if (tree.options !== void 0) props.options = tree.options;
+		if (tree.discriminator !== void 0) props.discriminator = tree.discriminator;
+		if (tree.keyType !== void 0) props.keyType = tree.keyType;
+		if (tree.valueType !== void 0) props.valueType = tree.valueType;
+		return renderFn(props);
+	}
+	if (value === void 0 || value === null) return serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
+	return serialize(h("span", { class: "sc-value" }, typeof value === "string" ? value : JSON.stringify(value)));
+}
+//#endregion
+export { defaultHtmlResolver, renderToHtml };

package/dist/html/renderToHtmlStream.d.mts

@@ -0,0 +1,58 @@
+import { RenderToHtmlOptions } from "./renderToHtml.mjs";
+
+//#region src/html/renderToHtmlStream.d.ts
+/**
+ * Streaming HTML renderer — yields HTML chunks incrementally.
+ *
+ * Same rendering pipeline as `renderToHtml` but yields string fragments
+ * as each field/element is produced instead of building the entire string
+ * in memory. Use for server-side rendering where you want to start
+ * flushing the response before the full schema is rendered.
+ *
+ * Three output formats:
+ *
+ * - `renderToHtmlChunks(schema, options)` → sync `Iterable<string>`
+ * - `renderToHtmlStream(schema, options)` → async `AsyncIterable<string>`
+ * - `renderToHtmlReadable(schema, options)` → web `ReadableStream<string>`
+ *
+ * Chunk boundaries:
+ * - Object: opening tag, one chunk per field, closing tag
+ * - Array: opening tag, one chunk per item, closing tag
+ * - Record: opening tag, one chunk per entry, closing tag
+ * - Leaf types (string, number, boolean, enum, literal, unknown):
+ *   rendered entirely as one chunk
+ *
+ * All HTML construction uses `h()` from `html.ts` — the streaming module
+ * manually yields the opening tag, then children, then the closing tag.
+ */
+type StreamRenderOptions = RenderToHtmlOptions;
+/**
+ * Render a schema to HTML string chunks, yielded incrementally.
+ *
+ * Each yielded chunk is a self-contained HTML fragment. Concatenating
+ * all chunks produces the same output as `renderToHtml`.
+ *
+ * @returns Sync iterable of HTML string chunks
+ */
+declare function renderToHtmlChunks(schema: unknown, options?: StreamRenderOptions): Iterable<string, void, undefined>;
+/**
+ * Render a schema to HTML string chunks asynchronously.
+ *
+ * Identical chunk boundaries to `renderToHtmlChunks` but yields via
+ * an async generator. Use with `for await...of` or pipe to a response.
+ *
+ * @returns Async iterable of HTML string chunks
+ */
+declare function renderToHtmlStream(schema: unknown, options?: StreamRenderOptions): AsyncIterable<string, void, undefined>;
+/**
+ * Render a schema to a web `ReadableStream<string>`.
+ *
+ * ```ts
+ * return new Response(renderToHtmlReadable(schema, { value }), {
+ *     headers: { "Content-Type": "text/html" },
+ * });
+ * ```
+ */
+declare function renderToHtmlReadable(schema: unknown, options?: StreamRenderOptions): ReadableStream<string>;
+//#endregion
+export { StreamRenderOptions, renderToHtmlChunks, renderToHtmlReadable, renderToHtmlStream };