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

package/dist/src/module-declarations.js

@@ -5,11 +5,12 @@
  * to the same module. One that names it by name or pattern also reads the members it
  * imports, whatever file the specifier resolves to, as a compiler reading no such file does.
  */
-import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isImportTypeNode, isLiteralTypeNode, isModuleDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isImportTypeNode, isLiteralTypeNode, isModuleDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { namesImported } from "./import-bindings.js";
 import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { aliasFragment, nameComponent } from "./ref.js";
+import { isPathSpecifier } from "./paths.js";
 /** Whether a node is a specifier's text: a string literal or a template with no substitution. */
 function literalText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -36,32 +37,12 @@ function specifierOf(node) {
     }
     return undefined;
 }
-/**
- * The export names an import or a re-export reads from the module it names: none for a
- * namespace, a star or a bare form.
- */
-export function namesImported(node) {
-    if (isImportDeclaration(node)) {
-        const clause = node.importClause;
-        const bindings = clause?.namedBindings;
-        return [
-            ...(clause?.name === undefined ? [] : ["default"]),
-            ...(bindings === undefined || isNamespaceImport(bindings)
-                ? []
-                : bindings.elements.map((one) => (one.propertyName ?? one.name).text)),
-        ];
-    }
-    const clause = isExportDeclaration(node) ? node.exportClause : undefined;
-    return clause === undefined || isNamespaceExport(clause)
-        ? []
-        : clause.elements.map((one) => (one.propertyName ?? one.name).text);
-}
 /**
  * Whether a specifier matches a declaration's name, the name's one `*` standing for any run.
  * A relative name is resolved against its own file, so no specifier names it by its text.
  */
 function namesModule(specifier, name) {
-    if (/^(?:\.{1,2}(?:\/|$)|\/)/u.test(name)) {
+    if (isPathSpecifier(name)) {
         return false;
     }
     const star = name.indexOf("*");
@@ -107,67 +88,71 @@ function namedBy(held) {
     });
 }
 /**
- * The references the imports of one project's own files make to the module declarations
- * they name, each at the import's specifier.
+ * The reads the imports of a side's files make of the module declarations of the target they
+ * name, each at the import's specifier. A specifier the checker leaves unanswered still names
+ * a declaration by its name or pattern.
  */
-export function moduleDeclarationReferences(project, held, root, testFiles) {
-    const imports = [];
-    const declared = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const own = held.declarations.get(nodeKey(file, node));
-            if (isModuleDeclaration(node) && literalText(node.name) && own !== undefined) {
-                declared.push({ id: own, name: node.name });
-            }
-            const specifier = specifierOf(node);
-            if (specifier !== undefined) {
-                imports.push({ file, from, specifier, names: namesImported(node) });
-            }
-            node.forEachChild((child) => {
-                visit(child, own ?? from);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (declared.length === 0 || imports.length === 0) {
-        return [];
-    }
-    const asked = [...declared.map((one) => one.name), ...imports.map((one) => one.specifier)];
-    const answers = project.symbolsAt(asked.map((node) => project.handle(node)));
-    const moduleOf = (at) => {
-        const symbol = answers[at];
-        return symbol === undefined || symbol === UNANSWERED ? undefined : symbol.id;
-    };
-    const named = namedBy(held);
-    const found = [];
-    imports.forEach((one, index) => {
-        const resolved = moduleOf(declared.length + index);
-        const position = renderPosition(one.file, root, one.specifier.getStart());
-        const read = (to, resolution, test) => {
-            found.push({ from: one.from, to, position, use: "read", resolution, test });
-        };
-        const test = testFiles.has(position.path);
-        const same = new Set(declared
-            .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
-            .map((declaration) => declaration.id));
-        for (const id of same) {
-            read(id, "batch", test);
-        }
-        for (const declaration of named(one.specifier.text, one.names)) {
-            // A wildcard declaration is how the compiler types the file a matching specifier
-            // names, so the import uses it whoever writes it, a test included.
-            if (declaration.wildcard || !same.has(declaration.id)) {
-                for (const to of [declaration.id, ...declaration.members]) {
-                    read(to, "syntax", test && !declaration.wildcard);
+export const moduleDeclarations = {
+    start() {
+        const imports = [];
+        return {
+            visit(node, { file, from }) {
+                const specifier = specifierOf(node);
+                if (specifier !== undefined) {
+                    imports.push({ file, from, specifier, names: namesImported(node) });
                 }
-            }
-        }
-    });
-    return found;
-}
+            },
+            reads({ project, held }) {
+                const found = [];
+                // A module declaration whose name is a string is written at a file's top level.
+                const declared = project.ownSourceFiles().flatMap((file) => file.statements.flatMap((statement) => {
+                    const id = held.declarations.get(nodeKey(file, statement));
+                    return isModuleDeclaration(statement) && literalText(statement.name) && id !== undefined
+                        ? [{ id, name: statement.name }]
+                        : [];
+                }));
+                if (declared.length === 0 || imports.length === 0) {
+                    return found;
+                }
+                const asked = [...declared.map((one) => one.name), ...imports.map((one) => one.specifier)];
+                const answers = project.symbolsAt(asked.map((node) => project.handle(node)));
+                const moduleOf = (at) => {
+                    const symbol = answers[at];
+                    return symbol === undefined || symbol === UNANSWERED ? undefined : symbol.id;
+                };
+                const named = namedBy(held);
+                imports.forEach((one, index) => {
+                    const resolved = moduleOf(declared.length + index);
+                    const read = (to, via, production) => {
+                        found.push({
+                            kind: "named",
+                            from: one.from,
+                            to,
+                            file: one.file,
+                            at: one.specifier,
+                            use: "read",
+                            via,
+                            ...(production ? { production: true } : {}),
+                        });
+                    };
+                    const same = new Set(declared
+                        .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
+                        .map((declaration) => declaration.id));
+                    for (const id of same) {
+                        read(id, "batch", false);
+                    }
+                    for (const declaration of named(one.specifier.text, one.names)) {
+                        // A wildcard declaration is how the compiler types the file a matching specifier
+                        // names, so the import uses it whoever writes it, a test included.
+                        if (declaration.wildcard || !same.has(declaration.id)) {
+                            for (const to of [declaration.id, ...declaration.members]) {
+                                read(to, "syntax", declaration.wildcard);
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};

package/dist/src/overrides.js

@@ -24,121 +24,136 @@ function nameOf(entry) {
     }
     return isQualifiedName(entry.typeName) ? entry.typeName.right : entry.typeName;
 }
-/** Each class of the target whose `extends` clause names a class, with the name node. */
-function extending(project, held) {
-    const found = [];
-    for (const file of project.ownSourceFiles()) {
-        const visit = (node) => {
-            if (isClassDeclaration(node) || isClassExpression(node)) {
-                const id = held.declarations.get(nodeKey(file, node));
-                const clause = node.heritageClauses?.find((one) => one.token === SyntaxKind.ExtendsKeyword);
-                const base = clause?.types[0];
-                if (id !== undefined && base !== undefined) {
-                    found.push({ id, base: nameOf(base) });
-                }
-            }
-            node.forEachChild(visit);
-        };
-        file.forEachChild(visit);
-    }
-    return found;
-}
 /**
- * The references each base class member makes to its overrides, for the classes of one
- * project that extend another class of the target, and each class makes to its members
- * that override a member of a class declared outside the target. A member a nearer base
- * already overrides is reached through that override. A private member is not
- * overridden. Each reference is placed at the override and made by its file.
+ * The reads each base class member makes of its overrides, for the classes of the target that
+ * extend another class of the target, and each class makes of its members that override a
+ * member of a class declared outside the target. A member a nearer base already overrides is
+ * reached through that override. A private member is not overridden. Each read is placed at
+ * the override. A class whose base the checker leaves unanswered holds every member it could
+ * override.
  */
-export function overrideReferences(project, held, chains, testFiles) {
-    const classes = extending(project, held);
-    if (classes.length === 0) {
-        return [];
-    }
-    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
-    const members = new Map();
-    for (const symbol of held.symbols) {
-        const component = memberComponent(symbol, byId);
-        if (component === undefined ||
-            !OVERRIDABLE.has(symbol.kind) ||
-            symbol.visibility === "private" ||
-            symbol.visibility === "private-name") {
-            continue;
-        }
-        const own = members.get(symbol.parent) ?? new Map();
-        own.set(component, symbol);
-        members.set(symbol.parent, own);
-    }
-    const bases = new Map();
-    const outsideBases = new Map();
-    const own = project.ownPaths();
-    const symbols = project.symbolsAt(classes.map((one) => project.handle(one.base)));
-    classes.forEach(({ id }, index) => {
-        const symbol = symbols[index];
-        if (symbol !== undefined && symbol !== UNANSWERED) {
-            const inTarget = chains
-                .chainOf(symbol)
-                .map((target) => target.id)
-                .filter((target) => byId.get(target)?.kind === "class" && target !== id);
-            bases.set(id, inTarget);
-            const declared = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
-            if (inTarget.length === 0 &&
-                declared !== UNANSWERED &&
-                (((declared.flags & SymbolFlags.Class) !== 0 &&
-                    // The target's augmentation of an outside class merges an interface into it,
-                    // so only a class declaration says where the class is.
-                    declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) ||
-                    ((declared.flags & SymbolFlags.Interface) !== 0 &&
-                        declared.declarations.some((handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path))))) {
-                outsideBases.set(id, declared);
-            }
-        }
-    });
-    /** The nearest member of one component the class or a class it extends declares. */
-    const declaredAbove = (classId, component, seen) => {
-        if (seen.has(classId)) {
-            return [];
-        }
-        seen.add(classId);
-        const own = members.get(classId)?.get(component);
-        if (own !== undefined) {
-            return [own.id];
-        }
-        return (bases.get(classId) ?? []).flatMap((base) => declaredAbove(base, component, seen));
-    };
-    const found = [];
-    const outsideNames = outsideMemberNames(project, bases, outsideBases);
-    for (const [classId, names] of outsideNames) {
-        for (const [component, member] of members.get(classId) ?? []) {
-            if (names.has(component)) {
-                found.push({
-                    from: classId,
-                    to: member.id,
-                    position: member.position,
-                    use: "read",
-                    resolution: "override",
-                    test: testFiles.has(member.position.path),
+export const overrides = {
+    start() {
+        const extending = [];
+        return {
+            visit(node, { file }) {
+                if (isClassDeclaration(node) || isClassExpression(node)) {
+                    const clause = node.heritageClauses?.find((one) => one.token === SyntaxKind.ExtendsKeyword);
+                    const base = clause?.types[0];
+                    if (base !== undefined) {
+                        extending.push({ node, file, base: nameOf(base) });
+                    }
+                }
+            },
+            reads({ project, held, chains }) {
+                const found = [];
+                const classes = extending.flatMap((one) => {
+                    const id = held.declarations.get(nodeKey(one.file, one.node));
+                    return id === undefined ? [] : [{ ...one, id }];
                 });
-            }
-        }
-    }
-    for (const [classId, baseIds] of bases) {
-        for (const [component, member] of members.get(classId) ?? []) {
-            const seen = new Set([classId]);
-            for (const base of baseIds.flatMap((one) => declaredAbove(one, component, seen))) {
-                found.push({
-                    from: base,
-                    to: member.id,
-                    position: member.position,
-                    use: "read",
-                    resolution: "override",
-                    test: testFiles.has(member.position.path),
+                if (classes.length === 0) {
+                    return found;
+                }
+                const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+                const members = new Map();
+                for (const symbol of held.symbols) {
+                    const component = memberComponent(symbol, byId);
+                    if (component === undefined ||
+                        !OVERRIDABLE.has(symbol.kind) ||
+                        symbol.visibility === "private" ||
+                        symbol.visibility === "private-name") {
+                        continue;
+                    }
+                    const own = members.get(symbol.parent) ?? new Map();
+                    own.set(component, symbol);
+                    members.set(symbol.parent, own);
+                }
+                const bases = new Map();
+                const outsideBases = new Map();
+                const fileOf = new Map(classes.map((one) => [one.id, one.file]));
+                const own = project.ownPaths();
+                const unanswered = new Set();
+                const symbols = project.symbolsAt(classes.map((one) => project.handle(one.base)));
+                classes.forEach(({ id }, index) => {
+                    const symbol = symbols[index];
+                    if (symbol === UNANSWERED) {
+                        unanswered.add(id);
+                        return;
+                    }
+                    if (symbol === undefined) {
+                        return;
+                    }
+                    const inTarget = chains
+                        .chainOf(symbol)
+                        .map((target) => target.id)
+                        .filter((target) => byId.get(target)?.kind === "class" && target !== id);
+                    bases.set(id, inTarget);
+                    const declared = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
+                    if (declared === UNANSWERED) {
+                        unanswered.add(id);
+                        return;
+                    }
+                    if (inTarget.length === 0 &&
+                        (((declared.flags & SymbolFlags.Class) !== 0 &&
+                            // The target's augmentation of an outside class merges an interface into it,
+                            // so only a class declaration says where the class is.
+                            declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) ||
+                            ((declared.flags & SymbolFlags.Interface) !== 0 &&
+                                declared.declarations.some((handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path))))) {
+                        outsideBases.set(id, declared);
+                    }
                 });
-            }
-        }
-    }
-    return found;
-}
+                /** The nearest member of one component the class or a class it extends declares. */
+                const declaredAbove = (classId, component, seen) => {
+                    if (seen.has(classId)) {
+                        return [];
+                    }
+                    seen.add(classId);
+                    const member = members.get(classId)?.get(component);
+                    if (member !== undefined) {
+                        return [member.id];
+                    }
+                    return (bases.get(classId) ?? []).flatMap((base) => declaredAbove(base, component, seen));
+                };
+                const read = (classId, from, member) => {
+                    const file = fileOf.get(classId);
+                    if (file !== undefined) {
+                        found.push({
+                            kind: "named",
+                            from,
+                            to: member.id,
+                            file,
+                            at: member.position,
+                            use: "read",
+                            via: "override",
+                        });
+                    }
+                };
+                const outside = outsideMemberNames(project, bases, outsideBases);
+                for (const classId of [...unanswered, ...outside.unanswered]) {
+                    const ids = [...(members.get(classId)?.values() ?? [])].map((member) => member.id);
+                    found.push({ kind: "held", from: classId, ids });
+                }
+                for (const [classId, names] of outside.names) {
+                    for (const [component, member] of members.get(classId) ?? []) {
+                        if (names.has(component)) {
+                            read(classId, classId, member);
+                        }
+                    }
+                }
+                for (const [classId, baseIds] of bases) {
+                    for (const [component, member] of members.get(classId) ?? []) {
+                        const seen = new Set([classId]);
+                        for (const base of baseIds.flatMap((one) => declaredAbove(one, component, seen))) {
+                            read(classId, base, member);
+                        }
+                    }
+                }
+                return found;
+            },
+        };
+    },
+};
 /**
  * Per class of the target with a class declared outside the target in its `extends`
  * chain, the member components that outside class's instances and constructor carry, a
@@ -146,10 +161,17 @@ export function overrideReferences(project, held, chains, testFiles) {
  */
 function outsideMemberNames(project, bases, outsideBases) {
     const direct = new Map();
+    const unanswered = [];
     const error = errorType(project);
     for (const [classId, base] of outsideBases) {
         const instance = project.queries.declaredTypeOf(base);
         const statics = project.queries.typeOfSymbol(base);
+        if (instance === UNANSWERED ||
+            statics === UNANSWERED ||
+            project.queries.propertiesOf(instance) === UNANSWERED ||
+            (statics !== undefined && project.queries.propertiesOf(statics) === UNANSWERED)) {
+            unanswered.push(classId);
+        }
         const components = [
             ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
             ...(instance !== UNANSWERED && reaches(project, instance, error) ? ["toString"] : []),
@@ -176,7 +198,7 @@ function outsideMemberNames(project, bases, outsideBases) {
             names.set(classId, found);
         }
     }
-    return names;
+    return { names, unanswered };
 }
 /** The global `Error` instance type's identifier, where the program's library declares one. */
 function errorType(project) {

package/dist/src/paths.js

@@ -8,6 +8,50 @@ const SEPARATOR = "/";
 export function isAbsolutePath(path) {
     return path.startsWith(SEPARATOR);
 }
+/** Whether a specifier starts a path relative to the file that writes it: `./` or `../`. */
+export function startsRelativePath(specifier) {
+    return specifier.startsWith("./") || specifier.startsWith("../");
+}
+/** Whether a specifier names a path relative to the file that writes it: `.`, `..`, `./` or `../` first. */
+export function isRelativeSpecifier(specifier) {
+    return specifier === "." || specifier === ".." || startsRelativePath(specifier);
+}
+/**
+ * Whether a module specifier names a path rather than a package, as the compiler reads one:
+ * a relative specifier or an absolute path.
+ */
+export function isPathSpecifier(specifier) {
+    return isRelativeSpecifier(specifier) || isAbsolutePath(specifier);
+}
+/**
+ * Whether a string starts with `./`, `../` or `/`, the specifiers a browser reads as a URL
+ * rather than a bare name, so a bare `.` or `..` stays a request:
+ * https://html.spec.whatwg.org/multipage/webappapis.html#resolve-a-url-like-module-specifier
+ */
+export function isExplicitPath(text) {
+    return startsRelativePath(text) || isAbsolutePath(text);
+}
+/**
+ * Whether a string starts with `.` or `/`, which no npm package name does, so a reader that
+ * takes any other string as a package's takes it as a path:
+ * https://docs.npmjs.com/cli/v11/configuring-npm/package-json#name
+ */
+export function cannotStartPackageName(text) {
+    return text.startsWith(".") || isAbsolutePath(text);
+}
+/** A URL scheme, `file:` and `node:` among them: https://url.spec.whatwg.org/#url-scheme-string */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
+/** Whether a string starts with a URL scheme. */
+export function hasURLScheme(text) {
+    return URL_SCHEME.test(text);
+}
+/**
+ * Whether a URL reference is a relative one that does not start with a solidus, the bare
+ * name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+export function isPathRelativeURL(reference) {
+    return reference !== "" && !reference.startsWith(SEPARATOR) && !hasURLScheme(reference);
+}
 /**
  * One path with `.` removed, `..` applied to the segment before it, and repeated
  * separators collapsed. A `..` that walks past the root of an absolute path is
@@ -88,17 +132,12 @@ export function extensionOf(path) {
 export function resolvePath(against, path) {
     return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);
 }
-/**
- * A URL reference's scheme. A reference with none that does not start with a solidus is
- * relative, the bare name included: https://url.spec.whatwg.org/#relative-url-string
- */
-const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
 /**
  * The path a relative URL reference names against `dir`, its query and its fragment
  * removed, which name no part of the file; undefined where the reference is not relative.
  */
 export function relativeURLPath(dir, reference) {
-    if (reference === "" || reference.startsWith("/") || URL_SCHEME.test(reference)) {
+    if (!isPathRelativeURL(reference)) {
         return undefined;
     }
     const cut = reference.search(/[?#]/u);
@@ -112,7 +151,7 @@ export function relativeURLPath(dir, reference) {
  */
 export function queriedModulePath(specifier) {
     const query = specifier.indexOf("?");
-    if (query < 0 || !(specifier.startsWith("./") || specifier.startsWith("../"))) {
+    if (query < 0 || !startsRelativePath(specifier)) {
         return undefined;
     }
     const raw = specifier

package/dist/src/platform-calls.js

@@ -1,6 +1,6 @@
 /**
- * Which calls are the platform's `require` and which constructions its `URL` (roots.23,
- * references-ts.1), decided once over the bindings of the names a callee is written with: the
+ * Which calls are the platform's `require` or AMD's `define` and which constructions its `URL`
+ * (roots.23, references-ts.37, references-ts.1), decided once over the bindings of the names a callee is written with: the
  * checker's in a program, the file's own scopes in a module read outside every program.
  */
 import { isBindingElement, isCallExpression, isExportSpecifier, isIdentifier, isImportSpecifier, isPropertyAccessExpression, isStringLiteral, isVariableDeclaration, } from "@typescript/native/ast";

package/dist/src/platform-symbols.js

@@ -11,11 +11,10 @@ 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) {
+function dealiased(project, symbol) {
     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. */
@@ -50,7 +49,7 @@ function writesBody(node) {
  * 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) {
+function boundBy(project, symbol) {
     if (typeof symbol !== "object") {
         return undefined;
     }
@@ -66,28 +65,23 @@ function boundBy(project, symbol, asked) {
         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);
-    };
+function checkerBinding(project) {
+    return (written) => boundBy(project, project.symbolsAt([project.handle(written)])[0]);
 }
 /**
  * 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`.
+ * is one of the platform's `require`, AMD's `define` or `URL` (roots.23, references-ts.37,
+ * references-ts.1), as {@link callsPlatformBy} decides it over this project's checker.
  */
-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));
+export function callsPlatform(project, name, callee, symbol) {
+    const others = checkerBinding(project);
+    return callsPlatformBy(name, callee, (written) => written === callee ? boundBy(project, symbol) : others(written));
 }
 /**
  * Whether a worker's constructor or `navigator`, the batch's answer for which is `symbol`, is
@@ -122,16 +116,16 @@ function inThreadsModule(node) {
  * (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`.
+ * decides where the module has no declaration.
  */
-export function startsThread(project, symbol, holder, asked) {
-    const bindingOf = checkerBinding(project, asked);
+export function startsThread(project, symbol, holder) {
+    const bindingOf = checkerBinding(project);
     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;
+    const named = typeof symbol === "object" ? dealiased(project, symbol) : undefined;
     return (typeof named === "object" &&
         named.declarations.some((handle) => {
             const node = project.declarationAt(handle)?.node;