@firsthandjs/server 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Firsthand contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @firsthandjs/server
+
+Server rendering for Firsthand: the same components, rendered to markup.
+
+**Documentation:** [guide](https://github.com/firsthandjs/firsthand/blob/main/docs/guide/17-server-rendering.md) · [API reference](https://github.com/firsthandjs/firsthand/blob/main/docs/reference/server.md) · [ADR-0027](https://github.com/firsthandjs/firsthand/blob/main/docs/adr/0027-server-rendering-and-hydration.md)
+
+```
+npm install @firsthandjs/server
+```
+
+1.17 kB gzip, on a server, so it is not part of any browser's download. It
+depends on `@firsthandjs/core` and never touches a `document`.
+
+```tsx
+import { renderToString } from '@firsthandjs/server';
+
+const html = renderToString(() => <App />);
+```
+
+The application is the application. Nothing in it is written for a server:
+`App` is the same file the browser renders, compiled a second time against a
+runtime that builds a string instead of a tree. Vite already knows which build
+it is running, so the project configures nothing beyond saying that it
+hydrates:
+
+```ts
+firsthand({ hydratable: true });
+```
+
+## With data
+
+```tsx
+const storage = createMemoryStorage();
+const data = createData({ storage });
+
+const html = await renderToStringAsync(() => <App data={data} />, {
+  settle: () => data.settle(),
+  timeout: 2_000,
+});
+```
+
+`storage.dump()` goes into the page, and a browser that starts from it finds
+every named resource already answered — during its first run, not a microtask
+later, which is what makes the first paint the markup rather than a spinner
+replacing it.
+
+## In the browser
+
+```tsx
+import { hydrate } from '@firsthandjs/dom/hydrate';
+
+hydrate(() => <App data={data} />, document.getElementById('app')!);
+```
+
+Every element the server sent is adopted rather than built. The only writes are
+the listeners and the properties markup cannot express — which
+`tests/browser/ssr.spec.ts` asserts in Chromium, Firefox and WebKit with a
+`MutationObserver` installed before any script the page carries.
+
+## Measured
+
+1 000 rows, production builds on every side, output compared before anything is
+timed (`node benchmarks/ssr/run.mjs`):
+
+|                  | Firsthand    | Solid     | Vue       | React     |
+| ---------------- | ------------ | --------- | --------- | --------- |
+| render to markup | **0.171 ms** | 0.205 ms  | 15.02 ms  | 199.67 ms |
+| markup size      | 222 802 B    | 238 694 B | 222 802 B | 222 802 B |
+| hydrate          | **4.12 ms**  | 4.62 ms   | 10.48 ms  | —         |
+
+A complete example — application, two entry points, and a server in eighty
+lines of `node:http` — is in
+[`examples/ssr`](https://github.com/firsthandjs/firsthand/tree/main/examples/ssr).

package/dist/chunk-2FO6Y3CD.js

@@ -0,0 +1 @@
+var u=/[&<>]/,l=/[&"]/;function f(n){if(!u.test(n))return n;let t="",r=0;for(let e=0;e<n.length;e++){let s=n.charCodeAt(e),i;if(s===38)i="&amp;";else if(s===60)i="&lt;";else if(s===62)i="&gt;";else continue;t+=n.slice(r,e)+i,r=e+1}return t+n.slice(r)}function p(n){if(!l.test(n))return n;let t="",r=0;for(let e=0;e<n.length;e++){let s=n.charCodeAt(e),i;if(s===38)i="&amp;";else if(s===34)i="&quot;";else continue;t+=n.slice(r,e)+i,r=e+1}return t+n.slice(r)}function c(n,t){return t==null||t===!1?"":t===!0?` ${n}=""`:` ${n}="${p(String(t))}"`}function T(n,t){return t===!0||t!=null&&t!==!1&&t?` ${d(n)}=""`:""}function d(n){return n==="readOnly"?"readonly":n.toLowerCase()}var a={value:"value",textContent:"",innerHTML:"",innerText:"",scrollTop:"",scrollLeft:"",volume:"",currentTime:"",playbackRate:"",srcObject:"",className:"class",class:"class",htmlFor:"for"};function x(n,t){let r=a[n];return r===void 0||r===""?"":c(r,t)}function k(n){return c("class",y(n))}function y(n){if(n==null)return null;if(typeof n=="string")return n;if(Array.isArray(n))return n.filter(Boolean).join(" ");if(typeof n=="object"){let t=[];for(let r in n)n[r]&&t.push(r);return t.length===0?null:t.join(" ")}return String(n)}function b(n){if(n==null)return"";if(typeof n!="object")return c("style",String(n));let t=[];for(let r in n){let e=n[r];e!=null&&t.push(`${w(r)}: ${String(e)};`)}return t.length===0?"":c("style",t.join(" "))}var h=/[A-Z]/g;function w(n){return n.startsWith("--")?n:n.replace(h,t=>`-${t.toLowerCase()}`)}var o=class{constructor(t){this.html=t}html};function E(n,...t){if(t.length===0)return new o(n[0]);let r=n[0];for(let e=0;e<t.length;e++)r+=t[e]??"",r+=n[e+1];return new o(r)}function g(n){let t=typeof n;if(t==="object"){if(n===null)return"";if(n instanceof o)return n.html}else{if(t==="string")return f(n);if(t==="number"||t==="bigint")return String(n);if(n===void 0||t==="boolean")return""}if(Array.isArray(n)){let r="";for(let e=0;e<n.length;e++)r+=g(n[e]);return r}return t==="function"?g(n()):f(String(n))}export{f as a,p as b,c,T as d,x as e,k as f,b as g,o as h,E as i,g as j};

package/dist/component.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Instantiating a component where there is no DOM.
+ *
+ * The twin of `createComponent` in `@firsthandjs/dom`, and deliberately the
+ * same shape: props are frozen and handed over untouched, the setup runs once
+ * under its own owner, and what it returns is the view. The only difference is
+ * what a view *is* — markup rather than nodes.
+ *
+ * The symbols are `Symbol.for`, so this recognises a component and a view
+ * function without importing the DOM package at all. A server that never
+ * touches `@firsthandjs/dom` cannot accidentally reach for a `document`.
+ */
+declare const COMPONENT: unique symbol;
+declare const VIEW: unique symbol;
+type Declared = {
+    readonly [COMPONENT]?: true;
+    readonly [VIEW]?: true;
+    readonly setup?: (props: unknown) => unknown;
+    readonly name?: string;
+    tag?: string | undefined;
+    readonly options?: {
+        readonly shadow?: boolean;
+    } | undefined;
+};
+/** Emitted by the compiler for a module-level function it compiled markup into. */
+export declare function view<T>(target: T): T;
+export declare function createComponent(target: Declared, props: unknown): unknown;
+/**
+ * `{...props}` as markup.
+ *
+ * `spread` in the browser applies whatever it is given by the same rules the
+ * named attributes follow, so this has to as well — including leaving out the
+ * things a server cannot write: handlers, refs and properties with no
+ * attribute behind them.
+ */
+export declare function spread(values: Record<string, unknown>): string;
+export {};
+//# sourceMappingURL=component.d.ts.map

package/dist/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,QAAA,MAAM,SAAS,EAAE,OAAO,MAAmD,CAAC;AAC5E,QAAA,MAAM,IAAI,EAAE,OAAO,MAA8C,CAAC;AAElE,KAAK,QAAQ,GAAG;IACd,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC;IAC5B,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC7C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CAC9D,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAGpC;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAuCzE;AAkBD;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAiB9D"}

package/dist/html.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Turning values into markup, with exactly the meaning the DOM layer gives
+ * them.
+ *
+ * Every function here has a twin in `@firsthandjs/dom`'s `attributes.ts`, and
+ * the pairs have to agree: what the server writes is what the client would
+ * have built, or hydration adopts a tree that does not match and the
+ * difference shows up as a repaint nobody asked for.
+ *
+ * The agreement is not asserted by reading the two files. It is asserted by
+ * rendering the same component both ways and comparing the markup, which is
+ * what `packages/server/test/parity.test.tsx` does for every shape the
+ * compiler can emit.
+ */
+/**
+ * Text, escaped for a child position.
+ *
+ * One pass over the characters, and no allocation at all when there is
+ * nothing to escape — which is almost every string a page contains. A regular
+ * expression test followed by three `replace` calls reads better and measured
+ * slower on the server benchmark, where escaping happens twice per row.
+ *
+ * `&` is handled by the same pass as the others, or the escapes would escape
+ * each other. `>` is not strictly required in text, but a stray one is a
+ * smell worth not emitting.
+ */
+export declare function escapeText(value: string): string;
+/** Text, escaped for a double-quoted attribute value. The same pass. */
+export declare function escapeAttribute(value: string): string;
+/**
+ * One attribute, or nothing at all.
+ *
+ * `setAttribute` in the DOM layer removes the attribute for `null`,
+ * `undefined` and `false`, and writes an empty value for `true`. The absent
+ * cases have to produce no attribute here rather than an empty one, because
+ * `title=""` and no `title` are different trees.
+ */
+export declare function attribute(name: string, value: unknown): string;
+/**
+ * A boolean DOM property, as the attribute that stands for it.
+ *
+ * The client writes `node.checked = true`, which is a property and leaves no
+ * attribute behind. The server has only attributes, so it writes the one the
+ * parser turns back into that property.
+ */
+export declare function booleanAttribute(name: string, value: unknown): string;
+/**
+ * A DOM property, as markup.
+ *
+ * Most properties have no attribute that reproduces them — a `scrollTop` is
+ * not something HTML can say — and those produce nothing: the client sets them
+ * during hydration, which is the only time they can be set at all. `value` is
+ * the one that matters in practice, and the parser does seed it.
+ */
+export declare function property(name: string, value: unknown): string;
+/** `class` from a string, an object or an array, as the DOM layer reads it. */
+export declare function classValue(value: unknown): string;
+/** `style` from a string or an object. */
+export declare function styleValue(value: unknown): string;
+//# sourceMappingURL=html.d.ts.map

package/dist/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../src/html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA4BhD;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAsBrD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAQ9D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAIrE;AAwBD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAM7D;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEjD;AA6BD,0CAA0C;AAC1C,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAejD"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Server-side rendering for Firsthand.
+ *
+ * ```ts
+ * import { renderToString } from '@firsthandjs/server';
+ *
+ * const html = renderToString(() => <App />);
+ * ```
+ *
+ * The application is the application: the same components, the same signals,
+ * the same context. What is different is only what cannot exist without a
+ * browser — effects do not run, and refs and handlers are attached later, by
+ * `hydrate` in `@firsthandjs/dom`.
+ */
+export { renderToString, renderToStringAsync, type AsyncRenderOptions, type RenderOptions, } from './render.js';
+export { escapeAttribute, escapeText } from './html.js';
+export { Markup } from './markup.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+import{a as l,b as O,h as w,j as u}from"./chunk-2FO6Y3CD.js";import{createOwner as c,disposeOwner as f,setOwner as d,setRendering as p,untrack as g}from"@firsthandjs/core";function R(n,e={}){let r=c(null);try{return m(i(n,r),e)}finally{f(r)}}async function T(n,e={}){let r=c(null);try{let t=i(n,r),o=e.settle;if(o!==void 0){let a=e.passes??5;for(let s=1;s<a;s++){let y=t;if(await x(o(),e.timeout),t=i(n,r),t===y)break}}return m(t,e)}finally{f(r)}}async function x(n,e){if(e===void 0)return n;let r;try{await Promise.race([n,new Promise(t=>{r=setTimeout(t,e)})])}finally{clearTimeout(r)}}function i(n,e){let r=d(e),t=p(!0);try{return u(g(n))}finally{p(t),d(r)}}function m(n,e){return e.document===void 0?n:e.document(n)}export{w as Markup,O as escapeAttribute,l as escapeText,R as renderToString,T as renderToStringAsync};

package/dist/internal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The compiler/runtime protocol for a server render.
+ *
+ * The twin of `@firsthandjs/dom/internal`: the compiler emits calls against
+ * exactly this surface when it is asked for server output, and against the
+ * DOM one otherwise. Two surfaces, one set of semantics — which is a promise
+ * that has to be kept by measurement, not by care, and is: the parity suite
+ * renders every shape both ways and compares the markup.
+ */
+export declare const PROTOCOL_VERSION = 1;
+export { ssr, child, Markup } from './markup.js';
+export { createComponent, spread, view } from './component.js';
+export { attribute, attribute as setAttribute, booleanAttribute as setBoolean, classValue as setClass, escapeAttribute, escapeText, property as setProperty, styleValue as setStyle, } from './html.js';
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EACL,SAAS,EACT,SAAS,IAAI,YAAY,EACzB,gBAAgB,IAAI,UAAU,EAC9B,UAAU,IAAI,QAAQ,EACtB,eAAe,EACf,UAAU,EACV,QAAQ,IAAI,WAAW,EACvB,UAAU,IAAI,QAAQ,GACvB,MAAM,WAAW,CAAC"}

package/dist/internal.js

@@ -0,0 +1 @@
+import{a as l,b as p,c as t,d,e as f,f as m,g as w,h as i,i as y,j as a}from"./chunk-2FO6Y3CD.js";import{deferOwner as h,getOwner as b,handleError as k,restoreOwner as u}from"@firsthandjs/core";var c=Symbol.for("firsthand.view");function g(n){return n[c]=!0,n}function O(n,r){if(n.setup===void 0){if(c in n)return n(r);let o=typeof n=="function"&&n.name!==""?n.name:"The value";throw new Error(`${String(o)} is not a Firsthand component, and a server render has no adapter to hand it to. Declare it with component(), or render it in the browser only.`)}let e=h();try{let o=n.setup(r);return u(e),n.tag===void 0?o:x(n,o)}catch(o){let s=b();return u(e),k(o,s),null}}function x(n,r){let e=n.tag,o=a(r),s=n.options?.shadow===!0?`<template shadowrootmode="open">${o}</template>`:o;return new i(`<${e}>${s}</${e}>`)}function T(n){let r="";for(let e in n){if(e==="ref"||e==="children"||E(e))continue;let o=n[e];if(e==="class"||e==="className"){r+=t("class",typeof o=="string"?o:A(o));continue}e==="style"&&typeof o=="object"||(r+=t(e,o))}return r}function E(n){return n.startsWith("on")&&n.length>2&&/[A-Z:]/.test(n[2])}function A(n){if(n==null)return null;if(Array.isArray(n))return n.filter(Boolean).join(" ");if(typeof n=="object"){let r=[];for(let e in n)n[e]===!0&&r.push(e);return r.join(" ")}return String(n)}var M=1;export{i as Markup,M as PROTOCOL_VERSION,t as attribute,a as child,O as createComponent,p as escapeAttribute,l as escapeText,t as setAttribute,d as setBoolean,m as setClass,f as setProperty,w as setStyle,T as spread,y as ssr,g as view};

package/dist/markup.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What the compiler's server output is made of.
+ *
+ * A view is a **string** on the server, and that creates exactly one problem:
+ * once markup and text are both strings, nothing can tell them apart, and a
+ * component that returns `<b>hi</b>` would be escaped into visible angle
+ * brackets while a user string containing `<script>` would not be.
+ *
+ * So markup is carried in a one-field object and text is not. `ssr()` produces
+ * markup; `child()` escapes everything that is not already markup. The object
+ * costs one allocation per element, which is a fraction of the DOM node the
+ * client would have built for the same thing.
+ */
+export declare class Markup {
+    readonly html: string;
+    constructor(html: string);
+}
+/**
+ * Interleaves a template's static parts with the values between them.
+ *
+ * `parts` is one longer than `values`, always: the compiler splits the markup
+ * at every hole, so a template with no holes is a single part and a template
+ * ending in a hole still has an empty part after it.
+ */
+export declare function ssr(parts: readonly string[], ...values: readonly unknown[]): Markup;
+/**
+ * A child position: markup passes through, everything else is escaped.
+ *
+ * The shapes are the ones `applyChild` accepts in the browser, so that a view
+ * that renders on the client renders the same thing here: nothing for `null`,
+ * `undefined` and booleans, the text for a string or a number, and the
+ * concatenation for an array.
+ */
+export declare function child(value: unknown): string;
+//# sourceMappingURL=markup.d.ts.map

package/dist/markup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markup.d.ts","sourceRoot":"","sources":["../src/markup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,qBAAa,MAAM;IACL,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAClC;AAED;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAYnF;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CA+B5C"}

package/dist/render.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Turning a view into markup.
+ *
+ * The same components, the same signals, the same context — compiled to build
+ * a string instead of a tree. What differs from the browser is only what
+ * cannot exist without one:
+ *
+ * - **Effects do not run.** An effect is a side effect over time, and a render
+ *   that produces one string has none. Anything that must happen before the
+ *   markup exists is data, and data has `useResource`.
+ * - **Refs and event handlers are not emitted.** A server has no node to hand
+ *   to a ref and no one to click. Both are attached during hydration, where
+ *   they are the only things left to do.
+ */
+export type RenderOptions = {
+    /**
+     * Wraps the markup, so the document a server sends is written in one place.
+     *
+     * It receives the rendered body and returns the whole response; leaving it
+     * out returns the body alone, which is what a fragment or a test wants.
+     */
+    document?: (body: string) => string;
+};
+export type AsyncRenderOptions = RenderOptions & {
+    /**
+     * Waits for whatever the render started.
+     *
+     * A data store's `settle()`, a cache client's, or both — the server package
+     * knows nothing about either, so the application says what waiting means:
+     *
+     * ```ts
+     * const html = await renderToStringAsync(() => <App />, {
+     *   settle: () => data.settle(),
+     * });
+     * ```
+     */
+    settle?: () => Promise<void>;
+    /**
+     * How many times to render before giving up on stillness.
+     *
+     * Each pass renders, waits, and renders again if the wait produced more
+     * work. Default 5, which is four chances for one load to reveal the next;
+     * past that the last markup is sent as it stands rather than never.
+     */
+    passes?: number;
+    /**
+     * How long to wait, in ms, before rendering with what is there.
+     *
+     * A loader that never answers would otherwise hold the response open for as
+     * long as the client is willing to wait, which is a page that never arrives
+     * rather than one that arrives incomplete. Left out, the wait is however
+     * long the application's own loaders take — which is the right default when
+     * they have timeouts of their own, and the wrong one when they do not.
+     */
+    timeout?: number;
+};
+/**
+ * Renders a view to markup.
+ *
+ * ```ts
+ * const html = renderToString(() => <App />);
+ * ```
+ *
+ * Everything the view creates belongs to a root that is disposed before this
+ * returns, so a server that renders a thousand requests holds nothing from any
+ * of them.
+ */
+export declare function renderToString(view: () => unknown, options?: RenderOptions): string;
+/**
+ * Renders a view that loads something first.
+ *
+ * ```ts
+ * const html = await renderToStringAsync(() => <App />, {
+ *   settle: () => data.settle(),
+ * });
+ * ```
+ *
+ * The view is rendered, the wait is awaited, and the view is rendered again —
+ * over the same owner, so a component's setup runs once and its resources are
+ * not started twice. What the second pass reads is what the first pass asked
+ * for, now answered.
+ *
+ * Without `settle` this is `renderToString` with a promise around it, which is
+ * what a view with nothing to wait for should cost.
+ */
+export declare function renderToStringAsync(view: () => unknown, options?: AsyncRenderOptions): Promise<string>;
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAYH,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,OAAO,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAOvF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,OAAO,EACnB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,MAAM,CAAC,CAoBjB"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@firsthandjs/server",
+  "version": "0.9.0",
+  "type": "module",
+  "description": "Server-side rendering for Firsthand: the same components, rendered to markup.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/firsthandjs/firsthand.git",
+    "directory": "packages/server"
+  },
+  "homepage": "https://github.com/firsthandjs/firsthand#readme",
+  "bugs": {
+    "url": "https://github.com/firsthandjs/firsthand/issues"
+  },
+  "keywords": [
+    "reactive",
+    "signals",
+    "ssr",
+    "server-side-rendering",
+    "hydration",
+    "jsx",
+    "no-virtual-dom"
+  ],
+  "engines": {
+    "node": ">=20.11.0"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@firsthandjs/core": "0.9.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}