diff --git a/README.md b/README.md
index ac2d775..91ac04a 100644
--- a/README.md
+++ b/README.md
@@ -26,6 +26,93 @@ cannot safely rewrite is not itself an error, so it does not fail the run.
 python3 -m dayamlchecker --fix path/to/interview.yml
 ```
 
+## Jinja2 preprocessing
+
+Files whose first line is exactly `# use jinja` (LF, CRLF, or end of file) are
+rendered before the normal validation
+pass, following docassemble's [YAML preprocessing feature](https://docassemble.org/docs/interviews.html#jinja2).
+Expressions, loops, conditionals, macros, and local includes are supported.
+Include paths are relative to the input file's directory; includes can contain
+partial YAML blocks. Ordinary YAML files and Mako expressions are unaffected.
+
+This is an offline check: server configuration, `jinja data`, docassemble's
+special context variables, and package-qualified includes are not supplied.
+Unknown variables are treated as empty values throughout -- in arithmetic and
+comparisons, and through every built-in filter and test -- so interviews that
+use server-side Jinja context can still be checked; a branch that tests one is
+taken as if the value were empty, and only that branch is checked. An expression
+that renders to such a value is replaced with a placeholder and reported as
+`WG107`, described below. Missing imports and parent templates produce `EG106`.
+Rendering uses Jinja's sandbox and disables HTML escaping. Compilation
+and rendering run in an isolated worker with a 5-second wall timeout and 2-second
+CPU limit. Linux and other supported Unix platforms also use a 256 MiB
+address-space limit; macOS skips that limit because Darwin rejects limits below
+the process's existing virtual address space. Source and rendered output are
+limited to 4 MiB each.
+Exceeding a limit produces `EG106`. Bounded rendering requires Unix resource-limit
+support; other platforms report `EG106` rather than rendering without limits.
+Ordinary YAML checking does not require these limits.
+
+Jinja syntax and runtime errors identify the original template file and line,
+including nested local templates, so their source-level suppressions work.
+
+Missing `{% include %}` files (including unavailable package-qualified paths)
+produce warning `WG106`: the included Jinja2 document could not be verified and
+findings are partial. The checker substitutes a marker, skips each rendered YAML
+document containing that marker, and checks the remaining documents. This also
+applies to `ignore missing`; include fallback lists try all candidates first.
+Repeated execution of the same include site produces one diagnostic.
+
+Partial validation is best effort. An unavailable include may itself supply YAML
+document boundaries or Jinja definitions, so the remaining output may differ from
+the real interview. A partial-block include causes its entire containing YAML
+document to be skipped. Findings retain rendered line numbers.
+
+Expressions that depend on values only the server supplies produce warning
+`WG107`. Rather than rendering to nothing -- which would leave an empty YAML
+value, an invalid Python line, or a block with no `id`, and hide every real
+problem around it -- each one is replaced with a placeholder such as
+`dayc_unknown_1`, so the surrounding document stays parseable and is still
+checked. Each placeholder is distinct, so two unknown block ids do not look
+like duplicates of each other. The warning names the variable and points at the
+line of the original template, and one source site produces one warning however
+many times it renders.
+
+Nothing that depends on the real value is checked, so a later block that relies
+on what an earlier expression produced may be checked against the placeholder
+instead. Checks that resolve a name against the rest of the interview stay quiet
+when a placeholder is involved; anything else can be suppressed with
+`# no-dayc: WG107` on the line or `# no-dayc-block: WG107` in its source block,
+which -- like `WG106` -- refer to the original template, not the rendered YAML.
+
+Missing includes and unknown values are skipped by default and do not fail CI
+unless a warning limit such as `--max-warnings 0` is set. You can suppress the partial-validation
+warning with `# no-dayc: WG106` on the include or `# no-dayc-block: WG106` in its
+source block.
+
+Other errors, including missing imports and parent templates (`EG106`), still
+fail by default. Explicitly suppress a known dependency-related
+rendering limitation with a source-level suppression, for example:
+
+```yaml
+# use jinja
+# no-dayc-block: EG106
+{% import "external-macros.yml" as framework %}
+```
+
+Rendering errors also honor source suppressions, but a rendering failure prevents
+validation of the remaining file. Missing includes alone allow partial validation;
+suppressing their warning does not suppress errors in the remaining YAML.
+
+Findings after preprocessing name the original file but are labeled
+`(rendered Jinja)`; their line numbers and suppression comments refer to the
+rendered YAML, not the original template. `--format github` therefore annotates
+the file as a whole and reports the generated line in the message, so the
+annotation resolves without pointing at an unrelated source line. Only the
+rendered branches are checked. `--fix` skips these files because generated line
+numbers cannot safely identify source edits.
+Template-aware formatting is outside this feature's scope.
+
 ## Suppressing checks
 
 You can suppress specific errors or warnings by their ID or finding class (`accessibility`, `style`, `translatability`, `general`). 
diff --git a/pyproject.toml b/pyproject.toml
index c816c2b..aeee2fe 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,6 +7,7 @@ requires-python = ">=3.12"
 dependencies = [
     "esprima>=4.0.1",
     "mako>=1.3.10",
+    "jinja2>=3.1.6",
     "black>=24.0.0",
     "ruamel.yaml>=0.18.0",
     "docx2python>=3.5.0",
diff --git a/requirements.txt b/requirements.txt
index 0ab72df..252af92 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,6 @@
 esprima>=4.0.1
 mako>=1.3.10
+jinja2>=3.1.6
 black>=24.0.0
 ruamel.yaml>=0.18.0
 docx2python>=3.5.0
diff --git a/src/dayamlchecker/_jinja.py b/src/dayamlchecker/_jinja.py
new file mode 100644
index 0000000..aa56cbe
--- /dev/null
+++ b/src/dayamlchecker/_jinja.py
@@ -0,0 +1,423 @@
+"""The optional docassemble YAML preprocessor, isolated from validation."""
+
+from copy import copy
+from dataclasses import asdict, dataclass
+import json
+from pathlib import Path
+import re
+import subprocess
+import sys
+from tempfile import TemporaryFile
+from typing import Any
+from uuid import uuid4
+
+from jinja2 import (
+    DictLoader,
+    FileSystemLoader,
+    Template,
+    TemplateNotFound,
+    Undefined,
+    nodes,
+)
+from jinja2.compiler import CodeGenerator, Frame
+from jinja2.exceptions import SecurityError
+from jinja2.sandbox import SandboxedEnvironment
+
+# Applied before any template is compiled, including constant folding.
+_RENDER_TIMEOUT = 5
+_MAX_SOURCE_BYTES = 4 * 1024 * 1024
+_MAX_OUTPUT_BYTES = 4 * 1024 * 1024
+_MAX_RESPONSE_BYTES = 32 * 1024 * 1024
+_MEMORY_BYTES = 256 * 1024 * 1024
+_CPU_SECONDS = 2
+# Substituted for a value only the server can supply. A bare identifier keeps
+# the rendered YAML parseable in every position a value can appear, including
+# as a mapping key and inside a Python code block. The counter makes each one
+# distinct so two unknown block ids do not collide.
+_UNKNOWN_PREFIX = "dayc_unknown_"
+
+
+_UNKNOWN_VALUE_RE = re.compile(rf"\b{_UNKNOWN_PREFIX}\d+\b")
+
+
+def is_unknown_jinja_value(text: str) -> bool:
+    """Report whether a placeholder for a server value appears in ``text``.
+
+    Checks that resolve a name against the rest of the interview have nothing
+    to resolve once a placeholder is involved, so they use this to stay quiet
+    rather than describing our own substitution as an undefined variable.
+    """
+    return bool(_UNKNOWN_VALUE_RE.search(text))
+
+
+def uses_jinja(source: str) -> bool:
+    """Recognize only the documented first-line directive (LF, CRLF, or EOF)."""
+    return re.match(r"# use jinja(?:\r?\n|$)", source) is not None
+
+
+class JinjaRenderError(Exception):
+    def __init__(
+        self, message: str, filename: str | None = None, lineno: int | None = None
+    ):
+        super().__init__(message)
+        self.filename = filename
+        self.lineno = lineno
+
+
+class _OfflineUndefined(Undefined):
+    """Stand in for values supplied by docassemble's server configuration.
+
+    Static checking has no access to ``jinja data`` or docassemble's built-in
+    Jinja context.  Treat unknown values as empty instead of rejecting an
+    otherwise valid interview.  Chained lookups and calls are supported because
+    configuration values may be nested or exposed through helper objects.
+    Arithmetic and comparison are too: a configuration value is often a count
+    or a threshold, so ``{% if jinja_data.limit > 0 %}`` must select a branch
+    rather than abort the whole file.
+    """
+
+    def _guard_sandbox_violation(self) -> None:
+        if self._undefined_exception is SecurityError:
+            self._fail_with_undefined_error()
+
+    def _stay_empty(self, *args: object, **kwargs: object) -> "_OfflineUndefined":
+        self._guard_sandbox_violation()
+        return self
+
+    def _compare_as_empty(self, other: object) -> bool:
+        self._guard_sandbox_violation()
+        return False
+
+    def __str__(self) -> str:
+        self._guard_sandbox_violation()
+        return ""
+
+    def __iter__(self):
+        self._guard_sandbox_violation()
+        return iter(())
+
+    def __len__(self) -> int:
+        self._guard_sandbox_violation()
+        return 0
+
+    def __bool__(self) -> bool:
+        self._guard_sandbox_violation()
+        return False
+
+    def __getattr__(self, name: str) -> "_OfflineUndefined":
+        self._guard_sandbox_violation()
+        if name.startswith("_"):
+            raise AttributeError(name)
+        return self
+
+    def __getitem__(self, key: object) -> "_OfflineUndefined":  # type: ignore[override]
+        self._guard_sandbox_violation()
+        return self
+
+    def __call__(  # type: ignore[override]
+        self, *args: object, **kwargs: object
+    ) -> "_OfflineUndefined":
+        self._guard_sandbox_violation()
+        return self
+
+    def __int__(self) -> int:  # type: ignore[override]
+        self._guard_sandbox_violation()
+        return 0
+
+    def __float__(self) -> float:  # type: ignore[override]
+        self._guard_sandbox_violation()
+        return 0.0
+
+    def __complex__(self) -> complex:  # type: ignore[override]
+        self._guard_sandbox_violation()
+        return 0j
+
+    def __index__(self) -> int:
+        # `range(config.count)` and friends need a real integer.
+        self._guard_sandbox_violation()
+        return 0
+
+    def __abs__(self) -> "_OfflineUndefined":
+        self._guard_sandbox_violation()
+        return self
+
+    def __round__(self, ndigits: int | None = None) -> "_OfflineUndefined":
+        self._guard_sandbox_violation()
+        return self
+
+    def __format__(self, format_spec: str) -> str:
+        # object.__format__ rejects any non-empty spec, so "{:>5}".format()
+        # would fail on a value the server supplies.
+        self._guard_sandbox_violation()
+        return ""
+
+    # Undefined maps each of these to _fail_with_undefined_error; an offline
+    # value has to survive them instead.  Ordering is unknowable, so every
+    # comparison against an absent value is false.
+    __add__ = __radd__ = __sub__ = __rsub__ = _stay_empty  # type: ignore[assignment]
+    __mul__ = __rmul__ = __truediv__ = __rtruediv__ = _stay_empty  # type: ignore[assignment]
+    __floordiv__ = __rfloordiv__ = __mod__ = __rmod__ = _stay_empty  # type: ignore[assignment]
+    __pow__ = __rpow__ = __pos__ = __neg__ = _stay_empty  # type: ignore[assignment]
+    __lt__ = __le__ = __gt__ = __ge__ = _compare_as_empty  # type: ignore[assignment]
+
+
+def _json_default(value: object) -> str:
+    """Serialize offline values for ``| tojson``, which json cannot encode."""
+    if isinstance(value, _OfflineUndefined):
+        value._guard_sandbox_violation()
+        return ""
+    raise TypeError(f"Object of type {type(value).__name__} is not JSON serializable")
+
+
+@dataclass(frozen=True)
+class MissingInclude:
+    description: str
+    file_name: str | None
+    line_number: int
+
+
+@dataclass(frozen=True)
+class UnknownValue:
+    """A rendered expression that depended on a value the server supplies."""
+
+    name: str
+    file_name: str | None
+    line_number: int
+
+
+class _IncludeCodeGenerator(CodeGenerator):
+    def visit_Output(self, node: nodes.Output, frame: Frame) -> None:
+        # Route each rendered expression through the environment so a value
+        # the server would supply leaves a traceable placeholder instead of
+        # vanishing. Literal text is left alone so it still folds at compile
+        # time.
+        node = copy(node)
+        node.nodes = [
+            (
+                child
+                if isinstance(child, (nodes.TemplateData, nodes.Const))
+                else self._wrap_output(child)
+            )
+            for child in node.nodes
+        ]
+        super().visit_Output(node, frame)
+
+    def _wrap_output(self, child: nodes.Expr) -> nodes.Expr:
+        call = nodes.Call(
+            nodes.EnvironmentAttribute("substitute_unknown"),
+            [child, nodes.Const(self.filename), nodes.Const(child.lineno)],
+            [],
+            None,
+            None,
+        )
+        call.set_lineno(child.lineno)
+        return call
+
+    def write_commons(self) -> None:
+        super().write_commons()
+        # The preamble binds `cond_expr_undefined = Undefined`, deliberately
+        # using Jinja's strict type for the implicit else of an inline if.
+        # Offline, `{{ "a" if server_value }}` has to behave like every other
+        # missing value, so rebind it to the environment's type.
+        self.writeline("cond_expr_undefined = environment.undefined")
+
+    def visit_Include(self, node: nodes.Include, frame: Frame) -> None:
+        # Wrap only include lookups. Imports and inheritance must still fail.
+        node = copy(node)
+        node.template = nodes.Call(
+            nodes.EnvironmentAttribute("load_include"),
+            [
+                node.template,
+                nodes.Const(self.name),
+                nodes.Const(self.filename),
+                nodes.Const(node.lineno),
+            ],
+            [],
+            None,
+            None,
+        )
+        node.template.set_lineno(node.lineno)
+        super().visit_Include(node, frame)
+
+
+class _PartialEnvironment(SandboxedEnvironment):
+    code_generator_class = _IncludeCodeGenerator
+    missing_includes: list[MissingInclude]
+    unknown_values: list[UnknownValue]
+    unknown_count: int
+    missing_marker: str
+
+    def substitute_unknown(self, value: Any, filename: str | None, lineno: int) -> Any:
+        if not isinstance(value, _OfflineUndefined):
+            return value
+        # A sandbox violation is a real finding, not an absent value.
+        value._guard_sandbox_violation()
+        name = value._undefined_name
+        unknown = UnknownValue(str(name) if name else "expression", filename, lineno)
+        if unknown not in self.unknown_values:
+            self.unknown_values.append(unknown)
+        self.unknown_count += 1
+        return f"{_UNKNOWN_PREFIX}{self.unknown_count}"
+
+    def load_include(
+        self,
+        name: str | Template | list[str | Template],
+        parent: str | None,
+        filename: str | None,
+        lineno: int,
+    ) -> Template:
+        try:
+            return self.get_or_select_template(name, parent)
+        except TemplateNotFound as exc:
+            # Try every candidate in an include list before substituting.
+            missing = MissingInclude(str(exc), filename, lineno)
+            if missing not in self.missing_includes:
+                self.missing_includes.append(missing)
+            return self.from_string(self.missing_marker)
+
+
+def _render_yaml(
+    source: str, input_file: str | None = None
+) -> tuple[str, list[MissingInclude], list[UnknownValue]]:
+    """Render YAML, blanking documents affected by unavailable includes.
+
+    The result is best effort: missing templates may supply document separators
+    or definitions. Preserve newlines so unaffected findings keep rendered line
+    numbers. Values the server would supply are undefined here, so a branch on
+    one is taken as if it were empty and only that branch is checked.
+    """
+    env = _PartialEnvironment(
+        loader=(
+            FileSystemLoader(Path(input_file).parent) if input_file else DictLoader({})
+        ),
+        undefined=_OfflineUndefined,
+        autoescape=False,
+    )
+    env.policies["json.dumps_kwargs"] = {
+        **env.policies["json.dumps_kwargs"],
+        "default": _json_default,
+    }
+    env.missing_includes = []
+    env.unknown_values = []
+    env.unknown_count = 0
+    env.missing_marker = f"DAYAMLCHECKER_MISSING_{uuid4().hex}"
+    chunks = []
+    size = 0
+    for chunk in env.from_string(source).generate():
+        size += len(chunk.encode("utf-8"))
+        if size > _MAX_OUTPUT_BYTES:
+            raise JinjaRenderError("Jinja rendered output exceeds 4 MiB limit")
+        chunks.append(chunk)
+    rendered = "".join(chunks)
+    # Match the validator's document boundaries, retaining the separators.
+    parts = re.split(r"(^--- *$)", rendered, flags=re.MULTILINE)
+    rendered = "".join(
+        "\n" * part.count("\n") if env.missing_marker in part else part
+        for part in parts
+    )
+    return rendered, env.missing_includes, env.unknown_values
+
+
+def render_yaml(
+    source: str, input_file: str | None = None
+) -> tuple[str, list[MissingInclude], list[UnknownValue]]:
+    """Compile and render in a disposable, resource-limited worker."""
+    if len(source.encode("utf-8")) > _MAX_SOURCE_BYTES:
+        raise JinjaRenderError("Jinja source exceeds 4 MiB limit")
+    # A file bounds parent memory even if the worker fails while serializing.
+    with TemporaryFile() as output:
+        try:
+            completed = subprocess.run(
+                [sys.executable, "-I", str(Path(__file__).resolve())],
+                input=json.dumps({"source": source, "input_file": input_file}).encode(),
+                stdout=output,
+                stderr=subprocess.DEVNULL,
+                timeout=_RENDER_TIMEOUT,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise JinjaRenderError(
+                f"Jinja rendering exceeded {_RENDER_TIMEOUT} second time limit"
+            ) from exc
+        if completed.returncode:
+            raise JinjaRenderError(
+                "Jinja rendering worker stopped (CPU, memory, or response limit "
+                f"may have been exceeded; exit {completed.returncode})"
+            )
+        output.seek(0)
+        response = output.read(_MAX_RESPONSE_BYTES + 1)
+    if len(response) > _MAX_RESPONSE_BYTES:
+        raise JinjaRenderError("Jinja worker response exceeded size limit")
+    result = json.loads(response)
+    if "error" in result:
+        raise JinjaRenderError(**result["error"])
+    return (
+        result["rendered"],
+        [MissingInclude(**item) for item in result["missing"]],
+        [UnknownValue(**item) for item in result["unknown"]],
+    )
+
+
+def _set_resource_limits() -> None:
+    # Fail closed on platforms without OS-enforced limits; never fall back to
+    # unbounded in-process rendering. The parent separately enforces wall time.
+    try:
+        import resource
+    except ImportError as exc:
+        raise JinjaRenderError(
+            "Bounded Jinja rendering requires Unix resource limits"
+        ) from exc
+    limits = [
+        (resource.RLIMIT_CPU, _CPU_SECONDS),
+        (resource.RLIMIT_FSIZE, _MAX_RESPONSE_BYTES),
+    ]
+    # A fresh Darwin process reserves hundreds of GiB of virtual address space.
+    # Lowering RLIMIT_AS below that existing reservation fails with EINVAL, so
+    # retain the CPU, response-size, and parent wall-time bounds on macOS while
+    # using the address-space cap on platforms where it is enforceable.
+    if sys.platform != "darwin":
+        limits.insert(0, (resource.RLIMIT_AS, _MEMORY_BYTES))
+    for kind, limit in limits:
+        _, hard = resource.getrlimit(kind)
+        if hard != resource.RLIM_INFINITY:
+            limit = min(limit, hard)
+        resource.setrlimit(kind, (limit, limit))
+
+
+def _worker() -> None:
+    try:
+        _set_resource_limits()
+        request = json.load(sys.stdin)
+        rendered, missing, unknown = _render_yaml(
+            request["source"], request["input_file"]
+        )
+        result: dict[str, Any] = {
+            "rendered": rendered,
+            "missing": [asdict(item) for item in missing],
+            "unknown": [asdict(item) for item in unknown],
+        }
+    except Exception as exc:
+        filename = getattr(exc, "filename", None)
+        lineno = getattr(exc, "lineno", None)
+        if lineno is None:
+            # Jinja rewrites runtime tracebacks into template-source frames.
+            # Keep the innermost such frame, not a later Python library frame.
+            tb = exc.__traceback__
+            while tb is not None:
+                if "__jinja_exception__" in tb.tb_frame.f_globals:
+                    filename = tb.tb_frame.f_code.co_filename
+                    lineno = tb.tb_lineno
+                tb = tb.tb_next
+        if filename == "<template>":
+            filename = None
+        message = (
+            "Jinja rendering exceeded 256 MiB memory limit"
+            if isinstance(exc, MemoryError)
+            else str(exc)[:4096]
+        )
+        result = {"error": {"message": message, "filename": filename, "lineno": lineno}}
+    sys.stdout.write(json.dumps(result))
+
+
+if __name__ == "__main__":
+    _worker()
diff --git a/src/dayamlchecker/fixer.py b/src/dayamlchecker/fixer.py
index b0c678d..a4e865e 100644
--- a/src/dayamlchecker/fixer.py
+++ b/src/dayamlchecker/fixer.py
@@ -22,6 +22,7 @@
 from pathlib import Path
 from typing import Any, Iterable
 
+from dayamlchecker._jinja import uses_jinja
 from ruamel.yaml import YAML
 
 from dayamlchecker.accessibility import (
@@ -915,6 +916,10 @@ def plan_file(path: Path, options: FixOptions | None = None) -> FilePlan:
         plan.skipped_reason = f"could not read file: {exc}"
         return plan
 
+    if uses_jinja(text):
+        plan.skipped_reason = "Jinja templates cannot be automatically rewritten"
+        return plan
+
     documents, parse_error = _load_documents(text)
     if documents is None:
         plan.skipped_reason = f"YAML parse failed: {parse_error}"
diff --git a/src/dayamlchecker/messages.py b/src/dayamlchecker/messages.py
index 7230652..142f0c9 100644
--- a/src/dayamlchecker/messages.py
+++ b/src/dayamlchecker/messages.py
@@ -22,6 +22,9 @@ class MessageId(StrEnum):
     YAML_DUPLICATE_KEY = "yaml_duplicate_key"
     YAML_DUPLICATE_BLOCK_ID = "yaml_duplicate_block_id"
     YAML_PARSE_ERROR = "yaml_parse_error"
+    JINJA_RENDER_ERROR = "jinja_render_error"
+    JINJA_MISSING_INCLUDE = "jinja_missing_include"
+    JINJA_UNKNOWN_VALUE = "jinja_unknown_value"
     YAML_STRING_REQUIRED = "yaml_string_required"
 
     MAKO_SYNTAX_ERROR = "mako_syntax_error"
@@ -298,6 +301,32 @@ class MessageDefinition:
         summary="Duplicate YAML key",
         template="{error}",
     ),
+    MessageId.JINJA_MISSING_INCLUDE: MessageDefinition(
+        code="WG106",
+        severity=Severity.WARNING,
+        finding_class=FindingClass.GENERAL,
+        summary="Missing Jinja include; validation is partial",
+        template="Included Jinja2 document could not be verified: {missing}. "
+        "Validation is partial: rendered YAML documents containing its placeholder "
+        "were skipped. The missing include may supply document boundaries or "
+        "definitions, so remaining findings are best effort.",
+    ),
+    MessageId.JINJA_UNKNOWN_VALUE: MessageDefinition(
+        code="WG107",
+        severity=Severity.WARNING,
+        finding_class=FindingClass.GENERAL,
+        summary="Jinja value came from the server; checked as a placeholder",
+        template="`{name}` is supplied by the server, so this expression was "
+        "replaced with a placeholder and the surrounding YAML checked around "
+        "it. Anything depending on its real value was not checked.",
+    ),
+    MessageId.JINJA_RENDER_ERROR: MessageDefinition(
+        code="EG106",
+        severity=Severity.ERROR,
+        finding_class=FindingClass.GENERAL,
+        summary="Jinja rendering error",
+        template="Could not render Jinja YAML: {error}",
+    ),
     MessageId.YAML_PARSE_ERROR: MessageDefinition(
         code="EG102",
         severity=Severity.ERROR,
@@ -1626,6 +1655,10 @@ class Finding:
     end_line: int | None = None
     end_column: int | None = None
     context: Mapping[str, Any] = field(default_factory=dict)
+    # Set when the finding comes from preprocessed Jinja output. ``file_name``
+    # stays the real path so tools can resolve it, but ``line_number`` counts
+    # rendered lines, which need not correspond to lines of that file.
+    rendered_jinja: bool = False
 
     @property
     def definition(self) -> MessageDefinition:
@@ -1657,6 +1690,8 @@ def err_str(self) -> str:
 
     def __str__(self) -> str:
         location = self.file_name or "<unknown>"
+        if self.rendered_jinja:
+            location = f"{location} (rendered Jinja)"
         if self.line_number is not None:
             location = f"{location}:{self.line_number}"
         severity_label = {
@@ -1745,19 +1780,28 @@ def print_github_annotation(d: Finding) -> None:
 
     if getattr(d, "file_name", None):
         props.append(f"file={escape_property(str(d.file_name))}")
-    if getattr(d, "line_number", None):
-        props.append(f"line={d.line_number}")
-    if d.column is not None:
-        props.append(f"col={d.column}")
-    if d.end_line is not None:
-        props.append(f"endLine={d.end_line}")
-    if d.end_column is not None:
-        props.append(f"endColumn={d.end_column}")
+    # Rendered Jinja line numbers count generated lines, so anchoring them in
+    # the source file would point at an unrelated line. Annotate the file as a
+    # whole and keep the generated location in the message instead.
+    if not d.rendered_jinja:
+        if getattr(d, "line_number", None):
+            props.append(f"line={d.line_number}")
+        if d.column is not None:
+            props.append(f"col={d.column}")
+        if d.end_line is not None:
+            props.append(f"endLine={d.end_line}")
+        if d.end_column is not None:
+            props.append(f"endColumn={d.end_column}")
     if getattr(d, "code", None):
         props.append(f"title={escape_property(d.code)}")
 
     prop_text = ",".join(props)
     message = escape_data(d.message)
+    if d.rendered_jinja:
+        location = "rendered Jinja"
+        if d.line_number is not None:
+            location = f"{location} line {d.line_number}"
+        message = f"[{location}] {message}"
 
     if prop_text:
         print(f"::{kind} {prop_text}::{message}")
diff --git a/src/dayamlchecker/yaml_structure.py b/src/dayamlchecker/yaml_structure.py
index 042843f..e8de409 100644
--- a/src/dayamlchecker/yaml_structure.py
+++ b/src/dayamlchecker/yaml_structure.py
@@ -33,6 +33,7 @@
     CompileException,
 )
 import esprima  # type: ignore[import-untyped]
+from dayamlchecker._jinja import is_unknown_jinja_value, uses_jinja
 from ruamel.yaml import YAML
 from ruamel.yaml.comments import CommentedMap, CommentedSeq
 from ruamel.yaml.error import MarkedYAMLError
@@ -58,8 +59,6 @@
 # * is "gathered" a valid attr?
 # * handle "response"
 # * labels above fields?
-# * if "# use jinja" at top, process whole file with Jinja:
-#   https://docassemble.org/docs/interviews.html#jinja2
 
 
 __all__ = [
@@ -195,7 +194,9 @@ def _apply_dayc_suppressions_from_files(findings: list[Finding]) -> list[Finding
 
     for finding in findings:
         file_name = finding.file_name
-        if not file_name or file_name.startswith("<"):
+        # A rendered-Jinja finding names a real file, but its line numbers are
+        # generated ones: re-reading that source would match the wrong lines.
+        if not file_name or file_name.startswith("<") or finding.rendered_jinja:
             filtered.append(finding)
             continue
 
@@ -334,6 +335,12 @@ class MakoText:
 
     def __init__(self, x):
         self.errors = _malformed_markdown_link_errors(x)
+        if not isinstance(x, str):
+            # A null or structured value holds no Mako to compile, and
+            # MakoTemplate raises RuntimeException rather than reporting it.
+            # `question:` with no text reaches here, as does any key whose
+            # value a Jinja server variable rendered away.
+            return
         try:
             self.template = MakoTemplate(
                 x, strict_undefined=True, input_encoding="utf-8"
@@ -768,6 +775,10 @@ def _validate_python_modifier(
         def references_screen_variable(var_expr):
             if not isinstance(var_expr, str):
                 return False
+            if is_unknown_jinja_value(var_expr):
+                # A placeholder stands in for a value the server supplies, so
+                # there is no name here to resolve against this screen.
+                return True
             candidates = self._variable_candidates(var_expr)
             if any(candidate in screen_variables for candidate in candidates):
                 return True
@@ -2061,11 +2072,88 @@ def depth(var_name: str) -> int:
     return max((depth(var) for var in adjacency.keys()), default=0)
 
 
+def _apply_jinja_suppressions(
+    findings: list[Finding], source: str, input_file: str | None
+) -> list[Finding]:
+    """Jinja diagnostics refer to template source, not generated YAML."""
+    result = []
+    for finding in findings:
+        if finding.file_name == input_file:
+            result.extend(_apply_dayc_suppressions([finding], source))
+        else:
+            result.extend(_apply_dayc_suppressions_from_files([finding]))
+    return result
+
+
 def find_errors_from_string(
     full_content: str,
     input_file: Optional[str] = None,
     lint_mode: str = DEFAULT_LINT_MODE,
     runtime_options: Optional[RuntimeOptions] = None,
+) -> list[YAMLError]:
+    """Preprocess opted-in Jinja templates, then run normal YAML validation."""
+    partial_findings: list[YAMLError] = []
+    if uses_jinja(full_content):
+        from dayamlchecker._jinja import render_yaml
+
+        source_content = full_content
+        try:
+            full_content, missing_includes, unknown_values = render_yaml(
+                full_content, input_file
+            )
+        except Exception as exc:
+            # Rendering can also raise Python errors (e.g. division by zero).
+            return _apply_jinja_suppressions(
+                [
+                    make_finding(
+                        MessageId.JINJA_RENDER_ERROR,
+                        file_name=getattr(exc, "filename", None) or input_file,
+                        line_number=getattr(exc, "lineno", None),
+                        error=str(exc),
+                    )
+                ],
+                source_content,
+                input_file,
+            )
+        partial_findings = [
+            make_finding(
+                MessageId.JINJA_MISSING_INCLUDE,
+                file_name=missing.file_name or input_file,
+                line_number=missing.line_number,
+                missing=missing.description,
+            )
+            for missing in missing_includes
+        ] + [
+            make_finding(
+                MessageId.JINJA_UNKNOWN_VALUE,
+                file_name=unknown.file_name or input_file,
+                line_number=unknown.line_number,
+                name=unknown.name,
+            )
+            for unknown in unknown_values
+        ]
+        partial_findings = _apply_jinja_suppressions(
+            partial_findings, source_content, input_file
+        )
+        # Generated lines need not correspond to template lines, so mark these
+        # findings rather than renaming the file they came from: the path stays
+        # usable, while suppression and annotation stay off the source lines.
+        return partial_findings + [
+            replace(finding, rendered_jinja=True)
+            for finding in _find_errors_from_yaml(
+                full_content, input_file, lint_mode, runtime_options
+            )
+        ]
+    return partial_findings + _find_errors_from_yaml(
+        full_content, input_file, lint_mode, runtime_options
+    )
+
+
+def _find_errors_from_yaml(
+    full_content: str,
+    input_file: Optional[str] = None,
+    lint_mode: str = DEFAULT_LINT_MODE,
+    runtime_options: Optional[RuntimeOptions] = None,
 ) -> list[YAMLError]:
     """Return list of findings found in the given full_content string
 
@@ -2519,8 +2607,7 @@ def find_errors(
 ) -> list[YAMLError]:
     """Return list of findings found in the given input_file
 
-    If the file has Docassemble's optional Jinja2 preprocessor directive at the top,
-    it is ignored and an empty list is returned.
+    Files beginning with ``# use jinja`` are rendered before validation.
 
     Args:
         input_file (str): Path to the YAML file to check.
@@ -2531,11 +2618,6 @@ def find_errors(
     with open(input_file, "r") as f:
         full_content = f.read()
 
-    if full_content[:12] == "# use jinja\n":
-        print()
-        print(f"Ah Jinja! ignoring {input_file}")
-        return []
-
     return find_errors_from_string(
         full_content,
         input_file=input_file,
diff --git a/tests/fixtures/jinja/README.md b/tests/fixtures/jinja/README.md
new file mode 100644
index 0000000..03fbaaa
--- /dev/null
+++ b/tests/fixtures/jinja/README.md
@@ -0,0 +1,12 @@
+`x_documents_anonymized.yml` and `x_review_anonymized.yml` are the unmodified
+examples shared by @jpagh in
+https://github.com/SuffolkLITLab/DAYamlChecker/pull/89#issuecomment-5778835599.
+
+Original attachments:
+- https://github.com/user-attachments/files/32524216/x_documents_anonymized.yml
+- https://github.com/user-attachments/files/32524217/x_review_anonymized.yml
+
+The documents example depends on server configuration, unavailable offline.
+Its config-driven include loop renders empty; its two ordinary question blocks
+still produce EG414 (missing question IDs). The review example expands local
+macros while preserving Mako expressions and produces no findings.
diff --git a/tests/fixtures/jinja/fields.yml b/tests/fixtures/jinja/fields.yml
new file mode 100644
index 0000000..42f9811
--- /dev/null
+++ b/tests/fixtures/jinja/fields.yml
@@ -0,0 +1,2 @@
+  - Like {{ fruit }}s: likes_{{ fruit }}
+    datatype: yesno
diff --git a/tests/fixtures/jinja/interview.yml b/tests/fixtures/jinja/interview.yml
new file mode 100644
index 0000000..f82a2e1
--- /dev/null
+++ b/tests/fixtures/jinja/interview.yml
@@ -0,0 +1,13 @@
+# use jinja
+{% set fruits = ['apple', 'pear'] %}
+{% for fruit in fruits %}
+---
+id: {{ fruit }}
+question: Do you like {{ fruit }}s?
+fields:
+{% include 'fields.yml' %}
+{% endfor %}
+---
+mandatory: true
+code: |
+  likes_both = likes_apple and likes_pear
diff --git a/tests/fixtures/jinja/x_documents_anonymized.yml b/tests/fixtures/jinja/x_documents_anonymized.yml
new file mode 100644
index 0000000..a15e045
--- /dev/null
+++ b/tests/fixtures/jinja/x_documents_anonymized.yml
@@ -0,0 +1,62 @@
+# use jinja
+---
+include:
+{% for name in config.categories.keys() %}
+  - {{ "category_" ~ name ~ ".yml" }}
+{% endfor %}
+---
+code: |
+  selected = registry[registry.category]
+  for stage in registry.stages:
+    section = registry[stage]
+    section.output.clear()
+    attachments = make_attachments(
+      storage=section.output,
+      category=selected,
+      name=stage,
+      **registry.builders[stage],
+    )
+    section.output.extend(attachments)
+---
+question: |
+  ${question("Items", "Categories")}
+fields:
+  - label: no label
+    field: registry.category
+    input type: radio
+    code: |
+      registry.available() + ([{"extra": "Extra option"}] if registry.include_extra else [])
+  - note: |
+      % if registry.has_saved_data:
+      <span class="text-body-secondary">Saved information is available.</span>
+      % endif
+---
+question: |
+  ${question(registry.labels[registry.category], "Selection")}
+fields:
+  - label: Commonly used sets
+    field: registry.selected_bundle
+    label above field: True
+    code: |
+      [*registry.bundle_builder.keys()]
+    required: False
+  - label: Items to create
+    field: registry.selected_items
+    label above field: True
+    datatype: checkboxes
+    code: |
+      registry.single_builder
+script: |
+  var builders = ${json.dumps(registry.bundle_builder)};
+  var $field = $("#" + ${json.dumps(encode_name("registry.selected_bundle"))});
+  $field.on("change", function() {
+      var selected = val("registry.selected_items");
+      selected.forEach(function(item) {
+        setField("registry.selected_items[" + JSON.stringify(item) + "]", false);
+      });
+      var bundle = builders[val("registry.selected_bundle")] || [];
+      bundle.forEach(function(item) {
+        setField("registry.selected_items[" + JSON.stringify(item) + "]", true);
+      });
+  });
+---
diff --git a/tests/fixtures/jinja/x_review_anonymized.yml b/tests/fixtures/jinja/x_review_anonymized.yml
new file mode 100644
index 0000000..85ba766
--- /dev/null
+++ b/tests/fixtures/jinja/x_review_anonymized.yml
@@ -0,0 +1,83 @@
+# use jinja
+---
+{% macro item_review(item_index, item_label) -%}
+  - fields:
+      - record.items[{{ item_index }}].name
+      - record.items[{{ item_index }}].details.revisit
+    label: Edit
+    button: |
+      ${review_button(
+        question = """Item details — {{ item_label }}""",
+        dict = {
+          """Name""": record.items[{{ item_index }}].name,
+          """Kind""": record.items[{{ item_index }}].details.kind,
+          """Enabled""": yes_or_no(record.items[{{ item_index }}].details.enabled),
+        },
+      ) + review_button(
+        subquestion = """Additional entries""",
+        list = record.items[{{ item_index }}].details.entries,
+        attributes = {
+          "value": dict(label="Value", format="currency"),
+        },
+      )}
+  - fields:
+      - record.items[{{ item_index }}].details.members.revisit
+    show if: record.items[{{ item_index }}].details.enabled
+    label: Edit
+    button: |
+      ${review_button(
+        question = """Members of {{ item_label }}""",
+        list = record.items[{{ item_index }}].details.members,
+        attributes = {
+          "role": dict(label="Role"),
+        },
+      )}
+{%- endmacro %}
+---
+{% macro section_review(section_name) -%}
+  - note: |
+      <hr><h4>{{ section_name }}</h4>
+    show if: defined("record.{{ section_name }}")
+  - fields:
+      - record.{{ section_name }}.revisit
+    label: Edit
+    button: |
+      ${review_button(
+        question = """{{ section_name }}""",
+        list = record.{{ section_name }},
+      )}
+{%- endmacro %}
+---
+breadcrumb: Review & Edit
+question: |
+  <i class="fa-solid fa-pen-to-square"></i> Review &amp; Edit answers
+review:
+  - note: |
+      <h4>Items</h4>
+    show if: record.items.item(0) or record.items.item(1)
+  {{ item_review(0, "First item") }}
+  {{ item_review(1, "Second item") }}
+  {{ section_review("summary") }}
+  - fields:
+      - record.items[0]
+    label: Edit
+    button: |
+      % for item in record.items[0]:
+      ${review_button(
+        question = f"""Entry — {item}""",
+        dict = {
+          """Value""": getattr(item, "value", ""),
+          """Visible""": yes_or_no(getattr(item, "visible", False)),
+        },
+      )}
+      % endfor
+  - fields:
+      - record.items[1].details.choice
+    show if: record.items.item(1) and record.items[1].details.choice
+    label: Edit
+    button: |
+      ${review_button(
+        question = """Selected option""",
+        value = record.items[1].details.choice,
+      )}
+---
diff --git a/tests/test_jinja.py b/tests/test_jinja.py
new file mode 100644
index 0000000..e30b821
--- /dev/null
+++ b/tests/test_jinja.py
@@ -0,0 +1,793 @@
+from dataclasses import replace
+from pathlib import Path
+import sys
+
+import pytest
+
+from dayamlchecker._jinja import JinjaRenderError, render_yaml
+from dayamlchecker.fixer import plan_file
+from dayamlchecker.messages import MESSAGE_DEFINITIONS, MessageId
+from dayamlchecker.yaml_structure import find_errors, find_errors_from_string, main
+
+FIXTURES = Path(__file__).parent / "fixtures" / "jinja"
+
+
+@pytest.mark.parametrize(
+    "filename, expected_codes, exit_status",
+    [
+        ("x_documents_anonymized.yml", ["EG414", "EG414"], 1),
+        ("x_review_anonymized.yml", [], 0),
+    ],
+)
+def test_jpagh_examples(filename, expected_codes, exit_status, capsys):
+    path = FIXTURES / filename
+    rendered, missing, unknown = render_yaml(path.read_text(), str(path))
+    assert missing == []
+    assert unknown == []
+    assert "{%" not in rendered and "{{" not in rendered
+    findings = find_errors(str(path))
+    assert [f.code for f in findings] == expected_codes
+    assert all(f.rendered_jinja for f in findings)
+    if filename == "x_documents_anonymized.yml":
+        assert "category_" not in rendered  # Server config is unavailable offline.
+        assert '${question("Items", "Categories")}' in rendered
+    else:
+        for index, label in [(0, "First item"), (1, "Second item")]:
+            assert f"record.items[{index}].name" in rendered
+            assert f"Item details — {label}" in rendered
+        assert "record.summary.revisit" in rendered
+        assert "% for item in record.items[0]:" in rendered
+        assert "${review_button(" in rendered
+    assert main([str(path), "--no-url-check", "--no-docx-accessibility"]) == exit_status
+    output = capsys.readouterr().out
+    assert "EG106" not in output
+
+
+def test_jpagh_review_macro_output_is_validated():
+    path = FIXTURES / "x_review_anonymized.yml"
+    source = path.read_text().replace("label: Edit", "label: [unclosed", 1)
+    findings = find_errors_from_string(source, input_file=str(path))
+    assert any(f.message_id == MessageId.YAML_PARSE_ERROR for f in findings)
+    assert all(f.rendered_jinja for f in findings)
+
+
+def test_includes_loops_and_normal_validation():
+    path = FIXTURES / "interview.yml"
+    rendered, missing, _unknown = render_yaml(path.read_text(), str(path))
+    assert missing == []
+    assert "likes_apple" in rendered and "likes_pear" in rendered
+    assert "{%" not in rendered
+    assert [
+        replace(finding, rendered_jinja=False) for finding in find_errors(str(path))
+    ] == find_errors_from_string(rendered, input_file=str(path))
+    assert not any(f.severity == "error" for f in find_errors(str(path)))
+
+
+def test_included_invalid_python_is_validated(tmp_path):
+    (tmp_path / "included.yml").write_text("code: |\n  broken =\n")
+    path = tmp_path / "main.yml"
+    path.write_text('# use jinja\n{% include "included.yml" %}\n')
+    findings = find_errors(str(path))
+    finding = next(f for f in findings if f.message_id == MessageId.PYTHON_SYNTAX_ERROR)
+    assert finding.file_name == str(path)
+    assert finding.rendered_jinja
+    assert finding.line_number is not None
+
+
+@pytest.mark.parametrize(
+    "body, expected",
+    [
+        ("{% if %}", "Expected an expression"),
+        ("question: {{ 1 / 0 }}", "division by zero"),
+        ("{{ ''.__class__.__mro__ }}", "unsafe"),
+    ],
+)
+def test_render_failures_are_findings(tmp_path, body, expected):
+    findings = find_errors_from_string(
+        "# use jinja\n" + body, input_file=str(tmp_path / "main.yml")
+    )
+    assert len(findings) == 1
+    assert findings[0].message_id == MessageId.JINJA_RENDER_ERROR
+    assert expected in findings[0].message
+
+
+def test_syntax_error_in_include_has_source_location(tmp_path):
+    included = tmp_path / "bad.yml"
+    included.write_text("question: Hello\n{% if %}\n")
+    findings = find_errors_from_string(
+        '# use jinja\n{% include "bad.yml" %}',
+        input_file=str(tmp_path / "main.yml"),
+    )
+    assert findings[0].file_name == str(included)
+    assert findings[0].line_number == 2
+
+
+def test_jinja_is_opt_in_and_preserves_mako():
+    source = "question: |\n  {{ literal }} and ${ answer }\n"
+    assert render_yaml("# use jinja\n{% raw %}" + source + "{% endraw %}") == (
+        "# use jinja\n" + source,
+        [],
+        [],
+    )
+    assert not any(
+        f.message_id == MessageId.JINJA_RENDER_ERROR
+        for f in find_errors_from_string(source)
+    )
+
+
+def test_string_input_and_crlf():
+    findings = find_errors_from_string(
+        '# use jinja\r\n{% set value = "broken =" %}\r\ncode: |\r\n  {{ value }}\r\n'
+    )
+    assert any(f.message_id == MessageId.PYTHON_SYNTAX_ERROR for f in findings)
+
+
+def test_cli_reports_generated_errors_and_honors_rendered_suppressions(
+    tmp_path, capsys
+):
+    path = tmp_path / "main.yml"
+    path.write_text('# use jinja\n{{ "\\n" * 10 }}\n---\ncode: |\n  broken =\n')
+    assert main([str(path), "--no-docx-accessibility"]) == 1
+    assert "rendered Jinja" in capsys.readouterr().out
+    path.write_text(
+        '# use jinja\n{{ "\\n" * 10 }}\n---\n'
+        "# no-dayc-block: EG122\ncode: |\n  broken =\n# end of block\n"
+    )
+    assert main([str(path), "--no-docx-accessibility"]) == 0
+
+
+def test_fixer_leaves_even_yaml_parseable_templates_untouched(tmp_path):
+    path = tmp_path / "main.yml"
+    source = '# use jinja\nquestion: "{{ 1 + 1 }}"\nyesno: answer\n'
+    path.write_text(source)
+    plan = plan_file(path)
+    assert plan.skipped_reason == "Jinja templates cannot be automatically rewritten"
+    assert path.read_text() == source
+
+
+def test_conditionals_and_generated_yaml_errors():
+    source = (
+        "# use jinja\n{% set enabled = true %}\n"
+        "{% if enabled %}question: [unclosed{% else %}question: Fine{% endif %}\n"
+    )
+    assert any(
+        f.message_id == MessageId.YAML_PARSE_ERROR
+        for f in find_errors_from_string(source)
+    )
+    assert not any(
+        f.severity == "error"
+        for f in find_errors_from_string(
+            source.replace("enabled = true", "enabled = false")
+        )
+    )
+
+
+def test_docassemble_documented_include_pattern(tmp_path):
+    # Adapted from docassemble's examples/jinjayaml{,-included}.yml.
+    (tmp_path / "fruit.yml").write_text(
+        "id: fruit\nquestion: |\n  What is your favorite fruit?\n"
+        "fields:\n  - Fruit: favorite_fruit\n---\n"
+    )
+    source = (
+        '# use jinja\n{% include "fruit.yml" %}\n'
+        "id: result\nmandatory: True\nquestion: |\n"
+        "  Your favorite fruit is ${ favorite_fruit }.\n"
+    )
+    assert not any(
+        f.severity == "error"
+        for f in find_errors_from_string(source, input_file=str(tmp_path / "main.yml"))
+    )
+
+
+def test_server_jinja_data_is_tolerated_when_unavailable_offline():
+    source = (
+        "# use jinja\n"
+        "{% for category in jinja_config_automatedpleading_document_categories %}\n"
+        "---\nquestion: {{ category.label }}\nfield: {{ category.value }}\n"
+        "{% endfor %}\n"
+        "---\nid: config context\nquestion: |\n"
+        "  {{ nested_config.item.helper() }}\n"
+        "fields:\n  - Value: answer\n"
+        "{% if __debug__ %}help: Debug mode{% endif %}\n"
+    )
+    rendered, missing, unknown = render_yaml(source)
+    assert missing == []
+    assert [u.name for u in unknown] == ["nested_config"]
+    assert "question: |\n  dayc_unknown_" in rendered
+    assert [f.code for f in find_errors_from_string(source)] == ["WG107"]
+
+
+def test_offline_server_values_survive_arithmetic_and_comparison():
+    # A `jinja data` value is often a count or a threshold. Comparing or adding
+    # one must pick the empty branch, not abort the file.
+    source = (
+        "# use jinja\n"
+        "{% if jinja_data.limit > 0 %}\n"
+        "question: Configured limit\n"
+        "{% else %}\n"
+        "question: Answer {{ jinja_data.limit + 1 }}{{ -jinja_data.offset }}\n"
+        "fields:\n  - Value: answer\n"
+        "{% endif %}\n"
+    )
+    rendered, missing, unknown = render_yaml(source)
+    assert missing == []
+    assert "Configured limit" not in rendered
+    assert "question: Answer" in rendered
+    assert all(f.code == "WG107" for f in find_errors_from_string(source))
+
+
+@pytest.mark.parametrize(
+    "expression",
+    [
+        "{{ ''.__class__ > 1 }}",
+        "{{ ''.__class__ + 1 }}",
+        "{{ ''.__class__ | int }}",
+        "{{ -''.__class__ }}",
+    ],
+)
+def test_sandbox_violations_still_fail_through_offline_operators(expression):
+    findings = find_errors_from_string("# use jinja\nquestion: " + expression + "\n")
+    assert [f.code for f in findings] == ["EG106"]
+    assert "unsafe" in findings[0].message
+
+
+def test_every_failing_undefined_operator_is_covered():
+    """Guard against a future Jinja adding an operator that aborts a render.
+
+    ``Undefined`` routes a fixed set of operators to an error. Each one is a
+    way a real interview could use a value the server supplies, so every one
+    has to be handled here rather than found one failing file at a time.
+    """
+    from jinja2.runtime import Undefined
+
+    from dayamlchecker._jinja import _OfflineUndefined
+
+    raises = Undefined._fail_with_undefined_error
+    uncovered = {
+        name
+        for name, attr in vars(Undefined).items()
+        if attr is raises
+        and getattr(_OfflineUndefined, name, None) is getattr(Undefined, name, None)
+    }
+    # __div__/__rdiv__ are Python 2 spellings that Python 3 never calls, and
+    # _fail_with_undefined_error is the helper itself.
+    assert uncovered == {"__div__", "__rdiv__", "_fail_with_undefined_error"}
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        # Protocols that reach an undefined value without going through
+        # Undefined's own operator table.
+        "{{ x | abs }}",
+        "{{ x | round }}",
+        "{{ x | round(2) }}",
+        "{{ x | tojson }}",
+        "{{ {'k': x} | tojson }}",
+        "{% for i in range(x) %}{{ i }}{% endfor %}",
+        "{{ '{:>5}'.format(x) }}",
+        # The compiler binds Jinja's strict Undefined for the implicit else of
+        # an inline if, bypassing the environment's type.
+        "{{ 'A' if x }}",
+        "{{ (1 if x) + 1 }}",
+        "{% if (1 if x) > 0 %}A{% endif %}",
+        "{% block b %}{{ (1 if x) + 1 }}{% endblock %}",
+        "{% macro m() %}{{ (1 if x) + 1 }}{% endmacro %}{{ m() }}",
+    ],
+)
+def test_offline_values_survive_every_reachable_protocol(body):
+    render_yaml("# use jinja\n" + body + "\n")
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        "{{ ''.__class__ | abs }}",
+        "{{ ''.__class__ | round }}",
+        "{{ ''.__class__ | tojson }}",
+        "{% for i in range(''.__class__) %}{{ i }}{% endfor %}",
+        "{{ '{:>5}'.format(''.__class__) }}",
+        "{{ 'abc'[''.__class__] }}",
+        "{{ (1 if ''.__class__.__mro__) + 1 }}",
+    ],
+)
+def test_sandbox_fails_closed_through_every_offline_protocol(body):
+    findings = find_errors_from_string("# use jinja\nquestion: " + body + "\n")
+    assert [f.code for f in findings] == ["EG106"]
+    assert "unsafe" in findings[0].message
+
+
+def test_builtin_filters_and_tests_accept_offline_values():
+    """Every stock filter and test has to tolerate a server-supplied value."""
+    from jinja2.sandbox import SandboxedEnvironment
+
+    env = SandboxedEnvironment()
+
+    def rejects(body):
+        try:
+            render_yaml("# use jinja\n" + body + "\n")
+        except JinjaRenderError as exc:
+            # Arity complaints are about the call, not the undefined value.
+            return "argument" not in str(exc) and "positional" not in str(exc)
+        return False
+
+    failed = []
+    for name in sorted(env.filters):
+        shapes = [
+            f"{{{{ x | {name} }}}}",
+            f"{{{{ x | {name}(1) }}}}",
+            f"{{{{ x | {name}('a') }}}}",
+            f"{{{{ x | {name}('a', 'b') }}}}",
+        ]
+        if all(rejects(shape) for shape in shapes):
+            failed.append(name)
+    for name in sorted(env.tests):
+        if not name.isalpha():
+            continue  # operator aliases such as `>=` are not `is` syntax
+        shapes = [f"{{{{ x is {name} }}}}", f"{{{{ x is {name} 1 }}}}"]
+        if all(rejects(shape) for shape in shapes):
+            failed.append(name)
+    assert failed == []
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        "{{ a.b.c.d }}",
+        "{{ a['b'][0] }}",
+        "{{ a.helper(1, k=2) }}",
+        "{% if 0 < x < 10 %}A{% endif %}",
+        "{% for k, v in x %}{{ k }}{% endfor %}",
+        "{% for i in x %}{{ loop.index }}{{ loop.previtem }}{{ loop.nextitem }}{% endfor %}",
+        "{% for i in x recursive %}{{ loop(i) }}{% endfor %}",
+        "{{ x ~ 'y' }}{{ x + 1 }}{{ 1 + x }}{{ x * 2 }}{{ x / 2 }}{{ x % 2 }}{{ x ** 2 }}",
+        "{{ -x }}{{ +x }}{{ not x }}{{ x and 1 }}{{ x or 2 }}",
+        "{{ x == 1 }}{{ x != 1 }}{{ 1 in x }}{{ x is in [1, 2] }}",
+        "{% set y = x %}{{ y }}",
+        "{% set y %}{{ x }}{% endset %}{{ y }}",
+        "{% with y = x %}{{ y }}{% endwith %}",
+        "{% set ns = namespace(v=x) %}{% set ns.v = x %}{{ ns.v }}",
+        "{% filter upper %}{{ x }}{% endfilter %}",
+        "{% macro m(a, b) %}{{ a }}{{ b }}{% endmacro %}{{ m(x) }}",
+        "{% macro m() %}{{ caller() }}{% endmacro %}{% call m() %}{{ x }}{% endcall %}",
+        "{% macro m() %}{{ varargs }}{{ kwargs }}{% endmacro %}{{ m(x) }}",
+        "{% block b %}{{ x }}{% endblock %}{{ self.b() }}",
+        "{{ {'k': x} }}{{ [x, x] }}{{ x[1:3] }}",
+        "{{ lipsum(x) }}",
+        "{%- if x -%}A{%- else -%}B{%- endif -%}",
+    ],
+)
+def test_jinja_constructs_tolerate_offline_values(body):
+    render_yaml("# use jinja\n" + body + "\n")
+
+
+def test_a_server_value_as_a_whole_scalar_does_not_break_validation():
+    # These render to a null YAML value, which reaches checks that expect a
+    # string. The interview is valid on a real server, so it must stay clean.
+    for body in (
+        "question: {{ jinja_data.text }}\n",
+        "question: Hi\nsubquestion: {{ jinja_data.text }}\n",
+    ):
+        source = "# use jinja\nid: q\n" + body + "fields:\n  - Name: name\n"
+        findings = find_errors_from_string(source, input_file="i.yml")
+        assert [f.code for f in findings] == ["WG107"]
+
+
+def test_unknown_value_becomes_a_unique_placeholder_warned_once_per_site():
+    # One source line rendered three times is one warning, but three distinct
+    # placeholders, so the generated block ids do not collide.
+    source = (
+        "# use jinja\n"
+        "{% for i in [1, 2, 3] %}---\n"
+        "id: q{{ i }}{{ jinja_data.suffix }}\n"
+        "question: Q\nfields:\n  - Name: n{{ i }}\n"
+        "{% endfor %}"
+    )
+    rendered, missing, unknown = render_yaml(source)
+    assert missing == []
+    assert [(u.name, u.line_number) for u in unknown] == [("jinja_data", 3)]
+    ids = sorted(line for line in rendered.splitlines() if line.startswith("id:"))
+    assert len(set(ids)) == 3
+    assert [f.code for f in find_errors_from_string(source)] == ["WG107"]
+
+
+def test_placeholder_keeps_the_surrounding_yaml_checkable():
+    # Each of these renders a server value into a position where an empty
+    # value would break the structure and hide everything after it.
+    for body in (
+        "id: q\nquestion: Hello\nfields:\n  - {{ jinja_data.label }}: name\n",
+        "id: c\ncode: |\n  x = {{ jinja_data.value }}\n",
+        "id: {{ jinja_data.id }}\nquestion: Hi\nfields:\n  - Name: name\n",
+        "id: q\nmandatory: {{ jinja_data.m }}\nquestion: Hi\nfields:\n  - Name: name\n",
+    ):
+        findings = find_errors_from_string("# use jinja\n" + body, input_file="i.yml")
+        assert [f.code for f in findings] == ["WG107"], body
+
+
+def test_placeholder_does_not_hide_a_real_error_in_the_same_file():
+    source = (
+        "# use jinja\n"
+        "id: q\nquestion: {{ jinja_data.title }}\nfields:\n  - Name: name\n"
+        "---\nid: c\ncode: |\n  broken =\n"
+    )
+    codes = [f.code for f in find_errors_from_string(source, input_file="i.yml")]
+    assert "WG107" in codes and "EG122" in codes
+
+
+def test_placeholder_is_not_reported_as_an_unknown_screen_variable():
+    source = (
+        "# use jinja\nid: q\nquestion: Hi\n"
+        "fields:\n  - Name: name\n    show if: {{ jinja_data.cond }}\n"
+    )
+    assert [f.code for f in find_errors_from_string(source, input_file="i.yml")] == [
+        "WG107"
+    ]
+
+
+@pytest.mark.parametrize("suppression", ["inline", "block"])
+def test_unknown_value_warning_suppresses_from_template_source(suppression):
+    source = (
+        "# use jinja\nid: q\nquestion: {{ jinja_data.t }}\nfields:\n  - Name: name\n"
+    )
+    findings = find_errors_from_string(source, input_file="i.yml")
+    assert [(f.code, f.line_number) for f in findings] == [("WG107", 3)]
+    if suppression == "inline":
+        source = source.replace(
+            "{{ jinja_data.t }}", "{{ jinja_data.t }} # no-dayc: WG107"
+        )
+    else:
+        source = source.replace(
+            "# use jinja\n", "# use jinja\n# no-dayc-block: WG107\n"
+        )
+    assert find_errors_from_string(source, input_file="i.yml") == []
+
+
+def test_sandbox_violation_is_an_error_not_a_placeholder():
+    findings = find_errors_from_string("# use jinja\nquestion: {{ ''.__class__ }}\n")
+    assert [f.code for f in findings] == ["EG106"]
+
+
+def test_render_error_code_is_not_shared_with_an_unrelated_check():
+    # Suppression matches on the code string alone, so a code shared with an
+    # unrelated check would silence that check too.
+    render_error = MESSAGE_DEFINITIONS[MessageId.JINJA_RENDER_ERROR]
+    assert render_error.code not in [
+        definition.code
+        for message_id, definition in MESSAGE_DEFINITIONS.items()
+        if message_id != MessageId.JINJA_RENDER_ERROR
+    ]
+
+
+@pytest.mark.parametrize(
+    "include",
+    [
+        '{% include "docassemble.other:data/questions/fields.yml" %}',
+        '{% include "missing.yml" without context %}',
+        '{% include "missing.yml" ignore missing %}',
+        '{% set file = "missing.yml" %}{% include file %}',
+    ],
+)
+def test_missing_include_skips_affected_document_only(include):
+    source = (
+        "# use jinja\ncode: |\n  before =\n---\n"
+        "id: incomplete\nquestion: Incomplete\nfields:\n"
+        + include
+        + "\n---\ncode: |\n  after =\n"
+    )
+    rendered, missing, _unknown = render_yaml(source)
+    assert len(missing) == 1
+    assert "fields:" not in rendered
+    assert rendered.count("\n") == source.count("\n") - 1
+    findings = find_errors_from_string(source)
+    missing_findings = [
+        f for f in findings if f.message_id == MessageId.JINJA_MISSING_INCLUDE
+    ]
+    errors = [f for f in findings if f.message_id != MessageId.JINJA_MISSING_INCLUDE]
+    assert len(missing_findings) == 1
+    assert missing_findings[0].severity == "warning"
+    assert "Validation is partial" in missing_findings[0].message
+    assert len(errors) == 2
+    assert all(f.message_id == MessageId.PYTHON_SYNTAX_ERROR for f in errors)
+    # Blanking the incomplete document must not shift subsequent locations.
+    expected = find_errors_from_string(rendered)
+    assert [f.line_number for f in errors] == [f.line_number for f in expected]
+
+
+def test_missing_standalone_and_nested_includes(tmp_path):
+    (tmp_path / "local.yml").write_text('{% include "missing.yml" %}')
+    source = '# use jinja\n{% include "local.yml" %}\n---\ncode: |\n  valid = 1\n'
+    findings = find_errors_from_string(source, input_file=str(tmp_path / "main.yml"))
+    assert len(findings) == 1
+    assert findings[0].message_id == MessageId.JINJA_MISSING_INCLUDE
+    assert "missing.yml" in findings[0].message
+
+
+def test_include_fallback_list_uses_existing_file(tmp_path):
+    (tmp_path / "exists.yml").write_text("code: |\n  valid = 1\n")
+    source = '# use jinja\n{% include ["missing.yml", "exists.yml"] %}'
+    assert find_errors_from_string(source, input_file=str(tmp_path / "main.yml")) == []
+    findings = find_errors_from_string(source.replace("exists.yml", "also-missing.yml"))
+    assert len(findings) == 1
+    assert findings[0].message_id == MessageId.JINJA_MISSING_INCLUDE
+    assert "missing.yml" in findings[0].message
+    assert "also-missing.yml" in findings[0].message
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        '{% import "missing.yml" as macros %}',
+        '{% from "missing.yml" import question %}',
+        '{% extends "missing.yml" %}',
+    ],
+)
+def test_missing_imports_and_parents_still_fail(tmp_path, body):
+    # Also exercise failures inside an otherwise available include.
+    (tmp_path / "local.yml").write_text(body)
+    for source in [body, '{% include "local.yml" %}']:
+        findings = find_errors_from_string(
+            "# use jinja\n" + source, input_file=str(tmp_path / "main.yml")
+        )
+        assert len(findings) == 1
+        assert findings[0].message_id == MessageId.JINJA_RENDER_ERROR
+
+
+def test_missing_includes_report_once_and_ignore_unselected_branches():
+    source = (
+        "# use jinja\n{% for i in range(3) %}\n"
+        '{% include "missing.yml" %}\n---\n{% endfor %}\n'
+        '{% if false %}{% include "unused.yml" %}{% endif %}'
+    )
+    findings = find_errors_from_string(source)
+    assert len(findings) == 1
+    assert "unused.yml" not in findings[0].message
+
+
+def test_partial_validation_cli_exit_status(tmp_path, capsys):
+    path = tmp_path / "main.yml"
+    path.write_text(
+        '# use jinja\n{% include "missing.yml" %}\n---\ncode: |\n  valid = 1\n'
+    )
+    args = [str(path), "--no-docx-accessibility"]
+    assert main(args) == 0
+    assert "Validation is partial" in capsys.readouterr().out
+    assert main(args + ["--max-warnings", "0"]) == 1
+    path.write_text(path.read_text().replace("%}\n---", "%} # no-dayc: WG106\n---"))
+    assert main(args + ["--max-warnings", "0"]) == 0
+    path.write_text(path.read_text().replace("valid = 1", "broken ="))
+    assert main(args) == 1
+
+
+@pytest.mark.parametrize(
+    "suppression", ["# no-dayc: WG106", "# no-dayc: jinja_missing_include"]
+)
+def test_inline_suppression_hides_only_partial_validation_warning(suppression):
+    source = (
+        '# use jinja\n{% include "docassemble.framework:data/questions/base.yml" %} '
+        + suppression
+        + "\n---\ncode: |\n  broken =\n"
+    )
+    findings = find_errors_from_string(source)
+    assert [f.message_id for f in findings] == [MessageId.PYTHON_SYNTAX_ERROR]
+
+
+def test_block_suppression_does_not_hide_other_missing_dependencies():
+    source = (
+        '# use jinja\n# no-dayc-block: WG106\n{% include "known.yml" %}\n'
+        '---\n{% include "unexpected.yml" %}\n'
+    )
+    findings = find_errors_from_string(source)
+    assert len(findings) == 1
+    assert findings[0].code == "WG106"
+    assert "unexpected.yml" in findings[0].message
+    assert findings[0].line_number == 5
+
+
+def test_nested_include_suppression_uses_its_own_source(tmp_path):
+    included = tmp_path / "local.yml"
+    included.write_text('{% include "external.yml" %} # no-dayc: WG106\n')
+    source = '# use jinja\n{% include "local.yml" %}\n---\ncode: |\n  valid = 1\n'
+    assert find_errors_from_string(source, input_file=str(tmp_path / "main.yml")) == []
+    included.write_text('{% include "external.yml" %}\n')
+    findings = find_errors_from_string(source, input_file=str(tmp_path / "main.yml"))
+    assert findings[0].file_name == str(included)
+    assert findings[0].line_number == 1
+
+
+def test_jinja_syntax_error_suppression_uses_template_source():
+    assert find_errors_from_string("# use jinja\n{% if %} # no-dayc: EG106\n") == []
+
+
+def test_include_suppression_is_per_source_site_not_rendered_line():
+    source = (
+        '# use jinja\n{{ "\\n" * 10 }}\n'
+        '{% include "external.yml" %} # no-dayc: WG106\n---\n'
+        '{% include "external.yml" %}\n'
+    )
+    findings = find_errors_from_string(source)
+    assert len(findings) == 1
+    assert findings[0].code == "WG106"
+    assert findings[0].line_number == 5
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        '{% import "external.yml" as framework %}',
+        '{% extends "external.yml" %}',
+    ],
+)
+def test_other_dependency_errors_require_explicit_suppression(tmp_path, body):
+    path = tmp_path / "main.yml"
+    args = [str(path), "--no-docx-accessibility"]
+    source = "# use jinja\n" + body + "\n"
+    path.write_text(source)
+    assert main(args) == 1
+    findings = find_errors(str(path))
+    assert findings[0].code == "EG106"
+    assert findings[0].severity == "error"
+    path.write_text(
+        source.replace("# use jinja\n", "# use jinja\n# no-dayc-block: EG106\n")
+    )
+    assert main(args) == 0
+    assert find_errors(str(path)) == []
+
+
+def test_missing_include_does_not_make_downstream_errors_nonbreaking(tmp_path):
+    path = tmp_path / "main.yml"
+    source = '# use jinja\n{% include "external.yml" %}\n---\ncode: |\n  broken =\n'
+    path.write_text(source)
+    assert main([str(path), "--no-docx-accessibility"]) == 1
+    assert {f.code for f in find_errors(str(path))} == {"WG106", "EG122"}
+    path.write_text(
+        source.replace("code: |", "# no-dayc-block: EG122\ncode: |") + "# end\n"
+    )
+    assert main([str(path), "--no-docx-accessibility"]) == 0
+    assert [f.code for f in find_errors(str(path))] == ["WG106"]
+
+
+@pytest.mark.parametrize(
+    "header", ["# use jinja2", "# use jinja disabled", " # use jinja", "\n# use jinja"]
+)
+def test_directive_prefixes_remain_ordinary_yaml(tmp_path, header):
+    path = tmp_path / "ordinary.yml"
+    path.write_text(header + '\nquestion: "{{ missing }}"\nfields:\n  - Name: name\n')
+    findings = find_errors(str(path))
+    assert all(f.message_id != MessageId.JINJA_RENDER_ERROR for f in findings)
+    assert all(not f.rendered_jinja for f in findings)
+    plan = plan_file(path)
+    assert plan.skipped_reason is None
+
+
+@pytest.mark.parametrize("ending", ["\n", "\r\n", ""])
+def test_exact_directive_is_shared_by_checker_and_fixer(tmp_path, ending):
+    from dayamlchecker._jinja import uses_jinja
+
+    source = "# use jinja" + ending
+    assert uses_jinja(source)
+    assert find_errors_from_string(source) == []
+    path = tmp_path / "main.yml"
+    path.write_bytes(source.encode())
+    assert (
+        plan_file(path).skipped_reason
+        == "Jinja templates cannot be automatically rewritten"
+    )
+
+
+@pytest.mark.parametrize("expression", ["{{ 1 / 0 }}"])
+@pytest.mark.parametrize("suppression", ["inline", "block"])
+def test_nested_runtime_error_location_and_suppression(
+    tmp_path, expression, suppression
+):
+    inner = tmp_path / "inner.yml"
+    outer = tmp_path / "outer.yml"
+    outer.write_text('{% include "inner.yml" %}\n')
+    source = '# use jinja\n{% include "outer.yml" %}\n'
+    inner.write_text("# comment\n" + expression + "\n")
+    findings = find_errors_from_string(source, input_file=str(tmp_path / "main.yml"))
+    assert len(findings) == 1
+    assert findings[0].code == "EG106"
+    assert findings[0].file_name == str(inner)
+    assert findings[0].line_number == 2
+    if suppression == "inline":
+        inner.write_text("# comment\n" + expression + " # no-dayc: EG106\n")
+    else:
+        inner.write_text("# no-dayc-block: EG106\n" + expression + "\n")
+    assert find_errors_from_string(source, input_file=str(tmp_path / "main.yml")) == []
+
+
+def test_top_level_runtime_error_has_source_line():
+    source = "# use jinja\nquestion: {{ 1 / 0 }}\n"
+    findings = find_errors_from_string(source, input_file="unsaved.yml")
+    assert findings[0].file_name == "unsaved.yml"
+    assert findings[0].line_number == 2
+    assert (
+        find_errors_from_string(
+            source.rstrip() + " # no-dayc: EG106\n", input_file="unsaved.yml"
+        )
+        == []
+    )
+
+
+def test_rendered_output_limit_is_a_finding():
+    source = '# use jinja\n{% for i in range(10) %}{{ "x" * 1000000 }}{% endfor %}'
+    findings = find_errors_from_string(source)
+    assert len(findings) == 1
+    assert findings[0].code == "EG106"
+    assert "output exceeds" in findings[0].message
+    # A failed worker must not poison subsequent validations.
+    assert render_yaml("code: |\n  valid = 1")[0] == "code: |\n  valid = 1"
+
+
+def test_render_timeout_kills_and_reaps_worker(monkeypatch):
+    from dayamlchecker import _jinja
+
+    processes = []
+    real_popen = _jinja.subprocess.Popen
+
+    def record_process(*args, **kwargs):
+        process = real_popen(*args, **kwargs)
+        processes.append(process)
+        return process
+
+    monkeypatch.setattr(_jinja.subprocess, "Popen", record_process)
+    monkeypatch.setattr(_jinja, "_RENDER_TIMEOUT", 0.2)
+    source = (
+        "# use jinja\n{% for a in range(100000) %}{% for b in range(100000) %}"
+        "{% set value = a + b %}{% endfor %}{% endfor %}"
+    )
+    findings = find_errors_from_string(source)
+    assert findings[0].code == "EG106"
+    assert "time limit" in findings[0].message
+    assert len(processes) == 1
+    assert processes[0].poll() is not None
+
+
+@pytest.mark.skipif(
+    sys.platform == "darwin",
+    reason="Darwin cannot lower RLIMIT_AS below the process's existing virtual size",
+)
+def test_large_allocation_is_confined_to_worker():
+    # A single expression can allocate before generate() yields, even during
+    # compilation/constant folding. The worker's OS memory limit covers both.
+    findings = find_errors_from_string('# use jinja\n{{ "x" * (1024 ** 3) }}')
+    assert len(findings) == 1
+    assert findings[0].code == "EG106"
+    assert "memory" in findings[0].message
+    assert render_yaml("code: |\n  valid = 1")[1] == []
+
+
+def test_source_limit_rejects_before_launching_worker(monkeypatch):
+    from dayamlchecker import _jinja
+
+    def unexpected_run(*args, **kwargs):
+        pytest.fail("Oversized input should not start a worker")
+
+    monkeypatch.setattr(_jinja.subprocess, "run", unexpected_run)
+    findings = find_errors_from_string("# use jinja\n" + "x" * _jinja._MAX_SOURCE_BYTES)
+    assert findings[0].code == "EG106"
+    assert "source exceeds" in findings[0].message
+
+
+def test_resource_limits_unavailable_fail_closed(monkeypatch):
+    import sys
+    from dayamlchecker import _jinja
+
+    monkeypatch.setitem(sys.modules, "resource", None)
+    with pytest.raises(_jinja.JinjaRenderError, match="requires Unix resource limits"):
+        _jinja._set_resource_limits()
+
+
+def test_darwin_skips_unsupported_address_space_limit(monkeypatch):
+    import resource
+    from dayamlchecker import _jinja
+
+    applied = []
+    monkeypatch.setattr(_jinja.sys, "platform", "darwin")
+    monkeypatch.setattr(resource, "getrlimit", lambda kind: (0, resource.RLIM_INFINITY))
+    monkeypatch.setattr(
+        resource, "setrlimit", lambda kind, limits: applied.append(kind)
+    )
+    _jinja._set_resource_limits()
+    assert resource.RLIMIT_AS not in applied
+    assert applied == [resource.RLIMIT_CPU, resource.RLIMIT_FSIZE]
diff --git a/tests/test_yaml_structure.py b/tests/test_yaml_structure.py
index 0daf284..570d168 100644
--- a/tests/test_yaml_structure.py
+++ b/tests/test_yaml_structure.py
@@ -3201,6 +3201,18 @@ def test_attachment_level_skip_undefined_suppresses_error(self):
             f"Did not expect attachment content error with attachment-level skip undefined, got: {errs}",
         )
 
+    def test_null_mako_value_is_reported_not_raised(self):
+        # MakoTemplate raises RuntimeException on a non-string, which used to
+        # escape as an unhandled error and end the whole run.
+        for key in ("question", "subquestion"):
+            with self.subTest(key=key):
+                source = f"id: q\nquestion: Hi\n{key}:\nfields:\n  - Name: name\n"
+                errs = find_errors_from_string(source, input_file="<string_valid>")
+                self.assertFalse(
+                    _has_code(errs, "EG111") or _has_code(errs, "EG112"),
+                    f"A null value has no Mako to report on, got: {errs}",
+                )
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_yaml_structure_cli.py b/tests/test_yaml_structure_cli.py
index b091921..fbaefbb 100644
--- a/tests/test_yaml_structure_cli.py
+++ b/tests/test_yaml_structure_cli.py
@@ -1,6 +1,7 @@
 import io
 import sys
 from contextlib import redirect_stdout
+from dataclasses import replace
 from pathlib import Path
 from tempfile import TemporaryDirectory
 
@@ -80,6 +81,32 @@ def test_github_finding_format_is_unchanged(capsys):
     )
 
 
+def test_github_annotation_for_rendered_jinja_stays_resolvable(capsys):
+    # GitHub drops an annotation whose file it cannot resolve, so the path must
+    # stay real. Generated line numbers are not lines of that file, so they
+    # belong in the message rather than in the annotation's anchor.
+    finding = replace(
+        make_finding(
+            MessageId.ACCESSIBILITY_YESNO_SHORTCUT,
+            file_name="docassemble/AssemblyLine/data/questions/al_question_test.yml",
+            line_number=125,
+            shortcut="yesno",
+        ),
+        rendered_jinja=True,
+    )
+
+    print_github_annotation(finding)
+
+    assert capsys.readouterr().out == (
+        "::error "
+        "file=docassemble/AssemblyLine/data/questions/al_question_test.yml,"
+        "title=EA510::"
+        "[rendered Jinja line 125] "
+        "screen uses `yesno` question shorthand; prefer `fields` with an explicit "
+        "datatype\n"
+    )
+
+
 def test_collect_yaml_files_recurses_directories_and_dedupes():
     with TemporaryDirectory() as tmp:
         root = Path(tmp)