Compiler errors

Decline gives no reason

Decline names a rule that can't be declined

Decline's rule no longer fires on its declaration

Name or folder imported twice

Name used without its import

Import names nothing in its folder

Import of a name the file sees without one

Imported name the file does not use

Shared code depends on a domain

File name does not match its declaration

Declaration is used beyond the file that holds it

Route group prefix does not match its file name

Test file has no subject beside it

Jadpo file is outside the fixed layout

Shared declaration is not used

Declaration is in the wrong folder

A library function already does the same

Two names fold to the same file name

Domain or library has a generic name

Name does not survive conversion to its file name

Name is declared more than once

Name has the wrong case for its kind

Name cannot be called

Own-domain call is qualified

Name belongs to a standard-library namespace

Standard-library operation is called without its namespace

Called name is not declared

Name is not declared

Name is the wrong kind of declaration here

Comment written with # or /* */

Expected a declaration

Expected a name

Declaration marked export or pub

Import written in another language's form

Unknown escape in a string

Character is not part of Jadpo

Something else was expected here

String is not closed

Project declares nothing

Application's jadpo: is not a major and minor version as text

Project is on a later Jadpo line

Project is on an earlier Jadpo line

Another domain uses a private declaration

Declaration can't be public

Public declaration's signature names one that isn't public

Public declaration no other domain uses

Collection type written in another language's form

Value created with new

Default for a missing value written with ??

Nullable type written in another language's form

Field of a missing value read with ?.

String in single quotes or backticks

Type has no block

Type declared with struct, interface or enum

Type has no base

Variable has no type

Omitted or optional field is not present

Base is used outside a type declaration

Constraint does not fit the type's base

Constraints contradict each other

Refinement loosens a rule it inherits

Constraint is given twice

Constructor is not given exactly one value

Value cannot be converted to this type

Copied field would replace another field

Type includes its own fields

Input copies every field of another type

Decimal type has no scale

Field is given twice

Enum variant is declared twice

Variant field is given twice

Enum declares no variants

Enum variant is given a label or a value

Field is read from a value without fields

Object field value may break the field's rules

Type named as another language names it

Value written as another language writes it

Literal breaks its type's rules

Pattern is not a supported regular expression

Map key at a boundary isn't text

Value has the wrong type

Object is missing a field

Variant is missing a field

Field's type is written as a value or a call

Braces build a type that has no fields

Field is read from a value that may be none

Optional or default field outside an Input

Signature uses a built-in type directly

Type is already nullable

Field uses a reserved name

Rule is named like a field, another rule or invalid

Rule's condition isn't a Bool

Rule reads something besides its type's fields

Rule is written outside an object type

Setting has the wrong kind of value

Field type is used for a sibling field type

Type has the wrong number of type arguments

Enum has no such variant

Type has no such field

Setting is not one Jadpo knows

Variant has no such field

Constant's value depends on itself

Another constant of the same type holds the same value

Constant's value is only known while the app runs

Outside call inside a for loop

Function calls an action or query

Function reads or writes stored data

Action is part of a call cycle

Attempt is used on something that cannot fail

Call that can fail is not handled

Outcome match handles a failure twice

Outcome match is on a call that cannot fail

Outcome match does not handle every failure

Outcome match arm has a pattern for values

Outcome match is not on a call

Outcome match repeats its success arm

Outcome match has no success arm

Success arm passes on a failure

Outcome arm names a failure the call cannot produce

Outcome match uses a wildcard

Propagate is used outside a failure arm

Reject is used inside an expression

Callable can end without returning its result

Code can never run

Value is computed and thrown away

Variable is never used

Code marked async or await

Attempt is used inside an expression

Member has no colon before its value

Condition is not in brackets

Else-if written as elif or elsif

Comparison written with another language's operator

Expected a value

Expected a statement

Loop written in another language's form

Function declared with fn, func, def or fun

Variable changed with ++, -- or +=

Inline function written in another language's form

Logical operator written in another language's form

Match arm uses =>

Expected a match pattern

Members separated by commas

Named argument is given twice

Named argument written with =

Positional argument follows a named one

Result type written after :

Statement or member ends with ;

Choice written with switch or when

Value chosen with ? :

Failure handled with try, catch or ?

Failure raised with throw or raise

Variable declared with let, const or val

Operation is declared but not built yet

Call has the wrong number of arguments

Arithmetic operand has the wrong type

Value that never changes is assigned

Assignment target is not declared

Divisor may be zero

Values cannot be compared for equality

Inline function has a different number of parameters than its operation gives

Inline function is not an argument to a collection operation

Logical operator needs Bool operands

Match arm gives no value

Match pattern is already covered

Match does not cover every case

Pattern cannot match this value

Nullable pattern on a value that is never none

Pattern names data a case does not carry

Pattern names an unknown enum variant

Match arm is unreachable after the wildcard

Wildcard on a value whose cases can be listed

Open value space needs a wildcard arm

Named argument is not a parameter

Callable does not take named arguments

Declaration named where a value is read

Values cannot be ordered

Operator cannot be used with this value

Name is not defined in this scope

Failure code is not lower_snake_case

Field is declared for both the client and the log

Failure code is already in use

Failure field is given twice

Failure is listed twice after fails

Condition is mapped twice

Catch-all covers no rule, because every rule that can break has an arm

Catch-all for rules is used on something that is not a construction

Failure has no kind

Failure kind is raised only by the runtime

Mapped failure's kind does not fit its condition

Rejected failure is missing a field

Arm maps a rule the value cannot break

Rule that can break has no arm and no catch-all

Listed failure can never happen

Failure that can leave is not listed after fails

Rejected failure has no such field

Mapping names a condition the operation does not have

Fails list comes after the result type

Mappings are written after the call instead of in a block

A reference that can never be none is cleared on delete

Unique rule or index repeats another

Field holds an entity instead of a reference to one

Unique rule or index is not a list of fields

Structured field holds a type with no stored JSON form

Generated field is not a required Instant

Entity has no id field

Entity's id is not a required Uuid

Lifecycle condition isn't a test of the record's own fields

Required field a transition sets has no starting value

Purge's after: isn't a positive duration

Purge's since: isn't a time field of the record

Lifecycle purges records but hides none

Lifecycle has a section it doesn't take, or lacks one it needs

Transition is named like another operation or a field

Lifecycle names a field the entity doesn't have

Lifecycle sets a value that isn't fixed

Name is too long for a table or column

Field that is not a reference sets on_delete

Reference does not say what deleting its record does

Reference points at an entity in another store

Required references form a cycle

Unique rule or index lists a field twice

Entity's table name starts with jadpo_

Entity names no store and there is no main

Entity's store is not a database connection

Unique rule includes a field that can be none

Unique rule has only one field

Unique rule or index names a field the entity does not have

Entity has a section Jadpo does not know

Computed backfill can fail

Computed backfill reads more than its row

Migration decision does not fit its change

Migration needs a decision

Migration decides about something that is not changing

Entities and the latest migration disagree

Migration folder cannot be read

Latest migration is not finished

Conflict mapping for a rule the write can't break

Conflict mapping names no unique rule or reference

Write can break a rule its conflict: doesn't map

Delete would remove a record its lifecycle keeps

Write sets a field only the lifecycle changes

Patch input has a field that isn't optional

Patch names a field the entity or its input doesn't have

Patch given something other than an Input

Supplied-field block sets a field the patch already sets

Query or get inside a for loop

Write sets a field the store generates

Update by id adds a decimal with more places than its field keeps

Stored field read outside an update by id

Update by id builds a value from a stored field that could break its type's rules

Update by id sets a value from something it can't use

Write comes before a later outside call

Write names a type that isn't an entity

Write doesn't say what it changes

Write has a section it doesn't take

Aggregate is given the wrong arguments

Aggregate cannot be worked out over this field

Aggregate entry is not count, sum, min, max or average

Query condition is not one an index can serve

Query reads something that is not an entity

Map layer's geometry field is not a stored geometry of its type

Records cannot be grouped by this

Includes nest more than two levels

Result type has no field of the right shape for an include

Include names no reference to or from the entity

Query limit or page size is below 1

Query limit or page size comes from a value with no maximum

Query for one record can match several

Condition compares with a value that may be absent, or where_present: with one that is always there

Order field has no asc or desc

Field cannot be in a query's order

Query reads another domain's entity

Page block is missing a setting or has a wrong one

Query section is given twice

Result type has a field the entity cannot fill

Query result type has rules across its fields

Query result is not the entity or a type derived from it

Query is missing a section its result needs

Query has a section its result does not take

Query names a field its entity does not have

Query has a section Jadpo does not know

Query value is computed rather than a parameter, literal or enum value

Action writes more than one store

API authentication is not a list of declared sign-in methods

API idempotency is not an Idempotency

Two APIs share a prefix

Declared API has no prefix

API serve_openapi is not true or false

API setting is not one an API takes

Route group names an API the application doesn't declare

Route passes something other than a placeholder, the input or their fields

Route authentication is not RouteAuthentication.none or .fresh

Route reads a placeholder or input it never passes on

Route deadline is not a duration up to 60 seconds

Input field reads a header authentication owns

Two input fields read the same header

Header name is not a valid HTTP header name

Header field is not a single value

Route input is not an Input type

Route item is given twice

Route or route group item is not one it takes

Route output is not exactly what it runs returns

Route output is not an Output type

Route has no output:

A no_content route has an output

Two routes could answer the same request

Placeholder name is used twice in a route's path

Placeholder is not typed with a named scalar or an X.id

Route group prefix does not start with its API's prefix

Route group has no prefix

Query-string input field is not a scalar, an enum or a list of them

Route run: is not a call of a named action or query

A GET route runs a query and other methods run an action

Route does not say what it runs

Route settle: is not an answer query and a wait inside its deadline

Route status is not a SuccessStatus

Streaming route answers with another status or waits with settle:

Route method is not one a route is written with

Sign-in method is declared twice

Sign-in method is not one the language has

Routes need a signed-in caller, but nothing signs anyone in

Sign-in method has no principal variant to sign in

Sign-in setting has a value it can't take

Sign-in method is missing a setting it needs

Sign-in setting is not one the method takes

Project declares more than one application

Project declares more than one authentication block

Project declares more than one principal

Principal declares a variant twice

Principal variant is not a subject and an optional active condition

Principal declares neither a user nor a service

Principal variant is not user or service

Revocation delay is not a positive duration

Entity field holds an API token or a service key

Caller is made from a record outside tests, fixtures and seeds

Failure field holds a caller

Input field holds a caller

Output field holds a caller

Caller variant is not one the principal declares

Public route passes a caller it never reads

Session, API token or service key operation outside an action, or without its sign-in method

Principal's active condition is not a test of the record's own fields

Principal's subject is not a field of a stored entity

Principal's subject field is not unique

Policy names something that can't say who

Policy is declared twice

Policy gives the same list twice

Route reaches something no grant allows

Policy holds something that isn't a grant or a setting

An event or a batch names a tenant its action never reached under its caller's policy

Field policy lets in someone its record's grants don't

Entity declares a membership twice, or gives one of its parts twice

Membership doesn't say who holds it

Membership doesn't say which field holds the role

Membership doesn't say what it is held in

Output carries a value not every caller may read

Route anyone may call reaches what not everyone may do

Create sets the user field its grant needs from the request, not the caller

Grant names a role no membership holds

Grant doesn't say which reference a role or the tenant applies through

A scope or tenant is given twice

Entity has no reference a role or the tenant applies through

Grant names the same caller twice

Schedule or subscriber reaches what only Access.public grants, not Access.system

Update changes a field that never changes

Setting names an empty environment variable

Setting names a variable that is not in capitals

Client address is declared twice

Client address counts proxies with something that is not a count from 1

Client address gives a count of proxies to a source that counts none

Client address is not a block of a source and a count of proxies

Client address names a source that is not one of the four

Setting value breaks its type's rules

Setting value is not a literal

Setting value is the wrong kind of value for its type

Two settings read the same environment variable

Setting option is given twice

Configuration holds something that is not a setting

Configuration has no setting with this name

Configuration is declared more than once

Secret setting has a value in source

Secret setting is used where it could leave the server

Secret option is not true or false

Setting read by a test has no value in tests

Setting type cannot be read from one variable

Setting option is not one a setting takes

Connection address is not a setting of the type its driver needs

Locales are declared more than once

Locales declaration has no default

Locales option is given twice

Locales declaration lists no supported locales

Locales declaration has no such option

A language file words a Jadpo message of a feature the application has off

A message field is a type a wording can't hold

No wording in a language uses one of a message's fields

A supported locale has no language file

A language file is not named for a locale

A group in the root language file is not one Jadpo reads

A supported locale lacks wording for Jadpo's own messages

A language file is for a locale the application does not support

Translations without declared locales

A member is written twice in a language file

A language file words something that is no message, enum or email

A translation call names no message or enum

An option of translations in app.jadpo is not one it takes

A wording writes an amount of money without its style, or a style on another field

A wording writes a field the message does not have

Translation review is not a TranslationReview

A translations folder's sources record cannot be read

A translation was made from default wording that has changed

A message has more than one enum or plural field

A wording lacks a value of the enum or a plural form

A wording is for a value or plural form that does not exist

A wording is not a plain string with {field} placeholders

A supported locale has no wording for a message

A member is written in the wrong shape for what it words

The operation clock is unavailable in this context

Default locale is not a supported one

Locale is listed twice

The default locale is listed as in progress

An in-progress locale is not a supported locale

Locale is not written as a Locale

Locale is not one the application supports

Formatted text is stored

Clock time is not written HH:MM

Format component is given twice

Format component takes no such style

Declared format shows nothing

Format is not a written-out time format

Format shows a clock time a date doesn't have

Formatting needs declared locales

Option means nothing for this value

Formatting an instant needs a zone

Action calls a connection its domain isn't listed on

Connection gives a key its package doesn't take

Connection leaves out a key its package needs

Connection names no provider package the app holds

Connection's key holds a value it can't

Package action does what package code may not

Installed package's files differ from its digest in the lock

Package holds email templates

Package's index is missing, or holds what an index can't

Proprietary package isn't installed from git

Package's index names another package than its folder

Package's name is already one of the app's

Lock names a package that isn't installed

Installed package has no line in the lock

Code uses a package's declaration that isn't public

Provider operation holds what it can't, or lacks what it needs

Provider file holds what it can't, or lacks protocol:

Package has resources but no provider.jadpo

Provider package carries translations

App's own integration takes a provider's reserved name

Provider field looks like a standard type the package doesn't use

Name written through a package held in two versions doesn't say which

Name written through a package held in one version carries a version

Field says how it is sent in a way it can't

Wire name outside a provider package, or one the type already uses

Outside calls a route reaches can take longer than its deadline

Recorded provider answer its operation's decoders don't read

Field's decode and encode don't round-trip a recorded value

Emit is given something that isn't an event, or is used outside an action

Events settings in app.jadpo hold something other than a database's store:

Action emits an event but writes no store to keep it in

A queue in receiving: doesn't say how its messages are read

Schedule's every: isn't a whole number of seconds, minutes, hours or days

Schedule holds an item it doesn't take, gives one twice or leaves out every: or run:

Schedule's run: isn't a call of an action in its own domain with no arguments

Schedules settings in app.jadpo hold something other than a database's store:

Schedule has no database named to keep its state and lease in

Several changing calls where a retry can't resume them

Actions make several changing calls but no key encrypts their answers

Operation with a large answer among several changing calls

Action can fail for good after a changing call took effect

Steps setting in application { } doesn't read

Action makes several changing calls but writes no store to keep their record in

More than 8 changing calls on one way through an action

Changing call with no idempotency key beside another changing call

Subscriber passes something other than its event or a field of it

Subscriber's on: doesn't name an event type

Subscriber holds an item it doesn't take, gives one twice or leaves out on: or run:

Subscriber's retry: isn't attempts and a duration within their limits

Subscriber's run: isn't a call of an action in its own domain

A batch saves a value that can't be stored

Batch operation called outside an action

A batch's each: or finished: is not one call of an action in its domain, or a write's each: no inline function giving the row

A batch's from: is not a call of a named query giving a Page

An Input or a route placeholder holds a batch type, which only the runtime builds

A batch walks a query ordered by a field an update can change

A file helper's rows can't be read as the type its as: names or from where its items_at: says, its max_unpacked_size: isn't a size, or its rows can't be written as the row its each: gives

Test's fakes script something no provider operation answers

Route test request doesn't fit its route

No route answers a route test's request

Assertion written in another language's form

Test assertion does not hold

Test called a faked operation more times than its fakes script

Test left a faked operation's scripted answers unused

Test stopped on a fault

Subscriber failed for good during a test

Test ended in a failure it did not expect

The clock is moved outside a test

AI usage's database couldn't be read

AI command has invalid arguments

Api command has invalid arguments

Build command has invalid arguments

Calls command has invalid arguments

Check command has invalid arguments

Completions command has invalid arguments

Config command has invalid arguments

Secure configuration prompt failed

Configuration entry requires an interactive terminal

Declines command has invalid arguments

Deliveries command has invalid arguments

Dev command has invalid arguments

Development port is invalid

Development server could not start

Email command has invalid arguments

Fix command has invalid arguments

Format command has invalid arguments

Help command has invalid arguments

Language-server command has invalid arguments

Migrate command has invalid arguments

New command has invalid arguments

Package command has invalid arguments

Description to import is not an OpenAPI 3 document

Description to import could not be read as JSON

Terminal presentation option is invalid

Records command has invalid arguments

Routes command has invalid arguments

Runs command has invalid arguments

Schedules command has invalid arguments

Sql command has invalid arguments

Suggest command has invalid arguments

Test command has invalid arguments

Toolchain command has invalid arguments

Translations command has invalid arguments

Unknown Jadpo command

Unknown flag

Version command has invalid arguments

Why command has invalid arguments

Local configuration changed during the update

Local configuration is not UTF-8 text

Local configuration could not be read

Local configuration syntax is invalid

Local configuration target is unsafe

Local configuration could not be saved

A setting already has the constant's name

Constant is read where a setting can't be

Constant's type can't be a setting

Configuration value is invalid

Required configuration is missing

Package's answers don't conform to its capability

Conformance suite can't run against the provider's API

No delivery or schedule run has the id given

Deliveries' database couldn't be read

Delivery or schedule run isn't in a state the action applies to

Deployable serves an API the app doesn't have

Deployable serves nothing and runs nothing

Deployable is written in a form deployables: doesn't take

Route waits for follow-on work its deployable doesn't run

Deployable's target isn't one Jadpo builds for

Deployable reaches a connection its target can't run

Deployable runs something that isn't a trigger

No deployable serves an API, or runs the background work, the app has

Source file is not formatted

Formatting would change the file's meaning

Formatted source could not be written

Package's git repository or tag couldn't be read

Package to remove is still used by the app

Linked package in a CI or production build

Package's committed surface doesn't match its code

Migrations could not be applied

Database lacks a PostgreSQL extension the project's migrations need

Database's PostgreSQL extension is older than the project's queries need

Database does not match the project's migrations

Package's surface breaks its last release within one major version

Package's changelog doesn't say why its new version is released

Package's public declaration has no description

Example in a package's description doesn't compile or doesn't hold

Package's function has no example, or a failure it raises is shown by none

Package's recipes have no sample app with one domain to compile in

Sandbox or model gave no answer to record

Answer can't be recorded through this connection

Unfinished runs' database couldn't be read

Schedule is already running

No tick picked up the run asked for

Schedule's run failed

Schedules' database couldn't be read

Suggestions settings are declared more than once

Suggestions record can't be read

Jadpo HQ couldn't be reached or refused what was shared

Suggestions setting is given twice

Suggestions settings have no such option

Test run failed

No tests to run

Test runtime could not start

Generated file could not be written

Rust compiler couldn't build the deployable

Rust toolchain or crates couldn't be fetched

Project could not be found

Scaffold destination is an existing file

Scaffold destination directory is not empty

Project destination has no valid name

Scaffold destination could not be inspected

Project scaffold file could not be written

Jadpo source file could not be read

Translation exchange file can't be read or written

Translation file holds a unit the project does not have

Suggestions setting has a value it can't take

A File field's store, size or types are missing or wrong

Email's attachments may exceed what its mail package accepts

Action emits an email but the application names no email connection

Email's field is written by no template and no subject

Email's template fails a check of the mail health score

Template includes a partial that doesn't exist, can't be reached or is given the wrong fields

Reads email.sent outside a test

Application's email: or display_name: is invalid

Email has no template, or a template no email

Template does more than read fields, translate and format

Template writes out something that isn't text or a number

Deployable built for Workers would count its rate limits in each instance's memory

Rate limits' store isn't a connection that can count them

Deployable built for Workers has nowhere to count its rate limits

A whole read of a file field that can hold more than 10 MB

Generated record was edited by hand

Record was written by a newer Jadpo

Generated record disagrees with the source

Standard-library operation has moved to another name

A number, % and a value with no spaces could be a percentage or a remainder

Text that may be empty where it never is

Count or position may be negative

Money is divided by a count

Password hash is sent, read from a request or put in a failure

Randomness is read outside an action

Variant is called all, which lists an enum's variants

Secret value is sent, stored, logged or read as text

Declaration has a standard type's name

Type has a standard type's shape under another name

Format shows a part a local time doesn't have

Number is given where a quantity needs a unit

Number is written with a suffix that is no unit

Code writes a retired code

Action asks a model but the application names no ai: connection

Application's ai: holds something it doesn't take, or leaves out what it needs

Vector field on a store that isn't PostgreSQL

A free-text placeholder is written in a prompt's instructions

A prompt's field is of a type a prompt can't send

A prompt's text writes a field its type does not have

A prompt's field is written nowhere in its text

A prompt and its file don't make its two sections, each once and in order

Nearest-neighbour order on a vector too long for an index reads every record

Nearest-neighbour query returns a page

Nearest-neighbour order measures from something it can't

Nearest-neighbour order on a vector with no fixed length

Application's ai: sets no daily limit

Vector type an embedding is asked for as has a length other than embedding_dimensions:

A field marked to_models: false reaches a prompt or an embedded text

A marked field's value is stored in a field without its marks

A ModelId is written out anywhere but a setting's default:

Type a model is asked to answer as is one no model's answer can be

Personal data reaches a model in a category ai: { personal_data: { allowed: } } doesn't list