Skip to content
CAI
Software that uses CAICheck a score

denoland/deno

46.2

Weak · 14 November 2026

626.9k

lines of production code

Rust

with JavaScript, TypeScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add enum support to the FromV8 derive macro

The \FromV8\ derive macro in \libs/ops/conversion/from\_v8\ now supports Rust enums, allowing them to be deserialized from V8 values. Unit variants are matched against string representations (with optional \\#\[from\_v8(rename = ...)\]\ overrides), while single-element newtype variants are matched against object keys. The implementation supports externally-tagged enums only, rejecting other tagging strategies, and allows individual variants to opt into \serde\_v8\ deserialization via the \\#\[from\_v8(serde)\]\ attribute.

_libs/ops/conversion/from\v8 · high confidence

Add node:test/reporters builtin

The \node:test/reporters\ module is now available as a builtin polyfill, providing TAP, JUnit, dot, and other reporters for Node.js-compatible test output. This enables users to run tests with standard reporting formats supported by CI systems and local tooling.

ext/node/polyfills/test · high confidence

Add promises sub-module to timers with scheduler support

Users can now import the promises API from the timers module (e.g., \node:timers/promises\), which exposes \setTimeout\, \setImmediate\, \setInterval\, and a new \scheduler\ API. This change introduces the \promises.ts\ and \promises\_esm.ts\ polyfills to provide these specific exports, enabling asynchronous timer operations and scheduling capabilities consistent with Node.js.

ext/node/polyfills/timers · high confidence

Added DNS promises API polyfills

The \ext/node/polyfills/dns\ directory now includes \promises.ts\ and \promises\_esm.ts\, exposing the Node.js \dns.promises\ API (including methods like \lookup\, \resolve\, and \getDefaultResultOrder\) to Deno users. This enables code relying on the promise-based DNS interface to function correctly within the Node compatibility layer.

ext/node/polyfills/dns · high confidence

Added Node.js compatibility utilities for callbackify and OS detection

The \ext/node/polyfills/\_util\ directory now includes \\_util\_callbackify.js\ and \os.ts\. The callbackify utility implements Node.js-style conversion of promise-returning functions to callback-style functions, handling falsy rejection errors and ensuring callbacks are invoked on the next tick. The OS utility provides platform detection helpers (Windows, Linux, macOS, Android, FreeBSD, OpenBSD) via virtual ops, supporting cross-platform Node compatibility.

_ext/node/polyfills/\util · high confidence

Added Node.js stream polyfills for consumers, promises, and web streams

This change introduces new polyfill files in \ext/node/polyfills/stream\ to improve Node.js compatibility. It adds \consumers.js\ and \consumers\_esm.js\ to support stream consumption methods (such as \text()\, \json()\, \blob()\, and \arrayBuffer()\), \promises.js\ to provide \pipeline\ and \finished\ promise-based utilities, and \web.js\/\web\_esm.js\ to expose Web Streams API classes (like \ReadableStream\, \WritableStream\, and \TransformStream\) within the Node stream context. These modules are implemented as lazy-loaded scripts to optimize startup performance.

ext/node/polyfills/stream · high confidence

Added OptionNull type for explicit null serialization in V8 conversions

A new \OptionNull\ wrapper type has been introduced in \cli/util/v8/convert.rs\ to handle the serialization of optional values. This type ensures that \None\ values are explicitly converted to \null\ when passing data to V8, rather than being omitted or handled differently by default \Option\ behavior. This provides more predictable and explicit JSON-like serialization for optional fields in the CLI's V8 integration.

cli/util/v8 · high confidence

Added node:util.parseArgs polyfill

The \node:util.parseArgs\ function is now available in Deno, providing a Node.js-compatible API for parsing command-line arguments. This implementation supports standard option parsing, including short and long options, option grouping, default values, and strict mode validation, allowing applications relying on this Node.js utility to run without modification.

_ext/node/polyfills/internal/util/parse\args · high confidence

Added promise-based readline API

The \node:readline/promises\ module is now available, providing an \Interface\ class and \createInterface\ function that return Promises instead of using callbacks. This allows users to interact with the readline interface using \async/await\ syntax, including support for aborting pending questions via an \AbortSignal\.

ext/node/polyfills/readline · high confidence

Bundling now uses esbuild as the underlying engine

The \deno bundle\ command has been rewritten to use esbuild for bundling, replacing the previous implementation. This change introduces support for new capabilities such as HTML entrypoints, \--declaration\ for generating rolled-up \.d.ts\ files, \--sourcemap\ generation, and \--keep-names\ for preserving function names in minified output. It also adds \--watch\ mode, \--platform\ targeting, and improved handling of CommonJS interop, CSS, and WebAssembly imports. The esbuild binary is now automatically downloaded and cached, and the bundler respects \--frozen\ and \--check\ flags.

cli/tools/bundle · high confidence

Extracted Node.js module resolution into a standalone library

The Node.js module resolution logic has been extracted from the CLI into a new, standalone Rust crate (\libs/node\_resolver\). This library provides Node.js-compatible resolution for Deno, including support for CommonJS analysis, npm package folder resolution, \package.json\ handling, and built-in module checking. By decoupling this logic, the resolution engine is now reusable and testable independently of the main Deno binary.

_libs/node\resolver · high confidence

HTTP server implementation refactored into new ext/http module

The server-side HTTP functionality has been reorganized into a new \ext/http\ extension, introducing a modernized architecture that supports both the legacy \HttpConn\ API (in \01\_http.js\) and the newer \Deno.serve\ API (in \00\_serve.ts\). This change includes a dedicated WebSocket upgrade handler (\02\_websocket.ts\) and a Rust-based compression engine (\compressible.rs\, \fly\_accept\_encoding.rs\) that automatically selects the best encoding (Brotli, Gzip, Deflate, or Zstd) based on client preferences. The new implementation also integrates OpenTelemetry for request tracing and metrics, and adds support for HTTP/2 clear-text (h2c) upgrades and configurable compression levels.

ext/http · high confidence

Hot Module Replacement (HMR) support for \`deno run\`

The \deno run\ command now supports Hot Module Replacement via the \--watch-hmr\ flag. This change introduces a new \HmrRunner\ in \cli/tools/run/hmr.rs\ that communicates with the V8 inspector to detect file changes and attempt to replace modules in the running process without a full restart. The runner handles compile errors and exceptions, falling back to a full restart if hot replacement is blocked (e.g., by top-level variable changes). This feature is exposed through the \cli/tools/run\ module, which also includes logic to resolve and execute native npm binaries directly.

cli/tools/run · high confidence

Implement Node.js os.cpus(), os.getPriority(), and os.setPriority() compatibility

The \ext/node/ops/os\ module now provides native Rust implementations for several Node.js \os\ module operations. \os.cpus()\ returns detailed CPU information (model, speed, and user/nice/sys/idle/irq times) using platform-specific syscalls on macOS, Windows, and stubbed for OpenBSD. \os.getPriority()\ and \os.setPriority()\ allow adjusting process scheduling priorities, mapping Node.js priority levels to Windows priority classes or Unix \getpriority\/\setpriority\ calls. These changes ensure that applications relying on these specific \os\ APIs behave consistently with Node.js environments.

ext/node/ops/os · high confidence

Include built-in @types/node type declarations

The \cli/tsc/dts/node\ directory now ships with a complete set of built-in TypeScript type declarations for Node.js modules (such as \assert\, \buffer\, \child\_process\, and \console\). This change provides out-of-the-box type checking for Node.js APIs without requiring users to manually install the \@types/node\ package, ensuring that global types and module definitions are available by default in the Deno TypeScript compiler.

cli/tsc/dts/node · high confidence

Initial release of the ext/node compatibility layer

This change introduces the \ext/node\ extension, providing a Node.js compatibility layer for Deno. It includes the core Rust implementation (\lib.rs\, \build.rs\) which embeds the \llhttp\ parser and defines the \NodeRequireLoader\ trait for module resolution. The extension ships with TypeScript polyfills for standard Node modules such as \assert\ and \util/types\, and a build script (\update\_node\_stream.ts\) to transform Node.js internal stream code into Deno-compatible ESM. It also enforces strict filesystem access controls via a \clippy.toml\ configuration that disallows direct \std::fs\ calls in favor of the \FileSystem\ trait.

ext/node · high confidence

Interactive SVG flamegraphs and source-mapped CPU profiling

The CPU profiler now supports generating interactive SVG flamegraphs via the new \--cpu-prof-flamegraph\ flag, providing a visual, zoomable representation of call stacks that fills the browser viewport. Additionally, the profiler applies source maps to the CPU profile output before writing it, ensuring that generated reports and flamegraphs reference original source locations rather than transpiled code.

_runtime/cpu\profiler · high confidence

Introduce Checkin, a dedicated testing runtime for deno\_core

A new testing tool called Checkin has been added to libs/core\_testing to exercise deno\_core functionality. It provides a minimal standard library implemented via Rust extensions (exposing ops for logging, async operations, I/O, workers, and error handling) and TypeScript modules that map to global APIs like console, timers, and Worker. The runner supports creating JsRuntime instances from snapshots, running integration tests that compare output against .out files, and executing unit tests that register and invoke individual test functions, enabling developers to validate core behaviors in a controlled environment.

_libs/core\testing · high confidence

Introduce Deno KV key-value store extension

This change adds the \ext/kv\ extension, providing a new \Deno.openKv()\ API for persistent key-value storage. It supports local SQLite backends for development and remote backends (via the KV Connect protocol) for production, with automatic fallback based on the connection path. The implementation includes configurable limits for atomic operations (e.g., 80 KiB total key size), queue management with up to 30-day delays, and strict validation for inputs like \expireIn\ and backoff schedules. It also enforces security measures such as rejecting symlinked database paths and requiring environment variables for remote access tokens.

ext/kv · high confidence

Introduce Deno.cron() API for scheduled tasks

Deno now supports scheduled tasks via the new \Deno.cron()\ API, available as an unstable feature. This addition includes a JavaScript interface in \ext/cron/01\_cron.ts\ that accepts a name, a schedule (supporting both standard cron strings and a JSON object format for convenience), and a handler function, along with optional backoff and abort signal configurations. The underlying Rust implementation in \ext/cron\ provides two execution modes: a local in-process scheduler (\LocalCronHandler\) for single-instance use and a socket-based remote scheduler (\SocketCronHandler\) that communicates via a configurable socket address (\DENO\_UNSTABLE\_CRON\_SOCK\), allowing for distributed cron management. The feature also integrates with OpenTelemetry for tracing cron executions.

ext/cron · high confidence

Introduce Node.js CLI argument shim

A new \libs/node\_shim\ crate and CLI binary have been added to translate Node.js command-line arguments into Deno equivalents, allowing users to run scripts with a \node\ shim that forwards arguments to the Deno runtime. The implementation includes a Rust-based argument parser mirroring Node's CLI behavior, a \clippy.toml\ configuration to enforce system-trait usage for file and environment operations, and a helper JavaScript module (\resolve.js\) for module resolution.

_libs/node\shim · high confidence

Introduce Web Cache API with SQLite and LSCache backends

Deno now supports the Web Cache API, allowing applications to store and retrieve HTTP responses for offline or performance-critical use cases. The \ext/cache\ module provides \CacheStorage\ and \Cache\ classes that implement the W3C Service Worker specification, including methods like \open\, \match\, \put\, \delete\, and \keys\. The underlying storage is backed by SQLite (with support for in-memory mode via the \DENO\_CACHE\_DB\_MODE\ environment variable) or a remote LSCache backend, enabling persistent caching across sessions.

ext/cache · high confidence

Introduce \`deno init\` command with multiple project templates

Users can now scaffold new Deno projects using the \deno init\ command, which supports several modes: a basic HTTP server template (\--serve\) that includes routing, static file serving, and tests; a library template (\--lib\) for creating reusable modules; an empty project (\--empty\); and initialization from JSR or npm packages (\--jsr \<package\>\ or \--npm \<package\>\). The command generates a \deno.json\ configuration file, appropriate source files (e.g., \main.ts\, \mod.ts\), and test files, handling dependencies via JSR specifiers or temporary \node\_modules\ folders for npm packages.

cli/tools/init · high confidence

Introduce \`deno jupyter\` subcommand for notebook support

Users can now run \deno jupyter\ to install and manage a Deno kernel for Jupyter notebooks. The new \install\ module handles kernel registration by writing a \kernel.json\ spec to the platform-specific Jupyter data directory (e.g., \\~/.local/share/jupyter/kernels/deno\ on Linux, \\~/Library/Jupyter\ on macOS) and copying the Deno logo assets. It ensures the kernel binary path is stable across upgrades by resolving the executable via the system \PATH\ rather than relying on symlink-resolved paths. The kernel implementation spawns a background REPL thread to handle Jupyter protocol messages, enabling interactive notebook execution.

cli/tools/jupyter · high confidence

Introduce \`deno pack\` command to create npm tarballs

The \deno pack\ command is now available to bundle Deno packages into npm-compatible tarballs. This feature handles TypeScript transpilation to JavaScript, generates corresponding \.d.ts\ declaration files, and collects assets specified in the \publish.include\ configuration. It automatically rewrites JSR and npm specifiers to standard npm formats, generates a valid \package.json\ with correct exports and dependencies, and produces reproducible tarballs with deterministic file metadata.

cli/tools/pack · high confidence

Introduce \`deno\_maybe\_sync\` crate for platform-agnostic concurrency primitives

A new \deno\_maybe\_sync\ library has been added to provide optional \Sync\ structures that adapt to the runtime environment. When the \sync\ feature is enabled (e.g., for Deno), it exposes standard thread-safe types like \Arc\, \OnceLock\, \DashMap\, and \DashSet\. When the feature is disabled (e.g., for Deno Deploy/Wasm), it provides single-threaded equivalents using \Rc\, \OnceCell\, and \RefCell\-wrapped collections, ensuring compatibility across both multi-threaded and single-threaded execution contexts.

_libs/maybe\sync · high confidence

Introduce deno\_process crate for subprocess management

The \ext/process\ location now contains the new \deno\_process\ Rust crate, which consolidates the implementation of Deno's subprocess APIs. This change introduces the core Rust logic for spawning and managing child processes, including IPC stream handling and signal management, alongside the corresponding JavaScript bindings in \40\_process.js\ that expose these capabilities to the runtime.

ext/process · high confidence

Introduce deno\_resolver crate for module resolution

The \libs/resolver\ directory now contains the \deno\_resolver\ crate, which centralizes Deno's module resolution algorithm. This new library includes components for parsing and converting lockfiles from other package managers (npm, yarn, pnpm, and bun) into Deno's native \deno.lock\ format, managing compiler options via \deno.json\, handling file fetching and caching, and resolving dependencies within workspaces and npm packages. It also provides utilities for emitting transpiled code and displaying resolution diagnostics.

libs/resolver · high confidence

Introduce eszip library for serializing ECMAScript module graphs

The \libs/eszip\ crate has been added to the repository, providing a format to losslessly serialize an ECMAScript module graph (represented by \deno\_graph::ModuleGraph\) into a single compact, streaming-capable file. This new library supports both V1 and V2 formats, with V2 offering features like npm package snapshots and source map handling. The release includes the core library implementation, error definitions, and example binaries (\builder\ and \viewer\) that demonstrate how to construct eszip files from module graphs and inspect or extract their contents.

libs/eszip · high confidence

Introduce experimental LSP testing API

Adds an experimental testing API to the Deno Language Server, enabling IDEs to discover, run, and monitor tests directly. This change introduces new custom LSP notifications (\deno/testModule\, \deno/testRun\, \deno/testRunProgress\) and requests (\deno/testRunCancel\) to support test discovery, execution filtering, and real-time progress reporting. The implementation includes static analysis collectors to parse test definitions from source files, a test execution engine that respects \--env-file\ configurations, and server-side logic to manage test run lifecycles and notify clients of test states (passed, failed, errored).

cli/lsp/testing · high confidence

Introduce external Permission Broker for cross-process permission decisions

The permissions system now supports an external Permission Broker, allowing permission checks to be delegated to a separate process via IPC. This is implemented through new \broker.rs\ and \ipc\_pipe.rs\ modules that handle JSON-based request/response communication over Unix domain sockets (on Unix) or named pipes (on Windows). The broker protocol includes versioning, process IDs, and timestamps to ensure secure and traceable decision-making. This architecture enables scenarios where permission policies are managed externally, such as by a parent process or a dedicated security service, rather than being handled inline by the runtime.

runtime/permissions · high confidence

Introduce standalone HTTP/1.1 protocol library

Adds a new \libs/http\_h1\ crate providing a zero-allocation, single-threaded HTTP/1.1 implementation for Deno. This library includes request and response parsing, chunked body handling, and optimized serialization, along with a benchmarking suite and a reference echo server example to demonstrate the API.

_libs/http\h1 · high confidence

Introduce standalone binary builder with embedded virtual filesystem

The \cli/standalone\ module now provides the core implementation for creating standalone Deno executables via \deno compile\. This change introduces a virtual filesystem (VFS) that embeds source files, assets, and npm dependencies directly into the binary, allowing the runtime to execute without external files. It includes logic to discover and bundle native \.node\ addons, manage CJS/ESM module resolution within the embedded environment, and display a summary of embedded file sizes during the build process.

cli/standalone · high confidence

Introduce standalone binary format with virtual filesystem and persistent storage support

This change introduces the core infrastructure for Deno's standalone compiled binaries, including a new virtual filesystem (VFS) and binary serialization layer. Users can now create self-contained executables that bundle source code, dependencies, and metadata into a single file. Key capabilities include support for self-extracting binaries, preservation of file timestamps (atime/birthtime/mtime/ctime) within the VFS, and the ability to persist Web Storage and Key-Value data in a per-app data directory. The implementation also adds support for CommonJS via the \--require\ flag, handles CJS export analysis for re-exported ESM modules, and supports the \--preload\ flag for preloading modules at startup.

cli/lib/standalone · high confidence

Introduce standalone runtime crate for compiled binaries

A new \cli/rt\ crate has been added to serve as the entry point and runtime environment for standalone executables produced by \deno compile\. This crate handles extracting the embedded virtual file system (VFS) and metadata from the binary, managing code caching for faster subsequent runs, and providing a custom file system implementation that reads from the VFS. It also includes support for Hot Module Replacement (HMR) in development scenarios, desktop window management APIs, and Node.js compatibility features like CJS analysis and native addon loading within the standalone context.

cli/rt · high confidence

Introduce the \`\#\[op2\]\` macro as the new standard for defining ops

The \libs/ops/op2\ library has been added as the in-progress replacement for the legacy \\#\[op\]\ macro. This new infrastructure provides a more robust and performant way to define JavaScript ops in Rust, featuring support for fastcalls, CppGC-backed JavaScript objects, and granular control over asynchronous execution modes (eager, lazy, and deferred). It also introduces improved argument conversion traits and stricter validation for attribute combinations, laying the groundwork for future performance optimizations in the core runtime.

libs/ops/op2 · high confidence

Introduce the ext/ffi extension for dynamic library interop

This change introduces the \ext/ffi\ extension, providing a new FFI (Foreign Function Interface) capability for Deno. It adds Rust-side operations for loading dynamic libraries (\dlopen\), calling symbols, and managing pointers, alongside a JavaScript API (\UnsafePointerView\, \UnsafeCallback\) for reading/writing memory and defining callbacks. The implementation leverages V8 Fast API calls and a JIT-compiled trampoline (via Cranelift) for high-performance synchronous calls, while also supporting non-blocking asynchronous calls and thread-safe callbacks.

ext/ffi · high confidence

Introduce the new ext/canvas extension

This change introduces a new \ext/canvas\ extension that provides the \OffscreenCanvas\ API and the \ImageBitmapRenderingContext\ for transferring bitmap data to canvases. It also adds the \UnsafeWindowSurface\ object, which allows creating canvas contexts backed by native window handles (requiring FFI permissions) on supported platforms. The extension is implemented in Rust and exposes these capabilities via lazy-loaded JavaScript modules.

ext/canvas · high confidence

Introduces a custom, multi-mode progress bar implementation

The CLI now uses a new, custom progress bar module (\cli/util/progress\_bar\) instead of external libraries, providing a unified rendering engine for various operations including downloads, compilation, cleaning, and initialization. This change introduces support for multiple visual styles: a detailed bar with human-readable file sizes for downloads, a numeric counter, and a text-only spinner for blocking or indeterminate tasks. It also implements logic to defer display until multiple entries are active, reducing visual clutter and flickering during complex operations like npm installation or module compilation.

_cli/util/progress\bar · high confidence

Introduces undici polyfill for Node.js compatibility

A new polyfill file for the undici library has been added to the Node.js compatibility layer, exposing the Agent, EnvHttpProxyAgent, and global dispatcher functions. This implementation handles certificate validation options and integrates with Deno's internal dispatcher mechanism, enabling applications relying on undici-based HTTP clients to function correctly within the Deno runtime.

ext/node/polyfills/internal/deps · high confidence

Introduction of the \`deno\_lockfile\` crate

The \deno\_lockfile\ library has been introduced to manage the Deno lockfile format. This new component includes core logic for parsing and serializing lockfiles (supporting version 5), a graph-based analysis engine to determine which packages and remotes can be removed based on configuration changes, and comprehensive error handling for parsing, deserialization, and version mismatches. It also provides workspace configuration support, including handling of JSR and npm dependencies, package links, and npm overrides, along with a full suite of integration and specification tests to validate these behaviors.

libs/lockfile · high confidence

Linting now enforces strict import paths and detects slow types

The linting system introduces two new rules to improve code quality and performance. The \no-sloppy-imports\ rule flags imports that rely on implicit resolution (such as missing \./\ prefixes or ambiguous module paths) and provides automatic fixes to correct them, ensuring imports are explicit and reliable. Additionally, the \no-slow-types\ rule analyzes package exports to detect and report type definitions that cause slow type-checking, helping users optimize their projects for faster development workflows.

cli/tools/lint/rules · high confidence

Native libuv compatibility layer for TCP, pipes, and TTY handles

The \libs/core/uv\_compat\ module now provides a native Rust implementation of the libuv handle types (\uv\_tcp\_t\, \uv\_pipe\_t\, \uv\_tty\_t\) and their associated I/O streams. This replaces previous compatibility shims with a dedicated reactor integration that uses per-handle wakers and ready queues to poll only active handles, improving event loop efficiency. The implementation supports cross-platform features including Unix domain sockets, Windows named pipes (with retry logic for \ERROR\_PIPE\_BUSY\), abstract Unix sockets, and macOS TTY select fallbacks, enabling Node.js \net\, \pipe\, and \tty\ modules to function with native performance.

_libs/core/uv\compat · high confidence

Native llhttp-based HTTP parser for Node compatibility

The \ext/node/ops/llhttp\ extension now provides a native HTTP/1.1 parser built on the llhttp library (version 9.3.1), replacing the previous JavaScript-based implementation. This change introduces Rust FFI bindings (\binding.rs\) and C source files (\api.c\, \http.c\, \llhttp.c\) that expose an \HTTPParser\ class to JavaScript, matching Node.js's native \internalBinding('http\_parser')\ interface. The parser supports standard HTTP callbacks (message begin, headers, body, complete) and includes optimizations such as bulk header array building, in-place whitespace trimming, and a fast path for consuming HTTP streams directly via \ReadInterceptor\. This native implementation improves parsing performance and compatibility for Node.js HTTP modules running in Deno.

ext/node/ops/llhttp · high confidence

New JavaScript implementations for testing, linting, benchmarking, and Jupyter kernel

The CLI now ships new JavaScript source files for core subsystems: \40\_test.js\ and \40\_test\_snapshot.js\ provide the test runner with built-in snapshot testing, test steps, and setup/teardown hooks; \40\_lint.js\ and \40\_lint\_selector.js\ implement the JS lint plugin infrastructure with AST selector support; \40\_bench.js\ adds benchmarking with warmup and iteration control; and \40\_jupyter.js\ along with \jupyter\_kernel.js\ deliver a JS-based Jupyter kernel with display, broadcast, and image APIs. These files replace or supplement previous snapshot-based or Rust-heavy implementations, changing how these features are executed and extended at runtime.

cli/js · high confidence

New Rust-based Node.js crypto compatibility layer

The \ext/node\_crypto\ extension has been rewritten in Rust to replace the previous implementation, introducing a comprehensive set of new modules (\cipher\, \dh\, \digest\, \keys\, \sign\, \x509\) and over 60 new ops to align with Node.js behavior. This change adds support for AES Key Wrap (RFC 3394/5649), named Diffie-Hellman groups (RFC 3526), and various hash algorithms (including MD5, SHA-1, SHA-2, SHA-3, BLAKE2, SM3). It also implements key handling for RSA, EC (P-224, P-256, P-384, P-521, secp256k1), Ed25519, Ed448, X25519, X448, and DSA, along with X.509 certificate parsing and validation. The new layer includes specific compatibility fixes such as caching hash digests to survive stream pipelines, using constant-time comparisons for GCM tags and secret keys, and enforcing minimum Miller-Rabin rounds for prime checking.

_ext/node\crypto · high confidence

New Rust-based crypto library for Deno

A new Rust library (\libs/crypto\) has been added to provide the underlying cryptography provider for Deno's WebCrypto API and the \node:crypto\ compatibility layer. This library introduces FFI bindings to the AWS-LC cryptographic engine, implements RFC 7748 scalar decoding for X448 key exchange, and adds support for validating and exporting Netscape SPKI (SPKAC) certificate structures.

libs/crypto · high confidence

New WebIDL proc-macro for dictionary and enum conversion

The \libs/ops/webidl\ module now provides a \\#\[derive(WebIDL)\]\ proc-macro that automatically generates \WebIdlConverter\ implementations for Rust structs and enums. For structs marked with \\#\[webidl(dictionary)\]\, the macro generates code to parse JavaScript objects into Rust structs, supporting field renaming, default values, and converter options (such as clamping). For enums marked with \\#\[webidl(enum)\]\, it generates string-based conversion logic, allowing variants to be mapped to kebab-case strings or custom renamed values. This simplifies the integration of Rust types with WebIDL-compliant JavaScript interfaces.

libs/ops/webidl · high confidence

New \`ToV8\` derive macro for structs and enums

The \libs/ops/conversion/to\_v8\ module introduces a new \ToV8\ derive macro that automatically implements \deno\_core::convert::ToV8\ for Rust structs and enums, replacing the previous reliance on \serde\_v8\ for these types. This macro supports named and tuple structs, as well as various enum modes (externally tagged, internally tagged, adjacently tagged, and untagged). Users can customize field names via \\#\[to\_v8(rename)\]\, force legacy serialization via \\#\[to\_v8(serde)\]\, and conditionally skip fields using \\#\[to\_v8(skip\_if)\]\, allowing for more efficient and flexible conversion of Rust types to V8 values.

_libs/ops/conversion/to\v8 · high confidence

New \`deno bump-version\` subcommand and improved \`deno clean\` with progress and exception support

Users can now use the new \deno bump-version\ subcommand to automatically increment the version in \deno.json\ or \package.json\ files, supporting standard semver increments (major, minor, patch, pre-release) and working with workspaces. Additionally, \deno clean\ now features a progress bar during cache removal and supports a \--dry-run\ flag to preview what would be deleted, as well as an \--except\ flag to preserve specific paths while cleaning the rest of the cache.

cli/tools · high confidence

New \`deno\_config\` library for configuration parsing and JSR-to-NPM resolution

This change introduces the \deno\config\ crate in \libs/config\, providing a Rust implementation for parsing Deno configuration files. It adds logic to extract JSR and npm dependencies from import maps and includes a new capability to rewrite \jsr:\ import specifiers into their \npm:\ equivalents (e.g., \jsr:@david/dax\ to \npm:@jsr/david\\_dax\), enabling JSR dependencies to be installed into \node\_modules\ via the npm compatibility registry. The library also introduces utilities for parsing minimum dependency ages (supporting minutes, ISO-8601 durations, and RFC3339 dates) and ensures consistent config auto-discovery behavior across platforms by standardizing error handling.

libs/config · high confidence

New \`deno\_package\_json\` library for parsing and validating package.json

A new \deno\_package\_json\ library has been introduced to handle the parsing, validation, and caching of \package.json\ files within the Deno CLI. This library provides structured types for key fields such as \engines\ (including mismatch detection), \sideEffects\, and the \browser\ field map, while also supporting advanced npm resolution features like the \jsr:\ scheme, \catalog:\ protocol, and \workspace:\ dependencies with aliases. It serves as the foundational component for how Deno interprets and validates npm package metadata.

_libs/package\json · high confidence

New \`ext/image\` extension for \`createImageBitmap\`

The \ext/image\ extension has been introduced to provide the \createImageBitmap\ API. This change adds Rust-based image decoding and processing capabilities for PNG, JPEG, GIF, BMP, ICO, and WebP formats, handling pixel manipulation, alpha premultiplication, and color space conversion. The JavaScript layer in \01\_image.js\ implements the Web IDL converters and the \createImageBitmap\ function, which is backed by the new \op\_create\_image\_bitmap\ Rust operation.

ext/image · high confidence

New async flag and atomic counter utilities

The \cli/util/sync\ module now exposes an \AsyncFlag\ struct for coordinating asynchronous state transitions using a Tokio semaphore, along with a \RelaxedAtomicCounter\ for simple, relaxed-ordering integer counting. These utilities provide low-level synchronization primitives for internal use within the CLI.

cli/util/sync · high confidence

New binary AST buffer format for JavaScript lint plugins

The JavaScript lint plugin infrastructure now uses a new, compact binary AST representation (the AST buffer) instead of the previous serialization method. This change introduces a new \ast\_buffer\ module that converts the parsed source into a binary format optimized for plugin consumption, including support for selectors, comments, and decorators. For users, this enables the use of custom JavaScript lint plugins (currently unstable) that can traverse and analyze code using this efficient binary structure.

_cli/tools/lint/ast\buffer · high confidence

New core examples for ops, snapshots, and TypeScript loading

The \libs/core/examples\ directory now includes a set of runnable examples demonstrating key Deno core capabilities. These include \hello\_world.rs\ and \op2.rs\ for defining and invoking Rust ops from JavaScript, \disable\_ops.rs\ for disabling specific ops, and \eval\_js\_value.rs\ for evaluating JS and deserializing results. A new \snapshot/\ subdirectory provides a complete example of creating and using a startup snapshot with ESM-based extensions. Additionally, \ts\_module\_loader.rs\ demonstrates transpiling TypeScript/JSX using SWC, and \wasm.rs\/\wasm.js\ show how to load and interact with WebAssembly modules.

libs/core/examples · high confidence

New coverage ignore directives and dark-mode HTML report

The coverage tool now supports \deno-coverage-ignore\, \deno-coverage-ignore-start\, \deno-coverage-ignore-stop\, and \deno-coverage-ignore-file\ comments to exclude specific lines, ranges, or entire files from coverage reports. The HTML coverage report has been updated with a dark-mode theme, including a toggle button and system-preference detection.

cli/tools/coverage · high confidence

New deno.json configuration library with granular permission and TypeScript compiler options

The \libs/config/deno\_json\ crate introduces a dedicated library for parsing and managing \deno.json\ configuration files. It adds support for granular permission controls (allow, deny, ignore) for read, write, import, env, and net scopes, allowing users to fine-tune security policies directly in the config. Additionally, it provides structured TypeScript compiler options, including JSX settings, emit configurations, and verbatim module syntax, enabling precise control over code transpilation and type checking behavior.

_libs/config/deno\json · high confidence

New developer tooling and CI automation scripts

The \tools/\ directory now includes several new scripts to support development and CI workflows: \apply\_web\_globals\_deferral.ts\ rewrites TypeScript global declarations to defer to \lib.dom\ when present, \bsdiff\_helper/main.rs\ generates zstd-compressed binary delta patches for faster upgrades, \build\_bench.ts\ automates building specific git commits for benchmarking, and \build\_lzld.sh\ enables lazy-loading of macOS system frameworks to improve startup performance. Additionally, \check\_deno\_core\_changes.js\ and \check\_docs\_only\_changes.js\ allow CI to skip unnecessary jobs when only core or documentation files change, while \download\_tsc.ts\ pre-caches the native TypeScript compiler for test runs. The \tools/README.md\ documentation has been updated to reflect these new tools.

tools · high confidence

New drop\_print macros prevent panics on broken pipes

The \libs/print\ crate introduces \drop\_print\, \drop\_println\, \drop\_eprint\, and \drop\_eprintln\ macros, which behave like standard Rust print macros but silently ignore write errors instead of panicking. This change ensures that output operations do not crash the runtime when the receiving end of a pipe is closed (e.g., \deno test \| head\), aligning behavior with Node.js and improving stability for subcommand reporters and other stdout-bound output.

libs/print · high confidence

New ext/io crate centralizes IO primitives and file descriptor management

The \ext/io\ extension has been introduced to consolidate IO primitives, including stdio streams, file system abstractions, and pipe implementations. This change introduces a central \FdTable\ to track file descriptors, supporting ownership models for table-owned files, inherited extra stdio descriptors, and libuv-owned handles. It also adds cross-platform bidirectional and unidirectional pipe support, including a native Windows named pipe implementation, and lazy-loads the streams polyfill to improve startup performance.

ext/io · high confidence

New ext/net extension consolidates networking APIs

The \ext/net\ extension has been introduced to centralize Deno's networking implementation, replacing the previous scattered setup. This change introduces a unified JavaScript API surface in \01\_net.js\ (TCP/UDP/Unix), \02\_tls.js\ (TLS connections/listeners), and \03\_quic.js\ (QUIC/WebTransport), backed by a comprehensive Rust implementation in \lib.rs\, \ops.rs\, \ops\_tls.rs\, and \ops\_unix.rs\. Key capabilities include the new Happy Eyeballs algorithm for TCP connections (\happy\_eyeballs.rs\), support for Unix domain sockets and abstract paths, QUIC endpoint management, and WebTransport integration. The extension also enforces stricter permission checks for Unix sockets and multicast groups, and provides a consistent resource model for network streams.

ext/net · high confidence

New ext/telemetry crate with gRPC and console OTLP exporters

The \ext/telemetry\ extension has been introduced to centralize OpenTelemetry functionality, providing a new gRPC protocol exporter for OTLP (supporting traces, metrics, and logs via standard environment variables) and a console exporter for debugging. This location specifically implements the Rust-side telemetry infrastructure, including the \deno\_telemetry\ extension registration, the \console\_exporter.rs\ and \grpc\_exporter.rs\ modules, and the core \lib.rs\ and TypeScript bindings (\telemetry.ts\, \util.ts\) that expose the OpenTelemetry API to the runtime.

ext/telemetry · high confidence

New internal Node.js polyfill modules added

The \ext/node/polyfills/internal\ directory now contains a comprehensive set of new internal polyfill modules (such as \assert\, \async\_hooks\, \blocklist\, \buffer\, \child\_process\, \errors\, and \event\_target\) that provide the foundational implementation details for the Node.js compatibility layer. These files introduce the internal logic, validation, and error handling required for Node.js APIs to function correctly within Deno.

ext/node/polyfills/internal · high confidence

New internal binding module structure for Node.js compatibility

The \ext/node/polyfills/internal\_binding\ directory now contains a comprehensive set of new TypeScript and JavaScript modules that implement Node.js internal C++ bindings. This includes a central \mod.ts\ entry point that loads and exposes bindings for core subsystems such as \async\_wrap\, \buffer\, \cares\_wrap\ (DNS), \constants\, \crypto\, \http\_parser\, \http2\, \inspector\, \tcp\_wrap\, \tls\_wrap\, and \uv\. These modules provide the low-level compatibility layer required for Node.js APIs to function correctly within Deno.

_ext/node/polyfills/internal\binding · high confidence

New npm library with SIMD-accelerated registry parsing and trust policies

The \libs/npm\ crate introduces a new npm registry client and dependency resolver for the Deno CLI. It features a \fast\_registry\_json\ module that uses SIMD instructions to scan and index npm packument JSON, significantly improving parse performance. The resolver now supports npm overrides (including the \catalog:\ protocol), a \no-downgrade\ publishing-trust policy to prevent supply-chain downgrades, and wildcard patterns in \minimumDependencyAge\ exclusions. It also handles linked packages with peer dependencies, resolves bundled npm dependencies without \node\_modules\, and validates lockfile tarball origins.

libs/npm · high confidence

New npm\_cache library for downloading and caching npm dependencies

The \libs/npm\_cache\ crate has been introduced to handle the downloading and caching of npm dependencies for Deno. This new component implements robust tarball extraction with integrity verification, using \libdeflater\ for faster decompression and \aws-lc-rs\ for hashing. It supports abbreviated packument requests to reduce bandwidth, respects \npmrc\ configuration for authentication (including email-based auth), and enforces security by rejecting symlinked package materialization directories. The cache also handles race conditions during hard-linking and limits concurrent filesystem writes to improve stability.

_libs/npm\cache · high confidence

New npmrc library with INI parsing and advanced registry configuration

The \libs/npmrc\ crate has been introduced to provide a dedicated library for parsing \.npmrc\ files and managing npm registry configurations. It includes a new INI parser (\ini.rs\) built on the \monch\ parsing library, enabling the handling of sections, key-value pairs, and various data types. The library exposes a structured \NpmRc\ configuration model that supports advanced npm features such as scoped registry mappings, authentication details, and the \replace-registry-host\ setting for controlling tarball URL resolution. Additionally, it introduces support for security and stability policies, including \min-release-age\ to enforce a minimum age for package versions and a \trust-policy\ (with \no-downgrade\ mode) to prevent resolving versions with weaker publishing-trust evidence than previously published ones. A \clippy.toml\ file is also added to enforce the use of \sys\_traits\ for system operations, ensuring better testability and WebAssembly compatibility.

libs/npmrc · high confidence

New package management subcommands: approve-scripts, audit, list, and why

The \cli/tools/pm\ module has been restructured into dedicated subcommand files, introducing four new capabilities for users. The \approve-scripts\ subcommand allows users to interactively or explicitly approve npm lifecycle scripts in their workspace configuration. The \audit\ subcommand scans dependencies for known vulnerabilities, supporting both the npm advisory API and an optional socket.dev integration, and includes a \--fix\ flag to automatically patch vulnerable dependencies. The \list\ subcommand displays declared dependencies in a flat or tree format, showing required versus resolved versions. The \why\ subcommand helps users understand the dependency tree by showing which packages depend on a specific package. These changes replace the previous monolithic implementation with a modular structure that also includes \cache\_deps\, \deps\, and \interactive\_picker\ utilities.

cli/tools/pm · high confidence

New runtime API for bundling via Deno.bundle

This change introduces a new runtime API for bundling, exposing the \Deno.bundle\ function to JavaScript. The implementation adds a new \ext/bundle\ extension that wires up the \op\_bundle\ operation and provides a \BundleProvider\ trait for Rust embedders. A key behavioral detail is that compiled binaries (created via \deno compile\) now return a clear error message stating that \Deno.bundle()\ is not available in that context, rather than failing silently or with a generic error.

ext/bundle · high confidence

New signal handling extension

The ext/signals extension has been introduced to manage process signals, providing a unified API for registering signal handlers across Unix and Windows platforms. This change adds a new module containing signal dictionaries for various operating systems (FreeBSD, OpenBSD, Linux, macOS, Solaris/Illumos) and implements platform-specific signal reception logic using the signal\_hook crate on Unix and Windows console control handlers on Windows. Users can now register custom handlers for signals like SIGINT, SIGTERM, and SIGHUP, with support for preventing default OS behavior.

ext/signals · high confidence

New utility modules for checksums, hashing, logging, and error handling

The \cli/lib/util\ module now includes several new utility modules: \checksum.rs\ provides SHA256 checksum generation using \aws\_lc\_rs\; \hash.rs\ introduces a fast, insecure xxHash-based hasher (\FastInsecureHasher\) with optional Deno-version awareness; \logger.rs\ implements a new CLI logging system (\CliLogger\) that integrates with OpenTelemetry telemetry and supports configurable log levels and formatting; \result.rs\ adds helper traits and functions for error downcasting and handling; \net.rs\ provides a utility to allocate random ephemeral TCP ports; \text\_encoding.rs\ offers UTF-8 validation and lossy conversion helpers; and \v8.rs\ contains a utility for constructing V8 command-line flags. These modules collectively enhance the CLI's internal capabilities for hashing, logging, error management, and V8 configuration.

cli/lib/util · high confidence

Ported Node.js cluster internals to TypeScript

Added TypeScript implementations for the internal Node.js cluster module components (child, primary, worker, round-robin and shared handles, utilities, and linked list) to \ext/node/polyfills/internal/cluster\. This change enables the \node:cluster\ API on Unix systems by providing the underlying state management, worker lifecycle, and load-balancing logic required for cluster functionality.

ext/node/polyfills/internal/cluster · high confidence

Promisified Node.js Inspector API

The Node.js inspector module now exposes a promisified API via \node:inspector/promises\. This change introduces a \Session\ class where the \post\ method is promisified, allowing developers to use \await\ instead of callbacks for inspector commands. The module also re-exports standard inspector functions like \open\, \close\, \console\, \DOMStorage\, \Network\, \url\, and \waitForDebugger\ from the underlying inspector implementation.

ext/node/polyfills/inspector · high confidence

Stabilized node:sqlite with backup, sessions, and safety fixes

The \ext/node\_sqlite\ extension is now a stable, standalone module providing the full \node:sqlite\ API. This release introduces database backup capabilities via \DatabaseSync.backup()\, database change tracking via \Session\ (with \changeset()\ and \patchset()\), and support for tagged template literals in SQL queries. It also adds a \limits\ property to \DatabaseSync\ for configuring SQLite constraints, implements \DatabaseSync.serialize()\ and \deserialize()\ for transaction safety, and enforces stricter security by refusing symlinked database paths and guarding against reentrant authorizer callbacks. Under the hood, statement execution is optimized using an LRU cache and direct V8 property creation for improved performance.

_ext/node\sqlite · high confidence

Support DENO\_SERVE\_ADDRESS override in node:http servers

Node.js http.Server instances now respect the DENO\_SERVE\_ADDRESS environment variable, allowing them to listen on the same address as top-level Deno.serve() calls. When this override is set, the first node:http server to call listen() consumes the address, listening on the override instead of the application-requested address (or on both if the duplicate flag is used). This applies to TCP, Unix sockets, VSOCK, and tunnel transports, with non-TCP connections handled via a lightweight Duplex wrapper that feeds accepted connections into the server's connection listener.

ext/node/polyfills/internal/http · high confidence

Support for synchronous script loading in classic workers

Classic web workers can now load scripts synchronously via \importScripts()\. This change introduces a new \op\_worker\_sync\_fetch\ operation that handles HTTP(S), data, and blob URLs, allowing scripts to be fetched and executed in a blocking manner within the worker context.

_runtime/ops/web\worker · high confidence

Syntax highlighting for code blocks now supports JSX, TSX, and dark mode

The documentation tooling now uses PrismJS 1.30.0 to highlight code blocks, adding support for JSX and TSX syntax in addition to the previously supported languages. The included CSS provides both light and dark themes, allowing code blocks to adapt to the user's display preference.

cli/tools/doc · high confidence

TypeScript 6.0.3 upgrade with new standard library declarations

The Deno runtime has upgraded to TypeScript 6.0.3, replacing the previous TypeScript fork with stock TypeScript. This update introduces new type declaration files in the \cli/tsc/dts\ directory, including \lib.decorators.d.ts\ and \lib.decorators.legacy.d.ts\ to support modern decorator contexts, and \lib.deno.desktop.d.ts\ to provide type definitions for the new \deno desktop\ subcommand (e.g., \Notification\, \UIEvent\). The upgrade also brings in \@types/node\ type declarations out of the box, ensuring compatibility with Node.js APIs like \NodeJS.Timeout\ and \NodeListOf\.

cli/tsc/dts · high confidence

TypeScript 7.0.2 native compiler integration for deno check

Deno now supports running the native TypeScript compiler (tsc) for type checking via the \deno check\ command. This change introduces a new native check path that downloads and executes the pinned TypeScript 7.0.2 compiler binary, allowing users to leverage the stock TypeScript engine for faster and more accurate diagnostics. The implementation includes a new \cli/tsc/native.rs\ module to manage the compiler lifecycle, a \tsconfig\_gen.rs\ module to generate compatible tsconfig overlays, and updated JavaScript/TypeScript host files in \cli/tsc\ to bridge the native compiler with Deno's module resolution and runtime environment.

cli/tsc · high confidence

WebGPU implementation re-added to Deno

The WebGPU API has been re-introduced to Deno as a new extension in the \ext/webgpu\ directory. This change adds the full set of Rust bindings and JavaScript interfaces for GPU computing and rendering, including core objects like \GPUDevice\, \GPUBuffer\, \GPUTexture\, and \GPURenderPipeline\, as well as canvas integration via \GPUCanvasContext\. The implementation is built on the \wgpu\ backend library and exposes the standard WebGPU interface for use in Deno applications.

ext/webgpu · high confidence

Removals

deno\_console extension deprecated in favor of deno\_web

The \deno\_console\ extension has been deprecated. Users should migrate to using \deno\_web\ instead, as the functionality provided by this crate is now part of the broader web extension.

ext/console · high confidence

Architecture

CLI argument parsing migrated to the deno\_cli\_parser crate

The \cli/args\ module has been refactored to use the new \deno\_cli\_parser\ crate for parsing command-line flags and subcommands. This change consolidates flag definitions and parsing logic, moving core parsing implementation out of the CLI-specific code into a shared library. Users will see no functional change in supported flags or subcommands, but the internal structure of how arguments are processed has been standardized, improving maintainability and consistency across the codebase.

cli/args · high confidence

Consolidate web extensions into a single ext/web module

The \deno\_web\, \deno\_url\, \deno\_console\, and \deno\_broadcast\_channel\ extensions have been merged into a single \ext/web\ module. This consolidation reorganizes the underlying JavaScript source files (such as \00\_infra.js\, \00\_url.js\, \01\_broadcast\_channel.js\, and \01\_console.js\) into a unified location, simplifying the extension architecture and reducing module boundaries.

ext/web · high confidence

Extracted CommonJS resolution logic into a dedicated library crate

The CommonJS module resolution logic has been extracted from the CLI crate into a new, reusable \libs/resolver/cjs\ library. This change introduces a \CjsTracker\ and \IsCjsResolver\ that manage the determination of whether modules should be treated as CommonJS or ESM based on package.json configuration, file contents, and explicit \require()\ calls. This refactoring centralizes the CJS analysis logic, making it easier to maintain and reuse across different parts of the system.

libs/resolver/cjs · high confidence

Extracted cache logic into a standalone library

The cache implementation has been extracted from the CLI crate into a new, standalone \libs/resolver/cache\ library. This change introduces dedicated modules for managing the Deno directory structure (\DenoDir\), handling disk-based caching (\DiskCache\), storing transpiled emit outputs (\EmitCache\), and caching parsed AST nodes (\ParsedSourceCache\). By decoupling these components, the library can now be reused by other tools and services that require Deno's caching mechanisms without depending on the full CLI.

libs/resolver/cache · high confidence

Extracted module loading logic into a dedicated resolver/loader library

The module loading and resolution logic previously embedded in the CLI crate has been extracted into a new \libs/resolver/loader\ library. This change introduces a dedicated \ModuleLoader\ and \NpmModuleLoader\ that handle loading prepared and unprepared modules, including specific support for JSON imports (with attribute validation), CommonJS analysis, and npm package resolution. It also defines core types like \LoadedModule\ and \AllowJsonImports\ to standardize how modules are fetched and typed across the runtime.

libs/resolver/loader · high confidence

File system operations are now routed through an abstract FileSystem trait

The \ext/fs\ module has been refactored to decouple file system operations from the standard library by introducing a \FileSystem\ trait. This change allows the runtime to abstract away direct \std::fs\ calls, enabling features like custom file system implementations, better permission checking integration, and improved testability. The \RealFs\ struct now implements this trait to provide the default behavior, while the JavaScript API remains unchanged for users.

ext/fs · high confidence

Introduce dedicated npm\_installer library for package installation logic

The npm installation logic has been extracted into a new \libs/npm\_installer\ library, providing a modular foundation for managing \node\_modules\ layouts, bin entry generation (including Windows shim support), lifecycle scripts, and caching strategies. This change introduces a structured installer with support for hoisted layouts, workspace member resolution, and robust file-system synchronization, laying the groundwork for improved reliability and testability in Deno's npm compatibility layer.

_libs/npm\installer · high confidence

Introduce deno\_lib crate for shared CLI and runtime code

A new \deno\_lib\ crate has been added to \cli/lib\ to house shared code between the Deno CLI and the standalone runtime (\denort\). This refactoring consolidates common functionality—such as argument parsing, module loading, system abstraction, and version management—into a single library, ensuring both entry points stay in sync and reducing code duplication.

cli/lib · high confidence

Language server cache and document management refactored

The language server's internal caching and document handling have been restructured. A new \LspCache\ type now centralizes cache directory resolution and vendor scope management, replacing the previous scattered cache logic. Additionally, the \documents.rs\ module has been significantly expanded (over 2,600 lines) to consolidate document state, resolution, and dependency tracking, improving how the server manages open files and their associated metadata.

cli/lsp · high confidence

Merged deno\_core crate into main repository

The \deno\_core\ crate has been merged into the main repository under \libs/core\. This change consolidates the core runtime engine, V8 bindings, and essential JavaScript infrastructure (including primordials, timers, and the event loop) into a single codebase, replacing the previous external dependency structure.

libs/core · high confidence

New ext/os extension for OS APIs and signal handling

The \ext/os\ extension has been introduced to centralize operating-system-specific functionality, exposing lazy-loaded JavaScript modules (\30\_os.js\ and \40\_signals.js\) for environment variables, process exit, system information, and signal management. This change adds dedicated signal handling logic (binding, polling, and unbinding signals) and refactors core OS operations—such as \Deno.exit()\, environment variable access, and system info retrieval—into this new extension structure.

ext/os · high confidence

Node-API implementation moved to ext/napi

The Node-API implementation has been relocated into the \ext/napi\ extension directory. This change consolidates the Node-API source code, including the core API implementations, symbol export definitions, and build configuration, into a single, dedicated extension module. Users relying on Node-API compatible native addons will see this as a structural reorganization of the runtime's internal extension layout, ensuring the Node-API layer is now managed as a distinct, self-contained extension within the Deno runtime.

ext/napi · high confidence

Refactor CLI utilities into the cli/util module

The CLI utility functions have been consolidated into the new cli/util module, introducing dedicated modules for archive handling (archive.rs), console output and ANSI filtering (console.rs), human-readable display formatting (display.rs), global draw-thread rendering (draw\_thread.rs), environment variable tracking and denylist enforcement (env.rs), doc-test and snippet extraction (extract.rs), file watching and debouncing (file\_watcher.rs), file system operations (fs.rs), git integration (git.rs), path resolution and normalization (path.rs), and automatic pnpm-workspace.yaml migration (pnpm\_workspace.rs).

cli/util · high confidence

Refactored module system into focused submodules

The module loading and management logic in \libs/core/modules\ has been split into focused submodules (\import\_graph\, \loaders\, \map\, \map/dynamic\, \map/evaluation\, \map/ext\_script\, \map/tracked\, \map/wasm\). This structural change improves code organization and maintainability without altering the external module loading API or runtime behavior.

libs/core/modules · high confidence

Runtime crate restructured into modular extension crates

The \deno\_runtime\ crate has been refactored to replace the monolithic \deno\ crate with a collection of specialized extension crates (such as \deno\_fs\, \deno\_node\, \deno\_permissions\, and \deno\_process\). This change introduces a new modular architecture where the runtime is composed of these distinct components, exposing them via \lib.rs\ and configuring them through the \shared.rs\ extension definition and \snapshot\_info.rs\ initialization logic. For users, this represents a significant internal restructuring that improves modularity and maintainability, though the public \MainWorker\ API and core JavaScript execution behavior remain consistent.

runtime · high confidence

Test reporters refactored into a modular directory structure

The test reporting logic has been reorganized from a flat structure into a dedicated \cli/tools/test/reporters\ directory, introducing a modular architecture with separate files for each reporter type (common, compound, dot, junit, pretty, tap) and a central module definition. This change establishes a shared \TestReporter\ trait and common utilities, enabling reporters to be developed and maintained independently while supporting features like compound reporting, step-level result handling, and retry/repetition state management across all reporter implementations.

cli/tools/test/reporters · high confidence

Behavioural changes

1880 commits (567 fixes) modifying cli

A change to existing behaviour in cli — 1880 commits (567 fixs), 30 files: “Refactor Worker and ThreadSafeState (\#3242)”; “fix(lsp): do sloppy resolution for node-to-node imports in byonm (\#24481)”; “http\_cache: change .headers.json to .metadata.json (\#4175)”; and 1874 more (refs \#3242, \#24481, \#4175, \#2259, \#19975, …).

cli · medium confidence · unverified

Add AbortSignal listener with disposal support

The \addAbortListener\ utility in the Node.js polyfills now uses \AbortSignal.addEventListener\ to register listeners and returns a disposable object that implements \SymbolDispose\. This allows the listener to be automatically cleaned up when the returned object is disposed, improving resource management for abort handling.

ext/node/polyfills/internal/events · high confidence

Bench tool rewritten with Mitata engine and new reporting format

The benchmarking tool in cli/tools/bench has been completely rewritten to use the Mitata benchmarking engine. This introduces a new console output format that displays CPU and runtime information, supports benchmark grouping with group summaries, and includes a new JSON reporter that outputs a structured schema including version, runtime, and CPU details. The change replaces the previous implementation with a modular architecture separating the core engine (mitata.rs), reporting logic (reporters.rs), and main orchestration (mod.rs).

cli/tools/bench · high confidence

Broadcast Channel extension deprecated in favor of deno\_web

The \ext/broadcast\_channel\ crate is now deprecated and users should migrate to \deno\_web\. The extension's functionality has been merged into the \deno\_web\ crate, and the standalone \broadcast\_channel\ extension is no longer the recommended way to access Broadcast Channel APIs.

_ext/broadcast\channel, ext/url · high confidence

Deno CLI snapshot system restructured with lazy-loading and minification

The snapshot build process has been restructured to improve startup performance and binary size. The build script now generates a V8 snapshot and separately handles 'residual' sources—lazy-loaded modules that were not consumed during snapshot creation—by pre-transpiling and optionally minifying them (controlled by the \DENO\_SNAPSHOT\_MINIFY\_SOURCES\ environment variable). These residual sources are embedded as static strings in the binary to avoid per-script heap allocations at runtime. The system also enforces that lazy modules do not leak into the eager snapshot, ensuring that heavy dependencies like the Node.js polyfill closure remain lazy-loaded. The embedded TypeScript version is updated to 6.0.3.

cli/snapshot · high confidence

Fetch extension rewritten with hyper and lazy-loaded scripts

The \ext/fetch\ module has been completely rewritten to use the \hyper\ HTTP library instead of \reqwest\, and its JavaScript source files (such as \20\_headers.js\, \22\_body.js\, and \26\_fetch.js\) have been converted to lazy-loaded scripts. This change improves startup performance by deferring the loading of fetch-related code until it is actually needed, and it aligns the fetch implementation with the new \hyper\-based HTTP server infrastructure.

ext/fetch · high confidence

Improved CommonJS export analysis for member-reexport patterns

The CommonJS analyzer now correctly handles the \module.exports = require("X").MEMBER\ pattern (common in packages like graphql-tag) by detecting this shape and recording it as a member-scoped re-export, ensuring only the specific member is advertised rather than the entire inner module. Additionally, the analyzer now supports \exports.MEMBER = IDENT\ patterns where IDENT has static property assignments (e.g., \IDENT.X = ...\), allowing the resolver to narrow advertised exports to exactly those properties. This change also introduces a guard for extensionless files to avoid parsing binary assets as code.

libs/resolver/cjs/analyzer · high confidence

Improved \`deno outdated\` output and error handling

The \deno outdated\ command now displays a warning when packages are skipped due to registry errors, ensuring users are aware of missing metadata instead of having them silently ignored. Additionally, the 'Latest' column in the outdated report now uses the \dist-tags.latest\ value, aligning the output with the behavior of npm, pnpm, and Bun.

cli/tools/pm/outdated · high confidence

Improved error source location accuracy via V8 API

The Node.js compatibility layer now uses a new V8-based operation (\op\_node\_get\_first\_expression\) to determine the source location of errors. This change, implemented in the new \error\_source.ts\ module, replaces previous methods to provide more accurate file and line information in error messages, enhancing debugging for applications relying on Node.js assertion and error handling behaviors.

ext/node/polyfills/internal/errors · high confidence

Inspector server refactored into a standalone crate with host header validation

The inspector server implementation has been moved into a separate \libs/inspector\_server\ crate, making the server a global singleton. This change introduces strict validation for the \Host\ header in inspector requests, rejecting ambiguous or named authorities to improve security and compatibility. It also adds configuration options for publishing the inspector UID to the console and via HTTP endpoints, mirroring Node.js behavior, and includes a Clippy configuration to enforce system trait usage for file and environment operations within the new crate.

_libs/inspector\server · high confidence

Inspector server validates Host headers and LSP runtime initialization order is fixed

The inspector server now validates the HTTP Host header on incoming WebSocket connections, rejecting requests with invalid or unspecified addresses to prevent unauthorized access. Additionally, the LSP component ensures the Tokio runtime is created before the JsRuntime in the TSC thread, resolving a CPU busy loop issue that occurred when delayed V8 tasks were scheduled.

libs/dcore · high confidence

Introduce centralized codegen for unstable feature flags

The runtime now uses a new \runtime/features\ module to manage unstable features via a centralized data model and build-time code generation. A new \build.rs\ script reads \data.rs\ to auto-generate \gen.rs\ (Rust definitions) and \gen.js\ (JavaScript IDs), ensuring the CLI flags and runtime checks stay in sync. This introduces a \FeatureChecker\ component that validates feature availability at runtime, exiting with an error if an unstable feature is used without the corresponding flag. The diff explicitly lists supported unstable features including bare-node-builtins, broadcast-channel, cron, FFI, KV, net, temporal, and others, establishing the single source of truth for feature gating.

runtime/features · high confidence

Introduce on-demand growing future arena for improved operation performance

The runtime's operation driver now utilizes a new arena-based memory management system to store and manage asynchronous operations. This change introduces a \FutureArena\ that pre-allocates space for a small number of futures (16) and grows on demand (up to 256) by appending new chunks, avoiding expensive reallocations. Futures that exceed the arena's capacity or size limits are automatically allocated on the heap. This optimization reduces memory overhead and improves performance for workloads with many concurrent operations by minimizing heap allocations and improving cache locality for in-flight ops.

_libs/core/arena, libs/core/runtime/op\driver · high confidence

Isolated native addon loading for compiled binaries

The \deno compile\ runtime now extracts native addons (used by Deno FFI and Node API) into a dedicated, isolated cache directory (\deno-native-addons\) within the system temp folder rather than loading them from the bundled executable path. This change ensures that native addons are written to a writable location with correct permissions, resolving issues where readonly filesystems or sandboxed environments prevented addon loading, and improves security by isolating these dynamic libraries from the main binary.

_ext/rt\helper · high confidence

Lazy-loaded fs/promises API with expanded function support

The \fs/promises\ module now uses lazy loading to defer initialization of the underlying Node.js \fs\ implementation until first access, improving startup performance. This change also expands the available API surface by adding support for \glob\, \cp\, \lchmod\, \lchown\, \lutimes\, \statfs\, and \mkdtempDisposable\, ensuring broader compatibility with Node.js file system operations.

ext/node/polyfills/fs · high confidence

Linting infrastructure refactored with plugin support and fix capabilities

The linting engine in \cli/tools/lint\ has been restructured to support JavaScript linting plugins, automatic code fixes via \--fix\, and package-level lint rules. This change introduces a new \CliLinter\ and \PluginHost\ architecture that allows external JS plugins to run within a dedicated worker, enabling richer linting capabilities. Users will see improved handling of lint fixes, better integration with workspace configurations, and more robust error reporting through updated reporters.

cli/tools/lint · high confidence

Major upgrade of Node.js stream polyfills for improved compatibility and performance

The internal stream polyfills in \ext/node/polyfills/internal/streams\ have been significantly upgraded and refactored. This change introduces new implementations for core stream utilities such as \add-abort-signal\, \compose\, \destroy\, \duplex\, \duplexify\, \end-of-stream\, \from\, \operators\, \passthrough\, and \pipeline\, replacing previous versions to better align with Node.js behavior. It also adds a new \fast-utf8-stream\ module to support the \fs.Utf8Stream\ feature, providing a high-performance streaming interface for UTF-8 text. Additionally, the polyfills now utilize lazy-loaded scripts via \core.loadExtScript\ to improve startup performance and reduce memory usage, while fixing several compatibility issues related to web streams, abort signals, and error handling.

ext/node/polyfills/internal/streams · high confidence

New Windows subprocess implementation with improved pipe handling and argument validation

The \deno\_subprocess\_windows\ crate introduces a custom Windows subprocess spawning implementation that replaces the previous approach. This new library provides better support for detached processes and passing file descriptors to child processes. Key improvements include avoiding collisions in Windows stdio pipe names by using named pipes with overlapped operations instead of anonymous pipes, rejecting NUL bytes in command arguments to prevent security issues, and properly honoring the \windowsHide\ option in child process spawning. The implementation is largely adapted from libuv and the Rust standard library, maintaining compatibility with \std::process::Command\ while adding Windows-specific capabilities.

_runtime/subprocess\windows · high confidence

New core I/O resource and buffer management system

The \libs/core/io\ module has been replaced with a new implementation that introduces \AdaptiveBufferStrategy\ for dynamic buffer sizing based on stream hints, \BufView\ and \BufMutView\ for efficient buffer management, and a new \Resource\ trait with \ResourceTable\ for managing I/O resources (like sockets and files) via numeric IDs. This change restructures how the runtime handles readable and writable resources, including support for bring-your-own-buffer (BYOB) reads and resource cancellation.

libs/core/io · high confidence

New glob collector with gitignore support and parse-error resilience

The glob configuration module has been replaced with a new implementation that recursively collects files based on include/exclude patterns while respecting .gitignore rules. This change introduces a new file walker that correctly handles nested gitignore files and allows explicit include paths to override gitignore exclusions. Additionally, the parser now retains valid gitignore patterns even when encountering parse errors, ensuring that configuration remains usable despite malformed entries.

libs/config/glob · high confidence

New global HTTP cache implementation with metadata-embedded file format

The global HTTP cache now uses a new file format where HTTP response metadata (URL, headers, timestamp) is appended to the end of the cached content file, separated by a specific marker line. This allows the cache to store and retrieve both the response body and its associated HTTP headers/metadata in a single file, improving cache integrity and enabling checksum verification during reads. The implementation includes new \cache\_file.rs\ module for reading/writing this format and updates to \GlobalHttpCache\ to use this new storage mechanism.

_libs/cache\dir/global · high confidence

New hand-written CLI parser library replaces clap

The \libs/cli\_parser\ crate introduces a zero-cost, hand-written CLI argument parser to replace the previous clap-based implementation. This change provides static command definitions, a custom parsing engine, and dedicated modules for converting arguments into typed flags, generating shell completions (bash, zsh, fish, powershell), and rendering help text. The new parser includes specific behavioral fixes, such as preserving double dashes before entrypoints and accepting all valid system permission descriptors, while also adding microbenchmarks to track parse performance.

_libs/cli\parser · high confidence

New internal DNS polyfill implementation for Node compatibility

The \ext/node/polyfills/internal/dns\ directory now contains new \promises.ts\ and \utils.ts\ files that implement the internal logic for the Node.js \dns\ module polyfill. This adds support for promise-based DNS operations (such as \lookup\ with family, hints, and order options) and provides utility functions for DNS record types, validation, and error handling, improving compatibility with Node.js applications relying on these internal DNS mechanisms.

ext/node/polyfills/internal/dns · high confidence

New signal handling implementation using deno\_signals

The \ext/os/ops\ module now implements signal handling via the \deno\_signals\ crate, introducing new operations (\op\_signal\_bind\, \op\_signal\_poll\, \op\_signal\_unbind\) to manage signal resources. This change replaces previous signal handling logic, ensuring that signal resources are properly unregistered when dropped or closed, and validates signal names against a forbidden list before binding.

ext/os/ops · high confidence

Node process polyfills: active resources, warnings, and report stubs

The \ext/node/polyfills/internal/process\ directory now includes dedicated polyfill modules that enhance Node.js compatibility. \active\_resources.ts\ implements the internal tracking infrastructure for \process.getActiveResourcesInfo()\, maintaining sets of active requests and handles to report their types. \warning.ts\ handles deprecation and other process warnings, ensuring they are printed to \stderr\ and respecting \--disable-warning\ flags. \report.ts\ provides a stubbed \process.report\ object, including a \getReport\ method that correctly omits \glibcVersion\ fields on non-glibc platforms (like musl) to prevent tooling breakage. \per\_thread.mjs\ contains the core per-thread process logic, including the comprehensive list of allowed Node environment flags.

ext/node/polyfills/internal/process · high confidence

Node.js assert polyfill implementation and lazy-loading

The \ext/node/polyfills/internal/assert\ module has been implemented with new files (\assertion\_error.js\, \calltracker.js\, \myers\_diff.js\, \utils.ts\) to provide Node.js-compatible assertion behavior, including support for \assert.CallTracker\, message functions, and formatted arguments. These polyfill scripts are now loaded lazily via \core.loadExtScript\ to improve startup performance.

ext/node/polyfills/internal/assert · high confidence

Node.js fs.cp and fs.cpSync compatibility improvements

The \fs.cp\ and \fs.cpSync\ polyfills have been refactored to improve Node.js compatibility and performance. The implementation now leverages native Rust operations (\op\_node\_cp\_fast\, \op\_node\_cp\_sync\) for faster execution paths when specific options are used, while maintaining a JavaScript fallback for complex scenarios involving filters or specific flag combinations. Error handling has been standardized to map internal errors to Node.js-compatible error codes (such as \EEXIST\, \EINVAL\, \EISDIR\), ensuring that applications relying on Node.js-style error behavior receive consistent results.

_ext/node/polyfills/\fs/cp · high confidence

Node.js internal util polyfills now use lazy-loaded scripts

The internal utility modules in ext/node/polyfills/internal/util (including colorize, colors, comparisons, debuglog, inspect, and types) have been converted to lazy-loaded JavaScript scripts. This change improves startup performance by deferring the loading of these polyfills until they are actually needed, aligning with the broader effort to optimize the Node.js compatibility layer.

ext/node/polyfills/internal/util · high confidence

REPL architecture refactored into modular components

The REPL implementation in cli/tools/repl has been reorganized into distinct modules (channel, editor, session, and mod) to improve code structure and maintainability. This change introduces a synchronous message channel to bridge Rustyline's synchronous interface with async runtime operations, refactors the editor helper to handle tab completion and syntax validation via CDP messages, and consolidates session state and evaluation logic into a dedicated session module. Users benefit from a more stable and maintainable interactive experience, with underlying improvements to how input is processed, validated, and evaluated.

cli/tools/repl · high confidence

Readline polyfill rewritten in lazy-loaded JavaScript for better performance and compatibility

The internal Node.js readline polyfills have been converted from TypeScript to lazy-loaded JavaScript modules (callbacks.mjs, emitKeypressEvents.mjs, interface.mjs, promises.mjs, symbols.mjs, utils.mjs). This change improves startup performance by deferring module loading and enhances compatibility with Node.js behavior, including fixes for line separators, environment permission checks for TERM, and the process object definition within readline.

ext/node/polyfills/internal/readline · high confidence

Redesigned \`deno publish\` with OIDC support and improved diagnostics

The \deno publish\ command has been refactored to support authentication via GitHub Actions OIDC, allowing tokenless publishing from CI environments. The tool now provides more granular diagnostics, including validation of package paths, detection of circular workspace dependencies, and better error reporting for JSR manifest verification. It also handles precompilation in JSX publishing and improves the handling of import specifiers in Wasm modules.

cli/tools/publish · high confidence

Refactored CLI cache to use a shared SQLite backend with WAL journaling

The cache implementation in cli/cache has been refactored to use a shared SQLite database backend (via rusqlite) for type checking, code caching, fast check, incremental formatting/linting, module info, and Node CJS analysis. The new CacheDB abstraction initializes SQLite connections off the main thread to prevent blocking, and uses Write-Ahead Logging (WAL) journal mode by default to improve concurrency, with a fallback to TRUNCATE mode on WSL-1 systems. Cache data is now versioned and automatically cleared when the Deno CLI version changes, and failures are handled gracefully by falling back to in-memory or blackhole caches.

cli/cache · high confidence

Refactored Node.js process polyfills for improved performance and compatibility

The process polyfills in ext/node have been restructured to improve startup performance and Node.js compatibility. The process module is now lazy-loaded, and internal dependencies (such as nextTick, errors, and fs) are loaded via lazy scripts to reduce snapshot size and initialization time. The process.env implementation has been rewritten using a Proxy to better match Node.js behavior, including proper handling of Symbol keys, deletion, and type validation. The process.chdir function now wraps errors with path, destination, and syscall information to match Node.js error formats. Additionally, process.stdout and process.stderr streams now support partial writes, resize events, color depth detection, and have writable isTTY properties, providing more accurate emulation of Node.js standard streams.

_ext/node/polyfills/\process · high confidence

Refactored console implementation to use lazy-loaded scripts and updated module scheme

The console polyfill implementation in ext/node/polyfills/internal/console has been refactored to improve performance and maintainability. The code now utilizes lazy-loaded scripts via core.loadExtScript for dependencies such as diagnostics\_channel, errors, validators, buffer, util/inspect, and cli\_table, which reduces initial startup overhead. Additionally, the internal module loading scheme has been updated to use the ext:deno\_node/ prefix for these dependencies, aligning with broader changes to the Node.js compatibility layer's module resolution.

ext/node/polyfills/internal/console · high confidence

Refactored installer into global and local modules with improved binary name resolution

The installer logic in \cli/tools/installer\ has been split into separate \global.rs\ and \local.rs\ modules, introducing a new \BinNameResolver\ component that accurately resolves executable names for global npm installs by inspecting package bin entries and handling scoped packages. This refactoring supports installing multiple global packages, requires \--\ to separate script arguments from package specifiers in \deno install -g\, and ensures that workspace member resolutions and import maps are correctly preserved and flattened into the installed command's configuration.

cli/tools/installer · high confidence

Refactored node:fs polyfills into internal/fs modules with expanded FileHandle and stream support

The \node:fs\ polyfill layer has been consolidated into the \ext/node/polyfills/internal/fs\ directory, introducing dedicated modules for file handles (\handle.ts\), promise-based operations (\promises.ts\), and streams (\streams.mjs\, \sync\_write\_stream.js\). This restructuring adds comprehensive support for the \FileHandle\ class, including methods such as \read\, \write\, \writev\, \readv\, \appendFile\, \writeFile\, \chmod\, \chown\, \utimes\, \truncate\, \sync\, \readLines\, and \readableWebStream\, as well as enabling \FileHandle\ instances as valid arguments for \createReadStream\ and \createWriteStream\. The update also introduces \fs.SyncWriteStream\ for synchronous stdio handling, implements \fs.glob\ and \fs.globSync\, and ensures correct argument normalization and lazy-loading patterns to prevent circular dependency issues during module evaluation.

ext/node/polyfills/internal/fs · high confidence

Refactored npm package resolution into a managed resolver with hoisted and global modes

The npm resolution logic in \libs/resolver/npm/managed\ has been restructured into a new \ManagedNpmResolver\ that supports both local (hoisted) and global cache resolution modes. This change introduces a \LocalNpmPackageResolver\ for projects using a \node\_modules\ directory and a \GlobalNpmPackageResolver\ for global cache resolution, unified under a common \NpmPackageFsResolver\ interface. The refactoring includes improved \@types\ package resolution logic in \common.rs\ to better match version major/minor/patch when selecting DefinitelyTyped packages, and adds support for resolving bundled npm dependencies within the global cache. The \NpmResolutionCell\ now handles in-memory resolution state, separating it from file system interactions.

libs/resolver/npm/managed · high confidence

Replace external napi-sys with in-tree Node-API bindings

The \libs/napi\_sys\ crate has been replaced with an in-tree implementation forked from \napi-sys\ 2.2.2. This change removes the build-time dependency on the external Node.js binaries required by the previous crate and allows new Node-API symbols to be added directly within the project. The in-tree bindings flatten all Node-API version feature gates, making all symbols always available, and include updated type definitions such as \Float16Array\ support.

_libs/napi\sys · high confidence

Repository restructured with new configuration and tooling files

The repository root has been reorganized to include new configuration and tooling files. A \.dprint.json\ file is added to configure the dprint code formatter with specific settings for TypeScript, Markdown, JSON, YAML, and Rust (via rustfmt). An \.editorconfig\ file is introduced to standardize editor settings such as line endings and indentation. A \.gitattributes\ file is added to manage line endings and mark vendored files. The \.gitignore\ file is updated to exclude new build artifacts, coverage files, JUnit reports, and other generated files. A \.gitmodules\ file is added to define submodules for the standard library, Web Platform Tests, Node compatibility tests, and other dependencies. A \rust-toolchain.toml\ file specifies the Rust toolchain version and components. A \CLAUDE.md\ file is added as a development guide. The \LICENSE.md\ file is updated with the current copyright year. The \README.md\ is updated with new installation instructions and links. The \Releases.md\ file is updated with recent release notes. The \flake.nix\ and \flake.lock\ files are added for Nix-based development and building. The \x\ script is added as a developer CLI tool. The \main.go\, \main.ts\, and \tsconfig.json\ files are removed, indicating a shift away from the previous Go/TypeScript hybrid prototype.

(repo-wide) · high confidence

Rewrite CLI ops to use the op2 macro

The Rust implementation of CLI operations in cli/ops has been rewritten to use the new op2 macro system. This structural change modernizes the internal op registration and execution model, affecting core areas such as testing, benchmarking, linting, Jupyter kernel communication, and deployment token management.

cli/ops · high confidence

Rewrite node:zlib extension to use op2 macros and custom allocators

The \node:zlib\ extension has been rewritten to use the \op2\ macro system, replacing the previous implementation. This change introduces custom memory allocators (\zalloc\/\zfree\ and \brotli\_alloc\/\brotli\_free\) to manage zlib and Brotli streams, ensuring proper deallocation and preventing memory leaks. The rewrite also adds support for Brotli compression APIs, zstd compression, and dictionary options during initialization, while fixing several compatibility issues such as invalid compression parameters and incorrect return types for \zlib.crc32()\. The extension now validates input ranges more strictly and handles gzip header detection more robustly.

ext/node/ops/zlib · high confidence

Rewrite of Node.js Web Streams adapters for improved compatibility

The internal Web Streams adapters in the Node.js compatibility layer have been rewritten to improve interoperability between Node.js streams and Web Streams. This change introduces new lazy-loaded modules for adapters, readable streams, utilities, and worker transferable handling. Users will see fixes for backpressure handling in Readable.toWeb(), proper error handling in Writable.toWeb(), and corrected cancel semantics that prevent socket destruction when cancelling Readable.toWeb(). The implementation also adds validation for the options.type parameter and introduces a deprecation warning (DEP0201) for Duplex.toWeb({ type }).

ext/node/polyfills/internal/webstreams · high confidence

Runtime JavaScript modules restructured for lazy loading and performance

The runtime JavaScript source files have been reorganized to support lazy loading of heavy modules, significantly reducing cold-start overhead. Key changes include the introduction of \core.loadExtScript\ and \core.createLazyLoader\ in \90\_deno\_ns.js\ and \99\_main.js\ to defer loading of large dependencies like HTTP, WebSockets, and Telemetry until first access. New dedicated modules have been created for error classes (\01\_errors.js\), version info (\01\_version.ts\), and logging (\06\_util.js\), while global scope definitions are split into window and worker variants (\98\_global\_scope\_window.js\, \98\_global\_scope\_worker.js\) to optimize the \navigator\ object setup. This refactoring ensures that rarely used features do not impact startup time.

runtime/js · high confidence

Runtime ops migrated to the op2 macro and extension system

The runtime ops in \runtime/ops\ have been rewritten to use the new \op2\ macro and \deno\_core::extension!\ system. This migration introduces a modular extension architecture, replacing the previous monolithic op registration with distinct, self-contained extensions for bootstrap, desktop, file system events, HTTP, permissions, runtime, TTY, and workers. The change standardizes how operations are defined, registered, and exposed to JavaScript, improving performance and maintainability while ensuring stable external references for snapshotting.

runtime/ops · high confidence

Stack overflow protection during V8 deserialization

The \serde\_v8\ deserializer now enforces a maximum nesting depth of 128 levels when converting V8 values to Rust types. Previously, deeply nested objects or arrays from untrusted JavaScript could cause a stack overflow and abort the process; this change returns a specific \RecursionLimitExceeded\ error instead, preventing crashes while maintaining compatibility with standard serde behavior.

_libs/serde\v8 · high confidence

TLS extension restructured with key logging and flexible certificate verification

The \ext/tls\ crate has been reorganized to provide shared TLS utilities for other Deno extensions. This change introduces support for TLS key logging via the \SSLKEYLOGFILE\ environment variable, allowing encrypted traffic to be decrypted by tools like Wireshark. It also adds flexible certificate verification options, including the ability to ignore hostname verification errors for specific IP addresses or DNS names via an allowlist, and supports disabling server name verification entirely. The extension now uses concrete error types and lazy initialization for the root certificate store to improve performance.

ext/tls · high confidence

Web Storage implementation rewritten with SQLite backend and op2 ops

The \ext/webstorage\ module has been completely rewritten to use SQLite for persistence instead of the previous implementation. \localStorage\ is now backed by a persistent SQLite database file (with Write-Ahead Logging enabled for performance), while \sessionStorage\ uses an in-memory SQLite database. The Rust side now uses the \op2\ macro for operations, and the JavaScript side implements the \Storage\ object via a Proxy to handle property access, iteration, and symbol traps according to the Web Storage spec. A 10MB storage limit is enforced via \size\_check\ on input and total database size.

ext/webstorage · high confidence

WebCrypto API rewritten in Rust with cppgc integration

The \ext/crypto\ extension has been ported from JavaScript to Rust, implementing the core \Crypto\, \CryptoKey\, and \SubtleCrypto\ classes as cppgc-wrapped native objects. This change moves the algorithm registry, key management, and cryptographic operations (including AES, RSA, ECDSA, Ed25519, HKDF, and post-quantum algorithms like ML-DSA and ML-KEM) into the Rust layer for improved performance and stability. The JavaScript side now serves as a thin shim for V8-specific bookkeeping, such as lazy singleton initialization, structured clone support, and ensuring correct Promise-based error handling for synchronous native methods.

ext/crypto · high confidence

WebIDL extension is now lazy-loaded

The \deno\_webidl\ extension has been restructured to load its JavaScript implementation (\00\_webidl.js\) lazily rather than at runtime startup. This change reduces the initial memory footprint and startup time by deferring the loading of Web IDL conversion utilities until they are actually needed by other APIs.

ext/webidl · high confidence

WebSocket implementation rewritten using fastwebsockets and hyper 1.1

The \ext/websocket\ extension has been completely rewritten to replace the previous \tokio-tungstenite\ backend with \fastwebsockets\ and to migrate the HTTP upgrade logic to \hyper\ 1.1. This change introduces new Rust ops (e.g., \op\_ws\_create\, \op\_ws\_send\_binary\) and JavaScript modules (\01\_websocket.js\, \02\_websocketstream.js\) that handle WebSocket connections, including support for HTTP/2 upgrades and custom HTTP headers. The rewrite also adds an internal stream abstraction (\stream.rs\) to manage read/write halves for upgraded connections, network streams, and HTTP/2 streams, resulting in improved performance and stability for WebSocket operations.

ext/websocket · high confidence

Workspace config discovery now supports mixed Deno and npm package.json roots

The workspace configuration system has been refactored to handle directories containing both \deno.json\ and \package.json\ files. The new \ConfigFolder\ and \DenoOrPkgJson\ types in the discovery logic allow a workspace root or member to be defined by either config file, or both simultaneously. This enables better interoperability for projects that use \package.json\ for npm dependencies while using \deno.json\ for Deno-specific settings, ensuring that workspace member discovery and configuration resolution work correctly regardless of which config file is present.

libs/config/workspace · high confidence

Fixes

Cache 404 responses and disambiguate HTTP authority filenames

The cache now stores HTTP 404 responses as cached entries (using a dedicated header) so that missing remote modules are not re-requested on every process start. Additionally, the filename generation for HTTP/HTTPS URLs has been updated to make authority paths unambiguous: hostnames containing underscores are escaped, explicit ports are separated by a distinct token, and authorities that would exceed filesystem component length limits are hashed, ensuring that different URLs never collide in the cache directory.

_libs/cache\dir · high confidence

Fix Linux desktop runtime crashes and NAPI symbol export issues

The Linux desktop runtime now correctly exports NAPI symbols required by native addons (such as next-swc) and hides bundled libc++ symbols to prevent runtime aborts when the runtime is loaded via dlopen. This resolves a crash caused by ELF interposition conflicts between the bundled C++ runtime and the host system's libstdc++.

_cli/rt\desktop · high confidence

Fix npm registry read permission check for BYONM paths

The npm registry read permission checker now normalizes paths before checking for a \node\_modules\ ancestor in Bring Your Own Node Modules (BYONM) mode. This prevents traversal attacks (e.g., \./node\_modules/../../../etc/passwd\) from bypassing the \--allow-read\ permission check, ensuring that only legitimate paths within the node\_modules tree are accessible without explicit read permissions.

cli/lib/npm · high confidence

Fix npm resolution for synthetic modules and BYONM version mismatches

The npm resolver now correctly handles synthetic modules (like \deno eval\ or piped stdin) by ensuring they are not mistakenly treated as npm package files, which previously caused resolution failures when the current working directory was inside \node\_modules\. Additionally, the Bring Your Own Node Modules (BYONM) resolver has been improved to fall back to the \.deno/\ cache directory when the version of a package installed in \node\_modules\ does not satisfy the requested version requirement, and to prefer exact version matches during resolution.

libs/resolver/npm · high confidence

Fix worker thread crashes when receiving Node.js host objects

Resolves a crash in worker threads when receiving Node.js host objects (such as crypto KeyObjects, X509Certificates, or perf\_hooks histograms) via postMessage or workerData. A new eagerly-evaluated module registers structured-clone deserializers for these types at snapshot time, ensuring they are available in every worker even when their lazy polyfill modules are not loaded at startup.

ext/node/polyfills · high confidence

Fixes to .env file parsing and loading behavior

This update improves the reliability and compatibility of loading .env files. It fixes parsing to correctly handle inner quotes within double-quoted values and includes underscores in unbraced variable names. Additionally, it restores the ability to traverse parent directories when locating env files and ensures that missing env files do not cause errors during compilation. The library also now supports value substitution when loading environment variables, allowing variables to reference other previously defined variables.

libs/dotenv · high confidence

Improved remote module caching with 404 handling and redirect support

The file fetcher now caches 404 responses for remote modules with a 15-minute TTL, preventing repeated network requests for missing resources while allowing new packages to propagate. It also correctly surfaces cached redirects, ensuring that modules previously fetched via redirection are resolved accurately from the cache. Additionally, the module now supports parsing and applying HTTP cache-control headers (such as max-age and no-cache) to determine cache freshness, and includes a new authentication token system that parses the DENO\_AUTH\_TOKENS environment variable to authorize access to private remote modules.

_libs/cache\_dir/file\fetcher · high confidence

New \`node:path\` polyfill implementation

The \ext/node/polyfills/path\ module has been replaced with a new implementation ported from \path-browserify\. This change introduces dedicated internal files for POSIX (\\_posix.ts\) and Windows (\\_win32.ts\) path logic, along with shared utilities (\\_util.ts\, \\_constants.ts\) and a main entry point (\mod.ts\) that exports standard Node.js path functions (such as \resolve\, \normalize\, \join\, \parse\, and \relative\) as well as platform-specific namespaces (\path.posix\ and \path.win32\). The implementation uses primordials for safe string operations and lazy-loads dependencies like glob matching, ensuring compatibility with Node.js path behavior across different operating systems.

ext/node/polyfills/path · high confidence

Node.js fs compatibility layer restructured and expanded

The \ext/node/polyfills/\_fs\ module has been consolidated into a new file-based structure, introducing dedicated implementations for \fs.copyFile\, \fs.cp\, \fs.lstat\, \fs.lutimes\, \fs.read\, \fs.readdir\, and \fs.write\, alongside shared utilities in \\_fs\_common.ts\ and constants in \\_fs\_constants.ts\. This restructure adds support for new Node.js APIs like \fs.cp\ and \fs.lutimes\, enhances \fs.readdir\ with recursive directory traversal and proper UTF-8 sorting, and improves \fs.exists\ to handle invalid paths gracefully. The changes ensure that file operations, including symbolic link handling and error mapping, align more closely with Node.js behavior.

_ext/node/polyfills/\fs · high confidence

Rewrite Node.js compatibility layer ops in Rust

The \ext/node/ops\ module has been rewritten in Rust, replacing the previous implementation with native \op2\ functions for core Node.js APIs including \assert\, \buffer\, \dns\, \fs\, \http\, \inspector\, and \ipc\. This change improves performance and stability by moving logic such as Buffer transcoding, DNS resolution, file descriptor handling, and IPC serialization directly into the runtime, while also fixing numerous compatibility issues with Node.js behavior.

ext/node/ops · high confidence

Rewrite of Node.js crypto polyfill internals

The internal implementation of the \node:crypto\ polyfill has been rewritten to align more closely with Node.js behavior. This change introduces new internal modules for handling cryptographic keys (\\_keys.ts\, \keys.ts\), random data generation (\\_randomBytes.ts\, \\_randomFill.mjs\, \\_randomInt.ts\), and core algorithms including ciphers (\cipher.ts\), hashes (\hash.ts\), Diffie-Hellman key exchange (\diffiehellman.ts\), key derivation (\hkdf.ts\, \pbkdf2.ts\, \scrypt.ts\), and key generation (\keygen.ts\). These files replace previous implementations to fix compatibility issues, improve performance, and ensure correct error handling and state management for cryptographic operations.

ext/node/polyfills/internal/crypto · high confidence

Rewritten HTTP/2 implementation with improved security and performance

The HTTP/2 implementation in ext/node/ops/http2 has been rewritten to improve protocol compliance, security, and performance. Key changes include fixing response splitting vulnerabilities by encoding headers as Latin-1, enforcing HTTP/2 header list size limits, and properly handling flow control and backpressure. The rewrite also adds support for HTTP/2 push streams, improves error handling for protocol violations, and enhances performance through optimized state management and frame processing.

ext/node/ops/http2 · high confidence

Rewritten HTTP/2 polyfill with improved validation and Node.js compatibility

The internal HTTP/2 polyfill implementation has been rewritten to enhance Node.js compatibility and protocol correctness. This change introduces a new compatibility layer (\compat.js\) that mirrors the \require('http')\ API, adds missing HTTP/2 constants and error codes, and enforces stricter validation on headers and frames (such as rejecting invalid pseudo-headers and empty DATA frames without END\_STREAM). It also exposes internal classes like \Http2Session\ for \instanceof\ checks and ensures proper handling of connection-level errors like unsolicited PING ACKs and GOAWAY flushing.

ext/node/polyfills/internal/http2 · high confidence

Test coverage

1 commit adding/updating tests in tests/testdata/image; 2 commits adding/updating tests in tests/specs/lint/no\_import\_prefix; 4 commits adding/updating tests in tests/specs/lint/no\_slow\_types; Add Autobahn\|testsuite fuzzing client for WebSocket conformance testing; Add spec tests for proxy configuration and HTTP proxying; Add unit tests for Deno runtime APIs; Added CLI integration tests for OpenTelemetry; Added ESM test suite for Node module.registerHooks API; Added FFI test suite and test harness; Added JSR and NPM test registry fixtures; Added Node.js compatibility regression and feature tests; Added Node.js compatibility test fixtures; Added Node.js compatibility test runner configuration; Added REPL test fixtures for type imports and promise rejections; Added SQLite test extension for validating extension loading; Added TLS test fixtures for certificate and PFX validation; Added WebGPU shader test data; Added WebIDL dictionary converter microbenchmark; Added Windows test runner assets and test fixtures; Added benchmark for HTTP content compressibility check; Added benchmark for Node.js child\_process IPC; Added benchmark test fixtures and expected outputs; Added benchmarking utility for deno\_core ops; Added benchmarks for Fetch Body and Headers performance; Added benchmarks for Web API performance; Added comprehensive benchmark suite for Deno performance testing; Added core runtime benchmarks for ops, snapshots, and arenas; Added formatter tests for Mustache, SVG, and XML files; Added inspector tests for Network domain, fetch, WebSocket, and watch restart behavior; Added integration tests for CA file handling in certificate validation; Added integration tests for Deno check behavior; Added integration tests for Deno check command scenarios; Added integration tests for JSX linting behavior; Added integration tests for \deno bump-version\ CLI; Added integration tests for bench, cache, compile, coverage, eval, FFI, flags, init, and JSR features; Added integration tests for custom CA file usage in fetch and cache operations; Added integration tests for lint JSON output and config overrides; Added integration tests for lint command scenarios; Added integration tests for lint configuration and file exclusion; Added integration tests for the bundle command; Added internal test utilities for Node.js compatibility; Added npm specifier test data and fixtures; Added regression test for HTML inline style formatting performance; Added regression test for HTTP agent reusedSocket flag after retry; Added regression test for HTTP/2 TCP handle ownership; Added regression test for JSR @latest specifier handling; Added regression test for JSR link with incidental package.json; Added regression test for JSX pragma linting panic; Added regression test for Node fs write stream permissions on Windows; Added regression test for Node.js require compile hook compatibility; Added regression test for Svelte switch-case in class interpolation; Added regression test for TLS Happy Eyeballs fallback; Added regression test for TLS JSStreamSocket deadlock; Added regression test for TLS JSStreamSocket resource leak; Added regression test for TLS detached ArrayBuffer handling; Added regression test for TLS empty buffer write panic; Added regression test for TLS keepalive with large request bodies; Added regression test for TLS readStop backpressure; Added regression test for Windows named pipe server re-acceptance; Added regression test for brotli CompressionFormat support; Added regression test for clearImmediate and TCP socket close race; Added regression test for coverage exclusion of patched packages; Added regression test for dead streaming body resource handling; Added regression test for host-FS CJS fallback with defineProperty exports; Added regression test for indestructible TTY stdout; Added regression test for negative caching of 404 responses; Added regression test for npm ESM packages without default type exports; Added regression test for npm registry sub-path compilation; Added regression test for process.\_getActiveHandles() in exit handler; Added regression test for readline permission behavior; Added regression test for type-only imports in JSR package resolution; Added regression test for unhandled rejection reporting in coverage mode; Added regression test for workspace node\_modules symlink creation; Added regression tests for CJS/ESM default interop; Added regression tests for Node.js socket garbage collection; Added regression tests for Node.js stream wrap infrastructure; Added regression tests for blob URL worker revocation; Added regression tests for crypto.randomBytes buffer isolation; Added regression tests for vm.SourceTextModule import.meta handling; Added runtime test suite for core error handling, realms, and snapshots; Added snapshot tests for the JavaScript lint plugin AST; Added spec test for unsafe SSL certificate handling; Added spec tests for CA file URL imports and unsafe SSL handling; Added spec tests for TypeScript declaration file checking; Added spec tests for \deno eval\ behavior; Added spec tests for bare node builtins and publish behaviors; Added spec tests for cache and publish commands; Added spec tests for cache behavior with --allow-import and redirects; Added spec tests for caching multiple remote imports; Added spec tests for extensionless remote module checking; Added spec tests for import map configuration and internal specifier handling; Added spec tests for linting behavior and plugin API; Added spec tests for lockfile behavior; Added spec tests for node:worker\_threads compatibility; Added spec tests for package.json check scenarios; Added spec tests for publish command scenarios; Added spec tests for publish slow-types and unanalyzable dynamic import checks; Added spec tests for publish warnings and no-check mode; Added spec tests for the \deno x\ command; Added spec tests for the benchmark runner; Added spec tests for workspace publishing scenarios; Added test cases for type-checking code snippets in JSDoc and Markdown; Added test certificates for WPT runner; Added test coverage for @std/testing 1.0.0 registry entries; Added test coverage for BYONM publish with package.json; Added test coverage for CA file installation; Added test coverage for CJS detection via package.json type field; Added test coverage for CLI flags; Added test coverage for CSS imports and module-not-found diagnostics; Added test coverage for Deno check with no default lib; Added test coverage for JSON import assertions in cache command; Added test coverage for Node.js \test\ module \.only\ filtering; Added test coverage for Node.js child\_process IPC and stdio; Added test coverage for Node.js module resolution errors; Added test coverage for Node.js timer type compatibility; Added test coverage for TTY stream file descriptor properties; Added test coverage for Windows file fallback during compilation; Added test coverage for \deno check --all\ behavior; Added test coverage for \deno check --all\ behavior; Added test coverage for \deno compile --bundle\ scenarios; Added test coverage for \deno list\ and \deno why\ commands; Added test coverage for \export =\ declaration file handling; Added test coverage for \typesVersions\ resolution in npm dependencies; Added test coverage for ambient module declarations; Added test coverage for blob URL imports; Added test coverage for browser field map support; Added test coverage for bundling multiple entry points; Added test coverage for bytes and text raw imports in check mode; Added test coverage for child process extra pipes; Added test coverage for compile-time redirect handling; Added test coverage for compiler options with experimental decorators; Added test coverage for compilerOptions.paths with sloppy imports; Added test coverage for deno doc capabilities; Added test coverage for deny-net with resolved IPs in tcp\_wrap; Added test coverage for describe.only behavior; Added test coverage for erasableSyntaxOnly type-checking behavior; Added test coverage for ignore-directive edge case; Added test coverage for isolated declarations support; Added test coverage for lint respecting .gitignore; Added test coverage for missing license validation; Added test coverage for node fs.cp behavior; Added test coverage for node:readline/promises module; Added test coverage for node:test module compatibility; Added test coverage for package.json imports in Deno workspaces; Added test coverage for package.json overrides in audit; Added test coverage for process.kill on self without --allow-run; Added test coverage for process.stdout resize events; Added test coverage for publishing JSR packages in npm workspaces; Added test coverage for publishing JSX/TSX modules; Added test coverage for sloppy imports bundling behavior; Added test coverage for special specifier resolution in check mode; Added test coverage for the --allow-import flag in deno add; Added test coverage for the --desktop flag in type checking; Added test coverage for the --frozen flag in the bundle command; Added test coverage for the \deno pack\ command; Added test coverage for the noImplicitOverride compiler option; Added test coverage for trailing comment line counting; Added test coverage for workspace check behavior and known limitations; Added test coverage for workspace patching with local links; Added test data for Wasm module support; Added test data for coverage tool edge cases; Added test data for dynamic import compilation scenarios; Added test data for dynamic import permission checks; Added test fixture for @denotest/echo package; Added test fixture for JSR pre-release version handling; Added test fixture for JSR types-file registry entry; Added test fixture for import.meta.main detection; Added test fixture for linting public base classes; Added test fixture for verifying unstable flag forwarding in JSR targets; Added test fixture for write operations; Added test fixtures for @denotest/add registry versions; Added test fixtures for @denotest/subtract and @denotest/different-deps-per-export; Added test fixtures for CommonJS module resolution and runtime behavior; Added test fixtures for CommonJS module.exports member re-exports; Added test fixtures for JSR create functionality; Added test fixtures for JSR multiple exports; Added test fixtures for JSR registry and deploy help command; Added test fixtures for JSX precompile skip elements; Added test fixtures for Node-API C++ addons; Added test fixtures for TLS, Node.js SQLite, and utility scripts; Added test fixtures for TypeScript check scenarios; Added test fixtures for compile scenarios; Added test fixtures for configuration parsing and formatting; Added test fixtures for deno serve scenarios; Added test fixtures for glob patterns and SIGINT handling; Added test fixtures for inspector debugging scenarios; Added test fixtures for lazy-loaded ESM modules and script loading; Added test fixtures for minimum dependency age validation; Added test fixtures for module graph analysis; Added test fixtures for module resolution and import scenarios; Added test fixtures for multi-language formatting and glob patterns; Added test fixtures for npm workspace wildcard support; Added test fixtures for npm-private3 registry packages; Added test fixtures for performance benchmarks, compilation, and LSP registries; Added test fixtures for pre-release version handling; Added test fixtures for recursive parallel task execution; Added test fixtures for the bin-package registry entry; Added test fixtures for type-only JSR dependencies; Added test fixtures for unstable JSR package pre-release versions; Added test fixtures for workspace wildcard package resolution; Added test for --no-config flag error in deno install; Added test for AsyncLocalStorage context in unhandledRejection; Added test for BYONM compilation in subdirectories; Added test for Bun specifier externalization; Added test for CA store configuration in audit; Added test for CJS bound reexport detection; Added test for CJS default export type-checking behavior; Added test for CJS exports resolution without parent filename; Added test for CJS exports with escaped characters; Added test for CJS module resolution without extension in MJS package; Added test for CJS re-export handling in sub-folders; Added test for CJS re-export of relative path with parent component; Added test for CJS re-export with node condition; Added test for DENO\_COVERAGE\_DIR environment variable; Added test for DENO\_INSTALL\_ARCH environment variable; Added test for Deno.bundle() error in compiled binaries; Added test for Deno.unrefTimer with setTimeout; Added test for ES modules defined as CJS; Added test for ESM import of native Node.js addons; Added test for HTTP agent stale keep-alive connection retry; Added test for HTTP over Windows named pipes; Added test for HTTP proxy env var reading without --allow-env; Added test for HTTPS request over TLS with JSStreamSocket; Added test for HTTPS server peer certificate retrieval; Added test for JSDoc @import tag type checking; Added test for JSR package export caching; Added test for JSR package with unused parameters disabled; Added test for JSR publish exclusion errors; Added test for JSR publish validation of external imports; Added test for JSR subset type graph checking; Added test for JSR version-not-found error; Added test for JSX automatic runtime without explicit import source; Added test for JSX bundling with react-jsx; Added test for JSX import source resolution in check mode; Added test for JSX import source resolution with tsconfig; Added test for Node resolver error codes; Added test for Node types library reference; Added test for Node.js CommonJS classification of .js files; Added test for Node.js net module wake behavior; Added test for Node.js setImmediate timer ordering; Added test for Node.js test module with disabled exit sanitizer; Added test for Node.js worker threads module caching; Added test for POST body preservation on stale keepalive connections; Added test for TypeScript error message truncation behavior; Added test for TypeScript type checking in npm packages; Added test for WASM multi-value return type checking; Added test for Web/Node rejection handling order; Added test for WebAssembly streaming callback preservation in node:vm; Added test for Windows DLL lazy loading; Added test for adding packages without root exports; Added test for audit module fallback behavior; Added test for audit module fallback behavior; Added test for audit with subpath registry URLs; Added test for avoiding redundant packument refetches when registry lacks time data; Added test for banned triple-slash directives in non-leading positions; Added test for bare import error handling in cache command; Added test for bare import resolution errors; Added test for bare specifier not found errors; Added test for branch-junction line coverage in single-arm execution; Added test for bundled npm dependency resolution; Added test for bundling .wasm imports; Added test for bundling JSON imports; Added test for bundling modules within a Worker; Added test for bundling npm packages without bin entrypoints; Added test for bundling with createRequire and Node builtins; Added test for cache busting when lockfile version is missing; Added test for caching DTS query parameter redirects; Added test for caching npm dependencies from package.json; Added test for case-insensitive file inclusion in compilation; Added test for case-insensitive path permissions on Windows; Added test for child process pipe fd stdio nonblocking behavior; Added test for circular workspace dependency detection; Added test for compiled binary compatibility with eu-strip; Added test for compiling TypeScript files as assets; Added test for compiling WASM assets with host imports via --include; Added test for compiling with duplicate symlinks in include paths; Added test for compiling with external node\_modules symlinks; Added test for compiling with node\_modules inclusion; Added test for coverage data flushing on Deno.exit(); Added test for coverage merging with URL variants; Added test for coverage report error when no files are included; Added test for cross-compiling to Intel Mac targets; Added test for decorator polyfill exclusion from coverage; Added test for default V8 flags during compilation; Added test for deno add error with importMap field; Added test for deno fmt --check immutability; Added test for deno.json compiler option priority; Added test for deprecated npm package installation warnings; Added test for deterministic CJS re-export error reporting; Added test for diagnostic message chain formatting; Added test for dry-run publish error on gitignored files; Added test for entrypoint-only npm package installation; Added test for environment variable documentation in help output; Added test for excluding unused npm packages during compilation; Added test for export= error in ES modules; Added test for filtering doc testing URLs from coverage reports; Added test for formatting Astro files with TypeScript scripts; Added test for fs.cp with ignored read permissions; Added test for fs.cpSync filter function error handling; Added test for global cache node\_modules permission checks; Added test for global install config file warning; Added test for global install with package.json dependencies; Added test for global install with relative imports in config; Added test for global installation of npm specifiers; Added test for handling invalid lockfile bin entries; Added test for handling non-existent optional peer dependencies; Added test for ignoring certificate errors with IP addresses; Added test for inspector.url(); Added test for install with ignored entrypoints; Added test for install with import map pointing to a directory; Added test for invalid .gitignore handling in dry-run publish; Added test for invalid lint plugin error reporting; Added test for invalid scheme warnings during install; Added test for invalid workspace member version linting; Added test for lint plugin diagnostics without fixers; Added test for lint plugin fix error handling; Added test for lint plugin lifecycle hooks; Added test for lint plugin resolution in workspaces; Added test for lint plugin rule context API; Added test for lint syntax error reporting; Added test for linting JSR packages without a version field; Added test for linting UTF-8 BOM files; Added test for linting slow types in npm workspaces; Added test for local installation of scoped npm packages; Added test for local npm package installation via \deno install\; Added test for manual node\modules handling in cache; Added test for missing exports error message; Added test for missing name field error; Added test for missing npm module type declarations; Added test for missing version constraint errors during dry-publish; Added test for missing version constraint on JSX import source;

Added test for moving project after deno install; Added test for multi-file lint plugin comment reporting; Added test for multi-level indented embedded HTML templates; Added test for nested Deno workspace npm dependency resolution; Added test for nested coverage ignore comment warnings; Added test for net deny list enforcement on resolved IPs; Added test for node register hooks redirect in compiled binaries; Added test for node:net unix socket permission checks; Added test for non-blocking stdin handling after node:process import; Added test for non-fatal workspace diagnostics; Added test for non-normalized import specifiers; Added test for npm dist tag support in deno add; Added test for npm install diagnostics in type checking; Added test for npm package aliasing with ESM/CJS interop; Added test for npm package with empty main entry; Added test for npm specifier compilation in temporary directory; Added test for npm state preservation in Node spawning; Added test for npmrc auto-install with private registries; Added test for overloaded generics with unused type parameters; Added test for package.json auto-install in check command; Added test for package.json sideEffects field handling; Added test for peer dependency constraint warnings; Added test for peer dependency override warning suppression; Added test for per-workspace-member JSX import sources; Added test for permission denied errors in compiled binaries; Added test for preserving default exports in \export \\ re-exports; Added test for publish failure without authentication token; Added test for publishing JavaScript modules with declaration files; Added test for publishing a package.json-based module; Added test for publishing workspace root package; Added test for rejecting string arguments in ReadableStream.from; Added test for relative config resolution in check command; Added test for remote module override check; Added test for repeated compilation with --include flag; Added test for require("..") resolution in bundling; Added test for scoped package installation and checking; Added test for serving via import map bare specifier; Added test for skipLibCheck behavior; Added test for skipLibCheck graph errors; Added test for skipping already-published package versions; Added test for sloppy imports in npm packages; Added test for sloppy imports with rootDirs; Added test for spawnSync FD-indexed stdio inheritance; Added test for stable formatting of multi-line HTML tagged templates; Added test for standalone binary process.argv\[1\] behavior; Added test for streaming POST retry on stale keepalive connections; Added test for subpath imports starting with '\#/'; Added test for syntax error reporting with --no-check; Added test for transitive dependency cleanup in node\_modules; Added test for tree-shaking computed keys in bundling; Added test for tsconfig default library handling; Added test for tsconfig exclusion in publish graph; Added test for tsconfig rootDirs support in check command; Added test for tsconfig.json detection in check command; Added test for type-checking .d.ts files importing non-existent modules; Added test for type-checking Wasm module imports; Added test for types@ export conditions; Added test for uncaught exceptions thrown in nextTick; Added test for unref'd child process survival; Added test for unsafe SSL certificate validation with URL imports; Added test for untrusted TLS certificate hint; Added test for unused npm packages in lockfile; Added test for unused package cleanup during install; Added test for upgrade with spaces in temp directory; Added test for upgrading to specific canary versions; Added test for useUnknownInCatchVariables check behavior; Added test for vendor folder resilience when version metadata is deleted; Added test for vendor type-only imports during \deno ci\; Added test for workspace absolute link resolution; Added test for workspace auto-install with member-only package.json; Added test for workspace compilerOptions.rootDirs; Added test for workspace config warning when child is not a member; Added test for workspace import installation; Added test for workspace member dependency lifecycle INIT\_CWD behavior; Added test for workspace member with scoped tag dependency; Added test for workspace registry isolation during bundling; Added test registry fixtures for @std/url v0.220.1; Added test registry stubs for @std/assert and @std/path; Added test server utilities for HTTPS and npm registries; Added test suite for HTML entrypoint bundling; Added test suite for the \deno transpile\ subcommand; Added test utility macro for enhanced test configuration; Added tests for --ignore-env flag and config; Added tests for --npm and --jsr flags in deno add/install; Added tests for --package-json flag in add/remove commands; Added tests for .editorconfig integration in the formatter; Added tests for .gitignore support in formatting; Added tests for /dev/fd/XXX permission handling; Added tests for @std/http v1.0.0 route handling; Added tests for Astro CSS comment formatting and non-workspace directory handling; Added tests for BYONM dependency publishing and deno.jsonc exclusion; Added tests for BYONM phantom dependency resolution errors; Added tests for BYONM tag handling after installation; Added tests for CJS and CTS module compilation; Added tests for CJS re-exporting ESM modules; Added tests for CJS reexport source provider and npm reexport compilation; Added tests for CLI task completion in workspaces; Added tests for CPU profiler features; Added tests for CSS module import type checking; Added tests for ChildProcess IPC handle support on Unix; Added tests for DNS lookup permission token isolation; Added tests for DefinitelyTyped type resolution and node\_modules\_dir settings; Added tests for Deno workspace type-checking behavior; Added tests for Deno workspace vendor mode; Added tests for Deno.build.standalone in compiled executables and workers; Added tests for Deno.upgradeWebSocket with node:http upgrade events; Added tests for ESM module.exports export handling; Added tests for FFI and Node API compilation; Added tests for HTTP Agent keepAlive connection reuse; Added tests for HTTP/2 support in DENO\_SERVE\_ADDRESS override; Added tests for JSDoc comment dynamic imports; Added tests for JSON REPL mode and console log formatting; Added tests for JSON import attributes; Added tests for JSON import in bundled code; Added tests for JSONC trailing comma configuration and malformed config error handling; Added tests for JSR HTTPS import support and worker functionality; Added tests for JSR add preferring deno.json creation; Added tests for JSR dependency resolution and info output; Added tests for JSR export resolution using locked versions; Added tests for JSR linked package lockfile handling; Added tests for JSR module graph and HTTPS import security; Added tests for JSR module graph resolution; Added tests for JSR packages with npm dependencies and aliasing; Added tests for JSX pragma handling in JSR modules; Added tests for Jupyter kernel installation command; Added tests for NODE\_DEBUG environment variable support; Added tests for Node.js ESM directory import error handling; Added tests for Node.js \t.assert.fileSnapshot\ API; Added tests for Node.js builtin module type checking; Added tests for Node.js child\_process CLI argument handling; Added tests for Node.js compatibility of process.argv\[0\]; Added tests for Node.js crypto random functions; Added tests for Node.js dynamic import and require dual resolution; Added tests for Node.js error stack frames with internal frames; Added tests for Node.js missing extension suggestions; Added tests for Node.js module.registerHooks API; Added tests for Node.js net.Socket file descriptor handling; Added tests for Node.js nextTick microtask ordering; Added tests for Node.js package.json imports with wildcards; Added tests for Node.js process events and import permission flags; Added tests for Node.js process.title behavior; Added tests for Node.js unhandled rejection handling; Added tests for Node.js wrapped Response compatibility; Added tests for Nunjucks and Vento template formatting; Added tests for OAEP hash validation in publicEncrypt/privateDecrypt; Added tests for Pipe.open() file descriptor handling; Added tests for RSA PSS padding in Node.js crypto API; Added tests for Svelte top-level block formatting; Added tests for TCP numeric alias denial; Added tests for TypeScript formatting defaults and extension handling; Added tests for TypeScript suppression of unresolved imports; Added tests for UTF-8 BOM stripping in formatter; Added tests for V8 code cache coverage handling; Added tests for V8 single-threaded mode; Added tests for YAML formatter behavior; Added tests for \deno add --no-save\ and \--save-optional\ flags; Added tests for \deno add\ subpath and version constraint validation; Added tests for \deno audit\ registry error handling and clean scans; Added tests for \deno audit\ with Socket.dev integration; Added tests for \deno clean --dry-run\ behavior; Added tests for \deno clean --except\ with npm, JSR, and vendor dependencies; Added tests for \deno init\ library mode, npm scaffolding, and the \--yes\ flag; Added tests for \deno link\ and \deno unlink\ commands; Added tests for \import.meta.resolve\ with non-JSR URLs; Added tests for adding packages with only pre-release versions; Added tests for audit --level flag exit codes; Added tests for auto-linking external import maps in workspaces; Added tests for auto-serve and request body lifecycle; Added tests for automatic JSR tag linting; Added tests for browser platform export resolution; Added tests for buffered file reads in compiled binaries; Added tests for bundle error messages; Added tests for bundle external handling; Added tests for bundle sourcemap generation modes; Added tests for bundle type-checking behavior; Added tests for bundling directory imports with package.json; Added tests for bytes and text imports in Deno compile; Added tests for cache directory file fetching and caching logic; Added tests for canary upgrade functionality; Added tests for canary upgrade functionality; Added tests for catalog and workspace outdated behavior; Added tests for catalog: protocol support in deno.json imports; Added tests for child\_process fork CLI argument parsing; Added tests for child\_process stdio Socket compatibility; Added tests for child\_process.spawnSync maxBuffer enforcement; Added tests for compile --env flag and embedded file metadata display; Added tests for compile --include with data files and folders; Added tests for compile asset inclusion and preload resolution behavior; Added tests for compile config include/exclude fields; Added tests for compile determinism across different directories; Added tests for compile error handling in local and remote scenarios; Added tests for compile-time framework detection; Added tests for compiled binary child\_process.fork behavior; Added tests for compiled binary storage and validation; Added tests for compiled module registerHooks; Added tests for compiled npm module VFS operations; Added tests for compilerOptions.types resolution; Added tests for compiling blob URLs; Added tests for configurable coverage thresholds; Added tests for coverage behavior with missing source files; Added tests for coverage ignore comment warnings; Added tests for coverage report generation; Added tests for coverage reporting with non-BMP characters; Added tests for cyclic and diamond dependency graphs in vm.Module.link(); Added tests for cyclic npm workspace symlinks; Added tests for declaration emit with custom lib settings; Added tests for default npm registry resolution; Added tests for delta (bsdiff) upgrade behavior; Added tests for dependency addition with comments and existing dependencies; Added tests for dev dependency installation and npm aliasing; Added tests for dist tag support in \deno add\; Added tests for doc type-checking with duplicate identifiers and success cases; Added tests for dynamic import read permission checks in compiled binaries; Added tests for environment permission suffix wildcards; Added tests for exact version package addition; Added tests for external formatter with embedded languages; Added tests for extra package info resolution during install; Added tests for fallible dynamic imports and missing dependencies; Added tests for file lock starvation and unlock ordering; Added tests for formatter check mode, Jupyter notebook stdin, and config file handling; Added tests for formatter parse error handling; Added tests for fs.fstatSync on VFS files; Added tests for future \deno install\ with node\_modules and lockfile v5; Added tests for global JSR lockfile handling and security validation; Added tests for global install behavior when package name matches a non-existent file; Added tests for global install of unprefixed scoped packages; Added tests for global install workspace member resolution; Added tests for global installation of JSR packages; Added tests for global npm install with multiple bin entries; Added tests for graceful shutdown on SIGTERM/SIGINT; Added tests for handling broken pipes in help and version commands; Added tests for import assertions deprecation; Added tests for import deny list with resolved IPs; Added tests for import.meta.main bundling behavior; Added tests for improved error messages on missing npm specifiers; Added tests for install entrypoint and allow-scripts support; Added tests for install error messages on HTTP/HTTPS URLs without global flag; Added tests for install script execution in temporary directories and without file extensions; Added tests for installing existing npm dependencies; Added tests for installing npm packages as dev dependencies; Added tests for invalid --unsafely-ignore-certificate-errors values; Added tests for invalid exports map handling in linked packages; Added tests for invalid import validation in JSR publish; Added tests for jsxImportSourceTypes support; Added tests for lint JSON output including checked files list; Added tests for lint configuration validation with unknown fields; Added tests for lint plugin comment access; Added tests for lint plugin configuration and rule execution; Added tests for lint plugin environment and file read permissions; Added tests for lint plugin infinite edit detection and UTF-16 handling; Added tests for lint plugin multiple fixes and source code helpers; Added tests for lint plugin runtime API access; Added tests for linting in Deno workspaces; Added tests for linting packages with unanalyzable exports; Added tests for local deno install with --allow-import and lockfile v5; Added tests for local package patching via links; Added tests for lockfile updates during package add/remove; Added tests for minimum dependency age abbreviated packument behavior; Added tests for minimum dependency age exclusions; Added tests for minimum dependency age filtering; Added tests for minimumDependencyAge.exclude wildcard patterns; Added tests for net deny list enforcement on resolved IPs and ports; Added tests for node module type resolution; Added tests for node:dns.getServers() permission requirements; Added tests for node:fs APIs on VFS files in compiled binaries; Added tests for node:fs.statfs compilation and execution; Added tests for node:http proxy target permission checks; Added tests for node:net unix socket permission checks; Added tests for node:test context API and hook behavior; Added tests for node:test expectFailure API; Added tests for node:test mock.timers; Added tests for node:test runOnly behavior; Added tests for node:test timeout and unhandled rejection handling; Added tests for node:test watch-mode events; Added tests for node:test/reporters builtin module; Added tests for node\_modules lockfile copy behavior; Added tests for non-recursive permission checks on denied ancestors; Added tests for npm and JSR version range support in \deno add\; Added tests for npm dependency configuration in package.json and deno.json; Added tests for npm install with missing package.json metadata; Added tests for npm package module-not-found diagnostics; Added tests for npm pre-release dist-tag installation; Added tests for npm workspace dependency aliases; Added tests for npm workspace package installation behavior; Added tests for numeric hostname denial in network permissions; Added tests for package.json engines validation; Added tests for permission denial with absolute paths and temp file write scoping; Added tests for permission errors with binary execution paths; Added tests for pnpm lockfile catalog and workspace import; Added tests for preferPackageJson configuration; Added tests for publish provenance attestation outcomes; Added tests for publishing JSR packages with npm dependencies in workspaces; Added tests for publishing multiple packages with set-version; Added tests for publishing packages with special specifier schemes; Added tests for raw import publishing behavior; Added tests for raw text and bytes imports in bundling; Added tests for relative package import diagnostics; Added tests for removing process.once signal listeners; Added tests for removing scoped packages from package.json; Added tests for runtime TypeScript dynamic imports in compiled binaries; Added tests for serve type-checking behavior; Added tests for shebang-less script execution fallback; Added tests for shell argument injection prevention in node:child\_process; Added tests for slimmed packument caching with minimumDependencyAge; Added tests for sloppy import resolution patterns; Added tests for sortNamedImports and sortNamedExports options; Added tests for special file permission guards; Added tests for stabilized FFI and file system APIs; Added tests for stable embedded CSS multiline indentation; Added tests for stable upgrade process; Added tests for standalone binary self-spawning behavior; Added tests for stdin formatting with XML and SVG support; Added tests for symlink permission scoping behavior; Added tests for the --allow-import permission flag; Added tests for the --minimum-dependency-age flag in deno add; Added tests for the --permit-no-files flag; Added tests for the --preload flag in deno compile; Added tests for the --unscoped flag in package addition; Added tests for the Node.js module SourceMap API; Added tests for the OpenTelemetry console exporter; Added tests for the \deno audit\ command; Added tests for the \deno remove\ command; Added tests for the \deno serve\ subcommand; Added tests for the \onListen\ callback in \deno serve\; Added tests for the bundle allow-import flag; Added tests for the node:test mock API; Added tests for the unstable component formatter; Added tests for tsconfig handling without deno.json or --no-config; Added tests for tsconfig references, extends, files, include, and exclude; Added tests for type-only import caching in

\deno install\; Added tests for uncaughtExceptionMonitor origin handling; Added tests for uninstalling multiple global packages; Added tests for unprefixed package resolution in \deno add\; Added tests for unresolved imports in .d.ts entrypoints; Added tests for unstable CJS detection scenarios; Added tests for upgrade checksum verification; Added tests for upgrading to Deno 1.43.2; Added tests for v8.setHeapSnapshotNearHeapLimit; Added tests for vm dynamic import callback support; Added tests for vm dynamic import error handling; Added tests for vm.SyntheticModule constructor; Added tests for worker behavior and permissions; Added tests for worker import permissions; Added tests for workspace dependency catalog feature; Added tests for workspace lockfile behavior; Added tests for workspace member auto-linking by name; Added tests for workspace member imports; Added tests for workspace member node\_modules installation and pruning; Added tests for workspace package.json exports in compiled binaries; Added tests for yarn.lock to deno.lock seeding; Added type-checking tests for Express/Koa and transitive @types/node resolution; Added type-checking tests for node:stream/web global aliases; Added worker test fixtures and benchmarks; Expanded Node-API test coverage for native addon stability; Expanded Node.js compatibility test coverage; Expanded Node.js crypto compatibility tests; Expanded npm integration test coverage; Expanded npm test registry fixtures; Introduce WPT test runner infrastructure; New WPT test runner and documentation in tests/wpt; New spec-based integration test framework; New test harness utilities in tests/util; New test infrastructure for HTTP/2, gRPC, and registry simulations; Node.js compatibility test suite infrastructure and configuration; Spec tests for the task runner; Spec-based test suite for the test runner; Test coverage for banned triple-slash directives in dry-run mode; Test coverage for npmrc-based private registry authentication during compilation; Test runner infrastructure restructured with new channel and sanitizer logic; Tests for the removed \deno vendor\ command; Updated cache test expectations for bare import errors and performance stats.

Dependencies

3023 commits updating dependencies (817 manifests)

A dependency / build maintenance change in (dependencies) — 3023 commits (872 fixs), 817 files: “chore(ext/net): bump rustls-tokio-stream to fix panic (\#21763)”; “chore: upgrade deno\_task\_shell to 0.32.0 (\#34267)”; “fix(npm): occasional panic when upgrading npm package constraints (\#31006)”; and 3003 more (refs \#21763, \#34267, \#31006, \#31183, \#31205, …).

(dependencies) · high confidence · unverified

Updated bundled minimatch dependency to v10.2.5

The bundled minimatch library used for Node.js glob pattern matching has been updated to version 10.2.5. This change includes updated underlying dependencies (balanced-match 4.0.4 and brace-expansion 5.0.7) to support the new minimatch release, ensuring compatibility with the latest glob pattern syntax and fixes included in the upstream library.

ext/node/polyfills/deps · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 46 → 46 (+0.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 33 → 31 (-2.2)
  • Architecture 85 → 85 (-0.8)
  • Maturity 78 → 80 (+2.0)
  • Readiness 43 → 43 (+0.1)
  • Security 66 → 67 (+0.7)
  • Domain Modelling 100 → 100 (+0.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 60 → 70 (+10.0)

Resolved (269)

  • 00_serve.mapToCallback::mapped (cognitive 29) (ext/http/00_serve.ts)
  • 00_serve.mapToCallback::mapped (cyclomatic 22) (ext/http/00_serve.ts)
  • 01_http.createRespondWith (cognitive 86) (ext/http/01_http.js)
  • 01_http.createRespondWith (cyclomatic 39) (ext/http/01_http.js)
  • Coverage read from a committed report
  • Duplicated block (10 lines × 2) (cli/lib/standalone/binary.rs)
  • Duplicated block (10 lines × 2) (cli/lib/standalone/virtual_fs.rs)
  • Duplicated block (10 lines × 2) (cli/lsp/registries.rs)
  • Duplicated block (10 lines × 2) (cli/lsp/ts_server.rs)
  • Duplicated block (10 lines × 2) (cli/tools/lint/ast_buffer/swc.rs)
  • Duplicated block (10 lines × 2) (ext/crypto/node_interop.rs)
  • Duplicated block (10 lines × 2) (ext/crypto/node_interop.rs)
  • Duplicated block (10 lines × 2) (ext/io/lib.rs)
  • Duplicated block (10 lines × 2) (ext/node_sqlite/database.rs)
  • Duplicated block (10 lines × 2) (libs/config/deno_json/mod.rs)
  • Duplicated block (10 lines × 2) (libs/config/workspace/mod.rs)
  • Duplicated block (10 lines × 2) (libs/npm_installer/hoisted.rs)
  • Duplicated block (10 lines × 3) (ext/telemetry/lib.rs)
  • Duplicated block (10 lines × 3) (libs/core/uv_compat.rs)
  • Duplicated block (10 lines × 6) (ext/image/bitmap.rs)
  • …and 249 more

New (808)

  • 00_serve.mapToCallback.mapped (cognitive 29) (ext/http/00_serve.ts)
  • 00_serve.mapToCallback.mapped (cyclomatic 22) (ext/http/00_serve.ts)
  • 01_http.createRespondWith.respondWith (cognitive 86) (ext/http/01_http.js)
  • 01_http.createRespondWith.respondWith (cyclomatic 39) (ext/http/01_http.js)
  • AWS access key ID with no secret key beside it (.appveyor.yml)
  • AWS access key ID with no secret key beside it (.appveyor.yml)
  • AWS access key ID with no secret key beside it (.github/workflows/build.yml)
  • AWS access key ID with no secret key beside it (.github/workflows/lint.yml)
  • AWS access key ID with no secret key beside it (.travis.yml)
  • AWS access key ID with no secret key beside it (.travis.yml)
  • Critical CVE: [GHSA redacted] (Cargo.lock)
  • Duplicated block (10 lines × 2) (cli/lib/standalone/binary.rs)
  • Duplicated block (10 lines × 2) (cli/lib/standalone/virtual_fs.rs)
  • Duplicated block (10 lines × 2) (cli/lsp/language_server.rs)
  • Duplicated block (10 lines × 2) (cli/lsp/registries.rs)
  • Duplicated block (10 lines × 2) (cli/tools/lint/ast_buffer/swc.rs)
  • Duplicated block (10 lines × 2) (cli/tools/pm/cache_deps.rs)
  • Duplicated block (10 lines × 2) (ext/crypto/node_interop.rs)
  • Duplicated block (10 lines × 2) (ext/crypto/node_interop.rs)
  • Duplicated block (10 lines × 2) (ext/http/http_next.rs)
  • …and 788 more

Changes since last survey

  • 1 commits — 0 feature/other, 1 fixes

By area

  • tests/specs — 1 commit

Notable commits

  • fix: revert: type-check with native tsc by default (#37057)

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

denoland/deno was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit e7b39ebd55c85aaf6a29290c1f5a99e2e21e09dd — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.