vinojs 0.1.3 → 0.2.0

package/README.md

@@ -1,16 +1,22 @@
 # Vino
 
 Hono + Vite meta-framework designed for Cloudflare Workers.
+Vino extends your server, it will simply mounts pages onto it
 
 Early WIP - core changes will happen
 
+## Vino extends hono with the following features
+
+- Hydration - `definePage` for a whole page, `src/components/` for widgets (`hono/jsx/dom`)
+- Client routing - Optionally with `clientRouting: true`, same-origin navigations fetch only new content
+- Page factory - Create new pages with server data fetching builtin
+
+## Optional vite plugin
+
 - **Pages** — filesystem routes in `src/pages` using Nitro path syntax
 - **Layouts** — `src/layout` files wrap matching routes
-- **Server** — your Hono app; Vino mounts pages onto it
-- **SSR** — `hono/jsx`
-- **Hydration** — `definePage` for a whole page, `src/components/` for widgets (`hono/jsx/dom`)
-- **SSG** — prerender static routes (and dynamic routes with `ssgParams`) at build time; `partial` writes layout shells, `full` writes complete HTML
-- **Dev / deploy** — `@cloudflare/vite-plugin`
+- **SSG** — prerender static routes (and dynamic routes with `ssgParams`) at build time as full HTML
+- **Dev / deploy** — Integrates with `@cloudflare/vite-plugin`
 
 ## Install
 
@@ -21,11 +27,11 @@ pnpm add -D vite @cloudflare/vite-plugin wrangler
 
 ## Quick start
 
-`src/server.ts` — you own the Hono app; extra routes stay on it:
+`src/server.ts`
 
 ```ts
 import { Hono } from "hono";
-import { createVino, mountVino } from "vinojs";
+import { mountVino } from "vinojs/mount";
 import { api } from "./api";
 
 const app = new Hono().route("/api", api);
@@ -66,7 +72,7 @@ export default defineConfig({
 | `blog/[slug].tsx`      | `/blog/:slug` |
 | `docs/[...slug].tsx`   | `/docs/*`     |
 
-The file **is** the page. Export a default component, `definePage(...)`, `defineServerPage(...)`, a Hono sub-app, or named `GET` / `POST` handlers.
+You export a default component, `definePage(...)`, `defineServerPage(...)`
 
 ```tsx
 import { definePage } from "vinojs";
@@ -82,15 +88,15 @@ export default definePage(() => {
 import { definePage } from "vinojs";
 
 export default definePage({
-  render: ({ data }) => <h1>{data.title}</h1>,
+  config: { prerender: true, clientRouting: true },
   data: async (c) => ({ title: "Hello" }),
-  config: { prerender: "full", clientRouting: true },
+  render: ({ data }) => <h1>{data.title}</h1>,
 });
 ```
 
 `definePage` SSRs with `hono/jsx`, then hydrates `#vino-page` with `hono/jsx/dom`. `data` and `config` are colocated on the page.
 
-Colocate loaders in `*.server.ts` and pass them through `defineServerFn`. The result is a `data` loader today; the same wrapper is how server functions will be called later (no `'use server'`).
+Colocate loaders in `*.server.ts` and pass them through `defineServerFn`. The result is a `data` loader today; the same wrapper is how server functions will be called later.
 
 ```ts
 // [slug].server.ts
@@ -123,7 +129,7 @@ import { defineServerPage } from "vinojs";
 export default defineServerPage(() => <h1>About</h1>);
 ```
 
-`prerender` may be `'full'` (complete HTML at build), `'partial'` (layout shell + empty `#vino-page`; client fetches content), or `false`.
+`prerender: true` includes the page in SSG (full HTML at build). Omit or set `false` to skip.
 
 ### Layouts (`src/layout`)
 
@@ -145,17 +151,16 @@ Put widgets in `src/components/` (or name `$Widget.tsx` / `Widget.component.tsx`
 
 ### Navigation
 
-`clientRouting: true` in `definePage({ config })` or `vino({ clientRouting: true })` intercepts same-origin links, fetches page content only (`X-Vino-Nav`), swaps `#vino-page`, and rehydrates. Layout stays mounted. Default is on via the Vite plugin.
+`clientRouting: true` in `definePage({ config })`, `vino({ clientRouting: true })`, or `hydration({ clientRouting: true })` intercepts same-origin links, fetches page content only (`X-Vino-Nav`), swaps `#vino-page`, and rehydrates. Layout stays mounted. Default is on via the Vite plugin.
 
 ## API
 
-- `createVino()` — `vinojs`
-- `mountVino(app)` — `vinojs`
+- `createVino()` / `mountVino(app)` — `vinojs/mount` (Vite filesystem routes; uses virtual modules)
 - `definePage(fn | { render, data?, config? })` — hydrate the page (`vinojs`)
 - `defineServerPage(...)` — SSR only, never hydrate (`vinojs`)
 - `defineServerFn(fn)` — server-only function; pass as `definePage({ data })` (`vinojs`)
-- `createClient()` — `vinojs/client` (injected automatically)
-- `vino({ pagesDir, layoutsDir, clientRouting, prerender })` — `vinojs/vite`
+- `createClient()` — `vinojs/client` (injected automatically by the Vite plugin; hydrates and runs client routing)
+- `vino({ pagesDir, layoutsDir, clientRouting, prerender })` — `vinojs/vite` (`prerender: true` writes full HTML at build)
 
 APIs stay on your Hono app. Use `hono/client` `hc` against those routes; page HTML is never fetched through `hc`.
 
@@ -164,7 +169,7 @@ APIs stay on your Hono app. Use `hono/client` `hc` against those routes; page HT
 ```bash
 pnpm install
 pnpm build
-pnpm --filter @vinojs/example-basic dev
+pnpm --filter @vinojs/example-basic-vite dev
 ```
 
 ## License

package/dist/client.d.mts

@@ -1,13 +1,19 @@
-import { u as VinoPayload } from "./types-CQITdkpF.mjs";
+import { l as VinoPayload } from "./types-jfsZLl9U.mjs";
 //#region src/client/create-client.d.ts
-interface CreateClientOptions {
-  hydrate?: (vnode: unknown, el: Element) => void | Promise<void>;
-  createElement?: (type: unknown, props: unknown) => unknown;
-}
 type ComponentLoaders = Record<string, () => Promise<Record<string, unknown>>>;
 type ClientPageLoaders = Record<string, () => Promise<{
   default?: unknown;
 }>>;
+interface CreateClientOptions {
+  /** Hydratable component loaders (from Vite `virtual:vino/components`). */
+  components?: ComponentLoaders;
+  /** Client-page loaders (from Vite `virtual:vino/client-pages`). */
+  clientPages?: ClientPageLoaders;
+  /** Escape hatch: custom hydrate when not using the signal runtime. */
+  hydrate?: (vnode: unknown, el: Element) => void | Promise<void>;
+  /** Escape hatch: build a vnode for custom `hydrate` (legacy hono/jsx/dom path). */
+  createElement?: (type: unknown, props: unknown) => unknown;
+}
 type VinoHmrPayload = {
   kind: "component";
   id: string;
@@ -29,13 +35,73 @@ type VinoHmrPayload = {
 };
 type HmrFn = (payload: VinoHmrPayload) => void;
 /**
- * Fill partial shells, hydrate `#vino-page` / `<vino-component>`, and intercept
- * same-origin links with content-only swaps when `clientRouting` is enabled.
+ * Hydrate `#vino-page` / `<vino-component>`, and intercept same-origin links
+ * with content-only swaps when `clientRouting` is enabled in the payload.
  */
 declare function createClient(options?: CreateClientOptions): {
   ready: Promise<VinoPayload | null>;
   hmr: HmrFn;
 };
 //#endregion
-export { type CreateClientOptions, type VinoHmrPayload, createClient };
+//#region src/client/runtime/signal.d.ts
+type Accessor<T> = {
+  (): T;
+  readonly [SIGNAL]: true;
+};
+type Setter<T> = (value: T | ((prev: T) => T)) => T;
+type Signal<T> = [get: Accessor<T>, set: Setter<T>];
+declare const SIGNAL: unique symbol;
+declare function isSignalAccessor(value: unknown): value is Accessor<unknown>;
+declare function createSignal<T>(initial: T): Signal<T>;
+declare function createEffect(fn: () => void | (() => void)): void;
+declare function onCleanup(fn: () => void): void;
+declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+declare function untrack<T>(fn: () => T): T;
+//#endregion
+//#region src/client/runtime/mount.d.ts
+type Mountable = (props: never) => unknown;
+interface MountRoot {
+  render: (component: Mountable, props?: Record<string, unknown>) => void;
+  unmount: () => void;
+}
+/**
+ * Mount a setup-style component into `el`.
+ * Prefers hydrating a single SSR root element; otherwise replaces children.
+ */
+declare function mountComponent(el: Element, component: Mountable, props?: Record<string, unknown>): MountRoot;
+/** Alias for page slot mounting. */
+declare function hydratePage(el: Element, page: Mountable, props?: Record<string, unknown>): MountRoot;
+//#endregion
+//#region src/client/runtime/control.d.ts
+type ShowProps = {
+  when: boolean | Accessor<boolean> | (() => boolean);
+  children?: unknown;
+  fallback?: unknown;
+};
+/**
+ * Conditionally mount `children` or `fallback` based on a reactive `when`.
+ * On the server (no `document`), returns the active branch for `hono/jsx` SSR.
+ */
+declare function Show(props: ShowProps): unknown;
+//#endregion
+//#region src/client/runtime/control-for.d.ts
+type ForProps<T> = {
+  each: T[] | Accessor<T[]> | (() => T[]);
+  children: (item: T, index: number) => unknown;
+};
+/**
+ * Reactive list. On the server, maps `each` once for `hono/jsx` SSR.
+ */
+declare function For<T>(props: ForProps<T>): unknown;
+//#endregion
+//#region src/client/runtime/hooks.d.ts
+/** Signal-backed `useState` compatible with stock JSX (`value={count}`, `{count}` as child). */
+declare function useState<T>(initial: T | (() => T)): [Accessor<T>, Setter<T>];
+/** Runs `fn` in a reactive effect. Dependency arrays are ignored (Solid-style). */
+declare function useEffect(fn: () => void | (() => void), _deps?: unknown[]): void;
+declare function useRef<T>(initial: T): {
+  current: T;
+};
+//#endregion
+export { type Accessor, type CreateClientOptions, For, type ForProps, type MountRoot, type Mountable, type Setter, Show, type ShowProps, type Signal, type VinoHmrPayload, createClient, createEffect, createRoot, createSignal, hydratePage, isSignalAccessor, mountComponent, onCleanup, untrack, useEffect, useRef, useState };
 //# sourceMappingURL=client.d.mts.map

package/dist/client.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.mts","names":[],"sources":["../src/client/create-client.ts"],"mappings":";;UAIiB;EACf,WAAW,gBAAgB,IAAI,mBAAmB;EAClD,iBAAiB,eAAe;;KAG7B,mBAAmB,qBAAqB,QAAQ;KAChD,oBAAoB,qBAAqB;EAAU;;KAc5C;EACN;EAAmB;EAAY,MAAM;;EACrC;EAAqB;EAAY;IAAQ;;;EACzC;;EACA;;EACA;EAAkB,aAAa;EAAkB,cAAc;;KAEhE,SAAS,SAAS;;;;;iBAgVP,aAAa,UAAS"}
+{"version":3,"file":"client.d.mts","names":[],"sources":["../src/client/create-client.ts","../src/client/runtime/signal.ts","../src/client/runtime/mount.ts","../src/client/runtime/control.ts","../src/client/runtime/control-for.ts","../src/client/runtime/hooks.ts"],"mappings":";;KAKK,mBAAmB,qBAAqB,QAAQ;KAChD,oBAAoB,qBAAqB;EAAU;;UAEvC;;EAEf,aAAa;;EAEb,cAAc;;EAEd,WAAW,gBAAgB,IAAI,mBAAmB;;EAElD,iBAAiB,eAAe;;KAUtB;EACN;EAAmB;EAAY,MAAM;;EACrC;EAAqB;EAAY;IAAQ;;;EACzC;;EACA;;EACA;EAAkB,aAAa;EAAkB,cAAc;;KAEhE,SAAS,SAAS;;;;;iBAqTP,aAAa,UAAS;;;;;;KCtV1B,SAAS;MACf;YACM;;KAGA,OAAO,MAAM,OAAO,MAAM,MAAM,MAAM,OAAO;KAE7C,OAAO,MAAM,KAAK,SAAS,IAAI,KAAK,OAAO;cAE1C;iBA0BG,iBAAiB,iBAAiB,SAAS;iBAI3C,aAAa,GAAG,SAAS,IAAI,OAAO;iBAiCpC,aAAa;iBA0Bb,UAAU;iBAUV,WAAW,GAAG,KAAK,wBAAwB,IAAI;iBA0B/C,QAAQ,GAAG,UAAU,IAAI;;;KCnI7B,aAAa;UAER;EACf,SAAS,WAAW,WAAW,QAAQ;EACvC;;;;;;iBAoDc,eACd,IAAI,SACJ,WAAW,WACX,QAAO,0BACN;;iBA8Ba,YACd,IAAI,SACJ,MAAM,WACN,QAAO,0BACN;;;KC/FS;EACV,gBAAgB;EAChB;EACA;;;;;;iBAiCc,KAAK,OAAO;;;KCpChB,SAAS;EACnB,MAAM,MAAM,SAAS,cAAc;EACnC,WAAW,MAAM,GAAG;;;;;iBAgCN,IAAI,GAAG,OAAO,SAAS;;;;iBCjCvB,SAAS,GAAG,SAAS,WAAW,MAAM,SAAS,IAAI,OAAO;;iBAK1D,UAAU,+BAA+B;iBAOzC,OAAO,GAAG,SAAS;EAAM,SAAS"}

package/dist/client.mjs

@@ -1,5 +1,73 @@
-import { c as PAGE_SLOT_ID, l as PAYLOAD_SCRIPT_ID, o as NAV_HEADER, t as COMPONENT_TAG } from "./constants-BVT2bJEd.mjs";
-import { u as resolvePageRender } from "./definePage-CcqUZAiy.mjs";
+import { c as PAGE_SLOT_ID, l as PAYLOAD_SCRIPT_ID, o as NAV_HEADER, t as COMPONENT_TAG } from "./constants-DyXAsId-.mjs";
+import { f as resolvePageRender } from "./definePage-DC6gJKwW.mjs";
+import { a as pushHydrateCursor, c as createSignal, d as untrack, i as popHydrateCursor, l as isSignalAccessor, o as createEffect, s as createRoot, u as onCleanup } from "./jsx-runtime-5OIvn_Qa.mjs";
+//#region src/client/runtime/mount.ts
+function isDomNode$2(value) {
+	return typeof value === "object" && value !== null && "nodeType" in value && typeof value.nodeType === "number";
+}
+function toNodes$2(value) {
+	if (value == null || value === false || value === true) return [];
+	if (typeof value === "string" || typeof value === "number") return [document.createTextNode(String(value))];
+	if (isDomNode$2(value)) return [value];
+	if (Array.isArray(value)) return value.flatMap(toNodes$2);
+	return [];
+}
+function elementChildCount(el) {
+	return Array.from(el.childNodes).filter((n) => !(n.nodeType === 3 && !n.textContent?.trim())).length;
+}
+/**
+* Hydrate into existing SSR DOM when the slot has a single element child
+* and `jsx()` claims that node. Stock `react-jsx` evaluates nested `jsx()`
+* before the parent, so a mismatch falls back to create-mode instead of
+* keeping an empty claimed root.
+*/
+function mountInto(el, component, props) {
+	if (elementChildCount(el) === 1) {
+		pushHydrateCursor(el);
+		try {
+			const live = toNodes$2(component(props))[0];
+			const ssr = Array.from(el.childNodes).find((n) => n.nodeType === 1);
+			if (live && ssr && live === ssr) return;
+		} finally {
+			popHydrateCursor();
+		}
+	}
+	el.replaceChildren(...toNodes$2(component(props)));
+}
+/**
+* Mount a setup-style component into `el`.
+* Prefers hydrating a single SSR root element; otherwise replaces children.
+*/
+function mountComponent(el, component, props = {}) {
+	let dispose;
+	const run = (next, nextProps) => {
+		dispose?.();
+		createRoot((d) => {
+			dispose = d;
+			mountInto(el, next, nextProps);
+		});
+	};
+	run(component, props);
+	return {
+		render: (next, nextProps) => {
+			dispose?.();
+			createRoot((d) => {
+				dispose = d;
+				el.replaceChildren(...toNodes$2(next(nextProps ?? props)));
+			});
+		},
+		unmount: () => {
+			dispose?.();
+			dispose = void 0;
+			el.replaceChildren();
+		}
+	};
+}
+/** Alias for page slot mounting. */
+function hydratePage(el, page, props = {}) {
+	return mountComponent(el, page, props);
+}
+//#endregion
 //#region src/client/create-client.ts
 const islands = /* @__PURE__ */ new Map();
 let pageRoot = null;
@@ -48,39 +116,26 @@ function writePayload(payload) {
 	}
 	el.textContent = JSON.stringify(payload).replaceAll("<", "\\u003c");
 }
-async function loadDom() {
-	const [{ hydrateRoot }, { createElement }] = await Promise.all([import("hono/jsx/dom/client"), import("hono/jsx/dom")]);
-	return {
-		hydrateRoot,
-		createElement
-	};
-}
-async function getComponentLoaders() {
-	componentLoaders ??= (await import("virtual:vino/components")).components;
-	return componentLoaders;
+function getComponentLoaders() {
+	return componentLoaders ?? {};
 }
-async function getClientPageLoaders() {
-	clientPageLoaders ??= (await import("virtual:vino/client-pages")).clientPages;
-	return clientPageLoaders;
+function getClientPageLoaders() {
+	return clientPageLoaders ?? {};
 }
-function vnodeFor(options, createElement, type, props) {
-	return options.createElement ? options.createElement(type, props) : createElement(type, props);
-}
-async function mountVnode(options, el, vnode, existing) {
-	if (existing) {
-		existing.render(vnode);
-		return existing;
-	}
+async function mountSetup(options, el, component, props, existing) {
 	if (options.hydrate) {
+		const vnode = options.createElement ? options.createElement(component, props) : component(props);
 		await options.hydrate(vnode, el);
 		return null;
 	}
-	const { hydrateRoot } = await loadDom();
-	return hydrateRoot(el, vnode);
+	if (existing) {
+		existing.render(component, props);
+		return existing;
+	}
+	return hydratePage(el, component, props);
 }
 async function hydrateComponents(options, root = document) {
-	const components = await getComponentLoaders();
-	const { createElement } = await loadDom();
+	const components = getComponentLoaders();
 	const nodes = root.querySelectorAll(COMPONENT_TAG);
 	for (const el of nodes) {
 		const id = el.getAttribute("data-component");
@@ -95,10 +150,9 @@ async function hydrateComponents(options, root = document) {
 		const Component = (await loader())[exportName];
 		if (typeof Component !== "function") continue;
 		const props = JSON.parse(propsJson);
-		const vnode = vnodeFor(options, createElement, Component, props);
 		const previous = islands.get(el);
 		if (previous?.root) previous.root.unmount();
-		const mounted = await mountVnode(options, el, vnode, null);
+		const mounted = await mountSetup(options, el, Component, props, null);
 		islands.set(el, {
 			id,
 			exportName,
@@ -111,7 +165,7 @@ async function hydrateClientPage(payload, options) {
 	if (!payload.clientPage) return;
 	const root = document.getElementById(PAGE_SLOT_ID);
 	if (!root) return;
-	const load = (await getClientPageLoaders())[payload.clientPage];
+	const load = getClientPageLoaders()[payload.clientPage];
 	if (!load) return;
 	const mod = await load();
 	await renderClientPage(payload.clientPage, mod, payload, options, root);
@@ -119,21 +173,19 @@ async function hydrateClientPage(payload, options) {
 async function renderClientPage(path, mod, payload, options, root) {
 	const Page = resolvePageRender(mod.default);
 	if (!Page) return;
-	const { createElement } = await loadDom();
-	const vnode = vnodeFor(options, createElement, Page, {
+	const props = {
 		data: payload.data,
 		params: payload.params
-	});
+	};
 	const reuse = pageRoot?.el === root ? pageRoot.root : null;
 	if (pageRoot && pageRoot.el !== root) pageRoot.root?.unmount();
 	pageRoot = {
 		el: root,
 		path,
-		root: await mountVnode(options, root, vnode, reuse)
+		root: await mountSetup(options, root, Page, props, reuse)
 	};
 }
 async function patchComponent(id, mod, options) {
-	const { createElement } = await loadDom();
 	for (const [el, rec] of islands) {
 		if (rec.id !== id) continue;
 		if (!el.isConnected) {
@@ -143,7 +195,7 @@ async function patchComponent(id, mod, options) {
 		}
 		const Component = mod[rec.exportName];
 		if (typeof Component !== "function") continue;
-		rec.root = await mountVnode(options, el, vnodeFor(options, createElement, Component, rec.props), rec.root);
+		rec.root = await mountSetup(options, el, Component, rec.props, rec.root);
 	}
 }
 async function patchClientPage(path, mod, options) {
@@ -202,17 +254,6 @@ async function applyContent(href, push, options, fragment) {
 async function navigate(href, push, options) {
 	return applyContent(href, push, options, await fetchContent(href));
 }
-async function fillPartialShell(options, payload) {
-	if (!payload?.partial) return payload;
-	const slot = document.getElementById(PAGE_SLOT_ID);
-	if (!slot) return payload;
-	if (slot.childNodes.length > 0) return hydrateSlot(options, {
-		...payload,
-		partial: false
-	});
-	const fragment = await fetchContent(location.href);
-	return applyContent(location.href, false, options, fragment);
-}
 function bindRouting(options, payload) {
 	if (!payload?.clientRouting) return;
 	document.addEventListener("click", (event) => {
@@ -262,19 +303,19 @@ async function handleHmr(payload, options) {
 	if (payload.kind === "client-page" && payload.mod) await patchClientPage(payload.id, payload.mod, options);
 }
 /**
-* Fill partial shells, hydrate `#vino-page` / `<vino-component>`, and intercept
-* same-origin links with content-only swaps when `clientRouting` is enabled.
+* Hydrate `#vino-page` / `<vino-component>`, and intercept same-origin links
+* with content-only swaps when `clientRouting` is enabled in the payload.
 */
 function createClient(options = {}) {
+	if (options.components) componentLoaders = options.components;
+	if (options.clientPages) clientPageLoaders = options.clientPages;
 	const hmr = (payload) => {
 		handleHmr(payload, options);
 	};
 	bindHmr(hmr);
 	return {
 		ready: (async () => {
-			let payload = readPayload();
-			if (payload?.partial) payload = await fillPartialShell(options, payload) ?? payload;
-			else payload = await hydrateSlot(options, payload) ?? payload;
+			const payload = await hydrateSlot(options, readPayload()) ?? readPayload();
 			bindRouting(options, payload);
 			return payload;
 		})(),
@@ -282,6 +323,106 @@ function createClient(options = {}) {
 	};
 }
 //#endregion
-export { createClient };
+//#region src/client/runtime/control.ts
+function readWhen(when) {
+	if (isSignalAccessor(when)) return Boolean(when());
+	if (typeof when === "function") return Boolean(when());
+	return Boolean(when);
+}
+function isDomNode$1(value) {
+	return typeof value === "object" && value !== null && "nodeType" in value && typeof value.nodeType === "number";
+}
+function toNodes$1(value) {
+	if (value == null || value === false || value === true) return [];
+	if (typeof value === "string" || typeof value === "number") return [document.createTextNode(String(value))];
+	if (isDomNode$1(value)) return [value];
+	if (Array.isArray(value)) return value.flatMap(toNodes$1);
+	if (typeof value === "function") return toNodes$1(value());
+	return [];
+}
+/**
+* Conditionally mount `children` or `fallback` based on a reactive `when`.
+* On the server (no `document`), returns the active branch for `hono/jsx` SSR.
+*/
+function Show(props) {
+	if (typeof document === "undefined") return readWhen(props.when) ? props.children : props.fallback;
+	const frag = document.createDocumentFragment();
+	const start = document.createComment("vino-show");
+	const end = document.createComment("/vino-show");
+	frag.append(start, end);
+	let current = [];
+	const clear = () => {
+		for (const node of current) node.parentNode?.removeChild(node);
+		current = [];
+	};
+	const insert = (nodes) => {
+		const parent = start.parentNode;
+		if (!parent) return;
+		for (const node of nodes) parent.insertBefore(node, end);
+		current = nodes;
+	};
+	createEffect(() => {
+		clear();
+		insert(toNodes$1(readWhen(props.when) ? props.children : props.fallback));
+	});
+	return frag;
+}
+//#endregion
+//#region src/client/runtime/control-for.ts
+function readEach(each) {
+	if (isSignalAccessor(each)) return each();
+	if (typeof each === "function") return each();
+	return each;
+}
+function isDomNode(value) {
+	return typeof value === "object" && value !== null && "nodeType" in value && typeof value.nodeType === "number";
+}
+function toNodes(value) {
+	if (value == null || value === false || value === true) return [];
+	if (typeof value === "string" || typeof value === "number") return [document.createTextNode(String(value))];
+	if (isDomNode(value)) return [value];
+	if (Array.isArray(value)) return value.flatMap(toNodes);
+	if (typeof value === "function") return toNodes(value());
+	return [];
+}
+/**
+* Reactive list. On the server, maps `each` once for `hono/jsx` SSR.
+*/
+function For(props) {
+	if (typeof document === "undefined") return readEach(props.each).map((item, i) => props.children(item, i));
+	const frag = document.createDocumentFragment();
+	const start = document.createComment("vino-for");
+	const end = document.createComment("/vino-for");
+	frag.append(start, end);
+	let current = [];
+	createEffect(() => {
+		for (const node of current) node.parentNode?.removeChild(node);
+		current = [];
+		const parent = start.parentNode;
+		if (!parent) return;
+		const nodes = readEach(props.each).flatMap((item, i) => toNodes(props.children(item, i)));
+		for (const node of nodes) parent.insertBefore(node, end);
+		current = nodes;
+	});
+	return frag;
+}
+//#endregion
+//#region src/client/runtime/hooks.ts
+/** Signal-backed `useState` compatible with stock JSX (`value={count}`, `{count}` as child). */
+function useState(initial) {
+	return createSignal(typeof initial === "function" ? initial() : initial);
+}
+/** Runs `fn` in a reactive effect. Dependency arrays are ignored (Solid-style). */
+function useEffect(fn, _deps) {
+	createEffect(() => {
+		const cleanup = fn();
+		if (typeof cleanup === "function") onCleanup(cleanup);
+	});
+}
+function useRef(initial) {
+	return { current: initial };
+}
+//#endregion
+export { For, Show, createClient, createEffect, createRoot, createSignal, hydratePage, isSignalAccessor, mountComponent, onCleanup, untrack, useEffect, useRef, useState };
 
 //# sourceMappingURL=client.mjs.map