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

package/dist/src/reporters/template.js

@@ -793,7 +793,7 @@ class Execution {
             case "lit":
                 return arg.value;
             case "pipe":
-                return this.pipeline(arg.pipe, dot, false);
+                return this.pipeline(arg.pipe, dot);
             case "field":
                 return this.field(arg.recv === undefined ? dot : this.arg(arg.recv, dot), arg.names);
             case "func":
@@ -837,19 +837,18 @@ class Execution {
         }
         return call(head.name, operands());
     }
-    pipeline(pipe, dot, declares) {
+    pipeline(pipe, dot) {
         let value;
         for (const command of pipe.commands) {
             value = this.command(command, dot, value);
         }
         const result = value ?? null;
-        const [only] = pipe.vars;
-        if (only !== undefined && (declares || pipe.assign)) {
+        for (const name of pipe.vars) {
             if (pipe.assign) {
-                this.assign(only, result);
+                this.assign(name, result);
             }
             else {
-                this.scopes.at(-1)?.set(only, result);
+                this.scopes.at(-1)?.set(name, result);
             }
         }
         return result;
@@ -861,7 +860,7 @@ class Execution {
                     this.write(node.text);
                     break;
                 case "action": {
-                    const value = this.pipeline(node.pipe, dot, true);
+                    const value = this.pipeline(node.pipe, dot);
                     if (node.pipe.vars.length === 0) {
                         this.write(formatted(value, false));
                     }
@@ -874,7 +873,7 @@ class Execution {
                 case "with": {
                     this.scopes.push(new Map());
                     try {
-                        const value = this.pipeline(node.pipe, dot, true);
+                        const value = this.pipeline(node.pipe, dot);
                         const taken = truthy(value);
                         this.run(taken ? node.list : node.otherwise, taken && node.k === "with" ? value : dot);
                     }
@@ -892,7 +891,9 @@ class Execution {
     range(node, dot) {
         this.scopes.push(new Map());
         try {
-            const value = this.pipeline({ ...node.pipe, vars: [] }, dot, false);
+            // Go's `evalPipeline` gives every variable the range declares or assigns the whole value first:
+            // https://github.com/golang/go/blob/go1.27.2/src/text/template/exec.go#L525
+            const value = this.pipeline(node.pipe, dot);
             let entries;
             if (value === null) {
                 entries = [];
@@ -913,14 +914,22 @@ class Execution {
                 return;
             }
             const [first, second] = node.pipe.vars;
+            const scope = this.scopes.at(-1);
+            const bind = (name, held) => {
+                if (node.pipe.assign) {
+                    this.assign(name, held);
+                }
+                else {
+                    scope?.set(name, held);
+                }
+            };
             for (const [key, element] of entries) {
-                const scope = this.scopes.at(-1);
                 if (second !== undefined && first !== undefined) {
-                    scope?.set(first, key);
-                    scope?.set(second, element);
+                    bind(first, key);
+                    bind(second, element);
                 }
                 else if (first !== undefined) {
-                    scope?.set(first, element);
+                    bind(first, element);
                 }
                 try {
                     this.run(node.list, element);

package/dist/src/serialization-contract.js

@@ -16,7 +16,7 @@ import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
 import { erasedStores } from "./erased-stores.js";
-import { checkedTypes, valueReach } from "./value-reach.js";
+import { checkedTypes, CONVERSION_MEMBERS, valueReach } from "./value-reach.js";
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
 /** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
@@ -313,13 +313,14 @@ function destinations(input, chains, walked) {
     const inAnalysis = (path) => own.has(path) || input.consumers.some((root) => path === root || path.startsWith(`${root}/`));
     const implemented = implementedOwners(project, inAnalysis);
     /**
-     * Whether every declaration of a callee is outside the analysis or ambient. An ambient
-     * declaration has no body, so the code that runs is outside the analysis, unless it is a
-     * member of an interface or an object type a class or a typed object literal of the
-     * analysis implements; `settled` false skips that question, which asks the checker.
+     * Whether every one of `declarations`, all of the callee's by default, is outside the
+     * analysis or ambient. An ambient declaration has no body, so the code that runs is
+     * outside the analysis, unless it is a member of an interface or an object type a class
+     * or a typed object literal of the analysis implements; `settled` false skips that
+     * question, which asks the checker.
      */
-    const outside = (target, settled) => target.declarations.length > 0 &&
-        target.declarations.every((handle) => {
+    const outside = (target, settled, declarations = target.declarations) => declarations.length > 0 &&
+        declarations.every((handle) => {
             if (!inAnalysis(handle.path)) {
                 return true;
             }
@@ -333,6 +334,12 @@ function destinations(input, chains, walked) {
             const owner = must(queries.parentOf(target));
             return owner === undefined || !implemented().has(owner.id);
         });
+    /**
+     * Whether some one declaration of a callee is outside the analysis or ambient, without
+     * asking the checker. A project's declaration merged into a library's symbol leaves the
+     * library's beside it, so a call can still resolve to the library's.
+     */
+    const mayBeOutside = (target) => target.declarations.some((handle) => outside(target, false, [handle]));
     const invocation = (call) => {
         const form = forms.get(call);
         const method = form === undefined ? undefined : callees.get(form.method);
@@ -340,7 +347,7 @@ function destinations(input, chains, walked) {
         // program's own `call` and `Reflect.apply` invoke nothing here.
         if (form !== undefined &&
             method !== undefined &&
-            outside(method, false) &&
+            mayBeOutside(method) &&
             FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")) {
             return form.invocation;
         }
@@ -350,6 +357,30 @@ function destinations(input, chains, walked) {
         const name = calleeName(invocation(call).callee);
         return name === undefined ? undefined : callees.get(name);
     };
+    const signatures = new Map();
+    const resolvedOf = (call) => {
+        if (!signatures.has(call)) {
+            signatures.set(call, must(queries.resolvedSignature(call)));
+        }
+        return signatures.get(call);
+    };
+    /**
+     * The declarations of a callee that the declaration of a direct call's resolved
+     * signature lies in, or all of them where it lies in none: a declaration merged into
+     * the callee's symbol that the call does not resolve to does not decide where it runs.
+     */
+    const calledDeclarations = (call, target) => {
+        const declaration = invocation(call).indirect ? undefined : resolvedOf(call)?.declaration;
+        const signature = declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
+        if (declaration === undefined || signature === undefined) {
+            return target.declarations;
+        }
+        const containing = target.declarations.filter((handle) => {
+            const node = handle.path === declaration.path ? project.declarationAt(handle)?.node : undefined;
+            return node !== undefined && node.pos <= signature.pos && signature.end <= node.end;
+        });
+        return containing.length === 0 ? target.declarations : containing;
+    };
     const erasedArguments = new Map();
     const erasedAt = (call, argument) => {
         let indexes = erasedArguments.get(call);
@@ -362,7 +393,7 @@ function destinations(input, chains, walked) {
                 ? type === undefined
                     ? []
                     : must(queries.signaturesOf(type, SignatureKind.Call))
-                : [must(queries.resolvedSignature(call))].filter((one) => one !== undefined);
+                : [resolvedOf(call)].filter((one) => one !== undefined);
             indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
                 const parameter = must(queries.parameterType(signature, index));
                 return parameter !== undefined && (parameter.flags & ERASED) !== 0;
@@ -384,7 +415,7 @@ function destinations(input, chains, walked) {
         if (entry !== undefined) {
             return { reach: "properties", callee: spelledEntry(entry.entry, held) };
         }
-        if (outside(target, true)) {
+        if (outside(target, true, calledDeclarations(call, target))) {
             return erasedAt(call, argument)
                 ? {
                     reach: "conversions",
@@ -419,7 +450,7 @@ function destinations(input, chains, walked) {
         if (target === undefined) {
             return false;
         }
-        if (named.some((one) => names(one, target, chains)) || outside(target, false)) {
+        if (named.some((one) => names(one, target, chains)) || mayBeOutside(target)) {
             return true;
         }
         return chains
@@ -509,7 +540,7 @@ export function serializationContract(input) {
     // A destination holds back a data member and `toJSON`, and `toString` as well where
     // the value left the analysis.
     const holdsBack = (flags, name, to) => (flags & SymbolFlags.Property) !== 0 ||
-        ((flags & SymbolFlags.Method) !== 0 &&
+        ((flags & CONVERSION_MEMBERS) !== 0 &&
             (name === SERIALIZED_CONVERSION || (to.reach === "conversions" && CONVERSIONS.has(name))));
     const found = [];
     for (const flow of flows) {

package/dist/src/session.js

@@ -189,12 +189,30 @@ export function ownedAs(project, own) {
         },
     };
 }
-/** The three diagnostic sets one project carries, read before any analysis. */
+/**
+ * The program's diagnostics placed in no file. The per-file sets never carry one; the
+ * client answers its `fileName` as `null`, and the global set repeats the program set:
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/api/session.go#L3726-L3752
+ */
+function unplacedOf(program) {
+    const seen = new Set();
+    return [...program.getGlobalDiagnostics(), ...program.getProgramDiagnostics()]
+        .filter((diagnostic) => diagnostic.fileName == null)
+        .filter((diagnostic) => {
+        const key = `${String(diagnostic.code)}\u0000${diagnostic.text}`;
+        const fresh = !seen.has(key);
+        seen.add(key);
+        return fresh;
+    })
+        .map((diagnostic) => ({ ...diagnostic, fileName: undefined }));
+}
+/** The diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf(project) {
     return {
         syntactic: project.program.getSyntacticDiagnostics(),
         semantic: project.program.getSemanticDiagnostics(),
         configParsing: project.program.getConfigFileParsingDiagnostics(),
+        unplaced: unplacedOf(project.program),
         locate: (fileName, offset) => {
             const file = project.program.getSourceFile(fileName);
             if (file === undefined || offset < 0 || offset > file.text.length) {

package/dist/src/spelled-names.js

@@ -0,0 +1,58 @@
+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, } 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) {
+    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/dist/src/suppress-file.js

@@ -51,7 +51,7 @@ function isObject(value) {
  */
 function readRecord(value, site, byReference, shape) {
     const refuse = (text, want) => {
-        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);
@@ -159,7 +159,7 @@ function readDocument(host, targetRoot, symbols, shape) {
     const records = [];
     const refusals = [];
     held.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/dist/src/suppress-inline.js

@@ -100,7 +100,9 @@ function lineComments(file) {
     const spans = [];
     const visit = (node) => {
         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/dist/src/template-field.js

@@ -14,7 +14,7 @@
 import { readComponent } from "./component-files.js";
 import { ConfigError } from "./config.js";
 import { memberNames } from "./member-names.js";
-import { isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
+import { extensionOf, isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.js";
 import { isComponentFile } from "./position.js";
 /** The kinds of declaration an action can name. */
 const READ_BY_A_TEMPLATE = new Set([
@@ -87,7 +87,10 @@ function stringEnd(text, from) {
     }
     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, from) {
     let depth = 1;
     let at = from;
@@ -112,7 +115,7 @@ function substitutionEnd(text, from) {
         }
         at += 1;
     }
-    return at;
+    return text.length + 1;
 }
 /** The end of the template literal at `from`; each `${…}` expression goes to `substitution`. */
 function templateEnd(text, from, substitution) {
@@ -198,8 +201,8 @@ function namesOf(text, delimiters) {
     }
 }
 /** Every identifier the markup of one component file writes in an action. */
-function markupNamesOf(text) {
-    return readComponent(text).markup.flatMap((one) => identifiersOf(one.text, true).map(({ name, offset }) => ({
+function markupNamesOf(file) {
+    return readComponent(file.text, extensionOf(file.path)).markup.flatMap((one) => identifiersOf(one.text, true).map(({ name, offset }) => ({
         name,
         offset: one.start + offset,
         action: one.action,
@@ -238,7 +241,7 @@ export function templateField(input) {
             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/dist/src/type-errors.js

@@ -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 { isClassDeclaration, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/ast";
 import { packageOfSpecifier } from "./dependencies.js";
@@ -23,7 +23,7 @@ const MANIFEST_SECTIONS = [
 export function insideSkipped(skipped, position) {
     return skipped.some((unit) => unit.path === position.path && unit.fromLine <= position.line && position.line <= unit.toLine);
 }
-/** The string literal holding one offset, innermost first. */
+/** The string literal holding one offset, innermost first, a doc comment's included. */
 function literalAt(file, offset) {
     let found;
     const visit = (node) => {
@@ -33,32 +33,55 @@ function literalAt(file, offset) {
         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.jsDoc ?? []) {
+            visit(doc);
+        }
         node.forEachChild(visit);
     };
     file.forEachChild(visit);
     return found;
 }
-/** Whether one `paths` key matches one specifier: exactly, or around its one `*`. */
+/**
+ * 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, specifier) {
     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.endsWith(suffix)
+        ? specifier.slice(prefix.length, specifier.length - suffix.length)
+        : undefined;
+}
+/**
+ * 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, star) {
+    const at = target.indexOf("*");
+    return at < 0 ? target : target.slice(0, at) + star + target.slice(at + 1);
 }
-/** Whether a relative import's path names something on disk, as written or with any extension. */
-function provided(host, path) {
-    if (host.kindOf(path) !== "absent") {
+/**
+ * Whether a path names something on disk, as written or with any extension; under
+ * `fileOnly`, only a file counts.
+ */
+function provided(host, path, fileOnly) {
+    const counts = (at) => 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;
@@ -90,6 +113,20 @@ function declaringManifest(host, dir, targetRoot, name) {
         }
     }
 }
+/**
+ * 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, dir, name) {
+    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.
@@ -98,17 +135,31 @@ function expectedModule(context, importer, specifier) {
     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
         : declaringManifest(host, dirnamePath(importer), targetRoot, name);
@@ -143,14 +194,8 @@ export function readErrors(project, errors, context) {
     const files = new Map(project.ownSourceFiles().map((file) => [file.fileName, file]));
     const missing = [];
     const skips = [];
-    const failing = [];
-    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;
         }
@@ -176,7 +221,7 @@ export function readErrors(project, errors, context) {
             });
         }
     }
-    return { missing, skips, failing };
+    return { missing, skips };
 }
 /** The lines each skip withholds, below the target root. */
 export function skippedUnits(skips, targetRoot) {
@@ -241,13 +286,22 @@ export function skippedRoots(project, held, skips) {
     }
     return [...kept];
 }
-/** The keys of one compiler configuration's `paths` mapping, none where it cannot be read. */
+/** One compiler configuration's `paths` mapping, empty where it cannot be read. */
 export function pathsOf(engine, configFile) {
+    const base = dirnamePath(configFile);
     try {
-        const paths = 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.pathsBasePath;
+        return {
+            base: typeof declaredAt === "string" ? declaredAt : base,
+            entries: Object.entries(paths ?? {}).map(([key, targets]) => ({ key, targets })),
+        };
     }
     catch {
-        return [];
+        return { base, entries: [] };
     }
 }

package/dist/src/value-reach.js

@@ -10,12 +10,22 @@ import { isAsExpression, isParenthesizedExpression, isSatisfiesExpression, isTyp
 import { ObjectFlags, SymbolFlags, } from "@typescript/native/sync";
 import { classNames, typesAt } from "./class-members.js";
 import { must } from "./query.js";
-/** 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;
 /** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
 const CONVERSION_NAMES = 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
@@ -92,7 +102,9 @@ export function valueReach(project, held, stored = () => []) {
         if ((type.objectFlags & ObjectFlags.Anonymous) !== 0) {
             return (symbol.flags & LITERAL_SYMBOLS) !== 0;
         }
-        return ((symbol.flags & SymbolFlags.Interface) !== 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 | SymbolFlags.Class)) !== 0 &&
             symbol.declarations.every((handle) => own.has(handle.path)));
     };
     /** The types a value of one object type holds in its data members. */
@@ -115,9 +127,9 @@ export function valueReach(project, held, stored = () => []) {
                 (target.isObjectType() && (target.objectFlags & ObjectFlags.Tuple) !== 0));
         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) => 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. */
     const childrenOf = (type) => {
         const known = children.get(type.id);

package/dist/src/verbs/analyze.js

@@ -161,6 +161,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     let partial;
     let warnings;
     let unread;
+    let unfound;
     try {
         const root = runRelative(invoked, targetRoot);
         const mode = { production: true };
@@ -178,6 +179,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         const { result, run } = analysis;
         warnings = run.componentWarnings;
         unread = run.componentsUnread.map(({ 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,
@@ -243,7 +245,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
     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) {