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

A file uses a name declared elsewhere in the project without bringing it in on a use line

Import names nothing in its folder

A file imports a name it already sees without a use line, such as a built-in or something its test subject declares

Imported name the file does not use

Code in shared/ uses a declaration that belongs to one 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

A domain or library is called something generic, such as helpers or utils, that says nothing about what it holds

Name does not survive conversion to its file name

Application has a section Jadpo does not know

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

The code uses a name that nothing in the project or the standard library declares

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

The project is written for a later Jadpo release line than the jadpo checking it, and that jadpo can't run the later release instead

The project is written for an earlier Jadpo release line than the jadpo checking it, and that jadpo can't run the earlier release instead

Code in one domain uses an action, type or other declaration that another domain keeps private, because it isn't marked public

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

A type that builds on another sets a looser bound than the one it inherits, such as a higher max_length

Constraint is given twice

Constructor is not given exactly one value

A type's constructor is given a value it can't convert, because the value is built on a different kind of value or may be none

Copied field would replace another field

Type includes its own fields

An Input type copies every field of another type with include, so a request could set any of them

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

A literal value breaks a rule of the type it goes into, such as a number below the type's min

Pattern is not a supported regular expression

Map key at a boundary isn't text

A value of one type is used where a different type is required

An object value is built without one of the fields its type declares

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

A record names its type with type arguments, which come from its place or its values

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

You declared a type named for a unit, such as Grams, Pence or Percent, on a plain number

The code names a variant that the enum doesn't have, often a misspelling of one it does

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

An action calls itself, or calls other actions that end up calling it again

Attempt is used on something that cannot fail

A call that can fail is made as if it can't, with nothing passing its failure on or handling it

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

A variable is given a value that nothing ever reads

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

A variable is declared with let, const or val, words from other languages, where Jadpo writes var

Operation is declared but not built yet

A call passes more or fewer values than the function or action it calls has parameters

A sum, difference or division mixes two different named types, or uses a value that isn't a number

A variable declared without mut, or a parameter, is given a new value

Assignment target is not declared

A division's divisor has a type that allows zero, so the division could fail when the program runs

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

A match on an enum, a Bool or a value that may be none leaves out one of its cases

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

A match on text or a number lists some values but has no _ arm for all the others

Named argument is not a parameter

Callable does not take named arguments

Declaration named where a value is read

A comparison such as < or > is used on a value that has no order, such as text or a value that may be none

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

Two failures have the same code, or a failure has a code the runtime already answers with itself

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

A failure is declared without a kind: saying what sort of failure it is

Failure kind is raised only by the runtime

Mapped failure's kind does not fit its condition

Rejected failure is missing a field

An attempt block maps a rule to a failure, but the value being built can never break that rule

An attempt block builds a value that can break one of its type's rules, and no arm says which failure that gives

A function or action lists a failure after fails that nothing in it can ever raise or pass on

A function or action can end with a failure that its fails list doesn't name

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

A lifecycle's visible: or when: condition isn't a plain test of the record's own fields against fixed values

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

A field refers to a record of another entity but doesn't say what happens to it when that record is deleted

A field refers to a record of an entity that is kept in a different database

Two or more entities refer to each other through required fields, so none of their records could ever be created first

Unique rule or index lists a field twice

Entity's table name starts with jadpo_

An entity names no database to live in, and the app declares databases but none called 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

A migration needs your decision, such as a value for records already stored, and its changes.jadpo doesn't give one yet

Migration decides about something that is not changing

The entities ask for a database schema that no migration has written yet, because they are new or have changed since the latest migration

A file in a migration's folder is missing, can't be read, or was changed by hand, so Jadpo can't use the migration

Latest migration is not finished

A write's conflict: block maps a rule that the write can never break

Conflict mapping names no unique rule or reference

A write could be refused by a unique rule or a reference, and its conflict: block doesn't say which failure the caller gets then

Code would remove a record that has a lifecycle for good, which only the lifecycle's own purge may do

A create, update or patch sets a field that only the entity's lifecycle may change

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

An update by id works out a new value from a stored field, and the value could break its type's rules

An update by id sets a value that the database can't work out on its own, such as one read earlier in the action

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

A map-layer query's geometry: names a field whose type isn't the shape the layer's result type says each feature holds

Records cannot be grouped by this

A query's includes nest more than two levels deep: records inside records inside records

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

Include names no reference to or from the entity

A query's limit: could be less than 1, either as written or because its value's type allows it

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

A query that returns one record, or none, picks it by a test that several records could match

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

A query sorts records by a field, such as a Bool or an enum, that the database and Jadpo don't order the same way

A query in one domain reads the records of an entity that belongs to another domain

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

A query leaves out a section its result type needs, such as from:, or the limit: that bounds a list

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

An action writes to two databases, itself or through an action it calls, but an action's writes all commit in one database

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

A route needs a signed-in caller, but its API says authentication: [], which accepts no way to sign in

An API's serve_openapi: setting holds something other than 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

A route's authentication: line holds something other than RouteAuthentication.none or RouteAuthentication.fresh

Route reads a placeholder or input it never passes on

Route's cache: isn't immutable, or it keeps an answer a public cache may not hold

Route deadline is not a duration up to 60 seconds

A route's input reads a header that sign-in or the runtime reads first, such as Authorization, a cookie or Idempotency-Key

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 an action that isn't read-only, or a route of another method runs a query

Route does not say what it runs

Route's sends: isn't a media type, or its Output isn't exactly one Bytes field

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

A route's confirm: holds something other than Confirmation.passkey, or no signed-in person could confirm the route

Sign-in method is declared twice

Sign-in method is not one the language has

A route needs a signed-in caller, but the app declares no way for anyone to sign 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

A route that anyone may call, with authentication: RouteAuthentication.none, passes on the signed-in caller, though it never looks for one

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

An action listed under actions: calls another action that refuses some of the people the listed action's line lets in

Policy is declared twice

Policy gives the same list twice

A route runs an action that nobody is allowed to call, because nothing in the app says who may

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

A field's own 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

A query or action lets a caller see a field's value, directly or through what it decides, though not every caller may read that field

A route that anyone may call, with no sign-in, reads or changes a record that only signed-in people are allowed to see

A role's line in requires: holds something a requirement can't

A role's requirement asks for a sign-in that no way in the app can give

A membership's requires: leaves out one of its roles

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

An entity names a role held in another record, or belongs to the app's tenant, but has no reference to that record

Grant names the same caller twice

A schedule or subscriber reaches something whose list doesn't name Access.system, the one way an entity lets background work in

An update changes a field that stays fixed once its record exists, such as a user field a grant names or a field marked immutable: true

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

Your code reads a secret setting somewhere other than the few places where Jadpo keeps it on the server

Secret option is not true or false

A test reaches code that reads a setting, and the setting has no value for tests to use

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

The app supports a locale, but a folder of messages has no language file for it

A language file is not named for a locale

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

The app supports a locale that Jadpo doesn't ship its own messages in, and the app hasn't worded them itself

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 placeholder, such as {nom}, that isn't one of its message's fields

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 that changes with a count or with an enum's value leaves out one of the plural forms or values

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

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

A language file of a supported locale leaves out one of the messages, or failures, that its folder has to word

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

Your code writes out a locale, such as Locale.fr_fr, that isn't in the app's list of supported locales

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

Your code formats a date with a format that also shows a clock time, and a date has no time to show

Formatting needs declared locales

Option means nothing for this value

Your code formats an Instant for people to read without saying which time zone to show it in

An action calls an outside service through a connection whose domains: list doesn't include the action's domain

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

The files of an installed package in packages/ have been changed, added or removed since it was installed

Package holds email templates

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

An installed package says its licence is proprietary, but it wasn't installed from a git repository

Package's index names another package than its folder

A package has the same name as one of the app's domains, libraries, declarations or other packages

The app's lock file, jadpo.lock, lists a package whose folder in packages/ isn't there

A package sits in packages/, but jadpo.lock has no line for it, so it was copied in rather than installed

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

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

Application's packages: lists your company's git locations wrongly

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

Your code names something through a package that the app holds in two versions, without saying which version it means

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

The outside calls a route makes could, at their slowest, take longer than the route is allowed to run

A saved answer from an outside service doesn't fit the types your integration reads that answer as

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:

An action emits an event but writes no database, and the app names no database to keep its events in

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

A schedule's every: says how often it runs in something other than 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:

An app has a schedule but no database named to keep its state in, because it has several databases or none

An action makes several changing calls from somewhere a retry can't carry on where it stopped, such as a route whose API doesn't require Idempotency-Key

An action makes several changing calls, but the app names no key to encrypt the answers it keeps from them

Operation with a large answer among several changing calls

An action can fail for good after a call that changes something outside the app took effect, leaving that change behind

Steps setting in application { } doesn't read

An action makes several changing calls but writes no database, and the app names no database to keep the record of its calls 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

A subscriber's on: names something other than an event, such as an entity or a plain type

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

A subscriber's retry: holds something other than 1 to 100 tries and up to 30 days to keep trying

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 something other than a call of a named query that gives a Page, such as a query that gives a List

An Input or a route placeholder holds a batch type, a File or a FileContents, or what a provider or a queue sends holds a File or a FileContents, 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

A route test's request { } gives an item, or a placeholder in params:, twice

A route test's request { } names a method and path that no route in the app answers

A test gives one of its settings, clock:, config:, fakes: or flags:, twice

Assertion written in another language's form

A test's assert doesn't hold: its condition is false, or a call checked with assert … fails returned or failed differently

Test called a faked operation more times than its fakes script

A test passed otherwise, but its fakes: scripted more answers for a provider operation than the code called it for

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

Base commit the change is compared with isn't in this clone

Acceptance already on the before side was edited

Acceptance file isn't written as an acceptance

A change could break someone else or widen who can do what, and no acceptance this change adds says a person agreed to it

An acceptance this change adds has no /// line above acceptance saying why a person accepted the changes it lists

Acceptance lists a change this change doesn't make

The app's AI usage couldn't be read from its database, because it can't be reached or has no table for it yet

A jadpo acceptance command names no action, one it doesn't have, or no purpose for new

A jadpo ai command names no action, one it doesn't have, or a prompt the project doesn't declare

A jadpo api command names no action, one it doesn't have, or more than update

A jadpo approval command is given an argument it doesn't take, names a --before git doesn't know, or has nothing to compare with

A jadpo build command names a deployable the app doesn't have, or more than one

A jadpo calls command names an action it doesn't have, a call the log doesn't hold, or an answer without its operation

A jadpo check command names a path that isn't there or isn't a .jadpo file, or a --before git doesn't know

A jadpo completions command names no shell, or one Jadpo writes no completions for

A jadpo config command names no action, an action it doesn't have, or a setting config.jadpo doesn't declare

A new key would be written where a person could read it, by jadpo config generate, or --generate would replace a key already set

Nothing was typed at the prompt of jadpo config set, or the terminal couldn't hide what you type there

The sealed rows jadpo config rotation counts couldn't be counted, because their database can't be reached or has no table for them yet

You ran jadpo config set where there is no terminal to type the value at, such as from a coding agent or a script

A jadpo declines command names no action, one it doesn't have, or a rule or path that isn't the project's

A jadpo deliveries command names an action it doesn't have, no id for one that needs it, or a state or page it doesn't list

A jadpo dev command names an action it doesn't have, token without a user's id, or a --url the project's several stores can't share

A jadpo dev --port flag holds something other than a whole number from 0 to 65535

The app couldn't start under jadpo dev, usually because another program is using its port, it has no database to run on, or a connection would call a provider's live API

A jadpo email command names an action it doesn't have, or a mail or link the dev inbox doesn't hold

A jadpo fix command names a declaration with nothing to fix, or a fix it doesn't have

A jadpo flags command names an action it doesn't have, a flag the project doesn't declare, or a value, user or share the flag can't take

A jadpo fmt command names a path that isn't there or isn't a .jadpo file

A jadpo help command names more than one command or rule

A jadpo lsp command is given an argument, which it doesn't take

A jadpo migrate command names no action, one it doesn't have, a purpose for an action that takes none, or a --drop of what isn't retired

A jadpo new command names no project, or more than one

A jadpo package command names no action, one it doesn't have, or a package the project doesn't hold

A file given to jadpo package import is JSON but not an OpenAPI 3.0 or 3.1 document

A file given to jadpo package import isn't there, can't be read, or isn't JSON

A --color flag holds something other than auto, always or never, or nothing

A jadpo records command names an action other than update

A jadpo routes command is given an argument, which it doesn't take

A jadpo runs command names an action other than unfinished, or leaves out its --build

A jadpo schedules command names an action it doesn't have, or a schedule the project doesn't declare

A jadpo seed command names no seed, one the project doesn't have, or more than one

A jadpo sql command names no query or action, one the project doesn't declare, or an action that writes nothing

A jadpo suggest command names an action it doesn't have, or a suggestion the last scan didn't find

A jadpo test command names a path that isn't there, or a seed, a kind or a --name it can't use

A jadpo toolchain command names an action it doesn't have, or a release that isn't kept

A jadpo translations command names no action, one it doesn't have, or a locale the project doesn't translate into

A jadpo command line starts with a command Jadpo doesn't have, or asks jadpo help about a command or rule it doesn't have

A jadpo command line has a flag the command doesn't take

The verifier won't start, for want of its credential or a sandbox to run packages in, or because it can't listen

A jadpo version command is given an argument, which it doesn't take

A jadpo why command names no schedule, one the project doesn't declare, or more than one

Something else saved .env.local while jadpo config set was saving a value in it

The .env.local file holds bytes that aren't UTF-8 text

The .env.local file is there, but it couldn't be read: it is a folder, or you aren't allowed to read it

A line of .env.local isn't blank, a # comment or NAME=value, or it sets a variable a line above it already sets

The .env.local file that jadpo config set would save a value in is a link, not an ordinary file

Saving a value in .env.local failed, usually because the project's folder can't be written

A constant jadpo config move was asked to make a setting has the name of a setting config { } already declares

A constant jadpo config move was asked to make a setting is read where a setting can't be: in a query, an update by id, a backfill or another constant's value

A constant jadpo config move was asked to make a setting has a type one environment variable can't hold, such as a list or an object

A setting's value on this machine, from the environment or .env.local, doesn't fit the type config.jadpo gives it

A setting config.jadpo declares without a default: has no value on this machine, in the environment or .env.local

A package's answers to jadpo package conform don't fit the capability it fills, or the suite couldn't run

The conformance suite wasn't sent to the provider's live API, because the app has no connection to the package, nothing sets the connection's credential or address, or ai: doesn't ask its models through it

The id given to jadpo deliveries matches no delivery or schedule run in the database

The app's deliveries couldn't be read from their database, because it can't be reached or has no table for them yet

A delivery or schedule run was asked to do something its state rules out, such as cancelling one that has already failed

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

A jadpo email open command couldn't start the browser to open a mail's link

The flags' state couldn't be read or changed in their database, because it can't be reached, has no table for them yet, or changed while the command ran

A file jadpo fmt --check read isn't laid out as jadpo fmt would write it

A file was left as it was, because what the formatter made of it didn't read back as the same code, which is a mistake in Jadpo's formatter

A file jadpo fmt formatted couldn't be written, usually because it is read-only

Installing a package couldn't read its git repository, or found no release there at the tag you gave

Package to remove is still used by the app

Linked package in a CI or production build

The registry has no package of the name you gave, or no such release of it

The registry's answers don't prove the release is the one in its public log

The package you are installing has code that offers something different from its committed surface.jadpo_record

The release you asked for has been yanked, so it can't be newly installed

Applying the project's migrations to a database stopped at a step that failed

A migration removes data, and no acceptance in the project says a person agreed to it

The project's migrations need a PostgreSQL extension, such as pgvector, that the database server doesn't offer or that the role applying them can't create

The database server's PostgreSQL extension, such as pgvector, is older than the project's migrations and queries need

The migrations a database has applied don't match the project's: one has changed since it ran, the project doesn't have one, or one comes out of order

An advisory is against a declaration of an installed package that the app reaches

A registry's OpenAPI document differs from the registry protocol

The document given to jadpo package protocol couldn't be read as OpenAPI's JSON

An example or test of a package's last release fails against its new version, and the change isn't marked a fix

A package's new version changes or removes something its last release offered, within the same 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

The registry's verifier refused the release

A commit holds a file a release can't: anything but Jadpo source and the package's text files

A package's licence is Licence.proprietary, which the public registry refuses

What jadpo package publish would ask for isn't a pushed v<version> tag whose commit is the one checked out

A release names another publisher than the one asked to publish it

A package's index names no publisher, and it has to for the registry

The package's repository isn't one the registry can fetch: a public git repository reached over HTTPS

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

A commit's surface.jadpo_record or changelog list isn't what the package's code gives

A commit's release is past the size limit

A recording by jadpo package record or jadpo ai record got no answer worth keeping from the sandbox or the model, or its call couldn't be made

A recording was refused before anything was sent, because its connection would call a live API or has nothing set for its sandbox, its package is installed, or there is nothing to ask its prompt with

The registry couldn't be reached, or answered in a way that can't be read

The app's unfinished runs couldn't be read from their database, because it can't be reached or has no table for them yet

A schedule was run by hand while another run of it still holds its lease, so it wasn't run again

A schedule was run by hand against a deployment, and no tick of the app picked the run up in time, so nothing ran

A schedule run by hand ended in a failure, or its run on the app never ended

The app's schedules couldn't be read from their database, because it can't be reached or has no table for them yet

A seed jadpo seed ran stopped at a call that failed or faulted, and the calls before it stay in the database

A seed was run against a database that isn't on this machine, which may be production

The database a seed runs against couldn't be reached, so nothing was run

Suggestions settings are declared more than once

A suggestions record jadpo suggest reads, ignored_suggestions.jadpo_record or taught_suggestions.jadpo_record, isn't as Jadpo writes it

Jadpo HQ couldn't be reached, or refused what jadpo suggest share sent, so the entries wait to be shared again

Suggestions setting is given twice

Suggestions settings have no such option

The tests that need a database couldn't run, because PostgreSQL for the tests couldn't be started or reached

A test failed under jadpo test, or among a package's own tests under jadpo package check

A jadpo test command found no test to run: the project has none, or none matches the path, line, name, kind or --failed it gives

The tests couldn't start, because the machine couldn't give jadpo test the thread with a large stack they run on, usually for lack of memory

A file Jadpo writes for you, such as a record, couldn't be written, usually because it or its folder is read-only

The Rust jadpo build wrote for a deployable didn't compile, because the machine lacks something the build runs, such as a C compiler, or because of a mistake in Jadpo

The Rust toolchain or the crates jadpo build compiles with couldn't be fetched, usually because the server they come from, or the mirror in its place, can't be reached

You ran a command that works on a project in a folder with no app.jadpo, in it or in any folder above it

You ran jadpo new or jadpo package new with the name of a file that already exists

You ran jadpo new or jadpo package new on a folder that already has files in it, hidden files included

You ran jadpo new with a path that doesn't end in a folder's name, such as .. or /

You ran jadpo new or jadpo package new on a path Jadpo can't look into, such as a folder you can't read or a path through a file

You ran jadpo new or jadpo package new, and writing its files failed, usually because the folder they go in can't be written

A .jadpo file in the project couldn't be read, because it isn't UTF-8 text or you aren't allowed to read it

A file given to jadpo translations import isn't XLIFF 2.x or JSON in the shape export writes, or can't be read as one

A file given to jadpo translations import holds a unit of wording the project doesn't have

Suggestions setting has a value it can't take

A field that can't be stored sealed, or that says it isn't sealed when its type always is

An encrypted field is used somewhere the database or a log would have to read it

Erasing a person would clear a field that can't be none: a reference whose record erasure keeps, a marked field of a record it anonymises, or a marked field of the person's own record it keeps

A person's own record says something about erasure it can't: erase: on a field with anything but Erasure.retained or with no personal:, a reference that deletes a record that must stay, or a field named as the column erasure keeps

A restricted reference into records that erasing a person deletes doesn't say what erasure does to the record holding it

Erasing a person keeps records with Erasure.retained, their own or others', but their entity has no retention: saying when they go

A field's erase: is on a field erasing a person never reaches: one that isn't a reference, or a reference to records erasure never deletes

The application's field_encryption_key: reads something other than an EncryptionKey setting

A field is kept sealed, but the application names no key to seal it with

A field marked as personal data is on an entity erasing a person never reaches, so it could never be found

A field's retention: is on a field that can't be none, so its value could never be cleared

An entity's retention: would delete records that a restricted reference keeps from being deleted

A field's retention: would clear a field the entity's lifecycle owns or reads, changing which records are hidden or undoing what a transition set

A retention's after: isn't a Duration setting in config.jadpo

A retention's since: isn't one of the record's Instant fields

A query that finds erased people reads more than their id and the fields erasure keeps of them

A query says include_erased: true on an entity that keeps nothing of an erased person

A disk store's path: isn't an absolute folder outside the project

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

An email template includes a partial that doesn't exist, can't be reached from it, 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

An email template calls a function, does arithmetic or builds a value, when it may only read its fields, translate and format

An email template writes out a value that isn't text, a number or an enum with wording, such as a date

A flag in flags { } isn't a Bool or an enum of plain variants, or its default:, owner: or expires: is missing or isn't valid

A flag's expires: date has passed while the flag is still declared

A function, a constant or other pure code reads a flag, which only an action, a test or a route's run: can

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

An app declares flags but no database named to keep their state in, because it has several databases or none

Code or a test's flags: names a flag that flags { } doesn't declare

A flag is read where no test that reaches the read gives it one of its values

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 rate limit's window is one its store can't count

A rate_limit: doesn't say how many requests over how long, or says it wrongly

An entity's search: holds something it doesn't take, or leaves out what it needs

A query searches an entity by words that has no search: section

A threshold in thresholds { } doesn't watch one thing, gives a limit that doesn't apply to it, or gives a value a limit can't take

A threshold watches a route, action, query, schedule or subscriber its domain doesn't have

Code reads a whole file into memory from a file field that can hold more than the 10 MB a whole read allows

Generated record was edited by hand

A record file in the project was written by a newer Jadpo, in a format this one can't read

A record file that Jadpo writes from your code is missing, or no longer matches the code

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

A list or text operation is given a count or a position that might be negative

A key held as data is read as a value, when it goes only into a key-type field or a crypto call's key:

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

You declared a type with the same fields as a standard type, such as a start and an end, under a name of your own

Format shows a part a local time doesn't have

A plain number is given where a physical quantity, such as a length or a mass, needs its 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 prompt writes a free-text value, such as text a user typed, in its instructions rather than in its request

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 type has a field that its prompt file never writes

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 value from a field marked to_models: false, which must never be sent to a model, reaches a prompt or text sent for an embedding

Code stores a value from a field marked as personal data, or to_models: false, in a field that doesn't carry the same 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

Your code sends a model personal data of a kind, such as health records, that the app's ai: settings don't allow it to send