acrylblends 0.6.2 → 0.6.4

package/lib/basic-auth.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+import { L as MiddlewareHandler, t as Context } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/basic-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;

package/lib/bearer-auth.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, _ as Env, t as Context } from "./context-B5Y1lLha.js";
+import { L as MiddlewareHandler, t as Context, v as Env } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/bearer-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;

package/lib/body-limit.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+import { L as MiddlewareHandler, t as Context } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/body-limit/index.d.ts
 type OnError = (c: Context) => Response | Promise<Response>;

package/lib/cache.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+import { L as MiddlewareHandler, t as Context } from "./context-DS3fYyG-.js";
 import { c as StatusCode } from "./http-status-DaAwGAFL.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/cache/index.d.ts

package/lib/cache.js

@@ -7,10 +7,10 @@ import { cloneRawRequest } from "./request.js";
 const defaultCacheableStatusCodes = [200];
 const defaultMaxQueryBodySize = 64 * 1024;
 const cacheKeyPath = "/.acryl-router/cache";
-const cacheKeyParameter = "__hono_cache_key";
-const cacheMethodKeyParameter = "__hono_cache_method";
-const queryDigestKeyParameter = "__hono_query_digest";
-const cacheVaryKeyParameter = "__hono_cache_vary";
+const cacheKeyParameter = "__acryl_cache_key";
+const cacheMethodKeyParameter = "__acryl_cache_method";
+const queryDigestKeyParameter = "__acryl_query_digest";
+const cacheVaryKeyParameter = "__acryl_cache_vary";
 const queryRepresentationMetadataHeaders = [
 	"content-type",
 	"content-encoding",

package/lib/{client-BHTr318g.js → client-DDLXwhBo.js}

@@ -1,128 +1,5 @@
 import { serialize } from "./utils/cookie.js";
-//#region ../../plugins/acryl-router/src/core/client/fetch-result-please.ts
-/**
-* @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Acryl's custom needs.
-*
-* @link https://www.npmjs.com/package/fetch-result-please
-*/
-const nullBodyResponses = /* @__PURE__ */ new Set([
-	101,
-	204,
-	205,
-	304
-]);
-/**
-* Smartly parses and return the consumable result from a fetch `Response`.
-*
-* Throwing a structured error if the response is not `ok`. ({@link DetailedError})
-*/
-async function fetchRP(fetchRes) {
-	const _fetchRes = await fetchRes;
-	if ((_fetchRes.body || _fetchRes._bodyInit) && !nullBodyResponses.has(_fetchRes.status)) _fetchRes._data = await _fetchRes[detectResponseType(_fetchRes)]();
-	if (!_fetchRes.ok) throw new DetailedError(`${_fetchRes.status} ${_fetchRes.statusText}`, {
-		statusCode: _fetchRes?.status,
-		detail: {
-			data: _fetchRes?._data,
-			statusText: _fetchRes?.statusText
-		}
-	});
-	return _fetchRes._data;
-}
-var DetailedError = class extends Error {
-	/**
-	* Additional `message` that will be logged AND returned to client
-	*/
-	detail;
-	/**
-	* Additional `code` that will be logged AND returned to client
-	*/
-	code;
-	/**
-	* Additional value that will be logged AND NOT returned to client
-	*/
-	log;
-	/**
-	* Optionally set the status code to return, in a web server context
-	*/
-	statusCode;
-	constructor(message, options = {}) {
-		super(message);
-		this.name = "DetailedError";
-		this.log = options.log;
-		this.detail = options.detail;
-		this.code = options.code;
-		this.statusCode = options.statusCode;
-	}
-};
-const jsonRegex = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(?:;.+)?$/i;
-function detectResponseType(response) {
-	const _contentType = response.headers.get("content-type");
-	if (!_contentType) return "text";
-	const contentType = _contentType.split(";").shift();
-	if (jsonRegex.test(contentType)) return "json";
-	return "text";
-}
-//#endregion
-//#region ../../plugins/acryl-router/src/core/client/utils.ts
-const mergePath = (base, path) => {
-	base = base.replace(/\/+$/, "");
-	base = base + "/";
-	path = path.replace(/^\/+/, "");
-	return base + path;
-};
-const replaceUrlParam = (urlString, params) => {
-	for (const [k, v] of Object.entries(params)) {
-		const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??(?=/|$)");
-		urlString = urlString.replace(reg, () => v ? `/${v}` : "");
-	}
-	return urlString;
-};
-const buildSearchParams = (query) => {
-	const searchParams = new URLSearchParams();
-	for (const [k, v] of Object.entries(query)) {
-		if (v === void 0) continue;
-		if (Array.isArray(v)) for (const v2 of v) {
-			if (v2 === void 0) continue;
-			searchParams.append(k, v2);
-		}
-		else searchParams.set(k, v);
-	}
-	return searchParams;
-};
-const replaceUrlProtocol = (urlString, protocol) => {
-	switch (protocol) {
-		case "ws": return urlString.replace(/^http/, "ws");
-		case "http": return urlString.replace(/^ws/, "http");
-	}
-};
-const removeIndexString = (urlString) => {
-	if (/^https?:\/\/[^\/]+?\/index(?=\?|$)/.test(urlString)) return urlString.replace(/\/index(?=\?|$)/, "/");
-	return urlString.replace(/\/index(?=\?|$)/, "");
-};
-function isObject(item) {
-	return typeof item === "object" && item !== null && !Array.isArray(item);
-}
-function deepMerge(target, source) {
-	if (!isObject(target) && !isObject(source)) return source;
-	const merged = { ...target };
-	for (const key in source) {
-		const value = source[key];
-		if (isObject(merged[key]) && isObject(value)) merged[key] = deepMerge(merged[key], value);
-		else merged[key] = value;
-	}
-	return merged;
-}
-/**
-* Shortcut to get a consumable response from `hc`'s fetch calls (Response), with types inference.
-*
-* Smartly parse the response data, throwing a structured error if the response is not `ok`. ({@link DetailedError})
-*
-* @example const result = await parseResponse(client.posts.$get())
-*/
-async function parseResponse(fetchRes) {
-	return fetchRP(fetchRes);
-}
-//#endregion
+import { a as removeIndexString, n as deepMerge, o as replaceUrlParam, r as mergePath, s as replaceUrlProtocol, t as buildSearchParams } from "./utils-Cx61GFMC.js";
 //#region ../../plugins/acryl-router/src/core/client/client.ts
 const createProxy = (callback, path) => {
 	return new Proxy(() => {}, {
@@ -263,4 +140,4 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
 	return req;
 }, []);
 //#endregion
-export { parseResponse as n, DetailedError as r, hc as t };
+export { hc as t };

package/lib/client.d.ts

@@ -1,3 +1,3 @@
-import { a as ClientResponse, c as InferRequestType, i as ClientRequestOptions, l as InferResponseType, o as Fetch, r as ClientRequest, t as ApplyGlobalResponse, u as PickResponseByStatusCode } from "./types-Bd29gh2o.js";
-import { n as DetailedError, r as hc, t as parseResponse } from "./index-m12zcmph.js";
+import { a as ClientResponse, c as InferRequestType, i as ClientRequestOptions, l as InferResponseType, o as Fetch, r as ClientRequest, t as ApplyGlobalResponse, u as PickResponseByStatusCode } from "./types-zNxyEpG2.js";
+import { n as DetailedError, r as hc, t as parseResponse } from "./index-Bb7YJKCq.js";
 export { type ApplyGlobalResponse, type ClientRequest, type ClientRequestOptions, type ClientResponse, DetailedError, type Fetch, type InferRequestType, type InferResponseType, type PickResponseByStatusCode, hc, parseResponse };

package/lib/client.js

@@ -1,2 +1,3 @@
-import { n as parseResponse, r as DetailedError, t as hc } from "./client-BHTr318g.js";
+import { c as DetailedError, i as parseResponse } from "./utils-Cx61GFMC.js";
+import { t as hc } from "./client-DDLXwhBo.js";
 export { DetailedError, hc, parseResponse };

package/lib/combine.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+import { L as MiddlewareHandler, t as Context } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/combine/index.d.ts
 type Condition = (c: Context) => boolean;

package/lib/common-D8Z4JRCw.d.ts

@@ -0,0 +1,46 @@
+//#region ../../plugins/acryl-router/src/core/helper/css/common.d.ts
+declare const SELECTOR: unique symbol;
+declare const CLASS_NAME: unique symbol;
+declare const STYLE_STRING: unique symbol;
+declare const SELECTORS: unique symbol;
+declare const EXTERNAL_CLASS_NAMES: unique symbol;
+declare const CSS_ESCAPED: unique symbol;
+interface CssClassName {
+  [SELECTOR]: string;
+  [CLASS_NAME]: string;
+  [STYLE_STRING]: string;
+  [SELECTORS]: CssClassName[];
+  [EXTERNAL_CLASS_NAMES]: string[];
+}
+interface CssEscapedString {
+  [CSS_ESCAPED]: string;
+}
+/**
+ * @experimental
+ * `rawCssString` is an experimental feature.
+ * The API might be changed.
+ */
+declare const rawCssString: (value: string) => CssEscapedString;
+type CssVariableBasicType = CssClassName | CssEscapedString | string | number | boolean | null | undefined;
+type CssVariableAsyncType = Promise<CssVariableBasicType>;
+type CssVariableArrayType = (CssVariableBasicType | CssVariableAsyncType)[];
+type CssVariableType = CssVariableBasicType | CssVariableAsyncType | CssVariableArrayType;
+/**
+ * A function that customizes generated CSS class names.
+ *
+ * @param hash - The default hash-based class name (e.g. `css-1234567890`)
+ * @param label - The comment label extracted from the CSS template, may be empty.
+ *   Whitespace is trimmed and inner spaces are replaced with hyphens.
+ * @param styleString - The minified CSS style string
+ * @returns The custom class name to use. Must be a safe CSS identifier;
+ *   otherwise, the default hash is used as a fallback.
+ */
+type ClassNameSlug = (hash: string, label: string, styleString: string) => string;
+/**
+ * A callback function called when an invalid slug is returned from ClassNameSlug.
+ *
+ * @param slug - The invalid slug
+ */
+type OnInvalidSlug = (slug: string) => void;
+//#endregion
+export { rawCssString as a, OnInvalidSlug as i, CssClassName as n, CssVariableType as r, ClassNameSlug as t };

package/lib/components-0o0CBYNv.js

@@ -0,0 +1,268 @@
+import { C as captureRenderContext, E as useContext, d as renderUntrustedObject, i as isUntrustedObject, n as JSXNode, o as jsx, t as Fragment, u as renderChildren, w as createContext } from "./base-ddiVmiE7.js";
+import { HtmlEscapedCallbackPhase, raw, resolveCallback } from "./utils/html.js";
+import { a as DOM_STASH, i as DOM_RENDERER } from "./constants-BR9jM9BC.js";
+import { x as buildDataStack } from "./hooks-BMw6BAyP.js";
+import { n as Suspense$1, t as ErrorBoundary$1 } from "./components-DdI7-ns7.js";
+//#region ../../plugins/acryl-router/src/core/jsx/streaming.ts
+/**
+* @module
+* This module enables JSX to supports streaming Response.
+*/
+/**
+* Used to specify nonce for scripts generated by `Suspense` and `ErrorBoundary`.
+*
+* @example
+* ```tsx
+* <StreamingContext.Provider value={{ scriptNonce: 'test-nonce' }}>
+*   <Suspense fallback={<p>Loading...</p>}>
+*     <Content />
+*   </Suspense>
+* </StreamingContext.Provider>
+* ```
+*/
+const StreamingContext = createContext(null);
+let suspenseCounter = 0;
+const serializeBoundaryChild = (child) => typeof child === "string" || Array.isArray(child) ? renderChildren([child]) : child == null || typeof child === "boolean" ? "" : isUntrustedObject(child) ? renderUntrustedObject(child) : child.toString();
+/**
+* @experimental
+* `Suspense` is an experimental feature.
+* The API might be changed.
+*/
+const Suspense = async ({ children, fallback }) => {
+	if (!Array.isArray(children)) children = [children];
+	const nonce = useContext(StreamingContext)?.scriptNonce;
+	let resArray = [];
+	const stackNode = { [DOM_STASH]: [0, []] };
+	const popNodeStack = () => {
+		buildDataStack.pop();
+	};
+	try {
+		stackNode[DOM_STASH][0] = 0;
+		buildDataStack.push([[], stackNode]);
+		resArray = children.map(serializeBoundaryChild);
+	} catch (e) {
+		if (e instanceof Promise) {
+			const resume = captureRenderContext();
+			resArray = [e.then(() => resume(() => {
+				stackNode[DOM_STASH][0] = 0;
+				buildDataStack.push([[], stackNode]);
+				return childrenToString(children).finally(popNodeStack);
+			}))];
+		} else throw e;
+	} finally {
+		popNodeStack();
+	}
+	if (resArray.some((res) => res instanceof Promise)) {
+		const index = suspenseCounter++;
+		const fallbackStr = await (typeof fallback === "string" || Array.isArray(fallback) ? renderChildren([fallback]) : isUntrustedObject(fallback) ? renderUntrustedObject(fallback) : fallback.toString());
+		return raw(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [...fallbackStr.callbacks || [], ({ phase, buffer, context }) => {
+			if (phase === HtmlEscapedCallbackPhase.BeforeStream) return;
+			return Promise.all(resArray).then(async (htmlArray) => {
+				htmlArray = htmlArray.flat();
+				const content = htmlArray.join("");
+				if (buffer) buffer[0] = buffer[0].replace(new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`, "s"), () => content);
+				let html = buffer ? "" : `<template data-acryl-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('H:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
+d.replaceWith(c.content)
+})(document)
+<\/script>`;
+				const callbacks = htmlArray.map((html) => html.callbacks || []).flat();
+				if (!callbacks.length) return html;
+				if (phase === HtmlEscapedCallbackPhase.Stream) html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				return raw(html, callbacks);
+			});
+		}]);
+	} else return raw(resArray.join(""));
+};
+Suspense[DOM_RENDERER] = Suspense$1;
+const textEncoder = new TextEncoder();
+/**
+* @experimental
+* `renderToReadableStream()` is an experimental feature.
+* The API might be changed.
+*/
+const renderToReadableStream = (content, onError = console.trace) => {
+	let cancelled = false;
+	return new ReadableStream({
+		async start(controller) {
+			try {
+				if (content instanceof JSXNode) content = content.toString();
+				const context = typeof content === "object" ? content : {};
+				const resolved = await resolveCallback(content, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				if (!cancelled) controller.enqueue(textEncoder.encode(resolved));
+				let resolvedCount = 0;
+				const callbacks = [];
+				const then = (promise) => {
+					callbacks.push(promise.catch((err) => {
+						console.log(err);
+						onError(err);
+						return "";
+					}).then(async (res) => {
+						res = await resolveCallback(res, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+						res.callbacks?.map((c) => c({
+							phase: HtmlEscapedCallbackPhase.Stream,
+							context
+						})).filter(Boolean).forEach(then);
+						resolvedCount++;
+						if (!cancelled) controller.enqueue(textEncoder.encode(res));
+					}));
+				};
+				resolved.callbacks?.map((c) => c({
+					phase: HtmlEscapedCallbackPhase.Stream,
+					context
+				})).filter(Boolean).forEach(then);
+				while (resolvedCount !== callbacks.length) await Promise.all(callbacks);
+			} catch (e) {
+				onError(e);
+			}
+			if (!cancelled) controller.close();
+		},
+		cancel() {
+			cancelled = true;
+		}
+	});
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/jsx/components.ts
+let errorBoundaryCounter = 0;
+const childrenToString = async (children) => {
+	try {
+		return children.flat().map(resolveChildEarly);
+	} catch (e) {
+		if (e instanceof Promise) {
+			const resume = captureRenderContext();
+			await e;
+			return resume(() => childrenToString(children));
+		} else throw e;
+	}
+};
+const resolveChildEarly = (child) => {
+	if (child == null || typeof child === "boolean") return "";
+	else if (typeof child === "string" || Array.isArray(child)) return renderChildren([child]);
+	else if (isUntrustedObject(child)) return renderUntrustedObject(child);
+	else {
+		const str = child.toString();
+		return str instanceof Promise ? str : raw(str);
+	}
+};
+/**
+* @experimental
+* `ErrorBoundary` is an experimental feature.
+* The API might be changed.
+*/
+const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
+	if (!children) return raw("");
+	if (!Array.isArray(children)) children = [children];
+	const nonce = useContext(StreamingContext)?.scriptNonce;
+	let resume;
+	const getResume = () => resume ||= captureRenderContext();
+	let fallbackStrPromise;
+	const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
+		const awaitedFallback = await fallback;
+		if (awaitedFallback === null || awaitedFallback === void 0) return;
+		if (typeof awaitedFallback === "string" || Array.isArray(awaitedFallback)) return getResume()(() => renderChildren([awaitedFallback]));
+		if (isUntrustedObject(awaitedFallback)) return getResume()(() => renderUntrustedObject(awaitedFallback));
+		const fallbackResult = await getResume()(() => awaitedFallback.toString());
+		return raw(fallbackResult, fallbackResult.callbacks || awaitedFallback.callbacks);
+	})();
+	const renderFallback = async (error) => {
+		const fallbackStr = await resolveFallbackStr();
+		return getResume()(async () => {
+			onError?.(error);
+			const fallbackRes = fallbackStr !== void 0 ? fallbackStr : fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
+			const fallbackResString = await Fragment({ children: fallbackRes }).toString();
+			return raw(fallbackResString, fallbackResString.callbacks || fallbackRes.callbacks);
+		});
+	};
+	let resArray = [];
+	try {
+		resArray = children.map(resolveChildEarly);
+	} catch (e) {
+		const resume = getResume();
+		if (e instanceof Promise) resArray = [e.then(() => resume(() => childrenToString(children))).catch((e) => renderFallback(e))];
+		else resArray = [await renderFallback(e)];
+	}
+	if (resArray.some((res) => res instanceof Promise)) {
+		getResume();
+		const index = errorBoundaryCounter++;
+		const replaceRe = RegExp(`(<template id="E:${index}"></template>)(.*?)(<!--E:${index}-->)`, "s");
+		let caught = false;
+		const catchCallback = async ({ error, buffer }) => {
+			if (caught) return "";
+			caught = true;
+			const fallbackResString = await renderFallback(error);
+			const fallbackCallbacks = fallbackResString.callbacks;
+			if (buffer) {
+				buffer[0] = buffer[0].replace(replaceRe, () => fallbackResString);
+				return fallbackCallbacks?.length ? raw("", fallbackCallbacks) : "";
+			}
+			return raw(`<template data-acryl-target="E:${index}">${fallbackResString}</template><script>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
+d.replaceWith(c.content)
+})(document)
+<\/script>`, fallbackCallbacks);
+		};
+		let error;
+		const promiseAll = Promise.all(resArray).catch((e) => error = e);
+		return raw(`<template id="E:${index}"></template><!--E:${index}-->`, [({ phase, buffer, context }) => {
+			if (phase === HtmlEscapedCallbackPhase.BeforeStream) return;
+			return promiseAll.then(async (htmlArray) => {
+				if (error) throw error;
+				htmlArray = htmlArray.flat();
+				const content = htmlArray.join("");
+				let html = buffer ? "" : `<template data-acryl-target="E:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+if(!d)return
+d.parentElement.insertBefore(c.content,d.nextSibling)
+})(document)
+<\/script>`;
+				if (htmlArray.every((html) => !html.callbacks?.length)) {
+					if (buffer) buffer[0] = buffer[0].replace(replaceRe, () => content);
+					return html;
+				}
+				if (buffer) buffer[0] = buffer[0].replace(replaceRe, (_all, pre, _, post) => `${pre}${content}${post}`);
+				const callbacks = htmlArray.map((html) => html.callbacks || []).flat();
+				if (phase === HtmlEscapedCallbackPhase.Stream) html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				let resolvedCount = 0;
+				const promises = callbacks.map((c) => (...args) => c(...args)?.then((content) => {
+					resolvedCount++;
+					if (buffer) {
+						if (resolvedCount === callbacks.length) buffer[0] = buffer[0].replace(replaceRe, (_all, _pre, content) => content);
+						buffer[0] += content;
+						return raw("", content.callbacks);
+					}
+					return raw(content + (resolvedCount !== callbacks.length ? "" : `<script>
+((d,c,n) => {
+d=d.getElementById('E:${index}')
+if(!d)return
+n=d.nextSibling
+while(n.nodeType!=8||n.nodeValue!='E:${index}'){n=n.nextSibling}
+n.remove()
+d.remove()
+})(document)
+<\/script>`), content.callbacks);
+				}).catch((error) => catchCallback({
+					error,
+					buffer
+				})));
+				return raw(html, promises);
+			}).catch((error) => catchCallback({
+				error,
+				buffer
+			}));
+		}]);
+	} else return Fragment({ children: resArray });
+};
+ErrorBoundary[DOM_RENDERER] = ErrorBoundary$1;
+//#endregion
+export { renderToReadableStream as i, StreamingContext as n, Suspense as r, ErrorBoundary as t };

package/lib/components-DdI7-ns7.js

@@ -0,0 +1,24 @@
+import { t as DOM_ERROR_HANDLER } from "./constants-BR9jM9BC.js";
+import { t as Fragment } from "./jsx-dev-runtime-D18Y35TI.js";
+import "./jsx/dom/jsx-runtime.js";
+//#region ../../plugins/acryl-router/src/core/jsx/dom/components.ts
+const ErrorBoundary = (({ children, fallback, fallbackRender, onError }) => {
+	const res = Fragment({ children });
+	res[DOM_ERROR_HANDLER] = (err) => {
+		if (err instanceof Promise) throw err;
+		onError?.(err);
+		return fallbackRender?.(err) || fallback;
+	};
+	return res;
+});
+const Suspense = (({ children, fallback }) => {
+	const res = Fragment({ children });
+	res[DOM_ERROR_HANDLER] = (err, retry) => {
+		if (!(err instanceof Promise)) throw err;
+		err.finally(retry);
+		return fallback;
+	};
+	return res;
+});
+//#endregion
+export { Suspense as n, ErrorBoundary as t };

package/lib/compress.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler } from "./context-B5Y1lLha.js";
+import { L as MiddlewareHandler } from "./context-DS3fYyG-.js";
 import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "./utils/compress.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/compress/index.d.ts

package/lib/conninfo.d.ts

@@ -1,5 +1,5 @@
-import { t as Context } from "./context-B5Y1lLha.js";
-import { i as NetAddrInfo, n as ConnInfo, r as GetConnInfo, t as AddressType } from "./types-ZM9gIiKh.js";
+import { t as Context } from "./context-DS3fYyG-.js";
+import { i as NetAddrInfo, n as ConnInfo, r as GetConnInfo, t as AddressType } from "./types-Dv_nV2cv.js";
 
 //#region ../../plugins/acryl-router/src/connection.d.ts
 /** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */

package/lib/constants-BR9jM9BC.js

@@ -0,0 +1,9 @@
+//#region ../../plugins/acryl-router/src/core/jsx/constants.ts
+const DOM_RENDERER = Symbol("RENDERER");
+const DOM_ERROR_HANDLER = Symbol("ERROR_HANDLER");
+const DOM_STASH = Symbol("STASH");
+const DOM_INTERNAL_TAG = Symbol("INTERNAL");
+const DOM_MEMO = Symbol("MEMO");
+const PERMALINK = Symbol("PERMALINK");
+//#endregion
+export { DOM_STASH as a, DOM_RENDERER as i, DOM_INTERNAL_TAG as n, PERMALINK as o, DOM_MEMO as r, DOM_ERROR_HANDLER as t };

package/lib/{context-B5Y1lLha.d.ts → context-DS3fYyG-.d.ts}

@@ -1,7 +1,7 @@
 import { c as Result, l as Router } from "./router-CvUxUTOq.js";
 import { i as ResponseHeader, n as CustomHeader, r as RequestHeader } from "./headers-tu2YYN8T.js";
 import { c as StatusCode, n as ContentfulStatusCode, o as RedirectStatusCode } from "./http-status-DaAwGAFL.js";
-import { C as Simplify, E as UnionToIntersection, _ as JSONValue, d as InvalidJSONValue, f as IsAny, h as JSONParsed, l as IfAnyThenEmptyObject, x as RemoveBlankRecord } from "./types-D9DEXMjE.js";
+import { D as UnionToIntersection, S as RemoveBlankRecord, f as InvalidJSONValue, g as JSONParsed, p as IsAny, u as IfAnyThenEmptyObject, v as JSONValue, w as Simplify } from "./types-Lqx5BxQF.js";
 import { t as BaseMime } from "./mime-BQOYHl-l.js";
 
 //#region ../../plugins/acryl-router/src/core/request/constants.d.ts
@@ -1231,4 +1231,4 @@ declare class Context<E extends Env = any, P extends string = any, I extends Inp
   notFound: () => ReturnType<NotFoundHandler>;
 }
 //#endregion
-export { Acryl as $, Input as A, NotFoundResponse as B, FetchEventLike as C, Handler as D, HTTPResponseError as E, MergeSchemaPath as F, RemoveQuestion as G, ParamKeyToRecord as H, MiddlewareHandler as I, Schema as J, ResponseFormat as K, MiddlewareHandlerInterface as L, IntersectNonAnyTypes as M, KnownResponseFormat as N, HandlerInterface as O, MergePath as P, Variables as Q, Next as R, ExtractSchemaForStatusCode as S, H as T, ParamKeys as U, OnHandlerInterface as V, ParsedFormValue as W, TypedResponse as X, ToSchema as Y, ValidationTargets as Z, Env as _, ExecutionContext as a, ExtractInput as b, BodyData as c, AddParam as d, AcrylOptions as et, Bindings as f, Endpoint as g, BlankSchema as h, Data as i, InputToDataByTarget as j, HandlerResponse as k, ParseBodyOptions as l, BlankInput as m, ContextRenderer as n, AcrylRequest as o, BlankEnv as p, RouterRoute as q, ContextVariableMap as r, cloneRawRequest as s, Context as t, parseBody as u, ErrorHandler as v, FormValue as w, ExtractSchema as x, ExtractHandlerResponse as y, NotFoundHandler as z };
+export { Variables as $, HandlerResponse as A, NotFoundHandler as B, ExtractSchemaForStatusCode as C, HTTPResponseError as D, H as E, MergePath as F, ParsedFormValue as G, OnHandlerInterface as H, MergeSchemaPath as I, RouterRoute as J, RemoveQuestion as K, MiddlewareHandler as L, InputToDataByTarget as M, IntersectNonAnyTypes as N, Handler as O, KnownResponseFormat as P, ValidationTargets as Q, MiddlewareHandlerInterface as R, ExtractSchema as S, FormValue as T, ParamKeyToRecord as U, NotFoundResponse as V, ParamKeys as W, ToSchema as X, Schema as Y, TypedResponse as Z, Endpoint as _, ExecutionContext as a, ExtractHandlerResponse as b, cloneRawRequest as c, parseBody as d, Acryl as et, AddParam as f, BlankSchema as g, BlankInput as h, Data as i, Input as j, HandlerInterface as k, BodyData as l, BlankEnv as m, ContextRenderer as n, PropsForRenderer as o, Bindings as p, ResponseFormat as q, ContextVariableMap as r, AcrylRequest as s, Context as t, AcrylOptions as tt, ParseBodyOptions as u, Env as v, FetchEventLike as w, ExtractInput as x, ErrorHandler as y, Next as z };