tina4-nodejs 3.13.131 → 3.13.133

package/packages/core/src/devAdmin.ts

@@ -576,9 +576,6 @@ export class DevAdmin {
       { method: "POST", pattern: "/__dev/api/websockets/disconnect", handler: handleWebsocketsDisconnect },
       // Tools
       { method: "POST", pattern: "/__dev/api/tool", handler: handleTool },
-      // Chat — proxies to Rust agent /chat (SSE passthrough). Forwards
-      // active_file and any other body keys verbatim. See proxyToSupervisor.
-      { method: "POST", pattern: "/__dev/api/chat", handler: handleChat },
       // Threads — proxies to Rust agent /threads. Mirrors Python's
       // _api_threads + _api_threads_sub.
       { method: "GET",  pattern: "/__dev/api/threads", handler: handleThreads },
@@ -658,8 +655,6 @@ export class DevAdmin {
       { method: "GET", pattern: "/__dev/api/supervise/diff", handler: handleSuperviseStub },
       { method: "POST", pattern: "/__dev/api/supervise/commit", handler: handleSuperviseStub },
       { method: "POST", pattern: "/__dev/api/supervise/cancel", handler: handleSuperviseStub },
-      // Execute — proxies to the framework_port+2000 Rust agent (SSE passthrough)
-      { method: "POST", pattern: "/__dev/api/execute", handler: handleExecute },
       // Framework-grounding MCP token config — self-contained (.env upsert)
       { method: "GET", pattern: "/__dev/api/grounding/status", handler: handleGroundingStatus },
       { method: "POST", pattern: "/__dev/api/grounding/token", handler: handleGroundingToken },
@@ -1638,16 +1633,6 @@ async function proxyToSupervisor(
   }
 }
 
-// -- Chat handler --
-//
-// Proxies POST /__dev/api/chat → Rust agent `POST /chat`. The SPA's Chat
-// view POSTs `{message, settings?, thread_id?, active_file?, files?}` and
-// expects an SSE stream of `event: status / message / done` chunks.
-// active_file (and any other body keys) are forwarded verbatim.
-const handleChat: RouteHandler = async (req, res) => {
-  await proxyToSupervisor(req, res, "/chat");
-};
-
 // -- Framework-grounding (mcp.tina4.com) token config --
 //
 // TINA4_MCP_TOKEN grounds the coder against mcp.tina4.com's tina4_context.
@@ -2138,37 +2123,6 @@ const handleSuperviseStub: RouteHandler = (_req, res) => {
   );
 };
 
-const handleExecute: RouteHandler = async (req, res) => {
-  // Proxy to framework_port+2000 Rust agent (SSE passthrough).
-  const port = parseInt(process.env.TINA4_PORT ?? process.env.PORT ?? "7148", 10);
-  const agentUrl = `http://127.0.0.1:${port + 2000}/execute`;
-  try {
-    const upstream = await fetch(agentUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(req.body ?? {}),
-    });
-    if (!upstream.body) {
-      res.json({ error: "agent returned no body" }, 502);
-      return;
-    }
-    res.raw.writeHead(upstream.status || 200, {
-      "Content-Type": upstream.headers.get("content-type") || "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    });
-    const reader = upstream.body.getReader();
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (value) res.raw.write(Buffer.from(value));
-    }
-    res.raw.end();
-  } catch (e) {
-    res.json({ error: `agent unreachable at ${agentUrl}: ${(e as Error).message}` }, 502);
-  }
-};
-
 // --- file-browser noise filter + git decoration (mirrors PHP/Python dev-admin) ---
 const DEV_FILES_IGNORED = new Set([
   "__pycache__", "node_modules", "vendor", ".git",

package/packages/core/src/index.ts

@@ -14,7 +14,7 @@ export type {
   WebSocketRouteDefinition,
 } from "./types.js";
 
-export { startServer, resolvePortAndHost, handle, start, stop, httpReason, resolveTemplate, resetTemplateCache, templateAutoRoutingEnabled, isBannerSuppressed } from "./server.js";
+export { startServer, resolvePortAndHost, loopbackBindHosts, handle, start, stop, httpReason, resolveTemplate, resetTemplateCache, templateAutoRoutingEnabled, isBannerSuppressed } from "./server.js";
 export { background, stopAllBackgroundTasks, backgroundTaskCount } from "./background.js";
 export { Router, RouteGroup, RouteRef, WsRouteRef, defaultRouter, runRouteMiddlewares, resolveStringMiddleware, isTrailingSlashRedirectEnabled } from "./router.js";
 export { get, post, put, patch, del, any, websocket, del as delete } from "./router.js";

package/packages/core/src/server.ts

@@ -1280,7 +1280,9 @@ function injectIntoHtml(ctx: ResponseWrapContext, devToolbar: boolean, html: str
     // Suppress the live reloader on the AI/stable port (data-reload="0"); the
     // toolbar JS early-returns when data-reload !== "1". Mirrors PHP's
     // suppressReload flag.
-    reload: !ctx.isAiPortRequest,
+    // Also suppress on the dev-admin dashboard (any /__dev page): its SPA reloads
+    // itself gently, so the toolbar's full-page reloader must not fire there.
+    reload: !ctx.isAiPortRequest && !ctx.pathname.startsWith("/__dev"),
   };
   return injectFeedbackWidget(ctx.req, injectDevToolbar(html, toolbarCtx));
 }
@@ -1847,6 +1849,98 @@ export async function runDispatch(
   return Log.runWithRequestId(requestId, () => dispatchInner(ctx, rawReq, rawRes, requestId));
 }
 
+/**
+ * Sibling loopback addresses to ALSO listen on, so `localhost` reaches this
+ * server whether the OS resolves it to IPv4 (127.0.0.1) or IPv6 (::1).
+ *
+ * `localhost` resolves to `::1` (IPv6) FIRST on Windows, so a server bound only
+ * to `127.0.0.1` — or `0.0.0.0`, the IPv4 wildcard, which does NOT cover IPv6 —
+ * refuses the browser with ERR_CONNECTION_REFUSED even though it is serving,
+ * because nothing listens on `::1`. Binding the sibling family closes that gap.
+ *
+ * Returns only the families a direct bind of `host` does not already cover, as
+ * UNBRACKETED addresses (Node's net/http take a bare "::1"). A host that is
+ * neither loopback nor a wildcard yields an empty list — an explicit LAN
+ * address is bound exactly as asked. Mirrors PHP `Server::loopbackBindHosts`.
+ */
+export function loopbackBindHosts(host: string): string[] {
+  const normalized = host.trim().replace(/^\[|\]$/g, "").toLowerCase();
+  switch (normalized) {
+    case "localhost":
+      return ["127.0.0.1", "::1"];
+    case "127.0.0.1":
+    case "0.0.0.0":
+      return ["::1"];
+    case "::1":
+    case "::":
+      return ["127.0.0.1"];
+    default:
+      return [];
+  }
+}
+
+/**
+ * Best-effort extra listeners on the SAME port for the sibling loopback family
+ * (see loopbackBindHosts), each REUSING the primary `dispatch` handler so a
+ * request on `::1` is served identically to one on `127.0.0.1`.
+ *
+ * CRITICAL Node gotcha: a listen failure is an ASYNCHRONOUS `'error'` EVENT,
+ * never a thrown exception, so every sibling attaches an `'error'` handler
+ * BEFORE it can fire. A sibling is pure convenience — the primary is the source
+ * of truth — so ANY bind error is swallowed and that sibling skipped:
+ * EADDRINUSE (the family the primary already answers, e.g. the `localhost`
+ * case), EADDRNOTAVAIL / EAFNOSUPPORT (no IPv6 loopback here) are the expected
+ * ones and stay silent; anything else is logged at debug. It never rejects,
+ * never bubbles to `uncaughtException`, and never fails the primary startup.
+ * The handler stays attached for the life of the socket, so a late error on a
+ * kept sibling is swallowed too and cannot crash the process.
+ *
+ * Resolves to the siblings that actually reached `'listening'`, so the shutdown
+ * path closes exactly those.
+ */
+function startLoopbackSiblings(
+  port: number,
+  host: string,
+  dispatch: (req: IncomingMessage, res: ServerResponse) => Promise<void>,
+): Promise<ReturnType<typeof createServer>[]> {
+  const siblingHosts = loopbackBindHosts(host);
+  if (siblingHosts.length === 0) return Promise.resolve([]);
+
+  return Promise.all(
+    siblingHosts.map(
+      (siblingHost) =>
+        new Promise<ReturnType<typeof createServer> | null>((resolveSibling) => {
+          const sibling = createServer(dispatch);
+          let settled = false;
+          sibling.on("error", (err: NodeJS.ErrnoException) => {
+            const expected =
+              err.code === "EADDRINUSE" ||
+              err.code === "EADDRNOTAVAIL" ||
+              err.code === "EAFNOSUPPORT";
+            if (!expected) {
+              Log.debug(
+                `Loopback sibling ${siblingHost}:${port} not bound ` +
+                  `(${err.code ?? err.message}) — skipped, primary already serves`,
+              );
+            }
+            if (!settled) {
+              settled = true;
+              resolveSibling(null);
+            }
+            // Already kept/settled: swallow so a late error never reaches
+            // uncaughtException and never disturbs the primary listener.
+          });
+          sibling.listen(port, siblingHost, () => {
+            settled = true;
+            resolveSibling(sibling);
+          });
+        }),
+    ),
+  ).then((results) =>
+    results.filter((s): s is ReturnType<typeof createServer> => s !== null),
+  );
+}
+
 export async function startServer(config?: Tina4Config): Promise<{
   close: () => void;
   router: Router;
@@ -2269,11 +2363,21 @@ ${reset}
   });
 
   return new Promise((resolvePromise) => {
-    server.listen(port, host, () => {
+    server.listen(port, host, async () => {
       // Record THIS process as the Tina4 dev server on this port, so a later
       // `tina4 serve` can identify it as reclaimable (TAKEOVER-DEC-01). Only the
       // single dev process needs it; takeover is dev-gated off in cluster/prod.
       if (!cluster.isWorker) writePidfile(port);
+
+      // Dual-stack loopback: ALSO listen on the sibling loopback family on the
+      // SAME port, so `localhost` is reachable whether the OS resolves it to
+      // IPv4 or IPv6 (the Windows `localhost` -> `::1` gap). Best-effort and
+      // async-error-guarded — a sibling that cannot bind is skipped and never
+      // fails the primary startup (see startLoopbackSiblings). Parity with PHP
+      // PR #206 / Python / Ruby. Awaited so it is settled before the caller's
+      // promise resolves (a client can then rely on both families being up).
+      const siblingServers = await startLoopbackSiblings(port, host, dispatch);
+
       const displayHost = host === "0.0.0.0" ? "localhost" : host;
       const isDebug = isTruthy(process.env.TINA4_DEBUG);
       const logLevel = (process.env.TINA4_LOG_LEVEL ?? "DEBUG").toUpperCase();
@@ -2400,18 +2504,30 @@ ${reset}
 
       const closeListeners = (): Promise<void> =>
         new Promise((done) => {
-          let pending = aiServer ? 2 : 1;
+          let pending = 1 + (aiServer ? 1 : 0) + siblingServers.length;
           const one = (): void => {
             if (--pending === 0) done();
           };
           server.close(one);
           if (aiServer) aiServer.close(one);
+          // Sibling loopback listeners share this port and are drained too. Each
+          // reached 'listening' (startLoopbackSiblings filters), so close(one)
+          // fires its callback; a throw only if it is already gone, in which
+          // case count it as closed so the counter still settles.
+          for (const sibling of siblingServers) {
+            try {
+              sibling.close(one);
+            } catch {
+              one();
+            }
+          }
           // A keep-alive socket with no request on it still counts as an open
           // connection, so close() would sit on it until the client wandered
           // off. Without this a fully drained server still burns the whole
           // shutdown budget.
           server.closeIdleConnections();
           aiServer?.closeIdleConnections();
+          for (const sibling of siblingServers) sibling.closeIdleConnections();
         });
 
       const gracefulShutdown = async (signal: string): Promise<void> => {
@@ -2458,6 +2574,7 @@ ${reset}
           );
           server.closeAllConnections();
           aiServer?.closeAllConnections();
+          for (const sibling of siblingServers) sibling.closeAllConnections();
         }
 
         try {
@@ -2506,6 +2623,15 @@ ${reset}
           stopAllBackgroundTasks();
           if (aiServer) aiServer.close();
           server.close();
+          // Sibling loopback listeners share the port — close them alongside the
+          // primary (guarded: a sibling already gone must not throw out of close()).
+          for (const sibling of siblingServers) {
+            try {
+              sibling.close();
+            } catch {
+              /* already not running */
+            }
+          }
           // Close database if ORM was initialized
           import("../../orm/src/index.js").then((orm) => orm.closeDatabase()).catch(() => {});
         },

package/packages/frond/dist/index.js

@@ -2588,33 +2588,17 @@ var Frond = class _Frond {
       i++;
     }
   }
-  handleCache(tokens, start, context) {
-    const [content] = stripTag(tokens[start][1]);
-    const m = content.match(/^cache\s+["'](.+?)["']\s*(\d+)?/);
-    const cacheKey = m ? m[1] : "default";
-    const ttl = m && m[2] ? parseInt(m[2], 10) : 60;
-    sweepExpiredCache(this.fragmentCache);
-    const cached = this.fragmentCache.get(cacheKey);
-    if (cached) {
-      const [htmlContent, expiresAt] = cached;
-      if (Date.now() < expiresAt) {
-        let i2 = start + 1;
-        let depth2 = 0;
-        while (i2 < tokens.length) {
-          if (tokens[i2][0] === "BLOCK") {
-            const [tagContent] = stripTag(tokens[i2][1]);
-            const tag = tagContent.split(/\s+/)[0] || "";
-            if (tag === "cache") depth2++;
-            else if (tag === "endcache") {
-              if (depth2 === 0) return [htmlContent, i2 + 1];
-              depth2--;
-            }
-          }
-          i2++;
-        }
-        return [htmlContent, i2];
-      }
-    }
+  /**
+   * Collect the body tokens of a {% <openTag> %}...{% end<openTag> %} block,
+   * starting from the token after the opening tag (start + 1). Nested same-tag
+   * blocks are kept in the body and balanced by depth; the matching closing tag is
+   * consumed but NOT included. Returns [bodyTokens, indexAfterClosingTag].
+   *
+   * canNest guards the open-tag count: handleSetBlock passes it so the inline
+   * {% set x = 1 %} form (which has no {% endset %}) never opens a nested block —
+   * only the block form {% set x %} nests. Omitted, every openTag occurrence nests.
+   */
+  collectBlockBody(tokens, start, openTag, closeTag, canNest) {
     const bodyTokens = [];
     let i = start + 1;
     let depth = 0;
@@ -2622,10 +2606,10 @@ var Frond = class _Frond {
       if (tokens[i][0] === "BLOCK") {
         const [tagContent] = stripTag(tokens[i][1]);
         const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "cache") {
+        if (tag === openTag && (canNest ? canNest(tagContent) : true)) {
           depth++;
           bodyTokens.push(tokens[i]);
-        } else if (tag === "endcache") {
+        } else if (tag === closeTag) {
           if (depth === 0) {
             i++;
             break;
@@ -2640,6 +2624,36 @@ var Frond = class _Frond {
       }
       i++;
     }
+    return [bodyTokens, i];
+  }
+  handleCache(tokens, start, context) {
+    const [content] = stripTag(tokens[start][1]);
+    const m = content.match(/^cache\s+["'](.+?)["']\s*(\d+)?/);
+    const cacheKey = m ? m[1] : "default";
+    const ttl = m && m[2] ? parseInt(m[2], 10) : 60;
+    sweepExpiredCache(this.fragmentCache);
+    const cached = this.fragmentCache.get(cacheKey);
+    if (cached) {
+      const [htmlContent, expiresAt] = cached;
+      if (Date.now() < expiresAt) {
+        let i2 = start + 1;
+        let depth = 0;
+        while (i2 < tokens.length) {
+          if (tokens[i2][0] === "BLOCK") {
+            const [tagContent] = stripTag(tokens[i2][1]);
+            const tag = tagContent.split(/\s+/)[0] || "";
+            if (tag === "cache") depth++;
+            else if (tag === "endcache") {
+              if (depth === 0) return [htmlContent, i2 + 1];
+              depth--;
+            }
+          }
+          i2++;
+        }
+        return [htmlContent, i2];
+      }
+    }
+    const [bodyTokens, i] = this.collectBlockBody(tokens, start, "cache", "endcache");
     const rendered = this.renderTokens([...bodyTokens], context);
     capCache(this.fragmentCache, TEMPLATE_CACHE_MAX);
     this.fragmentCache.set(cacheKey, [rendered, Date.now() + ttl * 1e3]);
@@ -2804,62 +2818,20 @@ var Frond = class _Frond {
   handleSetBlock(tokens, start, context) {
     const [content] = stripTag(tokens[start][1]);
     const name = (content.split(/\s+/)[1] || "").trim();
-    const bodyTokens = [];
-    let i = start + 1;
-    let depth = 0;
-    while (i < tokens.length) {
-      if (tokens[i][0] === "BLOCK") {
-        const [tagContent] = stripTag(tokens[i][1]);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "set" && !tagContent.includes("=")) {
-          depth++;
-          bodyTokens.push(tokens[i]);
-        } else if (tag === "endset") {
-          if (depth === 0) {
-            i++;
-            break;
-          }
-          depth--;
-          bodyTokens.push(tokens[i]);
-        } else {
-          bodyTokens.push(tokens[i]);
-        }
-      } else {
-        bodyTokens.push(tokens[i]);
-      }
-      i++;
-    }
+    const [bodyTokens, i] = this.collectBlockBody(
+      tokens,
+      start,
+      "set",
+      "endset",
+      (tagContent) => !tagContent.includes("=")
+    );
     if (name) {
       context[name] = new SafeString(this.renderTokens([...bodyTokens], context));
     }
     return i;
   }
   handleSpaceless(tokens, start, context) {
-    const bodyTokens = [];
-    let i = start + 1;
-    let depth = 0;
-    while (i < tokens.length) {
-      if (tokens[i][0] === "BLOCK") {
-        const [tagContent] = stripTag(tokens[i][1]);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "spaceless") {
-          depth++;
-          bodyTokens.push(tokens[i]);
-        } else if (tag === "endspaceless") {
-          if (depth === 0) {
-            i++;
-            break;
-          }
-          depth--;
-          bodyTokens.push(tokens[i]);
-        } else {
-          bodyTokens.push(tokens[i]);
-        }
-      } else {
-        bodyTokens.push(tokens[i]);
-      }
-      i++;
-    }
+    const [bodyTokens, i] = this.collectBlockBody(tokens, start, "spaceless", "endspaceless");
     let rendered = this.renderTokens([...bodyTokens], context);
     rendered = rendered.replace(/>\s+</g, "><");
     return [rendered, i];
@@ -2868,31 +2840,7 @@ var Frond = class _Frond {
     const [content] = stripTag(tokens[start][1]);
     const modeMatch = content.match(/^autoescape\s+(false|true)/);
     const autoEscapeOn = !(modeMatch && modeMatch[1] === "false");
-    const bodyTokens = [];
-    let i = start + 1;
-    let depth = 0;
-    while (i < tokens.length) {
-      if (tokens[i][0] === "BLOCK") {
-        const [tagContent] = stripTag(tokens[i][1]);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "autoescape") {
-          depth++;
-          bodyTokens.push(tokens[i]);
-        } else if (tag === "endautoescape") {
-          if (depth === 0) {
-            i++;
-            break;
-          }
-          depth--;
-          bodyTokens.push(tokens[i]);
-        } else {
-          bodyTokens.push(tokens[i]);
-        }
-      } else {
-        bodyTokens.push(tokens[i]);
-      }
-      i++;
-    }
+    const [bodyTokens, i] = this.collectBlockBody(tokens, start, "autoescape", "endautoescape");
     if (!autoEscapeOn) {
       const oldAutoEscape = this._autoEscape;
       this._autoEscape = false;

package/packages/frond/src/engine.ts

@@ -3175,6 +3175,51 @@ export class Frond {
     }
   }
 
+  /**
+   * Collect the body tokens of a {% <openTag> %}...{% end<openTag> %} block,
+   * starting from the token after the opening tag (start + 1). Nested same-tag
+   * blocks are kept in the body and balanced by depth; the matching closing tag is
+   * consumed but NOT included. Returns [bodyTokens, indexAfterClosingTag].
+   *
+   * canNest guards the open-tag count: handleSetBlock passes it so the inline
+   * {% set x = 1 %} form (which has no {% endset %}) never opens a nested block —
+   * only the block form {% set x %} nests. Omitted, every openTag occurrence nests.
+   */
+  private collectBlockBody(
+    tokens: Token[],
+    start: number,
+    openTag: string,
+    closeTag: string,
+    canNest?: (tagContent: string) => boolean,
+  ): [Token[], number] {
+    const bodyTokens: Token[] = [];
+    let i = start + 1;
+    let depth = 0;
+    while (i < tokens.length) {
+      if (tokens[i][0] === "BLOCK") {
+        const [tagContent] = stripTag(tokens[i][1]);
+        const tag = tagContent.split(/\s+/)[0] || "";
+        if (tag === openTag && (canNest ? canNest(tagContent) : true)) {
+          depth++;
+          bodyTokens.push(tokens[i]);
+        } else if (tag === closeTag) {
+          if (depth === 0) {
+            i++;
+            break;
+          }
+          depth--;
+          bodyTokens.push(tokens[i]);
+        } else {
+          bodyTokens.push(tokens[i]);
+        }
+      } else {
+        bodyTokens.push(tokens[i]);
+      }
+      i++;
+    }
+    return [bodyTokens, i];
+  }
+
   private handleCache(tokens: Token[], start: number, context: Record<string, unknown>): [string, number] {
     const [content] = stripTag(tokens[start][1]);
     const m = content.match(/^cache\s+["'](.+?)["']\s*(\d+)?/);
@@ -3208,31 +3253,7 @@ export class Frond {
     }
 
     // Collect body tokens
-    const bodyTokens: Token[] = [];
-    let i = start + 1;
-    let depth = 0;
-    while (i < tokens.length) {
-      if (tokens[i][0] === "BLOCK") {
-        const [tagContent] = stripTag(tokens[i][1]);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "cache") {
-          depth++;
-          bodyTokens.push(tokens[i]);
-        } else if (tag === "endcache") {
-          if (depth === 0) {
-            i++;
-            break;
-          }
-          depth--;
-          bodyTokens.push(tokens[i]);
-        } else {
-          bodyTokens.push(tokens[i]);
-        }
-      } else {
-        bodyTokens.push(tokens[i]);
-      }
-      i++;
-    }
+    const [bodyTokens, i] = this.collectBlockBody(tokens, start, "cache", "endcache");
 
     // Render and cache
     const rendered = this.renderTokens([...bodyTokens], context);
@@ -3422,31 +3443,10 @@ export class Frond {
     const [content] = stripTag(tokens[start][1]);
     const name = (content.split(/\s+/)[1] || "").trim();
 
-    const bodyTokens: Token[] = [];
-    let i = start + 1;
-    let depth = 0;
-    while (i < tokens.length) {
-      if (tokens[i][0] === "BLOCK") {
-        const [tagContent] = stripTag(tokens[i][1]);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "set" && !tagContent.includes("=")) {
-          depth++;
-          bodyTokens.push(tokens[i]);
-        } else if (tag === "endset") {
-          if (depth === 0) {
-            i++;
-            break;
-          }
-          depth--;
-          bodyTokens.push(tokens[i]);
-        } else {
-          bodyTokens.push(tokens[i]);
-        }
-      } else {
-        bodyTokens.push(tokens[i]);
-      }
-      i++;
-    }
+    const [bodyTokens, i] = this.collectBlockBody(
+      tokens, start, "set", "endset",
+      (tagContent) => !tagContent.includes("="),
+    );
 
     if (name) {
       context[name] = new SafeString(this.renderTokens([...bodyTokens], context));
@@ -3455,31 +3455,7 @@ export class Frond {
   }
 
   private handleSpaceless(tokens: Token[], start: number, context: Record<string, unknown>): [string, number] {
-    const bodyTokens: Token[] = [];
-    let i = start + 1;
-    let depth = 0;
-    while (i < tokens.length) {
-      if (tokens[i][0] === "BLOCK") {
-        const [tagContent] = stripTag(tokens[i][1]);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "spaceless") {
-          depth++;
-          bodyTokens.push(tokens[i]);
-        } else if (tag === "endspaceless") {
-          if (depth === 0) {
-            i++;
-            break;
-          }
-          depth--;
-          bodyTokens.push(tokens[i]);
-        } else {
-          bodyTokens.push(tokens[i]);
-        }
-      } else {
-        bodyTokens.push(tokens[i]);
-      }
-      i++;
-    }
+    const [bodyTokens, i] = this.collectBlockBody(tokens, start, "spaceless", "endspaceless");
 
     let rendered = this.renderTokens([...bodyTokens], context);
     rendered = rendered.replace(/>\s+</g, "><");
@@ -3491,31 +3467,7 @@ export class Frond {
     const modeMatch = content.match(/^autoescape\s+(false|true)/);
     const autoEscapeOn = !(modeMatch && modeMatch[1] === "false");
 
-    const bodyTokens: Token[] = [];
-    let i = start + 1;
-    let depth = 0;
-    while (i < tokens.length) {
-      if (tokens[i][0] === "BLOCK") {
-        const [tagContent] = stripTag(tokens[i][1]);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "autoescape") {
-          depth++;
-          bodyTokens.push(tokens[i]);
-        } else if (tag === "endautoescape") {
-          if (depth === 0) {
-            i++;
-            break;
-          }
-          depth--;
-          bodyTokens.push(tokens[i]);
-        } else {
-          bodyTokens.push(tokens[i]);
-        }
-      } else {
-        bodyTokens.push(tokens[i]);
-      }
-      i++;
-    }
+    const [bodyTokens, i] = this.collectBlockBody(tokens, start, "autoescape", "endautoescape");
 
     if (!autoEscapeOn) {
       const oldAutoEscape = this._autoEscape;