fix(new): prefer process.stdout.columns over tput for terminal width

feat(cli): add rspack config path option to build and start commands

…aries

feat(assets): add option to include library assets in app builds

feat(package-managers): add bun support

…odenext resolution (#3364)

Under `moduleResolution: 'node16'` or `'nodenext'`, ESM-style imports
require explicit file extensions. The PluginMetadataGenerator previously
emitted dynamic `import("./hello.dto")` calls without an extension,
causing TypeScript diagnostics in the generated metadata file and
`ERR_MODULE_NOT_FOUND` at runtime when the metadata is executed.

Detect the consuming project's `moduleResolution` from the supplied
`ts.Program` and, when it is Node16 or NodeNext, walk both the
collected metadata AST and the visitor `typeImports` map to append
`.js` to relative specifiers that lack an extension. Bare specifiers,
absolute paths, and already-extended specifiers (`.js`, `.mjs`, `.cjs`,
`.json`, ...) are left untouched, so projects using classic / node10 /
bundler resolution are unaffected.

Closes #3364

v12.0.0 runs vitest without globals enabled, so the new spec needs to
import `describe`, `expect`, `it` explicitly. CI was failing with
`ReferenceError: describe is not defined` at file load time, which
caused the whole spec to be skipped.

After this change, all 18 cases in the spec pass alongside the existing
suite.

…Dir (#3387)

When `--path` (or any tsconfig override) results in an emit whose
`rootDir` differs from the configured `sourceRoot`, AssetsManager
currently strips asset paths against `sourceRoot`, leaving copied
assets one level above where the emitted JavaScript ended up.

Computes the effective rootDir the same way the TypeScript compiler
does — explicit `compilerOptions.rootDir` when set, otherwise the
longest common parent directory of the input file list — and uses it
as the strip root for application assets. Library assets keep the
per-library `_sourceRoot` introduced for `includeLibraryAssets` so
their layout is unchanged.

This is a re-implementation of #3403 on top of v12.0.0 (vitest tests,
library-assets-aware AssetsManager, debounced watch onSuccess).

…754525b

fix(plugin-metadata): emit .js extensions for dynamic imports under nodenext (#3364)

fix(build): align asset path stripping with effective TypeScript rootDir (#3387)

`nest info` walks the project `package.json` and lists every `@nestjs/*`
dependency it finds. The dependency list flows through `format()`, which
sorted the entries and then read `sorted[0].name.length` to compute a
column width — without first checking that the list was non-empty.

When `package.json` was readable but contained zero `@nestjs/*` entries
(running `nest info` from a non-Nest project, or from a fresh checkout
where dependencies have not been installed yet), `format([])` threw
`Cannot read properties of undefined (reading 'name')`. That exception
bubbled up to the outer `try/catch` in `displayNestInformationFromPackage`
and was silently relabeled as `NEST_INFORMATION_PACKAGE_MANAGER_FAILED`:

    smirk  cannot read your project package.json file,
    are you inside your project directory?

…which is a flat-out lie when the read itself succeeded, and sends users
hunting for a non-existent file/directory issue.

Fix it in two complementary places so the contract is right end-to-end:

* `format()` is now defensive — it returns an empty array unchanged
  instead of dereferencing `sorted[0]`. This means the helper is safe
  to call with any input, including from tests.
* `displayNestVersions()` short-circuits for an empty list and prints
  an honest, actionable message
  (`No @nestjs/* dependencies were found in package.json.`) instead of
  letting an exception fall into the misleading package-manager catch.

Tests cover both: `format([])` no longer throws, the existing
non-empty padding/version-range cleanup still works, and
`displayNestVersions({})` writes the new explanatory line.

Replace stray jest.Mock casts in the bun lock-file tests with vitest's
Mock type that the surrounding tests already use. The casts were left over
from #3258 and reference a global that does not exist on v12 (tests pass
at runtime only because vitest does not type-check by default).

Also add a unit test for the existing catch branch in
PackageManagerFactory.find that falls back to NpmPackageManager when
fs.promises.readdir rejects, so the behaviour is locked in.

The existing plugins-loader spec exercised only the most common shape: a
plugin exporting both `before` and `after` transformer factories. It left
several user-visible contracts of `PluginsLoader.load` untested:

- A plugin that exports only `afterDeclarations` is still valid and must
  produce an entry in `afterDeclarationsHooks` (not in beforeHooks /
  afterHooks).
- When a plugin exports a `ReadonlyVisitor` class, the loader must
  instantiate it with the merged user options + extras + `readonly: true`
  and stamp the plugin name onto `instance.key` so downstream metadata
  generation can identify the visitor.
- The `extras.pathToSource` argument must reach the visitor constructor.
- The bound hooks returned in `MultiNestCompilerPlugins` must, when called
  with a `ts.Program`, invoke the original transformer factory with the
  user-supplied options as the first argument and the program as the
  second.
- Plugin order in the input array must be preserved across the returned
  hook arrays.

These behaviors are relied on by `compiler.ts`, `watch-compiler.ts`,
`swc-compiler.ts`, `forked-type-checker.ts`, and the metadata pipeline,
so a regression in any of them would silently break swagger/graphql
plugin integration.

No production code is touched.

…age-v12

test(plugins-loader): cover declaration hooks and visitor wiring

…ry-jest-mock

test(package-managers): use vitest mock type and cover readdir rejection

fix(info): show clear message when no @nestjs/* deps are declared

The TypeCheckerHost spec only exercised the runOnce diagnostic-throwing paths. Add coverage for behaviours that real users hit but had no regression protection:

- Early throw when tsconfigPath is missing or empty
- spinner.fail() is invoked on type errors and spinner.succeed() is not (this branch was added in v12 to replace the previous process.exit)
- runInWatchMode wires the compiler options with noEmit and preserveWatchOutput so the type checker never emits files
- Watch status callback dispatches: onTypeCheck on success, console.error on 'Found N errors' diagnostics, silent ignore for unrelated messages
- onProgramInit is scheduled on the next tick with the program ref

JSON.parse failures from a malformed nest-cli.json bubbled up as a raw
SyntaxError with no indication of which file was being parsed. Wrap the
parse call so the thrown error names the configuration file and includes
the underlying parser reason, matching the pattern introduced for
TsConfigProvider in #3332.

The existing spec only exercises the happy path of FileSystemReader and the
empty-input branch of readAnyOf, leaving the EACCES/EPERM permission flow
and the fall-through-on-error logic uncovered.

Add tests that:

- assert list() and read() pass the configured directory through to fs
- exercise readAnyOf falling through to a later file after ENOENT
- pin the EACCES and EPERM branches to ReaderFileLackPermissionsError,
  including the subtle behaviour that filePath sticks to the *first*
  permission-blocked file even when later files raise different errors
- confirm a successful later read still wins over an earlier permission
  error (no premature ReaderFileLackPermissionsError leak)
- verify errors without a string code property are ignored cleanly
- cover the ReaderFileLackPermissionsError class itself (instanceof,
  exposed properties, message formatting)

No production code changes.

The --parallel flag accepted any value parseInt could partially parse,
including 0, negative numbers, and non-numeric strings. parseInt('abc')
returns NaN, parseInt('-1') returns -1, and either value drove
runBuild's chunked loop into an infinite loop because i += concurrency
never advances toward appNames.length.

Validate the user-supplied value at the command layer with a clear
error message, and harden the action to fall back to unlimited
concurrency (= appNames.length) for any non-positive or non-finite
value to defend against programmatic callers passing through bad
input. Add unit tests covering negative, NaN, true, positive, and
zero (sequential) values.

…ctly when peer deps fail to load

When `webpack` / `rspack` peer dependencies fail to load, the defaults
factories wrap the error with install advice. Two issues with the
existing logic:

1. The error wrapping fired for any thrown error, including ones
   unrelated to a missing module (e.g. version mismatch, syntax error
   inside the dep). This sent users to reinstall packages that were
   already installed and hid the real failure. Now only errors with
   `MODULE_NOT_FOUND` / `ERR_MODULE_NOT_FOUND` codes are wrapped, and
   the original error is attached as `cause` for diagnostics.

2. The greedy regex `/Cannot find.*'([^']+)'/` extracted the last
   quoted segment in the message. For Node ESM-style errors like
   `Cannot find package 'foo' imported from '/abs/file.mjs'` it
   captured `/abs/file.mjs` and told the user to install that as a
   package. Switched to non-greedy so the first quoted segment (the
   actual missing package) is captured.

Adds tests for both webpack-defaults and rspack-defaults covering the
happy path, the ESM error format, fallback when the regex misses, and
the unrelated-error rethrow case.

…t-coverage

test(swc): cover watch mode and spinner failure in type-checker-host

…json-parse-error

fix(configuration): surface clear error for invalid nest-cli.json

…te-concurrency

fix(build): validate --parallel value and guard against infinite loop

…ermissions

test(file-system-reader): cover permission-error and fallback paths

…ts-error-handling

fix(compiler): preserve original error and extract package name correctly when peer deps fail to load