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

package/src/spelled-names.ts

@@ -0,0 +1,102 @@
+import {
+  isBindingElement,
+  isBreakStatement,
+  isClassDeclaration,
+  isClassExpression,
+  isContinueStatement,
+  isEnumDeclaration,
+  isEnumMember,
+  isExportDeclaration,
+  isExportSpecifier,
+  isFunctionDeclaration,
+  isFunctionExpression,
+  isGetAccessorDeclaration,
+  isImportClause,
+  isImportEqualsDeclaration,
+  isImportSpecifier,
+  isInterfaceDeclaration,
+  isJsxAttribute,
+  isLabeledStatement,
+  isMetaProperty,
+  isMethodDeclaration,
+  isMethodSignatureDeclaration,
+  isModuleDeclaration,
+  isNamespaceExport,
+  isNamespaceExportDeclaration,
+  isNamespaceImport,
+  isParameterDeclaration,
+  isPropertyAccessExpression,
+  isPropertyAssignment,
+  isPropertyDeclaration,
+  isPropertySignatureDeclaration,
+  isQualifiedName,
+  isSetAccessorDeclaration,
+  isTypeAliasDeclaration,
+  isTypeParameterDeclaration,
+  isVariableDeclaration,
+  type Identifier,
+} from "@typescript/native/ast";
+
+/**
+ * Whether one identifier spells a name without referring to a binding of it: a member's
+ * name after a dot, a property or member an object literal, a class, a type or an enum
+ * declares, the name a declaration binds, the property a binding element destructures,
+ * an import or export specifier's name in another module or under a rename, a JSX
+ * attribute's name, a statement label, or the name of a meta-property. A shorthand
+ * property and an unrenamed local export are no such spelling: each reads the binding.
+ */
+export function spellsNoBinding(node: Identifier): boolean {
+  const parent = node.parent;
+  if (isPropertyAccessExpression(parent) || isMetaProperty(parent)) {
+    return parent.name === node;
+  }
+  if (isQualifiedName(parent)) {
+    return parent.right === node;
+  }
+  if (isBindingElement(parent)) {
+    return parent.propertyName === node || parent.name === node;
+  }
+  if (isImportSpecifier(parent)) {
+    return true;
+  }
+  if (isExportSpecifier(parent)) {
+    return (
+      (isExportDeclaration(parent.parent.parent) &&
+        parent.parent.parent.moduleSpecifier !== undefined) ||
+      (parent.propertyName !== undefined && parent.name === node)
+    );
+  }
+  if (
+    isPropertyAssignment(parent) ||
+    isPropertyDeclaration(parent) ||
+    isMethodDeclaration(parent) ||
+    isPropertySignatureDeclaration(parent) ||
+    isMethodSignatureDeclaration(parent) ||
+    isGetAccessorDeclaration(parent) ||
+    isSetAccessorDeclaration(parent) ||
+    isEnumMember(parent) ||
+    isJsxAttribute(parent) ||
+    isVariableDeclaration(parent) ||
+    isParameterDeclaration(parent) ||
+    isFunctionDeclaration(parent) ||
+    isFunctionExpression(parent) ||
+    isClassDeclaration(parent) ||
+    isClassExpression(parent) ||
+    isInterfaceDeclaration(parent) ||
+    isTypeAliasDeclaration(parent) ||
+    isEnumDeclaration(parent) ||
+    isModuleDeclaration(parent) ||
+    isTypeParameterDeclaration(parent) ||
+    isImportClause(parent) ||
+    isNamespaceImport(parent) ||
+    isImportEqualsDeclaration(parent) ||
+    isNamespaceExport(parent) ||
+    isNamespaceExportDeclaration(parent)
+  ) {
+    return parent.name === node;
+  }
+  return (
+    (isLabeledStatement(parent) || isBreakStatement(parent) || isContinueStatement(parent)) &&
+    parent.label === node
+  );
+}

package/src/suppress-file.ts

@@ -98,7 +98,7 @@ type ByReference = ReadonlyMap<string, readonly InventorySymbol[]>;
  */
 function readRecord(value: unknown, site: Position, byReference: ByReference, shape: Shape): Read {
   const refuse = (text: string, want: string): never => {
-    throw new SuppressionError(shape.mechanism, `${shape.file} ${siteText(site)}`, text, want);
+    throw new SuppressionError(shape.mechanism, siteText(site), text, want);
   };
   if (!isObject(value)) {
     return refuse(JSON.stringify(value), shape.recordWant);
@@ -217,7 +217,7 @@ function readDocument(
   const records: SuppressionRecord[] = [];
   const refusals: Refusal[] = [];
   (held as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.opened[index];
+    const offset = walk.starts[index];
     const site = offset === undefined ? documentSite(shape) : positionAt(text, shape.file, offset);
     const read = readRecord(value, site, byReference, shape);
     records.push(...read.records);

package/src/suppress-inline.ts

@@ -134,7 +134,9 @@ function lineComments(file: SourceFile): readonly LineComment[] {
   const spans: { readonly start: number; readonly end: number }[] = [];
   const visit = (node: Node): void => {
     if (LITERALS.has(node.kind)) {
-      spans.push({ start: tokenStart(text, node.pos), end: node.end });
+      // JSX text carries no trivia: its first code unit is at `pos`, even a `//`.
+      const start = node.kind === SyntaxKind.JsxText ? node.pos : tokenStart(text, node.pos);
+      spans.push({ start, end: node.end });
     }
     node.forEachChild(visit);
   };

package/src/template-field.ts

@@ -18,7 +18,7 @@ import type { DetectorInput, Evidence } from "./exempt.ts";
 import type { Host } from "./host.ts";
 import type { SymbolKind } from "./inventory.ts";
 import { memberNames } from "./member-names.ts";
-import { isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.ts";
+import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.ts";
 import { isComponentFile, type Position } from "./position.ts";
 
 /** One template, by its path below the target root. */
@@ -125,7 +125,10 @@ function stringEnd(text: string, from: number): number {
   return at + 1;
 }
 
-/** The end of the `${` substitution whose expression starts at `from`, past its closing brace. */
+/**
+ * The end of the `${` substitution whose expression starts at `from`: past its closing brace,
+ * or one past the text's end where none closes it, so the expression is the text to its end.
+ */
 function substitutionEnd(text: string, from: number): number {
   let depth = 1;
   let at = from;
@@ -149,7 +152,7 @@ function substitutionEnd(text: string, from: number): number {
     }
     at += 1;
   }
-  return at;
+  return text.length + 1;
 }
 
 /** The end of the template literal at `from`; each `${…}` expression goes to `substitution`. */
@@ -243,8 +246,8 @@ function namesOf(text: string, delimiters: TemplateDelimiters): readonly Named[]
 }
 
 /** Every identifier the markup of one component file writes in an action. */
-function markupNamesOf(text: string): readonly Named[] {
-  return readComponent(text).markup.flatMap((one) =>
+function markupNamesOf(file: TemplateFile): readonly Named[] {
+  return readComponent(file.text, extensionOf(file.path)).markup.flatMap((one) =>
     identifiersOf(one.text, true).map(({ name, offset }) => ({
       name,
       offset: one.start + offset,
@@ -287,7 +290,7 @@ export function templateField<Brand>(input: DetectorInput<Brand>): readonly Evid
       names: namesOf(file.text, templates.delimiters),
       markup: false,
     })),
-    ...components.map((file) => ({ file, names: markupNamesOf(file.text), markup: true })),
+    ...components.map((file) => ({ file, names: markupNamesOf(file), markup: true })),
   ];
   for (const { file, names, markup } of scanned) {
     for (const named of names) {

package/src/type-errors.ts

@@ -2,8 +2,8 @@
  * What the errors a project's own files carry do to the run. An import of a module the
  * project expects and nothing provides is a setup failure. Any other error in an own file
  * is a type error: the function, method or file-level statement holding it is skipped,
- * which only ever withholds a finding. An error the compiler places in no file is read as
- * a project that cannot be analyzed.
+ * which only ever withholds a finding. `projectErrors` decides, before any of these, which
+ * errors the compiler places in no file leave the project unloaded.
  */
 
 import {
@@ -69,8 +69,6 @@ interface ProjectErrorReading {
   readonly missing: readonly SetupFailure[];
   /** The type errors, each with the unit it skips. */
   readonly skips: readonly Skip[];
-  /** The errors placed in no file, which leave the project unanalyzable. */
-  readonly failing: readonly LocatedDiagnostic[];
 }
 
 /** Where one project reads what its imports may name. */
@@ -78,11 +76,17 @@ interface ErrorContext {
   readonly host: Host;
   /** The target root, absolute. */
   readonly targetRoot: string;
-  /** The keys of the project configuration's `paths` mapping. */
-  readonly paths: readonly string[];
+  /** The project configuration's `paths` mapping. */
+  readonly paths: PathsMapping;
 }
 
-/** The string literal holding one offset, innermost first. */
+/** One configuration's `paths` mapping, its targets read against `base`. */
+interface PathsMapping {
+  readonly base: string;
+  readonly entries: readonly { readonly key: string; readonly targets: readonly string[] }[];
+}
+
+/** The string literal holding one offset, innermost first, a doc comment's included. */
 function literalAt(file: SourceFile, offset: number): string | undefined {
   let found: string | undefined;
   const visit = (node: Node): void => {
@@ -92,36 +96,59 @@ function literalAt(file: SourceFile, offset: number): string | undefined {
     if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
       found = node.text;
     }
+    // `forEachChild` does not enter a doc comment, where a JavaScript file imports types.
+    for (const doc of (node as { readonly jsDoc?: readonly Node[] }).jsDoc ?? []) {
+      visit(doc);
+    }
     node.forEachChild(visit);
   };
   file.forEachChild(visit);
   return found;
 }
 
-/** Whether one `paths` key matches one specifier: exactly, or around its one `*`. */
-function mappedBy(key: string, specifier: string): boolean {
+/**
+ * What one `paths` key's `*` matches in one specifier, `""` for a key with no `*` that
+ * is the specifier, or `undefined` where the key does not match it.
+ */
+function mappedBy(key: string, specifier: string): string | undefined {
   const star = key.indexOf("*");
   if (star < 0) {
-    return key === specifier;
+    return key === specifier ? "" : undefined;
   }
   const prefix = key.slice(0, star);
   const suffix = key.slice(star + 1);
-  return (
-    specifier.length >= prefix.length + suffix.length &&
+  return specifier.length >= prefix.length + suffix.length &&
     specifier.startsWith(prefix) &&
     specifier.endsWith(suffix)
-  );
+    ? specifier.slice(prefix.length, specifier.length - suffix.length)
+    : undefined;
 }
 
-/** Whether a relative import's path names something on disk, as written or with any extension. */
-function provided(host: Host, path: string): boolean {
-  if (host.kindOf(path) !== "absent") {
+/**
+ * One `paths` target, its first `*` replaced by `star` taken literally, as the compiler does:
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L1282
+ */
+function substituted(target: string, star: string): string {
+  const at = target.indexOf("*");
+  return at < 0 ? target : target.slice(0, at) + star + target.slice(at + 1);
+}
+
+/**
+ * Whether a path names something on disk, as written or with any extension; under
+ * `fileOnly`, only a file counts.
+ */
+function provided(host: Host, path: string, fileOnly: boolean): boolean {
+  const counts = (at: string): boolean =>
+    fileOnly ? host.kindOf(at) === "file" : host.kindOf(at) !== "absent";
+  if (counts(path)) {
     return true;
   }
   const dir = dirnamePath(path);
   const stem = `${path.slice(dir.length + 1)}.`;
   try {
-    return host.readDirectory(dir).some((entry) => entry.name.startsWith(stem));
+    return host
+      .readDirectory(dir)
+      .some((entry) => entry.name.startsWith(stem) && counts(joinPath(dir, entry.name)));
   } catch {
     return false;
   }
@@ -158,6 +185,21 @@ function declaringManifest(
   }
 }
 
+/**
+ * Whether a package is installed for an importer in `dir`: in the `node_modules` of
+ * `dir` or of any ancestor, above the target root too, as Node and the compiler look.
+ */
+function installed(host: Host, dir: string, name: string): boolean {
+  for (let at = dir; ; at = dirnamePath(at)) {
+    if (host.kindOf(joinPath(at, "node_modules", name)) === "directory") {
+      return true;
+    }
+    if (dirnamePath(at) === at) {
+      return false;
+    }
+  }
+}
+
 /**
  * Why one import that the compiler cannot resolve names a module the project expects,
  * with the fix, or undefined where the module is one the project does not expect.
@@ -170,17 +212,31 @@ function expectedModule(
   const { host, targetRoot } = context;
   const fix = "run the generator or the build that writes it";
   if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
-    return provided(host, resolvePath(dirnamePath(importer), specifier))
+    return provided(host, resolvePath(dirnamePath(importer), specifier), false)
       ? undefined
       : `which names no file of the target: ${fix}`;
   }
   if (specifier.startsWith("#")) {
     return `which the manifest's imports map to no file: ${fix}`;
   }
-  if (context.paths.some((key) => mappedBy(key, specifier))) {
-    return `which the compiler configuration's paths map to no file: ${fix}`;
-  }
+  const mapped = context.paths.entries.flatMap(({ key, targets }) => {
+    const star = mappedBy(key, specifier);
+    return star === undefined
+      ? []
+      : targets.map((target) => resolvePath(context.paths.base, substituted(target, star)));
+  });
   const name = packageOfSpecifier(specifier);
+  // The compiler looks up in `node_modules` what `paths` does not resolve, so the error
+  // of an installed package's import is the import's own, a subpath its exports omit:
+  // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L548-L575
+  if (name !== undefined && installed(host, dirnamePath(importer), name)) {
+    return undefined;
+  }
+  if (mapped.length > 0) {
+    return mapped.some((path) => provided(host, path, true))
+      ? undefined
+      : `which the compiler configuration's paths map to no file: ${fix}`;
+  }
   const manifest =
     name === undefined
       ? undefined
@@ -223,14 +279,8 @@ export function readErrors<Brand>(
   const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
   const missing: SetupFailure[] = [];
   const skips: Skip[] = [];
-  const failing: LocatedDiagnostic[] = [];
-  for (const located of errors) {
-    const { diagnostic, at } = located;
-    if (diagnostic.fileName === undefined) {
-      failing.push(located);
-      continue;
-    }
-    const file = files.get(diagnostic.fileName);
+  for (const { diagnostic, at } of errors) {
+    const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
     if (file === undefined || diagnostic.reportsUnnecessary === true) {
       continue;
     }
@@ -257,7 +307,7 @@ export function readErrors<Brand>(
       });
     }
   }
-  return { missing, skips, failing };
+  return { missing, skips };
 }
 
 /** The lines each skip withholds, below the target root. */
@@ -330,12 +380,21 @@ export function skippedRoots<Brand>(
   return [...kept];
 }
 
-/** The keys of one compiler configuration's `paths` mapping, none where it cannot be read. */
-export function pathsOf(engine: Engine, configFile: string): readonly string[] {
+/** One compiler configuration's `paths` mapping, empty where it cannot be read. */
+export function pathsOf(engine: Engine, configFile: string): PathsMapping {
+  const base = dirnamePath(configFile);
   try {
-    const paths: unknown = engine.parseConfigFile(configFile).options.paths;
-    return typeof paths === "object" && paths !== null ? Object.keys(paths) : [];
+    const { options } = engine.parseConfigFile(configFile);
+    const { paths } = options;
+    // The parse answers `pathsBasePath`, the directory of the configuration that writes
+    // `paths` (an extended one included), though the client's option type omits it:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/tsoptions/tsconfigparsing.go#L1120
+    const declaredAt = (options as { readonly pathsBasePath?: unknown }).pathsBasePath;
+    return {
+      base: typeof declaredAt === "string" ? declaredAt : base,
+      entries: Object.entries(paths ?? {}).map(([key, targets]) => ({ key, targets })),
+    };
   } catch {
-    return [];
+    return { base, entries: [] };
   }
 }

package/src/value-reach.ts

@@ -26,8 +26,12 @@ import type { Inventory } from "./inventory.ts";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
-/** The object types whose members the walk reads whatever declares them. */
-const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped;
+/**
+ * The object types whose members the walk reads whatever declares them. A reverse-mapped
+ * type has no symbol: it is the shape the checker infers from an argument the target
+ * writes against a homomorphic mapped type.
+ */
+const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped | ObjectFlags.ReverseMapped;
 
 /** The symbols of an anonymous object type the target writes as a type. */
 const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
@@ -38,7 +42,7 @@ export interface Reached {
   readonly classes: ReadonlySet<string>;
   /**
    * The members of the interfaces and object types the target writes, other than its
-   * classes: each data member, and each method named `toJSON` or `toString`.
+   * classes: each data member, and each method or getter named `toJSON` or `toString`.
    */
   readonly members: readonly TSSymbol[];
 }
@@ -51,6 +55,13 @@ interface ValueReach {
 /** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
 const CONVERSION_NAMES: ReadonlySet<string> = new Set(["toJSON", "toString"]);
 
+/**
+ * The members that can answer a conversion: a serializer reads the name with `[[Get]]`
+ * and calls what it answers, so a getter answers it as a method does:
+ * https://tc39.es/ecma262/#sec-serializejsonproperty (step 2).
+ */
+export const CONVERSION_MEMBERS = SymbolFlags.Method | SymbolFlags.GetAccessor;
+
 /**
  * The types each value is checked against by the `satisfies` expressions and type assertions
  * it is written as, through parentheses, and the innermost operand's own type where there is
@@ -147,8 +158,10 @@ export function valueReach<Brand>(
     if ((type.objectFlags & ObjectFlags.Anonymous) !== 0) {
       return (symbol.flags & LITERAL_SYMBOLS) !== 0;
     }
+    // A class the inventory holds is read as a class before this, so an own class
+    // here is one it does not hold, such as a class declared in a function.
     return (
-      (symbol.flags & SymbolFlags.Interface) !== 0 &&
+      (symbol.flags & (SymbolFlags.Interface | SymbolFlags.Class)) !== 0 &&
       symbol.declarations.every((handle) => own.has(handle.path))
     );
   };
@@ -178,12 +191,12 @@ export function valueReach<Brand>(
     return !isList && isWritten(type);
   };
 
-  /** The data members and conversion methods of one written object type. */
+  /** The data members and conversion members of one written object type. */
   const carried = (type: Type): readonly TSSymbol[] =>
     must(queries.propertiesOf(type)).filter(
       (property) =>
         (property.flags & SymbolFlags.Property) !== 0 ||
-        ((property.flags & SymbolFlags.Method) !== 0 && CONVERSION_NAMES.has(property.name)),
+        ((property.flags & CONVERSION_MEMBERS) !== 0 && CONVERSION_NAMES.has(property.name)),
     );
 
   /** The types a value of one type holds, read once per type. */

package/src/verbs/analyze.ts

@@ -229,6 +229,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   let partial: readonly string[];
   let warnings: readonly ComponentWarning[];
   let unread: readonly string[];
+  let unfound: readonly string[];
   try {
     const root = runRelative(invoked, targetRoot);
     const mode = { production: true };
@@ -256,6 +257,10 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       ({ configFile, reason }) =>
         `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: its component files are not read: ${reason}`,
     );
+    unfound = run.librariesUnfound.map(
+      ({ configFile, error }) =>
+        `${relativePath(resolvePath(invoked, targetRoot), configFile) ?? configFile}: ${error}: the configuration is analyzed without that library`,
+    );
     partial = partialNotes({
       notBuilt: run.notBuilt,
       unanswered: run.unanswered,
@@ -325,7 +330,7 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   for (const note of partial) {
     err.write(`deadset-ts: ${note}\n`);
   }
-  for (const line of unread) {
+  for (const line of [...unread, ...unfound]) {
     err.write(`deadset-ts: ${line}\n`);
   }
   for (const warning of warnings) {

package/src/version-range.ts

@@ -66,10 +66,12 @@ function partialOf(text: string): Partial | undefined {
     parts.push(Number(part));
   }
   const prerelease = prereleaseOf(match[4]);
-  if (prerelease === undefined || (prerelease.length > 0 && wild)) {
+  if (prerelease === undefined) {
     return undefined;
   }
-  return { major: parts[0], minor: parts[1], patch: parts[2], prerelease };
+  // node-semver drops the prerelease of a version with a wildcard part (`1.2.x-beta` is `1.2.x`):
+  // https://github.com/npm/node-semver/blob/v7.8.5/classes/range.js#L409-L430
+  return { major: parts[0], minor: parts[1], patch: parts[2], prerelease: wild ? [] : prerelease };
 }
 
 /** One exact version, or `undefined` where the text is not one. */
@@ -152,11 +154,14 @@ function passes(version: Version, comparator: Comparator): boolean {
   }
 }
 
-/** The comparators a version with missing parts stands for: any value of each. */
+/**
+ * The comparators a version with missing parts stands for: any value of each. A wildcard
+ * major is no comparator, so it never refuses a 0.0.0 prerelease another comparator admits.
+ */
 function anyOf(partial: Partial): Comparator[] {
   const { major, minor } = partial;
   if (major === undefined) {
-    return [{ operator: ">=", version: exact(0, 0, 0) }];
+    return [];
   }
   if (minor === undefined) {
     return [
@@ -210,7 +215,7 @@ function primitive(operator: "<" | "<=" | ">" | ">=", partial: Partial): Compara
   if (major === undefined) {
     return operator === "<" || operator === ">"
       ? [{ operator: "<", version: floorOf(0, 0, 0) }]
-      : [{ operator: ">=", version: exact(0, 0, 0) }];
+      : [];
   }
   if (minor !== undefined && patch !== undefined) {
     return [{ operator, version: lowest(partial) }];

package/src/workspace-resolution.ts

@@ -45,6 +45,7 @@ const DEPENDENCY_MEMBERS = [
 ] as const;
 
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
+const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -77,10 +78,17 @@ function exportsEntry(
   exportsField: unknown,
   subpath: string,
 ): { readonly value: unknown; readonly match?: string } | undefined {
-  const map =
-    isRecord(exportsField) && Object.keys(exportsField).some((key) => key.startsWith("."))
-      ? exportsField
-      : { ".": exportsField };
+  const keys = isRecord(exportsField) ? Object.keys(exportsField) : [];
+  const dotted = keys.filter((key) => key.startsWith(".")).length;
+  // An object mixing subpath keys with others is invalid to Node; the compiler still
+  // answers `.` from its `"."` key and no other subpath:
+  // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/module/resolver.go#L673-L695
+  if (isRecord(exportsField) && dotted > 0 && dotted < keys.length) {
+    return subpath === "." && Object.hasOwn(exportsField, ".")
+      ? { value: exportsField["."] }
+      : undefined;
+  }
+  const map = isRecord(exportsField) && dotted > 0 ? exportsField : { ".": exportsField };
   if (Object.hasOwn(map, subpath)) {
     return { value: map[subpath] };
   }
@@ -371,6 +379,18 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       if (answered !== undefined) {
         return { kind: "default" };
       }
+      // A stylesheet or another asset is no module with a source, so the import of one
+      // keeps the compiler's resolution.
+      if (
+        targets.some(
+          (target) =>
+            !SOURCE.test(target) &&
+            !OUTPUT.test(target) &&
+            host.kindOf(joinPath(member.dir, target)) === "file",
+        )
+      ) {
+        return { kind: "default" };
+      }
       const named = targets.length === 0 ? "no target" : targets.join(", ");
       const built = targets.some((target) => host.kindOf(joinPath(member.dir, target)) === "file");
       return {

package/src/workspace.ts

@@ -274,7 +274,7 @@ function memberDirectories(
 /** Whether a workspace's patterns name one directory below its root, read without listing any. */
 function namesDirectory(root: string, patterns: readonly string[], dir: string): boolean {
   const below = relativePath(root, dir);
-  if (below === undefined || below.startsWith("..")) {
+  if (below === undefined) {
     return false;
   }
   const path = below.split("/");