@psnext/slingcli 3.1.20260904-1 → 3.3.20260914-1

package/node_modules/@types/node/http.d.ts

@@ -225,7 +225,7 @@ declare module "node:http" {
          * The number of milliseconds of inactivity a server needs to wait for additional incoming data,
          * after it has finished writing the last response, before a socket will be destroyed.
          * @see Server.keepAliveTimeout for more information.
-         * @default 5000
+         * @default 65000
          * @since v18.0.0
          */
         keepAliveTimeout?: number | undefined;

package/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "26.4.1",
+    "version": "26.5.1",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -147,9 +147,9 @@
     },
     "scripts": {},
     "dependencies": {
-        "undici-types": "~8.3.0"
+        "undici-types": "~8.9.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "463ff626c280fc7ad82097e8ff9ab6bd4a19fb2b4c56c8d56c2b8148cd872d0c",
+    "typesPublisherContentHash": "6f5c8d0dfea5f391f6d414b5de64b03719aeafbbbe627156f715a8c47167ddcd",
     "typeScriptVersion": "5.6"
 }

package/node_modules/@types/node/perf_hooks.d.ts

@@ -301,6 +301,7 @@ declare module "node:perf_hooks" {
     namespace constants {
         const NODE_PERFORMANCE_GC_MAJOR: number;
         const NODE_PERFORMANCE_GC_MINOR: number;
+        const NODE_PERFORMANCE_GC_MINOR_MARK_SWEEP: number;
         const NODE_PERFORMANCE_GC_INCREMENTAL: number;
         const NODE_PERFORMANCE_GC_WEAKCB: number;
         const NODE_PERFORMANCE_GC_FLAGS_NO: number;
@@ -313,9 +314,14 @@ declare module "node:perf_hooks" {
     }
     interface EventLoopMonitorOptions {
         /**
-         * The sampling rate in milliseconds.
-         * Must be greater than zero.
-         * @default 10
+         * When `true`, samples are taken once per
+         * event loop iteration. **Default:** `false`.
+         */
+        samplePerIteration?: boolean | undefined;
+        /**
+         * The sampling rate in milliseconds for interval-based
+         * sampling. Must be greater than zero. This option is ignored when
+         * `samplePerIteration` is `true`. **Default:** `10`.
          */
         resolution?: number | undefined;
     }
@@ -399,21 +405,25 @@ declare module "node:perf_hooks" {
          */
         readonly stddev: number;
     }
-    interface IntervalHistogram extends Histogram {
+    /**
+     * A `Histogram` that records event loop delay, returned by
+     * `perf_hooks.monitorEventLoopDelay()`.
+     */
+    interface ELDHistogram extends Histogram {
         /**
-         * Enables the update interval timer. Returns `true` if the timer was
-         * started, `false` if it was already started.
+         * Disables event loop delay sampling. Returns `true` if sampling was
+         * stopped, `false` if it was already stopped.
          * @since v11.10.0
          */
-        enable(): boolean;
+        disable(): boolean;
         /**
-         * Disables the update interval timer. Returns `true` if the timer was
-         * stopped, `false` if it was already stopped.
+         * Enables event loop delay sampling. Returns `true` if sampling was
+         * started, `false` if it was already started.
          * @since v11.10.0
          */
-        disable(): boolean;
+        enable(): boolean;
         /**
-         * Disables the update interval timer when the histogram is disposed.
+         * Disables event loop delay sampling when the histogram is disposed.
          *
          * ```js
          * const { monitorEventLoopDelay } = require('node:perf_hooks');
@@ -508,14 +518,16 @@ declare module "node:perf_hooks" {
     /**
      * _This property is an extension by Node.js. It is not available in Web browsers._
      *
-     * Creates an `IntervalHistogram` object that samples and reports the event loop
-     * delay over time. The delays will be reported in nanoseconds.
+     * Creates a histogram object that samples and reports the event loop delay over
+     * time. The delays will be reported in nanoseconds.
      *
-     * Using a timer to detect approximate event loop delay works because the
-     * execution of timers is tied specifically to the lifecycle of the libuv
-     * event loop. That is, a delay in the loop will cause a delay in the execution
-     * of the timer, and those delays are specifically what this API is intended to
-     * detect.
+     * By default, the histogram is updated by a timer using the configured
+     * `resolution`. When `samplePerIteration` is `true`, samples are taken once per
+     * event loop iteration using `uv_prepare_t` and `uv_check_t` hooks. In that mode,
+     * the histogram does not keep the loop alive or force additional iterations when
+     * the application is idle.
+     * The two sampling modes produce significantly different results and should not
+     * be compared directly.
      *
      * ```js
      * import { monitorEventLoopDelay } from 'node:perf_hooks';
@@ -533,7 +545,7 @@ declare module "node:perf_hooks" {
      * ```
      * @since v11.10.0
      */
-    function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
+    function monitorEventLoopDelay(options?: EventLoopMonitorOptions): ELDHistogram;
     interface TimerifyOptions {
         /**
          * A histogram object created using

package/node_modules/@types/node/quic.d.ts

@@ -1059,8 +1059,8 @@ declare module "node:quic" {
     interface CreateStreamOptions {
         /**
          * The outbound body source. See `stream.setBody()` for details on
-         * supported types. When omitted, the stream starts half-closed (writable
-         * side open, no body queued).
+         * supported types. When omitted, the stream's outgoing side remains
+         * writable with no body queued; no FIN is sent immediately.
          */
         body?: StreamBody | undefined;
         /**
@@ -1375,7 +1375,8 @@ declare module "node:quic" {
         onqlog: OnQlogCallback | undefined;
         /**
          * Open a new bidirectional stream. If the `body` option is not specified,
-         * the outgoing stream will be half-closed. The `priority` and `incremental`
+         * the stream's outgoing side remains writable and no FIN is sent
+         * immediately. The `priority` and `incremental`
          * options are only used when the session supports priority (e.g. HTTP/3).
          * The `headers`, `onheaders`, `ontrailers`, `oninfo`, and `onwanttrailers`
          * options are only used when the session supports headers (e.g. HTTP/3).
@@ -1384,7 +1385,8 @@ declare module "node:quic" {
         createBidirectionalStream(options?: CreateStreamOptions): Promise<QuicStream>;
         /**
          * Open a new unidirectional stream. If the `body` option is not specified,
-         * the outgoing stream will be closed. The `priority` and `incremental`
+         * the stream's outgoing side remains writable and no FIN is sent
+         * immediately. The `priority` and `incremental`
          * options are only used when the session supports priority (e.g. HTTP/3).
          * @since v23.8.0
          */

package/node_modules/@types/node/stream/web.d.ts

@@ -294,6 +294,26 @@ declare module "node:stream/web" {
         prototype: WritableStreamDefaultWriter;
         new<W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
     };
+    // Node.js extensions
+    /**
+     * Runs the WHATWG `ReadableStreamTee` abstract operation on `stream`.
+     *
+     * This differs from `readableStream.tee()` only when `cloneForBranch2` is
+     * `true`. The `tee()` method always passes `false`, while other web platform
+     * specifications, such as Fetch body cloning, pass `true` so that the second
+     * branch receives cloned chunks and consumption of one branch cannot mutate chunks
+     * seen by the other.
+     * @since v26.5.0
+     * @experimental
+     * @param cloneForBranch2 When `true`, chunks enqueued into the second
+     * branch are cloned from chunks enqueued into the first branch. **Default:**
+     * `false`.
+     * @returns Two `ReadableStream` branches.
+     */
+    function ReadableStreamTee<R>(
+        stream: ReadableStream<R>,
+        cloneForBranch2?: boolean,
+    ): [ReadableStream<R>, ReadableStream<R>];
 }
 declare module "stream/web" {
     export * from "node:stream/web";

package/node_modules/@types/node/tls.d.ts

@@ -270,11 +270,19 @@ declare module "node:tls" {
          */
         getCipher(): CipherNameAndProtocol;
         /**
-         * Returns an object representing the type, name, and size of parameter of
-         * an ephemeral key exchange in `perfect forward secrecy` on a client
-         * connection. It returns an empty object when the key exchange is not
-         * ephemeral. As this is only supported on a client socket; `null` is returned
-         * if called on a server socket. The supported types are `'DH'` and `'ECDH'`. The `name` property is available only when type is `'ECDH'`.
+         * Returns an object describing ephemeral key agreement in [perfect forward
+         * secrecy](https://nodejs.org/docs/latest-v26.x/api/tls.html#perfect-forward-secrecy) on a client connection. It returns an empty object when the key
+         * agreement is not ephemeral. As this is only supported on a client socket;
+         * `null` is returned if called on a server socket. The supported types are `'DH'`,
+         * `'ECDH'`, and `'TLSGroup'`. For `'DH'` and `'ECDH'`, the object describes peer
+         * temporary key parameters. For `'TLSGroup'`, the object identifies the negotiated
+         * TLS Supported Group used for key agreement when a peer temporary key object is
+         * not available.
+         *
+         * The `name` property is available only when type is `'ECDH'` or `'TLSGroup'`. The
+         * `size` property is not available when type is `'TLSGroup'`. For `'TLSGroup'`,
+         * `name` is the negotiated TLS Supported Group name. Standardized TLS group names
+         * and code points are listed in the [IANA TLS Supported Groups registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8).
          *
          * For example: `{ type: 'ECDH', name: 'prime256v1', size: 256 }`.
          * @since v5.0.0
@@ -822,13 +830,16 @@ declare module "node:tls" {
          */
         dhparam?: string | Buffer | undefined;
         /**
-         * A string describing a named curve or a colon separated list of curve
-         * NIDs or names, for example P-521:P-384:P-256, to use for ECDH key
-         * agreement. Set to auto to select the curve automatically. Use
-         * crypto.getCurves() to obtain a list of available curve names. On
-         * recent releases, openssl ecparam -list_curves will also display the
-         * name and description of each available elliptic curve. Default:
-         * tls.DEFAULT_ECDH_CURVE.
+         * A string describing a named curve, TLS group, or
+         * colon-separated list of named curves or TLS groups to use for key agreement,
+         * for example `P-521:P-384:P-256`, `X25519`, or `X25519MLKEM768`. The
+         * historical name of this option refers to ECDH key agreement in TLSv1.2 and
+         * below. In TLSv1.3, this option configures the TLS Supported Groups and
+         * key share groups offered or accepted by the TLS stack. Set to `auto` to
+         * select the group automatically. Use `crypto.getCurves()` to obtain a
+         * list of available elliptic curve names. For TLS group names, use
+         * `openssl list -tls-groups` or consult the [IANA TLS Supported Groups
+         * registry](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8).
          */
         ecdhCurve?: string | undefined;
         /**
@@ -1167,9 +1178,9 @@ declare module "node:tls" {
      */
     function setDefaultCACertificates(certs: ReadonlyArray<string | NodeJS.ArrayBufferView>): void;
     /**
-     * The default curve name to use for ECDH key agreement in a tls server.
-     * The default value is `'auto'`. See `{@link createSecureContext()}` for further
-     * information.
+     * The default named curve or TLS group list to use for key agreement in a TLS
+     * server. The default value is `'auto'`. See `tls.createSecureContext()` for
+     * further information.
      * @since v0.11.13
      */
     let DEFAULT_ECDH_CURVE: string;

package/node_modules/@types/node/vfs.d.ts

@@ -182,10 +182,11 @@ declare module "node:vfs" {
         setReadOnly(): void;
     }
     /**
-     * A provider that wraps a directory (i.e. one on the actual file system) and exposes its
-     * contents through the VFS API. All VFS paths are resolved relative to
-     * the root and verified to stay inside it; symbolic links resolving
-     * outside the root are rejected.
+     * A provider that wraps a directory (i.e. one on the actual file system) and
+     * exposes its contents through the VFS API. All VFS paths are resolved relative to
+     * the root and verified to stay inside it; symbolic links resolving outside the
+     * root are rejected. This path mapping is not a sandbox or access-control
+     * mechanism.
      * @since v26.4.0
      */
     class RealFSProvider extends VirtualProvider {
@@ -193,8 +194,8 @@ declare module "node:vfs" {
          * ```js
          * const vfs = require('node:vfs');
          *
-         * const realVfs = vfs.create(new vfs.RealFSProvider('/tmp/sandbox'));
-         * realVfs.writeFileSync('/file.txt', 'hello'); // writes /tmp/sandbox/file.txt
+         * const realVfs = vfs.create(new vfs.RealFSProvider('/tmp/vfs-root'));
+         * realVfs.writeFileSync('/file.txt', 'hello'); // writes /tmp/vfs-root/file.txt
          * ```
          * @since v26.4.0
          * @param rootPath The absolute file-system path to use as the root.

package/node_modules/@types/node/web-globals/streams.d.ts

@@ -19,6 +19,8 @@ type _ReadableStreamDefaultController<R = any> = typeof globalThis extends { onm
     : webstreams.ReadableStreamDefaultController<R>;
 type _ReadableStreamDefaultReader<R = any> = typeof globalThis extends { onmessage: any } ? {}
     : webstreams.ReadableStreamDefaultReader<R>;
+type _ReadableWritablePair<R = any, W = any> = typeof globalThis extends { onmessage: any } ? {}
+    : webstreams.ReadableWritablePair<R, W>;
 type _TextDecoderStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.TextDecoderStream;
 type _TextEncoderStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.TextEncoderStream;
 type _TransformStream<I = any, O = any> = typeof globalThis extends { onmessage: any } ? {}
@@ -82,6 +84,8 @@ declare global {
         ? T
         : typeof webstreams.ReadableStreamDefaultReader;
 
+    interface ReadableWritablePair<R = any, W = any> extends _ReadableWritablePair<R, W> {}
+
     interface TextDecoderStream extends _TextDecoderStream {}
     var TextDecoderStream: typeof globalThis extends { onmessage: any; TextDecoderStream: infer T } ? T
         : typeof webstreams.TextDecoderStream;

package/node_modules/@types/node/zlib.d.ts

@@ -32,6 +32,13 @@ declare module "node:zlib" {
          * @default buffer.kMaxLength
          */
         maxOutputLength?: number | undefined;
+        /**
+         * If `true`, decompression fails when
+         * trailing input is detected after the end of the compressed stream. This
+         * includes unreadable bytes and, when decompressing gzip, additional gzip
+         * members following the first member. **Default:** `false`
+         */
+        rejectGarbageAfterEnd?: boolean | undefined;
     }
     interface BrotliOptions {
         /**
@@ -63,6 +70,11 @@ declare module "node:zlib" {
          * If `true`, returns an object with `buffer` and `engine`.
          */
         info?: boolean | undefined;
+        /**
+         * If `true`, decompression fails when
+         * input remains after the first complete compressed stream. **Default:** `false`
+         */
+        rejectGarbageAfterEnd?: boolean | undefined;
     }
     interface ZstdOptions {
         /**
@@ -98,6 +110,11 @@ declare module "node:zlib" {
          * @since v24.6.0
          */
         dictionary?: NodeJS.ArrayBufferView | undefined;
+        /**
+         * If `true`, decompression fails when
+         * input remains after the first complete compressed stream. **Default:** `false`
+         */
+        rejectGarbageAfterEnd?: boolean | undefined;
     }
     interface Zlib {
         readonly bytesWritten: number;

package/node_modules/hono/dist/cjs/client/client.js

@@ -157,24 +157,24 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   const path = parts.join("/");
   const url = (0, import_utils.mergePath)(baseUrl, path);
   if (method === "url" || method === "path") {
-    let result = url;
+    let result = (0, import_utils.removeIndexString)(url);
     if (opts.args[0]) {
       if (opts.args[0].param) {
-        result = (0, import_utils.replaceUrlParam)(url, opts.args[0].param);
+        result = (0, import_utils.replaceUrlParam)(result, opts.args[0].param);
       }
       if (opts.args[0].query) {
         result = appendQueryParams(result, buildSearchParamsOption(opts.args[0].query));
       }
     }
-    result = (0, import_utils.removeIndexString)(result);
     if (method === "url") {
       return new URL(result);
     }
     return result.slice(baseUrl.replace(/\/+$/, "").length).replace(/^\/?/, "/");
   }
   if (method === "ws") {
+    const normalizedUrl = (0, import_utils.removeIndexString)(url);
     const webSocketUrl = (0, import_utils.replaceUrlProtocol)(
-      opts.args[0]?.param ? (0, import_utils.replaceUrlParam)(url, opts.args[0].param) : url,
+      opts.args[0]?.param ? (0, import_utils.replaceUrlParam)(normalizedUrl, opts.args[0].param) : normalizedUrl,
       "ws"
     );
     const targetUrl = new URL(webSocketUrl);

package/node_modules/hono/dist/cjs/hono-base.js

@@ -61,13 +61,14 @@ class Hono {
     const allMethods = [...import_router.METHODS, import_router.METHOD_NAME_ALL_LOWERCASE];
     allMethods.forEach((method) => {
       this[method] = (args1, ...args) => {
+        const methodName = method.toUpperCase();
         if (typeof args1 === "string") {
           this.#path = args1;
         } else {
-          this.#addRoute(method, this.#path, args1);
+          this.#addRoute(methodName, this.#path, args1);
         }
         args.forEach((handler) => {
-          this.#addRoute(method, this.#path, handler);
+          this.#addRoute(methodName, this.#path, handler);
         });
         return this;
       };
@@ -76,9 +77,10 @@ class Hono {
       for (const p of [path].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
-          handlers.map((handler) => {
-            this.#addRoute(m.toUpperCase(), this.#path, handler);
-          });
+          const methodName = m.toUpperCase();
+          for (const handler of handlers) {
+            this.#addRoute(methodName, this.#path, handler);
+          }
         }
       }
       return this;
@@ -279,7 +281,6 @@ class Hono {
     return this;
   }
   #addRoute(method, path, handler, baseRoutePath) {
-    method = method.toUpperCase();
     path = (0, import_url.mergePath)(this._basePath, path);
     const r = {
       basePath: baseRoutePath !== void 0 ? (0, import_url.mergePath)(this._basePath, baseRoutePath) : this._basePath,

package/node_modules/hono/dist/cjs/jsx/base.js

@@ -33,11 +33,14 @@ __export(base_exports, {
   booleanAttributes: () => booleanAttributes,
   cloneElement: () => cloneElement,
   getNameSpaceContext: () => getNameSpaceContext,
+  isUntrustedObject: () => isUntrustedObject,
   isValidElement: () => isValidElement,
   jsx: () => jsx,
   jsxFn: () => jsxFn,
   memo: () => memo,
   reactAPICompatVersion: () => reactAPICompatVersion,
+  renderChildren: () => renderChildren,
+  renderUntrustedObject: () => renderUntrustedObject,
   shallowEqual: () => shallowEqual
 });
 module.exports = __toCommonJS(base_exports);
@@ -101,7 +104,7 @@ const booleanAttributes = [
   "selected"
 ];
 const resolveFunctionComponentResult = (result, suspendedContext) => result.then((resolved) => {
-  if (!Array.isArray(resolved) && !(resolved instanceof JSXNode)) {
+  if (typeof resolved !== "string" && !Array.isArray(resolved) && !(resolved instanceof JSXNode)) {
     return resolved;
   }
   const children = Array.isArray(resolved) ? resolved : [resolved];
@@ -139,6 +142,17 @@ const childrenToStringToBuffer = (children, buffer) => {
     }
   }
 };
+const renderChildren = (children) => (0, import_context.runWithRenderContext)(() => {
+  const buffer = [""];
+  childrenToStringToBuffer(children, buffer);
+  return buffer.length === 1 ? (0, import_html.raw)(buffer[0], buffer.callbacks) : (0, import_html2.stringBufferToString)(buffer, buffer.callbacks);
+});
+const isUntrustedObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof JSXNode) && !(value instanceof Promise) && !value.isEscaped && typeof value.toString === "function";
+const renderUntrustedObject = (value) => {
+  const stringified = value.toString();
+  const escape = (result) => renderChildren([String(result)]);
+  return stringified instanceof Promise ? stringified.then(escape) : escape(stringified);
+};
 class JSXNode {
   tag;
   props;
@@ -369,10 +383,13 @@ const reactAPICompatVersion = "19.0.0-hono-jsx";
   booleanAttributes,
   cloneElement,
   getNameSpaceContext,
+  isUntrustedObject,
   isValidElement,
   jsx,
   jsxFn,
   memo,
   reactAPICompatVersion,
+  renderChildren,
+  renderUntrustedObject,
   shallowEqual
 });

package/node_modules/hono/dist/cjs/jsx/components.js

@@ -31,7 +31,7 @@ var import_streaming = require("./streaming");
 let errorBoundaryCounter = 0;
 const childrenToString = async (children) => {
   try {
-    return children.flat().map((c) => c == null || typeof c === "boolean" ? "" : c.toString());
+    return children.flat().map(resolveChildEarly);
   } catch (e) {
     if (e instanceof Promise) {
       const resume = (0, import_context.captureRenderContext)();
@@ -42,18 +42,16 @@ const childrenToString = async (children) => {
     }
   }
 };
-const resolveChildEarly = (c) => {
-  if (c == null || typeof c === "boolean") {
+const resolveChildEarly = (child) => {
+  if (child == null || typeof child === "boolean") {
     return "";
-  } else if (typeof c === "string") {
-    return c;
+  } else if (typeof child === "string" || Array.isArray(child)) {
+    return (0, import_base.renderChildren)([child]);
+  } else if ((0, import_base.isUntrustedObject)(child)) {
+    return (0, import_base.renderUntrustedObject)(child);
   } else {
-    const str = c.toString();
-    if (!(str instanceof Promise)) {
-      return (0, import_html.raw)(str);
-    } else {
-      return str;
-    }
+    const str = child.toString();
+    return str instanceof Promise ? str : (0, import_html.raw)(str);
   }
 };
 const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
@@ -69,26 +67,27 @@ const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) =>
   let fallbackStrPromise;
   const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
     const awaitedFallback = await fallback;
-    if (typeof awaitedFallback === "string") {
-      return awaitedFallback;
-    } else {
-      const fallbackResult = await getResume()(() => awaitedFallback?.toString());
-      if (typeof fallbackResult === "string") {
-        return (0, import_html.raw)(
-          fallbackResult,
-          fallbackResult.callbacks || awaitedFallback?.callbacks
-        );
-      }
+    if (awaitedFallback === null || awaitedFallback === void 0) {
+      return;
+    }
+    if (typeof awaitedFallback === "string" || Array.isArray(awaitedFallback)) {
+      return getResume()(() => (0, import_base.renderChildren)([awaitedFallback]));
+    }
+    if ((0, import_base.isUntrustedObject)(awaitedFallback)) {
+      return getResume()(() => (0, import_base.renderUntrustedObject)(awaitedFallback));
     }
+    const fallbackResult = await getResume()(() => awaitedFallback.toString());
+    return (0, import_html.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 && (0, import_base.jsx)(import_base.Fragment, {}, fallbackRender(error)) || "";
-      const fallbackResString = await (0, import_base.Fragment)({
-        children: fallbackRes
-      }).toString();
+      const fallbackResString = await (0, import_base.Fragment)({ children: fallbackRes }).toString();
       return (0, import_html.raw)(
         fallbackResString,
         fallbackResString.callbacks || fallbackRes.callbacks
@@ -121,7 +120,7 @@ const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) =>
       const fallbackResString = await renderFallback(error2);
       const fallbackCallbacks = fallbackResString.callbacks;
       if (buffer) {
-        buffer[0] = buffer[0].replace(replaceRe, fallbackResString);
+        buffer[0] = buffer[0].replace(replaceRe, () => fallbackResString);
         return fallbackCallbacks?.length ? (0, import_html.raw)("", fallbackCallbacks) : "";
       }
       return (0, import_html.raw)(
@@ -160,7 +159,7 @@ d.parentElement.insertBefore(c.content,d.nextSibling)
 </script>`;
           if (htmlArray.every((html2) => !html2.callbacks?.length)) {
             if (buffer) {
-              buffer[0] = buffer[0].replace(replaceRe, content);
+              buffer[0] = buffer[0].replace(replaceRe, () => content);
             }
             return html;
           }

package/node_modules/hono/dist/cjs/jsx/context.js

@@ -155,18 +155,18 @@ const createContext = (defaultValue) => {
   const context = ((props) => {
     const contextValues = getContextValuesIn(getCurrentStore(), context);
     contextValues.push(props.value);
-    let string;
+    let rendered;
     try {
-      string = props.children ? (Array.isArray(props.children) ? new import_base.JSXFragmentNode("", {}, props.children) : props.children).toString() : "";
+      rendered = typeof props.children === "string" ? (0, import_base.renderChildren)([props.children]) : (0, import_base.isUntrustedObject)(props.children) ? (0, import_base.renderUntrustedObject)(props.children) : props.children ? (Array.isArray(props.children) ? new import_base.JSXFragmentNode("", {}, props.children) : props.children).toString() : (0, import_html.raw)("");
     } catch (e) {
       contextValues.pop();
       throw e;
     }
-    if (string instanceof Promise) {
-      return string.finally(() => contextValues.pop()).then((resString) => (0, import_html.raw)(resString, resString.callbacks));
+    if (rendered instanceof Promise) {
+      return rendered.finally(() => contextValues.pop()).then((resString) => (0, import_html.raw)(resString, resString.callbacks));
     } else {
       contextValues.pop();
-      return (0, import_html.raw)(string);
+      return (0, import_html.raw)(rendered);
     }
   });
   context.values = values;

package/node_modules/hono/dist/cjs/jsx/dom/server.js

@@ -33,13 +33,16 @@ __export(server_exports, {
   version: () => import__.default
 });
 module.exports = __toCommonJS(server_exports);
+var import_base = require("../base");
 var import_streaming = require("../streaming");
 var import__ = __toESM(require("./"), 1);
+const prepareRoot = (element) => typeof element === "string" || Array.isArray(element) ? (0, import_base.renderChildren)([element]) : element;
 const renderToString = (element, options = {}) => {
   if (Object.keys(options).length > 0) {
     console.warn("options are not supported yet");
   }
-  const res = element?.toString() ?? "";
+  element = prepareRoot(element);
+  const res = element instanceof Promise ? element : element?.toString() ?? "";
   if (typeof res !== "string") {
     throw new Error("Async component is not supported in renderToString");
   }
@@ -49,6 +52,7 @@ const renderToReadableStream = async (element, options = {}) => {
   if (Object.keys(options).some((key) => key !== "onError")) {
     console.warn("options are not supported yet, except onError");
   }
+  element = prepareRoot(element);
   if (!element || typeof element !== "object") {
     element = element?.toString() ?? "";
   }

package/node_modules/hono/dist/cjs/jsx/intrinsic-element/components.js

@@ -85,10 +85,10 @@ const insertIntoHead = (tagName, tag, props, precedence) => ({ buffer, context }
     insertTags.forEach((tag2) => {
       buffer[0] = buffer[0].replaceAll(tag2, "");
     });
-    buffer[0] = buffer[0].replace(/(?=<\/head>)/, insertTags.join(""));
+    buffer[0] = buffer[0].replace(/(?=<\/head>)/, () => insertTags.join(""));
   }
 };
-const returnWithoutSpecialBehavior = (tag, children, props) => (0, import_html.raw)(new import_base.JSXNode(tag, props, (0, import_children.toArray)(children ?? [])).toString());
+const returnWithoutSpecialBehavior = (tag, children, props) => (0, import_base.renderChildren)([new import_base.JSXNode(tag, props, (0, import_children.toArray)(children ?? []))]);
 const documentMetadataTag = (tag, children, props, sort) => {
   if ("itemProp" in props) {
     return returnWithoutSpecialBehavior(tag, children, props);