wip: Approved diagnostic changes.

TODOS.md

@@ -27,6 +27,7 @@
   - 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
@@ -111,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

mustache/mustache.odin

@@ -1,28 +1,26 @@
 package mustache
 
 import "core:fmt"
+import "core:log"
 import "core:strings"
 
 // ---------------------------------------------------------------------------
 // Error types
 // ---------------------------------------------------------------------------
 
+// TODO: I don't think this is the best way to do our errors.
 Syntax_Error :: struct {
 	msg: string,
 	pos: int,
 }
 Data_Error :: struct {
 	msg: string,
-}
+	pos: int,
-Partial_Error :: struct {
-	name: string,
-	msg:  string,
 }
 
 Render_Error :: union {
 	Syntax_Error,
 	Data_Error,
-	Partial_Error,
 }
 
 // ---------------------------------------------------------------------------
@@ -50,6 +48,7 @@ Node :: struct {
 	first_child: int,
 	child_count: int,
 	content:     string,
+	pos:         int,
 }
 
 // node_span returns the number of flat-array entries a node occupies:
@@ -67,12 +66,14 @@ node_span :: proc(n: Node) -> int {
 Template :: struct {
 	nodes:  [dynamic]Node,
 	source: string,
+	path:   string,
 }
 
 Block_Override :: struct {
 	all_nodes: []Node,
 	first:     int,
 	count:     int,
+	source:    Template,
 }
 
 delete_template :: proc(tmpl: ^Template) {
@@ -94,6 +95,7 @@ delete_partials :: proc(partials: map[string]Template) {
 
 parse :: proc(
 	source: string,
+	path := "",
 	allocator := context.allocator,
 	tokens_allocator := context.temp_allocator,
 ) -> (
@@ -111,6 +113,7 @@ parse :: proc(
 		return {}, err
 	}
 	tmpl.source = source
+	tmpl.path = path
 	deindent_blocks(tmpl.nodes[:], 0, len(tmpl.nodes), allocator)
 	return tmpl, nil
 }
@@ -133,7 +136,7 @@ render :: proc(
 	append(&ctx, data)
 
 	all_nodes := tmpl.nodes[:]
-	err = render_nodes(all_nodes, all_nodes, &ctx, partials, &builder)
+	err = render_nodes(tmpl, all_nodes, all_nodes, &ctx, partials, &builder)
 	if err != nil {
 		return result, err
 	}
@@ -158,7 +161,7 @@ parse_tokens :: proc(
 ) {
 	nodes = make([dynamic]Node, 0, len(tokens), allocator)
 	pos := 0
-	err = parse_section(tokens, &pos, &nodes, "", source, allocator)
+	err = parse_section(tokens, &pos, &nodes, "", source, allocator, 0)
 	return
 }
 
@@ -169,22 +172,23 @@ parse_section :: proc(
 	end_tag: string,
 	source: string,
 	allocator := context.allocator,
+	open_pos: int = 0,
 ) -> Render_Error {
 	for pos^ < len(tokens) {
 		tok := tokens[pos^]
 
 		switch tok.kind {
 		case .Text:
-			append(nodes, Node{kind = .Text, text = tok.value, first_child = -1})
+			append(nodes, Node{kind = .Text, text = tok.value, first_child = -1, pos = tok.pos})
 			pos^ += 1
 
 		case .Variable:
 			idx := len(nodes)
 			append(nodes, Node{kind = .Variable, first_child = -1})
-			pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters)
+			pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters, tok.pos)
 			if perr != nil {
 				return Syntax_Error {
-					msg = fmt.tprintf("pipe parse error in '{{%s}}': %v", tok.value, perr),
+					msg = fmt.tprintf("pipe parse error in '{{{{%s}}}}': %v", tok.value, perr),
 					pos = tok.pos,
 				}
 			}
@@ -194,10 +198,10 @@ parse_section :: proc(
 		case .Unescaped:
 			idx := len(nodes)
 			append(nodes, Node{kind = .Unescaped, first_child = -1})
-			pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters)
+			pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters, tok.pos)
 			if perr != nil {
 				return Syntax_Error {
-					msg = fmt.tprintf("pipe parse error in '{{&%s}}': %v", tok.value, perr),
+					msg = fmt.tprintf("pipe parse error in '{{{{&%s}}}}': %v", tok.value, perr),
 					pos = tok.pos,
 				}
 			}
@@ -212,16 +216,16 @@ parse_section :: proc(
 			idx := len(nodes)
 			content_start := 0
 			if pos^ < len(tokens) {content_start = tokens[pos^].pos}
-			append(nodes, Node{kind = .Section, first_child = -1})
+			append(nodes, Node{kind = .Section, first_child = -1, pos = tok.pos})
-			pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters)
+			pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters, tok.pos)
 			if perr != nil {
 				return Syntax_Error {
-					msg = fmt.tprintf("pipe parse error in '{{#%s}}': %v", tok.value, perr),
+					msg = fmt.tprintf("pipe parse error in '{{{{#%s}}}}': %v", tok.value, perr),
 					pos = tok.pos,
 				}
 			}
 			nodes[idx].key = pipe_key
-			parse_section(tokens, pos, nodes, pipe_key, source, allocator) or_return
+			parse_section(tokens, pos, nodes, pipe_key, source, allocator, tok.pos) or_return
 			close_pos := 0
 			if pos^ - 1 >= 0 && pos^ - 1 < len(tokens) {close_pos = tokens[pos^ - 1].pos}
 			nodes[idx].first_child = idx + 1
@@ -233,16 +237,16 @@ parse_section :: proc(
 			idx := len(nodes)
 			content_start := 0
 			if pos^ < len(tokens) {content_start = tokens[pos^].pos}
-			append(nodes, Node{kind = .Inverted, first_child = -1})
+			append(nodes, Node{kind = .Inverted, first_child = -1, pos = tok.pos})
-			pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters)
+			pipe_key, perr := parse_pipeline(tok.value, &nodes[idx].filters, tok.pos)
 			if perr != nil {
 				return Syntax_Error {
-					msg = fmt.tprintf("pipe parse error in '{{^%s}}': %v", tok.value, perr),
+					msg = fmt.tprintf("pipe parse error in '{{{{^%s}}}}': %v", tok.value, perr),
 					pos = tok.pos,
 				}
 			}
 			nodes[idx].key = pipe_key
-			parse_section(tokens, pos, nodes, pipe_key, source, allocator) or_return
+			parse_section(tokens, pos, nodes, pipe_key, source, allocator, tok.pos) or_return
 			close_pos := 0
 			if pos^ - 1 >= 0 && pos^ - 1 < len(tokens) {close_pos = tokens[pos^ - 1].pos}
 			nodes[idx].first_child = idx + 1
@@ -253,7 +257,7 @@ parse_section :: proc(
 			if strings.contains(tok.value, "|") {
 				return Syntax_Error {
 					msg = fmt.tprintf(
-						"pipe expression not allowed in close tag '{{/%s}}' — use the bare key",
+						"pipe expression not allowed in close tag '{{{{/%s}}}}' — use the bare key",
 						tok.value,
 					),
 					pos = tok.pos,
@@ -265,12 +269,12 @@ parse_section :: proc(
 			}
 			if end_tag == "" {
 				return Syntax_Error {
-					msg = fmt.tprintf("unexpected {{/%s}}", tok.value),
+					msg = fmt.tprintf("unexpected {{{{/%s}}}}", tok.value),
 					pos = tok.pos,
 				}
 			}
 			return Syntax_Error {
-				msg = fmt.tprintf("expected {{/%s}}, got {{/%s}}", end_tag, tok.value),
+				msg = fmt.tprintf("expected {{{{/%s}}}}, got {{{{/%s}}}}", end_tag, tok.value),
 				pos = tok.pos,
 			}
 
@@ -283,6 +287,7 @@ parse_section :: proc(
 					is_dynamic = tok.is_dynamic,
 					indent = tok.indent,
 					first_child = -1,
+					pos = tok.pos,
 				},
 			)
 			pos^ += 1
@@ -292,9 +297,15 @@ parse_section :: proc(
 			idx := len(nodes)
 			append(
 				nodes,
-				Node{kind = .Parent, key = tok.value, indent = tok.indent, first_child = -1},
+				Node {
+					kind = .Parent,
+					key = tok.value,
+					indent = tok.indent,
+					first_child = -1,
+					pos = tok.pos,
+				},
 			)
-			parse_section(tokens, pos, nodes, tok.value, source, allocator) or_return
+			parse_section(tokens, pos, nodes, tok.value, source, allocator, tok.pos) or_return
 			nodes[idx].first_child = idx + 1
 			nodes[idx].child_count = len(nodes) - idx - 1
 
@@ -303,16 +314,25 @@ parse_section :: proc(
 			idx := len(nodes)
 			append(
 				nodes,
-				Node{kind = .Block, key = tok.value, indent = tok.indent, first_child = -1},
+				Node {
+					kind = .Block,
+					key = tok.value,
+					indent = tok.indent,
+					first_child = -1,
+					pos = tok.pos,
+				},
 			)
-			parse_section(tokens, pos, nodes, tok.value, source, allocator) or_return
+			parse_section(tokens, pos, nodes, tok.value, source, allocator, tok.pos) or_return
 			nodes[idx].first_child = idx + 1
 			nodes[idx].child_count = len(nodes) - idx - 1
 		}
 	}
 
 	if end_tag != "" {
-		return Syntax_Error{msg = fmt.tprintf("unclosed section '{{#%s}}'", end_tag)}
+		return Syntax_Error {
+			msg = fmt.tprintf("unclosed section '{{{{#%s}}}}'", end_tag),
+			pos = open_pos,
+		}
 	}
 	return nil
 }
@@ -476,11 +496,20 @@ render_template :: proc(
 	indent: string,
 ) -> Render_Error {
 	if len(indent) > 0 && len(pt.source) > 0 {
+		// Per Mustache spec: the partial's source is indented before rendering,
+		// not its output. This is necessary so that data-injected newlines
+		// (e.g. from `{{{content}}}` where content contains `\n`) do NOT pick
+		// up the indent — only source-level line breaks do.
 		indented := indent_lines(pt.source, indent)
-		reparse := parse(indented, context.temp_allocator, context.temp_allocator) or_return
+		reparse := parse(
-		return render_nodes(reparse.nodes[:], reparse.nodes[:], ctx, partials, b, blocks)
+			indented,
+			pt.path,
+			context.temp_allocator,
+			context.temp_allocator,
+		) or_return
+		return render_nodes(reparse, reparse.nodes[:], reparse.nodes[:], ctx, partials, b, blocks)
 	}
-	return render_nodes(pt.nodes[:], pt.nodes[:], ctx, partials, b, blocks)
+	return render_nodes(pt, pt.nodes[:], pt.nodes[:], ctx, partials, b, blocks)
 }
 
 // ---------------------------------------------------------------------------
@@ -488,6 +517,7 @@ render_template :: proc(
 // ---------------------------------------------------------------------------
 
 render_nodes :: proc(
+	current: Template,
 	all_nodes: []Node,
 	nodes: []Node,
 	ctx: ^[dynamic]any,
@@ -505,19 +535,28 @@ render_nodes :: proc(
 
 		case .Variable:
 			val := resolve_name(node.key, ctx[:])
+			if val ==  nil {
+				warn_unknown_key(current, ctx[:], node)
+			}
 			if len(node.filters) > 0 {
-				transformed, perr := apply_pipeline(val, node.filters[:])
+				transformed, perr := apply_pipeline(val, node.filters[:], node.pos)
 				if perr != nil {
 					return perr
 				}
 				val = transformed
 			}
 			if result_str, ok := call_interp_lambda(val); ok {
-				sub_tpl, perr := parse(result_str, context.temp_allocator, context.temp_allocator)
+				sub_tpl, perr := parse(
+					result_str,
+					fmt.tprintf("<lambda output from '%s'>", node.key),
+					context.temp_allocator,
+					context.temp_allocator,
+				)
 				if perr == nil {
 					temp: strings.Builder
 					strings.builder_init(&temp, context.temp_allocator)
 					render_nodes(
+						sub_tpl,
 						sub_tpl.nodes[:],
 						sub_tpl.nodes[:],
 						ctx,
@@ -534,19 +573,28 @@ render_nodes :: proc(
 
 		case .Unescaped:
 			val := resolve_name(node.key, ctx[:])
+			if val == nil {
+				warn_unknown_key(current, ctx[:], node)
+			}
 			if len(node.filters) > 0 {
-				transformed, perr := apply_pipeline(val, node.filters[:])
+				transformed, perr := apply_pipeline(val, node.filters[:], node.pos)
 				if perr != nil {
 					return perr
 				}
 				val = transformed
 			}
 			if result_str, ok := call_interp_lambda(val); ok {
-				sub_tpl, perr := parse(result_str, context.temp_allocator, context.temp_allocator)
+				sub_tpl, perr := parse(
+					result_str,
+					fmt.tprintf("<lambda output from '%s'>", node.key),
+					context.temp_allocator,
+					context.temp_allocator,
+				)
 				if perr == nil {
 					temp: strings.Builder
 					strings.builder_init(&temp, context.temp_allocator)
 					render_nodes(
+						sub_tpl,
 						sub_tpl.nodes[:],
 						sub_tpl.nodes[:],
 						ctx,
@@ -563,17 +611,26 @@ render_nodes :: proc(
 
 		case .Section:
 			val := resolve_name(node.key, ctx[:])
+			if val == nil {
+				warn_unknown_key(current, ctx[:], node)
+			}
 			if len(node.filters) > 0 {
-				transformed, perr := apply_pipeline(val, node.filters[:])
+				transformed, perr := apply_pipeline(val, node.filters[:], node.pos)
 				if perr != nil {
 					return perr
 				}
 				val = transformed
 			}
 			if result_str, ok := call_section_lambda(val, node.content); ok {
-				sub_tpl, perr := parse(result_str, context.temp_allocator, context.temp_allocator)
+				sub_tpl, perr := parse(
+					result_str,
+					fmt.tprintf("<lambda output from '%s'>", node.key),
+					context.temp_allocator,
+					context.temp_allocator,
+				)
 				if perr == nil {
 					render_nodes(
+						sub_tpl,
 						sub_tpl.nodes[:],
 						sub_tpl.nodes[:],
 						ctx,
@@ -590,20 +647,31 @@ render_nodes :: proc(
 						elem := extract_list_element(elem_info, data, j)
 						append(ctx, elem)
 						defer pop(ctx)
-						render_nodes(all_nodes, children, ctx, partials, b, blocks) or_return
+						render_nodes(
+							current,
+							all_nodes,
+							children,
+							ctx,
+							partials,
+							b,
+							blocks,
+						) or_return
 					}
 				} else {
 					append(ctx, val)
 					defer pop(ctx)
-					render_nodes(all_nodes, children, ctx, partials, b, blocks) or_return
+					render_nodes(current, all_nodes, children, ctx, partials, b, blocks) or_return
 				}
 			}
 			i += 1 + node.child_count
 
 		case .Inverted:
 			val := resolve_name(node.key, ctx[:])
+			if val == nil {
+				warn_unknown_key(current, ctx[:], node)
+			}
 			if len(node.filters) > 0 {
-				transformed, perr := apply_pipeline(val, node.filters[:])
+				transformed, perr := apply_pipeline(val, node.filters[:], node.pos)
 				if perr != nil {
 					return perr
 				}
@@ -611,7 +679,7 @@ render_nodes :: proc(
 			}
 			if !is_truthy(val) {
 				children := all_nodes[node.first_child:node.first_child + node.child_count]
-				render_nodes(all_nodes, children, ctx, partials, b, blocks) or_return
+				render_nodes(current, all_nodes, children, ctx, partials, b, blocks) or_return
 			}
 			i += 1 + node.child_count
 
@@ -622,7 +690,9 @@ render_nodes :: proc(
 				name = any_to_string(val)
 			}
 			pt, found := partials[name]
-			if found {
+			if !found {
+				warn_missing_partial(current, partials, node, name)
+			} else {
 				render_template(pt, ctx, partials, b, nil, node.indent) or_return
 			}
 			i += 1
@@ -631,6 +701,7 @@ render_nodes :: proc(
 			content_nodes: []Node
 			content_pool: []Node
 			content_blocks := blocks
+			render_current := current
 
 			found_override := false
 			if blocks != nil {
@@ -638,6 +709,7 @@ render_nodes :: proc(
 					content_nodes = o.all_nodes[o.first:o.first + o.count]
 					content_pool = o.all_nodes
 					found_override = true
+					render_current = o.source
 				}
 			}
 			if !found_override {
@@ -649,6 +721,7 @@ render_nodes :: proc(
 				temp: strings.Builder
 				strings.builder_init(&temp, context.temp_allocator)
 				render_nodes(
+					render_current,
 					content_pool,
 					content_nodes,
 					ctx,
@@ -659,6 +732,7 @@ render_nodes :: proc(
 				write_indented(b, node.indent, strings.to_string(temp))
 			} else {
 				render_nodes(
+					render_current,
 					content_pool,
 					content_nodes,
 					ctx,
@@ -671,9 +745,12 @@ render_nodes :: proc(
 
 		case .Parent:
 			parent_children := all_nodes[node.first_child:node.first_child + node.child_count]
-			merged := merge_block_overrides(parent_children, all_nodes, blocks)
+			merged := merge_block_overrides(parent_children, all_nodes, blocks, current)
 			pt, found := partials[node.key]
-			if found {
+			if !found {
+				warn_missing_partial(current, partials, node, node.key)
+			} else {
+				warn_unmatched_block_overrides(current, pt, parent_children)
 				render_template(pt, ctx, partials, b, merged, node.indent) or_return
 			}
 			i += 1 + node.child_count
@@ -686,6 +763,7 @@ merge_block_overrides :: proc(
 	children: []Node,
 	all_nodes: []Node,
 	existing: map[string]Block_Override,
+	source: Template,
 ) -> map[string]Block_Override {
 	result := make(map[string]Block_Override, context.temp_allocator)
 
@@ -702,6 +780,7 @@ merge_block_overrides :: proc(
 					all_nodes = all_nodes,
 					first     = child.first_child,
 					count     = child.child_count,
+					source    = source,
 				}
 			}
 		}
@@ -711,3 +790,115 @@ merge_block_overrides :: proc(
 	return result
 }
 
+// warn_unknown_key checks whether the missing key is a genuine typo (vs. a
+// legitimate path through a user-defined map) and, if so, emits a diagnostic
+// warning with the closest field-name suggestion via Levenshtein.
+warn_unknown_key :: proc(current: Template, ctx: []any, node: Node) {
+	// `{{.}}` and dot-prefixed names refer to the current context — always valid.
+	if node.key == "." || (len(node.key) > 0 && node.key[0] == '.') {
+		return
+	}
+
+	path_ok, missing, available := validate_key_path(ctx, node.key)
+	if path_ok {
+		return
+	}
+
+	hint := ""
+	if len(available) > 0 {
+		suggestion := suggest_correction(available, missing)
+		if suggestion != "" {
+			hint = fmt.tprintf("did you mean '%s'?", suggestion)
+		}
+	}
+	msg := fmt.tprintf("unknown key '%s'", node.key)
+	path := current.path
+	if path == "" {
+		path = "<input>"
+	}
+	diag := format_error(path, current.source, node.pos, msg, hint, colorize = should_colorize())
+	log.warnf("%s", diag)
+}
+
+// warn_missing_partial emits a warning when a `{{> name}}` or `{{<name}}` tag
+// references a partial that isn't in the partials map.
+warn_missing_partial :: proc(
+	current: Template,
+	partials: map[string]Template,
+	node: Node,
+	name: string,
+) {
+	hint := ""
+	available := collect_partial_names(partials)
+	defer delete(available)
+	suggestion := suggest_correction(available, name)
+	if suggestion != "" {
+		hint = fmt.tprintf("did you mean '%s'?", suggestion)
+	}
+	msg := fmt.tprintf("partial '%s' not found", name)
+	path := current.path
+	if path == "" {
+		path = "<input>"
+	}
+	diag := format_error(path, current.source, node.pos, msg, hint, colorize = should_colorize())
+	log.warnf("%s", diag)
+}
+
+// warn_unmatched_block_overrides checks each `{{$name}}...{{/name}}` block
+// defined inside a `{{<parent}}` tag and warns when the name doesn't match
+// any block in the parent template.
+warn_unmatched_block_overrides :: proc(
+	current: Template,
+	parent: Template,
+	parent_children: []Node,
+) {
+	if len(parent_children) == 0 {
+		return
+	}
+	available := collect_block_names(parent)
+	defer delete(available)
+	parent_path := parent.path
+	if parent_path == "" {
+		parent_path = "<input>"
+	}
+	for child in parent_children {
+		if child.kind != .Block {
+			continue
+		}
+		matched := false
+		for name in available {
+			if name == child.key {
+				matched = true
+				break
+			}
+		}
+		if matched {
+			continue
+		}
+
+		hint := ""
+		suggestion := suggest_correction(available, child.key)
+		if suggestion != "" {
+			hint = fmt.tprintf("did you mean '%s'?", suggestion)
+		}
+		msg := fmt.tprintf(
+			"block override '%s' has no match in parent template '%s'",
+			child.key,
+			parent_path,
+		)
+		path := current.path
+		if path == "" {
+			path = "<input>"
+		}
+		diag := format_error(
+			path,
+			current.source,
+			child.pos,
+			msg,
+			hint,
+			colorize = should_colorize(),
+		)
+		log.warnf("%s", diag)
+	}
+}
+

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

@@ -27,6 +27,7 @@ Group :: struct {
 parse_pipeline :: proc(
 	content: string,
 	filters_out: ^[dynamic; MAX_PIPES]Pipe_Filter,
+	pos: int,
 ) -> (
 	key: string,
 	err: Render_Error,
@@ -46,12 +47,13 @@ parse_pipeline :: proc(
 				filter_count,
 				MAX_PIPES,
 			),
+			pos = pos,
 		}
 	}
 
 	key = strings.trim_space(segments[0])
 	if len(key) == 0 {
-		return "", Syntax_Error{msg = "pipe expression missing key"}
+		return "", Syntax_Error{msg = "pipe expression missing key", pos = pos}
 	}
 
 	if filter_count == 0 {
@@ -61,12 +63,12 @@ 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 "", Syntax_Error{msg = "empty filter", pos = pos}
 		}
 
 		tokens := strings.fields(seg)
 		if len(tokens) == 0 {
-			return "", Syntax_Error{msg = "filter missing op name"}
+			return "", Syntax_Error{msg = "filter missing op name", pos = pos}
 		}
 
 		arg_count := len(tokens) - 1
@@ -78,6 +80,7 @@ parse_pipeline :: proc(
 					arg_count,
 					MAX_PIPE_ARGS,
 				),
+				pos = pos,
 			}
 		}
 
@@ -94,10 +97,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, Render_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
 		}
@@ -106,19 +109,22 @@ 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, Render_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, Data_Error{msg = "format may only be used on dates"}
+			return value, Data_Error{msg = "format may only be used on dates", pos = pos}
 		} else {
-			return apply_format(str, filter.args[:])
+			return apply_format(str, filter.args[:], pos)
 		}
 	case:
-		return nil, Data_Error{msg = fmt.tprintf("unknown pipe op '%s'", filter.op)}
+		return nil, Data_Error{
+			msg = fmt.tprintf("unknown pipe op '%s'", filter.op),
+			pos = pos,
+		}
 	}
 }
 
@@ -138,9 +144,9 @@ apply_filter :: proc(value: any, filter: ^Pipe_Filter) -> (any, Render_Error) {
 //   2023-10-15T13:18:50Z
 //   2023-10-15T13:18:50
 //   2023-10-15
-apply_format :: proc(iso: string, args: []string) -> (result: any, err: Render_Error) {
+apply_format :: proc(iso: string, args: []string, pos: int) -> (result: any, err: Render_Error) {
 	if len(iso) < 10 {
-		return nil, Data_Error{msg = "format may only be used on dates"}
+		return nil, Data_Error{msg = "format may only be used on dates", pos = pos}
 	}
 
 	year := iso[:4]
@@ -148,7 +154,7 @@ apply_format :: proc(iso: string, args: []string) -> (result: any, err: Render_E
 	day_num := (int(iso[8]) - 0x30) * 10 + (int(iso[9]) - 0x30)
 
 	if month_num < 1 || month_num > 12 {
-		return nil, Data_Error{msg = fmt.tprintf("invalid date: \"%s\"", iso)}
+		return nil, Data_Error{msg = fmt.tprintf("invalid date: \"%s\"", iso), pos = pos}
 	}
 
 	month := fmt.tprintf("%s", time.Month(month_num))[:3]
@@ -156,15 +162,21 @@ apply_format :: proc(iso: string, args: []string) -> (result: any, err: Render_E
 }
 
 // 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: Render_Error) {
 	if len(args) != 1 {
-		return nil, Data_Error{msg = fmt.tprintf("group_by expects 1 argument, got %d", len(args))}
+		return nil, Data_Error{
+			msg = fmt.tprintf("group_by expects 1 argument, got %d", len(args)),
+			pos = pos,
+		}
 	}
 	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, Data_Error{
+			msg = "group_by expects a list",
+			pos = pos,
+		}
 	}
 
 	groups := make([dynamic]Group, 0, 8, context.temp_allocator)
@@ -179,11 +191,15 @@ apply_group_by :: proc(value: any, args: []string) -> (result: any, err: Render_
 		if !found {
 			return nil, Data_Error {
 				msg = fmt.tprintf("group_by: element missing field '%s'", field),
+				pos = pos,
 			}
 		}
 		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, Data_Error{
+				msg = fmt.tprintf("group_by: field '%s' is empty", field),
+				pos = pos,
+			}
 		}
 
 		idx, exists := key_to_idx[key_str]

mustache/pipes_test.odin

@@ -216,7 +216,7 @@ test_interp_pipe_basic :: proc(t: ^testing.T) {
 	data := Scalar_Data {
 		name = "2026-03-15T08:49:54-04:00",
 	}
-	tpl, _ := parse("[{{name | format}}]", context.temp_allocator)
+	tpl, _ := parse("[{{name | format}}]", "<test>", allocator = context.temp_allocator)
 	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "[15 Mar 2026]")
 }
@@ -229,7 +229,7 @@ test_interp_pipe_unescaped :: proc(t: ^testing.T) {
 	data := Scalar_Data {
 		name = "2025-12-25T00:00:00Z",
 	}
-	tpl, _ := parse("[{{&name | format}}]", context.temp_allocator)
+	tpl, _ := parse("[{{&name | format}}]", "<test>", allocator = context.temp_allocator)
 	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "[25 Dec 2025]")
 }
@@ -242,7 +242,7 @@ test_interp_pipe_dot_current :: proc(t: ^testing.T) {
 	data := List_Data {
 		items = {"2026-01-06T00:00:00Z", "2026-06-15T00:00:00Z", "2026-10-15T00:00:00Z"},
 	}
-	tpl, _ := parse("{{#items}}[{{. | format}}]{{/items}}", context.temp_allocator)
+	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]")
 }
@@ -260,7 +260,7 @@ test_format_typical_iso :: proc(t: ^testing.T) {
 	data := Format_Data {
 		date = "2026-03-15T08:49:54-04:00",
 	}
-	tpl, _ := parse("{{date | format}}", context.temp_allocator)
+	tpl, _ := parse("{{date | format}}", "<test>", allocator = context.temp_allocator)
 	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "15 Mar 2026")
 }
@@ -270,7 +270,7 @@ test_format_short_date_only :: proc(t: ^testing.T) {
 	data := Format_Data {
 		date = "2026-06-06",
 	}
-	tpl, _ := parse("{{date | format}}", context.temp_allocator)
+	tpl, _ := parse("{{date | format}}", "<test>", allocator = context.temp_allocator)
 	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "6 Jun 2026")
 }
@@ -280,7 +280,7 @@ test_format_empty_input_errors :: proc(t: ^testing.T) {
 	data := Format_Data {
 		date = "",
 	}
-	tpl, _ := parse("[{{date | format}}]", context.temp_allocator)
+	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")
@@ -291,7 +291,7 @@ test_format_non_date_string_errors :: proc(t: ^testing.T) {
 	data := Format_Data {
 		date = "abc",
 	}
-	tpl, _ := parse("[{{date | format}}]", context.temp_allocator)
+	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")
@@ -305,7 +305,7 @@ test_format_non_string_value_errors :: proc(t: ^testing.T) {
 	data := Int_Data {
 		count = 42,
 	}
-	tpl, _ := parse("{{count | format}}", context.temp_allocator)
+	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")
@@ -316,7 +316,7 @@ test_format_invalid_month_errors :: proc(t: ^testing.T) {
 	data := Format_Data {
 		date = "2023-13-15",
 	}
-	tpl, _ := parse("{{date | format}}", context.temp_allocator)
+	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")
@@ -331,7 +331,8 @@ test_format_inside_section_renders :: proc(t: ^testing.T) {
 	}
 	tpl, _ := parse(
 		"{{#date}}<time datetime=\"{{.}}\">{{. | format}}</time>{{/date}}",
-		context.temp_allocator,
+		"<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>")
@@ -342,7 +343,7 @@ test_format_inside_section_skips_when_empty :: proc(t: ^testing.T) {
 	data := Format_Data {
 		date = "",
 	}
-	tpl, _ := parse("[{{#date}}<time>{{. | format}}</time>{{/date}}]", context.temp_allocator)
+	tpl, _ := parse("[{{#date}}<time>{{. | format}}</time>{{/date}}]", "<test>", allocator = context.temp_allocator)
 	result, _ := render(tpl, data, {}, context.temp_allocator)
 	testing.expect_value(t, result, "[]")
 }
@@ -362,7 +363,7 @@ test_format_handles_all_iso8601_variants :: proc(t: ^testing.T) {
 		data := Format_Data {
 			date = c.input,
 		}
-		tpl, _ := parse("{{date | format}}", context.temp_allocator)
+		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: [dynamic]string
+	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: [dynamic]string
+		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: [dynamic]string
+	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: [dynamic]string
+	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,194 @@
+#+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"},
+	}
+	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)
+}
+

render.odin

@@ -55,14 +55,40 @@ build_page_context :: proc(page: Page) -> Page_Context {
 }
 
 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)
+		log.fatalf("template %s not found", virtual_path)
-		return mustache.Template{}
+		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)
+		switch e in err {
+		// TODO: Find a way to merge these branches.
+		case mustache.Syntax_Error:
+			log.errorf(
+				"%s",
+				mustache.format_error(
+					entry.fs_path,
+					source,
+					e.pos,
+					e.msg,
+					colorize = mustache.should_colorize(),
+				),
+			)
+		case mustache.Data_Error:
+			log.errorf(
+				"%s",
+				mustache.format_error(
+					entry.fs_path,
+					source,
+					e.pos,
+					e.msg,
+					colorize = mustache.should_colorize(),
+				),
+			)
+		}
+		os.exit(1)
 	}
 	return tpl
 }
@@ -122,7 +148,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
@@ -331,7 +360,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
 		}
@@ -342,14 +371,36 @@ 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)
+		data := vfs_entry_data(entry) or_continue
-		if !ok {
+		source := string(data)
-			continue
+		tpl, err := mustache.parse(source, entry.fs_path)
-		}
-		tpl, err := mustache.parse(string(data))
 		if err != nil {
-			log.warnf("failed to parse partial %s: %v", key, err)
+			// TODO: Find a way to merge these branches.
-			continue
+			switch e in err {
+			case mustache.Syntax_Error:
+				log.errorf(
+					"%s",
+					mustache.format_error(
+						entry.fs_path,
+						source,
+						e.pos,
+						e.msg,
+						colorize = mustache.should_colorize(),
+					),
+				)
+			case mustache.Data_Error:
+				log.errorf(
+					"%s",
+					mustache.format_error(
+						entry.fs_path,
+						source,
+						e.pos,
+						e.msg,
+						colorize = mustache.should_colorize(),
+					),
+				)
+			}
+			os.exit(1)
 		}
 		partials[key] = tpl
 	}

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
+}
+