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

package/dist/src/type-parameter-reads.js

@@ -0,0 +1,172 @@
+/**
+ * The members a read through a value typed by a type parameter reaches: `value.kind`,
+ * where `value` is of a type parameter `T` of a generic function, reads `kind` on each
+ * object type no class declares that a call of the function passes for `T`, because the
+ * call's value is what the read reads, whatever member of the constraint the name resolves
+ * to. A class's members a constraint requires are interface satisfaction's.
+ */
+import { isBinaryExpression, isCallExpression, isIdentifier, isNewExpression, isPropertyAccessExpression, isTypeParameterDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { isAnswered } from "./query.js";
+/** How deep a parameter's type is matched against the type a call passes: `readonly T[]` is one level. */
+const MATCH_DEPTH = 3;
+/** The name a call reaches one generic by: its own, or that of what holds it. */
+function nameOf(generic) {
+    const own = generic.name;
+    const holder = generic.parent?.name;
+    const name = own ?? holder;
+    return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+/** Whether a property access is the target of a plain assignment, which writes the member. */
+function assignedTo(access) {
+    const parent = access.parent;
+    return (isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+        parent.left === access);
+}
+/**
+ * The references the reads through type-parameter-typed values of one project's own files
+ * make to the members of the types its calls pass, each made by the declaration holding
+ * the read.
+ */
+export function typeParameterReads(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const reads = [];
+    const calls = [];
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const visit = (node, from, generic) => {
+            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
+            const inside = generic ||
+                node.typeParameters !== undefined;
+            if (inside &&
+                isPropertyAccessExpression(node) &&
+                isIdentifier(node.name) &&
+                !assignedTo(node)) {
+                reads.push({ file, from: holder, access: node });
+            }
+            if (isCallExpression(node) || isNewExpression(node)) {
+                calls.push(node);
+            }
+            node.forEachChild((child) => {
+                visit(child, holder, inside);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId, false);
+        });
+    }
+    if (reads.length === 0) {
+        return [];
+    }
+    // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
+    const receivers = queries.typesAt(reads.map((read) => read.access.expression));
+    const byGeneric = new Map();
+    reads.forEach((read, at) => {
+        const type = receivers[at];
+        if (type === undefined || !isAnswered(type) || !type.isTypeParameter()) {
+            return;
+        }
+        const symbol = queries.symbolOfType(type);
+        const declaration = symbol === undefined || !isAnswered(symbol)
+            ? undefined
+            : symbol.declarations
+                .map((handle) => project.declarationAt(handle)?.node)
+                .find((node) => node !== undefined && isTypeParameterDeclaration(node));
+        const generic = declaration?.parent;
+        if (generic !== undefined) {
+            byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
+        }
+    });
+    if (byGeneric.size === 0) {
+        return [];
+    }
+    /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+    const passedFor = (parameter, declared, instantiated, depth) => {
+        if (declared.id === parameter.id) {
+            return [instantiated];
+        }
+        if (depth >= MATCH_DEPTH) {
+            return [];
+        }
+        const a = queries.typeArguments(declared);
+        const b = queries.typeArguments(instantiated);
+        if (!isAnswered(a) || !isAnswered(b) || a.length !== b.length) {
+            return [];
+        }
+        return a.flatMap((one, at) => {
+            const other = b[at];
+            return other === undefined ? [] : passedFor(parameter, one, other, depth + 1);
+        });
+    };
+    // Only a call spelling a generic's name is resolved: one request each.
+    const spelled = new Set([...byGeneric.keys()].flatMap((generic) => nameOf(generic) ?? []));
+    const found = new Map();
+    for (const call of calls) {
+        const callee = call.expression;
+        const written = isIdentifier(callee)
+            ? callee.text
+            : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+                ? callee.name.text
+                : undefined;
+        if (written === undefined || !spelled.has(written)) {
+            continue;
+        }
+        const resolved = queries.resolvedSignature(call);
+        if (resolved === undefined || !isAnswered(resolved) || resolved.declaration === undefined) {
+            continue;
+        }
+        const generic = project.declarationAt(resolved.declaration)?.node;
+        const pending = generic === undefined ? undefined : byGeneric.get(generic);
+        const declared = pending === undefined ? undefined : queries.genericOf(resolved);
+        if (pending === undefined || declared === undefined || !isAnswered(declared)) {
+            continue;
+        }
+        const count = (generic?.parameters ?? []).length;
+        for (const { read, parameter } of pending) {
+            const passed = [];
+            for (let at = 0; at < count; at += 1) {
+                const own = queries.parameterType(declared, at);
+                const given = queries.typeAtPosition(resolved, at);
+                if (own !== undefined && isAnswered(own) && isAnswered(given)) {
+                    passed.push(...passedFor(parameter, own, given, 0));
+                }
+            }
+            const name = read.access.name.text;
+            const position = renderPosition(read.file, root, read.access.name.getStart());
+            for (const type of passed) {
+                const parts = type.isUnionType() ? queries.constituents(type) : [type];
+                for (const part of isAnswered(parts) ? parts : []) {
+                    const owner = queries.symbolOfType(part);
+                    if (!isAnswered(owner) ||
+                        owner === undefined ||
+                        (owner.flags & SymbolFlags.Class) !== 0) {
+                        continue;
+                    }
+                    const properties = queries.propertiesOf(part);
+                    for (const property of isAnswered(properties) ? properties : []) {
+                        if (property.name !== name) {
+                            continue;
+                        }
+                        for (const to of chains.declarationsOf(property)) {
+                            found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
+                                from: read.from,
+                                to,
+                                position,
+                                use: "read",
+                                resolution: "batch",
+                                test: testFiles.has(position.path),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return [...found.values()];
+}

package/dist/src/verbs/analyze.js

@@ -62,6 +62,21 @@ function runRelative(invoked, path) {
     }
     return below;
 }
+/**
+ * One note per manifest entry the run reads back to no source file: what the entry names
+ * reaches nothing, so the findings its file would have rooted are reported.
+ */
+function unmappedNotes(entries, targetRoot) {
+    return entries.map((entry) => {
+        const named = relativePath(targetRoot, entry.path) ?? entry.path;
+        return {
+            kind: "unmapped-entry",
+            path: relativePath(targetRoot, entry.dir) ?? ".",
+            key: "ts.entry_files",
+            message: `the manifest's ${entry.member} names ${named}, which reads back to no source file of the target: name the file it is built from in ts.entry_files`,
+        };
+    });
+}
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped, targetRoot) {
     return dropped.map((one) => {
@@ -207,6 +222,7 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             typeErrorSkips: run.typeErrorSkips,
             unanswered: unansweredCounts(analysis),
             conventionsApplied: run.conventionsApplied,
+            notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
         });
         report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
         verdict = verdictOf(result, config);

package/dist/src/verbs/explain.js

@@ -257,11 +257,13 @@ function reported(found) {
 /**
  * Every finding of the run that names the declaration by its reference and reports at
  * another position: a part of it, or a suppression record naming it. Each is published under
- * the reference asked about, so an explanation leaving it out would disagree with the report.
+ * the reference asked about, or a parameter's under one it starts, so an explanation leaving
+ * it out would disagree with the report.
  */
 function namedElsewhere(findings, subject) {
     return findings
-        .filter((found) => found.symbol.ref === subject.ref && positionKey(found.position) !== subject.id)
+        .filter((found) => (found.symbol.holder ?? found.symbol.ref) === subject.ref &&
+        positionKey(found.position) !== subject.id)
         .map((found) => `also reported: ${found.code} ${found.kind}\t${positionKey(found.position)}\t${found.symbol.kind} ${found.symbol.name}\n`)
         .join("");
 }

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "7.2.0";
+export const CONTRACT_VERSION = "8.0.0";

package/dist/src/workflow-steps.js

@@ -1,18 +1,33 @@
 /**
- * The source files a CI workflow's `run:` steps name by their path from the target root.
- * A workflow file is read as text, line by line, with no YAML parsed.
+ * The source files a CI workflow's `run:` steps and the repository's git hooks name by their
+ * path from the target root. A workflow or hook file is read as text, line by line, with no
+ * YAML parsed.
  */
 import { scriptTokens } from "./manifest.js";
-import { joinPath, resolvePath } from "./paths.js";
+import { joinPath, relativePath, resolvePath } from "./paths.js";
 const WORKFLOWS = ".github/workflows";
 /** A line holding a run command: indentation and one sequence marker before `run:`. */
 const RUN_LINE = /^(\s*(?:- )?)run:(.*)$/u;
+/** The directories whose every file is a git hook script, run as the shell runs it. */
+const HOOK_DIRS = [".husky", ".githooks"];
+/** The hook manager files whose commands are written under a key, with that key. */
+const HOOK_MANAGERS = [
+    [".pre-commit-config.yaml", /^(\s*(?:- )?)entry:(.*)$/u],
+    ["lefthook.yml", RUN_LINE],
+    ["lefthook.yaml", RUN_LINE],
+    [".lefthook.yml", RUN_LINE],
+];
+/** The names GNU make reads a makefile under, in the order it tries them. */
+const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"];
+/** The operators that end one shell command of a recipe line. */
+const COMMAND_SEPARATORS = /&&|\|\||;|\|/u;
 const BLOCK_SCALAR = /^[|>][+-]?$/u;
 const QUOTED = /^(["'])(.*)\1$/su;
 /** A token holding one of these is computed or a pattern, so it names no file. */
 const COMPUTED = /[${*?[]/u;
 const INDENT = /^\s*/u;
-function workflowFiles(host, dir) {
+/** The files directly in one directory whose name `accepts`, in name order. */
+function filesIn(host, dir, accepts) {
     let entries;
     try {
         entries = host.readDirectory(dir);
@@ -21,16 +36,24 @@ function workflowFiles(host, dir) {
         return [];
     }
     return entries
-        .filter((entry) => !entry.directory && /\.ya?ml$/u.test(entry.name))
+        .filter((entry) => !entry.directory && accepts(entry.name))
         .map((entry) => joinPath(dir, entry.name))
         .sort();
 }
-/** Every command line one workflow file's `run:` steps hold. */
-export function runCommands(text) {
+function readText(host, path) {
+    try {
+        return host.readFile(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Every command line one workflow file's `run:` steps, or the steps under `key`, hold. */
+export function runCommands(text, key = RUN_LINE) {
     const lines = text.split(/\r?\n/u);
     const found = [];
     for (let at = 0; at < lines.length; at += 1) {
-        const match = RUN_LINE.exec(lines[at] ?? "");
+        const match = key.exec(lines[at] ?? "");
         if (match === null) {
             continue;
         }
@@ -50,28 +73,92 @@ export function runCommands(text) {
     }
     return found;
 }
-/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
-export function workflowTokens(host, targetRoot) {
-    const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
+/**
+ * Every token the recipe lines of the target root's makefile hold, each with the directory
+ * below the root it is read against: a recipe line is one that starts with a tab, joined
+ * with the lines a trailing `\` continues it onto, and make runs each in a shell of its
+ * own, so a `cd` moves the directory of the later commands of its line alone.
+ */
+function recipeTokens(host, root) {
+    const path = MAKEFILES.map((name) => joinPath(root, name)).find((candidate) => host.kindOf(candidate) === "file");
+    const text = path === undefined ? undefined : readText(host, path);
+    if (text === undefined) {
+        return [];
+    }
     const found = [];
-    for (const path of workflowFiles(host, dir)) {
-        let text;
-        try {
-            text = host.readFile(path);
-        }
-        catch {
+    for (const line of text.replace(/\\\r?\n/gu, " ").split(/\r?\n/u)) {
+        if (!line.startsWith("\t")) {
             continue;
         }
-        for (const command of runCommands(text)) {
-            found.push(...scriptTokens(command));
+        let dir = root;
+        for (const command of withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS)) {
+            const tokens = scriptTokens(command);
+            const [first, target, ...rest] = tokens;
+            if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
+                dir = resolvePath(dir, target);
+                continue;
+            }
+            for (const token of tokens) {
+                found.push({ token, dir: relativePath(root, dir) ?? "" });
+            }
         }
     }
     return found;
 }
+/** One shell line up to its comment: a `#` that starts a word outside quotes. */
+function withoutComment(line) {
+    let quote = "";
+    for (let at = 0; at < line.length; at += 1) {
+        const char = line[at];
+        if (quote !== "") {
+            if (char === quote) {
+                quote = "";
+            }
+            else if (char === "\\" && quote === '"') {
+                at += 1;
+            }
+        }
+        else if (char === "'" || char === '"') {
+            quote = char;
+        }
+        else if (char === "\\") {
+            at += 1;
+        }
+        else if (char === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
+            return line.slice(0, at);
+        }
+    }
+    return line;
+}
+/**
+ * Every token the target root's workflow steps, git hooks and makefile hold: the `run:`
+ * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
+ * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
+ * of a lefthook file and the makefile's recipe lines.
+ */
+export function workflowTokens(host, targetRoot) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const commands = [];
+    for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
+        commands.push(...runCommands(readText(host, path) ?? ""));
+    }
+    for (const dir of HOOK_DIRS) {
+        for (const path of filesIn(host, joinPath(root, dir), () => true)) {
+            commands.push(...(readText(host, path) ?? "").split(/\r?\n/u).map(withoutComment));
+        }
+    }
+    for (const [name, key] of HOOK_MANAGERS) {
+        commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
+    }
+    return [
+        ...commands.flatMap((command) => scriptTokens(command)),
+        ...recipeTokens(host, root).map(({ token }) => token),
+    ];
+}
 /**
- * The own files the `run:` steps of every workflow file in the target root's
- * `.github/workflows` name: a token equal to a file's path below the target root, with or
- * without a leading `./`, whatever directory the step runs in.
+ * The own files the target root's workflow steps and git hooks name, as
+ * {@link workflowTokens} reads them: a token equal to a file's path below the target root,
+ * with or without a leading `./`, whatever directory the step runs in.
  */
 export function workflowEntries(host, targetRoot, files) {
     const found = [];
@@ -84,5 +171,15 @@ export function workflowEntries(host, targetRoot, files) {
             found.push({ file, source: token });
         }
     }
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    for (const { token, dir } of recipeTokens(host, root)) {
+        const below = COMPUTED.test(token) || dir === ""
+            ? undefined
+            : relativePath(root, resolvePath(joinPath(root, dir), token));
+        const file = below === undefined ? undefined : files.byPath.get(below);
+        if (file !== undefined) {
+            found.push({ file, source: token });
+        }
+    }
     return found;
 }

package/dist/src/workspace-programs.js

@@ -7,18 +7,22 @@
  */
 import { ModuleKind, ModuleResolutionKind } from "@typescript/native/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/ast";
+import { baseUrlPaths } from "./base-url.js";
 import { dirnamePath, resolvePath } from "./paths.js";
 /** The most questions one round trip carries. */
 const BATCH = 2048;
 /**
  * The options a configuration's program is built with: its own, less the ones that
- * lay out an emitted program's inputs and outputs. The analysis emits nothing, and a
+ * lay out an emitted program's inputs and outputs, and with `paths` read against the
+ * effective `baseUrl` as {@link baseUrlPaths} states. The analysis emits nothing, and a
  * member's source is outside the importer's root directory by construction, which
  * the compiler refuses under such a layout.
  */
 function analysisOptions(parsed) {
     const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = parsed.options;
-    return composite === true ? { ...kept, declaration: true } : kept;
+    const paths = baseUrlPaths(parsed.options);
+    const options = paths === undefined ? kept : { ...kept, paths };
+    return composite === true ? { ...options, declaration: true } : options;
 }
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
 function conditionsOf(parsed, mode) {
@@ -73,7 +77,7 @@ function configurationOf(engine, host, reading) {
     const raw = options["pathsBasePath"];
     const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
     const paths = {};
-    for (const [key, targets] of Object.entries(options.paths ?? {})) {
+    for (const [key, targets] of Object.entries(baseUrlPaths(options) ?? options.paths ?? {})) {
         paths[key] = targets.map((target) => resolvePath(base, target));
     }
     for (const entry of reading.entries) {

package/dist/src/workspace-resolution.js

@@ -1,12 +1,12 @@
 /**
- * Which file an import of a workspace package's name is read from. The package is the
- * one `node_modules` links the importer to or, with no link, the one the importer's
- * manifest depends on. A source file the compiler reaches stands; any other file is read
- * back to the source it is compiled from or to a manifest target that is source, a file
- * the package's configurations neither compile nor write is read as installed, and an
- * import nothing answers for is unresolved.
+ * Which file an import of a workspace package's name is read from: the package
+ * `node_modules` links the importer to or, with no link, the one its manifest depends on.
+ * A source file the compiler reaches stands; any other file reads back to its source or to
+ * a manifest target that is source, an ignored file to the source its path mirrors, a file
+ * the package neither compiles nor writes is read as installed, and the rest is unresolved.
  */
 import { emittedFrom } from "./emit-map.js";
+import { gitIgnored } from "./git-ignore.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
 /** The manifest members that name an entry point for the subpath `.` without `exports`. */
@@ -163,6 +163,27 @@ export function workspaceResolver(host, workspace) {
         links.set(key, found);
         return found;
     };
+    const root = workspace.members[0]?.dir;
+    const ignored = root === undefined ? () => false : gitIgnored(host, root);
+    const manifests = new Map();
+    /** The nearest manifest at or above one directory, up to the workspace's root. */
+    const nearestManifest = (dir) => {
+        if (manifests.has(dir)) {
+            return manifests.get(dir);
+        }
+        let found;
+        try {
+            const value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+            found = isRecord(value) ? { dir, manifest: value } : undefined;
+        }
+        catch {
+            const up = dirnamePath(dir);
+            found =
+                up === dir || root === undefined || !inside(root, up) ? undefined : nearestManifest(up);
+        }
+        manifests.set(dir, found);
+        return found;
+    };
     const linkOf = (candidates, fromDir) => {
         const name = candidates[0]?.name ?? "";
         const linked = linkedFrom(name, fromDir);
@@ -174,13 +195,15 @@ export function workspaceResolver(host, workspace) {
         if (scope?.name === name) {
             return { kind: "member", member: scope };
         }
-        const manifest = scope?.manifest;
+        // A package below the root that no workspace lists depends on a member as a member does.
+        const owner = scope ?? nearestManifest(fromDir);
+        const manifest = owner?.manifest;
         const declared = DEPENDENCY_MEMBERS.flatMap((field) => {
             const held = manifest?.[field];
             const specifier = isRecord(held) ? held[name] : undefined;
             return typeof specifier === "string" ? [specifier] : [];
         });
-        const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, scope?.dir ?? fromDir)));
+        const matched = candidates.filter((member) => declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)));
         const [one, two] = matched;
         if (one === undefined) {
             return { kind: "none" };
@@ -191,6 +214,21 @@ export function workspaceResolver(host, workspace) {
     };
     /** The files a member's configurations compile, which is what makes a file there source. */
     const compiled = (member, path) => member.configurations.some((configuration) => configuration.fileNames.has(path));
+    /**
+     * The member's source an ignored output path mirrors: the path below one of its
+     * directories, the deepest first, read below the member's own directory as an output
+     * directory's tree mirrors its root directory's, which a build leaves in an ignored
+     * directory however its configuration writes it.
+     */
+    const mirrored = (member, path) => {
+        for (let dir = dirnamePath(path); inside(member.dir, dir); dir = dirnamePath(dir)) {
+            const found = emittedFrom(path, { outDir: dir, sourceDirs: [member.dir] }).find((candidate) => SOURCE.test(candidate) && !ignored(candidate) && host.kindOf(candidate) === "file");
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    };
     /**
      * The member's source one of its paths is, or is compiled from: a TypeScript source
      * file, the source an output path maps back to, or a file one of the member's
@@ -212,6 +250,9 @@ export function workspaceResolver(host, workspace) {
         if (found !== undefined) {
             return found;
         }
+        if (ignored(path)) {
+            return mirrored(member, path);
+        }
         return compiled(member, path) && host.kindOf(path) === "file" ? path : undefined;
     };
     /** The targets a member's manifest names for one subpath, the selected one first. */
@@ -270,9 +311,11 @@ export function workspaceResolver(host, workspace) {
             }
             const { member } = linked;
             // A member no compiler configuration builds is read as the package manager
-            // installed it, wherever the compiler's resolution found it.
+            // installed it, wherever the compiler's resolution found it, unless what it found is
+            // a file the tree ignores, which no install wrote.
             if (answered !== undefined &&
-                (member.configurations.length === 0 || !inside(member.dir, answered.resolvedFileName))) {
+                ((member.configurations.length === 0 && !ignored(answered.resolvedFileName)) ||
+                    !inside(member.dir, answered.resolvedFileName))) {
                 return { kind: "default" };
             }
             if (answered !== undefined) {

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.4",
+  "version": "8.0.0-dev.2",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.2.0-dev.4",
+  "version": "8.0.0-dev.2",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -43,7 +43,7 @@
     "@types/node": "24.19.2",
     "eslint": "10.12.0",
     "fast-check": "4.10.2",
-    "prettier": "3.9.9",
+    "prettier": "3.9.10",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.71.1",
     "vitest": "5.0.4"