]`; search `change` → `query` |
+| `AUTHOR` | `
+{/snippet}
+
+{#snippet admin_setup(state: DashboardState, dispatch: DashboardDispatch)}
+ {@const current = String(state.selections['admin_setup'] ?? 'profile')}
+
+{/snippet}
+
+{#snippet admin_email(state: DashboardState, dispatch: DashboardDispatch)}
+
+{/snippet}
+
+{#snippet tabs(state: DashboardState, dispatch: DashboardDispatch)}
+
+ {@render threshold_form(state, dispatch)}
+ {@render approval_choice(state, dispatch)}
+ {@render audit_search(state, dispatch)}
+ {@render rule_editor(state, dispatch)}
+ {@render admin_setup(state, dispatch)}
+ {@render admin_email(state, dispatch)}
+
+{/snippet}
+
+{#snippet admin_view(state: DashboardState, dispatch: DashboardDispatch)}
+
+ {@render tabs(state, dispatch)}
+
+{/snippet}
+
+{@render admin_view(state, dispatch)}
diff --git a/packages/pro/tests/resolvers/__fixtures__/expected-interactive/vue/Dashboard.vue b/packages/pro/tests/resolvers/__fixtures__/expected-interactive/vue/Dashboard.vue
new file mode 100644
index 0000000..155b7f7
--- /dev/null
+++ b/packages/pro/tests/resolvers/__fixtures__/expected-interactive/vue/Dashboard.vue
@@ -0,0 +1,135 @@
+
+
+
+
diff --git a/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/python/resilient_etl.py b/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/python/resilient_etl.py
new file mode 100644
index 0000000..c8010d9
--- /dev/null
+++ b/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/python/resilient_etl.py
@@ -0,0 +1,168 @@
+"""
+Generated by NOMARK Intents resolver (target: python).
+Composition: resilient_etl v0.4.0
+ETL with retried fetch, error-handled validate, persisted records, and a compensating undo for the persist step.
+"""
+from __future__ import annotations
+import asyncio
+import dataclasses
+import json
+import os
+import random
+import re
+import time
+import uuid
+from typing import Any, Callable, Dict, List, Optional
+@dataclasses.dataclass
+class Ctx:
+ input: Any = None
+ values: Dict[str, Any] = dataclasses.field(default_factory=dict)
+ receipts: Dict[str, Dict[str, Any]] = dataclasses.field(default_factory=dict)
+async def _retry(fn: Callable[[], Any], max_attempts: int, delay_ms: int,
+ backoff: str = "exponential", jitter: bool = False) -> Any:
+ last_err: Optional[BaseException] = None
+ for attempt in range(max_attempts):
+ try:
+ return await fn()
+ except Exception as e:
+ last_err = e
+ base = delay_ms * (2 ** attempt) if backoff == "exponential" else delay_ms * (attempt + 1)
+ wait = base * (0.5 + random.random()) if jitter else base
+ await asyncio.sleep(wait / 1000.0)
+ raise last_err # type: ignore[misc]
+def _receipt(sink: str, reversible: bool = True) -> Dict[str, Any]:
+ return {
+ "id": str(uuid.uuid4()),
+ "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+ "sink": sink,
+ "reversible": reversible,
+ }
+def _predicate(expr: str, row: Any) -> bool:
+ """Opaque expression evaluator — spec §3.1. Resolver chose Python eval."""
+ return bool(eval(expr, {"__builtins__": {}}, {"row": row, "r": row}))
+def _project(expr: str, input: Any) -> Any:
+ return eval(expr, {"__builtins__": {"len": len, "sum": sum, "min": min, "max": max}},
+ {"input": input, "row": input, "r": input})
+def _reduce(expr: str, items: List[Any], initial: Any) -> Any:
+ m = re.match(r"^group_by\(([^)]+)\)\.(sum|count|avg|min|max)\(([^)]*)\)$", expr)
+ if m:
+ key_expr, op, field = m.group(1), m.group(2), m.group(3)
+ groups: Dict[Any, List[Any]] = {}
+ for row in items:
+ k = _project(key_expr, row)
+ groups.setdefault(k, []).append(row)
+ out: Dict[str, Any] = {}
+ for k, rows in groups.items():
+ if op == "count":
+ out[str(k)] = len(rows)
+ continue
+ vals = [_project(field, r) for r in rows]
+ if op == "sum": out[str(k)] = sum(vals)
+ elif op == "avg": out[str(k)] = sum(vals) / len(vals)
+ elif op == "min": out[str(k)] = min(vals)
+ elif op == "max": out[str(k)] = max(vals)
+ return out
+ m2 = re.match(r"^(sum|count|avg|min|max)\(([^)]*)\)$", expr)
+ if m2:
+ op, field = m2.group(1), m2.group(2)
+ if op == "count": return len(items)
+ vals = [_project(field, r) for r in items]
+ if op == "sum": return sum(vals)
+ if op == "avg": return sum(vals) / len(vals) if vals else 0
+ if op == "min": return min(vals) if vals else None
+ if op == "max": return max(vals) if vals else None
+ # generic lambda fallback: expr must name 'acc' and 'row'
+ acc = initial
+ for row in items:
+ acc = eval(expr, {"__builtins__": {}}, {"acc": acc, "row": row})
+ return acc
+async def fetch_with_retry(ctx: Ctx) -> Any:
+ async def _attempt():
+ import httpx
+ async with httpx.AsyncClient() as client:
+ r = await client.request("GET", "https://api.example.com/records", json=None)
+ r.raise_for_status()
+ return r.json()
+ return await _retry(_attempt, 3, 1000, "exponential", True)
+
+
+async def safe_validate(ctx: Ctx) -> Any:
+ try:
+ rules = [{"field": "id", "check": "required"}]
+ validator = globals().get("__validator__")
+ ok = validator(rules, ctx.input) if validator else True
+ if not ok:
+ raise ValueError("VALIDATE failed (action=reject)")
+ return ctx.input
+ except Exception as e:
+ catches = ["ValidationError", "ValueError"]
+ if any(t == type(e).__name__ or t == getattr(e, "code", None) for t in catches):
+ payload = ctx.input
+ import httpx
+ async with httpx.AsyncClient() as client:
+ body = {"channel": "#alerts", "text": payload if isinstance(payload, str) else json.dumps(payload)}
+ await client.post("", json=body)
+ return None
+ raise
+
+
+async def persist_data(ctx: Ctx) -> Any:
+ input = ctx.input
+ import asyncpg
+ conn = await asyncpg.connect(os.environ.get("DATABASE_URL", ""))
+ try:
+ rows = input if isinstance(input, list) else [input]
+ for row in rows:
+ keys = list(row.keys())
+ placeholders = ", ".join(f"$" + str(i+1) for i in range(len(keys)))
+ cols = ", ".join(keys)
+ sql = f'INSERT INTO records ({cols}) VALUES ({placeholders})'
+ await conn.execute(sql, *[row[k] for k in keys])
+ finally:
+ await conn.close()
+ receipt = _receipt("sql:records")
+ ctx.receipts["persist_data"] = receipt
+ return receipt
+
+
+async def rollback_persist(ctx: Ctx) -> Any:
+ receipt = ctx.receipts.get("persist_data")
+ if not receipt:
+ raise RuntimeError("COMPENSATE rollback_persist: no receipt for persist_data")
+ if not receipt.get("reversible"):
+ raise RuntimeError("COMPENSATE rollback_persist: receipt is non-reversible")
+ import asyncpg
+ conn = await asyncpg.connect(os.environ.get("DATABASE_URL", ""))
+ try:
+ await conn.execute('DELETE FROM records WHERE id = $1')
+ finally:
+ await conn.close()
+ return _receipt("sql:records", False)
+
+async def _execute(vid: str, ctx: Ctx) -> None:
+ if vid == "fetch_with_retry":
+ ctx.values["fetch_with_retry"] = await fetch_with_retry(ctx)
+ await _execute("safe_validate", ctx)
+ return
+ if vid == "safe_validate":
+ ctx.values["safe_validate"] = await safe_validate(ctx)
+ await _execute("persist_data", ctx)
+ return
+ if vid == "persist_data":
+ ctx.values["persist_data"] = await persist_data(ctx)
+ await _execute("rollback_persist", ctx)
+ return
+ if vid == "rollback_persist":
+ ctx.values["rollback_persist"] = await rollback_persist(ctx)
+ return
+ return
+ raise ValueError(f"unknown verb id: {vid}")
+
+async def run(input: Any = None) -> Ctx:
+ ctx = Ctx(input=input)
+ await _execute("fetch_with_retry", ctx)
+ return ctx
+
+
+if __name__ == "__main__":
+ asyncio.run(run())
diff --git a/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/rust/Cargo.toml b/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/rust/Cargo.toml
new file mode 100644
index 0000000..3acc334
--- /dev/null
+++ b/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/rust/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "resilient_etl"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1"
+async-recursion = "1"
+chrono = { version = "0.4", features = ["clock"] }
+rand = "0.8"
+regex = "1"
+reqwest = { version = "0.12", features = ["json"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sqlx = { version = "0.8", features = ["runtime-tokio", "postgres", "json", "chrono"] }
+tokio = { version = "1", features = ["full"] }
+uuid = { version = "1", features = ["v4"] }
diff --git a/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/rust/resilient_etl.rs b/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/rust/resilient_etl.rs
new file mode 100644
index 0000000..1c424f7
--- /dev/null
+++ b/packages/pro/tests/resolvers/__fixtures__/expected-resilience-verbs/rust/resilient_etl.rs
@@ -0,0 +1,246 @@
+// Generated by NOMARK Intents resolver (target: rust)
+// Composition: resilient_etl v0.4.0
+// ETL with retried fetch, error-handled validate, persisted records, and a compensating undo for the persist step.
+use std::collections::HashMap;
+use std::time::Duration as StdDuration;
+use anyhow::{anyhow, Result};
+use serde_json::{json, Value};
+use tokio::time::sleep;
+#[derive(Debug, Clone)]
+pub struct Receipt {
+ pub id: String,
+ pub timestamp: String,
+ pub sink: String,
+ pub reversible: bool,
+}
+#[derive(Debug, Default)]
+pub struct Ctx {
+ pub input: Value,
+ pub values: HashMap,
+ pub receipts: HashMap,
+}
+fn new_receipt(sink: &str, reversible: bool) -> Receipt {
+ Receipt {
+ id: uuid::Uuid::new_v4().to_string(),
+ timestamp: chrono::Utc::now().to_rfc3339(),
+ sink: sink.to_string(),
+ reversible,
+ }
+}
+async fn retry(mut f: F, max: u32, delay_ms: u64, backoff: &str, jitter: bool) -> Result
+where
+ F: FnMut() -> Fut,
+ Fut: std::future::Future