System checks

Module summary

next.dj contributes Django system checks for every subsystem. Run them through uv run python manage.py check and the framework reports configuration mistakes with a code and a hint.

Check registration

next.checks.register_all runs during AppConfig.ready. It imports each subsystem checks module so the @register side effects take effect. The imported modules are next.conf.checks, next.pages.checks, next.urls.checks, next.components.checks, and next.forms.checks. The list continues with next.static.checks, next.partial.checks, and next.apps.checks.

Each of these modules registers checks. The dependency injection layer contributes no Django system checks.

Every next.dj check carries the next tag. Run uv run python manage.py check --tag next to execute only the framework checks and skip the built-in Django and third-party ones. Checks that also concern templates or URL patterns keep their Django tags (templates, urls) alongside next, so filtering by those tags still reaches them. A tagged run reports what a full run reports: every check that reads registrations discovers the files declaring them itself, rather than relying on a URL check having expanded the router first.

next.checks.reset_check_caches drops every per-run check cache so the next run rebuilds from the current sources. The cached state covers the router and components managers, the composed-pages memo, the collected URL patterns, the page module memo, and the context registry. Most of these caches also clear on settings_reloaded, which a NEXT_FRAMEWORK change through override_settings triggers. Tests and scripts that invoke checks directly and mutate the page or component tree in place call reset_check_caches explicitly, since the caches otherwise freeze the scanned state for the lifetime of the process.

Shared helpers

next.checks.common holds helpers reused across subsystem check modules. It is imported indirectly by those modules rather than by register_all.

Shared helpers used by per-subpackage system-check modules.

exception next.checks.common.PageRootsError

A router failed to report usable page trees.

A raised failure travels as __cause__, so the check that reports it names the cause while every other reader takes the empty list.

next.checks.common.errors_for_unknown_keys(config: dict[str, Any], *, allowed: frozenset[str], prefix: str) → list[CheckMessage]

Return an Error list when config contains keys outside allowed.

next.checks.common.first_visit(path: Path, seen: set[Path]) → bool

Whether path is reached for the first time, recording it when it is.

The identity is the resolved path, so two spellings of one file count once.

next.checks.common.get_components_manager() → ComponentsManager

Return a per-run cached ComponentsManager holding every component source.

The manager is the checks’ own, because the live registry holds only what requests have already made the router walk. Invalidated like get_router_manager.

next.checks.common.get_page_roots(router: RouterBackend) → list[PageRoot]

Return every page tree router reports, duplicates and all, in router order.

A router that raises or answers the wrong shape reports none here. One check calls read_page_roots directly and turns that failure into a message, so the run reports it once instead of once per reader.

next.checks.common.get_pages_directories(router: RouterBackend) → list[Path]

Return every pages root a scanning check walks once, in router order.

A tree mounted twice is scanned once, keyed on the resolved path because a symlinked tree has several spellings, and reported under the spelling the router used because the page registries key on that path.

next.checks.common.get_router_manager() → tuple[RouterManager | None, list[CheckMessage]]

Return a per-run cached RouterManager or initialisation errors.

The cache is dropped only on settings_reloaded (a NEXT_FRAMEWORK change, which override_settings triggers) or an explicit reset_check_caches, so changes to other router inputs (for example INSTALLED_APPS) need a reset.

next.checks.common.import_backend_class(dotted_path: str) → type[Any]

Import a dotted backend path, folding any import-time failure into ImportError.

A backend module runs arbitrary code at import, and a check that lets it raise takes the whole run down instead of reporting one error.

next.checks.common.iter_page_tree_component_folders(router: RouterBackend) → Iterator[tuple[Path, Path, str]]

Yield (folder, tree_root, route_trail) per components folder in the trees.

The walk, the skip set and the folder name are the router’s own, so a check discovers the folders that walk registers and no others.

next.checks.common.iter_scanned_page_pairs(router: RouterBackend) → Iterator[tuple[str, Path]]

Yield (url_path, page_file) for every page under the trees router routes.

The walk is the framework’s own, not the backend’s, so a backend that reports its trees through page_roots is checked whatever it routes from.

next.checks.common.page_tree_skip_names(router: RouterBackend) → frozenset[str]

Return the directory names a walk of router’s page trees does not enter.

Both halves are that router’s own answers, so the check walk refuses exactly what the router refuses, never a name another PAGE_BACKENDS entry declared for a tree this router does not serve.

next.checks.common.read_page_roots(router: RouterBackend) → list[PageRoot]

Return the page trees router reports, raising PageRootsError on failure.

page_roots is third-party code that can raise anything and answer any shape, and a check run has to survive both with a message rather than a traceback, so either outcome becomes one framework exception the callers handle narrowly.

next.checks.common.reset_components_manager_cache(**kwargs) → None

Drop the cached ComponentsManager so the next check run rebuilds it.

next.checks.common.reset_router_manager_cache(**kwargs) → None

Drop the cached RouterManager and everything read off its routers.

The scans and the contract answers belong to routers this manager owns, so they go with it.

Subsystem checks

Pages

System checks for the pages subsystem.

next.pages.checks.check_context_functions(*args, **kwargs) → list[CheckMessage]

Require keyless @context callables to return a dict when invoked.

next.pages.checks.check_context_processor_signature(*args, **kwargs) → list[CheckMessage]

Warn when a configured context processor has no request parameter.

next.pages.checks.check_context_registration_files(*args, **kwargs) → list[CheckMessage]

Flag a @context no page render collects (next.E074).

A registration keys on the file declaring the callable, so decorating an imported helper binds it to that helper’s module, and decorating a callable from a sibling page.py binds it to that other page.

next.pages.checks.check_layout_templates(*args, **kwargs) → list[CheckMessage]

Check layout.djx files for the {% block template %} structure.

next.pages.checks.check_page_functions(*args, **kwargs) → list[CheckMessage]

Validate each page module for render or template. Warn when empty.

next.pages.checks.check_page_module_imports(*args, **kwargs) → list[CheckMessage]

Report page.py files that raise while importing (next.E017).

The message carries the recorded cause, so an ImportError raised by the module body is named as such instead of masking as a missing body.

next.pages.checks.check_pages_structure(*args, **kwargs) → list[CheckMessage]

Check each router’s pages tree for layouts, naming, and structure.

next.pages.checks.check_request_in_context(*args, **kwargs) → list[CheckMessage]

Ensure request is in the template context (required for {% form %}).

next.pages.checks.check_single_keyless_context(*args, **kwargs) → list[CheckMessage]

Flag a page.py with more than one keyless @context (next.E018).

Keyless callables share one slot, so only the last survives and runs.

next.pages.checks.check_template_loaders(*args, **kwargs) → list[CheckMessage]

Validate every NEXT_FRAMEWORK[‘TEMPLATE_LOADERS’] entry.

next.pages.checks.check_unrouted_working_directory_pages(*args, **kwargs) → list[CheckMessage]

Warn when a pages tree beside the process is routed by nobody (next.W002).

A project that lists no root in DIRS keeps writing pages under a directory the router never reaches, and the pages are never served. Nothing else reports that, because the checks walk the trees the routers report and this one is not among them.

URLs

System checks for the URL routing subsystem.

next.urls.checks.check_next_pages_configuration(*args, **kwargs) → list[CheckMessage]

Validate PAGE_BACKENDS inside merged NEXT_FRAMEWORK.

next.urls.checks.check_reverse_name_collisions(*args, **kwargs) → list[CheckMessage]

Fail when two distinct routes collapse to the same reverse URL name.

next.urls.checks.check_url_patterns(*args, **kwargs) → list[CheckMessage]

Collect patterns from routers and flag duplicate Django path strings.

next.urls.checks.reset_collected_patterns_cache(**kwargs) → None

Drop memoised collected patterns so the next check run recollects.

Components

System checks for the components subsystem.

next.components.checks.check_component_context_registration_files(*args, **kwargs) → list[CheckMessage]

Flag a @component.context no component render collects (next.E075).

A registration keys on the file declaring the callable, so decorating an imported helper binds it to that module, and decorating a callable from a sibling component.py binds it to that other component.

next.components.checks.check_component_py_no_pages_context(*args, **kwargs) → list[CheckMessage]

Check that component.py files do not use context from next.pages.

next.components.checks.check_cross_root_component_name_conflicts(*args, **kwargs) → list[CheckMessage]

Reject a root-scope name that only registration order resolves.

next.components.checks.check_duplicate_component_names(*args, **kwargs) → list[CheckMessage]

Check that no two components share a name within one route scope.

The scope is the pair the resolver scores on, so the same name under two route trails of one tree is the documented override rather than a clash.

next.components.checks.check_next_components_configuration(*args, **kwargs) → list[CheckMessage]

Validate COMPONENT_BACKENDS shape in merged NEXT_FRAMEWORK.

Forms

System checks for the forms subsystem.

next.forms.checks.check_action_applied_to_class(*args, **kwargs) → list[CheckMessage]

Error when @action decorator was applied to a class.

next.forms.checks.check_action_guard_permissions(*args, **kwargs) → list[CheckMessage]

Warn when permission_required is declared without django.contrib.auth.

This inspects the static ActionGuard only. The dynamic check_permissions and has_object_permission hooks run application code per request and are not statically inspectable, so no check covers them.

next.forms.checks.check_component_widget_components(*args, **kwargs) → list[CheckMessage]

Warn when a ComponentWidget names a component that does not resolve.

next.forms.checks.check_component_widget_field_types(*args, **kwargs) → list[CheckMessage]

Warn when a ComponentWidget is attached to an unsupported field type.

next.forms.checks.check_form_action_backends_configuration(*args, **kwargs) → list[CheckMessage]

Validate FORM_ACTION_BACKENDS shape and import paths.

next.forms.checks.check_form_action_collisions(*args, **kwargs) → list[CheckMessage]

Flag two @action calls that share a name but come from different handlers.

next.forms.checks.check_form_anchor_files(*args, **kwargs) → list[CheckMessage]

Validate that FORM_ANCHOR_FILES is None or a collection of strings.

next.forms.checks.check_form_wizard_backend(*args, **kwargs) → list[CheckMessage]

Validate FORM_WIZARD_BACKEND shape and import path.

next.forms.checks.check_form_wizard_sessions(*args, **kwargs) → list[CheckMessage]

Warn when wizard storage needs sessions without django.contrib.sessions.

next.forms.checks.check_form_wizard_steps(*args, **kwargs) → list[CheckMessage]

Error when a FormWizard declares no steps.

next.forms.checks.check_forms_outside_base_dir(*args, **kwargs) → list[CheckMessage]

Warn when form classes are declared outside BASE_DIR.

next.forms.checks.check_instance_from_url_on_non_model_form(*args, **kwargs) → list[CheckMessage]

Error when Meta.instance_from_url is set on a class that is not a ModelForm.

next.forms.checks.check_instance_from_url_unknown_field(*args, **kwargs) → list[CheckMessage]

Error when Meta.instance_from_url references a field absent on the model.

next.forms.checks.check_invalid_form_meta_scope(*args, **kwargs) → list[CheckMessage]

Error when a form class Meta.scope or an @action scope is invalid.

next.forms.checks.check_shared_action_name_collisions(*args, **kwargs) → list[CheckMessage]

Error when one shared action name is declared by two different modules.

next.forms.checks.check_success_message_framework(*args, **kwargs) → list[CheckMessage]

Warn when Meta.success_message is declared without the messages framework.

next.forms.checks.check_wizard_step_actions(*args, **kwargs) → list[CheckMessage]

Warn when a wizard step class is also a registered standalone action.

Only static Meta.steps are inspected, get_steps dynamics are not visible.

next.forms.checks.check_wizard_step_field_collisions(*args, **kwargs) → list[CheckMessage]

Warn when two static wizard steps declare the same field name.

Only static Meta.steps are inspected, get_steps dynamics are not visible.

next.forms.checks.check_wizard_step_file_fields(*args, **kwargs) → list[CheckMessage]

Warn when a static wizard step declares a FileField or ImageField.

Only static Meta.steps are inspected, get_steps dynamics are not visible.

next.forms.checks.check_wizard_url_param_route(*args, **kwargs) → list[CheckMessage]

Error when a page-scoped wizard’s page path lacks the url_param segment.

Only wizards declared in a page module are inspected. The page file path maps one to one onto the route, so a missing segment is a definite misconfiguration. Wizards declared in shared or component modules have no statically known route and are skipped.

Static

System checks for the static subsystem.

All identifiers live in the next.* namespace to avoid collisions with Django core checks.

next.static.checks.check_static_backends(**kwargs) → list[CheckMessage]

Validate the structure of NEXT_FRAMEWORK[‘STATIC_BACKENDS’].

next.static.checks.check_asset_kinds_are_loadable(*args, **kwargs) → list[CheckMessage]

Warn about a registered kind the partial runtime cannot insert.

next.static.checks.check_inline_asset_bodies_are_loadable(*args, **kwargs) → list[CheckMessage]

Warn about a kind whose inline bodies the partial runtime cannot insert.

next.static.checks.check_reserved_js_context_keys(*args, **kwargs) → list[CheckMessage]

Warn about a page or component context key the init payload reserves.

Pages and components feed the same init payload, so both registries are walked against the reserved namespace.

next.static.checks.check_js_context_serializer(*args, **kwargs) → list[CheckMessage]

Validate that JS_CONTEXT_SERIALIZER resolves to a protocol implementation.

Partial rendering

System checks for the partial-rendering subsystem.

This module is excluded from coverage like every other area checks.py. The zone checks read the same compiled page templates the renderer uses, so a misconfigured zone is caught at manage.py check time rather than on a partial request.

next.partial.checks.check_composed_templates_compile(*args, **kwargs) → list[CheckMessage]

Error when a composed page template fails to compile (next.E072).

The zone checks skip a page whose composed template does not compile, so without this check the syntax error would surface only as a 500 on the first request to the page.

next.partial.checks.check_custom_patch_ops_well_formed(*args, **kwargs) → list[CheckMessage]

Error when a custom patch verb is malformed or shadows a built-in (next.E066).

The runtime guard in Patches.op() rejects an unregistered verb on every call. This check turns the registry side of that contract into a startup error: a verb registered with a non-token name or one that silently shadows a built-in verb is caught at manage.py check rather than only when an op of that name reaches a client.

next.partial.checks.check_duplicate_zone_names(*args, **kwargs) → list[CheckMessage]

Error when two zones in one composed page share a name (next.E060).

next.partial.checks.check_form_backend_partial_aware(*args, **kwargs) → list[CheckMessage]

Warn when partial rendering is on but a form backend is not aware (next.W068).

The base FormActionBackend.shape_response routes partial requests to the patch shaping path. A custom backend that overrides shape_response without that branch would silently drop the patch envelope and serve a full page to the runtime. The check stays silent on the default backend, which inherits the partial-aware method.

next.partial.checks.check_lazy_zone_has_placeholder(*args, **kwargs) → list[CheckMessage]

Error when a lazy zone declares no {% placeholder %} (next.E064).

next.partial.checks.check_manifest_version_has_manifest_storage(*args, **kwargs) → list[CheckMessage]

Warn when manifest versioning has no manifest storage (next.W069).

The VERSION: “manifest” option asks the version stamp to track the staticfiles manifest, so a deploy of new assets bumps the version and the client reloads. That guard is silent unless the active staticfiles storage hashes its files into a manifest. The check pairs with the runtime fallback that resolves the sentinel to a stable default when no manifest storage is configured, surfacing the dead guard at startup.

next.partial.checks.check_no_zone_in_component(*args, **kwargs) → list[CheckMessage]

Error when a component template declares a zone (next.E065).

next.partial.checks.check_partial_backend_names_a_path(*args, **kwargs) → list[CheckMessage]

Error when a PARTIAL_BACKENDS entry omits its BACKEND key (next.E073).

Such an entry falls back to the default protocol backend, so the intended wire format would silently never load. The check names the entry that lacks a dotted path at startup instead.

next.partial.checks.check_repeated_form_has_key(*args, **kwargs) → list[CheckMessage]

Warn when a looped {% form %} has no key or zone (next.W070).

next.partial.checks.check_single_partial_backend(*args, **kwargs) → list[CheckMessage]

Warn when more than one partial protocol backend is configured (next.W071).

Partial rendering uses a single protocol backend. Only the first valid PARTIAL_BACKENDS entry is instantiated, so a second entry is dead config that silently never runs.

next.partial.checks.check_with_directly_over_zone(*args, **kwargs) → list[CheckMessage]

Warn when a {% with %} wraps a zone directly (next.W067).

next.partial.checks.check_zone_name_is_slug(*args, **kwargs) → list[CheckMessage]

Error when a zone name is not an ASCII slug (next.E061).

next.partial.checks.check_zone_not_in_if(*args, **kwargs) → list[CheckMessage]

Error when a zone sits inside an {% if %} block (next.E063).

next.partial.checks.check_zone_not_in_loop(*args, **kwargs) → list[CheckMessage]

Error when a zone sits inside a {% for %} loop (next.E062).

next.partial.checks.reset_composed_pages_memo(**kwargs) → None

Drop the memoised composed-page list for the next check run.

Identity against the router manager already invalidates the memo when the manager is rebuilt. Call this explicitly after editing a .djx in place under a live manager, since settings_reloaded only fires when NEXT_FRAMEWORK itself changes.

Apps

System checks for next-dj template engine wiring.

The next-dj tags install only into a DjangoTemplates backend and only through the explicit builtin tuple. A project missing either one gets a warning here instead of a missing-tag error at render time.

next.apps.checks.check_builtin_tag_libraries_complete(*args, **kwargs) → list[CheckMessage]

Warn when a tag library is not registered as a builtin (next.W063).

The builtin registration list is the explicit _BUILTIN_MODULES tuple. A tag library module added under next.templatetags but left out of that tuple installs into no engine, so its tags silently fail to load. This check pairs the explicit list with a completeness probe over the modules that exist on disk.

next.apps.checks.check_django_templates_backend_present(*args, **kwargs) → list[CheckMessage]

Warn when no DjangoTemplates engine carries the next-dj tags.

Configuration

System checks for the configuration layer.

Unknown top-level keys are reported as next.E035, values whose type the settings merge would silently discard as next.E076, a NEXT_FRAMEWORK that is no dict at all as next.E077, and non-bool values for bool flags as next.W072.

next.conf.checks.check_next_framework_unknown_top_level_keys(*args, **kwargs) → list[CheckMessage]

Reject keys under NEXT_FRAMEWORK that are not defined in defaults.

next.conf.checks.check_next_framework_value_types(*args, **kwargs) → list[CheckMessage]

Report NEXT_FRAMEWORK values whose type the merge would silently drop.

A NEXT_FRAMEWORK that is no dict is next.E077 on its own and skips the per-key probes, which have nothing to index into. It carries its own id because silencing the noise from one mistyped key must not silence “the whole setting is ignored”.

Dependency injection

The dependency injection layer does not contribute Django system checks. There is no next.ENNN code for a missing provider or a bad marker graph.

Note

Expect misconfiguration at runtime. Unresolved parameters become None, and cycles raise DependencyCycleError. Troubleshooting lives in Dependency injection and Troubleshooting.

Check code reference

The codes follow the Django convention next.X<NNN> where X is E for errors and W for warnings.

Errors

Code	Condition	Emitted by
next.E001	NEXT_FRAMEWORK is not a dict, or PAGE_BACKENDS is not a list.	next.urls.checks
next.E002	A PAGE_BACKENDS or COMPONENT_BACKENDS entry is not a dict.	next.urls.checks, next.components.checks
next.E003	A page backend entry does not specify BACKEND.	next.urls.checks
next.E004	A page backend entry names an unknown backend.	next.urls.checks
next.E005	The file router APP_DIRS value is not a boolean.	next.urls.checks
next.E006	The file router DIRS or OPTIONS has the wrong shape or an unknown key.	next.urls.checks
next.E007	The router manager fails to initialize.	next.checks.common
next.E008	A [param] directory uses invalid parameter syntax.	next.pages.checks
next.E009	A [[args]] directory uses invalid or incomplete args syntax.	next.pages.checks
next.E010	A parameter directory is missing its page.py file.	next.pages.checks
next.E011	An error was raised while checking page functions.	next.pages.checks
next.E012	A page.py has no body source: no render function, no template attribute, no loader match, and no sibling layout.djx.	next.pages.checks
next.E013	A page render attribute is not callable.	next.pages.checks
next.E014	An error was raised while checking URL conflicts.	next.urls.checks
next.E015	The same URL pattern is defined in more than one location.	next.urls.checks
next.E016	An error was raised while collecting patterns from a router.	next.urls.checks
next.E017	A page.py raises while importing. The message names the recorded exception type and text, so an ImportError raised by the module body reads as such instead of masking as a missing body source. The body-source checks next.E012, next.E013, and next.W043 stay silent for that file, so the import failure surfaces once.	next.pages.checks
next.E018	A page.py registers more than one keyless @context callable, and only the last one runs.	next.pages.checks
next.E019	request is missing from the template context (required for {% form %} and CSRF).	next.pages.checks
next.E020	A component name is registered more than once under one route scope, so nothing tells the two apart.	next.components.checks
next.E021	A component.py reaches for the page context decorator instead of the component one, under any spelling: next.pages, the next package root, or next.page.context.	next.components.checks
next.E022	PAGE_BACKENDS is empty.	next.urls.checks
next.E023	COMPONENT_BACKENDS is not a list.	next.components.checks
next.E024	A file router entry is missing PAGES_DIR.	next.urls.checks
next.E025	A file router entry is missing APP_DIRS.	next.urls.checks
next.E026	A file router entry is missing OPTIONS.	next.urls.checks
next.E027	A COMPONENTS_DIR or PAGES_DIR value is not a string.	next.components.checks, next.urls.checks
next.E028	A route repeats one or more bracket parameter names, all listed in the error.	next.urls.checks
next.E029	A keyless @context callable is not annotated as returning a dict. The check reads the context registry, so it catches @context, @page.context, an aliased import, and async def alike.	next.pages.checks
next.E030	An error was raised while checking router pages. A router whose page_roots raises, or answers something other than PageRoot entries, is named here once, with the exception text, and reports no tree to any other check. The run continues, so a third-party backend that cannot reach its source costs its own trees instead of ending manage.py check with a traceback. This is also the one place in the run that logs that traceback, so the message is not buried under a copy per check that asked.	next.pages.checks
next.E031	A component backend entry is missing a required key.	next.components.checks
next.E032	A component backend BACKEND or DIRS value has the wrong type, or BACKEND does not import as a ComponentsBackend subclass.	next.components.checks
next.E033	COMPONENT_BACKENDS is empty.	next.components.checks
next.E034	A component name sits at the root scope of two roots the same template resolves against, with neither taking precedence.	next.components.checks
next.E035	A configuration dict has unknown keys.	next.checks.common
next.E036	A static backend dotted path fails to import.	next.static.checks
next.E037	A static backend entry is not a dict, or the class is not a StaticBackend subclass.	next.static.checks
next.E038	STATIC_BACKENDS contains a duplicate BACKEND entry.	next.static.checks
next.E039	Two distinct routes collapse to the same reverse URL name after separator normalisation.	next.urls.checks
next.E040	A configured context processor does not accept a request parameter.	next.pages.checks
next.E041	A form action name is registered by more than one handler.	next.forms.checks
next.E042	A TEMPLATE_LOADERS entry is not a dotted-path string.	next.pages.checks
next.E043	A TEMPLATE_LOADERS entry cannot be imported or is not a TemplateLoader subclass.	next.pages.checks
next.E044	A form action backend entry has the wrong shape or cannot be imported.	next.forms.checks
next.E045	A form action backend class does not subclass FormActionBackend.	next.forms.checks
next.E046	One shared action name is declared in two different modules, so bare-name lookups resolve to whichever module imported first. Rename one class or set Meta.scope.	next.forms.checks
next.E047	A form class Meta.scope or an @action scope keyword is set to a value other than "page" or "shared".	next.forms.checks
next.E048	Meta.instance_from_url references a field name that does not exist on the model.	next.forms.checks
next.E049	Meta.instance_from_url is set on a class that is not a ModelForm subclass.	next.forms.checks
next.E050	A FormWizard declares no Meta.steps or an empty list.	next.forms.checks
next.E051	FORM_WIZARD_BACKEND is malformed, non-importable, or names a class that does not subclass FormWizardBackend.	next.forms.checks
next.E052	FORM_ANCHOR_FILES is not None or a list of strings.	next.forms.checks
next.E053	@action was applied to a class instead of a function.	next.forms.checks
next.E054	A page-scoped FormWizard is declared on a page whose route lacks the [url_param] segment, so the wizard can never advance past its first step.	next.forms.checks
next.E060	A zone name is declared more than once in a page’s composed template, the layout chain plus the page body.	next.partial.checks
next.E061	A zone name is not an ASCII slug, so it cannot travel in the latin-1 X-Next-Zone header.	next.partial.checks
next.E062	A {% zone %} sits inside a {% for %} loop, which a standalone zone render cannot reproduce.	next.partial.checks
next.E063	A {% zone %} sits inside an {% if %} block, whose condition a standalone zone render cannot evaluate.	next.partial.checks
next.E064	A lazy= zone declares no {% placeholder %} branch to show until its body arrives.	next.partial.checks
next.E065	A component template declares a {% zone %} tag, which belongs to a page or layout.	next.partial.checks
next.E066	A custom patch op shadows a built-in verb or uses a name that is not a valid verb token.	next.partial.checks
next.E067	NEXT_FRAMEWORK['PARTIAL_BACKENDS'] is not a list, so the value is ignored and the default protocol backend loads in place of the configured one.	next.partial.checks
next.E072	A composed page template does not compile, so the syntax error would otherwise surface only as a 500 on the first request to the page.	next.partial.checks
next.E073	A PARTIAL_BACKENDS entry has no BACKEND key, so the entry would fall back to the default protocol backend and the intended wire format would never load.	next.partial.checks
next.E074	A @context registration binds to a file no page render collects. A registration keys on the file declaring the callable, so decorating an imported helper binds it to the helper’s module, and decorating a callable imported from a sibling page.py binds it to that other page. Declare the callable in the page.py that needs it and let it call the shared helper.	next.pages.checks
next.E075	A @component.context registration binds to a file no component render collects. The rule and the fix match next.E074. The check covers the configured component roots and the _components folders the page trees carry, which it discovers through the same walk the router uses.	next.components.checks
next.E076	A NEXT_FRAMEWORK value has a type the settings merge silently drops in favour of the framework default. The check covers PAGE_BACKENDS, COMPONENT_BACKENDS, STATIC_BACKENDS, PARTIAL_BACKENDS, and TEMPLATE_LOADERS as lists. It also covers URL_NAME_TEMPLATE and URL_RESOLVER as strings and NEXT_JS_OPTIONS as a dict.	next.conf.checks
next.E077	NEXT_FRAMEWORK is not a dict, so the settings layer ignores it entirely and the project runs on the framework defaults. It carries its own code rather than sharing next.E076, so silencing the noise from one mistyped key never silences this one. The per-key probes are skipped, because there is nothing to index into.	next.conf.checks

A code emitted by next.checks.common is produced by a shared helper that the listed subsystem check modules call.

Warnings

Code	Condition	Emitted by
next.W001	A layout.djx is missing the required {% block template %}.	next.pages.checks
next.W002	A directory named by PAGES_DIR sits beside the working directory, holds pages, and no configured router routes it, so nothing under it is served. Name the directory in PAGE_BACKENDS DIRS, or turn that entry’s APP_DIRS off, which routes BASE_DIR over PAGES_DIR when DIRS names no root. The tree is not walked by the page checks, so its contents raise no next.E010, next.E012, or next.E017. This one warning stands for all of them.	next.pages.checks
next.W030	STATIC_BACKENDS is empty, so the framework falls back to StaticFilesBackend.	next.static.checks
next.W031	An OPTIONS tag template is missing the {url} placeholder.	next.static.checks
next.W042	JS_CONTEXT_SERIALIZER is set but does not resolve to a usable serializer.	next.static.checks
next.W043	A page.py declares more than one body source and the lower-priority ones are ignored.	next.pages.checks
next.W046	A form class is declared in a file outside BASE_DIR and will not be registered automatically.	next.forms.checks
next.W054	A ComponentWidget names a component that does not resolve.	next.forms.checks
next.W055	A ComponentWidget is attached to a FileField or MultiValueField, which it does not support.	next.forms.checks
next.W056	Wizards are registered and the configured wizard backend needs Django sessions to store steps, but django.contrib.sessions is not installed.	next.forms.checks
next.W057	A static Meta.steps form class is also registered as a standalone form action.	next.forms.checks
next.W058	A static Meta.steps form declares a FileField or ImageField, whose uploads do not survive the wizard draft storage between requests.	next.forms.checks
next.W059	Two static wizard steps declare the same field name, so get_all_cleaned_data() keeps only the last value.	next.forms.checks
next.W060	A form action declares permission_required while django.contrib.auth is not in INSTALLED_APPS.	next.forms.checks
next.W061	A form action declares Meta.success_message while the messages framework is not fully installed, so a valid submission raises MessageFailure.	next.forms.checks
next.W062	No DjangoTemplates engine is configured, so the framework {% %} tags cannot install.	next.apps.checks
next.W063	A tag library under next.templatetags is not listed as a builtin, so its tags never install.	next.apps.checks
next.W067	A {% zone %} is a direct child of a {% with %} block, whose bindings a standalone zone render cannot see.	next.partial.checks
next.W068	A form action backend overrides shape_response while PARTIAL_BACKENDS is configured, so it may drop the patch envelope.	next.partial.checks
next.W069	A partial backend sets VERSION: "manifest" while the staticfiles storage does not hash files, so the version guard stays silent.	next.partial.checks
next.W070	A {% form %} renders directly inside a {% for %} of a composed page without a key= or a zone=, so a partial morph cannot tell the repeated instances apart. The check does not descend into a component template, so a looped {% component %} that holds the form is not flagged. Thread a key= into the form to keep the repeated morph correct.	next.partial.checks
next.W071	PARTIAL_BACKENDS has more than one entry. Partial rendering uses a single protocol backend, so only the first entry runs and the rest are ignored.	next.partial.checks
next.W072	A NEXT_FRAMEWORK bool key, STRICT_CONTEXT, STRICT_LOADING, LAZY_COMPONENT_MODULES, or FORM_AUTODISCOVER, holds a non-bool value. The bool() coercion turns a falsy-looking string such as 'False' into True, so the written value can mean the opposite of the intent.	next.conf.checks
next.W074	A registered asset kind names a renderer outside render_link_tag, render_script_tag, and render_module_tag, so it carries no client insertion verb. Assets of that kind reach the browser only on a full page render, never through a patch envelope.	next.static.checks
next.W075	A page or a component registers a keyed serialize=True context under a name the next.min.js init payload reserves, $csrf or $dev. The framework owns those names on every render, so the registered value never reaches window.Next.context and no context patch updates it. The message names the declaring page.py or component.py and asks for a rename. A keyless serialize=True provider spreads the keys of the dict it returns at render time, so the check never sees them.	next.static.checks
next.W076	A registered asset kind names one of the three bundled renderers together with an inline_tag that is not the element that renderer’s verb builds. The URL form of such a kind travels in a patch envelope while its inline bodies carry no insertion verb and reach the browser only on a full page render. Pair render_link_tag with inline_tag="style" or render_script_tag with inline_tag="script".	next.static.checks

Note

Codes are assigned per check and are not contiguous. Inspect the source of each subsystem module above for the exact message text and trigger conditions.

See also

See also

Installation for the first manage.py check run. Troubleshooting for symptoms that map to individual next.* codes.