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

package/dist/src/platform-symbols.js

@@ -0,0 +1,140 @@
+/**
+ * The platform's names read through a program's checker: its `require` and `URL`, as
+ * `platform-calls.ts` decides them, its worker constructors and `navigator`, and Node's
+ * `Worker`.
+ */
+import { isArrowFunction, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isMethodDeclaration, isModuleDeclaration, isPropertyAssignment, isPropertyDeclaration, isSourceFile, isStringLiteralLikeNode, isVariableDeclaration, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { UNANSWERED } from "./query.js";
+import { boundExports, NAMESPACE } from "./entries/static-module.js";
+import { isAmbient } from "./inventory.js";
+import { callsPlatformBy, carriedNames } from "./platform-calls.js";
+import { unwrapped } from "./unwrap.js";
+/** The symbol one symbol names through its aliases, or the symbol itself where it is none. */
+function dealiased(project, symbol, asked) {
+    if ((symbol.flags & SymbolFlags.Alias) === 0) {
+        return symbol;
+    }
+    asked();
+    return project.queries.aliased(symbol);
+}
+/** Each declaration of `symbol` in a file of the target, read in this project's program. */
+function ownDeclarations(project, symbol) {
+    const own = project.ownPaths();
+    return symbol.declarations.flatMap((handle) => {
+        const node = own.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+        return node === undefined ? [] : [node];
+    });
+}
+/**
+ * Whether one declaration writes a function or a class with a body (roots.23): a function
+ * or method declaration with a body, a class declaration, or a variable, a property or a
+ * class field whose initializer is a function, an arrow function or a class expression,
+ * under no `declare` modifier and in no declaration file.
+ */
+function writesBody(node) {
+    const value = (isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)) &&
+        node.initializer !== undefined
+        ? unwrapped(node.initializer)
+        : node;
+    return ((isFunctionDeclaration(value) || isMethodDeclaration(value)
+        ? value.body !== undefined
+        : isFunctionExpression(value) ||
+            isArrowFunction(value) ||
+            isClassDeclaration(value) ||
+            isClassExpression(value)) && !isAmbient(value.getSourceFile(), value));
+}
+/**
+ * What the checker binds `symbol` to, one alias step at a time: every name a step of the
+ * chain carries it by, and the declarations of the target its last step reaches, which
+ * prove it the target's own where one {@link writesBody}. A chain that ends at no
+ * declaration, or that the checker leaves unanswered, reaches none.
+ */
+function boundBy(project, symbol, asked) {
+    if (typeof symbol !== "object") {
+        return undefined;
+    }
+    const names = new Set();
+    const stepped = new Set();
+    for (let at = symbol; at !== undefined && !stepped.has(at.id);) {
+        stepped.add(at.id);
+        names.add(at.name);
+        const own = ownDeclarations(project, at);
+        for (const node of own) {
+            carriedNames(node).forEach((one) => names.add(one));
+        }
+        if ((at.flags & SymbolFlags.Alias) === 0) {
+            return { names, own, provenOwn: own.some(writesBody) };
+        }
+        asked();
+        const next = project.aliasStepOf(at);
+        at = typeof next === "object" ? next : undefined;
+    }
+    return { names, own: [], provenOwn: false };
+}
+/** Each written name's binding, as this project's checker answers it. */
+function checkerBinding(project, asked) {
+    return (written) => {
+        asked();
+        return boundBy(project, project.symbolsAt([project.handle(written)])[0], asked);
+    };
+}
+/**
+ * Whether a call or construction through `callee`, the batch's answer for which is `symbol`,
+ * is one of the platform's `require` or `URL` (roots.23, references-ts.1), as
+ * {@link callsPlatformBy} decides it over this project's checker, each request it puts
+ * counted by `asked`.
+ */
+export function callsPlatform(project, name, callee, symbol, asked) {
+    const others = checkerBinding(project, asked);
+    return callsPlatformBy(name, callee, (written) => written === callee ? boundBy(project, symbol, asked) : others(written));
+}
+/**
+ * Whether a worker's constructor or `navigator`, the batch's answer for which is `symbol`, is
+ * the platform's (references-ts.2): a name the checker leaves unanswered, or one whose symbol
+ * is no alias and has a declaration outside the target's files.
+ */
+export function isPlatformGlobal(project, symbol) {
+    if (symbol === UNANSWERED) {
+        return true;
+    }
+    const own = project.ownPaths();
+    return (symbol !== undefined &&
+        (symbol.flags & SymbolFlags.Alias) === 0 &&
+        symbol.declarations.some((handle) => !own.has(handle.path)));
+}
+/** The module names Node's worker threads are imported by. */
+const THREADS = new Set(["worker_threads", "node:worker_threads"]);
+function namesThreads(node) {
+    return node !== undefined && isStringLiteralLikeNode(node) && THREADS.has(node.text);
+}
+/** Whether one declaration is written in the body of `declare module "worker_threads"`. */
+function inThreadsModule(node) {
+    for (let at = node; !isSourceFile(at); at = at.parent) {
+        if (isModuleDeclaration(at) && namesThreads(at.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether a `Worker` constructor, the batch's answer for which is `symbol`, is Node's
+ * (references-ts.2): its symbol resolves to a declaration of `worker_threads`, or one of its
+ * own declarations binds the module's `Worker`, or `holder`, the namespace it is read
+ * through, binds the module, each binding read as {@link boundExports} reads one, which
+ * decides where the module has no declaration. Each request it puts is counted by `asked`.
+ */
+export function startsThread(project, symbol, holder, asked) {
+    const bindingOf = checkerBinding(project, asked);
+    const declared = (one, member) => typeof one === "object" &&
+        ownDeclarations(project, one).some((node) => boundExports(node, (specifier) => THREADS.has(specifier), bindingOf).includes(member));
+    if (declared(symbol, "Worker") || declared(holder, NAMESPACE)) {
+        return true;
+    }
+    const named = typeof symbol === "object" ? dealiased(project, symbol, asked) : undefined;
+    return (typeof named === "object" &&
+        named.declarations.some((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            return node !== undefined && inThreadsModule(node);
+        }));
+}

package/dist/src/references.js

@@ -3,7 +3,7 @@ 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 { isParameterProperty, nodeKey } from "./inventory.js";
 import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
@@ -13,13 +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 { hasOwnBody } from "./own-body.js";
-import { computedLoadsOf, isLoadCall } from "./unseen-loads.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";
@@ -185,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 &&
@@ -213,6 +213,63 @@ 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)
@@ -226,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
@@ -338,6 +418,7 @@ function sitesOf(file, declarations, fileId, unread) {
     const evaluations = [];
     const wholes = [];
     const urls = [];
+    const workers = [];
     const loadCalls = [];
     const decorated = [];
     const parameterWrites = [];
@@ -414,14 +495,18 @@ 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, from: enclosing });
         }
+        const worker = workerOf(node);
+        if (worker !== undefined) {
+            workers.push({ ...worker, from: enclosing });
+        }
         if (isLoadCall(node)) {
             loadCalls.push({ call: node, from: enclosing });
         }
@@ -457,6 +542,7 @@ function sitesOf(file, declarations, fileId, unread) {
         evaluations,
         wholes,
         urls,
+        workers,
         loadCalls,
         decorated,
         parameterWrites,
@@ -643,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;
@@ -678,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
@@ -791,6 +883,7 @@ export function references(project, held, targetRoot, options) {
     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) {
@@ -870,9 +963,9 @@ export function references(project, held, targetRoot, options) {
         }
     }
     const keyNames = computedKeyNames(held.symbols);
-    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, loadCalls, 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);
+        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) : [];
@@ -909,9 +1002,15 @@ 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]),
@@ -952,9 +1051,11 @@ export function references(project, held, targetRoot, options) {
                 });
             }
         }
+        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 = evaluations.flatMap(({ node }) => answered.get(node) === undefined &&
+        const unnamed = loading.flatMap(({ node }) => answered.get(node) === undefined &&
             isStringLiteralLikeNode(node) &&
             queriedFile(file, node, fileIdByName) === undefined
             ? [node]
@@ -964,7 +1065,8 @@ export function references(project, held, targetRoot, options) {
             const name = resolved[at];
             return [node, name === undefined ? undefined : fileIdByName.get(name)];
         }));
-        for (const evaluation of evaluations) {
+        const wholeReads = [];
+        for (const evaluation of loading) {
             const queried = queriedFile(file, evaluation.node, fileIdByName);
             if (queried !== undefined) {
                 found.push({
@@ -977,7 +1079,18 @@ export function references(project, held, targetRoot, options) {
                 });
             }
             const module = answered.get(evaluation.node);
-            const script = scripts.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,
@@ -1007,12 +1120,34 @@ 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);
-            if (typeof constructor === "object" && hasOwnBody(project, constructor)) {
+            if (url.constructor !== undefined &&
+                !callsPlatform(project, "URL", url.constructor, answered.get(url.constructor), asked)) {
                 continue;
             }
-            const loaded = fileNamed(file, url.specifier, fileIdByName);
+            const path = relativeURLPath(dirnamePath(file.fileName), url.specifier);
+            const loaded = path === undefined ? undefined : fileNamed(file, path, fileIdByName);
             if (loaded !== undefined) {
                 found.push({
                     from: url.from,
@@ -1024,15 +1159,48 @@ 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; hasOwnBody owns which
-        // `require` loads nothing.
+        // 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) {
-            const callee = load.require === undefined ? undefined : answered.get(load.require);
-            if (typeof callee === "object" && hasOwnBody(project, callee)) {
+            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,
@@ -1248,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. */

package/dist/src/{entry-point-gaps.js → roots/entry-point-gaps.js}

@@ -1,13 +1,10 @@
 /**
- * Every entry-point convention this analyzer declines, each with the tool it belongs
- * to and why. A file only a declined convention enters is reported as never
- * imported, so a project that relies on one names the file in `ts.entry_files` or
- * `roots.patterns`, and this list is what tells it to.
- *
- * Every row carries a reason, because the list is read where the rows are shown
- * one at a time: beside a finding, or in a report's declared gaps.
+ * Every entry-point convention this analyzer declines, each with its tool and why. A file only
+ * a declined convention enters is reported as never imported, so a project relying on one names
+ * the file in `ts.entry_files` or `roots.patterns`, and this list tells it to. Every row carries
+ * a reason, since rows are shown one at a time, beside a finding or in a report's declared gaps.
  */
-import { bytewise } from "./text/compare.js";
+import { bytewise } from "../text/compare.js";
 /** What is declined for a tool whose own conventions are entered only through its configuration files. */
 const EVERY_CONVENTION = "every file it loads by its own convention beyond its configuration files";
 /** Why a tool whose own conventions are not read declines them. */

package/dist/src/{manifest.js → roots/manifest.js}

@@ -4,10 +4,10 @@
  * shell running its command or one of its scripts. {@link readManifest} reads one
  * directory's manifest, {@link packageEntries} those of the packages below the target root.
  */
-import { isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
-import { isRecord } from "./json-document.js";
-import { MANIFEST, manifestAt, readJSON } from "./fs/manifest.js";
-import { pathsNamed, readCommands } from "./commands/read.js";
+import { isAbsolutePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { isRecord } from "../json-document.js";
+import { MANIFEST, manifestAt, readJSON } from "../fs/manifest.js";
+import { pathsNamed, readCommands } from "../commands/read.js";
 /** The three members that name an entry point beside `exports` and `bin`. */
 const LEGACY_MEMBERS = ["main", "module", "types"];
 /**