tina4-nodejs 3.13.70 → 3.13.72

package/packages/core/src/devAdmin.ts

@@ -550,6 +550,13 @@ export class DevAdmin {
       { method: "POST", pattern: "/__dev/api/supervise/cancel", handler: handleSuperviseStub },
       // Execute — proxies to the framework_port+2000 Rust agent (SSE passthrough)
       { method: "POST", pattern: "/__dev/api/execute", handler: handleExecute },
+      // Framework-grounding MCP token config — self-contained (.env upsert)
+      { method: "GET", pattern: "/__dev/api/grounding/status", handler: handleGroundingStatus },
+      { method: "POST", pattern: "/__dev/api/grounding/token", handler: handleGroundingToken },
+      // Scaffold run chips — project-level operations (distinct from create)
+      { method: "POST", pattern: "/__dev/api/migrate", handler: handleMigrate },
+      { method: "POST", pattern: "/__dev/api/test", handler: handleTest },
+      { method: "POST", pattern: "/__dev/api/seed/run", handler: handleSeedRun },
       // File browser / editor
       { method: "GET", pattern: "/__dev/api/files", handler: handleFiles },
       { method: "GET", pattern: "/__dev/api/file", handler: handleFileRead },
@@ -922,27 +929,71 @@ const handleMessagesSearch: RouteHandler = (req, res) => {
 
 // -- Queue handlers --
 
-const handleQueue: RouteHandler = (req, res) => {
+/**
+ * Map a file-backed QueueJob (LiteBackend on-disk shape) to the shared JS
+ * dev-admin format the SPA queue panel renders.
+ */
+function mapQueueJob(job: any, topic: string, status: string) {
+  return {
+    id: job?.id ?? "",
+    topic: job?.topic ?? topic,
+    status,
+    attempts: Number(job?.attempts ?? 0) || 0,
+    created_at: job?.createdAt ?? job?.created_at ?? "",
+    data: job?.payload ?? {},
+  };
+}
+
+const handleQueue: RouteHandler = async (req, res) => {
   const url = new URL(req.url ?? "/", "http://localhost");
+  const topic = url.searchParams.get("topic") ?? "default";
   const statusFilter = url.searchParams.get("status") ?? "";
-  const data = DevQueue.stats();
-  let jobs = data.jobs;
-  if (statusFilter) {
-    jobs = jobs.filter((j) => j.status === statusFilter);
-  }
-  // Map to shared JS format: topic, attempts, created_at, data
-  const mappedJobs = jobs.map((j) => ({
-    id: j.id,
-    topic: j.name,
-    status: j.status,
-    attempts: 1,
-    created_at: j.timestamp,
-    data: j.payload ?? {},
-  }));
-  res.json({
-    stats: { pending: data.pending, completed: data.completed, failed: data.failed, reserved: data.reserved },
-    jobs: mappedJobs,
-  });
+  try {
+    const { Queue } = await import("./queue.js");
+    const queue = new Queue({ topic });
+
+    const stats = {
+      pending: queue.size("pending"),
+      completed: queue.size("completed"),
+      failed: queue.size("failed"),
+      reserved: queue.size("reserved"),
+    };
+
+    // Jobs by status — parity with Python's _api_queue: list PENDING by reading
+    // the on-disk queue files directly (data/queue/<topic>/*.queue-data), then
+    // fold in the file-backed failed() + deadLetters() jobs. This is why real
+    // persisted jobs now show even though DevQueue (in-memory) is empty.
+    const jobs: Array<ReturnType<typeof mapQueueJob>> = [];
+
+    if (!statusFilter || statusFilter === "pending") {
+      const queueDir = join(process.cwd(), "data", "queue", topic);
+      if (existsSync(queueDir)) {
+        for (const filename of readdirSync(queueDir).sort()) {
+          if (!filename.endsWith(".queue-data")) continue; // skips failed/ + reserved/ subdirs
+          try {
+            const job = JSON.parse(readFileSync(join(queueDir, filename), "utf-8"));
+            jobs.push(mapQueueJob(job, topic, "pending"));
+          } catch {
+            // skip corrupt files
+          }
+        }
+      }
+    }
+    if (!statusFilter || statusFilter === "failed") {
+      for (const j of queue.failed()) jobs.push(mapQueueJob(j, topic, "failed"));
+    }
+    if (!statusFilter || statusFilter === "dead") {
+      for (const j of queue.deadLetters()) jobs.push(mapQueueJob(j, topic, "dead_letter"));
+    }
+
+    res.json({ stats, jobs });
+  } catch (e: any) {
+    res.json({
+      stats: { pending: 0, completed: 0, failed: 0, reserved: 0 },
+      jobs: [],
+      error: String(e?.message ?? e),
+    });
+  }
 };
 
 const handleQueueTopics: RouteHandler = (_req, res) => {
@@ -970,23 +1021,20 @@ const handleQueueTopics: RouteHandler = (_req, res) => {
   }
 };
 
-const handleQueueDeadLetters: RouteHandler = (req, res) => {
+const handleQueueDeadLetters: RouteHandler = async (req, res) => {
   const url = new URL(req.url ?? "/", "http://localhost");
   const topic = url.searchParams.get("topic") ?? "default";
-  // DevQueue is in-memory and has no separate dead-letter store yet;
-  // surface failed jobs as dead letters until the queue backend is wired in.
-  const data = DevQueue.stats();
-  const jobs = data.jobs
-    .filter((j) => j.status === "failed")
-    .map((j) => ({
-      id: j.id,
-      topic: j.name,
-      status: "dead_letter",
-      attempts: 1,
-      created_at: j.timestamp,
-      data: j.payload ?? {},
-    }));
-  res.json({ jobs, count: jobs.length, topic });
+  // Parity with Python's _api_queue_dead_letters: read the file-backed
+  // dead-letter store (data/queue/<topic>/failed/*.queue-data) so real
+  // exhausted-retry jobs surface, not just the empty in-memory DevQueue.
+  try {
+    const { Queue } = await import("./queue.js");
+    const queue = new Queue({ topic });
+    const jobs = queue.deadLetters().map((j) => mapQueueJob(j, topic, "dead_letter"));
+    res.json({ jobs, count: jobs.length, topic });
+  } catch (e: any) {
+    res.json({ jobs: [], count: 0, topic, error: String(e?.message ?? e) });
+  }
 };
 
 const handleQueueRetry: RouteHandler = (_req, res) => {
@@ -1052,17 +1100,53 @@ const handleMailboxClear: RouteHandler = (req, res) => {
   res.json({ cleared: true, folder: folder ?? "all" });
 };
 
-// -- Database handlers (stubs) --
+// -- Database handlers --
 
-const handleTable: RouteHandler = (req, res) => {
+/**
+ * Quote a (optionally schema-qualified) table reference for safe interpolation.
+ * Returns null for anything that isn't one or two plain SQL identifiers, so a
+ * hostile ?name= can never reach the SELECT. Mirrors the identifier guard the
+ * sqlite adapter uses for PRAGMA table_info.
+ */
+function quoteTableRef(name: string): string | null {
+  const parts = name.split(".");
+  if (parts.length === 0 || parts.length > 2) return null;
+  for (const p of parts) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(p)) return null;
+  }
+  return parts.map((p) => `"${p}"`).join(".");
+}
+
+const handleTable: RouteHandler = async (req, res) => {
   const url = new URL(req.url ?? "/", "http://localhost");
   const name = url.searchParams.get("name") ?? "";
   if (!name) {
     res.json({ error: "Missing table name parameter" });
     return;
   }
-  // Stub response — actual implementation will use ORM adapter
-  res.json({ table: name, columns: [], rows: [], message: "Database not connected or table not found" });
+  // Real implementation — parity with Python's _api_table_info: return the
+  // table's column list + a sample of up to 20 rows via the same DB adapter
+  // `tables`/`query` use.
+  try {
+    const { getAdapter } = await import("../../orm/src/index.js");
+    const db = getAdapter();
+    const columns = db.columns(name);
+    if (!columns.length) {
+      res.json({ table: name, columns: [], rows: [], message: "Database not connected or table not found" });
+      return;
+    }
+    const ref = quoteTableRef(name);
+    if (!ref) {
+      // Columns resolved but the name isn't a plain identifier we'll splice
+      // into SQL — surface the schema without the sample rather than risk it.
+      res.json({ table: name, columns, rows: [], count: 0, message: "Invalid table name for sampling" });
+      return;
+    }
+    const rows = db.fetch(`SELECT * FROM ${ref} LIMIT 20`);
+    res.json({ table: name, columns, rows, count: rows.length });
+  } catch (e) {
+    res.json({ table: name, columns: [], rows: [], message: (e as Error)?.message ?? "Database not connected or table not found" });
+  }
 };
 
 const handleTables: RouteHandler = async (_req, res) => {
@@ -1422,6 +1506,147 @@ const handleChat: RouteHandler = async (req, res) => {
   await proxyToSupervisor(req, res, "/chat");
 };
 
+// -- Framework-grounding (mcp.tina4.com) token config --
+//
+// TINA4_MCP_TOKEN grounds the coder against mcp.tina4.com's tina4_context.
+// These routes are self-contained: they read/write the token in the project
+// .env directly (no dependency on the Rust agent being up), matching the
+// python/php/ruby dev_admin. The agent still resolves the same TINA4_MCP_TOKEN
+// (process env → .env) when it runs.
+//   GET  /__dev/api/grounding/status → {configured, last4, url}
+//   POST /__dev/api/grounding/token  → upsert TINA4_MCP_TOKEN in .env
+const DEFAULT_MCP_URL = "https://mcp.tina4.com";
+
+/** Resolve a var from the live process env, falling back to the project .env. */
+function resolveDevEnvVar(key: string): string {
+  const live = process.env[key];
+  if (live !== undefined && live !== "") return live;
+  const envPath = join(process.cwd(), ".env");
+  if (!existsSync(envPath)) return "";
+  for (const line of readFileSync(envPath, "utf-8").split("\n")) {
+    const t = line.trim();
+    if (!t || t.startsWith("#") || !t.includes("=")) continue;
+    const eq = t.indexOf("=");
+    if (t.slice(0, eq).trim() === key) return t.slice(eq + 1).trim();
+  }
+  return "";
+}
+
+/** Upsert KEY=value into the project .env (creates the file if absent). */
+function upsertDevEnvVar(key: string, value: string): void {
+  const envPath = join(process.cwd(), ".env");
+  const lines = existsSync(envPath) ? readFileSync(envPath, "utf-8").split("\n") : [];
+  let found = false;
+  const out: string[] = [];
+  for (const line of lines) {
+    const t = line.trim();
+    if (!t || t.startsWith("#") || !t.includes("=")) { out.push(line); continue; }
+    if (t.slice(0, t.indexOf("=")).trim() === key) { out.push(`${key}=${value}`); found = true; }
+    else out.push(line);
+  }
+  if (!found) out.push(`${key}=${value}`);
+  writeFileSync(envPath, out.join("\n").replace(/\n+$/, "") + "\n");
+}
+
+const handleGroundingStatus: RouteHandler = async (_req, res) => {
+  const token = resolveDevEnvVar("TINA4_MCP_TOKEN");
+  const url = resolveDevEnvVar("TINA4_MCP_URL") || DEFAULT_MCP_URL;
+  res.json({ configured: token.length > 0, last4: token ? token.slice(-4) : "", url });
+};
+const handleGroundingToken: RouteHandler = async (req, res) => {
+  const body = (req.body as Record<string, unknown>) || {};
+  const token = String(body.token ?? "").trim();
+  try {
+    upsertDevEnvVar("TINA4_MCP_TOKEN", token);
+    // Reflect into the live process env so a follow-up status reads back at once.
+    process.env.TINA4_MCP_TOKEN = token;
+    res.json({ ok: true, configured: token.length > 0, last4: token ? token.slice(-4) : "" });
+  } catch (e) {
+    res.json({ ok: false, error: (e as Error).message }, 500);
+  }
+};
+
+// -- Scaffold run chips: migrate / test / seed-all --
+//
+// The dev-admin's ▶ Migrate / ▶ Test / ▶ Seed chips are project-level
+// operations, distinct from the create endpoint (/scaffold/run). Each uses the
+// framework's own machinery so behaviour matches the CLI.
+
+/** POST /__dev/api/migrate — apply pending migrations via the ORM's migrate(). */
+const handleMigrate: RouteHandler = async (_req, res) => {
+  try {
+    const orm = await import("../../orm/src/index.js");
+    const result = await orm.migrate();
+    res.json({
+      ok: result.failed.length === 0,
+      applied: result.applied,
+      skipped: result.skipped,
+      failed: result.failed,
+    });
+  } catch (e) {
+    res.json({ ok: false, error: (e as Error).message }, 500);
+  }
+};
+
+/** POST /__dev/api/seed/run — seed every discovered model, FK-ordered. */
+const handleSeedRun: RouteHandler = async (req, res) => {
+  const body = (req.body as Record<string, unknown>) || {};
+  const count = parseInt(String(body.count ?? "10"), 10) || 10;
+  try {
+    const orm = await import("../../orm/src/index.js");
+    // Models live in src/orm/ (primary) and src/models/ (fallback) — same dirs
+    // the server discovers on startup.
+    const dirs = ["src/orm", "src/models"].map((d) => resolve(process.cwd(), d)).filter((d) => existsSync(d));
+    const classes: unknown[] = [];
+    for (const dir of dirs) {
+      for (const m of await orm.discoverModels(dir)) classes.push(m.modelClass);
+    }
+    if (classes.length === 0) {
+      res.json({ ok: false, error: "No models found in src/orm/ or src/models/" }, 400);
+      return;
+    }
+    const summaries = await orm.seedModels(classes as never[], count);
+    let seeded = 0, failed = 0;
+    for (const s of Object.values(summaries) as Array<{ seeded: number; failed: number }>) {
+      seeded += s.seeded; failed += s.failed;
+    }
+    res.json({ ok: failed === 0, seeded, failed, tables: Object.keys(summaries).length });
+  } catch (e) {
+    res.json({ ok: false, error: (e as Error).message }, 500);
+  }
+};
+
+/** POST /__dev/api/test — run the project test suite (`npm test`) and stream back
+ *  the combined output + exit code. Bounded timeout so a hung suite can't wedge
+ *  the dev server. */
+const handleTest: RouteHandler = async (_req, res) => {
+  try {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const run = promisify(execFile);
+    try {
+      const { stdout, stderr } = await run("npm", ["test"], {
+        cwd: resolve(process.cwd()),
+        timeout: 180_000,
+        encoding: "utf-8",
+        maxBuffer: 8 * 1024 * 1024,
+      });
+      res.json({ ok: true, code: 0, output: `${stdout}${stderr}` });
+    } catch (err) {
+      // Non-zero exit (failing tests) lands here — that's a valid, reportable
+      // result, not a 500. Surface the output + code so the UI shows failures.
+      const e = err as { code?: number; stdout?: string; stderr?: string; message?: string };
+      res.json({
+        ok: false,
+        code: typeof e.code === "number" ? e.code : 1,
+        output: `${e.stdout ?? ""}${e.stderr ?? ""}` || e.message || "tests failed",
+      });
+    }
+  } catch (e) {
+    res.json({ ok: false, error: (e as Error).message }, 500);
+  }
+};
+
 // -- Threads handlers --
 
 /**

package/packages/core/src/request.ts

@@ -46,10 +46,36 @@ export function createRequest(req: IncomingMessage): Tina4Request {
   const host = (Array.isArray(xfHost) ? xfHost[0] : xfHost)
     ?? (req.headers.host ?? "localhost");
 
-  const url = new URL(req.url ?? "/", `${proto}://${host}`);
+  // Parse the request-target into path + query. The WHATWG `URL` parser THROWS
+  // `ERR_INVALID_URL` on malformed targets like `//`, `///`, and `/\` — and this
+  // runs BEFORE the dispatch try/catch, with the uncaughtException net only wired
+  // under TINA4_DEBUG, so an unguarded throw crashes the worker in production
+  // (unauthenticated remote DoS — scanners send `//` routinely). Guard it: on a
+  // parse failure, derive the path/query straight from the raw target so routing
+  // proceeds to a normal 404 instead of taking the process down. (#33)
   const query: Record<string, string> = {};
-  for (const [key, value] of url.searchParams) {
-    query[key] = value;
+  let path: string;
+  let queryString: string;
+  let fullUrl: string;
+  try {
+    const url = new URL(req.url ?? "/", `${proto}://${host}`);
+    for (const [key, value] of url.searchParams) {
+      query[key] = value;
+    }
+    path = url.pathname;
+    queryString = url.search.replace(/^\?/, "");
+    fullUrl = url.toString();
+  } catch {
+    const rawTarget = req.url ?? "/";
+    const questionIdx = rawTarget.indexOf("?");
+    path = questionIdx >= 0 ? rawTarget.slice(0, questionIdx) : rawTarget;
+    queryString = questionIdx >= 0 ? rawTarget.slice(questionIdx + 1) : "";
+    try {
+      for (const [key, value] of new URLSearchParams(queryString)) {
+        query[key] = value;
+      }
+    } catch { /* unparseable query — leave query empty, still route the path */ }
+    fullUrl = `${proto}://${host}${rawTarget}`;
   }
 
   tReq.params = {};
@@ -58,9 +84,9 @@ export function createRequest(req: IncomingMessage): Tina4Request {
   // `path` is the URL path only; `queryString` is the raw query without "?".
   // `url` is overridden from Node's IncomingMessage.url (path+query) to the
   // full absolute URL — parity with PHP/Python/Ruby.
-  tReq.path = url.pathname;
-  tReq.queryString = url.search.replace(/^\?/, "");
-  tReq.url = url.toString();
+  tReq.path = path;
+  tReq.queryString = queryString;
+  tReq.url = fullUrl;
   tReq.body = undefined;
   tReq.files = {};
   tReq.contentType = (req.headers["content-type"] ?? "") as string;

package/packages/frond/src/engine.ts

@@ -628,6 +628,41 @@ function evalExpr(expr: string, context: Record<string, unknown>): unknown {
     }
   }
 
+  // Filter pipe: value | filter1 | filter2(args). In Twig `|` binds TIGHTER than
+  // concat (`~`), comparisons and arithmetic, but looser than member/function
+  // access — so it is resolved here, AFTER those operators have had a chance to
+  // split the expression. Handling it inside the expression evaluator (not only
+  // at the {{ }} output layer) makes filters work at any nesting depth: concat
+  // operands, ternary branches, and parenthesised sub-expressions. This fixes
+  // both the `|`-vs-`~` precedence bug and the "pipe inside parens returns empty"
+  // defect. (#171)
+  if (findOutsideQuotes(expr, "|") >= 0) {
+    const [baseExpr, filters] = parseFilterChain(expr);
+    if (filters.length > 0) {
+      const baseValue = evalExpr(baseExpr, context);
+      const applier = (context as {
+        __frond_apply_filters__?: (
+          value: unknown,
+          filters: [string, unknown[]][],
+          context: Record<string, unknown>,
+        ) => unknown;
+      }).__frond_apply_filters__;
+      if (applier) {
+        return applier(baseValue, filters, context);
+      }
+      // No Frond instance in context (evalExpr used stand-alone) — apply the
+      // built-in filters directly so common cases still resolve.
+      let value = baseValue;
+      for (const [fname, rawArgs] of filters) {
+        if (fname === "raw" || fname === "safe") continue;
+        const args = rawArgs.map((a) => (a instanceof VarRef ? evalExpr(a.name, context) : a));
+        const fn = BUILTIN_FILTERS[fname];
+        if (fn) value = fn(value, ...args);
+      }
+      return value;
+    }
+  }
+
   // Function call: name("arg1", "arg2") — supports dotted names like user.t("key")
   const fnMatch = expr.match(FN_CALL_RE);
   if (fnMatch) {
@@ -1131,12 +1166,17 @@ function wordwrap(text: string, width: number): string {
   return lines.join("\n");
 }
 
-function numberFormat(value: unknown, decimals: number): string {
+function numberFormat(
+  value: unknown,
+  decimals: number,
+  decimalPoint = ".",
+  thousandsSep = ",",
+): string {
   const num = parseFloat(String(value));
   const fixed = num.toFixed(decimals);
   const [intPart, decPart] = fixed.split(".");
-  const formatted = intPart.replace(THOUSANDS_RE, ",");
-  return decPart ? `${formatted}.${decPart}` : formatted;
+  const formatted = intPart.replace(THOUSANDS_RE, thousandsSep);
+  return decPart ? `${formatted}${decimalPoint}${decPart}` : formatted;
 }
 
 const BUILTIN_FILTERS: Record<string, FilterFn> = {
@@ -1248,7 +1288,15 @@ const BUILTIN_FILTERS: Record<string, FilterFn> = {
       return null;
     });
   },
-  number_format: (v, decimals) => numberFormat(v, decimals !== undefined ? parseInt(String(decimals), 10) : 0),
+  // Twig signature: number_format(decimals=0, decimalPoint='.', thousandsSep=',').
+  // 1-arg (or no-arg) calls keep the original output; args 2/3 enable localized
+  // formats like `1.234,50`. (#170)
+  number_format: (v, decimals, decimalPoint, thousandsSep) => numberFormat(
+    v,
+    decimals !== undefined ? parseInt(String(decimals), 10) : 0,
+    decimalPoint !== undefined ? String(decimalPoint) : ".",
+    thousandsSep !== undefined ? String(thousandsSep) : ",",
+  ),
   date: (v, fmt) => dateFilter(v, fmt !== undefined ? String(fmt) : "%Y-%m-%d"),
   truncate: (v, length) => {
     const s = String(v);
@@ -1486,6 +1534,13 @@ export class Frond {
   /** Token pre-compilation cache for string templates */
   private compiledStrings = new Map<string, { tokens: Token[]; cachedAt: number }>();
 
+  /**
+   * Bound reference to `applyFilters`, stashed into the render context as
+   * `__frond_apply_filters__` so the module-level `evalExpr` can resolve a
+   * filter pipe using THIS instance's registered filters. Bound once. (#171)
+   */
+  private readonly _applyFiltersBound = this.applyFilters.bind(this);
+
   getTemplateDir(): string { return this.templateDir; }
 
   constructor(templateDir: string = "src/templates") {
@@ -1819,6 +1874,12 @@ export class Frond {
   }
 
   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)
+    // filters. The currently-rendering engine always wins — an included/macro
+    // template rendered by another engine re-stamps its own here. (#171)
+    (context as { __frond_apply_filters__?: unknown }).__frond_apply_filters__ = this._applyFiltersBound;
+
     const output: string[] = [];
     let i = 0;
 
@@ -1948,6 +2009,78 @@ export class Frond {
     return i;
   }
 
+  /**
+   * Apply a parsed filter chain to an already-evaluated value. This is the
+   * instance-aware filter engine used by `evalExpr` (via the
+   * `__frond_apply_filters__` hook in the render context) so filters resolve
+   * with this Frond's registered/custom filters at ANY nesting depth — inside
+   * concat operands, ternary branches, and parenthesised sub-expressions — not
+   * only at the top-level {{ }} output. Mirrors the filter loop in
+   * `evalVarRaw`: `first`/`last` tail-paths, registered `this.filters`, and the
+   * trailing-comparison form (`length != 1`). Auto-escaping stays the caller's
+   * concern (`evalVarInner`). (#171)
+   */
+  private applyFilters(
+    value: unknown,
+    filters: [string, unknown[]][],
+    context: Record<string, unknown>,
+  ): unknown {
+    for (const [fname, rawArgs] of filters) {
+      const args = rawArgs.map((a) => (a instanceof VarRef ? evalExpr(a.name, context) : a));
+      if (fname === "raw" || fname === "safe") continue;
+
+      // Sandbox: a blocked filter is silently skipped (value passes through
+      // 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);
+        }
+      }
+    }
+    return value;
+  }
+
   private evalVar(expr: string, context: Record<string, unknown>): unknown {
     // Check for top-level ternary BEFORE splitting filters so that
     // expressions like ``products|length != 1 ? "s" : ""`` work correctly.
@@ -1974,6 +2107,12 @@ export class Frond {
       const args = rawArgs.map((a) => (a instanceof VarRef ? evalExpr(a.name, context) : a));
       if (fname === "raw" || fname === "safe") continue;
 
+      // Sandbox: a blocked filter is silently skipped (value passes through
+      // 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
@@ -2044,6 +2183,20 @@ export class Frond {
       }
     }
 
+    // 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;
+    }
+
     let value = evalExpr(varName, context);
 
     let isSafe = false;