internal/

Command record writes one bench/quiet_machine.sh run to bench/results as a validated record (internal/benchresults).

Command runoutput prints what one measured run said about itself, read from its `--json` output (benchresults.ParseRunOutput), as quiet_machine.sh's columns: engine seconds, findings and cache use, tab-separated.

Package capture is the record the lint test harness writes for the docs generator: one case a rule's test asserted, with the source it ran on and what the rule did there.

Command generate writes the website's data (internal/docsdata) into the module's docs/data/ directory.

Package arena hands out values from chunks of memory that are kept and reused, for the trees a format builds and drops one file at a time (#93dpede).

Package formatdiff measures typescript-go's formatter against the Prettier fork that formats this codebase today.

Package mediaquery is postcss-media-query-parser 0.2.3 (dist/), the parser Prettier's src/language-css/parse/parse-media-query.js runs on the params of @media and @custom-media.

Package postcss is postcss 8.5.16's CSS parser ported to Go: lib/tokenize.js, lib/parser.js and lib/parse.js, with the parts of lib/input.js, lib/css-syntax-error.js and the node classes they need.

Package selector is postcss-selector-parser 2.2.3, the selector parser Prettier's CSS printer reads: dist/processor.js, dist/parser.js, dist/tokenize.js and dist/selectors/*.js, ported to Go.

Package values ports postcss-values-parser 2.0.1 (lib/parser.js, lib/tokenize.js and the node classes), the parser Prettier's language-css hands declaration values and some at-rule params to.

Package differential measures a candidate formatter against the Prettier fork, byte for byte, over real corpora.

Package doc is Prettier's document IR and layout algorithm, ported to Go.

Command generate_string_width captures the three tables Prettier's getStringWidth depends on, from the exact package versions the fork bundles, and writes them as Go.

Package estree is the ESTree tree Prettier's JavaScript printer reads, built from typescript-go's AST.

Package formatfiles decides which files a tree offers the formatter: the walk, its ignore layers (git's ignore files, the house list, the project's ignorePatterns), and an account of every file it did not offer.

Package formatoptions is what a file formats with: the options, Prettier's names for them, and how a directory resolves them from its repository's config.

Package graphql is Prettier's GraphQL language: graphql-js's parser, ported here, and Prettier's printer-graphql, ported beside it.

Package javascript is Prettier's JavaScript and TypeScript printer, src/language-js in the fork, ported to Go over the ESTree tree internal/format/estree builds.

Package markdown is Prettier's markdown printer (src/language-markdown) for the markdown parser, ported to Go over the tree internal/format/markdown/mdast builds with the same parser the fork runs.

Package mdast is the syntax tree Prettier's markdown printer reads, and mdast-util-from-markdown, the compiler that builds it from micromark's events.

Package micromark is micromark 4, the markdown tokenizer Prettier's markdown parser runs, ported to Go.

Command generate_characters captures micromark's two Unicode character classes from the bundle the oracle runs, and writes them as Go.

Command generate_entities captures the HTML named character references micromark decodes, from the table the oracle's bundle carries, and writes them as Go.

Command generate_classes captures the character classes Prettier's markdown printer splits and wraps text by, from the bundle the oracle runs, and writes them as Go.

Command generate_languages captures the languages markdown's embed infers a parser from, from the bundles the oracle runs, and writes them as Go.

Package native is cohere's own formatter: the printers that replace Prettier, routed by file type.

Package oracletest keeps what the embedded Prettier answered for a test's fixtures in a checked-in golden file, so the test compares bytes and runs no JavaScript (#nxgt2ca).

Package prettier formats source by running our own Prettier fork inside a JavaScript engine.

Package printing is Prettier's print core, shared by every native printer in cohere: AstPath, the print driver that wraps each node's doc in its comments, comment attachment, and embedding.

Package yaml is Prettier's YAML printer (src/language-yaml) ported to Go, printing the tree internal/format/yaml/unist describes: yaml-unist-parser's, over eemeli/yaml.

Package compose is eemeli/yaml 2.9.0's composer, dist/compose/, ported to Go with the node classes it builds (dist/nodes/), the parts of dist/doc/ it runs (the Document constructor and setSchema, the Directives), and the schemas it resolves tags against (dist/schema/: the core schema, the common map, seq, string and null tags, and the YAML 1.1 schema, which a %YAML 1.1 directive selects and six of whose tags the core schema reaches as known tags).

Package cst is eemeli/yaml 2.9.0's concrete syntax tree parser, dist/parse/, ported to Go: the lexer (lexer.js), the parser (parser.js), the token types and tokenType (cst.js), and the LineCounter (line-counter.js).

Package unist is the syntax tree Prettier's YAML printer reads: yaml-unist-parser 3.2.0's tree, built over the documents eemeli/yaml 2.9.0 composes.

Source: tsgolint `internal/utilities/builtin_symbol_likes.go`.

Package flow finds every place a value of one type is put into a slot of another, and relates the two part by part.

Package config decides which rules apply to which files.

Package binding answers whether an identifier names something this file chose.

Package classmembers answers which members of a class collide with each other.

Package consistentreturn answers whether the `return` statements in one function agree about carrying a value, and where to point when they do not.

Vendored from web-infra-dev/rslint, `internal/utilities/cfg`, at commit 44956a0c53201157aaf5bc19e1c2728896c83ec4.

Package decorators reads TypeScript decorators and the declared/actual nullability that the decorator parity rules compare.

Package descriptor answers whether a function is the `get` or `set` of a property descriptor passed to one of the platform methods that read descriptors: `Object.defineProperty`, `Object.defineProperties`, `Object.create` and `Reflect.defineProperty`.

Package directives is the grammar of suppression comments, and the short list of rules whose findings are about those comments.

Package dotnotation is the judgment behind `dot-notation`: which bracket accesses with a literal key read better as dot accesses, which dot accesses must be bracketed when keywords are disallowed, and the repairs for both.

Making a method call and its property agree about scopes.

Package imports answers where a file's imports come from, in every shape the language allows.

Package jsx answers the questions a rule asks about a JSX element: what tag it names, what attributes it writes, and what a given attribute's text is.

Package literal answers questions about the text a string literal holds, where the bytes on disk and the value the program receives are two different strings.

Package module answers questions about how a file exposes its declarations.

Package module_roots decides which files are alive with no importer: a framework loads them by filename, a test runner by glob, a computed `import()` by directory.

Package nextjs answers which Next.js file a path is, for the rules that gate on it.

Package property answers what property a key or a member access names, when the syntax settles it without evaluation.

Package react answers the questions a rule asks about React code that are not questions about JSX: is this call constructing an element, is this a component, which component encloses this.

Package reference answers what an identifier occurrence does to the binding it names.

Package regexp compiles a JavaScript regexp the way JavaScript reads it.

Package regexpattern walks a regular expression pattern and reports each character it matches, with the structure enclosing it.

cspell:ignore octals

Package scope answers which construct encloses a node.

Package text holds string measurements that are not specific to any language we lint.

Package tokens is a node's tokens, comments and whitespace excluded, and the questions ESLint's SourceCode asks of them: getTokenBefore, getTokenAfter and getFirstTokenBetween.

Package housesets decides, from the program, which house sets a zero-config run applies where (#bfxz13m, #j6p9t1g).

Package linter walks source files once and dispatches every rule against them.

Package optionschema holds every ported rule's upstream options schema and checks a config's options against it, so cohere accepts exactly the option shapes ESLint accepts and refuses the rest (#pd2chkx).

Package registry is the list of every rule cohere knows.

Package report turns findings into what a person reads, and says what was covered.

Package rule defines what a rule is and how it speaks.

Package base holds the rules that check Base's own conventions.

Package boundaries holds cohere's port of eslint-plugin-boundaries, which checks which parts of a codebase may import which.

Package core ports ESLint's own core rules, the ones that guard JavaScript rather than any convention of ours.

Package next holds the rules from `@next/eslint-plugin-next`, ported from Vercel's originals.

Package nexus holds the rules that describe how Nexus code reads, ported from the TypeScript originals in ahra's libraries/structure/libraries/nexus/code-quality/lint/rules.

Package react holds the ported `eslint-plugin-react` rules.

Package react_conformance scores an implementation against React's own compiler error fixtures.

Command vendor_fixtures re-pulls React's error-named compiler fixtures at a chosen commit.

Package structure holds the rules for this project's own conventions, as opposed to the language rules in core and the cross-cutting ones in nexus.

The live candidate split: a class broken into the pieces that decide whether it can merge, using this repository's own roots.

decodeArbitraryValue and isValidArbitrary: the two functions every arbitrary bracket in a class string is routed through before the candidate parser will look at it.

Command generate_candidate captures candidate readings from the real Tailwind candidate parser, so that the Go port in internal/lint/rules/tailwind/collapse/candidate.go is tested against measurements rather than against a reading of the TypeScript source.

Command generate_class_literals asks better-tailwindcss itself what it reads as a class string (#btxd64n), and writes two files from its answers:

Command generate_class_order captures the Tier 2 differential fixture: `{order, count}` for every class in every design system, as the shipped Tailwind engine computes it, together with the per-repository tables the Go side needs to answer the same question.

Command generate_collapse regenerates the Tailwind collapse table from the installed Tailwind.

Command generate_css_parser captures parse trees from the real Tailwind CSS parser, so that the Go port in internal/lint/rules/tailwind/collapse/cssparser.go is tested against measurements rather than against a reading of the TypeScript source.

Command generate_data_type captures what the real Tailwind engine infers for a corpus of CSS value shapes, so that the Go port in internal/tailwind can be tested against measurements rather than against a reading of the TypeScript source.

Command generate_descriptor_base prints the framework-invariant half of the descriptor table into shipped Go, so a design system can be given a descriptor Table without a checked-in fixture.

Command generate_descriptor_table turns the descriptor extractor's diagnostic JSON into the Go table `internal/tailwind` looks readings up in.

Command generate_framework_variants prints the framework's variant registrations into shipped Go.

Command generate_statics turns the engine's own static-utility registrations into Go.

Command generate_syntax_tree captures compiled utility trees from the real Tailwind engine, together with the {order, count} reading the engine takes from each, so that the Go AST and PropertySort in internal/tailwind are tested against measurements rather than against a reading of the TypeScript source.

Command generate_theme captures the theme the real Tailwind engine resolved for a corpus of stylesheets, so that the Go port in internal/lint/rules/tailwind/collapse/theme.go is tested against measurements rather than against a reading of the TypeScript source.

Command generate_utility captures what the shipped Tailwind engine does with a repository's own `@utility` blocks, so that the Go evaluator in internal/lint/rules/tailwind/collapse/utility.go is tested against measurements rather than against a reading of `createCssUtility`.

Command generate_value_parser captures the node tree the real Tailwind value parser produces for a corpus of CSS value shapes, so that the Go port in internal/tailwind is tested against measurements rather than against a reading of the TypeScript source.

Command generate_variant captures how the real Tailwind engine orders variants, so that the Go port in internal/lint/rules/tailwind/collapse/variant.go is tested against measurements rather than against a reading of the TypeScript source.

Package tooldirectory finds a generator's own source directory, where its sibling scripts live.

Package vendored is the installed tailwindcss the Tailwind rules' tests build a design system against: a snapshot of tailwindcss 4.3.3 in testdata, so those tests run on any machine instead of only where ahra's node_modules happens to be (#sycrdr6).

Package typescript holds the rules from `@typescript-eslint/eslint-plugin`, ported from the originals.

Package suppression reads the comments that tell a rule "not here", and records what they did.

Package rule_testing runs a rule against source text and reports what it found.

Package changelog writes a release's section of CHANGELOG.md from what changed in the rule sets cohere carries, and says the smallest version that change allows.

Package dispatch resolves which cohere binary to run, rebuilding it when its inputs change.

Package gocache bounds a Go build cache by size, which Go itself never does.

Package notices writes cohere's third-party notices: NOTICE, which carries the TypeScript compiler's Apache-2.0 notice, and THIRD_PARTY_NOTICES.md, which credits every other project cohere is built on with its license in full.

Package release holds what a shipped cohere knows about itself: which build it is, and where its binary comes from on a machine that has no source and no Go toolchain.

Command build_dispatcher_package writes one npm package to a directory, and compiles nothing.

Command changelog prints a release's section of CHANGELOG.md from what changed in the rule sets, and refuses a version smaller than that change allows.

Command notices writes NOTICE and THIRD_PARTY_NOTICES.md at the module root, from cohere's build graph and the curated upstreams in internal/release/notices.

Command generate writes the settings schemas and their reference (internal/settingsschema) into the module's schema/ directory.

Package program builds the type graph and hands the other phases a checker they call as a function.

Package sourcename says what a source file's name means to cohere's TypeScript decisions.