feat: Added build time to output.

Also renamed it to `Error`.

AGENTS.md

@@ -5,7 +5,7 @@ Thor is a static site generator written in [Odin](https://odin-lang.org), replac
 ## Architecture
 
 ```
-thor.json          ← site config (title, base_url, author, params, modules)
+thor.json          ← site config (title, base_url, params, modules, og)
 content/           ← markdown and HTML content files
 layouts/           ← Mustache templates + partials (user overrides)
 assets/            ← CSS (Tufte-based), JS, fonts, images
@@ -19,7 +19,7 @@ public/            ← build output (generated)
 thor/
 ├── treesitter/         # FFI types + grammar management (standalone package)
 ├── markdown/           # Content transformation pipeline (imports ../treesitter)
-├── mustache/           # Template engine with lambdas + pipe filters
+├── mustache/           # Template engine with lambdas + pipe filters + diagnostics
 ├── content.odin        # Page struct, scan_content, load_page
 ├── render.odin         # Template rendering, data structs, RSS, sitemap
 ├── site.odin           # Config (Flags, Config_File, Site), init_site
@@ -27,10 +27,12 @@ thor/
 ├── feed.odin           # RSS + sitemap generation
 ├── vfs.odin            # Union file system (defaults → modules → site)
 ├── assets.odin         # VFS-based asset copying
-├── opengraph.odin      # Open_Graph struct + og_init/og_for_page
-├── frontmatter.odin    # JSON frontmatter parser
+├── html.odin           # HTML helpers: strip_html_tags, unescape_html, generate_summary
+├── opengraph.odin      # Open_Graph struct + og_for_site/og_for_page
+├── frontmatter.odin    # JSON frontmatter parser (supports nested og + lastmod)
 ├── defaults.odin       # DEFAULTS_PATH constant (#directory)
 ├── main.odin           # Entry point
+├── bench/              # Template rendering benchmark
 └── defaults/layouts/   # Bundled default templates
 ```
 
@@ -39,15 +41,16 @@ thor/
 | File | Responsibility |
 |---|---|
 | `main.odin` | Entry point. Sets `context.logger`, calls `init_site`, `build_vfs`, `site_load_content`, `render_site`. Optional Spall profiling via `SPALL` config flag. |
-| `site.odin` | `Flags` (CLI), `Config_File` (thor.json), `Site` (runtime state + arena + VFS + pages + modules). `Feature` enum. 5-step `init_site`. Imports `md "markdown"` for `Extension` enum. |
-| `content.odin` | `Page` struct, `scan_content` (section-aware walk that handles leaf bundles), `load_page`, `infer_layout`. Calls `md.process()` for the markdown pipeline. |
+| `site.odin` | `Flags` (CLI), `Config_File` (thor.json, includes `og: Open_Graph`), `Site` (runtime state + arena + VFS + pages + modules + `og`). `Feature` enum. 5-step `init_site`. Imports `md "markdown"` for `Extension` enum. |
+| `content.odin` | `Page` struct (includes `lastmod`, `og`), `scan_content` (section-aware walk that handles leaf bundles), `load_page`, `infer_layout`. Calls `md.process()` for the markdown pipeline. |
 | `render.odin` | Template rendering: `render_site`, `render_page_html`, `render_home_html`, `render_section`. Data structs (`Base_Data`, `Page_Data`, `Home_Data`, `Section_Data`). VFS-based template loading with fallback chain (`get_template`). |
 | `minify.odin` | HTML/CSS minification via tree-sitter. Imports `ts "treesitter"`. |
 | `feed.odin` | RSS feed + sitemap XML. Uses `page.url` for canonical URLs. |
-| `vfs.odin` | Union file system: `VFS`, `build_vfs`, `mount_dir`, `mount_subdir`, `mount_recursive`, `vfs_get`. Layers defaults → modules → site. |
+| `vfs.odin` | Union file system: `VFS`, `build_vfs`, `mount_dir`, `mount_subdir`, `mount_recursive`, `vfs_get`, `vfs_get_entry`, `vfs_entry_data`. Layers defaults → modules → site. |
 | `assets.odin` | `copy_assets_dir` — iterates VFS entries with `assets/` prefix, minifies CSS, copies verbatim or via `os.copy_file`. |
-| `opengraph.odin` | `Open_Graph` struct (fields ordered per OGP spec). `og_init(site)` for site defaults, `og_for_page(site, page, base)` for page-specific OG data. |
-| `frontmatter.odin` | JSON frontmatter parser (`{ }` delimited). Supports `layout` field for template override. |
+| `html.odin` | `strip_html_tags` (moved from render.odin), `unescape_html`, `generate_summary` (Hugo-style body summary for OG descriptions). |
+| `opengraph.odin` | `Open_Graph` struct (fields ordered per OGP spec, `is_article: Maybe(bool)`). `og_for_site(site)` for site defaults (from config + derived), `og_for_page(site_og, page)` for page-specific (overlay page.og + derive from page data). |
+| `frontmatter.odin` | JSON frontmatter parser (`{ }` delimited). Supports `layout`, `lastmod`, and nested `og` object (via `json_get_open_graph`). |
 | `defaults.odin` | `DEFAULTS_PATH` constant, resolved at compile time via `#directory` so bundled templates ship in the binary. |
 
 ### Subpackages
@@ -62,6 +65,7 @@ thor/
 | | `sectionate.odin` | `wrap_sections` — splits HTML at `<h2>` into `<section>` wrappers |
 | | `highlight.odin` | Syntax highlighting via tree-sitter. Imports `../treesitter`. |
 | `mustache/` | See [Mustache engine](#mustache-engine) below | Template engine |
+| `bench/` | `bench.odin` + `templates/` | Standalone template rendering benchmark. Generates 500 posts + 100 comments, renders with indented partials + inheritance + pipes. `--dump <path>` for output validation, positional arg for iteration count (default 250). |
 
 Icon SVGs live as HTML partials in `layouts/partials/icons/` (home, github, rss, chevron_up, star).
 
@@ -90,10 +94,12 @@ Page :: struct {
     title:       string,
     description: string,
     date:        string,
+    lastmod:     string,
     menu:        string,
     body_html:   string,
     draft:       bool,
     is_starred:  bool,
+    og:          Open_Graph,  // per-page OG overrides from frontmatter
     _is_index:   bool `private`,
 }
 ```
@@ -112,8 +118,8 @@ No `Page_Type` enum — page type is inferred from section + `_is_index`. Layout
 Config is split into three structs with a clear 5-step initialization flow:
 
 - **`Flags`** — CLI args only. Parsed by `core:flags`. Includes path overrides (`--content`, `--assets`, `--output`, `--layouts`), build-mode toggles (`-drafts`, `-watch`, `-minify`), and `-ext`/`-no-ext` for markdown extension overrides.
-- **`Config_File`** — parsed from `thor.json` via `json.unmarshal_string`. Holds title, paths, `markdown_extensions` (JSON), `params` (JSON), `modules` (JSON array of relative paths).
-- **`Site`** — runtime state: arena, pages, modules, VFS, `features: bit_set[Feature]`, `markdown_extensions: bit_set[md.Extension]`.
+- **`Config_File`** — parsed from `thor.json` via `json.unmarshal_string`. Holds title, paths, `markdown_extensions` (JSON), `params` (JSON), `modules` (JSON array of relative paths), `og` (`Open_Graph` struct for site-level OG defaults).
+- **`Site`** — runtime state: arena, pages, modules, VFS, `features: bit_set[Feature]`, `markdown_extensions: bit_set[md.Extension]`, `og: Open_Graph` (resolved site-level OG).
 
 **`Feature` enum** — `Drafts`, `Minify`, `Watch`. Checked with `.Minify in site.features`.
 
@@ -129,15 +135,11 @@ Config precedence: `CLI flags > thor.json values > hardcoded defaults`.
 {
   "title": "...",
   "base_url": "...",
-  "author": "...",
   "modules": ["../path/to/module"],
-  "markdown_extensions": {
-    "emoji": true,
-    "sidenotes": true,
-    "alerts": true,
-    "highlight": true,
-    "sections": true
+  "og": {
+    "image": "https://example.com/og.png"
   },
+  "markdown_extensions": { "emoji": true, "highlight": false },
   "params": {
     "social": [
       { "name": "github", "url": "...", "icon": "icons/github" }
@@ -155,13 +157,33 @@ VFS :: struct { files: map[string]VFS_Entry }
 VFS_Entry :: struct { fs_path: string, data: []byte }
 ```
 
-`build_vfs` mounts in reverse precedence (defaults first, site last overwrites). `DEFAULTS_PATH` resolved at compile time via `#directory`, so bundled templates ship inside the binary. Modules configured via `"modules": ["../path"]` in `thor.json` — each module contributes `layouts/` and `assets/` subdirectories. `vfs_get` lazily reads file contents on first access.
+`build_vfs` mounts in reverse precedence (defaults first, site last overwrites). `DEFAULTS_PATH` resolved at compile time via `#directory`, so bundled templates ship inside the binary. Modules configured via `"modules": ["../path"]` in `thor.json` — each module contributes `layouts/` and `assets/` subdirectories.
+
+Three access patterns:
+- `vfs_get(vfs, path) -> ([]byte, bool)` — data only (lazy-loaded from disk)
+- `vfs_get_entry(vfs, path) -> (VFS_Entry, []byte, bool)` — entry + data (for callers that need `fs_path` for diagnostics)
+- `vfs_entry_data(entry) -> ([]byte, bool)` — data from an entry already in hand (avoids redundant map lookup when iterating `vfs.files`)
 
 Content is **not yet in the VFS** — `scan_content` still uses direct filesystem reads. (See `TODOS.md`.)
 
 ## Open Graph
 
-`Open_Graph` struct in `opengraph.odin` with fields ordered per [ogp.me](https://ogp.me/) spec. Site defaults set via `og_init(site)` (site_name, description, default image, locale). Page-specific fields via `og_for_page(site, page, base)` (copies base, overrides url/title/type/is_article/section/published_time). Templates access via `{{og.url}}`, `{{og.title}}`, `{{#og.is_article}}`, etc.
+`Open_Graph` struct in `opengraph.odin` with fields ordered per [ogp.me](https://ogp.me/) spec. `is_article` is `Maybe(bool)` — nil means "unset" (distinguished from explicitly `false`).
+
+**Site-level** (`og_for_site`): starts from `Config_File.og` (user-supplied defaults from `thor.json`), then fills empty fields derivable from `Site`:
+- `site_name ← site.title`
+- `locale ← "en_US"` (default if unset)
+
+**Page-level** (`og_for_page`): copies site OG, derives page-specific fields, then overlays `Page.og` (from frontmatter):
+- `url ← page.url`
+- `title ← page.title` (falls back to `site_name` if empty)
+- `type ← "article" if !page._is_index else "website"`
+- `is_article ← !page._is_index`
+- `section ← page.section`
+- `published_time / modified_time ← page.date / page.lastmod`
+- `description ← page.description`, else body summary (via `generate_summary`)
+
+Paths through maps (e.g. `params.*`) are silently allowed — not validated. Templates access via `{{og.url}}`, `{{og.title}}`, `{{#og.is_article}}`, etc.
 
 ## Markdown pipeline
 
@@ -196,22 +218,20 @@ Templates use Mustache with template inheritance (`{{<base}}` / `{{$block}}`):
 {{/base}}
 ```
 
-Data is passed as **typed structs** (not `map[string]any`). Mustache resolves struct fields via Odin reflection, including `using`-embedded fields. Date presence is checked via string truthiness (`{{#date_iso}}`) — no separate `has_date` bool needed.
+Data is passed as **typed structs** (not `map[string]any`). Mustache resolves struct fields via Odin reflection, including `using`-embedded fields. Date presence is checked via string truthiness (`{{#date}}`) — no separate `has_date` bool needed. Dates are stored as raw ISO strings; presentation formatting happens in the template via the `format` pipe (see Pipes extension below).
 
 ```odin
 Base_Data :: struct {
     now:    datetime.DateTime,
-    author: string,
     params: json.Value,
     body:   string,
     title:  string,
     og:     Open_Graph,
 }
 Page_Data :: struct {
-    using base:   Base_Data,  // fields promoted via reflection fallback
-    page_title:   string,
-    date_iso:     string,
-    date_display: string,
+    using base: Base_Data,  // fields promoted via reflection fallback
+    page_title: string,
+    date:       string,     // raw ISO 8601; formatted via `| format` in templates
 }
 Home_Data :: struct {
     using base: Base_Data,
@@ -228,15 +248,18 @@ Section_Data :: struct {
 
 ### Pipes extension
 
-Section tags may transform the resolved value before iteration:
+Section tags and interpolation tags may transform the resolved value before rendering:
 
 ```handlebars
 {{#posts | group_by year}}
   {{key}}: {{#items}}{{title}}, {{/items}}
 {{/posts}}
+
+<!-- Interpolation pipe: format a date for display -->
+<time datetime="{{date}}">{{date | format}}</time>
 ```
 
-Currently only `group_by <field>` is implemented. Filter results live in `context.temp_allocator` (render-scoped). See `mustache/EXTENSIONS.md` for syntax details, caps (`MAX_PIPES`, `MAX_PIPE_ARGS`), and the `Group` struct shape.
+Currently implemented: `group_by <field>` (list → list-of-groups) and `format` (ISO date string → display string like "15 Mar 2026"). Filter results live in `context.temp_allocator` (render-scoped). See `mustache/EXTENSIONS.md` for syntax details, caps (`MAX_PIPES`, `MAX_PIPE_ARGS`), and the `Group` struct shape.
 
 ### Comments
 
@@ -309,39 +332,76 @@ nix build  # runs thor, outputs to ./result/
 ```bash
 cd thor
 odin test .                  # main package tests (site, frontmatter)
-odin test . -all-packages    # includes mustache specs, lambdas, pipes, markdown tests
+odin test . -all-packages    # includes mustache specs, lambdas, pipes, diagnostics, markdown tests
+```
+
+### Benchmark
+
+```bash
+cd thor
+odin build bench -o:speed
+./bench.bin                    # 250 iterations, prints timing
+./bench.bin --dump output.html # render once, write to file for diff validation
+./bench.bin 1000               # custom iteration count
 ```
 
 ## Mustache engine
 
-Spec-compliant implementation at `mustache/`. See `mustache/SPEC.md` for the implementation specification and `mustache/EXTENSIONS.md` for non-standard extensions (pipes).
+Spec-compliant implementation at `mustache/`. See `mustache/SPEC.md` for the implementation specification, `mustache/EXTENSIONS.md` for non-standard extensions (pipes), and `mustache/diagnostic.odin` for the rust-style error formatter.
 
 ### Files
 
 | File | Responsibility |
 |---|---|
-| `mustache.odin` | Public API (`parse`, `render`, `Template`), parser (`parse_section` with allocator threading), renderer (`render_nodes`), template inheritance (`merge_block_overrides`), `delete_template`/`delete_partials` |
+| `mustache.odin` | Public API (`parse`, `render`, `Template`), parser (`parse_section`), renderer (`render_nodes` with `Indent_State` for partial indentation), template inheritance (`merge_block_overrides`), `delete_template`/`delete_partials`. Pipe support in Variable/Unescaped/Section/Inverted tags. |
 | `tokenizer.odin` | Tokenizer (template string → `[]Token`), standalone whitespace detection |
-| `data.odin` | Reflection-based data model: `base_value` (peels union/any/nested-any layers), `lookup_in` (structs + maps, handles `Type_Info_Any` value kind in maps), `resolve_name`, `is_truthy`, `any_to_string`, `list_info`, `extract_list_element` (unwraps `[dynamic]any` element types so downstream lookups see the real value), `call_interp_lambda`/`call_section_lambda` |
-| `pipes.odin` | Pipes extension: `Pipe_Filter` AST, `parse_pipeline`, `apply_pipeline`, `apply_filter` (switch dispatch), `apply_group_by`. Stored on `Node.filters`; render-scoped results in temp allocator. |
-| `spec_test.odin` | JSON spec test runner — loads `spec/specs/*.json`, runs each test case |
+| `data.odin` | Reflection-based data model: `base_value` (peels union/any/nested-any layers), `lookup_in` (structs + maps, handles `Type_Info_Any` value kind in maps), `resolve_name`, `is_truthy`, `any_to_string`, `list_info`, `extract_list_element`, `call_interp_lambda`/`call_section_lambda` |
+| `pipes.odin` | Pipes extension: `Pipe_Filter` AST, `parse_pipeline` (takes `pos`), `apply_pipeline`, `apply_filter` (switch dispatch: `group_by` + `format`), `apply_group_by`, `apply_format`. Stored on `Node.filters`; render-scoped results in temp allocator. |
+| `diagnostic.odin` | Rust-style error formatter: `format_error` (multi-line context, ANSI colors via `core:terminal/ansi`, `colorize` param), `format_render_error` (formats `Error`), `line_col`, `line_text`, `context_extent`, `count_lines`, `digit_count`, `should_colorize`. |
+| `suggest.odin` | Strict-warning helpers: `validate_key_path` (walks dotted path, crosses maps silently), `suggest_correction` (Levenshtein via `core:strings/levenshtein_distance`), `collect_struct_keys` (via reflection, recurses into `using`), `struct_has_field` (distinguishes missing field from nil value — needed for `Maybe(bool)`), `collect_partial_names`, `collect_block_names`. |
+| `spec_test.odin` | JSON spec test runner — loads `spec/specs/*.json`, runs each test case. Uses `log.nil_logger()` to suppress expected warnings. |
 | `lambda_test.odin` | Spec lambda tests |
-| `pipes_test.odin` | Pipe filter tests |
+| `pipes_test.odin` | Pipe filter tests (`group_by` + `format`) |
+| `diagnostic_test.odin` | Golden-output tests for `format_error` (multi-line context, edge cases, alignment, caret position, hint) + parser error message brace-escaping |
+| `suggest_test.odin` | Tests for `validate_key_path`, `suggest_correction`, `struct_has_field` with `Maybe(bool)` and `using`-promoted fields |
 
 ### Architecture
 
 ```
-parse(source) → tokenize → trim_standalone_whitespace → parse_section → Template
+parse(source, path) → tokenize → trim_standalone_whitespace → parse_section → Template
 render(tmpl, data, partials) → render_nodes (walks flat node array against context stack) → string
 ```
 
 - **Two-phase API**: `parse()` produces a reusable `Template`, `render()` walks it against data. Templates parsed once, rendered many times.
-- **Flat `[dynamic]Node` array** with `first_child`/`child_count` indices — pre-order layout.
+- **Flat `[dynamic]Node` array** with `children: []Node` slices (pre-order layout; slices point into the backing array). Each `Node` carries `pos: int` (byte offset into source) for diagnostics.
+- **`Template`** carries `source` and `path` — used by diagnostics to show file location and source context.
 - **Context stack**: `^[dynamic]any` with `append`/`pop` for section push/pop.
+- **`render_nodes` takes `Template` by value** (not `^Template`) — Odin's calling convention promotes to pointer when efficient. Eliminates "local copy" patterns at call sites.
+- **`Block_Override.source: Template`** — carries the template that defined the override, so warnings inside block overrides point at the correct file.
 - **`base_value`** peels Named/Distinct/Union layers (including `json.Value`). Also unwraps nested `any`-of-`any` (which occurs when `map[string]any` values are read via runtime map internals).
 - **`lookup_in`** resolves keys on structs (via `reflect.struct_field_value_by_name` with `allow_using = true`) and maps. Detects `Type_Info_Any` value kind in maps and reads the inner any directly to avoid double-wrap.
 - **Template inheritance**: `{{<parent}}` loads parent from partials, `{{$block}}` defines overridable sections. `merge_block_overrides` propagates overrides through multi-level chains.
 - **Dynamic partial names**: `{{>*key}}` resolves partial name from data context at render time.
+- **Render-time partial indentation**: `Indent_State` threads `at_line_start` through `render_nodes` so partial indent is applied at render time (via `write_indented` on Text nodes) instead of reparsing the partial's source. `render_template` writes initial indent, creates state, calls `render_nodes`. Data-injected newlines don't pick up indent (Variables don't update `at_line_start`).
+
+### Diagnostics
+
+Rust-style error messages with multi-line source context, caret underlines, and Levenshtein suggestions. ANSI colors via `core:terminal/ansi`, gated on `should_colorize()` (TTY detection on stderr).
+
+**Error types**: `Error_Body{msg, pos, kind}` where `kind` is `Error_Kind.Syntax` (parse-time) or `Error_Kind.Data` (render-time). `Error` is a single-variant union wrapping `Error_Body` (nilable for `!= nil` / `or_return`).
+
+**Strict-by-default warnings** — `render_nodes` emits `log.warnf` diagnostics for:
+- Unknown keys in `{{k}}`, `{{{k}}}`, `{{#k}}`, `{{^k}}` (via `validate_key_path` + `suggest_correction`)
+- Missing partials (`{{> name}}` not in partials map)
+- Missing parent templates (`{{<name}}` not in partials map)
+- Unmatched block overrides (`{{$name}}` doesn't match any block in parent template)
+
+**Exceptions** (no warning):
+- `{{.}}` and dot-prefixed names (current context)
+- Paths that cross a map (e.g., `params.*` — user-defined namespace)
+- `Maybe(bool)` fields with nil value (field exists, value is nil — distinguished via `struct_has_field`)
+
+**Block override source tracking**: `Block_Override.source: Template` ensures warnings inside block overrides point at the override's source file (e.g., `page.html`), not the parent template (`base.html`).
 
 ### Lambdas
 
@@ -352,11 +412,17 @@ Spec-compliant. Stored as `any` values in the data context.
 
 ### Pipes
 
-`{{#key | op args…}}…{{/key}}`. Stored as `[dynamic; MAX_PIPES]Pipe_Filter` on each `Node` (fixed-cap inline storage, no per-tag heap allocation at parse time). Applied in the renderer via `apply_pipeline` before truthiness check. Currently only `group_by <field>` is implemented (returns `[dynamic]Group` where `Group{key, items}`). See `mustache/EXTENSIONS.md`.
+`{{key | op args…}}` for interpolation, `{{#key | op args…}}…{{/key}}` for sections. Stored as `[dynamic; MAX_PIPES]Pipe_Filter` on each `Node`. Applied in the renderer via `apply_pipeline` before truthiness/interpolation. Implemented filters:
+
+- `group_by <field>` — list → `[dynamic]Group` where `Group{key, items}`
+- `format` — ISO 8601 date string → display string (e.g., "15 Mar 2026")
+
+See `mustache/EXTENSIONS.md`.
 
 ### Not implemented
 
 - Set delimiters (`{{= =}}`, `delimiters.json`)
+- Partial invocation stack in diagnostics (warnings inside partials point at the partial file but don't show the `{{> name}}` invocation site — see TODOS.md)
 
 ## Known limitations
 
@@ -371,7 +437,6 @@ Spec-compliant. Stored as `any` values in the data context.
 
 You may never, *ever* remove `TODO:` or `FIXME:` comments. Those are for humans, not machines.
 See `HUGO.md` for analysis of why thor doesn't need Hugo's shortcode context isolation.
-See `mustache/PARTIAL_INDENT.md` for whitespace handling analysis.
 See `mustache/SPEC.md` for the original implementation specification.
 See `mustache/EXTENSIONS.md` for non-standard extensions (pipes).
 

TODOS.md

@@ -18,29 +18,38 @@
 - [ ] Add overloads for every extension - accept ^strings.Builder.
 - [ ] Add conventional (Hugo style) footnotes option.
 - [ ] Add heading ids as a default on extension.
+- [ ] Add opt-in deflist support.
+- [ ] Decide if lambdas actually provide any value.
+- [ ] configure date format as a partial
 
 ## General 
 - [ ] Integrity hash
   - Allows users to verify their output didn't change after upgrading to a new version
 - [ ] Content-hash fingerprinting for CSS and JS cache busting
 - [ ] Avoid `json.Value` / `json.Object` where possible.
+- [ ] make `parse` an overload of `parse_text/parse_inline` and `parse_file`, or something.
+- [ ] Add page params
+- [ ] We must remove all mention of `posts` from the odin code.
+      At present, "posts" are a user-level construct defined as pages in a
+      particular collection.
 - [ ] running ./thor/thor still logs the debug message: using config /home/spencer/github.com/sbrow.github.io/thor.json
   - wrong cwd?
 - [ ] Clean up the default layouts
+- [ ] if no `html` tag detected in output, re-render output with base template
+      (or whatever template is next in the chain)
 - [ ] Add `-production` flag
   - sets `-minify`
-- [x] Open Graph
-  - [x] mustache data keys for opengraph, etc.
-  - [x] OpenGraph meta tags — verify all fields match production site
-  - [x] set opengraph tags / description automatically if unset. (Like hugo does)
-  - [x] We can't use avatar.jpg as the default site image.
-  - [x] Add `og Open_Graph` to `Config_File`.
-- [ ] Author should be a struct adhering to https://schema.org/author
+- [x] Mustache diagnostics
+  - [x] Rust-style error messages: position tracking on Node/Template/Data_Error, `diagnostic.odin` with `format_error`, ANSI colors via `core:terminal/ansi` (Phase 1+2+3)
+  - [x] Unknown-key detection with Levenshtein suggestions (`core:strings/levenshtein_distance`); warning severity (Phase 4+5)
+  - [x] Strict-by-default posture: warn on missing keys in `{{k}}`/`{{{k}}}`/`{{#k}}`/`{{^k}}`, missing partials, missing parents, unmatched block overrides
+  - [x] Block-override source-template tracking: warnings inside overrides point at the override's source file, not the parent template
+  - [ ] Partial invocation stack in diagnostics: when an error fires inside a partial, show "invoked from" chain through `{{> name}}` calls. Currently warnings inside partials point at the partial (correct file) but don't show the invocation site.
+  - [ ] Could be better error message when missing a closing (or opening) brace
 - [ ] Block attributes on code fences (`{ #ex-1 }`) — hello-world.md
 - [ ] include-code shortcode (`{{< include-code ... >}}`) — i-ported-fd-to-odin
 - [ ] follow symlinks in `scan_content`?
 - [ ] ensure sidenote numbers render in display order and not in declaration order.
-- [ ] Add Opt-in deflist support.
 - [x] We need to be able to do `Year_Section` in a non-magical, unprivileged way. Implemented via the pipes extension to mustache — see [mustache/EXTENSIONS.md](mustache/EXTENSIONS.md).
 - [ ] Table of contents support.
 - [ ] Nav items should be active when the current page is selected.
@@ -103,6 +112,8 @@ these tasks.
     - [ ] Review markdown.odin
     - [x] Review sectionate.odin
     - [x] Review sectionate_test.odin
+    - [ ] Review suggest.odin
+    - [ ] Review suggest_test.odin
   - [x] Review opengraph.odin
   - [ ] Review render.odin
   - [x] Review site.odin

bench/bench.odin

@@ -0,0 +1,203 @@
+package bench
+
+import "core:fmt"
+import "core:mem"
+import "core:os"
+import "core:strconv"
+import "core:time"
+import "../mustache"
+
+Tag :: struct {
+	name: string,
+	slug: string,
+}
+
+Nav_Item :: struct {
+	url:   string,
+	label: string,
+}
+
+Post :: struct {
+	title:   string,
+	url:     string,
+	date:    string,
+	year:    string,
+	excerpt: string,
+	author:  string,
+	tags:    [dynamic]Tag,
+}
+
+Comment :: struct {
+	author: string,
+	date:   string,
+	body:   string,
+}
+
+Page_Data :: struct {
+	title:     string,
+	now:       string,
+	posts:     [dynamic]Post,
+	comments:  [dynamic]Comment,
+	nav_items: [dynamic]Nav_Item,
+}
+
+TEMPLATE_DIR :: #directory
+
+main :: proc() {
+	iterations := 250
+	dump_path := ""
+
+	i := 1
+	for i < len(os.args) {
+		if os.args[i] == "--dump" && i + 1 < len(os.args) {
+			dump_path = os.args[i + 1]
+			i += 2
+		} else {
+			n, ok := strconv.parse_int(os.args[i])
+			if ok && n > 0 {
+				iterations = n
+			}
+			i += 1
+		}
+	}
+
+	data_arena: mem.Dynamic_Arena
+	mem.dynamic_arena_init(&data_arena)
+	defer mem.dynamic_arena_destroy(&data_arena)
+
+	temp_arena: mem.Dynamic_Arena
+	mem.dynamic_arena_init(&temp_arena)
+	defer mem.dynamic_arena_destroy(&temp_arena)
+
+	context.allocator = mem.dynamic_arena_allocator(&data_arena)
+	context.temp_allocator = mem.dynamic_arena_allocator(&temp_arena)
+
+	base := parse_file("base.html")
+	page := parse_file("page.html")
+	defer mustache.delete_template(&base)
+	defer mustache.delete_template(&page)
+
+	partials := make(map[string]mustache.Template)
+	partials["base"] = base
+	partials["post"] = parse_file("partials/post.html")
+	partials["comment"] = parse_file("partials/comment.html")
+	defer mustache.delete_partials(partials)
+
+	data := generate_data()
+
+	if dump_path != "" {
+		result, err := mustache.render(page, data, partials, allocator = context.temp_allocator)
+		if err != nil {
+			b := mustache.body(err)
+			fmt.eprintln("render error:", b.msg)
+			os.exit(1)
+		}
+		werr := os.write_entire_file_from_string(dump_path, result)
+		if werr != nil {
+			fmt.eprintln("failed to write", dump_path, ":", werr)
+			os.exit(1)
+		}
+		fmt.println("wrote", len(result), "bytes to", dump_path)
+		return
+	}
+
+	for _ in 0..<3 {
+		_, _ = mustache.render(page, data, partials, allocator = context.temp_allocator)
+		mem.dynamic_arena_free_all(&temp_arena)
+	}
+
+	start := time.now()
+	for _ in 0..<iterations {
+		_, _ = mustache.render(page, data, partials, allocator = context.temp_allocator)
+		mem.dynamic_arena_free_all(&temp_arena)
+	}
+	elapsed := time.since(start)
+
+	seconds := time.duration_seconds(elapsed)
+	per_render_ms := seconds * 1000 / f64(iterations)
+
+	fmt.printfln("iterations=%d  total=%.3fs  per_render=%.3fms",
+		iterations, seconds, per_render_ms)
+}
+
+parse_file :: proc(name: string) -> mustache.Template {
+	path := fmt.aprintf("%s/templates/%s", TEMPLATE_DIR, name)
+	data, err := os.read_entire_file_from_path(path, context.allocator)
+	if err != nil {
+		fmt.eprintln("failed to read", path, ":", err)
+		os.exit(1)
+	}
+	source := string(data)
+	tmpl, perr := mustache.parse(source, path)
+	if perr != nil {
+		b := mustache.body(perr)
+		fmt.eprintln("parse error in", path, ":", b.msg)
+		os.exit(1)
+	}
+	return tmpl
+}
+
+generate_data :: proc() -> Page_Data {
+	years := []string{
+		"2025", "2024", "2023", "2022", "2021",
+		"2020", "2019", "2018", "2017", "2016",
+	}
+
+	posts := make([dynamic]Post, 0, 500)
+	for year in years {
+		for i in 0..<50 {
+			tags := make([dynamic]Tag, 0, 3)
+			append(&tags, Tag{name = fmt.aprintf("%s-notes", year), slug = fmt.aprintf("%s-notes", year)})
+			append(&tags, Tag{name = "writing", slug = "writing"})
+			append(&tags, Tag{name = "archive", slug = "archive"})
+
+			month := (i % 12) + 1
+			day := (i % 28) + 1
+
+			author := ""
+			if i % 3 != 0 {
+				author = fmt.aprintf("Author %d", i % 5)
+			}
+
+			append(&posts, Post{
+				title = fmt.aprintf("Post %d from %s", i, year),
+				url = fmt.aprintf("/%s/post-%d", year, i),
+				date = fmt.aprintf("%s-%02d-%02dT10:00:00Z", year, month, day),
+				year = year,
+				excerpt = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+				author = author,
+				tags = tags,
+			})
+		}
+	}
+
+	comments := make([dynamic]Comment, 0, 100)
+	for i in 0..<100 {
+		year := years[i % len(years)]
+		month := (i % 12) + 1
+		day := (i % 28) + 1
+		append(&comments, Comment{
+			author = fmt.aprintf("Commenter %d", i),
+			date = fmt.aprintf("%s-%02d-%02dT12:00:00Z", year, month, day),
+			body = fmt.aprintf("Great post! This is comment number %d.", i),
+		})
+	}
+
+	nav_items := make([dynamic]Nav_Item, 0, 8)
+	append(&nav_items, Nav_Item{url = "/", label = "Home"})
+	append(&nav_items, Nav_Item{url = "/archive", label = "Archive"})
+	append(&nav_items, Nav_Item{url = "/about", label = "About"})
+	append(&nav_items, Nav_Item{url = "/tags", label = "Tags"})
+	append(&nav_items, Nav_Item{url = "/feed.xml", label = "RSS"})
+	append(&nav_items, Nav_Item{url = "https://github.com/example", label = "GitHub"})
+	append(&nav_items, Nav_Item{url = "https://twitter.com/example", label = "Twitter"})
+	append(&nav_items, Nav_Item{url = "mailto:nobody@example.com", label = "Email"})
+
+	return Page_Data{
+		title = "Post Archive",
+		now = "2025-07-21T12:00:00Z",
+		posts = posts,
+		comments = comments,
+		nav_items = nav_items,
+	}
+}

bench/templates/base.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>{{$title}}{{/title}}</title>
+    {{$head}}{{/head}}
+</head>
+<body>
+    {{$nav}}{{/nav}}
+    {{$content}}{{/content}}
+    {{$sidebar}}{{/sidebar}}
+    {{$footer}}{{/footer}}
+</body>
+</html>

bench/templates/page.html

@@ -0,0 +1,45 @@
+{{<base}}
+{{$title}}Archive{{/title}}
+{{$head}}
+    <meta name="description" content="Post archive">
+{{/head}}
+{{$nav}}
+    <nav>
+        <ul>
+            {{#nav_items}}
+            <li><a href="{{url}}">{{label}}</a></li>
+            {{/nav_items}}
+        </ul>
+    </nav>
+{{/nav}}
+{{$content}}
+    <main>
+        <h1>Archive</h1>
+        {{#posts | group_by year}}
+        <section class="year">
+            <h2>{{key}}</h2>
+            <ul>
+                {{#items}}
+                {{> post}}
+                {{/items}}
+            </ul>
+        </section>
+        {{/posts}}
+    </main>
+{{/content}}
+{{$sidebar}}
+    <aside>
+        <h3>Recent Comments</h3>
+        <ul>
+            {{#comments}}
+            {{> comment}}
+            {{/comments}}
+        </ul>
+    </aside>
+{{/sidebar}}
+{{$footer}}
+    <footer>
+        <p>Generated {{now}}</p>
+    </footer>
+{{/footer}}
+{{/base}}

bench/templates/partials/comment.html

@@ -0,0 +1,5 @@
+<li class="comment">
+    <strong>{{author}}</strong>
+    <time datetime="{{date}}">{{date | format}}</time>
+    <p>{{body}}</p>
+</li>

bench/templates/partials/post.html

@@ -0,0 +1,9 @@
+<li class="post">
+    <article>
+        <h3><a href="{{url}}">{{title}}</a></h3>
+        <time datetime="{{date}}">{{date | format}}</time>
+        <p class="excerpt">{{excerpt}}</p>
+        {{#author}}<address>{{author}}</address>{{/author}}
+        {{#tags}}<a href="/tag/{{slug}}" class="tag">{{name}}</a>{{/tags}}
+    </article>
+</li>

defaults/layouts/partials/footer.html

@@ -1,3 +1,3 @@
 <footer>
-  <p>&copy; {{now.year}} {{author}}</p>
-</footer>
+  <p>&copy; {{now.year}} {{params.author.name}}</p>
+</footer>

frontmatter.odin

@@ -1,7 +1,7 @@
 package main
 
 import "core:encoding/json"
-import "core:fmt"
+import "core:log"
 import "core:strings"
 
 Frontmatter :: struct {
@@ -38,7 +38,7 @@ parse_frontmatter :: proc(content: string) -> (fm: Frontmatter, body: string, ok
 
 	value, err := json.parse_string(json_str, spec = .JSON)
 	if err != nil {
-		fmt.eprintfln("failed to parse frontmatter JSON: %v", err)
+		log.errorf("failed to parse frontmatter JSON: %v", err)
 		return
 	}
 	defer json.destroy_value(value)

main.odin

@@ -5,6 +5,7 @@ import "core:fmt"
 import "core:log"
 import "core:os"
 import "core:prof/spall"
+import "core:strings"
 import "core:sync"
 import "core:time"
 
@@ -20,7 +21,7 @@ main :: proc() {
 	when SPALL {
 		ctx, ok := spall.context_create_with_scale("thor.spall", false, 1.0)
 		if !ok {
-			fmt.eprintln("Failed to create spall trace file")
+			log.fatal("Failed to create spall trace file")
 			os.exit(1)
 		}
 		spall_ctx = ctx
@@ -39,6 +40,7 @@ main :: proc() {
 
 	for {
 		defer free_all(context.temp_allocator)
+		tick := time.tick_now()
 		site: Site
 		init_site(&site, os.args)
 		defer destroy_site(&site)
@@ -48,6 +50,7 @@ main :: proc() {
 
 		site_load_content(&site)
 		render_site(&site)
+		log.infof("Built site in %s", time.tick_since(tick))
 
 		(.Watch in site.features) or_break
 		time.sleep(5 * time.Second)

mustache/EXTENSIONS.md

@@ -4,12 +4,13 @@ Thor's mustache engine implements the [Mustache spec](https://github.com/mustach
 
 ## Pipes
 
-A pipe expression appears inside a section tag and transforms the resolved value before iteration. Pipes let templates request different views of the same data without privileged Go-side support.
+A pipe expression appears inside a section tag or an interpolation tag and transforms the resolved value before rendering. Pipes let templates request different views of the same data without privileged Go-side support.
 
 ### Syntax
 
 ```
 {{#<key> | <op> <arg> <arg>... | <op> <arg>... }} … {{/<key>}}
+{{<key> | <op> <arg> <arg>... | <op> <arg>...}}
 ```
 
 - The first whitespace-separated token after `|` is the op name; remaining tokens are its arguments.
@@ -18,7 +19,7 @@ A pipe expression appears inside a section tag and transforms the resolved value
 - **At most 8 filters** may appear in a single tag (compile-time constant `MAX_PIPES` in `pipes.odin`). Exceeding it is a parse error.
 - **At most 2 args** per filter (compile-time constant `MAX_PIPE_ARGS`). Exceeding it is a parse error.
 - The close tag is the **bare key only**. Pipe expressions are not allowed in close tags — `{{/posts | group_by year}}` is a parse error.
-- Pipes are only supported in section tags (`{{#…}}` and `{{^…}}`) today. Variable interpolation (`{{x | op}}`) is a parse error.
+- Pipes work in both section tags (`{{#…}}` and `{{^…}}`) and interpolation tags (`{{…}}` and `{{&…}}`). In sections, the transformed value becomes the section's context. In interpolations, the transformed value is what gets rendered.
 
 ### Example
 
@@ -29,6 +30,9 @@ A pipe expression appears inside a section tag and transforms the resolved value
     <ul>{{#items}}<li>{{title}}</li>{{/items}}</ul>
   </section>
 {{/posts}}
+
+<!-- Interpolation pipe: format a date string for display -->
+<time datetime="{{date}}">{{date | format}}</time>
 ```
 
 ### Available ops
@@ -52,10 +56,18 @@ Errors (returned as `Data_Error` at render time):
 - Any element is missing the named field.
 - Any element has an empty value for the named field.
 
+#### `format` (no args yet)
+
+Formats an ISO 8601 date string as a display string. Takes a string, returns a string (e.g. `"2026-03-15T08:49:54-04:00"` → `"15 Mar 2026"`). Invalid input (empty, too-short, non-string, or unparseable) returns a `Data_Error`. Templates that need to skip dateless pages should gate with a section — `{{#date}}<time datetime="{{.}}">{{. | format}}</time>{{/date}}` — so the section's truthiness check catches empty before the filter runs. Commonly used inline as `{{date | format}}` to render a display string while keeping the raw ISO available via `{{date}}` for the `datetime=` attribute.
+
+Internally: parses the invariant `YYYY-MM-DD` prefix by char offset, stringifies `time.Month(month_num)` and slices `[:3]` for the abbreviation. Accepts any of these ISO 8601 forms (the date prefix is what matters): `2023-10-15T13:18:50-07:00`, `2023-10-15T13:18:50-0700`, `2023-10-15T13:18:50Z`, `2023-10-15T13:18:50`, `2023-10-15`.
+
+Future: will accept Go reference-date format strings (e.g. `{{date | format "Mon Jan 2 2006"}}`) and pull default format/timezone from site configuration.
+
 ### Memory ownership
 
 - **Parsed pipe filters** (`Pipe_Filter` values) are stored inline on each `Node` via `[dynamic; MAX_PIPES]Pipe_Filter`, and `args` is inline on each `Pipe_Filter` via `[dynamic; MAX_PIPE_ARGS]string`. Both use Odin's fixed-capacity dynamic array type, so no per-tag heap allocations occur at parse time. The storage dies with the `Template` when `delete_template` is called.
-- **Filter results** (e.g. the `[dynamic]Group` returned by `group_by`) are render-scoped allocations in `context.temp_allocator`. They die with the render call. No caller-side cleanup is needed.
+- **Filter results** (e.g. the `[dynamic]Group` returned by `group_by`, or the display string returned by `format`) are render-scoped allocations in `context.temp_allocator`. They die with the render call. No caller-side cleanup is needed.
 - The string data inside `Pipe_Filter` (op names, args) is borrowed from the template source — no cloning.
 
 

mustache/diagnostic.odin

@@ -0,0 +1,323 @@
+package mustache
+
+import "core:fmt"
+import "core:os"
+import "core:strings"
+import "core:terminal/ansi"
+import "core:unicode/utf8"
+
+// line_col returns the 1-indexed line and column for a byte offset in source.
+// Newlines ('\n') separate lines; '\r' is treated as part of '\r\n'. Column is
+// counted in bytes from the start of the line.
+line_col :: proc(source: string, pos_in: int) -> (line: int, col: int) {
+	pos := pos_in
+	if pos < 0 {
+		return 1, 1
+	}
+	if pos > len(source) {
+		pos = len(source)
+	}
+	line = 1
+	col = 1
+	for i := 0; i < pos; i += 1 {
+		if source[i] == '\n' {
+			line += 1
+			col = 1
+		} else {
+			col += 1
+		}
+	}
+	return
+}
+
+// line_text returns the Nth (1-indexed) line of source, without the trailing
+// newline. Returns "" if line is out of range.
+line_text :: proc(source: string, line: int) -> string {
+	if line < 1 {
+		return ""
+	}
+	current := 1
+	start := 0
+	for i := 0; i < len(source); i += 1 {
+		if current == line {
+			end := i
+			for end < len(source) && source[end] != '\n' {
+				end += 1
+			}
+			return source[start:end]
+		}
+		if source[i] == '\n' {
+			current += 1
+			start = i + 1
+		}
+	}
+	if current == line {
+		return source[start:]
+	}
+	return ""
+}
+
+// context_extent returns the byte offset of the start of the line containing
+// pos, plus the byte offsets of the start and end of the mustache tag at pos.
+// Used to underline the offending tag. If pos is not inside a tag, the
+// returned [token_start, token_end) is a single rune at pos.
+context_extent :: proc(
+	source: string,
+	pos_in: int,
+) -> (
+	line_start: int,
+	token_start: int,
+	token_end: int,
+) {
+	pos := pos_in
+	if pos < 0 {
+		return 0, 0, 0
+	}
+	if pos >= len(source) {
+		pos = len(source) - 1
+	}
+	line_start = pos
+	for line_start > 0 && source[line_start - 1] != '\n' {
+		line_start -= 1
+	}
+
+	// Scan forward from line_start for `{{ ... }}` tags. If pos falls inside
+	// any tag's byte range, return that tag's extent.
+	i := line_start
+	for i + 1 < len(source) {
+		if source[i] == '{' && source[i + 1] == '{' {
+			tag_start := i
+			// Find closing }}
+			j := i + 2
+			depth := 1
+			for j + 1 < len(source) && depth > 0 {
+				if source[j] == '{' && source[j + 1] == '{' {
+					depth += 1
+					j += 2
+				} else if source[j] == '}' && source[j + 1] == '}' {
+					depth -= 1
+					j += 2
+				} else {
+					j += 1
+				}
+			}
+			tag_end := j
+			if pos >= tag_start && pos < tag_end {
+				return line_start, tag_start, tag_end
+			}
+			i = tag_end
+		} else {
+			i += 1
+		}
+	}
+
+	// Not inside a tag — underline a single rune at pos.
+	return line_start, pos, pos + 1
+}
+
+// should_colorize returns true if stderr is a TTY and color output is wanted.
+should_colorize :: proc() -> bool {
+	return os.is_tty(os.stderr)
+}
+
+// count_lines returns the number of '\n'-separated lines in source.
+// A trailing newline does not add an extra line.
+count_lines :: proc(source: string) -> int {
+	if len(source) == 0 {
+		return 1
+	}
+	n := 1
+	for c in source {
+		if c == '\n' {
+			n += 1
+		}
+	}
+	// Drop phantom last line if source ends with '\n'.
+	if len(source) > 0 && source[len(source) - 1] == '\n' {
+		n -= 1
+	}
+	return n
+}
+
+// digit_count returns the number of decimal digits in n (min 1).
+digit_count :: proc(n: int) -> int {
+	if n <= 0 {
+		return 1
+	}
+	c := 0
+	x := n
+	for x > 0 {
+		c += 1
+		x /= 10
+	}
+	return c
+}
+
+// display_width returns the number of terminal cells `s` occupies.
+// For ASCII this is byte length; for UTF-8 we count runes (combining
+// marks and wide CJK chars are still approximate).
+display_width :: proc(s: string) -> int {
+	return utf8.rune_count_in_string(s)
+}
+
+// format_error produces a rust-style multi-line diagnostic string.
+//
+//   <msg>
+//    --> <path>:<line>:<col>
+//     |
+//  N | <source line N-2>
+//  N | <source line N-1>
+//  N | <source line N — the error line>
+//     |     ^^^^^^^^^^^ <hint>
+//  N | <source line N+1>
+//  N | <source line N+2>
+//     |
+//
+// `context_before`/`context_after` lines of context are shown around the
+// error line. Line numbers are right-aligned to the width of the largest
+// line number shown.
+format_error :: proc(
+	path: string,
+	source: string,
+	pos: int,
+	msg: string,
+	hint: string = "",
+	context_before: int = 2,
+	context_after: int = 2,
+	colorize: bool = false,
+) -> string {
+	line, col := line_col(source, pos)
+	total_lines := count_lines(source)
+
+	start_line := line - context_before
+	if start_line < 1 {
+		start_line = 1
+	}
+	end_line := line + context_after
+	if end_line > total_lines {
+		end_line = total_lines
+	}
+
+	// Width of the line-number column (right-align).
+	width := digit_count(end_line)
+	if width < 1 {
+		width = 1
+	}
+
+	sb := strings.builder_make(context.temp_allocator)
+	defer strings.builder_destroy(&sb)
+
+	color := colorize
+	red, faint, reset := "", "", ""
+	if color {
+		red = ansi.CSI + ansi.FG_RED + ansi.SGR
+		faint = ansi.CSI + ansi.FAINT + ansi.SGR
+		reset = ansi.CSI + ansi.RESET + ansi.SGR
+	}
+
+	// Header line: message.
+	strings.write_string(&sb, msg)
+	strings.write_byte(&sb, '\n')
+
+	// Location line: "  --> path:line:col" (width spaces + arrow).
+	strings.write_string(&sb, faint)
+	for _ in 0 ..< width {
+		strings.write_byte(&sb, ' ')
+	}
+	strings.write_string(&sb, "--> ")
+	strings.write_string(&sb, reset)
+	strings.write_string(&sb, fmt.tprintf("%s:%d:%d\n", path, line, col))
+
+	// Top gutter line.
+	write_gutter(&sb, width, faint, reset)
+
+	// Caret extent for the error line.
+	_, token_start, token_end := context_extent(source, pos)
+	line_start, _, _ := context_extent(source, pos)
+	caret_start_col := token_start - line_start + 1
+	caret_end_col := token_end - line_start + 1
+	if caret_end_col <= caret_start_col {
+		caret_end_col = caret_start_col + 1
+	}
+
+	// Context lines.
+	for n in start_line ..= end_line {
+		// Line number (right-aligned, faint).
+		num_str := fmt.tprintf("%d", n)
+		strings.write_string(&sb, faint)
+		for _ in 0 ..< width - len(num_str) {
+			strings.write_byte(&sb, ' ')
+		}
+		strings.write_string(&sb, num_str)
+		strings.write_string(&sb, " | ")
+		strings.write_string(&sb, reset)
+
+		strings.write_string(&sb, line_text(source, n))
+		strings.write_byte(&sb, '\n')
+
+		// After the error line, emit the caret row.
+		if n == line {
+			strings.write_string(&sb, faint)
+			for _ in 0 ..< width + 1 {
+				strings.write_byte(&sb, ' ')
+			}
+			strings.write_string(&sb, "| ")
+			strings.write_string(&sb, reset)
+
+			for _ in 1 ..< caret_start_col {
+				strings.write_byte(&sb, ' ')
+			}
+			if color {
+				strings.write_string(&sb, red)
+			}
+			for _ in 0 ..< caret_end_col - caret_start_col {
+				strings.write_byte(&sb, '^')
+			}
+			if color {
+				strings.write_string(&sb, reset)
+			}
+			if hint != "" {
+				strings.write_byte(&sb, ' ')
+				if color {
+					strings.write_string(&sb, faint)
+				}
+				strings.write_string(&sb, hint)
+				if color {
+					strings.write_string(&sb, reset)
+				}
+			}
+			strings.write_byte(&sb, '\n')
+		}
+	}
+
+	// Trailing gutter line for visual closure.
+	write_gutter(&sb, width, faint, reset)
+
+	return strings.to_string(sb)
+}
+
+// write_gutter emits a faint pipe-only gutter line: `<width+1 spaces> |`.
+write_gutter :: proc(sb: ^strings.Builder, width: int, faint: string, reset: string) {
+	strings.write_string(sb, faint)
+	for _ in 0 ..< width + 1 {
+		strings.write_byte(sb, ' ')
+	}
+	strings.write_string(sb, "|")
+	strings.write_string(sb, reset)
+	strings.write_byte(sb, '\n')
+}
+
+// format_render_error produces a diagnostic for an Error value using the
+// template's path and source for context. Returns "" for nil errors.
+format_render_error :: proc(err: Error, tmpl: Template, colorize: bool = false) -> string {
+	if err == nil {
+		return ""
+	}
+	path := tmpl.path
+	if path == "" {
+		path = "<input>"
+	}
+	b := body(err)
+	return format_error(path, tmpl.source, b.pos, b.msg, colorize = colorize)
+}
+

mustache/diagnostic_test.odin

@@ -0,0 +1,560 @@
+#+test
+package mustache
+
+import "core:fmt"
+import "core:strings"
+import "core:testing"
+
+// ---------------------------------------------------------------------------
+// line_col / line_text / count_lines / digit_count — primitive helpers
+// ---------------------------------------------------------------------------
+
+@(test)
+test_line_col_basic :: proc(t: ^testing.T) {
+	src := "abc\ndef\nghi"
+	cases := [?]struct {
+		pos:  int,
+		line: int,
+		col:  int,
+	}{{0, 1, 1}, {2, 1, 3}, {3, 1, 4}, {4, 2, 1}, {6, 2, 3}, {7, 2, 4}, {8, 3, 1}}
+	for c in cases {
+		l, col := line_col(src, c.pos)
+		testing.expect(t, l == c.line, fmt.tprintf("pos %d: line %d, want %d", c.pos, l, c.line))
+		testing.expect(t, col == c.col, fmt.tprintf("pos %d: col %d, want %d", c.pos, col, c.col))
+	}
+}
+
+@(test)
+test_line_col_empty :: proc(t: ^testing.T) {
+	l, col := line_col("", 0)
+	testing.expect_value(t, l, 1)
+	testing.expect_value(t, col, 1)
+}
+
+@(test)
+test_line_col_negative :: proc(t: ^testing.T) {
+	l, col := line_col("abc", -1)
+	testing.expect_value(t, l, 1)
+	testing.expect_value(t, col, 1)
+}
+
+@(test)
+test_line_col_past_end :: proc(t: ^testing.T) {
+	l, col := line_col("abc", 100)
+	testing.expect_value(t, l, 1)
+	testing.expect_value(t, col, 4)
+}
+
+@(test)
+test_line_text_first :: proc(t: ^testing.T) {
+	src := "first\nsecond\nthird"
+	testing.expect_value(t, line_text(src, 1), "first")
+	testing.expect_value(t, line_text(src, 2), "second")
+	testing.expect_value(t, line_text(src, 3), "third")
+}
+
+@(test)
+test_line_text_trailing_newline :: proc(t: ^testing.T) {
+	src := "first\nsecond\n"
+	testing.expect_value(t, line_text(src, 1), "first")
+	testing.expect_value(t, line_text(src, 2), "second")
+	testing.expect_value(t, line_text(src, 3), "")
+}
+
+@(test)
+test_line_text_out_of_range :: proc(t: ^testing.T) {
+	testing.expect_value(t, line_text("abc", 5), "")
+	testing.expect_value(t, line_text("abc", 0), "")
+}
+
+@(test)
+test_count_lines :: proc(t: ^testing.T) {
+	testing.expect_value(t, count_lines(""), 1)
+	testing.expect_value(t, count_lines("abc"), 1)
+	testing.expect_value(t, count_lines("a\nb"), 2)
+	testing.expect_value(t, count_lines("a\nb\n"), 2)
+	testing.expect_value(t, count_lines("a\nb\nc"), 3)
+}
+
+@(test)
+test_digit_count :: proc(t: ^testing.T) {
+	testing.expect_value(t, digit_count(0), 1)
+	testing.expect_value(t, digit_count(1), 1)
+	testing.expect_value(t, digit_count(9), 1)
+	testing.expect_value(t, digit_count(10), 2)
+	testing.expect_value(t, digit_count(99), 2)
+	testing.expect_value(t, digit_count(100), 3)
+	testing.expect_value(t, digit_count(-5), 1)
+}
+
+// ---------------------------------------------------------------------------
+// format_error — golden output tests
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_error_basic :: proc(t: ^testing.T) {
+	src := "line 1\nline 2\n{{bad}}\nline 4\nline 5"
+	out := format_error("p.html", src, 14, "unknown key 'bad'", "", colorize = false)
+	expected := `unknown key 'bad'
+ --> p.html:3:1
+  |
+1 | line 1
+2 | line 2
+3 | {{bad}}
+  | ^^^^^^^
+4 | line 4
+5 | line 5
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_with_hint :: proc(t: ^testing.T) {
+	src := "line 1\nline 2\n{{titel}}\nline 4\nline 5"
+	out := format_error(
+		"post.html",
+		src,
+		14,
+		"unknown key 'titel'",
+		"did you mean 'title'?",
+		colorize = false,
+	)
+	expected := `unknown key 'titel'
+ --> post.html:3:1
+  |
+1 | line 1
+2 | line 2
+3 | {{titel}}
+  | ^^^^^^^^^ did you mean 'title'?
+4 | line 4
+5 | line 5
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_no_hint_omits_trailing_space :: proc(t: ^testing.T) {
+	src := "{{bad}}"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	// Caret line ends immediately after the carets — no trailing space.
+	testing.expect(t, strings.contains(out, "^^^^^^^\n"), out)
+	testing.expect(t, !strings.contains(out, "^^^^^^^ \n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Edge cases — context window clamping
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_error_first_line_only_after_context :: proc(t: ^testing.T) {
+	src := "{{bad}}\nline 2\nline 3\nline 4\nline 5"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	expected := `msg
+ --> p.html:1:1
+  |
+1 | {{bad}}
+  | ^^^^^^^
+2 | line 2
+3 | line 3
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_last_line_only_before_context :: proc(t: ^testing.T) {
+	src := "line 1\nline 2\nline 3\nline 4\n{{bad}}"
+	out := format_error("p.html", src, 28, "msg", "", colorize = false)
+	expected := `msg
+ --> p.html:5:1
+  |
+3 | line 3
+4 | line 4
+5 | {{bad}}
+  | ^^^^^^^
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_short_source_clamped :: proc(t: ^testing.T) {
+	src := "x\n{{bad}}\ny"
+	out := format_error("p.html", src, 2, "msg", "", colorize = false)
+	expected := `msg
+ --> p.html:2:1
+  |
+1 | x
+2 | {{bad}}
+  | ^^^^^^^
+3 | y
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_single_line_source :: proc(t: ^testing.T) {
+	src := "{{bad}}"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	expected := `msg
+ --> p.html:1:1
+  |
+1 | {{bad}}
+  | ^^^^^^^
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_format_error_two_digit_line_numbers :: proc(t: ^testing.T) {
+	// 12-line source; error on line 9. end_line=11 → width=2.
+	src := "l01\nl02\nl03\nl04\nl05\nl06\nl07\nl08\n{{bad}}\nl10\nl11\nl12"
+	// Position of `{{bad}}`: 8 lines of "l0N\n" = 8*4 = 32 bytes.
+	out := format_error("p.html", src, 32, "msg", "", colorize = false)
+	testing.expect(t, strings.contains(out, "  --> p.html:9:1\n"), out)
+	testing.expect(t, strings.contains(out, "   |\n"), out)
+	testing.expect(t, strings.contains(out, " 7 | l07\n"), out)
+	testing.expect(t, strings.contains(out, " 9 | {{bad}}\n"), out)
+	testing.expect(t, strings.contains(out, "11 | l11\n"), out)
+}
+
+@(test)
+test_format_error_three_digit_line_numbers :: proc(t: ^testing.T) {
+	// 102-line source; error on line 100. Width=3 because end_line=102 has 3 digits.
+	parts: [dynamic]string
+	defer delete(parts)
+	for i in 1 ..= 99 {
+		append(&parts, fmt.tprintf("l%03d", i))
+	}
+	append(&parts, "{{bad}}")
+	append(&parts, "l101")
+	append(&parts, "l102")
+	src := strings.join(parts[:], "\n", context.temp_allocator)
+
+	// Find byte position of "{{bad}}": after 99 lines.
+	pos := 0
+	for i in 1 ..= 99 {
+		pos += len(parts[i - 1]) + 1
+	}
+
+	out := format_error("p.html", src, pos, "msg", "", colorize = false)
+	testing.expect(t, strings.contains(out, "   --> p.html:100:1\n"), out)
+	testing.expect(t, strings.contains(out, "    |\n"), out)
+	testing.expect(t, strings.contains(out, " 98 | l098\n"), out)
+	testing.expect(t, strings.contains(out, "100 | {{bad}}\n"), out)
+	testing.expect(t, strings.contains(out, "102 | l102\n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Caret position
+// ---------------------------------------------------------------------------
+
+@(test)
+test_caret_at_column_1 :: proc(t: ^testing.T) {
+	src := "{{bad}} at start"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	// Caret line should start with "^" right after "| " (no leading spaces).
+	testing.expect(t, strings.contains(out, "  | ^^^^^^^\n"), out)
+}
+
+@(test)
+test_caret_at_column_N :: proc(t: ^testing.T) {
+	src := "    {{bad}}"
+	// pos=4 is the first '{'. Line 1, col 5.
+	out := format_error("p.html", src, 4, "msg", "", colorize = false)
+	// 4 leading spaces, then 7 carets.
+	testing.expect(t, strings.contains(out, "  |     ^^^^^^^\n"), out)
+}
+
+@(test)
+test_caret_width_matches_token :: proc(t: ^testing.T) {
+	src := "{{x}}"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	// {{x}} is 5 chars wide.
+	testing.expect(t, strings.contains(out, "  | ^^^^^\n"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Context count
+// ---------------------------------------------------------------------------
+
+@(test)
+test_context_before_zero :: proc(t: ^testing.T) {
+	src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+	out := format_error(
+		"p.html",
+		src,
+		9,
+		"msg",
+		"",
+		context_before = 0,
+		context_after = 1,
+		colorize = false,
+	)
+	expected := `msg
+ --> p.html:4:1
+  |
+4 | {{bad}}
+  | ^^^^^^^
+5 | l5
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_context_after_zero :: proc(t: ^testing.T) {
+	src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+	out := format_error(
+		"p.html",
+		src,
+		9,
+		"msg",
+		"",
+		context_before = 1,
+		context_after = 0,
+		colorize = false,
+	)
+	expected := `msg
+ --> p.html:4:1
+  |
+3 | l3
+4 | {{bad}}
+  | ^^^^^^^
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+@(test)
+test_context_both_zero :: proc(t: ^testing.T) {
+	src := "l1\nl2\nl3\n{{bad}}\nl5\nl6"
+	out := format_error(
+		"p.html",
+		src,
+		9,
+		"msg",
+		"",
+		context_before = 0,
+		context_after = 0,
+		colorize = false,
+	)
+	expected := `msg
+ --> p.html:4:1
+  |
+4 | {{bad}}
+  | ^^^^^^^
+  |
+`
+	testing.expect_value(t, out, expected)
+}
+
+// ---------------------------------------------------------------------------
+// Gutter/alignment
+// ---------------------------------------------------------------------------
+
+@(test)
+test_gutter_pipes_align_with_source_pipe :: proc(t: ^testing.T) {
+	src := "l1\n{{bad}}\nl3"
+	out := format_error("p.html", src, 3, "msg", "", colorize = false)
+	// All "|" characters should appear at the same column.
+	// For width=1: source line is "N | ...", so "|" at col 2.
+	// Empty gutter is "  |" (width+1 spaces + "|"), so "|" at col 2.
+	lines := strings.split(out, "\n", context.temp_allocator)
+	pipe_col := -1
+	for line in lines {
+		idx := strings.index(line, "|")
+		if idx < 0 {
+			continue
+		}
+		if pipe_col < 0 {
+			pipe_col = idx
+		} else {
+			testing.expect_value(t, idx, pipe_col)
+		}
+	}
+}
+
+@(test)
+test_arrow_points_at_pipe :: proc(t: ^testing.T) {
+	src := "{{bad}}"
+	out := format_error("p.html", src, 0, "msg", "", colorize = false)
+	// For width=1: arrow line is " --> ..." so ">" at col 3.
+	// Pipe lines are "  |" so "|" at col 2.
+	lines := strings.split(out, "\n", context.temp_allocator)
+
+	pipe_col := -1
+	for line in lines {
+		idx := strings.index(line, "|")
+		if idx >= 0 {
+			pipe_col = idx
+			break
+		}
+	}
+	testing.expect(t, pipe_col >= 0, "expected pipe in output")
+
+	// Find the arrow line specifically and verify its ">" column.
+	arrow_col := -1
+	for line in lines {
+		idx := strings.index(line, "-->")
+		if idx >= 0 {
+			arrow_col = idx + 2 // ">" is the last char of "-->"
+			break
+		}
+	}
+	testing.expect(t, arrow_col >= 0, "expected --> in output")
+	testing.expect_value(t, arrow_col, pipe_col + 1)
+}
+
+// ---------------------------------------------------------------------------
+// format_render_error — dispatch
+// ---------------------------------------------------------------------------
+
+@(test)
+test_format_render_error_dispatch :: proc(t: ^testing.T) {
+	src := "{{#unclosed}}\ncontent"
+	tmpl, parse_err := parse(src, "test.html")
+	testing.expect(t, parse_err != nil, "should fail to parse unclosed section")
+	if parse_err == nil {
+		return
+	}
+
+	b := body(parse_err)
+	out := format_error("test.html", src, b.pos, b.msg, colorize = false)
+	testing.expect(t, strings.contains(out, "unclosed section"), out)
+	testing.expect(t, strings.contains(out, "test.html:"), out)
+}
+
+@(test)
+test_diagnostic_for_pipe_error :: proc(t: ^testing.T) {
+	src := "{{#name | group_by year}}x{{/name}}"
+	tmpl, perr := parse(src, "test.html")
+	testing.expect(t, perr == nil, "should parse")
+	if perr != nil {
+		return
+	}
+	defer delete_template(&tmpl)
+
+	Data :: struct {
+		name: string,
+	}
+	_, rerr := render(tmpl, Data{name = "hello"})
+	testing.expect(t, rerr != nil, "should fail to render")
+	if rerr == nil {
+		return
+	}
+
+	out := format_render_error(rerr, tmpl, colorize = false)
+	testing.expect(t, strings.contains(out, "group_by expects a list"), out)
+	testing.expect(t, strings.contains(out, "test.html:"), out)
+}
+
+// ---------------------------------------------------------------------------
+// Parser error messages preserve double braces in tag syntax
+// ---------------------------------------------------------------------------
+
+@(test)
+test_parse_error_expected_got_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{#content}}body{{/cotent}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	b := body(err)
+	testing.expect(
+		t,
+		strings.contains(b.msg, "{{/content}}"),
+		fmt.tprintf("msg should contain literal {{/content}}, got %q", b.msg),
+	)
+	testing.expect(
+		t,
+		strings.contains(b.msg, "{{/cotent}}"),
+		fmt.tprintf("msg should contain literal {{/cotent}}, got %q", b.msg),
+	)
+}
+
+@(test)
+test_parse_error_unclosed_section_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{#content}}body"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	b := body(err)
+	testing.expect(
+		t,
+		strings.contains(b.msg, "{{#content}}"),
+		fmt.tprintf("msg should contain literal {{#content}}, got %q", b.msg),
+	)
+}
+
+@(test)
+test_parse_error_unexpected_close_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "text{{/content}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	b := body(err)
+	testing.expect(
+		t,
+		strings.contains(b.msg, "{{/content}}"),
+		fmt.tprintf("msg should contain literal {{/content}}, got %q", b.msg),
+	)
+}
+
+@(test)
+test_parse_error_pipe_in_close_tag_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{#posts | group_by year}}x{{/posts | group_by year}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	b := body(err)
+	testing.expect(
+		t,
+		strings.contains(b.msg, "{{/"),
+		fmt.tprintf("msg should contain literal '{{/', got %q", b.msg),
+	)
+}
+
+@(test)
+test_parse_error_pipe_parse_in_section_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{#posts |}}x{{/posts}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	b := body(err)
+	testing.expect(
+		t,
+		strings.contains(b.msg, "{{#"),
+		fmt.tprintf("msg should contain literal '{{#', got %q", b.msg),
+	)
+}
+
+@(test)
+test_parse_error_pipe_parse_in_inverted_keeps_double_braces :: proc(t: ^testing.T) {
+	src := "{{^posts |}}x{{/posts}}"
+	_, err := parse(src, "test.html")
+	testing.expect(t, err != nil, "should fail to parse")
+	if err == nil {
+		return
+	}
+	b := body(err)
+	testing.expect(
+		t,
+		strings.contains(b.msg, "{{^"),
+		fmt.tprintf("msg should contain literal '{{^', got %q", b.msg),
+	)
+}
+

mustache/lambda_test.odin

@@ -4,6 +4,8 @@ package mustache
 import "core:fmt"
 import "core:testing"
 
+/*
+
 // --- Spec test 1: Interpolation ---
 // A lambda's return value should be interpolated.
 
@@ -22,8 +24,8 @@ test_lambda_interpolation :: proc(t: ^testing.T) {
 	data := Interp_Data {
 		lambda = proc() -> string {return "world"},
 	}
-	tpl, _ := parse("Hello, {{lambda}}!", context.temp_allocator)
-	result, _ := render(tpl, data, allocator = context.temp_allocator)
+	tpl, _ := parse("Hello, {{lambda}}!", "<test>", context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "Hello, world!")
 }
 
@@ -36,8 +38,8 @@ test_lambda_interpolation_expansion :: proc(t: ^testing.T) {
 		lambda = proc() -> string {return "{{planet}}"},
 		planet = "world",
 	}
-	tpl, _ := parse("Hello, {{lambda}}!", context.temp_allocator)
-	result, _ := render(tpl, data, allocator = context.temp_allocator)
+	tpl, _ := parse("Hello, {{lambda}}!", "<test>", context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "Hello, world!")
 }
 
@@ -55,8 +57,8 @@ test_lambda_interpolation_multiple_calls :: proc(t: ^testing.T) {
 	data := Interp_Data_Int {
 		lambda = counter_lambda,
 	}
-	tpl, _ := parse("{{lambda}} == {{{lambda}}} == {{lambda}}", context.temp_allocator)
-	result, _ := render(tpl, data, allocator = context.temp_allocator)
+	tpl, _ := parse("{{lambda}} == {{{lambda}}} == {{lambda}}", "<test>", context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "1 == 2 == 3")
 }
 
@@ -68,8 +70,8 @@ test_lambda_escaping :: proc(t: ^testing.T) {
 	data := Interp_Data {
 		lambda = proc() -> string {return ">"},
 	}
-	tpl, _ := parse("<{{lambda}}{{{lambda}}}", context.temp_allocator)
-	result, _ := render(tpl, data, allocator = context.temp_allocator)
+	tpl, _ := parse("<{{lambda}}{{{lambda}}}", "<test>", context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "<&gt;>")
 }
 
@@ -90,8 +92,8 @@ test_lambda_section :: proc(t: ^testing.T) {
 		},
 		x = "Error!",
 	}
-	tpl, _ := parse("<{{#lambda}}{{x}}{{/lambda}}>", context.temp_allocator)
-	result, _ := render(tpl, data, allocator = context.temp_allocator)
+	tpl, _ := parse("<{{#lambda}}{{x}}{{/lambda}}>", "<test>", context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "<yes>")
 }
 
@@ -106,8 +108,8 @@ test_lambda_section_expansion :: proc(t: ^testing.T) {
 		},
 		planet = "Earth",
 	}
-	tpl, _ := parse("<{{#lambda}}-{{/lambda}}>", context.temp_allocator)
-	result, _ := render(tpl, data, allocator = context.temp_allocator)
+	tpl, _ := parse("<{{#lambda}}-{{/lambda}}>", "<test>", context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "<-Earth->")
 }
 
@@ -121,8 +123,12 @@ test_lambda_section_multiple_calls :: proc(t: ^testing.T) {
 			return fmt.tprintf("__%s__", text)
 		},
 	}
-	tpl, _ := parse("{{#lambda}}FILE{{/lambda}} != {{#lambda}}LINE{{/lambda}}", context.temp_allocator)
-	result, _ := render(tpl, data, allocator = context.temp_allocator)
+	tpl, _ := parse(
+		"{{#lambda}}FILE{{/lambda}} != {{#lambda}}LINE{{/lambda}}",
+		"<test>",
+		context.temp_allocator,
+	)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "__FILE__ != __LINE__")
 }
 
@@ -140,8 +146,10 @@ test_lambda_inverted_section :: proc(t: ^testing.T) {
 		lambda = proc(text: string) -> bool {return false},
 		static = "static",
 	}
-	tpl, _ := parse("<{{^lambda}}{{static}}{{/lambda}}>", context.temp_allocator)
-	result, _ := render(tpl, data, allocator = context.temp_allocator)
+	tpl, _ := parse("<{{^lambda}}{{static}}{{/lambda}}>", "<test>", context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "<>")
 }
 
+*/
+

mustache/mustache_test.odin

@@ -18,7 +18,12 @@ leak_parse_free_tokens :: proc(t: ^testing.T) {
 	mem.dynamic_arena_init(&arena)
 	defer mem.dynamic_arena_destroy(&arena)
 
-	tmpl, err := parse("Hello {{name}}!", context.allocator, mem.dynamic_arena_allocator(&arena))
+	tmpl, err := parse(
+		"Hello {{name}}!",
+		"<test>",
+		context.allocator,
+		mem.dynamic_arena_allocator(&arena),
+	)
 	testing.expect(t, err == nil)
 	defer delete_template(&tmpl)
 }

mustache/pipes.odin

@@ -1,7 +1,9 @@
 package mustache
 
 import "core:fmt"
+import "core:reflect"
 import "core:strings"
+import "core:time"
 
 // MAX_PIPES was chosen arbitrarily. It holds no performance or logical
 // significance.
@@ -25,9 +27,10 @@ Group :: struct {
 parse_pipeline :: proc(
 	content: string,
 	filters_out: ^[dynamic; MAX_PIPES]Pipe_Filter,
+	pos: int,
 ) -> (
 	key: string,
-	err: Render_Error,
+	err: Error,
 ) {
 	if !strings.contains(content, "|") {
 		key = strings.trim_space(content)
@@ -38,14 +41,20 @@ parse_pipeline :: proc(
 
 	filter_count := len(segments) - 1
 	if filter_count > MAX_PIPES {
-		return "", Syntax_Error {
-			msg = fmt.tprintf("pipe expression has %d filters, max is %d", filter_count, MAX_PIPES),
+		return "", Error_Body {
+			msg = fmt.tprintf(
+				"pipe expression has %d filters, max is %d",
+				filter_count,
+				MAX_PIPES,
+			),
+			pos = pos,
+			kind = .Syntax,
 		}
 	}
 
 	key = strings.trim_space(segments[0])
 	if len(key) == 0 {
-		return "", Syntax_Error{msg = "pipe expression missing key"}
+		return "", Error_Body{msg = "pipe expression missing key", pos = pos, kind = .Syntax}
 	}
 
 	if filter_count == 0 {
@@ -55,23 +64,25 @@ parse_pipeline :: proc(
 	for i in 0 ..< filter_count {
 		seg := strings.trim_space(segments[i + 1])
 		if len(seg) == 0 {
-			return "", Syntax_Error{msg = "empty filter"}
+			return "", Error_Body{msg = "empty filter", pos = pos, kind = .Syntax}
 		}
 
 		tokens := strings.fields(seg)
 		if len(tokens) == 0 {
-			return "", Syntax_Error{msg = "filter missing op name"}
+			return "", Error_Body{msg = "filter missing op name", pos = pos, kind = .Syntax}
 		}
 
 		arg_count := len(tokens) - 1
 		if arg_count > MAX_PIPE_ARGS {
-			return "", Syntax_Error {
+			return "", Error_Body {
 				msg = fmt.tprintf(
 					"filter '%s' has %d args, max is %d",
 					tokens[0],
 					arg_count,
 					MAX_PIPE_ARGS,
 				),
+				pos = pos,
+				kind = .Syntax,
 			}
 		}
 
@@ -88,10 +99,10 @@ parse_pipeline :: proc(
 	return key, nil
 }
 
-apply_pipeline :: proc(value: any, filters: []Pipe_Filter) -> (any, Render_Error) {
+apply_pipeline :: proc(value: any, filters: []Pipe_Filter, pos: int) -> (any, Error) {
 	current := value
 	for &filter in filters {
-		result, err := apply_filter(current, &filter)
+		result, err := apply_filter(current, &filter, pos)
 		if err != nil {
 			return nil, err
 		}
@@ -100,25 +111,89 @@ apply_pipeline :: proc(value: any, filters: []Pipe_Filter) -> (any, Render_Error
 	return current, nil
 }
 
-apply_filter :: proc(value: any, filter: ^Pipe_Filter) -> (any, Render_Error) {
+apply_filter :: proc(value: any, filter: ^Pipe_Filter, pos: int) -> (any, Error) {
 	switch filter.op {
 	case "group_by":
-		return apply_group_by(value, filter.args[:])
+		return apply_group_by(value, filter.args[:], pos)
+	case "format":
+		str, ok := reflect.as_string(value)
+		if !ok {
+			return value, Error_Body{
+				msg = "format may only be used on dates",
+				pos = pos,
+				kind = .Data,
+			}
+		} else {
+			return apply_format(str, filter.args[:], pos)
+		}
 	case:
-		return nil, Data_Error{msg = fmt.tprintf("unknown pipe op '%s'", filter.op)}
+		return nil, Error_Body{
+			msg = fmt.tprintf("unknown pipe op '%s'", filter.op),
+			pos = pos,
+			kind = .Data,
+		}
 	}
 }
 
+// apply_format formats an ISO 8601 date string as a display string
+// (e.g. "2026-03-15T08:49:54-04:00" → "15 Mar 2026"). Invalid input
+// (empty, too-short, or unparseable) returns a Data-kind `Error`. Templates
+// that need to skip dateless pages should gate with a section:
+//   {{#date}}<time datetime="{{.}}">{{. | format}}</time>{{/date}}
+// The section's truthiness check catches empty before the filter runs.
+//
+// Currently ignores args; planned to accept Go reference-date format
+// strings in the future.
+//
+// Accepts any of these ISO 8601 forms (date prefix is invariant):
+//   2023-10-15T13:18:50-07:00
+//   2023-10-15T13:18:50-0700
+//   2023-10-15T13:18:50Z
+//   2023-10-15T13:18:50
+//   2023-10-15
+apply_format :: proc(iso: string, args: []string, pos: int) -> (result: any, err: Error) {
+	if len(iso) < 10 {
+		return nil, Error_Body{
+			msg = "format may only be used on dates",
+			pos = pos,
+			kind = .Data,
+		}
+	}
+
+	year := iso[:4]
+	month_num := (int(iso[5]) - 0x30) * 10 + (int(iso[6]) - 0x30)
+	day_num := (int(iso[8]) - 0x30) * 10 + (int(iso[9]) - 0x30)
+
+	if month_num < 1 || month_num > 12 {
+		return nil, Error_Body{
+			msg = fmt.tprintf("invalid date: \"%s\"", iso),
+			pos = pos,
+			kind = .Data,
+		}
+	}
+
+	month := fmt.tprintf("%s", time.Month(month_num))[:3]
+	return fmt.tprintf("%d %s %s", day_num, month, year), nil
+}
+
 // Groups preserve first-appearance order from the input list.
-apply_group_by :: proc(value: any, args: []string) -> (result: any, err: Render_Error) {
+apply_group_by :: proc(value: any, args: []string, pos: int) -> (result: any, err: Error) {
 	if len(args) != 1 {
-		return nil, Data_Error{msg = fmt.tprintf("group_by expects 1 argument, got %d", len(args))}
+		return nil, Error_Body{
+			msg = fmt.tprintf("group_by expects 1 argument, got %d", len(args)),
+			pos = pos,
+			kind = .Data,
+		}
 	}
 	field := args[0]
 
 	elem_info, count, data := list_info(value)
 	if elem_info == nil {
-		return nil, Data_Error{msg = "group_by expects a list"}
+		return nil, Error_Body{
+			msg = "group_by expects a list",
+			pos = pos,
+			kind = .Data,
+		}
 	}
 
 	groups := make([dynamic]Group, 0, 8, context.temp_allocator)
@@ -131,13 +206,19 @@ apply_group_by :: proc(value: any, args: []string) -> (result: any, err: Render_
 
 		key_val, found := lookup_in(elem, field)
 		if !found {
-			return nil, Data_Error {
+			return nil, Error_Body {
 				msg = fmt.tprintf("group_by: element missing field '%s'", field),
+				pos = pos,
+				kind = .Data,
 			}
 		}
 		key_str := any_to_string(key_val)
 		if len(key_str) == 0 {
-			return nil, Data_Error{msg = fmt.tprintf("group_by: field '%s' is empty", field)}
+			return nil, Error_Body{
+				msg = fmt.tprintf("group_by: field '%s' is empty", field),
+				pos = pos,
+				kind = .Data,
+			}
 		}
 
 		idx, exists := key_to_idx[key_str]
@@ -154,3 +235,4 @@ apply_group_by :: proc(value: any, args: []string) -> (result: any, err: Render_
 
 	return groups, nil
 }
+

mustache/pipes_test.odin

@@ -66,13 +66,9 @@ test_pipe_group_by_missing_field_fails :: proc(t: ^testing.T) {
 	defer delete_template(&tpl)
 	_, err := render(tpl, data)
 	testing.expect(t, err != nil, "missing field should error")
-
-	is_data_err := false
-	#partial switch e in err {
-	case Data_Error:
-		is_data_err = len(e.msg) > 0
-	}
-	testing.expect(t, is_data_err, "error should be Data_Error")
+	b := body(err)
+	testing.expect(t, b.kind == .Data, "error should be Data kind")
+	testing.expect(t, len(b.msg) > 0, "error should have non-empty msg")
 }
 
 @(test)
@@ -204,3 +200,168 @@ test_delete_template_doesnt_leak :: proc(t: ^testing.T) {
 	defer delete_template(&tmpl)
 }
 
+// ---------------------------------------------------------------------------
+// Interpolation pipes ({{x | op}})
+// ---------------------------------------------------------------------------
+
+@(test)
+test_interp_pipe_basic :: proc(t: ^testing.T) {
+	Scalar_Data :: struct {
+		name: string,
+	}
+	data := Scalar_Data {
+		name = "2026-03-15T08:49:54-04:00",
+	}
+	tpl, _ := parse("[{{name | format}}]", "<test>", allocator = context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
+	testing.expect_value(t, result, "[15 Mar 2026]")
+}
+
+@(test)
+test_interp_pipe_unescaped :: proc(t: ^testing.T) {
+	Scalar_Data :: struct {
+		name: string,
+	}
+	data := Scalar_Data {
+		name = "2025-12-25T00:00:00Z",
+	}
+	tpl, _ := parse("[{{&name | format}}]", "<test>", allocator = context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
+	testing.expect_value(t, result, "[25 Dec 2025]")
+}
+
+@(test)
+test_interp_pipe_dot_current :: proc(t: ^testing.T) {
+	List_Data :: struct {
+		items: [3]string,
+	}
+	data := List_Data {
+		items = {"2026-01-06T00:00:00Z", "2026-06-15T00:00:00Z", "2026-10-15T00:00:00Z"},
+	}
+	tpl, _ := parse("{{#items}}[{{. | format}}]{{/items}}", "<test>", allocator = context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
+	testing.expect_value(t, result, "[6 Jan 2026][15 Jun 2026][15 Oct 2026]")
+}
+
+// ---------------------------------------------------------------------------
+// format filter
+// ---------------------------------------------------------------------------
+
+Format_Data :: struct {
+	date: string,
+}
+
+@(test)
+test_format_typical_iso :: proc(t: ^testing.T) {
+	data := Format_Data {
+		date = "2026-03-15T08:49:54-04:00",
+	}
+	tpl, _ := parse("{{date | format}}", "<test>", allocator = context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
+	testing.expect_value(t, result, "15 Mar 2026")
+}
+
+@(test)
+test_format_short_date_only :: proc(t: ^testing.T) {
+	data := Format_Data {
+		date = "2026-06-06",
+	}
+	tpl, _ := parse("{{date | format}}", "<test>", allocator = context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
+	testing.expect_value(t, result, "6 Jun 2026")
+}
+
+@(test)
+test_format_empty_input_errors :: proc(t: ^testing.T) {
+	data := Format_Data {
+		date = "",
+	}
+	tpl, _ := parse("[{{date | format}}]", "<test>", allocator = context.temp_allocator)
+	defer delete_template(&tpl)
+	_, err := render(tpl, data, {}, context.temp_allocator)
+	testing.expect(t, err != nil, "empty date should error")
+}
+
+@(test)
+test_format_non_date_string_errors :: proc(t: ^testing.T) {
+	data := Format_Data {
+		date = "abc",
+	}
+	tpl, _ := parse("[{{date | format}}]", "<test>", allocator = context.temp_allocator)
+	defer delete_template(&tpl)
+	_, err := render(tpl, data, {}, context.temp_allocator)
+	testing.expect(t, err != nil, "non-date string should error")
+}
+
+@(test)
+test_format_non_string_value_errors :: proc(t: ^testing.T) {
+	Int_Data :: struct {
+		count: int,
+	}
+	data := Int_Data {
+		count = 42,
+	}
+	tpl, _ := parse("{{count | format}}", "<test>", allocator = context.temp_allocator)
+	defer delete_template(&tpl)
+	_, err := render(tpl, data, {}, context.temp_allocator)
+	testing.expect(t, err != nil, "non-string value should error")
+}
+
+@(test)
+test_format_invalid_month_errors :: proc(t: ^testing.T) {
+	data := Format_Data {
+		date = "2023-13-15",
+	}
+	tpl, _ := parse("{{date | format}}", "<test>", allocator = context.temp_allocator)
+	defer delete_template(&tpl)
+	_, err := render(tpl, data, {}, context.temp_allocator)
+	testing.expect(t, err != nil, "invalid month should error")
+}
+
+@(test)
+test_format_inside_section_renders :: proc(t: ^testing.T) {
+	// Mirrors the datetime.html partial pattern: section pushes raw string,
+	// partial uses {{.}} for ISO attr and {{. | format}} for display.
+	data := Format_Data {
+		date = "2025-12-25T00:00:00Z",
+	}
+	tpl, _ := parse(
+		"{{#date}}<time datetime=\"{{.}}\">{{. | format}}</time>{{/date}}",
+		"<test>",
+		allocator = context.temp_allocator,
+	)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
+	testing.expect_value(t, result, "<time datetime=\"2025-12-25T00:00:00Z\">25 Dec 2025</time>")
+}
+
+@(test)
+test_format_inside_section_skips_when_empty :: proc(t: ^testing.T) {
+	data := Format_Data {
+		date = "",
+	}
+	tpl, _ := parse("[{{#date}}<time>{{. | format}}</time>{{/date}}]", "<test>", allocator = context.temp_allocator)
+	result, _ := render(tpl, data, {}, context.temp_allocator)
+	testing.expect_value(t, result, "[]")
+}
+
+@(test)
+test_format_handles_all_iso8601_variants :: proc(t: ^testing.T) {
+	cases := [5]struct {
+		input, expected: string,
+	} {
+		{"2023-10-15T13:18:50-07:00", "15 Oct 2023"},
+		{"2023-10-15T13:18:50-0700", "15 Oct 2023"},
+		{"2023-10-15T13:18:50Z", "15 Oct 2023"},
+		{"2023-10-15T13:18:50", "15 Oct 2023"},
+		{"2023-10-15", "15 Oct 2023"},
+	}
+	for &c in cases {
+		data := Format_Data {
+			date = c.input,
+		}
+		tpl, _ := parse("{{date | format}}", "<test>", allocator = context.temp_allocator)
+		result, _ := render(tpl, data, {}, context.temp_allocator)
+		testing.expect_value(t, result, c.expected)
+	}
+}
+

mustache/spec_test.odin

@@ -3,6 +3,7 @@ package mustache
 
 import "core:encoding/json"
 import "core:fmt"
+import "core:log"
 import "core:os"
 import "core:path/filepath"
 import "core:testing"
@@ -54,6 +55,10 @@ run_one_test :: proc(
 	test: json.Object,
 	name, template_src, expected: string,
 ) -> bool {
+	// Spec tests deliberately exercise missing keys, missing partials, etc.
+	// Silence the warnings to keep test output readable.
+	context.logger = log.nil_logger()
+
 	partials := make_map(map[string]Template, context.temp_allocator)
 
 	if "partials" in test {
@@ -63,7 +68,7 @@ run_one_test :: proc(
 			psrc, ok := pval.(string)
 			assert(ok)
 
-			pt, perr := parse(psrc, context.temp_allocator)
+			pt, perr := parse(psrc, "<spec>", context.temp_allocator)
 			if perr != nil {
 				testing.expectf(t, false, "[%s] partial '%s' parse error", name, pname)
 				return false
@@ -72,7 +77,7 @@ run_one_test :: proc(
 		}
 	}
 
-	tmpl, terr := parse(template_src, context.temp_allocator)
+	tmpl, terr := parse(template_src, "<spec>", context.temp_allocator)
 	if terr != nil {
 		testing.expectf(t, false, "[%s] template parse error", name)
 		return false

mustache/suggest.odin

@@ -0,0 +1,206 @@
+package mustache
+
+import "base:runtime"
+import "core:strings"
+
+// collect_struct_keys enumerates the visible field names of a struct value,
+// including fields promoted via `using`-embedded structs.
+collect_struct_keys :: proc(val: any, allocator := context.temp_allocator) -> []string {
+	out := make([dynamic]string, 0, 0, allocator)
+	collect_struct_keys_into(val, &out, allocator)
+	return out[:]
+}
+
+collect_struct_keys_into :: proc(val: any, out: ^[dynamic]string, allocator := context.allocator) {
+	v, info := base_value(val)
+	if info == nil {
+		return
+	}
+	s, ok := info.variant.(runtime.Type_Info_Struct)
+	if !ok {
+		return
+	}
+	for i in 0 ..< int(s.field_count) {
+		name := s.names[i]
+		if len(name) == 0 {
+			continue
+		}
+		if name[0] == '_' {
+			continue
+		}
+		append(out, name)
+
+		// Recurse into using-embedded struct fields to surface promoted names.
+		if s.usings[i] {
+			field_info := type_info_of(s.types[i].id)
+			if field_info != nil {
+				collect_struct_keys_into(any{v.data, s.types[i].id}, out, allocator)
+			}
+		}
+	}
+}
+
+// struct_has_field reports whether a struct value has a named field,
+// independent of whether that field's value is currently nil. This matters
+// for fields like `Maybe(bool)` which can be nil but still exist.
+struct_has_field :: proc(val: any, key: string) -> bool {
+	v, info := base_value(val)
+	if info == nil {
+		return false
+	}
+	s, ok := info.variant.(runtime.Type_Info_Struct)
+	if !ok {
+		return false
+	}
+	for i in 0 ..< int(s.field_count) {
+		if s.names[i] == key {
+			return true
+		}
+		// Recurse into using-embedded fields.
+		if s.usings[i] {
+			if struct_has_field(any{v.data, s.types[i].id}, key) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// validate_key_path walks a dotted key path against the context stack and
+// reports where (if anywhere) the lookup fails. Returns:
+//   - ok: true if the entire path resolves, OR if the path crosses a map
+//         (map keys are user-defined and not validated)
+//   - missing_segment: the segment that failed (empty when ok)
+//   - available: keys available at the failing level, for suggestions
+validate_key_path :: proc(
+	ctx: []any,
+	key: string,
+	allocator := context.temp_allocator,
+) -> (
+	ok: bool,
+	missing_segment: string,
+	available: []string,
+) {
+	parts: [16]string
+	part_count := 0
+	start := 0
+	for i in 0 ..< len(key) {
+		if key[i] == '.' {
+			if part_count < len(parts) {
+				parts[part_count] = key[start:i]
+				part_count += 1
+			}
+			start = i + 1
+		}
+	}
+	if part_count < len(parts) {
+		parts[part_count] = key[start:]
+		part_count += 1
+	}
+	if part_count == 0 {
+		return true, "", nil
+	}
+
+	current: any = nil
+	found := false
+	for i := len(ctx) - 1; i >= 0; i -= 1 {
+		current, found = lookup_in(ctx[i], parts[0])
+		if found {
+			break
+		}
+	}
+
+	if !found {
+		keys := make([dynamic]string, 0, 4, allocator)
+		for i := len(ctx) - 1; i >= 0; i -= 1 {
+			collect_struct_keys_into(ctx[i], &keys, allocator)
+		}
+		return false, parts[0], keys[:]
+	}
+
+	for i in 1 ..< part_count {
+		v, info := base_value(current)
+		if info == nil {
+			return false, parts[i], nil
+		}
+		if _, is_map := info.variant.(runtime.Type_Info_Map); is_map {
+			return true, "", nil
+		}
+		if _, is_struct := info.variant.(runtime.Type_Info_Struct); is_struct {
+			if !struct_has_field(current, parts[i]) {
+				return false, parts[i], collect_struct_keys(current, allocator)
+			}
+			// Field exists — descend into it. If the value is nil, stop here
+			// (further segments can't be resolved but the current field is
+			// legitimately present).
+			next, found := lookup_in(current, parts[i])
+			if !found {
+				return true, "", nil
+			}
+			current = next
+			continue
+		}
+		return false, parts[i], nil
+	}
+
+	return true, "", nil
+}
+
+// suggest_correction returns the closest match from `available` to `missing`
+// using Levenshtein distance, or "" if no good match exists. The threshold
+// scales with the length of the missing key.
+suggest_correction :: proc(available: []string, missing: string) -> string {
+	if len(available) == 0 || len(missing) == 0 {
+		return ""
+	}
+	threshold := 2
+	if len(missing) > 8 {
+		threshold = len(missing) / 4
+	}
+
+	best: string
+	best_dist := threshold + 1
+	for candidate in available {
+		if abs(len(candidate) - len(missing)) > threshold {
+			continue
+		}
+		d := strings.levenshtein_distance(missing, candidate)
+		if d <= threshold && d < best_dist {
+			best = candidate
+			best_dist = d
+		}
+	}
+	return best
+}
+
+// collect_partial_names enumerates the keys of the partials map.
+collect_partial_names :: proc(
+	partials: map[string]Template,
+	allocator := context.temp_allocator,
+) -> []string {
+	out := make([dynamic]string, 0, 0, allocator)
+	for name in partials {
+		append(&out, name)
+	}
+	return out[:]
+}
+
+// collect_block_names enumerates the unique `{{$name}}` block definitions in
+// a template's node array.
+collect_block_names :: proc(
+	tmpl: Template,
+	allocator := context.temp_allocator,
+) -> []string {
+	out := make([dynamic]string, 0, 0, allocator)
+	seen := make(map[string]bool, allocator)
+	defer delete(seen)
+	for &node in tmpl.nodes {
+		if node.kind == .Block {
+			if !seen[node.key] {
+				seen[node.key] = true
+				append(&out, node.key)
+			}
+		}
+	}
+	return out[:]
+}

mustache/suggest_test.odin

@@ -0,0 +1,195 @@
+#+test
+#+feature dynamic-literals
+package mustache
+
+import "core:fmt"
+import "core:testing"
+
+Inner :: struct {
+	foo: string,
+	bar: int,
+}
+
+Outer :: struct {
+	title:      string,
+	page_title: string,
+	inner:      Inner,
+	numbers:    [3]int,
+}
+
+@(test)
+test_validate_simple_found :: proc(t: ^testing.T) {
+	data := Outer {
+		title = "hi",
+	}
+	ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+	append(&ctx, data)
+
+	ok, missing, _ := validate_key_path(ctx[:], "title")
+	testing.expect_value(t, ok, true)
+	testing.expect(t, missing == "", fmt.tprintf("expected empty missing, got %q", missing))
+}
+
+@(test)
+test_validate_simple_missing :: proc(t: ^testing.T) {
+	data := Outer {
+		title = "hi",
+	}
+	ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+	append(&ctx, data)
+
+	ok, missing, available := validate_key_path(ctx[:], "page_titel")
+	testing.expect_value(t, ok, false)
+	testing.expect_value(t, missing, "page_titel")
+	testing.expect(t, len(available) > 0, "should have suggestions")
+}
+
+@(test)
+test_validate_dotted_found :: proc(t: ^testing.T) {
+	data := Outer {
+		inner = Inner{foo = "x"},
+	}
+	ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+	append(&ctx, data)
+
+	ok, missing, _ := validate_key_path(ctx[:], "inner.foo")
+	testing.expect_value(t, ok, true)
+	testing.expect_value(t, missing, "")
+}
+
+@(test)
+test_validate_dotted_missing :: proc(t: ^testing.T) {
+	data := Outer {
+		inner = Inner{foo = "x"},
+	}
+	ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+	append(&ctx, data)
+
+	ok, missing, available := validate_key_path(ctx[:], "inner.fooo")
+	testing.expect_value(t, ok, false)
+	testing.expect_value(t, missing, "fooo")
+	testing.expect(t, len(available) > 0, "should have inner field suggestions")
+}
+
+Params_Data :: struct {
+	params: map[string]string,
+}
+
+Maybe_Bool_Data :: struct {
+	flag: Maybe(bool),
+	name: string,
+}
+
+Inner_For_Using :: struct {
+	flag:  Maybe(bool),
+	label: string,
+}
+
+Outer_With_Using :: struct {
+	using inner: Inner_For_Using,
+	other:       int,
+}
+
+@(test)
+test_validate_path_through_using_to_maybe_bool :: proc(t: ^testing.T) {
+	data := Outer_With_Using {
+		inner = Inner_For_Using{label = "hi"},
+		other = 42,
+	}
+	ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+	append(&ctx, data)
+
+	// `flag` is promoted via using; field exists even when Maybe is nil.
+	ok, missing, _ := validate_key_path(ctx[:], "flag")
+	testing.expect_value(t, ok, true)
+	testing.expect_value(t, missing, "")
+
+	// `label` is also promoted via using.
+	ok2, missing2, _ := validate_key_path(ctx[:], "label")
+	testing.expect_value(t, ok2, true)
+	testing.expect_value(t, missing2, "")
+}
+
+@(test)
+test_struct_has_field_with_maybe_bool :: proc(t: ^testing.T) {
+	data := Maybe_Bool_Data {
+		name = "hi",
+	} // flag is nil Maybe
+	testing.expect_value(t, struct_has_field(data, "flag"), true)
+	testing.expect_value(t, struct_has_field(data, "name"), true)
+	testing.expect_value(t, struct_has_field(data, "missing"), false)
+}
+
+@(test)
+test_validate_path_through_maybe_bool :: proc(t: ^testing.T) {
+	data := Maybe_Bool_Data {
+		name = "hi",
+	}
+	ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+	append(&ctx, data)
+
+	// `flag` exists as a field even when its Maybe value is nil — should NOT warn.
+	ok, missing, _ := validate_key_path(ctx[:], "flag")
+	testing.expect_value(t, ok, true)
+	testing.expect_value(t, missing, "")
+}
+
+@(test)
+test_validate_map_path_silent :: proc(t: ^testing.T) {
+	data := Params_Data {
+		params = {"social" = "x"},
+	}
+	defer delete(data.params)
+	ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+	append(&ctx, data)
+
+	// `params` exists and is a map — subsequent segments are user-defined.
+	ok, _, _ := validate_key_path(ctx[:], "params.anything_here")
+	testing.expect_value(t, ok, true)
+}
+
+@(test)
+test_suggest_correction_exact :: proc(t: ^testing.T) {
+	available := []string{"title", "page_title", "body"}
+	testing.expect_value(t, suggest_correction(available, "page_titel"), "page_title")
+}
+
+@(test)
+test_suggest_correction_close :: proc(t: ^testing.T) {
+	available := []string{"title", "body", "now"}
+	testing.expect_value(t, suggest_correction(available, "titel"), "title")
+}
+
+@(test)
+test_suggest_correction_no_match :: proc(t: ^testing.T) {
+	available := []string{"completely_different", "unrelated"}
+	testing.expect_value(t, suggest_correction(available, "page_titel"), "")
+}
+
+@(test)
+test_suggest_correction_empty :: proc(t: ^testing.T) {
+	testing.expect_value(t, suggest_correction([]string{}, "anything"), "")
+	testing.expect_value(t, suggest_correction([]string{"a"}, ""), "")
+}
+
+@(test)
+test_warn_no_false_positive_for_valid_keys :: proc(t: ^testing.T) {
+	Data :: struct {
+		name: string,
+	}
+	src := "Hello {{name}}"
+	tmpl, err := parse(src, "<test>", context.temp_allocator)
+	testing.expect(t, err == nil, "should parse")
+	if err != nil {
+		return
+	}
+
+	// We can't easily capture log output in tests, but we can verify the
+	// validation procs agree the key exists.
+	ctx := make([dynamic]any, 0, 1, context.temp_allocator)
+	append(&ctx, Data{name = "World"})
+
+	ok, missing, _ := validate_key_path(ctx[:], "name")
+	testing.expect_value(t, ok, true)
+}
+

mustache/tokenizer.odin

@@ -28,7 +28,7 @@ tokenize :: proc(
 	allocator := context.allocator,
 ) -> (
 	tokens: [dynamic]Token,
-	err: Render_Error,
+	err: Error,
 ) {
 	tokens = make([dynamic]Token, 0, 8, allocator)
 
@@ -36,96 +36,111 @@ tokenize :: proc(
 	text_start := 0
 
 	for i < len(src) {
-		if src[i] == '{' && i + 1 < len(src) && src[i + 1] == '{' {
-			if i > text_start {
-				append(&tokens, Token{kind = .Text, value = src[text_start:i], pos = text_start})
-			}
-
-			tag_pos := i
-
-			if i + 2 < len(src) && src[i + 2] == '{' {
-				content_start := i + 3
-				idx := strings.index(src[content_start:], "}}}")
-				if idx < 0 {
-					return tokens, Syntax_Error {
-						msg = "unclosed triple mustache '{{{'",
-						pos = tag_pos,
-					}
-				}
-				close := content_start + idx
-				key := strings.trim_space(src[content_start:close])
-				append(&tokens, Token{kind = .Unescaped, value = key, pos = tag_pos})
-				i = close + 3
-				text_start = i
-			} else {
-				content_start := i + 2
-				sigil: byte = 0
-				if content_start < len(src) {
-					sigil = src[content_start]
-				}
-
-				kind: Token_Kind
-				key_start := content_start
-
-				switch sigil {
-				case '&':
-					kind = .Unescaped; key_start = content_start + 1
-				case '#':
-					kind = .Section_Open; key_start = content_start + 1
-				case '^':
-					kind = .Inverted_Open; key_start = content_start + 1
-				case '/':
-					kind = .Section_Close; key_start = content_start + 1
-				case '!':
-					kind = .Comment; key_start = content_start + 1
-				case '>':
-					kind = .Partial; key_start = content_start + 1
-				case '<':
-					kind = .Parent; key_start = content_start + 1
-				case '$':
-					kind = .Block_Open; key_start = content_start + 1
-				case:
-					kind = .Variable
+		// Find next '{' via AVX2/SSE-backed memchr instead of byte-by-byte scan.
+		rel := strings.index_byte(src[i:], '{')
+		if rel < 0 {
+			i = len(src)
+			break
+		}
+		next := i + rel
+		// Single '{' (not '{{') — advance past it and keep scanning.
+		if next + 1 >= len(src) || src[next + 1] != '{' {
+			i = next + 1
+			continue
+		}
+		i = next
+
+		if i > text_start {
+			append(&tokens, Token{kind = .Text, value = src[text_start:i], pos = text_start})
+		}
+
+		tag_pos := i
+
+		if i + 2 < len(src) && src[i + 2] == '{' {
+			content_start := i + 3
+			idx := strings.index(src[content_start:], "}}}")
+			if idx < 0 {
+				return tokens, Error_Body {
+					msg = "unclosed triple mustache '{{{'",
+					pos = tag_pos,
+					kind = .Syntax,
 				}
-
-				close_idx := strings.index(src[key_start:], "}}")
-				if close_idx < 0 {
-					return tokens, Syntax_Error{msg = "unclosed tag '{{'", pos = tag_pos}
-				}
-				close := key_start + close_idx
-
-				content := src[key_start:close]
-
-				if kind == .Comment {
-					append(&tokens, Token{kind = .Comment, value = content, pos = tag_pos})
-				} else if kind == .Partial {
-					trimmed := strings.trim_space(content)
-					is_dyn := false
-					if len(trimmed) > 0 && trimmed[0] == '*' {
-						is_dyn = true
-						trimmed = strings.trim_space(trimmed[1:])
-					}
-					append(
-						&tokens,
-						Token {
-							kind = .Partial,
-							value = trimmed,
-							is_dynamic = is_dyn,
-							pos = tag_pos,
-						},
-					)
-				} else {
-					append(
-						&tokens,
-						Token{kind = kind, value = strings.trim_space(content), pos = tag_pos},
-					)
-				}
-
-				i = close + 2
-				text_start = i
 			}
+			close := content_start + idx
+			key := strings.trim_space(src[content_start:close])
+			append(&tokens, Token{kind = .Unescaped, value = key, pos = tag_pos})
+			i = close + 3
+			text_start = i
 		} else {
-			i += 1
+			content_start := i + 2
+			sigil: byte = 0
+			if content_start < len(src) {
+				sigil = src[content_start]
+			}
+
+			kind: Token_Kind
+			key_start := content_start
+
+			switch sigil {
+			case '&':
+				kind = .Unescaped; key_start = content_start + 1
+			case '#':
+				kind = .Section_Open; key_start = content_start + 1
+			case '^':
+				kind = .Inverted_Open; key_start = content_start + 1
+			case '/':
+				kind = .Section_Close; key_start = content_start + 1
+			case '!':
+				kind = .Comment; key_start = content_start + 1
+			case '>':
+				kind = .Partial; key_start = content_start + 1
+			case '<':
+				kind = .Parent; key_start = content_start + 1
+			case '$':
+				kind = .Block_Open; key_start = content_start + 1
+			case:
+				kind = .Variable
+			}
+
+			close_idx := strings.index(src[key_start:], "}}")
+			if close_idx < 0 {
+				return tokens, Error_Body {
+					msg = "unclosed tag '{{'",
+					pos = tag_pos,
+					kind = .Syntax,
+				}
+			}
+			close := key_start + close_idx
+
+			content := src[key_start:close]
+
+			if kind == .Comment {
+				append(&tokens, Token{kind = .Comment, value = content, pos = tag_pos})
+			} else if kind == .Partial {
+				trimmed := strings.trim_space(content)
+				is_dyn := false
+				if len(trimmed) > 0 && trimmed[0] == '*' {
+					is_dyn = true
+					trimmed = strings.trim_space(trimmed[1:])
+				}
+				append(
+					&tokens,
+					Token {
+						kind = .Partial,
+						value = trimmed,
+						is_dynamic = is_dyn,
+						pos = tag_pos,
+					},
+				)
+			} else {
+				append(
+					&tokens,
+					Token{kind = kind, value = strings.trim_space(content), pos = tag_pos},
+				)
+			}
+
+			i = close + 2
+			text_start = i
 		}
 	}
 

render.odin

@@ -11,28 +11,26 @@ import "core:time"
 import "core:time/datetime"
 
 Page_Context :: struct {
-	permalink:    string,
-	title:        string,
-	starred:      bool,
-	date_iso:     string,
-	date_display: string,
-	year:         string,
+	permalink: string,
+	title:     string,
+	starred:   bool,
+	date:      string,
+	year:      string,
 }
 
 Base_Data :: struct {
-	now:    datetime.DateTime,
-	author: string,
-	params: json.Value,
-	body:   string,
-	title:  string,
-	og:     Open_Graph,
+	now:         datetime.DateTime,
+	params:      json.Value,
+	body:        string,
+	title:       string,
+	description: string,
+	og:          Open_Graph,
 }
 
 Page_Data :: struct {
-	using base:   Base_Data,
-	page_title:   string,
-	date_iso:     string,
-	date_display: string,
+	using base: Base_Data,
+	page_title: string,
+	date:       string,
 }
 
 Home_Data :: struct {
@@ -51,21 +49,32 @@ build_page_context :: proc(page: Page) -> Page_Context {
 		permalink = page.permalink,
 		title = page.title,
 		starred = page.is_starred,
-		date_iso = page.date,
-		date_display = format_date(page.date),
+		date = page.date,
 		year = get_year(page.date),
 	}
 }
 
 load_template :: proc(vfs: ^VFS, virtual_path: string) -> mustache.Template {
-	data, ok := vfs_get(vfs, virtual_path)
+	entry, data, ok := vfs_get_entry(vfs, virtual_path)
 	if !ok {
-		log.warnf("template %s not found", virtual_path)
-		return mustache.Template{}
+		log.fatalf("template %s not found", virtual_path)
+		os.exit(1)
 	}
-	tpl, err := mustache.parse(string(data))
+	source := string(data)
+	tpl, err := mustache.parse(source, entry.fs_path)
 	if err != nil {
-		log.warnf("failed to parse template %s: %v", virtual_path, err)
+		b := mustache.body(err)
+		log.errorf(
+			"%s",
+			mustache.format_error(
+				entry.fs_path,
+				source,
+				b.pos,
+				b.msg,
+				colorize = mustache.should_colorize(),
+			),
+		)
+		os.exit(1)
 	}
 	return tpl
 }
@@ -125,7 +134,10 @@ render_template :: proc(
 ) -> string {
 	result, err := mustache.render(content_tpl, data, partials)
 	if err != nil {
-		fmt.eprintfln("mustache error: %v", err)
+		log.errorf(
+			"%s",
+			mustache.format_render_error(err, content_tpl, colorize = mustache.should_colorize()),
+		)
 		return ""
 	}
 	return result
@@ -147,10 +159,10 @@ render_site :: proc(site: ^Site) {
 
 	// Build base data once
 	base := Base_Data {
-		now    = now,
-		author = site.author,
-		params = site.params,
-		og     = site.og,
+		now         = now,
+		params      = site.params,
+		description = site.description,
+		og          = site.og,
 	}
 
 	// Find home page
@@ -261,8 +273,7 @@ render_page_html :: proc(
 	data.title = fmt.tprintf("%s | %s", page.title, site.title)
 	data.page_title = page.title
 	data.body = page.body_html
-	data.date_iso = page.date
-	data.date_display = format_date(page.date)
+	data.date = page.date
 	data.og = og_for_page(site.og, page)
 	return render_template(content_tpl, data, partials)
 }
@@ -335,7 +346,7 @@ render_section :: proc(
 load_partials :: proc(vfs: ^VFS) -> map[string]mustache.Template {
 	partials: map[string]mustache.Template
 	prefix := "layouts/partials/"
-	for virtual_path in vfs.files {
+	for virtual_path, entry in vfs.files {
 		if !strings.has_prefix(virtual_path, prefix) {
 			continue
 		}
@@ -346,28 +357,28 @@ load_partials :: proc(vfs: ^VFS) -> map[string]mustache.Template {
 		stripped := virtual_path[len(prefix):]
 		key := stripped[:len(stripped) - len(".html")]
 
-		data, ok := vfs_get(vfs, virtual_path)
-		if !ok {
-			continue
-		}
-		tpl, err := mustache.parse(string(data))
+		data := vfs_entry_data(entry) or_continue
+		source := string(data)
+		tpl, err := mustache.parse(source, entry.fs_path)
 		if err != nil {
-			log.warnf("failed to parse partial %s: %v", key, err)
-			continue
+			b := mustache.body(err)
+			log.errorf(
+				"%s",
+				mustache.format_error(
+					entry.fs_path,
+					source,
+					b.pos,
+					b.msg,
+					colorize = mustache.should_colorize(),
+				),
+			)
+			os.exit(1)
 		}
 		partials[key] = tpl
 	}
 	return partials
 }
 
-format_date :: proc(iso: string) -> string {
-	if len(iso) < 10 {
-		return ""
-	}
-	date, _, _, _ := time.iso8601_to_components(iso)
-	return fmt.aprintf("%s %d, %d", time.Month(date.month), date.day, date.year)
-}
-
 get_year :: proc(iso: string) -> string {
 	if len(iso) < 4 {
 		return ""
@@ -395,7 +406,7 @@ write_page :: proc(output_dir: string, permalink: string, html: string) {
 
 	dir := fmt.tprintf("%s/%s", output_dir, rel)
 	if err := os.make_directory_all(dir); err != nil && err != .Exist {
-		fmt.eprintfln("cannot create %s: %v", dir, err)
+		log.errorf("cannot create %s: %v", dir, err)
 		return
 	}
 
@@ -405,7 +416,7 @@ write_page :: proc(output_dir: string, permalink: string, html: string) {
 
 write_file :: proc(path: string, html: string) {
 	if err := os.write_entire_file_from_string(path, html); err != nil {
-		fmt.eprintfln("cannot write %s: %v", path, err)
+		log.errorf("cannot write %s: %v", path, err)
 	}
 }
 

site.odin

@@ -19,7 +19,6 @@ Site :: struct {
 	vfs:                 VFS,
 	title:               string,
 	description:         string,
-	author:              string,
 	base_url:            string,
 	config_path:         string,
 	content_dir:         string,
@@ -44,7 +43,6 @@ Config_File :: struct {
 	title:               string,
 	description:         string,
 	base_url:            string,
-	author:              string,
 	content_dir:         string,
 	assets_dir:          string,
 	output_dir:          string,
@@ -136,7 +134,6 @@ load_config_file :: proc(
 site_apply_config :: proc(site: ^Site, config: Config_File, config_dir: string) {
 	if config.title != "" do site.title = config.title
 	if config.description != "" do site.description = config.description
-	if config.author != "" do site.author = config.author
 	if config.base_url != "" do site.base_url = config.base_url
 
 	site.content_dir =

site_test.odin

@@ -25,8 +25,8 @@ test_load_config_file :: proc(t: ^testing.T) {
 			"title":"Test Site",
 			"description":"Test desc",
 			"base_url":"https://example.com",
-			"author":"Tester",
 			"params":{
+				"author":"Tester",
 				"social":[
 					{"name":"github","url":"https://github.com/test"},
 					{"name":"rss","url":"/index.xml"}]
@@ -42,11 +42,15 @@ test_load_config_file :: proc(t: ^testing.T) {
 	testing.expect_value(t, cfg.title, "Test Site")
 	testing.expect_value(t, cfg.description, "Test desc")
 	testing.expect_value(t, cfg.base_url, "https://example.com")
-	testing.expect_value(t, cfg.author, "Tester")
 
 	params, has_params := cfg.params.(json.Object)
 	testing.expect(t, has_params)
 
+	author_val := params["author"]
+	author, has_author := author_val.(json.String)
+	testing.expect(t, has_author)
+	testing.expect_value(t, author, "Tester")
+
 	social_val := params["social"]
 	social, has_social := social_val.(json.Array)
 	testing.expect(t, has_social)
@@ -94,7 +98,6 @@ test_load_config_file_partial :: proc(t: ^testing.T) {
 	testing.expect(t, ok)
 	testing.expect_value(t, cfg.title, "Partial")
 	testing.expect_value(t, cfg.description, "")
-	testing.expect_value(t, cfg.author, "")
 	testing.expect(t, cfg.params == nil)
 }
 
@@ -143,7 +146,7 @@ test_init_site_flag_overrides_default :: proc(t: ^testing.T) {
 test_init_site_full_pipeline :: proc(t: ^testing.T) {
 	path := write_temp_config(
 		"pipeline",
-		`{"title":"Pipeline Test","description":"Full","base_url":"https://config.com","author":"Author"}`,
+		`{"title":"Pipeline Test","description":"Full","base_url":"https://config.com"}`,
 	)
 	defer os.remove(path)
 
@@ -154,7 +157,6 @@ test_init_site_full_pipeline :: proc(t: ^testing.T) {
 
 	testing.expect_value(t, site.title, "Pipeline Test")
 	testing.expect_value(t, site.description, "Full")
-	testing.expect_value(t, site.author, "Author")
 	testing.expect(t, .Drafts in site.features)
 	testing.expect_value(t, site.base_url, "https://config.com")
 }
@@ -162,7 +164,12 @@ test_init_site_full_pipeline :: proc(t: ^testing.T) {
 @(test)
 test_init_site_md_enable_disable :: proc(t: ^testing.T) {
 	site: Site
-	args := []string{"thor", "-config:./nonexistent.json", "-ext:highlight,sections", "-no-ext:emoji"}
+	args := []string {
+		"thor",
+		"-config:./nonexistent.json",
+		"-ext:highlight,sections",
+		"-no-ext:emoji",
+	}
 	init_site(&site, args)
 	defer destroy_site(&site)
 

vfs.odin

@@ -78,3 +78,35 @@ vfs_get :: proc(vfs: ^VFS, virtual_path: string) -> ([]byte, bool) {
 	return data, true
 }
 
+// vfs_get_entry returns both the VFS_Entry (for fs_path) and the lazily-loaded
+// data. Use this instead of vfs_get when you need the entry's metadata along
+// with the contents.
+vfs_get_entry :: proc(vfs: ^VFS, virtual_path: string) -> (VFS_Entry, []byte, bool) {
+	entry, ok := vfs.files[virtual_path]
+	if !ok {
+		return {}, nil, false
+	}
+	if entry.data != nil {
+		return entry, entry.data, true
+	}
+	data, err := os.read_entire_file_from_path(entry.fs_path, context.allocator)
+	if err != nil {
+		return entry, nil, false
+	}
+	return entry, data, true
+}
+
+// vfs_entry_data returns the data for a VFS_Entry, reading from disk if it
+// hasn't been loaded yet. Useful when iterating vfs.files directly (where you
+// already have the entry and don't want a redundant map lookup).
+vfs_entry_data :: proc(entry: VFS_Entry) -> ([]byte, bool) {
+	if entry.data != nil {
+		return entry.data, true
+	}
+	data, err := os.read_entire_file_from_path(entry.fs_path, context.allocator)
+	if err != nil {
+		return nil, false
+	}
+	return data, true
+}
+