Diagnostics glossary
Stable codes printed by nudo check / analysis. Product-native messages use actual ⊭ expected (Nudo Abs implication), not TypeScript diagnostics in disguise.
Machine-readable face: nudo check --json. Agents: see Agents and the published agents.md.
Contract gate (L1)
nudo:constraint-violated
| Meaning | Call/return does not satisfy an explicit contract Pred |
| Layer | L1 error |
| Source | *.nudo.js / @nudo:contract |
// needsPositive with @nudo:contract x positive
needsPositive(-1);
// actual: -1 #exact
// expected: x > 0
Fix: tighten the call site, or correct the contract if the obligation was wrong. Intentional out-of-range input is not a product default — change the contract, do not “ignore” L1 silently.
Context: L1 — explicit contracts · Gate with check
nudo:assign-mismatch
Assignment / binding shape does not satisfy a previous contract shape (leqAbs structural fail). Fix the value or the declared slot.
Context: L1 — explicit contracts · Contracts
nudo:arg-structure
HOF argument is not a callable fn or arity mismatches an explicit relation contract. (Body-promote suggestions are warnings, not this error.)
Context: nudo check · Contracts
Call-site verification precision
These fire from call-site / contract verification (checkCall / checkArg): when a call is checked against a generalized parameter face, the checker reports not only violations but also degraded verification — honest "cannot prove" instead of silent pass.
nudo:constraint-unproven
cannot prove the argument satisfies x > 0
Argument pred does not provably imply the contract pred, and it is not a literal the engine can decide. Warning — verification is inconclusive, not failed. Fix: add a call site / @nudo:case, or state preconditions via --assume.
Context: nudo check · Predicate implication (bounded)
nudo:arg-opaque
argument type is unknown; cannot verify constraint x > 0
The argument Abs is unknown (no term) — the constraint cannot even be checked. Warning — add a call site or @nudo:case, or provide preconditions via --assume. Model the value's source (env / mock) if the unknown is engine debt.
Context: any vs unknown · nudo check
nudo:arg-count
scale expects 2 argument(s), got 1
Arity mismatch between the call and the generalized parameter face. Error.
Context: nudo check · Usage sites (--from)
nudo:fn-not-found
function nope not found
A call references a function the analyzer cannot resolve in scope. Error — check the name / export, or provide the missing module via env / @nudo:mock-module.
Context: @nudo:mock-module · Dependency types
nudo:partial-result
f(...) result confidence partial
Result Abs carries #partial confidence. Info — observation only. Suggestion: add a call site or constraint to improve precision.
Context: nudo check · Usage sites (--from)
nudo:case-inconsistency
A declared @nudo:case witness conflicts with an explicit refine. Debug witness vs contract disagree — fix the witness or the contract.
Context: @nudo:case · Declared assertions
nudo:contract-param-mismatch
Handwritten contract param name is not on the formal surface. Legal names: plain parameter names, destructured binding names (source property keys for renames), and dot-path keys for nested destructuring ('card.grade' for ({ card: { grade } })) — see Sidecar auto-binding.
Context: Contracts first · Contract diagnostics
nudo:contract-conflict
Handwritten contract conjunction is unsatisfiable. Simplify the sidecar / refine.
Context: Contracts first · Contract diagnostics
nudo:contract-load
Sidecar file failed to load (parse / import / resolution error). Error. Fix the sidecar, or remove the binding if the contract is gone.
Context: Sidecar auto-binding · Contract diagnostics
nudo:contract-name-clash
Sidecar export name collides with a source export, or emit would overwrite a handwritten binding. Handwritten always wins.
Context: Emit generated segments · Contract diagnostics
nudo:contract-cycle
Sidecar @nudo:import chain forms a cycle. Error. Fix: break the sidecar import cycle.
Context: @nudo:import · Contract diagnostics
nudo:contract-domain-exceeds
Cross-file call-site evidence injected via nudo check --from is not within the handwritten contract domain (⊄). Error. Fix: widen the contract, or correct the usage site.
Context: Contract diagnostics · Usage sites (--from)
nudo:contract-drift
Persisted @generated sidecar segment ≠ today's recomputed call-site domain or return. Warning — does not gate exit.
Context: Emit generated segments · Contract diagnostics
nudo:contract-entry-only
Exported function has no contract root (no handwritten / generated sidecar or @nudo:contract) and no call-site domain (only synthesized entry@ with any params). Info — coverage/contract gap, not a gate failure. Fix: add a contract (*.nudo.js / @nudo:contract) or exercise the export from usage sites (nudo check --from).
Context: Observation → draft · Contract diagnostics
nudo:dual-entry
dual-entry package "lib": browser (./browser.js) and node (./node.js) call-site
records do not cross files — analysis observes only the browser entry variant
The package ships browser/node dual entrypoints (package.json exports conditions or a browser field pointing at a different file than main/node), and this analysis ran on one variant. Call-site records are file-scoped: evidence collected against the other entry does not inject here. Info — observation, not a gate failure. Never fires on single-entry packages or on shared helpers that are not an entry target.
Fix: analyze the entry you ship and mock or skip the other variant; do not expect --from records to merge across the two faces. Still a ceiling — see Limits.
Context: Call-site discovery ceiling
nudo:contract-emit-denied
emit target 'path/lib.js' is outside package.json#nudo.contract.emit allowlist (patterns match the source file path, not the sidecar path 'path/lib.nudo.js')
contract --emit refused to write a sidecar outside the configured allowlist. Warning — the write is skipped. The allowlist patterns match the source file path, not the sidecar path (the message names both). Fix: move the target, or extend package.json#nudo.contract.emit.
Context: Emit generated segments
nudo:contract-multi-declarator
generated section 'a, b' is a hand-merged multi-declarator form; kept verbatim
A @generated section was hand-merged into one multi-declarator export. Warning — kept verbatim (handwritten wins); split it into one export per section to make it re-emittable.
Context: Emit generated segments
nudo:contract-not-projectable
assembled sidecar failed round-trip (path); refusing to write
The assembled sidecar source failed to re-parse to the derived contract. Error — nothing is written. Report as engine debt (round-trip must succeed), and adjust the source until contract --emit --dry-run is clean.
Context: Emit generated segments
Runtime boundary (L2)
nudo:entry-may-throw
| Meaning | Entry/export function has undigested may-throw |
| Layer | L2 error (default) |
| Display | throws TypeError on the signature line |
export function getName(user) {
return user.name; // any receiver → may throw
}
Fix options: refine param to a shape; try/catch the path; or (while migrating) --ignore-throws TypeError / package.json#nudo.check.ignoreThrows / --entry-throws warning. L2 does not gate internal helpers.
Context: L2 — entry throws · @nudo:throws
nudo:module-throw
| Meaning | The module's top-level code always throws, so the module can never be imported |
| Layer | L2 error (default) |
| Display | module initializer always throws TypeError — the module cannot be imported … |
throw new TypeError("boom");
export function f() { return 1; } // never importable: loading the module throws
The evaluator reports the module as not analysed: every export is dropped, so
signatures degrade to unknown and no L2 entry evidence exists. Before this code
existed, that state was indistinguishable from "analysed, found nothing" (OK,
exit 0) — a green gate for a module the engine could not analyse at all.
Only syntactic evidence counts: a throw statement that the top-level
statement sequence executes unconditionally (descending through bare blocks
only). Conditional throws (if (typeof window === "undefined") throw …),
try/catch-absorbed throws, and throws the engine infers from its own
approximation of host APIs (a missing dependency modelled as a closed object, for
example) are not reported — real packages (typescript, react-dom,
vitest) load fine natively while the evaluator fails on them, so the engine's
"always throws" is not evidence about the program.
Fix/suppress: make the throw conditional if the module should be importable;
if throwing at load is intended, --ignore-throws <Kind> (the reported kind) or
--entry-throws off / package.json#nudo.check.entryThrows. One diagnostic per
module, not per entry.
Context: L2 — entry throws
Engine debt / observation
nudo:unknown-inference
True unknown on a signature — inference failed. Not unconstrained entry any. Fix: model env, add mock, or refine.
Context: any vs unknown · Dependency types
nudo:unproven-return
Return postcondition could not be proved (any / unknown / opaque face, or a widened/bound-less arm facing a bounded obligation, or an out-of-bounds marker arm — an abstract index read like d[m][n] on a loop-built table joins a synthetic undefined; the loop-bound/length relation is lost, so neither proof nor disproof is possible). A bare widened prim arm still proves a bound-less prim contract (number() / string()) — the value domain is known even without term/pred evidence; only bounds (gt(0), int, …) remain unprovable. Warning — inference failed to discharge the obligation; do not treat as success. Distinct from nudo:constraint-violated (definite violation).
Context: nudo check
nudo:assume-relied
sim: return contract proved via @nudo:assume d <= max
→ @nudo:assume is a user-supplied axiom — falsify it with concrete @nudo:case runs (nudo test)
A return-contract proof relied on a user-supplied lemma (@nudo:assume). Info — an audit annotation, not a gate: the engine verifies the obligation (the return contract), never the lemma itself. The report suggests falsifying the lemma with concrete @nudo:case runs (nudo test) — a wrong lemma makes the affected proof unsound, so the reliance must stay visible. Complement of nudo:unproven-return (cannot prove — honestly kept as a warning).
Context: @nudo:assume · nudo check
nudo:invariant-relied
levenshtein: return contract proved via @nudo:invariant dp[*][*] >= 0
→ @nudo:invariant is a user-supplied axiom — falsify it with concrete @nudo:case runs (nudo test)
A return-contract proof relied on a user-declared loop invariant (@nudo:invariant). Info — an audit annotation, not a gate: the engine verifies the obligation (the return contract), never the invariant itself. The report suggests falsifying it with concrete @nudo:case runs (nudo test) — a wrong invariant makes the affected proof unsound, so the reliance must stay visible. Complement of nudo:unproven-return.
Context: @nudo:invariant · nudo check
nudo:invariant-inferred
loop-carried 's' was widened after 9 observed iteration(s) (observed bound: s >= 0; widening dropped it)
→ an observed extreme is NOT a proved invariant — declare @nudo:invariant only if the bound truly holds
A loop-carried scalar was widened after the engine observed a few iteration snapshots. Info — an observation hint, never a proof premise: the reported extreme is one-sided evidence from a bounded number of iterations, so it is not an invariant and does not participate in any proof. Declaring @nudo:invariant explicitly is the only way to make the engine rely on a bound (audited via nudo:invariant-relied).
Context: @nudo:invariant · nudo check
nudo:unknown-recv
Member access on unknown receiver. Does not replace L2 throws modeling.
Context: any vs unknown · L2 — entry throws
nudo:builtin-unknown
API not covered by env/inference (e.g. unmodeled global). Prefer @nudo:env / mock.
Context: @nudo:env · Dependency types
nudo:capability-denied
A host global or node: module classified as side-effectful is disabled for untrusted analysis (strict capability mode — the default). The value degrades to unknown and never executes natively; mock it (@nudo:mock / @nudo:mock-module) when its shape is needed, or analyze trusted code with NUDO_CAPABILITIES=trusted. This is defense in depth, not a sandbox claim.
Context: Execution model and trust boundary
nudo:opaque-result
Evaluation returned opaque / uninformative Abs.
Context: Evaluator gaps
nudo:recursion-truncated
Recursive evaluation was cut short; the result widened to unknown#opaque. The message — and the reason field in check --json — tells you which kind:
cycle— a call with the same abstract arguments was already on the evaluation stack (data-dependent self/mutual recursion, e.g.walk(dir, out)recursing on(dir, out)). This is not a budget: raising@nudo:budgetcannot lift it. Make the recursion arguments vary per level, narrow the base case, or declare@nudo:contract.depth/calls— the call budget (depth 64 / 20,000 total entries) ran out. The suggestion and the@nudo:budgetquickfix (nudo check --fix/ LSP code action) carry a concrete value derived from the observed depth/call count (default-limits ×2 floor, i.e.@nudo:budget depth=128/calls=40000— e.g.raise the function budget with @nudo:budget depth=128 (or narrow the recursion base case / declare @nudo:contract return)); otherwise restructure the recursion.
Budget knobs and what to do: Performance.
Context: Analysis budgets
nudo:fork-truncated
Branch-expansion budget ($fork total count) hit; affected results widened. Info. The suggestion carries a computed ceiling from the observed fork count — max(20000, observed × 1.5, rounded up to the next thousand) — e.g. fix: package.json#nudo.analysis.maxForks=20000 (observed 6 forks this run), or @nudo:budget forks=20000 on the function — non-blocking. Raise via NUDO_MAX_FORKS, package.json#nudo.analysis.maxForks, or the per-function @nudo:budget forks=N (default 5000). Budgets and fixes: Performance.
Context: Analysis budgets
nudo:loop-truncated
A loop's exit condition stayed concrete-true past the iteration budget (abstract unroll cap 8, concrete extension cap 1024 — e.g. an unbounded while (i < n) with concrete i/n); the loop state was widened (bounded, not exact). Info. This is a loop iteration budget, not the call budget — @nudo:budget calls=…/depth=… cannot lift it. Make the bound data-dependent (abstract) or pin the result with @nudo:case / @nudo:contract — non-blocking.
Context: Analysis budgets
nudo:promise-micro-truncated
Promise microtask queue hit the hard cap (MAX_PROMISE_MICROS = 1024); remaining queued callbacks were dropped. Info. Affected promise results stay widened rather than silently wrong.
Context: Analysis budgets
nudo:promise-micro-error
A queued promise microtask threw while being drained at an eval exit. Info. The callback's effect is incomplete; inspect the reported error and the expression that queued the then/catch.
Context: Analysis budgets
nudo:math-fold-error
A Math native fold threw during analysis (host-tampered or divergent Math.*); the result was widened to number. Info. Keep Math.* builtins unmodified in analyzed code, or mock them with @nudo:mock — non-blocking.
Context: Mocking external dependencies
nudo:host-effect-blocked
Host side-effect function (fetch / XMLHttpRequest / WebSocket / EventSource / setTimeout / setInterval / setImmediate / queueMicrotask / requestAnimationFrame / requestIdleCallback) was not executed during analysis — running it for real would perform network I/O or schedule real timers with Abs arguments. Result widened to unknown#opaque. Info. The suggestion carries a pasteable single-line @nudo:mock skeleton for the blocked host name (paste it into the JSDoc of the calling function), or feed the value in from a call site:
fetch→mock it: @nudo:mock fetch = (url) => ({ ok: true, json: () => ({ id: 1 }) }) (single line, in the calling function's JSDoc), or pass the value in from a call site — non-blocking- timers (
setTimeout/setInterval/setImmediate/queueMicrotask/requestAnimationFrame/requestIdleCallback) →@nudo:mock setTimeout = stub().returns(0) - constructors (
new WebSocket(url)/XMLHttpRequest/EventSource) →@nudo:mock WebSocket = stub().returns({ send: () => 1, close: () => 1 })— thestub()form is required: an arrow-function mock is not constructible, andnewon it would trade this Info for athrows TypeErrormay-throw.
All skeletons are verified end-to-end: pasted verbatim into the calling function's JSDoc, the diagnostic disappears and the result regains precision (promise<{ id: 1 }> / timer id / exact object shape). Syntax rules: Mocking external dependencies.
Context: Mocking external dependencies · @nudo:env
nudo:no-signature
Function could not be generalized (CJS/anon forms still get L2 via entry fallback).
Context: Evaluator gaps · nudo check
nudo:no-method
Member access that cannot resolve: Method 'x' does not exist on type 'T' / Property 'x' does not exist on type 'T'. Error on primitive receivers (number / boolean / bigint / symbol), warning otherwise. Distinct from nudo:unknown-recv (which fires on an unknown receiver).
Context: Evaluator gaps
nudo:mock-invalid
A @nudo:mock expression could not be parsed as a known pattern (stub/spy/mock forms, arrow functions, or type expressions). Warning — check the supported forms.
Context: Mocking syntax · @nudo:mock
nudo:directive-syntax
Malformed @nudo:case / @nudo:mock / @nudo:as / @nudo:skip directive syntax (bad name, trailing comment, unrecognized type expression). Warning — the directive is ignored; fix the form.
Context: Directive syntax · Skip grammar
nudo:contract-syntax
Malformed @nudo:contract segment or @nudo:import form (e.g. x > 0 instead of x positive, default import). Warning — the segment is ignored; use <param> <constraintName> or return <constraintName>.
Context: Contracts · Contract gate (L1)
nudo:assume-invalid
sim: malformed @nudo:assume 'd <= 10' (expected <param> <= <param> or <param> >= <param>; constant bounds belong to sidecar contracts)
sim: @nudo:assume name(s) not bound as parameters or top-level locals (x, y)
A @nudo:assume segment is outside the var <= var grammar, or references names that are not parameters or top-level const/let/var locals of the anchored function's body (destructuring, nested blocks, and for-init declarations do not count). Error — the segment is ignored; no lemma folds. The grammar accepts only <name> <= <name> (>= is normalized to le); < / > / == and constant bounds (d <= 10) are invalid — constant bounds belong to sidecar contracts (number().le(10)); the directive is only for cross-variable lemmas the engine cannot derive.
Fix: reference names bound as parameters or top-level locals of the anchored function; move constant bounds into a sidecar / @nudo:contract (for a local's constant bound, put the contract on the return of the callee that produces it).
Context: @nudo:assume · Contract gate (L1)
nudo:invariant-invalid
levenshtein: malformed @nudo:invariant 'dp[*][*] == 0' (expected <name><path> <rel> <number>; path = [*] or .member steps)
f: @nudo:invariant name not bound as a parameter or top-level local (table)
A @nudo:invariant segment is outside the <name><path> <rel> <number> grammar (== / != / non-numeric bounds are invalid), or references a name that is not a parameter or top-level const/let/var local of the anchored function's body. Warning — the segment is ignored; no invariant strengthens loop joins, so proofs that depended on it stay honestly unproven.
Fix: use >= / <= / > / < with a numeric constant (dp[*][*] >= 0, .ident for object slots), and reference names bound as parameters or top-level locals of the anchored function.
Context: @nudo:invariant · Contract gate (L1)
nudo:env-unresolved
path env failed to load: ./nudo-env.mjs — Cannot find package '@nudojs/env'
path env failed to load: ./nope.mjs — path env not found: <resolved-path>
unknown env name "bogus" (built-in envs: es, web, node; a path env needs a ./ or ../ prefix)
env file must export a defineEnv() function (got undefined)
A path-type env entry (package.json#nudo.env path item, or /// @nudo:env <path>) failed to load — either the direct import() and the bare-specifier rewrite fallback both failed, or the pointed-to file does not exist. Warning — the env falls back to "env off" semantics for that entry, so the analysis silently loses those bindings (a run where the env loads can infer more); do not treat the warning as benign.
The same code also covers two env contract failures: an env name that is neither a built-in (es, web, node) nor a path (a path env needs a ./ or ../ prefix), and a path env file that does not export a defineEnv() function, exports a non-function, throws while being evaluated, or returns something other than { globals }. Both were silent before: the env simply did not apply and the affected code was then judged to always throw ReferenceError. A non-string entry in package.json#nudo.env is reported the same way instead of crashing.
Emitted by: nudo check (issues section), nudo test (env warnings section, identical line format; with --json the warning goes to stderr so stdout stays a single JSON document), and the LSP (warning diagnostic with this code, same message format). It never gates the exit code.
Fix: check that the package.json#nudo.env path (or /// @nudo:env <path>) points at an existing, intended file and that its imports resolve — fix the import specifiers inside the env file, make sure @nudojs/env (and @nudojs/core) are resolvable from the project, or drop the entry.
Context: Env & harvest
nudo:env-harvest-conflict
handwritten @nudo:env wins over harvest on module "fs"; harvest only fills missing slots
A handwritten @nudo:env module and the @types harvest both supply the same module key or export. Warning — the handwritten env is authoritative (mergeHarvestUnderEnv); harvest only fills missing slots. To silence: remove the overlapping export from the handwritten env, or accept the precedence.
Context: Common pitfalls
nudo:contract-underivable
A derived contract row (root-driven derivation / nudo contract --draft) cannot be derived from source evidence (opaque / truncated / no evidence). Info — the row is skipped; handwritten contracts are never flagged by this code.
Context: Observation → draft
nudo-unreachable
Code after return/throw — info level. Note the hyphen: this is the one diagnostic id without a colon.
Context: nudo check
nudo:may-throw
Case-path may throw (test / clue). L2 elevates entry throws.
Context: L2 — entry throws · @nudo:throws
nudo:internal
Check error: <message>
Internal analysis/check failure surfaced as a diagnostic (check gate could not run to completion). Error — the check channel must not silently disappear; fix the underlying failure or report the bug.
Context: nudo check
Module graph
Reported when Abs module evaluation (evalAbsModuleGraph) hits a load problem. cycle/depth are warnings; missing / missing-export are errors.
nudo:module-cycle
Circular module load: a.js -> b.js -> a.js
(bindings inside the cycle resolve to their partially evaluated types)
Fix: break the cycle (extract shared logic) or accept the partial types.
Context: nudo check
nudo:module-depth
Module load chain too deep (depth N > M max): a.js -> b.js -> …
(loading truncated, deeper modules typed as unknown)
Fix: the chain exceeds the loader depth budget — flatten re-export hops or raise the budget.
Context: nudo check
nudo:module-unreadable
cannot read module '/abs/path/dep.js' (EACCES): EACCES: permission denied, open '/abs/path/dep.js'
Error. The dependency exists but cannot be read (EACCES / EIO / EMFILE / ESTALE …). Distinct from nudo:module-missing (no such file): the file is there, only unreadable — its types stay unknown and the gate fails closed. Fix: fix the file permissions (or the module path); the dependency is present but unreadable, so its types are unknown.
Context: @nudo:mock-module · nudo check
nudo:json-invalid
JSON module './data.json' (from main.js) is not valid JSON: <parser message>
Error. A .json dependency is syntactically invalid JSON. Distinct from nudo:module-missing (the file is absent) and nudo:module-unreadable (the file cannot be read): the file is there and readable, but its content is not valid JSON, so no value can be imported. Fix: correct the JSON syntax — trailing commas, comments and single quotes are not valid JSON.
Context: nudo check
nudo:module-missing
Module file not found for 'spec' (from file); tried: path
Error. The analyzed file imports a module the loader cannot resolve. Fix: correct the spec, or mock the module (@nudo:mock-module / @nudo:mock).
Context: @nudo:mock-module · nudo check
nudo:exports-unresolved
Package.json exports declared targets but the subpath/conditions did not resolve to a file. Warning — analysis fell back to harvest stub / file guess, which may not match the real entry. Distinct from nudo:module-missing (no module at all).
Context: Evaluator gaps
nudo:missing-export
Module './m.js' has no export 'b' (from index.js)
Error. A named import (or export { x } from) references a name the source module does not export — typically a typo. Only reported when the source module's export table came from a successful evaluation (fail-closed empty tables and unresolved modules stay silent so this never stacks on nudo:module-missing). Fix: correct the imported name, add the export to the source module, or mock the module (@nudo:mock-module).
Context: @nudo:mock-module · nudo check
nudo:missing-slot
Field 'name' is missing on the evaluated object shape
Warning, default off. C0.5: evaluation actually hit a closed object shape's missing field (opt in with package.json#nudo.analysis.evalMissingSlot: "warning"). It is observation, not an obligation — it never invents check errors; handwritten contracts still gate through nudo:constraint-violated.
Context: Non-goals
Test assertions (nudo test)
nudo:case-expected
debug "bad": expected 5, got 4. The inferred return type does not match the
expected type declared in the @nudo:case witness
A declared @nudo:case "name" (…) => expected witness whose expected type does not match the inferred result. Error in the test run — a declared assertion failure sets nudo test exit 1; synthetic call@ / entry@ cases never fail the run.
The failure face in the report:
=== double ===
debug "bad" (2) => 4
assertions
✗ 0 passed · 1 failed · 0 unchecked
[FAIL] double case "bad"
expected: 5
actual: 4
Fix: correct the witness expectation or the function body.
Context: Declared assertions · @nudo:case
CLI path resolution
Path errors from CLI target / --from resolution — collected in the --json envelope's pathErrors[] ({ path, code, message, suggestion? }), or printed as a one-line reason + fix: hint on the human face. Non-empty pathErrors ⇒ ok: false ⇒ exit 1. Usage errors before analysis starts — not Abs diagnostics.
nudo:path-not-found
Not found: /abs/path
The requested path does not exist. Error (usage) — check the path; it must be an existing .js/.mjs/.ts file or a directory containing them.
Context: nudo check · What it checks
nudo:path-empty-dir
No nudo files found in directory: /abs/dir
The directory exists but holds no analysis targets. Error (usage) — add .js/.mjs/.ts sources (or point at a directory that has them); sidecar/decl/JSX are skipped.
Context: nudo check · What it checks
nudo:path-not-target
Not an analysis target (need .js/.mjs/.ts, not sidecar/decl/JSX): /abs/file.nudo.js
The file exists but is not an analysis target (.nudo.js sidecars, .d.ts decls, and .jsx/.tsx are excluded). Error (usage) — pass a .js/.mjs/.ts analysis file.
Context: nudo check · What it checks
nudo:path-missing-callsite
Callsite file not found: /abs/tests
A --from usage-site path does not exist. Error (usage) — pass --from <file-or-dir> that exists; it supplies call@ records for generation.
Context: Usage sites (--from) · nudo check
nudo:path-io
export --out mkdir failed: out/dir
A --out output-directory IO operation failed (mkdir / write). Error (usage) — the raw errno never reaches the product face; check that --out <dir> is writable and is a directory path, then re-run. (BUG-023: added so nudo export carries the same PathError face as check / test.)
Context: nudo export
nudo:migrate-strip-failed
migrate strip: src/cls.ts: the emitted .js would still contain TypeScript syntax (class member modifier 'private') — Node cannot parse it
nudo migrate strip --write refused to write a product that Node cannot parse. Error (usage) — the strip pass removes type syntax only; whatever it cannot lower itself must be lowered by hand (or by tsc). Class member modifiers (private / public / protected / readonly / abstract / override) and constructor parameter properties are lowered by the strip pass now (the modifiers are dropped; a parameter property becomes a field plus a this.x = x assignment in the constructor body), so they no longer trip this gate — what still trips it is a construct the pass cannot lower (e.g. a destructured constructor parameter property). migrate is a one-way gate: a half-written .js has no rollback path, so the file is left untouched and named.
Context: nudo migrate
Reading actual ⊭ expected
actual: 0 #exact // Abs observed at the call
expected: price > 0 // Pred from the contract
Conf markers on Abs: #exact / #path / #widened / #mock / #partial / #opaque — see Abs.
Config that affects diagnostics
{
"nudo": {
"analysis": { "mode": "exports", "evalMissingSlot": "off" },
"check": {
"ignoreThrows": ["TypeError"],
"entryThrows": "error"
},
"contract": { "autoBind": true }
}
}
ignoreThrows / entryThrows affect L2 only — they never swallow L1 contract violations.