@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.3

package/dist/src/conventions.js

@@ -12,7 +12,14 @@ import { documentStrings } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
+import { yamlDocument } from "./yaml-document.js";
 const JSON_EXTENSION = ".json";
+/**
+ * A configuration file its tool reads as a YAML document, read as the JSON document it
+ * denotes. Its nodes' offsets are that JSON text's, so no move may read one: a failure's
+ * line would name the wrong line.
+ */
+const YAML_NAME = /\.ya?ml$/u;
 /** A configuration file with no extension that its tool reads as a JSON document. */
 const JSON_RC = /^\.[\w-]+rc$/u;
 /** The sections an installed package is required by, so its absence fails the run. */
@@ -614,6 +621,14 @@ function readingFiles(host, parse, dir, files) {
             catch {
                 continue;
             }
+            if (YAML_NAME.test(name)) {
+                const value = yamlDocument(text);
+                if (value !== undefined) {
+                    const json = JSON.stringify(value);
+                    found.push({ name, text: json, file: parse(`${path}${JSON_EXTENSION}`, json) });
+                }
+                continue;
+            }
             found.push({
                 name,
                 text,

package/dist/src/dependencies.js

@@ -664,6 +664,91 @@ function scriptTokensOf(manifest) {
     }
     return found;
 }
+/**
+ * The runtime flags whose value is a module loaded before the entry, as `--flag value` or
+ * `--flag=value`: https://nodejs.org/api/cli.html#--importmodule,
+ * https://nodejs.org/api/cli.html#--experimental-loadermodule,
+ * https://nodejs.org/api/cli.html#-r---require-module
+ */
+const PRELOAD_FLAGS = new Set([
+    "--experimental-loader",
+    "--import",
+    "--loader",
+    "--require",
+    "-r",
+]);
+/**
+ * The programs that pass a preload flag to the runtime they start: Node itself, and the
+ * runners that forward Node's flags or read the same `--require`:
+ * https://mochajs.org/#-require-module-r-module, https://tsx.is/node-enhancement,
+ * https://typestrong.org/ts-node/docs/options#require,
+ * https://github.com/remy/nodemon#running-non-node-scripts
+ */
+const PRELOADING_PROGRAMS = new Set([
+    "mocha",
+    "node",
+    "nodemon",
+    "ts-node",
+    "tsx",
+]);
+/** The programs that run the command after them, and an environment assignment before it. */
+const LAUNCHERS = new Set(["cross-env", "env", "npx"]);
+const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/u;
+/** The commands one script string runs, split at the shell's list and pipeline operators. */
+const COMMAND_SEPARATORS = /&&|\|\||;|\||&/u;
+/**
+ * The packages one manifest's scripts preload by a runtime flag's bare module specifier,
+ * a flag counting only in a command whose program passes it to the runtime, and for Node
+ * only before the script it runs, whose own arguments come after it.
+ */
+function scriptPreloadsOf(manifest) {
+    const scripts = manifest["scripts"];
+    const found = new Set();
+    if (!isRecord(scripts)) {
+        return found;
+    }
+    for (const script of Object.values(scripts)) {
+        if (typeof script !== "string") {
+            continue;
+        }
+        for (const command of script.split(COMMAND_SEPARATORS)) {
+            const tokens = scriptTokens(command);
+            let at = 0;
+            while (at < tokens.length &&
+                (ASSIGNMENT.test(tokens[at] ?? "") || LAUNCHERS.has(tokens[at] ?? ""))) {
+                at += 1;
+            }
+            const path = tokens[at] ?? "";
+            const program = path.slice(path.lastIndexOf("/") + 1);
+            if (!PRELOADING_PROGRAMS.has(program)) {
+                continue;
+            }
+            for (at += 1; at < tokens.length; at += 1) {
+                const token = tokens[at] ?? "";
+                if (!token.startsWith("-")) {
+                    if (program === "node") {
+                        break;
+                    }
+                    continue;
+                }
+                const equals = token.indexOf("=");
+                const flag = equals < 0 ? token : token.slice(0, equals);
+                if (!PRELOAD_FLAGS.has(flag)) {
+                    continue;
+                }
+                if (equals < 0) {
+                    at += 1;
+                }
+                const value = equals < 0 ? tokens[at] : token.slice(equals + 1);
+                const name = value === undefined ? undefined : packageOfSpecifier(value);
+                if (name !== undefined) {
+                    found.add(name);
+                }
+            }
+        }
+    }
+    return found;
+}
 /** Whether a path below the target root lies in the directory `dir` below it, `""` being the root. */
 function isInside(path, dir) {
     return dir === "" || path.startsWith(`${dir}/`);
@@ -745,12 +830,16 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             continue;
         }
         const tokens = scriptTokensOf(read.value);
+        const preloads = scriptPreloadsOf(read.value);
         for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
             const found = installedOf(host, dir, dependency.name);
             if (found === undefined && uninstalledHere.has(dir)) {
                 continue;
             }
             declared.push(dependency);
+            if (preloads.has(dependency.name)) {
+                ran.add(declarationKey(dependency));
+            }
             if (found === undefined) {
                 continue;
             }

package/dist/src/entry-points.js

@@ -10,14 +10,16 @@
  * value that is not a literal is not evaluated and not guessed, so a file it would
  * have named is entered by nothing here.
  */
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
+import { buildScriptEntries } from "./build-scripts.js";
 import { globExpression } from "./glob.js";
 import { htmlEntries } from "./html-entries.js";
 import { documentEntries } from "./mdx-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
+import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.js";
 import { workflowEntries } from "./workflow-steps.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"];
@@ -210,7 +212,7 @@ function configurationEntries(host, targetRoot, files, parse, selected) {
         strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
     }
     for (const { file } of outside) {
-        strings(dirnamePath(file.fileName), moduleStrings(file).map((one) => one.text));
+        strings(dirnamePath(file.fileName), unselected(file));
     }
     return found;
 }
@@ -398,17 +400,6 @@ function workersOf(project, file, files) {
     }
     return found;
 }
-/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
-function leadingLiteral(node) {
-    const at = unwrapped(node);
-    if (isTemplateExpression(at)) {
-        return at.head.text;
-    }
-    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
-        return literalOf(unwrapped(at.left)) ?? leadingLiteral(at.left);
-    }
-    return undefined;
-}
 /** Whether one call is `import.meta.glob(...)`. */
 function isMetaGlob(node) {
     if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
@@ -432,11 +423,8 @@ function computedImportsOf(file, files) {
     const dir = dirnamePath(file.fileName);
     const found = [];
     const below = (prefix) => {
-        const target = resolvePath(dir, prefix);
-        if (!isModuleRelative(prefix) ||
-            !prefix.endsWith("/") ||
-            target === dir ||
-            relativePath(target, dir) !== undefined) {
+        const target = computedLoadDirectory(dir, prefix);
+        if (target === undefined) {
             return;
         }
         for (const candidate of files.byName.values()) {
@@ -522,6 +510,9 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse,
             ...(names === undefined ? {} : { names }),
         });
     }
+    for (const { file, source } of buildScriptEntries(host, targetRoot, files, parse)) {
+        found.push({ file, rule: "bundler-entry", source, exports: true });
+    }
     for (const { file, source } of workflowEntries(host, targetRoot, files)) {
         found.push({ file, rule: "workflow-step", source, exports: true });
     }

package/dist/src/findings/completion.js

@@ -105,6 +105,19 @@ function reachabilityClasses(input) {
         return published.has(id) ? outside : "certain";
     };
 }
+/**
+ * Whether one test of dead code references a target symbol that is published API of a run
+ * that declares no consumer, which outside programs the run cannot see may use, so the
+ * target counts as live for the test and the test is no test of dead code.
+ */
+export function testsUnseenAPI(input) {
+    if (input.boundary.consumers.declared.length > 0) {
+        return () => false;
+    }
+    const union = input.swept.matrix.union;
+    const published = publishedIds(union);
+    return (id) => testTargets(union, id).some((target) => published.has(target));
+}
 /** The target symbols one test of dead code references, by id: production declarations the sweep judges. */
 function testTargets(union, id) {
     return (union.out[union.at(id)] ?? []).flatMap((edge) => {
@@ -151,13 +164,16 @@ function testUsedSubjects(input) {
 }
 /**
  * The ceiling the roots the run found put on one dead subject: a subject other declarations
- * reference, found dead only because no root reaches them, is `probable` unless
- * the configuration declares the roots complete, because a root the analysis cannot see
- * would make it live; every other declaration has none below `certain`.
+ * reference, found dead only because no root reaches them, is `probable` unless the
+ * configuration declares the roots complete and no configuration holding the subject loads
+ * a module the analysis cannot resolve, because a root the analysis cannot see would make
+ * it live; every other declaration has none below `certain`.
  */
-function rootsCeiling(input, finding, candidate) {
+function rootsCeiling(input, finding, candidate, configurations) {
     const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
-    return unreachable && !input.config.ts.rootsComplete ? "probable" : "certain";
+    const unseen = new Set((input.files.unseenLoads ?? []).map((load) => load.configuration));
+    const complete = input.config.ts.rootsComplete && !configurations.some((one) => unseen.has(one));
+    return unreachable && !complete ? "probable" : "certain";
 }
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
@@ -170,8 +186,24 @@ function findingComponents(swept, components, cascade) {
             held.set(member, component);
         }
     }
+    const listed = membersListed(swept);
+    return (id) => {
+        const component = held.get(id);
+        return component === undefined
+            ? undefined
+            : {
+                id: component.id,
+                root: component.roots.includes(id),
+                symbolCount: component.members.length,
+                deletableLines: component.deletableLines,
+                ...(cascade === "full" ? { members: listed(component.members) } : {}),
+            };
+    };
+}
+/** The members of a component as the run lists them, positioned and in the canonical order. */
+function membersListed(swept) {
     const symbols = new Map(swept.matrix.union.symbols.map((symbol) => [symbol.id, symbol]));
-    const listed = (component) => component.members
+    return (members) => members
         .flatMap((member) => {
         const symbol = symbols.get(member);
         return symbol === undefined
@@ -188,18 +220,6 @@ function findingComponents(swept, components, cascade) {
             ];
     })
         .sort((a, b) => byPosition(a.position, b.position));
-    return (id) => {
-        const component = held.get(id);
-        return component === undefined
-            ? undefined
-            : {
-                id: component.id,
-                root: component.roots.includes(id),
-                symbolCount: component.members.length,
-                deletableLines: component.deletableLines,
-                ...(cascade === "full" ? { members: listed(component) } : {}),
-            };
-    };
 }
 /**
  * The run's dead components with each file a `DS1502` finding reports dead among them, so
@@ -277,11 +297,12 @@ export function completed(input, findings, kinds = KINDS) {
     let minted = computed;
     const dead = new Set(components.map((component) => component.id));
     const fallingWith = new Map();
-    for (const { heldByTests } of swept.sweep.candidates) {
+    for (const { id, heldByTests } of swept.sweep.candidates) {
         if (heldByTests !== undefined) {
-            fallingWith.set(heldByTests, (fallingWith.get(heldByTests) ?? 0) + 1);
+            fallingWith.set(heldByTests, [...(fallingWith.get(heldByTests) ?? []), id]);
         }
     }
+    const listed = membersListed(swept);
     const done = findings.map((finding) => {
         const row = kinds.get(finding.code);
         if (row === undefined) {
@@ -326,11 +347,25 @@ export function completed(input, findings, kinds = KINDS) {
         let component = found;
         if (component === undefined) {
             minted += 1;
+            const falling = symbol?.kind === "interface" ? fallingWith.get(symbol.id) : undefined;
             component = {
                 id: componentId(minted),
                 root: true,
-                symbolCount: symbol?.kind === "interface" ? (fallingWith.get(symbol.id) ?? 1) : 1,
+                symbolCount: falling?.length ?? 1,
                 deletableLines: 0,
+                ...(input.config.reporters.cascade !== "full"
+                    ? {}
+                    : falling === undefined
+                        ? {
+                            members: [
+                                {
+                                    ref: finding.symbol.ref,
+                                    name: finding.symbol.name,
+                                    position: finding.position,
+                                },
+                            ],
+                        }
+                        : { members: listed(falling) }),
             };
         }
         const counts = candidate === undefined
@@ -341,7 +376,11 @@ export function completed(input, findings, kinds = KINDS) {
             ? candidate !== undefined && testUsed.declarations.has(judged.id)
             : finding.code === FILE_NEVER_IMPORTED && testUsed.files.has(finding.position.path);
         const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
-        const untested = capped(capped(capped(ownClass, row.maxClass), rootsCeiling(input, finding, candidate)), judged === undefined ? "certain" : ceilingOf(judged.id));
+        const configurations = candidate?.configurations ??
+            (judged === undefined && !part
+                ? swept.matrix.configurations
+                : (swept.matrix.heldIn[at] ?? swept.matrix.configurations));
+        const untested = capped(capped(capped(ownClass, row.maxClass), rootsCeiling(input, finding, candidate, configurations)), judged === undefined ? "certain" : ceilingOf(judged.id));
         const generated = input.files.generated?.has(finding.position.path) === true;
         const fixability = generated
             ? "none"
@@ -372,10 +411,7 @@ export function completed(input, findings, kinds = KINDS) {
             generated,
             component,
             retainedBy: [],
-            configurations: candidate?.configurations ??
-                (judged === undefined && !part
-                    ? swept.matrix.configurations
-                    : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
+            configurations,
             consumersLoaded: input.boundary.consumers.loaded,
             fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),

package/dist/src/findings/intra-function.js

@@ -28,7 +28,8 @@ function overlapClause(overlap, part) {
  * caller may pass a function used as a value more arguments than it declares, so there one
  * a read parameter follows is renamed to an underscore name, which the compilers read as
  * declared unread, and one no read parameter follows is deleted: kept where the call's
- * inference may read its annotation, at `probable` where nothing reads the annotation.
+ * inference may read its annotation, at `probable` where nothing reads the annotation or
+ * where it is a name a contextually typed object pattern binds.
  */
 function parameterVerdict(part, free, freeButValued) {
     const place = part.parameter;
@@ -45,7 +46,8 @@ function parameterVerdict(part, free, freeButValued) {
     if (place?.annotated === "steers") {
         return undefined;
     }
-    return { fix: "delete", confidence: place?.annotated === "free" ? "probable" : "certain" };
+    const unseen = place?.annotated === "free" || place?.contextualPattern === true;
+    return { fix: "delete", confidence: unseen ? "probable" : "certain" };
 }
 /**
  * Whether one part is reported. A parameter needs its function's signature free to

package/dist/src/findings/reads-and-writes.js

@@ -1,7 +1,7 @@
 import { positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
-/** The containers whose type parameters `DS1303` reports: a function and a class method. */
-const SIGNATURES = new Set(["function", "method"]);
+/** The containers whose type parameters `DS1303` reports: a function, a class method and a type alias. */
+const SIGNATURES = new Set(["function", "method", "type"]);
 function indexed(input) {
     const { matrix, sweep } = input.swept;
     return {
@@ -165,10 +165,11 @@ function unusedEnumMembers(run) {
     return unnamed(run, "enum-member").map((symbol) => findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`));
 }
 /**
- * `DS1303`: a type parameter of a function or a class method that neither the
- * declaration's signature nor its body names. A type parameter of a class, an interface,
- * a type alias or a method signature belongs to a type declaration and is never
- * reported, because a phantom parameter makes two instantiations distinct types.
+ * `DS1303`: a type parameter of a function, a class method or a type alias that neither
+ * the declaration's signature nor its body names. An alias names no type of its own, so
+ * a parameter its type never names makes no two instantiations distinct. One of a class,
+ * an interface or a method signature is never reported: a class or an interface merges
+ * only with declarations of the same parameters.
  */
 function unusedTypeParameters(run) {
     return unnamed(run, "type-parameter")

package/dist/src/findings/unused-declarations.js

@@ -1,3 +1,4 @@
+import { testsUnseenAPI } from "./completion.js";
 import { unreachableExports } from "./visibility-narrowing.js";
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
 const MEMBERS = new Set([
@@ -48,7 +49,7 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
 function codeOf(judged) {
     const { candidate, symbol } = judged;
     if (candidate.testOfDeadCode) {
-        return "DS1005";
+        return judged.testsUnseenAPI ? undefined : "DS1005";
     }
     if ((judged.test && !candidate.unreferencedTest) || NOT_THIS_FAMILY.has(symbol.kind)) {
         return undefined;
@@ -199,6 +200,7 @@ function familyFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
+    const unseenAPI = testsUnseenAPI(input);
     let brands;
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
@@ -217,6 +219,7 @@ function familyFindings(input, fallen) {
             test: union.test[at] === true,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),
+            testsUnseenAPI: candidate.testOfDeadCode && unseenAPI(candidate.id),
         };
         const code = codeOf(judged);
         if (code === undefined ||

package/dist/src/graph.js

@@ -34,9 +34,9 @@ const SWEPT = {
  * Whether a root of each kind names a caller, which holds it live under both relations: a
  * tool reads what it loads and what its strings name, a runtime runs a test, setup or
  * worker file, a page's module script, a command, a script or a workflow step, the manifest
- * names what enters the package, an alias global stands for its export, and an entry file,
- * a configured root and a pattern assert a caller. A library's published API only supposes
- * an unseen consumer, so it is live under reachability alone.
+ * names what enters the package, an alias global stands for its export, an outside
+ * declaration names a global interface merging into it, and an entry file, a configured root
+ * and a pattern assert a caller. A published API supposes a consumer: reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
@@ -49,8 +49,10 @@ const NAMES_A_CALLER = {
     pattern: true,
     "type-error": true,
     "type-query-alias": true,
+    "global-augmentation": true,
     "configuration-file": true,
     "configuration-string": true,
+    "bundler-entry": true,
     "test-runner": true,
     "browser-tests": true,
     worker: true,

package/dist/src/intra-function-parts.js

@@ -772,10 +772,9 @@ function calleeSteers(project, signature, at) {
 }
 /**
  * The parts with each name of `contextual` judged where the compiler gives its function a
- * contextual type: the code handing the argument may act on what an object pattern reads,
- * so each such name is read, and an annotated parameter is marked with whether the call's
- * inference may read its annotation. A question the checker leaves unanswered keeps the
- * name read.
+ * contextual type: a name an object pattern binds is marked as one, and an annotated
+ * parameter with whether the call's inference may read its annotation. A question the
+ * checker leaves unanswered keeps the name read.
  */
 function withContextualRead(project, parts, contextual) {
     if (contextual.length === 0) {
@@ -791,15 +790,17 @@ function withContextualRead(project, parts, contextual) {
             continue;
         }
         const place = one.part.parameter;
-        judged.set(one.part, one.pattern || answer === UNANSWERED || place === undefined
+        judged.set(one.part, answer === UNANSWERED || place === undefined
             ? { ...one.part, used: true }
-            : {
-                ...one.part,
-                parameter: {
-                    ...place,
-                    annotated: calleeSteers(project, one.signature, one.at) ? "steers" : "free",
-                },
-            });
+            : one.pattern
+                ? { ...one.part, parameter: { ...place, contextualPattern: true } }
+                : {
+                    ...one.part,
+                    parameter: {
+                        ...place,
+                        annotated: calleeSteers(project, one.signature, one.at) ? "steers" : "free",
+                    },
+                });
     }
     return parts.map((part) => judged.get(part) ?? part);
 }
@@ -884,15 +885,28 @@ function functionOf(block) {
     }
 }
 /**
- * The locals one block declares with `let`, `const` or `var`, each with the names of the
- * block that spell it. A `var` of a nested block is one where no nested function of its
- * function names it, since the function scope holds it past the block's end.
+ * The locals one block declares with `let`, `const`, `var` or a function declaration
+ * inside a function, each with the names of the block that spell it. A `var` of a nested
+ * block is one where no nested function of its function names it, since the function scope
+ * holds it past the block's end.
  */
 function localsOf(block) {
     const declared = [];
     const scope = functionOf(block);
     const outlives = scope?.body !== block;
     block.statements.forEach((statement, at) => {
+        if (isFunctionDeclaration(statement)) {
+            if (scope !== undefined && statement.name !== undefined && statement.body !== undefined) {
+                declared.push({
+                    name: statement.name,
+                    statement: at,
+                    initialized: true,
+                    outlives: false,
+                    hoisted: true,
+                });
+            }
+            return;
+        }
         if (!isVariableStatement(statement)) {
             return;
         }
@@ -902,6 +916,11 @@ function localsOf(block) {
             return;
         }
         for (const declaration of list.declarations) {
+            // A write to a local typed `never` is the compiler's exhaustiveness check, which
+            // fails to compile once a case goes unhandled.
+            if (declaration.type?.kind === SyntaxKind.NeverKeyword) {
+                continue;
+            }
             for (const name of boundNames(declaration.name)) {
                 if (!blockScoped &&
                     outlives &&
@@ -913,6 +932,7 @@ function localsOf(block) {
                     statement: at,
                     initialized: declaration.initializer !== undefined,
                     outlives: !blockScoped && outlives,
+                    hoisted: false,
                 });
             }
         }
@@ -953,12 +973,20 @@ function deadStores(file, root, block, holder, locals, ids) {
         used: false,
     });
     for (const local of locals) {
-        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids));
+        const own = local.hoisted ? block.statements[local.statement] : undefined;
+        // A function's reads of itself keep it no more than its absence would.
+        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids) && (own === undefined || !within(use, own)));
         if (!local.outlives && uses.every(isPlainWrite)) {
-            const targets = [...(local.initialized ? [local.name] : []), ...uses];
+            // A declaration with no initializer writes `undefined`, the one store left to name.
+            const writes = [...(local.initialized ? [local.name] : []), ...uses];
+            const targets = writes.length === 0 ? [local.name] : writes;
             found.push(...targets.map((target) => deadAt(local, target)));
             continue;
         }
+        // A read anywhere in the block reads a function declaration, which is written first.
+        if (local.hoisted) {
+            continue;
+        }
         if (uses.some((use) => inNestedFunction(use, block))) {
             continue;
         }