Diagnostic codes

Every diagnostic a pherolang surface emits carries a stable string code. The codes live in one place — the phero-diagnostics crate — and this page is generated from that registry: a new code is a table row in phero-diagnostics, never a local constant. Two schemes are registered side by side: the numeric bands (E#### errors, W#### warnings, X#### cross-surface integrity) are surface-local, human-facing codes the CLI prints, while the driver’s camelCase names are payload-carrying LSP diagnostic codes (phero_driver::DiagnosticCode); both are first-class registry entries, cross-referenced by band. To allocate a code, claim (or find) your band in the ledger and add the constant plus its entry to the band module. Run pherolang explain <code> for one entry, or pherolang explain --list for everything.

Allocation ledger

Band	Range	Owner	Severity	Next free
ifml.resolver	E0001–E0099	phero-ifml resolver	error	E0010
ifml.check	E0100–E0149	phero-ifml typed checker	error	E0112
ifml.lints	W0150–W0199	phero-ifml lints	warning	W0155
driver.payload	camelCase names	phero-driver DiagnosticCode	error	n/a
driver.integrity	X0001–X0099	phero-driver integrity pass	error	X0009
dmn.check	E0200–E0299	phero-driver .dmn surface and .ddd decision links	error	E0255
driver.domain	E0300–E0349	phero-driver .mox domain-surface checks	error	E0302
driver.ddd	E0350–E0399	phero-driver .ddd lifecycle checks	error	E0361

Band ifml.resolver (E0001–E0099)

Code	Class	Title	Meaning	Fix
E0001	error	Import not provided	An .ifml import has no content in the IfmlImports bundle (imported ifml '<path>' was not provided).	Provide the import’s source in the IfmlImports bundle, keyed (importing path, import path as written).
E0002	error	Parse error	A file (main or imported) failed to parse; the message carries the parse error.	Fix the reported syntax error; pherolang fmt restores canonical layout.
E0003	error	Circular import	A circular .ifml import (circular ifml import involving '<path>').	Break the cycle — move the shared module into its own file and import it from both sides.
E0004	error	Ambiguous module	Two distinct imported files declare the same module name (ambiguous module '<name>' ...).	Rename one of the conflicting modules; main-file declarations shadow imports silently.
E0005	error	Duplicate module	One file declares the same module name twice (duplicate module '<name>').	Remove or rename the second declaration — the first one wins.
E0006	error	Unknown module	A use targets no declared module (unknown module '<name>').	Declare the module locally, or import the file that declares it.
E0007	error	Unknown input	An override matches neither an input parameter nor a module property (unknown input '<p>' for module '<m>').	Spell the input exactly as the module’s input { } block declares it.
E0008	error	Missing input	An input without a default receives no override (module '<m>' requires input '<p>').	Pass the required input at the use site, or give it a default in the module.
E0009	error	Input type mismatch	A literal override’s type contradicts the input’s declared type (input '<p>' of module '<m>' expects <ty>); structural check only — string literals suit String/Uuid/custom-identifier types, numbers suit Int/Float, booleans suit Boolean.	Use a literal of the declared type, or a non-literal expression (typed by the checker).

Band ifml.check (E0100–E0149)

Code	Class	Title	Meaning	Fix
E0100	error	Unknown data entity	A component’s data: entity does not resolve to exactly one class in the domain model (unknown data entity 'X', or ambiguous data entity 'X' when several packages declare the name).	Make the name unique in the domain union, or qualify it so exactly one (package, class) matches.
E0101	error	Type mismatch	An expression contradicts the type its site expects (expected <ty>, found <ty> in '<expr>'), or another phero-expr semantic rule fires (R1/R2/R4/R9/…), carried through verbatim.	Align the expression with the site’s expected type — docs/EXPRESSIONS.md rules R1–R4 pin the arithmetic, equality, and division behavior.
E0102	error	Unknown feature	Unknown feature or operation on a navigation path (phero-expr’s unknown feature ... / unknown operation ...), or an unknown or ambiguous bare package-function call, prefixed with site context.	Check the spelling against the entity’s features or the package function table — the did-you-mean hint names the closest declared one.
E0103	error	Unknown variable	A name that is not a view/container/module parameter, not a data: feature, and not an event parameter (unknown name 'x'), prefixed with site context.	Declare it as a parameter, read a feature of the component’s entity, or fix the spelling.
E0104	error	Unknown action reference	An action("X") invocation whose name resolves to no action "X" { target: ...; } declaration (action 'X' is not declared).	add action “X” { target: ; }
E0105	error	Unknown navigate target	A navigate("X") target that is neither a declared view nor a declared container (navigate target 'X' is not a declared view or container).	Declare the view or container, or spell the target as declared (wizard steps count as containers).
E0106	error	Unknown refresh target	A refresh("X") target that is not a declared component (refresh target 'X' is not a declared component).	Spell the target exactly as the component is declared.
E0107	error	Unknown capability	A requires: capability name no provided actor model declares (capability 'X' is not declared).	add “capability X on ;” to an actors block
E0108	error	Unknown role	A roles: name no provided actor model declares as an actor (role 'X' is not declared).	add “actor X;” to an actors block
E0109	error	Unknown action target	An action declaration’s target: entity does not resolve to exactly one class in the domain model (unknown target entity 'X', or ambiguous target entity 'X' when several packages declare the name) — the data: discipline applied to the lowering’s payload.	Point target: at a domain class that resolves to exactly one (package, class).
E0110	error	Decision service without outputs	A component’s data: names a decision service that declares no outputs (decision service 'X' declares no outputs) — the service exposes nothing, so the component has no data contract.	Declare at least one output decision on the service (outputs { ... }), or bind the component to a domain class.
E0111	error	Ambiguous decision service	A component’s data: names a decision service that two or more of the provided decision models declare (decision service 'X' is declared by two models — 'A' and 'B', … declared by multiple models — 'A', 'B' and 'C'); resolution is bare-name union-wide, so the reference is ambiguous. The models are named by their declared decision_model names (the checker receives artifacts, not paths).	Rename the service in one of the decision models, or bind the component to a domain class.

Band ifml.lints (W0150–W0199)

Code	Class	Title	Meaning	Fix
W0150	warning	Dead action	A main-file action "X" { ... } declaration no action("X") invocation names (action 'X' is declared but never invoked). References count anywhere in the compilation — an uninstantiated module’s invocation is still live intent — and only the main file’s declarations are judged, so pattern libraries never warn.	Invoke the action from an event handler, or delete the declaration.
W0151	warning	Unreachable view	A main-file view that is neither the first view (the entry view by position), nor landmark: true, nor reached by any navigate target anywhere in the compilation, and whose body carries no content — no components, containers, event handlers, or module uses (view 'X' is never navigated to ...). A content view is intentionally routed (the manifest exports every view as a route); the empty shell no navigation reaches is the dead-UI class.	Navigate to it from another view, mark it landmark: true, give it content, or delete it.
W0152	warning	Shadowed module	A main-file module declaration whose name equals an imported file’s module declaration (module 'X' shadows an imported module of the same name (from '<path>')). Resolution deliberately lets the local declaration win silently; the warning documents the shadowing at the winning declaration’s name.	Rename the local module (and its use sites), or drop it if the imported one is wanted.
W0153	warning	Component without data	A main-file component with no data: binding that also declares no event handlers, carries no chart (inline spec, chart reference, or type: chart), and spells no explicit Entity.field table column (<context> component 'X' binds no entity data) — a fully static placeholder. Interactive components wire their data flow through handlers; charts aggregate by construction; explicit-column tables use the generation-time Class.feature spelling — all exempt.	Bind data: <Entity>;, or leave as-is when the component is deliberately static.
W0154	warning	View without domain binding	A main-file view with no domain tie at all: no data: binding on any component (recursively through containers), no explicit Entity.field column references, no declared params, no module composition, no event handlers anywhere in its body, and no roles:/requires: policy gate (view 'X' has no domain binding ...). Views that bind nothing are placeholders — often leftovers from a deleted flow.	Bind data: on a component, declare params, compose a module, add the interactions — or delete the view.

Band driver.payload (camelCase names)

Code	Class	Title	Meaning	Fix
attributeWithClassType	error	Attribute with class type	feature '<feature>' has class type '<class>' — the author almost certainly meant contains or refers; the payload drives a two-way quick fix.	Replace the class type with contains <Class> (many) or refers <Class> (one) — the LSP offers both.
unknownCapability	error	Unknown capability	unknown capability '<capability>' on … — the name carries no resolution to a declared actor capability (pherolang#128’s J3, resolved at compile time); a did-you-mean suggestion is attached when one is close.	Declare the capability (capability X on <Class>; in an actors block), or rename the reference to the suggested declared name.
grantedCapabilityUncarried	error	Granted capability uncarried	capability '<capability>' is granted but no operation or search carries it — the granted capability guards a transition that cannot happen (pherolang#128’s J4, resolved at compile time); the fix lives in another file, so there is no local quick fix.	Carry the capability — add it to an operation or search across the designs — or drop the grant entry.

Band driver.integrity (X0001–X0099)

Code	Class	Title	Meaning	Fix
X0001	warning	Unknown operation capability	unknown capability '<capability>' on operation '<op>' of service '<service>' (or on search '<search>') — the capability clause names no capability declared in any provided actor block. Since pherolang#128 the compile-time join is the language error (code unknownCapability); this union-pass finding is the lint channel for hosts that gather artifacts without compiling.	Declare the capability (capability X on <Class>; in an actors block), or rename the reference to a declared capability.
X0002	warning	Granted capability uncarried	capability '<capability>' is granted but no operation or search carries it — the granted (or delegated) capability guards a transition that cannot happen. Since pherolang#128 the compile-time join is the language error (code grantedCapabilityUncarried); this union-pass finding is the lint channel.	Carry the capability — add it to an operation or search across the designs — or drop the grant entry.
X0003	error	Unknown emitted event	operation '<op>' of service '<service>' emits unknown event '<event>' — the emits clause is loosely coupled by design (the design compile has no event bucket), so the name resolves only across the artifact union.	Declare the event in an .evt contract, or fix the spelling.
X0004	error	Orphan declared event	event '<event>' is declared but no operation emits it — nothing produces the declared event, so it is dead weight. Channel publishes entries and subscription events [...] lists are consumption-side wiring and never satisfy production.	Emit the event from a service operation’s emits clause, or drop the declaration.
X0005	error	Unbound action	action '<action>' does not bind to any service operation — binding is ASCII-case-insensitive name equality (the PascalCase action ↔ camelCase operation mirror), and no operation carries the name. An unbound action is a button whose backend does not exist.	Name the action after the operation it drives (or the reverse), or add the operation to a design.
X0006	error	Ambiguous action binding	action '<action>' binds ambiguously to '<service.op>' and '<service.op>' — several operations across the designs share the action’s case-insensitive mirror name, so the binding names no unique backend (listing every carrier).	Rename the colliding operations so each action’s case-insensitive mirror names exactly one service operation.
X0007	error	Unknown subscription consumer	subscription '<subscription>' consumer '<consumer>' does not resolve to a declared component — a dead inbox: the events are published, but no deploy component receives them.	Declare the component in a deploy model (any application), or fix the consumer’s spelling.
X0008	error	Unknown flow actor reference	unknown capability or actor '<name>' in requires of view/command '<name>', or unknown actor '<name>' in roles of view '<name>' — the flow clause names neither a capability nor an actor the actor layer declares (roles: is strictly actors).	Declare the capability or actor in an actors block, or fix the spelling.

Band dmn.check (E0200–E0299)

Code	Class	Title	Meaning	Fix
E0200	error	Unknown type	unknown type '<type>' on <what> '<name>' — the element’s declared type (<what> is the element kind: input data, decision, knowledge-model parameter, …) names neither a FEEL builtin (string, number, boolean, date, …) nor a type the imported domain union declares.	Use a builtin type, import the domain that declares the type, or fix the spelling.
E0201	error	Unknown information requirement	unknown input or decision '<required>' required by decision '<requiring>' — the decision’s information requirement names neither a declared input-data element nor another decision in the decision-requirements graph, so the decision has no source for the input it consumes. Or '<requiring>' is not a decision; requirements are carried by decisions — requirement lines are always the decision’s perspective.	Declare the input data, point the requirement at a declared decision, or fix the spelling.
E0202	error	Unknown knowledge model	unknown knowledge model '<required>' invoked by decision '<requiring>' — the decision’s knowledge requirement names no declared business knowledge model, so the decision has no boxed logic to apply (the same shape fires at a logic invoke clause naming an unknown model). Or '<requiring>' is not a decision; requirements are carried by decisions.	Declare the knowledge model, or fix the spelling.
E0203	error	Unknown knowledge source	unknown knowledge source '<required>' governed by decision '<requiring>' — the decision’s authority requirement names no declared knowledge source; DMN models the authority behind a decision (a person, policy, or system) separately from the logic that computes it. Or '<requiring>' is not a decision; requirements are carried by decisions.	Declare the knowledge source, or fix the spelling.
E0204	error	Duplicate element name	duplicate <kind> '<name>' — two elements of the same kind (decision, input data, knowledge model, knowledge source, decision service) share one name; requirements resolve by name, so every reference to it is ambiguous.	Rename one of the elements and update the requirements that reference it.
E0205	error	Decision cycle	decision cycle: '<a>' -> '<b>' -> ... -> '<a>' — the information requirements form a cycle, so no decision in it can be evaluated first; the decision-requirements graph must stay acyclic (the message walks the whole loop).	Break the cycle — remove or redirect one requirement so the dependencies form a DAG.
E0206	error	Unknown decision-service endpoint	unknown <input/output/decision/knowledge model> '<name>' on decision service '<service>' — the decision service’s endpoint list names an element that is not declared; a service exposes decisions (and their inputs, outputs, and knowledge models) as one invocable unit.	Point the endpoint at an element the model declares, or fix the spelling.
E0207	error	Unknown view element	unknown element '<name>' in view '<view>' — the view’s element list names no declared element; a view is a decision service’s projection of the graph, so it can only show what exists.	Point the view at a declared element, or fix the spelling.
E0208	error	Invalid FEEL expression	invalid FEEL expression on <what> '<name>': <error> — the element’s FEEL expression (FEEL is DMN’s expression language for decision logic and table cells) failed to parse; the message carries the FEEL error verbatim. Conditional (if) expressions gate like every other expression: the pinned dsntk fork parser accepts the full DMN FEEL conditional grammar (the fork fix for dsntk-rs#14), so nothing is deferred.	Fix the reported FEEL error in the expression.
E0209	error	Decision table not provided	decision table "<path>" was not provided — the model references an external markdown decision table the host bundle carries no content for (the driver stays filesystem-free; tables ride in the imports bundle, like schema imports).	Provide the table’s markdown under its referenced path, or fix the path’s spelling.
E0210	error	Decision table error	decision table "<path>": <error> — the external markdown decision table was provided but could not be ingested (malformed table markdown, a hit policy the dialect does not support, …); the message carries the ingest error verbatim.	Fix the reported table error in the referenced markdown file.
E0211	error	Decision table input mismatch	decision table "<path>" input clause '<name>' is not a declared input of decision '<decision>', or decision table "<path>" is missing input clause '<name>' required by decision '<decision>' — the table’s input clauses and the decision’s declared inputs must match one-for-one; an extra clause reads data no decision provides, a missing one leaves an input unfed.	Align the table’s input clauses with the decision’s declared inputs — rename or drop the extra clause, add the missing one.
E0212	error	Decision table output mismatch	decision table "<path>" output clause '<name>' is not a declared output of decision '<decision>', or decision table "<path>" has <n> output clauses but decision '<decision>' declares <m> — the table’s output clauses and the decision’s declared outputs must match one-for-one.	Align the table’s output clauses with the decision’s declared outputs — rename or drop the extra clause, add the missing one.
E0213	error	Knowledge-model binding mismatch	unknown parameter '<param>' bound by decision '<decision>', decision '<decision>' does not bind parameter '<param>' of knowledge model '<model>', or parameter '<param>' bound twice by <what> '<name>' — an invocation (a decision’s or a knowledge model’s) must bind every parameter of the invoked knowledge model, and no others, exactly once, or the invocation cannot evaluate.	Bind exactly the knowledge model’s declared parameters — add the missing binding or drop the unknown one.
E0214	error	Duplicate metadata	duplicate '<word>' metadata — the same metadata word (description, owner, …) is declared twice on one element, so the element carries two values for one attribute.	Keep one occurrence of the metadata word and merge the values.
E0215	error	Unknown emitted event	unknown event '<event>' emitted by decision '<decision>' — the decision’s emits block names an event no provided .evt contract declares; the emitted names resolve union-wide against every provided event contract (the rule-10 pooling), and a .dmn that emits nothing provided is the loosely-coupled record (an empty events bucket with no .evt imports lowers the entries as authored, unchecked).	Declare the event in an imported .evt contract, import the contract that declares it, or fix the spelling.
E0250	error	Unknown invoked decision service	unknown decision service '<name>' invoked by operation '<op>' of service '<service>' — the .ddd application service’s operation invokes a decision service no provided .dmn model declares; the decision-link check joins the design against the decision surface.	Declare the decision service in a .dmn model, or fix the spelling.
E0251	error	Unknown injected decision service	unknown decision service '<name>' injected by service '<service>' — the .ddd application service injects a decision service no provided .dmn model declares; the decision-link check joins the design against the decision surface.	Declare the decision service in a .dmn model, or fix the spelling.
E0252	error	Pinned service version not available	decision service '<name>' is not provided at version "<pin>" invoked by <context> — the reference carries an exact version "X.Y.Z" pin (pherolang#154) and no provided model declares the service at that version. The help line names the versions the bucket’s same-name candidates declare (empty when none of them carries a strict X.Y.Z version metadata). The same failure shape fires on a .cmmn decision task with an exact pin — the CMMN side carries no numeric codes.	Pin a version a provided model declares (the help names them), import the model that declares it, or drop the pin.
E0253	error	Ambiguous service version	decision service '<name>' at version "<version>" is ambiguous invoked by <context>: provided by '<path>', '<path>' — two or more provided models declare the service at the same version (pherolang#154): for an exact pin, two candidates matching the pinned version; for version compatible, two candidates tying at the selected highest version. The message names every declaring model’s path.	Keep one model per version in the provided bucket, or pin a version only one of them declares.
E0254	error	No usable service version	decision service '<name>' declares no usable version invoked by <context> — the reference carries a version compatible pin (pherolang#154) but none of the models providing the service declares a parseable version metadata (strict X.Y.Z, three numeric dot-separated parts); the models compile alone but cannot satisfy a compatibility selection.	Give a providing model a strict “X.Y.Z” version metadata line, or pin an exact version.

Band driver.domain (E0300–E0349)

Code	Class	Title	Meaning	Fix
E0300	error	Stripped-name collision	stripped module name '<name>' is shared by <kind> '<a>' and <kind> '<b>' — two declarations in one package (classes and/or enums) whose names strip to the same module identifier: one trailing Type suffix removed, then snake_case (PayRun and PayRunType both strip to pay_run; TypeWriter keeps its name). Consumers generate the same module path for both and one overwrites the other. The diagnostic spans the later declaration and names both. Pairs where either class is a containment target (some class declares a contains feature targeting it) are exempt — contained value objects share their owner’s module downstream by design.	Rename one of the declarations, or give one class a distinct table "…" override when the collision is a value-object/table pairing.
E0301	error	Table-name collision	table name '<name>' is shared by class '<a>' and class '<b>' — two classes in one package map to the same effective table name (a declared table "…" override, else the derived default), so both would generate the same pg table and one overwrites the other. The diagnostic spans the later declaration and names both. Pairs where either class is a containment target are exempt.	Give one of the classes a distinct table "…" override, or rename it.

Band driver.ddd (E0350–E0399)

Code	Class	Title	Meaning	Fix
E0350	error	Unknown transition trigger	unknown transition trigger '<trigger>' on operation '<op>' of service '<service>' — the operation’s transition binding names no trigger of the machine bound to the delegation target’s repository design: the spelling is a typo (a did-you-mean names the closest declared trigger when one is plausible), the qualifier names another machine’s enum type, the target’s design carries no machine, or the name is both declared via and derived from a bare arrow — ambiguous, so it binds nothing.	Name a trigger the machine declares — an explicit via name or a bare arrow’s derived name (the lowerCamel of the target state) — and qualify it with the machine’s enum type in a multi-machine module.
E0351	error	Transition on a non-save delegation	transition on operation '<op>' of service '<service>', which declares its own signature or … which delegates to <target>.<operation>; only a save delegation carries a transition— the transition binding fires the machine-bound transition of the aggregate a repositorysave` persists, so a declared operation or a delegation to anything else has no machine to bind.	Delegate with name => <Repository>.save and bind the transition there, or drop the clause.
E0352	error	Transition qualifier required	transition on operation '<op>' of service '<service>' has no machine qualifier; module '<module>' carries <n> machine-bearing designs — in a multi-machine module the unqualified spelling cannot say which machine the operation advances, so the binding is refused.	Qualify the trigger by the machine’s enum type: transition PayRunStatus.Submit.
E0353	error	Unknown condition path	unknown condition path '<path>' in <context> — the when condition’s qualified path names no scope binding of the operation: the first segment is neither an injected repository of the service nor any other bound name, or a later segment names no field of the injected repository’s designed class. A path that resolves but mistypes is not this error — the shared expression language’s same-type rule reports it.	Declare the injection (inject <Repository>;), fix the spelling, or name a field the repository’s class carries.
E0354	error	Ambiguous machine scope	ambiguous machine scope: '<name>' is declared by more than one machine in module '<module>' — the condition references a state name or a state-typed field name that several machines of the module declare, so the unqualified spelling never binds (multi-machine modules admit op-level when guards only when every referenced name resolves uniquely). The qualified spellings resolve it: <EnumType>.<State> for a state, lowerCamel(<EnumType>) for a field.	Qualify the reference by its machine’s enum type — PayRunStatus.Draft for a state, payRunStatus for a field.
E0355	error	Unknown child feature	unknown child feature '<feature>' on '<class>' (or child feature '<feature>' of '<class>' is an attribute) — an extend block’s child operation names a feature the extended class does not carry, or one that is not a containment or cross reference (an attribute has no child aggregate to act on). extend operates on the aggregate’s contained children, so only contains and refers features are eligible.	Name a containment or reference feature of the extended class (the help lists the eligible ones), or extend the class that actually holds the child.
E0356	error	Child action needs a collection	child operation '<op>' in extend '<class>': action '<action>' requires a collection; feature '<feature>' is single-valued — add and remove act on the elements of a many-valued child feature, so a single-valued containment (a scalar child object) admits only save.	Use save for a single-valued child, or declare the feature as a many-valued containment (contains Child[] children).
E0357	error	Unknown child action	unknown child action '<action>' in child operation '<op>' of extend '<class>' — the action after the child feature’s dot is one of the closed vocabulary add, remove, save: add a new child, remove an existing one, or persist (insert/replace) it. The action selects the aggregate-internal operation the child-scoped operation performs, so an unknown word is refused rather than silently ignored (the lowered artifact carries the operation’s signature and its childScope).	Write add, remove, or save as the action.
E0358	error	Unknown extend target	unknown extend target '<class>' — the extend block’s class must be a domain class with an entity design in the same module that is an aggregate root (a repository-bearing entity, validation rule 6). The message names which part failed: the class resolves against the imported domains, the design must live in the extending module, and the design must carry a repository (a contained, repository-less child is not a root).	Extend an aggregate root designed in the same module (add its repository block if it is missing), or move the extend block next to the root’s design.
E0359	error	Unknown body receiver	unknown body receiver '<name>' on operation '<op>' of service '<service>' — a statement-body operation written name(...) => <Repository> { ... } binds the named repository as self; the name must match a repository designed in the operation’s module that the service injects. A qualified receiver is refused at the syntax layer (the body binds one repository as self), and a repository another module designs is not addressable from this service (the module-coupling rule).	Name a repository the service injects (inject <Repository>;), or add the missing inject line.
E0360	error	Invalid operation body	invalid service body in operation '<op>': <slot>: <detail> (repository bodies use the same shape) — the .ddd statement body is a closed procedural subset (let, let … else error …, assignment, guard … else error …, if/else, return), typed against the operation’s parameters, the designed aggregate, and the synthetic repository classes. Unknown features/operations, type mismatches, non-boolean guards, unknown raise variants or arities, and value-returning paths that do not return (missing return) are all hard compile errors — unlike the sigil Rune bodies’ generate-time deferral, the .ddd compiler never attaches an unchecked body.	Fix the named slot: use a declared feature or operation, match the target type exactly, make guards boolean, raise NotFound (2 arguments) or Conflict (1 argument), and return on every successful path of a value-returning operation.