@torpor/view 1.0.3 → 1.1.0

package/dist/{fromWebSocket-DeB35Q4w.d.cts → AsyncOptions-BtMe2PAd.d.cts}

@@ -87,5 +87,24 @@ declare function fromServer(url: string | (() => string)): StreamSource<MessageE
  */
 declare function fromWebSocket(url: string | (() => string)): StreamSource<MessageEvent>;
 //#endregion
-export { buildStyles as a, ClassValue as c, StreamSource as i, fromServer as n, StyleValue as o, fromElement as r, buildClasses as s, fromWebSocket as t };
-//# sourceMappingURL=fromWebSocket-DeB35Q4w.d.cts.map
+//#region src/types/AsyncOptions.d.ts
+/**
+ * Options for the `$async` getter primitive.
+ */
+interface AsyncOptions {
+  /**
+   * Where the value comes from. The default (`"client"`) starts the fetch
+   * after hydration; `"server"` fetches during SSR and ships the resolved
+   * value embedded in the HTML (see ASYNC.md → "Server rendering").
+   */
+  source?: "client" | "server";
+  /**
+   * With `source: "server"`, how long (ms) the server waits for this
+   * getter's promise before the enclosing `@await` boundary degrades to its
+   * `with` branch and the client fetches instead. Defaults to 5000.
+   */
+  timeout?: number;
+}
+//#endregion
+export { StreamSource as a, buildClasses as c, fromElement as i, ClassValue as l, fromWebSocket as n, buildStyles as o, fromServer as r, StyleValue as s, AsyncOptions as t };
+//# sourceMappingURL=AsyncOptions-BtMe2PAd.d.cts.map

package/dist/AsyncOptions-BtMe2PAd.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncOptions-BtMe2PAd.d.cts","names":[],"sources":["../src/types/ClassValue.ts","../src/render/buildClasses.ts","../src/types/StyleValue.ts","../src/render/buildStyles.ts","../src/types/StreamSource.ts","../src/stream/fromElement.ts","../src/stream/fromServer.ts","../src/stream/fromWebSocket.ts","../src/types/AsyncOptions.ts"],"mappings":";;KAAK,sBAEF,6CACA,MAAM;;;iBCAe,aAAa,OAAO,YAAY;;;KCHnD,sBAEF,4CACA,MAAM;;;iBCCe,YAAY,OAAO;;;;;;;;;;;;;;;;;KCYtC,aAAa,MAAM,OAAO,OAAO,eAAe;;;;;;;;;;;;;;KCHhD,mBAAmB,qBAAqB;;;;;;;;;;;iBAYrB,YAAY,UAAU,QAAQ,OACrD,QAAQ,kBACR,eACE,aAAa;;;;;;;;;;;;;;;;;iBCZQ,WAAW,+BAA+B,aAAa;;;;;;;;;;;;;;;;;iBCAvD,cAAc,+BAA+B,aAAa;;;;;;UCbzD;;;;;;EAMxB;;;;;;EAOA"}

package/dist/{fromWebSocket-B52kN3-W.d.mts → AsyncOptions-ClS1_ERX.d.mts}

@@ -87,5 +87,24 @@ declare function fromServer(url: string | (() => string)): StreamSource<MessageE
  */
 declare function fromWebSocket(url: string | (() => string)): StreamSource<MessageEvent>;
 //#endregion
-export { buildStyles as a, ClassValue as c, StreamSource as i, fromServer as n, StyleValue as o, fromElement as r, buildClasses as s, fromWebSocket as t };
-//# sourceMappingURL=fromWebSocket-B52kN3-W.d.mts.map
+//#region src/types/AsyncOptions.d.ts
+/**
+ * Options for the `$async` getter primitive.
+ */
+interface AsyncOptions {
+  /**
+   * Where the value comes from. The default (`"client"`) starts the fetch
+   * after hydration; `"server"` fetches during SSR and ships the resolved
+   * value embedded in the HTML (see ASYNC.md → "Server rendering").
+   */
+  source?: "client" | "server";
+  /**
+   * With `source: "server"`, how long (ms) the server waits for this
+   * getter's promise before the enclosing `@await` boundary degrades to its
+   * `with` branch and the client fetches instead. Defaults to 5000.
+   */
+  timeout?: number;
+}
+//#endregion
+export { StreamSource as a, buildClasses as c, fromElement as i, ClassValue as l, fromWebSocket as n, buildStyles as o, fromServer as r, StyleValue as s, AsyncOptions as t };
+//# sourceMappingURL=AsyncOptions-ClS1_ERX.d.mts.map

package/dist/AsyncOptions-ClS1_ERX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncOptions-ClS1_ERX.d.mts","names":[],"sources":["../src/types/ClassValue.ts","../src/render/buildClasses.ts","../src/types/StyleValue.ts","../src/render/buildStyles.ts","../src/types/StreamSource.ts","../src/stream/fromElement.ts","../src/stream/fromServer.ts","../src/stream/fromWebSocket.ts","../src/types/AsyncOptions.ts"],"mappings":";;KAAK,sBAEF,6CACA,MAAM;;;iBCAe,aAAa,OAAO,YAAY;;;KCHnD,sBAEF,4CACA,MAAM;;;iBCCe,YAAY,OAAO;;;;;;;;;;;;;;;;;KCYtC,aAAa,MAAM,OAAO,OAAO,eAAe;;;;;;;;;;;;;;KCHhD,mBAAmB,qBAAqB;;;;;;;;;;;iBAYrB,YAAY,UAAU,QAAQ,OACrD,QAAQ,kBACR,eACE,aAAa;;;;;;;;;;;;;;;;;iBCZQ,WAAW,+BAA+B,aAAa;;;;;;;;;;;;;;;;;iBCAvD,cAAc,+BAA+B,aAAa;;;;;;UCbzD;;;;;;EAMxB;;;;;;EAOA"}

package/dist/{Effect-BTKurOpr.d.mts → Effect-DazmAdyC.d.mts}

@@ -168,7 +168,7 @@ interface Computed<T = any> {
   /**
    * True when the current suspend is a "bare refresh" — a re-fetch with no
    * tracked dependency change, i.e. a silent `$refresh(fn, { silent: true })`
-   * (background revalidation), per ASYNC.md §7.4's quiet-on-refresh rule.
+   * (background revalidation), per ASYNC.md → "Loud vs quiet")
    * `$pending` reads this to stay quiet (return `false`) on silent refreshes,
    * matching Solid's stale-while-revalidate default.
    *
@@ -182,7 +182,7 @@ interface Computed<T = any> {
   suspendQuiet: boolean;
   /**
    * The previously resolved value, retained across a refresh suspend for
-   * stale-while-revalidate (ASYNC.md §6.2). Maintained by `$async`'s
+   * stale-while-revalidate (ASYNC.md → "Stale-while-revalidate"). Maintained by `$async`'s
    * generation-guarded settle handlers — set on resolve, cleared on
    * rejection — so it always holds the last RESOLVED value, never a
    * superseded run's in-flight promise (rapid prop changes would otherwise
@@ -378,4 +378,4 @@ interface Effect {
 }
 //#endregion
 export { ProxySignal as i, Region as n, Computed as r, Effect as t };
-//# sourceMappingURL=Effect-BTKurOpr.d.mts.map
+//# sourceMappingURL=Effect-DazmAdyC.d.mts.map

package/dist/{Effect-BTKurOpr.d.mts.map → Effect-DazmAdyC.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"Effect-BTKurOpr.d.mts","names":[],"sources":["../src/types/constants.ts","../src/types/ProxySignal.ts","../src/types/Subscription.ts","../src/types/Computed.ts","../src/types/ErrorBoundary.ts","../src/types/Region.ts","../src/types/Effect.ts"],"mappings":";;;;;cAGa;;;;cAKA;;;;cAKA;;;;;;;UCNY;;;;EAIxB,aAAa;;;;EAKb,aAAa;;;;EAKb,oBAAoB;;;;EAKpB;;;;;;;;UClBwB;;;;EAIxB,QAAQ,cAAc;;;;EAKtB,QAAQ,WAAW;;;;;EAMnB,YAAY;;;;;EAMZ,YAAY;;;;;;;EAQZ,gBAAgB;;;;;;EAOhB;;;;;EAMA;;;;EAKA;;;;;;;;;UC/CwB,SAAS;;;;EAIjC,aAAa;;;;;;;;EASb;;;;EAKA,OAAO;;;;EAKP,WAAW;;;;EAKX,aAAa;;;;EAKb,aAAa;;;;;;;EAQb;;;;EAKA;;;;EAKA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;;;EAUA;;;;;;;;;;;;;;;EAgBA;;;;;;;;;;;;;EAcA;;;;EAKA,UAAU;;;;EAKV;;;;;;;;;;UC3HwB;;;;;;EAMxB;;;;;EAMA;;;;;EAMA,QAAQ;;;;;;;;;EAUR,cAAc,cAAc;;;;UCnCJ;EACxB,WAAW;EACX,SAAS;EAET,gBAAgB;EAChB,YAAY;EACZ;;;;;EAMA,YAAY,IAAI;;;;EAKhB;;;;EAKA,SAAS;;;;;;;EAQT,gBAAgB;;;;;;;EAQhB;;;;;;EAOA;;;;;;;UCtCwB;;;;EAIxB,aAAa;;;;;EAMb,WAAW;;;;EAKX,SAAS;;;;EAKT,aAAa;EAKb,YAAY;;;;EAKZ;;;;;;EAOA;;;;EAKA;;;;;;;EAQA;;;;;;;;;;EAWA,iBAAiB,IAAI;;;;EAKrB;;;;;;EAOA,SAAS;;;;;;EAOT,gBAAgB,cAAc;;;;;;;;;EAU9B;;;;;;;;;;;;;;;;EAiBA"}
+{"version":3,"file":"Effect-DazmAdyC.d.mts","names":[],"sources":["../src/types/constants.ts","../src/types/ProxySignal.ts","../src/types/Subscription.ts","../src/types/Computed.ts","../src/types/ErrorBoundary.ts","../src/types/Region.ts","../src/types/Effect.ts"],"mappings":";;;;;cAGa;;;;cAKA;;;;cAKA;;;;;;;UCNY;;;;EAIxB,aAAa;;;;EAKb,aAAa;;;;EAKb,oBAAoB;;;;EAKpB;;;;;;;;UClBwB;;;;EAIxB,QAAQ,cAAc;;;;EAKtB,QAAQ,WAAW;;;;;EAMnB,YAAY;;;;;EAMZ,YAAY;;;;;;;EAQZ,gBAAgB;;;;;;EAOhB;;;;;EAMA;;;;EAKA;;;;;;;;;UC/CwB,SAAS;;;;EAIjC,aAAa;;;;;;;;EASb;;;;EAKA,OAAO;;;;EAKP,WAAW;;;;EAKX,aAAa;;;;EAKb,aAAa;;;;;;;EAQb;;;;EAKA;;;;EAKA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;;;EAUA;;;;;;;;;;;;;;;EAgBA;;;;;;;;;;;;;EAcA;;;;EAKA,UAAU;;;;EAKV;;;;;;;;;;UC3HwB;;;;;;EAMxB;;;;;EAMA;;;;;EAMA,QAAQ;;;;;;;;;EAUR,cAAc,cAAc;;;;UCnCJ;EACxB,WAAW;EACX,SAAS;EAET,gBAAgB;EAChB,YAAY;EACZ;;;;;EAMA,YAAY,IAAI;;;;EAKhB;;;;EAKA,SAAS;;;;;;;EAQT,gBAAgB;;;;;;;EAQhB;;;;;;EAOA;;;;;;;UCtCwB;;;;EAIxB,aAAa;;;;;EAMb,WAAW;;;;EAKX,SAAS;;;;EAKT,aAAa;EAKb,YAAY;;;;EAKZ;;;;;;EAOA;;;;EAKA;;;;;;;EAQA;;;;;;;;;;EAWA,iBAAiB,IAAI;;;;EAKrB;;;;;;EAOA,SAAS;;;;;;EAOT,gBAAgB,cAAc;;;;;;;;;EAU9B;;;;;;;;;;;;;;;;EAiBA"}

package/dist/{Effect-COl3aRJV.d.cts → Effect-Dewn7MLc.d.cts}

@@ -168,7 +168,7 @@ interface Computed<T = any> {
   /**
    * True when the current suspend is a "bare refresh" — a re-fetch with no
    * tracked dependency change, i.e. a silent `$refresh(fn, { silent: true })`
-   * (background revalidation), per ASYNC.md §7.4's quiet-on-refresh rule.
+   * (background revalidation), per ASYNC.md → "Loud vs quiet")
    * `$pending` reads this to stay quiet (return `false`) on silent refreshes,
    * matching Solid's stale-while-revalidate default.
    *
@@ -182,7 +182,7 @@ interface Computed<T = any> {
   suspendQuiet: boolean;
   /**
    * The previously resolved value, retained across a refresh suspend for
-   * stale-while-revalidate (ASYNC.md §6.2). Maintained by `$async`'s
+   * stale-while-revalidate (ASYNC.md → "Stale-while-revalidate"). Maintained by `$async`'s
    * generation-guarded settle handlers — set on resolve, cleared on
    * rejection — so it always holds the last RESOLVED value, never a
    * superseded run's in-flight promise (rapid prop changes would otherwise
@@ -378,4 +378,4 @@ interface Effect {
 }
 //#endregion
 export { ProxySignal as i, Region as n, Computed as r, Effect as t };
-//# sourceMappingURL=Effect-COl3aRJV.d.cts.map
+//# sourceMappingURL=Effect-Dewn7MLc.d.cts.map

package/dist/{Effect-COl3aRJV.d.cts.map → Effect-Dewn7MLc.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"Effect-COl3aRJV.d.cts","names":[],"sources":["../src/types/constants.ts","../src/types/ProxySignal.ts","../src/types/Subscription.ts","../src/types/Computed.ts","../src/types/ErrorBoundary.ts","../src/types/Region.ts","../src/types/Effect.ts"],"mappings":";;;;;cAGa;;;;cAKA;;;;cAKA;;;;;;;UCNY;;;;EAIxB,aAAa;;;;EAKb,aAAa;;;;EAKb,oBAAoB;;;;EAKpB;;;;;;;;UClBwB;;;;EAIxB,QAAQ,cAAc;;;;EAKtB,QAAQ,WAAW;;;;;EAMnB,YAAY;;;;;EAMZ,YAAY;;;;;;;EAQZ,gBAAgB;;;;;;EAOhB;;;;;EAMA;;;;EAKA;;;;;;;;;UC/CwB,SAAS;;;;EAIjC,aAAa;;;;;;;;EASb;;;;EAKA,OAAO;;;;EAKP,WAAW;;;;EAKX,aAAa;;;;EAKb,aAAa;;;;;;;EAQb;;;;EAKA;;;;EAKA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;;;EAUA;;;;;;;;;;;;;;;EAgBA;;;;;;;;;;;;;EAcA;;;;EAKA,UAAU;;;;EAKV;;;;;;;;;;UC3HwB;;;;;;EAMxB;;;;;EAMA;;;;;EAMA,QAAQ;;;;;;;;;EAUR,cAAc,cAAc;;;;UCnCJ;EACxB,WAAW;EACX,SAAS;EAET,gBAAgB;EAChB,YAAY;EACZ;;;;;EAMA,YAAY,IAAI;;;;EAKhB;;;;EAKA,SAAS;;;;;;;EAQT,gBAAgB;;;;;;;EAQhB;;;;;;EAOA;;;;;;;UCtCwB;;;;EAIxB,aAAa;;;;;EAMb,WAAW;;;;EAKX,SAAS;;;;EAKT,aAAa;EAKb,YAAY;;;;EAKZ;;;;;;EAOA;;;;EAKA;;;;;;;EAQA;;;;;;;;;;EAWA,iBAAiB,IAAI;;;;EAKrB;;;;;;EAOA,SAAS;;;;;;EAOT,gBAAgB,cAAc;;;;;;;;;EAU9B;;;;;;;;;;;;;;;;EAiBA"}
+{"version":3,"file":"Effect-Dewn7MLc.d.cts","names":[],"sources":["../src/types/constants.ts","../src/types/ProxySignal.ts","../src/types/Subscription.ts","../src/types/Computed.ts","../src/types/ErrorBoundary.ts","../src/types/Region.ts","../src/types/Effect.ts"],"mappings":";;;;;cAGa;;;;cAKA;;;;cAKA;;;;;;;UCNY;;;;EAIxB,aAAa;;;;EAKb,aAAa;;;;EAKb,oBAAoB;;;;EAKpB;;;;;;;;UClBwB;;;;EAIxB,QAAQ,cAAc;;;;EAKtB,QAAQ,WAAW;;;;;EAMnB,YAAY;;;;;EAMZ,YAAY;;;;;;;EAQZ,gBAAgB;;;;;;EAOhB;;;;;EAMA;;;;EAKA;;;;;;;;;UC/CwB,SAAS;;;;EAIjC,aAAa;;;;;;;;EASb;;;;EAKA,OAAO;;;;EAKP,WAAW;;;;EAKX,aAAa;;;;EAKb,aAAa;;;;;;;EAQb;;;;EAKA;;;;EAKA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;;;EAUA;;;;;;;;;;;;;;;EAgBA;;;;;;;;;;;;;EAcA;;;;EAKA,UAAU;;;;EAKV;;;;;;;;;;UC3HwB;;;;;;EAMxB;;;;;EAMA;;;;;EAMA,QAAQ;;;;;;;;;EAUR,cAAc,cAAc;;;;UCnCJ;EACxB,WAAW;EACX,SAAS;EAET,gBAAgB;EAChB,YAAY;EACZ;;;;;EAMA,YAAY,IAAI;;;;EAKhB;;;;EAKA,SAAS;;;;;;;EAQT,gBAAgB;;;;;;;EAQhB;;;;;;EAOA;;;;;;;UCtCwB;;;;EAIxB,aAAa;;;;;EAMb,WAAW;;;;EAKX,SAAS;;;;EAKT,aAAa;EAKb,YAAY;;;;EAKZ;;;;;;EAOA;;;;EAKA;;;;;;;EAQA;;;;;;;;;;EAWA,iBAAiB,IAAI;;;;EAKrB;;;;;;EAOA,SAAS;;;;;;EAOT,gBAAgB,cAAc;;;;;;;;;EAU9B;;;;;;;;;;;;;;;;EAiBA"}

package/dist/compile.cjs

@@ -2800,7 +2800,7 @@ function buildServerComponentNode(node, status, b) {
 			const nameAttribute = slot.attributes.find((a) => a.name === "name");
 			const slotName = nameAttribute?.value ? trimQuotes(nameAttribute.value) : "_";
 			const slotParams = [slot.hasSlotProps ? "$slot: Record<PropertyKey, any>" : "_$slot?: Record<PropertyKey, any>", "// @ts-ignore\n// eslint-disable-next-line no-unused-vars\n$context?: Record<PropertyKey, any>"];
-			b.append(`${slot.hasSlotProps ? "// @ts-ignore\n" : ""}${slotsName}["${slotName}"] = (\n${slotParams.join(",\n")}\n) => {`);
+			b.append(`${slot.hasSlotProps ? "// @ts-ignore\n" : ""}${slotsName}["${slotName}"] = async (\n${slotParams.join(",\n")}\n) => {`);
 			b.append(`let t_body = "";`);
 			for (let child of slot.children) buildServerNode(child, status, b);
 			if (status.output) {
@@ -2819,7 +2819,7 @@ function buildServerComponentNode(node, status, b) {
 	let renderParams = `${propsName}, $context`;
 	if (slotsName !== "undefined") renderParams += `, ${slotsName}`;
 	const componentResult = nextVarName("comp", status);
-	b.append(`const ${componentResult} = ${componentName}(${renderParams});`);
+	b.append(`const ${componentResult} = await ${componentName}(${renderParams});`);
 	b.append(`${status.inHead ? "t_head" : "t_body"} += ${componentResult}.body;`);
 	b.append(`t_head += ${componentResult}.head;`);
 	status.output += HYDRATION_END_COMMENT;
@@ -2827,16 +2827,37 @@ function buildServerComponentNode(node, status, b) {
 }
 //#endregion
 //#region src/compile/build/server/buildServerAwaitNode.ts
+/**
+* Builds an `@await` boundary for the server (ASYNC.md → "Server rendering").
+*
+* Rather than inlining the `with` branch (the old shape), the boundary is
+* handed to the `t_await_server` runtime helper: content and `with` branches
+* become closures, and the helper decides at render time whether resolved
+* content can ship (all `source: "server"` reads settled) or the `with`
+* branch + client fetch is the honest output. The runtime emits the
+* hydration markers and anchor itself, including the `<!--t-await:...-->`
+* values payload for resolved boundaries.
+*/
 function buildServerAwaitNode(node, status, b) {
-	status.output += HYDRATION_START_COMMENT;
 	flushOutput(status, b);
-	for (let branch of node.children) if (isControlNode(branch) && branch.operation === "@with") buildServerAwaitBranch(branch, status, b);
-	status.output += HYDRATION_END_COMMENT;
-	status.output += "<!>";
-}
-function buildServerAwaitBranch(node, status, b) {
-	for (let child of node.children) buildServerNode(child, status, b);
+	status.imports.add("t_await_server");
+	const id = status.awaitCount++;
+	const resultName = nextVarName("await", status);
+	b.append(`const ${resultName} = await t_await_server("${id}", async () => {`);
+	b.append(`let t_body = "";`);
+	b.append(`let t_head = "";`);
+	for (let branch of node.children) if (isControlNode(branch) && branch.operation === "@await") for (let child of branch.children) buildServerNode(child, status, b);
 	flushOutput(status, b);
+	b.append(`return { body: t_body, head: t_head };`);
+	b.append(`}, async () => {`);
+	b.append(`let t_body = "";`);
+	b.append(`let t_head = "";`);
+	for (let branch of node.children) if (isControlNode(branch) && branch.operation === "@with") for (let child of branch.children) buildServerNode(child, status, b);
+	flushOutput(status, b);
+	b.append(`return { body: t_body, head: t_head };`);
+	b.append(`});`);
+	b.append(`${status.inHead ? "t_head" : "t_body"} += ${resultName}.body;`);
+	b.append(`t_head += ${resultName}.head;`);
 }
 //#endregion
 //#region src/compile/build/server/buildServerForNode.ts
@@ -3091,7 +3112,7 @@ function buildServerSlotNode(node, status, b) {
 		else b.append(`${propsName}["${name}"] = true;`);
 	}
 	b.append(`if ($slots && $slots["${slotName}"]) {`);
-	b.append(`${status.inHead ? "t_head" : "t_body"} += $slots["${slotName}"](${slotHasProps ? propsName : "undefined"}, $context);`);
+	b.append(`${status.inHead ? "t_head" : "t_body"} += await $slots["${slotName}"](${slotHasProps ? propsName : "undefined"}, $context);`);
 	const fill = node.children.find((c) => isSpecialNode(c) && (c.tagName === "fill" || c.tagName === "filldef"));
 	if (fill && isSpecialNode(fill) && fill.children.length) {
 		b.append(`} else {`);
@@ -3194,6 +3215,8 @@ const importsMap = {
 	$unwrap: "import { $unwrap } from \"${folder}\";",
 	$peek: "import { $peek } from \"${folder}\";",
 	$batch: "import { $batch } from \"${folder}\";",
+	t_server_flush: "import { t_server_flush } from \"${folder}\";",
+	t_await_server: "import { t_await_server } from \"${folder}\";",
 	t_fmt: "import { t_fmt } from \"${folder}\";",
 	t_attr: "import { t_attr } from \"${folder}\";",
 	t_class: "import { t_class } from \"${folder}\";",
@@ -3236,18 +3259,24 @@ function buildServerTemplate(template, imports, b, options) {
 	if (/\$unwrap\b/.test(scriptCode)) imports.add("$unwrap");
 	if (/\$peek\b/.test(scriptCode)) imports.add("$peek");
 	if (/\$batch\b/.test(scriptCode)) imports.add("$batch");
+	const asyncChunks = /* @__PURE__ */ new Set();
+	for (let [i, chunk] of template.script.entries()) if (chunk.script === "/* @params */" && i > 0) asyncChunks.add(i - 1);
 	let currentIndex = 0;
 	let current = template.components[0];
-	for (let chunk of template.script) if (chunk.script === "/* @params */") {
+	for (let [chunkIndex, chunk] of template.script.entries()) if (chunk.script === "/* @params */") {
 		let params = [
 			current.params ?? `${current.props?.length ? "$props: Record<PropertyKey, any>" : "_$props?: Record<PropertyKey, any>"}`,
 			`${current.contextProps?.length || current.markup && markupRendersComponent(current.markup) || current.error && markupRendersComponent(current.error) ? "$context" : "_$context"}?: Record<PropertyKey, any>`,
 			`${current.slotProps?.length ? "$slots" : "_$slots"}?: Record<string, ServerSlotRender>`
 		];
 		b.append(params.join(",\n") + ",");
-	} else if (chunk.script === ") /* @return_type */ {") b.append("): { body: string; head: string } {");
+	} else if (chunk.script === ") /* @return_type */ {") b.append("): Promise<{ body: string; head: string }> {");
 	else if (chunk.script === "/* @start */") {
 		if (current.contextProps?.length) b.append(`$context = Object.assign({}, $context);`);
+		if (containsAwaitGroup(current.markup) || containsAwaitGroup(current.error) || containsAwaitGroup(current.head)) {
+			imports.add("t_server_flush");
+			b.append(`return t_server_flush(async () => {`);
+		}
 		b.append(`let t_body = "";`);
 		b.append(`let t_head = "";`);
 	} else if (chunk.script === "/* @render */") {
@@ -3258,6 +3287,7 @@ function buildServerTemplate(template, imports, b, options) {
 				styleHash: current.style?.hash || "",
 				varNames: {},
 				preserveWhitespace: false,
+				awaitCount: 0,
 				options
 			};
 			b.append("");
@@ -3281,6 +3311,7 @@ function buildServerTemplate(template, imports, b, options) {
 				styleHash: current.style?.hash || "",
 				varNames: {},
 				preserveWhitespace: false,
+				awaitCount: 0,
 				options
 			};
 			b.append(`} catch (${current.errorVar}) {`);
@@ -3303,6 +3334,7 @@ function buildServerTemplate(template, imports, b, options) {
 				varNames: {},
 				preserveWhitespace: false,
 				inHead: true,
+				awaitCount: 0,
 				options
 			};
 			b.append("");
@@ -3319,9 +3351,23 @@ function buildServerTemplate(template, imports, b, options) {
 		}
 	} else if (chunk.script === "/* @end */") {
 		b.append(`return { body: t_body, head: t_head };`);
+		if (containsAwaitGroup(current.markup) || containsAwaitGroup(current.error) || containsAwaitGroup(current.head)) b.append(`});`);
 		currentIndex += 1;
 		current = template.components[currentIndex];
-	} else b.append(chunk.script);
+	} else if (asyncChunks.has(chunkIndex)) b.append(chunk.script.replace(/(?<!async\s)function\s+([A-Za-z_$][\w$]*)((?:<(?:[^<>]|<[^<>]*>)*>)?)\s*\($/, "async function $1$2("));
+	else b.append(chunk.script);
+}
+/**
+* Whether a markup tree contains an `@await` boundary, so the component's
+* render must be wrapped in a flush.
+*/
+function containsAwaitGroup(node) {
+	if (node === void 0 || node === null) return false;
+	if (isControlNode(node) && node.operation === "@await group") return true;
+	if (node.type !== "text" && node.type !== "comment") {
+		for (let child of node.children) if (containsAwaitGroup(child)) return true;
+	}
+	return false;
 }
 //#endregion
 //#region src/compile/utils/trimWhitespace.ts

package/dist/compile.mjs

@@ -2799,7 +2799,7 @@ function buildServerComponentNode(node, status, b) {
 			const nameAttribute = slot.attributes.find((a) => a.name === "name");
 			const slotName = nameAttribute?.value ? trimQuotes(nameAttribute.value) : "_";
 			const slotParams = [slot.hasSlotProps ? "$slot: Record<PropertyKey, any>" : "_$slot?: Record<PropertyKey, any>", "// @ts-ignore\n// eslint-disable-next-line no-unused-vars\n$context?: Record<PropertyKey, any>"];
-			b.append(`${slot.hasSlotProps ? "// @ts-ignore\n" : ""}${slotsName}["${slotName}"] = (\n${slotParams.join(",\n")}\n) => {`);
+			b.append(`${slot.hasSlotProps ? "// @ts-ignore\n" : ""}${slotsName}["${slotName}"] = async (\n${slotParams.join(",\n")}\n) => {`);
 			b.append(`let t_body = "";`);
 			for (let child of slot.children) buildServerNode(child, status, b);
 			if (status.output) {
@@ -2818,7 +2818,7 @@ function buildServerComponentNode(node, status, b) {
 	let renderParams = `${propsName}, $context`;
 	if (slotsName !== "undefined") renderParams += `, ${slotsName}`;
 	const componentResult = nextVarName("comp", status);
-	b.append(`const ${componentResult} = ${componentName}(${renderParams});`);
+	b.append(`const ${componentResult} = await ${componentName}(${renderParams});`);
 	b.append(`${status.inHead ? "t_head" : "t_body"} += ${componentResult}.body;`);
 	b.append(`t_head += ${componentResult}.head;`);
 	status.output += HYDRATION_END_COMMENT;
@@ -2826,16 +2826,37 @@ function buildServerComponentNode(node, status, b) {
 }
 //#endregion
 //#region src/compile/build/server/buildServerAwaitNode.ts
+/**
+* Builds an `@await` boundary for the server (ASYNC.md → "Server rendering").
+*
+* Rather than inlining the `with` branch (the old shape), the boundary is
+* handed to the `t_await_server` runtime helper: content and `with` branches
+* become closures, and the helper decides at render time whether resolved
+* content can ship (all `source: "server"` reads settled) or the `with`
+* branch + client fetch is the honest output. The runtime emits the
+* hydration markers and anchor itself, including the `<!--t-await:...-->`
+* values payload for resolved boundaries.
+*/
 function buildServerAwaitNode(node, status, b) {
-	status.output += HYDRATION_START_COMMENT;
 	flushOutput(status, b);
-	for (let branch of node.children) if (isControlNode(branch) && branch.operation === "@with") buildServerAwaitBranch(branch, status, b);
-	status.output += HYDRATION_END_COMMENT;
-	status.output += "<!>";
-}
-function buildServerAwaitBranch(node, status, b) {
-	for (let child of node.children) buildServerNode(child, status, b);
+	status.imports.add("t_await_server");
+	const id = status.awaitCount++;
+	const resultName = nextVarName("await", status);
+	b.append(`const ${resultName} = await t_await_server("${id}", async () => {`);
+	b.append(`let t_body = "";`);
+	b.append(`let t_head = "";`);
+	for (let branch of node.children) if (isControlNode(branch) && branch.operation === "@await") for (let child of branch.children) buildServerNode(child, status, b);
 	flushOutput(status, b);
+	b.append(`return { body: t_body, head: t_head };`);
+	b.append(`}, async () => {`);
+	b.append(`let t_body = "";`);
+	b.append(`let t_head = "";`);
+	for (let branch of node.children) if (isControlNode(branch) && branch.operation === "@with") for (let child of branch.children) buildServerNode(child, status, b);
+	flushOutput(status, b);
+	b.append(`return { body: t_body, head: t_head };`);
+	b.append(`});`);
+	b.append(`${status.inHead ? "t_head" : "t_body"} += ${resultName}.body;`);
+	b.append(`t_head += ${resultName}.head;`);
 }
 //#endregion
 //#region src/compile/build/server/buildServerForNode.ts
@@ -3090,7 +3111,7 @@ function buildServerSlotNode(node, status, b) {
 		else b.append(`${propsName}["${name}"] = true;`);
 	}
 	b.append(`if ($slots && $slots["${slotName}"]) {`);
-	b.append(`${status.inHead ? "t_head" : "t_body"} += $slots["${slotName}"](${slotHasProps ? propsName : "undefined"}, $context);`);
+	b.append(`${status.inHead ? "t_head" : "t_body"} += await $slots["${slotName}"](${slotHasProps ? propsName : "undefined"}, $context);`);
 	const fill = node.children.find((c) => isSpecialNode(c) && (c.tagName === "fill" || c.tagName === "filldef"));
 	if (fill && isSpecialNode(fill) && fill.children.length) {
 		b.append(`} else {`);
@@ -3193,6 +3214,8 @@ const importsMap = {
 	$unwrap: "import { $unwrap } from \"${folder}\";",
 	$peek: "import { $peek } from \"${folder}\";",
 	$batch: "import { $batch } from \"${folder}\";",
+	t_server_flush: "import { t_server_flush } from \"${folder}\";",
+	t_await_server: "import { t_await_server } from \"${folder}\";",
 	t_fmt: "import { t_fmt } from \"${folder}\";",
 	t_attr: "import { t_attr } from \"${folder}\";",
 	t_class: "import { t_class } from \"${folder}\";",
@@ -3235,18 +3258,24 @@ function buildServerTemplate(template, imports, b, options) {
 	if (/\$unwrap\b/.test(scriptCode)) imports.add("$unwrap");
 	if (/\$peek\b/.test(scriptCode)) imports.add("$peek");
 	if (/\$batch\b/.test(scriptCode)) imports.add("$batch");
+	const asyncChunks = /* @__PURE__ */ new Set();
+	for (let [i, chunk] of template.script.entries()) if (chunk.script === "/* @params */" && i > 0) asyncChunks.add(i - 1);
 	let currentIndex = 0;
 	let current = template.components[0];
-	for (let chunk of template.script) if (chunk.script === "/* @params */") {
+	for (let [chunkIndex, chunk] of template.script.entries()) if (chunk.script === "/* @params */") {
 		let params = [
 			current.params ?? `${current.props?.length ? "$props: Record<PropertyKey, any>" : "_$props?: Record<PropertyKey, any>"}`,
 			`${current.contextProps?.length || current.markup && markupRendersComponent(current.markup) || current.error && markupRendersComponent(current.error) ? "$context" : "_$context"}?: Record<PropertyKey, any>`,
 			`${current.slotProps?.length ? "$slots" : "_$slots"}?: Record<string, ServerSlotRender>`
 		];
 		b.append(params.join(",\n") + ",");
-	} else if (chunk.script === ") /* @return_type */ {") b.append("): { body: string; head: string } {");
+	} else if (chunk.script === ") /* @return_type */ {") b.append("): Promise<{ body: string; head: string }> {");
 	else if (chunk.script === "/* @start */") {
 		if (current.contextProps?.length) b.append(`$context = Object.assign({}, $context);`);
+		if (containsAwaitGroup(current.markup) || containsAwaitGroup(current.error) || containsAwaitGroup(current.head)) {
+			imports.add("t_server_flush");
+			b.append(`return t_server_flush(async () => {`);
+		}
 		b.append(`let t_body = "";`);
 		b.append(`let t_head = "";`);
 	} else if (chunk.script === "/* @render */") {
@@ -3257,6 +3286,7 @@ function buildServerTemplate(template, imports, b, options) {
 				styleHash: current.style?.hash || "",
 				varNames: {},
 				preserveWhitespace: false,
+				awaitCount: 0,
 				options
 			};
 			b.append("");
@@ -3280,6 +3310,7 @@ function buildServerTemplate(template, imports, b, options) {
 				styleHash: current.style?.hash || "",
 				varNames: {},
 				preserveWhitespace: false,
+				awaitCount: 0,
 				options
 			};
 			b.append(`} catch (${current.errorVar}) {`);
@@ -3302,6 +3333,7 @@ function buildServerTemplate(template, imports, b, options) {
 				varNames: {},
 				preserveWhitespace: false,
 				inHead: true,
+				awaitCount: 0,
 				options
 			};
 			b.append("");
@@ -3318,9 +3350,23 @@ function buildServerTemplate(template, imports, b, options) {
 		}
 	} else if (chunk.script === "/* @end */") {
 		b.append(`return { body: t_body, head: t_head };`);
+		if (containsAwaitGroup(current.markup) || containsAwaitGroup(current.error) || containsAwaitGroup(current.head)) b.append(`});`);
 		currentIndex += 1;
 		current = template.components[currentIndex];
-	} else b.append(chunk.script);
+	} else if (asyncChunks.has(chunkIndex)) b.append(chunk.script.replace(/(?<!async\s)function\s+([A-Za-z_$][\w$]*)((?:<(?:[^<>]|<[^<>]*>)*>)?)\s*\($/, "async function $1$2("));
+	else b.append(chunk.script);
+}
+/**
+* Whether a markup tree contains an `@await` boundary, so the component's
+* render must be wrapped in a flush.
+*/
+function containsAwaitGroup(node) {
+	if (node === void 0 || node === null) return false;
+	if (isControlNode(node) && node.operation === "@await group") return true;
+	if (node.type !== "text" && node.type !== "comment") {
+		for (let child of node.children) if (containsAwaitGroup(child)) return true;
+	}
+	return false;
 }
 //#endregion
 //#region src/compile/utils/trimWhitespace.ts