Diagnostics reference

Every diagnostic Xeer emits carries a stable XE#### code. There are 106 of them, and this page is generated from the same catalogue the compiler and CLI emit from, so it cannot fall behind.

Codes are stable; messages are not. Dispatch on code, read message and span for the location, and treat hint as the platform's own suggested edit.

TypeScript

interface Diagnostic {
  code: string;                 // XE####, stable
  severity: 'error' | 'warning' | 'info';
  message: string;              // human wording, free to change
  file?: string;                // project-relative POSIX path, never absolute
  span?: { line: number; column: number; length?: number };  // 1-based
  hint?: string;                // suggested edit
}

Every command prints these as JSON with --json; see Building with AI agents. The "Seen in" column lists the commands whose output can carry the code. check diagnostics also appear in build and dev, because both run the same manifest and analysis stages first.

#CLI (XE00xx)

The command itself failed. Not an application defect.

Code	Seen in	Means	Repair
`XE0000`	any	The CLI crashed before it could report a structured result. Written to stderr, so it is the one code that can arrive outside a JSON envelope.	Report it: an internal error is a platform bug, not a project defect. stderr carries the stack.
`XE0001`	any	Unknown or unimplemented command.	Read `xeer --help` and use a documented command.

#Manifest (XE10xx)

xeer.app.json is missing, unparseable, or violates the application-source schema — including the database schema, indexes, capabilities, and budgets it declares.

Code	Seen in	Means	Repair
`XE1001`	check, build, dev, test	xeer.app.json was not found in the target directory.	Run `xeer new <directory>`, or point the command at the project root that holds the manifest.
`XE1002`	check, build, dev, test	A manifest value is invalid: bad JSON, a failed schema rule, or an entrypoint that does not exist. Also covers the declared database schema — unknown field types, an index naming a field the table does not declare, reserved field names, and tables declared without the "database" capability — and every capability declaration: an unknown capability name, one declared twice, a config block whose capability is not in `capabilities` (or the reverse), and a declared limit above the platform ceiling.	Read the message: it names the failing manifest path (for example database.tables.notes.indexes.by_owner) and the rule. Correct that one value. A capability and its config block are one declaration in two halves — `"capabilities": ["storage"]` and a `"storage": {}` block — so either add the missing half or remove the present one.
`XE1003`	check, build, dev, test	The manifest carries a property the application-source schema does not define.	Remove the property, or fix its spelling. The manifest is closed: unknown keys are never ignored.

#Manifest paths (XE11xx)

A manifest path does not resolve to a file inside the project root.

Code	Seen in	Means	Repair
`XE1101`	check, build, dev, test	An entrypoint path is absolute or escapes the project root.	Use a forward-slash path relative to xeer.app.json that stays inside the project.

#Module graph and zones (XE12xx)

The client and server graphs are walked separately. Each zone has its own package allowlist, every import must be a static literal resolving inside the project, and shared code lives under src/shared/. Type errors in the reachable graph land here too.

Code	Seen in	Means	Repair
`XE1201`	check, build, dev, test	A source import breaks the zone boundary: it is absolute, leaves the project root, reaches the opposite entrypoint, or the module is reachable from both graphs while living outside src/shared/.	Keep imports relative and inside the project. Move genuinely shared code to src/shared/ and update both importers; never import one entrypoint from the other.
`XE1202`	check, build, dev, test	A package import is not on the allowlist for that zone.	The client zone may import @impetik/xeer/client, /shared, the JSX runtimes, and preact; the server zone may import @impetik/xeer/server and /shared. Node builtins are never importable. Move the code to the zone that owns it instead of widening the import.
`XE1203`	check, build, dev, test	A dynamic import() specifier is not a string literal.	Use a literal specifier so the module graph stays statically knowable, or a static import.
`XE1204`	check, build, dev, test	A relative source import does not resolve to a file.	Write the specifier without an extension, or with the file's real one: the resolver appends candidate extensions rather than rewriting them, so ./shared/title.js does not find shared/title.ts. Directory imports resolve to index.*.
`XE1205`	check, build, dev, test	TypeScript reported an error in a file reachable from an entrypoint. The message starts with the TS#### code and span points at the exact position.	Fix the type error. Operation input and result types come from the generated contract, so a mismatch between a client call and its server handler surfaces here.
`XE1206`	check, build, dev, test	A stylesheet is imported outside the client graph.	Import .css only from client modules; the server bundle has no styling stage.

#Operations (XE13xx)

The default defineServer({...}) export is read statically, so operation and endpoint registration must be a literal object with valid, unambiguous names.

Code	Seen in	Means	Repair
`XE1300`	check, build, dev, test	The default server export is not a statically inspectable defineServer({...}) call, or an operation group is not a literal object.	Export `default defineServer({ queries: {...}, mutations: {...}, endpoints: {...} })` with literal object members: no spreads, shorthand, computed keys, or wrappers.
`XE1301`	check, build, dev, test	Two operations in the same group share a name.	Rename one of them, or delete the duplicate registration if it was a copy-paste.
`XE1302`	check, build, dev, test	An endpoint key is not `METHOD /api/path`.	Use an uppercase HTTP method, one space, and a literal /api path; dynamic segments are :name.
`XE1303`	check, build, dev, test	A query or mutation name is not namespaced.	Use a dotted lowercase name such as notes.list.
`XE1304`	check, build, dev, test	Two endpoints reduce to the same route shape, so dispatch would be ambiguous.	Change the method or a static path segment. Parameter names do not distinguish routes: GET /api/notes/:id and GET /api/notes/:slug are the same route.

#Budgets and assets (XE14xx)

A module or public asset breaks a v0 size limit, collides with generated output, or claims a platform-reserved path.

Code	Seen in	Means	Repair
`XE1401`	build, dev, test	A compiled module (10 MiB) or an asset (25 MiB) exceeds the v0 limit.	Shrink the module or asset. There is no flag that raises a v0 limit.
`XE1402`	build, dev, test	A file in public/ collides with generated output.	Rename the public file; imported client CSS owns /assets/app.css.
`XE1403`	build, dev, test	A file in public/ claims a platform-reserved path.	Move it: /_xeer/* and /__xeer/* belong to the platform.

#Bundling (XE15xx)

The client or server bundle failed after analysis passed.

Code	Seen in	Means	Repair
`XE1501`	build, dev, test	Bundling failed after the module graph and types were accepted.	Read the bundler message in `message`. It usually names a syntax construct the target does not support, rather than a Xeer rule.

#Development loop (XE16xx)

A watch rebuild failed. The last-good preview stays active and is rolled back to; these codes arrive as compile.diagnostic events, never as a dead server.

Code	Seen in	Means	Repair
`XE1602`	dev	A watch rebuild failed. The previously accepted generation is still serving.	Fix the edit named by `file`. The next quiet-window rebuild promotes automatically; no restart.
`XE1603`	dev	A rebuilt candidate compiled but failed to take over — usually a manifest or schema change the running state cannot accept — and the last-good generation was restored.	Fix the manifest or schema change. To adopt an incompatible schema locally, stop dev and run `xeer state reset . --state dev --confirm <application>`.
`XE1604`	dev	The manifest could not be watched for changes, so edits to it will not rebuild the preview. Everything already serving keeps serving.	On Linux this is normally an exhausted inotify allowance: raise `fs.inotify.max_user_watches` and `fs.inotify.max_user_instances`. Restart `xeer dev` afterwards.

#Artifact preview (XE17xx)

xeer preview verifies the content-addressed artifact and its blobs before booting. These codes mean the build output is missing, malformed, or does not match its own identity.

Code	Seen in	Means	Repair
`XE1700`	build, preview, test, deploy, state	No verifiable build artifact was found for preview.	Run `xeer build` first; preview never compiles.
`XE1701`	build, preview, test, deploy, state	The artifact, its latest pointer, or its server source map is malformed.	Rebuild with `xeer build`. Do not hand-edit anything under .xeer/build/. If a fresh build reports this itself, it is a compiler defect: report it with the diagnostic.
`XE1702`	build, preview, test, deploy, state	The artifact does not match its own content-addressed identity or schema identity.	Rebuild. A mismatch means the output was mutated after it was written.
`XE1703`	build, preview, test, deploy, state	An artifact blob is missing, the wrong size, or hashes differently than its receipt.	Rebuild. The build output is incomplete or corrupted.
`XE1704`	preview	The artifact preview server failed to start or crashed.	Read `message`. Re-run `xeer build`, then preview again.

#Local state and state transfer (XE18xx)

Local dev/preview/test state is leased per project and mode, destructive resets are confirmed by exact application name, and xeer export/xeer import move it as a versioned xeer.state-export.v0 document that must fit the schema currently in force.

Code	Seen in	Means	Repair
`XE1801`	state	A state command was invoked without a valid --state selector.	Pass `--state dev`, `--state preview`, or `--state test`. The three modes never share a root.
`XE1810`	state	A destructive state command was invoked without --confirm.	Pass `--confirm <application>` using the manifest `name` exactly.
`XE1811`	state	The --confirm value does not match the application name.	Use the manifest `name` verbatim; the guard is exact-match by design.
`XE1812`	dev, preview, test, state	The local state lease for that project and mode could not be acquired, or is held by a live process. Two concurrent `xeer test` runs in one project report this rather than racing.	Stop the other `xeer dev`/`xeer preview`/`xeer test` for this project and retry.
`XE1813`	dev, preview, test, state	The resolved state directory escapes the project or traverses a link.	Remove the link under .xeer/ and retry. State must stay inside the project.
`XE1814`	dev, preview, test, state	A local state operation failed for an underlying filesystem reason.	Read `message`. Usually permissions or a partially removed .xeer/ directory.
`XE1820`	export, import	No `xeer dev`/`xeer preview` server owns that mode's state in that directory, or it has not published its address yet. Local state lives in a Durable Object, so only the running runtime can read or write it.	Start `xeer dev` (or `xeer preview`) in that directory and re-run, or pass a deployed application name, appId, or URL instead.
`XE1821`	export, import	The export file could not be read or written.	Read `message`: usually a missing path or permissions. `--out` creates parent directories.
`XE1822`	export, import	The document is not a usable xeer.state-export.v0 export: wrong protocol, or it contradicts itself (counts, schema, or an encoded value).	Import the unmodified file `xeer export --out` produced. `detail.code` names the exact defect.
`XE1823`	import	`xeer import` was pointed at a deployed application. It writes local dev and preview state only; a deployed import needs a write-scoped grant and a pre-import snapshot.	Import into `xeer dev`/`xeer preview` state (`--state dev`), verify there, and `xeer deploy`.
`XE1824`	export, import	The runtime refused the transfer. `detail.code` is the reason: state_import_schema_mismatch, state_import_application_mismatch, state_import_record_invalid, or state_export_too_large.	For a schema mismatch, `detail.expected` and `detail.found` carry both schema identities: check out the schema the export came from, import there, and let the compatible-change path carry the data forward, or re-export from the current schema. There is no forced import.
`XE1825`	export, import	The command was invoked without a usable target, without the export file, or with a --state value other than dev or preview.	Pass `<preview-url\|app>` or `--state dev\|preview [directory]`; `xeer import` also needs the file.

#Tests (XE19xx)

xeer test builds the project, type-checks tests/**/*.test.ts against the generated contract, and runs each test against a fresh isolated state. A failure carries the standard Diagnostic fields plus kind, matcher, expected, and actual, so the same parser handles it.

Code	Seen in	Means	Repair
`XE1900`	test	xeer test found no test files.	Create tests/.test.ts importing test, as, and expect from @impetik/xeer/test. `xeer new` scaffolds a passing suite to copy.
`XE1901`	test	A test file could not be compiled.	Read `message`: it is the bundler error for that file. Test files may import @impetik/xeer/test, @impetik/xeer/shared, and project-relative modules.
`XE1902`	test	The test runtime failed to start.	Not a test failure. Run `xeer build` and `xeer doctor` — the artifact or the local workerd toolchain is the problem.
`XE1903`	test	A test file threw while loading, so none of its tests ran. Other files still run.	Move work out of module scope and into a test body; only test registration belongs at the top level.
`XE1904`	test	An assertion failed. The failure carries `matcher`, `expected`, `actual`, and the project-relative test location.	Decide which side is wrong. If the application is wrong, fix it and re-run; if the expectation is wrong, fix the test. Never delete the assertion to go green.
`XE1905`	test	A test threw, including a call that was refused when the test did not expect it. `operation` names the persona, operation, status, and runtime error code.	When the refusal is the point, wrap the call in expectFailure(). A refused workspace-scoped call usually means the persona's declared membership does not contain the workspace the operation names: pass it with as({ name, workspaceIds }).
`XE1906`	test	A test exceeded its 20 second budget. The remaining tests still run.	Remove the wait: tests run against a local runtime, so a timeout means an unresolved promise or an operation that never returns, not a slow machine.

#Inspector (XE20xx)

An inspector request failed. Locally the target is a preview URL; for a deployed app the request is routed through the control plane and requires builder ownership.

Code	Seen in	Means	Repair
`XE2001`	inspect, state	An inspector command was invoked without a target.	Pass the preview URL from the dev/preview `preview.ready` event, or a deployed application name, appId, or URL.
`XE2002`	inspect, state	The inspector request itself failed: a local dev/preview inspector that answered a non-2xx status or no JSON, or a control plane that refused the proxied read, in which case the read never reached the application. An application that refused the read is XE2004.	Confirm the preview is still running and the URL matches the current `preview.ready` event. For a deployed read, `message` carries the control plane's own refusal.
`XE2003`	inspect, state	No deployed application matched the inspector target for the signed-in builder.	Pass the application name from xeer.app.json, its appId, or its deployed URL, and confirm with `xeer auth status` that you are signed in as its owner.
`XE2004`	inspect, state, export	The deployed application refused the read itself, and the control plane forwarded its answer. The application's own runtime code, its errorId, and the cause are in `message`, and in `detail` as `code`, `errorId`, and `appId`.	Dispatch on `detail.code`, not on the wording. `state_bootstrap_failed` means the application state never bootstrapped, so the read never ran: fix the cause named in `message` and redeploy. `state_unavailable` means the read never reached the state object at all — most often a brand-new application whose state namespace is not dispatchable yet — so there is nothing to fix: wait out the advertised retry and read again. Quote `detail.errorId` when correlating with the Worker's console output.

#Scaffold (XE30xx)

xeer new could not create the project.

Code	Seen in	Means	Repair
`XE3001`	new	xeer new could not scaffold the project — most often a non-empty target directory.	Choose an empty or non-existent directory.
`XE3002`	new	`--template` named a scaffold that does not exist. Refused before the target directory is read, so nothing was written.	Use one of the names the message lists, or omit --template for the default. `xeer --help` describes each template.

#Environment (XE40xx)

xeer doctor found a broken toolchain or generated-file state. The failing check id and details are in result.checks.

Code	Seen in	Means	Repair
`XE4001`	doctor	A doctor check failed. `hint` carries the check details as JSON, and result.checks lists every check with its id and status.	Fix the environment problem the failing check names. Doctor never edits the project.

#Builder authentication (XE50xx)

Builder sign-in against the control plane. Sign-in is a human step; an agent reads these codes and asks for it.

Code	Seen in	Means	Repair
`XE5000`	auth	An auth subcommand was invoked with wrong arguments.	Use `xeer auth <login\|status\|logout\|as\|clear>`; `auth as` takes alice or bob.
`XE5001`	auth, deploy	The --control-url value is not an exact HTTP(S) origin, or is plain HTTP off localhost.	Pass an origin such as https://control.example.com with no path.
`XE5002`	auth, deploy	No valid builder credential is stored.	A human must run `xeer auth login` and approve the shown code. An agent cannot complete sign-in.
`XE5004`	auth	The control plane returned a response the CLI will not trust.	Retry; if it persists the control plane is misconfigured or unreachable. Not a project defect.
`XE5005`	auth	The device authorization expired before sign-in completed.	Run `xeer auth login` again and approve promptly.
`XE5008`	auth, deploy	The stored CLI credential file is unreadable or invalid.	Run `xeer auth logout` and sign in again.
`XE5009`	auth	An auth command failed without a more specific code.	Read `message`; it is the underlying error verbatim.

#Deployment, project identity, and environment variables (XE51xx)

The deployment itself; the checked-in xeer.project.json appId that decides which hosted app a checkout deploys to, where the repair is always xeer link rather than a new appId; the per-project encrypted environment store behind xeer env; and the deployment history behind xeer deployments.

Code	Seen in	Means	Repair
`XE5101`	deploy	The deployment Worker module could not be constructed from the artifact.	Re-run `xeer build` and inspect the artifact; the build output is incomplete.
`XE5102`	deploy	The control plane rejected the deployment or answered without a usable JSON envelope.	Read `message`: it carries the control-plane error. Check sign-in and that the project name is claimable.
`XE5103`	deploy	The deployment was accepted but the deployed runtime never became ready.	The upload succeeded; the runtime did not. Retry, then report it — the artifact is already recorded.
`XE5104`	deploy	The deployment serves assets but authenticated requests fail.	A platform identity problem, not an application one. Report it with the diagnostic message.
`XE5105`	deploy	The --environment value is not a deployable scope.	Pass prod, production, or preview. `dev` is a local-only scope that `xeer env pull` writes to a gitignored file; no deployment ever injects it.
`XE5106`	deploy, promote, rollback	A capability the manifest declares could not be provisioned. Either the control plane could not create or adopt the backing resource (a per-app R2 bucket for "storage"), it is not configured to provision at all, or it does not support that capability name. Nothing was activated: the previous version is still serving.	Retry the deployment — provisioning is adopt-or-create, so a half-finished attempt heals on the next one. A capability the control plane does not recognise is not retryable: remove it from `capabilities` in xeer.app.json, or deploy against a control plane that supports it. `message` carries the control plane's own reason.
`XE5109`	deploy	Deployment failed without a more specific code.	Read `message`; it is the underlying error verbatim.
`XE5111`	deploy	The appId declared in xeer.project.json is owned by a different builder, so the control plane refused the deployment.	Run `xeer link --new` to fork this checkout into a new app you own, or `xeer link` to attach it to one of yours. A clone of someone else's project cannot silently take over their app.
`XE5112`	deploy	The builder is at their apps-per-builder quota, so the control plane refused to create the app this deployment would have claimed.	This quota is a standing cap and does not lift on its own. Run `xeer link` to deploy into an app you already own, or ask the Xeer team to raise it. `message` states the quota and your usage.
`XE5113`	deploy	The builder has spent their hourly or daily deploy quota.	Retry after the reset `message` states — it is the exact moment a slot frees, not a fixed backoff. Failed deployments count toward the quota, so a fix-and-retry loop spends it too.
`XE5120`	deploy, link, dev, preview, test, doctor	xeer.project.json exists but is unusable: not JSON, not an object, the wrong `format`, or without a valid `appId`.	Run `xeer link --app <appId>` to rewrite it, or `xeer link --new` to mint a fresh identity. A present-but-broken file is never repaired by guessing, because that would fork the app.
`XE5121`	deploy, link, dev, preview, test, doctor	The checked-in xeer.project.json and the local .xeer/project.json cache name different appIds.	The checked-in file wins. `xeer link --app <declared appId>` re-points the cache, or `xeer link --new` deliberately forks this checkout.
`XE5122`	link, deploy	An appId is malformed, or `xeer link` was given both --app and --new.	Run `xeer link` with no flags to list the appIds you own, then pass exactly one of --app or --new.
`XE5123`	link	The signed-in builder does not own a project with that appId.	Run `xeer link` to list your projects, or `xeer link --new` to create a new app for this checkout.
`XE5124`	link	The control plane returned an invalid project or project list.	Retry; if it persists the control plane is unreachable or misconfigured. Not a project defect.
`XE5129`	link	xeer link failed without a more specific code.	Read `message`; it is the underlying error verbatim.
`XE5130`	env	An `xeer env` invocation is wrong: an unknown --environment, a missing name or value, or no usable xeer.app.json in the target directory.	Read `message` and the usage it quotes. --environment takes prod, preview, or dev, and the command must run inside a Xeer project.
`XE5131`	env	The control plane rejected the environment-variable request.	Read `message`: it carries the control-plane error and hint. Check sign-in and that you own the project.
`XE5132`	env	The control plane returned an environment payload the CLI will not trust.	Retry; if it persists the control plane is misconfigured or unreachable. Not a project defect.
`XE5133`	env	A closed-beta quota refused the environment-variable request: `xeer env set` claims the project on first use, so it is capped by the same apps-per-builder quota as `xeer deploy`.	Set the value on an app you already own — `xeer link` lists them — or ask the Xeer team to raise the quota. `message` states the quota, your usage, and any reset.
`XE5139`	env	xeer env failed without a more specific code.	Read `message`; it is the underlying error verbatim.
`XE5140`	deployments	An `xeer deployments` invocation is wrong: an unusable --limit, or a directory that declares no app identity.	Read `message`. --limit takes a positive integer up to 200. In a directory with no appId, run `xeer deploy` or `xeer link` first, or name the app: `xeer deployments <app>`.
`XE5141`	deployments	The control plane rejected the deployment-history request.	Read `message`: it carries the control-plane error and hint. Check sign-in and that you own the app.
`XE5142`	deployments	The control plane returned a deployment listing the CLI will not trust.	Retry; if it persists the control plane is misconfigured or unreachable. Not a project defect.
`XE5143`	deployments	No app matched the reference for the signed-in builder.	Pass the application name from xeer.app.json, its appId, or its deployed URL, and confirm with `xeer auth status` that you are signed in as its owner.
`XE5149`	deployments	xeer deployments failed without a more specific code.	Read `message`; it is the underlying error verbatim.
`XE5160`	rollback	An `xeer rollback` invocation is wrong: a missing or malformed artifact id, an unknown --environment, or a directory that declares no app identity.	An artifact id is `sha256:` followed by 64 hex characters — copy it from the ARTIFACT column of `xeer deployments <app>`. --environment takes prod or preview; `dev` is never deployed.
`XE5161`	rollback	The control plane refused the rollback.	Read `message` and `hint`: they carry the control-plane error verbatim. A rollback is a deployment, so it can also be refused by the deploy quota.
`XE5162`	rollback	The control plane returned a rollback result the CLI will not trust.	Retry; if it persists the control plane is misconfigured or unreachable. Not a project defect.
`XE5163`	rollback	No app matched the reference for the signed-in builder, or it has already been deleted.	Pass the application name from xeer.app.json, its appId, or its deployed URL, and confirm with `xeer auth status` that you are signed in as its owner.
`XE5164`	rollback	This application has no completed deployment of that artifact — it belongs to another project, was never deployed here, or its deployment failed.	Run `xeer deployments <app>` and roll back to an artifact listed there. Only a deployment that completed can be rolled back to.
`XE5169`	rollback	xeer rollback failed without a more specific code.	Read `message`; it is the underlying error verbatim.
`XE5170`	token	An `xeer token` invocation is wrong: an unknown action, a missing or unusable --name, a token id that is not an `xstid_` value, or no interactively signed-in builder.	Issuing a service token requires `xeer auth login` first — the browser approval is the root of every credential an account holds, so a service token cannot mint another. Take ids from `xeer token ls`; the id is the `xstid_` value, never the secret.
`XE5171`	token	The control plane refused the service-token request.	Read `message` and `hint`: they carry the control-plane error verbatim. A service token cannot issue another one, and a disabled builder is refused every credential they hold.
`XE5172`	token	The control plane returned a service-token response the CLI will not trust.	Retry; if it persists the control plane is misconfigured or unreachable. Not a project defect.
`XE5173`	promote	No app matched the reference for the signed-in builder, or it has already been deleted.	Pass the application name from xeer.app.json, its appId, or its deployed URL, and confirm with `xeer auth status` that you are signed in as its owner.
`XE5174`	promote	This application has no completed deployment of that artifact — it belongs to another project, was never deployed here, or its deployment failed.	Run `xeer deployments <app>` and promote an artifact listed there. Only a deployment that completed can be promoted.
`XE5175`	promote	The application has no completed preview deployment, so there is nothing to promote.	Run `xeer deploy --environment preview` to put a version on the preview origin first, or name the version explicitly with `--from-artifact sha256:…`.
`XE5179`	token	xeer token failed without a more specific code.	Read `message`; it is the underlying error verbatim.
`XE5150`	disable, enable, delete	A lifecycle invocation is wrong: `xeer delete` without --confirm, or a directory that declares no app identity.	Deleting an application is permanent, so it requires its exact name: `xeer delete <app> --confirm <app>`. In a directory with no appId, name the app instead of relying on the directory.
`XE5151`	disable, enable, delete	The control plane refused the lifecycle change — most often because --confirm does not match the application name, or because it cannot delete the deployed Worker.	Read `message` and `hint`: they carry the control-plane error verbatim. A confirmation must equal the name in xeer.app.json exactly.
`XE5152`	disable, enable, delete	The control plane returned a lifecycle result the CLI will not trust.	Retry; if it persists the control plane is misconfigured or unreachable. Not a project defect.
`XE5153`	disable, enable, delete	No app matched the reference for the signed-in builder, or it has already been deleted.	Pass the application name from xeer.app.json, its appId, or its deployed URL, and confirm with `xeer auth status` that you are signed in as its owner. A deleted app never resolves again.
`XE5159`	disable, enable, delete	A lifecycle command failed without a more specific code.	Read `message`; it is the underlying error verbatim.