@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/dist/src/contextual-uses.js

@@ -63,9 +63,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     const privateNames = new Set(held.symbols
         .filter((symbol) => symbol.visibility === "private-name")
         .map((symbol) => symbol.id));
-    let batches = 0;
-    let lookups = 0;
-    const batchesOf = (count) => Math.ceil(count / cap);
     const parts = new Map();
     /** The object types one type is: itself, or its constituents at any depth. */
     const partsOf = (type) => {
@@ -75,7 +72,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         let found = [];
         if (type.isUnionType() || type.isIntersectionType()) {
-            lookups += 1;
             const constituents = queries.constituents(type);
             found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
         }
@@ -94,7 +90,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
         const table = new Map();
         const read = properties.of(type);
-        lookups += read.asked ? 1 : 0;
         for (const property of isAnswered(read.properties) ? read.properties : []) {
             table.set(property.name, {
                 ids: chains
@@ -112,7 +107,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         return table;
     };
     const writes = [];
-    batches += batchesOf(literals.length);
     const contexts = queries.contextualTypes(literals.map((one) => one.literal), cap);
     // A computed name that is not literal text names the property the literal declares
     // under the checker's own key, which is how a type declares a member a unique symbol
@@ -123,7 +117,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             const name = propertyName(property);
             return name !== undefined && name.text === undefined ? [name.node] : [];
         }));
-    batches += batchesOf(computed.length);
     const keys = new Map();
     (computed.length === 0
         ? []
@@ -152,7 +145,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         }
     });
     const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
-    batches += batchesOf(carried.length);
     const types = queries.typesAt(carried.map((flow) => flow.value), cap);
     /** The members a position may read structurally: those of object types, not of classes. */
     const readable = (member) => [
@@ -198,11 +190,9 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (elements.has(type.id)) {
             return elements.get(type.id);
         }
-        lookups += 1;
         const isArray = queries.isArray(type);
         let element;
         if (isAnswered(isArray) && isArray) {
-            lookups += 1;
             const held = queries.typeArguments(type);
             element = isAnswered(held) ? held[0] : undefined;
         }
@@ -216,7 +206,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (known !== undefined) {
             return known;
         }
-        lookups += type.isTypeReference() ? 1 : 0;
         const held = queries.typeArguments(type);
         const found = isAnswered(held) ? held : [];
         argumentsOf.set(type.id, found);
@@ -232,18 +221,15 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (known !== undefined) {
             return known;
         }
-        lookups += 1;
         let kind = SignatureKind.Call;
         let signatures = queries.signaturesOf(type, kind);
         if (isAnswered(signatures) && signatures.length === 0) {
-            lookups += 1;
             kind = SignatureKind.Construct;
             signatures = queries.signaturesOf(type, kind);
         }
         const called = (isAnswered(signatures) ? signatures : []).map((signature) => {
             const parameters = signature.parameters.map((_parameter, index) => queries.parameterType(signature, index));
             const result = queries.returnTypeOf(signature);
-            lookups += parameters.length + 1;
             return {
                 kind,
                 parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
@@ -335,7 +321,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         const type = types[index];
         return type === undefined || !isAnswered(type) || !mayCarry(type) ? [] : [{ flow, type }];
     });
-    batches += batchesOf(sourced.length);
     const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
     const reads = [];
     // A literal property writes a position's members once, however many values carry it there.
@@ -408,7 +393,6 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         return known;
     };
     const spreads = literals.flatMap(({ literal, from }) => literal.properties.flatMap((property) => isSpreadAssignment(property) ? [{ value: property.expression, from }] : []));
-    batches += batchesOf(spreads.length);
     const spreadTypes = queries.typesAt(spreads.map((one) => one.value), cap);
     spreads.forEach(({ value, from }, index) => {
         const type = spreadTypes[index];
@@ -426,5 +410,5 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             reads.push({ at: value, from, ids });
         }
     });
-    return { writes, reads, batches, lookups };
+    return { writes, reads };
 }

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

@@ -273,7 +273,7 @@ export const SETTINGS = [
         role: "setting",
         read: true,
         default: [
-            "**/*.test.{ts,tsx,mts,cts}",
+            "**/*.test.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
             "**/*.test-d.{ts,tsx,mts,cts}",
             "**/*.spec-d.{ts,tsx,mts,cts}",
             "**/*.spec.*",
@@ -483,7 +483,10 @@ export const SETTINGS = [
         key: "provenance",
         role: "ignored",
         read: true,
-        value: { type: "string", pattern: "^(default|(repository|central|flag): [^\\r\\n]+)$" },
+        value: {
+            type: "string",
+            pattern: "^(default|(repository|central|flag): ([^\\r\\n]|[\\r\\n])+)$",
+        },
         keyPattern: "^[a-z][a-z_]*(\\.[A-Za-z0-9_]+)*$",
     },
 ];

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

@@ -2,6 +2,7 @@
 export const CONTRACT_VERSION = "8.0.0";
 export const SCHEMA_VERSIONS = ["9.0.0"];
 export const SCHEMA_VERSION = "9.0.0";
+export const FACTS_VERSION = "1.0.0";
 export const CORPUS_VERSION = "6.0.0";
 export const CODE_PREFIX = "DS";
 export const FAMILY_KEY_LENGTH = 4;
@@ -25,16 +26,19 @@ export const LANGUAGE_ROWS = {
         analyzer: "deadset-go",
         markers: ["go.mod"],
         skippedDirectories: ["node_modules", "testdata", "vendor", ".*", "_*"],
+        skippedFiles: ["_*", ".*"],
     },
     ts: {
         analyzer: "deadset-ts",
         markers: ["tsconfig*.json", "jsconfig*.json"],
         skippedDirectories: ["node_modules", ".git"],
+        skippedFiles: ["*.min.js", "*.min.cjs", "*.min.mjs"],
     },
     proto: {
         analyzer: "deadset-proto",
         markers: ["buf.yaml", "buf.work.yaml"],
         skippedDirectories: ["node_modules", "vendor", ".*"],
+        skippedFiles: [],
     },
 };
 export const EXIT_CLEAN = 0;
@@ -441,8 +445,8 @@ export const KIND_ROWS = [
         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.",
+        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 or callee 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 `require()` call as `roots.23` reads one, or a call of `import.meta.resolve`, of `require.resolve`, whatever `require` names, or of `resolve` on another name that is such a `require`, in them, 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",
@@ -708,6 +712,38 @@ export const SYMBOL_SUBJECTS = {
     "configured-declaration": "record",
     edge: "record",
 };
+export const REMEDIES = {
+    declaration: {
+        names: "a declaration",
+        suppressions: ["inline", "ignore", "baseline"],
+        remedy: "delete the symbol, or wire it up so the program uses it",
+    },
+    binding: {
+        names: "an import binding",
+        suppressions: ["inline", "ignore", "baseline"],
+        remedy: "delete the import, or use what it binds",
+    },
+    part: {
+        names: "a part of a declaration",
+        suppressions: ["inline", "ignore", "baseline"],
+        remedy: "remove the part, or use it",
+    },
+    file: {
+        names: "a file",
+        suppressions: [],
+        remedy: "delete the file, name it as a root, or build it in a configuration of the build matrix",
+    },
+    dependency: {
+        names: "a dependency row",
+        suppressions: ["ignore", "baseline"],
+        remedy: "remove the dependency",
+    },
+    record: {
+        names: "a record of deadset's own configuration",
+        suppressions: [],
+        remedy: "correct or remove the record the finding names",
+    },
+};
 export const EXEMPTION_CLASSES = [
     {
         class: "interface-satisfaction",
@@ -1220,6 +1256,86 @@ export const EVIDENCE = [
         codes: ["DS1801", "DS1802", "DS1803", "DS1804", "DS1805"],
     },
 ];
+/** The generators whose TypeScript output a generated file is matched against, in the document's order. */
+export const GENERATORS = [
+    {
+        id: "protoc-gen-es-2",
+        plugin: "protoc-gen-es",
+        header: "^// @generated by protoc-gen-es v2\\.",
+        versions: { min: "v2.10.0", max: "v2.16.0" },
+        cell: "exact",
+    },
+    {
+        id: "protoc-gen-es-2-fallback",
+        plugin: "protoc-gen-es",
+        header: "^// @generated by protoc-gen-es v2\\.",
+        cell: "fallback",
+    },
+    {
+        id: "protoc-gen-es-1",
+        plugin: "protoc-gen-es",
+        header: "^// @generated by protoc-gen-es v1\\.",
+        cell: "exact",
+    },
+    {
+        id: "protoc-gen-connect-es-1",
+        plugin: "protoc-gen-connect-es",
+        header: "^// @generated by protoc-gen-connect-es v1\\.",
+        cell: "exact",
+    },
+    {
+        id: "ts-proto-2-output-schema",
+        plugin: "ts-proto",
+        header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+        versions: { min: "v2.11.4", max: "v2.15.0" },
+        cell: "exact",
+    },
+    {
+        id: "ts-proto-2",
+        plugin: "ts-proto",
+        header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+        versions: { min: "v2.11.4", max: "v2.15.0" },
+        cell: "rpc-types-fallback",
+    },
+    {
+        id: "ts-proto-2-types",
+        plugin: "ts-proto",
+        header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+        versions: { min: "v2.11.4", max: "v2.15.0" },
+        cell: "fallback",
+    },
+    {
+        id: "ts-proto-2-fallback",
+        plugin: "ts-proto",
+        header: "^// Code generated by protoc-gen-ts_proto\\. DO NOT EDIT\\.$",
+        cell: "fallback",
+    },
+    {
+        id: "protoc-gen-js",
+        plugin: "protoc-gen-js",
+        header: "^// GENERATED CODE -- DO NOT EDIT!$",
+        cell: "fallback",
+    },
+    {
+        id: "protoc-gen-grpc-web",
+        plugin: "protoc-gen-grpc-web",
+        header: "^// Code generated by protoc-gen-grpc-web\\. DO NOT EDIT\\.$",
+        cell: "fallback",
+    },
+    {
+        id: "protobuf-ts",
+        plugin: "protobuf-ts",
+        header: "^// @generated by protobuf-ts ",
+        cell: "fallback",
+    },
+    { id: "ts-protoc-gen", plugin: "ts-protoc-gen", header: "^// package: ", cell: "fallback" },
+    {
+        id: "protoc-gen-es-unsupported",
+        plugin: "protoc-gen-es",
+        header: "^// @generated by protoc-gen-es v(?:0|[3-9]|[1-9][0-9]+)\\.",
+        cell: "unsupported",
+    },
+];
 /** Each group of failure classes, and the text opening the line that names one of its failures. */
 export const FAILURE_PREFIXES = { setup: "setup failure: ", run: "run failure: " };
 /** Each failure class the Contract names, and its group. */
@@ -1230,6 +1346,7 @@ export const FAILURE_CLASSES = {
     "workspace-member-without-source": "setup",
     "convention-not-literal": "setup",
     "no-program": "setup",
+    "unreadable-configuration": "setup",
     "unreadable-document": "setup",
     "missing-import-path": "setup",
     "binding-undecodable": "setup",

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

@@ -43,6 +43,11 @@ export const REPORT_SCHEMAS = {
                 },
                 else: { properties: { configurations: { minItems: 1 }, target: { required: ["kind"] } } },
             },
+            {
+                if: { required: ["merged_from"], properties: { merged_from: { maxItems: 0 } } },
+                then: { properties: { analyzer: { properties: { languages: { maxItems: 0 } } } } },
+                else: { properties: { analyzer: { properties: { languages: { minItems: 1 } } } } },
+            },
         ],
         properties: {
             schema_version: { type: "string", pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+$" },
@@ -59,7 +64,6 @@ export const REPORT_SCHEMAS = {
                     },
                     languages: {
                         type: "array",
-                        minItems: 1,
                         uniqueItems: true,
                         items: { type: "string", enum: ["go", "ts", "proto"] },
                     },
@@ -95,7 +99,7 @@ export const REPORT_SCHEMAS = {
                             pattern: "^[0-9]+\\.[0-9]+\\.[0-9]+(-[0-9A-Za-z.-]+)?(\\+[0-9A-Za-z.-]+)?$",
                         },
                         digest: { type: "string", pattern: "^sha256:[0-9a-f]{64}$" },
-                        languages: { $ref: "#/properties/analyzer/properties/languages" },
+                        languages: { $ref: "#/properties/analyzer/properties/languages", minItems: 1 },
                         totals: { $ref: "#/properties/totals" },
                     },
                 },

package/dist/src/dependencies.js

@@ -7,15 +7,19 @@
  * itself is that dependency's need, not the target's.
  */
 import { isArrayLiteralExpression, isCallExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { amdLoadOf, amdPlatform } from "./amd.js";
 import { automaticTypes } from "./automatic-types.js";
-import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, outsideChain, } from "./configuration-files.js";
+import { declaredIn as declaredBeside, dependenciesNamed, moduleStrings, outsideChain, } from "./entries/configuration-files.js";
+import { declarationBindings } from "./import-bindings.js";
 import { nodeKey } from "./inventory.js";
 import { packageScope } from "./load/package-scope.js";
-import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, } from "./paths.js";
+import { ancestors, cannotStartPackageName, dirnamePath, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
-import { manifestCommands, nodemonTexts } from "./manifest.js";
-import { commandFileTexts, workflowCommands } from "./workflow-steps.js";
+import { manifestCommands, nodemonTexts } from "./roots/manifest.js";
+import { writtenName } from "./platform-calls.js";
+import { callsPlatform } from "./platform-symbols.js";
+import { parenthesesRemoved } from "./unwrap.js";
 import { pathsNamed, preloadedPackages, readCommands, } from "./commands/read.js";
 import { heldNames } from "./text/named-files.js";
 import { bytewise } from "./text/compare.js";
@@ -151,7 +155,7 @@ function configurationPackages(host, configFile, options, programPackages, parse
         }
         seen.add(file);
         for (const entry of extendsOf(host, file, parse)) {
-            if (entry.startsWith(".") || isAbsolutePath(entry)) {
+            if (cannotStartPackageName(entry)) {
                 const local = resolvePath(dirnamePath(file), entry);
                 pending.push(local.endsWith(".json") ? local : `${local}.json`);
             }
@@ -176,36 +180,19 @@ function importOf(specifier) {
 }
 /** The local names one import declaration binds. */
 function bindingsOf(node) {
-    if (node === undefined) {
-        return [];
-    }
-    if (isImportEqualsDeclaration(node)) {
-        return [node.name];
-    }
-    if (!isImportDeclaration(node) || node.importClause === undefined) {
-        return [];
-    }
-    const clause = node.importClause;
-    const names = clause.name === undefined ? [] : [clause.name];
-    const bindings = clause.namedBindings;
-    if (bindings !== undefined) {
-        if (bindings.kind === SyntaxKind.NamespaceImport) {
-            names.push(bindings.name);
-        }
-        else {
-            names.push(...bindings.elements.map((element) => element.name));
-        }
-    }
-    return names;
+    return node !== undefined && (isImportDeclaration(node) || isImportEqualsDeclaration(node))
+        ? declarationBindings(node).map((binding) => binding.name)
+        : [];
 }
 /**
  * Every package one project needs, and which declaration each use is written in.
  * One local walk and one batched resolution per file: a use of an import binding is
  * an identifier resolving to the binding's own symbol, so a local declaration that
- * shadows the name is not one. A string of a configuration file uses each dependency
- * the manifest beside the file declares that it spells.
+ * shadows the name is not one. A string of a configuration file, as the entry sources
+ * read them in `configuration`, uses each dependency the manifest beside the file
+ * declares that it spells.
  */
-export function projectNeeds(project, held, host, targetRoot, parse) {
+export function projectNeeds(project, held, host, targetRoot, parse, configuration, workflows) {
     const programPackages = new Set();
     for (const name of project.program.getSourceFileNames()) {
         const named = packageOfPath(name);
@@ -256,7 +243,6 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         return names;
     };
     const files = sourceFilesOf(project, targetRoot);
-    const configuration = configurationFiles(host, targetRoot, files, parse);
     for (const { file, manifestDir } of configuration.modules) {
         const names = declaredAt(joinPath(manifestDir, MANIFEST));
         for (const { node, text } of moduleStrings(file)) {
@@ -271,7 +257,7 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             }
         }
     }
-    const ranFiles = outsideChain(host, targetRoot, files, parse, scriptRunFiles(host, targetRoot, files));
+    const ranFiles = outsideChain(host, targetRoot, files, parse, scriptRunFiles(host, targetRoot, files, workflows));
     for (const { file, manifestDirs } of [...configuration.outside, ...ranFiles]) {
         for (const manifestDir of manifestDirs) {
             const names = declaredAt(joinPath(manifestDir, MANIFEST));
@@ -288,7 +274,7 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
  * workflow step or git hook names, with the target root's: a path `pathsNamed` reads, below the
  * target root and in no `node_modules`.
  */
-function scriptRunFiles(host, targetRoot, files) {
+function scriptRunFiles(host, targetRoot, files, workflows) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const dirs = new Set([root]);
     for (const name of files.byName.keys()) {
@@ -300,12 +286,7 @@ function scriptRunFiles(host, targetRoot, files) {
         }
     }
     const named = new Map([
-        [
-            root,
-            workflowReadings(host, root)
-                .flatMap(pathsNamed)
-                .map((one) => one.path),
-        ],
+        [root, workflows.readings.flatMap(pathsNamed).map((one) => one.path)],
     ]);
     for (const dir of dirs) {
         const read = readDocument(host, joinPath(dir, MANIFEST));
@@ -341,19 +322,9 @@ function manifestUses(host, dir, manifest) {
     return { ...uses, held: [uses.held, ...texts].join("\n") };
 }
 /** What the target root's workflow steps, git hooks and recipes use, held with their files' whole text. */
-function workflowUses(host, targetRoot) {
-    const uses = usesOf(workflowReadings(host, targetRoot));
-    return { ...uses, held: [uses.held, ...commandFileTexts(host, targetRoot)].join("\n") };
-}
-/**
- * What the target root's workflow steps, git hooks, hook managers and recipes run, each held
- * with the directory the file writes for it.
- */
-function workflowReadings(host, targetRoot) {
-    return workflowCommands(host, targetRoot).map(({ text, dir, writtenDirectory }) => {
-        const reading = readCommands(text, dir);
-        return { ...reading, held: [reading.held, writtenDirectory ?? ""].join("\n") };
-    });
+function workflowUses(workflows) {
+    const uses = usesOf(workflows.readings);
+    return { ...uses, held: [uses.held, ...workflows.texts].join("\n") };
 }
 function usesOf(readings) {
     return {
@@ -439,7 +410,16 @@ function fileNeeds(project, held, file, { programPackages, automatic }, use) {
     if (names.size > 0 || automatic.globals.size > 0) {
         visit(file);
     }
-    const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates, ...globals];
+    const loads = runtimeLoads(file);
+    const callees = loads.flatMap((load) => load.callees);
+    const amdCallees = new Set(loads.flatMap((load) => (load.amd ? load.callees : [])));
+    const asked = [
+        ...specifiers,
+        ...bindings.map(({ node }) => node),
+        ...candidates,
+        ...globals,
+        ...callees,
+    ];
     const handles = asked.map((node) => project.handle(node));
     const resolved = project.symbolsAt(handles);
     const packagesOf = new Map();
@@ -510,33 +490,80 @@ function fileNeeds(project, held, file, { programPackages, automatic }, use) {
     for (const reference of file.typeReferenceDirectives) {
         use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
     }
-    for (const specifier of resolvedSpecifiers(file)) {
-        const named = packageOfSpecifier(specifier.text);
-        if (named !== undefined) {
+    // A callee the checker leaves unanswered may be a require, so its call holds the
+    // dependency it names by live code, as program.33 holds one.
+    const calleesAt = unresolvedAt + globals.length;
+    const decided = new Map();
+    const requires = new Set();
+    const unansweredCallees = new Set();
+    callees.forEach((callee, index) => {
+        const symbol = resolved[calleesAt + index];
+        if (symbol === UNANSWERED) {
+            unansweredCallees.add(callee);
+            return;
+        }
+        // The decision reads the callee's symbol, its written name and its platform name, and nothing else.
+        const platform = amdCallees.has(callee) ? amdPlatform(callee) : "require";
+        const key = symbol === undefined ? undefined : `${symbol.id}\u0000${platform}\u0000${callee.text}`;
+        const answer = (key === undefined ? undefined : decided.get(key)) ??
+            callsPlatform(project, platform, callee, symbol);
+        if (key !== undefined) {
+            decided.set(key, answer);
+        }
+        if (answer) {
+            requires.add(callee);
+        }
+    });
+    for (const { specifier, named, callees: through } of loads) {
+        if (through.length === 0 || through.some((one) => requires.has(one))) {
             use(ownersOf(file, held, specifier), [named]);
         }
+        else if (through.some((one) => unansweredCallees.has(one))) {
+            use([PROJECT_OWNER], [named]);
+        }
     }
     return resolved.slice(0, specifiers.length).includes(UNANSWERED);
 }
 /**
- * The literal specifiers one file asks the runtime to resolve, through `import.meta.resolve`
- * or `require.resolve`, each of which needs the package it names installed.
+ * The calls one file may load or resolve a package with at run time, each of whose first
+ * argument is literal text naming a package: a `require()` call, which the compiler lists among
+ * a file's imports only in a JavaScript file and only through the bare name; a `.resolve` of
+ * another name, which needs it where that name is a `require`; and `import.meta.resolve` or
+ * a `.resolve` of the name `require`, whatever it names, a use where it stands; and each id of
+ * an AMD dependency list (references-ts.37), which needs it where the call is AMD's.
  */
-function resolvedSpecifiers(file) {
+function runtimeLoads(file) {
     const found = [];
-    if (!file.text.includes(".resolve(")) {
-        return found;
-    }
     const visit = (node) => {
-        if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
-            const callee = node.expression;
+        const amd = amdLoadOf(node);
+        if (amd !== undefined) {
+            for (const { id } of amd.ids) {
+                const named = packageOfSpecifier(id.text);
+                if (named !== undefined) {
+                    found.push({ specifier: id, named, callees: [amd.callee], amd: true });
+                }
+            }
+        }
+        else if (isCallExpression(node)) {
             const [argument] = node.arguments;
-            const receiver = callee.expression;
-            const resolving = callee.name.text === "resolve" &&
-                ((isMetaProperty(receiver) && receiver.name.text === "meta") ||
-                    (isIdentifier(receiver) && receiver.text === "require"));
-            if (resolving && argument !== undefined && isLiteralText(argument)) {
-                found.push(argument);
+            if (argument !== undefined && isLiteralText(argument)) {
+                const named = packageOfSpecifier(argument.text);
+                const callee = parenthesesRemoved(node.expression);
+                const receiver = isPropertyAccessExpression(callee) && callee.name.text === "resolve"
+                    ? parenthesesRemoved(callee.expression)
+                    : undefined;
+                const stands = receiver !== undefined &&
+                    ((isMetaProperty(receiver) && receiver.name.text === "meta") ||
+                        (isIdentifier(receiver) && receiver.text === "require"));
+                const callees = stands
+                    ? []
+                    : [
+                        writtenName(callee),
+                        receiver === undefined ? undefined : writtenName(receiver),
+                    ].filter((one) => one !== undefined);
+                if (named !== undefined && (stands || callees.length > 0)) {
+                    found.push({ specifier: argument, named, callees, amd: false });
+                }
             }
         }
         node.forEachChild(visit);
@@ -727,7 +754,7 @@ function addNeededPeers(declared, peers, needed, ran) {
  * manifest declares nothing, nor does a nested package's uninstalled dependency, because
  * no run requires a nested package to be installed.
  */
-export function dependenciesOf(host, targetRoot, perProject, candidates, members = [], unbuiltMembers = [], nested = []) {
+export function dependenciesOf(host, targetRoot, workflows, perProject, candidates, members = [], unbuiltMembers = [], nested = []) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const scopeOf = packageScope(host, targetRoot);
     const manifests = new Map([[root, MANIFEST]]);
@@ -744,7 +771,7 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             unbuilt.add(path);
         }
     }
-    const workflow = workflowUses(host, targetRoot);
+    const workflow = workflowUses(workflows);
     const declared = [];
     const ran = new Set();
     const peers = new Map();