Skip to content
CAI
Software that uses CAICheck a score

facebook/flow

45.3

Weak · 14 November 2026

576.3k

lines of production code

Rust

with JavaScript

3

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Babel plugin to transform Flow Enums

A new Babel plugin, \babel-plugin-transform-flow-enums\, has been added to convert Flow \EnumDeclaration\ nodes into runtime calls. When enabled with the Flow syntax plugin, it transforms enum declarations into \require('flow-enums-runtime')\ calls, supporting boolean, number, string, and symbol enum members, as well as exported and default-exported enums. The plugin also allows users to provide a custom \getRuntime\ option to customize the runtime reference generation.

packages/babel-plugin-transform-flow-enums · high confidence

Add JSON formatting and exit utilities for Flow CLI

Introduces new Rust crates \flow\_common\_exit\ and \flow\_hh\_json\ to handle CLI exit logic and JSON output. The \flow\_hh\_json\ crate provides functions to convert JSON values to strings, including a \pretty\_print\_compact\_at\_indent\ function that reformats compact JSON into multi-line output (mimicking OCaml's \Hh\_json\ style) when the compact form exceeds 80 characters, while preserving duplicate keys. The \flow\_common\_exit\ crate uses these utilities to print structured JSON error messages to stderr when exiting in JSON mode, allowing users to receive machine-readable error details from the Flow CLI.

_rust\_port/crates/flow\_hh\json · high confidence

Add Rust crate for reading process cgroup information

A new Rust library \flow\_procfs\ has been introduced to provide functionality for reading process cgroup data from the \/proc\ filesystem. The crate exposes a \first\_cgroup\_for\_pid\ function that retrieves the cgroup path for a given process ID, handling both cgroup v1 and v2 formats by parsing the first line of the \/proc/\<PID\>/cgroup\ file. It includes support for verifying proc filesystem availability and contains unit tests for the cgroup parsing logic.

_rust\_port/crates/flow\procfs · high confidence

Add TTY utility library for colored terminal output and spinners

Introduces a new Rust crate, \flow\_utils\_tty\, providing utilities for formatted terminal output. This includes support for ANSI color codes (foreground, background, and various text styles like bold or underline), automatic color detection based on terminal capabilities, and animated ASCII or emoji spinners for progress indication. Users will benefit from consistent, styled CLI output and visual feedback during long-running operations.

_rust\_port/crates/flow\_utils\tty · high confidence

Add \`tool ping\` command for measuring IDE command latency

A new \tool ping\ command has been added to the Flow dev tools. This command spawns the Flow Language Server Protocol (LSP) process, initializes a connection, and continuously sends \telemetry/ping\ requests to measure the latency of IDE commands. It outputs JSON results containing the start time, duration, and response data for each ping, allowing users to profile and monitor the performance of the Flow server.

packages/flow-dev-tools/src/ping · high confidence

Add file content and input utilities to flow\_server\_utils

The flow\_server\_utils crate now exposes file\_content and file\_input modules, providing utilities for handling LSP-style text edits and file inputs. The file\_content module introduces Position, Range, and TextEdit structs along with functions to convert between byte offsets and line/column positions, and to apply text edits to file content. The file\_input module defines a FileInput enum to represent files by name or content, with methods to retrieve the filename and content, including unsafe variants for direct access.

_rust\_port/crates/flow\_server\utils · high confidence

Added Flow type definitions for chalk, glob, and minimist

The flow-dev-tools package now includes Flow type definitions for the chalk, glob, and minimist libraries. This enables Flow to correctly type-check code that uses these dependencies, improving type safety and developer experience within the tooling.

packages/flow-dev-tools/flow-typed · high confidence

Added Flow type definitions for core parsing and utility libraries

This change introduces a suite of new Flow type definitions in the \packages/flow-typed\ directory to improve type checking for development tooling. The additions cover JavaScript and TypeScript parsers (\@babel/parser\, \espree\, \hermes-parser\, \@typescript-eslint/parser\), code formatting (\prettier\), and essential utilities (\glob\, \mkdirp\, \jest\, \jest-specific-snapshot\, \@babel/code-frame\). It also includes a minimal \node.js\ definition providing only the types required by \hermes-parser\ (such as \Buffer\, \fs\, and \child\_process\), ensuring that internal parsing and tooling code is properly typed without pulling in the full Node.js standard library.

packages/flow-typed · high confidence

Added Rust implementation for Watchman file-watcher expressions

A new Rust crate, flow\_server\_watchman\_expression\_terms, has been introduced to generate Watchman query expressions for the file watcher. This module constructs filters based on file suffixes, basenames, and excluded directories using configuration options, replacing the previous logic in the Flow server port.

_rust\_port/crates/flow\_server\_watchman\_expression\terms · high confidence

Added Rust-based test262 parser runner

A new binary \parse\_test262\ has been added to the flow parser crate, providing a Rust implementation for running the test262 JavaScript test suite. This tool scans test files, parses them using the Rust parser, and reports pass/fail/errored results, serving as a baseline for validating the parser's compliance with the ECMAScript specification.

_rust\_port/crates/flow\parser/src/bin · high confidence

Added subprocess execution utility with non-panicking error handling

A new \exec\ function has been added to the \flow\_lwt\_sys\_utils\ crate to run external commands asynchronously. On non-WASM targets, it executes commands via \tokio::process::Command\ and returns a \CommandResult\ containing stdout, stderr, and the exit status; notably, it treats non-zero exit codes as successful execution (returning \Ok\), only failing if the command itself cannot be spawned. On WASM targets, the function is stubbed to panic with a clear error message indicating that subprocess execution is not supported.

_rust\_port/crates/flow\_lwt\_sys\utils · high confidence

Enable file completion in bash for the flow command

Users can now benefit from enhanced bash command-line completion for the 'flow' command. The new completion script allows the shell to suggest file paths when the command context requires file arguments, improving usability when specifying input or output files.

resources · high confidence

Flow Upgrade tool adds codemods for modernizing Flow syntax and types

The Flow Upgrade tool in \packages/flow-upgrade/src/codemods\ has been expanded with a suite of new codemods to automate the migration of legacy Flow syntax to modern, TypeScript-compatible equivalents. These updates include converting legacy utility types (such as \$Partial\, \$Shape\, \$ReadOnly\, and \$NonMaybeType\) to their standard counterparts (\Partial\, \Partial\, \Readonly\, \NonNullable\), replacing React-specific dollar-utility types (e.g., \React$ComponentType\) with qualified names (\React.ComponentType\), and updating type casting syntax from \(\<expr\>: \<type\>)\ to \\<expr\> as \<type\>\. Additionally, the tool now handles structural cleanup by collapsing object initializations, removing duplicate class properties, eliminating abstract component references, and enforcing explicit inexact object type syntax.

packages/flow-upgrade/src/codemods · high confidence

Initial Rust port of the Flow server implementation

The Flow server is now implemented in Rust within the \flow\_server\ crate, replacing the previous implementation. This change introduces the core server lifecycle, including daemon registration and child-process handling (\server\_daemon.rs\), multi-threaded worker management via a thread pool (\server\_worker.rs\), and the main server initialization logic (\server.rs\). The new server respects the \FLOW\_MAX\_WORKERS\ configuration to control concurrency, manages the committed heap and environment state through the orchestrator, and supports saved-state initialization and extraction of built-in library definitions (including a new \flowlib-with-lib-dom-d-ts\ mode).

_rust\_port/crates/flow\server · high confidence

Initial open-source release of Flow

This change introduces the initial open-source release of Flow, including the project's code of conduct, contributing guidelines, MIT license, and comprehensive documentation. It establishes the build system for the Rust port (via Makefile and runtests.sh) and configures repository attributes to ensure consistent line endings and correct language detection for OCaml and binary files.

(repo-wide) · high confidence

Initial release of flow-transform and flow-eslint packages

This change introduces two new packages to the repository: \flow-transform\, a utility for traversing and transforming the Flow AST, and \flow-eslint\, a custom ESLint parser for linting Flow code. The \flow-eslint\ package supports both modern flat config and legacy \.eslintrc\ configurations, allowing users to specify parser options such as \jsxPragma\, \jsxFragmentName\, \sourceType\, and \fbt\ handling. Both packages include their respective MIT licenses and standard build artifacts in their \.gitignore\ files.

packages/flow-transform · high confidence

Initial setup of Flow configuration and package metadata for flow-dev-tools

The flow-dev-tools package now includes a .flowconfig defining include and ignore paths for node\_modules and internal test directories, with options for emoji support and pattern matching. A .npmignore file is added to exclude .flowconfig, flow-typed directories, and test files from the published package, while a .gitignore excludes node\_modules. Additionally, a flow-typed.config.json is introduced to specify environment libraries (bom, cssom, dom, etc.) for type definitions.

packages/flow-dev-tools · high confidence

Introduce AST node detachment and cloning utilities

The flow-transform package now exports utilities for handling detached AST nodes, allowing code generation to manipulate nodes without affecting the original source tree. This includes functions to create detached nodes (which can be shallow or deep clones), check if a node is detached, and retrieve the original node reference. These utilities help prevent unintended side effects when transforming or generating code, ensuring that original source locations and parent pointers are managed correctly.

packages/flow-transform/src · high confidence

Introduce Flow typing debug and spread cache modules

This change adds two new Rust crates to the Flow type-checking engine: \flow\_typing\_debug\ and \flow\_typing\_spread\_cache\. The \flow\_typing\_debug\ module provides comprehensive debugging and error-reporting infrastructure, importing and utilizing a wide array of error message data structures (such as \EIncompatibleTypeData\, \EnumErrorKind\, and \MatchErrorKind\) to format type errors for users. The \flow\_typing\_spread\_cache\ module implements a caching mechanism for spread operations, tracking lower bounds of operands to detect and report exponential spread errors efficiently, thereby improving performance and error clarity when handling complex object spreads.

_rust\_port/crates/flow\_typing\debug · high confidence

Introduce Rust type system core and JSX editing services

This change introduces the \flow\_common\_ty\ crate, which defines the core type representation (including primitives, generics, unions, intersections, and template literals) along with utilities for debugging, printing, serialization, and simplification. It also adds the \flow\_services\_jsx\ crate, providing IDE services for JSX that enable auto-closing of elements and linked editing of matching tags.

_rust\_port/crates/flow\_common\ty · high confidence

Introduce Rust-based AST diffing and code-printing utilities

The \flow\_parser\_utils\_output\ crate now provides a Rust implementation for generating AST diffs and printing JavaScript/Flow code. This includes a layout system (\layout.rs\) for managing whitespace and line breaks, a \js\_layout\_generator\ for converting AST nodes into layout structures, and printers (\pretty\_printer.rs\, \compact\_printer.rs\) that render these layouts into source text. The module also supports generating code patches (\replacement\_printer.rs\) for use in IDE services and code actions, enabling precise source transformations based on AST differences.

_rust\_port/crates/flow\_parser\_utils\output/src · high confidence

Introduce Rust-based Flow.js WebAssembly binding

Added a new Rust crate (\flow\_dot\_js\_wasm\) that compiles the Flow type checker to WebAssembly, providing a JavaScript glue layer to expose type-checking capabilities to web environments. This implementation includes state management for files and contexts, configuration parsing for linting and React runtime settings, and the core logic to parse, prepare, and check TypeScript/Flow files, enabling IDE and browser-based type checking.

_rust\_port/crates/flow\_dot\_js\wasm · high confidence

Introduce Rust-based error code and utility infrastructure

The \flow\_common\_errors\ crate now provides the foundational Rust implementation for Flow's error reporting system. This includes a comprehensive \ErrorCode\ enum covering type-checking, React, and linting diagnostics, alongside \error\_utils\ that define error structures (\ClassicError\, \FriendlyGeneric\) and formatting logic for user-facing messages. This change establishes the core error-handling layer for the Rust port, replacing previous mechanisms with a structured, serializable error model. Also in this area: Cleanup of OCaml translation artifacts in Rust source comments; Report unrecognized assertion calls; Dynamic discovery of built-in TypeScript libdefs.

_rust\_port/crates/flow\_common\errors · high confidence

Introduce Rust-based parser utilities for AST construction, validation, and analysis

The \flow\_parser\_utils\ crate has been added to the Rust port, providing a suite of utilities for working with the Flow AST. This includes an AST builder for constructing nodes, an enum validator for checking member consistency, and a file signature extractor that tracks imports, exports, and requires. The crate also features an AST differ for computing edit scripts, location mapping utilities (including indexed locations), and helpers for resolving package exports and GraphQL template literals. Comprehensive tests are included to verify the correctness of these components.

_rust\_port/crates/flow\_parser\utils · high confidence

Introduce Rust-based type signature and import/export analysis infrastructure

This change adds the \flow\_type\_sig\ and \flow\_imports\_exports\ crates to the Rust port, establishing the core data structures and logic for extracting, compacting, and hashing type signatures from source files. It introduces a compact table representation to efficiently store definitions and references, a marking phase to identify reachable exports, and specific support for TypeScript enum member value resolution. Additionally, it implements the parsing and representation of ES and CommonJS import/export statements, enabling the type checker to accurately model module boundaries and dependencies.

_rust\_port/crates/flow\_type\sig · high confidence

Introduce Rust-compiled Flow.js with WebAssembly support

Flow now includes a new JavaScript entry point (\flow\_dot\_js\_wasm.js\) and a packager utility (\flow\_dot\_js\_wasm\_packager.js\) that enable running the Flow type checker via a Rust-to-WASM build. This change adds the necessary glue code to load the WebAssembly module, handle memory allocation, and manage cryptographic primitives across different environments (Node.js and browsers). The packager script allows bundling the compressed WASM binary directly into the JavaScript output, creating a self-contained distribution that does not require separate sidecar files or network fetches for the WASM module.

src · high confidence

Introduce dedicated CLI entry points for Flow upgrade and codemod execution

The \flow-upgrade\ package now exposes two distinct command-line binaries: \upgrade.js\ and \runSpecificCodemod.js\. The \upgrade\ command allows users to specify a source and target Flow version to run the full upgrade suite, while the new \runSpecificCodemod\ command enables running individual codemods from the \codemods\ directory by name. Both tools share common options such as \--all\ (to process files without the \@flow\ pragma), \--prettierrc\ (for output formatting), \--silent\, and \--yes\ (to auto-confirm prompts), providing a more granular and flexible interface for managing Flow version migrations.

packages/flow-upgrade/src/bin · high confidence

Introduce eslint-plugin-fb-flow with five Flow-specific linting rules

The Flow team has published a new ESLint plugin, \eslint-plugin-fb-flow\, offering five rules to enforce modern Flow patterns: \use-indexed-access-type\ (replacing \$PropertyType\/\$ElementType\ with indexed access syntax), \use-exact-by-default-object-type\ (enforcing \{}\ over \{\|}\ for exact objects), \use-flow-enums\ (migrating from \keyMirror\/\Object.freeze\ to Flow Enums), \flow-enums-default-if-possible\ (simplifying enum member definitions), and \no-flow-enums-object-mapping\ (enforcing switch statements over object literals for enum mapping). Several rules include autofixers to automatically apply these changes.

packages/eslint-plugin-fb-flow · high confidence

Introduce flow services coverage tracking

Added a new Rust crate, \flow\_services\_coverage\, which implements a \CoverageVisitor\ to track type-checking coverage for Flow. This visitor analyzes type variables and constraints to determine whether code paths are fully checked, partially covered (Any), or empty, supporting both AND and OR merge operations for coverage metrics.

_rust\_port/crates/flow\_services\coverage · high confidence

Introduce flow-dev-tools record command for test recording

The flow-dev-tools package now includes a new 'record' command (recordCommand.js and recordRunner.js) that allows users to record test suites. This command supports specifying test suites via arguments, customizing the test directory with a --tests-dir flag, and re-recording failed tests from a previous run using --rerun-failed. The runner executes tests using the Flow binary, manages parallelism, and outputs status updates (RECORDING, RECORDED, FAIL) to the console, utilizing hermes-parser for inline snapshot recording and chalk for colored output.

packages/flow-dev-tools/src/record · high confidence

Introduce flow-enums-runtime package for Flow Enums support

This change introduces the \flow-enums-runtime\ package, which provides the runtime support required by the Flow Enums Babel transform. The package exposes an \Enum\ constructor and an \Enum.Mirrored\ variant, implementing methods such as \isValid\, \cast\, \getName\, and \members\ to handle enum validation and introspection at runtime. It relies on native \Map\ and \Array.prototype.values\ support, with a fallback to \Map\ if \WeakMap\ is unavailable, and is distributed under the MIT license.

packages/flow-enums-runtime · high confidence

Introduce flow-parser package with Babel plugin and WASM-based parser

The \packages/flow-parser\ directory now contains the standalone \flow-parser\ package, which exposes a JavaScript parser built from Flow's Rust parser compiled to WebAssembly. This package includes a Babel plugin (\babel-plugin.js\) that allows Babel to use \flow-parser\ instead of \@babel/parser\ for Flow syntax, supporting options like \babel\ AST format, \flow\ mode detection, and experimental features such as enums and match syntax. The package also provides a Makefile for building the \flow\_parser.js\ artifact and a README documenting the API and Babel plugin usage.

packages/flow-parser · high confidence

Introduce flow-remove-types package with CLI, Node API, and Jest integration

The \packages/flow-remove-types\ directory is introduced, providing a standalone tool to strip Flow type annotations from JavaScript. This package includes a command-line interface (\flow-remove-types\) supporting options for pretty-printing, source maps, and empty import removal, as well as a Node.js API (\index.js\) and a Jest transformer (\jest.js\) for seamless integration into testing workflows. It also provides a \register.js\ hook for on-the-fly transformation and a \flow-node\ REPL for executing Flow-typed code directly.

packages/flow-remove-types · high confidence

Introduce flow-upgrade tool with Hermes-based codemods

Adds the \flow-upgrade\ package, a utility for upgrading codebases to newer Flow versions. The tool now uses \hermes-parser\ and \hermes-transform\ instead of \flow-remove-types\ for parsing and transformation, configured via \.babelrc\ with \@babel/preset-env\ targeting Node 14. It includes a suite of codemods (accessible via \flow-codemod\) to handle syntax migrations such as casting (\(x: T)\ to \x as T\), utility types (\$Partial\ to \Partial\, \$Shape\ to \Partial\, legacy types to TypeScript-compatible equivalents), and React type updates (\React.AbstractComponent\ to \React.ComponentType\).

packages/flow-upgrade · high confidence

Introduce new test infrastructure for Flow

Adds a new testing framework in the \newtests/\ directory, including a \Tester.js\ module that provides \suite()\ and \test()\ helpers for defining test cases, a \.flowconfig\ to configure Flow checking for these tests, and a \README.md\ documenting the new test structure and usage.

newtests · high confidence

Introduce structured mutation API and Prettier comment handling for Flow transforms

The \flow-transform\ package now provides a structured mutation API for AST modifications, including operations to add, remove, clone, and replace comments, as well as insert, remove, and replace statements and nodes. This new system handles edge cases such as wrapping statements in block statements when necessary and preserving comments during replacements. Additionally, the package integrates a forked version of Prettier's comment attachment algorithm to ensure comments are correctly positioned and attached to AST nodes during transformation.

packages/flow-transform/src/transform/mutations · high confidence

Introduces Rust-based Flow event logging facade with OSS stubs

Adds a new \flow\_event\_logger\ crate that provides an OSS-facing facade for Flow's event logging system. This implementation mirrors the internal \flowEventLogger.ml\ API, featuring a \LoggingContext\ singleton that captures command-line arguments, working directory, start time, and server/monitor options. In non-Facebook builds, it falls back to in-file stubs where event-logging functions are no-ops while context-setter helpers remain functional, ensuring the build remains green during the gradual migration of callers across \flow\_cli\, \flow\_lsp\, and \flow\_server\.

_rust\_port/crates/flow\_event\logger · high confidence

Introduces codemod utility infrastructure for AST transformation and reporting

The \rust\_port/crates/flow\_codemods/src/utils\ module now provides the core utilities required to run codemods, including context management for typed and untyped analysis, AST mapping and reduction logic, and a reporting system. This change adds the \codemod\_runner\ to orchestrate file processing and the \codemod\_printer\ to handle dry-run output or actual file writes, establishing the foundational execution pipeline for code transformation tools.

_rust\_port/crates/flow\codemods/src/utils · high confidence

Introduces cross-platform socket abstraction for IPC

The \flow\_common\_socket\ crate now provides a unified interface for inter-process communication, abstracting away platform-specific details. On Unix systems, it utilizes Unix domain sockets, while on Windows, it switches to named pipes. This change ensures consistent socket behavior across different operating systems within the flow monitoring infrastructure.

_rust\_port/crates/flow\_common\socket · high confidence

Introduction of ALoc type for abstract location handling

The \flow\_aloc\ crate has been added to provide an abstract location type (\ALoc\) that wraps the existing \Loc\ type. This change introduces utilities to convert AST nodes from \Loc\-based to \ALoc\-based representations using unsafe transmutation, leveraging the fact that \ALoc\ is repr(transparent) over \Loc\. It also includes a \LocToALocMapper\ for AST transformations and an \ALocTable\ for managing location data, enabling more efficient or flexible location handling in the parser's abstract syntax tree.

_rust\_port/crates/flow\aloc · high confidence

Introduction of Rust port for Flow common utilities

This change introduces the initial Rust port of several core Flow utility modules. The \flow\_common\_cycle\_hash\ crate provides logic for computing stable hashes of cyclic directed graphs using Tarjan's algorithm to handle strongly connected components. The \flow\_common\_leb128\ crate adds support for reading and writing unsigned LEB128 encoded integers. Additionally, the \flow\_typing\_exists\_check\ crate defines the \ExistsCheck\ struct, which tracks the presence of various primitive types (such as null, bool, string, number, bigint, and mixed) via location references.

_rust\_port/crates/flow\_common\_cycle\_hash, rust\_port/crates/flow\_common\_leb128, rust\_port/crates/flow\_typing\_exists\check · high confidence

Introduction of Rust-based saved state fetching infrastructure

The \flow\_saved\_state\_fetcher\ crate has been introduced to handle the retrieval of Flow's incremental compilation state. This new module provides a unified \FETCHER\ trait and \FetchResult\ enum, along with specific implementations: a dummy fetcher for servers that do not use saved state, a local fetcher for testing that reads state from \.flow.saved\_state\ files, and an SCM-aware fetcher that identifies the most recent compatible saved state by querying Git or Mercurial for merge bases and file changes. This change establishes the core logic for locating and validating saved state files based on version control history.

_rust\_port/crates/flow\_saved\_state\fetcher · high confidence

Introduction of minimal prelude libdefs for no\_flowlibs mode

A new \prelude.js\ file has been added to provide minimal type definitions for core JavaScript globals and Flow intrinsics, enabling the use of \no\_flowlibs=true\ to skip loading the full standard library. This file declares essential types such as \undefined\, \Object\, \Function\, \Array\, \Promise\, and various iterator interfaces, while also introducing new intrinsics like \$Flow$ModuleRef\ and \$FlowFixMe\, and defining opaque types for \React$CreateElement\ and module exports to support stricter type checking in environments where the full prelude is not desired.

prelude · high confidence

Introduction of structured logging and Flow configuration

The extension now includes a new Logger component in the common module that writes structured messages (Error, Warn, Info, Debug, Trace) to the VS Code output channel, enabling better visibility into extension behavior. Additionally, a Flow configuration file has been added to the playground directory to support type checking.

packages/flow-for-vscode/playground, packages/flow-for-vscode/src/common · high confidence

Introduction of synchronous transaction management with scoped borrowing

The \flow\_common\_transaction\ crate now provides a synchronous transaction system that allows mutators to borrow values from the surrounding scope without requiring ownership. Users can register commit and rollback actions via \add\, and execute them using \with\_transaction\_sync\ or \with\_transaction\_result\_sync\. The system ensures that rollback is automatically triggered if a transaction is dropped without being committed, and logs commit and rollback events using \flow\_hh\_logger\.

_rust\_port/crates/flow\_common\transaction · high confidence

LSP global find-references and rename now support JSX props, identifiers, and private names

The LSP now correctly handles global find-references and rename operations for JSX component props, standard identifiers, and private class names. This change ensures that renaming a prop or identifier updates all usages across the project, including cases involving unsaved document changes, and extends support to private names which were previously not fully covered by global refactoring tools.

newtests/lsp/globalReferencesAndRename · high confidence

LSP quickfixes for record syntax errors and expression conversions

The LSP now provides quickfix actions for several record-related issues. It can automatically fix invalid record declaration syntax, including removing invalid \=\ signs, semicolons, variance annotations, and correcting optional property declarations. Additionally, it offers quickfixes to convert invalid expressions into proper record syntax, such as transforming \new Record(...)\ calls and object literals assigned to record-typed variables into the correct \Record { ... }\ expression format.

newtests/lsp/code-action/quickfix/records · high confidence

New AST traversal and event system in flow-transform

The \packages/flow-transform/src/traverse\ directory now includes a new internal AST traversal infrastructure. This change introduces a \SafeEmitter\ for decoupled event handling, an \esquery\ wrapper for AST node selection, a \NodeEventGenerator\ to map selectors to AST events, and a \traverse.js\ module that orchestrates the traversal with scope management and code-frame utilities. This provides the foundation for future transform logic within the flow-transform package.

packages/flow-transform/src/traverse · high confidence

New ESLint rules for Flow code style and modernization

The \eslint-plugin-fb-flow\ package now includes several new linting rules to enforce modern Flow patterns and improve code consistency. The \use-flow-enums\ rule detects legacy enum implementations using \keyMirror\ or \Object.freeze\ and suggests migrating to native Flow Enums. The \flow-enums-default-if-possible\ rule encourages omitting redundant string values in Flow Enum members. The \no-flow-enums-object-mapping\ rule advises against using object literals to map enum values, recommending switch statements instead. The \use-exact-by-default-object-type\ rule promotes the use of exact object types (using \{}\ instead of \{\|}\) where appropriate. Finally, the \use-indexed-access-type\ rule suggests replacing \$ElementType\ and \$PropertyType\ utility types with native indexed access syntax (\\[key\]\).

packages/eslint-plugin-fb-flow/rules · high confidence

New Rust data-structure wrappers for immutable collections and optimized maps

The \flow\_data\_structure\_wrapper\ crate now provides a suite of Rust wrappers around persistent and immutable data structures (from the \im\ and \rpds\ libraries) and optimized standard collections. These wrappers—such as \FlowHashSet\, \FlowOrdMap\, \FlowOrdSet\, \FlowVector\, \FlowOcamlList\, and \FlowRedBlackTreeMap\—implement the \Dupe\ trait to enable cheap, consistent cloning via \.dupe()\ instead of \.clone()\. Additionally, the crate introduces \IntHashMap\ and \IntHashSet\ for integer keys using an identity hasher to eliminate hash computation overhead, and \MultiLevelMap\ for layered key-value storage with push/pop scoping. An \OverlayMap\ is also provided for maintaining a shared immutable base with a lightweight delta of changes, and \FlowSmolStr\ wraps \ArcStr\ for efficient reference-counted string handling.

_rust\_port/crates/flow\_data\_structure\wrapper · high confidence

New Rust export index and search service

The \flow\_services\_export\ crate now provides a Rust implementation of the export index and search functionality. This includes an export index for tracking module exports, a fuzzy search service (\export\_search\) for finding exports by name, and an export service (\export\_service\) that resolves module dependencies and re-exports. The implementation is accompanied by comprehensive tests for the index operations, search logic, and module name inference.

_rust\_port/crates/flow\_services\export · high confidence

New Rust implementation for the type-of-name service

A new Rust crate (\flow\_services\_type\_of\_name\) has been introduced to handle the logic for determining the type of a specific identifier or name within the codebase. This module provides the core functionality for looking up member types in object properties and component props, extracting property documentation from JSDoc comments, and finding the first occurrence of an identifier by name in the typed AST. This change represents a port of the existing Flow type-of-name service logic into the new Rust-based architecture.

_rust\_port/crates/flow\_services\_type\_of\name · high confidence

New Rust lint settings infrastructure

The \flow\_lint\_settings\ crate has been introduced to manage lint configurations in the Rust port. It defines the \LintKind\ enum covering specific checks (such as \sketchy-null\, \deprecated-type\, and \internal-type\), the \Severity\ levels (\off\, \warn\, \error\), and the \LintSettings\ data structure for storing and retrieving these configurations. Additionally, it provides \LintSeverityCover\ to handle file-range-based overrides and \StrictModeSettings\ for strict-mode lint enforcement, enabling the system to parse and apply lint rules from source code comments and configuration files.

_rust\_port/crates/flow\_lint\settings · high confidence

New Rust-based saved state system for Flow

The \flow\_saved\_state\ crate introduces a new Rust implementation for persisting and loading Flow's internal state. This change adds support for serializing environment metadata (such as file sets, dependency graphs, and local errors) and the committed heap to disk, enabling faster startup times by recovering the type-checking state from previous runs. It also includes logic to validate the saved state against the current binary build ID and \.flowconfig\ hash, ensuring compatibility and correctness upon restoration.

_rust\_port/crates/flow\_saved\state · high confidence

New Tarjan's algorithm crate for detecting dependency cycles

Added a new Rust crate, \flow\_common\_tarjan\, that implements Tarjan's algorithm to identify strongly connected components within source-indexed dependency graphs. This capability allows the system to detect cyclic dependencies (such as mutual imports or circular chains) among modules, which is essential for validating the integrity of the dependency graph structure.

_rust\_port/crates/flow\_common\tarjan · high confidence

New async and string utility functions for flow-dev-tools

The flow-dev-tools package now includes new utility modules in src/utils to support asynchronous operations and string manipulation. The async.js module provides promise-based wrappers for common Node.js operations including command execution (exec, execManual), file system actions (rimraf, mkdirp), glob pattern matching, process monitoring (isRunning), and a new withTimeout helper that races a promise against a timeout. The string.js module adds a splitIntoChunks function used internally by the exec utility to handle large stdin inputs safely by writing them in chunks to prevent crashes.

packages/flow-dev-tools/src/utils · high confidence

New build, testing, and utility scripts for the Rust-based Flow.js

This change introduces several new shell and JavaScript scripts to support the new Rust port of Flow.js. The \build-flow-dot-js-wasm.sh\ script handles building the Rust-based \flow.js\ binary using Emscripten, defaulting to a release profile for optimized builds. A new \serve-website.sh\ script automates building the Rust implementation and serving the documentation site. To support testing, \scripts/tests\_bin/git\ and \scripts/tests\_bin/node\ are added to allow configuring the Node and Git binaries used during test runs, while \scripts/lib/runtests-common.sh\ defines shared test exit codes. Additionally, \scripts/add-specific-error-code.js\ provides a codemod to automatically update Flow suppression comments with specific error codes.

scripts · high confidence

New concurrency primitives for cancellation, timeouts, and parallel data structures

The \flow\_utils\_concurrency\ crate introduces a suite of concurrency utilities for the Flow type checker. It adds a \CheckBudget\ mechanism that combines global cancellation checks with per-file timeouts, allowing the checker to respect \FLOW\_MAX\_WORKERS\ and stop work promptly. Worker cancellation is handled via a global flag and an interruptible sleep that wakes immediately on cancel. The crate also provides thread pool management that automatically sizes itself to physical cores and supports custom stack sizes, a panic-safe map-reduce framework for parallel processing, and concurrent data structures including a lock-free overlay map, a locked map, a skip-list-based locked set, and wrappers for standard synchronization primitives.

_rust\_port/crates/flow\_utils\concurrency · high confidence

OSS facade for EdenFS watcher with stub implementation

The \flow\_edenfs\_watcher\ crate now provides an OSS-facing facade for the EdenFS watcher. In non-Facebook builds, it exposes a stub implementation that returns \false\ for availability and panics on functional calls, while re-exporting the underlying types (such as \Changes\, \Settings\, and telemetry structs) to maintain API compatibility. This allows Flow to compile and link against the watcher interface on OSS platforms where the actual native watcher is not available.

_rust\_port/crates/flow\_edenfs\watcher · high confidence

Open-source Flow AI evals with JSX type definitions

This change adds the Flow AI evaluation suite to the public repository, specifically introducing \evals/flow-typed/environment/jsx.js\. This new file provides comprehensive Flow type definitions for React JSX intrinsics and synthetic DOM events (such as mouse, keyboard, and touch events), enabling accurate type-checking for React applications within the Flow type system.

evals/flow-typed · high confidence

Open-source Flow AI evaluation graders

The \evals/graders\ directory now includes a suite of open-source shell scripts used to grade Flow AI agent trajectories. These graders validate evaluation outcomes by checking for specific AST node types (\ast\_query\, \contains\_ast\_node\_type\), verifying file modifications (\file\_modified\, \file\_not\_modified\), ensuring code quality constraints like no \any\ types or CommonJS usage (\no\_any\, \no\_commonjs\), and confirming the absence of TypeScript compiler invocations (\no\_tsc\) or Flow error suppressions (\no\_flowfixme\). The suite also includes a \flow\_check\ grader to run type-checking on output directories and a \no\_extra\_flow\_errors\ grader that analyzes agent trajectories to penalize unintended Flow errors during execution.

evals/graders · high confidence

Open-source Flow AI evaluation harness

The evals directory now contains a complete, open-source suite for evaluating LLM coding performance on the Flow type system. This includes a Makefile-based harness, Python scripts to compile evals into SWE-bench JSONL format and run them (with a default model of claude-sonnet-5-5), and a comprehensive README. The harness supports dry-run validation against gold patches, parallel execution, and filtering by category or tags. It also introduces an opt-in \--docs\ flag to stage Flow documentation for agent analysis. The suite covers six categories: error fixing, unique features, project patterns, TypeScript-to-Flow conversion, code generation, and config tooling, with automated grading via shell scripts that check for type-checking success, AST properties, and absence of forbidden patterns.

evals · high confidence

Open-sourced Flow AI evals for error-fixing scenarios

The evals/evals directory now includes a suite of open-source evaluation cases focused on Flow type error fixing. These new test scenarios cover a range of common type-checking issues, including refinement invalidation, exact object types, unknown type narrowing, array and property variance, generic bounds, React component props, unsafe type casts, and missing annotations. Each case provides input code with Flow errors, the expected fixed output, and grading criteria to help evaluate how well an AI model can correct type errors in JavaScript.

evals/evals · high confidence

Port Flow LSP server to Rust

The Flow LSP server implementation has been ported from the previous language to Rust. This change introduces the core server logic in \rust\_port/crates/flow\_lsp\_server\, including the main loop (\flow\_lsp.rs\), JSON-RPC message handling (\jsonrpc.rs\), and providers for IDE features such as document symbols (\document\_symbol\_provider.rs\) and selection ranges (\selection\_range\_provider.rs\). It also includes modules for managing LSP errors (\lsp\_errors.rs\), interaction triggers (\lsp\_interaction.rs\), and diagnostic output (\lsp\_writers.rs\), establishing the new Rust-based foundation for the language server.

_rust\_port/crates/flow\_lsp\server · high confidence

Port Flow server monitor to Rust

The Flow server monitor has been ported from OCaml to Rust, introducing a new \flow\_server\_monitor\ crate that handles server lifecycle, file watching, and client connections. This port includes a new exit-signal mechanism for coordinated shutdown, a file-watcher abstraction supporting Watchman, DFind, and EdenFS, and a connection layer using bincode-framed serialization for IPC. The monitor now integrates with the \flow\_daemon\ for process management and provides a Rust-native implementation of the logging and status-streaming infrastructure previously handled by the OCaml runtime.

_rust\_port/crates/flow\_server\monitor · high confidence

Port Flow typing error reporting to Rust

This change introduces the Rust implementation of the Flow type-checking error system in the \flow\_typing\_errors\ crate. It adds the core data structures for representing type errors (\FlowError\, \ErrorMessage\), the logic for generating intermediate error representations (\IntermediateError\), and the infrastructure for handling error suppression comments (\$FlowFixMe\, \$FlowExpectedError\). This port replaces the previous implementation, enabling the type checker to report errors using the new Rust-based architecture.

_rust\_port/crates/flow\_typing\errors · high confidence

Port Flow's JavaScript type-checking engine to Rust

The JavaScript type-checking engine has been ported from OCaml to Rust, introducing a new \flow\_typing\_flow\_js\ crate. This change replaces the previous implementation with a Rust-based subtyping algorithm and constraint system, including new modules for dispatch, evaluation, and property lookup helpers, while preserving the existing type-checking behavior and error reporting for users.

_rust\_port/crates/flow\_typing\_flow\js · high confidence

Port TypeScript library definitions to Rust for Flow type checking

The \flow\_flowlib\ crate now embeds and serves TypeScript's standard library definitions (tslib) and Flow's core library definitions directly from Rust code. This change introduces a \BuiltinLib\ enum to select between different library sets (Flowlib, FlowlibWithLibDomDts, Prelude, Tslib) and provides functions to extract these embedded \.js\ and \.d.ts\ files into temporary directories at runtime. Users benefit from a self-contained Rust port that no longer relies on external \flowlib\ or \tslib\ directories for core type definitions, ensuring consistent type-checking behavior across environments.

_rust\_port/crates/flow\flowlib · high confidence

Port flow\_daemon to Rust with cross-process communication and testing

The flow\_daemon module has been ported to Rust, introducing a new cross-process communication layer that uses TCP sockets and bincode serialization for bidirectional data exchange between parent and child processes. This change includes a new daemon implementation that supports registering entry points, spawning child processes, and managing their lifecycle (including safe killing without affecting the parent). Additionally, a comprehensive test suite has been added to verify process spawning, parameter serialization round-trips, and correct signal handling across processes.

_rust\_port/crates/flow\daemon · high confidence

Port of the 'Go to Definition' service to Rust

The \flow\_services\_get\_def\ crate has been ported from the legacy codebase to Rust, introducing the core logic for the 'Go to Definition' feature. This change adds new modules (\get\_def\_js\, \get\_def\_process\_location\, \get\_def\_utils\, etc.) that handle requests for identifiers, member properties, and JSX attributes, enabling the IDE to locate the source definition of code elements. Also in this area: 1 commit (0 fixes) modifying rust\_port/crates/flow\_services\_get\_def; Cleanup of OCaml translation artifacts in Rust source comments.

_rust\_port/crates/flow\_services\_get\def · medium confidence · unverified

Ported Flow heap and transaction system to Rust

The \flow\_heap\ crate now provides the core in-memory data structures and transactional overlay system for Flow's type checking, implemented in Rust. This includes the \CommittedHeap\ for managing base type information, \ActiveTransaction\ for handling incremental rechecks with lock-free overlays, and data models for \FileEntry\, \HasteModule\, and \TypedParse\. The implementation supports concurrent reads via \ArcSwap\ and atomic transaction guards, replacing the previous OCaml-based heap logic with a Rust-native equivalent that maintains the same logical structure for file parsing, dependency resolution, and type signature storage.

_rust\_port/crates/flow\heap · high confidence

Ported Flow typing location environment to Rust

The \flow\_typing\_loc\_env\ crate has been ported from OCaml to Rust, introducing core data structures for the type checker's local environment. This includes \LocEnv\ for mapping AST locations to types with lazy resolution support, \NodeCache\ for caching typed AST nodes (functions, classes, components, match patterns), and dedicated type definitions for component signatures, function/class signatures, and match pattern IR (including support for global \NaN\ patterns).

_rust\_port/crates/flow\_typing\_loc\env · high confidence

Ported core utility modules to Rust

The \flow\_common\_utils\ crate now provides Rust implementations for several foundational utilities previously available in the Flow codebase. This includes a generic, size-limited cache with async and sync access patterns (\cache.rs\), a \CheckedSet\ for managing disjoint sets of focused, dependent, and dependency files with optimized set-diff operations (\checked\_set.rs\), and a directional graph structure that maintains forward and backward edges for efficient traversal (\graph.rs\). Additionally, the port adds helpers for line-based string manipulation compliant with ECMAScript line terminators (\line.rs\), list and option utilities that preserve identity when no changes occur (\list\_utils.rs\, \option\_utils.rs\), a performance measurement system with global record stacking and distribution tracking (\measure.rs\), random ID generation (\random\_id.rs\), typo suggestions using Levenshtein distance (\utils\_js.rs\), and JSX text normalization (\utils\_jsx.rs\).

_rust\_port/crates/flow\_common\utils · high confidence

Porting Flow CLI commands and utilities to Rust

The Rust port of the Flow CLI now includes implementations for a wide range of commands previously available in the JavaScript-based tooling. This update adds the \apply-code-action\ command (supporting quickfixes and import suggestions), the \ast\ command for printing and checking ASTs, the \autocomplete\ command for querying completion information, the \autofix\ command for inserting type annotations, the \batch-coverage\ command for aggregate coverage statistics, the \check-contents\ command for type-checking stdin input, the \codemod\ command for running automated code transformations, and the \config\ command for finding and validating \.flowconfig\ files. These changes bring the core developer-facing CLI capabilities into the new Rust architecture.

_rust\_port/crates/flow\cli · high confidence

Rust port of the Flow server environment and LSP integration

The Flow server environment, including error collation, dependency tracking, and LSP protocol handling, has been ported from OCaml to Rust. This change introduces the \flow\_server\_env\ crate, which manages the server's state (such as collated errors and dependency graphs), handles persistent LSP client connections, and converts internal Flow types to LSP structures for IDE integration. Users benefit from the continued availability of the Flow language server with this new Rust-based implementation.

_rust\_port/crates/flow\_server\env · high confidence

Website migration to Docusaurus 2

The Flow documentation site has been rebuilt using Docusaurus 2, replacing the previous Jekyll-based infrastructure. This change introduces a modern static site generator setup, including a new \docusaurus.config.js\, \babel.config.js\ with \@docusaurus/core\ and \babel-plugin-syntax-hermes-parser\, and dedicated \.flowconfig\ files for the main site and code snippets to enforce strict type checking and component syntax. Users will experience a refreshed site architecture with improved local development workflows via \serve-website.sh\ and \yarn start\, while the underlying content (blog posts, docs) remains largely preserved but now processed through the new Docusaurus pipeline.

website · high confidence

Architecture

Extracted check cache into a dedicated crate

The check cache logic has been extracted into a new \flow\_check\_cache\ crate, providing a reusable, LRU-based cache for type-checking contexts and files. This change introduces a cleaner ownership model where the \server\_orchestrator\ owns the committed heap and the check cache, improving memory management and reducing reference-count cycles during incremental rechecks.

_rust\_port/crates/flow\_services\inference · high confidence

Port Flow parser to Rust

The Flow parser implementation has been ported from OCaml to Rust. This change introduces a new Rust-based parser crate (\flow\_parser\) that handles the full parsing pipeline, including the lexer, AST definition, and visitor infrastructure. For users, this represents a significant architectural shift in the underlying parsing engine, aiming to improve performance and maintainability while preserving existing parsing behavior and compatibility with TypeScript declaration files. Also in this area: 1 commit (0 fixes) modifying rust\_port/crates/flow\_parser; Support import attributes on re-export declarations; Improved Flow signature parsing and reduced memory contention; Parser updates for TypeScript compatibility and robustness; Cleanup of OCaml translation artifacts in Rust source comments; and 2 more.

_rust\_port/crates/flow\parser/src · low confidence · unverified

Behavioural changes

1 commit (0 fixes) modifying rust\_port/crates/flow\_docs

A change to existing behaviour in rust\_port/crates/flow\_docs — 1 commit, 1 file: “\[flow\] Bundle \website/docs\ into a \flow\_docs\ crate”.

_rust\_port/crates/flow\docs · medium confidence · unverified

10 commits (0 fixes) modifying packages/scripts/transform

A change to existing behaviour in packages/scripts/transform — 10 commits, 5 files: “\[flow\]\[parser\] Rename \ImportType.argument\ to \source\”; “\[flow\]\[js-tools\] Unbreak build”; “\[flow\]\[parser\] Unify ESTree enum bodies”; and 7 more.

packages/scripts/transform · medium confidence · unverified

133 commits (12 fixes) modifying rust\_port/crates/flow\_typing\_context

A change to existing behaviour in rust\_port/crates/flow\_typing\_context — 133 commits (12 fixs), 2 files: “\[flow\] Only accept true for \experimental.instance\_t\_objkit\_fix\”; “\[flow\] Enable TypeScript enums independently of the Flow enum option”; “\[flow\]\[tslib\] Allow \export { Type }\ in .ts files without type-as-value error”; and 130 more (refs \#5452).

_rust\_port/crates/flow\_typing\context · medium confidence · unverified

14 commits (1 fix) modifying packages/flow-transform/src/generated

A change to existing behaviour in packages/flow-transform/src/generated — 14 commits (1 fix), 5 files: “\[flow\]\[parser\] Rename \ImportType.argument\ to \source\”; “\[flow\] Replace deprecated Flow utility types with modern ones”; “\[flow\]\[parser\] Unify ESTree enum bodies”; and 11 more.

packages/flow-transform/src/generated · medium confidence · unverified

14 commits (3 fixes) modifying packages/flow-parser/oxidized-src/estree

A change to existing behaviour in packages/flow-parser/oxidized-src/estree — 14 commits (3 fixs), 6 files: “\[flow\]\[EZ\] Fix flow errors in the JS packages”; “\[flow\]\[parser\] Unify ESTree enum bodies”; “\[flow\] Correct default-interface export kinds and AST types”; and 11 more.

packages/flow-parser/oxidized-src/estree · medium confidence · unverified

15 commits (1 fix) modifying packages/flow-eslint/src

A change to existing behaviour in packages/flow-eslint/src — 15 commits (1 fix), 62 files: “prettier reformatting 01/14”; “\[flow\]\[js-tools\] Align flow-eslint with latest hermes-eslint”; “\[flow\] Correct nullable array-expression elements”; and 12 more (refs \#9445).

packages/flow-eslint/src · medium confidence · unverified

18 commits (0 fixes) modifying packages/flow-api-translator/src

A change to existing behaviour in packages/flow-api-translator/src — 18 commits, 6 files: “\[flow\]\[parser\] Rename \ImportType.argument\ to \source\”; “\[flow\] Expose \translateFlowTypeToTSType\ for reusable type AST translation”; “\[flow\] Use \React.ComponentProps\ in package fixtures”; and 15 more (refs \#9491).

packages/flow-api-translator/src · medium confidence · unverified

2 commits (0 fixes) modifying packages/flow-bin

A change to existing behaviour in packages/flow-bin — 2 commits, 11 files: “\[flow\] Include github.com/flow/flow-bin here so we don't have to push commits to publish”; “\[flow\] Point release automation at the \meta\ GitHub org”.

packages/flow-bin · medium confidence · unverified

210 commits (17 fixes) modifying rust\_port/crates/flow\_typing\_flow\_common

A change to existing behaviour in rust\_port/crates/flow\_typing\_flow\_common — 210 commits (17 fixs), 10 files: “\[flow\] Print guard types in type guard and assertion function errors”; “\[flow\]\[tslib\] Allow \export { Type }\ in .ts files without type-as-value error”; “\[flow\] No longer accept \ExactReactElement\_DEPRECATED\ as arguments for render types”; and 207 more (refs \#5452).

_rust\_port/crates/flow\_typing\_flow\common · medium confidence · unverified

213 commits (15 fixes) modifying rust\_port/crates/flow\_typing\_type

A change to existing behaviour in rust\_port/crates/flow\_typing\_type — 213 commits (15 fixs), 7 files: “\[flow\]\[refactor\] Collect \GetProtoT\ outputs with a \TypeCollector\”; “\[flow\] Describe cast expressions in errors without a reason”; “\[flow\] Print guard types in type guard and assertion function errors”; and 210 more (refs \#5452).

_rust\_port/crates/flow\_typing\type · medium confidence · unverified

215 commits (18 fixes) modifying rust\_port/crates/flow\_typing

A change to existing behaviour in rust\_port/crates/flow\_typing — 215 commits (18 fixs), 18 files: “\[flow\]\[tslib\] Allow \export { Type }\ in .ts files without type-as-value error”; “\[flow\] Implement unique symbol support”; “\[flow\] Classify ESM default imports from CJS assertion modules”; and 212 more (refs \#5452).

_rust\_port/crates/flow\typing · medium confidence · unverified

25 commits (2 fixes) modifying packages/flow-parser/oxidized-src

A change to existing behaviour in packages/flow-parser/oxidized-src — 25 commits (2 fixs), 15 files: “\[flow\] Preserve accessibility on bodyless class methods”; “\[flow\]\[parser\] Support top-level await in flow-parser modules”; “\[flow\]\[parser\] Rename \ImportType.argument\ to \source\”; and 22 more (refs \#9492).

packages/flow-parser/oxidized-src · medium confidence · unverified

26 commits (2 fixes) modifying packages/flow-estree/src

A change to existing behaviour in packages/flow-estree/src — 26 commits (2 fixs), 6 files: “\[flow\] Preserve accessibility on bodyless class methods”; “\[flow\]\[parser\] Rename \ImportType.argument\ to \source\”; “\[flow\] Replace deprecated Flow utility types with modern ones”; and 23 more.

packages/flow-estree/src · medium confidence · unverified

26 commits (3 fixes) modifying rust\_port/crates/flow\_codemods/src

A change to existing behaviour in rust\_port/crates/flow\_codemods/src — 26 commits (3 fixs), 6 files: “\[flow\] Remove redundant literal reason variants”; “\[flow\] Support symbol-typed property keys in objects”; “\[flow\]\[refactor\] Print the object type in \EPropNotFoundInLookup\”; and 23 more.

_rust\_port/crates/flow\codemods/src · medium confidence · unverified

266 commits (16 fixes) modifying rust\_port/crates/flow\_common

A change to existing behaviour in rust\_port/crates/flow\_common — 266 commits (16 fixs), 43 files: “\[flow\] Only accept true for \experimental.instance\_t\_objkit\_fix\”; “\[flow\] Describe cast expressions in errors without a reason”; “\[flow\] v0.339.0”; and 263 more (refs \#9434).

_rust\_port/crates/flow\common · medium confidence · unverified

309 commits (28 fixes) modifying rust\_port/crates/flow\_typing\_utils

A change to existing behaviour in rust\_port/crates/flow\_typing\_utils — 309 commits (28 fixs), 19 files: “\[flow\] Print guard types in type guard and assertion function errors”; “\[flow\]\[tslib\] Allow \export { Type }\ in .ts files without type-as-value error”; “\[flow\] Use TypeScript's ES2019 array library with Flow union ordering”; and 306 more (refs \#5452).

_rust\_port/crates/flow\_typing\utils · medium confidence · unverified

374 commits (20 fixes) modifying rust\_port/crates/flow\_typing\_statement

A change to existing behaviour in rust\_port/crates/flow\_typing\_statement — 374 commits (20 fixs), 20 files: “\[flow\]\[refactor\] Collect \GetProtoT\ outputs with a \TypeCollector\”; “\[flow\] Build the type map of the React rules effect visitors once per file”; “\[flow\] Clean up stale comments in Conditional handler”; and 371 more (refs \#5452, \#9492).

_rust\_port/crates/flow\_typing\statement · medium confidence · unverified

381 commits (12 fixes) modifying lib

A change to existing behaviour in lib — 381 commits (12 fixs), 6 files: “\[flow\] Align \RegExpMatchArray\ in \lib.es5.js\ with TypeScript”; “Use full names for type parameters”; “\[flow\] Use \extends\ for type parameter bounds in libs core.js and react.js”; and 370 more.

lib · medium confidence · unverified

39 commits (8 fixes) modifying rust\_port/crates/flow\_analysis

A change to existing behaviour in rust\_port/crates/flow\_analysis — 39 commits (8 fixs), 14 files: “\[flow\]\[property-init\] Check fields named by any number literal in brackets”; “\[flow\]\[tslib\] Allow importing type as a value in .ts files”; “\[flow\] Track loc of \type\ and \typeof\ keyword in ast for import statement”; and 36 more.

_rust\_port/crates/flow\analysis · medium confidence · unverified

4 commits (0 fixes) modifying packages/flow-parser/oxidized-src/transform

A change to existing behaviour in packages/flow-parser/oxidized-src/transform — 4 commits, 3 files: “\[flow\] Replace deprecated Flow utility types with modern ones”; “\[flow\] Correct nullable array-expression elements”; “\[flow\]\[oxidation\] Move flow-parser-oxidized as \oxidized\ directory in flow-parser”; and 1 more.

packages/flow-parser/oxidized-src/transform · medium confidence · unverified

4 commits (0 fixes) modifying rust\_port/crates/flow\_parser\_utils\_output/src/indented\_printer

A change to existing behaviour in rust\_port/crates/flow\_parser\_utils\_output/src/indented\_printer — 4 commits, 4 files: “\[flow\] Support import attributes on re-export declarations”; “\[flow\] Strip definite assignment assertions from erased JavaScript”; “\[flow\] Implement a new simpler JavaScript AST printer with conservative parentheses everywhere”; and 1 more.

_rust\_port/crates/flow\_parser\_utils\_output/src/indented\printer · medium confidence · unverified

5 commits (0 fixes) modifying tslib

A change to existing behaviour in tslib — 5 commits, 99 files: “\[flow\] crlf -\> lf for \lib.esnext.iterator.d.ts\”; “\[flow\] Add the React DOM declarations from \@types/react\”; “\[flow\] Remove multiple indexers in vendored lib.dom.d.ts”; and 2 more.

tslib · medium confidence · unverified

58 commits (6 fixes) modifying rust\_port/crates/flow\_parser\_wasm

A change to existing behaviour in rust\_port/crates/flow\_parser\_wasm — 58 commits (6 fixs), 29 files: “\[flow\] Preserve accessibility on bodyless class methods”; “\[flow\]\[parser\] Support top-level await in flow-parser modules”; “\[flow\]\[oxidation\] Almost complete fork of hermes-parser related packages”; and 55 more (refs \#9492, \#9445).

_rust\_port/crates/flow\_parser\wasm · medium confidence · unverified

6 commits (0 fixes) modifying packages/flow-parser/oxidized-src/utils

A change to existing behaviour in packages/flow-parser/oxidized-src/utils — 6 commits, 5 files: “\[flow\]\[oxidation\] Move flow-parser-oxidized as \oxidized\ directory in flow-parser”; “\[flow\]\[js-tools\] Modernize legacy Flow variance syntax across the JS packages”; “\[prettier\]\[flow\] Preserve custom Flow ASTs with Prettier 3.10”; and 3 more.

packages/flow-parser/oxidized-src/utils · medium confidence · unverified

6 commits (0 fixes) modifying packages/flow-transform/src/generated/special-case-node-types

A change to existing behaviour in packages/flow-transform/src/generated/special-case-node-types — 6 commits, 8 files: “\[flow\]\[js-tools\] Align flow-transform with latest hermes-transform 2/n: update and run codegen”; “\[flow\]\[js-tools\] Modernize legacy Flow variance syntax across the JS packages”; “\[flow\]\[oxidation\] Rename those rust port based packages”; and 3 more.

packages/flow-transform/src/generated/special-case-node-types · medium confidence · unverified

6 commits (1 fix) modifying packages/flow-api-translator/src/utils

A change to existing behaviour in packages/flow-api-translator/src/utils — 6 commits (1 fix), 6 files: “\[flow\] Expose \translateFlowTypeToTSType\ for reusable type AST translation”; “\[flow\] Add opt-in semantic default export names”; “\[flow\] Add opt-in default export doc comment placement”; and 3 more (refs \#9486).

packages/flow-api-translator/src/utils · medium confidence · unverified

62 commits (3 fixes) modifying rust\_port/crates/flow\_command\_utils

A change to existing behaviour in rust\_port/crates/flow\_command\_utils — 62 commits (3 fixs), 1 file: “\[flow\] Add a \package-boundary\ error for imports that cross a package boundary”; “\[flow\]\[libdef\] Default to libdef with lib.dom.d.ts”; “\[flow\] Resolve JSX intrinsics through \React.JSX.IntrinsicElements\, behind a flag”; and 59 more.

_rust\_port/crates/flow\_command\utils · medium confidence · unverified

7 commits (0 fixes) modifying packages/flow-parser/\_\_test\_utils\_\_

A change to existing behaviour in packages/flow-parser/\_\_test\utils\\_ — 7 commits, 3 files: “\[flow\] Replace deprecated Flow utility types with modern ones”; “\[flow\]\[EZ\] Remove unused files in flow-parser package”; “\[flow\]\[parser\] Unify ESTree enum bodies”; and 4 more.

packages/flow-parser/\\_test\utils\\_ · medium confidence · unverified_

76 commits (7 fixes) modifying rust\_port/crates/flow\_typing\_ty\_normalizer

A change to existing behaviour in rust\_port/crates/flow\_typing\_ty\_normalizer — 76 commits (7 fixs), 4 files: “\[flow\] Implement unique symbol support”; “\[flow\] Remove redundant literal reason variants”; “\[flow\] Give a mapped type the strictness of the file that declares it”; and 73 more.

_rust\_port/crates/flow\_typing\_ty\normalizer · medium confidence · unverified

80 commits (7 fixes) modifying rust\_port/crates/flow\_env\_builder/src

A change to existing behaviour in rust\_port/crates/flow\_env\_builder/src — 80 commits (7 fixs), 15 files: “\[flow\]\[tslib\] Fix namespace declaration merging support in local checking”; “\[flow\] Remove provider generator-next and return reason descriptions”; “\[flow\] Add declared types signature analysis”; and 77 more.

_rust\_port/crates/flow\_env\builder/src · medium confidence · unverified

9 commits (0 fixes) modifying packages/flow-transform/src/transform

A change to existing behaviour in packages/flow-transform/src/transform — 9 commits, 7 files: “\[flow\]\[js-tools\] Port over changes from D111854445 and remove \prettier-plugin-flow-parser\”; “\[flow\]\[parser\] Emit bare type-parameter bounds in ESTree”; “\[flow\]\[oxidation\] Move flow-parser-oxidized as \oxidized\ directory in flow-parser”; and 6 more (refs \#9445).

packages/flow-transform/src/transform · medium confidence · unverified

97 commits (13 fixes) modifying rust\_port/crates/flow\_env\_builder\_resolver

A change to existing behaviour in rust\_port/crates/flow\_env\_builder\_resolver — 97 commits (13 fixs), 7 files: “\[flow\]\[tslib\] Fix namespace declaration merging support in local checking”; “\[flow\] Fix \o.x++\ keeping narrowings of \x\ made through other names”; “\[flow\] Remove provider generator-next and return reason descriptions”; and 94 more.

_rust\_port/crates/flow\_env\_builder\resolver · medium confidence · unverified

Added OSS-compatible logging and signal handling stubs

New Rust crates have been introduced to provide OSS-facing facades for internal logging and signal utilities. The \flow\_event\_logger\_common\, \flow\_event\_logger\_lwt\, and \flow\_interaction\_logger\ crates now expose stub implementations for \EventLogger\, \Scuba\, and \FlowInteractionLogger\ APIs that act as no-ops in open-source builds, ensuring compatibility when the internal \flow\_facebook\_logging\ dependencies are unavailable. Additionally, the \flow\_print\_signal\ crate adds a utility to convert POSIX signal codes into human-readable strings, supporting both Unix and Windows environments.

(repo-wide) · high confidence

Added upgrade paths for Flow versions 0.84.0, 0.170.0, 0.176.0, and 0.201.0

The flow-upgrade tool now includes specific upgrade codemods for Flow versions 0.84.0, 0.170.0, 0.176.0, and 0.201.0. Users upgrading to these versions will automatically have duplicate class properties removed (0.170.0), annotations in destructuring cleaned up (0.176.0), implicit inexact object types converted (0.84.0), and $Partial types renamed to Partial (0.201.0).

packages/flow-upgrade/src/upgrades · high confidence

Adopts Hermes (Rust) parser for Flow tooling and establishes new package-level configuration

The packages workspace now uses the Hermes parser (compiled to WASM) instead of the legacy JavaScript parser for Flow syntax support. This is enabled via the new \babel-plugin-syntax-flow-parser\ package, which acts as a thin re-export shim to the core \flow-parser/babel-plugin\ and is integrated into the workspace's \babel.config.js\ to parse Flow files during builds. To support this shift, the workspace now includes a dedicated \.flowconfig\ that maps the \flow-parser\ module to its Rust-based \oxidized-src\ implementation, alongside new \eslint.config.js\, \jest.config.js\, and formatting configurations to standardize development across the packages.

packages · high confidence

Flow dev tools now use Hermes parser for syntax handling

The \tool\ script in \packages/flow-dev-tools/bin\ has been updated to replace the previous Flow type removal approach with the Hermes parser. When running the tool, JavaScript files within the source and test directories are now transformed using \@babel/preset-flow\ combined with the \babel-plugin-syntax-hermes-parser\ plugin, ensuring that Flow syntax is handled via Hermes' parser rather than the older method.

packages/flow-dev-tools/bin · high confidence

Flow dev-tools command infrastructure restructured with new base class and flag system

The flow-dev-tools package has been refactored to use a new JavaScript-based command infrastructure. A new Base class now handles argument parsing, validation, and usage display for all commands, replacing previous implementations. Common flags like 'bin', 'flowconfigName', 'parallelism', and 'errorCheckCommand' are now defined centrally. The command registry (allCommands.js) has been updated to use this new structure, and a new findFlowBin utility has been added to locate the Flow binary. This change affects how users interact with flow-dev-tools commands, particularly regarding flag handling and error reporting.

packages/flow-dev-tools/src/command · high confidence

Flow dev-tools source code migrated to new modular structure

The source files for the flow-dev-tools package have been reorganized into a new directory structure under \packages/flow-dev-tools/src\. This change introduces a modular architecture with dedicated files for constants, error handling, flow result parsing, help commands, and the main entry point. The migration includes replacing the \colors\ library with \chalk\ for terminal output and updating copyright headers from Facebook to Meta. The new structure supports better organization of command implementations and utility functions, while maintaining compatibility with existing Flow tooling workflows.

packages/flow-dev-tools/src · high confidence

Flow for VS Code extension rewritten in TypeScript with new LSP features

The Flow for VS Code extension has been rewritten in TypeScript and now includes support for type coverage reporting, status bar updates, and completion snippet configuration. The extension also includes a new FlowconfigCache utility and various utility functions for finding Flow configuration files, checking Flow version compatibility, and verifying Flow binary integrity.

packages/flow-for-vscode/src/utils · high confidence

Flow for VS Code extension rewritten in TypeScript with security and configuration fixes

The Flow for VS Code extension has been rewritten in TypeScript to improve maintainability and align with upstream VS Code API typings. This update includes two critical security fixes: it disables the extension in untrusted (Restricted Mode) workspaces to prevent a Workspace Trust bypass, and it fixes an OS command injection (RCE) vulnerability by ensuring the Flow language server is spawned with \shell: false\. Additionally, the extension no longer supports the \flow.lazyMode\ configuration, and it now includes proper build configuration files (tsconfig, babel, esbuild) and metadata to support the new codebase.

packages/flow-for-vscode · high confidence

Flow upgrade tool now processes files sequentially to prevent transformation errors

The flow-upgrade tool has been updated to process JavaScript files sequentially rather than concurrently. This change addresses a bug in hermes-transform where parallel processing could cause state persistence issues, leading to incorrect code transformations. The tool now clears the require cache for hermes-transform and Prettier between each file to ensure reliable upgrades.

packages/flow-upgrade/src · high confidence

Improved parse error reporting and server stability

Flow now provides more specific error messages for parse failures, explicitly stating what was expected (such as a semicolon) when an unexpected identifier is encountered. Additionally, the server is stabilized to prevent crashes when such parse errors are introduced in the codebase.

_newtests/recheck\_parse\error · medium confidence

Introduces serialized AST caching and compression for shared memory

The \flow\_heap\_serialization\ crate now includes a \ReaderCache\ that stores deserialized ASTs and allocation tables (up to 1000 entries each) to avoid redundant parsing during shared memory garbage collection. Additionally, all serialized data (ASTs, docblocks, type signatures, etc.) is now compressed using LZ4 before storage, reducing memory footprint in shared memory environments.

_rust\_port/crates/flow\_heap\serialization · high confidence

Introduces shared Tokio runtime with configurable worker threads and stack size

The Flow service now uses a centralized Tokio runtime for asynchronous operations, allowing users to control concurrency via the FLOW\_MAX\_WORKERS environment variable. To prevent stack overflows during deep type-checking operations, the runtime threads are configured with a larger stack size matching the type checker's requirements. Additionally, the blocking pool is prewarmed to ensure immediate availability for LSP workloads.

_rust\_port/crates/flow\_tokio\runtime · high confidence

Introduction of standardized Flow exit status codes and types

The Flow CLI now exposes a comprehensive \FlowExitStatus\ enum and an \error\_code\ mapping function that translates internal server states into specific POSIX-style exit codes. This change provides a stable, documented API for external tools to interpret Flow's termination reasons, distinguishing between success (0), type errors (2), timeouts (3), and various infrastructure failures (e.g., lock contention, shared memory issues, or Watchman errors) via unique integer codes. Users relying on exit codes to detect specific failure modes will now see consistent, granular return values instead of generic non-zero exits.

_rust\_port/crates/flow\_common\_exit\status · high confidence

LSP initialization fails on version mismatch

The LSP server now validates the Flow version specified in the \.flowconfig\ against the running server version during initialization. If the versions do not match, the server rejects the \initialize\ request with an error message indicating the version mismatch and subsequently shuts down, rather than proceeding with potentially incompatible behavior.

newtests/lsp/version · high confidence

New CI scripts for website builds and npm releases

Added new shell scripts in the .circleci directory to automate the build and deployment of the Flow website and npm packages. The build\_website.sh script now builds the website with controlled concurrency (2 workers) and copies the master flow.js and flowlib to the static site. New deploy scripts (deploy\_flow\_bin.sh, deploy\_npm.sh) handle publishing flow-bin and various Flow-related npm packages (flow-estree, flow-parser, flow-eslint, flow-transform, flow-api-translator, flow-remove-types, flow-node, flow-upgrade) to npm on tagged releases. Additional scripts manage GitHub release asset uploads (github\_upload.sh), list available Flow versions for the website (list\_versions.sh), and create cache breakers for Opam builds (make\_opam\_cachebreaker.sh). A new cacert.pem file provides updated CA root certificates for secure HTTPS connections during CI runs.

.circleci · high confidence

New Rust implementation for Flow IDE type-info services

The Flow IDE services for signature help and type-at-position queries have been ported to Rust. This change introduces the \flow\_services\_type\_info\ crate, which provides the backend logic for displaying function signatures, parameter documentation, and type information in the editor. Users will see these IDE features now powered by the new Rust implementation, replacing the previous JavaScript-based service. Also in this area: Simplified type-reason reporting and enabled dynamic TypeScript lib definitions by default; Improved JSX prop inference and signature help accuracy.

_rust\_port/crates/flow\_services\_type\info · high confidence

New Rust implementation for Flow server connection and management

The \flow\_commands\_connect\ crate now provides the Rust implementation for connecting to and managing the Flow server, replacing the previous logic. This includes \command\_connect.rs\ for handling server startup, retry logic, and progress display, \command\_connect\_simple.rs\ for low-level socket connections with TCP\_NODELAY enabled and connection pooling, and \command\_mean\_kill.rs\ for forcefully terminating server processes on both Unix and Windows platforms.

_rust\_port/crates/flow\_commands\connect · high confidence

New Rust-based flow profiling infrastructure

The \flow\_profiling\ crate has been introduced to replace the previous JavaScript-based profiling implementation with a native Rust port. This change adds new modules for managing memory sampling (including heap size, hash table statistics, and cgroup metrics) and detailed timing measurements (user/system time, worker wall times, and garbage collection durations). For users, this provides the same profiling capabilities as before but implemented in Rust, ensuring consistent data collection for performance analysis without relying on the legacy JS profiling stack.

_rust\_port/crates/flow\profiling · high confidence

New test scaffolding command for Flow dev tools

The \new-test\ command in \flow-dev-tools\ has been refactored to use \fs.promises\ for asynchronous file operations, improving reliability when creating new test directories and files. The command now generates a standardized test structure, including a \test.js\ file with a pre-configured test suite and a renamed \.flowconfig\ to \\_flowconfig\, streamlining the process of adding new Flow tests.

packages/flow-dev-tools/src/new-test · high confidence

Port Flow server command handling and inference types to Rust

The Flow server's command handling logic and core type inference data structures have been ported from OCaml to Rust. This change introduces the \flow\_server\_command\_handler\ crate, which now manages LSP requests and server commands, and the \flow\_services\_inference\_types\ crate, which defines the Rust equivalents for parse and typecheck artifacts. For users, this represents a foundational shift in the server's internal architecture, moving critical path logic into the Rust port while maintaining existing LSP protocol compatibility.

_rust\_port/crates/flow\_server\_command\handler · high confidence

Port flow parsing infrastructure to Rust

The flow parsing logic has been ported to Rust, introducing new modules for docblock parsing and the core parsing service. This change enables the server to recognize TypeScript global augmentation contributors (files with \declare global\) and tracks TypeScript global library definitions during parsing, allowing the system to recover when the set of global definitions changes.

_rust\_port/crates/flow\parsing · medium confidence

Port the Flow test runner to Rust

The \runtests\ runner in \rust\_port/crates/flow\_dev\_tools/src/runtests\ has been rewritten in Rust, replacing the previous implementation. This new runner manages test execution with parallelism, handles test configuration parsing, and performs output comparison and diffing using the \similar\ library. It also includes logic for environment setup, file discovery, and result reporting, ensuring the test suite runs consistently across platforms.

_rust\_port/crates/flow\_dev\tools/src/runtests · high confidence

Ported Flow Watchman integration to Rust

The file watcher implementation for Flow has been rewritten in Rust (replacing the previous Flow/JS implementation). This new \flow\_watchman\ crate handles communication with the Watchman daemon, including initialization, subscription management, and change reporting. It integrates with the new \flow\_hh\_logger\ for error reporting and supports Git and Mercurial (Hg) version control systems via the \flow\_common\_vcs\ module. Users will benefit from improved stability and performance in file watching, particularly regarding the detection of \.flowconfig\ changes and merge-base tracking.

_rust\_port/crates/flow\watchman · high confidence

Ported Flow dev-tools commands to Rust

The Flow dev-tools commands for running tests and updating error suppressions have been reimplemented in Rust. This change introduces the \runtests\ runner and suppression update logic into the \flow\_dev\_tools\ crate, replacing the previous JavaScript-based implementations. Users will now interact with these specific development utilities via the new Rust-based CLI commands, while the \remove-comments\ command has been removed as it is no longer needed. Also in this area: Resolve Clippy lint warnings across Flow analysis and parser crates; Website Flow checks are now integrated into the dev-tools test runner.

_rust\_port/crates/flow\_dev\tools/src · high confidence

Ported Flow module resolution service to Rust

This change introduces the Rust implementation of the Flow module resolution service (\flow\_services\_module\), replacing the previous logic. The new code handles module name candidate generation, resolves duplicate providers by distinguishing between declaration and implementation files, and tracks package incompatibility reasons such as changes to \types\, \main\, or \exports\ fields in \package.json\.

_rust\_port/crates/flow\_services\module · high confidence

Ported Flow monitor RPC protocol and status types to Rust

The \flow\_monitor\_rpc\ crate now provides the Rust implementation of the communication protocol between the Flow server and the monitor process. This includes the \FlowClock\ and \Since\ types for tracking server state and handling incremental queries, status enums for file watchers and server lifecycle events, and the JSON-based message definitions for monitor-server and server-client interactions. The transport layer uses length-prefixed JSON over TCP streams to handle cross-platform daemon communication, replacing the previous implementation.

_rust\_port/crates/flow\_monitor\rpc · high confidence

Ported Flow server rechecker to Rust

The Flow server's rechecking logic has been ported from OCaml to Rust, introducing the \flow\_server\_rechecker\ crate. This change implements the core mechanism for detecting file changes (including \.flowconfig\ and \package.json\ updates), managing the recheck queue, and coordinating with the server orchestrator to perform type checks and find-references operations. Users will experience the same recheck behavior but with the underlying implementation now residing in the Rust codebase, enabling better concurrency handling and integration with the Tokio runtime.

_rust\_port/crates/flow\_server\rechecker · high confidence

Ported JavaScript autocomplete and IDE services to Rust

The JavaScript autocomplete and IDE services have been ported from the original implementation to Rust. This change introduces a new \flow\_lazy\ crate providing a thread-safe, lazily-evaluated value type used by the autocomplete system. The core autocomplete logic in \flow\_services\_autocomplete\ now handles cursor positioning via a special \AUTO332\ sigil, processes JavaScript-specific completion types (such as JSX elements, member access, and import specifiers), and generates LSP-compatible completion items. Additionally, the port includes support for automatic import fixing, JSDoc stub insertion, and documentation lookup, ensuring that IDE features like code actions and symbol resolution function correctly in the new Rust-based architecture.

_rust\_port/crates/flow\_services\autocomplete · high confidence

Ported JavaScript reference-finding and rename services to Rust

The \flow\_services\_references\ crate now provides the Rust implementation for locating symbol references and performing renames in JavaScript/Flow code. This port introduces modules for searching local and imported references (\find\_refs\_js\, \local\_import\_ref\_searcher\), handling property and variable definitions (\property\_find\_refs\, \variable\_find\_refs\), and generating the necessary text edits for renaming (\rename\_mapper\, \rename\_module\). For users, this ensures that IDE features like 'Find All References' and 'Rename Symbol' continue to function correctly as the underlying logic is migrated from the original OCaml implementation.

_rust\_port/crates/flow\_services\references · high confidence

Ported LSP helper modules to Rust

The Flow LSP crate now includes a faithful Rust port of the LSP helper modules, introducing new source files for file URL parsing, LSP type mappings, formatting, and helper utilities. This change provides the foundational infrastructure for the LSP service in the Rust port, handling URI conversions, position/range mappings, and JSON serialization for LSP messages.

_rust\_port/crates/flow\lsp · high confidence

Ported code action autofix and AST extraction utilities to Rust

The \flow\_services\_code\_action\ crate now includes Rust implementations of the code action autofix logic previously written in OCaml. This port introduces utilities for AST extraction and a suite of autofixers that automatically correct common syntax and typing issues, including converting legacy colon-based type casts to \as\ expressions, fixing missing local type annotations, organizing and adding imports, capitalizing enum member names, prefixing class member access with \this\, replacing object types with interfaces, converting legacy \$Keys\ syntax to \keyof\, and fixing \match\ statement patterns. These changes enable the IDE and code action services to apply these fixes directly within the Rust-based language server.

_rust\_port/crates/flow\_services\_code\action · high confidence

Ported flow-dev-tools suppression commands to Rust CLI

The \flow-dev-tools\ command now includes Rust implementations for suppression-related functionality, replacing the previous JavaScript-based logic. This change introduces new modules within the \flow\_dev\_tools\ crate to parse source code ASTs, locate specific error positions, and intelligently insert or update \// @flow\ suppression comments in source files. Users will see these suppression capabilities handled by the Rust backend, ensuring consistent behavior for managing Flow lint errors directly through the CLI.

_rust\_port/crates/flow\_dev\_tools/src/comment, rust\_port/crates/flow\_dev\tools/src/utils · high confidence

Ported update-suppressions logic from JavaScript to Rust

The \update-suppressions\ command logic has been moved from the JavaScript-based \flow-dev-tools\ into the Rust \dev-tools\ CLI. This change implements the core functionality for analyzing and updating ESLint/Flow suppression comments in source files directly within the Rust codebase, replacing the previous JavaScript implementation.

_rust\_port/crates/flow\_dev\_tools/src/update\suppressions · high confidence

Redesigned Flow language client with detailed error rendering and refined-value highlighting

The VS Code extension's Flow language client has been rewritten in TypeScript and restructured into a modular architecture (FlowClients, ClientCommands, StatusBarWidget) to improve stability and feature support. Users now benefit from detailed error rendering, where clicking a diagnostic code opens a view with the full, styled error message, and refined-value highlighting, which visually marks specific code ranges for type refinements. The update also introduces a new status bar widget that displays the Flow version, server status (idle/busy/error), and type coverage percentage, along with a command palette menu for client actions like restarting the client or toggling coverage visibility.

packages/flow-for-vscode/src/FlowLanguageClient · high confidence

Rust port introduces file path generation with Windows path-length handling

The flow\_server\_files crate now provides Rust implementations for generating server file paths (logs, locks, sockets, etc.) based on the project root and temporary directory. A key behavioral addition is the handling of Windows MAX\_PATH limits: on Windows, long root paths are digested (using MD5) and truncated to ensure generated filenames do not exceed system limits, preventing ENAMETOOLONG errors, while non-Windows platforms use the full path without truncation.

_rust\_port/crates/flow\_server\files · high confidence

Rust port of the Flow configuration parser

The flow configuration system has been ported to Rust, introducing a new \flow\_config\ crate that parses \.flowconfig\ files. This change brings a new glob-based pattern system for \\[include\]\ and \\[ignore\]\ sections, replacing the legacy glob prefix support, and establishes new default behaviors for features such as \component\_syntax\, \enums\, and \pattern\_matching\. The parser now strictly validates glob patterns (rejecting absolute paths and empty strings) and supports new options like \saved\_state\_restart\_on\_reinit\ and \allow\_variance\_keywords\, while removing support for deprecated experimental flags and legacy saved state formats. Also in this area: 1 commit (0 fixes) modifying (repo-wide); Removal of several experimental Flow configuration options; Simplified type-reason reporting and enabled dynamic TypeScript lib definitions by default; Cleanup of OCaml translation artifacts in Rust source comments; Dynamic discovery of built-in TypeScript libdefs.

_rust\_port/crates/flow\config · low confidence · unverified

Symlinked skills directory for Claude configuration

The .claude/skills path is now a symbolic link pointing to ../.llms/skills/, centralizing skill definitions in the .llms directory while maintaining the expected structure for the .claude tooling.

.claude · high confidence

The \`add-comments\` command in \`flow-dev-tools\` is removed

The \add-comments\ command within the \flow-dev-tools\ package has been disabled. Running this command now prints a message instructing users to use \flow dev-tools add-comments\ instead and exits with an error code.

packages/flow-dev-tools/src/comment · high confidence

Unified build and test infrastructure for the Rust-port parser packages

The \packages/scripts\ directory now provides a cohesive build and test workflow for the Flow parser ecosystem, specifically supporting the new Rust-port (oxidized) parser. The new \build.sh\ script orchestrates the compilation of key packages (\flow-estree\, \flow-parser\, \flow-eslint\, \flow-transform\, \flow-api-translator\), handling source copying, Flow type stripping, and Babel transpilation. It integrates with \buildFlowParserWasm.sh\ to compile the Rust parser into a WebAssembly static library and \genFlowWasmParser.js\ to wrap it for Node.js consumption. Additionally, \genSelectorTypes.js\ generates TypeScript/Flow selector types for the ESTree AST, and \runOxidizedJestTests.sh\ provides a unified test runner that manages workspace dependencies and ensures build/test concurrency safety.

packages/scripts · high confidence

Updated flow-typed definitions for core dependencies

The flow-typed definitions in packages/flow-upgrade/flow-typed have been refreshed to match current library versions, adding or updating stubs for chalk v2, fs-extra v10, Jest v27, memfs v3.4, ora v5.4, prompt-confirm, semver v7, and yargs v17. This ensures that the Flow type checker correctly understands the APIs of these dependencies during the upgrade process.

packages/flow-upgrade/flow-typed · high confidence

Fixes

Align jest-specific-snapshot with Jest v29 defaults

The patch for the jest-specific-snapshot package now passes Jest v29 default configuration options (specifically snapshotFormat settings) when initializing snapshot state, ensuring consistent snapshot formatting behavior in environments using newer Jest versions.

packages/patches · high confidence

Fix LSP hover crashes on stale transactions in lazy mode

Resolves a crash in the Language Server Protocol hover feature that occurred when lazy mode was enabled. Previously, hovering over a component would force type thunks cached by an earlier request (such as diagnostics) to read from a transaction that had already been released, causing the hover to fail with a 'transaction was read after its guard was released' error. The fix ensures that hovers correctly handle these lazy type thunks, allowing hover information to display successfully without panicking the server.

newtests/lsp/staleTransaction · high confidence

Fix dfind file watcher staleness caused by busy-spin

The dfind daemon's file watcher no longer enters a busy-spin loop that previously flooded the response channel with empty updates, which caused \flow check\ to report stale errors indefinitely. This is fixed by changing the poll request encoding from a unit type (which deserialized immediately without blocking) to a named \PollRequest::GetChanges\ enum variant, ensuring the daemon blocks until a real poll arrives. A cross-process regression test is added to verify that file changes are reported promptly.

_rust\_port/crates/flow\dfind · high confidence

Test coverage

10 commits adding/updating tests in packages/flow-api-translator/\_\tests\\/flowDefToTSDef; 10 commits adding/updating tests in packages/flow-parser/\\tests\\/transform; 13 commits adding/updating tests in packages/flow-transform/\\tests\\; 2 commits adding/updating tests in packages/flow-api-translator/\\tests\\/TSDefToFlowDef; 2 commits adding/updating tests in packages/flow-eslint/\\tests\\/eslint-scope; 2 commits adding/updating tests in packages/flow-transform/\\tests\\_/test\codemods; 3 commits adding/updating tests in packages/flow-api-translator/\\tests\\/flowDefToTSDef/fixtures; 4 commits adding/updating tests in packages/flow-api-translator/\\tests\\/flowToJS; 4 commits adding/updating tests in packages/flow-eslint/\\tests\\; 4 commits adding/updating tests in packages/flow-remove-types/\\tests\\; 42 commits adding/updating tests in packages/flow-parser/\\tests\\; 5 commits adding/updating tests in packages/flow-transform/\\tests\\/transform; 7 commits adding/updating tests in packages/flow-eslint/\\tests\\/hermes-scope; 8 commits adding/updating tests in packages/flow-api-translator/\\tests\\_; Add LSP code-action tests for initialization and JSDoc insertion; Add LSP completion test suite; Add LSP executeCommand test for the 'log' command; Add layout generator tests for JavaScript and TypeScript syntax; Add tests for hierarchical document symbols and component syntax support; Added LSP connection lifecycle tests; Added LSP diagnostics tests for live error reporting and configuration scenarios; Added LSP document highlight tests for destructuring and class inheritance; Added LSP query tests for hover, definition, and coverage; Added LSP quick-fix tests for TypeScript and legacy Flow syntax; Added LSP quickfix tests for invariant subtyping, optional chaining, and property access; Added LSP quickfix tests for match statement syntax errors; Added LSP test for open file edits and close behavior; Added LSP tests for document paste functionality; Added comprehensive snapshot tests for flow-remove-types; Added end-to-end tests for LSP find-references functionality; Added example test suite for the new test tooling; Added regression test for LSP saved-state reinit stability; Added scope verification utility for ESLint parser tests; Added smoke test for the Rust-based flow.js WASM build; Added smoke tests for flow\_parser.js filename option and ES2016 exponent operator parsing; Added test coverage for Flow upgrade codemods; Added test coverage for flow-transform codemods and AST mutation utilities; Added test coverage for hierarchical workspace symbol queries; Added test fixtures for LSP document highlight scenarios; Added test fixtures for LSP document paste scenarios; Added test fixtures for LSP find-references scenarios; Added test fixtures for LSP global references and rename scenarios; Added test fixtures for component syntax auto-imports; Added test fixtures for local variable renaming in LSP; Added test fixtures for overload and static overload scenarios; Added test for Flow server autostop behavior; Added test for LSP connection teardown on server restart; Added tests for Flow ESLint rules; Added tests for Flow Enums runtime behavior; Added tests for Haste package auto-import completion paths; Added tests for LSP auto-imports in nested and symlinked node\_modules; Added tests for LSP autofix exports code actions; Added tests for LSP autoimport completion behavior; Added tests for LSP detailed diagnostics rendering; Added tests for LSP linkedEditingRange in JSX contexts; Added tests for LSP query behavior during rechecks; Added tests for LSP rename-file-imports across cross-file dependencies; Added tests for React quickfix code actions; Added tests for auto-import behavior with component syntax enabled; Added tests for enum quickfix code actions; Added tests for flow-upgrade CLI, file discovery, and upgrade logic; Added tests for local LSP rename functionality; Added tests for runCodemods file transformation; Added tests for the Flow AST traversal utilities; Added tests for the LSP auto-close JSX tag feature; Added tests for the readonly conversion refactor code action; Added tests for the textDocument/selectionRange LSP feature; Centralized test runner with server crash detection for flow-dev-tools; Expanded LSP signature help test coverage for Flow; New LSP refactor code-action tests for extract and switch-to-match; New codemod testing utility for Flow upgrades; New test assertion modules for LSP and output normalization; New test harness for flow-dev-tools; New test runner infrastructure for flow-parser; Test coverage for package.json change detection behavior; Updated test suite for React 19 type definitions.

Dependencies

Introduce Flow Evals and new OSS packages

This change adds a new \evals\ directory containing \package.json\ and \package-lock.json\ files to set up an LLM coding evaluation environment for the Flow type checker, pinning \flow-bin\ to version 0.322.0. It also introduces several new npm packages to the \packages/\ directory, including \babel-plugin-syntax-flow-parser\, \babel-plugin-transform-flow-enums\, and \eslint-plugin-fb-flow\, along with their respective dependency lock files. Additionally, a \newtests\ directory is added with fixture \package.json\ files for LSP completion tests, and the root \package.json\ is updated to configure Yarn workspaces including \flow-dev-tools\ and \flow-remove-types\.

(dependencies) · 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

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 47 → 45 (-1.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 39 → 33 (-6.2)
  • Architecture 90 → 85 (-4.5)
  • Maturity 62 → 62 (-0.2)
  • Readiness 38 → 44 (+6.0)
  • Security 58 → 58 (+0.7)
  • Performance 100 → 100 (+0.0)

Resolved (41)

  • Change coupling: ty_printer.rs ↔ query_types.rs (rust_port/crates/flow_common_ty/src/ty_printer.rs)
  • Change-coupling hub: misc.js → flowlib_contents.rs, tslib_contents.rs, flow-loader.js (lib/misc.js)
  • Cross-context type T (newtests → flow-dev-tools) (packages/flow-dev-tools/flow-typed/node.js)
  • Cross-context type T (newtests → flow-dev-tools) (packages/flow-dev-tools/flow-typed/node.js)
  • Cross-context type T (newtests → flow-dev-tools) (packages/flow-dev-tools/flow-typed/node.js)
  • Cross-context type T (newtests → flow-dev-tools) (packages/flow-dev-tools/flow-typed/node.js)
  • High CVE: [GHSA redacted] (packages/flow-for-vscode/yarn.lock)
  • High CVE: [GHSA redacted] (packages/yarn.lock)
  • High CVE: [GHSA redacted] (packages/flow-for-vscode/yarn.lock)
  • High CVE: [GHSA redacted] (packages/yarn.lock)
  • High CVE: [GHSA redacted] (packages/yarn.lock)
  • High CVE: [GHSA redacted] (packages/flow-upgrade/yarn.lock)
  • High CVE: [GHSA redacted] (packages/yarn.lock)
  • High CVE: [GHSA redacted] (packages/flow-upgrade/yarn.lock)
  • High secret: WD-SECRET-0002 (newtests/lsp/completion/component_syntax_auto_imports/snapshots/type.json)
  • High secret: WD-SECRET-0002 (newtests/lsp/completion/component_syntax_auto_imports/snapshots/value.json)
  • High: security finding (details withheld)
  • Leaked secret: hardcoded-credential (evals/graders/file_contains.sh)
  • Leaked secret: hardcoded-credential (evals/graders/no_flowfixme.sh)
  • Low cohesion: Test (LCOM4 5) (newtests/Tester.js)
  • …and 21 more

New (4237)

  • Annot::iter (cognitive 67) (rust_port/crates/flow_type_sig/src/type_sig.rs)
  • Annot::iter (cyclomatic 72) (rust_port/crates/flow_type_sig/src/type_sig.rs)
  • AnnotateExportsMapper::map_class_element (cognitive 28) (rust_port/crates/flow_codemods/src/annotate_exports.rs)
  • AnnotateExportsMapper::map_class_element (cyclomatic 16) (rust_port/crates/flow_codemods/src/annotate_exports.rs)
  • AnnotateExportsMapper::map_expression (cognitive 17) (rust_port/crates/flow_codemods/src/annotate_exports.rs)
  • AnnotateExportsMapper::map_function_return_annotation (cognitive 24) (rust_port/crates/flow_codemods/src/annotate_exports.rs)
  • AnnotateLiteralDeclarationsMapper::program (cognitive 20) (rust_port/crates/flow_codemods/src/annotate_literal_declarations.rs)
  • AnnotateOptionalPropertiesMapper::get_props_for_obj (cognitive 18) (rust_port/crates/flow_codemods/src/annotate_optional_properties.rs)
  • AnnotateOptionalPropertiesMapper::variable_declarator (cognitive 16) (rust_port/crates/flow_codemods/src/annotate_optional_properties.rs)
  • Builder::compact (cognitive 21) (rust_port/crates/flow_type_sig/src/compact_table.rs)
  • Change coupling: convert_types.rs ↔ type_mapper.rs (rust_port/crates/flow_typing_utils/src/convert_types.rs)
  • Change coupling: misc.js ↔ flowlib_contents.rs (lib/misc.js)
  • Change coupling: misc.js ↔ tslib_contents.rs (lib/misc.js)
  • Change coupling: parse.rs ↔ type_service.rs (rust_port/crates/flow_heap/src/parse.rs)
  • Change coupling: type_sig_options.rs ↔ lib.rs (rust_port/crates/flow_type_sig/src/type_sig_options.rs)
  • CheckedSet::add (cognitive 17) (rust_port/crates/flow_common_utils/src/checked_set.rs)
  • ClassTooLong: Annot (rust_port/crates/flow_type_sig/src/type_sig.rs)
  • ClassTooLong: AnnotateExportsMapper (rust_port/crates/flow_codemods/src/annotate_exports.rs)
  • ClassTooLong: AstVisitor (rust_port/crates/flow_parser/src/ast_visitor.rs)
  • ClassTooLong: ComponentLowerer (rust_port/crates/flow_parser_wasm/src/babel_adapter/component_lowering.rs)
  • …and 4217 more

Changes since last survey

  • 300 commits — 294 feature/other, 6 fixes

By area

  • rust_port/crates — 124 commits
  • rust_port/Cargo.lock — 18 commits
  • tests/implicit_instantiation_walk_regressions — 16 commits
  • lib/lib.es5.js — 15 commits
  • website/docs — 11 commits
  • src/parser — 7 commits
  • website/src — 7 commits
  • website/tests — 6 commits
  • packages/flow-parser — 5 commits
  • tests/lti_implicit_instantiation — 5 commits
  • packages/flow-api-translator — 4 commits
  • tests/strict_property_initialization — 4 commits
  • packages/flow-remove-types — 3 commits
  • packages/flow-upgrade — 3 commits
  • tests/ts_void — 3 commits
  • website/.flowconfig — 3 commits
  • website/package.json — 3 commits
  • lib/react.js — 2 commits
  • newtests/lsp — 2 commits
  • packages/flow-eslint — 2 commits

Notable commits

  • fix: [flow] Fix break, continue, return and throw paths being dropped by finally
  • fix: [flow] Fix flaky incremental_package_json_new test
  • fix: [flow] Fix internal errors on loops and destructuring in unreachable code
  • fix: [flow] Fix nested match property extraction for interfaces
  • fix: [flow][misplaced-error-fix] Position keyof indexer keys at the key set
  • fix: [flow][tslib] Move reserved tuple label regression into tuple tests
  • change: Bump follow-redirects from 1.16.1 to 1.16.2 in /website (#9524)
  • change: Bump node-forge from 1.4.2 to 1.4.3 in /website (#9526)
  • change: [3p][rust] Bump erased-serde 0.4.10 -> 0.4.11
  • change: [3p][rust] Bump rustix 1.1.5 -> 1.1.6
  • change: [3p][rust] Bump similar 3.2.0 -> 3.2.1
  • change: [3p][rust] Bump smallvec 1.16.2 -> 1.16.4
  • change: [3p][rust] Bump tokio 1.53.2 -> 1.54.1
  • change: [3p][rust] Bump zerocopy 0.8.59 -> 0.8.63
  • change: [AI Codemod][RustfixClaudeHumanReview] Fix deprecated lint in fbcode/flow/rust_port
  • change: [Opsmate Oncall Operator] [flow] Tolerate delayed autostop startup notifications
  • change: [Opsmate Oncall Operator] [flow] Update eval gold React event annotations
  • change: [flow] Accept any return type where a TS-declared => void function type is expected
  • change: [flow] Accept negated literals as declare variable initializers
  • change: [flow] Add Copy JSON to the Try Flow AST pane
  • …and 280 more

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

Survey your own repository

facebook/flow 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 53cf2180cb48276d4aba51ee75253fdc98eccff4 — 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.