Skip to main content

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​

MeaningCall/return does not satisfy an explicit contract Pred
LayerL1 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​

MeaningEntry/export function has undigested may-throw
LayerL2 error (default)
Displaythrows TypeError on the signature line
engine-verifiedRun in Playground
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​

MeaningThe module's top-level code always throws, so the module can never be imported
LayerL2 error (default)
Displaymodule 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:budget cannot 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:budget quickfix (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 }) — the stub() form is required: an arrow-function mock is not constructible, and new on it would trade this Info for a throws TypeError may-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.

Next​