@cplieger/deadset-ts 8.0.0-dev.14 → 8.0.0-dev.16

package/dist/src/position.js

@@ -25,6 +25,47 @@ export function isComponentFile(file) {
 export function writtenLength(file) {
     return isComponentFile(file) ? file.originalText.length : file.text.length;
 }
+/** Whether one character ends a line, under the language's line terminators. */
+function endsLine(char) {
+    return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
+}
+/** The offset where the line holding `from` ends. */
+export function lineEnd(text, from) {
+    let at = from;
+    while (at < text.length && !endsLine(text[at])) {
+        at += 1;
+    }
+    return at;
+}
+/**
+ * The offset of the first token at or after `from`: whitespace, comments and a leading
+ * hashbang are trivia.
+ */
+export function tokenStart(text, from) {
+    let at = from;
+    if (at === 0 && text.startsWith("#!")) {
+        at = lineEnd(text, 0);
+    }
+    for (;;) {
+        if (/\s/u.test(text[at] ?? "")) {
+            at += 1;
+        }
+        else if (text.startsWith("//", at)) {
+            at = lineEnd(text, at);
+        }
+        else if (text.startsWith("/*", at)) {
+            const close = text.indexOf("*/", at + 2);
+            at = close < 0 ? text.length : close + 2;
+        }
+        else {
+            return at;
+        }
+    }
+}
+/** The line, counted from one, of the first token at or after one offset of one file. */
+export function startLine(file, offset) {
+    return file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+}
 /**
  * The position of one offset of one file, rendered against the target root.
  *

package/dist/src/ref.js

@@ -1,13 +1,9 @@
 /**
- * The stable symbol reference: the identifier that names one declaration across
- * runs, across reports, in an ignore entry, in a configured root and in a
- * cross-language edge. It is built from names and containers only, so an edit above
- * a declaration leaves it unchanged, and it is compared as bytes, so there is one
- * canonical spelling per declaration and this module is where that spelling is
- * written.
- *
- * The position key of {@link ./position.ts} is the other identifier and has the
- * other job: it locates a finding inside one run, and the two never mix.
+ * The stable symbol reference: the identifier that names one declaration across runs,
+ * reports, ignore entries, configured roots and cross-language edges. It is built from
+ * names and containers only, so an edit above a declaration leaves it unchanged, and it
+ * is compared as bytes, so this module writes the one canonical spelling. The position
+ * key of {@link ./position.ts} locates a finding inside one run; the two never mix.
  */
 /** The language prefix, which namespaces every reference this analyzer emits. */
 const PREFIX = "ts://";
@@ -30,16 +26,10 @@ const TS_FILE = String.raw `${TS_DIRS}[^/#\r\n]+(?:(?:\.d)?\.[mc]?ts|\.tsx|\.[mc
 const SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_FILE}`;
 const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_DIRS}package\\.json`;
 /**
- * One expression per form the grammar defines, each anchored and each the whole of
- * a reference. Several forms share one expression because they differ in what the
- * symbol is rather than in how the reference is spelled, so the list is the set of
- * spellings and not the set of subjects. A reference is valid when it matches one.
- *
- * They are written here rather than read from the Contract at run time: the Contract
- * is data a reader outside this program consults, and a product that read it while
- * running would need it installed beside itself. A test compares this list against
- * the release this analyzer is written against, so a grammar that grows a form
- * arrives here as a failing test.
+ * One anchored expression per spelling the grammar defines; a reference is valid when it
+ * matches one. They are written here rather than read from the Contract at run time, so
+ * the product needs no Contract installed beside it; a test compares this list against
+ * the release this analyzer implements, so a grammar that grows a form fails it.
  */
 export const REF_EXPRESSIONS = [
     `^${SCOPE}#$`,
@@ -102,7 +92,8 @@ export function aliasFragment(name, block) {
     const head = block === undefined ? "" : `${quoted(block)}.`;
     return `${head}${nameComponent(name)}:alias`;
 }
-function spell(component) {
+/** The canonical spelling of one component: a name, or a computed key. */
+export function spell(component) {
     return component.computed ? computedComponent(component.text) : nameComponent(component.text);
 }
 /**

package/dist/src/references.js

@@ -1,11 +1,11 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isStringLiteralLikeNode, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
 import { parenthesesRemoved } from "./unwrap.js";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
-import { specifierCandidates } from "./configuration-files.js";
+import { specifierCandidates } from "./entries/configuration-files.js";
 import { namespaceUses } from "./namespace-objects.js";
-import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
+import { isParameterProperty, nodeKey } from "./inventory.js";
 import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
@@ -13,11 +13,15 @@ import { keyofComparisonReferences } from "./keyof-comparisons.js";
 import { unimplementedCalleeReads } from "./unimplemented-callees.js";
 import { moduleDeclarationReferences } from "./module-declarations.js";
 import { overrideReferences } from "./overrides.js";
-import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, queriedModulePath, relativePath, relativeURLPath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile, renderPosition } from "./position.js";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
+import { sourceFilesOf } from "./source-files.js";
 import { typeParameterReads } from "./type-parameter-reads.js";
 import { typeQueryAliases } from "./type-query-alias.js";
+import { callsPlatform, isPlatformGlobal, startsThread } from "./platform-symbols.js";
+import { writtenName } from "./platform-calls.js";
+import { computedLoadsOf, isLoadCall } from "./roots/unseen-loads.js";
 import { computedKeyNames, iterationReferences, keyNameOf, keyedUses, } from "./symbol-keys.js";
 import { handedOn, valuesOf } from "./value-flow.js";
 import { bytewise } from "./text/compare.js";
@@ -183,25 +187,23 @@ function isImportMetaURL(node) {
 }
 /** The module URL one node builds, where it builds one. */
 function moduleURLOf(node) {
-    const relative = (argument) => {
+    const literal = (argument) => {
         const at = argument === undefined ? undefined : parenthesesRemoved(argument);
-        return at !== undefined &&
-            (isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at)) &&
-            /^\.\.?\//u.test(at.text)
-            ? at.text
-            : undefined;
+        return isLiteralText(at) ? at.text : undefined;
     };
-    if (isNewExpression(node) && isIdentifier(node.expression) && node.expression.text === "URL") {
+    const constructor = isNewExpression(node) ? writtenName(node.expression) : undefined;
+    if (isNewExpression(node) && constructor !== undefined) {
         const [reference, base] = node.arguments ?? [];
-        const specifier = relative(reference);
+        const specifier = literal(reference);
         return specifier !== undefined && base !== undefined && isImportMetaURL(base)
-            ? { specifier, constructor: node.expression, at: node }
+            ? { specifier, constructor, at: node }
             : undefined;
     }
     if (isCallExpression(node)) {
         const callee = parenthesesRemoved(node.expression);
-        const specifier = relative(node.arguments[0]);
+        const specifier = literal(node.arguments[0]);
         if (specifier !== undefined &&
+            /^\.\.?\//u.test(specifier) &&
             isPropertyAccessExpression(callee) &&
             isMetaProperty(callee.expression) &&
             callee.expression.keywordToken === SyntaxKind.ImportKeyword &&
@@ -211,6 +213,69 @@ function moduleURLOf(node) {
     }
     return undefined;
 }
+/** The constructors whose first argument addresses a worker. */
+const WORKER_CONSTRUCTORS = new Set(["Worker", "SharedWorker"]);
+/** Whether an options argument is an object literal whose `eval` member is written as anything but `false`. */
+function evaluatesCode(options) {
+    const at = options === undefined ? undefined : parenthesesRemoved(options);
+    return (at !== undefined &&
+        isObjectLiteralExpression(at) &&
+        at.properties.some((property) => (isShorthandPropertyAssignment(property) &&
+            isIdentifier(property.name) &&
+            property.name.text === "eval") ||
+            (isPropertyAssignment(property) &&
+                (isIdentifier(property.name) || isStringLiteral(property.name)) &&
+                property.name.text === "eval" &&
+                parenthesesRemoved(property.initializer).kind !== SyntaxKind.FalseKeyword)));
+}
+/** The worker one node starts by a literal address, where it starts one. */
+function workerOf(node) {
+    if (isNewExpression(node)) {
+        const constructor = writtenName(node.expression);
+        const [address, options] = node.arguments ?? [];
+        const literal = address === undefined ? undefined : parenthesesRemoved(address);
+        // A thread's constructor may be imported under another name, whose path is relative.
+        if (constructor === undefined ||
+            !isLiteralText(literal) ||
+            (!WORKER_CONSTRUCTORS.has(constructor.text) && !/^\.\.?\//u.test(literal.text))) {
+            return undefined;
+        }
+        const callee = parenthesesRemoved(node.expression);
+        const holder = isPropertyAccessExpression(callee)
+            ? parenthesesRemoved(callee.expression)
+            : undefined;
+        return {
+            address: literal,
+            constructor,
+            holder: holder !== undefined && isIdentifier(holder) ? holder : undefined,
+            evaluated: evaluatesCode(options),
+            at: node,
+        };
+    }
+    if (!isCallExpression(node)) {
+        return undefined;
+    }
+    const callee = parenthesesRemoved(node.expression);
+    const registry = isPropertyAccessExpression(callee) && callee.name.text === "register"
+        ? parenthesesRemoved(callee.expression)
+        : undefined;
+    const navigator = registry !== undefined &&
+        isPropertyAccessExpression(registry) &&
+        registry.name.text === "serviceWorker"
+        ? writtenName(registry.expression)
+        : undefined;
+    const [address] = node.arguments;
+    const literal = address === undefined ? undefined : parenthesesRemoved(address);
+    return navigator?.text === "navigator" && isLiteralText(literal)
+        ? { address: literal, constructor: navigator, holder: undefined, evaluated: false, at: node }
+        : undefined;
+}
+/** The file of the target a relative specifier written in `file` names, by its source or output name. */
+function fileNamed(file, specifier, fileIdByName) {
+    return specifierCandidates(dirnamePath(file.fileName), specifier)
+        .map((path) => fileIdByName.get(path))
+        .find((id) => id !== undefined);
+}
 /** Whether one node is a string literal or a template literal with no substitution. */
 function isLiteralText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -218,10 +283,33 @@ function isLiteralText(node) {
 /**
  * The module specifier of the module one node evaluates, if it evaluates one: an import
  * declaration, an import-equals declaration of an external module, an export
- * declaration that names a module, and an `import()` call whose argument is literal
- * text. A type-only form evaluates nothing. An `import()` of a computed argument names
- * no module this pass can know.
+ * declaration that names a module, an `import()` call whose argument is literal text, and
+ * a call that may be a `require()` of literal text: one written as the name `require`, or
+ * one of a relative specifier through another name. A type-only form evaluates nothing.
+ * An `import()` of a computed argument names no module this pass can know.
  */
+function evaluationOf(node) {
+    if (isCallExpression(node) && node.expression.kind !== SyntaxKind.ImportKeyword) {
+        const [argument] = node.arguments;
+        const require = writtenName(node.expression);
+        if (require === undefined ||
+            !isLiteralText(argument) ||
+            (require.text !== "require" && !/^\.\.?\//u.test(argument.text))) {
+            return undefined;
+        }
+        return { node: argument, require, whole: !discarded(node) };
+    }
+    const specifier = evaluatedBy(node);
+    return specifier === undefined ? undefined : { node: specifier };
+}
+/** Whether an expression's value is thrown away: it is a statement of its own, or `void`'s operand. */
+function discarded(expression) {
+    let at = expression.parent;
+    while (isParenthesizedExpression(at)) {
+        at = at.parent;
+    }
+    return isExpressionStatement(at) || isVoidExpression(at);
+}
 function evaluatedBy(node) {
     if (isImportDeclaration(node)) {
         return node.importClause?.phaseModifier === SyntaxKind.TypeKeyword
@@ -330,6 +418,8 @@ function sitesOf(file, declarations, fileId, unread) {
     const evaluations = [];
     const wholes = [];
     const urls = [];
+    const workers = [];
+    const loadCalls = [];
     const decorated = [];
     const parameterWrites = [];
     const namespaces = namespaceUses(file);
@@ -405,13 +495,20 @@ function sitesOf(file, declarations, fileId, unread) {
             reads.push({ ...read, from: enclosing });
         }
         links.push(...linksOf(file, node, declarations, enclosing));
-        const evaluated = evaluatedBy(node);
+        const evaluated = evaluationOf(node);
         if (evaluated !== undefined) {
-            evaluations.push({ node: evaluated, from: enclosing });
+            evaluations.push({ ...evaluated, from: enclosing });
         }
         const url = moduleURLOf(node);
         if (url !== undefined) {
-            urls.push(url);
+            urls.push({ ...url, from: enclosing });
+        }
+        const worker = workerOf(node);
+        if (worker !== undefined) {
+            workers.push({ ...worker, from: enclosing });
+        }
+        if (isLoadCall(node)) {
+            loadCalls.push({ call: node, from: enclosing });
         }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
@@ -445,6 +542,8 @@ function sitesOf(file, declarations, fileId, unread) {
         evaluations,
         wholes,
         urls,
+        workers,
+        loadCalls,
         decorated,
         parameterWrites,
         keyed,
@@ -611,20 +710,12 @@ function aloneIn(file, uses, writes, found) {
     return result;
 }
 /**
- * Every reference one project's own files make to the project's own declarations, in
- * position order, and the files the test-file rules classified.
- *
- * `held` is the inventory of the same project, whose declaration map is what a resolved
- * symbol is looked up in; `targetRoot` is the absolute path every position is rendered
- * against, which is the root the inventory was read against. A pass over a consumer
- * walks the consumer's files instead and renders against its root, as
- * {@link ReferenceOptions.consumer} states.
- *
- * The order is by the referencing position, then by the declaration named, the
- * declaration referencing it and the use. That is a total order because one name
- * references one declaration once from one declaration, while a chain of aliases reaches
- * several declarations at one position and a bare star re-export's specifier both reads
- * and evaluates the module it names.
+ * Every reference one project's own files make to its own declarations, and the files the
+ * test-file rules classified. `held` is the same project's inventory, where a resolved symbol
+ * is looked up; positions render against `targetRoot`, or a consumer's root as
+ * {@link ReferenceOptions.consumer} states. The order is by position, then the declaration
+ * named, the referencing declaration and the use: an alias chain or a bare star re-export
+ * names several at one position, and one name references one declaration once.
  */
 export function references(project, held, targetRoot, options) {
     const cap = options.batchCap ?? DEFAULT_BATCH_CAP;
@@ -638,6 +729,10 @@ export function references(project, held, targetRoot, options) {
     let batched = 0;
     let fileBatches = 0;
     let residueFallbacks = 0;
+    let platformLookups = 0;
+    const asked = () => {
+        platformLookups += 1;
+    };
     let shorthandLookups = 0;
     const consumer = options.consumer;
     const root = consumer?.root ?? targetRoot;
@@ -673,6 +768,8 @@ export function references(project, held, targetRoot, options) {
         }
         return moduleBodies.get(moduleId) ?? [];
     };
+    let ownFiles;
+    const unseenLoads = [];
     const exportsCache = new Map();
     /**
      * Every declaration one module exports, each re-export walked along its chain. A module
@@ -716,7 +813,7 @@ export function references(project, held, targetRoot, options) {
      * live. A name a namespace import binds may be a use of any file.
      */
     const named = (node) => {
-        const byName = declarationsByName(held);
+        const byName = held.byName;
         const text = node.getText();
         const imported = importedNames(node.getSourceFile()).get(text) ?? [];
         return [
@@ -740,7 +837,7 @@ export function references(project, held, targetRoot, options) {
                 return;
             }
             aliased.set(id, symbol === UNANSWERED
-                ? (declarationsByName(held).get(alias.name) ?? []).map((one) => ({
+                ? (held.byName.get(alias.name) ?? []).map((one) => ({
                     id: one,
                     stepped: true,
                     guessed: true,
@@ -783,6 +880,10 @@ export function references(project, held, targetRoot, options) {
         return { file, fileId, ...sitesOf(file, declarations, fileId, unread) };
     });
     const fileIdByName = new Map(walked.filter((one) => fileIds.has(one.fileId)).map((one) => [one.file.fileName, one.fileId]));
+    const loadable = walked
+        .filter((one) => fileIds.has(one.fileId))
+        .map(({ file, fileId }) => ({ file, fileId }));
+    const loadableById = new Map(loadable.map((one) => [one.fileId, one.file]));
     const contextual = contextualUses(project, held, chains, walked.flatMap((one) => one.literals), walked.flatMap((one) => one.flows), cap, tables);
     const writtenBy = new Map();
     for (const write of contextual.writes) {
@@ -862,8 +963,9 @@ export function references(project, held, targetRoot, options) {
         }
     }
     const keyNames = computedKeyNames(held.symbols);
-    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated, parameterWrites, keyed, } of walked) {
+    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, workers, loadCalls, decorated, parameterWrites, keyed, } of walked) {
         const test = testFile.get(file) === true;
+        const loads = computedLoadsOf(file, loadCalls, loadable, (fileName) => options.directories.bundlerRootOf(fileName));
         // A component file's markup may use any binding its blocks declare at the top level.
         const markup = isComponentFile(file);
         const bindings = markup ? importBindings(file) : [];
@@ -900,10 +1002,20 @@ export function references(project, held, targetRoot, options) {
             ...new Set([
                 ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
                 ...links.map((link) => link.node),
-                ...evaluations.map((evaluation) => evaluation.node),
+                ...evaluations.flatMap((evaluation) => evaluation.require === undefined
+                    ? [evaluation.node]
+                    : [
+                        evaluation.require,
+                        ...(evaluation.require.text === "require" ? [evaluation.node] : []),
+                    ]),
                 ...wholes.map((whole) => whole.specifier),
                 ...urls.flatMap((url) => url.constructor ?? []),
+                ...workers.flatMap((worker) => worker.holder === undefined ? [worker.constructor] : [worker.constructor, worker.holder]),
                 ...bindings.map((binding) => binding.node),
+                ...loads.flatMap((load) => [
+                    ...(load.require === undefined ? [] : [load.require]),
+                    ...(load.asset ? [] : load.files.map((loaded) => loaded.file)),
+                ]),
             ]),
         ];
         const answered = new Map();
@@ -939,7 +1051,22 @@ export function references(project, held, targetRoot, options) {
                 });
             }
         }
-        for (const evaluation of evaluations) {
+        const loading = evaluations.filter((one) => one.require === undefined ||
+            callsPlatform(project, "require", one.require, answered.get(one.require), asked));
+        // A script declares no module, so the checker names nothing for a specifier of one;
+        // the compiler's module resolution still names its file.
+        const unnamed = loading.flatMap(({ node }) => answered.get(node) === undefined &&
+            isStringLiteralLikeNode(node) &&
+            queriedFile(file, node, fileIdByName) === undefined
+            ? [node]
+            : []);
+        const resolved = project.resolvedFileNames(unnamed);
+        const scripts = new Map(unnamed.map((node, at) => {
+            const name = resolved[at];
+            return [node, name === undefined ? undefined : fileIdByName.get(name)];
+        }));
+        const wholeReads = [];
+        for (const evaluation of loading) {
             const queried = queriedFile(file, evaluation.node, fileIdByName);
             if (queried !== undefined) {
                 found.push({
@@ -952,6 +1079,28 @@ export function references(project, held, targetRoot, options) {
                 });
             }
             const module = answered.get(evaluation.node);
+            // Node's require resolves a relative specifier the program records no resolution for,
+            // as in a TypeScript file, by its own extension search.
+            const script = scripts.get(evaluation.node) ??
+                (evaluation.require !== undefined &&
+                    module === undefined &&
+                    isLiteralText(evaluation.node) &&
+                    /^\.\.?\//u.test(evaluation.node.text)
+                    ? fileNamed(file, evaluation.node.text, fileIdByName)
+                    : undefined);
+            if (script !== undefined && evaluation.whole === true && module === undefined) {
+                wholeReads.push({ evaluation, fileId: script });
+            }
+            if (script !== undefined) {
+                found.push({
+                    from: evaluation.from,
+                    to: script,
+                    position: renderPosition(file, root, evaluation.node.getStart()),
+                    use: "evaluation",
+                    resolution: "syntax",
+                    test,
+                });
+            }
             if (module === undefined) {
                 continue;
             }
@@ -971,21 +1120,37 @@ export function references(project, held, targetRoot, options) {
                 }
             }
         }
+        // A required file the checker names no module for is read whole where the call's value
+        // is used: the value is the file's exports object, which this pass does not follow.
+        const required = wholeReads.flatMap((one) => {
+            const loaded = loadableById.get(one.fileId);
+            return loaded === undefined ? [] : [{ ...one, loaded }];
+        });
+        const modules = project.symbolsAt(required.map((one) => project.handle(one.loaded)), cap);
+        required.forEach(({ evaluation }, at) => {
+            const module = modules[at];
+            const position = renderPosition(file, root, evaluation.node.getStart());
+            for (const target of module === undefined ? [] : exportsRead(module)) {
+                found.push({
+                    from: evaluation.from,
+                    to: target.id,
+                    position,
+                    use: "read",
+                    resolution: target.guessed ? "by-name" : "batch",
+                    test,
+                });
+            }
+        });
         for (const url of urls) {
-            const constructor = url.constructor === undefined ? undefined : answered.get(url.constructor);
-            // An augmentation of the global `URL` merges into it, which keeps the
-            // library's declaration; a `URL` the target declares has no other.
-            if (typeof constructor === "object" &&
-                constructor.declarations.length > 0 &&
-                constructor.declarations.every((handle) => ownPaths.has(handle.path))) {
+            if (url.constructor !== undefined &&
+                !callsPlatform(project, "URL", url.constructor, answered.get(url.constructor), asked)) {
                 continue;
             }
-            const loaded = specifierCandidates(dirnamePath(file.fileName), url.specifier)
-                .map((path) => fileIdByName.get(path))
-                .find((id) => id !== undefined);
+            const path = relativeURLPath(dirnamePath(file.fileName), url.specifier);
+            const loaded = path === undefined ? undefined : fileNamed(file, path, fileIdByName);
             if (loaded !== undefined) {
                 found.push({
-                    from: fileId,
+                    from: url.from,
                     to: loaded,
                     position: renderPosition(file, root, url.at.getStart()),
                     use: "evaluation",
@@ -994,6 +1159,70 @@ export function references(project, held, targetRoot, options) {
                 });
             }
         }
+        for (const worker of workers) {
+            const symbol = answered.get(worker.constructor);
+            const text = worker.address.text;
+            let path;
+            if (startsThread(project, symbol, worker.holder && answered.get(worker.holder), asked)) {
+                path =
+                    worker.evaluated || !/^\.\.?\//u.test(text)
+                        ? undefined
+                        : resolvePath(options.directories.workingDirectoryOf(file.fileName), text);
+            }
+            else if ((WORKER_CONSTRUCTORS.has(worker.constructor.text) ||
+                worker.constructor.text === "navigator") &&
+                isPlatformGlobal(project, symbol)) {
+                path = relativeURLPath(dirnamePath(file.fileName), text);
+            }
+            ownFiles ??= sourceFilesOf(project, targetRoot);
+            for (const started of path === undefined ? [] : ownFiles.named(path)) {
+                const to = declaredAt(started);
+                if (to !== undefined && fileIds.has(to)) {
+                    found.push({
+                        from: worker.from,
+                        to,
+                        position: renderPosition(file, root, worker.at.getStart()),
+                        use: "evaluation",
+                        resolution: "syntax",
+                        test,
+                    });
+                }
+            }
+        }
+        // A computed load imports each file it loads where the call is written, reading what
+        // the file exports unless it reads the file as text or a URL; callsPlatform owns which
+        // call is a `require`.
+        for (const load of loads) {
+            if (load.require !== undefined &&
+                !callsPlatform(project, "require", load.require, answered.get(load.require), asked)) {
+                continue;
+            }
+            const position = renderPosition(file, root, load.call.getStart());
+            if (!load.resolved && !test && consumer === undefined && !file.isDeclarationFile) {
+                unseenLoads.push(position);
+            }
+            for (const loaded of load.files) {
+                found.push({
+                    from: load.eager ? fileId : load.from,
+                    to: loaded.fileId,
+                    position,
+                    use: "evaluation",
+                    resolution: "syntax",
+                    test,
+                });
+                const module = load.asset ? undefined : answered.get(loaded.file);
+                for (const target of module === undefined ? [] : exportsRead(module)) {
+                    found.push({
+                        from: load.from,
+                        to: target.id,
+                        position,
+                        use: "read",
+                        resolution: target.guessed ? "by-name" : "batch",
+                        test,
+                    });
+                }
+            }
+        }
         for (const whole of wholes) {
             const module = answered.get(whole.specifier);
             if (module === undefined) {
@@ -1060,7 +1289,7 @@ export function references(project, held, targetRoot, options) {
             }
             const position = renderPosition(file, root, read.key.getStart());
             const targets = symbol === UNANSWERED
-                ? (declarationsByName(held).get(read.name) ?? []).map((id) => ({
+                ? (held.byName.get(read.name) ?? []).map((id) => ({
                     id,
                     stepped: false,
                     guessed: true,
@@ -1187,12 +1416,14 @@ export function references(project, held, targetRoot, options) {
             ? found
             : found.map((reference) => ({ ...reference, consumer: consumer.id })),
         testFilePaths: tests.sort(bytewise),
+        unseenLoads,
         cost: {
             batched,
             fileBatches,
             residueFallbacks,
             shorthandLookups,
             aliasSteps: chains.steps,
+            platformLookups,
             patternBatches: destructured.cost.patternBatches,
             patternLookups: destructured.cost.patternLookups,
             contextualBatches: contextual.batches,

package/dist/src/resolve.js

@@ -1,7 +1,7 @@
 import { SETTINGS } from "./contract/config.generated.js";
 import { FAMILY_KEY_LENGTH } from "./contract/contract.generated.js";
 import {} from "./config.js";
-import { CONVENTION_ROWS } from "./convention-rows.js";
+import { CONVENTION_ROWS } from "./entries/convention-rows.js";
 import { refuseOverBound } from "./fs/document.js";
 import { dotted, isRecord, locatedFault, placeIn, pointerOf, readStrict, StrictJSONError, } from "./json-document.js";
 import { FIXED_SEVERITY_CODES } from "./kinds.js";

package/dist/src/{configured-declarations.js → roots/configured-declarations.js}

@@ -6,10 +6,10 @@
  */
 import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { resolvedTargets } from "./calls.js";
-import { declaredComponent } from "./inventory.js";
-import { must, Unanswerable } from "./query.js";
-import { nameComponent } from "./ref.js";
+import { resolvedTargets } from "../calls.js";
+import { declaredComponent } from "../inventory.js";
+import { must, Unanswerable } from "../query.js";
+import { nameComponent } from "../ref.js";
 /** The meanings a name of the global scope is looked up under: any of them. */
 const ANY_MEANING = SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace;
 /** The suffix that marks a static member at the end of a path. */