@cplieger/deadset-ts 8.0.0-dev.5 → 8.0.0-dev.7

package/dist/src/contract/contract.generated.js

@@ -0,0 +1,1084 @@
+// Code generated by scripts/gen-contract.ts from the Contract copy under fixtures/ (npm run gen). DO NOT EDIT.
+export const CONTRACT_VERSION = "8.0.0";
+export const SCHEMA_VERSIONS = ["9.0.0"];
+export const SCHEMA_VERSION = "9.0.0";
+export const CORPUS_VERSION = "6.0.0";
+export const CODE_PREFIX = "DS";
+export const FAMILY_KEY_LENGTH = 4;
+export const LANGUAGES = ["go", "ts"];
+export const SEVERITIES = ["allow", "warn", "deny"];
+export const CONFIDENCES = [
+    "certain",
+    "probable",
+    "possible",
+];
+export const FORMATS = [
+    "text",
+    "json",
+    "github",
+    "sarif",
+    "template",
+];
+/** Each analyzed language's row: its analyzer, the names that mark it and the directories it skips. */
+export const LANGUAGE_ROWS = {
+    go: {
+        analyzer: "deadset-go",
+        markers: ["go.mod"],
+        skippedDirectories: ["node_modules", "testdata", "vendor", ".*", "_*"],
+    },
+    ts: {
+        analyzer: "deadset-ts",
+        markers: ["tsconfig*.json"],
+        skippedDirectories: ["node_modules", ".git"],
+    },
+};
+export const EXIT_CLEAN = 0;
+export const EXIT_FINDINGS = 1;
+export const EXIT_USAGE = 2;
+export const EXIT_FAILURE = 3;
+export const EXIT_PENDING = 4;
+export const KIND_ROWS = [
+    {
+        code: "DS1001",
+        name: "unused-exported",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "An exported symbol with no reference in the target and no reference from any loaded consumer. A symbol referenced only from its own declaration site counts as unreferenced.",
+        details: { name_literal: "optional" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        fixed: false,
+    },
+    {
+        code: "DS1002",
+        name: "unused-unexported",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "An unexported symbol with no reference in the target. A symbol referenced only from its own declaration site counts as unreferenced. In Go a constant or a type a function body declares, a function literal's body included, that nothing in that body names outside its own specification is reported under this code, under the reference of the enclosing declaration, as `grammar/symbol-ref.md` states for a declaration inside a function body, at the local declaration's own position, with `symbol.kind` `constant` or `type` and the liveness relation `reference-counting`.",
+        details: { name_literal: "optional" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        fixed: false,
+    },
+    {
+        code: "DS1003",
+        name: "unused-member",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "A struct field, class member or type member with no reference, a private member included. A member referenced only from its own declaration site counts as unreferenced.",
+        precondition: "A TypeScript member that no value writes and nothing reads, whose type names a type parameter of its declaring interface, class or type alias, is not reported when every part of that declaration that names the type parameter is a member no value writes and nothing reads. TypeScript compares object types by their members, so such members are what make two instantiations of their type distinct types, and deleting them leaves the type parameter phantom and lets one instantiation stand for another. A member a value writes is decided by the rule of DS1301 instead, whatever its type names.",
+        details: {},
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        fixed: false,
+    },
+    {
+        code: "DS1004",
+        name: "unused-import",
+        languages: ["ts"],
+        subject: "binding",
+        holdsLive: false,
+        rule: "A name a TypeScript import declaration binds, or an `import x = require()` declaration that is not exported, a symbol of its own file beside the declaration it imports, reported at the binding when nothing in the file reads it: a use in a type position, in a local export or in a type, a link or a `@see` tag of a doc comment reads it, and so does JSX the compiler turns into calls of a factory it names. A binding of a declaration file or of a component file is not judged, nor one of a generated file while generated files are excluded.",
+        details: {},
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        fixed: false,
+    },
+    {
+        code: "DS1005",
+        name: "unused-enum-member",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "An enumerated member that no symbol names, at the reachability class derived for the member and with no confidence ceiling below it. Every member of a type that carries a string, text or binary conversion method, or that a conversion from an integer or a wire value produces, is retained by the enum-group exemption first, so a member reached only by value is never a candidate.",
+        details: {},
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        fixed: false,
+    },
+    {
+        code: "DS1006",
+        name: "unused-type-parameter",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "A type parameter of a function, a method or a TypeScript type alias that no part of the declaration's signature, body or aliased type names, at the certain class. The deletion is local to the declaration and the explicit instantiations the reference set already lists. A type parameter of a declaration that is itself dead falls with it and is reported under no code of its own.",
+        precondition: "Function and method type parameters, and in TypeScript those of a type alias. A TypeScript alias names no type of its own, so two instantiations that differ only in a parameter its type never names are one type. A Go type declaration's type parameter is never reported, because a phantom type parameter such as `type ID[T any] int` makes two instantiations distinct types while naming the parameter nowhere, so deleting it changes the program. Nor is one of a TypeScript class or interface, which merges only with declarations of the same type parameters. A method signature an interface or an object type declares belongs to that type declaration, so its type parameters are never reported either.",
+        details: {},
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        fixed: false,
+    },
+    {
+        code: "DS1101",
+        name: "unreachable-export",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "An unused exported symbol in a package or file no external code can import: an unused-exported candidate whose enclosing package or file is unimportable from outside, reported once under this code at the certain class, because unimportability is a property of the package graph rather than of the consumer set, except where the confidence rule of grammar/analysis/confidence.md gives a declaration a string literal spells the class possible.",
+        details: { name_literal: "optional" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        derivedFrom: ["DS1001"],
+        fixed: false,
+    },
+    {
+        code: "DS1102",
+        name: "test-only-use",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only tests reach and that carries test evidence of its own language, is a test reference. A declaration of test-support code is test code and is no subject of this code, as grammar/analysis/tests.md states. An interface method whose only calls and selections through the interface are in test code, and that DS1202's precondition does not exempt, is reported under this code. The methods implementing it are not reported with it, because the test reaches them through it. A candidate found dead under reachability, every production reference to which is made by a declaration itself dead, is reported under this code as well where test code that is no test of dead code, and that the run counting test references reaches, references it, because that test keeps it, and the finding's message names both kinds of reference.",
+        details: { name_literal: "optional" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        derivedFrom: ["DS1001", "DS1002", "DS1003"],
+        fixed: false,
+    },
+    {
+        code: "DS1103",
+        name: "test-of-dead-code",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "A test symbol whose set of referenced target symbols is non-empty and every member of that set is reported dead. In TypeScript an ambient declaration, one a declaration file holds or one a `declare` modifier carries or a declaration carrying one holds, describes code the target does not implement, so it is no target symbol of that set. A test that references at least one live target symbol is never reported, no notion of a test's subject and no name matching enters the rule, and the message states the rule. A production declaration whose reachability class is `possible` because programs outside the analysis may use it, being published API of a library whose run declares no consumer, and in Go a declaration of a package no build links or an export of a unit a dropped module requires, counts as a live target symbol of every test that references it, so such a test is no test of dead code. The declaration is still reported at `possible`. The test joins the dead component of the symbols it references, and it and each of them count as referencing each other, so the test is a member of their cycle and never a dead symbol outside it.",
+        details: {},
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        fixed: false,
+    },
+    {
+        code: "DS1104",
+        name: "deprecated-unused",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "A symbol carrying a deprecation marker and no production reference: an unused-exported, unused-unexported or unused-member candidate whose symbol is deprecated, reported once under this code. Go identifies the marker by the convention the standard tools recognize, TypeScript by the documentation tag its tools recognize.",
+        details: { name_literal: "optional" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        derivedFrom: ["DS1001", "DS1002", "DS1003"],
+        fixed: false,
+    },
+    {
+        code: "DS1201",
+        name: "unused-interface",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "An interface no symbol uses as a type, counting uses from every loaded module. The finding names the concrete implementations and their positions, and the interface's members join its dead component rather than being reported as independent unused declarations.",
+        details: { implementations: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        findingFixabilities: ["manual"],
+        fixed: false,
+    },
+    {
+        code: "DS1202",
+        name: "uncalled-interface-method",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: false,
+        rule: "An interface method that no call site invokes or selects through the interface, whatever the number of implementations. A call or selection in test code is no call for this rule, and an interface method only test code calls is DS1102's. The finding names the concrete implementations and their positions. Each method that implements it and that nothing else keeps is reported under the code its own references select. Such a method counts as referenced by the interface method alone, so it belongs to this finding's dead component, whose root member is the interface method.",
+        precondition: "In Go, every method of an exported interface whose method set holds an unexported method is exempt, a method of an interface it embeds included. An unexported interface restricts no implementor outside its package, so a method only it holds is judged. That is the sum-type shape, whose method set exists to restrict the implementors, and a TypeScript interface cannot take it because it declares no member less visible than itself. In both languages, every marker method is exempt, an interface method whose every implementation carries an empty body.",
+        details: { implementations: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "warn",
+        maxClass: "certain",
+        fixability: "manual",
+        fixed: false,
+    },
+    {
+        code: "DS1203",
+        name: "unused-satisfaction-assertion",
+        languages: ["go"],
+        subject: "declaration",
+        holdsLive: true,
+        rule: "A compile-time satisfaction assertion whose interface no symbol uses as a type.",
+        precondition: "In a library, an assertion whose interface and whose concrete type are both published API, each an exported declaration of a package outside programs can import, is not reported: it states to every importer a promise of the published API. An assertion whose interface alone is published API has the reachability class possible, whatever consumers the run declares and loads. The assertion checks a promise the published API makes, that the type satisfies the published interface, and that promise is made to every program that imports the package, not only to the consumers the run declares. A loaded consumer that names the interface as a type uses it, and the assertion is not reported.",
+        details: { implementations: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        fixed: false,
+    },
+    {
+        code: "DS1301",
+        name: "write-only-symbol",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: true,
+        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. In Go a read counts only from a declaration that is live under the finding's liveness relation, which is reference counting: a read from a declaration nothing references, whose own finding has the reachability class `certain`, is no read, so a declaration that only such declarations read is reported where a declaration something references writes it. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In Go, a conversion the compiler accepts between two struct types, or between two pointer types that are not named types and whose base types are struct types, reads every field of the two struct types where their struct type literals are distinct, recorded at the conversion, because the conversion is legal only while their fields are identical, ignoring tags, and so no field of either can be deleted alone. It reads in the same way every field of each pair of distinct struct type literals the identity of the two types compares in turn: through each field's type, and from there through the element, key, base, parameter and result types of the type literals it reaches, through the method signatures of an interface type literal, and through the type arguments of an instantiated generic type. A field reached there has no reference of its own, as grammar/symbol-ref.md states, so it is never a subject and those reads hold no finding back. It stops at a defined type, whose fields the conversion does not read, because a defined type is identical to itself whatever fields it declares. A pair whose two sides are one struct type literal, the two struct types themselves included, as where one type is declared from the other or the conversion is to the operand's own type, reads nothing, because a field deleted from that literal leaves both sides identical. Where the operand's type or the conversion's type is a type parameter, the struct type its constraint's core type is takes that side's place, and a type parameter operand reads in the same way the fields of each struct type argument an instantiation the program holds gives it, an instantiation made through another generic declaration's own type parameters included. A conversion to any other type, an interface type among them, reads no field under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. A TypeScript parameter property, a constructor parameter that carries a modifier, declares a member of its class that the constructor writes with its argument, so the member is judged under this rule, and under every rule that reads a class member, as a member the class body declares is. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A literal whose type the compiler infers, as one a callback returns to a generic call, writes in the same way the member of each property's name that each object type a value of the literal's type reaches declares, through array elements, type arguments and the parameters and results of functions, so `ids.map((id) => ({ id }))` returned as `Row[]` writes `Row.id`. An object literal handed to a callee the target does not implement has its members read, as grammar/analysis/references-ts.md states. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
+        details: { write_positions: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        fixed: false,
+    },
+    {
+        code: "DS1401",
+        name: "unused-parameter",
+        languages: ["go", "ts"],
+        subject: "part",
+        holdsLive: false,
+        rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
+        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a go-fuzz entry point, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. In Go a function literal that is the callee of the call it is written in, the call of a `go` or a `defer` statement included, is not used as a value, wherever the literal is written. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported for deletion when its body reads no parameter after it, and an unread parameter before the last read one is reported for a rename to its name with a leading underscore, which keeps every argument in place and which the compilers' unused-parameter rules read as declared unread, unless its name already starts with one. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type, and that carries a type annotation, is not reported for deletion where the inference of the call holding the function may read the annotation, being where the callee is generic and its parameter type at the function's place names a type parameter at the parameter's place, or where the function is written inside an object literal such a call is passed, and it is reported for deletion at `probable` where it carries an annotation no such inference reads, because nothing in the program shows that an outside reader ignores it. A name an object binding pattern of a parameter of such a function binds, annotated or not, that the body never reads is reported for deletion at `probable`, because the pattern reads the property it names from the argument and the code that hands the argument may act on that read, which nothing in the program shows. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. A TypeScript constructor is used as a value where its class is used as a value other than as the callee of a `new` expression or the class an `extends` clause names, and its signature is not free where its class carries a decorator or a parameter of the constructor carries one, because the code that decorator or a container runs may construct the class. A parameter property is read by the write to its member the constructor makes, so it is never reported under this kind, and its member is judged under DS1301. A TypeScript name a parameter binds, whole or through a binding pattern, that starts with an underscore is never reported, because a leading underscore is the spelling unused-parameter rules read as declared unread, and no other name exempts a parameter. A Go parameter named by the blank identifier declares no name a body could read and is never reported.",
+        details: { overlap: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "warn",
+        maxClass: "certain",
+        fixability: "manual",
+        overlap: {
+            go: ["revive unused-parameter", "gopls unusedparams", "unparam"],
+            ts: ["tsc --noUnusedParameters", "@typescript-eslint/no-unused-vars"],
+        },
+        fixed: false,
+    },
+    {
+        code: "DS1402",
+        name: "unused-receiver",
+        languages: ["go"],
+        subject: "part",
+        holdsLive: false,
+        rule: "A named method receiver with no reference inside the method body. Go permits a method with no receiver name, so the fix deletes an identifier and changes no signature.",
+        precondition: "None beyond the rule. Deleting a receiver name changes no signature, so a method retained by interface satisfaction, a method used as a value and a stub are reported as any other method is.",
+        details: { overlap: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "warn",
+        maxClass: "certain",
+        fixability: "deletable",
+        overlap: { go: ["revive unused-receiver"], ts: ["not applicable"] },
+        fixed: false,
+    },
+    {
+        code: "DS1403",
+        name: "unused-result",
+        languages: ["go", "ts"],
+        subject: "part",
+        holdsLive: false,
+        rule: "A result value that no call site of the function uses, on a function whose signature is free to change.",
+        precondition: "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible. A function a program run by naming the file names, a file under the `ignore` tag or a script of a dropped module, has call sites outside the loaded graph. A call that is the operand of an await expression written as a statement of its own uses a result whose type has a member named then, a promise or another thenable, because the caller sequences on it, and discards any other result. A call written as a statement of its own, or as the operand of void, discards its result whatever its type.",
+        details: { overlap: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "warn",
+        maxClass: "certain",
+        fixability: "manual",
+        overlap: { go: ["unparam"], ts: ["none known"] },
+        fixed: false,
+    },
+    {
+        code: "DS1404",
+        name: "dead-store",
+        languages: ["go", "ts"],
+        subject: "part",
+        holdsLive: false,
+        rule: "A write to a local variable with no read before the next write to it or the end of its scope, computed on the same read-and-write classification the write-only-symbol kind uses. The finding names the write position.",
+        precondition: "In TypeScript the binding of a catch clause is a local variable the clause writes when it catches, so a binding that is a name and that the clause's block never reads is a dead store, positioned at the binding: the clause written with no binding behaves the same. A TypeScript local is a name a `let` or `const` declaration of a block binds, or a `var` declaration of a block of a function, a name an object or array binding pattern of one binds at any depth included, except a name with a default, whose removal skips the default's evaluation, and a name beside a rest element of its object pattern, whose removal changes what the rest holds. A function declaration of a block of a function is a TypeScript local too, written with its function when the block starts, wherever it stands in the block, so one that nothing outside its own body reads is a dead store positioned at its name, and a read anywhere else in the block reads it. A `let` or `var` declaration with no initializer writes `undefined`, so one that nothing reads and nothing writes is a dead store positioned at its name. A local whose declaration carries the type annotation `never` is no subject: a write to it is the compiler's exhaustiveness check, which fails to compile once a case goes unhandled, so deleting it changes what the program checks. A `var` of a block nested in its function's body is judged in that block, its last write kept because the function scope reads on past the block's end, and is no subject where a nested function of its function names it. A local a nested function reads is no subject, because the function may read it at any time, and every write to a local nothing reads is dead, one a nested function makes included, each positioned at the name it writes. The variable a `let` or `const` declaration of a `for…of` or `for…in` statement binds is written at each iteration, so one the loop body never reads is a dead store positioned at the binding, except a name that starts with an underscore, because a loop must bind a name and that spelling declares it unread. In Go a function literal a package-level variable's initializer holds is a function body of its own, and a finding about one of its stores carries the reference of the variable the literal initializes, which for a blank variable is its package's, as `grammar/symbol-ref.md` states for a blank-identifier declaration. In Go a range statement stores its key and its value at the start of every iteration, and an empty range stores neither. In Go a function literal reads each variable it names where it is written, and a store that a literal naming its variable may precede on some path of the control-flow graph, the literal of an earlier iteration of a loop included, is not dead, because a call of the literal the graph does not order may read it. A store no such literal precedes is judged as any other. A literal that is the callee of the call it is written in, outside a `go` or `defer` statement, runs there, so it reads its variables at that call and precedes no later store.",
+        details: { write_positions: "required", overlap: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        overlap: {
+            go: ["ineffassign", "wastedassign", "staticcheck SA4006"],
+            ts: ["eslint no-useless-assignment", "@typescript-eslint/no-unused-vars"],
+        },
+        fixed: false,
+    },
+    {
+        code: "DS1405",
+        name: "unreachable-statement",
+        languages: ["go", "ts"],
+        subject: "part",
+        holdsLive: false,
+        rule: "A statement that control flow cannot reach, at the precision the language's compiler applies to the same construct.",
+        details: { overlap: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        overlap: {
+            go: ["go vet unreachable"],
+            ts: ["tsc allowUnreachableCode", "eslint no-unreachable"],
+        },
+        fixed: false,
+    },
+    {
+        code: "DS1406",
+        name: "unreachable-case",
+        languages: ["go", "ts"],
+        subject: "part",
+        holdsLive: false,
+        rule: "A switch case whose type or value an earlier case in the same switch already covers.",
+        details: { overlap: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        overlap: { go: ["staticcheck SA4020"], ts: ["none known"] },
+        fixed: false,
+    },
+    {
+        code: "DS1501",
+        name: "unnecessary-export",
+        languages: ["go", "ts"],
+        subject: "declaration",
+        holdsLive: true,
+        rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
+        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
+        details: { narrower_visibility: "required", name_literal: "optional" },
+        defaultEnabled: true,
+        defaultSeverity: "warn",
+        maxClass: "certain",
+        fixability: "narrowable",
+        fixed: false,
+    },
+    {
+        code: "DS1502",
+        name: "unnecessary-exposure",
+        languages: ["go"],
+        subject: "declaration",
+        holdsLive: true,
+        rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
+        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
+        details: { narrower_visibility: "required", name_literal: "optional" },
+        defaultEnabled: true,
+        defaultSeverity: "warn",
+        maxClass: "certain",
+        fixability: "narrowable",
+        fixed: false,
+    },
+    {
+        code: "DS1503",
+        name: "redundant-export-keyword",
+        languages: ["ts"],
+        subject: "declaration",
+        holdsLive: true,
+        rule: "An exported declaration used only inside its own file, reported as a candidate for removing the export keyword. The finding names the narrower visibility the references support.",
+        precondition: 'Closed world only. Reported in a file that is not an entry file, a file only a configuration string or a script token names being none, because each runs the file and reads no name it exports, while a file a build script\'s bundler call names is one, because the bundle exposes what it exports, and a test file being one only for the exports its test runner calls, as grammar/analysis/tests.md "Test code" states, and a file a Markdown or MDX document imports one only for the exports the import reads, as grammar/analysis/roots.md "Markdown and MDX documents" states, and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file. Where the edge\'s other side is unknown to the analyzer, the finding is emitted pending. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.',
+        details: { narrower_visibility: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "warn",
+        maxClass: "certain",
+        fixability: "narrowable",
+        fixed: false,
+    },
+    {
+        code: "DS1601",
+        name: "file-never-built",
+        languages: ["go", "ts"],
+        subject: "file",
+        holdsLive: false,
+        rule: "A source file no configuration in the build matrix builds. On the Go side the finding names the build constraint that excluded the file. A file whose build constraint holds only when the ignore tag is set is never reported, because grammar/analysis/matrix.md keeps such a file outside the analysis wherever no configuration builds it: the tag is the toolchain's convention for a file kept out of ordinary package builds unless a configuration explicitly satisfies the tag, and built by hand, the toolchain applying no build constraint to a file named on its own command line. A file any other custom tag excludes is reported under a matrix the configuration declares complete, because completeness is the maintainer's assertion that the listed configurations are every one the target builds, and a configuration the maintainer builds by hand belongs in that list.",
+        precondition: 'Reported only when the configuration declares the build matrix complete, and never for a file the toolchain ignored solely because it imports "C" under a build with cgo disabled. Such a file is recorded as excluded by cgo rather than as never built.',
+        details: { excluded_by: ["go"] },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        fixed: false,
+    },
+    {
+        code: "DS1602",
+        name: "file-never-imported",
+        languages: ["go", "ts"],
+        subject: "file",
+        holdsLive: false,
+        rule: "A source file that no import from live code reaches, that no root names, and in which no declared cross-language edge names a declaration: an import counts where it is written in a file a root, a live declaration or such an import keeps, or in a live declaration, so a file only dead code imports is reported, under reachability. An import written in a loaded consumer reaches a file of the target as an import written in the target does. An edge's side names a declaration as a root names one, so a file holding a declaration an edge names is evaluated with the edge rather than reported: whether that declaration is dead is the edge evaluation's to say, and the merge resolves it against the paired side.",
+        details: {},
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "deletable",
+        fixed: false,
+    },
+    {
+        code: "DS1701",
+        name: "unused-dependency",
+        languages: ["go", "ts"],
+        subject: "dependency",
+        holdsLive: false,
+        rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency. On the TypeScript side, a needed dependency whose every use is written inside declarations that are members of the run's dead components, or at the top level of a file reported under DS1602, that no command runs and that no needed dependency used otherwise names as a peer, is reported as well, dead only through that code: at the reachability class possible where one of those declarations belongs to a library's published API, and found under reachability alone where one of those declarations or files is, so at probable unless ts.roots_complete is true. A use the configuration makes, a use an unanswered specifier may make and an import none of whose bindings is used are uses by live code.",
+        precondition: "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a call of `import.meta.resolve` or of `require.resolve` in them, whatever `require` names, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. A `@types/<name>` package in a type root of a compiler configuration that lists no `types`, a `node_modules/@types` directory at or above the configuration's directory or a `typeRoots` entry naming one, is needed by a use, in a file of that configuration, of a global name or an ambient module that one of the package's declaration files declares, which resolves to no declaration of the program: a compiler before version 6 includes every package of the type roots where `types` is not listed, and version 6 and later include none, so the program the analysis builds holds none of those declarations. A package's declaration files are the file its `types` or `typings` names, else its `index.d.ts`, and each file a `/// <reference path>` of one of them reaches inside the package. A global is a top-level declaration of such a file that is no module, or a declaration of a `declare global` block of one that is, and an ambient module is a `declare module` with a string name of a file that is no module. A name that names a member, a property or a label is no use of a global. Four more dependencies are needed: one whose command a script entry, a workflow step or a git hook runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis/conventions.md states, and one that a needed dependency names as a peer, as stated below. A command no script entry, workflow step or git hook runs needs nothing. A declared dependency that the installed manifest of a needed declared dependency names in its peerDependencies is needed, and so on until no further dependency joins. A peer dependency is a package the needed dependency expects beside it at a version its manifest states, whether or not it imports the package, and the project's declaration is what keeps that package present at a version the project chooses, so removing the declaration can break the needed dependency where nothing the analysis reads imports the peer. A peer that peerDependenciesMeta marks optional is needed in the same way, because the needed dependency's manifest still names it as a package it works with, and a package manager may leave an optional peer out where the project does not declare it, so the project's declaration is what keeps it present for the needed dependency. A declared dependency that only dependencies nothing needs name as a peer is needed by nothing. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the directory of the manifest that declares the dependency, and a dependency with none is decided by the import closure alone. On the TypeScript side, the dependencies judged are those of every manifest grammar/analysis/program.md says the analysis reads, a nested package's among them, each read against its own directory: a dependency is needed by a use written in a file at or below the directory of the manifest that declares it where no manifest between them declares a dependency of the same name, so a use below a nested manifest that declares the same dependency needs that nested manifest's declaration only, by a use no one file holds, and as a peer of a needed dependency of the same manifest or of a manifest below it. A dependency a nested package's manifest declares whose installed manifest the analysis cannot find is not judged, because no run requires a nested package to be installed and its commands and peers cannot be read, while a workspace member's and the target's own are judged as above.",
+        details: { dependency_class: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "manual",
+        fixed: false,
+    },
+    {
+        code: "DS1702",
+        name: "unused-module-directive",
+        languages: ["go"],
+        subject: "dependency",
+        holdsLive: false,
+        rule: "A replace directive whose target module is absent from the build list, the one case in which the directive is exactly a no-op.",
+        precondition: "Only a replace whose target is absent from the build list. No other module-file directive is reported. An exclude directive is not, because not selected is a counterfactual about a resolution that did not happen. A workspace use entry and a tool directive are not, because each is an external entry point whose invocation lives outside anything the analysis reads.",
+        details: { replacement: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "warn",
+        maxClass: "certain",
+        fixability: "deletable",
+        fixed: false,
+    },
+    {
+        code: "DS9001",
+        name: "suppression-without-reason",
+        languages: ["go", "ts"],
+        subject: "record",
+        holdsLive: false,
+        rule: "A suppression that carries no reason, in any of the three documents: an inline directive, an ignore-file entry or a baseline row. For the ignore file and the baseline, an entry or a row whose reason field is absent, empty or whitespace only is refused and reported rather than matched.",
+        details: { mechanism: "required", entry: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "none",
+        fixed: false,
+    },
+    {
+        code: "DS9002",
+        name: "unscoped-ignore-entry",
+        languages: ["go", "ts"],
+        subject: "record",
+        holdsLive: false,
+        rule: "An ignore-file entry or a baseline row that names a symbol and no file path. The entry is reported rather than matched, so a bare name cannot mask a match anywhere else in the project. The inline directive is scoped by its position and cannot be unscoped.",
+        details: { mechanism: "required", entry: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "none",
+        fixed: false,
+    },
+    {
+        code: "DS9003",
+        name: "stale-suppression",
+        languages: ["go", "ts"],
+        subject: "record",
+        holdsLive: false,
+        rule: "A suppression record that is stale, as grammar/suppression.md defines it, at either mechanism and in the baseline alike. The run exits with the findings code when at least one is reported. The kind is fixed on at deny: no flag, no severity setting and no per-mechanism exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
+        details: { mechanism: "required", entry: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "none",
+        fixed: true,
+    },
+    {
+        code: "DS9004",
+        name: "unmatched-root",
+        languages: ["go", "ts"],
+        subject: "record",
+        holdsLive: false,
+        rule: "A configured root that matches no symbol, or a configured root pattern that matches no symbol. A root set nobody checks silently changes every result, so a stale one is a finding. The kind is fixed on at deny: no flag, no severity setting and no exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
+        details: {},
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "none",
+        fixed: true,
+    },
+    {
+        code: "DS9005",
+        name: "stale-cross-language-edge",
+        languages: ["go", "ts"],
+        subject: "record",
+        holdsLive: false,
+        rule: "A declared cross-language edge with a side that at least one analyzer evaluated and every evaluation of that side reports absent, so no analyzer that ran enumerates that side's symbol. Emitted by the merge, once per edge, never by an analyzer, so a stale edge is visible rather than silently inert. A dead side paired with an absent side drops its pending finding, and the edge is the reported defect: a misspelled reference must not turn a live pairing into a deletion.",
+        details: { edge: "required", sides: "required" },
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "none",
+        fixed: false,
+    },
+    {
+        code: "DS9006",
+        name: "unmatched-configured-declaration",
+        languages: ["ts"],
+        subject: "record",
+        holdsLive: false,
+        rule: "An entry of a configuration key that names a declaration, being an entry of ts.injection_registrations, of the components or the bases of an entry of ts.lifecycle_contracts, or of ts.serializers, that names no declaration in any project of the run, by the resolution the ts section of contract/config.schema.json states for its shape. An entry that names a declaration no call reaches matches. An exemption whose configured declarations nobody checks silently retains nothing, so a stale entry is a finding. The kind is fixed on at deny: no flag, no severity setting and no exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
+        details: {},
+        defaultEnabled: true,
+        defaultSeverity: "deny",
+        maxClass: "certain",
+        fixability: "none",
+        fixed: true,
+    },
+];
+export const CODE = {
+    unusedExported: "DS1001",
+    unusedUnexported: "DS1002",
+    unusedMember: "DS1003",
+    unusedImport: "DS1004",
+    unusedEnumMember: "DS1005",
+    unusedTypeParameter: "DS1006",
+    unreachableExport: "DS1101",
+    testOnlyUse: "DS1102",
+    testOfDeadCode: "DS1103",
+    deprecatedUnused: "DS1104",
+    unusedInterface: "DS1201",
+    uncalledInterfaceMethod: "DS1202",
+    unusedSatisfactionAssertion: "DS1203",
+    writeOnlySymbol: "DS1301",
+    unusedParameter: "DS1401",
+    unusedReceiver: "DS1402",
+    unusedResult: "DS1403",
+    deadStore: "DS1404",
+    unreachableStatement: "DS1405",
+    unreachableCase: "DS1406",
+    unnecessaryExport: "DS1501",
+    unnecessaryExposure: "DS1502",
+    redundantExportKeyword: "DS1503",
+    fileNeverBuilt: "DS1601",
+    fileNeverImported: "DS1602",
+    unusedDependency: "DS1701",
+    unusedModuleDirective: "DS1702",
+    suppressionWithoutReason: "DS9001",
+    unscopedIgnoreEntry: "DS9002",
+    staleSuppression: "DS9003",
+    unmatchedRoot: "DS9004",
+    staleCrossLanguageEdge: "DS9005",
+    unmatchedConfiguredDeclaration: "DS9006",
+};
+export const FAMILIES = [
+    { key: "DS10", name: "unused", title: "Unused", status: "live" },
+    {
+        key: "DS11",
+        name: "dead-or-test-only",
+        title: "Only dead code or tests use it",
+        status: "live",
+    },
+    { key: "DS12", name: "interfaces", title: "Interfaces", status: "live" },
+    { key: "DS13", name: "unread-data", title: "Data nobody reads", status: "live" },
+    { key: "DS14", name: "inside-functions", title: "Inside functions", status: "live" },
+    { key: "DS15", name: "too-visible", title: "Too visible", status: "live" },
+    { key: "DS16", name: "files", title: "Files", status: "live" },
+    { key: "DS17", name: "dependencies", title: "Dependencies and module files", status: "live" },
+    { key: "DS18", name: "schemas", title: "Schemas", status: "reserved" },
+    { key: "DS90", name: "configuration", title: "deadset configuration", status: "live" },
+];
+export const SYMBOL_SUBJECTS = {
+    function: "declaration",
+    method: "declaration",
+    type: "declaration",
+    class: "declaration",
+    interface: "declaration",
+    enum: "declaration",
+    namespace: "declaration",
+    variable: "declaration",
+    constant: "declaration",
+    "export-alias": "declaration",
+    field: "declaration",
+    "class-member": "declaration",
+    "type-member": "declaration",
+    "interface-method": "declaration",
+    "enum-member": "declaration",
+    "satisfaction-assertion": "declaration",
+    "type-parameter": "declaration",
+    parameter: "part",
+    receiver: "part",
+    result: "part",
+    statement: "part",
+    case: "part",
+    store: "part",
+    file: "file",
+    import: "binding",
+    dependency: "dependency",
+    "module-directive": "dependency",
+    suppression: "record",
+    root: "record",
+    "configured-declaration": "record",
+    edge: "record",
+};
+export const EXEMPTION_CLASSES = [
+    {
+        class: "interface-satisfaction",
+        languages: ["go", "ts"],
+        confidence: "certain",
+        retainsKinds: { go: ["method", "field"], ts: ["method", "class-member"] },
+        typescriptVisibility: { private: false, privateName: false },
+    },
+    {
+        class: "encoding-reflection",
+        languages: ["go"],
+        confidence: "certain",
+        retainsKinds: { go: ["field", "method"] },
+    },
+    {
+        class: "format-verb-contract",
+        languages: ["go"],
+        confidence: "certain",
+        retainsKinds: { go: ["method"] },
+    },
+    {
+        class: "errors-duck-typing",
+        languages: ["go"],
+        confidence: "certain",
+        retainsKinds: { go: ["method"] },
+    },
+    {
+        class: "enum-group",
+        languages: ["go", "ts"],
+        confidence: "certain",
+        retainsKinds: { go: ["enum-member"], ts: ["enum-member"] },
+        typescriptVisibility: { private: false, privateName: false },
+    },
+    {
+        class: "generated-file",
+        languages: ["go", "ts"],
+        confidence: "certain",
+        retainsKinds: {
+            go: [
+                "function",
+                "method",
+                "type",
+                "interface",
+                "variable",
+                "constant",
+                "field",
+                "interface-method",
+                "enum-member",
+                "satisfaction-assertion",
+                "type-parameter",
+            ],
+            ts: [
+                "function",
+                "method",
+                "type",
+                "class",
+                "interface",
+                "enum",
+                "namespace",
+                "variable",
+                "export-alias",
+                "import",
+                "class-member",
+                "type-member",
+                "interface-method",
+                "enum-member",
+                "type-parameter",
+            ],
+        },
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "linkname-cgo-asm-plugin",
+        languages: ["go"],
+        confidence: "certain",
+        retainsKinds: { go: ["function", "variable"] },
+    },
+    {
+        class: "template-field",
+        languages: ["go", "ts"],
+        confidence: "possible",
+        retainsKinds: {
+            go: ["field", "method"],
+            ts: [
+                "function",
+                "method",
+                "type",
+                "class",
+                "interface",
+                "enum",
+                "namespace",
+                "variable",
+                "export-alias",
+                "import",
+                "class-member",
+                "type-member",
+                "interface-method",
+                "enum-member",
+                "type-parameter",
+            ],
+        },
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "reflective-lookup",
+        languages: ["go", "ts"],
+        confidence: "possible",
+        retainsKinds: {
+            go: ["field", "method"],
+            ts: [
+                "function",
+                "method",
+                "type",
+                "class",
+                "interface",
+                "enum",
+                "namespace",
+                "variable",
+                "export-alias",
+                "import",
+                "class-member",
+                "type-member",
+                "interface-method",
+                "enum-member",
+                "type-parameter",
+            ],
+        },
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "decorator",
+        languages: ["ts"],
+        confidence: "certain",
+        retainsKinds: {
+            ts: [
+                "function",
+                "method",
+                "type",
+                "class",
+                "interface",
+                "enum",
+                "namespace",
+                "variable",
+                "export-alias",
+                "import",
+                "class-member",
+                "type-member",
+                "interface-method",
+                "enum-member",
+                "type-parameter",
+            ],
+        },
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "injection-container",
+        languages: ["ts"],
+        confidence: "certain",
+        retainsKinds: { ts: ["method", "class-member"] },
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "framework-lifecycle",
+        languages: ["ts"],
+        confidence: "certain",
+        retainsKinds: { ts: ["method", "class-member"] },
+        typescriptVisibility: { private: true, privateName: false },
+    },
+    {
+        class: "serialization-contract",
+        languages: ["ts"],
+        confidence: "certain",
+        retainsKinds: { ts: ["method", "class-member", "interface-method", "type-member"] },
+        typescriptVisibility: { private: true, privateName: false },
+    },
+];
+export const EVIDENCE = [
+    {
+        evidence: "consumers-not-loaded",
+        rule: "confidence.2",
+        class: "probable",
+        languages: ["go", "ts"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+        ],
+    },
+    {
+        evidence: "no-consumer-information",
+        rule: "confidence.2",
+        class: "possible",
+        languages: ["go", "ts"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+        ],
+    },
+    {
+        evidence: "unlinked-go-package",
+        rule: "roots.25",
+        class: "possible",
+        languages: ["go"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+        ],
+    },
+    {
+        evidence: "name-literal",
+        rule: "confidence.8",
+        class: "possible",
+        languages: ["go"],
+        codes: ["DS1001", "DS1002", "DS1101", "DS1102", "DS1104", "DS1501", "DS1502"],
+    },
+    {
+        evidence: "in-operand",
+        rule: "confidence.13",
+        class: "possible",
+        languages: ["ts"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+        ],
+    },
+    {
+        evidence: "outside-filler",
+        rule: "confidence.14",
+        class: "possible",
+        languages: ["go"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+        ],
+    },
+    {
+        evidence: "decoded-outside",
+        rule: "confidence.19",
+        class: "possible",
+        languages: ["go", "ts"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+        ],
+    },
+    {
+        evidence: "test-reached",
+        rule: "confidence.20",
+        class: "possible",
+        languages: ["ts"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+            "DS1602",
+        ],
+    },
+    {
+        evidence: "test-reached",
+        rule: "confidence.21",
+        class: "possible",
+        languages: ["go"],
+        codes: ["DS1001", "DS1002", "DS1003", "DS1102", "DS1103", "DS1104", "DS1201", "DS1301"],
+    },
+    {
+        evidence: "possible-class",
+        rule: "confidence.23",
+        class: "possible",
+        languages: ["go", "ts"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+        ],
+    },
+    {
+        evidence: "roots-incomplete",
+        rule: "confidence.25",
+        class: "probable",
+        languages: ["ts"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+            "DS1602",
+        ],
+    },
+    {
+        evidence: "computed-load",
+        rule: "confidence.26",
+        class: "probable",
+        languages: ["ts"],
+        codes: [
+            "DS1001",
+            "DS1002",
+            "DS1003",
+            "DS1004",
+            "DS1005",
+            "DS1006",
+            "DS1101",
+            "DS1102",
+            "DS1103",
+            "DS1104",
+            "DS1201",
+            "DS1202",
+            "DS1203",
+            "DS1301",
+            "DS1501",
+            "DS1502",
+            "DS1503",
+            "DS1602",
+        ],
+    },
+];
+export const SETUP_CLASSES = [
+    { class: "missing-module", languages: ["go", "ts"] },
+    { class: "incomplete-module-sum", languages: ["go"] },
+    { class: "missing-consumer", languages: ["go", "ts"] },
+    { class: "workspace-member-without-source", languages: ["ts"] },
+    { class: "convention-not-literal", languages: ["ts"] },
+    { class: "no-program", languages: ["go", "ts"] },
+];
+/** The text opening the line of the error stream that names one setup failure. */
+export const SETUP_FAILURE_PREFIX = "setup failure: ";