tina4-nodejs 3.10.19 → 3.10.20

package/CLAUDE.md

@@ -1,10 +1,10 @@
-# CLAUDE.md — AI Developer Guide for tina4-nodejs (v3.10.19)
+# CLAUDE.md — AI Developer Guide for tina4-nodejs (v3.10.21)
 
 > This file helps AI assistants (Claude, Copilot, Cursor, etc.) understand and work on this codebase effectively.
 
 ## What This Project Is
 
-Tina4 for Node.js/TypeScript v3.10.19 — a convention-over-configuration structural paradigm. **Not a framework.** The developer writes TypeScript; Tina4 is invisible infrastructure.
+Tina4 for Node.js/TypeScript v3.10.21 — a convention-over-configuration structural paradigm. **Not a framework.** The developer writes TypeScript; Tina4 is invisible infrastructure.
 
 The philosophy: zero ceremony, batteries included, file system as source of truth.
 
@@ -154,6 +154,9 @@ Database layer with auto-CRUD generation, seeding, fake data, and SQL translatio
 - `seeder.ts` — Database seeding (`seedTable` for raw SQL, `seedOrm` for model-based)
 - `sqlTranslation.ts` — Cross-engine SQL translator (`SQLTranslator`) and TTL query cache (`QueryCache`)
 - QueryBuilder supports `toMongo()` for generating MongoDB query documents from the same fluent API
+- `getNextId(table: string, pkColumn?: string, generatorName?: string): Promise<number>` — Race-safe ID generation using atomic sequence table (`tina4_sequences`). SQLite/MySQL/MSSQL use `tina4_sequences` with atomic UPDATE+SELECT. PostgreSQL auto-creates sequences if missing. Firebird uses existing generators (unchanged).
+
+**`tina4_sequences` table** — Auto-created by `getNextId()` on first use for SQLite, MySQL, and MSSQL. Stores the current sequence value per table. Do not modify this table manually.
 
 ### @tina4/swagger (`packages/swagger/`)
 Auto-generates OpenAPI 3.0 docs.
@@ -584,6 +587,8 @@ When adding new features, add a corresponding `test/<feature>.test.ts` file.
 
 - **38 built-in features**, zero third-party dependencies
 - **1,812 tests** passing across all modules
+- **Race-safe `getNextId()`** with atomic sequence table (`tina4_sequences`) for SQLite/MySQL/MSSQL; PostgreSQL auto-creates sequences
+- **Frond template engine optimizations**: pre-compiled regexes, lazy loop context (copy-on-write), filter chain caching, path split caching, inline common filters (11-15% speedup)
 - **Production server auto-detect**: `npx tina4nodejs serve --production` auto-uses cluster mode
 - **`npx tina4nodejs generate`**: model, route, migration, middleware scaffolding
 - **Database**: 5 engines (SQLite, PostgreSQL, MySQL, MSSQL, Firebird), query caching (`TINA4_DB_CACHE=true`)
@@ -607,6 +612,7 @@ When adding new features, add a corresponding `test/<feature>.test.ts` file.
 - **Don't bundle `swagger-ui-dist`** — we load Swagger UI from CDN to stay under 8MB
 - **Don't break the test files** — run `npm test` before committing
 - **Don't add unnecessary dependencies** — minimal footprint is a core principle
+- **Parity across all frameworks** — Every new feature, fix, or optimization must be implemented with equivalent logic AND tests in all 4 Tina4 frameworks (Python, PHP, Ruby, Node.js). Never ship to one without shipping to all.
 - **Don't use `url.parse()`** — use the WHATWG `URL` constructor instead (deprecated in Node 20+)
 
 ## Tina4 Maintainer Skill

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.10.19",
+  "version": "3.10.20",
   "type": "module",
   "description": "This is not a framework. Tina4 for Node.js/TypeScript — zero deps, 38 built-in features.",
   "keywords": ["tina4", "framework", "web", "api", "orm", "graphql", "websocket", "typescript"],

package/packages/frond/src/engine.ts

@@ -22,6 +22,33 @@ class SafeString {
 type TokenType = "TEXT" | "VAR" | "BLOCK" | "COMMENT";
 type Token = [TokenType, string];
 
+// ── Pre-compiled Regexes (module level) ────────────────────────
+
+const NUMERIC_RE = /^-?\d+(\.\d+)?$/;
+const METHOD_CALL_RE = /^(\w+)\s*\(([\s\S]*)?\)$/;
+const FN_CALL_RE = /^([\w.]+)\s*\(([\s\S]*)?\)$/;
+const IS_NOT_RE = /^(.+?)\s+is\s+not\s+(\w+)(.*)$/;
+const IS_RE = /^(.+?)\s+is\s+(\w+)(.*)$/;
+const NOT_IN_RE = /^(.+?)\s+not\s+in\s+(.+)$/;
+const IN_RE = /^(.+?)\s+in\s+(.+)$/;
+const DIVISIBLE_BY_RE = /\s*by\s*\(\s*(\d+)\s*\)/;
+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 FORMAT_RE = /%[sd]/g;
+const LEADING_WS_RE = /^\s+/;
+const TRAILING_WS_RE = /\s+$/;
+const THOUSANDS_RE = /\B(?=(\d{3})+(?!\d))/g;
+
+// ── Caches (module level) ─────────────────────────────────────
+
+/** Cache for parsed filter chains: expr string -> [variable, filters] */
+const filterChainCache = new Map<string, [string, [string, string[]][]]>();
+
+/** Cache for parsed dotted/bracket paths: expr string -> [parts, fromBracket] */
+const pathParseCache = new Map<string, [string[], boolean[]]>();
+
 // ── Lexer ──────────────────────────────────────────────────────
 
 const TOKEN_RE = /(\{%-?\s*[\s\S]*?\s*-?%\})|(\{\{-?\s*[\s\S]*?\s*-?\}\})|(\{#[\s\S]*?#\})/g;
@@ -118,7 +145,7 @@ function resolveVar(expr: string, context: Record<string, unknown>): unknown {
   }
 
   // Numeric literal
-  if (/^-?\d+(\.\d+)?$/.test(expr)) {
+  if (NUMERIC_RE.test(expr)) {
     return expr.includes(".") ? parseFloat(expr) : parseInt(expr, 10);
   }
 
@@ -137,41 +164,50 @@ function resolveVar(expr: string, context: Record<string, unknown>): unknown {
 
   // Dotted path with bracket access — split on . and [...] but not . inside parentheses
   // Track which parts came from bracket access (need variable resolution)
-  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;
+  let parts: string[];
+  let fromBracket: boolean[];
+
+  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;
         }
-        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;
       }
-      current += ch;
+      if (current) { parts.push(current); fromBracket.push(false); }
     }
-    if (current) { parts.push(current); fromBracket.push(false); }
+    pathParseCache.set(expr, [parts, fromBracket]);
   }
 
   let value: unknown = context;
@@ -181,7 +217,7 @@ function resolveVar(expr: string, context: Record<string, unknown>): unknown {
     if (value === null || value === undefined) return null;
 
     // Check for method call: name(args)
-    const methodMatch = part.match(/^(\w+)\s*\(([\s\S]*)?\)$/);
+    const methodMatch = part.match(METHOD_CALL_RE);
     if (methodMatch) {
       const methodName = methodMatch[1];
       const rawArgs = methodMatch[2] || "";
@@ -384,7 +420,7 @@ function evalExpr(expr: string, context: Record<string, unknown>): unknown {
   }
 
   // Function call: name("arg1", "arg2") — supports dotted names like user.t("key")
-  const fnMatch = expr.match(/^([\w.]+)\s*\(([\s\S]*)?\)$/);
+  const fnMatch = expr.match(FN_CALL_RE);
   if (fnMatch) {
     const fnName = fnMatch[1];
     const rawArgs = fnMatch[2] || "";
@@ -483,53 +519,58 @@ function splitOnTilde(expr: string): string[] {
   return parts;
 }
 
-function evalComparison(expr: string, context: Record<string, unknown>): boolean {
+function evalComparison(
+  expr: string,
+  context: Record<string, unknown>,
+  evalFn?: (expr: string, context: Record<string, unknown>) => unknown,
+): boolean {
+  const ev = evalFn ?? evalExpr;
   expr = expr.trim();
 
   // Handle 'not' prefix
   if (expr.startsWith("not ")) {
-    return !evalComparison(expr.slice(4), context);
+    return !evalComparison(expr.slice(4), context, evalFn);
   }
 
   // 'or' (lowest precedence)
   const orParts = splitOnKeyword(expr, " or ");
   if (orParts.length > 1) {
-    return orParts.some(p => evalComparison(p, context));
+    return orParts.some(p => evalComparison(p, context, evalFn));
   }
 
   // 'and'
   const andParts = splitOnKeyword(expr, " and ");
   if (andParts.length > 1) {
-    return andParts.every(p => evalComparison(p, context));
+    return andParts.every(p => evalComparison(p, context, evalFn));
   }
 
   // 'is not' test
-  let m = expr.match(/^(.+?)\s+is\s+not\s+(\w+)(.*)$/);
+  let m = expr.match(IS_NOT_RE);
   if (m) {
-    return !evalTest(m[1].trim(), m[2], m[3].trim(), context);
+    return !evalTest(m[1].trim(), m[2], m[3].trim(), context, evalFn);
   }
 
   // 'is' test
-  m = expr.match(/^(.+?)\s+is\s+(\w+)(.*)$/);
+  m = expr.match(IS_RE);
   if (m) {
-    return evalTest(m[1].trim(), m[2], m[3].trim(), context);
+    return evalTest(m[1].trim(), m[2], m[3].trim(), context, evalFn);
   }
 
   // 'not in'
-  m = expr.match(/^(.+?)\s+not\s+in\s+(.+)$/);
+  m = expr.match(NOT_IN_RE);
   if (m) {
-    const val = evalExpr(m[1].trim(), context);
-    const collection = evalExpr(m[2].trim(), context);
+    const val = ev(m[1].trim(), context);
+    const collection = ev(m[2].trim(), context);
     if (Array.isArray(collection)) return !collection.includes(val);
     if (typeof collection === "string") return !collection.includes(val as string);
     return true;
   }
 
   // 'in'
-  m = expr.match(/^(.+?)\s+in\s+(.+)$/);
+  m = expr.match(IN_RE);
   if (m) {
-    const val = evalExpr(m[1].trim(), context);
-    const collection = evalExpr(m[2].trim(), context);
+    const val = ev(m[1].trim(), context);
+    const collection = ev(m[2].trim(), context);
     if (Array.isArray(collection)) return collection.includes(val);
     if (typeof collection === "string") return collection.includes(val as string);
     return false;
@@ -550,8 +591,8 @@ function evalComparison(expr: string, context: Record<string, unknown>): boolean
     if (opIdx !== -1) {
       const left = expr.slice(0, opIdx).trim();
       const right = expr.slice(opIdx + op.length).trim();
-      const l = evalExpr(left, context);
-      const r = evalExpr(right, context);
+      const l = ev(left, context);
+      const r = ev(right, context);
       try {
         return fn(l, r);
       } catch {
@@ -561,7 +602,7 @@ function evalComparison(expr: string, context: Record<string, unknown>): boolean
   }
 
   // Fall through to simple eval
-  const val = evalExpr(expr, context);
+  const val = ev(expr, context);
   return val !== null && val !== undefined && val !== false && val !== 0 && val !== "";
 }
 
@@ -607,8 +648,10 @@ function evalTest(
   testName: string,
   args: string,
   context: Record<string, unknown>,
+  evalFn?: (expr: string, context: Record<string, unknown>) => unknown,
 ): boolean {
-  const val = evalExpr(valueExpr, context);
+  const ev = evalFn ?? evalExpr;
+  const val = ev(valueExpr, context);
 
   // Check custom tests first
   const customTests = (context as { __frond_tests__?: Record<string, TestFn> }).__frond_tests__;
@@ -631,7 +674,7 @@ function evalTest(
 
   // 'divisible by(n)'
   if (testName === "divisible") {
-    const dm = args.match(/\s*by\s*\(\s*(\d+)\s*\)/);
+    const dm = args.match(DIVISIBLE_BY_RE);
     if (dm) {
       const n = parseInt(dm[1], 10);
       return typeof val === "number" && Number.isInteger(val) && val % n === 0;
@@ -649,6 +692,10 @@ function evalTest(
 // ── Filters ────────────────────────────────────────────────────
 
 function parseFilterChain(expr: string): [string, [string, string[]][]] {
+  // Check cache first
+  const cached = filterChainCache.get(expr);
+  if (cached) return cached;
+
   // Split on | but not inside strings or parentheses
   const parts: string[] = [];
   let current = "";
@@ -683,7 +730,7 @@ function parseFilterChain(expr: string): [string, [string, string[]][]] {
 
   for (let i = 1; i < parts.length; i++) {
     const f = parts[i].trim();
-    const fm = f.match(/^(\w+)\s*\(([\s\S]*)\)$/);
+    const fm = f.match(FILTER_WITH_ARGS_RE);
     if (fm) {
       const name = fm[1];
       const rawArgs = fm[2].trim();
@@ -694,7 +741,9 @@ function parseFilterChain(expr: string): [string, [string, string[]][]] {
     }
   }
 
-  return [variable, filters];
+  const result: [string, [string, string[]][]] = [variable, filters];
+  filterChainCache.set(expr, result);
+  return result;
 }
 
 function parseArgs(raw: string): string[] {
@@ -827,7 +876,7 @@ function numberFormat(value: unknown, decimals: number): string {
   const num = parseFloat(String(value));
   const fixed = num.toFixed(decimals);
   const [intPart, decPart] = fixed.split(".");
-  const formatted = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  const formatted = intPart.replace(THOUSANDS_RE, ",");
   return decPart ? `${formatted}.${decPart}` : formatted;
 }
 
@@ -835,10 +884,10 @@ const BUILTIN_FILTERS: Record<string, FilterFn> = {
   upper: (v) => String(v).toUpperCase(),
   lower: (v) => String(v).toLowerCase(),
   capitalize: (v) => { const s = String(v); return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase(); },
-  title: (v) => String(v).replace(/\b\w/g, c => c.toUpperCase()),
+  title: (v) => String(v).replace(TITLE_WORD_RE, c => c.toUpperCase()),
   trim: (v) => String(v).trim(),
-  ltrim: (v) => String(v).replace(/^\s+/, ""),
-  rtrim: (v) => String(v).replace(/\s+$/, ""),
+  ltrim: (v) => String(v).replace(LEADING_WS_RE, ""),
+  rtrim: (v) => String(v).replace(TRAILING_WS_RE, ""),
   length: (v) => {
     if (Array.isArray(v)) return v.length;
     if (typeof v === "string") return v.length;
@@ -866,7 +915,7 @@ const BUILTIN_FILTERS: Record<string, FilterFn> = {
   safe: (v) => v,
   escape: (v) => htmlEscape(String(v)),
   e: (v) => htmlEscape(String(v)),
-  striptags: (v) => String(v).replace(/<[^>]+>/g, ""),
+  striptags: (v) => String(v).replace(STRIP_TAGS_RE, ""),
   nl2br: (v) => String(v).replace(/\n/g, "<br>\n"),
   abs: (v) => typeof v === "number" ? Math.abs(v) : v,
   round: (v, decimals) => {
@@ -957,7 +1006,7 @@ const BUILTIN_FILTERS: Record<string, FilterFn> = {
     let s = String(v);
     // Simple %s / %d replacement like Python's % operator
     let idx = 0;
-    s = s.replace(/%[sd]/g, () => {
+    s = s.replace(FORMAT_RE, () => {
       const val = idx < args.length ? String(args[idx]) : "";
       idx++;
       return val;
@@ -1259,20 +1308,20 @@ export class Frond {
       } else if (ttype === "VAR") {
         const [content, stripB, stripA] = stripTag(raw);
         if (stripB && output.length > 0) {
-          output[output.length - 1] = output[output.length - 1].replace(/\s+$/, "");
+          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(/^\s+/, "")];
+          tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
         }
         i++;
       } else if (ttype === "BLOCK") {
         const [content, stripB, stripA] = stripTag(raw);
         if (stripB && output.length > 0) {
-          output[output.length - 1] = output[output.length - 1].replace(/\s+$/, "");
+          output[output.length - 1] = output[output.length - 1].replace(TRAILING_WS_RE, "");
         }
 
         const parts = content.split(/\s+/);
@@ -1280,7 +1329,7 @@ export class Frond {
 
         // 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(/^\s+/, "")];
+          tokens[i + 1] = ["TEXT", tokens[i + 1][1].replace(LEADING_WS_RE, "")];
         }
 
         if (tag === "if") {
@@ -1342,7 +1391,7 @@ export class Frond {
         }
 
         if (stripA && i < tokens.length && tokens[i][0] === "TEXT") {
-          tokens[i] = ["TEXT", tokens[i][1].replace(/^\s+/, "")];
+          tokens[i] = ["TEXT", tokens[i][1].replace(LEADING_WS_RE, "")];
         }
       } else {
         i++;
@@ -1401,7 +1450,7 @@ export class Frond {
         // 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(/^(\w+)\s*(!=|==|>=|<=|>|<)\s*(.+)$/);
+        const m = fname.match(FILTER_COMPARISON_RE);
         if (m) {
           const realFilter = m[1];
           const op = m[2];
@@ -1458,6 +1507,40 @@ export class Frond {
         }
       }
 
+      // 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 = JSON.stringify(value); continue;
+          case "dump":       value = JSON.stringify(value); continue;
+          case "nl2br":      value = 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);
@@ -1503,25 +1586,25 @@ export class Frond {
         } 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(/\s+$/, "")];
+            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(/^\s+/, "")];
+            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(/\s+$/, "")];
+            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(/\s+$/, "")];
+            currentTokens[currentTokens.length - 1] = ["TEXT", currentTokens[currentTokens.length - 1][1].replace(TRAILING_WS_RE, "")];
           }
           branches.push([currentCond, currentTokens]);
           currentCond = null; // else branch
@@ -1537,7 +1620,7 @@ export class Frond {
 
     // Evaluate branches
     for (const [cond, branchTokens] of branches) {
-      if (cond === null || evalComparison(cond, context)) {
+      if (cond === null || evalComparison(cond, context, this.evalVarRaw.bind(this))) {
         return [this.renderTokens([...branchTokens], context), i];
       }
     }
@@ -1613,38 +1696,70 @@ export class Frond {
       : Array.isArray(iterable) ? iterable : [];
     const total = items.length;
 
+    // Reusable loop object — mutated each iteration to avoid allocation
+    const loopObj = {
+      index: 0,
+      index0: 0,
+      first: false,
+      last: false,
+      length: total,
+      revindex: 0,
+      revindex0: 0,
+      even: false,
+      odd: false,
+    };
+
     for (let idx = 0; idx < total; idx++) {
       const item = items[idx];
-      const loopCtx: Record<string, unknown> = { ...context };
-      loopCtx.loop = {
-        index: idx + 1,
-        index0: idx,
-        first: idx === 0,
-        last: idx === total - 1,
-        length: total,
-        revindex: total - idx,
-        revindex0: total - idx - 1,
-        even: (idx + 1) % 2 === 0,
-        odd: (idx + 1) % 2 !== 0,
-      };
+
+      // 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.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];
-        if (var2) {
-          loopCtx[var1] = key;
-          loopCtx[var2] = value;
-        } else {
-          loopCtx[var1] = key;
-        }
+        locals[var1] = key;
+        if (var2) locals[var2] = value;
       } else {
         if (var2) {
-          loopCtx[var1] = idx;
-          loopCtx[var2] = item;
+          locals[var1] = idx;
+          locals[var2] = item;
         } else {
-          loopCtx[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)])];
+        },
+        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] };
+          return undefined;
+        },
+      }) as Record<string, unknown>;
+
       output.push(this.renderTokens([...bodyTokens], loopCtx));
     }
 

package/packages/orm/src/database.ts

@@ -400,18 +400,100 @@ export class Database {
     return typeof id === "bigint" ? id.toString() : id;
   }
 
+  /**
+   * Create the tina4_sequences table if it doesn't exist.
+   * Used by sequenceNext() for race-safe ID generation on
+   * SQLite, MySQL, MSSQL, and as a PostgreSQL fallback.
+   */
+  private ensureSequenceTable(): void {
+    const adapter = this.getNextAdapter();
+
+    if (!adapter.tableExists("tina4_sequences")) {
+      if (this.dbType === "mssql") {
+        adapter.execute(
+          "CREATE TABLE tina4_sequences (" +
+          "seq_name VARCHAR(200) NOT NULL PRIMARY KEY, " +
+          "current_value INTEGER NOT NULL DEFAULT 0)"
+        );
+      } else {
+        adapter.execute(
+          "CREATE TABLE IF NOT EXISTS tina4_sequences (" +
+          "seq_name VARCHAR(200) NOT NULL PRIMARY KEY, " +
+          "current_value INTEGER NOT NULL DEFAULT 0)"
+        );
+      }
+      try { adapter.commit(); } catch { /* no active transaction */ }
+    }
+  }
+
+  /**
+   * Atomically increment and return the next value from the sequence table.
+   *
+   * If the sequence row doesn't exist yet, seeds it from MAX(pkColumn)
+   * of the given table (or 0 if the table is empty/missing).
+   */
+  private sequenceNext(seqName: string, table?: string, pkColumn = "id"): number {
+    this.ensureSequenceTable();
+    const adapter = this.getNextAdapter();
+
+    // Check if the sequence row exists
+    const existing = adapter.fetchOne<Record<string, unknown>>(
+      "SELECT current_value FROM tina4_sequences WHERE seq_name = ?",
+      [seqName]
+    );
+
+    if (existing == null) {
+      // Seed from current MAX
+      let seedValue = 0;
+      if (table) {
+        try {
+          const maxRow = adapter.fetchOne<Record<string, unknown>>(
+            `SELECT MAX(${pkColumn}) AS max_id FROM ${table}`
+          );
+          if (maxRow?.max_id != null) {
+            seedValue = Number(maxRow.max_id);
+          }
+        } catch {
+          // Table doesn't exist — start at 0
+        }
+      }
+
+      adapter.execute(
+        "INSERT INTO tina4_sequences (seq_name, current_value) VALUES (?, ?)",
+        [seqName, seedValue]
+      );
+      try { adapter.commit(); } catch { /* no active transaction */ }
+    }
+
+    // Atomic increment
+    adapter.execute(
+      "UPDATE tina4_sequences SET current_value = current_value + 1 WHERE seq_name = ?",
+      [seqName]
+    );
+    try { adapter.commit(); } catch { /* no active transaction */ }
+
+    // Read the new value
+    const row = adapter.fetchOne<Record<string, unknown>>(
+      "SELECT current_value FROM tina4_sequences WHERE seq_name = ?",
+      [seqName]
+    );
+    return row?.current_value != null ? Number(row.current_value) : 1;
+  }
+
   /**
    * Pre-generate the next available primary key ID using engine-aware strategies.
    *
-   * - Firebird: auto-creates a generator if missing, then increments via GEN_ID.
-   * - PostgreSQL: tries nextval() on the standard sequence, falls through to MAX+1.
-   * - SQLite/MySQL/MSSQL: uses MAX(pk) + 1.
+   * - Firebird: auto-creates a generator if missing, then increments via GEN_ID (atomic).
+   * - PostgreSQL: tries nextval() first; if sequence missing, auto-creates it
+   *   seeded from MAX; falls through to sequence table on failure.
+   * - SQLite/MySQL/MSSQL: uses tina4_sequences table with atomic UPDATE + SELECT
+   *   (race-safe, replaces old MAX+1).
    * - Returns 1 if the table is empty or does not exist.
    */
   getNextId(table: string, pkColumn = "id", generatorName?: string): number {
     const adapter = this.getNextAdapter();
 
-    // Firebird — use generators
+    // Firebird — use generators (atomic)
     if (this.dbType === "firebird") {
       const genName = generatorName ?? `GEN_${table.toUpperCase()}_ID`;
 
@@ -426,27 +508,38 @@ export class Database {
       return Number(row?.NEXT_ID ?? row?.next_id ?? 1);
     }
 
-    // PostgreSQL — try sequence first, fall through to MAX
+    // PostgreSQL — try sequence first, auto-create if missing, fall through to sequence table
     if (this.dbType === "postgres") {
-      const seqName = `${table.toLowerCase()}_${pkColumn.toLowerCase()}_seq`;
+      const seqName = generatorName ?? `${table.toLowerCase()}_${pkColumn.toLowerCase()}_seq`;
       try {
         const row = adapter.fetchOne<Record<string, unknown>>(`SELECT nextval('${seqName}') AS next_id`);
         if (row?.next_id != null) {
           return Number(row.next_id);
         }
       } catch {
-        // No sequence — fall through to MAX
+        // Sequence doesn't exist — try to auto-create it
       }
-    }
 
-    // SQLite / MySQL / MSSQL / PostgreSQL fallback — MAX + 1
-    try {
-      const row = adapter.fetchOne<Record<string, unknown>>(`SELECT MAX(${pkColumn}) + 1 AS next_id FROM ${table}`);
-      const nextId = row?.next_id;
-      return nextId != null ? Number(nextId) : 1;
-    } catch {
-      return 1;
+      // Auto-create sequence seeded from MAX
+      try {
+        const maxRow = adapter.fetchOne<Record<string, unknown>>(
+          `SELECT COALESCE(MAX(${pkColumn}), 0) AS max_id FROM ${table}`
+        );
+        const start = maxRow?.max_id != null ? Number(maxRow.max_id) + 1 : 1;
+        adapter.execute(`CREATE SEQUENCE ${seqName} START WITH ${start}`);
+        try { adapter.commit(); } catch { /* no active transaction */ }
+        const row = adapter.fetchOne<Record<string, unknown>>(`SELECT nextval('${seqName}') AS next_id`);
+        if (row?.next_id != null) {
+          return Number(row.next_id);
+        }
+      } catch {
+        // Fall through to sequence table
+      }
     }
+
+    // SQLite / MySQL / MSSQL / PostgreSQL fallback — atomic sequence table
+    const seqKey = generatorName ?? `${table}.${pkColumn}`;
+    return this.sequenceNext(seqKey, table, pkColumn);
   }
 }