tina4-nodejs 3.13.133 → 3.13.134

package/packages/frond/src/engine.ts

@@ -88,6 +88,7 @@ const BLOCK_TAG_ENDS: Record<string, string> = {
   spaceless: "endspaceless",
 };
 
+
 /**
  * Serialize a value to compact JSON text that is always valid JSON.
  *
@@ -166,83 +167,56 @@ function jsonSafe(value: unknown): SafeString {
  * Output is a plain string; callers wrap it in <pre> and mark it safe so
  * the template engine doesn't double-escape.
  */
+function inspectPrimitive(value: unknown): { handled: boolean; output: string } {
+  if (value === null) return { handled: true, output: "null" };
+  if (value === undefined) return { handled: true, output: "undefined" };
+  if (typeof value === "string") return { handled: true, output: JSON.stringify(value) };
+  if (typeof value === "number" || typeof value === "boolean") return { handled: true, output: String(value) };
+  if (typeof value === "bigint") return { handled: true, output: `${value.toString()}n` };
+  if (typeof value === "symbol") return { handled: true, output: value.toString() };
+  if (typeof value === "function") return { handled: true, output: `[Function: ${value.name || "(anonymous)"}]` };
+  return { handled: false, output: "" };
+}
+
+function inspectCollection(obj: object, seen: WeakSet<object>, depth: number): string | null {
+  if (obj instanceof Map) {
+    if (obj.size === 0) return "Map(0) {}";
+    const entries = [...obj].map(([key, value]) => `${inspectValue(key, seen, depth + 1)} => ${inspectValue(value, seen, depth + 1)}`);
+    return `Map(${obj.size}) { ${entries.join(", ")} }`;
+  }
+  if (obj instanceof Set) {
+    if (obj.size === 0) return "Set(0) {}";
+    return `Set(${obj.size}) { ${[...obj].map((value) => inspectValue(value, seen, depth + 1)).join(", ")} }`;
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    return `[${obj.map((value) => inspectValue(value, seen, depth + 1)).join(", ")}]`;
+  }
+  return null;
+}
+
+function inspectObject(obj: object, seen: WeakSet<object>, depth: number): string {
+  if (obj instanceof Date) return `Date(${obj.toISOString()})`;
+  if (obj instanceof RegExp) return obj.toString();
+  if (obj instanceof Error) return `${obj.constructor.name}(${JSON.stringify(obj.message)})`;
+  const collection = inspectCollection(obj, seen, depth);
+  if (collection !== null) return collection;
+  const keys = Object.keys(obj);
+  const className = obj.constructor && obj.constructor.name !== "Object" ? `${obj.constructor.name} ` : "";
+  if (keys.length === 0) return `${className}{}`;
+  const props = keys.map((key) => `${key}: ${inspectValue((obj as Record<string, unknown>)[key], seen, depth + 1)}`);
+  return `${className}{ ${props.join(", ")} }`;
+}
+
 function inspectValue(value: unknown, seen: WeakSet<object> = new WeakSet(), depth = 0): string {
-  // Primitives
-  if (value === null) return "null";
-  if (value === undefined) return "undefined";
-  if (typeof value === "string") return JSON.stringify(value);
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  if (typeof value === "bigint") return `${value.toString()}n`;
-  if (typeof value === "symbol") return value.toString();
-  if (typeof value === "function") {
-    const name = value.name || "(anonymous)";
-    return `[Function: ${name}]`;
-  }
-
-  // value is now object (including arrays, Date, Map, Set, etc.)
+  const primitive = inspectPrimitive(value);
+  if (primitive.handled) return primitive.output;
   const obj = value as object;
-
-  // Cycle detection
   if (seen.has(obj)) return "[Circular]";
   seen.add(obj);
-
-  // Depth cap — prevents runaway recursion on enormous graphs
   if (depth > 8) return "[...]";
-
   try {
-    // Date
-    if (obj instanceof Date) {
-      return `Date(${obj.toISOString()})`;
-    }
-
-    // RegExp
-    if (obj instanceof RegExp) {
-      return obj.toString();
-    }
-
-    // Error
-    if (obj instanceof Error) {
-      return `${obj.constructor.name}(${JSON.stringify(obj.message)})`;
-    }
-
-    // Map
-    if (obj instanceof Map) {
-      if (obj.size === 0) return "Map(0) {}";
-      const entries: string[] = [];
-      for (const [k, v] of obj) {
-        entries.push(`${inspectValue(k, seen, depth + 1)} => ${inspectValue(v, seen, depth + 1)}`);
-      }
-      return `Map(${obj.size}) { ${entries.join(", ")} }`;
-    }
-
-    // Set
-    if (obj instanceof Set) {
-      if (obj.size === 0) return "Set(0) {}";
-      const items: string[] = [];
-      for (const v of obj) {
-        items.push(inspectValue(v, seen, depth + 1));
-      }
-      return `Set(${obj.size}) { ${items.join(", ")} }`;
-    }
-
-    // Array
-    if (Array.isArray(obj)) {
-      if (obj.length === 0) return "[]";
-      const items = obj.map((v) => inspectValue(v, seen, depth + 1));
-      return `[${items.join(", ")}]`;
-    }
-
-    // Plain object or class instance
-    const keys = Object.keys(obj);
-    const className = obj.constructor && obj.constructor.name !== "Object"
-      ? `${obj.constructor.name} `
-      : "";
-    if (keys.length === 0) return `${className}{}`;
-    const props = keys.map((k) => {
-      const v = (obj as Record<string, unknown>)[k];
-      return `${k}: ${inspectValue(v, seen, depth + 1)}`;
-    });
-    return `${className}{ ${props.join(", ")} }`;
+    return inspectObject(obj, seen, depth);
   } finally {
     seen.delete(obj);
   }
@@ -274,6 +248,19 @@ function renderDump(value: unknown): SafeString {
 type TokenType = "TEXT" | "VAR" | "BLOCK" | "COMMENT";
 type Token = [TokenType, string];
 
+type MacroDefinition = {
+  name: string;
+  params: Array<[string, string | null]>;
+  bodyTokens: Token[];
+};
+type BlockHandlerResult = { next: number; output?: string };
+type BlockHandler = (
+  tokens: Token[],
+  start: number,
+  content: string,
+  context: Record<string, unknown>,
+) => BlockHandlerResult;
+
 // ── Pre-compiled Regexes (module level) ────────────────────────
 
 const NUMERIC_RE = /^-?\d+(\.\d+)?$/;
@@ -288,6 +275,32 @@ const FILTER_WITH_ARGS_RE = /^(\w+)\s*\(([\s\S]*)\)$/;
 const FILTER_COMPARISON_RE = /^(\w+)\s*(!=|==|>=|<=|>|<)\s*(.+)$/;
 const TITLE_WORD_RE = /\b\w/g;
 const STRIP_TAGS_RE = /<[^>]+>/g;
+const FAST_FILTERS: Record<string, (value: unknown) => unknown> = {
+  upper: (value) => String(value).toUpperCase(),
+  lower: (value) => String(value).toLowerCase(),
+  trim: (value) => String(value).trim(),
+  length: (value) => Array.isArray(value) ? value.length
+    : typeof value === "string" ? value.length
+    : typeof value === "object" && value !== null ? Object.keys(value).length : 0,
+  capitalize: (value) => { const s = String(value); return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase(); },
+  title: (value) => String(value).replace(TITLE_WORD_RE, c => c.toUpperCase()),
+  string: (value) => String(value),
+  int: (value) => value ? parseInt(String(value), 10) || 0 : 0,
+  float: (value) => value ? parseFloat(String(value)) || 0.0 : 0.0,
+  abs: (value) => typeof value === "number" ? Math.abs(value) : value,
+  striptags: (value) => String(value).replace(STRIP_TAGS_RE, ""),
+  first: (value) => Array.isArray(value) ? value[0] ?? null : null,
+  last: (value) => Array.isArray(value) ? value[value.length - 1] ?? null : null,
+  keys: (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.keys(value) : [],
+  values: (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.values(value) : [],
+  json_encode: (value) => jsonSafe(value),
+  dump: (value) => renderDump(value),
+  nl2br: (value) => new SafeString(htmlEscape(String(value)).replace(/\n/g, "<br />\n")),
+  unique: (value) => Array.isArray(value) ? [...new Set(value)] : value,
+  sort: (value) => Array.isArray(value) ? [...value].sort() : value,
+  reverse: (value) => Array.isArray(value) ? [...value].reverse() : String(value).split("").reverse().join(""),
+  filter: (value) => Array.isArray(value) ? value.filter(Boolean) : value,
+};
 // printf-style conversions: %%, plus %[flags][width][.precision]type for the
 // common types. Matches PHP sprintf / Python % / Ruby format so the `format`
 // filter renders e.g. `{{ '%.2f' | format(n) }}` as "3.14" across all engines.
@@ -508,159 +521,130 @@ function extendsTarget(source: string): string {
 
 // ── Expression Evaluator ───────────────────────────────────────
 
-function resolveVar(expr: string, context: Record<string, unknown>): unknown {
-  expr = expr.trim();
+function parsePath(expr: string): [string[], boolean[]] {
+  const cachedPath = pathParseCache.get(expr);
+  if (cachedPath) return cachedPath;
 
-  // String literal
-  if ((expr.startsWith('"') && expr.endsWith('"')) ||
-      (expr.startsWith("'") && expr.endsWith("'"))) {
-    return expr.slice(1, -1);
+  const parts: string[] = [];
+  const fromBracket: boolean[] = [];
+  let current = "";
+  let depth = 0;
+  let inQuote: string | null = null;
+  for (let i = 0; i < expr.length; i++) {
+    const ch = expr[i];
+    if (inQuote) {
+      current += ch;
+      if (ch === inQuote) inQuote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") { inQuote = ch; current += ch; continue; }
+    if (ch === '(') { depth++; current += ch; continue; }
+    if (ch === ')') { depth--; current += ch; continue; }
+    if (ch === '.' && depth === 0) {
+      if (current) { parts.push(current); fromBracket.push(false); }
+      current = "";
+      continue;
+    }
+    if (ch === '[' && depth === 0) {
+      if (current) { parts.push(current); fromBracket.push(false); }
+      current = "";
+      const end = expr.indexOf(']', i + 1);
+      if (end !== -1) {
+        parts.push(expr.slice(i + 1, end));
+        fromBracket.push(true);
+        i = end;
+      }
+      continue;
+    }
+    current += ch;
   }
+  if (current) { parts.push(current); fromBracket.push(false); }
+  const parsed: [string[], boolean[]] = [parts, fromBracket];
+  capCache(pathParseCache, MEMO_CACHE_MAX);
+  pathParseCache.set(expr, parsed);
+  return parsed;
+}
 
-  // Numeric literal
-  if (NUMERIC_RE.test(expr)) {
-    return expr.includes(".") ? parseFloat(expr) : parseInt(expr, 10);
-  }
+function resolveMethodPart(value: unknown, part: string, context: Record<string, unknown>): { matched: boolean; value: unknown } {
+  const methodMatch = part.match(METHOD_CALL_RE);
+  if (!methodMatch || typeof value !== "object" || value === null) return { matched: false, value };
+  const methodName = methodMatch[1];
+  const rawArgs = methodMatch[2] || "";
+  const fn = (value as Record<string, unknown>)[methodName];
+  if (typeof fn !== "function") return { matched: false, value };
+  const args = rawArgs.trim() ? splitArgs(rawArgs).map(a => evalExpr(a.trim(), context)) : [];
+  return { matched: true, value: fn.apply(value, args) };
+}
 
-  // Boolean/null literals
-  if (expr === "true") return true;
-  if (expr === "false") return false;
-  if (expr === "null" || expr === "none" || expr === "None") return null;
+function resolvePathKey(part: string, isBracket: boolean, context: Record<string, unknown>): string | number {
+  const isQuotedPart = (part.startsWith('"') && part.endsWith('"')) ||
+                       (part.startsWith("'") && part.endsWith("'"));
+  if (isQuotedPart) return part.slice(1, -1);
+  const asNum = parseInt(part, 10);
+  if (!isNaN(asNum) && String(asNum) === part) return asNum;
+  if (isBracket) {
+    const resolved = evalExpr(part, context);
+    return resolved !== undefined ? String(resolved) : part;
+  }
+  return part;
+}
 
-  // Array literal [...]
+function resolvePathPart(value: unknown, key: string | number): { found: boolean; value: unknown } {
+  if (typeof value !== "object" || value === null) return { found: false, value: null };
+  if (Array.isArray(value) && typeof key === "number") return { found: true, value: value[key] };
+  if (!(key in (value as Record<string, unknown>))) return { found: false, value: null };
+  const member = (value as Record<string, unknown>)[key as string];
+  return { found: true, value: typeof member === "function" ? member.call(value) : member };
+}
+
+function resolveLiteral(expr: string, context: Record<string, unknown>): { handled: boolean; value: unknown } {
+  if ((expr.startsWith('"') && expr.endsWith('"')) || (expr.startsWith("'") && expr.endsWith("'"))) {
+    return { handled: true, value: expr.slice(1, -1) };
+  }
+  if (NUMERIC_RE.test(expr)) return { handled: true, value: expr.includes(".") ? parseFloat(expr) : parseInt(expr, 10) };
+  if (expr === "true") return { handled: true, value: true };
+  if (expr === "false") return { handled: true, value: false };
+  if (expr === "null" || expr === "none" || expr === "None") return { handled: true, value: null };
   if (expr.startsWith("[") && expr.endsWith("]")) {
     const inner = expr.slice(1, -1).trim();
-    if (inner === "") return [];
-    const items = splitArgs(inner);
-    return items.map(item => evalExpr(item.trim(), context));
+    return { handled: true, value: inner === "" ? [] : splitArgs(inner).map(item => evalExpr(item.trim(), context)) };
   }
+  return { handled: false, value: undefined };
+}
 
-  // Dotted path with bracket access — split on . and [...] but not . inside parentheses
-  // Track which parts came from bracket access (need variable resolution)
-  let parts: string[];
-  let fromBracket: boolean[];
+function resolvePathSegment(
+  value: unknown,
+  part: string,
+  isBracket: boolean,
+  context: Record<string, unknown>,
+): { found: boolean; value: unknown } {
+  if (value === null || value === undefined) return { found: false, value: null };
+  const method = resolveMethodPart(value, part, context);
+  if (part.match(METHOD_CALL_RE)) return method.matched ? { found: true, value: method.value } : { found: false, value: null };
+  const isQuotedPart = (part.startsWith('"') && part.endsWith('"')) || (part.startsWith("'") && part.endsWith("'"));
+  if (isBracket && part.includes(":") && !isQuotedPart) {
+    const [rawStart, rawEnd] = part.split(":", 2);
+    const start = rawStart.trim() ? parseInt(String(evalExpr(rawStart.trim(), context)), 10) : undefined;
+    const end = rawEnd.trim() ? parseInt(String(evalExpr(rawEnd.trim(), context)), 10) : undefined;
+    if (Array.isArray(value)) return { found: true, value: value.slice(start ?? 0, end) };
+    if (typeof value === "string") return { found: true, value: value.slice(start ?? 0, end) };
+    return { found: false, value: null };
+  }
+  return resolvePathPart(value, resolvePathKey(part, isBracket, context));
+}
 
-  const cachedPath = pathParseCache.get(expr);
-  if (cachedPath) {
-    [parts, fromBracket] = cachedPath;
-  } else {
-    parts = [];
-    fromBracket = [];
-    {
-      let current = "";
-      let depth = 0;
-      let inQuote: string | null = null;
-      for (let i = 0; i < expr.length; i++) {
-        const ch = expr[i];
-        if (inQuote) {
-          current += ch;
-          if (ch === inQuote) inQuote = null;
-          continue;
-        }
-        if (ch === '"' || ch === "'") { inQuote = ch; current += ch; continue; }
-        if (ch === '(') { depth++; current += ch; continue; }
-        if (ch === ')') { depth--; current += ch; continue; }
-        if (ch === '.' && depth === 0) {
-          if (current) { parts.push(current); fromBracket.push(false); }
-          current = "";
-          continue;
-        }
-        if (ch === '[' && depth === 0) {
-          if (current) { parts.push(current); fromBracket.push(false); }
-          current = "";
-          const end = expr.indexOf(']', i + 1);
-          if (end !== -1) {
-            parts.push(expr.slice(i + 1, end));
-            fromBracket.push(true);
-            i = end;
-          }
-          continue;
-        }
-        current += ch;
-      }
-      if (current) { parts.push(current); fromBracket.push(false); }
-    }
-    capCache(pathParseCache, MEMO_CACHE_MAX);
-    pathParseCache.set(expr, [parts, fromBracket]);
-  }
+function resolveVar(expr: string, context: Record<string, unknown>): unknown {
+  expr = expr.trim();
+  const literal = resolveLiteral(expr, context);
+  if (literal.handled) return literal.value;
 
+  const [parts, fromBracket] = parsePath(expr);
   let value: unknown = context;
   for (let pi = 0; pi < parts.length; pi++) {
-    const part = parts[pi];
-    const isBracket = fromBracket[pi];
-    if (value === null || value === undefined) return null;
-
-    // Check for method call: name(args)
-    const methodMatch = part.match(METHOD_CALL_RE);
-    if (methodMatch) {
-      const methodName = methodMatch[1];
-      const rawArgs = methodMatch[2] || "";
-      if (typeof value === "object" && value !== null && methodName in (value as Record<string, unknown>)) {
-        const fn = (value as Record<string, unknown>)[methodName];
-        if (typeof fn === "function") {
-          if (rawArgs.trim()) {
-            const argParts = splitArgs(rawArgs);
-            const evalArgs = argParts.map(a => evalExpr(a.trim(), context));
-            value = fn.apply(value, evalArgs);
-          } else {
-            value = fn.call(value);
-          }
-          continue;
-        }
-      }
-      return null;
-    }
-
-    // Slice syntax: value[1:5], value[:10], value[start:end]
-    const isQuotedPart = (part.startsWith('"') && part.endsWith('"')) ||
-                         (part.startsWith("'") && part.endsWith("'"));
-    if (isBracket && part.includes(":") && !isQuotedPart) {
-      const sliceParts = part.split(":", 2);
-      const sStart = sliceParts[0].trim() ? parseInt(String(evalExpr(sliceParts[0].trim(), context)), 10) : undefined;
-      const sEnd = sliceParts[1].trim() ? parseInt(String(evalExpr(sliceParts[1].trim(), context)), 10) : undefined;
-      if (Array.isArray(value)) {
-        value = (value as unknown[]).slice(sStart ?? 0, sEnd);
-      } else if (typeof value === "string") {
-        value = (value as string).slice(sStart ?? 0, sEnd);
-      } else {
-        return null;
-      }
-      continue;
-    }
-
-    let key: string | number;
-    // Check if this part came from bracket access and needs variable resolution
-    if (isQuotedPart) {
-      // Quoted string literal — strip quotes
-      key = part.slice(1, -1);
-    } else {
-      const asNum = parseInt(part, 10);
-      if (!isNaN(asNum) && String(asNum) === part) {
-        key = asNum;
-      } else if (isBracket) {
-        // Only resolve as a variable from context for bracket-derived parts
-        const resolved = evalExpr(part, context);
-        key = resolved !== undefined ? String(resolved) : part;
-      } else {
-        // Dot-derived parts or root — use the part name directly as the key
-        key = part;
-      }
-    }
-
-    if (typeof value === "object" && value !== null) {
-      if (Array.isArray(value) && typeof key === "number") {
-        value = (value as unknown[])[key];
-      } else if (key in (value as Record<string, unknown>)) {
-        const v = (value as Record<string, unknown>)[key as string];
-        value = typeof v === "function" ? v.call(value) : v;
-      } else {
-        return null;
-      }
-    } else {
-      return null;
-    }
+    const result = resolvePathSegment(value, parts[pi], fromBracket[pi], context);
+    if (!result.found) return null;
+    value = result.value;
   }
-
   return value;
 }
 
@@ -1435,6 +1419,55 @@ function numberFormat(
   return decPart ? `${formatted}${decimalPoint}${decPart}` : formatted;
 }
 
+function formatInteger(type: string, arg: unknown): string {
+  const integer = Math.trunc(Number(arg) || 0);
+  if (type === "d" || type === "i") return String(integer);
+  if (type === "x") return integer.toString(16);
+  if (type === "X") return integer.toString(16).toUpperCase();
+  if (type === "o") return integer.toString(8);
+  return integer.toString(2);
+}
+
+function formatDecimal(type: string, precision: number | undefined, arg: unknown): string {
+  const places = precision !== undefined ? precision : 6;
+  if (type === "f" || type === "F") return Number(arg).toFixed(places);
+  if (type === "e" || type === "E") {
+    const out = Number(arg).toExponential(places);
+    return type === "E" ? out.toUpperCase() : out;
+  }
+  return String(Number(arg));
+}
+
+function formatValue(type: string, precision: number | undefined, arg: unknown): string {
+  if (type === "s") return String(arg ?? "");
+  if ("dixXob".includes(type)) return formatInteger(type, arg);
+  if ("fFeEgG".includes(type)) return formatDecimal(type, precision, arg);
+  return String(arg ?? "");
+}
+
+function padFormattedValue(value: string, flags: string | undefined, width: string | undefined): string {
+  if (!width) return value;
+  const targetWidth = parseInt(width, 10);
+  if (value.length >= targetWidth) return value;
+  const padFlags = flags || "";
+  return padFlags.includes("-")
+    ? value.padEnd(targetWidth, " ")
+    : value.padStart(targetWidth, padFlags.includes("0") ? "0" : " ");
+}
+
+function formatMatch(
+  match: string,
+  flags: string | undefined,
+  width: string | undefined,
+  prec: string | undefined,
+  type: string,
+  arg: unknown,
+): string {
+  if (match === "%%") return "%";
+  const precision = prec !== undefined ? parseInt(prec, 10) : undefined;
+  return padFormattedValue(formatValue(type, precision, arg), flags, width);
+}
+
 const BUILTIN_FILTERS: Record<string, FilterFn> = {
   upper: (v) => String(v).toUpperCase(),
   lower: (v) => String(v).toLowerCase(),
@@ -1580,37 +1613,7 @@ const BUILTIN_FILTERS: Record<string, FilterFn> = {
   url_encode: (v) => encodeURIComponent(String(v)),
   format: (v, ...args) => {
     let idx = 0;
-    return String(v).replace(FORMAT_RE, (m, flags, width, prec, type) => {
-      if (m === "%%") return "%";
-      const arg = args[idx++];
-      const p = prec !== undefined ? parseInt(String(prec), 10) : undefined;
-      let out: string;
-      switch (type) {
-        case "s": out = String(arg ?? ""); break;
-        case "d": case "i": out = String(Math.trunc(Number(arg) || 0)); break;
-        case "f": case "F": out = Number(arg).toFixed(p !== undefined ? p : 6); break;
-        case "e": case "E": {
-          out = Number(arg).toExponential(p !== undefined ? p : 6);
-          if (type === "E") out = out.toUpperCase();
-          break;
-        }
-        case "g": case "G": out = String(Number(arg)); break;
-        case "x": out = Math.trunc(Number(arg) || 0).toString(16); break;
-        case "X": out = Math.trunc(Number(arg) || 0).toString(16).toUpperCase(); break;
-        case "o": out = Math.trunc(Number(arg) || 0).toString(8); break;
-        case "b": out = Math.trunc(Number(arg) || 0).toString(2); break;
-        default:  out = String(arg ?? "");
-      }
-      if (width) {
-        const w = parseInt(String(width), 10);
-        if (out.length < w) {
-          const f = String(flags || "");
-          if (f.includes("-")) out = out.padEnd(w, " ");
-          else out = out.padStart(w, f.includes("0") ? "0" : " ");
-        }
-      }
-      return out;
-    });
+    return String(v).replace(FORMAT_RE, (m, flags, width, prec, type) => formatMatch(m, flags, width, prec, type, args[idx++]));
   },
   dump: (v) => JSON.stringify(v),
   formToken: (v?: unknown) => _generateFormToken(v != null ? String(v) : ""),
@@ -1790,6 +1793,7 @@ export class Frond {
   private _allowedVars: Set<string> | null;
   private fragmentCache: Map<string, [string, number]>;
   private _autoEscape: boolean;
+  private readonly blockHandlers: Record<string, BlockHandler>;
   /**
    * Token pre-compilation cache for file templates.
    *
@@ -1821,6 +1825,47 @@ export class Frond {
     this._allowedVars = null;
     this.fragmentCache = new Map();
     this._autoEscape = true;
+    this.blockHandlers = {
+      if: (tokens, start, _content, context) => {
+        const [output, next] = this.handleIf(tokens, start, context);
+        return { output, next };
+      },
+      for: (tokens, start, _content, context) => {
+        const [output, next] = this.handleFor(tokens, start, context);
+        return { output, next };
+      },
+      set: (tokens, start, content, context) => {
+        if (!content.includes("=")) return { next: this.handleSetBlock(tokens, start, context) };
+        this.handleSet(content, context);
+        return { next: start + 1 };
+      },
+      include: (_tokens, start, content, context) => ({ output: this.handleInclude(content, context), next: start + 1 }),
+      macro: (tokens, start, _content, context) => ({ next: this.handleMacro(tokens, start, context) }),
+      import: (_tokens, start, content, context) => {
+        this.handleImportAs(content, context);
+        return { next: start + 1 };
+      },
+      from: (_tokens, start, content, context) => {
+        this.handleFromImport(content, context);
+        return { next: start + 1 };
+      },
+      cache: (tokens, start, _content, context) => {
+        const [output, next] = this.handleCache(tokens, start, context);
+        return { output, next };
+      },
+      live: (tokens, start, _content, context) => {
+        const [output, next] = this.handleLive(tokens, start, context);
+        return { output, next };
+      },
+      spaceless: (tokens, start, _content, context) => {
+        const [output, next] = this.handleSpaceless(tokens, start, context);
+        return { output, next };
+      },
+      autoescape: (tokens, start, _content, context) => {
+        const [output, next] = this.handleAutoescape(tokens, start, context);
+        return { output, next };
+      },
+    };
 
     // Built-in global functions
     this.globals.formToken = (descriptor?: string) => _generateFormToken(descriptor || "");
@@ -2240,6 +2285,68 @@ export class Frond {
     return this.renderTokens(tokenize(result), context);
   }
 
+  private dispatchBlock(
+    tokens: Token[],
+    start: number,
+    content: string,
+    tag: string,
+    context: Record<string, unknown>,
+  ): BlockHandlerResult {
+    if (!this.tagPermitted(tag)) return { next: this.skipDeniedTag(tokens, start, tag, content) };
+    const handler = this.blockHandlers[tag];
+    if (handler) return handler(tokens, start, content, context);
+    if (tag === "block" || tag === "endblock" || tag === "extends") return { next: start + 1 };
+    if (tag !== "" && !TERMINATOR_TAGS.has(tag)) {
+      throw new Error(
+        `Frond: unknown tag "${tag}" -- known tags are: ${[...KNOWN_TAGS].sort().join(", ")}`,
+      );
+    }
+    return { next: start + 1 };
+  }
+
+  private renderTextToken(tokens: Token[], index: number, output: string[]): number {
+    output.push(tokens[index][1]);
+    return index + 1;
+  }
+
+  private renderVarToken(tokens: Token[], index: number, context: Record<string, unknown>, output: string[]): number {
+    const [content, stripB, stripA] = stripTag(tokens[index][1]);
+    if (stripB && output.length > 0) output[output.length - 1] = output[output.length - 1].replace(TRAILING_WS_RE, "");
+    const result = this.evalVar(content, context);
+    output.push(result !== null && result !== undefined ? String(result) : "");
+    if (stripA && index + 1 < tokens.length && tokens[index + 1][0] === "TEXT") {
+      tokens[index + 1] = ["TEXT", tokens[index + 1][1].replace(LEADING_WS_RE, "")];
+    }
+    return index + 1;
+  }
+
+  private renderBlockToken(tokens: Token[], index: number, context: Record<string, unknown>, output: string[]): number {
+    const [content, stripB, stripA] = stripTag(tokens[index][1]);
+    if (stripB && output.length > 0) output[output.length - 1] = output[output.length - 1].replace(TRAILING_WS_RE, "");
+    const tag = content.split(/\s+/)[0] || "";
+    if (stripA && index + 1 < tokens.length && tokens[index + 1][0] === "TEXT") {
+      tokens[index + 1] = ["TEXT", tokens[index + 1][1].replace(LEADING_WS_RE, "")];
+    }
+    let next: number;
+    if (tag === "if" && this.tagPermitted(tag)) {
+      const [result, after] = this.handleIf(tokens, index, context);
+      output.push(result);
+      next = after;
+    } else if (tag === "for" && this.tagPermitted(tag)) {
+      const [result, after] = this.handleFor(tokens, index, context);
+      output.push(result);
+      next = after;
+    } else {
+      const block = this.dispatchBlock(tokens, index, content, tag, context);
+      if (block.output !== undefined) output.push(block.output);
+      next = block.next;
+    }
+    if (stripA && next < tokens.length && tokens[next][0] === "TEXT") {
+      tokens[next] = ["TEXT", tokens[next][1].replace(LEADING_WS_RE, "")];
+    }
+    return next;
+  }
+
   private renderTokens(tokens: Token[], context: Record<string, unknown>): string {
     // Expose this instance's filter engine to the module-level evalExpr so a
     // filter pipe resolves at any expression depth with the right (custom)
@@ -2251,114 +2358,16 @@ export class Frond {
     let i = 0;
 
     while (i < tokens.length) {
-      const [ttype, raw] = tokens[i];
+      const [ttype] = tokens[i];
 
       if (ttype === "TEXT") {
-        output.push(raw);
-        i++;
+        i = this.renderTextToken(tokens, i, output);
       } else if (ttype === "COMMENT") {
         i++;
       } else if (ttype === "VAR") {
-        const [content, stripB, stripA] = stripTag(raw);
-        if (stripB && output.length > 0) {
-          output[output.length - 1] = output[output.length - 1].replace(TRAILING_WS_RE, "");
-        }
-
-        const result = this.evalVar(content, context);
-        output.push(result !== null && result !== undefined ? String(result) : "");
-
-        if (stripA && i + 1 < tokens.length && tokens[i + 1][0] === "TEXT") {
-          tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
-        }
-        i++;
+        i = this.renderVarToken(tokens, i, context, output);
       } else if (ttype === "BLOCK") {
-        const [content, stripB, stripA] = stripTag(raw);
-        if (stripB && output.length > 0) {
-          output[output.length - 1] = output[output.length - 1].replace(TRAILING_WS_RE, "");
-        }
-
-        const parts = content.split(/\s+/);
-        const tag = parts[0] || "";
-
-        // Apply stripA before handlers consume body tokens
-        if (stripA && i + 1 < tokens.length && tokens[i + 1][0] === "TEXT") {
-          tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
-        }
-
-        if (!this.tagPermitted(tag)) {
-          // ONE sandbox gate for the whole tag vocabulary. Previously only if, for,
-          // set and include were checked, so every other tag ignored the allow-list
-          // -- {% autoescape false %} could switch escaping off from inside a
-          // sandbox whose tags were restricted to something else entirely.
-          i = this.skipDeniedTag(tokens, i, tag, content);
-        } else if (tag === "if") {
-          const [result, skip] = this.handleIf(tokens, i, context);
-          output.push(result);
-          i = skip;
-        } else if (tag === "for") {
-          const [result, skip] = this.handleFor(tokens, i, context);
-          output.push(result);
-          i = skip;
-        } else if (tag === "set") {
-          // An assignment has an "="; without one this is the BLOCK form,
-          // {% set name %}...{% endset %}, which captures its rendered body. A
-          // bare includes() is exact here, not a shortcut: the block form's tag
-          // content is only ever "set <name>", so an "=" anywhere -- even inside
-          // a quoted value like {% set m = "a = b" %} -- means assignment.
-          if (!content.includes("=")) {
-            i = this.handleSetBlock(tokens, i, context);
-          } else {
-            this.handleSet(content, context);
-            i++;
-          }
-        } else if (tag === "include") {
-          const result = this.handleInclude(content, context);
-          output.push(result);
-          i++;
-        } else if (tag === "macro") {
-          const skip = this.handleMacro(tokens, i, context);
-          i = skip;
-        } else if (tag === "import") {
-          this.handleImportAs(content, context);
-          i++;
-        } else if (tag === "from") {
-          this.handleFromImport(content, context);
-          i++;
-        } else if (tag === "cache") {
-          const [result, skip] = this.handleCache(tokens, i, context);
-          output.push(result);
-          i = skip;
-        } else if (tag === "live") {
-          const [result, skip] = this.handleLive(tokens, i, context);
-          output.push(result);
-          i = skip;
-        } else if (tag === "spaceless") {
-          const [result, skip] = this.handleSpaceless(tokens, i, context);
-          output.push(result);
-          i = skip;
-        } else if (tag === "autoescape") {
-          const [result, skip] = this.handleAutoescape(tokens, i, context);
-          output.push(result);
-          i = skip;
-        } else if (tag === "block" || tag === "endblock" || tag === "extends") {
-          i++; // Already handled
-        } else {
-          i++;
-          if (tag !== "" && !TERMINATOR_TAGS.has(tag)) {
-            throw new Error(
-              `Frond: unknown tag "${tag}" -- known tags are: ${[...KNOWN_TAGS].sort().join(", ")}`,
-            );
-          }
-          // An empty tag ({%  %}) or a stray terminator (an {% endif %} with
-          // no {% if %}): no output.
-          // Malformed, but it has always rendered nothing, and nothing is the
-          // safe answer -- unlike an unknown tag it cannot expose content that
-          // was meant to be gated.
-        }
-
-        if (stripA && i < tokens.length && tokens[i][0] === "TEXT") {
-          tokens[i] = ["TEXT", tokens[i][1].replace(LEADING_WS_RE, "")];
-        }
+        i = this.renderBlockToken(tokens, i, context, output);
       } else {
         i++;
       }
@@ -2393,6 +2402,46 @@ export class Frond {
     return this._allowedTags.has(tag);
   }
 
+  private applyFilterValue(
+    value: unknown,
+    fname: string,
+    args: unknown[],
+    context: Record<string, unknown>,
+  ): unknown {
+    const [realFname, tailPath] = splitFilterNameAndPath(fname);
+    if (tailPath) {
+      let applied = false;
+      if (realFname === "first") {
+        value = Array.isArray(value) ? value[0] ?? null : null;
+        applied = true;
+      } else if (realFname === "last") {
+        value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
+        applied = true;
+      } else if (this.filters[realFname]) {
+        value = this.filters[realFname](value, ...args);
+        applied = true;
+      }
+      if (applied) return evalExpr("__frondFilterTmp." + tailPath, { __frondFilterTmp: value });
+    }
+
+    const fn = this.filters[fname];
+    if (fn) return fn(value, ...args);
+    const comparison = fname.match(FILTER_COMPARISON_RE);
+    if (!comparison) return evalExpr(fname, context);
+    const comparisonFn = this.filters[comparison[1]];
+    if (comparisonFn) value = comparisonFn(value, ...args);
+    const right = evalExpr(comparison[3].trim(), context);
+    switch (comparison[2]) {
+      case "!=": return value !== right;
+      case "==": return value === right;
+      case ">=": return (value as number) >= (right as number);
+      case "<=": return (value as number) <= (right as number);
+      case ">": return (value as number) > (right as number);
+      case "<": return (value as number) < (right as number);
+      default: return value;
+    }
+  }
+
   /**
    * Consume a denied tag WITHOUT running it, returning the index past its body.
    *
@@ -2451,50 +2500,8 @@ export class Frond {
       // unchanged) — same gate as evalVarInner. applyFilters is reached by the
       // folded filter pipe in evalExpr (`x|f ~ y`, #171), so without this gate a
       // non-allow-listed filter would run in sandbox mode.
-      if (this._sandbox && this._allowedFilters !== null && !this._allowedFilters.has(fname)) continue;
-
-      const [realFname, tailPath] = splitFilterNameAndPath(fname);
-      if (tailPath) {
-        let applied = false;
-        if (realFname === "first") {
-          value = Array.isArray(value) ? value[0] ?? null : null;
-          applied = true;
-        } else if (realFname === "last") {
-          value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
-          applied = true;
-        } else if (this.filters[realFname]) {
-          value = this.filters[realFname](value, ...args);
-          applied = true;
-        }
-        if (applied) {
-          value = evalExpr("__frondFilterTmp." + tailPath, { __frondFilterTmp: value });
-          continue;
-        }
-      }
-
-      const fn = this.filters[fname];
-      if (fn) {
-        value = fn(value, ...args);
-      } else {
-        // The filter name may carry a trailing comparison operator, e.g.
-        // "length != 1" — apply the real filter, then evaluate the comparison.
-        const m = fname.match(FILTER_COMPARISON_RE);
-        if (m) {
-          const fn2 = this.filters[m[1]];
-          if (fn2) value = fn2(value, ...args);
-          const right = evalExpr(m[3].trim(), context);
-          switch (m[2]) {
-            case "!=": value = value !== right; break;
-            case "==": value = value === right; break;
-            case ">=": value = (value as number) >= (right as number); break;
-            case "<=": value = (value as number) <= (right as number); break;
-            case ">":  value = (value as number) > (right as number); break;
-            case "<":  value = (value as number) < (right as number); break;
-          }
-        } else {
-          value = evalExpr(fname, context);
-        }
-      }
+      if (!this.filterPermitted(fname)) continue;
+      value = this.applyFilterValue(value, fname, args, context);
     }
     return value;
   }
@@ -2529,193 +2536,89 @@ export class Frond {
       // unchanged) — same gate as evalVarInner. evalVarRaw is reached by a
       // ternary condition (`x|f ? a : b`), evalComparison, and set, none of
       // which gated filters before, so a non-allow-listed filter could run.
-      if (this._sandbox && this._allowedFilters !== null && !this._allowedFilters.has(fname)) continue;
-
-      // Filter + property-access chain: `first.groupSummary` — apply
-      // the filter, then traverse the path on the result via a
-      // synthetic context so evalExpr's dotted resolution does the
-      // work. Parity with tina4-python + tina4-php. `first` and
-      // `last` are inlined because they're in the fast-path switch
-      // rather than `this.filters`.
-      const [realFname, tailPath] = splitFilterNameAndPath(fname);
-      if (tailPath) {
-        let applied = false;
-        if (realFname === "first") {
-          value = Array.isArray(value) ? value[0] ?? null : null;
-          applied = true;
-        } else if (realFname === "last") {
-          value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
-          applied = true;
-        } else if (this.filters[realFname]) {
-          value = this.filters[realFname](value, ...args);
-          applied = true;
-        }
-        if (applied) {
-          value = evalExpr("__frondFilterTmp." + tailPath,
-                           { __frondFilterTmp: value });
-          continue;
-        }
-      }
-
-      const fn = this.filters[fname];
-      if (fn) {
-        value = fn(value, ...args);
-      } else {
-        // The filter name may include a trailing comparison operator,
-        // e.g. "length != 1".  Extract the real filter name and the
-        // comparison suffix, apply the filter, then evaluate the comparison.
-        const m = fname.match(FILTER_COMPARISON_RE);
-        if (m) {
-          const realFilter = m[1];
-          const op = m[2];
-          const rightExpr = m[3].trim();
-          const fn2 = this.filters[realFilter];
-          if (fn2) {
-            value = fn2(value, ...args);
-          }
-          const right = evalExpr(rightExpr, context);
-          switch (op) {
-            case "!=": value = value !== right; break;
-            case "==": value = value === right; break;
-            case ">=": value = (value as number) >= (right as number); break;
-            case "<=": value = (value as number) <= (right as number); break;
-            case ">":  value = (value as number) > (right as number); break;
-            case "<":  value = (value as number) < (right as number); break;
-          }
-        } else {
-          value = evalExpr(fname, context);
-        }
-      }
+      if (!this.filterPermitted(fname)) continue;
+      value = this.applyFilterValue(value, fname, args, context);
     }
     return value;
   }
 
-  private evalVarInner(expr: string, context: Record<string, unknown>): unknown {
-    const [varName, filters] = parseFilterChain(expr);
-
-    // Sandbox: check variable access
-    if (this._sandbox && this._allowedVars !== null) {
-      const rootVar = varName.split(".")[0].split("[")[0].trim();
-      if (rootVar && !this._allowedVars.has(rootVar) && rootVar !== "loop") {
-        return ""; // Silently block
+  /**
+   * Apply the no-argument filters that are common enough to avoid generic
+   * dispatch. Keeping this table separate from evalVarInner makes the
+   * expression pipeline easier to audit without changing filter order.
+   */
+  private applyFastFilter(name: string, value: unknown): { handled: boolean; value: unknown } {
+    const handler = FAST_FILTERS[name];
+    return handler ? { handled: true, value: handler(value) } : { handled: false, value };
+  }
+
+  private applyRenderedFilter(value: unknown, fname: string, args: unknown[]): unknown {
+    const [realFname, tailPath] = splitFilterNameAndPath(fname);
+    if (tailPath) {
+      let applied = false;
+      if (realFname === "first") {
+        value = Array.isArray(value) ? value[0] ?? null : null;
+        applied = true;
+      } else if (realFname === "last") {
+        value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
+        applied = true;
+      } else if (this.filters[realFname]) {
+        value = this.filters[realFname](value, ...args);
+        applied = true;
       }
+      if (applied) return evalExpr("__frondFilterTmp." + tailPath, { __frondFilterTmp: value });
     }
-
-    // Concat precedence (#171): a top-level `~` means the whole expression is a
-    // concatenation, and `|` binds TIGHTER than `~`. parseFilterChain above
-    // wrongly glued the trailing `~ ...` onto the last filter, so evaluate the
-    // WHOLE expression through evalExpr (which resolves the filter pipe at the
-    // correct precedence, at any depth) and only auto-escape the result here.
-    if (findOutsideQuotes(expr, "~") >= 0) {
-      let concatValue = evalExpr(expr, context);
-      if (concatValue instanceof SafeString) return concatValue.value;
-      if (this._autoEscape && typeof concatValue === "string") {
-        concatValue = htmlEscape(concatValue);
-      }
-      return concatValue;
+    if (args.length === 0) {
+      const fast = this.applyFastFilter(fname, value);
+      if (fast.handled) return fast.value;
     }
+    const fn = this.filters[fname];
+    return fn ? fn(value, ...args) : value;
+  }
 
-    let value = evalExpr(varName, context);
+  private variablePermitted(varName: string): boolean {
+    if (!this._sandbox || this._allowedVars === null) return true;
+    const rootVar = varName.split(".")[0].split("[")[0].trim();
+    return !rootVar || rootVar === "loop" || this._allowedVars.has(rootVar);
+  }
+
+  private resolveConcatenation(
+    expr: string,
+    context: Record<string, unknown>,
+  ): { handled: boolean; value: unknown } {
+    if (findOutsideQuotes(expr, "~") < 0) return { handled: false, value: undefined };
+    let value = evalExpr(expr, context);
+    if (value instanceof SafeString) return { handled: true, value: value.value };
+    if (this._autoEscape && typeof value === "string") value = htmlEscape(value);
+    return { handled: true, value };
+  }
 
-    let isSafe = false;
+  private applyRenderedFilters(
+    value: unknown,
+    filters: [string, unknown[]][],
+    context: Record<string, unknown>,
+  ): { value: unknown; safe: boolean } {
+    let safe = false;
     for (const [fname, rawArgs] of filters) {
       const args = rawArgs.map((a) => (a instanceof VarRef ? evalExpr(a.name, context) : a));
       if (fname === "raw" || fname === "safe") {
-        // Decide from what was permitted to RUN, not from what the source asked
-        // for. Marking the value safe here regardless meant a DENIED raw produced
-        // byte-identical output to an allowed one -- the allow-list entry that
-        // governs XSS escaping did nothing at all.
-        if (this.filterPermitted(fname)) isSafe = true;
+        if (this.filterPermitted(fname)) safe = true;
         continue;
       }
-      // escape/e filter marks output as safe (already escaped) -- but ONLY when it
-      // is permitted to run. Node's escape returns a plain string, so this flag is
-      // what suppresses auto-escaping; setting it for a DENIED escape emitted the
-      // value unescaped, having never escaped it.
-      if (fname === "escape" || fname === "e") {
-        if (this.filterPermitted(fname)) isSafe = true;
-      }
-
-      // Sandbox: check filter access
-      if (this._sandbox && this._allowedFilters !== null) {
-        if (!this._allowedFilters.has(fname)) {
-          continue; // Silently skip blocked filter
-        }
-      }
-
-      // Filter + property-access chain: `first.groupSummary` — apply
-      // the filter, then traverse the path on the result via evalExpr.
-      // Done BEFORE the inline fast-path so `items|first.name` works
-      // whether or not `first` is in the fast-path list.
-      //
-      // We inline `first` and `last` here because they're defined by
-      // the fast-path switch below, not in `this.filters` — without
-      // this explicit branch, the chain would fall through and we'd
-      // return the unfiltered array. All other registered filters
-      // route through `this.filters[realFname]`.
-      const [realFname, tailPath] = splitFilterNameAndPath(fname);
-      if (tailPath) {
-        let applied = false;
-        if (realFname === "first") {
-          value = Array.isArray(value) ? value[0] ?? null : null;
-          applied = true;
-        } else if (realFname === "last") {
-          value = Array.isArray(value) ? value[value.length - 1] ?? null : null;
-          applied = true;
-        } else if (this.filters[realFname]) {
-          value = this.filters[realFname](value, ...args);
-          applied = true;
-        }
-        if (applied) {
-          value = evalExpr("__frondFilterTmp." + tailPath,
-                           { __frondFilterTmp: value });
-          continue;
-        }
-      }
-
-      // Inline fast-path for common no-arg filters — avoids generic dispatch
-      if (args.length === 0) {
-        switch (fname) {
-          case "upper":      value = String(value).toUpperCase(); continue;
-          case "lower":      value = String(value).toLowerCase(); continue;
-          case "trim":       value = String(value).trim(); continue;
-          case "length":
-            if (Array.isArray(value)) { value = value.length; }
-            else if (typeof value === "string") { value = value.length; }
-            else if (typeof value === "object" && value !== null) { value = Object.keys(value).length; }
-            else { value = 0; }
-            continue;
-          case "capitalize": { const s = String(value); value = s.charAt(0).toUpperCase() + s.slice(1).toLowerCase(); continue; }
-          case "title":      value = String(value).replace(TITLE_WORD_RE, c => c.toUpperCase()); continue;
-          case "string":     value = String(value); continue;
-          case "int":        value = value ? parseInt(String(value), 10) || 0 : 0; continue;
-          case "float":      value = value ? parseFloat(String(value)) || 0.0 : 0.0; continue;
-          case "abs":        value = typeof value === "number" ? Math.abs(value) : value; continue;
-          case "striptags":  value = String(value).replace(STRIP_TAGS_RE, ""); continue;
-          case "first":      value = Array.isArray(value) ? value[0] ?? null : null; continue;
-          case "last":       value = Array.isArray(value) ? value[value.length - 1] ?? null : null; continue;
-          case "keys":       value = (typeof value === "object" && value !== null && !Array.isArray(value)) ? Object.keys(value) : []; continue;
-          case "values":     value = (typeof value === "object" && value !== null && !Array.isArray(value)) ? Object.values(value) : []; continue;
-          case "json_encode": value = jsonSafe(value); continue;
-          case "dump":
-            // Delegates to renderDump(), which is gated on TINA4_DEBUG.
-            // In production this emits an empty SafeString (no leaked state).
-            value = renderDump(value);
-            continue;
-          case "nl2br":      value = new SafeString(htmlEscape(String(value)).replace(/\n/g, "<br />\n")); continue;
-          case "unique":     value = Array.isArray(value) ? [...new Set(value)] : value; continue;
-          case "sort":       value = Array.isArray(value) ? [...value].sort() : value; continue;
-          case "reverse":    value = Array.isArray(value) ? [...value].reverse() : String(value).split("").reverse().join(""); continue;
-          case "filter":     value = Array.isArray(value) ? value.filter(Boolean) : value; continue;
-          // Not a fast-path filter — fall through to generic dispatch
-        }
-      }
-
-      const fn = this.filters[fname];
-      if (fn) {
-        value = fn(value, ...args);
-      }
+      if ((fname === "escape" || fname === "e") && this.filterPermitted(fname)) safe = true;
+      if (!this.filterPermitted(fname)) continue;
+      value = this.applyRenderedFilter(value, fname, args);
     }
+    return { value, safe };
+  }
+
+  private evalVarInner(expr: string, context: Record<string, unknown>): unknown {
+    const [varName, filters] = parseFilterChain(expr);
+    if (!this.variablePermitted(varName)) return "";
+    const concatenated = this.resolveConcatenation(expr, context);
+    if (concatenated.handled) return concatenated.value;
+    const applied = this.applyRenderedFilters(evalExpr(varName, context), filters, context);
+    let value = applied.value;
 
     // SafeString instances are already rendered/safe
     if (value instanceof SafeString) {
@@ -2723,213 +2626,187 @@ export class Frond {
     }
 
     // Auto-escape HTML unless marked safe or auto-escape is disabled
-    if (!isSafe && this._autoEscape && typeof value === "string") {
+    if (!applied.safe && this._autoEscape && typeof value === "string") {
       value = htmlEscape(value);
     }
 
     return value;
   }
 
-  private handleIf(tokens: Token[], start: number, context: Record<string, unknown>): [string, number] {
-    const [content] = stripTag(tokens[start][1]);
-    const conditionExpr = content.slice(3).trim(); // Remove 'if '
+  private pushIfBranch(
+    branches: [string | null, Token[]][],
+    condition: string | null,
+    branchTokens: Token[],
+    stripBefore: boolean,
+  ): void {
+    if (stripBefore && branchTokens.length > 0 && branchTokens[branchTokens.length - 1][0] === "TEXT") {
+      const last = branchTokens[branchTokens.length - 1];
+      branchTokens[branchTokens.length - 1] = ["TEXT", last[1].replace(TRAILING_WS_RE, "")];
+    }
+    branches.push([condition, branchTokens]);
+  }
 
-    // Collect branches: [condition, tokens][]
+  private collectIfBranches(
+    tokens: Token[],
+    start: number,
+    conditionExpr: string,
+  ): { branches: [string | null, Token[]][]; next: number } {
     const branches: [string | null, Token[]][] = [];
     let currentTokens: Token[] = [];
     let currentCond: string | null = conditionExpr;
     let depth = 0;
     let i = start + 1;
-
     while (i < tokens.length) {
       const [ttype, raw] = tokens[i];
-      if (ttype === "BLOCK") {
-        const [tagContent, tagStripB, tagStripA] = stripTag(raw);
-        const tag = tagContent.split(/\s+/)[0] || "";
-
-        if (tag === "if") {
-          depth++;
-          currentTokens.push(tokens[i]);
-        } else if (tag === "endif" && depth > 0) {
-          depth--;
-          currentTokens.push(tokens[i]);
-        } else if (tag === "endif" && depth === 0) {
-          // Strip trailing whitespace from last body token if endif has strip_before
-          if (tagStripB && currentTokens.length > 0 && currentTokens[currentTokens.length - 1][0] === "TEXT") {
-            currentTokens[currentTokens.length - 1] = ["TEXT", currentTokens[currentTokens.length - 1][1].replace(TRAILING_WS_RE, "")];
-          }
-          branches.push([currentCond, currentTokens]);
-          // Apply stripA on token after endif
-          if (tagStripA && i + 1 < tokens.length && tokens[i + 1][0] === "TEXT") {
-            tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
-          }
-          i++;
-          break;
-        } else if ((tag === "elseif" || tag === "elif") && depth === 0) {
-          if (tagStripB && currentTokens.length > 0 && currentTokens[currentTokens.length - 1][0] === "TEXT") {
-            currentTokens[currentTokens.length - 1] = ["TEXT", currentTokens[currentTokens.length - 1][1].replace(TRAILING_WS_RE, "")];
-          }
-          branches.push([currentCond, currentTokens]);
-          currentCond = tagContent.slice(tag.length).trim();
-          currentTokens = [];
-        } else if (tag === "else" && depth === 0) {
-          if (tagStripB && currentTokens.length > 0 && currentTokens[currentTokens.length - 1][0] === "TEXT") {
-            currentTokens[currentTokens.length - 1] = ["TEXT", currentTokens[currentTokens.length - 1][1].replace(TRAILING_WS_RE, "")];
-          }
-          branches.push([currentCond, currentTokens]);
-          currentCond = null; // else branch
-          currentTokens = [];
-        } else {
-          currentTokens.push(tokens[i]);
+      if (ttype !== "BLOCK") {
+        currentTokens.push(tokens[i]);
+        i++;
+        continue;
+      }
+      const [tagContent, tagStripB, tagStripA] = stripTag(raw);
+      const tag = tagContent.split(/\s+/)[0] || "";
+      if (tag === "if") {
+        depth++;
+        currentTokens.push(tokens[i]);
+      } else if (tag === "endif" && depth > 0) {
+        depth--;
+        currentTokens.push(tokens[i]);
+      } else if (tag === "endif") {
+        this.pushIfBranch(branches, currentCond, currentTokens, tagStripB);
+        if (tagStripA && i + 1 < tokens.length && tokens[i + 1][0] === "TEXT") {
+          tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
         }
+        return { branches, next: i + 1 };
+      } else if ((tag === "elseif" || tag === "elif") && depth === 0) {
+        this.pushIfBranch(branches, currentCond, currentTokens, tagStripB);
+        currentCond = tagContent.slice(tag.length).trim();
+        currentTokens = [];
+      } else if (tag === "else" && depth === 0) {
+        this.pushIfBranch(branches, currentCond, currentTokens, tagStripB);
+        currentCond = null;
+        currentTokens = [];
       } else {
         currentTokens.push(tokens[i]);
       }
       i++;
     }
+    return { branches, next: i };
+  }
+
+  private handleIf(tokens: Token[], start: number, context: Record<string, unknown>): [string, number] {
+    const [content] = stripTag(tokens[start][1]);
+    const conditionExpr = content.slice(3).trim(); // Remove 'if '
+    const { branches, next } = this.collectIfBranches(tokens, start, conditionExpr);
 
     // Evaluate branches
     for (const [cond, branchTokens] of branches) {
       if (cond === null || evalComparison(cond, context, this.evalVarRaw.bind(this))) {
-        return [this.renderTokens([...branchTokens], context), i];
+        return [this.renderTokens([...branchTokens], context), next];
       }
     }
 
-    return ["", i];
+    return ["", next];
   }
 
-  private handleFor(tokens: Token[], start: number, context: Record<string, unknown>): [string, number] {
-    const [content] = stripTag(tokens[start][1]);
-    const forMatch = content.match(/^for\s+(\w+)(?:\s*,\s*(\w+))?\s+in\s+(.+)/);
-    if (!forMatch) return ["", start + 1];
-
-    const var1 = forMatch[1];
-    const var2 = forMatch[2] || null;
-    const iterableExpr = forMatch[3].trim();
-
-    // Collect body and else tokens
+  private collectForTokens(tokens: Token[], start: number): { bodyTokens: Token[]; elseTokens: Token[]; next: number } {
     const bodyTokens: Token[] = [];
     const elseTokens: Token[] = [];
     let inElse = false;
     let forDepth = 0;
     let ifDepth = 0;
     let i = start + 1;
-
     while (i < tokens.length) {
-      const [ttype, raw] = tokens[i];
-      if (ttype === "BLOCK") {
-        const [tagContent] = stripTag(raw);
-        const tag = tagContent.split(/\s+/)[0] || "";
-
-        if (tag === "for") {
-          forDepth++;
-          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
-        } else if (tag === "endfor" && forDepth > 0) {
-          forDepth--;
-          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
-        } else if (tag === "endfor" && forDepth === 0) {
-          i++;
-          break;
-        } else if (tag === "if") {
-          ifDepth++;
-          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
-        } else if (tag === "endif") {
-          ifDepth--;
-          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
-        } else if (tag === "else" && forDepth === 0 && ifDepth === 0) {
-          inElse = true;
-        } else {
-          (inElse ? elseTokens : bodyTokens).push(tokens[i]);
-        }
-      } else {
-        (inElse ? elseTokens : bodyTokens).push(tokens[i]);
+      const token = tokens[i];
+      if (token[0] !== "BLOCK") {
+        (inElse ? elseTokens : bodyTokens).push(token);
+        i++;
+        continue;
+      }
+      const [tagContent] = stripTag(token[1]);
+      const tag = tagContent.split(/\s+/)[0] || "";
+      if (tag === "for") forDepth++;
+      else if (tag === "endfor" && forDepth > 0) forDepth--;
+      else if (tag === "endfor") return { bodyTokens, elseTokens, next: i + 1 };
+      else if (tag === "if") ifDepth++;
+      else if (tag === "endif") ifDepth--;
+      else if (tag === "else" && forDepth === 0 && ifDepth === 0) {
+        inElse = true;
+        i++;
+        continue;
       }
+      (inElse ? elseTokens : bodyTokens).push(token);
       i++;
     }
+    return { bodyTokens, elseTokens, next: i };
+  }
 
-    // Evaluate iterable
-    const iterable = evalExpr(iterableExpr, context);
+  private forItems(iterable: unknown): { items: unknown[]; isDict: boolean } {
+    const isDict = typeof iterable === "object" && iterable !== null && !Array.isArray(iterable);
+    if (isDict) return { items: Object.entries(iterable as Record<string, unknown>), isDict: true };
+    return { items: Array.isArray(iterable) ? iterable : [], isDict: false };
+  }
 
-    if (!iterable || (Array.isArray(iterable) && iterable.length === 0) ||
-        (typeof iterable === "object" && !Array.isArray(iterable) && Object.keys(iterable as object).length === 0)) {
-      if (elseTokens.length > 0) {
-        return [this.renderTokens([...elseTokens], context), i];
-      }
-      return ["", i];
-    }
+  private handleFor(tokens: Token[], start: number, context: Record<string, unknown>): [string, number] {
+    const [content] = stripTag(tokens[start][1]);
+    const forMatch = content.match(/^for\s+(\w+)(?:\s*,\s*(\w+))?\s+in\s+(.+)/);
+    if (!forMatch) return ["", start + 1];
+
+    const var1 = forMatch[1];
+    const var2 = forMatch[2] || null;
+    const { bodyTokens, elseTokens, next: i } = this.collectForTokens(tokens, start);
+
+    // Evaluate iterable
+    const iterable = evalExpr(forMatch[3].trim(), context);
+    const { items, isDict } = this.forItems(iterable);
+    if (items.length === 0) return [elseTokens.length ? this.renderTokens([...elseTokens], context) : "", i];
 
-    // Iterate
     const output: string[] = [];
-    const isDict = typeof iterable === "object" && !Array.isArray(iterable);
-    const items = isDict
-      ? Object.entries(iterable as Record<string, unknown>)
-      : Array.isArray(iterable) ? iterable : [];
-    const total = items.length;
 
     // Reusable loop object — mutated each iteration to avoid allocation
-    const loopObj = {
+    const loopObj: Record<string, unknown> = {
       index: 0,
       index0: 0,
       first: false,
       last: false,
-      length: total,
+      length: items.length,
       revindex: 0,
       revindex0: 0,
       even: false,
       odd: false,
     };
 
-    for (let idx = 0; idx < total; idx++) {
+    for (let idx = 0; idx < items.length; idx++) {
       const item = items[idx];
-
-      // Update loop object in-place
       loopObj.index = idx + 1;
       loopObj.index0 = idx;
       loopObj.first = idx === 0;
-      loopObj.last = idx === total - 1;
-      loopObj.revindex = total - idx;
-      loopObj.revindex0 = total - idx - 1;
+      loopObj.last = idx === items.length - 1;
+      loopObj.revindex = items.length - idx;
+      loopObj.revindex0 = items.length - idx - 1;
       loopObj.even = (idx + 1) % 2 === 0;
       loopObj.odd = (idx + 1) % 2 !== 0;
-
-      // Lazy overlay context: reads from local overrides first, then parent
       const locals: Record<string, unknown> = { loop: loopObj };
-
       if (isDict) {
         const [key, value] = item as [string, unknown];
         locals[var1] = key;
         if (var2) locals[var2] = value;
+      } else if (var2) {
+        locals[var1] = idx;
+        locals[var2] = item;
       } else {
-        if (var2) {
-          locals[var1] = idx;
-          locals[var2] = item;
-        } else {
-          locals[var1] = item;
-        }
+        locals[var1] = item;
       }
-
       const loopCtx = new Proxy(locals, {
-        get(target, prop: string) {
-          if (prop in target) return target[prop];
-          return (context as Record<string, unknown>)[prop];
-        },
-        set(target, prop: string, value) {
-          target[prop] = value;
-          return true;
-        },
-        has(target, prop: string) {
-          return prop in target || prop in context;
-        },
-        ownKeys() {
-          return [...new Set([...Object.keys(locals), ...Object.keys(context)])];
-        },
+        get(target, prop: string) { return prop in target ? target[prop] : context[prop]; },
+        set(target, prop: string, value) { target[prop] = value; return true; },
+        has(target, prop: string) { return prop in target || prop in context; },
+        ownKeys() { return [...new Set([...Object.keys(locals), ...Object.keys(context)])]; },
         getOwnPropertyDescriptor(target, prop: string) {
           if (prop in target) return { configurable: true, enumerable: true, value: target[prop] };
-          if (prop in context) return { configurable: true, enumerable: true, value: (context as Record<string, unknown>)[prop] };
+          if (prop in context) return { configurable: true, enumerable: true, value: context[prop] };
           return undefined;
         },
       }) as Record<string, unknown>;
-
       output.push(this.renderTokens([...bodyTokens], loopCtx));
     }
 
@@ -3072,49 +2949,8 @@ export class Frond {
     const namespace: Record<string, unknown> = {};
 
     const source = this.load(filename);
-    const tokens = tokenize(source);
-
-    let i = 0;
-    while (i < tokens.length) {
-      const [ttype, raw] = tokens[i];
-      if (ttype === "BLOCK") {
-        const [tagContent] = stripTag(raw);
-        if ((tagContent.split(/\s+/)[0] || "") === "macro") {
-          const macroM = tagContent.match(/^macro\s+(\w+)\s*\(([^)]*)\)/);
-          if (macroM) {
-            const macroName = macroM[1];
-            const params = Frond.parseMacroParams(macroM[2]);
-
-            const bodyTokens: Token[] = [];
-            i++;
-            while (i < tokens.length) {
-              if (tokens[i][0] === "BLOCK" && tokens[i][1].includes("endmacro")) {
-                i++;
-                break;
-              }
-              bodyTokens.push(tokens[i]);
-              i++;
-            }
-
-            // Own copies per macro — avoids closure-over-loop-variable sharing.
-            const capturedBody = [...bodyTokens];
-            const capturedParams = [...params];
-            const capturedCtx = { ...context };
-            const engine = this;
-
-            namespace[macroName] = (...args: unknown[]) => {
-              const macroCtx: Record<string, unknown> = { ...capturedCtx };
-              for (let pi = 0; pi < capturedParams.length; pi++) {
-                const [pname, pdefault] = capturedParams[pi];
-                macroCtx[pname] = pi < args.length ? args[pi] : pdefault;
-              }
-              return new SafeString(engine.renderTokens([...capturedBody], macroCtx));
-            };
-            continue;
-          }
-        }
-      }
-      i++;
+    for (const definition of this.collectMacroDefinitions(tokenize(source))) {
+      namespace[definition.name] = this.createMacro(definition, context);
     }
 
     context[alias] = namespace;
@@ -3128,51 +2964,66 @@ export class Frond {
     const names = m[2].split(",").map(n => n.trim()).filter(Boolean);
 
     const source = this.load(filename);
-    const tokens = tokenize(source);
+    for (const definition of this.collectMacroDefinitions(tokenize(source))) {
+      if (names.includes(definition.name)) {
+        // Add each selected macro before capturing the next one, preserving the
+        // historical ability for a later macro to call an earlier macro.
+        context[definition.name] = this.createMacro(definition, context);
+      }
+    }
+  }
 
+  private collectMacroDefinitions(tokens: Token[]): MacroDefinition[] {
+    const definitions: MacroDefinition[] = [];
     let i = 0;
     while (i < tokens.length) {
-      const [ttype, raw] = tokens[i];
-      if (ttype === "BLOCK") {
-        const [tagContent] = stripTag(raw);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "macro") {
-          const macroM = tagContent.match(/^macro\s+(\w+)\s*\(([^)]*)\)/);
-          if (macroM && names.includes(macroM[1])) {
-            const macroName = macroM[1];
-            const paramNames = Frond.parseMacroParams(macroM[2]);
-
-            const bodyTokens: Token[] = [];
-            i++;
-            while (i < tokens.length) {
-              if (tokens[i][0] === "BLOCK" && tokens[i][1].includes("endmacro")) {
-                i++;
-                break;
-              }
-              bodyTokens.push(tokens[i]);
-              i++;
-            }
+      if (tokens[i][0] !== "BLOCK") {
+        i++;
+        continue;
+      }
+      const [tagContent] = stripTag(tokens[i][1]);
+      if ((tagContent.split(/\s+/)[0] || "") !== "macro") {
+        i++;
+        continue;
+      }
+      const macroMatch = tagContent.match(/^macro\s+(\w+)\s*\(([^)]*)\)/);
+      if (!macroMatch) {
+        i++;
+        continue;
+      }
 
-            // Create closure with its own copy of captured values
-            const capturedBody = [...bodyTokens];
-            const capturedParams = [...paramNames];
-            const capturedCtx = { ...context };
-            const engine = this;
-
-            context[macroName] = (...args: unknown[]) => {
-              const macroCtx: Record<string, unknown> = { ...capturedCtx };
-              for (let pi = 0; pi < capturedParams.length; pi++) {
-                const [pname, pdefault] = capturedParams[pi];
-                macroCtx[pname] = pi < args.length ? args[pi] : pdefault;
-              }
-              return new SafeString(engine.renderTokens([...capturedBody], macroCtx));
-            };
-            continue;
-          }
+      const bodyTokens: Token[] = [];
+      i++;
+      while (i < tokens.length) {
+        if (tokens[i][0] === "BLOCK" && tokens[i][1].includes("endmacro")) {
+          i++;
+          break;
         }
+        bodyTokens.push(tokens[i]);
+        i++;
       }
-      i++;
+      definitions.push({
+        name: macroMatch[1],
+        params: Frond.parseMacroParams(macroMatch[2]),
+        bodyTokens,
+      });
     }
+    return definitions;
+  }
+
+  private createMacro(definition: MacroDefinition, context: Record<string, unknown>): (...args: unknown[]) => SafeString {
+    const capturedBody = [...definition.bodyTokens];
+    const capturedParams = [...definition.params];
+    const capturedCtx = { ...context };
+    const engine = this;
+    return (...args: unknown[]) => {
+      const macroCtx: Record<string, unknown> = { ...capturedCtx };
+      for (let pi = 0; pi < capturedParams.length; pi++) {
+        const [pname, pdefault] = capturedParams[pi];
+        macroCtx[pname] = pi < args.length ? args[pi] : pdefault;
+      }
+      return new SafeString(engine.renderTokens([...capturedBody], macroCtx));
+    };
   }
 
   /**
@@ -3279,69 +3130,70 @@ export class Frond {
     }
     const name = m[1];
     const rest = (m[2] || "").trim();
+    const options = this.parseLiveOptions(rest);
+    const [bodyTokens, i] = this.collectLiveBody(tokens, start);
+
+    // Register the raw body source so the auto endpoint can re-render it.
+    Frond.liveFragments.set(name, bodyTokens.map((t) => t[1]).join(""));
+
+    const attrs = this.liveAttributes(name, options);
+
+    const firstPaint = this.renderTokens([...bodyTokens], context);
+    return [`<div ${attrs.join(" ")}>${firstPaint}</div>`, i];
+  }
+
+  private parseLiveOptions(rest: string): { mode: string; src: string | null; interval: number | null; wsPath: string | null } {
     const parts = rest.split(/\s+/).filter(Boolean);
     const mode = parts[0] || "";
-
-    const sm = rest.match(LIVE_SRC_RE);
-    const src = sm ? sm[1] : null;
-    if (src && (src.startsWith("http://") || src.startsWith("https://") || src.startsWith("//"))) {
+    const sourceMatch = rest.match(LIVE_SRC_RE);
+    const src = sourceMatch ? sourceMatch[1] : null;
+    if (src && /^(?:https?:)?\/\//.test(src)) {
       throw new Error("live: src must be a same-origin path, not an absolute URL");
     }
-
-    let interval: number | null = null;
-    let wsPath: string | null = null;
     if (mode === "poll") {
       if (!parts[1] || !/^\d+$/.test(parts[1])) {
         throw new Error('live: poll requires seconds, e.g. {% live "x" poll 5 %}');
       }
-      interval = parseInt(parts[1], 10);
-    } else if (mode === "sse") {
-      // no extra config
-    } else if (mode === "ws") {
-      const wm = rest.match(LIVE_WS_RE);
-      if (!wm) {
-        throw new Error('live: ws requires a path, e.g. {% live "x" ws "/ws/x" %}');
-      }
-      wsPath = wm[1];
-    } else {
-      throw new Error(`live: unknown transport "${mode}" (use poll N, sse, or ws "path")`);
+      return { mode, src, interval: parseInt(parts[1], 10), wsPath: null };
+    }
+    if (mode === "sse") return { mode, src, interval: null, wsPath: null };
+    if (mode === "ws") {
+      const wsMatch = rest.match(LIVE_WS_RE);
+      if (!wsMatch) throw new Error('live: ws requires a path, e.g. {% live "x" ws "/ws/x" %}');
+      return { mode, src, interval: null, wsPath: wsMatch[1] };
     }
+    throw new Error(`live: unknown transport "${mode}" (use poll N, sse, or ws "path")`);
+  }
 
-    // Collect body tokens up to {% endlive %}. Nested live is unsupported.
-    const bodyTokens: Token[] = [];
+  private collectLiveBody(tokens: Token[], start: number): [Token[], number] {
+    const body: Token[] = [];
     let i = start + 1;
     while (i < tokens.length) {
-      if (tokens[i][0] === "BLOCK") {
-        const [tagContent] = stripTag(tokens[i][1]);
-        const tag = tagContent.split(/\s+/)[0] || "";
-        if (tag === "live") throw new Error("live: nested live blocks are not supported");
-        if (tag === "endlive") {
-          i++;
-          break;
-        }
-        bodyTokens.push(tokens[i]);
-      } else {
-        bodyTokens.push(tokens[i]);
+      if (tokens[i][0] !== "BLOCK") {
+        body.push(tokens[i++]);
+        continue;
       }
-      i++;
+      const [tagContent] = stripTag(tokens[i][1]);
+      const tag = tagContent.split(/\s+/)[0] || "";
+      if (tag === "live") throw new Error("live: nested live blocks are not supported");
+      if (tag === "endlive") return [body, i + 1];
+      body.push(tokens[i++]);
     }
+    return [body, i];
+  }
 
-    // Register the raw body source so the auto endpoint can re-render it.
-    Frond.liveFragments.set(name, bodyTokens.map((t) => t[1]).join(""));
-
-    const endpoint = src || `/__frond/live/${name}`;
+  private liveAttributes(name: string, options: { mode: string; src: string | null; interval: number | null; wsPath: string | null }): string[] {
+    const endpoint = options.src || `/__frond/live/${name}`;
     const attrs = [`data-frond-live="${liveAttr(name)}"`, `id="live-${liveAttr(name)}"`];
-    if (mode === "poll") {
-      attrs.push('data-mode="poll"', `data-interval="${interval}"`, `data-src="${liveAttr(endpoint)}"`);
-    } else if (mode === "sse") {
+    if (options.mode === "poll") {
+      attrs.push('data-mode="poll"', `data-interval="${options.interval}"`, `data-src="${liveAttr(endpoint)}"`);
+    } else if (options.mode === "sse") {
       attrs.push('data-mode="sse"', `data-src="${liveAttr(endpoint)}"`);
-    } else if (mode === "ws") {
-      Frond.liveWsPaths.set(name, wsPath as string);
-      attrs.push('data-mode="ws"', `data-ws="${liveAttr(wsPath)}"`);
+    } else {
+      Frond.liveWsPaths.set(name, options.wsPath as string);
+      attrs.push('data-mode="ws"', `data-ws="${liveAttr(options.wsPath)}"`);
     }
-
-    const firstPaint = this.renderTokens([...bodyTokens], context);
-    return [`<div ${attrs.join(" ")}>${firstPaint}</div>`, i];
+    return attrs;
   }
 
   // ── Live-block class API (mirrors Python master + PHP/Ruby facades) ──