carrick 0.3.105 → 0.3.107

package/sidecar/dist/src/capture/index.js

@@ -34,13 +34,13 @@ import { entryRelativeSpecifier, resolveAnchor } from './anchors.js';
 import { findAugmentationFiles } from './augmentations.js';
 import { installedVersions, lockfileVersions } from './lockfile.js';
 import { rewriteEmittedSpecifiers } from './paths-rewrite.js';
-import { typesPackageOf, withInstalledPackages } from './installed-package.js';
+import { installedPackageSpecifier, typesPackageOf, withInstalledPackages } from './installed-package.js';
 import { selfCheckStub } from './self-check.js';
 import { collectSpecifiers, isRelative, packageNameOf } from './specifiers.js';
 import { DenoProject, findDenoConfig } from './deno-project.js';
 import { emitsAlike, ProjectGraph } from './project-references.js';
 import { findServiceTsconfig } from './service-config.js';
-import { placeEmittedTree } from './outside-root.js';
+import { placeEmittedTree, surfaceModuleInTree } from './outside-root.js';
 import { WriteGuard } from './guarded-fs.js';
 export { DenoProject, findDenoConfig } from './deno-project.js';
 export { serviceConfigPath } from './project-references.js';
@@ -351,7 +351,14 @@ export function captureStub(opts) {
     if (emitPartial) {
         errors.push(`declaration emit was partial: kept ${emitted.size} emitted file(s); ` +
             'aliases referencing unemitted modules are demoted to structural_fallback');
-        resolved = demoteDanglingAliases({ resolved, emitted, declarationSources, staging, surfaceDeclaration });
+        resolved = demoteDanglingAliases({
+            resolved,
+            emitted,
+            declarationSources,
+            staging,
+            entryDir,
+            surfaceDeclaration,
+        });
     }
     // ---- Relocate the emitted tree into the stub package ----
     const typesDir = path.join(stubDir, 'types');
@@ -520,43 +527,47 @@ export function captureStub(opts) {
     };
 }
 /**
- * Partial-emit demotion: with the set of modules that DID reach the tree
- * (emitted .d.ts plus verbatim declaration sources), demote every anchor
- * whose alias text references a relative module absent from that set, and
+ * Partial-emit demotion: demote every anchor whose alias text names, by a
+ * relative or an absolute path, a module the stub will not resolve, and
  * rewrite the demoted aliases' lines in the emitted surface to `unknown`.
+ *
+ * A path resolves when the tree holds its module (`surfaceModuleInTree`: an
+ * emitted declaration inside rootDir or outside it, or a verbatim declaration
+ * source), read from where the entry was written, not from where the surface
+ * sits in the tree. An absolute path into an installed package resolves too
+ * (carrick#1773): no emit writes that module, and the specifier rewrite turns
+ * the path into the package's bare specifier and a pin, as it does when the
+ * emit is whole. A relative path into a package is not rewritten, so it stays
+ * demoted (carrick#1857).
+ *
  * Anchors already demoted stay as they are; anchors whose text is
  * self-contained (node-builder structural prints, literal object text) are
  * untouched even when their source file failed to emit — their surface line
  * references nothing that can dangle.
  */
 function demoteDanglingAliases(args) {
-    // Extensionless, entryDir-relative POSIX module ids present in the tree.
-    const treeModules = new Set();
-    let surfaceKey;
-    for (const fileName of args.emitted.keys()) {
-        const rel = path.relative(args.staging, fileName).split(path.sep).join('/');
-        if (path.basename(rel) === args.surfaceDeclaration)
-            surfaceKey = fileName;
-        if (rel.endsWith('.d.ts'))
-            treeModules.add(rel.slice(0, -'.d.ts'.length));
-    }
-    for (const rel of args.declarationSources.keys()) {
-        if (rel.endsWith('.d.ts'))
-            treeModules.add(rel.slice(0, -'.d.ts'.length));
-    }
-    // Deno's temporary surface lives in the cache inside the emitted tree.
-    const surfaceDir = surfaceKey ? path.posix.dirname(path.relative(args.staging, surfaceKey).split(path.sep).join('/')) : '.';
-    const moduleInTree = (spec) => {
-        const id = path.posix.normalize(path.posix.join(surfaceDir, spec));
-        if (id.startsWith('..'))
-            return false;
-        return treeModules.has(id) || treeModules.has(`${id}/index`);
+    const surfaceKey = [...args.emitted.keys()].find((fileName) => path.basename(fileName) === args.surfaceDeclaration);
+    const inTree = surfaceModuleInTree({
+        emitted: args.emitted.keys(),
+        declarationSources: args.declarationSources.keys(),
+        staging: args.staging,
+        entryDir: args.entryDir,
+        surfaceDeclaration: args.surfaceDeclaration,
+    });
+    const resolves = new Map();
+    const moduleResolves = (spec) => {
+        let answer = resolves.get(spec);
+        if (answer === undefined) {
+            answer = inTree(spec) || (spec.startsWith('/') && installedPackageSpecifier(spec) !== undefined);
+            resolves.set(spec, answer);
+        }
+        return answer;
     };
     const demoted = new Set();
     const next = args.resolved.map((anchor) => {
         if (anchor.failureReason !== undefined)
             return anchor;
-        const dangling = [...collectSpecifiers(anchor.aliasText)].find((spec) => isRelative(spec) && !moduleInTree(spec));
+        const dangling = [...collectSpecifiers(anchor.aliasText)].find((spec) => isRelative(spec) && !moduleResolves(spec));
         if (dangling === undefined)
             return anchor;
         demoted.add(anchor.request.alias);
@@ -661,6 +672,20 @@ function resolveAnchors(opts, parsed, ctx, deno) {
                     placeholders.set(stmt.name.text, stmt);
             }
         }
+        // A module specifier as the entry resolves it, under the program's own
+        // resolution (the Deno graph's, for a Deno service). Asked once per
+        // specifier: every anchor of a module asks for the same one.
+        const entryMode = entrySource?.impliedNodeFormat;
+        const fromEntry = new Map();
+        const resolveFromEntry = (specifier) => {
+            if (!fromEntry.has(specifier)) {
+                fromEntry.set(specifier, (deno
+                    ? deno.resolve(specifier, ctx.entryPath, options)
+                    : ts.resolveModuleName(specifier, ctx.entryPath, options, ts.sys, undefined, undefined, entryMode)
+                        .resolvedModule)?.resolvedFileName);
+            }
+            return fromEntry.get(specifier);
+        };
         // A literal anchor whose text is a bare identifier resolves through a
         // sibling symbol anchor's module when one names the same symbol.
         const siblingSymbolSpecs = new Map();
@@ -668,7 +693,7 @@ function resolveAnchors(opts, parsed, ctx, deno) {
             if (anchor.kind !== 'symbol')
                 continue;
             if (!siblingSymbolSpecs.has(anchor.symbol_name)) {
-                siblingSymbolSpecs.set(anchor.symbol_name, entryRelativeSpecifier(ctx.entryDir, ctx.repoRoot, anchor.source_file));
+                siblingSymbolSpecs.set(anchor.symbol_name, entryRelativeSpecifier(ctx.entryDir, ctx.repoRoot, anchor.source_file, resolveFromEntry));
             }
         }
         return opts.anchors.map((request) => resolveAnchor(program, request, {
@@ -676,6 +701,7 @@ function resolveAnchors(opts, parsed, ctx, deno) {
             entryDir: ctx.entryDir,
             placeholder: placeholders.get(request.alias),
             siblingSymbolSpecs,
+            resolveFromEntry,
         }));
     }
     finally {

package/sidecar/dist/src/capture/installed-package.d.ts

@@ -41,6 +41,8 @@ export interface InstalledPackageSpecifier {
  * deciding whether a runtime name is covered by a pinned types package.
  */
 export declare function typesPackageOf(name: string): string;
+/** A path or specifier without its script, source or declaration extension. */
+export declare function withoutExtension(subpath: string): string;
 /**
  * A compiler host that also resolves the packages an absolute specifier was
  * rewritten into, each from its own install directory. The capture's

package/sidecar/dist/src/capture/installed-package.js

@@ -101,7 +101,8 @@ function existingFile(spec) {
     }
     return undefined;
 }
-function withoutExtension(subpath) {
+/** A path or specifier without its script, source or declaration extension. */
+export function withoutExtension(subpath) {
     return subpath.replace(/(?:\.d)?\.(?:ts|mts|cts|js|mjs|cjs|tsx|jsx)$/, '');
 }
 /** Every string target an exports value names, whatever its conditions. */

package/sidecar/dist/src/capture/outside-root.d.ts

@@ -39,3 +39,22 @@ export declare function placeEmittedTree(args: {
     entryDir: string;
     surfaceDeclaration: string;
 }): PlacedTree;
+/**
+ * A test for whether the tree holds the module a specifier in the surface
+ * entry names (carrick#1773).
+ *
+ * The specifier is read the way the placement above reads one: resolved from
+ * the surface's SOURCE-side directory, so an absolute path stays what it is
+ * and `../` leaves rootDir, then looked up among the source-side paths of the
+ * declarations the tree holds. Those are every emitted declaration, inside
+ * rootDir or placed under `OUTSIDE_DIR`, and the declaration sources shipped
+ * verbatim (`declarationSources`, relative to rootDir).
+ */
+export declare function surfaceModuleInTree(args: {
+    /** tsc's file name for each emitted declaration. */
+    emitted: Iterable<string>;
+    declarationSources: Iterable<string>;
+    staging: string;
+    entryDir: string;
+    surfaceDeclaration: string;
+}): (spec: string) => boolean;

package/sidecar/dist/src/capture/outside-root.js

@@ -15,6 +15,7 @@
  * A capture whose program stays inside rootDir is placed exactly as before.
  */
 import * as path from 'node:path';
+import { withoutExtension } from './installed-package.js';
 import { rewriteSpecifiers } from './specifiers.js';
 /** Tree directory holding declarations of sources outside rootDir. */
 export const OUTSIDE_DIR = '__outside__';
@@ -31,13 +32,12 @@ export function placeEmittedTree(args) {
     const sourceSideOf = new Map();
     const outsideFiles = [];
     for (const fileName of args.emitted.keys()) {
+        sourceSideOf.set(fileName, sourceSidePath(fileName, args.staging, args.entryDir));
         const rel = posix(path.relative(args.staging, fileName));
         if (escapes(rel)) {
             outsideFiles.push(fileName);
-            sourceSideOf.set(fileName, path.resolve(fileName));
             continue;
         }
-        sourceSideOf.set(fileName, path.join(args.entryDir, rel));
         relOf.set(fileName, path.basename(rel) === args.surfaceDeclaration ? 'surface.d.ts' : rel);
     }
     const outside = new Map();
@@ -82,6 +82,43 @@ export function placeEmittedTree(args) {
     }
     return { relOf, textOf, outside, rewrites };
 }
+/**
+ * Where tsc would have written an emitted declaration in the source tree. A
+ * file under the staging dir mirrors rootDir; one outside it arrived at its
+ * source's own path.
+ */
+function sourceSidePath(fileName, staging, entryDir) {
+    const rel = posix(path.relative(staging, fileName));
+    return escapes(rel) ? path.resolve(fileName) : path.join(entryDir, rel);
+}
+/**
+ * A test for whether the tree holds the module a specifier in the surface
+ * entry names (carrick#1773).
+ *
+ * The specifier is read the way the placement above reads one: resolved from
+ * the surface's SOURCE-side directory, so an absolute path stays what it is
+ * and `../` leaves rootDir, then looked up among the source-side paths of the
+ * declarations the tree holds. Those are every emitted declaration, inside
+ * rootDir or placed under `OUTSIDE_DIR`, and the declaration sources shipped
+ * verbatim (`declarationSources`, relative to rootDir).
+ */
+export function surfaceModuleInTree(args) {
+    const held = new Set();
+    let surfaceDir = args.entryDir;
+    for (const fileName of args.emitted) {
+        const sourceSide = sourceSidePath(fileName, args.staging, args.entryDir);
+        if (path.basename(sourceSide) === args.surfaceDeclaration)
+            surfaceDir = path.dirname(sourceSide);
+        held.add(sourceSide.replace(DECLARATION_EXT, ''));
+    }
+    for (const rel of args.declarationSources) {
+        held.add(path.join(args.entryDir, rel).replace(DECLARATION_EXT, ''));
+    }
+    return (spec) => {
+        const target = path.resolve(surfaceDir, withoutExtension(spec));
+        return held.has(target) || held.has(path.join(target, 'index'));
+    };
+}
 function posix(p) {
     return p.split(path.sep).join('/');
 }

package/sidecar/dist/src/capture/self-check.js

@@ -32,7 +32,7 @@
 import ts from 'typescript';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { collectSpecifiers, isRelative, packageNameOf } from './specifiers.js';
+import { collectSpecifiers, declarationCandidates, isDeclarationFileName, isRelative, packageNameOf, } from './specifiers.js';
 import { repairDanglingImports } from './repair-dangling.js';
 import { findDisqualifyingTopTypes, findUnresolvedPlaceholders, isErrorPlaceholder, provenanceOf, unemittedModuleProvenance, unresolvedInTreeProvenance, } from './deep-walk.js';
 export function selfCheckStub(args) {
@@ -43,7 +43,7 @@ export function selfCheckStub(args) {
             const p = path.join(dir, entry.name);
             if (entry.isDirectory())
                 walk(p);
-            else if (entry.name.endsWith('.d.ts'))
+            else if (isDeclarationFileName(entry.name))
                 treeFiles.push(p);
         }
     };
@@ -247,6 +247,13 @@ function buildSurfaceSpanIndex(surfaceSource) {
         return spans.find((span) => position >= span.start && position <= span.end)?.alias;
     };
 }
+/**
+ * carrick#1842: a literal anchor whose text is a body read as raw text passes
+ * that mark to its record, where the check phase reads it.
+ */
+function rawTextMark(request) {
+    return request.kind === 'literal' && request.raw_text_read ? { raw_text_read: true } : {};
+}
 /** An alias that never reached a capture-native tier: the failure reason was
  * recorded at demotion time; the surface line is `unknown` by construction. */
 function demotedRecord(anchor) {
@@ -267,6 +274,7 @@ function demotedRecord(anchor) {
         ...(anchor.request.kind === 'literal' && anchor.namesUnemittedModule
             ? { unresolved_in_tree: [unemittedModuleProvenance()] }
             : {}),
+        ...rawTextMark(anchor.request),
     };
 }
 function checkedRecord(anchor, ctx) {
@@ -448,6 +456,7 @@ function checkedRecord(anchor, ctx) {
                     .map((p) => unresolvedInTreeProvenance(p, [...unfoundNames].sort())),
             }
             : {}),
+        ...rawTextMark(anchor.request),
     };
 }
 /** Resolve a relative specifier from `fromAbs` to a tree file, if present. */
@@ -455,15 +464,5 @@ function resolveTreeSpecifier(fromAbs, spec, tree) {
     if (!isRelative(spec))
         return undefined;
     const base = path.resolve(path.dirname(fromAbs), spec);
-    const candidates = [
-        `${base}.d.ts`,
-        path.join(base, 'index.d.ts'),
-        base.endsWith('.js') ? `${base.slice(0, -3)}.d.ts` : undefined,
-        base, // already .d.ts
-    ].filter((c) => c !== undefined);
-    for (const candidate of candidates) {
-        if (tree.has(candidate))
-            return candidate;
-    }
-    return undefined;
+    return declarationCandidates(base).find((candidate) => tree.has(candidate));
 }

package/sidecar/dist/src/capture/service-config.d.ts

@@ -17,3 +17,5 @@
  */
 /** Absolute path of the config that types the service, or undefined for none. */
 export declare function findServiceTsconfig(serviceRoot: string, scanRoot?: string): string | undefined;
+/** The path with every symlink resolved; the path as given when it does not exist. */
+export declare function realPath(p: string): string;

package/sidecar/dist/src/capture/service-config.js

@@ -47,7 +47,7 @@ export function findServiceTsconfig(serviceRoot, scanRoot) {
     return undefined;
 }
 /** The path with every symlink resolved; the path as given when it does not exist. */
-function realPath(p) {
+export function realPath(p) {
     try {
         return fs.realpathSync(p);
     }

package/sidecar/dist/src/capture/specifiers.d.ts

@@ -4,6 +4,20 @@
  * pattern matching for the post-emit rewrite pass.
  */
 export declare function isRelative(spec: string): boolean;
+/** A declaration file of any module format: `.d.ts`, `.d.mts`, `.d.cts`. */
+export declare function isDeclarationFileName(name: string): boolean;
+/**
+ * The declaration files a relative specifier can name in a stub's tree, in
+ * the order tried, given the path it resolves to from the file that holds it.
+ *
+ * A specifier names its module with no extension (`./a`: `a.d.ts`, or the
+ * directory's `index.d.ts`), by the file the module compiles to (`./a.js`:
+ * `a.d.ts`, `./a.mjs`: `a.d.mts`, `./a.cjs`: `a.d.cts`), or by the
+ * declaration file itself. The surface names an anchor's module the second
+ * way where the first does not resolve (carrick#1911), and so does any source
+ * written for `node16`..`nodenext`.
+ */
+export declare function declarationCandidates(resolved: string): string[];
 /** zod -> zod, @scope/pkg/sub -> @scope/pkg, pkg/sub -> pkg */
 export declare function packageNameOf(spec: string): string;
 /** Extract every module specifier mentioned in a .d.ts text: `from "x"`,

package/sidecar/dist/src/capture/specifiers.js

@@ -3,9 +3,34 @@
  * declaration text, external/internal classification, and tsconfig-`paths`
  * pattern matching for the post-emit rewrite pass.
  */
+import * as path from 'node:path';
 export function isRelative(spec) {
     return spec.startsWith('./') || spec.startsWith('../') || spec.startsWith('/');
 }
+/** A declaration file of any module format: `.d.ts`, `.d.mts`, `.d.cts`. */
+export function isDeclarationFileName(name) {
+    return /\.d\.[cm]?ts$/.test(name);
+}
+/**
+ * The declaration files a relative specifier can name in a stub's tree, in
+ * the order tried, given the path it resolves to from the file that holds it.
+ *
+ * A specifier names its module with no extension (`./a`: `a.d.ts`, or the
+ * directory's `index.d.ts`), by the file the module compiles to (`./a.js`:
+ * `a.d.ts`, `./a.mjs`: `a.d.mts`, `./a.cjs`: `a.d.cts`), or by the
+ * declaration file itself. The surface names an anchor's module the second
+ * way where the first does not resolve (carrick#1911), and so does any source
+ * written for `node16`..`nodenext`.
+ */
+export function declarationCandidates(resolved) {
+    const output = /\.([cm]?)jsx?$/.exec(resolved);
+    return [
+        `${resolved}.d.ts`,
+        path.join(resolved, 'index.d.ts'),
+        ...(output ? [`${resolved.slice(0, output.index)}.d.${output[1]}ts`] : []),
+        resolved,
+    ];
+}
 /** zod -> zod, @scope/pkg/sub -> @scope/pkg, pkg/sub -> pkg */
 export function packageNameOf(spec) {
     const parts = spec.split('/');

package/sidecar/dist/src/failure-path.d.ts

@@ -20,17 +20,48 @@
  * any other condition lets everything through. A node is on the failure path
  * only when NO status in 200-299 can reach it.
  *
- * That is deliberately stricter than the retype check's reading of a status
- * test (`okWhenTrue` in retype.ts), which reads the false side of
- * `res.status === 200` as the failure path so it can find a success read to
+ * The retype check (retype.ts) reads the same tests through `testsOnPath` and
+ * keeps its own policy on top: it also reads the false side of
+ * `res.status === 200` as the failure path, so it can find a success read to
  * judge. Here a decided failure REMOVES a read, so the reading has to be sound
  * the other way round: after `if (res.status === 204) return null`, 200 still
  * gets through, and the json read that follows is the payload.
  */
 import { Node } from 'ts-morph';
+/** A set of HTTP statuses, as the predicate that admits them. */
+export type Statuses = (status: number) => boolean;
+/** The statuses `ok` is true for. */
+export declare const SUCCEEDED: Statuses;
+/** The statuses from 100 to 599 that `statuses` admits, in order. */
+export declare function statusesIn(statuses: Statuses): number[];
+/** One test of the response on the path to a node, as the side the node is on. */
+export interface SideTaken {
+    /** Every status that can take this side, and maybe more (see `inexact`). */
+    admits: Statuses;
+    /**
+     * The test reads the response's `ok` or `status` in a form this reading
+     * cannot follow (`res.status === OK`, `codes.includes(res.status)`), or
+     * combines it with a condition that is not about the response
+     * (`res.ok && fresh`). `admits` then lets through more statuses than the
+     * side does: still sound for "no success status reaches the node", but no
+     * longer only the statuses the source singled out.
+     */
+    inexact: boolean;
+}
 /**
  * True when the source reaches `node` only after the response named by
  * `isResponse` failed. The walk climbs from `node` to `boundary` (the function
  * the call sits in) and never looks at a test outside it.
  */
 export declare function reachedOnlyOnFailure(node: Node, boundary: Node, isResponse: (node: Node) => boolean): boolean;
+/**
+ * Each test of the response on the path from `node` up to `boundary` (the
+ * whole file when it is `undefined`), as the side `node` is on: a branch of
+ * an `if` or a conditional expression it sits in, or an earlier `if` in an
+ * enclosing block one of whose branches cannot complete, which leaves the
+ * rest of the block to the other side. A test that does not read the
+ * response's `ok` or `status` is not listed.
+ */
+export declare function testsOnPath(node: Node, boundary: Node | undefined, isResponse: (node: Node) => boolean): SideTaken[];
+/** `node` reads the response's `ok` or `status`, itself or anywhere inside it. */
+export declare function readsResponseStatus(node: Node, isResponse: (node: Node) => boolean): boolean;

package/sidecar/dist/src/failure-path.js

@@ -20,9 +20,9 @@
  * any other condition lets everything through. A node is on the failure path
  * only when NO status in 200-299 can reach it.
  *
- * That is deliberately stricter than the retype check's reading of a status
- * test (`okWhenTrue` in retype.ts), which reads the false side of
- * `res.status === 200` as the failure path so it can find a success read to
+ * The retype check (retype.ts) reads the same tests through `testsOnPath` and
+ * keeps its own policy on top: it also reads the false side of
+ * `res.status === 200` as the failure path, so it can find a success read to
  * judge. Here a decided failure REMOVES a read, so the reading has to be sound
  * the other way round: after `if (res.status === 204) return null`, 200 still
  * gets through, and the json read that follows is the payload.
@@ -32,38 +32,62 @@ const FIRST_STATUS = 100;
 const LAST_STATUS = 599;
 const EVERY_STATUS = () => true;
 /** The statuses `ok` is true for. */
-const SUCCEEDED = (status) => status >= 200 && status <= 299;
-const UNDECIDED = { whenTrue: EVERY_STATUS, whenFalse: EVERY_STATUS };
+export const SUCCEEDED = (status) => status >= 200 && status <= 299;
+/** The statuses from 100 to 599 that `statuses` admits, in order. */
+export function statusesIn(statuses) {
+    const admitted = [];
+    for (let status = FIRST_STATUS; status <= LAST_STATUS; status++) {
+        if (statuses(status))
+            admitted.push(status);
+    }
+    return admitted;
+}
+/** A condition that does not read the response's `ok` or `status`. */
+const UNRELATED = { whenTrue: EVERY_STATUS, whenFalse: EVERY_STATUS, inexact: false };
+/** A condition that reads the response's status in a form this reading cannot follow. */
+const UNREAD = { whenTrue: EVERY_STATUS, whenFalse: EVERY_STATUS, inexact: true };
 /**
  * True when the source reaches `node` only after the response named by
  * `isResponse` failed. The walk climbs from `node` to `boundary` (the function
  * the call sits in) and never looks at a test outside it.
  */
 export function reachedOnlyOnFailure(node, boundary, isResponse) {
-    let admitted = EVERY_STATUS;
-    let narrowed = false;
-    const narrow = (by) => {
-        if (by === EVERY_STATUS)
+    const sides = testsOnPath(node, boundary, isResponse);
+    if (sides.length === 0)
+        return false;
+    const reaching = statusesIn((status) => sides.every((side) => side.admits(status)));
+    return reaching.length > 0 && !reaching.some(SUCCEEDED);
+}
+/**
+ * Each test of the response on the path from `node` up to `boundary` (the
+ * whole file when it is `undefined`), as the side `node` is on: a branch of
+ * an `if` or a conditional expression it sits in, or an earlier `if` in an
+ * enclosing block one of whose branches cannot complete, which leaves the
+ * rest of the block to the other side. A test that does not read the
+ * response's `ok` or `status` is not listed.
+ */
+export function testsOnPath(node, boundary, isResponse) {
+    const sides = [];
+    const take = (test, whenTrue) => {
+        if (test === UNRELATED)
             return;
-        const before = admitted;
-        admitted = (status) => before(status) && by(status);
-        narrowed = true;
+        sides.push({ admits: whenTrue ? test.whenTrue : test.whenFalse, inexact: test.inexact });
     };
     for (let child = node, parent = node.getParent(); parent && parent !== boundary; child = parent, parent = parent.getParent()) {
         if (Node.isIfStatement(parent)) {
             if (child === parent.getThenStatement()) {
-                narrow(readTest(parent.getExpression(), isResponse).whenTrue);
+                take(readTest(parent.getExpression(), isResponse), true);
             }
             else if (child === parent.getElseStatement()) {
-                narrow(readTest(parent.getExpression(), isResponse).whenFalse);
+                take(readTest(parent.getExpression(), isResponse), false);
             }
         }
         else if (Node.isConditionalExpression(parent)) {
             if (child === parent.getWhenTrue()) {
-                narrow(readTest(parent.getCondition(), isResponse).whenTrue);
+                take(readTest(parent.getCondition(), isResponse), true);
             }
             else if (child === parent.getWhenFalse()) {
-                narrow(readTest(parent.getCondition(), isResponse).whenFalse);
+                take(readTest(parent.getCondition(), isResponse), false);
             }
         }
         if (Node.isBlock(parent) ||
@@ -79,25 +103,15 @@ export function reachedOnlyOnFailure(node, boundary, isResponse) {
                 const thenLeaves = cannotComplete(statement.getThenStatement());
                 const elseLeaves = otherwise !== undefined && cannotComplete(otherwise);
                 if (thenLeaves && !elseLeaves) {
-                    narrow(readTest(statement.getExpression(), isResponse).whenFalse);
+                    take(readTest(statement.getExpression(), isResponse), false);
                 }
                 else if (elseLeaves && !thenLeaves) {
-                    narrow(readTest(statement.getExpression(), isResponse).whenTrue);
+                    take(readTest(statement.getExpression(), isResponse), true);
                 }
             }
         }
     }
-    if (!narrowed)
-        return false;
-    let reachable = false;
-    for (let status = FIRST_STATUS; status <= LAST_STATUS; status++) {
-        if (!admitted(status))
-            continue;
-        if (SUCCEEDED(status))
-            return false;
-        reachable = true;
-    }
-    return reachable;
+    return sides;
 }
 /** The statuses `condition` lets through when it is true and when it is false. */
 function readTest(condition, isResponse) {
@@ -107,10 +121,12 @@ function readTest(condition, isResponse) {
     if (Node.isPrefixUnaryExpression(test) &&
         test.getOperatorToken() === SyntaxKind.ExclamationToken) {
         const inner = readTest(test.getOperand(), isResponse);
-        return { whenTrue: inner.whenFalse, whenFalse: inner.whenTrue };
+        if (inner === UNRELATED || inner === UNREAD)
+            return inner;
+        return { whenTrue: inner.whenFalse, whenFalse: inner.whenTrue, inexact: inner.inexact };
     }
     if (isMemberOfResponse(test, 'ok', isResponse)) {
-        return { whenTrue: SUCCEEDED, whenFalse: (status) => !SUCCEEDED(status) };
+        return { whenTrue: SUCCEEDED, whenFalse: (status) => !SUCCEEDED(status), inexact: false };
     }
     if (Node.isBinaryExpression(test)) {
         const operator = test.getOperatorToken().getKind();
@@ -118,24 +134,27 @@ function readTest(condition, isResponse) {
             operator === SyntaxKind.BarBarToken) {
             const left = readTest(test.getLeft(), isResponse);
             const right = readTest(test.getRight(), isResponse);
-            if (left === UNDECIDED && right === UNDECIDED)
-                return UNDECIDED;
+            if (left === UNRELATED && right === UNRELATED)
+                return UNRELATED;
+            const inexact = left.inexact || right.inexact || left === UNRELATED || right === UNRELATED;
             return operator === SyntaxKind.AmpersandAmpersandToken
                 ? {
                     whenTrue: (status) => left.whenTrue(status) && right.whenTrue(status),
                     whenFalse: (status) => left.whenFalse(status) || right.whenFalse(status),
+                    inexact,
                 }
                 : {
                     whenTrue: (status) => left.whenTrue(status) || right.whenTrue(status),
                     whenFalse: (status) => left.whenFalse(status) && right.whenFalse(status),
+                    inexact,
                 };
         }
         const compared = statusComparison(test.getLeft(), operator, test.getRight(), isResponse);
         if (compared) {
-            return { whenTrue: compared, whenFalse: (status) => !compared(status) };
+            return { whenTrue: compared, whenFalse: (status) => !compared(status), inexact: false };
         }
     }
-    return UNDECIDED;
+    return readsResponseStatus(test, isResponse) ? UNREAD : UNRELATED;
 }
 /**
  * `res.status <op> N` or `N <op> res.status`, as the statuses it is true for;
@@ -186,6 +205,11 @@ function isMemberOfResponse(node, name, isResponse) {
         node.getName() === name &&
         isResponse(node.getExpression()));
 }
+/** `node` reads the response's `ok` or `status`, itself or anywhere inside it. */
+export function readsResponseStatus(node, isResponse) {
+    return [node, ...node.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)].some((inner) => isMemberOfResponse(inner, 'ok', isResponse) ||
+        isMemberOfResponse(inner, 'status', isResponse));
+}
 /**
  * A statement that never runs on into the statement after it: it returns,
  * throws, breaks or continues, or every path through it does. A loop, a

package/sidecar/dist/src/function-line-index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The function a line names, from an index built once per source file
+ * (carrick#1915).
+ *
+ * A signature request carries only the line its function starts on, and a
+ * signature pass sends one request per unannotated slot: thousands of
+ * lookups, several per function and many per file. Answering each by walking
+ * the file's every node cost the file's size per slot, and was 81% of the
+ * pass on a 2,345-file program. Here the file is walked once, over the
+ * compiler's own nodes, and each lookup reads the few entries near its line.
+ *
+ * The index belongs to the compiler's source file node, not to the file's
+ * name: replacing a file's text gives it a new node, so a file rewritten for
+ * one reading (the unwidened reading, the retype check) and then restored is
+ * indexed again each time, and never answered from positions it no longer has.
+ */
+import { type ArrowFunction, type FunctionDeclaration, type FunctionExpression, type MethodDeclaration, type SourceFile } from 'ts-morph';
+/** The declarations a line can name. */
+export type LineFunction = FunctionDeclaration | ArrowFunction | FunctionExpression | MethodDeclaration;
+/**
+ * The function whose declaration starts at, or within `LINE_TOLERANCE` lines
+ * of, the given line: the closest, then the smallest, then the first in the
+ * file. A function starting after the line is passed over when a statement
+ * that opens on the line or after it, on a line before the function's, does
+ * not contain the function. Undefined when no function is left.
+ *
+ * These are `TypeInferrer.findFunctionByLine`'s rules, which says why each is
+ * there; this is where they are computed.
+ */
+export declare function functionAtLine(sourceFile: SourceFile, line: number): LineFunction | undefined;