rulec diagnostics

Every code rulec can print, what makes it appear, and how to fix it. The code and the JSON shape are a stable API; only the prose improves. For one of them: rulec explain E101.

E001

error — Unterminated string

When. A string opened with " is not closed on the same line. Neither a cell nor a description may contain a line break.

Fix. Close the " on the same line. A long description either fits on one line or moves into a # comment.

Smallest reproduction:

rule t(t) v1
description "unterminated

Related codes: E002

E002

error — Unreadable character

When. A character that is neither a letter nor _ appears where a name is expected — an alias in parentheses that is not a name (sixty(60)) included. The check exists so that a typo does not quietly become a name, nor an alias quietly go missing.

Fix. Delete the character. A name starts with a letter or _ (@x(x) becomes x(x), and sixty(60) becomes sixty(size_60)).

Smallest reproduction:

rule t(t) v1

inputs
  %x(x) : bool

Related codes: E001, E009

E003

error — The file does not start with a rule line

When. One .rule is one rule, and its first line carries the name and the version. Anything else comes before it, or the rule line has no name — a file whose rule line had none used to pass the check as a rule with nothing in it.

Fix. Add rule <name>(<alias>) v1 as the first line.

Smallest reproduction:

inputs
  x(x) : bool

Related codes: E004, E011

E004

error — The line does not start with a word

When. A line that is neither a table row, a comment nor blank starts with a symbol. The syntax is line-oriented: the first word of a line decides what is being declared.

Fix. Start the line with a declaring word (description / import / enum / group / inputs / elements / outputs / derive / define / constraint / table / fold / count / sum / sequence / result / examples / policy / overrides / clause / source / apply / shape / machine / scenario). A table row starts with |.

Smallest reproduction:

rule t(t) v1

= 1

Related codes: E003, E005

E005

error — A word that cannot appear at this position

When. The word at the head of the line is not in the vocabulary. The vocabulary has no synonyms: one English spelling each.

Fix. Correct it to one of description / import / enum / group / inputs / elements / outputs / derive / define / constraint / table / fold / count / sum / sequence / result / examples / policy / overrides / clause / source / apply / shape / machine / scenario. Business words belong in names and cells, not at the head of a line.

Smallest reproduction:

rule t(t) v1

foo bar

Related codes: E004, E009

E006

error — The declaration has no =

When. enum, group, derive, define and result separate the name from the body with =. It is missing.

Fix. Insert the =, e.g. enum k(k) = a(a) | b(b).

Smallest reproduction:

rule t(t) v1

enum k(k) a(a) | b(b)

Related codes: E005

E007

error — No such policy

When. The word after policy is not unique or first. DMN's Any, Priority and Collect are not adopted.

Fix. Write either policy unique (every overlap is an error) or policy first (the earlier row wins).

Smallest reproduction:

rule t(t) v1

inputs
  x(x) : bool

outputs
  r(r) : bool

table j(j)
policy any
| x | -> r(r) : bool |
| - | true           |

Related codes: W110, E105, W105

E008

error — Empty cell

When. A cell of a table holds only whitespace. A blank is indistinguishable from a forgotten entry, so it is a syntax error.

Fix. If any value is meant, write -. If a value was forgotten, write the value.

Smallest reproduction:

rule t(t) v1

inputs
  x(x) : bool

outputs
  r(r) : bool

table j(j)
policy unique
| x | -> r(r) : bool |
|   | true           |

Related codes: E101

E009

error — A declared name collides with a reserved word

When. A declared name (or alias) is the same as a word of the vocabulary. Otherwise the line-oriented parser reads the line as the start of a section and drops the declaration silently. An enum value never starts a line, so for a value it is only the eleven words its own position reads as something else (not none true false starts_with default after empty exhausted by with).

Fix. Rename it (enum range(kind) becomes enum range_band(range_kind)). The reserved words are fixed by the one table in src/kw.rs.

Smallest reproduction:

rule t(t) v1

enum range(kind) = a(a) | b(b)

Related codes: E005, E011

E010

error — The .. range notation is not allowed

When. A cell contains .., as in 0g..1000g. Whether "up to 1000g" includes the endpoint cannot be read off the text.

Fix. Rewrite it with comparison operators: 0g..1000g is either <=1000g or <1000g. To fix both ends, write >=0g <=1000g.

Smallest reproduction:

rule t(t) v1

inputs
  w(w) : mass[g]  range >=0g <=10kg

outputs
  r(r) : bool

table j(j)
policy unique
| w         | -> r(r) : bool |
| 0g..1000g | true           |
| >1000g    | false          |

Related codes: E105, E101

E011

error — A public name has no ASCII alias

When. The rule name, an input or an output has a non-ASCII name and no alias in parentheses. The alias becomes the public name in the generated code (a kanji has no uppercase and cannot begin an exported Go identifier). A name that is already ASCII is its own public name and needs no alias.

Fix. Add the alias in parentheses (重量 : bool becomes 重量(weight) : bool). On a derived value, a definition, a group or a table the alias is optional: write one and the generated code uses it, leave it out and the declared name is used as it stands.

Smallest reproduction:

rule t(t) v1

inputs
  重量 : bool

outputs
  r(r) : bool

table j(j)
policy unique
| 重量 | -> r(r) : bool |
| -    | true           |

Related codes: E009, E012

E012

error — The name is not declared

When. A column or an expression names something that is declared nowhere. There is no forward reference: a name is declared above the line that uses it. It also appears when a value written in a cell or a group is a value of no enum; when the rule imports a built-in namespace of divisions (std/us/states and the rest), the note gives the closest spelling, or the namespace of another country that has the word. And it appears when a word is a spelling two imported countries share (WA is the code of Washington and of Western Australia).

Fix. Match the spelling to the declaration, or declare the input, derived value or definition above. For a spelling two countries share, write the value's name (Washington or Western_Australia).

Smallest reproduction:

rule t(t) v1

inputs
  x(x) : bool

outputs
  r(r) : bool

table j(j)
policy unique
| y | -> r(r) : bool |
| - | true           |

Related codes: E011, E013

E013

error — No such import

When. The target of import is not there. There are three kinds: the built-in namespace (the first-level divisions of thirteen countries: std/us/states, std/gb/nations, std/cn/provinces, std/tw/divisions, std/kr/provinces, std/in/states, std/fr/regions, std/es/communities, std/it/regions, std/de/states, std/au/states, std/br/states and std/jp/prefectures, whose prefectures std/都道府県 also imports, with the values spelled in Japanese), an enum in a .proto (import proto "<file>" <Enum> -> <enum of this rule>), and an enum in a JSON Schema (import jsonschema "<file>" "<pointer>" -> <enum of this rule>, OpenAPI included). For the last two it appears when the file cannot be read, when it holds no such enum, or when the line is not that shape. YAML is not read; point at a JSON form of it. It also appears when one country's divisions are imported under both of its names (std/都道府県 and std/jp/prefectures).

Fix. Correct the namespace's spelling (the note gives the closest one), or declare the enum in this file with enum. When importing from a file, the path is followed from the directory of the rule file, so write it relative to that. A JSON Schema pointer looks like #/components/schemas/<name>, and one that does not resolve comes back with the keys that are there.

Smallest reproduction:

rule t(t) v1

import std/us/state

Related codes: E012, E032

E014

error — An output cell cannot hold an expression

When. A cell to the right of -> holds two or more words. Only one value or one name may be written there. Taking just the first word and skipping the rest would emit generated code with the multiplication silently dropped.

Fix. Give the calculation a name on a define line and leave only that name in the table (| - | rate_discount |). A table holds the branching and nothing else.

Smallest reproduction:

rule t(t) v1

inputs
  p(p) : money[JPY, incl_tax]  range >=0JPY <=10_000JPY
  r(r) : rate[step 1%]  range >=0% <=100%

outputs
  o(o) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy first
| r    | -> o(o) : money[JPY, incl_tax] |
| <=5% | 0JPY                           |
| -    | p * r                          |

Related codes: E008, E012

E015

error — result can only assemble the first output

When. A result names an output other than the first. result is sugar for the first output, and both the evaluator and the generated code apply it only there. The name used to be ignored, so a number could land in a money slot without an E103.

Fix. Write a define of the same name as that output (define points(pts) : number = base_points * multiplier); outputs are taken, in declaration order, from the binding of their own name. To assemble it with result instead, move that output to the top of outputs.

Smallest reproduction:

rule t(t) v1

inputs
  p(p) : money[JPY, incl_tax]  range >=0JPY <=10_000JPY

outputs
  a(a) : money[JPY, incl_tax]  round down(1JPY)
  b(b) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| p | -> a(a) : money[JPY, incl_tax] |
| - | 100JPY                         |

result b = p

Related codes: E016, E103

E016

error — There can be only one result

When. A file has more than one result line. Only the first output can be assembled, so a second result merely replaces the first — which it used to do in silence.

Fix. Keep one. The other outputs are taken from a define of the same name as the output.

Smallest reproduction:

rule t(t) v1

inputs
  p(p) : money[JPY, incl_tax]  range >=0JPY <=10_000JPY

outputs
  a(a) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| p | -> a(a) : money[JPY, incl_tax] |
| - | 100JPY                         |

result a = p
result a = p + 100JPY

Related codes: E015

E017

error — A constraint is not shaped like this

When. A constraint line is not input comparison input: either there is no comparison, or a side is not a single name.

Fix. Write constraint <input> <= <input>; the comparisons are <=, <, >= and >. For A = B, write the two lines A <= B and A >= B.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : number  range >=0 <=10
  b(b) : number  range >=0 <=10

constraint a

outputs
  r(r) : bool

table j(j)
policy unique
| a | -> r(r) : bool |
| - | true           |

Related codes: E018

E018

error — A constraint relates two inputs

When. A side of a constraint is not an input, or has a type with no order. A constraint says which combinations of the values the caller passes can happen, so both sides name something in inputs, and each is money, a quantity, a rate, a number or a date.

Fix. Name inputs on both sides. A derived or defined value is computed from inputs, so write the relation between those inputs; an enum and a boolean have no order.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : number  range >=0 <=10

constraint a <= r

outputs
  r(r) : bool

table j(j)
policy unique
| a | -> r(r) : bool |
| - | true           |

Related codes: E017, W111

E019

error — An example is an input the generated code refuses at its door

When. An example's inputs do not satisfy a constraint, or the value of an input — a field of an element of the sequence included — lies outside its declared range. A constraint declares that a combination does not happen and a range that no value outside it arrives; the completeness check believed them and demanded no row there, and the generated code refuses that input at the door. It is not an input an answer can be claimed for. An example outside the range used to pass the check, and the vector made from it was then refused by the generated code.

Fix. Correct the example's values — or, if that value or combination really does arrive, widen the range or drop the constraint.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : number  range >=0 <=10
  b(b) : number  range >=0 <=10

constraint a <= b

outputs
  r(r) : bool

table j(j)
policy unique
| a | b | -> r(r) : bool |
| - | - | true           |

examples
| a | b | -> r |
| 5 | 1 | true |

Related codes: E017, E018, E101

E020

error — The elements declaration is not right

When. An elements line has no name, or there are two of them. A rule walks one sequence, and the fields of one of its elements are declared there.

Fix. Write elements fee_rows(fee_rows), and the fields of one element under it, declared the way inputs are. Two sequences mean two rules.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

elements xs(xs)
  k(k) : number  range >=0 <=10

elements ys(ys)
  m(m) : number  range >=0 <=10

outputs
  r(r) : bool

table j(j)
policy unique
| n | -> r(r) : bool |
| - | true           |

Related codes: E021

E021

error — The fold is not written correctly

When. The heading is not fold <verdict column> over <sequence>, or an arm is not one of next, stop, stop with <value>, take_unique <value>, take_first <value>, keep_max <value> by <key>, or the column being folded is not an enum.

Fix. Correct the heading and the arms. A bare take cannot be written: whether one and only one element may be taken, or the first of several, is for the author to choose.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

elements xs(xs)
  k(k) : number  range >=0 <=10

outputs
  r(r) : bool

table j(j)
policy unique
| n | -> r(r) : bool |
| - | true           |

fold r
  empty -> false

Related codes: E020, E022, E023, E024

E022

error — The answer for a sequence with no elements is not declared

When. A fold has no empty -> <value>. An empty sequence always turns up, and it is the case a hand-written loop most often forgets — usually by reading the first element and falling over.

Fix. Add empty -> <value>. What to answer is a business decision, and not one the tool can make.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  exhausted -> held

Related codes: E023, E024

E023

error — The answer for a walk that reached the end is not declared

When. A fold has no exhausted -> <value>: the answer when the sequence ran out and no element ended the walk. Answering with the value that was held is a choice, and it is made by writing it.

Fix. Add exhausted -> <value>; to answer with what is held, that is exhausted -> held.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0JPY

Related codes: E022, E024

E024

error — Some verdict has no arm

When. A verdict the table can produce has no arm in the fold: when an element lands on it, the walk has no move. It is the table's own completeness check, applied to the fold.

Fix. Add the arm, or stop the table producing that value. The other direction — an arm for a verdict nothing can reach — is W115.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  empty -> 0JPY
  exhausted -> held

Related codes: E022, E023, W115

E025

error — The examples have no column for the sequence

When. A rule that walks a sequence has examples, but the header has no column named after its elements. An example that does not say which sequence it walks is an example with no answer.

Fix. Write the list with sequence <name>, add a column for the sequence to the examples header, and name it in the cell. A sequence with no rows is the example for a sequence with nothing in it.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0JPY
  exhausted -> held

examples
| -> r |
| 0JPY |

Related codes: E026, E027

E026

error — The sequence is not written correctly

When. The columns of a sequence do not line up with the fields of elements: a column that is not a field, a field left out, a ->, no sequence to be a list of, two blocks with the same name, or a cell that is not a value (a range or a -).

Fix. Make the header the fields of elements as they are, and write one element's values per row. This is not a table: it is the list of values as they would really be passed.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0JPY
  exhausted -> held

sequence s(s)
| m    |
| 3JPY |

Related codes: E025, E020

E027

error — The example names a sequence that is not there

When. The cell in the sequence column names a sequence that is not declared, or holds something that is not a name at all.

Fix. Write a sequence under that name, or correct the cell to one that is written.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0JPY
  exhausted -> held

examples
| xs   | -> r |
| nope | 0JPY |

Related codes: E025, E026

E028

error — The count is not written correctly

When. The line is not count <name>(<alias>) over <sequence> where <column> = <value>: no over, no where, a sequence that elements does not declare, or an = with nothing on its right.

Fix. Write it in that shape. The = <value> may be left out only for a bool column.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

elements xs(xs)
  b(b) : bool

outputs
  r(r) : bool

count h(h) where b  range >=0 <=10

table j(j)
policy unique
| n | -> r(r) : bool |
| - | true           |

Related codes: E029, E030, E020

E029

error — This column cannot be counted

When. The column where names is not a value of one element (an input or a derived value is one per call, so counting it could only answer 0 or 1); or its values are not a closed set; or the value written is not one of that enum's; or an enum column was given no = <value>.

Fix. Name a field of an element, or a column a per-element table produces. Writing the classification as a table is what puts the classification itself under the completeness check.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10
  ok(ok) : bool

elements xs(xs)
  b(b) : bool

outputs
  r(r) : bool

count h(h) over xs where ok  range >=0 <=10

table j(j)
policy unique
| h | -> r(r) : bool |
| - | true           |

Related codes: E028, E012

E030

error — A count needs a range

When. The count line has no range >=0 <=<max>, or no upper bound, or a negative lower one. The range means two things: the universe the completeness check quantifies over once the count is a column, and the cap on the sequence.

Fix. Write it as range >=0 <=100. The generated code refuses a longer sequence at the door, the way it refuses a number outside its range.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

elements xs(xs)
  b(b) : bool

outputs
  r(r) : bool

count h(h) over xs where b

table j(j)
policy unique
| h | -> r(r) : bool |
| - | true           |

Related codes: E028, E112

E031

error — A rule cannot have both a fold and a count

When. One rule has both. They are two endings for the same walk, and a fold can stop partway: what a count means on a walk that stopped is not decided.

Fix. To count, drop the fold and let a table judge the count. To fold, drop the count.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : number  range >=0 <=10

outputs
  r(r) : number  round down(1)

table j(j)
policy unique
| k   | -> d(d) : v |
| <=5 | a           |
| >5  | b           |

count h(h) over xs where d = a  range >=0 <=10

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0
  exhausted -> held

Related codes: E021, E029

E032

error — The declared enum and the imported one disagree

When. The values of the enum named by import proto or import jsonschema and the values of the rule's enum (their ASCII aliases, where they have them) are not the same set. Values on either side alone are named, in both directions. It is usually the proto that gained one, and it shipped as a compatible change made outside this rule.

Fix. Add the new value to the rule's enum; where the enum gives its values names with aliases, the name is yours to choose. A value the contract dropped goes from the rule too. Once it is added, the table asks whether it needs a row (E033).

Smallest reproduction:

rule t(t) v1

import proto "tier.proto" Tier -> v
enum v(v) = one(one)

inputs
  x(x) : v

outputs
  r(r) : bool

table j(j)
policy unique
| x   | -> r(r) : bool |
| one | true           |

With tier.proto beside it:

syntax = "proto3";

enum Tier {
  TIER_UNSPECIFIED = 0;
  TIER_ONE = 1;
  TIER_TWO = 2;
}

Related codes: E013, E033, E101

E033

error — A value of an imported enum has neither a row nor default

When. A value of an imported enum appears in no row and is not marked default. For a value you wrote yourself that is a forgotten line (W111); for a value that came through the contract it means a change from elsewhere that nobody has read yet, so it stops. With a default row the completeness check passes and the new value quietly takes the default row's answer.

Fix. Add a row for it, or mark the value default in the declaration. default is a signature saying that falling through to the default row is what is meant — that someone decided how it is treated.

Smallest reproduction:

rule t(t) v1

import proto "tier.proto" Tier -> v
enum v(v) = one(one) | two(two)

inputs
  x(x) : v

outputs
  r(r) : bool

table j(j)
policy first
| x   | -> r(r) : bool |
| one | true           |
| -   | false          |

With tier.proto beside it:

syntax = "proto3";

enum Tier {
  TIER_UNSPECIFIED = 0;
  TIER_ONE = 1;
  TIER_TWO = 2;
}

Related codes: E032, W111, E101

E034

error — A row label appears twice

When. Two rows of one table carry the same label before their first |. A label is how an overrides line, a record's trace and a later version name the row, so it is unique within its table.

Fix. Change one of the two labels.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : bool

outputs
  x(x) : bool

table t1(t1)
   | a     | -> x  |
r1 | true  | true  |
r1 | false | false |

Related codes: E009, E035

E035

error — The target of overrides does not exist

When. An overrides line names a table that does not exist, or one declared below this table, or a row label (table:label) the table has no row of. A line whose shape cannot be read is reported the same way. The exception is written after what it excepts, so a target is always above.

Fix. Name a table declared above, or one of its rows (label the row at its head and write table:label). Write the side that takes precedence later.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : bool

outputs
  x(x) : bool

table t1(t1)
overrides no_such_table
| a     | -> x  |
| true  | true  |
| false | false |

Related codes: E034, E036

E036

error — The target of overrides does not define the same output

When. The table an overrides line names defines a different output from this table. Precedence exists only between definitions of the same output.

Fix. Name a table that defines the same output, or make this table's output column the same one.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : bool

outputs
  x(x) : bool
  y(y) : bool

table base(base)
| a | -> x |
| - | true |

table special(special)
overrides base
| a | -> y |
| - | true |

Related codes: E035, E045

E037

error — A cited fragment is not pinned

When. A fragment cited with @source fragment has no fragment sha256:… pin line under its source line; for a file source, the line carries no sha256:…. A law cited with no article (@source alone), and a fragment name, a citation or a source line whose shape cannot be read, are reported the same way (a file beside the rule may be cited whole, @postal). A document's fragments are its tables, so table3 (the third table in document order; 表3 is its Japanese spelling) is the only name read. A fragment the language cannot read as one word is quoted (@osha "§1910.157"). Without a pin, a revised copy passes check in silence.

Fix. Once the transcribed rows are checked against the document, paste the fix.text line or run rulec source pin <file.rule> to pin the copy's digest.

Smallest reproduction:

rule t(t) v1

source 法 = law "000AC0000000001" asof 2026-04-01

inputs
  a(a) : bool

outputs
  x(x) : bool

table 表(t1)  @法 第1条
| a | -> x |
| - | true |

With sources/law/000AC0000000001@2026-04-01/MainProvision-Article_1.xml beside it:

<Article Num="1"><ArticleTitle>第一条</ArticleTitle><Paragraph Num="1"><ParagraphNum/><ParagraphSentence><Sentence>甲は、乙とする。</Sentence></ParagraphSentence></Paragraph></Article>

Related codes: E038, E039, W119

E038

error — A source fragment has changed

When. The pinned digest differs from the digest of the copy beside the rule. It fails in the pull request that refreshed the copy, and names the tables, clauses and rows that cite the fragment, which is all there is to reread.

Fix. Read the copy's diff; if the transcribed rows still hold, rewrite the pin line as fix.text says (rulec source pin writes it too). If the rows have to change, change them first.

Smallest reproduction:

rule t(t) v1

source 法 = law "000AC0000000001" asof 2026-04-01
  第1条 sha256:0000000000000000

inputs
  a(a) : bool

outputs
  x(x) : bool

table 表(t1)  @法 第1条
| a | -> x |
| - | true |

With sources/law/000AC0000000001@2026-04-01/MainProvision-Article_1.xml beside it:

<Article Num="1"><ArticleTitle>第一条</ArticleTitle><Paragraph Num="1"><ParagraphNum/><ParagraphSentence><Sentence>甲は、乙とする。</Sentence></ParagraphSentence></Paragraph></Article>

Related codes: E037, E039

E039

error — There is no copy of a source

When. The copy of a cited fragment is not beside the rule — sources/law/<law id>@<date>/<element>.xml for a law, tariff.md.fragments/table3.tsv beside the document for a document's table — or the file source itself cannot be read. check reads neither the network nor the document, so without a copy there is nothing to compare.

Fix. rulec source fetch <file.rule> fetches the fragment from e-Gov, the Japanese government's statute database, and takes the cited tables out of a document, into the copies beside the rule. Commit the copies.

Smallest reproduction:

rule t(t) v1

source 法 = law "000AC0000000001" asof 2026-04-01

inputs
  a(a) : bool

outputs
  x(x) : bool

table 表(t1)  @法 第2条
| a | -> x |
| - | true |

Related codes: E037, E038

E040

error — The callee differs from its pinned digest

When. The apply heading carries no sha256:…, or the digest it carries differs from the digest of the callee file beside the rule. When the callee is amended, the answers of the rule that applies it change too; without a pin, that change passes with nobody approving it.

Fix. See with rulec diff <old> <new> how many answers of this rule move and by how much; once the movement is approved, rewrite the heading as fix.text says or run rulec source pin <file.rule> to pin the callee again.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=1 <=10

outputs
  y(y) : number  round down(1)

apply call(c) = "callee.rule"
  a = n
  x -> y

With callee.rule beside it:

rule callee(callee) v1

inputs
  a(a) : number  range >=1 <=10

outputs
  x(x) : number  round down(1)

table t(t)
policy unique
      | a   | -> x |
small | <=5 | 1    |
large | >5  | 2    |

Related codes: E037, E038, E044

E041

error — The bindings of an apply do not match the callee

When. A callee input is left unbound, a binding or an output line names something the callee does not have, the name given to a callee output is already declared in this rule, or the apply block is not shaped as one. Substitution is written by binding every input explicitly, so a missing binding is a substitution left unwritten.

Fix. Bind each callee input with one <callee input> = <value> line, and rename an output with <callee output> -> <name>. The callee's input and output names are listed in the message.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=1 <=10

outputs
  y(y) : number  round down(1)

apply call(c) = "callee.rule" sha256:1c554496c37f709f
  b = n
  x -> y

With callee.rule beside it:

rule callee(callee) v1

inputs
  a(a) : number  range >=1 <=10

outputs
  x(x) : number  round down(1)

table t(t)
policy unique
      | a   | -> x |
small | <=5 | 1    |
large | >5  | 2    |

Related codes: E040, E042, E043

E042

error — A binding does not agree in type

When. The type of a bound value differs from the callee input's (unit, tax kind, an enum against a number). Between two enums: a value of this rule's enum stands for no value of the callee's (values spelled the same on both sides map by themselves), a with names a value neither side has, or a literal is not a value of the callee's type.

Fix. Make the types agree. For enums, <input> = <value> with <this rule's value> -> <callee's value>, … maps every value of this rule's enum; that is the shape of "'retirement' is read as 'end of term'".

Smallest reproduction:

rule t(t) v1

enum kind(kind) = low(a) | mid(b) | high(c)

inputs
  k(k) : kind

outputs
  y(y) : number  round down(1)

apply call(c) = "enum_callee.rule" sha256:5c19644247d1b672
  a = k
  x -> y

With enum_callee.rule beside it:

rule enum_callee(enum_callee) v1

enum band(kind) = low(a) | mid(b)

inputs
  a(a) : band

outputs
  x(x) : number  round down(1)

table t(t)
policy unique
| a   | -> x |
| low | 1    |
| mid | 2    |

Related codes: E041, E043

E043

error — A value passed leaves the callee's range or constraint

When. The interval of a bound value reaches outside the callee input's range (the point outside is shown as the witness), or a constraint of the callee does not follow from this rule's declarations. The callee's completeness was proved over that range and constraint; outside them there is no definition. There is no fix.text: adding a row to the callee belongs to another unit of approval.

Fix. Narrow this rule's input range to the callee's, or define the region outside it in a clause of this rule; which is a business decision. For a constraint, declare the same relation with constraint.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

outputs
  y(y) : number  round down(1)

apply call(c) = "callee.rule" sha256:1c554496c37f709f
  a = n
  x -> y

With callee.rule beside it:

rule callee(callee) v1

inputs
  a(a) : number  range >=1 <=10

outputs
  x(x) : number  round down(1)

table t(t)
policy unique
      | a   | -> x |
small | <=5 | 1    |
large | >5  | 2    |

Related codes: E041, E042, E101

E044

error — That rule cannot be applied

When. The callee cannot be read, does not pass check (the codes are listed), itself has an apply, walks a sequence (elements, fold, count), or has a table or clause that produces one of its own enums. A broken rule expanded is a broken rule, and a provision applied through another is written flattened to one level.

Fix. Fix the callee first. To apply a rule that itself applies another or walks a sequence, write its expansion into this rule.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=1 <=10

outputs
  y(y) : number  round down(1)

apply call(c) = "broken_callee.rule" sha256:765fd7738ae6bfc1
  a = n
  x -> y

With broken_callee.rule beside it:

rule broken_callee(broken) v1

inputs
  a(a) : number  range >=1 <=10

outputs
  x(x) : number  round down(1)

table t(t)
policy unique
| a   | -> x |
| <=5 | 1    |

Related codes: E040, E041

E045

error — A table that shares an output has two or more output columns

When. An output is defined by two or more tables (or tables are joined by overrides), and one of them has two or more output columns. A row that bundles two definitions leaves the other value's origin undecided when only one is overridden, and the generated code would have to write the row's condition twice.

Fix. Move the second output to a table of its own.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : bool

outputs
  x(x) : bool
  y(y) : bool

table base(base)
| a | -> x | y    |
| - | true | true |

table special(special)
overrides base
| a    | -> x  |
| true | false |

Related codes: E036, E105

E046

error — A clause is not shaped like this

When. The clause heading lacks a name, the -> or the output; the when or then line is missing or appears twice; or the when condition is not <column> <cell> and … (a part without a column, a column twice, a column without a condition). A clause is a one-row table, so it needs exactly one condition and one value.

Fix. Under clause <name>(<alias>) -> <output>, write one when <column> <cell> and … line (when always when there is no condition) and one then <value> line. Add overrides <target> when it takes precedence over something.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : bool

outputs
  x(x) : bool

clause exception(exception) -> x
  then true

Related codes: E008, E035, E045

E047

error — Extra token after the declaration

When. A declaration line — an input, an output, a derive or a count — holds a word that belongs to none of range, round and contract_only. The readers look along the line for the word they want and step over everything else, so such a word used to be dropped in silence: a tax flag written after the range, as in range >=0JPY <=10_000JPY incl_tax, or what is left of a bound whose unit did not lex as one. A range is the universe the completeness proof quantifies over and the entry guard of the generated code, so a bound lost this way is answered "complete" with one side missing.

Fix. Remove the word, or write it in the form the declaration takes. A tax flag or a step goes inside the type's brackets (money[JPY, incl_tax], rate[step 0.1%]); a range is range >=<value> <=<value>; a rounding is round <mode>(<grid>).

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : money[JPY, incl_tax]  range >=0JPY <=10_000JPY incl_tax

outputs
  x(x) : bool

table t1(t1)
policy unique
| a | -> x |
| - | true |

Related codes: E011, E103, E104

E049

error — A thousands separator cannot be written

When. A number is written as a document writes it, one to three digits followed by , and groups of three: 1,000, 1,949,000JPY. Inside a cell , separates the members of a set, so as it stands the figure reads as more than one value. It used to be read that way without a word: <=1,000 in a column of numbers passed the check as <=1, and in a column of money it stopped at an E103 about 1 having no unit. Copying a document's figures as they stand lands here.

Fix. Take the commas out and write 1000; to group the digits, write 1_000. fix.text is the literal rewritten.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : money[JPY]  range >=0JPY <=5000JPY

outputs
  x(x) : bool

table t1(t1)
policy unique
| a          | -> x  |
| <=1,000JPY | true  |
| >1,000JPY  | false |