@cplieger/deadset-ts 7.0.0-dev.2 → 7.0.0-dev.4

package/dist/src/contextual-uses.js

@@ -6,8 +6,8 @@
  * the parameters and results of functions and constructors too; a class instance there is
  * the interface-satisfaction class's evidence instead.
  */
-import { isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, } from "@typescript/native/unstable/ast";
-import { SignatureKind, SymbolFlags } from "@typescript/native/unstable/sync";
+import { isClassDeclaration, isClassExpression, isComputedPropertyName, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isMethodSignatureDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, } from "@typescript/native/ast";
+import { SignatureKind } from "@typescript/native/sync";
 import { isAnswered } from "./query.js";
 /** The member kinds a contextual type writes and reads: data members and the members of object types. */
 const MEMBER_KINDS = new Set(["type-member", "class-member"]);
@@ -36,6 +36,20 @@ function propertyName(property) {
     }
     return undefined;
 }
+/**
+ * Whether an object spread copies a member a declaration declares: a method, a method
+ * signature and a class's accessor are no own data property of the value, while an
+ * accessor of an interface or a type literal describes one. It is decided on the
+ * declaration, because a mapped type over a class keeps the class's declarations on
+ * plain property symbols.
+ */
+function copiedBySpread(node) {
+    if (isMethodDeclaration(node) || isMethodSignatureDeclaration(node)) {
+        return false;
+    }
+    return !((isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node)) &&
+        (isClassDeclaration(node.parent) || isClassExpression(node.parent)));
+}
 /**
  * The contextual uses of one project's literals and values, asked in batches: one
  * contextual type per literal and per value whose type carries a member of the target,
@@ -85,9 +99,12 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                 ids: chains
                     .declarationsOf(property)
                     .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
+                methods: chains
+                    .declarationsOf(property)
+                    .filter((id) => kinds.get(id) === "interface-method"),
                 handles: new Set(property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`)),
                 own: property.declarations.some((handle) => ownPaths.has(handle.path)),
-                accessor: (property.flags & SymbolFlags.Accessor) !== 0,
+                declarations: property.declarations.filter((handle) => ownPaths.has(handle.path)),
             });
         }
         tables.set(type.id, table);
@@ -137,7 +154,10 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     batches += batchesOf(carried.length);
     const types = queries.typesAt(carried.map((flow) => flow.value), cap);
     /** The members a position may read structurally: those of object types, not of classes. */
-    const readable = (member) => member.ids.filter((id) => kinds.get(id) === "type-member");
+    const readable = (member) => [
+        ...member.ids.filter((id) => kinds.get(id) === "type-member"),
+        ...member.methods,
+    ];
     const carries = (part) => [...membersOf(part).values()].some((member) => readable(member).length > 0);
     /** Whether an object type has members and declares none of them in the target. */
     const outside = (part) => {
@@ -161,6 +181,19 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         elements.set(type.id, element);
         return element;
     };
+    const argumentsOf = new Map();
+    /** The type arguments of an instantiation of a generic type, read once per type. */
+    const typeArgumentsOf = (type) => {
+        const known = argumentsOf.get(type.id);
+        if (known !== undefined) {
+            return known;
+        }
+        lookups += type.isTypeReference() ? 1 : 0;
+        const held = queries.typeArguments(type);
+        const found = isAnswered(held) ? held : [];
+        argumentsOf.set(type.id, found);
+        return found;
+    };
     const calls = new Map();
     /**
      * The parameter and return types of a type's one call signature, or of its one construct
@@ -195,10 +228,11 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     };
     /**
      * Each object type a value of `source` is checked as against the object types of
-     * `target`: the value's own, and through array elements and through a function's
-     * parameters, checked the other way, and its result. A source that is one of the
-     * target's own object types matches it as it stands. Each pair is compared once, which
-     * ends the walk over a recursive type.
+     * `target`: the value's own, and through array elements, a function's parameters,
+     * checked the other way, and result, and the type arguments two instantiations share
+     * by place, an array among them, as an array reaches `Iterable<T>`.
+     * A source that is one of the target's own object types matches it as it stands. Each
+     * pair is compared once, which ends the walk over a recursive type.
      */
     const compared = (source, target, into, seen) => {
         const key = `${String(source?.id)}>${String(target?.id)}`;
@@ -220,9 +254,20 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             }
             const element = elementOf(one);
             const called = element === undefined ? callOf(one) : undefined;
+            const sourceArguments = typeArgumentsOf(one);
             for (const part of targets) {
+                const partElement = elementOf(part);
+                if (element !== undefined && partElement !== undefined) {
+                    compared(element, partElement, into, seen);
+                    continue;
+                }
+                const targetArguments = typeArgumentsOf(part);
+                // A defaulted trailing parameter, as `Iterable<T, TReturn, TNext>` has, leaves
+                // the places two instantiations share comparable.
+                sourceArguments.slice(0, targetArguments.length).forEach((argument, index) => {
+                    compared(argument, targetArguments[index], into, seen);
+                });
                 if (element !== undefined) {
-                    compared(element, elementOf(part), into, seen);
                     continue;
                 }
                 const other = called === undefined ? undefined : callOf(part);
@@ -253,7 +298,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             if (element !== undefined) {
                 return mayCarry(element, seen);
             }
-            return callOf(part) !== undefined;
+            return callOf(part) !== undefined || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
         });
     };
     const sourced = carried.flatMap((flow, index) => {
@@ -302,6 +347,19 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
         }
     });
+    const copies = new Map();
+    /** Whether a spread copies the member: where any declaration of it declares data. */
+    const copied = (member) => {
+        let known = copies.get(member);
+        if (known === undefined) {
+            known = member.declarations.some((handle) => {
+                const node = project.declarationAt(handle)?.node;
+                return node === undefined || copiedBySpread(node);
+            });
+            copies.set(member, known);
+        }
+        return known;
+    };
     const spreads = literals.flatMap(({ literal, from }) => literal.properties.flatMap((property) => isSpreadAssignment(property) ? [{ value: property.expression, from }] : []));
     batches += batchesOf(spreads.length);
     const spreadTypes = queries.typesAt(spreads.map((one) => one.value), cap);
@@ -310,11 +368,10 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
         if (type === undefined || !isAnswered(type)) {
             return;
         }
-        // A spread gets every own enumerable property, an overwritten key's getter included.
-        // So it reads each data member but a class's accessor, which sits on the prototype with
-        // the class's methods (never data members), and a private name, which is no property
+        // A spread gets every own enumerable property, an overwritten key's getter included,
+        // and no private name, which is no property
         // (https://tc39.es/ecma262/#sec-copydataproperties).
-        const own = (member, id) => !privateNames.has(id) && !(member.accessor && kinds.get(id) === "class-member");
+        const own = (member, id) => !privateNames.has(id) && copied(member);
         const ids = [
             ...new Set(partsOf(type).flatMap((part) => [...membersOf(part).values()].flatMap((member) => member.ids.filter((id) => own(member, id))))),
         ];

package/dist/src/convention-rows.js

@@ -41,7 +41,8 @@ const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
 /**
  * The properties Vitest takes its project root from, `test.root` before Vite's `root`; it
- * resolves `setupFiles` against that root (https://vitest.dev/config/setupfiles).
+ * resolves `setupFiles` and `globalSetup` against that root
+ * (https://vitest.dev/config/setupfiles, https://vitest.dev/config/globalsetup).
  */
 const VITEST_ROOTS = ["test.root", "root"];
 /** The entry files of an Angular CLI project, at the workspace root or below `projects`. */
@@ -540,6 +541,9 @@ export const CONVENTION_ROWS = [
             { property: "test.coverage.include", files: [VITEST_CONFIG] },
             { property: "test.coverage.exclude", files: [VITEST_CONFIG] },
         ],
-        testFiles: [{ property: "test.setupFiles", files: [VITEST_CONFIG], roots: VITEST_ROOTS }],
+        testFiles: [
+            { property: "test.setupFiles", files: [VITEST_CONFIG], roots: VITEST_ROOTS },
+            { property: "test.globalSetup", files: [VITEST_CONFIG], roots: VITEST_ROOTS },
+        ],
     },
 ];

package/dist/src/conventions.js

@@ -5,7 +5,7 @@
  * directory a configuration property moves read from the property's literal value.
  * No configuration file is run.
  */
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
 import { lineOf } from "./component-files.js";
 import { CONVENTION_ROWS, } from "./convention-rows.js";
 import { documentStrings } from "./configuration-files.js";
@@ -707,7 +707,9 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             }
             const version = versions.get(row.package);
             if (version === undefined) {
-                if (missing.has(row.package) || !declares(declared, row.package, REQUIRED_SECTIONS)) {
+                if (missing.has(row.package) ||
+                    manifest.nested === true ||
+                    !declares(declared, row.package, REQUIRED_SECTIONS)) {
                     continue;
                 }
                 missing.add(row.package);

package/dist/src/dependencies.js

@@ -6,7 +6,7 @@
  * file a tool loads needs each dependency its strings spell. A package one dependency pulls in for
  * itself is that dependency's need, not the target's.
  */
-import { isCallExpression, isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isPropertyAccessExpression, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isCallExpression, isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isPropertyAccessExpression, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, } from "./configuration-files.js";
 import { nodeKey, packageScope } from "./inventory.js";
 import { scriptTokens } from "./manifest.js";
@@ -29,11 +29,13 @@ const PROJECT_OWNER = "";
 /** What a configuration's own reading needs: packages no deletion of a declaration removes. */
 export function configurationNeeds(packages) {
     return {
-        packages: new Set(packages),
         uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
+        at: new Map([[ANYWHERE, new Set(packages)]]),
         unanswered: [],
     };
 }
+/** The key of {@link ProjectNeeds.at} for a use no file of the target governs. */
+const ANYWHERE = "";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -207,9 +209,10 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
     }
     const packages = configurationPackages(host, project.configFile, project.program.getCompilerOptions(), programPackages);
     const uses = new Map();
-    const use = (owners, named) => {
+    const at = new Map();
+    const use = (owners, named, path) => {
         for (const one of named) {
-            packages.add(one);
+            at.set(path, (at.get(path) ?? new Set()).add(one));
             for (const owner of owners) {
                 let set = uses.get(owner);
                 if (set === undefined) {
@@ -220,10 +223,13 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             }
         }
     };
-    use([PROJECT_OWNER], packages);
+    use([PROJECT_OWNER], packages, project.configFile);
     const unanswered = [];
     for (const file of project.ownSourceFiles()) {
-        if (fileNeeds(project, held, file, programPackages, use)) {
+        const inFile = (owners, named) => {
+            use(owners, named, file.fileName);
+        };
+        if (fileNeeds(project, held, file, programPackages, inFile)) {
             unanswered.push(file.fileName);
         }
     }
@@ -241,14 +247,14 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
     for (const { file } of configuration.modules) {
         const names = declaredAt(file.fileName);
         for (const { node, text } of moduleStrings(file)) {
-            use(ownersOf(file, held, node), dependenciesNamed(text, names));
+            use(ownersOf(file, held, node), dependenciesNamed(text, names), file.fileName);
         }
     }
     for (const { strings, manifestDirs } of configuration.documents) {
         for (const manifestDir of manifestDirs) {
             const names = declaredAt(joinPath(manifestDir, "package.json"));
             for (const text of strings) {
-                use([PROJECT_OWNER], dependenciesNamed(text, names));
+                use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
             }
         }
     }
@@ -256,11 +262,11 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         for (const manifestDir of manifestDirs) {
             const names = declaredAt(joinPath(manifestDir, "package.json"));
             for (const { text } of moduleStrings(file)) {
-                use([PROJECT_OWNER], dependenciesNamed(text, names));
+                use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
             }
         }
     }
-    return { packages, uses, unanswered };
+    return { uses, at, unanswered };
 }
 /** The declarations of the inventory a use written at one node belongs to. */
 function ownersOf(file, held, node) {
@@ -496,8 +502,10 @@ function installedOf(host, root, name) {
         const read = readJSON(host, joinPath(dir, MODULES_DIR, name, MANIFEST));
         if (read !== undefined && isRecord(read.value)) {
             const bin = read.value["bin"];
+            const peers = read.value["peerDependencies"];
             // A string `bin` names one command, the package's name without its scope.
             return {
+                peers: isRecord(peers) ? Object.keys(peers) : [],
                 commands: typeof bin === "string"
                     ? bin === ""
                         ? []
@@ -558,20 +566,49 @@ function scriptTokensOf(manifest) {
 function isInside(path, dir) {
     return dir === "" || path.startsWith(`${dir}/`);
 }
+/** The directory below the target root a declared dependency's manifest is in, `""` being the root. */
+function manifestDir(dependency) {
+    const dir = dirnamePath(dependency.position.path);
+    return dir === "." ? "" : dir;
+}
 /**
- * The run's dependency evidence: the target's manifest and each workspace member's in
- * `members` below the target root, read with the position of every dependency each
- * declares, what the projects and the commands its scripts and workflow steps run need,
- * and the last uses each deletion candidate holds. A member in `unbuilt` holds source only
- * in configurations the run could not build. A manifest the program cannot read declares
- * nothing.
+ * Adds to `needed` each declared dependency that the installed manifest of a needed or
+ * run declared dependency names as a peer, until no further one joins: the declaration of
+ * that name in the needing dependency's manifest or in a manifest above it, where the
+ * installed peer is resolved from. `peers` holds each declaration's installed peers by
+ * {@link declarationKey}.
  */
-export function dependenciesOf(host, targetRoot, perProject, candidates, members = [], unbuiltMembers = []) {
+function addNeededPeers(declared, peers, needed, ran) {
+    const pending = declared.filter((dependency) => needed.has(declarationKey(dependency)) || ran.has(declarationKey(dependency)));
+    for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+        const below = manifestDir(next);
+        for (const peer of peers.get(declarationKey(next)) ?? []) {
+            for (const dependency of declared) {
+                const key = declarationKey(dependency);
+                if (dependency.name === peer &&
+                    !needed.has(key) &&
+                    (below === manifestDir(dependency) || isInside(below, manifestDir(dependency)))) {
+                    needed.add(key);
+                    pending.push(dependency);
+                }
+            }
+        }
+    }
+}
+/**
+ * The run's dependency evidence over the target's manifest and those of `members` and
+ * `nested` packages below the root: each declared dependency's position, what the projects,
+ * scripts and workflow steps need, and each deletion candidate's last uses. A member in
+ * `unbuilt` holds source only in configurations the run could not build. An unreadable
+ * manifest declares nothing, nor does a nested package's uninstalled dependency, because
+ * no run requires a nested package to be installed.
+ */
+export function dependenciesOf(host, targetRoot, perProject, candidates, members = [], unbuiltMembers = [], nested = []) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const scopeOf = packageScope(host, targetRoot);
     const manifests = new Map([[root, MANIFEST]]);
     const unbuilt = new Set();
-    for (const dir of [...members, ...unbuiltMembers]) {
+    for (const dir of [...members, ...unbuiltMembers, ...nested]) {
         const below = relativePath(root, dir);
         if (below !== undefined && !manifests.has(dir)) {
             manifests.set(dir, `${below}/${MANIFEST}`);
@@ -586,6 +623,8 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
     const workflow = new Set(workflowTokens(host, targetRoot));
     const declared = [];
     const ran = new Set();
+    const peers = new Map();
+    const uninstalledHere = new Set(nested);
     for (const [dir, path] of manifests) {
         const read = readJSON(host, joinPath(dir, MANIFEST));
         if (read === undefined || !isRecord(read.value)) {
@@ -593,12 +632,16 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         }
         const tokens = scriptTokensOf(read.value);
         for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
-            declared.push(dependency);
             const found = installedOf(host, dir, dependency.name);
+            if (found === undefined && uninstalledHere.has(dir)) {
+                continue;
+            }
+            declared.push(dependency);
             if (found === undefined) {
                 continue;
             }
-            const runs = (command) => tokens.has(command) || (dir === root && workflow.has(command));
+            peers.set(declarationKey(dependency), found.peers);
+            const runs = (command) => tokens.has(command) || workflow.has(command);
             if (found.commands.some(runs)) {
                 ran.add(declarationKey(dependency));
             }
@@ -607,25 +650,36 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
     // A declaration several projects compile is one user, and a use any project makes is
     // a use, so the uses are merged by declaration before anything is counted.
     const needed = new Set();
+    const byName = new Map();
+    for (const dependency of declared) {
+        byName.set(dependency.name, [...(byName.get(dependency.name) ?? []), dependency]);
+    }
     const uses = new Map();
     for (const project of perProject) {
         // A specifier the checker left unanswered may resolve to any dependency a manifest at
         // or above its file declares, and what the configuration needs is never deleted.
         const unanswered = project.unanswered.flatMap((file) => relativePath(root, file) ?? []);
-        const unknown = declared
-            .filter((dependency) => {
-            const dir = dirnamePath(dependency.position.path);
-            return unanswered.some((file) => isInside(file, dir === "." ? "" : dir));
-        })
-            .map((dependency) => dependency.name);
+        const unknownDeclared = declared.filter((dependency) => unanswered.some((file) => isInside(file, manifestDir(dependency))));
+        unknownDeclared.forEach((dependency) => needed.add(declarationKey(dependency)));
+        const unknown = unknownDeclared.map((dependency) => dependency.name);
         const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)]];
         for (const [id, used] of [...project.uses, ...held]) {
             const merged = uses.get(id) ?? new Set();
             used.forEach((one) => merged.add(one));
             uses.set(id, merged);
         }
-        [...project.packages, ...unknown].forEach((one) => needed.add(one));
+        for (const [path, named] of project.at) {
+            const below = path === ANYWHERE ? undefined : relativePath(root, path);
+            for (const one of named) {
+                for (const dependency of byName.get(one) ?? []) {
+                    if (below === undefined || isInside(below, manifestDir(dependency))) {
+                        needed.add(declarationKey(dependency));
+                    }
+                }
+            }
+        }
     }
+    addNeededPeers(declared, peers, needed, ran);
     const users = new Map();
     for (const used of uses.values()) {
         used.forEach((one) => users.set(one, (users.get(one) ?? 0) + 1));

package/dist/src/deprecation.js

@@ -6,7 +6,7 @@
  * declares, and the checker attaches it to the first name alone, so the later names read
  * the list's own tags from the tree.
  */
-import { isVariableStatement, SyntaxKind } from "@typescript/native/unstable/ast";
+import { isVariableStatement, SyntaxKind } from "@typescript/native/ast";
 import { nodeKey } from "./inventory.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 /** The tag the TypeScript tools recognize as marking a declaration deprecated. */

package/dist/src/destructuring.js

@@ -5,8 +5,8 @@
  * to a local of the same name, renames it, gives it a default or nests a pattern under
  * it. A rest element names no property: what it copies is read where the copy is.
  */
-import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { TypeFlags } from "@typescript/native/unstable/sync";
+import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { TypeFlags } from "@typescript/native/sync";
 import { isAnswered, propertyTables, UNANSWERED, } from "./query.js";
 /** The text a property name spells, or `undefined` for a computed name. */
 function nameText(node) {

package/dist/src/discover.js

@@ -1,4 +1,4 @@
-import { DiagnosticCategory } from "@typescript/native/unstable/sync";
+import { DiagnosticCategory } from "@typescript/native/sync";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { SetupError } from "./setup-failure.js";
 /** Directory names discovery does not descend into. */