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

package/dist/src/module-declarations.js

@@ -79,9 +79,6 @@ function namesModule(specifier, name) {
  * the members that hold the export names given.
  */
 function namedBy(held) {
-    if (held.modules.size === 0) {
-        return () => [];
-    }
     const refs = new Map();
     const children = new Map();
     for (const symbol of held.symbols) {

package/dist/src/ref.js

@@ -25,9 +25,10 @@ const TS_COMPUTED = String.raw `\[[^\]\r\n\t ]+\]`;
 const TS_HEAD = `(?:${TS_IDENT}|${TS_QUOTED})`;
 const TS_MEMBER = `(?:${TS_IDENT}|#${TS_IDENT}|${TS_QUOTED}|${TS_COMPUTED})`;
 const TS_PACKAGE = String.raw `(?:@[A-Za-z0-9._-]+/)?[A-Za-z0-9._-]+`;
-const TS_FILE = String.raw `(?:[^/#\r\n]+/)*[^/#\r\n]+(?:(?:\.d)?\.[mc]?ts|\.tsx|\.[mc]?js|\.jsx)`;
+const TS_DIRS = String.raw `(?:[^/#\r\n]+/)*`;
+const TS_FILE = String.raw `${TS_DIRS}[^/#\r\n]+(?:(?:\.d)?\.[mc]?ts|\.tsx|\.[mc]?js|\.jsx)`;
 const SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_FILE}`;
-const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/package\\.json`;
+const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/${TS_DIRS}package\\.json`;
 /**
  * One expression per form the grammar defines, each anchored and each the whole of
  * a reference. Several forms share one expression because they differ in what the

package/dist/src/references.js

@@ -5,7 +5,7 @@ import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { specifierCandidates } from "./configuration-files.js";
 import { namespaceUses } from "./namespace-objects.js";
 import { globExpression } from "./glob.js";
-import { declarationsByName, nodeKey } from "./inventory.js";
+import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
 import { augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
@@ -336,6 +336,7 @@ function sitesOf(file, declarations, fileId, unread) {
     const wholes = [];
     const urls = [];
     const decorated = [];
+    const parameterWrites = [];
     const namespaces = namespaceUses(file);
     const literals = [];
     const flows = [];
@@ -419,7 +420,16 @@ function sitesOf(file, declarations, fileId, unread) {
         }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
-        if (held !== undefined) {
+        // A parameter property's annotation, initializer and decorators stay with the
+        // parameter when the member goes, so they are written inside the constructor's class.
+        if (held !== undefined && isParameterProperty(node)) {
+            parameterWrites.push({
+                name: node.name,
+                from: outer,
+                member: held,
+            });
+        }
+        else if (held !== undefined) {
             enclosing = held;
             for (const modifier of node.modifiers ?? []) {
                 if (isDecorator(modifier)) {
@@ -441,6 +451,7 @@ function sitesOf(file, declarations, fileId, unread) {
         wholes,
         urls,
         decorated,
+        parameterWrites,
         keyed,
     };
 }
@@ -523,15 +534,12 @@ function importedNames(file) {
     importedCache.set(file, names);
     return names;
 }
-/**
- * The name node of every import binding one file's top level declares, and whether it
- * binds a whole module.
- */
+/** The name node of every import binding one file's top level declares. */
 function importBindings(file) {
     const found = [];
     for (const statement of file.statements) {
         if (isImportEqualsDeclaration(statement)) {
-            found.push({ node: statement.name, whole: true });
+            found.push({ node: statement.name });
             continue;
         }
         const clause = isImportDeclaration(statement) ? statement.importClause : undefined;
@@ -539,17 +547,17 @@ function importBindings(file) {
             continue;
         }
         if (clause.name !== undefined) {
-            found.push({ node: clause.name, whole: false });
+            found.push({ node: clause.name });
         }
         const bindings = clause.namedBindings;
         if (bindings === undefined) {
             continue;
         }
         if (bindings.kind === SyntaxKind.NamespaceImport) {
-            found.push({ node: bindings.name, whole: true });
+            found.push({ node: bindings.name });
         }
         else {
-            found.push(...bindings.elements.map((element) => ({ node: element.name, whole: false })));
+            found.push(...bindings.elements.map((element) => ({ node: element.name })));
         }
     }
     return found;
@@ -856,7 +864,7 @@ export function references(project, held, targetRoot, options) {
         }
     }
     const keyNames = computedKeyNames(held.symbols);
-    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated, keyed, } of walked) {
+    for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated, parameterWrites, keyed, } of walked) {
         const test = testFile.get(file) === true;
         // A component file's markup may use any binding its blocks declare at the top level.
         const markup = isComponentFile(file);
@@ -874,6 +882,17 @@ export function references(project, held, targetRoot, options) {
                 test,
             });
         }
+        // The constructor stores its argument in the member a parameter property declares.
+        for (const { name, from, member } of parameterWrites) {
+            found.push({
+                from,
+                to: member,
+                position: renderPosition(file, root, name.getStart()),
+                use: "write",
+                resolution: "syntax",
+                test,
+            });
+        }
         // One batch per capped run of the file's name nodes, the re-exports' nodes after
         // the uses and the evaluated modules' specifiers last, each node once: a bare star
         // re-export's specifier is a link and an evaluation both. A shorthand is left out
@@ -1011,15 +1030,14 @@ export function references(project, held, targetRoot, options) {
                 const chained = symbol === UNANSWERED
                     ? named(binding.node).map((id) => ({ id, stepped: false, guessed: true }))
                     : chains.chainOf(symbol);
-                // The markup may name any export of a module a binding holds whole.
-                const targets = binding.whole
-                    ? chained.flatMap((target) => [
-                        target,
-                        ...declaredIn(target.id)
-                            .filter((one) => one.exported)
-                            .map((one) => ({ ...target, id: one.id })),
-                    ])
-                    : chained;
+                // The markup may name any export of a module a binding's chain reaches, whether a
+                // namespace import binds it or a named or default import of a namespace re-export.
+                const targets = chained.flatMap((target) => [
+                    target,
+                    ...declaredIn(target.id)
+                        .filter((one) => one.exported)
+                        .map((one) => ({ ...target, id: one.id })),
+                ]);
                 for (const target of targets) {
                     found.push({
                         from: fileId,

package/dist/src/report.js

@@ -4,7 +4,7 @@
  * renders this document, so no two renderings disagree about which findings exist.
  */
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "8.1.0";
+const SCHEMA_VERSION = "8.2.0";
 /** Every report schema version this analyzer reads: the one the Contract it implements admits. */
 export const SCHEMA_VERSIONS_ACCEPTED = [SCHEMA_VERSION];
 /** The name this analyzer writes every document under and mints every identifier with. */

package/dist/src/resolve.js

@@ -21,9 +21,9 @@ const PLATFORM_MEMBERS = ["os", "arch", "tags"];
 const PROJECT_MEMBER = "project";
 /**
  * One segment of a project path: not empty, not `.` or `..`, and holding no
- * solidus, backslash or line break.
+ * solidus or control character.
  */
-const PROJECT_SEGMENT = String.raw `(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+)`;
+const PROJECT_SEGMENT = String.raw `(?:[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.\.[^/\x00-\x1f\x7f]+)`;
 /**
  * A project path: segments joined by a solidus, so the path is relative, below
  * the root it is read against, and spelled one way on every machine.
@@ -151,6 +151,39 @@ function readStrings(parent, name, path, label, minItems, allowed) {
     }
     return value;
 }
+/**
+ * The target kind, a string or an object naming every language. The walk has
+ * already refused an undeclared member, so an object is refused for the first
+ * language it leaves out, then for the first language whose value is refused,
+ * each in the vocabulary's language order.
+ */
+function readTargetKind(target, label) {
+    const value = member(target, "kind");
+    const perLanguage = `an object naming the kind of each of ${spell(LANGUAGES)}`;
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        if (!TARGET_KINDS.includes(value)) {
+            throw malformed(label, "target.kind", `${JSON.stringify(value)} is not one of ${spell(TARGET_KINDS)}, nor ${perLanguage}`);
+        }
+        return value;
+    }
+    if (!isRecord(value)) {
+        throw malformed(label, "target.kind", `${JSON.stringify(value)} is neither one of ${spell(TARGET_KINDS)} nor ${perLanguage}`);
+    }
+    const missing = LANGUAGES.find((language) => !Object.hasOwn(value, language));
+    if (missing !== undefined) {
+        throw malformed(label, `target.kind.${missing}`, `is not set, and ${perLanguage} names each`);
+    }
+    for (const language of LANGUAGES) {
+        const kind = value[language];
+        if (typeof kind !== "string" || !TARGET_KINDS.includes(kind)) {
+            throw malformed(label, `target.kind.${language}`, `${JSON.stringify(kind)} is not one of ${spell(TARGET_KINDS)}`);
+        }
+    }
+    return { go: value["go"], ts: value["ts"] };
+}
 /** A component file's extension: a full stop followed by letters and digits. */
 const COMPONENT_EXTENSION = /^\.[A-Za-z0-9]+$/u;
 function readComponentExtensions(ts, label) {
@@ -194,7 +227,7 @@ function readProject(entry, at, label) {
     const project = requireMember(readString(entry, PROJECT_MEMBER, path, label), path, label);
     if (!PROJECT_PATH.test(project)) {
         throw malformed(label, path, `${JSON.stringify(project)} is not a path below the target root: segments joined by /, ` +
-            "none empty, . or .., and no backslash or line break");
+            "none empty, . or .., and no control character");
     }
     return { shape: "project", id, project };
 }
@@ -508,7 +541,7 @@ function readDoc(value, label) {
     }
     return {
         contractVersion,
-        targetKind: readEnum(target, "kind", "target.kind", label, TARGET_KINDS),
+        targetKind: readTargetKind(target, label),
         languages: readStrings(analysis, "languages", "analysis.languages", label, 0, LANGUAGES),
         minConfidence: readEnum(analysis, "min_confidence", "analysis.min_confidence", label, CONFIDENCES),
         generatedFiles: readEnum(analysis, "generated_files", "analysis.generated_files", label, GENERATED_FILES),

package/dist/src/schema.js

@@ -15,7 +15,10 @@ export const SCHEMA_ROOT = {
     kind: "section",
     members: {
         contract_version: leaf,
-        target: { kind: "section", members: { kind: leaf } },
+        target: {
+            kind: "section",
+            members: { kind: { kind: "object", members: { go: leaf, ts: leaf } } },
+        },
         analysis: {
             kind: "section",
             members: {

package/dist/src/suppress-file.js

@@ -205,11 +205,12 @@ export function rowReason(provenance) {
     return `recorded by ${provenance.analyzer} ${provenance.version}`;
 }
 /**
- * The rows of the other language's scheme that the baseline document `text` holds, in
- * document order and as written, which a write keeps. A document that is not a baseline,
- * or a row in a shape no record takes, is refused rather than dropped.
+ * The rows of a scheme other than `own` that the baseline document `text` holds, in
+ * document order and as written, which a write of `own`'s rows keeps. A document that is
+ * not a baseline, or a row in a shape no record takes, of any scheme, is refused rather
+ * than dropped.
  */
-export function otherSchemeRows(text) {
+export function otherSchemeRows(text, own = OWN_SCHEME) {
     const refuse = (detail) => {
         throw new Error(`${BASELINE_FILE} cannot be rewritten keeping the other language's rows: ${detail}`);
     };
@@ -233,7 +234,7 @@ export function otherSchemeRows(text) {
         }
         // readRecord has checked every member is a string and the code and symbol are present.
         const { code, symbol, path, reason } = value;
-        if (code === undefined || symbol === undefined || symbol.startsWith(OWN_SCHEME)) {
+        if (code === undefined || symbol === undefined || symbol.startsWith(own)) {
             return [];
         }
         return [
@@ -246,10 +247,32 @@ export function otherSchemeRows(text) {
         ];
     });
 }
+/** The reference schemes in the order a baseline holds their rows. */
+const SCHEME_ORDER = ["go://", "ts://"];
+function schemeRank(row) {
+    return SCHEME_ORDER.findIndex((scheme) => row.symbol.startsWith(scheme));
+}
+/** A surrogate half no other completes, which Go's encoding/json decodes as U+FFFD. */
+const LONE_SURROGATE = /[\ud800-\udfff]/gu;
+/** One string with every lone surrogate written as U+FFFD. */
+function wellFormed(text) {
+    return text.replace(LONE_SURROGATE, "\ufffd");
+}
 /**
- * A baseline holding one row per finding, in the order given, which is the report's, after
- * the other language's rows `kept`, so two analyzers writing one document in either order
- * write the same bytes. Every recorded row carries the provenance as its reason. A finding
+ * The pieces of a JSON document with U+2028 and U+2029 escaped, as Go's encoding/json
+ * writes them. Neither is JSON syntax, so each stands inside a string.
+ */
+function* separatorsEscaped(pieces) {
+    for (const piece of pieces) {
+        yield piece.replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+    }
+}
+/**
+ * A baseline holding one row per finding, in the order given, which is the report's, and
+ * the other language's rows `kept`, Go's rows ahead of TypeScript's and each scheme's in
+ * the order given, so two analyzers writing one document in either order write the same
+ * bytes, in the form grammar/suppression.md fixes. Every recorded row carries the
+ * provenance as its reason. A finding
  * missing a value a row needs, and an identity missing its name or version, are refused
  * rather than written, because the grammar requires a reason on every row.
  */
@@ -264,5 +287,16 @@ export function writeBaseline(findings, provenance, kept = []) {
         }
         return { code: found.code, symbol: found.symbol, path: found.path, reason };
     });
-    return jsonChunks({ description: BASELINE_DESCRIPTION, baseline: [...kept, ...baseline] }, 2);
+    const rows = [...kept, ...baseline]
+        .sort((a, b) => schemeRank(a) - schemeRank(b))
+        .map((row) => {
+        const { code, symbol, path, reason } = row;
+        return {
+            code: wellFormed(code),
+            symbol: wellFormed(symbol),
+            ...(path === undefined ? {} : { path: wellFormed(path) }),
+            ...(reason === undefined ? {} : { reason: wellFormed(reason) }),
+        };
+    });
+    return separatorsEscaped(jsonChunks({ description: BASELINE_DESCRIPTION, baseline: rows }, 2));
 }

package/dist/src/suppress-inline.js

@@ -3,11 +3,11 @@
  * one or more codes and a reason, and binding to every declaration that begins on the line
  * below it, or on its own line where it trails a token there.
  */
-import { SyntaxKind } from "@typescript/native/ast";
-import { nodeKey } from "./inventory.js";
+import { isConstructorDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isParameterProperty, nodeKey } from "./inventory.js";
 import { byPosition, positionKey, renderPosition } from "./position.js";
 import { signatureOf } from "./signatures.js";
-import { SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
+import { isPartKind, SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
 /**
  * The three expressions the grammar applies to the text of each line comment, in this
  * order: a comment in the namespace, a well-formed directive, and a directive that lacks
@@ -132,37 +132,53 @@ function lineComments(file) {
     }
     return found;
 }
+function bindingKey(one) {
+    return `${one.declared?.id ?? ""}\u0000${one.part.id}`;
+}
 /**
  * The declarations of one file by the line each begins on, the line of its first token: a
  * decorator, a modifier or the keyword. A variable's first token is its statement's
  * keyword, and a variable written on a later line of the statement also begins there. A
- * function also begins, for a directive, on the line of each of its parameters.
+ * function also begins, for a directive, on the line of each of its parameters, and a
+ * class, for a part kind, on the lines of its constructor and its constructor's parameters.
  */
 function declarationLines(file, held, symbols) {
     const below = new Map();
     const add = (offset, one) => {
         const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
         const at = below.get(line) ?? [];
-        if (!at.some((known) => known.id === one.id)) {
+        if (!at.some((known) => bindingKey(known) === bindingKey(one))) {
             at.push(one);
         }
         below.set(line, at);
     };
-    const visit = (node) => {
+    const declaredAt = (node) => {
         const id = held.declarations.get(nodeKey(file, node));
-        const one = id === undefined ? undefined : symbols.get(id);
+        return id === undefined ? undefined : symbols.get(id);
+    };
+    const visit = (node) => {
+        const one = declaredAt(node);
+        const owner = isConstructorDeclaration(node) ? declaredAt(node.parent) : undefined;
+        if (owner !== undefined && isConstructorDeclaration(node)) {
+            for (const at of [node, ...node.parameters.filter((one) => !isParameterProperty(one))]) {
+                add(at.pos, { declared: undefined, part: owner });
+            }
+        }
+        const holder = one !== undefined && isParameterProperty(node) ? declaredAt(node.parent.parent) : one;
+        if (one !== undefined && holder !== undefined) {
+            add(node.pos, { declared: one, part: holder });
+        }
         if (one !== undefined) {
-            add(node.pos, one);
             // A parameter on a later line of a wrapped signature takes its directive on the
             // line above it, inside the parameter list, and the directive binds the function.
             for (const parameter of signatureOf(node)?.parameters ?? []) {
-                add(parameter.pos, one);
+                add(parameter.pos, { declared: one, part: one });
             }
             const list = node.parent;
             if (node.kind === SyntaxKind.VariableDeclaration &&
                 list.kind === SyntaxKind.VariableDeclarationList &&
                 list.parent.kind === SyntaxKind.VariableStatement) {
-                add(list.parent.pos, one);
+                add(list.parent.pos, { declared: one, part: one });
             }
         }
         node.forEachChild(visit);
@@ -223,7 +239,7 @@ export function inlineSuppressions(perProject) {
             continue;
         }
         for (const one of written.bound) {
-            if (!known.bound.some((other) => other.id === one.id)) {
+            if (!known.bound.some((other) => bindingKey(other) === bindingKey(one))) {
                 known.bound.push(one);
             }
         }
@@ -251,8 +267,15 @@ export function inlineSuppressions(perProject) {
                 }
                 break;
             case "directive": {
-                const declared = [...bound].sort((a, b) => byPosition(a.position, b.position));
                 for (const code of directive.codes) {
+                    const targets = new Map();
+                    for (const one of bound) {
+                        const target = isPartKind(code) ? one.part : one.declared;
+                        if (target !== undefined) {
+                            targets.set(target.id, target);
+                        }
+                    }
+                    const declared = [...targets.values()].sort((a, b) => byPosition(a.position, b.position));
                     const base = {
                         code,
                         path: site.path,

package/dist/src/suppress.js

@@ -34,9 +34,10 @@ export function siteText(site) {
 export const CODE_FORM = /^DS[0-9]{4}$/u;
 /**
  * A path inside the target: relative to the target root, the solidus as separator, no
- * leading `./`, no trailing solidus, no `.` or `..` segment, never absolute.
+ * leading `./`, no trailing solidus, no `.` or `..` segment, never absolute, and no
+ * control character; a backslash is a character of a name.
  */
-export const PATH_EXPRESSION = String.raw `^(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+)(?:/(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+))*$`;
+export const PATH_EXPRESSION = String.raw `^(?:[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.\.[^/\x00-\x1f\x7f]+)(?:/(?:[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.\.[^/\x00-\x1f\x7f]+))*$`;
 const PATH_FORM = new RegExp(PATH_EXPRESSION, "u");
 /** Whether one value is a path in the form an entry's `path` takes. */
 export function isEntryPath(value) {

package/dist/src/type-errors.js

@@ -84,7 +84,8 @@ function declaringManifest(host, dir, targetRoot, name) {
                 }
             }
         }
-        if (at === targetRoot || relativePath(targetRoot, at) === undefined || dirnamePath(at) === at) {
+        // The target root is not below itself, so the walk stops after reading its manifest.
+        if (relativePath(targetRoot, at) === undefined) {
             return undefined;
         }
     }

package/dist/src/verbs/analyze.js

@@ -1,11 +1,11 @@
 import { runAnalysis, runBaselineWrite, unansweredCounts, } from "../analysis.js";
-import { ConfigError } from "../config.js";
+import { ConfigError, kindOf } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
 import { moduleIdentity } from "../consumers.js";
 import { analyzerProvenance, verdictOf } from "../findings-pass.js";
 import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { partialNotes } from "../partial.js";
-import { buildReport, capFindings, sortFindings, } from "../report.js";
+import { buildReport, LANGUAGE, capFindings, sortFindings, } from "../report.js";
 import { json } from "../reporters/json.js";
 import { RENDERINGS } from "../reporters/reporters.js";
 import { parseTemplate, TemplateError } from "../reporters/template.js";
@@ -188,7 +188,11 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             version,
             conformance: CONFORMANCE,
             declaredGaps: DECLARED_GAPS,
-            target: { kind, root, identity: moduleIdentity(host, scoped.target) },
+            target: {
+                kind: kindOf(kind, LANGUAGE),
+                root,
+                identity: moduleIdentity(host, scoped.target),
+            },
             configurations: configurationsOf(run.projects, targetRoot),
             notBuilt: notBuiltOf(run.notBuilt, targetRoot),
             loaded: run.consumers.map((consumer) => ({

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.1.0";
+export const CONTRACT_VERSION = "7.2.0";

package/dist/src/workspace-resolution.js

@@ -19,7 +19,6 @@ const DEPENDENCY_MEMBERS = [
     "optionalDependencies",
 ];
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
-const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -39,7 +38,7 @@ export function packageNameOf(specifier) {
     return first;
 }
 function inside(dir, path) {
-    return path === dir || relativePath(dir, path) !== undefined;
+    return relativePath(dir, path) !== undefined;
 }
 /** The `exports` entry one subpath selects, with what a pattern's `*` matched. */
 function exportsEntry(exportsField, subpath) {
@@ -199,12 +198,10 @@ export function workspaceResolver(host, workspace) {
                 return found;
             }
         }
-        if (OUTPUT.test(path)) {
-            const beside = emittedFrom(path, { sourceDirs: [] });
-            const found = beside.find((candidate) => host.kindOf(candidate) === "file");
-            if (found !== undefined) {
-                return found;
-            }
+        const beside = emittedFrom(path, { sourceDirs: [] });
+        const found = beside.find((candidate) => host.kindOf(candidate) === "file");
+        if (found !== undefined) {
+            return found;
         }
         return compiled(member, path) && host.kindOf(path) === "file" ? path : undefined;
     };

package/dist/src/workspace.js

@@ -198,14 +198,14 @@ function memberDirectories(host, root, patterns) {
     }
     return [...included].filter((dir) => {
         const below = relativePath(root, dir);
-        const segments = below === undefined || below === "." || below === "" ? [] : below.split("/");
+        const segments = below === undefined ? [] : below.split("/");
         return dir === root || !excluded.some((pattern) => pathMatches(pattern, segments));
     });
 }
 /** Whether a workspace's patterns name one directory below its root, read without listing any. */
 function namesDirectory(root, patterns, dir) {
     const below = relativePath(root, dir);
-    if (below === undefined || below === "" || below.startsWith("..")) {
+    if (below === undefined || below.startsWith("..")) {
         return false;
     }
     const path = below.split("/");

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "7.1.0",
+  "version": "7.2.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.1.0",
+  "version": "7.2.0-dev.2",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -40,7 +40,7 @@
     "@stryker-mutator/core": "10.0.0",
     "@stryker-mutator/typescript-checker": "10.0.0",
     "@stryker-mutator/vitest-runner": "10.0.0",
-    "@types/node": "24.19.1",
+    "@types/node": "24.19.2",
     "eslint": "10.12.0",
     "fast-check": "4.10.2",
     "prettier": "3.9.9",

package/src/alias-chain.ts

@@ -14,7 +14,7 @@ import {
   isNamespaceImport,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/sync";
-import { declarationsByName, nodeKey, type Inventory } from "./inventory.ts";
+import { declarationsByName, isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
 import { UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -76,7 +76,12 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
       const node = project.declarationAt(handle)?.node;
       const id =
         node === undefined ? undefined : held.declarations.get(nodeKey(node.getSourceFile(), node));
-      if (id !== undefined && !ids.includes(id)) {
+      // A parameter property's node declares the parameter too, whose reads are no member's.
+      const parameter =
+        node !== undefined &&
+        isParameterProperty(node) &&
+        (symbol.flags & SymbolFlags.Property) === 0;
+      if (id !== undefined && !parameter && !ids.includes(id)) {
         ids.push(id);
       }
     }

package/src/analysis.ts

@@ -7,7 +7,7 @@
  */
 
 import { lineOf, readComponent } from "./component-files.ts";
-import type { Config, Provenance } from "./config.ts";
+import { kindOf, type Config, type Provenance } from "./config.ts";
 import {
   consumerLoads,
   consumerReferences,
@@ -83,7 +83,7 @@ import {
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
-import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
+import { LANGUAGE, type TypeErrorSkip, type UnansweredCount } from "./report.ts";
 import { SetupError, setupLine, type SetupFailure } from "./setup-failure.ts";
 import {
   pathsOf,
@@ -377,7 +377,7 @@ function readProjects<Answer>(
       conventions,
       testFiles: config.ts.testFiles,
       parse,
-      publishedAPI: config.targetKind === "library",
+      publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
       publishedMembers: new Set(
         (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
       ),

package/src/config.ts

@@ -13,6 +13,14 @@ export const REPOSITORY_DOCUMENT = "deadset.json";
  */
 export type TargetKind = "application" | "library";
 
+/** The target kind as a source writes it: one kind for every language, or one per language. */
+export type TargetKindSetting = TargetKind | { readonly go: TargetKind; readonly ts: TargetKind };
+
+/** The kind a target kind setting gives one language's declarations. */
+export function kindOf(setting: TargetKindSetting, language: Language): TargetKind {
+  return typeof setting === "string" ? setting : setting[language];
+}
+
 /** The lowest reachability class a finding must reach to be reported. */
 export type Confidence = "certain" | "probable" | "possible";
 
@@ -183,7 +191,7 @@ export interface TSSection {
  */
 export interface Config {
   readonly contractVersion: string;
-  readonly targetKind: TargetKind | "";
+  readonly targetKind: TargetKindSetting | "";
   readonly analysis: Analysis;
   readonly consumersComplete: boolean;
   readonly rootPatterns: readonly string[];